blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
357
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
58
| license_type
stringclasses 2
values | repo_name
stringlengths 4
115
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringlengths 4
58
| visit_date
timestamp[ns]date 2015-07-14 21:31:45
2023-09-06 10:45:08
| revision_date
timestamp[ns]date 1970-01-01 00:00:00
2023-09-05 23:26:37
| committer_date
timestamp[ns]date 1970-01-01 00:00:00
2023-09-05 23:26:37
| github_id
int64 966
689M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 24
values | gha_event_created_at
timestamp[ns]date 2012-06-07 00:51:45
2023-09-14 21:58:52
⌀ | gha_created_at
timestamp[ns]date 2008-02-03 21:17:16
2023-08-24 19:49:39
⌀ | gha_language
stringclasses 180
values | src_encoding
stringclasses 35
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 6
10.4M
| extension
stringclasses 121
values | filename
stringlengths 1
148
| content
stringlengths 6
10.4M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f73b37d0886eea822d9e8d39527a20a0a110077d
|
19e356aa308d3adef259a912b29950a3af37a2e2
|
/Temp/il2cppOutput/il2cppOutput/mscorlib_System_Runtime_Remoting_Messaging_ConstructionCallDMethodDeclarations.h
|
597b98141ea3fb62ab35f7c0a52633e667dd2a79
|
[] |
no_license
|
minuJeong/AcocGame
|
87314d914b72290fff347cc590ae03669d10d6ba
|
24eeaba66393890998d55a633fcbd17d984549b4
|
refs/heads/master
| 2021-03-12T23:51:57.818655 | 2015-03-29T12:44:58 | 2015-03-29T12:44:58 | 32,936,460 | 1 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,483 |
h
|
mscorlib_System_Runtime_Remoting_Messaging_ConstructionCallDMethodDeclarations.h
|
#pragma once
#include <stdint.h>
#include <assert.h>
#include <exception>
#include "codegen/il2cpp-codegen.h"
// System.Runtime.Remoting.Messaging.ConstructionCallDictionary
struct ConstructionCallDictionary_t3479;
// System.Runtime.Remoting.Activation.IConstructionCallMessage
struct IConstructionCallMessage_t3452;
// System.Object
struct Object_t;
// System.String
struct String_t;
// System.Void System.Runtime.Remoting.Messaging.ConstructionCallDictionary::.ctor(System.Runtime.Remoting.Activation.IConstructionCallMessage)
void ConstructionCallDictionary__ctor_m12905 (ConstructionCallDictionary_t3479 * __this, Object_t * ___message, MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.Remoting.Messaging.ConstructionCallDictionary::.cctor()
void ConstructionCallDictionary__cctor_m12906 (Object_t * __this/* static, unused */, MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Object System.Runtime.Remoting.Messaging.ConstructionCallDictionary::GetMethodProperty(System.String)
Object_t * ConstructionCallDictionary_GetMethodProperty_m12907 (ConstructionCallDictionary_t3479 * __this, String_t* ___key, MethodInfo* method) IL2CPP_METHOD_ATTR;
// System.Void System.Runtime.Remoting.Messaging.ConstructionCallDictionary::SetMethodProperty(System.String,System.Object)
void ConstructionCallDictionary_SetMethodProperty_m12908 (ConstructionCallDictionary_t3479 * __this, String_t* ___key, Object_t * ___value, MethodInfo* method) IL2CPP_METHOD_ATTR;
|
534cc3f3632531d3dadf723f2fa658469eacee1e
|
7208b6b3b3867cfcd5d91dd0d7f85b33b2141310
|
/boot/bootconsole.c
|
eacb26155a6a3675af37576315349fed8cbecc11
|
[] |
no_license
|
davidv1992/newmoon-kernel
|
a2ac50464782910b23f8e1f7a9251181a6787d41
|
9575388d48484874fad612bd76a904dcd783c77c
|
refs/heads/master
| 2022-08-23T22:02:04.537529 | 2020-05-27T20:50:04 | 2020-05-27T20:54:08 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 2,916 |
c
|
bootconsole.c
|
#include <stdint.h>
#include <stdbool.h>
#include <stdarg.h>
#define BC_COLS 80
#define BC_ROWS 25
static uint8_t *console_buffer = (uint8_t*)0xB8000;
static int cur_row = 0, cur_col = 0;
static bool has_initialized = false;
static void bc_init() {
for (int i=0; i<BC_ROWS; i++) {
for (int j=0; j<BC_COLS; j++) {
console_buffer[2*(i*BC_COLS+j)] = ' ';
console_buffer[2*(i*BC_COLS+j)+1] = 15;
}
}
has_initialized = true;
}
static void bc_scroll() {
for (int i=0; i<BC_ROWS-1; i++) {
for (int j=0; j<BC_COLS; j++) {
console_buffer[2*(i*BC_COLS+j)] =
console_buffer[2*((i+1)*BC_COLS+j)];
}
}
for (int j=0; j<BC_COLS; j++) {
console_buffer[2*((BC_ROWS-1)*BC_COLS+j)] = ' ';
}
}
void bc_putchar(char c) {
if (!has_initialized) bc_init();
// special characters
if (c == '\n') {
cur_row++;
cur_col = 0;
if (cur_row == BC_ROWS) {
bc_scroll();
cur_row--;
}
return;
}
if (c == '\r') {
cur_col = 0;
return;
}
// normal case
if (cur_col == BC_COLS) {
cur_col = 0;
cur_row++;
}
if (cur_row == BC_ROWS) {
bc_scroll();
cur_row--;
}
console_buffer[2*(cur_row*BC_COLS+cur_col)] = c;
cur_col++;
}
void bc_puts(const char *c) {
while (*c != 0) bc_putchar(*(c++));
}
void bc_print_va(const char *format, va_list params) {
bool inSpecial = false;
while (*format != '\0') {
if (inSpecial) {
if (*format == 'x' || *format == 'X') {
uint32_t cur = (uint32_t)va_arg(params,uint32_t);
for (int i=7; i>=0; i--) {
uint32_t curdig = (cur & (0xF << (i*4))) >> (i*4);
if (curdig < 10)
bc_putchar('0'+(char)curdig);
else if (*format == 'x')
bc_putchar('a'+(char)(curdig-10));
else
bc_putchar('A'+(char)(curdig-10));
}
inSpecial = false;
format++;
continue;
} else if (*format == 'd') {
uint32_t cur = (uint32_t)va_arg(params, uint32_t);
bool hasDig = false;
uint32_t pow = 1000000000;
while (pow) {
uint32_t curdig = cur/pow;
cur %= pow;
if (curdig != 0 || pow == 1) hasDig = true;
if (hasDig) bc_putchar('0'+(char)curdig);
pow /= 10;
}
inSpecial = false;
format++;
continue;
} else if (*format == 's') {
char *str = (char*)va_arg(params, char*);
while (*str != '\0') {
bc_putchar(*str);
str++;
}
format++;
continue;
} else if (*format == 'c') {
char c = (char)va_arg(params,int);
bc_putchar(c);
format++;
continue;
} else {
inSpecial = false;
//falltrough
}
}
if (*format == '%') {
inSpecial = true;
} else {
bc_putchar(*format);
}
format++;
}
}
void bc_print(const char *format, ...) {
va_list params;
va_start(params, format);
bc_print_va(format, params);
va_end(params);
}
void panic(const char *format, ...) {
va_list params;
va_start(params, format);
bc_print_va(format, params);
va_end(params);
asm("cli\nhlt\n");
while(1);
}
|
19829ba112930c168bae221fd451e55421edb5fb
|
a280aa9ac69d3834dc00219e9a4ba07996dfb4dd
|
/regularexpress/home/weilaidb/work/kernel/linux-3.0.8/tools/perf/util/string.c
|
2cdc9fa967b4ec29a59f7b6a0bb9e2b5cfd4271f
|
[] |
no_license
|
weilaidb/PythonExample
|
b2cc6c514816a0e1bfb7c0cbd5045cf87bd28466
|
798bf1bdfdf7594f528788c4df02f79f0f7827ce
|
refs/heads/master
| 2021-01-12T13:56:19.346041 | 2017-07-22T16:30:33 | 2017-07-22T16:30:33 | 68,925,741 | 4 | 2 | null | null | null | null |
UTF-8
|
C
| false | false | 507 |
c
|
string.c
|
#define K 1024LL
s64 perf_atoll(const char *str)
static const char *skip_sep(const char *cp)
static const char *skip_arg(const char *cp)
static int count_argc(const char *str)
void argv_free(char **argv)
char **argv_split(const char *str, int *argcp)
static bool __match_charclass(const char *pat, char c, const char **npat)
static bool __match_glob(const char *str, const char *pat, bool ignore_space)
bool strglobmatch(const char *str, const char *pat)
bool strlazymatch(const char *str, const char *pat)
|
a461972cfe6fd07129dcc1ee6225c874a460d853
|
2131cc6e240a812a20456c15b72a22a14faee049
|
/src/map_reduce.c
|
e144d1b057e7612615e3ad9b48f0b44a0f09e897
|
[] |
no_license
|
rileywong/MapReduce
|
faa653049bf5cfbaca5fde560582bdd1398ff728
|
146ad936ebeac5e51719a6823cbb5ad52e77f37f
|
refs/heads/master
| 2021-01-19T09:20:51.162273 | 2018-02-02T17:43:06 | 2018-02-02T17:43:06 | 82,097,826 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 11,850 |
c
|
map_reduce.c
|
//**DO NOT** CHANGE THE PROTOTYPES FOR THE FUNCTIONS GIVEN TO YOU. WE TEST EACH
//FUNCTION INDEPENDENTLY WITH OUR OWN MAIN PROGRAM.
#include "../include/map_reduce.h"
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
//TODO need to fix this,
//Implement map_reduce.h functions here
// Needs to check for invalid dir names
int validateargs(int argc, char** argv){
if(argv[1]!=NULL){
if((strcmp("-h", argv[1])==0)) {
//printHelp();
return 0;
}
if((strcmp("ana", argv[1])==0)) {
if(argv[2]!=NULL){
if(argv[2]!=NULL){
DIR *dirN;
if ((dirN = opendir(argv[2])) == NULL) {
printf("%s/n","Directory is not valid");
return -1;
}
if(argv[3]!=NULL){
return -1;
}
return 1;
}
}
else{
return -1;
}
}
if((strcmp("stats", argv[1])==0)) {
if(argv[2]!=NULL){
if(argv[2]!=NULL){
DIR *dirN;
if ((dirN = opendir(argv[2])) == NULL) {
printf("%s/n","Directory does not valid");
return -1;
}
if(argv[3]!=NULL){
return -1;
}
return 2;
}
}
else{
return -1;
}
}
if((strcmp("-v",argv[1])==0)){
if(argv[2]!=NULL){
if(strcmp("ana",argv[2])==0){
DIR *dirN;
if ((dirN = opendir(argv[3])) == NULL) {
printf("%s/n","Directory does not valid");
return -1;
}
if(argv[4]!=NULL){
return -1;
}
//printHelp();
return 3;
}
if(strcmp("stats",argv[2])==0){
//printf("%s\n","we here1" );
DIR *dirN;
if ((dirN = opendir(argv[3])) == NULL) {
printf("%s/n","Directory does not valid");
return -1;
}
if(argv[4]!=NULL){
return -1;
}
//printf("%s\n","we here21" );
//printHelp();
return 4;
}
}
else{
//printHelp();
return -1;
}
}
}
//printHelp();
return -1;
}
int nfiles(char* dir){
int totalFiles = 0;
DIR *directory;
// CHECK IF DIRECTORY IS LEGITIMATE
if((directory = opendir(dir))==NULL){
//printf("Could not open : %s\n",dir );
return -1;
}
// CREATE DIRECT STRUCT
struct dirent *file1;
//LOOP THROUGH DIRECTORY INCREMENTING COUNTER EACH TIME UNTIL THE END
while((file1 = readdir(directory))!=NULL){
if((strcmp(file1->d_name,".")==0) || (strcmp(file1->d_name,"..")==0)){
totalFiles = totalFiles;
}
else{
totalFiles++;
}
}
// CLOSE DIRECTORY
closedir(directory);
// RETURN TOTAL NUMBER OF FILES
return totalFiles;
}
int map(char* dir, void* results, size_t size, int(*act)(FILE* f, void* res,char* fn)){
//(don't print for final result)
///printf("Here2%s\n", "test");
int sumOfAct = 0;
DIR *directory;
// CHECK IF DIRECTORY IS VALID
if((directory = opendir(dir)) == NULL){
return -1;
}
// LOOP THROUGH THE DIRECTORY AND RECORD
struct dirent *file1;
int counter = 0;
//printf("Here2%s\n", "test");
while((file1 = readdir(directory)) != NULL){
//printf("%s\n", "Do we reach here");
if((strcmp(file1->d_name,".")==0) || (strcmp(file1->d_name,"..")==0)) {
//printf("Here1%s\n", "test");
}
else{
//printf("%s\n", "Do we reach here1");
FILE *fp;
//char path[1];
char *path1 = malloc(strlen(dir)+strlen(file1->d_name)+2);
strcpy(path1,dir);
strcat(path1,"/");
strcat(path1,file1->d_name);
//printf("we %s\n", path1);
//printf("%s\n", "Do we reach here2");
/*
strcpy(path,dir);
strcat(path,"/");
strcat(path,file1->d_name);
*/
fp = fopen(path1, "r+");
//printf("%s\n", "Do we reach here3");
if(fp!=NULL){
//void *incrRes = &(((int*)results)[counter * size]);
void *incrRes = results;
int x = counter*size;
int n = 0;
for(n = 0; n < x; n ++){
incrRes++;
}
int *incrRes1 = (int*) incrRes;
//int *incrRes = &(((int*)results)[counter * size]);
//void *incrRes = &(((void*)results)[counter * size]);
//printf("%s\n", "Do we reach here1");
//printf("address of res: %d\n", incrRes);
int fileBytes = (*act) (fp, incrRes1, file1->d_name);
//Segfaults here ^^^^^
//printf("%s\n", "Do we reach here1");
if(fileBytes==-1){
printf("%s\n", "File not valid");
}
else{
//printf("Here%s\n", path1);
sumOfAct += fileBytes;
//printf("Number of bytes: %d\n", fileBytes);
counter++;
}
}
else{
printf("Error opening file at : %s\n", path1 );
}
free(path1);
fclose(fp);
}
//printf("%s\n", "bottom of while loop");
//printf("This is the counter : %d\n", counter);
}
closedir(directory);
return sumOfAct;
}
int analysis(FILE* f, void* res, char* filename){
char c;
int n = 0;
int numbersInALine= 0;
int lineYouOn = 1;
int numbersInALineDum = 0;
int lineYouOnDum = 0;
//int lineCounter = 0;
struct Analysis *fin = res;
//counter = 0;
// printf("%s\n", filename);
while((c = fgetc(f)) != EOF) {
//int lineCounterDum = 0;
//printf("%c", c);
if( c < 128 && c!= 10){
numbersInALineDum++;
//printf("In here%d", numbersInALine);
//lineCounterDum ++;
}
else{
lineYouOnDum++;
//printf("%d\n", numbersInALine);
if(numbersInALineDum>=numbersInALine){
numbersInALine = numbersInALineDum;
lineYouOn=lineYouOnDum;
}
numbersInALineDum = 0;
}
fin->ascii[(int)c]++;
n++;
}
fin->lnlen =numbersInALine;
fin->lnno = lineYouOn;
fin->filename = filename;
//printf("Longes Line : %d\n", lineYouOn);
//sprintf("Max Numbers : %d\n", numbersInALine);
///struct Analysis fin;
//fin.filename = filename;
return n;
}
struct Analysis analysis_reduce(int n, void* results){
struct Analysis *dumPoint = (struct Analysis*) results;
int lnlen1 = 0;
int lnno1 = 0;
int ascii1[128] = {0};
char* filename ;
int counter;
for(counter = 0; counter < n ; counter++ ){
/*if(lnlen1>dumPoint[counter].lnlen){
lnlen1 = dumPoint[counter].lnlen;
filename=
}
if(lnno1>dumPoint[counter].lnno){
lnno1 = dumPoint[counter].lnno;
}*/
int lnlen1Dum = dumPoint[counter].lnlen;
int lnno1Dum = dumPoint[counter].lnno;
if(lnlen1Dum > lnlen1){
lnlen1 = lnlen1Dum;
lnno1 = lnno1Dum;
filename = strdup(dumPoint[counter].filename);
}
int counter1;
for(counter1 = 0; counter1 < 128; counter1++){
//printf("%s\n","test" );
ascii1[counter1] += dumPoint[counter].ascii[counter1];
}
}
//printf("%s\n", "here");
struct Analysis fin = {{0}, lnlen1, lnno1, filename };
//printf("%s\n", "here");
memcpy(fin.ascii,ascii1,sizeof(fin.ascii));
return fin;
}
void analysis_print(struct Analysis res,int nbytes, int hist){
printf("File: %s\n", res.filename);
printf("Longest line length: %d\n", res.lnlen);
printf("Longest line number: %d\n", res.lnno);
//printf("%s\n","" );
if(hist!= 0){
printf("Total Bytes in directory: %d\n", nbytes);
printf("Histogram:%s\n","" );
int x;
for(x = 0; x < 128; x++){
//printf("%d\n", res.ascii[x]);
if(res.ascii[x] != 0){
int b;
printf(" %d:",x );
for(b = 0; b < res.ascii[x]; b ++){
printf("%s","-" );
}
printf("%s\n","" );
}
}
}
printf("%s\n","" );
}
int stats(FILE* f, void* res, char* filename){
char c;
int n = 0;
int sum = 0;
//counter = 0;
Stats * fin = res;
//int *trap = malloc(NVAL);
//fin.histogram = (Stats.histogram) malloc(NVAL);
// intialize everything to zero
// printf("%s\n","reach" );
for(int min = 1; min < NVAL; min++){
//printf("%s\n","seg?" );
fin->histogram[min] = 0;
//printf("%s\n", "Do we reach here1");
}
//printf("%s\n", "Do we reach here1");
//printf("%s\n", filename);
while((c = fgetc(f)) != EOF) {
char *numba = malloc(500);
int cunter = 0;
int val = 0;
numba[cunter] = c;
while(c!=32 && c!=10 && c!=0 && c!= EOF){
//printf("%c\n",c );
numba[cunter] = c;
c= fgetc(f);
cunter++;
/*if(val = 0){
//printf("over here%d\n",fin->histogram[val] );
}*/
}
//printf("%d", cunter);
//printf(" ______________ %d\n", (int)c);
numba[cunter] = 0;
val = atoi(numba);
//printf("%s|%d ", numba, val);
sum += val;
fin->histogram[val] = fin->histogram[val]+1;
/*
if(val = 0){
printf("over here%d\n",fin->histogram[val] );
printf(" %c",c );
}*/
if(cunter != 0){
n++;
}
/*
if(c!=32 && c!=10 && c!=0 ){
int val = c-'0';
sum += val;
fin.histogram[val]= fin.histogram[val]+1;
n++;
*/
free(numba);
}
//printf("adsfa\n");
fin->sum=sum;
fin->n=n;
fin->filename=filename;
//printf("3242\n");
//res = &fin;
//memcpy(res, &fin, sizeof(Stats));
//printf("%d\n", sum);
return 0;
}
/*
typedef struct Stats {
int histogram[NVAL]; //space to store the count for each number.
int sum; //the sum total of all the numbers in the file.
int n; //the total count of numbers the files.
char* filename; //the file corresponding to the struct.
//(don't print for final result)
} Stats;
*/
Stats stats_reduce(int n, void* results){
int sum1=0;
int counter;
int n1 = 0;
//char* filename1;
int his1[NVAL] = {0};
Stats *dumPoint = (Stats*) results;
//LOOP THROUGH ALL THE DIFFERENT STATS
for(counter= 0; counter < n; counter++ ){
sum1 += dumPoint[counter].sum;
n1 += dumPoint[counter].n;
// COPY ALL THE VALUES FROM HISTOGRAM
int counter1;
for(counter1 = 1; counter1 < NVAL; counter1++){
his1[counter1] += dumPoint[counter].histogram[counter1];
}
}
// COPY ALL THE NEW VALUES FROM STATS
Stats fin = {{0},sum1,n1,NULL};
memcpy(fin.histogram,his1,sizeof(fin.histogram));
//printf("%d\n", n1);
//printf("%d\n", sum1);
return fin;
}
//Print historgram if hist is non-zero
// int histogram[NVAL]
// int sum
// int n
// char * filename
void stats_print(Stats res, int hist){
int sum = res.sum;
int min_index = 1;
int max_index = NVAL-1;
//printf("Sum here: %d\n", sum);
//printf("N here: %d\n", res.n);
double mean = (double)sum/(double)res.n;
int max = -1;
int min = -1;
//printf("%s\n", res.filename);
//Find the MIN
for(min_index=1; min_index<max_index; min_index++){
if(res.histogram[min_index]!= 0){
//printf("%d\n",res.histogram[min_index] );
min = min_index;
break;
}
}
//Find the Max
for(max_index=NVAL -1; min_index<max_index; max_index--){
if(res.histogram[max_index]!= 0){
max = max_index;
break;
}
}
//Find the mode
//Create Sorted Array
int *order = malloc(res.n*sizeof(int));
int orderCount = 0;
for(int x = 0 ; x < NVAL; x ++){
for(int n = 0; n <res.histogram[x]; n++){
order[orderCount] = x;
orderCount++;
//printf("%d\n",x );
}
}
if(hist!=0){
printf("Histogram: %s\n", "");
int x;
for(x = 1; x < NVAL; x++){
//printf("%d\n", res.ascii[x]);
if(res.histogram[x] != 0){
int b;
printf("%d :",x );
for(b = 0; b < res.histogram[x]; b ++){
printf("%s","-" );
}
printf("%s\n","" );
}
}
printf("%s\n","" );
}
//Find the Q1
//Find the Q2
int med = 0;
// Find the Median
if((res.n % 2) ==1 ){
int up = (int) ((((double)res.n)/2) - 0.5);
int down = (int) ((((double)res.n)/2) +0.5);
int up1 = order[up];
int down1 = order[down];
med = (int)(up1+down1)/2;
}
if((res.n %2) ==0){
med = order[res.n/2];
}
//printf("%d\n", order[res.n/2]);
if(hist==0){
printf("File: %s\n",res.filename );
}
printf("Count: %d\n", res.n);
printf("Mean: %f\n", mean);
printf("Mode: %s\n", "");
printf("Median: %d\n", med);
printf("Q1: %s\n", "");
printf("Q3: %s\n", "");
printf("Min: %d\n", min);
printf("Max: %d\n\n", max);
}
|
9a840acb7fa2a18a0ab0613fc1cab149a7a846ff
|
c1429d8b25fc34373212e47ab9ddd824bec7e657
|
/cc/array.c
|
565d61b37b88783bbc77227caec779332ff8c1aa
|
[] |
no_license
|
chandu-2/baby
|
9b3a249169d32e2742ce144165244b710a00e2e0
|
e80cc9b326300621e7013bf7cd6ec33949e67d65
|
refs/heads/master
| 2020-07-15T07:41:37.480455 | 2019-08-31T08:35:42 | 2019-08-31T08:35:42 | 205,514,522 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 131 |
c
|
array.c
|
//static way
#include<stdio.h>
int main()
{
int i,a[4]={10,20,30,40};
for(i=0;i<4;i++)
{
printf("%d\n",a[i]);
}
}
|
948ecb3954fc528988e748b8d1566a646faec2cf
|
c920079b644668fcea120937ec7bec392d2029bd
|
/B2---Graphics-Programming/MUL_2013_rtracer/src/shadow/cylinder.c
|
7179a118e472748ee8321fdefea104ab056a3f7e
|
[] |
no_license
|
Ankirama/Epitech
|
d23fc8912d19ef657b925496ce0ffcc58dc51d3b
|
3690ab3ec0c8325edee1802b6b0ce6952e3ae182
|
refs/heads/master
| 2021-01-19T08:11:27.374033 | 2018-01-03T10:06:20 | 2018-01-03T10:06:20 | 105,794,978 | 0 | 5 | null | null | null | null |
UTF-8
|
C
| false | false | 1,130 |
c
|
cylinder.c
|
/*
** cylinder.c for cylinder in /home/mar_b/rendu/MUL_2013_rtracer
**
** Made by mar_b mar_b
** Login <mar_b@epitech.net>
**
** Started on Thu Oct 9 11:04:36 2014 mar_b mar_b
** Last update Sun Oct 12 22:12:47 2014 charles viterbo
*/
#include <stdlib.h>
#include "shadow.h"
#include "utils.h"
#include "intersection.h"
#include "objects.h"
#include "rotation.h"
/*
** brief : intersection with a cylinder for the shadow
** @scene : our scene
** @l : our vector light
** @p : our vector P
*/
double shadow_cylinder(t_scene *scene, t_vector *l, t_vector *p)
{
t_cylinder *cyls;
t_vector *tmp;
double k;
cyls = scene->list_cyl;
while (cyls != NULL)
{
pass_to_simple(&p, &l, cyls->coord, cyls->rot);
tmp = create_vector(l->x - p->x, l->y - p->y, l->z - p->z);
if ((k = inter_cylinder(tmp, p, cyls->radius)) > 0 && k < 1 &&
limit(vec_p(p, k, tmp), cyls->limit_up, cyls->limit_low))
{
pass_to_real(&p, &l, cyls->coord, cyls->rot);
free(tmp);
return (k);
}
pass_to_real(&p, &l, cyls->coord, cyls->rot);
free(tmp);
cyls = cyls->next;
}
return (-1);
}
|
598a4407fb006c95281563658115fdf45b00a6cd
|
0744dcc5394cebf57ebcba343747af6871b67017
|
/os/board/imxrt1050-evk/include/board.h
|
e17b0735bb2e0d7d90fd30c233c156371943c31c
|
[
"Apache-2.0",
"GPL-1.0-or-later",
"BSD-3-Clause",
"ISC",
"MIT",
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-other-permissive"
] |
permissive
|
Samsung/TizenRT
|
96abf62f1853f61fcf91ff14671a5e0c6ca48fdb
|
1a5c2e00a4b1bbf4c505bbf5cc6a8259e926f686
|
refs/heads/master
| 2023-08-31T08:59:33.327998 | 2023-08-08T06:09:20 | 2023-08-31T04:38:20 | 82,517,252 | 590 | 719 |
Apache-2.0
| 2023-09-14T06:54:49 | 2017-02-20T04:38:30 |
C
|
UTF-8
|
C
| false | false | 9,958 |
h
|
board.h
|
/* ****************************************************************
*
* Copyright 2019 NXP Semiconductors All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************/
/************************************************************************************
* os/configs/imxrt1050/include/board.h
*
* Copyright (C) 2018 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* 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 TinyARA 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.
*
************************************************************************************/
#ifndef __CONFIGS_IMXRT1050_EVK_INCLUDE_BOARD_H
#define __CONFIGS_IMXRT1050_EVK_INCLUDE_BOARD_H
/************************************************************************************
* Included Files
************************************************************************************/
#include <tinyara/config.h>
/************************************************************************************
* Pre-processor Definitions
************************************************************************************/
/* Clocking *************************************************************************/
/* Set VDD_SOC to 1.5V */
#define IMXRT_VDD_SOC (0x12)
/* Set Arm PLL (PLL1) to fOut = (24Mhz * ARM_PLL_DIV_SELECT/2) / ARM_PODF_DIVISOR
* 600Mhz = (24Mhz * ARM_PLL_DIV_SELECT/2) / ARM_PODF_DIVISOR
* ARM_PLL_DIV_SELECT = 100
* ARM_PODF_DIVISOR = 2
* 600Mhz = (24Mhz * 100/2) / 2
*
* AHB_CLOCK_ROOT = PLL1fOut / IMXRT_AHB_PODF_DIVIDER
* 1Hz to 600 Mhz = 600Mhz / IMXRT_ARM_CLOCK_DIVIDER
* IMXRT_ARM_CLOCK_DIVIDER = 1
* 600Mhz = 600Mhz / 1
*
* PRE_PERIPH_CLK_SEL = PRE_PERIPH_CLK_SEL_PLL1
* PERIPH_CLK_SEL = 1 (0 select PERIPH_CLK2_PODF, 1 select PRE_PERIPH_CLK_SEL_PLL1)
* PERIPH_CLK = 600Mhz
*
* IPG_CLOCK_ROOT = AHB_CLOCK_ROOT / IMXRT_IPG_PODF_DIVIDER
* IMXRT_IPG_PODF_DIVIDER = 4
* 150Mhz = 600Mhz / 4
*
* PRECLK_CLOCK_ROOT = IPG_CLOCK_ROOT / IMXRT_PERCLK_PODF_DIVIDER
* IMXRT_PERCLK_PODF_DIVIDER = 1
* 150Mhz = 150Mhz / 1
*
* SEMC_CLK_ROOT = 600Mhz / IMXRT_SEMC_PODF_DIVIDER (labeled AIX_PODF in 18.2)
* IMXRT_SEMC_PODF_DIVIDER = 8
* 75Mhz = 600Mhz / 8
*
* Set Sys PLL (PLL2) to fOut = (24Mhz * (20+(2*(DIV_SELECT)))
* 528Mhz = (24Mhz * (20+(2*(1)))
*
* Set USB1 PLL (PLL3) to fOut = (24Mhz * 20)
* 480Mhz = (24Mhz * 20)
*/
#define BOARD_XTAL_FREQUENCY 24000000
#define IMXRT_PRE_PERIPH_CLK_SEL CCM_CBCMR_PRE_PERIPH_CLK_SEL_PLL1
#define IMXRT_PERIPH_CLK_SEL CCM_CBCDR_PERIPH_CLK_SEL_PRE_PERIPH
#define IMXRT_ARM_PLL_DIV_SELECT 100
#define IMXRT_ARM_PODF_DIVIDER 2
#define IMXRT_AHB_PODF_DIVIDER 1
#define IMXRT_IPG_PODF_DIVIDER 4
#define IMXRT_PERCLK_CLK_SEL CCM_CSCMR1_PERCLK_CLK_SEL_IPG_CLK_ROOT
#define IMXRT_PERCLK_PODF_DIVIDER 9
#define IMXRT_SEMC_PODF_DIVIDER 8
#define IMXRT_LPSPI_CLK_SELECT CCM_CBCMR_LPSPI_CLK_SEL_PLL3_PFD0
#define IMXRT_LSPI_PODF_DIVIDER 8
#define IMXRT_USDHC1_CLK_SELECT CCM_CSCMR1_USDHC1_CLK_SEL_PLL2_PFD0
#define IMXRT_USDHC1_PODF_DIVIDER 2
#define IMXRT_SYS_PLL_SELECT CCM_ANALOG_PLL_SYS_DIV_SELECT_22
#define BOARD_CPU_FREQUENCY \
(BOARD_XTAL_FREQUENCY * (IMXRT_ARM_PLL_DIV_SELECT / 2)) / IMXRT_ARM_PODF_DIVIDER
/* LED definitions ******************************************************************/
/* There are four LED status indicators located on the EVK Board. The functions of
* these LEDs include:
*
* - Main Power Supply(D3)
* Green: DC 5V main supply is normal.
* Red: J2 input voltage is over 5.6V.
* Off: The board is not powered.
* - Reset RED LED(D15)
* - OpenSDA LED(D16)
* - USER LED(D18)
*
* Only a single LED, D18, is under software control.
*/
/* LED index values for use with board_userled() */
#define BOARD_USERLED 0
#define BOARD_NLEDS 1
/* LED bits for use with board_userled_all() */
#define BOARD_USERLED_BIT (1 << BOARD_USERLED)
/* This LED is not used by the board port unless CONFIG_ARCH_LEDS is
* defined. In that case, the usage by the board port is defined in
* include/board.h and src/imxrt_autoleds.c. The LED is used to encode
* OS-related events as follows:
*
* -------------------- ----------------------------- ------
* SYMBOL Meaning LED
* -------------------- ----------------------------- ------ */
#define LED_STARTED 0 /* TinyARA has been started OFF */
#define LED_HEAPALLOCATE 0 /* Heap has been allocated OFF */
#define LED_IRQSENABLED 0 /* Interrupts enabled OFF */
#define LED_STACKCREATED 1 /* Idle stack created ON */
#define LED_INIRQ 2 /* In an interrupt N/C */
#define LED_SIGNAL 2 /* In a signal handler N/C */
#define LED_ASSERTION 2 /* An assertion failed N/C */
#define LED_PANIC 3 /* The system has crashed FLASH */
#undef LED_IDLE /* Not used */
/* Thus if the LED is statically on, TinyARA has successfully booted and is,
* apparently, running normally. If the LED is flashing at approximately
* 2Hz, then a fatal error has been detected and the system has halted.
*/
/* Button definitions ***************************************************************/
/* The IMXRT board has one external user button
*
* 1. SW8 (IRQ88) GPIO5-00
*/
#define BUTTON_SW8 0
#define BUTTON_SW8_BIT (1 << BUTTON_SW8)
/* PIO Disambiguation ***************************************************************/
/* LPUARTs
*
* Virtual console port provided by OpenSDA:
*
* UART1_TXD GPIO_AD_B0_12 LPUART1_TX
* UART1_RXD GPIO_AD_B0_13 LPUART1_RX
*
* NOTE: There are no alternative pin configurations for LPUART1.
*
* Arduino RS-232 Shield:
*
* J22 D0 UART_RX/D0 GPIO_AD_B1_07 LPUART3_RX
* J22 D1 UART_TX/D1 GPIO_AD_B1_06 LPUART3_TX
*/
#define GPIO_LPUART3_RX GPIO_LPUART3_RX_1 /* GPIO_AD_B1_07 */
#define GPIO_LPUART3_TX GPIO_LPUART3_TX_1 /* GPIO_AD_B1_06 */
/* LPI2Cs
*
* Arduino Connector
*
* J23 A4 A4/ADC4/SDA GPIO_AD_B1_01 LPI2C1_SDA
* J23 A5 A5/ADC5/SCL GPIO_AD_B1_00 LPI2C1_SCL
*/
#define GPIO_LPI2C1_SDA GPIO_LPI2C1_SDA_2 /* GPIO_AD_B1_01 */
#define GPIO_LPI2C1_SCL GPIO_LPI2C1_SCL_2 /* GPIO_AD_B1_00 */
#define GPIO_LPI2C2_SDA GPIO_LPI2C2_SDA_2 /* GPIO_AD_B1_01 */
#define GPIO_LPI2C2_SCL GPIO_LPI2C2_SCL_2 /* GPIO_AD_B1_00 */
#define GPIO_LPI2C3_SDA GPIO_LPI2C3_SDA_2 /* GPIO_AD_B1_01 */
#define GPIO_LPI2C3_SCL GPIO_LPI2C3_SCL_2 /* GPIO_AD_B1_00 */
#define GPIO_LPI2C4_SDA GPIO_LPI2C4_SDA_2 /* GPIO_AD_B1_01 */
#define GPIO_LPI2C4_SCL GPIO_LPI2C4_SCL_2 /* GPIO_AD_B1_00 */
/************************************************************************************
* Public Types
************************************************************************************/
/************************************************************************************
* Public Data
************************************************************************************/
#ifndef __ASSEMBLY__
#undef EXTERN
#if defined(__cplusplus)
#define EXTERN extern "C"
extern "C" {
#else
#define EXTERN extern
#endif
/************************************************************************************
* Public Functions
************************************************************************************/
#undef EXTERN
#if defined(__cplusplus)
}
#endif
#endif /* __ASSEMBLY__ */
#endif /* __CONFIGS_IMXRT1050_EVK_INCLUDE_BOARD_H */
|
f70be3b05bd37803faa65b544bc7d8827d56e246
|
0c09f9b677604435546c00a552c95c654c347438
|
/onboard/can.h
|
b3b99e28795ac1a79b7df017d432a4bf22cc6c16
|
[] |
no_license
|
jwfjia123/AutoQuad
|
5217cb7294cc45d8b19630b8e794b43692124dab
|
76444c10f5794ecc2615cffb11114111e80107cb
|
refs/heads/master
| 2021-01-21T03:14:19.099563 | 2014-08-03T03:58:36 | 2014-08-03T03:58:36 | null | 0 | 0 | null | null | null | null |
WINDOWS-1252
|
C
| false | false | 6,314 |
h
|
can.h
|
/*
This file is part of AutoQuad.
AutoQuad 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.
AutoQuad 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 AutoQuad. If not, see <http://www.gnu.org/licenses/>.
Copyright © 2011, 2012, 2013 Bill Nesbitt
*/
#ifndef _can_h
#define _can_h
// Logical Communications Channel
// 2 bits [28:27]
#define CAN_LCC_MASK ((uint32_t)0x3<<30)
#define CAN_LCC_EXCEPTION ((uint32_t)0x0<<30)
#define CAN_LCC_HIGH ((uint32_t)0x1<<30)
#define CAN_LCC_NORMAL ((uint32_t)0x2<<30)
#define CAN_LCC_INFO ((uint32_t)0x3<<30)
// Target Type
// 1 bit [26:26]
#define CAN_TT_MASK ((uint32_t)0x1<<29)
#define CAN_TT_GROUP ((uint32_t)0x0<<29)
#define CAN_TT_NODE ((uint32_t)0x1<<29)
// Function ID
// 4 bits [25:22]
#define CAN_FID_MASK ((uint32_t)0xf<<25)
#define CAN_FID_RESET_BUS ((uint32_t)0x0<<25)
#define CAN_FID_ACK ((uint32_t)0x1<<25)
#define CAN_FID_NACK ((uint32_t)0x2<<25)
#define CAN_FID_CMD ((uint32_t)0x3<<25)
#define CAN_FID_GET ((uint32_t)0x4<<25)
#define CAN_FID_SET ((uint32_t)0x5<<25)
#define CAN_FID_REPLY ((uint32_t)0x6<<25)
#define CAN_FID_REQ_ADDR ((uint32_t)0x7<<25)
#define CAN_FID_GRANT_ADDR ((uint32_t)0x8<<25)
#define CAN_FID_ERROR ((uint32_t)0x9<<25)
#define CAN_FID_PING ((uint32_t)0xa<<25)
#define CAN_FID_TELEM ((uint32_t)0xb<<25)
// Data Object Code
// 6 bits [21:16]
#define CAN_DOC_MASK ((uint32_t)0x3f<<19)
// Source ID
// 5 bits [15:11]
#define CAN_SID_MASK ((uint32_t)0x1f<<14)
// Target ID
// 5 bits [10:6]
#define CAN_TID_MASK ((uint32_t)0x1f<<9)
// Sequence ID
// 6 bits [5:0]
#define CAN_SEQ_MASK ((uint32_t)0x3f<<3)
#define CAN_TIMEOUT 1000 // ms
#define CAN_BUF_SIZE 32 // depth of the application layer FIFO
// types
enum {
CAN_TYPE_ESC = 1,
CAN_TYPE_SERVO,
CAN_TYPE_SENSOR,
CAN_TYPE_LED,
CAN_TYPE_OSD,
CAN_TYPE_UART,
CAN_TYPE_HUB,
CAN_TYPE_NUM
};
// commands
enum {
CAN_CMD_DISARM = 1,
CAN_CMD_ARM,
CAN_CMD_START,
CAN_CMD_STOP,
CAN_CMD_SETPOINT10,
CAN_CMD_SETPOINT12,
CAN_CMD_SETPOINT16,
CAN_CMD_RPM,
CAN_CMD_CFG_READ,
CAN_CMD_CFG_WRITE,
CAN_CMD_CFG_DEFAULT,
CAN_CMD_TELEM_RATE,
CAN_CMD_TELEM_VALUE,
CAN_CMD_BEEP,
CAN_CMD_POS,
CAN_CMD_USER_DEFINED,
CAN_CMD_RESET,
CAN_CMD_STREAM
};
// data types
enum {
CAN_DATA_GROUP = 1,
CAN_DATA_TYPE,
CAN_DATA_ID,
CAN_DATA_INPUT_MODE,
CAN_DATA_RUN_MODE,
CAN_DATA_STATE,
CAN_DATA_PARAM,
CAN_DATA_TELEM,
CAN_DATA_VERSION
};
// telemetry values
enum {
CAN_TELEM_NONE = 0,
CAN_TELEM_STATUS,
CAN_TELEM_STATE,
CAN_TELEM_TEMP,
CAN_TELEM_VIN,
CAN_TELEM_AMPS,
CAN_TELEM_RPM,
CAN_TELEM_ERRORS,
CAN_TELEM_NUM
};
typedef struct {
uint32_t id;
uint32_t *data;
uint8_t sid;
uint8_t tid;
uint8_t seq;
uint8_t doc;
} canPacket_t;
typedef struct {
unsigned int value1 : 10;
unsigned int value2 : 10;
unsigned int value3 : 10;
unsigned int value4 : 10;
unsigned int value5 : 10;
unsigned int value6 : 10;
unsigned int unused : 4;
} __attribute__((packed)) canGroup10_t;
typedef struct {
unsigned int value1 : 12;
unsigned int value2 : 12;
unsigned int value3 : 12;
unsigned int value4 : 12;
unsigned int value5 : 12;
unsigned int unused : 4;
} __attribute__((packed)) canGroup12_t;
typedef struct {
uint16_t value1;
uint16_t value2;
uint16_t value3;
uint16_t value4;
} __attribute__((packed)) canGroup16_t;
typedef struct {
uint32_t uuid;
uint8_t networkId;
uint8_t type;
uint8_t canId;
uint8_t groupId;
uint8_t subgroupId;
} canNodes_t;
typedef struct {
uint32_t TIR;
uint32_t TDLR;
uint32_t TDHR;
uint8_t TDTR;
} canTxBuf_t;
typedef void canTelemCallback_t(uint8_t nodeId, void *p);
typedef struct {
CanRxMsg rxMsgs[CAN_BUF_SIZE];
canTxBuf_t txMsgs[CAN_BUF_SIZE];
canNodes_t nodes[(CAN_TID_MASK>>9)+1];
canTelemCallback_t *telemFuncs[CAN_TYPE_NUM-1];
volatile uint8_t responses[64];
volatile uint8_t rxHead, rxTail;
volatile uint8_t txHead, txTail;
uint8_t responseData[64*8];
uint8_t nextNodeSlot;
uint8_t seqId;
uint8_t initialized;
} canStruct_t;
extern canStruct_t canData;
extern void canInit(void);
extern void canLowLevelInit(void);
extern int canCheckMessage(void);
extern char *canGetVersion(uint8_t tid);
extern float *canGetParam(uint8_t tid, uint16_t paramId);
extern uint8_t *canSetParam(uint32_t tt, uint8_t tid, uint16_t paramId, float value);
extern uint8_t *canGetState(uint8_t tid);
extern uint8_t *canSetGroup(uint8_t tid, uint8_t gid, uint8_t sgid);
extern void canCommandPos(uint8_t tid, float angle);
extern uint8_t *canCommandBeep(uint32_t tt, uint8_t tid, uint16_t freq, uint16_t dur);
extern uint8_t *canSetRunMode(uint32_t tt, uint8_t tid, uint8_t mode);
extern void canCommandArm(uint32_t tt, uint8_t tid);
extern void canCommandDisarm(uint32_t tt, uint8_t tid);
extern uint8_t *canCommandConfigWrite(uint32_t tt, uint8_t tid);
extern uint8_t *canCommandStart(uint32_t tt, uint8_t tid);
extern uint8_t *canCommandStop(uint32_t tt, uint8_t tid);
extern canNodes_t *canFindNode(uint8_t type, uint8_t canId);
extern void canCommandSetpoint16(uint8_t tid, uint8_t *data);
extern uint8_t *canSetTelemetryValue(uint32_t tt, uint8_t tid, uint8_t index, uint8_t value);
extern uint8_t *canSetTelemetryRate(uint32_t tt, uint8_t tid, uint16_t rate);
extern void canTelemRegister(canTelemCallback_t *func, uint8_t type);
#endif
|
f3129593e2159b159c2358caa82c6d4dc6c84445
|
976f5e0b583c3f3a87a142187b9a2b2a5ae9cf6f
|
/source/linux/tools/power/x86/turbostat/extr_turbostat.c_decode_c6_demotion_policy_msr.c
|
a78e0220a24a2e9cb32d7714182e997c24d341f8
|
[] |
no_license
|
isabella232/AnghaBench
|
7ba90823cf8c0dd25a803d1688500eec91d1cf4e
|
9a5f60cdc907a0475090eef45e5be43392c25132
|
refs/heads/master
| 2023-04-20T09:05:33.024569 | 2021-05-07T18:36:26 | 2021-05-07T18:36:26 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,193 |
c
|
extr_turbostat.c_decode_c6_demotion_policy_msr.c
|
#define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
/* Type definitions */
/* Variables and functions */
int /*<<< orphan*/ MSR_CC6_DEMOTION_POLICY_CONFIG ;
int /*<<< orphan*/ MSR_MC6_DEMOTION_POLICY_CONFIG ;
int base_cpu ;
int /*<<< orphan*/ fprintf (int /*<<< orphan*/ ,char*,int,unsigned long long,char*) ;
int /*<<< orphan*/ get_msr (int,int /*<<< orphan*/ ,unsigned long long*) ;
int /*<<< orphan*/ outf ;
void decode_c6_demotion_policy_msr(void)
{
unsigned long long msr;
if (!get_msr(base_cpu, MSR_CC6_DEMOTION_POLICY_CONFIG, &msr))
fprintf(outf, "cpu%d: MSR_CC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-CC6-Demotion)\n",
base_cpu, msr, msr & (1 << 0) ? "EN" : "DIS");
if (!get_msr(base_cpu, MSR_MC6_DEMOTION_POLICY_CONFIG, &msr))
fprintf(outf, "cpu%d: MSR_MC6_DEMOTION_POLICY_CONFIG: 0x%08llx (%sable-MC6-Demotion)\n",
base_cpu, msr, msr & (1 << 0) ? "EN" : "DIS");
}
|
6ed4cd00b3aca71e0129267f999da26f32632b2c
|
faef90478ffce72d4510e6ff9021c486bff3ede3
|
/zaj2/string.c
|
bf1a3764d9e65a5343cf087e5484ebe6b688d8e8
|
[] |
no_license
|
Avenives/PP1
|
a31e8283dcda483caae9c2e10ab3f59310ddd9a1
|
7d08f4b00795712ae67f8ef5efcc600c2a905d83
|
refs/heads/main
| 2023-01-23T02:04:34.051451 | 2020-12-10T16:58:32 | 2020-12-10T16:58:32 | 304,865,072 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 344 |
c
|
string.c
|
#include <stdio.h>
int main()
{
char a[20]={'0'};
scanf("%s",&a);
int i=0;
while(a[i]!='1'&&i<20)
i++;
i=20-i;
i/=2;
printf("____________________\n");
printf("|");for(int b=0;b<i;b++) printf(" "); printf("%s",a);printf("|");
for(int b=0;b<i;b++) printf(" ");
printf("\n____________________");
}
|
4e170a411644088515dd2ccacdbe2c9d5a65b421
|
6d54a7b26d0eb82152a549a6a9dfde656687752c
|
/src/crypto/tests/DerSigConversion_test_vectors.h
|
533a1a25f1ccf9d0041a175ced21c8a13639f1d0
|
[
"Apache-2.0",
"LicenseRef-scancode-warranty-disclaimer"
] |
permissive
|
project-chip/connectedhomeip
|
81a123d675cf527773f70047d1ed1c43be5ffe6d
|
ea3970a7f11cd227ac55917edaa835a2a9bc4fc8
|
refs/heads/master
| 2023-09-01T11:43:37.546040 | 2023-09-01T08:01:32 | 2023-09-01T08:01:32 | 244,694,174 | 6,409 | 1,789 |
Apache-2.0
| 2023-09-14T20:56:31 | 2020-03-03T17:05:10 |
C++
|
UTF-8
|
C
| false | false | 13,449 |
h
|
DerSigConversion_test_vectors.h
|
/*
*
* Copyright (c) 2021 Project CHIP Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file - This file contains HMAC SHA256 test vectors.
*
* See https://tools.ietf.org/html/rfc4231#section-4.7
*/
#pragma once
#include <stddef.h>
#include <stdint.h>
typedef struct
{
const size_t fe_length_bytes;
const uint8_t * r;
const uint8_t * s;
const uint8_t * der_version;
const size_t der_version_length;
const uint8_t * raw_version;
const size_t raw_version_length;
} der_sig_conv_vector;
// CASE 1: MSB not set, all bytes non-zero
const uint8_t kDerSigConvRCase1[] = {
0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
};
const uint8_t kDerSigConvSCase1[] = {
0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
};
const uint8_t kDerSigConvRawCase1[] = {
0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
};
const uint8_t kDerSigConvDerCase1[] = {
0x30, 0x44, 0x02, 0x20, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e,
0x02, 0x20, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
};
static const der_sig_conv_vector kDerSigConvVect1 = { .fe_length_bytes = 32u,
.r = kDerSigConvRCase1,
.s = kDerSigConvSCase1,
.der_version = kDerSigConvDerCase1,
.der_version_length = sizeof(kDerSigConvDerCase1),
.raw_version = kDerSigConvRawCase1,
.raw_version_length = sizeof(kDerSigConvRawCase1) };
// CASE 2: MSB not set, first 16 bytes zero
const uint8_t kDerSigConvRCase2[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
};
const uint8_t kDerSigConvSCase2[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
};
const uint8_t kDerSigConvRawCase2[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
};
const uint8_t kDerSigConvDerCase2[] = {
0x30, 0x26, 0x02, 0x11, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
0x80, 0x02, 0x11, 0x00, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
};
static const der_sig_conv_vector kDerSigConvVect2 = { .fe_length_bytes = 32u,
.r = kDerSigConvRCase2,
.s = kDerSigConvSCase2,
.der_version = kDerSigConvDerCase2,
.der_version_length = sizeof(kDerSigConvDerCase2),
.raw_version = kDerSigConvRawCase2,
.raw_version_length = sizeof(kDerSigConvRawCase2) };
// CASE 3: MSB set, full width value (worst case for 256 bit ECDSA)
const uint8_t kDerSigConvRCase3[] = {
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
};
const uint8_t kDerSigConvSCase3[] = {
0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
};
const uint8_t kDerSigConvRawCase3[] = {
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
};
const uint8_t kDerSigConvDerCase3[] = {
0x30, 0x46, 0x02, 0x21, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x02, 0x21, 0x00, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
};
static const der_sig_conv_vector kDerSigConvVect3 = { .fe_length_bytes = 32u,
.r = kDerSigConvRCase3,
.s = kDerSigConvSCase3,
.der_version = kDerSigConvDerCase3,
.der_version_length = sizeof(kDerSigConvDerCase3),
.raw_version = kDerSigConvRawCase3,
.raw_version_length = sizeof(kDerSigConvRawCase3) };
// CASE 4: MSB set, full width value (worst case for 512 bit ECDSA, using 2 bytes length for sequence)
// Overhead here is the max
const uint8_t kDerSigConvRCase4[] = {
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
};
const uint8_t kDerSigConvSCase4[] = {
0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
};
const uint8_t kDerSigConvRawCase4[] = {
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
};
const uint8_t kDerSigConvDerCase4[] = {
0x30, 0x81, 0x86, 0x02, 0x41, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x41, 0x00, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
};
static const der_sig_conv_vector kDerSigConvVect4 = { .fe_length_bytes = 64u,
.r = kDerSigConvRCase4,
.s = kDerSigConvSCase4,
.der_version = kDerSigConvDerCase4,
.der_version_length = sizeof(kDerSigConvDerCase4),
.raw_version = kDerSigConvRawCase4,
.raw_version_length = sizeof(kDerSigConvRawCase4) };
// CASE 5: All zeroes
const uint8_t kDerSigConvRCase5[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
const uint8_t kDerSigConvSCase5[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
const uint8_t kDerSigConvRawCase5[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
const uint8_t kDerSigConvDerCase5[] = {
0x30, 0x06, 0x02, 0x01, 0x00, 0x02, 0x01, 0x00,
};
static const der_sig_conv_vector kDerSigConvVect5 = { .fe_length_bytes = 64u,
.r = kDerSigConvRCase5,
.s = kDerSigConvSCase5,
.der_version = kDerSigConvDerCase5,
.der_version_length = sizeof(kDerSigConvDerCase5),
.raw_version = kDerSigConvRawCase5,
.raw_version_length = sizeof(kDerSigConvRawCase5) };
static const der_sig_conv_vector kDerSigConvTestVectors[] = { kDerSigConvVect1, kDerSigConvVect2, kDerSigConvVect3,
kDerSigConvVect4, kDerSigConvVect5 };
|
4837b21fb5d4da002ec92e14c40267ba9429271e
|
01950cdb62a759dbab221ca82c42252630c27067
|
/includes/fractol_define.h
|
42494a53414bf10343bd152b3afb5ed962185774
|
[] |
no_license
|
sebpalluel/fractol
|
be696949d2ffa6d8143cb2ddf0b2e51a8e2309b0
|
7051ad4a332899a6a53e8351c00ec1b480208ad2
|
refs/heads/master
| 2021-03-27T11:16:08.628265 | 2017-10-12T13:30:48 | 2017-10-12T13:30:48 | 88,344,677 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,551 |
h
|
fractol_define.h
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* fractol_define.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: psebasti <sebpalluel@free.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/04/12 20:31:26 by psebasti #+# #+# */
/* Updated: 2017/10/03 16:25:16 by psebasti ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FRACTOL_DEFINE_H
# define FRACTOL_DEFINE_H
# define WIDTH 1080
# define HEIGHT 1080
# define NUM_THREAD 4
# define FNUM 4
# define AMP 1.3
# define ERROR 1
# define OK 0
# define SETUP setup[0]
# define MAN setup->fract[0]
# define JUL setup->fract[1]
# define BUR setup->fract[2]
# define CAN setup->fract[3]
# define MAP setup->map
# define M_WIDTH setup->map->width
# define M_HEIGHT setup->map->height
# define M_DEPTH setup->map->depth
# define LERP_IN setup->map->lerp_in
# define LERP_OUT setup->map->lerp_out
# define CLR setup->map->curr_clr
# define CAM setup->cam
# define MLX setup->mlx
# define IMG setup->img
#endif
|
2ec88d4d2d149361c815d7911625a2b14765da35
|
c70a73819b7f639347707313794705913fd76abf
|
/src/Linux-kernel-mod/server/sys/types.h
|
fc439afc9dc8785cd5ec2ecede5cad7ebd03fa20
|
[
"Apache-2.0"
] |
permissive
|
mfragkoulis/PiCO_QL
|
d8f15ff77441c04d2ba38f854db6135ade7d02ce
|
165afa114b2ffd3162aae039ffb62e072a62988e
|
refs/heads/PiCO_QL-application-release
| 2020-05-21T15:23:43.215927 | 2018-07-15T19:03:51 | 2018-07-15T19:03:51 | 4,446,567 | 11 | 8 | null | 2018-07-15T19:03:52 | 2012-05-25T14:47:20 |
C
|
UTF-8
|
C
| false | false | 68 |
h
|
types.h
|
#ifndef _TYPES_H
#define _TYPES_H
#include <linux/types.h>
#endif
|
05dc3838dcbb3bfc6fd0b0daeca086628be57f71
|
26922ce0f33589caea1bdaae0aacc972d4bbb167
|
/microchip library/apps/crypto_16bv1/aes/firmware/src/otp_key_demos.c.c
|
d6aa70c559e427c9788d921a07ca03eecd172939
|
[] |
no_license
|
alexandrequ/scalar4
|
d3afe3b09faf6731009593b71bf971d9d862d44d
|
deda54a12a635720f79fee3b7ce710b124fda087
|
refs/heads/main
| 2023-03-04T09:03:20.256507 | 2021-02-15T20:05:24 | 2021-02-15T20:05:24 | 339,189,700 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 16,527 |
c
|
otp_key_demos.c.c
|
/******************************************************************************
Software License Agreement:
The software supplied herewith by Microchip Technology Incorporated
(the "Company") for its PICmicro(r) Microcontroller is intended and
supplied to you, the Company's customer, for use solely and
exclusively on Microchip PICmicro Microcontroller products. The
software is owned by the Company and/or its supplier, and is
protected under applicable copyright laws. All rights are reserved.
Any use in violation of the foregoing restrictions may subject the
user to criminal sanctions under applicable laws, as well as to
civil liability for the breach of the terms and conditions of this
license.
THIS SOFTWARE IS PROVIDED IN AN "AS IS" CONDITION. NO WARRANTIES,
WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
********************************************************************/
#include <xc.h>
#include <stdint.h>
#include <crypto_16bv1/crypto_16bv1.h>
#include <string.h>
extern void CRYPTO_OTP_WriteStart(void);
uint8_t DEMO_OTP_AES128KeyProgram(void);
void DEMO_OTP_AES128Key1Test(BLOCK_CIPHER_HANDLE handle);
void DEMO_OTP_AES128Key2Test(BLOCK_CIPHER_HANDLE handle);
void DEMO_OTP_AES128Key3Test(BLOCK_CIPHER_HANDLE handle);
void DEMO_OTP_AES128Key4Test(BLOCK_CIPHER_HANDLE handle);
void AES_OTP_Examples(BLOCK_CIPHER_HANDLE handle)
{
uint8_t error;
error = DEMO_OTP_AES128KeyProgram();
if(error != 0)
{
/* There was an error in the key programming */
while(1){}
}
DEMO_OTP_AES128Key1Test(handle);
DEMO_OTP_AES128Key2Test(handle);
DEMO_OTP_AES128Key3Test(handle);
DEMO_OTP_AES128Key4Test(handle);
}
/* Select 4 different keys */
static uint8_t key1[] = {
0x00, 0x01, 0x02, 0x03,
0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0A, 0x0B,
0x0C, 0x0D, 0x0E, 0x0F
};
static uint8_t key2[] = {
0x10, 0x11, 0x12, 0x13,
0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1A, 0x1B,
0x1C, 0x1D, 0x1E, 0x1F
};
static uint8_t key3[] = {
0x20, 0x21, 0x22, 0x23,
0x24, 0x25, 0x26, 0x27,
0x28, 0x29, 0x2A, 0x2B,
0x2C, 0x2D, 0x2E, 0x2F
};
static uint8_t key4[] = {
0x30, 0x31, 0x32, 0x33,
0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x3A, 0x3B,
0x3C, 0x3D, 0x3E, 0x3F
};
uint8_t DEMO_OTP_AES128KeyProgram(void)
{
//Turn module on
CRYCONLbits.CRYON = 0b1;
/************************************************************
* Program Key 1
***********************************************************/
//Clear all registers
CRYCONH = 0;
CRYSTAT = 0;
CRYOTP = 0;
//point to page 1
CRYOTPbits.KEYPG = 1;
memcpy((void*)&CRYTXTC0, &key1[0], 8);
__builtin_write_CRYOTP();
while(CRYOTPbits.CRYWR == 1){}
//point to page 2
CRYOTPbits.KEYPG = 2;
memcpy((void*)&CRYTXTC0, &key1[8], 8);
__builtin_write_CRYOTP();
while(CRYOTPbits.CRYWR == 1){}
/************************************************************
* Program Key 2
***********************************************************/
//Clear all registers
CRYCONH = 0;
CRYSTAT = 0;
CRYOTP = 0;
//point to page 3
CRYOTPbits.KEYPG = 3;
memcpy((void*)&CRYTXTC0, &key2[0], 8);
__builtin_write_CRYOTP();
while(CRYOTPbits.CRYWR == 1){}
//point to page 4
CRYOTPbits.KEYPG = 4;
memcpy((void*)&CRYTXTC0, &key2[8], 8);
__builtin_write_CRYOTP();
while(CRYOTPbits.CRYWR == 1){}
/************************************************************
* Program Key 3
***********************************************************/
//Clear all registers
CRYCONH = 0;
CRYSTAT = 0;
CRYOTP = 0;
//point to page 5
CRYOTPbits.KEYPG = 5;
memcpy((void*)&CRYTXTC0, &key3[0], 8);
__builtin_write_CRYOTP();
while(CRYOTPbits.CRYWR == 1){}
//point to page 6
CRYOTPbits.KEYPG = 6;
memcpy((void*)&CRYTXTC0, &key3[8], 8);
__builtin_write_CRYOTP();
while(CRYOTPbits.CRYWR == 1){}
/************************************************************
* Program Key 4
***********************************************************/
//Clear all registers
CRYCONH = 0;
CRYSTAT = 0;
CRYOTP = 0;
//point to page 7
CRYOTPbits.KEYPG = 7;
memcpy((void*)&CRYTXTC0, &key4[0], 8);
__builtin_write_CRYOTP();
while(CRYOTPbits.CRYWR == 1){}
//point to page 8
CRYOTPbits.KEYPG = 8;
memcpy((void*)&CRYTXTC0, &key4[8], 8);
__builtin_write_CRYOTP();
while(CRYOTPbits.CRYWR == 1){}
//Clear all registers
CRYCONH = 0;
CRYSTAT = 0;
CRYOTP = 0;
/* Enable 128-bit AES for all pages and lock all pages for modification.
*
* Reserved
* |TSTPGM = 1 (OTP has been programmed)
* ||Unimplemented <1:0>
* ||| KEY7TYPE<1:0> = 10 (AES-128)
* ||| | KEY5TYPE<1:0> = 10 (AES-128)
* ||| | | KEY3TYPE<1:0> = 10 (AES-128)
* ||| | | | KEY1TYPE<1:0> = 10 (AES-128)
* ||| | | | | SKENEN = 0 (key 1 used for any operation)
* ||| | | | | |LKYSRC<7:0> = (N/A due to SRCLCK = 0)
* ||| | | | | || SRCLCK = 0
* ||| | | | | || |WRLOCK8 = 1 (locked)
* ||| | | | | || ||WRLOCK7 = 1 (locked)
* ||| | | | | || |||WRLOCK6 = 1 (locked)
* ||| | | | | || ||||WRLOCK5 = 1 (locked)
* ||| | | | | || |||||WRLOCK4 = 1 (locked)
* ||| | | | | || ||||||WRLOCK3 = 1 (locked)
* ||| | | | | || |||||||WRLOCK2 = 1 (locked)
* ||| | | | | || ||||||||WRLOCK1 = 1 (locked)
* ||| | | | | || |||||||||WRLOCK0 = 1 (locked)
* ||| | | | | || ||||||||||SWKYDIS = 0 (software keys allowed)
||| | | | | || ||||||||||| */
uint32_t otpConfig = 0b01001010101000000000001111111110;
/*********************/
/* Configure the OTP */
/*********************/
//point to page 0
CRYOTPbits.KEYPG = 0b0000;
memcpy((void*)&CRYTXTC0, (uint8_t*)&otpConfig, sizeof(otpConfig));
__builtin_write_CRYOTP();
while(CRYOTPbits.CRYWR == 1){}
CRYOTPbits.CRYREAD = 1;
while(CRYOTPbits.CRYREAD == 1){}
return 0;
}
void DEMO_OTP_AES128Key1Test(BLOCK_CIPHER_HANDLE handle)
{
static uint8_t plain_text[] = { 0x00, 0x11, 0x22, 0x33,
0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xAA, 0xBB,
0xCC, 0xDD, 0xEE, 0xFF
};
BLOCK_CIPHER_16BV1_ECB_CONTEXT context;
uint32_t num_bytes_encrypted = 0;
BLOCK_CIPHER_STATE state;
//We need a buffer to contain the resulting data.
// This buffer can be created statically or dynamically and can be
// of any size as long as it is larger than or equal to AES_BLOCK_SIZE
uint8_t cipher_text[sizeof(plain_text)];
memset(cipher_text, 0x00, sizeof(cipher_text));
// Initialize the Block Cipher context
BLOCK_CIPHER_16BV1_ECB_Initialize(
handle,
&context,
CRYPTO_16BV1_ALGORITHM_AES,
CRYPTO_16BV1_ALGORITHM_AES,
AES_BLOCK_SIZE,
NULL,
CRYPTO_KEY_HARDWARE_OTP_1,
CRYPTO_AES_128_KEY
);
//Encrypt the data
BLOCK_CIPHER_16BV1_ECB_Encrypt (
handle,
cipher_text,
&num_bytes_encrypted,
(void *) plain_text,
sizeof(plain_text),
BLOCK_CIPHER_OPTION_STREAM_START |
BLOCK_CIPHER_OPTION_STREAM_COMPLETE |
BLOCK_CIPHER_OPTION_PAD_NONE
);
while (((state = BLOCK_CIPHER_16BV1_GetState(handle)) != BLOCK_CIPHER_STATE_IDLE) && (state != BLOCK_CIPHER_STATE_ERROR))
{
BLOCK_CIPHER_16BV1_Tasks();
}
if (state == BLOCK_CIPHER_STATE_ERROR)
{
while(1);
}
//Now let's check the results
{
static uint8_t expected_result[] = { 0x69, 0xc4, 0xe0, 0xd8,
0x6a, 0x7b, 0x04, 0x30,
0xd8, 0xcd, 0xb7, 0x80,
0x70, 0xb4, 0xc5, 0x5a
};
unsigned int i;
for(i=0;i<sizeof(plain_text);i++)
{
if(cipher_text[i] != expected_result[i])
{
//Error: results don't match what was expected
while(1){}
}
}
}
}
void DEMO_OTP_AES128Key2Test(BLOCK_CIPHER_HANDLE handle)
{
static uint8_t plain_text[] = { 0x00, 0x11, 0x22, 0x33,
0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xAA, 0xBB,
0xCC, 0xDD, 0xEE, 0xFF
};
BLOCK_CIPHER_16BV1_ECB_CONTEXT context;
uint32_t num_bytes_encrypted = 0;
BLOCK_CIPHER_STATE state;
//We need a buffer to contain the resulting data.
// This buffer can be created statically or dynamically and can be
// of any size as long as it is larger than or equal to AES_BLOCK_SIZE
uint8_t cipher_text[sizeof(plain_text)];
// Initialize the Block Cipher context
BLOCK_CIPHER_16BV1_ECB_Initialize(
handle,
&context,
CRYPTO_16BV1_ALGORITHM_AES,
CRYPTO_16BV1_ALGORITHM_AES,
AES_BLOCK_SIZE,
NULL,
CRYPTO_KEY_HARDWARE_OTP_2,
CRYPTO_AES_128_KEY
);
//Encrypt the data
BLOCK_CIPHER_16BV1_ECB_Encrypt (
handle,
cipher_text,
&num_bytes_encrypted,
(void *) plain_text,
sizeof(plain_text),
BLOCK_CIPHER_OPTION_STREAM_START |
BLOCK_CIPHER_OPTION_STREAM_COMPLETE |
BLOCK_CIPHER_OPTION_PAD_NONE
);
while (((state = BLOCK_CIPHER_16BV1_GetState(handle)) != BLOCK_CIPHER_STATE_IDLE) && (state != BLOCK_CIPHER_STATE_ERROR))
{
BLOCK_CIPHER_16BV1_Tasks();
}
if (state == BLOCK_CIPHER_STATE_ERROR)
{
while(1);
}
//Now let's check the results
{
static uint8_t expected_result[] = { 0xe1, 0x8a, 0x55, 0x67,
0x01, 0xfe, 0x93, 0x4a,
0x34, 0xba, 0x4c, 0x02,
0x6b, 0x35, 0xf6, 0xc1
};
unsigned int i;
for(i=0;i<sizeof(plain_text);i++)
{
if(cipher_text[i] != expected_result[i])
{
//Error: results don't match what was expected
while(1){};
}
}
}
}
void DEMO_OTP_AES128Key3Test(BLOCK_CIPHER_HANDLE handle)
{
static uint8_t plain_text[] = { 0x00, 0x11, 0x22, 0x33,
0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xAA, 0xBB,
0xCC, 0xDD, 0xEE, 0xFF
};
BLOCK_CIPHER_16BV1_ECB_CONTEXT context;
uint32_t num_bytes_encrypted = 0;
BLOCK_CIPHER_STATE state;
//We need a buffer to contain the resulting data.
// This buffer can be created statically or dynamically and can be
// of any size as long as it is larger than or equal to AES_BLOCK_SIZE
uint8_t cipher_text[sizeof(plain_text)];
// Initialize the Block Cipher context
BLOCK_CIPHER_16BV1_ECB_Initialize(
handle,
&context,
CRYPTO_16BV1_ALGORITHM_AES,
CRYPTO_16BV1_ALGORITHM_AES,
AES_BLOCK_SIZE,
NULL,
CRYPTO_KEY_HARDWARE_OTP_3,
CRYPTO_AES_128_KEY
);
//Encrypt the data
BLOCK_CIPHER_16BV1_ECB_Encrypt (
handle,
cipher_text,
&num_bytes_encrypted,
(void *) plain_text,
sizeof(plain_text),
BLOCK_CIPHER_OPTION_STREAM_START |
BLOCK_CIPHER_OPTION_STREAM_COMPLETE |
BLOCK_CIPHER_OPTION_PAD_NONE
);
while (((state = BLOCK_CIPHER_16BV1_GetState(handle)) != BLOCK_CIPHER_STATE_IDLE) && (state != BLOCK_CIPHER_STATE_ERROR))
{
BLOCK_CIPHER_16BV1_Tasks();
}
if (state == BLOCK_CIPHER_STATE_ERROR)
{
while(1);
}
//Now let's check the results
{
static uint8_t expected_result[] = { 0x85, 0xa8, 0xa0, 0x5c,
0x4a, 0xc5, 0x40, 0x91,
0xe3, 0x8f, 0x3f, 0x03,
0x1e, 0x39, 0x85, 0x04
};
unsigned int i;
for(i=0;i<sizeof(plain_text);i++)
{
if(cipher_text[i] != expected_result[i])
{
//Error: results don't match what was expected
while(1){};
}
}
}
}
void DEMO_OTP_AES128Key4Test(BLOCK_CIPHER_HANDLE handle)
{
static uint8_t plain_text[] = { 0x00, 0x11, 0x22, 0x33,
0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xAA, 0xBB,
0xCC, 0xDD, 0xEE, 0xFF
};
BLOCK_CIPHER_16BV1_ECB_CONTEXT context;
uint32_t num_bytes_encrypted = 0;
BLOCK_CIPHER_STATE state;
//We need a buffer to contain the resulting data.
// This buffer can be created statically or dynamically and can be
// of any size as long as it is larger than or equal to AES_BLOCK_SIZE
uint8_t cipher_text[sizeof(plain_text)];
// Initialize the Block Cipher context
BLOCK_CIPHER_16BV1_ECB_Initialize(
handle,
&context,
CRYPTO_16BV1_ALGORITHM_AES,
CRYPTO_16BV1_ALGORITHM_AES,
AES_BLOCK_SIZE,
NULL,
CRYPTO_KEY_HARDWARE_OTP_4,
CRYPTO_AES_128_KEY
);
//Encrypt the data
BLOCK_CIPHER_16BV1_ECB_Encrypt (
handle,
cipher_text,
&num_bytes_encrypted,
(void *) plain_text,
sizeof(plain_text),
BLOCK_CIPHER_OPTION_STREAM_START |
BLOCK_CIPHER_OPTION_STREAM_COMPLETE |
BLOCK_CIPHER_OPTION_PAD_NONE
);
while (((state = BLOCK_CIPHER_16BV1_GetState(handle)) != BLOCK_CIPHER_STATE_IDLE) && (state != BLOCK_CIPHER_STATE_ERROR))
{
BLOCK_CIPHER_16BV1_Tasks();
}
if (state == BLOCK_CIPHER_STATE_ERROR)
{
while(1);
}
//Now let's check the results
{
static uint8_t expected_result[] = { 0x8d, 0x7b, 0xb9, 0x5f,
0xf3, 0x03, 0x6f, 0x89,
0x5a, 0x1c, 0x6c, 0x9d,
0xf6, 0xd3, 0x83, 0x1c
};
unsigned int i;
for(i=0;i<sizeof(plain_text);i++)
{
if(cipher_text[i] != expected_result[i])
{
//Error: results don't match what was expected
while(1){};
}
}
}
}
|
584fa4454f99946703be1940bdf025ad6461cf64
|
df6b0e21afddbbe4b7b14eb82d2cafa7b7016500
|
/TestExpendeur/TestExpendeur/Main.h
|
f955bdcf98dcc2ff7a2bf86421ecc0e5d4177dee
|
[] |
no_license
|
LaurentChevalier/ATMEGA_1284p
|
9caba43ae6048074e7e93c363e7d0226caf0cc95
|
da4acc89373a7e4c9aea419d66564fddd7fc0c11
|
refs/heads/master
| 2021-08-16T00:37:48.646432 | 2017-11-18T17:08:05 | 2017-11-18T17:08:05 | 111,075,682 | 2 | 0 | null | null | null | null |
ISO-8859-1
|
C
| false | false | 913 |
h
|
Main.h
|
// Main.h
#ifndef _main_h_
#define _main_h_
//****************************************
// CONSIGNES ET OBJECTIFS DU PROGRAMME
//****************************************
/*
Objectifs:
Utilisation du TIMER1 (16 bits) pour générer une interruption toutes les 2ms
Utilisation de l'entrée INT0 en interruption externe
Gestion des ports I/O
Gestion des interruptions et de la boucle infinie
Consignes du programme -> Par l'utilisation de CallBack
1. Clignotement de la LED à 1 Hertz
2. Si bouton poussoir appuyé alors activation relais pendant 3 sec et changement de clignotement de 1 Hz à 10 Hz
*/
// DEFINE
// Gestion registre par bit unique
#define sbiBF(port,bit) (port |= (1<<bit)) //set bit in port
#define cbiBF(port,bit) (port &= ~(1<<bit)) //clear bit in port
#define tbiBF(port,bit) (port ^= (1<<bit))
#define TRUE 1
#define FALSE 0
void Test (void);
#endif /* _main.h */
|
fd7e66cd641576ae63d63dd6bfbcb6e48efd6364
|
0ef27af9b946495e95d0e28ee870feb7d87af9f6
|
/IS2017/2d-array.c
|
3ae5a8531dd57af3bac4adb9326d3a2036bc2cd2
|
[] |
no_license
|
papagenox/bbc3502
|
5ba2cc455395fdffeeed74ead6fe13489b456752
|
4ff297d4bf740c19992fb9dd1a7ba71266daed5f
|
refs/heads/master
| 2023-05-10T12:53:14.178869 | 2021-06-04T07:05:30 | 2021-06-04T07:05:30 | 112,692,859 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 2,225 |
c
|
2d-array.c
|
/* Desc: 用二维数组来存储多个学生的多课成绩单
1，输出全部学生的各科成绩
2，找出最高得分
3，计算每位同学的平均分
4，计算每门课的平均分
Author: Liutong XU
Date: 2016/12/01
*/
#include<stdio.h>
#define STUDENTS 3
#define COURSES 4
int maximum(int grades[STUDENTS][COURSES],int students,int courses);
void printArray(int grades[STUDENTS][COURSES],int students,int courses);
float avgForStudent (int setOfGrades[],int courses);
float avgForCourse(int grades[STUDENTS][COURSES],int students, int course);
int main()
{
int studentGrades[STUDENTS][COURSES] = {{89,98,67,77},{98,77,65,88},{90,80,89,66}};
int i;
printArray(studentGrades,STUDENTS,COURSES);
printf("\nThe max score is %d\n\n",maximum(studentGrades,STUDENTS,COURSES));
for (i=0; i<STUDENTS; i++)
printf("The avg score of student #%d = %f\n",i,avgForStudent(studentGrades[i],COURSES));
printf("\n");
for (i=0; i<COURSES; i++)
printf("The avg score of course #%d is %f\n",i,avgForCourse(studentGrades,STUDENTS,i));
return 0;
}
//Output all scores
void printArray(int grades[STUDENTS][COURSES],int students,int courses)
{
int i,j;
for(i=0; i<=students-1; i++)
{
printf("studentGrades[%d] ",i);
for(j=0; j<=courses-1; j++)
printf("%-5d",grades[i][j]);
printf("\n");
}
}
//calculate the highest score among all students
int maximum(int grades[STUDENTS][COURSES],int students, int courses)
{
int i,j,highGrade=0;
for(i=0; i<=students-1; i++)
for(j=0; j<=courses-1; j++)
if(grades[i][j]>highGrade)
highGrade=grades[i][j];
return highGrade;
}
//Calculate average score for each student
float avgForStudent(int setOfGrades[],int courses)
{
int i,total=0;
for(i=0; i<=courses-1; i++)
total+=setOfGrades[i];
return (float)total/courses;
}
float avgForCourse(int grades[STUDENTS][COURSES],int students, int course)
{
int i,total=0;
for(i=0; i<=students-1; i++)
total+=grades[i][course];
return (float)total/students;
}
|
c311bd39aa964bda8ad4202c91f956c177640517
|
7989f8340c59c242e0dd233343f531af2f84d916
|
/include/Pieza.h
|
286bfd5aef620446ef84b302c2f805d8bee2cbe4
|
[] |
no_license
|
dadais216/ajedrez
|
514fbafb5898b73997288bec0bae317fbfe5257f
|
d55827fbcd2e0411a595e233728aa27934e3671a
|
refs/heads/master
| 2021-07-25T06:58:54.119741 | 2021-06-23T05:10:32 | 2021-06-23T05:10:32 | 115,892,398 | 0 | 1 | null | null | null | null |
UTF-8
|
C
| false | false | 876 |
h
|
Pieza.h
|
#ifndef PIEZA_H
#define PIEZA_H
struct operador;
struct Piece;
struct pBase{
int root;
memLocalt memLocal;
int size;
};
struct Piece{
Sprite spriteb,spriten;
int ind;//se usa en el reciclaje en spawn
int sn;
varray<pBase> movs;
int memPieceSize;
int hsSize;
//bool kamikase;
//bool spawner;
};
extern vector<int> pisados;
struct Holder{
int piece;
int tile;
varray<int> memPiece;//podria ser 1 puntero en vez de 2 TODO
varray<int> movs;
bool bando;
bool inPlay;//false cuando la pieza esta generada y capturada. Solo se usa para evitar activar triggers dinamicos a capturados
int step;//valor que varia para indicar si la pieza se movio, para comprobar validez de triggers
};
void crearMovHolder(int,int,bigVector*);
int initHolder(Piece*,int,int,bigVector*);
void generar(Holder*);
void makeCli(Holder*);
#endif // PIEZA_H
|
1c8922ef95463b2b3499db58676ea2d94790da45
|
38d013a187c4d3cfb958a35702894e9bc69f4c4f
|
/orion3d/code/gtk+/gdk/gdkcursor.h
|
3c531efa432b48d578b41826982bd9e81cbdd215
|
[] |
no_license
|
gpeyre/Orion3D
|
2a91288071085fedd73b9974ebd62945741f72b0
|
d96f70ce39cebdcd82355a507026acd25fa91eaf
|
refs/heads/master
| 2020-03-14T16:22:08.336181 | 2018-05-01T09:38:22 | 2018-05-01T09:38:22 | 131,696,922 | 8 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 830 |
h
|
gdkcursor.h
|
#ifndef __GDK_CURSOR_H__
#define __GDK_CURSOR_H__
#include <gdk/gdktypes.h>
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/* Cursor types.
*/
typedef enum
{
#include <gdk/gdkcursors.h>
GDK_LAST_CURSOR,
GDK_CURSOR_IS_PIXMAP = -1
} GdkCursorType;
struct _GdkCursor
{
GdkCursorType type;
guint ref_count;
};
/* Cursors
*/
GdkCursor* gdk_cursor_new (GdkCursorType cursor_type);
GdkCursor* gdk_cursor_new_from_pixmap (GdkPixmap *source,
GdkPixmap *mask,
GdkColor *fg,
GdkColor *bg,
gint x,
gint y);
GdkCursor* gdk_cursor_ref (GdkCursor *cursor);
void gdk_cursor_unref (GdkCursor *cursor);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __GDK_CURSOR_H__ */
|
24fd0462c64569ac25514da0e61eaa6f46d50a95
|
1cfa2c3766b4bc4db6305ea397db18ed14787a3c
|
/src/ziack.c
|
17f7d999f53a593c10dc1ca31b65bcf4ace7d1e8
|
[] |
no_license
|
Zimilo/ziack
|
2b80df5f5e14af208796e66e7b922d3c2247a994
|
a2f6211700e9d227c3b1d21ee9c6c1c3ed3c0c9e
|
refs/heads/master
| 2020-05-17T03:16:35.367389 | 2012-07-04T10:07:08 | 2012-07-04T10:07:08 | 3,334,745 | 2 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 594 |
c
|
ziack.c
|
/**
* zimilo@code-trick.com
*/
#include "ziack.h"
#include "ziack_memory.h"
#include "ziack_hint.h"
#include "ziack_file.h"
#include "ziack_vector.h"
#include <signal.h>
ziack_t *z = NULL;
ziack_rc_t
ziack_server_start()
{
z = (ziack_t *)ziack_calloc(1, sizeof(ziack_t));
z->hint = ziack_hint_create(0);
z->active_file = ziack_file_open();
z->old_fileds = ziack_vector_create(0);
return ZIACK_RC_OK;
}
ziack_rc_t
ziack_server_stop()
{
return ZIACK_RC_OK;
}
int
main(int argc, char **argv)
{
if (ziack_server_start() != ZIACK_RC_OK) {
}
return EXIT_SUCCESS;
}
|
d3ff3e77ccd5d05445fb7aeef568cdc6cee24e64
|
ba22f9becd4e5719c69e45b79c3edcb945c3b026
|
/DOTS/gotoxy.h
|
d879cb3395010923cb89d7849a19c5a762485ae2
|
[] |
no_license
|
RMarinh0/Dots
|
3623687650b2d0a8275b169f38a411298ec6aeec
|
6f3a84453e30d2c5507579f32a3f946928aa64dd
|
refs/heads/master
| 2021-01-04T03:11:26.056993 | 2020-02-13T20:38:48 | 2020-02-13T20:38:48 | 240,351,610 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 119 |
h
|
gotoxy.h
|
#ifndef GOTOXY_H_INCLUDED
#define GOTOXY_H_INCLUDED
void gotoxy(short x, short y);
#endif // GOTOXY_H_INCLUDED
|
f524f245dbc68c913f6a60fc006afa33a163bd9c
|
ee9560c4308a0f818b84afeaa0ed6ca2ab3f67f7
|
/Piscine_C/day03/ex01/ft_ultimate_ft.c
|
0a1a8c1dd0aaa84d73807e1136c62c989a780f6e
|
[] |
no_license
|
dashawebb/School21
|
e8168a3a0aab87181a1cd2985be1a23723d69116
|
a2c8b8c15c35d53bd7109f2935e8c98ab1cc78f3
|
refs/heads/master
| 2020-04-17T22:08:21.206369 | 2019-01-23T14:13:32 | 2019-01-23T14:13:32 | 166,981,912 | 0 | 3 | null | 2019-01-22T11:24:06 | 2019-01-22T11:24:06 | null |
UTF-8
|
C
| false | false | 954 |
c
|
ft_ultimate_ft.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ultimate_ft.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: elchrist <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/09/21 20:55:14 by elchrist #+# #+# */
/* Updated: 2018/09/21 21:03:22 by elchrist ### ########.fr */
/* */
/* ************************************************************************** */
void ft_ultimate_ft(int *********nbr)
{
*********nbr = 42;
}
|
adb027ca9be31350725ac1ce722d1db4de5fb594
|
05f0cab2f3c7426a0ae3bbe38e42e261c03ca49b
|
/application/system_resource_detect/source/gmi_network_reboot_times.h
|
b2c7803918185064d6d089521a9e58900bf6922c
|
[] |
no_license
|
JammyWei/ver30
|
199719eb7904db0b5d764a413e0ea6b7e8a26f6f
|
2e1fe0eeb6cef5c6e35a16e30226874a14b86f7d
|
refs/heads/master
| 2020-04-03T13:01:17.982783 | 2014-03-05T09:38:58 | 2014-03-05T09:38:58 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,627 |
h
|
gmi_network_reboot_times.h
|
#ifndef GMI_NETWORK_REBOOT_TIMES_H
#define GMI_NETWORK_REBOOT_TIMES_H
#include "gmi_system_headers.h"
#define NETWORK_REBOOT_FILE "/opt/log/networkTimes"
#define BUFFER_LENGTH 64
#define NETWORK_DOWN 0
#define NETWORK_UP 1
#define NETWORK_DETECT_NUMBER_MAX 10
#define NETWORK_DETECT_INTERRUPTS_MAX 5
#define NETWORK_INTERRUPTS_NUMBER_MAX 300000
#define GMI_NETWORK_RX_PACKETS_CMD "ifconfig eth0 | grep \"RX packets:\" | awk '{print $2}' | tr -d 'packets:'"
#define GMI_NETWORK_TX_PACKETS_CMD "ifconfig eth0 | grep \"TX packets:\" | awk '{print $2}' | tr -d 'packets:'"
#define GMI_NETWORK_DEV_CMD "ifconfig | grep \"eth0\" | awk '{print $1}'"
#define GMI_NETWORK_INTERRUPTS_CMD "cat /proc/interrupts | grep eth0 | awk '{print $2}'"
#define GMI_NETWORK_RESTART "/etc/init.d/S40network restart &"
#define GMI_CONFIT_TOOL_RESTART "killall -9 config_tool"
typedef struct _SystemNetWorkRebootTimes
{
uint8_t s_Times; //IP Addr
uint8_t s_Reserve[3]; //Mask Addr
uint32_t s_RebootTime;
} SystemNetWorkRebootTimes;
#ifdef __cplusplus
extern "C" {
#endif
GMI_RESULT GMI_ReadRebootTimes(SystemNetWorkRebootTimes *NetWorkRebootTimes);
GMI_RESULT GMI_WriteRebootTimes(const SystemNetWorkRebootTimes *NetWorkRebootTimes);
GMI_RESULT GMI_GetNetWorkPackets(const char_t *Cmd, char_t *Buf, int32_t Length);
GMI_RESULT GMI_FileExists(const char_t *FileName);
GMI_RESULT GMI_NetWorkDevCheck(boolean_t *dev);
#ifdef __cplusplus
}
#endif
#endif /* GMI_CONFIG_H */
|
d97ce2a5747e874bf2705877bdedbcdcd412be0e
|
8886361e436c7598419f444a52ae587bf94b1fbe
|
/contrib/bitshuffle_neon/Test/bitshuffle_bitunshuffle_test1.c
|
18e6361d97946ab3c2e753e85341e693844ab1ef
|
[
"BSD-3-Clause"
] |
permissive
|
Blosc/c-blosc2
|
d4b69bf735e1440ea1d7e147f434b488f975c8d4
|
6bbade9e13bd166ea0189f8c3b6253c9bbe9bb54
|
refs/heads/main
| 2023-08-31T15:47:35.224132 | 2023-08-31T03:01:37 | 2023-08-31T06:01:40 | 40,355,993 | 358 | 85 |
NOASSERTION
| 2023-09-12T09:26:36 | 2015-08-07T10:51:35 |
C
|
UTF-8
|
C
| false | false | 6,974 |
c
|
bitshuffle_bitunshuffle_test1.c
|
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <arm_neon.h>
#include <assert.h>
#define CHECK_MULT_EIGHT(n) if (n % 8) exit(0);
static void printmem8(uint8x8_t buf)
{
printf("%x,%x,%x,%x,%x,%x,%x,%x\n",
buf[7], buf[6], buf[5], buf[4],
buf[3], buf[2], buf[1], buf[0]);
}
static void printmem16(uint8x16_t r0)
{
uint8_t buf[16];
((uint8x16_t *)buf)[0] = r0;
printf("%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x\n",
buf[15], buf[14], buf[13], buf[12],
buf[11], buf[10], buf[9], buf[8],
buf[7], buf[6], buf[5], buf[4],
buf[3], buf[2], buf[1], buf[0]);
}
static void printmem(uint8_t* buf)
{
printf("%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,"
"%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x,%x\n",
buf[31], buf[30], buf[29], buf[28],
buf[27], buf[26], buf[25], buf[24],
buf[23], buf[22], buf[21], buf[20],
buf[19], buf[18], buf[17], buf[16],
buf[15], buf[14], buf[13], buf[12],
buf[11], buf[10], buf[9], buf[8],
buf[7], buf[6], buf[5], buf[4],
buf[3], buf[2], buf[1], buf[0]);
}
/* Routine optimized for bit-shuffling a buffer for a type size of 1 byte. */
static void
bitshuffle1_neon(const uint8_t* const src, uint8_t* dest, const size_t nbyte) {
const size_t elem_size = 1;
uint16x8_t x0;
size_t i, j, k;
const int8_t __attribute__ ((aligned (16))) xr[8] = {0,1,2,3,4,5,6,7};
uint8x8_t mask_and = vdup_n_u8(0x01);
int8x8_t mask_shift = vld1_s8(xr);
uint8x8_t lo_x, hi_x, lo, hi;
/* #define CHECK_MULT_EIGHT(n) if (n % 8) exit(0); */
CHECK_MULT_EIGHT(nbyte);
for (i = 0, k = 0; i < nbyte; i += 16, k++) {
/* Load 16-byte groups */
x0 = vld1q_u8(src + k*16);
/* Split in 8-bytes grops */
lo_x = vget_low_u8(x0);
hi_x = vget_high_u8(x0);
for (j = 0; j < 8; j++) {
/* Create mask from the most significant bit of each 8-bit element */
lo = vand_u8(lo_x, mask_and);
lo = vshl_u8(lo, mask_shift);
hi = vand_u8(hi_x, mask_and);
hi = vshl_u8(hi, mask_shift);
lo = vpadd_u8(lo,lo);
lo = vpadd_u8(lo,lo);
lo = vpadd_u8(lo,lo);
hi = vpadd_u8(hi,hi);
hi = vpadd_u8(hi,hi);
hi = vpadd_u8(hi,hi);
/* Shift packed 8-bit */
lo_x = vshr_n_u8(lo_x, 1);
hi_x = vshr_n_u8(hi_x, 1);
/* Store the created mask to the destination vector */
vst1_lane_u8(dest + 2*k + j*nbyte/(8*elem_size), lo, 0);
vst1_lane_u8(dest + 2*k+1 + j*nbyte/(8*elem_size), hi, 0);
}
}
}
/* Routine optimized for bit-unshuffling a buffer for a type size of 1 byte. */
static void
bitunshuffle1_neon(const uint8_t* const src, uint8_t* dest, const size_t nbyte) {
const size_t elem_size = 1;
uint8x8_t lo_x, hi_x, lo, hi;
size_t i, j, k;
const int8_t __attribute__ ((aligned (16))) xr[8] = {0,1,2,3,4,5,6,7};
uint8x8_t mask_and = vdup_n_u8(0x01);
int8x8_t mask_shift = vld1_s8(xr);
/* #define CHECK_MULT_EIGHT(n) if (n % 8) exit(0); */
CHECK_MULT_EIGHT(nbyte);
for (i = 0, k = 0; i < nbyte; i += 16, k++) {
for (j = 0; j < 8; j++) {
/* Load lanes */
lo_x[j] = src[2*k + j*nbyte/(8*elem_size)];
hi_x[j] = src[2*k+1 + j*nbyte/(8*elem_size)];
}
for (j = 0; j < 8; j++) {
/* Create mask from the most significant bit of each 8-bit element */
lo = vand_u8(lo_x, mask_and);
lo = vshl_u8(lo, mask_shift);
hi = vand_u8(hi_x, mask_and);
hi = vshl_u8(hi, mask_shift);
lo = vpadd_u8(lo,lo);
lo = vpadd_u8(lo,lo);
lo = vpadd_u8(lo,lo);
hi = vpadd_u8(hi,hi);
hi = vpadd_u8(hi,hi);
hi = vpadd_u8(hi,hi);
/* Shift packed 8-bit */
lo_x = vshr_n_u8(lo_x, 1);
hi_x = vshr_n_u8(hi_x, 1);
/* Store the created mask to the destination vector */
vst1_lane_u8(dest + j + i, lo, 0);
vst1_lane_u8(dest + 8*elem_size + j + i, hi, 0);
}
}
}
void main()
{
uint8_t *src = "\xcb\xff\xf1\x79\x24\x7c\xb1\x58\x69\xd2\xee\xdd\x99\x9a\x7a\x86"
"\x45\x3e\x5f\xdf\xa2\x43\x41\x25\x77\xae\xfd\x22\x19\x1a\x38\x2b"
"\x56\x93\xab\xc3\x61\xa8\x7d\xfc\xbb\x98\xf6\xd1\x29\xce\xe7\x58"
"\x73\x4c\xd3\x12\x3f\xcf\x46\x94\xba\xfa\x49\x83\x71\x1e\x35\x5f"
"\xbc\x2d\x3f\x7c\xf8\xb4\xb9\xa8\xc9\x9f\x8d\x9d\x11\xc4\xc3\x23"
"\x44\x3a\x11\x4f\xf2\x41\x31\xb8\x19\xbe\xad\x72\xdc\x3a\xbc\x34"
"\x53\xa7\xc6\xb3\x71\xc8\x83\x27\xb3\x45\x82\xd8\x95\x9e\x71\x92"
"\x88\x4f\xdd\x66\xbf\xc5\xd6\x42\x33\x18\x33\xf7\xaf\xab\x42\x47"
"\xcb\xff\xf1\x79\x24\x7c\xb1\x58\x69\xd2\xee\xdd\x99\x9a\x7a\x86"
"\x45\x3e\x5f\xdf\xa2\x43\x41\x25\x77\xae\xfd\x22\x19\x1a\x38\x2b"
"\x56\x93\xab\xc3\x61\xa8\x7d\xfc\xbb\x98\xf6\xd1\x29\xce\xe7\x58"
"\x73\x4c\xd3\x12\x3f\xcf\x46\x94\xba\xfa\x49\x83\x71\x1e\x35\x5f"
"\xbc\x2d\x3f\x7c\xf8\xb4\xb9\xa8\xc9\x9f\x8d\x9d\x11\xc4\xc3\x23"
"\x44\x3a\x11\x4f\xf2\x41\x31\xb8\x19\xbe\xad\x72\xdc\x3a\xbc\x34"
"\x53\xa7\xc6\xb3\x71\xc8\x83\x27\xb3\x45\x82\xd8\x95\x9e\x71\x92"
"\x88\x4f\xdd\x66\xbf\xc5\xd6\x42\x33\x18\x33\xf7\xaf\xab\x42\x47"
"\xcb\xff\xf1\x79\x24\x7c\xb1\x58\x69\xd2\xee\xdd\x99\x9a\x7a\x86"
"\x45\x3e\x5f\xdf\xa2\x43\x41\x25\x77\xae\xfd\x22\x19\x1a\x38\x2b"
"\x56\x93\xab\xc3\x61\xa8\x7d\xfc\xbb\x98\xf6\xd1\x29\xce\xe7\x58"
"\x73\x4c\xd3\x12\x3f\xcf\x46\x94\xba\xfa\x49\x83\x71\x1e\x35\x5f"
"\xbc\x2d\x3f\x7c\xf8\xb4\xb9\xa8\xc9\x9f\x8d\x9d\x11\xc4\xc3\x23"
"\x44\x3a\x11\x4f\xf2\x41\x31\xb8\x19\xbe\xad\x72\xdc\x3a\xbc\x34"
"\x53\xa7\xc6\xb3\x71\xc8\x83\x27\xb3\x45\x82\xd8\x95\x9e\x71\x92"
"\x88\x4f\xdd\x66\xbf\xc5\xd6\x42\x33\x18\x33\xf7\xaf\xab\x42\x47"
"\xcb\xff\xf1\x79\x24\x7c\xb1\x58\x69\xd2\xee\xdd\x99\x9a\x7a\x86"
"\x45\x3e\x5f\xdf\xa2\x43\x41\x25\x77\xae\xfd\x22\x19\x1a\x38\x2b"
"\x56\x93\xab\xc3\x61\xa8\x7d\xfc\xbb\x98\xf6\xd1\x29\xce\xe7\x58"
"\x73\x4c\xd3\x12\x3f\xcf\x46\x94\xba\xfa\x49\x83\x71\x1e\x35\x5f"
"\xbc\x2d\x3f\x7c\xf8\xb4\xb9\xa8\xc9\x9f\x8d\x9d\x11\xc4\xc3\x23"
"\x44\x3a\x11\x4f\xf2\x41\x31\xb8\x19\xbe\xad\x72\xdc\x3a\xbc\x34"
"\x53\xa7\xc6\xb3\x71\xc8\x83\x27\xb3\x45\x82\xd8\x95\x9e\x71\x92"
"\x88\x4f\xdd\x66\xbf\xc5\xd6\x42\x33\x18\x33\xf7\xaf\xab\x42\x47";
size_t i;
uint8_t *dest1 = calloc(512,1);
uint8_t *dest2 = calloc(512,1);
size_t size = 512;
bitshuffle1_neon(src, dest1, size);
bitunshuffle1_neon(dest1, dest2, size);
for (i = 0; i < 256; i++) {
assert(dest2[i] == src[i]);
}
free(dest1);
free(dest2);
}
|
33d70f0158bbac2543c1bf0f6e645f24a262cee4
|
2558b734f1d5814bb188bcf3512386e192092014
|
/kvs2.7mod4oculus-master/Source/SupportPython/NumPy.h
|
b1d48b5b31b397aeba7d961eefac7d13b770aaaf
|
[
"BSD-3-Clause"
] |
permissive
|
kawamuratakuma/VRKVS
|
3d620778e8261c9e814a36f49b1c8b1f138da007
|
5983a908a812a8df4418511678db844e1e1d5565
|
refs/heads/master
| 2023-08-17T00:43:31.317488 | 2021-09-13T02:40:24 | 2021-09-13T02:40:24 | 295,596,828 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 117 |
h
|
NumPy.h
|
#define NO_IMPORT_ARRAY
#define PY_ARRAY_UNIQUE_SYMBOL KVS_PYTHON_NUMPY_ARRAYOBJECT_H
#include <numpy/arrayobject.h>
|
54b99ada2759c24a8a033fe7a0be447939089933
|
238e46a903cf7fac4f83fa8681094bf3c417d22d
|
/VTK/vtk_7.1.1_x64_Debug/include/vtk-7.1/vtkFiltersSelectionModule.h
|
29a52a3ac8b93395965f6db2498c247c825a13e2
|
[
"BSD-3-Clause"
] |
permissive
|
baojunli/FastCAE
|
da1277f90e584084d461590a3699b941d8c4030b
|
a3f99f6402da564df87fcef30674ce5f44379962
|
refs/heads/master
| 2023-02-25T20:25:31.815729 | 2021-02-01T03:17:33 | 2021-02-01T03:17:33 | 268,390,180 | 1 | 0 |
BSD-3-Clause
| 2020-06-01T00:39:31 | 2020-06-01T00:39:31 | null |
UTF-8
|
C
| false | false | 1,082 |
h
|
vtkFiltersSelectionModule.h
|
#ifndef VTKFILTERSSELECTION_EXPORT_H
#define VTKFILTERSSELECTION_EXPORT_H
#ifdef VTKFILTERSSELECTION_STATIC_DEFINE
# define VTKFILTERSSELECTION_EXPORT
# define VTKFILTERSSELECTION_NO_EXPORT
#else
# ifndef VTKFILTERSSELECTION_EXPORT
# ifdef vtkFiltersSelection_EXPORTS
/* We are building this library */
# define VTKFILTERSSELECTION_EXPORT __declspec(dllexport)
# else
/* We are using this library */
# define VTKFILTERSSELECTION_EXPORT __declspec(dllimport)
# endif
# endif
# ifndef VTKFILTERSSELECTION_NO_EXPORT
# define VTKFILTERSSELECTION_NO_EXPORT
# endif
#endif
#ifndef VTKFILTERSSELECTION_DEPRECATED
# define VTKFILTERSSELECTION_DEPRECATED __declspec(deprecated)
# define VTKFILTERSSELECTION_DEPRECATED_EXPORT VTKFILTERSSELECTION_EXPORT __declspec(deprecated)
# define VTKFILTERSSELECTION_DEPRECATED_NO_EXPORT VTKFILTERSSELECTION_NO_EXPORT __declspec(deprecated)
#endif
#define DEFINE_NO_DEPRECATED 0
#if DEFINE_NO_DEPRECATED
# define VTKFILTERSSELECTION_NO_DEPRECATED
#endif
#endif
|
7cf84ef3e20ca3fd315f04fda448d73e68bba2c1
|
7e5e9717bb0acac13bf1e943f20f3ae503668d12
|
/threadpool-server-with-conditional-vars/socket_queue.c
|
e51afb6f3eca21db58b92e220e58ca819462f176
|
[] |
no_license
|
deusmax88/cexercises
|
bce7bf43a1445c24a06765795e847fbdaad0f67e
|
c048dd4d72637a84d56bfe665af514cd0823ef16
|
refs/heads/master
| 2022-11-19T13:31:00.674282 | 2020-07-26T17:42:02 | 2020-07-26T17:42:02 | 280,864,261 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 613 |
c
|
socket_queue.c
|
#include "socket_queue.h"
#include <stdlib.h>
node_t * tail = NULL;
node_t * head = NULL;
void enqueue (int *client_socket) {
node_t *newnode = malloc(sizeof(node_t));
newnode->client_socket = client_socket;
newnode->next = NULL;
if (tail == NULL) {
head = newnode;
}
else {
tail->next = newnode;
}
tail = newnode;
}
int* dequeue() {
if (head == NULL) {
return NULL;
}
int* result = head->client_socket;
node_t * tmp = head;
head = head->next;
if (head == NULL) {
tail = NULL;
}
free(tmp);
return result;
}
|
30cd72006f5246aa24e594ee3d9c5cc3636cd80c
|
b63e6515339cfda389a9e33381abf1ad6aa39d95
|
/software/olive_rubic_bsp/drivers/inc/peridot_i2c_master.h
|
8bdca5ce610e1cc647a85623e0c6d82289aa0d75
|
[
"MIT"
] |
permissive
|
kimushu/olive-piccolo
|
b5e16af78540a67fb8b91f9e3ed8da94a6987be8
|
f1198cc0721b259d81557817cc7e0ef66edb7b52
|
refs/heads/master
| 2021-01-19T04:44:41.277622 | 2017-11-12T08:30:36 | 2017-11-12T08:30:36 | 87,392,032 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 2,698 |
h
|
peridot_i2c_master.h
|
#ifndef __PERIDOT_I2C_MASTER_H__
#define __PERIDOT_I2C_MASTER_H__
#include "alt_types.h"
#ifdef __tinythreads__
# include <tthread.h>
#endif
#include "system.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct peridot_i2c_master_state_s
{
const char *name;
alt_u32 base;
alt_u32 freq;
alt_u32 irq_controller_id;
alt_u32 irq;
#ifdef __PERIDOT_PFC_INTERFACE
const struct peridot_pfc_map_io_s *scl_pfc_map;
const struct peridot_pfc_map_io_s *sda_pfc_map;
#endif /* __PERIDOT_PFC_INTERFACE */
#ifdef __tinythreads__
pthread_mutex_t lock;
sem_t done;
#else
volatile alt_u8 lock;
volatile alt_u8 done;
#endif
}
peridot_i2c_master_state;
#define PERIDOT_I2C_MASTER_STATE_INSTANCE_HEADER(name, state, ...) \
peridot_i2c_master_state state = \
{ \
#name, \
name##_BASE, \
name##_FREQ, \
name##_IRQ_INTERRUPT_CONTROLLER_ID, \
name##_IRQ, \
__VA_ARGS__ \
}
#ifdef __PERIDOT_PFC_INTERFACE
#define PERIDOT_I2C_MASTER_STATE_INSTANCE(name, state) \
extern const struct peridot_pfc_map_io_s state##_scl_pfc_map;\
extern const struct peridot_pfc_map_io_s state##_sda_pfc_map;\
PERIDOT_I2C_MASTER_STATE_INSTANCE_HEADER(name, state,\
&state##_scl_pfc_map, \
&state##_sda_pfc_map, \
)
#else /* !__PERIDOT_PFC_INTERFACE */
#define PERIDOT_I2C_MASTER_STATE_INSTANCE(name, state) \
PERIDOT_I2C_MASTER_STATE_INSTANCE_HEADER(name, state)
#endif /* !__PERIDOT_PFC_INTERFACE */
extern void peridot_i2c_master_init(peridot_i2c_master_state *state);
#define PERIDOT_I2C_MASTER_STATE_INIT(name, state) \
peridot_i2c_master_init(&state)
#ifdef __PERIDOT_PFC_INTERFACE
extern int peridot_i2c_master_configure_pins(peridot_i2c_master_state *sp, alt_u32 scl, alt_u32 sda, int dry_run);
#endif /* __PERIDOT_PFC_INTERFACE */
extern int peridot_i2c_master_get_clkdiv(peridot_i2c_master_state *sp, alt_u32 bitrate, alt_u32 *clkdiv);
#define PERIDOT_I2C_MASTER_10BIT_ADDRESS (0x8000)
extern int peridot_i2c_master_transfer(peridot_i2c_master_state *sp,
alt_u16 slave_address, alt_u32 clkdiv,
alt_u32 write_length, const alt_u8 *write_data,
alt_u32 read_length, alt_u8 *read_data);
#define PERIDOT_I2C_MASTER_INSTANCE(name, state) \
PERIDOT_I2C_MASTER_STATE_INSTANCE(name, state)
#define PERIDOT_I2C_MASTER_INIT(name, state) \
PERIDOT_I2C_MASTER_STATE_INIT(name, state)
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __PERIDOT_I2C_MASTER_H__ */
|
69e069f8a6fce9b40b4b7d6d7ca09d9feabf8761
|
e0837fec64290d5fde3a63c8885e998eebefa9f9
|
/src/pokemon/gfx/chandelure-frontNormal.c
|
696c9641ec95b1f269566c12ccc183e82516c400
|
[] |
no_license
|
EternalCode/Dark-Wish
|
5b9ef00cefa3e68251770fd0a2a6eef3d04b5449
|
5e5450bfca5fe6f27e3896624b08a43f09e4216f
|
refs/heads/master
| 2021-07-09T01:03:48.749029 | 2020-07-20T17:33:55 | 2020-07-20T17:33:55 | 168,088,353 | 2 | 9 | null | 2019-11-29T01:19:18 | 2019-01-29T04:22:08 |
C
|
UTF-8
|
C
| false | false | 4,730 |
c
|
chandelure-frontNormal.c
|
//{{BLOCK(chandelure_frontNormal)
//======================================================================
//
// chandelure_frontNormal, 64x64@4,
// + 64 tiles lz77 compressed
// Total size: 808 = 808
//
// Time-stamp: 2019-03-03, 16:26:54
// Exported by Cearn's GBA Image Transmogrifier, v0.8.14
// ( http://www.coranac.com/projects/#grit )
//
//======================================================================
const unsigned char chandelure_frontNormalTiles[808] __attribute__((aligned(4))) __attribute__((visibility("hidden")))=
{
0x10,0x00,0x08,0x00,0x3F,0x00,0x00,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xF0,
0x01,0x80,0x07,0x59,0x10,0x00,0x13,0x21,0xC0,0x03,0x10,0x13,0x10,0x01,0x00,0x2C,
0x75,0x02,0x00,0x30,0x10,0x07,0x10,0x0B,0x12,0x40,0x03,0x22,0x00,0x18,0x7F,0x22,
0x10,0x0C,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xFE,0xF0,
0x01,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xF0,0xFB,0x50,0x03,0x41,0x03,0x10,0x46,0x22,
0x30,0x03,0x21,0x22,0x22,0x00,0xE8,0x30,0x03,0x12,0xFF,0xF0,0x03,0xF1,0x00,0xF0,
0x01,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xDF,0xF0,0x01,0x31,0xC7,
0x20,0x40,0x03,0x51,0xCF,0xA0,0x25,0x51,0xC7,0x51,0xCF,0xFC,0x10,0xE3,0x30,0x03,
0x50,0xF3,0xB1,0xFF,0x70,0xFF,0x91,0x03,0x22,0x01,0x5F,0x32,0x10,0x03,0x23,0xF1,
0x00,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xF0,0xA4,0xD6,0x62,0x6C,0x52,0x79,0x10,0x02,
0x85,0x10,0x02,0x7D,0x10,0x03,0x21,0xF3,0x80,0x03,0xA2,0xB7,0x51,0xB7,0x51,0xBF,
0x40,0x25,0xA2,0xAF,0x50,0x03,0xAE,0x02,0xC4,0x52,0x02,0xC8,0x55,0x30,0xBD,0x42,
0xFB,0x21,0xF3,0x24,0x00,0x00,0x44,0x40,0x45,0x00,0x54,0x45,0x45,0x00,0x00,0x40,
0x55,0x55,0x00,0x00,0x54,0x55,0xD0,0x10,0xE3,0x10,0xE7,0x33,0x10,0x03,0x24,0x22,
0x01,0x43,0x00,0x45,0x42,0x44,0x42,0x45,0x55,0x44,0x55,0x03,0x55,0x45,0x04,0x55,
0x55,0x44,0xF0,0xBC,0xC2,0x4B,0xF6,0xC2,0x58,0x63,0x3F,0x53,0x47,0x23,0x50,0x21,
0x03,0x65,0x60,0x03,0x12,0xEE,0x02,0x7D,0x50,0x03,0x03,0x65,0x21,0x30,0x03,0x11,
0x88,0x50,0x03,0x50,0x00,0x41,0x22,0x04,0x40,0x54,0x42,0x04,0x40,0x2C,0x55,0x45,
0x00,0x7D,0x40,0x00,0xA7,0x10,0x03,0x00,0x54,0xB4,0x40,0x03,0x40,0x00,0xF7,0x00,
0x0B,0x54,0x10,0xC3,0x54,0x55,0x68,0x04,0x00,0xE7,0x30,0x03,0x60,0x00,0x2D,0x76,
0x44,0x04,0x00,0x40,0x87,0x55,0x45,0x40,0x87,0x44,0x54,0x00,0x94,0x56,0x05,0x00,
0x64,0xA5,0x00,0x66,0x00,0x76,0x63,0x66,0x67,0x77,0x36,0x77,0x76,0x04,0x37,0x36,
0x68,0x88,0x33,0x00,0x03,0x68,0x33,0x40,0x85,0x20,0x03,0x53,0x33,0x5A,0x37,0x53,
0x33,0x00,0x33,0x36,0x63,0x06,0x33,0x63,0x73,0x47,0xB0,0x00,0x03,0x77,0x00,0x0C,
0x40,0x03,0x35,0x73,0x33,0x33,0x03,0x55,0x76,0x33,0x53,0xAA,0x65,0x14,0x37,0x00,
0x62,0x24,0x21,0x46,0x03,0x33,0x67,0x04,0x00,0x03,0x47,0x10,0x08,0x22,0x77,0x76,
0x16,0x00,0x03,0x46,0x25,0x77,0x1C,0x46,0x45,0x55,0xD1,0x77,0x12,0x31,0x11,0x94,
0x55,0x42,0x06,0x04,0x00,0x55,0x45,0x55,0x00,0x31,0x00,0xDB,0x52,0x08,0x22,0x01,
0x40,0x52,0x00,0xD3,0x55,0x25,0x04,0xE2,0x10,0xB6,0x20,0x03,0x01,0x86,0x00,0x40,
0x05,0x30,0x0B,0x44,0xF8,0x00,0x07,0x10,0x0B,0x70,0xE6,0x10,0x10,0x30,0xEB,0x54,
0x45,0x50,0x82,0x01,0xAF,0x40,0x40,0x55,0x04,0x54,0x40,0x03,0x45,0x80,0x00,0xF6,
0x05,0x55,0x55,0x54,0x00,0x44,0x54,0x02,0x04,0x00,0x44,0x00,0x54,0xAA,0x00,0x1A,
0xAA,0x42,0x04,0x00,0xEB,0x04,0x50,0x94,0x56,0x01,0xB3,0x77,0x0A,0x44,0x44,0x40,
0x77,0x01,0xB6,0x74,0x11,0x3C,0x5A,0x45,0x57,0x00,0xE7,0x55,0x55,0x55,0x10,0x07,
0x75,0x00,0xEF,0x80,0x20,0x03,0x77,0x53,0x33,0x63,0x77,0x33,0x35,0x00,0x56,0x77,
0x37,0x35,0x35,0xA5,0xAA,0x5A,0x5E,0x55,0x00,0x03,0x35,0x00,0xEB,0x20,0xF3,0x20,
0xFB,0x20,0x03,0x77,0x08,0x33,0x53,0x73,0x77,0x10,0xE3,0x77,0x54,0x05,0x05,0x54,
0x77,0x54,0x04,0x40,0x10,0x03,0x57,0x00,0x8B,0x00,0x57,0x47,0x55,0x45,0x75,0x06,
0x44,0x44,0xC5,0x11,0x9D,0x00,0xE3,0x45,0x45,0x04,0x32,0x50,0x05,0x20,0x03,0xC1,
0x00,0xF6,0x02,0x7A,0x54,0x44,0x00,0x55,0x40,0x02,0x46,0x36,0x00,0x50,0x01,0xA0,
0x00,0x03,0x04,0x10,0x03,0x01,0xAC,0x04,0xFF,0x01,0xD2,0x02,0x7D,0x21,0xB3,0x11,
0xDD,0xF0,0x01,0xC0,0x02,0x61,0x2F,0x11,0xE9,0xF9,0x30,0x08,0x00,0x24,0xF2,0x98,
0x00,0x0E,0x02,0x0A,0x00,0x45,0x12,0x0F,0x90,0x02,0xB7,0x44,0x54,0x02,0xDF,0x40,
0x44,0x44,0x44,0x1F,0x44,0x77,0x53,0x00,0x87,0x00,0x10,0x12,0xEF,0x00,0x8F,0x00,
0x14,0x48,0x50,0x02,0xDE,0x45,0x44,0x30,0x50,0x33,0x53,0x47,0x9F,0x00,0x24,0x54,
0x45,0x22,0xEF,0x00,0x3C,0x00,0x29,0x01,0xB7,0x00,0x3C,0x1E,0x45,0x40,0x44,0x12,
0x5B,0x10,0x53,0xF0,0x01,0x03,0x3D,0x45,0x2F,0x44,0x54,0x00,0x63,0x45,0x70,0x57,
0x22,0x8F,0x02,0xB7,0x03,0x5E,0xFF,0x02,0x94,0x13,0x3A,0x10,0xA4,0x10,0x93,0xF0,
0x43,0xF0,0x01,0xF0,0x01,0xF0,0x01,0xFF,0xF0,0x01,0xF0,0x01,0xF0,0x01,0x93,0x37,
0xF0,0x01,0x53,0x3F,0x13,0x69,0xF0,0xA7,0xBF,0x13,0x7E,0x44,0xF0,0x16,0xF0,0x01,
0xF0,0x01,0xF0,0x01,0xF0,0x01,0x00,0x01,
};
//}}BLOCK(chandelure_frontNormal)
|
5cd39aa06c401e428e15d021f79617489049b500
|
5cf232448181278ef6a5272f6c3ea24916f5f503
|
/libft/src/ft_sortdoublechar.c
|
f7ba84dbafd123424894b058df4b6f99e1ae7a4e
|
[] |
no_license
|
k-fatimaezzahra/1337-my-gnl
|
7b616e13bd27666c927586b8da56844cb8bc22ee
|
39ce69fbc9cd5ea8b69ff4b7fa8c458eee95e149
|
refs/heads/master
| 2023-02-10T19:41:37.159351 | 2021-01-07T17:26:44 | 2021-01-07T17:26:44 | 327,679,249 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,295 |
c
|
ft_sortdoublechar.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_sortdoublechar.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fkarouac <fkarouac@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/11/21 22:28:32 by fkarouac #+# #+# */
/* Updated: 2020/01/20 07:46:56 by fkarouac ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
void ft_sortdoublechar(char **src)
{
int srclen;
int i;
int j;
if (src == NULL)
return ;
srclen = ft_doublestrlen(src);
if (srclen == 0)
return ;
else if (srclen == 1)
return ;
else
{
i = -1;
while (++i < srclen - 1)
{
j = i + 1;
while (j < srclen)
{
if (ft_strcmp(src[i], src[j]) >= 0)
ft_strswap(&src[i], &src[j]);
j++;
}
}
}
}
|
8f084ef83b27caa4a5d4cc2c95222207b9693e53
|
bc6858cfd6510a1440cf3f759c5749970bdcb30d
|
/src/Transmission.h
|
c3f05487557815c008c24a60897136b2166650e8
|
[] |
no_license
|
TomSalter/Raytracer
|
648fc51edd7d4c9c2741b1a31a51af17f32f380b
|
0efa9f07b7c12be0501aca3fecfc6e78358a5525
|
refs/heads/master
| 2021-01-19T13:18:58.225330 | 2017-08-20T05:01:30 | 2017-08-20T05:01:30 | 100,838,126 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 179 |
h
|
Transmission.h
|
#ifndef TRANSMISSION_H
#define TRANSMISSION_H
#include "Types.h"
#include <math.h>
#include "VectorLibrary.h"
RAY CalculateRefractedRay(RAY, const INTERSECTION*, float);
#endif
|
7e82c83290504b6c950730220ad30537a6bd90ae
|
c4cf2bc7a5c7de9cf9af2f9b48543b068b0cb59b
|
/Algorithms/Searching/Linear_Search.c
|
c8512b69600f26a4adc4d6219362cbc267a84d51
|
[] |
no_license
|
PacificPR/DS_ALGO_PRACTICE
|
abcf36007818d8448fbe50cf7a552ac89cfddf7f
|
ce42bf740035abb1deab75db78b2ec92bb9d8d8d
|
refs/heads/master
| 2021-05-20T09:45:26.941780 | 2020-10-01T20:08:11 | 2020-10-01T20:08:11 | 252,231,972 | 1 | 2 | null | 2020-10-01T20:08:13 | 2020-04-01T16:41:16 |
C++
|
UTF-8
|
C
| false | false | 790 |
c
|
Linear_Search.c
|
//The time complexity of above algorithm is O(n).
//Linear search is rarely used practically because other search algorithms
//such as the binary search algorithm and hash tables allow significantly faster searching compared to Linear search.
#include<stdlib.h>
#include<stdio.h>
void search(int *a,int n,int key){
int i;
for(i=0;i<n;i++)
if(key==a[i]){
printf("FOUND\n");
exit(0);
}
printf("NOT FOUND\n");
}
void main(){
int i,k,n,*a;
printf("Enter the number of elements in array\n");
scanf("%d",&n);
a=(int *)malloc(n*sizeof(int));
printf("Enter the numbers in array\n");
for(i=0;i<n;i++)
scanf("%d",a+i);
printf("Enter the number to be searched\n");
scanf("%d",&k);
search(a,n,k);
}
|
cdb684da1bc016c9638f5291060ddffb6b79c6ac
|
b30015926112f229f35bd22721e6b2ffcd15e4d6
|
/src/compiler/tlt.h
|
f8f37b881523ce5d68f62ab81171545af1beba95
|
[] |
no_license
|
kreofil/o7p
|
0cf2ab4f7f3641120883ac61ad2572511679e15d
|
7167ede70ae47146035411cb84b5bb5aab5805b5
|
refs/heads/master
| 2023-08-16T01:29:09.493676 | 2021-10-09T14:15:19 | 2021-10-09T14:15:19 | 272,444,309 | 0 | 2 | null | null | null | null |
UTF-8
|
C
| false | false | 285 |
h
|
tlt.h
|
#ifndef TLT_H
#define TLT_H
#include <ctype.h>
inline bool isLetter(char ch) {
return bool(isalpha(int(ch)));
}
inline bool isDigit(char ch) {
return bool(isdigit(int(ch)));
}
inline bool isSymbol(char ch, int const sym) {
return bool(int(ch)==sym);
}
#endif // TLT_H
|
9aa09504d730879e6b0ce4ab5614271e9b99793b
|
c4afbfe1885e8d0c7a1c8b928563f7bb8ab6a683
|
/Simulation_EnvSim/C_P138_compr_onboard_TM_conversions.h
|
18b9232c138a0b34ce7f80cfad3c5c5d6b3fcfd1
|
[] |
no_license
|
VladislavLasmann/srcAndBinary
|
cd48ebaa2f1f7f697ba5df9f38abb9ed50658e10
|
13aa76e545b9596f6dac84fb20480dffae7584d8
|
refs/heads/master
| 2021-05-08T15:04:05.709079 | 2016-01-22T12:40:10 | 2016-01-22T12:40:10 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,277 |
h
|
C_P138_compr_onboard_TM_conversions.h
|
/* $*************** KCG Version 6.1.3 (build i6) ****************
** Command: s2c613 -config S:/model/Scade/System/OBU_PreIntegrations/Testbench_Integration/Simulation_EnvSim\kcg_s2c_config.txt
** Generation date: 2015-11-23T09:24:20
*************************************************************$ */
#ifndef _C_P138_compr_onboard_TM_conversions_H_
#define _C_P138_compr_onboard_TM_conversions_H_
#include "kcg_types.h"
#include "CAST_Int_to_D_STARTREVERSE_TM_conversions.h"
#include "CAST_Int_to_L_REVERSEAREA_TM_conversions.h"
/* ===================== no input structure ====================== */
/* TM_conversions::C_P138_compr_onboard */
extern void C_P138_compr_onboard_TM_conversions(
/* TM_conversions::C_P138_compr_onboard::PacketData */CompressedPacketData_T_Common_Types_Pkg *PacketData,
/* TM_conversions::C_P138_compr_onboard::Metadata_Element */MetadataElement_T_Common_Types_Pkg *Metadata_Element,
/* TM_conversions::C_P138_compr_onboard::P138_onboard */P138_OBU_T_TM *P138_onboard);
#endif /* _C_P138_compr_onboard_TM_conversions_H_ */
/* $*************** KCG Version 6.1.3 (build i6) ****************
** C_P138_compr_onboard_TM_conversions.h
** Generation date: 2015-11-23T09:24:20
*************************************************************$ */
|
b6a0c8ee5ec9b1d0fb536a97ec2f34d7a4bfa0b1
|
3375fb075289d3b4ea2f8f1e75196e2b5c473f6d
|
/gainos-tk/toppers_osek/bin/mc9s12dp512/Project/Sources/main.c
|
537501ebdddbad4801fcc83f3d0c916a871cd7e5
|
[] |
no_license
|
paduc77/gainos
|
c8408fd2b1450e31b85df8963df2000b7f8be456
|
a42967a02c2ce70af6860eaf486e92c78c3b8a8c
|
refs/heads/master
| 2021-01-10T19:25:18.643247 | 2013-07-28T08:02:51 | 2013-07-28T08:02:51 | 38,877,269 | 1 | 2 | null | null | null | null |
GB18030
|
C
| false | false | 2,149 |
c
|
main.c
|
#include <hidef.h> /* common defines and macros */
#include "derivative.h" /* derivative-specific definitions */
#include "kernel.h"
#define CPU_FREQUENCY 32000000
void TERMIO_PutChar(char c)
{
while(!SCI0SR1_TDRE);
SCI0DRL = c;
}
static void Sci_Init()
{
SCI0BD = CPU_FREQUENCY/16/115200;
SCI0CR1 = 0x00;
SCI0CR2 = 0x08;
}
static void SystemClockInit(void)
{
CRGINT = 0; //关中断
CLKSEL_PLLSEL = 0; //在未初始化PLL前不使用PLL的输出作为CPU时钟
#if(CPU_FREQUENCY == 40000000)
SYNR = 4;
#elif(CPU_FREQUENCY == 32000000)
SYNR = 3;
#elif(CPU_FREQUENCY == 24000000)
SYNR = 2;
#endif
REFDV = 1; //PLLCLK=2×OSCCLK×(SYNR+1)/(REFDV+1)＝64MHz ,fbus=32M
PLLCTL_PLLON = 1; //开PLL
PLLCTL_AUTO = 1; //选取自动模式
while (CRGFLG_LOCK == 0); //等待PLL锁定频率
CLKSEL_PLLSEL = 1; //选择系统时钟由PLL产生
}
void sys_initialize(void)
{
SystemClockInit();
Sci_Init();
CRGINT_RTIE=1; //使能实时中断
RTICTL = 0x70; //设置实时中断的时间间隔为4.096ms
//中断周期=1/16 x 10E-6 x （0+1）x 2E（7+9）=0.004096s=4.096ms
}
void tool_initialize(void)
{
}
void cpu_initialize(void)
{
CRGINT = 0;
CLKSEL_PLLSEL = 0;
#if(CPU_FREQUENCY == 40000000)
SYNR = 4;
#elif(CPU_FREQUENCY == 32000000)
SYNR = 3;
#elif(CPU_FREQUENCY == 24000000)
SYNR = 2;
#endif
REFDV = 1;
PLLCTL_PLLON = 1;
PLLCTL_AUTO = 1;
while (CRGFLG_LOCK == 0);
CLKSEL_PLLSEL = 1;
}
void StartupHook(void)
{
}
void ShutdownHook(StatusType ercd)
{
}
void PreTaskHook(void)
{
}
void PostTaskHook(void)
{
}
void ErrorHook(StatusType ercd)
{
}
void cpu_terminate(void)
{
}
void sys_exit(void)
{
for(;;);
}
void main(void) {
DisableInterrupts;
StartOS(OSDEFAULTAPPMODE);
for(;;);
}
|
b8d20248620fc923a43644006b081285a801f448
|
51635684d03e47ebad12b8872ff469b83f36aa52
|
/external/gcc-12.1.0/gcc/testsuite/gcc.target/powerpc/ppc-target-4.c
|
43a98b353cf7328dc9f8efbf14613643b4479798
|
[
"LGPL-2.1-only",
"FSFAP",
"LGPL-3.0-only",
"GPL-3.0-only",
"GPL-2.0-only",
"GCC-exception-3.1",
"LGPL-2.0-or-later",
"Zlib",
"LicenseRef-scancode-public-domain"
] |
permissive
|
zhmu/ananas
|
8fb48ddfe3582f85ff39184fc7a3c58725fe731a
|
30850c1639f03bccbfb2f2b03361792cc8fae52e
|
refs/heads/master
| 2022-06-25T10:44:46.256604 | 2022-06-12T17:04:40 | 2022-06-12T17:04:40 | 30,108,381 | 59 | 8 |
Zlib
| 2021-09-26T17:30:30 | 2015-01-31T09:44:33 |
C
|
UTF-8
|
C
| false | false | 1,697 |
c
|
ppc-target-4.c
|
/* { dg-do compile { target { powerpc*-*-* } } } */
/* { dg-skip-if "" { powerpc*-*-darwin* } } */
/* { dg-require-effective-target powerpc_vsx_ok } */
/* { dg-options "-O2 -ffast-math -mdejagnu-cpu=power5 -mno-altivec -mabi=altivec -fno-unroll-loops" } */
/* { dg-final { scan-assembler-times "vaddfp" 1 } } */
/* { dg-final { scan-assembler-times "xvaddsp" 1 } } */
/* { dg-final { scan-assembler-times "fadds" 1 } } */
#ifndef SIZE
#define SIZE 1024
#endif
#ifdef __ALTIVEC__
#error "__ALTIVEC__ should not be defined."
#endif
#ifdef __VSX__
#error "__VSX__ should not be defined."
#endif
#pragma GCC target("vsx")
#include <altivec.h>
#pragma GCC reset_options
#pragma GCC push_options
#pragma GCC target("altivec,no-vsx")
#ifndef __ALTIVEC__
#error "__ALTIVEC__ should be defined."
#endif
#ifdef __VSX__
#error "__VSX__ should not be defined."
#endif
void
av_add (vector float *a, vector float *b, vector float *c)
{
unsigned long i;
unsigned long n = SIZE / 4;
for (i = 0; i < n; i++)
a[i] = vec_add (b[i], c[i]);
}
#pragma GCC target("vsx")
#ifndef __ALTIVEC__
#error "__ALTIVEC__ should be defined."
#endif
#ifndef __VSX__
#error "__VSX__ should be defined."
#endif
void
vsx_add (vector float *a, vector float *b, vector float *c)
{
unsigned long i;
unsigned long n = SIZE / 4;
for (i = 0; i < n; i++)
a[i] = vec_add (b[i], c[i]);
}
#pragma GCC pop_options
#pragma GCC target("no-vsx,no-altivec")
#ifdef __ALTIVEC__
#error "__ALTIVEC__ should not be defined."
#endif
#ifdef __VSX__
#error "__VSX__ should not be defined."
#endif
void
norm_add (float *a, float *b, float *c)
{
unsigned long i;
for (i = 0; i < SIZE; i++)
a[i] = b[i] + c[i];
}
|
3214fce9766cbfc68ec62bd20f8931c9b94de634
|
fa9e3f545d0788e0358b51d921b86f8d90d6208f
|
/0x0C-more_malloc_free/1-string_nconcat.c
|
3eaa4f55d13079faf953455371dbb4961604257d
|
[] |
no_license
|
martinmsaavedra/holbertonschool-low_level_programming
|
d25a75eb195c63d401b7669dd64e1e4b843a5c59
|
feaadbce17123fbecddb0fb36655cdf617a39944
|
refs/heads/master
| 2023-04-09T05:39:28.661776 | 2021-04-21T15:18:34 | 2021-04-21T15:18:34 | 296,028,577 | 1 | 1 | null | 2020-09-30T19:18:32 | 2020-09-16T12:39:43 |
C
|
UTF-8
|
C
| false | false | 1,004 |
c
|
1-string_nconcat.c
|
#include "holberton.h"
#include <stdlib.h>
int _strlen(char *s);
/**
*string_nconcat - concatenates two strings
*@s1: string one
*@s2: string two
*@n: size of buffer or string two
*Return: pointer shall point to a newly allocated space in memory
*/
char *string_nconcat(char *s1, char *s2, unsigned int n)
{
char *array;
unsigned int lenght1, lenght2, i, j;
if (s1 == NULL)
s1 = "";
if (s2 == NULL)
s2 = "";
lenght1 = _strlen(s1);
lenght2 = _strlen(s2);
if (n > lenght2)
n = lenght2;
array = malloc(sizeof(char) * (lenght1 + n) + 1);
if (array == NULL)
return (NULL);
for (i = 0; i < lenght1; i++)
array[i] = s1[i];
for (j = 0; j < n; j++)
array[i + j] = s2[j];
array[i + j] = '\0';
return (array);
}
/**
* _strlen - calculate the length of a string
* @s: pointer of string
*
* Return: returns the length of a string
*/
int _strlen(char *s)
{
int contador = 0;
int total = 0;
while (*(s + contador) != '\0')
{
contador++;
total++;
}
return (total);
}
|
f432b6e4715beb00396082662b0bce182c3a7518
|
9eecd0e1300f94b87827fc68582cd36ee87882a9
|
/C04/ex04/ft_putnbr_base.c
|
b8c2a5862f00359bb3167f11a9b0c6b3d35d63f6
|
[] |
no_license
|
ImaginaryDen/My_Piscine
|
fd3e8c22ce1f8e9e72d20cd315ff459a84af0324
|
967ea841437b23d9bc9c13593bf537c5a0fa23f6
|
refs/heads/master
| 2023-03-18T18:09:14.243135 | 2021-03-11T14:01:38 | 2021-03-11T14:01:38 | 346,720,597 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,739 |
c
|
ft_putnbr_base.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putnbr_base.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tjamis <tjamis@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/02/22 16:13:00 by tjamis #+# #+# */
/* Updated: 2021/02/23 20:48:05 by tjamis ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void check_nul(int nbr, int *norm, char *base)
{
if (!nbr && !*norm)
{
write(1, &base[0], 1);
*norm = 1;
}
}
int check(int nbr, char *base)
{
int i;
int j;
int norm;
i = 0;
norm = 0;
if (!base[0] || !base[1])
norm = 1;
while (base[i] && !norm)
{
if (base[i] == '+' || base[i] == '-')
norm = 1;
j = i - 1;
while (j > 0 && !norm)
{
if (base[i] == base[j])
norm = 1;
j--;
}
i++;
}
check_nul(nbr, &norm, base);
return (norm);
}
int abs(int i)
{
if (i < 0)
i = -i;
return (i);
}
void ft_putnbr_base(int nbr, char *base)
{
char str[35];
int i;
int b;
i = 0;
b = 0;
if (check(nbr, base))
return ;
if (nbr < 0)
write(1, "-", 1);
while (base[b])
b++;
while (nbr)
{
str[i] = base[abs(nbr % b)];
nbr /= b;
i++;
}
while (i-- > 0)
write(1, &str[i], 1);
}
|
ce7670099550e7d74891da27071f9915c853c438
|
765f7b8c2caf2d50da8f431f1332207456ba33ee
|
/libc/ctype/isalnum.c
|
4ccb614ae49178562069a8e2dff09f6c6182546d
|
[
"BSD-3-Clause",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-commercial-license",
"AGPL-3.0-or-later",
"GPL-1.0-or-later",
"NCSA",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
klange/toaruos
|
a840f8d46993dc7a8850f82b6d04ba0c2af276a9
|
4a31a09ba27904b42ee35e8fb1a3c7f87669a2ef
|
refs/heads/master
| 2023-09-01T02:00:53.151334 | 2023-08-28T00:59:18 | 2023-08-28T00:59:18 | 1,259,258 | 5,557 | 613 |
NCSA
| 2023-02-04T08:24:11 | 2011-01-16T00:59:27 |
C
|
UTF-8
|
C
| false | false | 80 |
c
|
isalnum.c
|
#include <ctype.h>
int isalnum(int c) {
return isalpha(c) || isdigit(c);
}
|
db3639b41acb574b5c622e9872c70d83bf04c815
|
6db21f2cc4817d0aaed5e4bdd2cd464c213bf94e
|
/include/librist/headers.h
|
b94953b86d2e62045753da82cffcc74c59049ce8
|
[
"BSD-2-Clause"
] |
permissive
|
prashantdhere13/librist
|
a3ddaef425b9537259c3a0615488e5cb44d516f6
|
efdae1e2613b883bc93ee5e8067520b7428301e1
|
refs/heads/main
| 2023-06-28T19:46:17.338374 | 2021-07-27T12:51:31 | 2021-07-27T12:51:31 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 9,166 |
h
|
headers.h
|
/*
* Copyright © 2020, VideoLAN and librist authors
* Copyright © 2019-2020 SipRadius LLC
* All rights reserved.
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#ifndef LIBRIST_HEADERS_H
#define LIBRIST_HEADERS_H
#include <stdint.h>
#include <stdlib.h>
/* Used for cname, miface and shared secret */
#define RIST_MAX_STRING_SHORT 128
/* Used for url/address */
#define RIST_MAX_STRING_LONG 256
/* Track PROTOCOL and API changes */
#define RIST_PEER_UDPSOCKET_VERSION (0)
#define RIST_PEER_CONFIG_VERSION (0)
#define RIST_UDP_CONFIG_VERSION (0)
#define RIST_STATS_VERSION (0)
/* Default peer config values */
#define RIST_DEFAULT_VIRT_SRC_PORT (1971)
#define RIST_DEFAULT_VIRT_DST_PORT (1968)
#define RIST_DEFAULT_RECOVERY_MODE RIST_RECOVERY_MODE_TIME
#define RIST_DEFAULT_RECOVERY_MAXBITRATE (100000)
#define RIST_DEFAULT_RECOVERY_MAXBITRATE_RETURN (0)
#define RIST_DEFAULT_RECOVERY_LENGHT_MIN (1000)
#define RIST_DEFAULT_RECOVERY_LENGHT_MAX (1000)
#define RIST_DEFAULT_RECOVERY_REORDER_BUFFER (25)
#define RIST_DEFAULT_RECOVERY_RTT_MIN (50)
#define RIST_DEFAULT_RECOVERY_RTT_MAX (500)
#define RIST_DEFAULT_CONGESTION_CONTROL_MODE RIST_CONGESTION_CONTROL_MODE_NORMAL
#define RIST_DEFAULT_MIN_RETRIES (6)
#define RIST_DEFAULT_MAX_RETRIES (20)
#define RIST_DEFAULT_VERBOSE_LEVEL RIST_LOG_INFO
#define RIST_DEFAULT_PROFILE RIST_PROFILE_MAIN
#define RIST_DEFAULT_SESSION_TIMEOUT (2000)
#define RIST_DEFAULT_KEEPALIVE_INTERVAL (1000)
#define RIST_DEFAULT_TIMING_MODE RIST_TIMING_MODE_SOURCE
/* Rist URL parameter names for peer config */
#define RIST_URL_PARAM_BUFFER_SIZE "buffer"
#define RIST_URL_PARAM_SECRET "secret"
#define RIST_URL_PARAM_AES_TYPE "aes-type"
#define RIST_URL_PARAM_BANDWIDTH "bandwidth"
#define RIST_URL_PARAM_RET_BANDWIDTH "return-bandwidth"
#define RIST_URL_PARAM_REORDER_BUFFER "reorder-buffer"
#define RIST_URL_PARAM_RTT "rtt"
#define RIST_URL_PARAM_COMPRESSION "compression"
#define RIST_URL_PARAM_CNAME "cname"
#define RIST_URL_PARAM_VIRT_DST_PORT "virt-dst-port"
#define RIST_URL_PARAM_WEIGHT "weight"
#define RIST_URL_PARAM_MIFACE "miface"
#define RIST_URL_PARAM_SESSION_TIMEOUT "session-timeout"
#define RIST_URL_PARAM_KEEPALIVE_INT "keepalive-interval"
#define RIST_URL_PARAM_SRP_USERNAME "username"
#define RIST_URL_PARAM_SRP_PASSWORD "password"
/* Less common URL parameters */
#define RIST_URL_PARAM_BUFFER_SIZE_MIN "buffer-min"
#define RIST_URL_PARAM_BUFFER_SIZE_MAX "buffer-max"
#define RIST_URL_PARAM_RTT_MIN "rtt-min"
#define RIST_URL_PARAM_RTT_MAX "rtt-max"
#define RIST_URL_PARAM_AES_KEY_ROTATION "key-rotation"
#define RIST_URL_PARAM_CONGESTION_CONTROL "congestion-control"
#define RIST_URL_PARAM_MIN_RETRIES "min-retries"
#define RIST_URL_PARAM_MAX_RETRIES "max-retries"
#define RIST_URL_PARAM_TIMING_MODE "timing-mode"
/* udp specific parameters */
#define RIST_URL_PARAM_STREAM_ID "stream-id"
#define RIST_URL_PARAM_RTP_TIMESTAMP "rtp-timestamp"
#define RIST_URL_PARAM_RTP_SEQUENCE "rtp-sequence"
#define RIST_URL_PARAP_RTP_OUTPUT_PTYPE "rtp-ptype"
/* Rist additional parameter names */
#define RIST_URL_PARAM_VIRT_SRC_PORT "virt-src-port"
#define RIST_URL_PARAM_PROFILE "profile"
#define RIST_URL_PARAM_VERBOSE_LEVEL "verbose-level"
/* Error Codes */
#define RIST_ERR_MALLOC -1
#define RIST_ERR_NULL_PEER -2
#define RIST_ERR_INVALID_STRING_LENGTH -3
#define RIST_ERR_INVALID_PROFILE -4
#define RIST_ERR_MISSING_CALLBACK_FUNCTION -5
#define RIST_ERR_NULL_CREDENTIALS -6
enum rist_nack_type
{
RIST_NACK_RANGE = 0,
RIST_NACK_BITMASK = 1,
};
enum rist_profile
{
RIST_PROFILE_SIMPLE = 0,
RIST_PROFILE_MAIN = 1,
RIST_PROFILE_ADVANCED = 2,
};
enum rist_log_level
{
RIST_LOG_DISABLE = -1,
RIST_LOG_ERROR = 3,
RIST_LOG_WARN = 4,
RIST_LOG_NOTICE = 5,
RIST_LOG_INFO = 6,
RIST_LOG_DEBUG = 7,
RIST_LOG_SIMULATE = 100,
};
enum rist_recovery_mode
{
RIST_RECOVERY_MODE_UNCONFIGURED = 0,
RIST_RECOVERY_MODE_DISABLED = 1,
RIST_RECOVERY_MODE_TIME = 2,
};
enum rist_congestion_control_mode
{
RIST_CONGESTION_CONTROL_MODE_OFF = 0,
RIST_CONGESTION_CONTROL_MODE_NORMAL = 1,
RIST_CONGESTION_CONTROL_MODE_AGGRESSIVE = 2
};
enum rist_timing_mode
{
RIST_TIMING_MODE_SOURCE = 0,
RIST_TIMING_MODE_ARRIVAL = 1,
RIST_TIMING_MODE_RTC = 2
};
enum rist_data_block_sender_flags
{
RIST_DATA_FLAGS_USE_SEQ = 1,
RIST_DATA_FLAGS_NEED_FREE = 2
};
enum rist_data_block_receiver_flags
{
RIST_DATA_FLAGS_DISCONTINUITY = 1,
RIST_DATA_FLAGS_FLOW_BUFFER_START = 2
};
enum rist_stats_type
{
RIST_STATS_SENDER_PEER,
RIST_STATS_RECEIVER_FLOW
};
enum rist_connection_status
{
RIST_CONNECTION_ESTABLISHED = 0,
RIST_CONNECTION_TIMED_OUT = 1,
RIST_CLIENT_CONNECTED = 2,
RIST_CLIENT_TIMED_OUT = 3
};
struct rist_ctx;
struct rist_peer;
struct rist_data_block
{
const void *payload;
size_t payload_len;
uint64_t ts_ntp;
/* The virtual source and destination ports are not used for simple profile */
uint16_t virt_src_port;
/* These next fields are not needed/used by rist_sender_data_write */
uint16_t virt_dst_port;
struct rist_peer *peer;
uint32_t flow_id;
/* Get's populated by librist with the rtp_seq on output, can be used on input to tell librist which rtp_seq to use */
uint64_t seq;
uint32_t flags;
struct rist_ref *ref;
};
struct rist_oob_block
{
struct rist_peer *peer;
const void *payload;
size_t payload_len;
uint64_t ts_ntp;
};
struct rist_udp_config
{
int version;
/* Communication parameters */
// If a value of 0 is specified for address family, the library
// will parse the address and populate all communication parameters.
// Alternatively, use either AF_INET or AF_INET6 and address will be
// treated like an IP address or hostname
int address_family;
int initiate_conn;
char address[RIST_MAX_STRING_LONG];
char miface[RIST_MAX_STRING_SHORT];
uint16_t physical_port;
char prefix[16];
int rtp_timestamp;
int rtp_sequence;
int rtp;
uint8_t rtp_ptype;
uint16_t stream_id;
};
struct rist_peer_config
{
int version;
/* Communication parameters */
// If a value of 0 is specified for address family, the library
// will parse the address and populate all communication parameters.
// Alternatively, use either AF_INET or AF_INET6 and address will be
// treated like an IP address or hostname
int address_family;
int initiate_conn;
char address[RIST_MAX_STRING_LONG];
char miface[RIST_MAX_STRING_SHORT];
uint16_t physical_port;
/* The virtual destination port is not used for simple profile */
uint16_t virt_dst_port;
/* Recovery options */
enum rist_recovery_mode recovery_mode;
uint32_t recovery_maxbitrate; /* kbps */
uint32_t recovery_maxbitrate_return; /* kbps */
uint32_t recovery_length_min; /* ms */
uint32_t recovery_length_max; /* ms */
uint32_t recovery_reorder_buffer; /* ms */
uint32_t recovery_rtt_min; /* ms */
uint32_t recovery_rtt_max; /* ms */
/* Load balancing weight (use 0 for duplication) */
uint32_t weight;
/* Encryption */
char secret[RIST_MAX_STRING_SHORT];
int key_size;
uint32_t key_rotation;
/* Compression (sender only as receiver is auto detect) */
int compression;
/* cname identifier for rtcp packets */
char cname[RIST_MAX_STRING_SHORT];
/* Congestion control */
enum rist_congestion_control_mode congestion_control_mode;
uint32_t min_retries;
uint32_t max_retries;
/* Connection options */
uint32_t session_timeout;
uint32_t keepalive_interval;
uint32_t timing_mode;
char srp_username[RIST_MAX_STRING_LONG];
char srp_password[RIST_MAX_STRING_LONG];
};
struct rist_stats_sender_peer
{
/* cname */
char cname[RIST_MAX_STRING_SHORT];
/* internal peer id */
uint32_t peer_id;
/* avg bandwidth calculation */
size_t bandwidth;
/* bandwidth devoted to retries */
size_t retry_bandwidth;
/* num sent packets */
uint64_t sent;
/* num received packets */
uint64_t received;
/* retransmitted packets */
uint64_t retransmitted;
/* quality: Q = (sent * 100.0) / sent + bloat_skipped + bandwidth_skipped + retransmit_skipped + retransmitted */
double quality;
/* current RTT */
uint32_t rtt;
};
struct rist_stats_receiver_flow
{
/* peer count */
uint32_t peer_count;
/* combined peer cnames */
char cname[RIST_MAX_STRING_LONG];
/* flow id (set by senders) */
uint32_t flow_id;
/* flow status */
int status;
/* avg bandwidth calculation */
size_t bandwidth;
/* bandwidth devoted to retries */
size_t retry_bandwidth;
/* num sent packets */
uint64_t sent;
/* num received packets */
uint64_t received;
/* missing, including reordered */
uint32_t missing;
/* reordered */
uint32_t reordered;
/* total recovered */
uint32_t recovered;
/* recovered on the first retry */
uint32_t recovered_one_retry;
/* lost packets */
uint32_t lost;
/* quality: Q = (received * 100.0) / received + missing */
double quality;
/* packet inter-arrival time (microseconds) */
uint64_t min_inter_packet_spacing;
uint64_t cur_inter_packet_spacing;
uint64_t max_inter_packet_spacing;
/* avg rtt all non dead peers */
uint32_t rtt;
};
struct rist_stats
{
uint32_t json_size;
char *stats_json;
uint16_t version;
enum rist_stats_type stats_type;
union {
struct rist_stats_sender_peer sender_peer;
struct rist_stats_receiver_flow receiver_flow;
} stats;
};
#endif
|
349f0f56a5532e23ccc9c3cfbfe0635df393b875
|
612d254d32c02b885cf5148ad5cfd3302d1c8288
|
/ADA/mergesort.c
|
82ef44f4a5ef78bafd967e4908a8a432a1d3bc42
|
[] |
no_license
|
Gowtham-M1729/CS_Lab
|
8c1969f19cc54befbb1f4855b0e1b5f26cde8190
|
c0dcd12687c905ecbd0a1a4b9c4f715548e889e5
|
refs/heads/master
| 2023-06-12T04:05:11.661767 | 2021-06-30T17:53:08 | 2021-06-30T17:53:08 | 381,789,133 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 2,402 |
c
|
mergesort.c
|
#include <stdio.h>
#include <string.h>
#include<stdlib.h>
#include<time.h>
FILE *fp1,*fp2;
int c,count=0;
void mergeSort(int list[],int low,int mid,int high)
{ c=0;
int i, mi, k, lo, temp[10000];
lo = low;
i = low;
mi = mid + 1;
while ((lo <= mid) && (mi <= high))
{ c++;
if (list[lo] <= list[mi])
{
temp[i] = list[lo];
lo++;
}
else
{
temp[i] = list[mi];
mi++;
}
i++;
}
if (lo > mid)
{
for (k = mi; k <= high; k++)
{
temp[i] = list[k];
i++;
}
}
else
{
for (k = lo; k <= mid; k++)
{
temp[i] = list[k];
i++;
}
}
for (k = low; k <= high; k++)
{
list[k] = temp[k];
}
count+=c;
}
int partition(int list[],int low,int high)
{
int mid,i;
if(low < high)
{
mid = (low + high) / 2;
partition(list, low, mid);
partition(list, mid + 1, high);
mergeSort(list, low, mid, high);
}
else
return 0;
}
void print(int x[],int n)
{
for(int i=0;i<n;i++)
printf("%d\t",x[i]);
printf("\n");
}
void join(int arr[],int left[],int right[],int l,int m,int r)
{
int i,j;
for(i=0;i<=m-l;i++)
arr[i]=left[i];
for(j=0;j<r-m;j++)
arr[i+j]=right[j];
}
void split(int arr[],int left[],int right[],int l,int r,int m)
{
int i;
for(i=0;i<=m-l;i++)
left[i]=arr[i*2];
for(i=0;i<r-m;i++)
right[i]=arr[i*2+1];
}
void generate(int arr[],int l,int r)
{
if(l<r)
{
int m=(l+r)/2;
int left[m-l+1];
int right[r-m];
split(arr,left,right,l,r,m);
generate(left,l,m);
generate(right,m+1,r);
join(arr,left,right,l,m,r);
}
}
int bestcase(int arr[],int k)
{ fp2 = fopen("Mergecount.txt","a");
int i;
for(i=0;i<k;i++)
arr[i]=i+1;
printf("Sorted array is \n");
//print(arr,k);
generate(arr,0,k-1);
count=0;
partition(arr, 0, k -1);
printf("No of Counts is->%d\n",count);
fprintf(fp2,"%d\t%d\n",k,count);
return 0;
}
int main()
{
int a[10000];
int i, size;
remove("Mergecount.txt");
for(int i=16;i<=10000;i=i*2)
{ count=0;
printf("Entering two strings\n");
bestcase(a,i);
}
return 0;
}
|
f668d0d17935be4b486573e858dead67c29c3ba6
|
e87d79f552cdcd1323aa9bbfa38ecbf777ac94d1
|
/src/blas/3/syr2k/un/flamec/FLA_Syr2k_un.h
|
4645fca0d4c713c7009d0e3b3866055d5fa45c80
|
[
"BSD-3-Clause",
"LicenseRef-scancode-other-permissive"
] |
permissive
|
iotamudelta/libflame
|
539165f48d24c159ad494e813a1fc30fa2ea3791
|
70c19e770ead0ae846c59b59216deb16d236b40c
|
refs/heads/master
| 2023-07-28T12:31:59.890987 | 2023-07-13T19:33:42 | 2023-07-13T19:33:42 | 103,612,203 | 0 | 2 |
NOASSERTION
| 2023-05-04T19:04:09 | 2017-09-15T04:00:39 |
Fortran
|
UTF-8
|
C
| false | false | 2,430 |
h
|
FLA_Syr2k_un.h
|
/*
Copyright (C) 2014, The University of Texas at Austin
This file is part of libflame and is available under the 3-Clause
BSD license, which can be found in the LICENSE file at the top-level
directory, or at http://opensource.org/licenses/BSD-3-Clause
*/
#include "FLAME.h"
FLA_Error FLA_Syr2k_un_blk_var1( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C, fla_syr2k_t* cntl );
FLA_Error FLA_Syr2k_un_blk_var2( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C, fla_syr2k_t* cntl );
FLA_Error FLA_Syr2k_un_blk_var3( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C, fla_syr2k_t* cntl );
FLA_Error FLA_Syr2k_un_blk_var4( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C, fla_syr2k_t* cntl );
FLA_Error FLA_Syr2k_un_blk_var5( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C, fla_syr2k_t* cntl );
FLA_Error FLA_Syr2k_un_blk_var6( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C, fla_syr2k_t* cntl );
FLA_Error FLA_Syr2k_un_blk_var7( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C, fla_syr2k_t* cntl );
FLA_Error FLA_Syr2k_un_blk_var8( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C, fla_syr2k_t* cntl );
FLA_Error FLA_Syr2k_un_blk_var9( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C, fla_syr2k_t* cntl );
FLA_Error FLA_Syr2k_un_blk_var10( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C, fla_syr2k_t* cntl );
FLA_Error FLA_Syr2k_un_unb_var1( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C );
FLA_Error FLA_Syr2k_un_unb_var2( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C );
FLA_Error FLA_Syr2k_un_unb_var3( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C );
FLA_Error FLA_Syr2k_un_unb_var4( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C );
FLA_Error FLA_Syr2k_un_unb_var5( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C );
FLA_Error FLA_Syr2k_un_unb_var6( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C );
FLA_Error FLA_Syr2k_un_unb_var7( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C );
FLA_Error FLA_Syr2k_un_unb_var8( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C );
FLA_Error FLA_Syr2k_un_unb_var9( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C );
FLA_Error FLA_Syr2k_un_unb_var10( FLA_Obj alpha, FLA_Obj A, FLA_Obj B, FLA_Obj beta, FLA_Obj C );
|
14b89ce69d1fe4d102d5a87ed2215e5af3c058df
|
191707dd19837f7abd6f4255cd42b78d3ca741c5
|
/X11R6/xc/programs/Xserver/hw/xfree86/vga256/drivers/cirrus/cir_bltC.c
|
75c8e601d64f075b2ab40ccac4d6d99b4e6784be
|
[] |
no_license
|
yoya/x.org
|
4709089f97b1b48f7de2cfbeff1881c59ea1d28e
|
fb9e6d4bd0c880cfc674d4697322331fe39864d9
|
refs/heads/master
| 2023-08-08T02:00:51.277615 | 2023-07-25T14:05:05 | 2023-07-25T14:05:05 | 163,954,490 | 2 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 10,335 |
c
|
cir_bltC.c
|
/* $XConsortium: cir_bltC.c,v 1.5 95/01/23 15:35:09 kaleb Exp $ */
/* $XFree86: xc/programs/Xserver/hw/xfree86/vga256/drivers/cirrus/cir_bltC.c,v 3.6 1995/01/18 06:14:32 dawes Exp $ */
/*
Copyright (c) 1989 X Consortium
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of the X Consortium shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the X Consortium.
Author: Keith Packard
*/
/*
* Author: Bill Reynolds, bill@goshawk.lanl.gov
*
* Reworked by: Simon P. Cooper, <scooper@vizlab.rutgers.edu>
* Modified: H. Hanemaayer, <hhanemaa@cs.ruu.nl>
* Added CirrusCopyPlane1to8.
*
* Id: cir_bltC.c,v 0.7 1993/09/16 01:07:25 scooper Exp
*/
/*
* This is the high-level BitBlt function. Calls CirrusBitBlt.
*/
#include "X.h"
#include "Xmd.h"
#include "Xproto.h"
#include "gcstruct.h"
#include "windowstr.h"
#include "scrnintstr.h"
#include "pixmapstr.h"
#include "regionstr.h"
#include "vgaBank.h"
#include "vga256.h"
#include "cir_driver.h"
extern void (*ourvgaBitBlt)();
void
CirrusDoBitbltCopy(pSrc, pDst, alu, prgnDst, pptSrc, planemask)
DrawablePtr pSrc, pDst;
int alu;
RegionPtr prgnDst;
DDXPointPtr pptSrc;
unsigned long planemask;
{
unsigned char *psrcBase, *pdstBase;
/* start of src and dst bitmaps */
int widthSrc, widthDst; /* add to get to same position in next line */
register void (*fnp)();
int NoCirrus = 0;
BoxPtr pbox;
int nbox;
BoxPtr pboxTmp, pboxNext, pboxBase, pboxNew1, pboxNew2;
/* temporaries for shuffling rectangles */
DDXPointPtr pptTmp, pptNew1, pptNew2;
/* shuffling boxes entails shuffling the
source points too */
int xdir; /* 1 = left right, -1 = right left/ */
int ydir; /* 1 = top down, -1 = bottom up */
int careful;
void fastBitBltCopy();
void vgaImageRead();
void vgaImageWrite();
void CirrusBLTImageWrite();
void CirrusBLTImageRead();
void CirrusPolyBitBlt(); /* Special, different args. */
void vgaPixBitBlt();
if (pSrc->type == DRAWABLE_WINDOW)
{
psrcBase = (unsigned char *)
(((PixmapPtr)(pSrc->pScreen->devPrivate))->devPrivate.ptr);
widthSrc = (int)((PixmapPtr)(pSrc->pScreen->devPrivate))->devKind;
}
else
{
psrcBase = (unsigned char *)(((PixmapPtr)pSrc)->devPrivate.ptr);
widthSrc = (int)(((PixmapPtr)pSrc)->devKind);
}
if (pDst->type == DRAWABLE_WINDOW)
{
pdstBase = (unsigned char *)
(((PixmapPtr)(pDst->pScreen->devPrivate))->devPrivate.ptr);
widthDst = (int)
((PixmapPtr)(pDst->pScreen->devPrivate))->devKind;
}
else
{
pdstBase = (unsigned char *)(((PixmapPtr)pDst)->devPrivate.ptr);
widthDst = (int)(((PixmapPtr)pDst)->devKind);
}
/* XXX we have to err on the side of safety when both are windows,
* because we don't know if IncludeInferiors is being used.
*/
careful = ((pSrc == pDst) ||
((pSrc->type == DRAWABLE_WINDOW) &&
(pDst->type == DRAWABLE_WINDOW)));
pbox = REGION_RECTS(prgnDst);
nbox = REGION_NUM_RECTS(prgnDst);
if (careful && (pptSrc->y < pbox->y1)) NoCirrus = 1;
if (careful && (pptSrc->x < pbox->x1)) NoCirrus = 1;
if (CHECKSCREEN(psrcBase))
{
if (CHECKSCREEN(pdstBase)) /* Screen -> Screen */
{
/* Forget about non-GXcopy BitBLTs. We can do them, but */
/* I don't know how common they are. */
if (alu == GXcopy && (planemask & 0xff) == 0xff)
/* NULL indicates potential hardware Cirrus BitBlt; we
* let that function traverse the list of regions.
* for efficiency. See end of function. */
fnp = NULL;
else
fnp = vgaBitBlt;
}
else /* Screen -> Mem */
{
/* if(NoCirrus || !HAVEBITBLTENGINE() || HAVE543X()) */
if (1) /* ImageRead is unreliable. */
{
fnp = vgaImageRead;
}
else
{
fnp = CirrusBLTImageRead;
}
}
}
else
if (CHECKSCREEN(pdstBase)) /* Mem -> Screen */
{
if(NoCirrus || !HAVEBITBLTENGINE() || cirrusAvoidImageBLT)
/* ImageWrite seems prone to pixel errors. Probably
* caused by other function -- ImageWrite is used all
* the time by the cursor.
*/
{
fnp = vgaImageWrite;
}
else
if (cirrusUseMMIO)
fnp = CirrusMMIOBLTImageWrite;
else
fnp = CirrusBLTImageWrite;
}
else fnp = vgaPixBitBlt; /* Don't need to change: Mem -> Mem */
pboxNew1 = NULL;
pptNew1 = NULL;
pboxNew2 = NULL;
pptNew2 = NULL;
if (careful && (pptSrc->y < pbox->y1))
{
/* walk source botttom to top */
ydir = -1;
widthSrc = -widthSrc;
widthDst = -widthDst;
if (nbox > 1)
{
/* keep ordering in each band, reverse order of bands */
pboxNew1 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
if(!pboxNew1)
return;
pptNew1 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
if(!pptNew1)
{
DEALLOCATE_LOCAL(pboxNew1);
return;
}
pboxBase = pboxNext = pbox+nbox-1;
while (pboxBase >= pbox)
{
while ((pboxNext >= pbox) &&
(pboxBase->y1 == pboxNext->y1))
pboxNext--;
pboxTmp = pboxNext+1;
pptTmp = pptSrc + (pboxTmp - pbox);
while (pboxTmp <= pboxBase)
{
*pboxNew1++ = *pboxTmp++;
*pptNew1++ = *pptTmp++;
}
pboxBase = pboxNext;
}
pboxNew1 -= nbox;
pbox = pboxNew1;
pptNew1 -= nbox;
pptSrc = pptNew1;
}
}
else
{
/* walk source top to bottom */
ydir = 1;
}
if (careful && (pptSrc->x < pbox->x1))
{
/* walk source right to left */
xdir = -1;
if (nbox > 1)
{
/* reverse order of rects in each band */
pboxNew2 = (BoxPtr)ALLOCATE_LOCAL(sizeof(BoxRec) * nbox);
pptNew2 = (DDXPointPtr)ALLOCATE_LOCAL(sizeof(DDXPointRec) * nbox);
if(!pboxNew2 || !pptNew2)
{
if (pptNew2) DEALLOCATE_LOCAL(pptNew2);
if (pboxNew2) DEALLOCATE_LOCAL(pboxNew2);
if (pboxNew1)
{
DEALLOCATE_LOCAL(pptNew1);
DEALLOCATE_LOCAL(pboxNew1);
}
return;
}
pboxBase = pboxNext = pbox;
while (pboxBase < pbox+nbox)
{
while ((pboxNext < pbox+nbox) &&
(pboxNext->y1 == pboxBase->y1))
pboxNext++;
pboxTmp = pboxNext;
pptTmp = pptSrc + (pboxTmp - pbox);
while (pboxTmp != pboxBase)
{
*pboxNew2++ = *--pboxTmp;
*pptNew2++ = *--pptTmp;
}
pboxBase = pboxNext;
}
pboxNew2 -= nbox;
pbox = pboxNew2;
pptNew2 -= nbox;
pptSrc = pptNew2;
}
}
else
{
/* walk source left to right */
xdir = 1;
}
/* Avoid the calling overhead for (potential) hardware blits. */
if (fnp == NULL)
/* Screen-to-screen, alu == GXcopy, (planemask & 0xff) == 0xff */
CirrusPolyBitBlt(pdstBase, psrcBase, widthSrc, widthDst, nbox,
pptSrc, pbox, xdir, ydir);
else
while(nbox--) {
(*fnp)(pdstBase, psrcBase,widthSrc,widthDst,
pptSrc->x, pptSrc->y, pbox->x1, pbox->y1,
pbox->x2 - pbox->x1, pbox->y2 - pbox->y1,
xdir, ydir, alu, planemask);
pbox++;
pptSrc++;
}
/* free up stuff */
if (pboxNew2)
{
DEALLOCATE_LOCAL(pptNew2);
DEALLOCATE_LOCAL(pboxNew2);
}
if (pboxNew1)
{
DEALLOCATE_LOCAL(pptNew1);
DEALLOCATE_LOCAL(pboxNew1);
}
}
#ifdef CIRRUS_INCLUDE_COPYPLANE1TO8
extern void cfbCopyPlane1to8();
void CirrusCopyPlane1to8(pSrcDrawable, pDstDrawable, rop, prgnDst, pptSrc,
planemask, bitplane)
DrawablePtr pSrcDrawable;
DrawablePtr pDstDrawable;
int rop;
unsigned long planemask;
RegionPtr prgnDst;
DDXPointPtr pptSrc;
int bitplane; /* Unused. */
{
unsigned long *psrcBase, *pdstBase;
int widthSrc, widthDst;
int pixwidth;
int nbox;
BoxPtr pbox;
cfbGetLongWidthAndPointer (pSrcDrawable, widthSrc, psrcBase)
cfbGetLongWidthAndPointer (pDstDrawable, widthDst, pdstBase)
if (!CHECKSCREEN(pdstBase) || cfb8StippleRRop != GXcopy) {
vga256CopyPlane1to8(pSrcDrawable, pDstDrawable, rop, prgnDst, pptSrc,
planemask, 1);
return;
}
nbox = REGION_NUM_RECTS(prgnDst);
pbox = REGION_RECTS(prgnDst);
/* The planemask is understood to be 1 for all cases in which */
/* this function is called. */
while (nbox--)
{
int srcx, srcy, dstx, dsty, width, height;
int bg, fg;
dstx = pbox->x1;
dsty = pbox->y1;
srcx = pptSrc->x;
srcy = pptSrc->y;
width = pbox->x2 - pbox->x1;
height = pbox->y2 - pbox->y1;
pbox++;
pptSrc++;
fg = cfb8StippleFg;
bg = cfb8StippleBg;
if (width >= 32)
if (cirrusUseMMIO)
CirrusMMIOBLTWriteBitmap(dstx, dsty, width, height,
psrcBase, widthSrc * 4, srcx, srcy, bg, fg,
widthDst * 4);
else
CirrusBLTWriteBitmap(dstx, dsty, width, height,
psrcBase, widthSrc * 4, srcx, srcy, bg, fg,
widthDst * 4);
else {
/* Create singular region. */
RegionRec reg;
(*pDstDrawable->pScreen->RegionInit)(®, pbox - 1, 1);
vga256CopyPlane1to8(pSrcDrawable, pDstDrawable, rop,
®, pptSrc - 1, planemask, 1);
(*pDstDrawable->pScreen->RegionUninit)(®);
}
}
}
#endif
|
ea059b031f00aa668bf0b70541a8b26644ab961b
|
70f63f6b356c665842e359469a89287106a5a754
|
/src/mudlib/d/simauria/comun/habitacion/simauria/rhoemas/seri/piso01/oeste/pasillo_10.c
|
88bd323c440666ad70b6e69a561a186d7ec6ac8e
|
[] |
no_license
|
DPrenC/endor-mud
|
2aebc7af384db692c7dbc6c0a0dbb3c600e93ecc
|
3ca7605715ce2c02734c68766470f5d581b9fc98
|
refs/heads/master
| 2021-01-21T18:53:26.493953 | 2017-05-21T23:04:36 | 2017-05-21T23:04:36 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 607 |
c
|
pasillo_10.c
|
/***************************************************************************************
ARCHIVO: pasillo_10.c
AUTOR: [z] Zomax
FECHA: 13-01-2002
COMENTARIOS: Pasillo oeste 00
***************************************************************************************/
#include "path.h"
inherit RHOESTD("pasillo");
create () {
::create();
SetLocate("Seri-Solderteg, primer piso, ala oeste");
AddExit("este",RHOEHAB("seri/piso01/oeste/pasillo_11"));
AddExit("oeste",RHOEHAB("seri/piso01/oeste/pasillo_09"));
if (!random(2)) AddItem(RHOEPNJ("seri/discipulo"),REFRESH_DESTRUCT,1+random(2));
}
|
f06f83a71e9fc011a944e7ecc21de6ead95e62a5
|
35df3663aff1be9f07f8dcefc9fc7ba2dfe03857
|
/src/get_next_line.c
|
0f81e8a9ee5dad754d8753d187a278ee0c93a9f4
|
[] |
no_license
|
Dan-Sette/so_long
|
0e0a3f2e59fd7496f8b476774e587a5719e79b9a
|
8d48ac8c72a985ade13e90df73c9964b5ca61edf
|
refs/heads/master
| 2023-08-04T22:02:34.407920 | 2021-09-20T23:29:47 | 2021-09-20T23:29:47 | 406,994,139 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 2,708 |
c
|
get_next_line.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_next_line.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dalves-s <dalves-s@student.42sp.org.br> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/06/16 17:28:13 by dalves-s #+# #+# */
/* Updated: 2021/09/04 17:11:08 by dalves-s ### ########.fr */
/* */
/* ************************************************************************** */
#include "get_next_line.h"
int gline_break(char *line_buf, size_t len)
{
size_t i;
i = 0;
if (!line_buf)
return (i);
while (i < len)
{
if (line_buf[i] == '\n')
return (1);
i++;
}
return (0);
}
void *gft_calloc(size_t nmemb, size_t size)
{
void *point;
char *set;
size_t i;
i = 0;
point = malloc(nmemb * size);
if (!point)
return (NULL);
set = (char *)point;
while (i < size)
{
set[i] = 0;
i++;
}
return (point);
}
char *gnew_line(char **line, char *line_buf, int bytes)
{
int i;
char *aux;
int len;
len = 0;
i = 0;
aux = NULL;
while ((line_buf)[i] != '\n' && (line_buf)[i] != '\0')
i++;
*line = gft_substr((line_buf), 0, i);
if (bytes)
{
if ((line_buf)[i] == '\n')
i++;
len = gft_strlen((char *)((line_buf) + i));
aux = gft_substr((line_buf), i, len);
if (!aux)
return (NULL);
}
free((line_buf));
if (!*line)
return (NULL);
return (aux);
}
char gsplit_line(int fd, char **line_buf, char **buf, int *bytes)
{
char *temp;
while (*bytes && !(gline_break(*line_buf, gft_strlen(*line_buf))))
{
*bytes = read(fd, *buf, BUFFER_SIZE);
(*buf)[*bytes] = 0;
if (*bytes < 0 || *bytes > BUFFER_SIZE)
{
free(*buf);
return (0);
}
temp = *line_buf;
*line_buf = gft_strjoin(temp, *buf);
free(temp);
}
free(*buf);
return (1);
}
int get_next_line(int fd, char **line)
{
static char *line_buf;
char *buf;
int bytes;
int check;
bytes = BUFFER_SIZE;
if ((fd < 0) || !line || (BUFFER_SIZE <= 0) || fd > RLIMIT_NOFILE)
return (-1);
if (!line_buf)
line_buf = gft_strdup("");
buf = gft_calloc(sizeof(char), (BUFFER_SIZE + 1));
if (!buf)
return (-1);
check = gsplit_line(fd, &line_buf, &buf, &bytes);
if (!check)
return (-1);
line_buf = gnew_line(line, line_buf, bytes);
if (!bytes)
return (0);
return (1);
}
|
d368c386c4b105cab117c90a8fb88ebe795ef31f
|
1390cb4f58bd09087184a64fe2838dec29600d8a
|
/3272.c
|
621a19eb633bb8766d57b87f0b3e3d1bb6a5196d
|
[] |
no_license
|
imasker/obfuscatorTestCases
|
bf21352be1dbd6c8bdd868b093af03f315d92a45
|
5f5561846ec09a040b42dc12842c9581e7be6b4d
|
refs/heads/master
| 2023-03-27T11:35:21.843689 | 2021-03-25T07:38:05 | 2021-03-25T07:38:05 | 351,342,479 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 226,860 |
c
|
3272.c
|
/*
* This is a RANDOMLY GENERATED PROGRAM.
*
* Generator: csmith 2.3.0
* Git version: 30dccd7
* Options: -o /home/x/obfuscator/data/programs/3272.c
* Seed: 2557541186
*/
#include "csmith.h"
static long __undefined;
/* --- Struct/Union Declarations --- */
struct S0 {
int32_t f0;
int32_t f1;
volatile unsigned f2 : 7;
int32_t f3;
volatile uint32_t f4;
uint32_t f5;
const uint8_t f6;
int32_t f7;
};
union U1 {
int32_t f0;
uint8_t f1;
volatile int32_t f2;
const int32_t f3;
};
union U2 {
const uint32_t f0;
uint64_t f1;
const int32_t f2;
volatile int32_t f3;
int32_t f4;
};
/* --- GLOBAL VARIABLES --- */
static const int32_t g_11[2][8][9] = {{{0x2DA3C3D2L,5L,0xE712C519L,6L,0x0197CBB4L,0x2DA3C3D2L,0x40E11A79L,0x74ACC013L,0x74ACC013L},{0x4A90C6D2L,(-1L),0xACC4B7C7L,(-9L),0xACC4B7C7L,(-1L),0x4A90C6D2L,1L,(-9L)},{0x42E11914L,(-2L),6L,(-1L),0x2321210CL,1L,(-2L),1L,0x2DA3C3D2L},{(-1L),0x8787D636L,0x34ADC6F7L,(-1L),0xDFADF628L,7L,1L,1L,7L},{(-1L),(-5L),0x74ACC013L,(-5L),(-1L),0xCC099843L,0x9E843631L,0x74ACC013L,(-1L)},{0xE8F7CF8FL,1L,0xDFADF628L,0x8E60D743L,(-1L),(-1L),7L,(-4L),0x3FFD03B1L},{0x9E843631L,0x2DA3C3D2L,0xD64EA33AL,5L,1L,(-1L),(-1L),1L,5L},{(-9L),(-1L),(-9L),(-1L),0x309642E4L,0xC5C6A3F1L,(-1L),0x7D17017AL,(-1L)}},{{0x74ACC013L,1L,0x42E11914L,0xE712C519L,5L,0xCCD20446L,6L,0xD64EA33AL,6L},{0xACC4B7C7L,7L,0x3FFD03B1L,(-1L),0xE8F7CF8FL,0xE8F7CF8FL,(-1L),0x3FFD03B1L,7L},{1L,0xCC099843L,0x0197CBB4L,5L,0x8905B8B7L,1L,5L,0x314A5EA9L,(-2L)},{0x8787D636L,0xE8F7CF8FL,7L,0x8E60D743L,0xEDFA90EFL,1L,0x34ADC6F7L,(-1L),0x8E60D743L},{0xC18AB9C2L,0xCC099843L,0xE712C519L,6L,6L,0xE712C519L,0xCC099843L,0xC18AB9C2L,0xD64EA33AL},{0x7D17017AL,7L,0xEDFA90EFL,(-9L),1L,(-9L),0x309642E4L,(-1L),0xC5C6A3F1L},{0x2321210CL,1L,(-2L),1L,0x2DA3C3D2L,(-5L),0xD64EA33AL,(-2L),0xD64EA33AL},{(-1L),(-1L),0xEF6F0C3DL,0xEF6F0C3DL,(-1L),(-1L),1L,0xDFADF628L,0x8E60D743L}}};
static volatile int32_t g_20 = 8L;/* VOLATILE GLOBAL g_20 */
static int32_t g_21 = 7L;
static int32_t g_22 = 0xE2EFAADAL;
static int32_t *g_50 = &g_21;
static int32_t **g_49[9] = {&g_50,&g_50,&g_50,&g_50,&g_50,&g_50,&g_50,&g_50,&g_50};
static volatile union U2 g_73[3] = {{8UL},{8UL},{8UL}};
static const uint8_t g_82 = 0x4CL;
static int32_t g_85 = 1L;
static int32_t g_88 = 0x4290833CL;
static uint8_t g_126 = 0UL;
static uint64_t g_128 = 0xF8BE535D5B94001ELL;
static int32_t * volatile g_132 = (void*)0;/* VOLATILE GLOBAL g_132 */
static uint16_t g_149 = 0xF988L;
static union U2 * volatile g_151 = (void*)0;/* VOLATILE GLOBAL g_151 */
static union U2 * volatile * volatile g_150[7] = {&g_151,&g_151,&g_151,&g_151,&g_151,&g_151,&g_151};
static int8_t g_152 = (-1L);
static uint64_t g_159 = 0x27892DAB10FF70A8LL;
static uint64_t *g_158 = &g_159;
static uint16_t g_204[2] = {0x580FL,0x580FL};
static union U2 g_209 = {0UL};/* VOLATILE GLOBAL g_209 */
static const volatile int16_t g_216 = 0x1854L;/* VOLATILE GLOBAL g_216 */
static const volatile int16_t * volatile g_215 = &g_216;/* VOLATILE GLOBAL g_215 */
static struct S0 g_276 = {-1L,2L,0,0x637BDA3AL,4294967294UL,5UL,0x56L,0L};/* VOLATILE GLOBAL g_276 */
static uint32_t g_279[10][4][1] = {{{0xF76A16CEL},{4294967295UL},{0x2C736C07L},{0x760309D2L}},{{4294967295UL},{1UL},{4294967295UL},{0x2C736C07L}},{{0x2C736C07L},{4294967295UL},{1UL},{4294967295UL}},{{0x760309D2L},{0x2C736C07L},{4294967295UL},{0xF76A16CEL}},{{4294967295UL},{0x2C736C07L},{0x760309D2L},{4294967295UL}},{{1UL},{4294967295UL},{0x2C736C07L},{0x2C736C07L}},{{4294967295UL},{1UL},{4294967295UL},{0x760309D2L}},{{0x2C736C07L},{4294967295UL},{0xF76A16CEL},{4294967295UL}},{{0x2C736C07L},{0x760309D2L},{4294967295UL},{1UL}},{{4294967295UL},{0x2C736C07L},{0x2C736C07L},{4294967295UL}}};
static const int32_t *g_295[1] = {(void*)0};
static const int32_t ** volatile g_294 = &g_295[0];/* VOLATILE GLOBAL g_294 */
static volatile union U1 g_334 = {0L};/* VOLATILE GLOBAL g_334 */
static const volatile int8_t g_338[1] = {(-1L)};
static int64_t g_357 = (-3L);
static uint8_t g_358 = 0xB9L;
static uint8_t g_359 = 247UL;
static const int32_t ** const volatile g_362 = &g_295[0];/* VOLATILE GLOBAL g_362 */
static int32_t g_366 = 0x13F9ECF2L;
static int64_t **g_393 = (void*)0;
static int64_t *** volatile g_392[8][2][4] = {{{&g_393,&g_393,&g_393,&g_393},{(void*)0,&g_393,&g_393,&g_393}},{{&g_393,&g_393,(void*)0,&g_393},{&g_393,&g_393,&g_393,&g_393}},{{&g_393,&g_393,&g_393,&g_393},{&g_393,&g_393,&g_393,&g_393}},{{&g_393,&g_393,(void*)0,&g_393},{&g_393,&g_393,&g_393,&g_393}},{{&g_393,&g_393,&g_393,&g_393},{&g_393,&g_393,&g_393,&g_393}},{{&g_393,&g_393,&g_393,&g_393},{&g_393,(void*)0,&g_393,&g_393}},{{&g_393,&g_393,&g_393,&g_393},{&g_393,&g_393,&g_393,&g_393}},{{&g_393,(void*)0,&g_393,&g_393},{&g_393,&g_393,&g_393,&g_393}}};
static union U1 g_412 = {1L};/* VOLATILE GLOBAL g_412 */
static int8_t g_466 = (-3L);
static int16_t g_480 = 0x3B50L;
static union U1 *g_553 = &g_412;
static union U1 **g_552 = &g_553;
static union U1 ***g_551 = &g_552;
static const int32_t ** volatile g_587 = &g_295[0];/* VOLATILE GLOBAL g_587 */
static volatile union U1 g_608 = {0x591586B0L};/* VOLATILE GLOBAL g_608 */
static uint32_t g_615 = 0x63ADDC3CL;
static uint16_t * volatile *g_625 = (void*)0;
static volatile int32_t * volatile g_673 = &g_334.f2;/* VOLATILE GLOBAL g_673 */
static int32_t * volatile g_675 = (void*)0;/* VOLATILE GLOBAL g_675 */
static int32_t * volatile g_695[7][1] = {{&g_88},{&g_88},{(void*)0},{&g_88},{&g_88},{(void*)0},{&g_88}};
static const union U1 g_724 = {0x4B606311L};/* VOLATILE GLOBAL g_724 */
static volatile struct S0 * volatile * const * volatile g_816 = (void*)0;/* VOLATILE GLOBAL g_816 */
static int16_t g_825 = (-1L);
static int16_t g_827 = 0x7D46L;
static union U1 g_848 = {0x7A89E768L};/* VOLATILE GLOBAL g_848 */
static int32_t g_852 = 0L;
static int64_t *** volatile g_875 = &g_393;/* VOLATILE GLOBAL g_875 */
static union U2 g_878 = {0x5B13E292L};/* VOLATILE GLOBAL g_878 */
static const int32_t ** volatile g_917[7] = {&g_295[0],&g_295[0],&g_295[0],&g_295[0],&g_295[0],&g_295[0],&g_295[0]};
static struct S0 g_968[5] = {{8L,0x1C53C376L,4,0x7B2F9A45L,1UL,1UL,0x6DL,0x25024AAEL},{8L,0x1C53C376L,4,0x7B2F9A45L,1UL,1UL,0x6DL,0x25024AAEL},{8L,0x1C53C376L,4,0x7B2F9A45L,1UL,1UL,0x6DL,0x25024AAEL},{8L,0x1C53C376L,4,0x7B2F9A45L,1UL,1UL,0x6DL,0x25024AAEL},{8L,0x1C53C376L,4,0x7B2F9A45L,1UL,1UL,0x6DL,0x25024AAEL}};
static struct S0 *g_967 = &g_968[1];
static struct S0 **g_966 = &g_967;
static struct S0 ***g_965 = &g_966;
static const volatile union U1 g_983[8][1] = {{{-6L}},{{-6L}},{{-6L}},{{-6L}},{{-6L}},{{-6L}},{{-6L}},{{-6L}}};
static volatile union U2 g_992 = {4294967292UL};/* VOLATILE GLOBAL g_992 */
static union U1 * const **g_1021[3] = {(void*)0,(void*)0,(void*)0};
static union U1 * const ***g_1020 = &g_1021[0];
static union U1 * const ****g_1019 = &g_1020;
static union U2 *g_1033 = &g_209;
static union U2 **g_1032[5][2] = {{&g_1033,&g_1033},{&g_1033,&g_1033},{&g_1033,&g_1033},{&g_1033,&g_1033},{&g_1033,&g_1033}};
static volatile uint8_t g_1061 = 0xD9L;/* VOLATILE GLOBAL g_1061 */
static union U2 *** volatile g_1078 = &g_1032[0][0];/* VOLATILE GLOBAL g_1078 */
static int8_t g_1082[8][8][4] = {{{0x79L,(-1L),(-7L),1L},{(-1L),(-1L),(-1L),0L},{1L,1L,0L,2L},{0L,(-4L),(-5L),9L},{(-9L),1L,0x83L,0xD1L},{0xF1L,0x08L,0x96L,(-1L)},{(-1L),1L,0xCDL,0x8EL},{1L,0x12L,0xD2L,(-1L)}},{{0L,(-7L),0xADL,0x83L},{0xEDL,(-1L),9L,0xADL},{0xC6L,9L,0x70L,0xEAL},{0xDCL,0x53L,(-3L),6L},{0x83L,0x12L,(-1L),0xCDL},{0x59L,(-10L),0x59L,0xDCL},{0x1FL,0L,0x8BL,0xD1L},{(-8L),0xBAL,0x68L,0L}},{{(-1L),3L,0x68L,0xD1L},{(-8L),1L,0x8BL,(-3L)},{0x1FL,0xCBL,0x59L,0L},{0x59L,0L,(-1L),(-5L)},{0x83L,(-1L),(-3L),0xD0L},{0xDCL,0xDDL,0x70L,0xC1L},{0xC6L,(-5L),9L,0x68L},{0xEDL,0x3DL,0xADL,0xBAL}},{{0L,0xC9L,0xD2L,(-5L)},{1L,0x4AL,0xCDL,0x31L},{(-1L),(-1L),0x96L,0xFCL},{0xF1L,1L,0x83L,0x70L},{(-9L),1L,(-5L),1L},{(-1L),0xEDL,6L,0x68L},{0x31L,0x68L,0x3DL,9L},{(-9L),0x3FL,1L,0xD3L}},{{9L,0xD2L,(-10L),4L},{0xD1L,(-9L),1L,0x1FL},{(-7L),(-9L),0x68L,1L},{1L,0L,5L,(-1L)},{(-10L),0xBAL,0xECL,0L},{0xEAL,0xD2L,0x59L,1L},{0x42L,(-5L),0xC1L,(-9L)},{0xFCL,0xFAL,0x1AL,0x68L}},{{1L,0xBEL,0xCBL,0L},{0L,0xC0L,1L,0x53L},{5L,(-1L),(-1L),0xECL},{(-3L),(-1L),0xC1L,0xD1L},{0x27L,0x31L,0x31L,0x27L},{0x83L,6L,1L,1L},{(-10L),0xD1L,0x53L,1L},{0x8BL,(-1L),0xFAL,1L}},{{0x84L,0xD1L,1L,1L},{2L,6L,0L,0x27L},{0xD2L,0x31L,1L,0xD1L},{(-9L),(-1L),0L,0xECL},{0L,(-1L),0x1FL,0x53L},{6L,0xC0L,0x27L,0L},{0x96L,0xBEL,1L,0x68L},{1L,0xFAL,0xDDL,(-9L)}},{{(-9L),(-5L),0xD3L,1L},{(-1L),0xD2L,(-9L),0L},{0x1CL,0xBAL,1L,(-1L)},{0L,0L,0L,1L},{0xD0L,(-9L),1L,0x1FL},{(-10L),(-9L),(-4L),4L},{(-1L),0xD2L,0xD1L,0xD3L},{0x68L,0x3FL,0xC1L,9L}}};
static int32_t * volatile g_1107 = &g_276.f7;/* VOLATILE GLOBAL g_1107 */
static int32_t * volatile g_1108 = (void*)0;/* VOLATILE GLOBAL g_1108 */
static union U1 g_1111 = {1L};/* VOLATILE GLOBAL g_1111 */
static int32_t * volatile g_1126 = &g_1111.f0;/* VOLATILE GLOBAL g_1126 */
static union U1 g_1131 = {0x193AB374L};/* VOLATILE GLOBAL g_1131 */
static int32_t * volatile g_1143 = &g_366;/* VOLATILE GLOBAL g_1143 */
static uint32_t g_1165 = 0xFA38E73FL;
static union U2 g_1218 = {4294967293UL};/* VOLATILE GLOBAL g_1218 */
static int32_t * volatile g_1222 = &g_209.f4;/* VOLATILE GLOBAL g_1222 */
static uint64_t **g_1256 = (void*)0;
static uint64_t *** volatile g_1255[1][1][9] = {{{&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256}}};
static union U1 g_1341 = {0xA7B61571L};/* VOLATILE GLOBAL g_1341 */
static volatile union U2 g_1345 = {4294967292UL};/* VOLATILE GLOBAL g_1345 */
static volatile union U2 g_1353[4][4] = {{{0x167774D3L},{0x167774D3L},{0x167774D3L},{0x167774D3L}},{{0x167774D3L},{0x167774D3L},{0x167774D3L},{0x167774D3L}},{{0x167774D3L},{0x167774D3L},{0x167774D3L},{0x167774D3L}},{{0x167774D3L},{0x167774D3L},{0x167774D3L},{0x167774D3L}}};
static const struct S0 g_1368[2][8] = {{{-1L,0xFC40423EL,3,0xDC64F3B2L,0x5A92147BL,0UL,0xD3L,0x992CED43L},{5L,0xB30BD661L,4,1L,0x0E54C6C1L,1UL,0xBFL,0x5C1974E6L},{5L,0xB30BD661L,4,1L,0x0E54C6C1L,1UL,0xBFL,0x5C1974E6L},{-1L,0xFC40423EL,3,0xDC64F3B2L,0x5A92147BL,0UL,0xD3L,0x992CED43L},{0x6F816F6EL,0x6C082FDDL,4,-4L,0xB784B22BL,18446744073709551610UL,0x1EL,4L},{-1L,0xFC40423EL,3,0xDC64F3B2L,0x5A92147BL,0UL,0xD3L,0x992CED43L},{5L,0xB30BD661L,4,1L,0x0E54C6C1L,1UL,0xBFL,0x5C1974E6L},{5L,0xB30BD661L,4,1L,0x0E54C6C1L,1UL,0xBFL,0x5C1974E6L}},{{5L,0xB30BD661L,4,1L,0x0E54C6C1L,1UL,0xBFL,0x5C1974E6L},{0x6F816F6EL,0x6C082FDDL,4,-4L,0xB784B22BL,18446744073709551610UL,0x1EL,4L},{1L,8L,9,0xE0EDA53AL,1UL,18446744073709551615UL,0x33L,0x9F79CD01L},{1L,8L,9,0xE0EDA53AL,1UL,18446744073709551615UL,0x33L,0x9F79CD01L},{0x6F816F6EL,0x6C082FDDL,4,-4L,0xB784B22BL,18446744073709551610UL,0x1EL,4L},{5L,0xB30BD661L,4,1L,0x0E54C6C1L,1UL,0xBFL,0x5C1974E6L},{0x6F816F6EL,0x6C082FDDL,4,-4L,0xB784B22BL,18446744073709551610UL,0x1EL,4L},{1L,8L,9,0xE0EDA53AL,1UL,18446744073709551615UL,0x33L,0x9F79CD01L}}};
static union U1 g_1380 = {0x710A5DEDL};/* VOLATILE GLOBAL g_1380 */
static union U1 g_1416 = {0x17B7304FL};/* VOLATILE GLOBAL g_1416 */
static int32_t *g_1422 = &g_85;
static int32_t **g_1421[8][6] = {{(void*)0,(void*)0,(void*)0,(void*)0,&g_1422,&g_1422},{&g_1422,&g_1422,&g_1422,&g_1422,&g_1422,(void*)0},{&g_1422,&g_1422,&g_1422,&g_1422,&g_1422,&g_1422},{&g_1422,&g_1422,&g_1422,&g_1422,&g_1422,&g_1422},{&g_1422,&g_1422,(void*)0,&g_1422,&g_1422,&g_1422},{&g_1422,(void*)0,&g_1422,&g_1422,&g_1422,(void*)0},{&g_1422,&g_1422,&g_1422,(void*)0,&g_1422,&g_1422},{&g_1422,(void*)0,(void*)0,(void*)0,(void*)0,&g_1422}};
static volatile struct S0 g_1459 = {0x5B89EA0AL,-1L,2,0x2BCC0059L,0xBBFF47C8L,0x7905E780L,0x5EL,0L};/* VOLATILE GLOBAL g_1459 */
static union U2 g_1485 = {0UL};/* VOLATILE GLOBAL g_1485 */
static union U1 g_1501 = {0xBAF4A8B2L};/* VOLATILE GLOBAL g_1501 */
static struct S0 g_1519[7] = {{0L,0L,1,-1L,0xD0A84683L,0x65AF891CL,0xA4L,0x3B70DF8EL},{0xC0DAD54FL,0L,9,-2L,4294967295UL,0xE833A4CFL,8UL,0x51B50E88L},{0xC0DAD54FL,0L,9,-2L,4294967295UL,0xE833A4CFL,8UL,0x51B50E88L},{0L,0L,1,-1L,0xD0A84683L,0x65AF891CL,0xA4L,0x3B70DF8EL},{0xC0DAD54FL,0L,9,-2L,4294967295UL,0xE833A4CFL,8UL,0x51B50E88L},{0xC0DAD54FL,0L,9,-2L,4294967295UL,0xE833A4CFL,8UL,0x51B50E88L},{0L,0L,1,-1L,0xD0A84683L,0x65AF891CL,0xA4L,0x3B70DF8EL}};
static struct S0 g_1520 = {1L,0x5873C8FFL,7,0x738FAF29L,0xF81824A7L,0xB8C1C7FEL,0x7DL,0x785BEF25L};/* VOLATILE GLOBAL g_1520 */
static struct S0 g_1521 = {0xFF16F1F9L,0xAD6F8CE1L,10,0x7AD24776L,0xCE8BC3E5L,0xBC604979L,250UL,0x341A087AL};/* VOLATILE GLOBAL g_1521 */
static struct S0 g_1522 = {0L,0xB748B3D4L,10,0L,2UL,0x33B16C54L,0x40L,0L};/* VOLATILE GLOBAL g_1522 */
static struct S0 g_1523 = {0L,7L,2,0x4F2F1E94L,0x8ED285D7L,0x56453467L,0xAFL,1L};/* VOLATILE GLOBAL g_1523 */
static struct S0 g_1524[7] = {{0x483C342EL,0L,9,0L,0x9BCDDEFFL,0x66955D88L,0xB4L,3L},{0x483C342EL,0L,9,0L,0x9BCDDEFFL,0x66955D88L,0xB4L,3L},{0x483C342EL,0L,9,0L,0x9BCDDEFFL,0x66955D88L,0xB4L,3L},{0x483C342EL,0L,9,0L,0x9BCDDEFFL,0x66955D88L,0xB4L,3L},{0x483C342EL,0L,9,0L,0x9BCDDEFFL,0x66955D88L,0xB4L,3L},{0x483C342EL,0L,9,0L,0x9BCDDEFFL,0x66955D88L,0xB4L,3L},{0x483C342EL,0L,9,0L,0x9BCDDEFFL,0x66955D88L,0xB4L,3L}};
static struct S0 g_1525 = {0x6E0C092BL,0x39105841L,1,0x3DE1EE68L,0xEA7C205FL,0x201B75F9L,3UL,0xED920245L};/* VOLATILE GLOBAL g_1525 */
static struct S0 g_1526 = {0xAC6F4FDFL,-1L,2,1L,0x9353992CL,0xDEEB0BFAL,0x96L,0x34339ED2L};/* VOLATILE GLOBAL g_1526 */
static struct S0 g_1527 = {-1L,0xF45ACFA2L,1,0xDCB17A1DL,0x26AA5F3EL,0x80E6549AL,1UL,-1L};/* VOLATILE GLOBAL g_1527 */
static struct S0 g_1529[1][6][8] = {{{{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L}},{{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L}},{{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L}},{{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L}},{{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L}},{{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L},{1L,0L,8,0x10328ACDL,4294967295UL,0xFA0D3926L,0x16L,0xA934D040L}}}};
static union U2 g_1549[5][3][6] = {{{{0x58B06024L},{0x1DCBB668L},{0x1DCBB668L},{0x58B06024L},{0x3C8CE505L},{0x3002DD05L}},{{0UL},{0x980CAB36L},{0xE384CD57L},{0x3002DD05L},{3UL},{0UL}},{{3UL},{0x3C8CE505L},{4294967295UL},{0x3C8CE505L},{3UL},{0xC0D4F74DL}}},{{{0UL},{0x980CAB36L},{0xA91FBABAL},{0x732A8B41L},{0x3C8CE505L},{0xE384CD57L}},{{0xE384CD57L},{0x1DCBB668L},{0x980CAB36L},{0x980CAB36L},{0x1DCBB668L},{0xE384CD57L}},{{0x732A8B41L},{0x3002DD05L},{0xA91FBABAL},{3UL},{0xE384CD57L},{0xC0D4F74DL}}},{{{0x1DCBB668L},{0UL},{4294967295UL},{0xE384CD57L},{4294967295UL},{0UL}},{{0x1DCBB668L},{0xC0D4F74DL},{0xE384CD57L},{3UL},{0xA91FBABAL},{0x3002DD05L}},{{0x732A8B41L},{0xE384CD57L},{0x1DCBB668L},{0x980CAB36L},{0x980CAB36L},{0x1DCBB668L}}},{{{0xE384CD57L},{0xE384CD57L},{0x3C8CE505L},{0x732A8B41L},{0xA91FBABAL},{0x980CAB36L}},{{0UL},{0xC0D4F74DL},{3UL},{0x3C8CE505L},{4294967295UL},{0x3C8CE505L}},{{3UL},{0UL},{3UL},{0x3002DD05L},{0xE384CD57L},{0x980CAB36L}}},{{{0UL},{0x3002DD05L},{0x3C8CE505L},{0x58B06024L},{0x1DCBB668L},{0x1DCBB668L}},{{0x58B06024L},{0x1DCBB668L},{0x1DCBB668L},{0x58B06024L},{0x3C8CE505L},{0x3002DD05L}},{{0UL},{0x980CAB36L},{0xE384CD57L},{0x3002DD05L},{3UL},{0UL}}}};
static volatile union U2 g_1564 = {4294967295UL};/* VOLATILE GLOBAL g_1564 */
static const uint64_t g_1598 = 18446744073709551612UL;
static volatile uint64_t g_1646 = 18446744073709551606UL;/* VOLATILE GLOBAL g_1646 */
static volatile uint16_t g_1653 = 7UL;/* VOLATILE GLOBAL g_1653 */
static int64_t g_1708 = 0x58E6E4058FE28A4BLL;
static volatile struct S0 g_1720[8][6] = {{{-7L,1L,10,0xF18C49C8L,0x4706F1D6L,0x356D2A3AL,0xCCL,0xAF8AE773L},{0x946392A6L,0x8741BCAAL,7,0L,1UL,4UL,0x67L,0L},{-1L,0L,3,0x0863EC94L,0x672B0882L,0x044C9656L,253UL,0xB3CDDED2L},{-7L,1L,10,0xF18C49C8L,0x4706F1D6L,0x356D2A3AL,0xCCL,0xAF8AE773L},{-7L,1L,10,0xF18C49C8L,0x4706F1D6L,0x356D2A3AL,0xCCL,0xAF8AE773L},{-1L,0L,3,0x0863EC94L,0x672B0882L,0x044C9656L,253UL,0xB3CDDED2L}},{{0x5A96ABA7L,0x08362C9EL,0,0x05613326L,0x11B31F66L,18446744073709551608UL,255UL,0xD3C5EC1FL},{0x5A96ABA7L,0x08362C9EL,0,0x05613326L,0x11B31F66L,18446744073709551608UL,255UL,0xD3C5EC1FL},{-7L,1L,10,0xF18C49C8L,0x4706F1D6L,0x356D2A3AL,0xCCL,0xAF8AE773L},{0xCEAB0970L,5L,9,0L,0x6EDAA8CEL,0x810AA784L,7UL,-1L},{1L,5L,2,0x26C5BFA9L,4294967289UL,1UL,0x43L,0L},{0xCEAB0970L,5L,9,0L,0x6EDAA8CEL,0x810AA784L,7UL,-1L}},{{0x946392A6L,0x8741BCAAL,7,0L,1UL,4UL,0x67L,0L},{0x5A96ABA7L,0x08362C9EL,0,0x05613326L,0x11B31F66L,18446744073709551608UL,255UL,0xD3C5EC1FL},{0x946392A6L,0x8741BCAAL,7,0L,1UL,4UL,0x67L,0L},{-1L,0L,3,0x0863EC94L,0x672B0882L,0x044C9656L,253UL,0xB3CDDED2L},{-7L,1L,10,0xF18C49C8L,0x4706F1D6L,0x356D2A3AL,0xCCL,0xAF8AE773L},{-7L,1L,10,0xF18C49C8L,0x4706F1D6L,0x356D2A3AL,0xCCL,0xAF8AE773L}},{{0L,0xF31E938AL,10,9L,4294967294UL,0UL,0x2DL,0x6459CE11L},{0x946392A6L,0x8741BCAAL,7,0L,1UL,4UL,0x67L,0L},{0x946392A6L,0x8741BCAAL,7,0L,1UL,4UL,0x67L,0L},{0L,0xF31E938AL,10,9L,4294967294UL,0UL,0x2DL,0x6459CE11L},{0x5A96ABA7L,0x08362C9EL,0,0x05613326L,0x11B31F66L,18446744073709551608UL,255UL,0xD3C5EC1FL},{0xCEAB0970L,5L,9,0L,0x6EDAA8CEL,0x810AA784L,7UL,-1L}},{{0xCEAB0970L,5L,9,0L,0x6EDAA8CEL,0x810AA784L,7UL,-1L},{0L,0xF31E938AL,10,9L,4294967294UL,0UL,0x2DL,0x6459CE11L},{-7L,1L,10,0xF18C49C8L,0x4706F1D6L,0x356D2A3AL,0xCCL,0xAF8AE773L},{0L,0xF31E938AL,10,9L,4294967294UL,0UL,0x2DL,0x6459CE11L},{0xCEAB0970L,5L,9,0L,0x6EDAA8CEL,0x810AA784L,7UL,-1L},{-1L,0L,3,0x0863EC94L,0x672B0882L,0x044C9656L,253UL,0xB3CDDED2L}},{{0L,0xF31E938AL,10,9L,4294967294UL,0UL,0x2DL,0x6459CE11L},{0xCEAB0970L,5L,9,0L,0x6EDAA8CEL,0x810AA784L,7UL,-1L},{-1L,0L,3,0x0863EC94L,0x672B0882L,0x044C9656L,253UL,0xB3CDDED2L},{-1L,0L,3,0x0863EC94L,0x672B0882L,0x044C9656L,253UL,0xB3CDDED2L},{0xCEAB0970L,5L,9,0L,0x6EDAA8CEL,0x810AA784L,7UL,-1L},{0L,0xF31E938AL,10,9L,4294967294UL,0UL,0x2DL,0x6459CE11L}},{{0x946392A6L,0x8741BCAAL,7,0L,1UL,4UL,0x67L,0L},{0L,0xF31E938AL,10,9L,4294967294UL,0UL,0x2DL,0x6459CE11L},{0x5A96ABA7L,0x08362C9EL,0,0x05613326L,0x11B31F66L,18446744073709551608UL,255UL,0xD3C5EC1FL},{0xCEAB0970L,5L,9,0L,0x6EDAA8CEL,0x810AA784L,7UL,-1L},{0x5A96ABA7L,0x08362C9EL,0,0x05613326L,0x11B31F66L,18446744073709551608UL,255UL,0xD3C5EC1FL},{0L,0xF31E938AL,10,9L,4294967294UL,0UL,0x2DL,0x6459CE11L}},{{0x5A96ABA7L,0x08362C9EL,0,0x05613326L,0x11B31F66L,18446744073709551608UL,255UL,0xD3C5EC1FL},{0x946392A6L,0x8741BCAAL,7,0L,1UL,4UL,0x67L,0L},{-1L,0L,3,0x0863EC94L,0x672B0882L,0x044C9656L,253UL,0xB3CDDED2L},{-7L,1L,10,0xF18C49C8L,0x4706F1D6L,0x356D2A3AL,0xCCL,0xAF8AE773L},{-7L,1L,10,0xF18C49C8L,0x4706F1D6L,0x356D2A3AL,0xCCL,0xAF8AE773L},{-1L,0L,3,0x0863EC94L,0x672B0882L,0x044C9656L,253UL,0xB3CDDED2L}}};
static volatile struct S0 g_1730 = {-7L,-1L,10,0L,0x059E3DC3L,18446744073709551608UL,0x61L,0xCC6EA0F2L};/* VOLATILE GLOBAL g_1730 */
static union U2 g_1775[9] = {{0xD6161C20L},{0xD6161C20L},{0xD6161C20L},{0xD6161C20L},{0xD6161C20L},{0xD6161C20L},{0xD6161C20L},{0xD6161C20L},{0xD6161C20L}};
static union U1 ** const volatile g_1787 = (void*)0;/* VOLATILE GLOBAL g_1787 */
static int32_t * volatile g_1838 = &g_968[1].f1;/* VOLATILE GLOBAL g_1838 */
static const struct S0 g_1850 = {0xB095E123L,-1L,9,0x8A967329L,0xD1EFE4C3L,0x66F3DDC9L,255UL,1L};/* VOLATILE GLOBAL g_1850 */
static volatile union U1 g_1903 = {-1L};/* VOLATILE GLOBAL g_1903 */
static const int32_t ** volatile g_1923 = (void*)0;/* VOLATILE GLOBAL g_1923 */
static volatile struct S0 g_1942 = {0x25CE5ABAL,0xD6E8597AL,5,0x8914BE49L,4294967292UL,1UL,255UL,0x9CC0F90BL};/* VOLATILE GLOBAL g_1942 */
static int64_t ** const g_1980 = (void*)0;
static int64_t ** const *g_1979 = &g_1980;
static int64_t * const **g_1981 = (void*)0;
static struct S0 g_1983[7][2][7] = {{{{-8L,0x19DAF4E6L,10,0x89039BF0L,0x41CDB462L,0xF2AD2962L,1UL,3L},{0xA5854D8CL,0xD771BCF0L,3,0xD8B3FE53L,0UL,0x1F76D5A1L,0UL,-9L},{5L,0x55DEF731L,1,0x1B9F5DD3L,0x592D9886L,18446744073709551615UL,0xD9L,-1L},{-1L,0L,3,0x3E231492L,1UL,18446744073709551606UL,0UL,0x87FBE72DL},{5L,0x55DEF731L,1,0x1B9F5DD3L,0x592D9886L,18446744073709551615UL,0xD9L,-1L},{0xA5854D8CL,0xD771BCF0L,3,0xD8B3FE53L,0UL,0x1F76D5A1L,0UL,-9L},{-8L,0x19DAF4E6L,10,0x89039BF0L,0x41CDB462L,0xF2AD2962L,1UL,3L}},{{0xA1269050L,0L,5,0xD8CA617AL,9UL,0x58370268L,252UL,5L},{0xC557317AL,5L,6,0x6763B1FBL,0UL,9UL,5UL,0x4F879874L},{-1L,0x6CA199CCL,0,0xBB60450DL,1UL,0x98C6906FL,0x48L,-5L},{0L,0xE546F8AAL,0,0x0957FE1BL,0UL,1UL,0x42L,0x6A80D170L},{0x7329A4BBL,-9L,0,0xE7668186L,0xD21BD337L,18446744073709551615UL,0xAFL,-1L},{0xA8A213CCL,1L,1,1L,0xD4B2AF2FL,0xC186D855L,0x7BL,0xED38AF21L},{0L,2L,10,0xECB71139L,0UL,3UL,0x42L,0xE2F300D2L}}},{{{0x32D58142L,0x51F18F27L,3,9L,0UL,1UL,0xD5L,-2L},{0xCA7D7ACBL,0xE3AA9488L,10,0x579173DEL,4294967287UL,18446744073709551606UL,7UL,0x93347D04L},{0x622BFC7EL,0x25ED220EL,4,0xD68C6BBBL,0x891D5C63L,0x2865C7AEL,0x13L,0x65C3E68FL},{5L,0x55DEF731L,1,0x1B9F5DD3L,0x592D9886L,18446744073709551615UL,0xD9L,-1L},{0x81529419L,0x20D2D4BDL,9,0xD6EFC415L,0x74206E04L,6UL,0x0DL,0x26B4E493L},{0x81529419L,0x20D2D4BDL,9,0xD6EFC415L,0x74206E04L,6UL,0x0DL,0x26B4E493L},{5L,0x55DEF731L,1,0x1B9F5DD3L,0x592D9886L,18446744073709551615UL,0xD9L,-1L}},{{-1L,0x6CA199CCL,0,0xBB60450DL,1UL,0x98C6906FL,0x48L,-5L},{0x88F92831L,-8L,2,0xDE28BE02L,0UL,0xA5E5DFA2L,255UL,0xBB073D28L},{-1L,0x6CA199CCL,0,0xBB60450DL,1UL,0x98C6906FL,0x48L,-5L},{0x98834848L,0x170B2B33L,4,0xFE0895C1L,4294967294UL,0xBB47CE4AL,255UL,0x02676B60L},{0x5F764267L,-3L,3,0x24D65734L,0x30CAE9FAL,18446744073709551615UL,0xB8L,-4L},{0x6EBD8262L,1L,7,0L,1UL,1UL,0xF8L,0x3EF36B23L},{0xA8A213CCL,1L,1,1L,0xD4B2AF2FL,0xC186D855L,0x7BL,0xED38AF21L}}},{{{0xA5854D8CL,0xD771BCF0L,3,0xD8B3FE53L,0UL,0x1F76D5A1L,0UL,-9L},{0xB7EED95DL,0x73CA9471L,5,0x38544CA3L,0x7B8FE932L,18446744073709551615UL,255UL,-1L},{5L,0x55DEF731L,1,0x1B9F5DD3L,0x592D9886L,18446744073709551615UL,0xD9L,-1L},{0xCA7D7ACBL,0xE3AA9488L,10,0x579173DEL,4294967287UL,18446744073709551606UL,7UL,0x93347D04L},{5L,-4L,5,1L,0xE1185E69L,0xD5BEC68AL,0x63L,1L},{-1L,4L,7,-1L,0xA70A8B0AL,0x15AB6DA7L,2UL,5L},{0x32D58142L,0x51F18F27L,3,9L,0UL,1UL,0xD5L,-2L}},{{0x6EBD8262L,1L,7,0L,1UL,1UL,0xF8L,0x3EF36B23L},{0xA1269050L,0L,5,0xD8CA617AL,9UL,0x58370268L,252UL,5L},{0x5446B8ABL,0x5D55F32AL,9,-1L,4294967295UL,0x696934F3L,1UL,6L},{0x5446B8ABL,0x5D55F32AL,9,-1L,4294967295UL,0x696934F3L,1UL,6L},{0xA1269050L,0L,5,0xD8CA617AL,9UL,0x58370268L,252UL,5L},{0x6EBD8262L,1L,7,0L,1UL,1UL,0xF8L,0x3EF36B23L},{8L,0x9968102DL,0,0xAC583338L,0xE3779D11L,0x88D6ADFEL,250UL,0xBBEE46DFL}}},{{{0xC890F2B8L,0xD1BDAACFL,9,0x293C5798L,0xD8264474L,18446744073709551606UL,0x9BL,0xEC660042L},{5L,0x55DEF731L,1,0x1B9F5DD3L,0x592D9886L,18446744073709551615UL,0xD9L,-1L},{5L,-4L,5,1L,0xE1185E69L,0xD5BEC68AL,0x63L,1L},{0x874A8060L,8L,4,3L,0xC648ED34L,0x4908F88AL,0x45L,0x98B20FBFL},{0x622BFC7EL,0x25ED220EL,4,0xD68C6BBBL,0x891D5C63L,0x2865C7AEL,0x13L,0x65C3E68FL},{0x81529419L,0x20D2D4BDL,9,0xD6EFC415L,0x74206E04L,6UL,0x0DL,0x26B4E493L},{1L,1L,3,0x9D400EADL,1UL,1UL,3UL,-9L}},{{-5L,0x97E96616L,9,0x0C650DF9L,8UL,0xE0AF8641L,1UL,0x96B05D7DL},{0x6EBD8262L,1L,7,0L,1UL,1UL,0xF8L,0x3EF36B23L},{0x5949B8DCL,1L,2,-1L,1UL,0UL,1UL,-3L},{0xA8A213CCL,1L,1,1L,0xD4B2AF2FL,0xC186D855L,0x7BL,0xED38AF21L},{0L,0xE546F8AAL,0,0x0957FE1BL,0UL,1UL,0x42L,0x6A80D170L},{0xA8A213CCL,1L,1,1L,0xD4B2AF2FL,0xC186D855L,0x7BL,0xED38AF21L},{0x5949B8DCL,1L,2,-1L,1UL,0UL,1UL,-3L}}},{{{5L,0x55DEF731L,1,0x1B9F5DD3L,0x592D9886L,18446744073709551615UL,0xD9L,-1L},{5L,0x55DEF731L,1,0x1B9F5DD3L,0x592D9886L,18446744073709551615UL,0xD9L,-1L},{-1L,4L,7,-1L,0xA70A8B0AL,0x15AB6DA7L,2UL,5L},{0x18EF8D76L,-4L,4,7L,0x3FAD3D24L,0xF621FC31L,252UL,3L},{0x874A8060L,8L,4,3L,0xC648ED34L,0x4908F88AL,0x45L,0x98B20FBFL},{0xA5854D8CL,0xD771BCF0L,3,0xD8B3FE53L,0UL,0x1F76D5A1L,0UL,-9L},{0x0806C526L,1L,4,4L,1UL,1UL,1UL,-5L}},{{8L,0x9968102DL,0,0xAC583338L,0xE3779D11L,0x88D6ADFEL,250UL,0xBBEE46DFL},{0xA1269050L,0L,5,0xD8CA617AL,9UL,0x58370268L,252UL,5L},{0x98834848L,0x170B2B33L,4,0xFE0895C1L,4294967294UL,0xBB47CE4AL,255UL,0x02676B60L},{0x7329A4BBL,-9L,0,0xE7668186L,0xD21BD337L,18446744073709551615UL,0xAFL,-1L},{0x5949B8DCL,1L,2,-1L,1UL,0UL,1UL,-3L},{0x5F764267L,-3L,3,0x24D65734L,0x30CAE9FAL,18446744073709551615UL,0xB8L,-4L},{0x5F764267L,-3L,3,0x24D65734L,0x30CAE9FAL,18446744073709551615UL,0xB8L,-4L}}},{{{0x874A8060L,8L,4,3L,0xC648ED34L,0x4908F88AL,0x45L,0x98B20FBFL},{0xB7EED95DL,0x73CA9471L,5,0x38544CA3L,0x7B8FE932L,18446744073709551615UL,255UL,-1L},{-8L,0x19DAF4E6L,10,0x89039BF0L,0x41CDB462L,0xF2AD2962L,1UL,3L},{0xB7EED95DL,0x73CA9471L,5,0x38544CA3L,0x7B8FE932L,18446744073709551615UL,255UL,-1L},{0x874A8060L,8L,4,3L,0xC648ED34L,0x4908F88AL,0x45L,0x98B20FBFL},{5L,0x55DEF731L,1,0x1B9F5DD3L,0x592D9886L,18446744073709551615UL,0xD9L,-1L},{-10L,0xBD3AC597L,1,0x73882F6EL,0x7C0E051DL,0x08EF4738L,0UL,0x3A3FB787L}},{{-7L,7L,3,0x7919BB5CL,0x8239865AL,0x7E8BC298L,0xFBL,0x8E062575L},{0x88F92831L,-8L,2,0xDE28BE02L,0UL,0xA5E5DFA2L,255UL,0xBB073D28L},{-5L,0x97E96616L,9,0x0C650DF9L,8UL,0xE0AF8641L,1UL,0x96B05D7DL},{0xC557317AL,5L,6,0x6763B1FBL,0UL,9UL,5UL,0x4F879874L},{0L,0xE546F8AAL,0,0x0957FE1BL,0UL,1UL,0x42L,0x6A80D170L},{1L,0x7262ED81L,2,0xE37C20D5L,1UL,0x0D6D5556L,0xF5L,0x5669B834L},{0x6EBD8262L,1L,7,0L,1UL,1UL,0xF8L,0x3EF36B23L}}},{{{-1L,0L,3,0x3E231492L,1UL,18446744073709551606UL,0UL,0x87FBE72DL},{0xCA7D7ACBL,0xE3AA9488L,10,0x579173DEL,4294967287UL,18446744073709551606UL,7UL,0x93347D04L},{0x18EF8D76L,-4L,4,7L,0x3FAD3D24L,0xF621FC31L,252UL,3L},{0x622BFC7EL,0x25ED220EL,4,0xD68C6BBBL,0x891D5C63L,0x2865C7AEL,0x13L,0x65C3E68FL},{0x622BFC7EL,0x25ED220EL,4,0xD68C6BBBL,0x891D5C63L,0x2865C7AEL,0x13L,0x65C3E68FL},{0x18EF8D76L,-4L,4,7L,0x3FAD3D24L,0xF621FC31L,252UL,3L},{0xCA7D7ACBL,0xE3AA9488L,10,0x579173DEL,4294967287UL,18446744073709551606UL,7UL,0x93347D04L}},{{-7L,7L,3,0x7919BB5CL,0x8239865AL,0x7E8BC298L,0xFBL,0x8E062575L},{0xC557317AL,5L,6,0x6763B1FBL,0UL,9UL,5UL,0x4F879874L},{0x88F92831L,-8L,2,0xDE28BE02L,0UL,0xA5E5DFA2L,255UL,0xBB073D28L},{8L,0x9968102DL,0,0xAC583338L,0xE3779D11L,0x88D6ADFEL,250UL,0xBBEE46DFL},{0xA1269050L,0L,5,0xD8CA617AL,9UL,0x58370268L,252UL,5L},{0x98834848L,0x170B2B33L,4,0xFE0895C1L,4294967294UL,0xBB47CE4AL,255UL,0x02676B60L},{0x7329A4BBL,-9L,0,0xE7668186L,0xD21BD337L,18446744073709551615UL,0xAFL,-1L}}}};
static const int32_t ** const volatile g_2005 = &g_295[0];/* VOLATILE GLOBAL g_2005 */
static union U2 g_2006[10][8] = {{{4294967295UL},{0xCAC48A36L},{0x52E2F9D9L},{0x94FB2081L},{4294967295UL},{4294967295UL},{0x1708EF45L},{0UL}},{{0UL},{0x94FB2081L},{0x7B9B5BAAL},{4294967295UL},{4294967295UL},{0x7B9B5BAAL},{0x94FB2081L},{0UL}},{{4294967295UL},{0x7B9B5BAAL},{0x94FB2081L},{0UL},{7UL},{1UL},{4294967295UL},{1UL}},{{0x94FB2081L},{0x52E2F9D9L},{0xCAC48A36L},{4294967295UL},{0UL},{1UL},{4294967295UL},{0xFA08AF08L}},{{1UL},{0x7B9B5BAAL},{0x2261EF39L},{4294967295UL},{0x2261EF39L},{4294967295UL},{4294967294UL},{1UL}},{{7UL},{4294967295UL},{0xCAC48A36L},{0UL},{4294967295UL},{0UL},{0x2261EF39L},{0x8C6D9029L}},{{0x1708EF45L},{0x2261EF39L},{0UL},{4294967295UL},{4294967295UL},{1UL},{4294967295UL},{4294967295UL}},{{7UL},{0x52E2F9D9L},{0x8C6D9029L},{0x8C6D9029L},{0x52E2F9D9L},{7UL},{0xFA08AF08L},{0x1708EF45L}},{{4294967294UL},{0xCAC48A36L},{0x1708EF45L},{4294967295UL},{0x94FB2081L},{1UL},{0UL},{0x7B9B5BAAL}},{{4294967295UL},{0UL},{0xFA08AF08L},{4294967295UL},{0x8C6D9029L},{0x1708EF45L},{1UL},{0x1708EF45L}}};
static volatile struct S0 g_2023 = {0xA0E89C3FL,0x754FD7C2L,6,0xD14EE7D4L,0xB2FC5B69L,5UL,255UL,0xFBDAD738L};/* VOLATILE GLOBAL g_2023 */
static const union U1 g_2177 = {0xE23F6CD2L};/* VOLATILE GLOBAL g_2177 */
static union U1 g_2211 = {0L};/* VOLATILE GLOBAL g_2211 */
static const union U1 g_2230[3] = {{-1L},{-1L},{-1L}};
static union U2 g_2241[5][7][5] = {{{{0UL},{0x96D7B5C8L},{0UL},{0x862BD6E1L},{4294967295UL}},{{0x9F68AA10L},{0x047A8FE5L},{0x42A593A2L},{0x96D7B5C8L},{0xED0EF6E8L}},{{1UL},{0x862BD6E1L},{0x42A593A2L},{4294967295UL},{0x5737EE3AL}},{{0xED0EF6E8L},{0xD9FAFC29L},{0UL},{4294967286UL},{4294967292UL}},{{1UL},{0x2F1FA7C9L},{4294967292UL},{4294967286UL},{0x9F68AA10L}},{{0x9F68AA10L},{0x82D9E9AAL},{4294967295UL},{4294967295UL},{0xCD987159L}},{{0UL},{0x2F1FA7C9L},{0x1CD04876L},{0x96D7B5C8L},{0xCD987159L}}},{{{0xF74D2CBEL},{0xD9FAFC29L},{0xB321B207L},{0x862BD6E1L},{0x9F68AA10L}},{{0x5737EE3AL},{0x862BD6E1L},{0x1CD04876L},{4294967290UL},{4294967292UL}},{{0x5737EE3AL},{0x047A8FE5L},{4294967295UL},{0x047A8FE5L},{0x5737EE3AL}},{{0xF74D2CBEL},{0x96D7B5C8L},{4294967292UL},{4294967290UL},{0xED0EF6E8L}},{{0UL},{0x96D7B5C8L},{0UL},{0x862BD6E1L},{4294967295UL}},{{0x9F68AA10L},{0x047A8FE5L},{0x42A593A2L},{0x96D7B5C8L},{0xED0EF6E8L}},{{1UL},{0x862BD6E1L},{0x42A593A2L},{4294967295UL},{0x5737EE3AL}}},{{{0xED0EF6E8L},{0xD9FAFC29L},{0UL},{4294967286UL},{4294967292UL}},{{1UL},{0x2F1FA7C9L},{4294967292UL},{4294967286UL},{0x9F68AA10L}},{{0x9F68AA10L},{0x82D9E9AAL},{4294967295UL},{4294967295UL},{0xCD987159L}},{{0UL},{0x2F1FA7C9L},{0x1CD04876L},{0x96D7B5C8L},{0xCD987159L}},{{0xF74D2CBEL},{0xD9FAFC29L},{0xB321B207L},{0x862BD6E1L},{0x9F68AA10L}},{{0x5737EE3AL},{0x862BD6E1L},{0x1CD04876L},{4294967290UL},{4294967292UL}},{{0x5737EE3AL},{0x047A8FE5L},{4294967295UL},{0x047A8FE5L},{0x5737EE3AL}}},{{{0xF74D2CBEL},{0x96D7B5C8L},{4294967292UL},{4294967290UL},{0xED0EF6E8L}},{{0UL},{0x96D7B5C8L},{0UL},{0x862BD6E1L},{4294967295UL}},{{0x9F68AA10L},{0x047A8FE5L},{0x42A593A2L},{0x96D7B5C8L},{0xED0EF6E8L}},{{1UL},{0x862BD6E1L},{0x42A593A2L},{4294967295UL},{0x5737EE3AL}},{{0xED0EF6E8L},{0xD9FAFC29L},{0UL},{4294967286UL},{4294967292UL}},{{1UL},{0x2F1FA7C9L},{4294967292UL},{4294967286UL},{0x9F68AA10L}},{{0x9F68AA10L},{0x82D9E9AAL},{4294967295UL},{4294967295UL},{0xCD987159L}}},{{{0UL},{0x2F1FA7C9L},{0x1CD04876L},{0x96D7B5C8L},{0x2F1FA7C9L}},{{0xD9FAFC29L},{0x9CB84A7BL},{0UL},{0xCA130A7DL},{0x96D7B5C8L}},{{0xBB220CBEL},{0xCA130A7DL},{0xC3FBF60AL},{0xEB7DD775L},{4294967295UL}},{{0xBB220CBEL},{2UL},{0UL},{2UL},{0xBB220CBEL}},{{0xD9FAFC29L},{0x02BFDE3DL},{0x91CD86B3L},{0xEB7DD775L},{4294967295UL}},{{4294967286UL},{0x02BFDE3DL},{0UL},{0xCA130A7DL},{0x862BD6E1L}},{{0x96D7B5C8L},{2UL},{4294967288UL},{0x02BFDE3DL},{4294967295UL}}}};
static union U2 g_2243[3] = {{4294967295UL},{4294967295UL},{4294967295UL}};
static int32_t * volatile g_2297 = &g_1519[2].f7;/* VOLATILE GLOBAL g_2297 */
static volatile union U2 g_2299 = {1UL};/* VOLATILE GLOBAL g_2299 */
static volatile union U1 g_2301[9][8][3] = {{{{-2L},{0xB7C0D181L},{-7L}},{{1L},{1L},{0x2B10520EL}},{{1L},{0x301F5196L},{1L}},{{0x148CAC0EL},{2L},{0x148CAC0EL}},{{-2L},{-7L},{1L}},{{1L},{0xC6F27F89L},{0x2B10520EL}},{{0x654ED406L},{1L},{-7L}},{{0xBE8F226BL},{2L},{0x0C5C0EDCL}}},{{{0x654ED406L},{-7L},{0x112C664AL}},{{1L},{1L},{9L}},{{-2L},{-2L},{-7L}},{{0x148CAC0EL},{1L},{0xBE8F226BL}},{{1L},{-7L},{1L}},{{1L},{2L},{1L}},{{-2L},{1L},{1L}},{{1L},{0xC6F27F89L},{0xBE8F226BL}}},{{{0x654ED406L},{-7L},{-7L}},{{0x2B10520EL},{2L},{9L}},{{0x654ED406L},{0x301F5196L},{0x112C664AL}},{{1L},{1L},{0x0C5C0EDCL}},{{-2L},{0xB7C0D181L},{-7L}},{{1L},{1L},{0x2B10520EL}},{{1L},{0x301F5196L},{1L}},{{0x148CAC0EL},{2L},{0x148CAC0EL}}},{{{-2L},{-7L},{1L}},{{1L},{0xC6F27F89L},{0x2B10520EL}},{{0x654ED406L},{1L},{-7L}},{{0xBE8F226BL},{2L},{0x0C5C0EDCL}},{{0x654ED406L},{-7L},{0x112C664AL}},{{1L},{1L},{9L}},{{-2L},{-2L},{-7L}},{{0x148CAC0EL},{1L},{0xBE8F226BL}}},{{{1L},{-7L},{1L}},{{1L},{2L},{1L}},{{-2L},{1L},{1L}},{{1L},{0xC6F27F89L},{0xBE8F226BL}},{{0x654ED406L},{-7L},{-7L}},{{0x2B10520EL},{2L},{9L}},{{0x654ED406L},{0x301F5196L},{0x112C664AL}},{{1L},{1L},{0x0C5C0EDCL}}},{{{-2L},{0xB7C0D181L},{-7L}},{{1L},{1L},{0x2B10520EL}},{{1L},{0x301F5196L},{1L}},{{0x148CAC0EL},{2L},{0x148CAC0EL}},{{-2L},{-7L},{1L}},{{1L},{0xC6F27F89L},{0x2B10520EL}},{{0x654ED406L},{1L},{-7L}},{{0xBE8F226BL},{2L},{0x0C5C0EDCL}}},{{{0x654ED406L},{-7L},{0x112C664AL}},{{1L},{1L},{9L}},{{-2L},{-2L},{-7L}},{{0x148CAC0EL},{1L},{0xBE8F226BL}},{{1L},{0xB7C0D181L},{-7L}},{{9L},{0xC6F27F89L},{9L}},{{1L},{0x654ED406L},{-7L}},{{0xBE8F226BL},{1L},{0x148CAC0EL}}},{{{0xED78ABCCL},{0x112C664AL},{0x112C664AL}},{{1L},{0xC6F27F89L},{0x70BBCC75L}},{{0xED78ABCCL},{-2L},{1L}},{{0xBE8F226BL},{0xA4374E7CL},{0x3E11DB51L}},{{1L},{-7L},{0x112C664AL}},{{9L},{0xA4374E7CL},{1L}},{{0x654ED406L},{-2L},{-7L}},{{0x0C5C0EDCL},{0xC6F27F89L},{0x0C5C0EDCL}}},{{{1L},{0x112C664AL},{-7L}},{{0x2B10520EL},{1L},{1L}},{{0xED78ABCCL},{0x654ED406L},{0x112C664AL}},{{0x148CAC0EL},{0xC6F27F89L},{0x3E11DB51L}},{{0xED78ABCCL},{0xB7C0D181L},{1L}},{{0x2B10520EL},{0xA4374E7CL},{0x70BBCC75L}},{{1L},{1L},{0x112C664AL}},{{0x0C5C0EDCL},{0xA4374E7CL},{0x148CAC0EL}}}};
static uint16_t g_2314 = 0xCC99L;
static uint8_t g_2354 = 246UL;
static uint32_t *g_2360 = &g_615;
static uint32_t **g_2359 = &g_2360;
static const int32_t ** volatile g_2442 = &g_295[0];/* VOLATILE GLOBAL g_2442 */
static const int64_t **g_2449[2] = {(void*)0,(void*)0};
static const int64_t ***g_2448 = &g_2449[0];
static const int64_t **** volatile g_2447 = &g_2448;/* VOLATILE GLOBAL g_2447 */
static volatile union U2 g_2459[6][10][4] = {{{{0xE6D1DCE2L},{7UL},{0xFB25917AL},{4294967286UL}},{{4294967289UL},{0xD866D383L},{4294967290UL},{0xF846B535L}},{{4294967287UL},{0x16DFA061L},{0x9B1E633DL},{4294967294UL}},{{1UL},{0UL},{0xF846B535L},{0x724FCA4AL}},{{9UL},{0xEE35951CL},{0xDED01F73L},{0x2FB97353L}},{{0xEE99F595L},{4294967295UL},{4294967289UL},{4UL}},{{0x60D03FAFL},{0x5C876C23L},{0x5C876C23L},{0x60D03FAFL}},{{0xFB25917AL},{0x7CBA57DAL},{0UL},{0x5FA0D14EL}},{{0xEE35951CL},{4294967286UL},{4294967295UL},{4294967295UL}},{{6UL},{0x6BDADB6AL},{9UL},{4294967295UL}}},{{{0xDED01F73L},{4294967286UL},{0xFEC1E2EEL},{0x5FA0D14EL}},{{4294967287UL},{0x7CBA57DAL},{7UL},{0x60D03FAFL}},{{0UL},{0x5C876C23L},{4294967290UL},{4UL}},{{0UL},{4294967295UL},{0xB66774C8L},{0x2FB97353L}},{{0x49217314L},{0xEE35951CL},{4294967294UL},{0x724FCA4AL}},{{0x117977EBL},{0UL},{0UL},{4294967294UL}},{{0xB66774C8L},{0x16DFA061L},{0UL},{0xF846B535L}},{{0x60D03FAFL},{0xD866D383L},{0x0C930CA2L},{4294967286UL}},{{4294967286UL},{7UL},{0UL},{4294967294UL}},{{0xB66774C8L},{4294967286UL},{0x9D0A11CAL},{0UL}}},{{{4UL},{0xE791D2B2L},{4294967294UL},{8UL}},{{1UL},{0xB270334FL},{0xFEC1E2EEL},{0xA8281872L}},{{0UL},{4294967294UL},{0xFB25917AL},{4294967290UL}},{{0xD866D383L},{1UL},{7UL},{4UL}},{{4294967295UL},{4294967295UL},{0UL},{4294967294UL}},{{0xDED01F73L},{0x724FCA4AL},{0x09C1F61BL},{0xFEC1E2EEL}},{{0x117977EBL},{0xEE99F595L},{4294967295UL},{4294967288UL}},{{0xEE99F595L},{4294967295UL},{0UL},{6UL}},{{0xFB25917AL},{0xD866D383L},{0xF6FA4234L},{4294967290UL}},{{3UL},{0x7CBA57DAL},{4294967289UL},{0xF2B6FA77L}}},{{{0x724FCA4AL},{0xB270334FL},{0x9D0A11CAL},{0UL}},{{9UL},{0xEF04E625L},{9UL},{0UL}},{{0x49217314L},{0x60D03FAFL},{0xE791D2B2L},{0x1E7A2230L}},{{0x09C1F61BL},{7UL},{0x0C930CA2L},{0x5C876C23L}},{{0xB534591BL},{0x892EAC0AL},{0x0C930CA2L},{0x6D410694L}},{{0x09C1F61BL},{0x9D0A11CAL},{0xE791D2B2L},{4294967290UL}},{{0UL},{4294967294UL},{0x88C83675L},{0UL}},{{0x88C83675L},{0UL},{0UL},{5UL}},{{6UL},{0xDED01F73L},{4UL},{7UL}},{{4294967289UL},{4294967295UL},{0x605822E6L},{4294967289UL}}},{{{0x0CEC4985L},{0xB270334FL},{0x8C3E9A09L},{4294967290UL}},{{0UL},{0x5C876C23L},{4294967287UL},{0xB66774C8L}},{{7UL},{0xED42FBF8L},{1UL},{0UL}},{{6UL},{4294967289UL},{4294967294UL},{4294967290UL}},{{0x09C1F61BL},{4294967290UL},{0UL},{0xF6FA4234L}},{{0UL},{4294967295UL},{0x0CEC4985L},{0x2FB97353L}},{{0x8C3E9A09L},{0x9D0A11CAL},{0UL},{5UL}},{{0UL},{6UL},{0x7CBA57DAL},{0x6BDADB6AL}},{{6UL},{4294967294UL},{0UL},{0xFB25917AL}},{{4294967295UL},{0UL},{0x8C3E9A09L},{0x6D410694L}}},{{{0xF6FA4234L},{0x7F80F509L},{0UL},{4294967289UL}},{{0x5C876C23L},{7UL},{4294967294UL},{4294967295UL}},{{4294967295UL},{4294967289UL},{4294967289UL},{0x8DE7B599L}},{{7UL},{0x5FA0D14EL},{0x7CBA57DAL},{0xFEC1E2EEL}},{{0UL},{0x0C930CA2L},{4294967295UL},{1UL}},{{0x8C3E9A09L},{4294967290UL},{1UL},{1UL}},{{0x892EAC0AL},{0x892EAC0AL},{0UL},{7UL}},{{9UL},{4294967295UL},{0UL},{0xFB25917AL}},{{6UL},{0x6BDADB6AL},{0x88C83675L},{0UL}},{{0x2FB97353L},{0x6BDADB6AL},{4294967287UL},{0xFB25917AL}}}};
static volatile int32_t g_2482 = 0x2D49A1DCL;/* VOLATILE GLOBAL g_2482 */
static int32_t ** volatile g_2506[3] = {&g_50,&g_50,&g_50};
static int32_t **g_2524 = &g_50;
static union U1 g_2528 = {2L};/* VOLATILE GLOBAL g_2528 */
static union U1 g_2623 = {0x03BB3D9FL};/* VOLATILE GLOBAL g_2623 */
static const volatile union U1 g_2643 = {0x53002D1CL};/* VOLATILE GLOBAL g_2643 */
static union U1 g_2654 = {0x771DF8A8L};/* VOLATILE GLOBAL g_2654 */
static struct S0 g_2677[7][7][5] = {{{{0xE8858CB6L,0xB80F3E1AL,2,0x2DB41994L,0x6022BA90L,18446744073709551615UL,255UL,0x64A03CB3L},{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL},{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL},{0x71A16387L,0x931BCF9EL,5,-1L,0UL,18446744073709551614UL,0x3FL,0xEAAD976FL},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L}},{{0L,0x355AC819L,7,0x4AE29F24L,0x3C269A97L,1UL,0xBAL,0L},{0x71A16387L,0x931BCF9EL,5,-1L,0UL,18446744073709551614UL,0x3FL,0xEAAD976FL},{-1L,1L,10,-4L,0UL,0x36262290L,247UL,0x972949ECL},{0x71A16387L,0x931BCF9EL,5,-1L,0UL,18446744073709551614UL,0x3FL,0xEAAD976FL},{0L,0x355AC819L,7,0x4AE29F24L,0x3C269A97L,1UL,0xBAL,0L}},{{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L},{-9L,0x4D2EE493L,6,0xD2D24C74L,0UL,0x4CC985DBL,255UL,0x9B72D59EL},{0xF18C126EL,-3L,7,0x497A91B7L,6UL,2UL,1UL,0x49D15530L},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{-9L,3L,5,0L,0x23761B7EL,0xD52667B5L,3UL,0x989FC93AL}},{{-5L,0x293CE7BAL,2,0x95AC9526L,0UL,0x60A982CDL,0x93L,0L},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL},{-5L,0x293CE7BAL,2,0x95AC9526L,0UL,0x60A982CDL,0x93L,0L},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L}},{{0x71A16387L,0x931BCF9EL,5,-1L,0UL,18446744073709551614UL,0x3FL,0xEAAD976FL},{3L,0x21722F51L,1,-1L,8UL,0UL,0xDFL,0x00BC7E5EL},{-1L,1L,10,-4L,0UL,0x36262290L,247UL,0x972949ECL},{-9L,0x4D2EE493L,6,0xD2D24C74L,0UL,0x4CC985DBL,255UL,0x9B72D59EL},{-9L,3L,5,0L,0x23761B7EL,0xD52667B5L,3UL,0x989FC93AL}},{{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL},{-5L,0x293CE7BAL,2,0x95AC9526L,0UL,0x60A982CDL,0x93L,0L},{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L},{0L,0x355AC819L,7,0x4AE29F24L,0x3C269A97L,1UL,0xBAL,0L}},{{-9L,3L,5,0L,0x23761B7EL,0xD52667B5L,3UL,0x989FC93AL},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{-1L,1L,10,0x192A03CAL,1UL,0UL,0x39L,-1L},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L}}},{{{-9L,3L,5,0L,0x23761B7EL,0xD52667B5L,3UL,0x989FC93AL},{-9L,3L,5,0L,0x23761B7EL,0xD52667B5L,3UL,0x989FC93AL},{0x4AF40AE5L,0x38D8B1EAL,6,9L,4294967295UL,0x91691B46L,0xEDL,0xD1167201L},{3L,0x21722F51L,1,-1L,8UL,0UL,0xDFL,0x00BC7E5EL},{0xE8858CB6L,0xB80F3E1AL,2,0x2DB41994L,0x6022BA90L,18446744073709551615UL,255UL,0x64A03CB3L}},{{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL},{0L,0x23D4672CL,5,0x039BA8A3L,0xD1982CCBL,0xFB92599DL,0UL,1L},{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{0L,0x23D4672CL,5,0x039BA8A3L,0xD1982CCBL,0xFB92599DL,0UL,1L}},{{0x71A16387L,0x931BCF9EL,5,-1L,0UL,18446744073709551614UL,0x3FL,0xEAAD976FL},{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL},{0x86A8F67BL,0L,2,1L,0xE64D0FDFL,0xD2126AA4L,0xE2L,0xBED1E14BL},{0L,0x23D4672CL,5,0x039BA8A3L,0xD1982CCBL,0xFB92599DL,0UL,1L},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L}},{{-5L,0x293CE7BAL,2,0x95AC9526L,0UL,0x60A982CDL,0x93L,0L},{0L,0x23D4672CL,5,0x039BA8A3L,0xD1982CCBL,0xFB92599DL,0UL,1L},{-1L,1L,10,-4L,0UL,0x36262290L,247UL,0x972949ECL},{0xE8858CB6L,0xB80F3E1AL,2,0x2DB41994L,0x6022BA90L,18446744073709551615UL,255UL,0x64A03CB3L},{3L,0x21722F51L,1,-1L,8UL,0UL,0xDFL,0x00BC7E5EL}},{{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L},{-9L,3L,5,0L,0x23761B7EL,0xD52667B5L,3UL,0x989FC93AL},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{-1L,1L,10,0x192A03CAL,1UL,0UL,0x39L,-1L}},{{0L,0x355AC819L,7,0x4AE29F24L,0x3C269A97L,1UL,0xBAL,0L},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{0L,0x355AC819L,7,0x4AE29F24L,0x3C269A97L,1UL,0xBAL,0L},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L}},{{0xE8858CB6L,0xB80F3E1AL,2,0x2DB41994L,0x6022BA90L,18446744073709551615UL,255UL,0x64A03CB3L},{-5L,0x293CE7BAL,2,0x95AC9526L,0UL,0x60A982CDL,0x93L,0L},{-1L,1L,10,-4L,0UL,0x36262290L,247UL,0x972949ECL},{-9L,3L,5,0L,0x23761B7EL,0xD52667B5L,3UL,0x989FC93AL},{-9L,0x4D2EE493L,6,0xD2D24C74L,0UL,0x4CC985DBL,255UL,0x9B72D59EL}}},{{{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL},{3L,0x21722F51L,1,-1L,8UL,0UL,0xDFL,0x00BC7E5EL},{0x86A8F67BL,0L,2,1L,0xE64D0FDFL,0xD2126AA4L,0xE2L,0xBED1E14BL},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L},{-5L,0x293CE7BAL,2,0x95AC9526L,0UL,0x60A982CDL,0x93L,0L}},{{-9L,0x4D2EE493L,6,0xD2D24C74L,0UL,0x4CC985DBL,255UL,0x9B72D59EL},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{-4L,0x93DEFBE4L,7,0L,7UL,0x041014A4L,0x18L,0L},{0x86A8F67BL,0L,2,1L,0xE64D0FDFL,0xD2126AA4L,0xE2L,0xBED1E14BL},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L}},{{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L},{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL},{-1L,1L,10,0x192A03CAL,1UL,0UL,0x39L,-1L},{0xF18C126EL,-3L,7,0x497A91B7L,6UL,2UL,1UL,0x49D15530L},{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L}},{{0L,-6L,2,0x809049D2L,0x2C4C197AL,1UL,254UL,0xE09DD082L},{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L},{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L}},{{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{-1L,1L,10,-4L,0UL,0x36262290L,247UL,0x972949ECL},{-9L,0xABEB8DA1L,5,0xCDA36951L,0x786DBC4EL,0UL,0xA7L,0x28B3C913L},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L}},{{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L},{-9L,0x4D2EE493L,6,0xD2D24C74L,0UL,0x4CC985DBL,255UL,0x9B72D59EL},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL}},{{-9L,0xABEB8DA1L,5,0xCDA36951L,0x786DBC4EL,0UL,0xA7L,0x28B3C913L},{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L},{-1L,1L,10,-4L,0UL,0x36262290L,247UL,0x972949ECL},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L},{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL}}},{{{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{0x7222805CL,0xED00D7A6L,4,-2L,1UL,1UL,0x53L,0x673DE950L},{0x4AF40AE5L,0x38D8B1EAL,6,9L,4294967295UL,0x91691B46L,0xEDL,0xD1167201L},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{0x9514AF2EL,-1L,7,1L,0xBE8588BAL,0x166A5DB4L,0UL,0x25E56045L}},{{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{0xF18C126EL,-3L,7,0x497A91B7L,6UL,2UL,1UL,0x49D15530L},{-9L,0x4D2EE493L,6,0xD2D24C74L,0UL,0x4CC985DBL,255UL,0x9B72D59EL},{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L},{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L}},{{0L,-6L,2,0x809049D2L,0x2C4C197AL,1UL,254UL,0xE09DD082L},{0xF18C126EL,-3L,7,0x497A91B7L,6UL,2UL,1UL,0x49D15530L},{0L,-6L,2,0x809049D2L,0x2C4C197AL,1UL,254UL,0xE09DD082L},{0x9514AF2EL,-1L,7,1L,0xBE8588BAL,0x166A5DB4L,0UL,0x25E56045L},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L}},{{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L},{0x7222805CL,0xED00D7A6L,4,-2L,1UL,1UL,0x53L,0x673DE950L},{0x9514AF2EL,-1L,7,1L,0xBE8588BAL,0x166A5DB4L,0UL,0x25E56045L},{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L}},{{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL},{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L},{-1L,1L,10,0x192A03CAL,1UL,0UL,0x39L,-1L},{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L}},{{0L,-6L,2,0x809049D2L,0x2C4C197AL,1UL,254UL,0xE09DD082L},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L},{0x9514AF2EL,-1L,7,1L,0xBE8588BAL,0x166A5DB4L,0UL,0x25E56045L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L}},{{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L},{-1L,1L,10,-4L,0UL,0x36262290L,247UL,0x972949ECL},{0L,-6L,2,0x809049D2L,0x2C4C197AL,1UL,254UL,0xE09DD082L},{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L}}},{{{0xF18C126EL,-3L,7,0x497A91B7L,6UL,2UL,1UL,0x49D15530L},{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L},{-9L,0x4D2EE493L,6,0xD2D24C74L,0UL,0x4CC985DBL,255UL,0x9B72D59EL},{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L},{0xF18C126EL,-3L,7,0x497A91B7L,6UL,2UL,1UL,0x49D15530L}},{{-9L,0xABEB8DA1L,5,0xCDA36951L,0x786DBC4EL,0UL,0xA7L,0x28B3C913L},{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL},{0x4AF40AE5L,0x38D8B1EAL,6,9L,4294967295UL,0x91691B46L,0xEDL,0xD1167201L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L},{0x86A8F67BL,0L,2,1L,0xE64D0FDFL,0xD2126AA4L,0xE2L,0xBED1E14BL}},{{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL},{0x7222805CL,0xED00D7A6L,4,-2L,1UL,1UL,0x53L,0x673DE950L},{-1L,1L,10,-4L,0UL,0x36262290L,247UL,0x972949ECL},{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL},{0x9514AF2EL,-1L,7,1L,0xBE8588BAL,0x166A5DB4L,0UL,0x25E56045L}},{{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{-9L,0x4D2EE493L,6,0xD2D24C74L,0UL,0x4CC985DBL,255UL,0x9B72D59EL},{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL},{0x86A8F67BL,0L,2,1L,0xE64D0FDFL,0xD2126AA4L,0xE2L,0xBED1E14BL}},{{0L,-6L,2,0x809049D2L,0x2C4C197AL,1UL,254UL,0xE09DD082L},{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL},{-9L,0xABEB8DA1L,5,0xCDA36951L,0x786DBC4EL,0UL,0xA7L,0x28B3C913L},{0x9514AF2EL,-1L,7,1L,0xBE8588BAL,0x166A5DB4L,0UL,0x25E56045L},{0xF18C126EL,-3L,7,0x497A91B7L,6UL,2UL,1UL,0x49D15530L}},{{0x86A8F67BL,0L,2,1L,0xE64D0FDFL,0xD2126AA4L,0xE2L,0xBED1E14BL},{0x7222805CL,0xED00D7A6L,4,-2L,1UL,1UL,0x53L,0x673DE950L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L},{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L}},{{0x86A8F67BL,0L,2,1L,0xE64D0FDFL,0xD2126AA4L,0xE2L,0xBED1E14BL},{0x86A8F67BL,0L,2,1L,0xE64D0FDFL,0xD2126AA4L,0xE2L,0xBED1E14BL},{-1L,1L,10,0x192A03CAL,1UL,0UL,0x39L,-1L},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L}}},{{{0L,-6L,2,0x809049D2L,0x2C4C197AL,1UL,254UL,0xE09DD082L},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{-4L,0x93DEFBE4L,7,0L,7UL,0x041014A4L,0x18L,0L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L}},{{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L},{-1L,1L,10,-4L,0UL,0x36262290L,247UL,0x972949ECL},{0x88CA3201L,-1L,5,5L,4294967288UL,0x23049954L,0x7FL,0L},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L}},{{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{-9L,0x4D2EE493L,6,0xD2D24C74L,0UL,0x4CC985DBL,255UL,0x9B72D59EL},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L}},{{-9L,0xABEB8DA1L,5,0xCDA36951L,0x786DBC4EL,0UL,0xA7L,0x28B3C913L},{0x86A8F67BL,0L,2,1L,0xE64D0FDFL,0xD2126AA4L,0xE2L,0xBED1E14BL},{0x7222805CL,0xED00D7A6L,4,-2L,1UL,1UL,0x53L,0x673DE950L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L},{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L}},{{0xF18C126EL,-3L,7,0x497A91B7L,6UL,2UL,1UL,0x49D15530L},{0x7222805CL,0xED00D7A6L,4,-2L,1UL,1UL,0x53L,0x673DE950L},{0x7222805CL,0xED00D7A6L,4,-2L,1UL,1UL,0x53L,0x673DE950L},{0xF18C126EL,-3L,7,0x497A91B7L,6UL,2UL,1UL,0x49D15530L},{0x9514AF2EL,-1L,7,1L,0xBE8588BAL,0x166A5DB4L,0UL,0x25E56045L}},{{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L},{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL},{-9L,0x4D2EE493L,6,0xD2D24C74L,0UL,0x4CC985DBL,255UL,0x9B72D59EL},{0x86A8F67BL,0L,2,1L,0xE64D0FDFL,0xD2126AA4L,0xE2L,0xBED1E14BL},{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL}},{{0L,-6L,2,0x809049D2L,0x2C4C197AL,1UL,254UL,0xE09DD082L},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{0x88CA3201L,-1L,5,5L,4294967288UL,0x23049954L,0x7FL,0L},{0x9514AF2EL,-1L,7,1L,0xBE8588BAL,0x166A5DB4L,0UL,0x25E56045L},{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL}}},{{{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL},{0x7222805CL,0xED00D7A6L,4,-2L,1UL,1UL,0x53L,0x673DE950L},{-4L,0x93DEFBE4L,7,0L,7UL,0x041014A4L,0x18L,0L},{0x86A8F67BL,0L,2,1L,0xE64D0FDFL,0xD2126AA4L,0xE2L,0xBED1E14BL},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L}},{{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L},{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL},{-1L,1L,10,0x192A03CAL,1UL,0UL,0x39L,-1L},{0xF18C126EL,-3L,7,0x497A91B7L,6UL,2UL,1UL,0x49D15530L},{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L}},{{0L,-6L,2,0x809049D2L,0x2C4C197AL,1UL,254UL,0xE09DD082L},{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L},{0xC6212031L,-2L,10,0x67FB125DL,0x65935FEBL,0x458797F9L,0UL,-8L}},{{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{-1L,1L,10,-4L,0UL,0x36262290L,247UL,0x972949ECL},{-9L,0xABEB8DA1L,5,0xCDA36951L,0x786DBC4EL,0UL,0xA7L,0x28B3C913L},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L}},{{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{1L,0x949A2340L,5,0L,0UL,0UL,0xFFL,-3L},{-9L,0x4D2EE493L,6,0xD2D24C74L,0UL,0x4CC985DBL,255UL,0x9B72D59EL},{1L,0xD59815A1L,7,0x06755497L,0x3501C001L,4UL,0x99L,-7L},{7L,0x09EEECBDL,6,0x12140DE0L,1UL,0xB225A40BL,255UL,0x90CD9E6EL}},{{-9L,0xABEB8DA1L,5,0xCDA36951L,0x786DBC4EL,0UL,0xA7L,0x28B3C913L},{0L,0x1EE7C0A9L,0,0xF6FAEF2FL,0xFAF9D705L,0x3ECED3A1L,0x50L,0x9A143696L},{-1L,1L,10,-4L,0UL,0x36262290L,247UL,0x972949ECL},{0x6F108924L,0xC514640FL,8,0xD1312DABL,0xD6B1A9F7L,0x04EEF062L,1UL,0xE431A197L},{0x4CF00D56L,0x85CB342EL,9,0x78CA26CCL,0x4465DC90L,0x280773D2L,1UL,0x2C45B6FCL}},{{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{0x7222805CL,0xED00D7A6L,4,-2L,1UL,1UL,0x53L,0x673DE950L},{0x4AF40AE5L,0x38D8B1EAL,6,9L,4294967295UL,0x91691B46L,0xEDL,0xD1167201L},{0xCE2E570BL,3L,1,-1L,0x7FA6DCE1L,18446744073709551606UL,0xF7L,0x2C37B847L},{0x9514AF2EL,-1L,7,1L,0xBE8588BAL,0x166A5DB4L,0UL,0x25E56045L}}}};
static uint16_t *g_2685 = &g_204[0];
static uint16_t **g_2684 = &g_2685;
static volatile union U2 g_2696 = {0x1D1D6CDEL};/* VOLATILE GLOBAL g_2696 */
static union U1 g_2704[5][1] = {{{0L}},{{0L}},{{0L}},{{0L}},{{0L}}};
static struct S0 * const volatile * volatile * volatile *g_2721 = (void*)0;
static struct S0 * const volatile * volatile * volatile ** volatile g_2720 = &g_2721;/* VOLATILE GLOBAL g_2720 */
static union U2 g_2727 = {0x0E36B506L};/* VOLATILE GLOBAL g_2727 */
static struct S0 g_2745 = {-5L,4L,9,1L,0UL,0x1E65DF92L,255UL,0x9663B89BL};/* VOLATILE GLOBAL g_2745 */
static int32_t * volatile g_2759 = &g_2211.f0;/* VOLATILE GLOBAL g_2759 */
static struct S0 g_2864 = {0x830A0202L,0x6F92EC2DL,7,0L,0x6439B693L,0x0EDA5925L,254UL,0x34195E41L};/* VOLATILE GLOBAL g_2864 */
static uint64_t ** volatile *g_2867[3][9] = {{&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256},{(void*)0,&g_1256,(void*)0,(void*)0,&g_1256,(void*)0,(void*)0,&g_1256,(void*)0},{&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256,&g_1256}};
static uint64_t ** volatile **g_2866 = &g_2867[2][1];
static uint64_t ** volatile ** volatile *g_2865 = &g_2866;
static int64_t g_2917 = (-1L);
static union U2 g_2937 = {0x7BBECD22L};/* VOLATILE GLOBAL g_2937 */
static volatile union U1 g_2944 = {-1L};/* VOLATILE GLOBAL g_2944 */
static struct S0 ****g_3005[3][5] = {{&g_965,&g_965,&g_965,(void*)0,&g_965},{&g_965,&g_965,&g_965,&g_965,&g_965},{&g_965,(void*)0,(void*)0,(void*)0,(void*)0}};
static uint64_t g_3025 = 4UL;
static volatile union U1 g_3045 = {9L};/* VOLATILE GLOBAL g_3045 */
static volatile struct S0 g_3088 = {0L,0x6AEF7C18L,7,-1L,2UL,4UL,0x6DL,0x68A6D2B8L};/* VOLATILE GLOBAL g_3088 */
static volatile uint32_t *g_3116[10][5] = {{(void*)0,&g_2023.f5,(void*)0,&g_2023.f5,(void*)0},{&g_2023.f5,&g_2023.f5,(void*)0,(void*)0,&g_2023.f5},{&g_1720[4][5].f5,&g_2023.f5,&g_1720[4][5].f5,&g_2023.f5,&g_1720[4][5].f5},{&g_2023.f5,(void*)0,(void*)0,&g_2023.f5,&g_2023.f5},{(void*)0,&g_2023.f5,(void*)0,&g_2023.f5,(void*)0},{&g_2023.f5,&g_2023.f5,(void*)0,(void*)0,&g_2023.f5},{&g_1720[4][5].f5,&g_2023.f5,&g_1720[4][5].f5,&g_2023.f5,&g_1720[4][5].f5},{&g_2023.f5,(void*)0,(void*)0,&g_2023.f5,&g_2023.f5},{(void*)0,&g_2023.f5,(void*)0,&g_2023.f5,(void*)0},{&g_2023.f5,&g_2023.f5,(void*)0,(void*)0,&g_2023.f5}};
static volatile uint32_t * volatile *g_3115 = &g_3116[2][1];
static volatile uint32_t * volatile ** volatile g_3117[7][7] = {{(void*)0,&g_3115,&g_3115,&g_3115,&g_3115,&g_3115,(void*)0},{(void*)0,&g_3115,&g_3115,&g_3115,&g_3115,&g_3115,(void*)0},{(void*)0,&g_3115,&g_3115,&g_3115,&g_3115,&g_3115,(void*)0},{(void*)0,&g_3115,&g_3115,&g_3115,&g_3115,&g_3115,(void*)0},{(void*)0,&g_3115,&g_3115,&g_3115,&g_3115,&g_3115,(void*)0},{(void*)0,&g_3115,&g_3115,&g_3115,&g_3115,&g_3115,(void*)0},{(void*)0,&g_3115,&g_3115,&g_3115,&g_3115,&g_3115,(void*)0}};
static volatile uint32_t * volatile ** volatile g_3118 = (void*)0;/* VOLATILE GLOBAL g_3118 */
static struct S0 g_3125[9] = {{0x238D8E58L,0L,5,-1L,9UL,0x47EAB6B2L,0x42L,-1L},{0x238D8E58L,0L,5,-1L,9UL,0x47EAB6B2L,0x42L,-1L},{0x238D8E58L,0L,5,-1L,9UL,0x47EAB6B2L,0x42L,-1L},{0x238D8E58L,0L,5,-1L,9UL,0x47EAB6B2L,0x42L,-1L},{0x238D8E58L,0L,5,-1L,9UL,0x47EAB6B2L,0x42L,-1L},{0x238D8E58L,0L,5,-1L,9UL,0x47EAB6B2L,0x42L,-1L},{0x238D8E58L,0L,5,-1L,9UL,0x47EAB6B2L,0x42L,-1L},{0x238D8E58L,0L,5,-1L,9UL,0x47EAB6B2L,0x42L,-1L},{0x238D8E58L,0L,5,-1L,9UL,0x47EAB6B2L,0x42L,-1L}};
static volatile uint64_t g_3131 = 0UL;/* VOLATILE GLOBAL g_3131 */
static volatile union U2 g_3132 = {1UL};/* VOLATILE GLOBAL g_3132 */
static const volatile struct S0 g_3143 = {0xBE5108E4L,1L,8,4L,1UL,0xE90F8CE6L,0x53L,0x12C769C2L};/* VOLATILE GLOBAL g_3143 */
static uint32_t g_3223 = 0xFEA26E47L;
static const int32_t **g_3245 = &g_295[0];
static const int32_t ***g_3244[5][10] = {{&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245},{&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245},{&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245},{&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245},{&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245,&g_3245}};
static int32_t **g_3256[3][8][6] = {{{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{(void*)0,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50}},{{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50}},{{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50},{&g_50,&g_50,&g_50,&g_50,&g_50,&g_50}}};
static union U2 g_3258 = {0x6FB77FE4L};/* VOLATILE GLOBAL g_3258 */
static const volatile union U1 g_3259 = {0x1DDBF166L};/* VOLATILE GLOBAL g_3259 */
static struct S0 g_3284 = {0x171E6BE4L,0x0AA1C8E0L,8,0xE08F4A4FL,4294967286UL,0UL,0x1FL,-1L};/* VOLATILE GLOBAL g_3284 */
static int64_t ***g_3289 = (void*)0;
static int64_t ****g_3288[6] = {&g_3289,&g_3289,&g_3289,&g_3289,&g_3289,&g_3289};
static volatile union U1 g_3291 = {0x08807019L};/* VOLATILE GLOBAL g_3291 */
static union U2 g_3320 = {0x2A626501L};/* VOLATILE GLOBAL g_3320 */
static volatile int8_t g_3336 = 1L;/* VOLATILE GLOBAL g_3336 */
static int8_t *g_3347 = (void*)0;
static volatile uint64_t g_3361 = 0x78DAE3A0F87BB258LL;/* VOLATILE GLOBAL g_3361 */
static int32_t g_3369 = 0xFABC1084L;
static uint64_t * volatile * volatile g_3381 = &g_158;/* VOLATILE GLOBAL g_3381 */
static uint64_t * volatile * volatile *g_3380 = &g_3381;
static uint64_t * volatile * volatile * volatile * volatile g_3379[9][3] = {{&g_3380,&g_3380,&g_3380},{(void*)0,&g_3380,&g_3380},{&g_3380,&g_3380,&g_3380},{&g_3380,(void*)0,&g_3380},{&g_3380,&g_3380,&g_3380},{&g_3380,&g_3380,&g_3380},{&g_3380,&g_3380,&g_3380},{&g_3380,&g_3380,&g_3380},{(void*)0,&g_3380,&g_3380}};
/* --- FORWARD DECLARATIONS --- */
static int64_t func_1(void);
static int32_t * func_2(int8_t p_3, int32_t * p_4);
static union U2 func_6(const int32_t * p_7, int32_t * p_8);
static int64_t func_14(uint16_t p_15, int8_t p_16);
static const union U2 func_40(union U2 * p_41, uint8_t p_42, int32_t ** p_43, uint16_t p_44);
static union U2 * func_45(uint32_t p_46);
static union U1 func_47(int32_t ** p_48);
static union U2 ** func_53(const int32_t ** const p_54, uint8_t p_55, union U2 ** p_56);
static int64_t func_58(int32_t p_59, const int32_t * p_60, union U2 ** p_61, int32_t p_62, uint16_t p_63);
static uint64_t func_68(uint8_t * p_69, uint32_t p_70, uint32_t p_71, uint64_t p_72);
/* --- FUNCTIONS --- */
/* ------------------------------------------ */
/*
* reads : g_11 g_1520.f5 g_1529.f3 g_204 g_215 g_216 g_1525.f6 g_82 g_50 g_1522.f4 g_1523.f3 g_1126 g_1524.f3 g_480 g_1368.f3 g_1111.f1 g_1838 g_21 g_1527.f3 g_158 g_1981 g_1983 g_357 g_1524.f7 g_1165 g_878.f4 g_1526.f0 g_276.f3 g_1708 g_1416 g_1421 g_412.f0 g_159 g_673 g_334.f2 g_587 g_295 g_1341.f1 g_276.f1 g_128 g_1368.f4 g_967 g_968 g_209.f2 g_276.f7 g_1368.f6 g_551 g_552 g_1459 g_1485 g_724.f0 g_1501 g_1218.f1 g_1368.f7 g_615 g_1521.f5 g_1525.f3 g_1549 g_878.f2 g_1564 g_724.f1 g_1218.f2 g_85 g_1522.f0 g_1222 g_1527.f7 g_126 g_1526.f5 g_1143 g_1082 g_1107 g_1529 g_1646 g_1521.f3 g_1653 g_553 g_848.f1 g_827 g_276.f5 g_1564.f0 g_1520.f6 g_1523.f0 g_1720 g_1730 g_412 g_965 g_966 g_279 g_1501.f1 g_152 g_1524.f0 g_1520.f0 g_366 g_2005 g_2006 g_149 g_2023 g_1416.f0 g_3245 g_3379
* writes: g_21 g_22 g_1520.f5 g_1165 g_126 g_204 g_1523.f7 g_1526.f7 g_1529.f7 g_1111.f0 g_480 g_1111.f1 g_968.f1 g_1527.f3 g_159 g_1979 g_1981 g_1524.f7 g_878.f4 g_276.f3 g_1485.f4 g_1519.f1 g_1522.f5 g_1523.f5 g_1341.f1 g_276.f1 g_1082 g_1218.f1 g_412.f0 g_357 g_209.f4 g_366 g_276.f7 g_152 g_848.f1 g_827 g_1131.f0 g_50 g_279 g_149 g_1527.f5 g_1416.f0 g_1033 g_295 g_49
*/
static int64_t func_1(void)
{ /* block id: 0 */
uint8_t l_5 = 0x69L;
const int32_t *l_10 = &g_11[0][0][5];
const int32_t **l_9 = &l_10;
int32_t *l_1966 = &g_1524[1].f7;
int32_t *l_2007 = &g_1416.f0;
int32_t **l_2008 = &l_1966;
uint64_t ***l_3378 = &g_1256;
uint64_t ****l_3377 = &l_3378;
uint64_t ****l_3384 = &l_3378;
int16_t *l_3394 = &g_480;
int32_t *l_3396 = &g_2243[1].f4;
int32_t *l_3397 = &g_3125[8].f7;
int32_t *l_3398[9][3][7] = {{{&g_2745.f3,&g_2654.f0,(void*)0,&g_2745.f3,&g_276.f1,&g_1524[1].f7,(void*)0},{&g_1520.f7,&g_2241[0][4][1].f4,(void*)0,&g_2677[4][3][3].f3,(void*)0,&g_3125[8].f1,&g_2704[4][0].f0},{&g_2677[4][3][3].f3,&g_366,&g_1775[2].f4,(void*)0,&g_968[1].f3,(void*)0,&g_21}},{{&g_1527.f3,&g_1775[2].f4,&g_1485.f4,(void*)0,&g_209.f4,&g_1983[4][1][3].f7,(void*)0},{&g_2727.f4,&g_1131.f0,&g_1485.f4,&g_1522.f7,(void*)0,&g_1983[4][1][3].f1,&g_1519[2].f7},{&g_2654.f0,&g_1522.f7,&g_2745.f3,(void*)0,&g_3125[8].f7,&g_968[1].f7,&g_2677[4][3][3].f7}},{{&g_2864.f7,&g_1519[2].f7,(void*)0,(void*)0,&g_2864.f3,&g_1527.f3,&g_2211.f0},{&g_1520.f7,(void*)0,&g_2677[4][3][3].f7,&g_2864.f3,&g_1524[1].f7,&g_2864.f3,&g_2677[4][3][3].f7},{&g_3125[8].f1,&g_3125[8].f1,&g_968[1].f7,&g_2654.f0,&g_276.f1,(void*)0,(void*)0}},{{&g_1529[0][4][5].f3,&g_1519[2].f7,(void*)0,&g_3125[8].f7,&g_2745.f1,&g_1380.f0,&g_412.f0},{&g_2745.f7,&g_1529[0][4][5].f3,&g_1522.f7,&g_1983[4][1][3].f7,&g_276.f1,&g_412.f0,&g_1519[2].f1},{(void*)0,&g_1520.f7,(void*)0,&g_1218.f4,&g_1524[1].f7,(void*)0,&g_1131.f0}},{{&g_2677[4][3][3].f3,&g_1775[2].f4,&g_1520.f7,&g_276.f1,&g_2864.f3,&g_1521.f1,&g_1529[0][4][5].f3},{&g_2745.f7,&g_412.f0,(void*)0,&g_1522.f7,&g_3125[8].f7,&g_1519[2].f1,&g_21},{&g_3125[8].f7,&g_2937.f4,(void*)0,&g_1522.f7,(void*)0,&g_968[1].f7,(void*)0}},{{(void*)0,&g_21,&g_1983[4][1][3].f7,&g_1524[1].f7,&g_209.f4,&g_1519[2].f7,(void*)0},{&g_1520.f7,&g_2211.f0,&g_1983[4][1][3].f1,&g_1983[4][1][3].f7,(void*)0,&g_276.f7,&g_21},{&g_2211.f0,&g_1218.f4,&g_968[1].f7,&g_1529[0][4][5].f3,&g_2937.f4,&g_2745.f3,&g_1529[0][4][5].f3}},{{&g_412.f0,&g_2677[4][3][3].f7,&g_1527.f3,(void*)0,&g_2745.f1,&g_2745.f7,&g_1131.f0},{&g_2727.f4,(void*)0,&g_2864.f3,&g_2864.f3,(void*)0,&g_2727.f4,&g_1519[2].f1},{&g_276.f1,&g_3125[8].f7,(void*)0,&g_276.f3,&g_2211.f0,&g_2745.f3,&g_412.f0}},{{&g_1983[4][1][3].f7,&g_1775[2].f4,&g_1380.f0,&g_2937.f4,&g_1983[4][1][3].f7,&g_1521.f1,(void*)0},{&g_1485.f4,&g_3125[8].f7,&g_412.f0,&g_1522.f7,(void*)0,&g_21,&g_2677[4][3][3].f7},{&g_1131.f0,(void*)0,(void*)0,&g_1983[4][1][3].f7,&g_1520.f7,&g_968[1].f7,&g_2211.f0}},{{&g_1218.f4,&g_2677[4][3][3].f7,&g_1521.f1,&g_2211.f0,&g_1983[4][1][3].f7,&g_1775[2].f4,&g_2677[4][3][3].f7},{&g_1520.f7,&g_1218.f4,&g_1519[2].f1,&g_209.f4,&g_1520.f7,&g_2745.f1,&g_1519[2].f7},{&g_2677[4][3][3].f7,&g_2211.f0,&g_968[1].f7,&g_1520.f7,&g_1983[4][1][3].f7,(void*)0,(void*)0}}};
uint16_t l_3399 = 0x879EL;
int i, j, k;
(*g_3245) = func_2(l_5, (func_6(((*l_9) = (void*)0), ((safe_mod_func_uint64_t_u_u(0x2DDFDAF0B56FE18BLL, func_14(g_11[0][1][2], g_11[0][7][4]))) , l_1966)) , ((*l_2008) = l_2007)));
if (g_1501.f1)
goto lbl_3395;
lbl_3395:
(*l_1966) = (safe_mul_func_uint8_t_u_u(((((+(l_3377 == g_3379[5][2])) | ((safe_sub_func_uint64_t_u_u((*l_2007), (l_3384 == &l_3378))) & (safe_rshift_func_int8_t_s_s(((!((((void*)0 != &g_2685) > (safe_sub_func_uint32_t_u_u((safe_mul_func_int16_t_s_s(((*l_3394) |= (safe_lshift_func_int8_t_s_u((((*g_158) & (*l_2007)) & (*l_2007)), 0))), g_357)), 0x830FF19BL))) ^ (*l_1966))) ^ (*l_1966)), (**l_2008))))) , g_1165) & (*l_2007)), (**l_2008)));
++l_3399;
return (**l_2008);
}
/* ------------------------------------------ */
/*
* reads : g_149 g_215 g_216 g_279 g_2023 g_1416.f0
* writes: g_149 g_49 g_1416.f0 g_50
*/
static int32_t * func_2(int8_t p_3, int32_t * p_4)
{ /* block id: 925 */
uint32_t l_2013 = 0x89F8139FL;
uint64_t l_2016 = 0x663D83FAE531C9E7LL;
int8_t l_2017[1][6][1] = {{{(-6L)},{(-1L)},{(-6L)},{(-1L)},{(-6L)},{(-1L)}}};
const uint8_t *l_2022 = (void*)0;
const int32_t *l_2036[9] = {&g_1983[4][1][3].f7,&g_1983[4][1][3].f7,&g_1983[4][1][3].f7,&g_1983[4][1][3].f7,&g_1983[4][1][3].f7,&g_1983[4][1][3].f7,&g_1983[4][1][3].f7,&g_1983[4][1][3].f7,&g_1983[4][1][3].f7};
int32_t l_2099 = 0xE435CB93L;
int32_t l_2106[8][7] = {{0xD016B272L,0x7675F052L,3L,0x7675F052L,0xD016B272L,0xD016B272L,0x7675F052L},{(-1L),(-1L),7L,(-4L),(-1L),(-7L),(-10L)},{0x58507015L,0xD016B272L,0xF59CC5FAL,0xF59CC5FAL,0xD016B272L,0x58507015L,0xD016B272L},{7L,(-4L),(-1L),(-7L),(-10L),(-7L),(-1L)},{0x7675F052L,0x7675F052L,0x58507015L,0xF59CC5FAL,0x58507015L,0x7675F052L,0x7675F052L},{0x57E93B1DL,(-4L),0xED5F9B65L,(-4L),0x57E93B1DL,0L,(-1L)},{3L,0xD016B272L,3L,0x58507015L,0x58507015L,3L,0xD016B272L},{(-1L),0x1A845F29L,0xED5F9B65L,(-1L),(-10L),(-4L),(-10L)}};
uint32_t l_2113 = 0x14A2ECB4L;
uint32_t l_2157 = 0UL;
int8_t *l_2229 = (void*)0;
int64_t *l_2289 = &g_1708;
int64_t **l_2288 = &l_2289;
uint32_t l_2463 = 0x1FA56C35L;
struct S0 ****l_2467 = &g_965;
struct S0 *****l_2466[4][1][5] = {{{&l_2467,&l_2467,&l_2467,&l_2467,&l_2467}},{{&l_2467,&l_2467,&l_2467,&l_2467,&l_2467}},{{&l_2467,(void*)0,&l_2467,(void*)0,&l_2467}},{{&l_2467,(void*)0,&l_2467,&l_2467,&l_2467}}};
uint16_t l_2471 = 0x0E5AL;
int32_t *l_2505 = &g_968[1].f7;
uint32_t l_2544 = 18446744073709551615UL;
const int64_t l_2626[10] = {0xE442BD6A39F6306BLL,0L,0L,0xE442BD6A39F6306BLL,3L,0xE442BD6A39F6306BLL,0L,0L,0xE442BD6A39F6306BLL,3L};
union U1 ****l_2627 = (void*)0;
uint64_t **l_2632 = &g_158;
uint32_t l_2633 = 0UL;
int8_t * const *l_2648 = &l_2229;
uint32_t * const * const l_2813 = &g_2360;
int32_t l_2819 = 0xEA2CC52CL;
int8_t l_2881 = 0x77L;
uint16_t l_2905 = 65535UL;
union U1 *****l_2921 = &l_2627;
int32_t **l_2933 = &g_1422;
uint32_t l_2963[4][6] = {{0x35A73028L,0x35A73028L,4294967295UL,0x19B845ADL,0x84DF519BL,4294967295UL},{0x19B845ADL,0x84DF519BL,4294967295UL,0x84DF519BL,0x19B845ADL,4294967295UL},{0x84DF519BL,0x19B845ADL,4294967295UL,0x35A73028L,0x35A73028L,4294967295UL},{0x35A73028L,0x35A73028L,4294967295UL,0x19B845ADL,0x84DF519BL,4294967295UL}};
uint16_t l_2969 = 0xD063L;
uint16_t l_2989 = 65534UL;
int32_t l_3006 = 0L;
union U2 **l_3016 = &g_1033;
uint8_t *l_3042 = &g_2654.f1;
int64_t l_3070[1];
int32_t l_3072 = 0x1AEAEC7DL;
uint32_t l_3157 = 0UL;
uint32_t l_3171 = 2UL;
uint64_t ***l_3179 = (void*)0;
uint32_t l_3181 = 0x0F9EA86EL;
int32_t l_3186[5][2][2] = {{{(-4L),(-4L)},{(-4L),(-4L)}},{{(-4L),(-4L)},{(-4L),(-4L)}},{{(-4L),(-4L)},{(-4L),(-4L)}},{{(-4L),(-4L)},{(-4L),(-4L)}},{{(-4L),(-4L)},{(-4L),(-4L)}}};
uint64_t l_3297[10] = {4UL,4UL,4UL,4UL,4UL,4UL,4UL,4UL,4UL,4UL};
uint8_t l_3352 = 7UL;
int i, j, k;
for (i = 0; i < 1; i++)
l_3070[i] = 0xA4022C1EBD425F69LL;
if ((safe_div_func_int8_t_s_s((safe_div_func_int32_t_s_s(((l_2013 , (safe_sub_func_int64_t_s_s(l_2013, 18446744073709551607UL))) > (p_3 , g_149)), (((((l_2016 = 0xCBB6089915209B59LL) || 0x81F473B6501F83EALL) , p_3) <= (l_2017[0][2][0] ^ (-1L))) ^ (*g_215)))), g_279[1][2][0])))
{ /* block id: 927 */
int32_t l_2018 = 0L;
int16_t *l_2019 = &g_825;
uint16_t *l_2020 = &g_149;
const uint8_t *l_2021 = &g_126;
int32_t ***l_2024 = &g_49[7];
int8_t *l_2031 = &l_2017[0][0][0];
int8_t *l_2032 = &g_1082[1][0][0];
int32_t **l_2041 = (void*)0;
int32_t l_2061 = (-1L);
int64_t l_2090[8] = {0xC4F47248C8BDA799LL,0xC4F47248C8BDA799LL,0xC4F47248C8BDA799LL,0xC4F47248C8BDA799LL,0xC4F47248C8BDA799LL,0xC4F47248C8BDA799LL,0xC4F47248C8BDA799LL,0xC4F47248C8BDA799LL};
int32_t l_2100 = 0x574E01FFL;
int32_t l_2102 = 7L;
int32_t l_2103 = 0x29F77C5EL;
int8_t l_2104 = 0L;
int32_t l_2105 = 0xB8E4D1A8L;
int32_t l_2107 = 2L;
int32_t l_2111 = (-1L);
int32_t l_2112[3][3][7] = {{{0xFD0DBB50L,0x0301DC19L,0xFD0DBB50L,0xFD0DBB50L,0x0301DC19L,0xFD0DBB50L,0xFD0DBB50L},{0xAAA70DF4L,0xAAA70DF4L,0x75F6378CL,0xAAA70DF4L,0xAAA70DF4L,0x75F6378CL,0xAAA70DF4L},{0x0301DC19L,0xFD0DBB50L,0xFD0DBB50L,0x0301DC19L,0xFD0DBB50L,0xFD0DBB50L,0x0301DC19L}},{{0xC44DCFA4L,0xAAA70DF4L,0xC44DCFA4L,0xC44DCFA4L,0xAAA70DF4L,0xC44DCFA4L,0xC44DCFA4L},{0x0301DC19L,0x0301DC19L,0xD39F117DL,0x0301DC19L,0x0301DC19L,0xD39F117DL,0x0301DC19L},{0xAAA70DF4L,0xC44DCFA4L,0xC44DCFA4L,0xAAA70DF4L,0xC44DCFA4L,0xC44DCFA4L,0xAAA70DF4L}},{{0xFD0DBB50L,0x0301DC19L,0xFD0DBB50L,0xFD0DBB50L,0x0301DC19L,0xFD0DBB50L,0xFD0DBB50L},{0xAAA70DF4L,0xAAA70DF4L,0x75F6378CL,0xC44DCFA4L,0xC44DCFA4L,0xAAA70DF4L,0xC44DCFA4L},{0xFD0DBB50L,0xD39F117DL,0xD39F117DL,0xFD0DBB50L,0xD39F117DL,0xD39F117DL,0xFD0DBB50L}}};
int8_t l_2174[10][1];
uint64_t *l_2283 = &l_2016;
int64_t *l_2287 = &l_2090[3];
int64_t **l_2286 = &l_2287;
int32_t l_2337[5] = {0L,0L,0L,0L,0L};
uint32_t ** const l_2362 = &g_2360;
int8_t l_2372[10] = {0x1EL,0L,0L,0x1EL,0L,0L,0x1EL,0L,0L,0x1EL};
struct S0 *****l_2468 = &l_2467;
int i, j, k;
for (i = 0; i < 10; i++)
{
for (j = 0; j < 1; j++)
l_2174[i][j] = 0x87L;
}
(*p_4) ^= ((((*l_2020) ^= (l_2018 & ((void*)0 != l_2019))) | ((5UL <= (l_2021 == l_2022)) == ((g_2023 , &g_675) == ((*l_2024) = &g_50)))) ^ p_3);
}
else
{ /* block id: 1106 */
int32_t **l_2507 = (void*)0;
int32_t **l_2508 = &g_50;
(*l_2508) = p_4;
}
return p_4;
}
/* ------------------------------------------ */
/*
* reads : g_1527.f3 g_158 g_1981 g_1983 g_357 g_50 g_1524.f7 g_1165 g_878.f4 g_1526.f0 g_276.f3 g_1708 g_1416 g_1421 g_412.f0 g_159 g_673 g_334.f2 g_587 g_295 g_1341.f1 g_276.f1 g_480 g_128 g_1368.f4 g_967 g_968 g_215 g_216 g_209.f2 g_276.f7 g_1368.f6 g_551 g_552 g_1459 g_1485 g_724.f0 g_1501 g_1218.f1 g_1368.f7 g_615 g_1521.f5 g_1525.f3 g_1549 g_21 g_878.f2 g_1111.f1 g_1564 g_724.f1 g_1218.f2 g_85 g_1522.f0 g_1222 g_1527.f7 g_126 g_1526.f5 g_1143 g_1082 g_1107 g_1529 g_1646 g_1521.f3 g_1653 g_553 g_848.f1 g_204 g_827 g_276.f5 g_1564.f0 g_1520.f6 g_1523.f0 g_1720 g_1730 g_412 g_965 g_966 g_279 g_1501.f1 g_1523.f3 g_152 g_1524.f0 g_1520.f0 g_366 g_2005 g_2006
* writes: g_1527.f3 g_159 g_1979 g_1981 g_21 g_1524.f7 g_1165 g_878.f4 g_480 g_276.f3 g_1485.f4 g_1519.f1 g_1522.f5 g_1523.f5 g_1341.f1 g_276.f1 g_1082 g_1218.f1 g_412.f0 g_357 g_1111.f1 g_209.f4 g_366 g_276.f7 g_152 g_848.f1 g_204 g_827 g_1131.f0 g_50 g_279 g_149 g_1527.f5 g_1416.f0 g_1033 g_295
*/
static union U2 func_6(const int32_t * p_7, int32_t * p_8)
{ /* block id: 879 */
int32_t l_1971 = 0x2FD6C9D3L;
int64_t ** const *l_1976[9] = {&g_393,&g_393,&g_393,&g_393,&g_393,&g_393,&g_393,&g_393,&g_393};
int32_t *l_1992 = &g_1519[2].f1;
int i;
for (g_1527.f3 = 6; (g_1527.f3 >= 1); g_1527.f3 -= 1)
{ /* block id: 882 */
int64_t ** const **l_1977 = (void*)0;
int64_t ** const **l_1978[2][3][7] = {{{&l_1976[7],&l_1976[7],(void*)0,&l_1976[2],&l_1976[1],&l_1976[7],&l_1976[2]},{&l_1976[7],(void*)0,&l_1976[2],&l_1976[7],&l_1976[7],&l_1976[2],(void*)0},{&l_1976[7],&l_1976[4],(void*)0,&l_1976[7],&l_1976[4],&l_1976[2],(void*)0}},{{&l_1976[7],&l_1976[7],&l_1976[2],&l_1976[7],(void*)0,&l_1976[7],&l_1976[2]},{&l_1976[1],&l_1976[1],&l_1976[7],&l_1976[7],&l_1976[7],&l_1976[5],&l_1976[1]},{&l_1976[1],&l_1976[2],(void*)0,&l_1976[7],&l_1976[7],&l_1976[7],&l_1976[7]}}};
int64_t * const ***l_1982[2][3] = {{&g_1981,(void*)0,&g_1981},{&g_1981,(void*)0,&g_1981}};
int32_t l_1987 = 0L;
int i, j, k;
(*p_8) ^= (safe_lshift_func_uint8_t_u_u((safe_div_func_uint8_t_u_u((((*g_158) = l_1971) <= l_1971), 5L)), (((safe_rshift_func_uint8_t_u_s(0x70L, 6)) || (((safe_mod_func_int64_t_s_s(((g_1979 = l_1976[7]) == (g_1981 = g_1981)), 0x8881B111D6B667A9LL)) != ((*g_50) = (((g_1983[4][1][3] , (~(safe_add_func_uint64_t_u_u(l_1987, l_1987)))) || g_357) == 8L))) < l_1987)) == 0x0A7CL)));
}
for (g_1165 = (-27); (g_1165 <= 58); g_1165 = safe_add_func_int8_t_s_s(g_1165, 1))
{ /* block id: 891 */
uint8_t l_1993 = 0x05L;
for (g_878.f4 = 0; (g_878.f4 > (-15)); --g_878.f4)
{ /* block id: 894 */
int16_t *l_1996 = &g_480;
l_1992 = l_1992;
if ((*p_8))
break;
(*p_8) = ((((-1L) | l_1993) > ((*l_1996) = (safe_lshift_func_int8_t_s_s(0x84L, g_1526.f0)))) > 0x4AL);
}
}
for (g_276.f3 = (-17); (g_276.f3 != 15); g_276.f3 = safe_add_func_uint32_t_u_u(g_276.f3, 4))
{ /* block id: 903 */
uint32_t *l_2003 = &g_1165;
union U2 **l_2004 = &g_1033;
for (g_1485.f4 = 7; (g_1485.f4 <= (-18)); --g_1485.f4)
{ /* block id: 906 */
(*l_1992) = (-1L);
for (g_1522.f5 = 0; (g_1522.f5 <= 6); g_1522.f5 += 1)
{ /* block id: 910 */
for (g_1523.f5 = 0; (g_1523.f5 <= 3); g_1523.f5 += 1)
{ /* block id: 913 */
(*l_1992) = (safe_rshift_func_uint8_t_u_s((&g_295[0] != &g_1126), 3));
}
}
}
(*l_2004) = func_45(((*l_2003) = g_1708));
(*g_2005) = p_7;
if ((*p_8))
break;
}
return g_2006[2][7];
}
/* ------------------------------------------ */
/*
* reads : g_1520.f5 g_1529.f3 g_204 g_215 g_216 g_1525.f6 g_82 g_50 g_1522.f4 g_1523.f3 g_1126 g_1524.f3 g_480 g_1368.f3 g_1111.f1 g_1838 g_21
* writes: g_21 g_22 g_1520.f5 g_1165 g_126 g_204 g_1523.f7 g_1526.f7 g_1529.f7 g_1111.f0 g_480 g_1111.f1 g_968.f1
*/
static int64_t func_14(uint16_t p_15, int8_t p_16)
{ /* block id: 2 */
uint8_t l_19[7][4][9] = {{{0xF8L,0xFEL,0xDEL,0UL,0x6CL,0x3CL,0x3CL,0x6CL,0UL},{4UL,0UL,4UL,0xCEL,0x6CL,0x51L,252UL,1UL,0xCEL},{4UL,0x6CL,0xDEL,0x92L,0UL,0x51L,0xDCL,0x6CL,0x92L},{0xF8L,0x6CL,0xEDL,0xCEL,0xFEL,0x3CL,0xDCL,0xEDL,0xCEL}},{{0xDEL,0UL,0xEDL,0UL,0UL,0xDCL,252UL,0xEDL,0UL},{0xF8L,0xFEL,0xDEL,0UL,0x6CL,0x3CL,0x3CL,0x6CL,0UL},{4UL,0UL,4UL,0xCEL,0x6CL,0x51L,252UL,1UL,0xCEL},{4UL,0x6CL,0xDEL,0x92L,0UL,0x51L,0xDCL,0x6CL,0x92L}},{{0xF8L,0x6CL,0xEDL,0xCEL,0xFEL,0x3CL,0xDCL,0xEDL,0xCEL},{0xDEL,0UL,0xEDL,0UL,0UL,0xDCL,252UL,0xEDL,0UL},{0xF8L,0xFEL,0xDEL,0UL,0x6CL,0x3CL,0x3CL,0x6CL,0UL},{4UL,0UL,4UL,0xCEL,0x6CL,0x51L,252UL,1UL,0xCEL}},{{7UL,0x51L,255UL,0xA7L,0x3CL,0x25L,0x55L,0x51L,0xA7L},{0xDEL,0x51L,255UL,255UL,0xDCL,0xAEL,0x55L,252UL,255UL},{255UL,0x3CL,255UL,0x03L,0x3CL,0x55L,0UL,252UL,0x03L},{0xDEL,0xDCL,255UL,0x03L,0x51L,0xAEL,0xAEL,0x51L,0x03L}},{{7UL,0x3CL,7UL,255UL,0x51L,0x25L,0UL,255UL,255UL},{7UL,0x51L,255UL,0xA7L,0x3CL,0x25L,0x55L,0x51L,0xA7L},{0xDEL,0x51L,255UL,255UL,0xDCL,0xAEL,0x55L,252UL,255UL},{255UL,0x3CL,255UL,0x03L,0x3CL,0x55L,0UL,252UL,0x03L}},{{0xDEL,0xDCL,255UL,0x03L,0x51L,0xAEL,0xAEL,0x51L,0x03L},{7UL,0x3CL,7UL,255UL,0x51L,0x25L,0UL,255UL,255UL},{7UL,0x51L,255UL,0xA7L,0x3CL,0x25L,0x55L,0x51L,0xA7L},{0xDEL,0x51L,255UL,255UL,0xDCL,0xAEL,0x55L,252UL,255UL}},{{255UL,0x3CL,255UL,0x03L,0x3CL,0x55L,0UL,252UL,0x03L},{0xDEL,0xDCL,255UL,0x03L,0x51L,0xAEL,0xAEL,0x51L,0x03L},{7UL,0x3CL,7UL,255UL,0x51L,0x25L,0UL,255UL,255UL},{7UL,0x51L,255UL,0xA7L,0x3CL,0x25L,0x55L,0x51L,0xA7L}}};
int32_t l_33[5];
union U2 **l_1405 = &g_1033;
uint32_t l_1863 = 0UL;
uint64_t l_1943[1];
union U1 *l_1961 = &g_412;
int32_t *l_1964[3];
const uint8_t l_1965 = 1UL;
int i, j, k;
for (i = 0; i < 5; i++)
l_33[i] = 0x59B3460EL;
for (i = 0; i < 1; i++)
l_1943[i] = 18446744073709551615UL;
for (i = 0; i < 3; i++)
l_1964[i] = &g_1775[2].f4;
for (p_16 = 0; (p_16 == 20); p_16 = safe_add_func_uint8_t_u_u(p_16, 9))
{ /* block id: 5 */
uint64_t l_30[2][9][10] = {{{0x81468F30040642FCLL,0UL,0UL,0UL,0x81468F30040642FCLL,18446744073709551615UL,18446744073709551615UL,0x81468F30040642FCLL,0UL,0UL},{0xB9DB5DF1D979388BLL,0xB9DB5DF1D979388BLL,0UL,0x81468F30040642FCLL,0x9E5FAF1BECDE8719LL,0x81468F30040642FCLL,0UL,0xB9DB5DF1D979388BLL,0xB9DB5DF1D979388BLL,0UL},{0UL,0x81468F30040642FCLL,18446744073709551615UL,18446744073709551615UL,0x81468F30040642FCLL,0UL,0UL,0UL,0x81468F30040642FCLL,18446744073709551615UL},{18446744073709551606UL,0xB9DB5DF1D979388BLL,18446744073709551606UL,18446744073709551615UL,0UL,0UL,18446744073709551615UL,18446744073709551606UL,0xB9DB5DF1D979388BLL,18446744073709551606UL},{18446744073709551606UL,0UL,0xB9DB5DF1D979388BLL,0x81468F30040642FCLL,0xB9DB5DF1D979388BLL,0UL,0x81468F30040642FCLL,0x81468F30040642FCLL,18446744073709551606UL,0x9E5FAF1BECDE8719LL},{18446744073709551606UL,0x81468F30040642FCLL,0x81468F30040642FCLL,18446744073709551606UL,0x9E5FAF1BECDE8719LL,18446744073709551615UL,0x9E5FAF1BECDE8719LL,18446744073709551606UL,0x81468F30040642FCLL,0x81468F30040642FCLL},{0x9E5FAF1BECDE8719LL,0x81468F30040642FCLL,0UL,0xB9DB5DF1D979388BLL,0xB9DB5DF1D979388BLL,0UL,0x81468F30040642FCLL,0x9E5FAF1BECDE8719LL,0x81468F30040642FCLL,0UL},{18446744073709551615UL,18446744073709551606UL,0xB9DB5DF1D979388BLL,18446744073709551606UL,18446744073709551615UL,0UL,0UL,18446744073709551615UL,18446744073709551606UL,0xB9DB5DF1D979388BLL},{0x9E5FAF1BECDE8719LL,0x9E5FAF1BECDE8719LL,0xB9DB5DF1D979388BLL,18446744073709551615UL,0UL,18446744073709551615UL,0xB9DB5DF1D979388BLL,0x9E5FAF1BECDE8719LL,0x9E5FAF1BECDE8719LL,0xB9DB5DF1D979388BLL}},{{18446744073709551606UL,18446744073709551615UL,0UL,0UL,18446744073709551615UL,18446744073709551606UL,0xB9DB5DF1D979388BLL,18446744073709551606UL,18446744073709551615UL,0UL},{0x81468F30040642FCLL,0x9E5FAF1BECDE8719LL,0x81468F30040642FCLL,0UL,0xB9DB5DF1D979388BLL,0xB9DB5DF1D979388BLL,0UL,0x81468F30040642FCLL,0x9E5FAF1BECDE8719LL,0x81468F30040642FCLL},{0x81468F30040642FCLL,18446744073709551606UL,0x9E5FAF1BECDE8719LL,18446744073709551615UL,0x9E5FAF1BECDE8719LL,18446744073709551606UL,0x81468F30040642FCLL,0x81468F30040642FCLL,18446744073709551606UL,0x9E5FAF1BECDE8719LL},{18446744073709551606UL,0x81468F30040642FCLL,0x81468F30040642FCLL,18446744073709551606UL,0x9E5FAF1BECDE8719LL,18446744073709551615UL,0x9E5FAF1BECDE8719LL,18446744073709551606UL,0x81468F30040642FCLL,0x81468F30040642FCLL},{0x9E5FAF1BECDE8719LL,0x81468F30040642FCLL,0UL,0xB9DB5DF1D979388BLL,0xB9DB5DF1D979388BLL,0UL,0x81468F30040642FCLL,0x9E5FAF1BECDE8719LL,0x81468F30040642FCLL,0UL},{18446744073709551615UL,18446744073709551606UL,0xB9DB5DF1D979388BLL,18446744073709551606UL,18446744073709551615UL,0UL,0UL,18446744073709551615UL,18446744073709551606UL,0xB9DB5DF1D979388BLL},{0x9E5FAF1BECDE8719LL,0x9E5FAF1BECDE8719LL,0xB9DB5DF1D979388BLL,18446744073709551615UL,0UL,18446744073709551615UL,0xB9DB5DF1D979388BLL,0x9E5FAF1BECDE8719LL,0x9E5FAF1BECDE8719LL,0xB9DB5DF1D979388BLL},{18446744073709551606UL,18446744073709551615UL,0UL,0UL,18446744073709551615UL,18446744073709551606UL,0xB9DB5DF1D979388BLL,18446744073709551606UL,18446744073709551615UL,0UL},{0x81468F30040642FCLL,0x9E5FAF1BECDE8719LL,0x81468F30040642FCLL,0UL,0xB9DB5DF1D979388BLL,0xB9DB5DF1D979388BLL,0UL,0x81468F30040642FCLL,0x9E5FAF1BECDE8719LL,0x81468F30040642FCLL}}};
union U2 *l_1774 = &g_1775[2];
const uint32_t *l_1779 = &g_279[7][0][0];
const uint32_t **l_1778 = &l_1779;
struct S0 ****l_1782 = &g_965;
union U1 * const l_1786 = &g_1501;
union U1 ****l_1830 = &g_551;
union U2 *** const l_1849 = &g_1032[1][0];
int32_t l_1889 = 9L;
int32_t **l_1902[7] = {&g_50,&g_50,&g_50,&g_50,&g_50,&g_50,&g_50};
uint64_t l_1948 = 0UL;
int i, j, k;
if (l_19[2][1][1])
{ /* block id: 6 */
uint8_t l_1406 = 250UL;
for (p_15 = 0; (p_15 <= 3); p_15 += 1)
{ /* block id: 9 */
uint32_t l_35[8] = {18446744073709551615UL,18446744073709551615UL,18446744073709551615UL,18446744073709551615UL,18446744073709551615UL,18446744073709551615UL,18446744073709551615UL,18446744073709551615UL};
int32_t *l_1772[1][10] = {{&g_1529[0][4][5].f7,&g_1526.f7,&g_1529[0][4][5].f7,&g_1529[0][4][5].f7,&g_1526.f7,&g_1529[0][4][5].f7,&g_1529[0][4][5].f7,&g_1526.f7,&g_1529[0][4][5].f7,&g_1529[0][4][5].f7}};
int32_t **l_1771 = &l_1772[0][8];
union U2 **l_1780 = &g_1033;
int64_t l_1807 = 0xDAC560824BB56B27LL;
int i, j;
for (g_21 = 3; (g_21 >= 0); g_21 -= 1)
{ /* block id: 12 */
int8_t *l_1407[3];
int32_t l_1408[9];
int64_t *l_1409 = &g_357;
int32_t *l_1410 = &g_276.f0;
union U2 *l_1773[6][9][1];
union U1 **l_1788 = &g_553;
int i, j, k;
for (i = 0; i < 3; i++)
l_1407[i] = &g_152;
for (i = 0; i < 9; i++)
l_1408[i] = 0L;
for (i = 0; i < 6; i++)
{
for (j = 0; j < 9; j++)
{
for (k = 0; k < 1; k++)
l_1773[i][j][k] = &g_209;
}
}
for (g_22 = 3; (g_22 >= 0); g_22 -= 1)
{ /* block id: 15 */
int32_t *l_23 = (void*)0;
int32_t l_24[8];
int32_t *l_25 = &l_24[7];
int32_t *l_26 = &l_24[0];
int32_t *l_27 = &l_24[7];
int32_t *l_28 = &l_24[6];
int32_t *l_29[9] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0};
int32_t l_34 = 0xEC160668L;
int i;
for (i = 0; i < 8; i++)
l_24[i] = 0xF3D0097EL;
--l_30[1][5][3];
l_35[0]++;
}
}
for (g_1520.f5 = 0; (g_1520.f5 <= 3); g_1520.f5 += 1)
{ /* block id: 786 */
uint32_t *l_1797 = &g_1165;
uint8_t *l_1800 = &g_126;
uint16_t *l_1803 = &g_204[1];
int32_t l_1806 = 0x078BD9B1L;
int i, j, k;
(**l_1771) = (((((0x8944EF05L && 0xB1C1D5B3L) >= (l_19[(p_15 + 3)][g_1520.f5][(p_15 + 4)] ^ (!((g_1529[0][4][5].f3 , ((safe_add_func_int16_t_s_s(((safe_sub_func_int64_t_s_s((safe_unary_minus_func_uint64_t_u(((((safe_mod_func_uint16_t_u_u((l_33[2] > (((l_1406 <= ((((*l_1797) = 0x5D62D4FEL) <= (safe_lshift_func_int16_t_s_u((((((*l_1800) = 0UL) & (safe_div_func_uint32_t_u_u(((((((--(*l_1803)) < (l_1806 = l_19[(g_1520.f5 + 1)][g_1520.f5][(g_1520.f5 + 2)])) < p_15) ^ 0UL) >= 0xF4L) , l_19[4][3][0]), p_16))) && p_16) <= 65535UL), 6))) != (-10L))) <= p_16) <= l_33[3])), (*g_215))) , 0x7640L) > l_19[3][0][5]) < l_1406))), l_33[3])) & l_1807), 0xAE77L)) >= p_16)) & g_1525.f6)))) <= p_16) < 0xA5L) | 2L);
(*g_1126) = ((safe_rshift_func_uint16_t_u_s((g_82 <= ((safe_lshift_func_int8_t_s_s(p_15, ((safe_rshift_func_uint8_t_u_u(((!p_16) < (safe_rshift_func_uint16_t_u_u(((((safe_lshift_func_int8_t_s_s((0x14791585L && ((*g_50) = p_16)), ((safe_div_func_int32_t_s_s(((**l_1771) = l_19[(g_1520.f5 + 1)][g_1520.f5][(g_1520.f5 + 2)]), 0x2C5E2F27L)) != ((*l_1797) = ((safe_div_func_int32_t_s_s((safe_mul_func_uint8_t_u_u(p_16, 1L)), l_30[1][5][3])) , g_1522.f4))))) != 0xC234B93BL) && 0L) , g_1523.f3), p_16))), 0)) && 4294967294UL))) || p_15)), 0)) != 0xFFL);
l_1806 = 0xD433246CL;
}
}
}
else
{ /* block id: 799 */
int32_t l_1827 = 1L;
int32_t **l_1835 = &g_1422;
uint8_t *l_1836 = &g_1111.f1;
int32_t l_1837 = 1L;
(*g_1838) = ((*g_50) = (safe_div_func_uint64_t_u_u(l_1827, (safe_div_func_int64_t_s_s((l_1837 = (((*l_1836) |= ((l_1830 == l_1830) <= ((l_1827 && (*g_215)) > ((safe_lshift_func_int16_t_s_s(g_1524[1].f3, ((&g_966 == &g_966) , (g_480 &= ((safe_sub_func_int32_t_s_s(((l_1835 != (void*)0) & 0x2993L), p_15)) > l_19[2][1][1]))))) <= g_1368[0][3].f3)))) <= l_33[0])), l_30[1][5][3])))));
}
}
(*g_50) ^= p_16;
(*g_50) = l_1965;
return p_16;
}
/* ------------------------------------------ */
/*
* reads : g_1523.f7 g_1526.f7 g_1529.f7 g_1078 g_1032 g_1033 g_209
* writes: g_1523.f7 g_1526.f7 g_1529.f7
*/
static const union U2 func_40(union U2 * p_41, uint8_t p_42, int32_t ** p_43, uint16_t p_44)
{ /* block id: 772 */
(**p_43) = (**p_43);
return (***g_1078);
}
/* ------------------------------------------ */
/*
* reads : g_1416 g_1421 g_412.f0 g_158 g_159 g_673 g_334.f2 g_587 g_295 g_1341.f1 g_276.f1 g_480 g_128 g_1368.f4 g_967 g_968 g_215 g_216 g_209.f2 g_276.f7 g_1368.f6 g_551 g_552 g_1459 g_1485 g_724.f0 g_1501 g_357 g_1218.f1 g_1368.f7 g_615 g_1521.f5 g_1525.f3 g_1549 g_21 g_878.f2 g_1111.f1 g_1564 g_724.f1 g_1218.f2 g_85 g_1522.f0 g_1222 g_1527.f7 g_126 g_1526.f5 g_1143 g_1082 g_1107 g_1529 g_1646 g_1521.f3 g_1653 g_553 g_848.f1 g_204 g_827 g_276.f5 g_1564.f0 g_1520.f6 g_1708 g_1523.f0 g_1720 g_1730 g_412 g_965 g_966 g_279 g_1501.f1 g_1523.f3 g_152 g_1524.f0 g_1520.f0 g_149 g_1527.f5 g_1416.f0 g_366
* writes: g_159 g_1341.f1 g_480 g_276.f1 g_1082 g_1218.f1 g_412.f0 g_357 g_1111.f1 g_209.f4 g_366 g_276.f7 g_152 g_848.f1 g_204 g_827 g_1131.f0 g_50 g_279 g_1165 g_149 g_1527.f5 g_1416.f0
*/
static union U2 * func_45(uint32_t p_46)
{ /* block id: 621 */
int32_t l_1417[5][2][9] = {{{(-1L),0x2131F2E4L,0x2131F2E4L,(-1L),(-1L),(-9L),(-5L),(-9L),0x7C9E31DDL},{0xCB9385C5L,0x7F2EC63BL,0x121B529CL,0x57295E08L,2L,0x7A32071EL,0x7A32071EL,2L,0x57295E08L}},{{(-4L),0x25B08D85L,(-4L),0x33223A7BL,(-1L),1L,(-9L),0x3CAA6EBDL,(-5L)},{(-3L),0x7A32071EL,0x6C602686L,(-8L),2L,0xB2665E9FL,2L,(-8L),0x6C602686L}},{{(-5L),(-5L),0x70C4991CL,(-7L),(-4L),(-1L),0x21FC618CL,3L,0x7C9E31DDL},{1L,0x2B11D85BL,0xB2665E9FL,0L,0x121B529CL,0x121B529CL,0L,0xB2665E9FL,0x2B11D85BL}},{{0x33223A7BL,(-1L),0x70C4991CL,0xBF8BB4A9L,0x2131F2E4L,(-7L),(-5L),0x21FC618CL,0x25B08D85L},{(-8L),1L,0x6C602686L,0x2B11D85BL,0x57295E08L,0x2B11D85BL,0x6C602686L,1L,(-8L)}},{{0x2131F2E4L,(-1L),(-1L),(-9L),(-5L),(-9L),0x7C9E31DDL,0x70C4991CL,1L},{0xCB9385C5L,0x2B11D85BL,0x7F2EC63BL,0xB2665E9FL,0xB2665E9FL,0x7F2EC63BL,0x2B11D85BL,0xCB9385C5L,1L}}};
int32_t l_1418 = 0x8BDBE35CL;
int32_t *l_1420 = &g_968[1].f0;
int32_t ** const l_1419 = &l_1420;
int64_t *l_1425[7][9][4] = {{{&g_357,(void*)0,&g_357,&g_357},{&g_357,&g_357,(void*)0,(void*)0},{&g_357,&g_357,&g_357,&g_357},{(void*)0,&g_357,&g_357,(void*)0},{&g_357,(void*)0,&g_357,&g_357},{(void*)0,&g_357,&g_357,&g_357},{(void*)0,&g_357,&g_357,(void*)0},{(void*)0,&g_357,&g_357,&g_357},{(void*)0,&g_357,(void*)0,(void*)0}},{{&g_357,&g_357,&g_357,&g_357},{&g_357,&g_357,&g_357,(void*)0},{&g_357,(void*)0,&g_357,&g_357},{&g_357,&g_357,&g_357,&g_357},{&g_357,(void*)0,&g_357,&g_357},{&g_357,&g_357,&g_357,&g_357},{&g_357,(void*)0,(void*)0,(void*)0},{&g_357,&g_357,&g_357,(void*)0},{&g_357,&g_357,&g_357,&g_357}},{{&g_357,&g_357,(void*)0,&g_357},{&g_357,&g_357,&g_357,&g_357},{&g_357,&g_357,&g_357,(void*)0},{&g_357,&g_357,(void*)0,(void*)0},{&g_357,(void*)0,&g_357,&g_357},{&g_357,&g_357,&g_357,&g_357},{&g_357,(void*)0,&g_357,&g_357},{&g_357,&g_357,&g_357,&g_357},{&g_357,(void*)0,(void*)0,(void*)0}},{{(void*)0,&g_357,&g_357,&g_357},{&g_357,&g_357,(void*)0,(void*)0},{&g_357,&g_357,&g_357,&g_357},{&g_357,&g_357,(void*)0,(void*)0},{&g_357,&g_357,(void*)0,&g_357},{&g_357,(void*)0,&g_357,&g_357},{&g_357,&g_357,&g_357,(void*)0},{&g_357,(void*)0,&g_357,(void*)0},{(void*)0,&g_357,&g_357,&g_357}},{{&g_357,(void*)0,&g_357,&g_357},{&g_357,(void*)0,&g_357,(void*)0},{&g_357,&g_357,&g_357,&g_357},{(void*)0,&g_357,&g_357,&g_357},{&g_357,&g_357,&g_357,&g_357},{&g_357,&g_357,&g_357,&g_357},{&g_357,&g_357,(void*)0,&g_357},{&g_357,&g_357,&g_357,&g_357},{(void*)0,(void*)0,&g_357,&g_357}},{{&g_357,(void*)0,&g_357,(void*)0},{&g_357,&g_357,&g_357,&g_357},{&g_357,&g_357,(void*)0,&g_357},{&g_357,&g_357,&g_357,(void*)0},{&g_357,&g_357,&g_357,(void*)0},{&g_357,(void*)0,&g_357,&g_357},{&g_357,&g_357,&g_357,&g_357},{&g_357,(void*)0,(void*)0,&g_357},{&g_357,&g_357,&g_357,&g_357}},{{&g_357,&g_357,(void*)0,&g_357},{&g_357,&g_357,&g_357,&g_357},{&g_357,&g_357,(void*)0,&g_357},{&g_357,&g_357,&g_357,&g_357},{&g_357,(void*)0,&g_357,&g_357},{&g_357,&g_357,&g_357,&g_357},{(void*)0,(void*)0,&g_357,(void*)0},{&g_357,&g_357,&g_357,(void*)0},{&g_357,&g_357,&g_357,&g_357}}};
int32_t l_1434 = 7L;
const int32_t *l_1435 = &l_1434;
const union U1 *l_1449 = &g_1416;
const union U1 **l_1448[9];
union U2 *l_1484 = &g_878;
int64_t *l_1490 = &g_357;
uint64_t **l_1508 = &g_158;
struct S0 *l_1518[7][3] = {{&g_1524[1],&g_1527,&g_1522},{&g_1521,&g_1521,&g_1522},{&g_1527,&g_1524[1],&g_1522},{&g_1524[1],&g_1527,&g_1522},{&g_1521,&g_1521,&g_1522},{&g_1527,&g_1524[1],&g_1522},{&g_1524[1],&g_1527,&g_1522}};
uint32_t l_1574 = 0UL;
int32_t *l_1592[3];
int32_t l_1617[10] = {0L,0x17C6426CL,0L,0x847827ADL,0x847827ADL,0L,0x17C6426CL,0L,0x847827ADL,0x847827ADL};
struct S0 ***l_1643 = &g_966;
int16_t l_1660 = 0x1CD1L;
int64_t ***l_1679 = (void*)0;
int16_t l_1765[3][5][10] = {{{1L,1L,0L,0L,1L,1L,0L,0L,1L,1L},{1L,0L,0L,1L,1L,0L,0L,1L,1L,0L},{1L,1L,0L,0L,1L,1L,0L,0L,1L,1L},{1L,0L,0L,1L,1L,0L,0L,1L,1L,0L},{1L,1L,0L,0L,1L,1L,0L,0L,1L,1L}},{{1L,0L,0L,1L,1L,0L,0L,1L,1L,0L},{1L,1L,0L,0L,1L,1L,0L,0L,1L,1L},{1L,0L,0L,1L,1L,0L,0L,1L,1L,0L},{1L,1L,0L,0L,1L,1L,0L,0L,1L,1L},{1L,0L,0L,1L,1L,0L,0L,1L,1L,0L}},{{1L,1L,0L,0L,1L,1L,0L,0L,1L,1L},{1L,0L,0L,1L,1L,0L,0L,1L,1L,0L},{1L,1L,0L,0L,1L,1L,0L,0L,1L,1L},{1L,0L,0L,1L,1L,0L,0L,1L,1L,0L},{1L,1L,0L,0L,1L,1L,0L,0L,1L,1L}}};
union U2 *l_1770 = &g_1549[4][0][2];
int i, j, k;
for (i = 0; i < 9; i++)
l_1448[i] = &l_1449;
for (i = 0; i < 3; i++)
l_1592[i] = &g_276.f7;
lbl_1439:
l_1435 = ((((safe_div_func_int64_t_s_s((((l_1417[2][0][3] = (!(g_1416 , 0x5DE9FEFB72C46882LL))) | (l_1418 = p_46)) ^ (l_1419 == g_1421[5][4])), p_46)) && ((safe_sub_func_int64_t_s_s((l_1417[2][0][3] = l_1417[4][1][4]), ((safe_mod_func_int64_t_s_s((0xCF1EBC77588EAEA2LL | (((((*g_158) &= (((l_1418 = (safe_lshift_func_int8_t_s_s(((safe_div_func_int64_t_s_s((safe_rshift_func_int16_t_s_u(0x44D0L, 6)), l_1418)) , (-2L)), p_46))) & p_46) || g_412.f0)) > p_46) | l_1434) ^ 0xB0393217177938C0LL)), p_46)) & p_46))) , 0xCA488876A154CC72LL)) , (*g_673)) , (void*)0);
for (g_1341.f1 = 0; (g_1341.f1 == 53); g_1341.f1 = safe_add_func_uint32_t_u_u(g_1341.f1, 1))
{ /* block id: 630 */
const int32_t **l_1438 = &l_1435;
union U1 ** const *l_1442 = &g_552;
union U1 ** const **l_1441 = &l_1442;
union U1 ** const *** const l_1440 = &l_1441;
int32_t l_1474[3];
uint32_t l_1478[8] = {4294967292UL,4294967292UL,4294967292UL,4294967292UL,4294967292UL,4294967292UL,4294967292UL,4294967292UL};
union U2 *l_1481[9][3] = {{&g_1218,&g_1218,&g_1218},{&g_1218,(void*)0,&g_1218},{&g_1218,&g_1218,&g_1218},{&g_1218,(void*)0,&g_1218},{&g_1218,&g_1218,&g_1218},{&g_1218,(void*)0,&g_1218},{&g_1218,&g_1218,&g_1218},{&g_1218,(void*)0,&g_1218},{&g_1218,&g_1218,&g_1218}};
int64_t *l_1488 = &g_357;
struct S0 * const l_1528 = &g_1529[0][4][5];
const uint64_t *l_1599 = (void*)0;
int32_t l_1601 = 0xA41B2B75L;
uint64_t l_1618 = 0x0B032FAA427C9DC9LL;
int32_t l_1647 = (-8L);
union U1 *l_1659 = &g_1111;
int64_t ** const *l_1681 = (void*)0;
union U2 *l_1712 = &g_1218;
struct S0 * const *l_1722 = (void*)0;
struct S0 * const **l_1721 = &l_1722;
const uint32_t l_1747[7] = {0xDF2C0C4FL,0xDF2C0C4FL,0xDF2C0C4FL,0xDF2C0C4FL,0xDF2C0C4FL,0xDF2C0C4FL,0xDF2C0C4FL};
int i, j;
for (i = 0; i < 3; i++)
l_1474[i] = 0x7F5428DFL;
(*l_1438) = (*g_587);
if (g_1341.f1)
goto lbl_1439;
for (g_480 = 0; (g_480 <= 1); g_480 += 1)
{ /* block id: 635 */
const uint32_t l_1461 = 8UL;
uint8_t l_1465 = 252UL;
int32_t l_1477 = 0xEBE6A358L;
const union U2 ***l_1515 = (void*)0;
uint8_t l_1532[2][1];
int32_t l_1605[7][10] = {{(-9L),(-6L),(-6L),(-9L),(-6L),(-6L),(-9L),(-6L),(-6L),(-9L)},{(-6L),(-9L),(-6L),(-6L),(-9L),(-6L),(-6L),(-9L),(-6L),(-6L)},{(-9L),(-9L),0L,(-9L),(-9L),0L,(-9L),(-9L),0L,(-9L)},{(-6L),0L,0L,(-6L),0L,0L,(-6L),0L,0L,(-6L)},{0L,(-6L),0L,0L,(-6L),0L,0L,(-6L),0L,0L},{(-6L),(-6L),(-9L),(-6L),(-6L),(-9L),(-6L),(-6L),(-9L),(-6L)},{(-6L),0L,0L,(-6L),0L,0L,(-6L),0L,0L,(-6L)}};
int32_t l_1613[6] = {0xE0F1BC78L,0xE0F1BC78L,0xE0F1BC78L,0xE0F1BC78L,0xE0F1BC78L,0xE0F1BC78L};
uint8_t l_1684[7] = {0x8CL,0x8CL,0x8CL,0x8CL,0x8CL,0x8CL,0x8CL};
uint64_t **l_1691[6][1][2];
union U2 *l_1751 = &g_1549[1][2][1];
int i, j, k;
for (i = 0; i < 2; i++)
{
for (j = 0; j < 1; j++)
l_1532[i][j] = 0x1FL;
}
for (i = 0; i < 6; i++)
{
for (j = 0; j < 1; j++)
{
for (k = 0; k < 2; k++)
l_1691[i][j][k] = &g_158;
}
}
if ((l_1440 == &l_1441))
{ /* block id: 636 */
int32_t *l_1443 = (void*)0;
int32_t *l_1444 = (void*)0;
int32_t *l_1445 = &l_1417[2][0][3];
int32_t l_1464 = 8L;
uint32_t l_1573[1];
uint64_t *l_1595 = &g_128;
const uint64_t *l_1597 = &g_1598;
const uint64_t **l_1596[9][1][4] = {{{&l_1597,&l_1597,(void*)0,&l_1597}},{{&l_1597,&l_1597,&l_1597,&l_1597}},{{&l_1597,&l_1597,&l_1597,&l_1597}},{{&l_1597,&l_1597,(void*)0,&l_1597}},{{&l_1597,&l_1597,&l_1597,&l_1597}},{{&l_1597,&l_1597,&l_1597,&l_1597}},{{&l_1597,&l_1597,(void*)0,&l_1597}},{{&l_1597,&l_1597,&l_1597,&l_1597}},{{&l_1597,&l_1597,&l_1597,&l_1597}}};
const int32_t ** volatile *l_1600 = (void*)0;
int32_t l_1607 = 5L;
int32_t l_1608 = 1L;
int32_t l_1609[10][8] = {{(-3L),0xA0281AA8L,(-1L),0x2CD6A18CL,0x7C5E9723L,(-1L),5L,5L},{(-9L),2L,0x7124B779L,0x7124B779L,2L,(-9L),(-10L),0x2CD6A18CL},{(-1L),0x33611376L,0x93BBBA80L,0x6BD6824AL,0x7124B779L,(-10L),(-1L),0x4CA5F630L},{2L,0x7C5E9723L,(-1L),0x6BD6824AL,5L,(-1L),(-3L),0x2CD6A18CL},{0x4CA5F630L,5L,0x33611376L,0x7124B779L,(-1L),0x7124B779L,0x33611376L,5L},{0xA0281AA8L,(-10L),0x4CA5F630L,0x2CD6A18CL,0x7124B779L,0x93BBBA80L,0x2CD6A18CL,(-9L)},{0x6BD6824AL,(-1L),(-1L),(-3L),0xA0281AA8L,(-1L),0x2CD6A18CL,0x7C5E9723L},{(-9L),(-3L),0x4CA5F630L,0x93BBBA80L,0xA00741A7L,0x33611376L,0x33611376L,0xA00741A7L},{0xA00741A7L,0x33611376L,0x33611376L,0xA00741A7L,0x93BBBA80L,0x4CA5F630L,(-3L),(-9L)},{0x7C5E9723L,0x2CD6A18CL,(-1L),0xA0281AA8L,(-3L),(-1L),(-1L),0x6BD6824AL}};
int i, j, k;
for (i = 0; i < 1; i++)
l_1573[i] = 0UL;
if (p_46)
break;
if (((*l_1445) = ((void*)0 == &g_673)))
{ /* block id: 639 */
int64_t l_1458 = 0x212FDD0AD0351166LL;
int32_t l_1468 = 0x936FA87EL;
int32_t l_1469 = 0x6719533DL;
int16_t *l_1555 = &g_825;
uint32_t *l_1571[3][6][9] = {{{(void*)0,(void*)0,(void*)0,&g_279[2][1][0],&l_1478[0],&g_279[6][0][0],(void*)0,&g_1165,&g_279[1][1][0]},{&l_1478[3],(void*)0,&l_1478[2],&l_1478[4],(void*)0,(void*)0,&g_279[0][0][0],&l_1478[2],&g_279[1][1][0]},{&l_1478[0],&g_279[3][3][0],&g_279[1][1][0],&g_279[2][1][0],(void*)0,&g_1165,&g_1165,&g_615,&g_615},{(void*)0,(void*)0,&l_1478[2],&g_279[3][2][0],&l_1478[2],(void*)0,(void*)0,&g_615,(void*)0},{(void*)0,(void*)0,&g_279[6][1][0],&g_279[6][0][0],&g_279[3][3][0],&l_1478[2],&l_1478[2],&g_615,&l_1478[2]},{&g_615,&g_1165,(void*)0,&g_279[1][1][0],(void*)0,&g_615,&g_615,&g_615,&g_279[0][0][0]}},{{&g_1165,(void*)0,&g_279[1][1][0],&g_615,&g_279[1][1][0],&l_1478[0],&g_279[1][1][0],&g_615,&g_279[1][1][0]},{(void*)0,(void*)0,&g_279[1][1][0],(void*)0,&g_279[3][2][0],&l_1478[4],&l_1478[2],&g_615,(void*)0},{&g_279[1][1][0],(void*)0,&l_1478[4],&l_1478[2],&g_279[6][1][0],(void*)0,&g_615,&g_1165,&g_279[3][3][0]},{&l_1478[2],&l_1478[2],&g_279[1][1][0],&g_279[0][0][0],(void*)0,&g_279[3][2][0],&g_279[7][2][0],&l_1478[3],&g_279[7][2][0]},{&l_1478[2],&g_279[1][1][0],&g_279[1][1][0],&g_279[1][1][0],&g_279[1][1][0],&l_1478[2],&l_1478[2],&l_1478[2],&l_1478[2]},{&g_279[1][1][0],&g_279[7][2][0],(void*)0,(void*)0,&l_1478[5],&g_279[1][1][0],&g_279[1][1][0],&g_615,&l_1478[4]}},{{&l_1478[0],&g_279[8][0][0],&g_279[6][1][0],&g_279[3][3][0],&g_1165,&g_615,&l_1478[2],(void*)0,&g_279[1][1][0]},{&l_1478[2],&g_615,&l_1478[2],&g_279[7][2][0],&l_1478[4],&l_1478[4],&g_279[7][2][0],&l_1478[2],&g_615},{&g_279[6][1][0],&l_1478[0],&l_1478[2],&l_1478[2],&l_1478[2],(void*)0,&g_615,&g_279[3][3][0],&g_279[1][1][0]},{&g_279[1][1][0],&g_279[3][2][0],&g_279[0][0][0],&l_1478[4],&g_615,(void*)0,&l_1478[2],(void*)0,&g_279[6][3][0]},{&l_1478[2],&l_1478[0],&l_1478[2],&g_279[1][1][0],&g_279[6][0][0],&l_1478[2],&g_279[1][1][0],&g_279[1][1][0],&l_1478[2]},{&l_1478[2],&g_615,&g_279[1][1][0],&g_615,&l_1478[2],&l_1478[2],&g_615,&g_279[3][2][0],&g_615}}};
int i, j, k;
for (g_276.f1 = 1; (g_276.f1 >= 0); g_276.f1 -= 1)
{ /* block id: 642 */
const union U1 ***l_1450 = (void*)0;
const union U1 ***l_1451[2][4] = {{&l_1448[3],(void*)0,&l_1448[3],&l_1448[3]},{(void*)0,(void*)0,&l_1448[3],(void*)0}};
int8_t *l_1460 = &g_1082[2][1][3];
int32_t *l_1462 = &l_1418;
int32_t *l_1463[7];
int i, j, k;
for (i = 0; i < 7; i++)
l_1463[i] = (void*)0;
(*l_1462) = (l_1417[(g_276.f1 + 2)][g_480][g_276.f1] = (l_1417[(g_276.f1 + 1)][g_480][(g_480 + 5)] ^ ((0x36L == l_1417[(g_276.f1 + 2)][g_480][(g_276.f1 + 7)]) < (((*l_1460) = ((-10L) && ((safe_sub_func_uint64_t_u_u(((((((((g_128 <= ((l_1448[1] = l_1448[3]) == (((4294967295UL < ((g_1368[0][3].f4 , ((((((!(safe_div_func_uint64_t_u_u((safe_mul_func_int8_t_s_s(((~((*g_967) , (*g_215))) && 0xD36CL), g_209.f2)), l_1417[(g_276.f1 + 2)][g_480][(g_276.f1 + 7)]))) & g_276.f7) == g_1368[0][3].f6) > p_46) > g_412.f0) || l_1458)) <= 0xA2L)) , p_46) , (*g_551)))) , (*g_158)) == 0L) != (*l_1445)) , g_1459) , p_46) >= 0L) , 0UL), p_46)) , p_46))) < l_1461))));
l_1465--;
(*l_1462) = l_1465;
}
for (g_1218.f1 = 0; (g_1218.f1 <= 1); g_1218.f1 += 1)
{ /* block id: 652 */
int32_t *l_1470 = (void*)0;
int32_t l_1471[10] = {2L,2L,(-10L),1L,(-10L),2L,2L,(-10L),1L,(-10L)};
int32_t *l_1472 = &g_968[1].f1;
int32_t *l_1473 = &g_412.f0;
int32_t *l_1475 = &g_276.f1;
int32_t *l_1476[10] = {&g_1380.f0,&l_1418,&g_1380.f0,&g_1380.f0,&l_1418,&g_1380.f0,&g_1380.f0,&l_1418,&g_1380.f0,&g_1380.f0};
int i;
--l_1478[2];
return l_1481[5][1];
}
if ((safe_lshift_func_uint8_t_u_s((0x3226C51E87692896LL == p_46), p_46)))
{ /* block id: 656 */
return l_1484;
}
else
{ /* block id: 658 */
int64_t **l_1489 = &l_1425[5][2][3];
uint16_t *l_1493 = (void*)0;
int16_t *l_1494 = (void*)0;
int32_t l_1495[8][3][7] = {{{(-1L),0x7885DDF5L,1L,0x4F978DA6L,0x74AFCAD8L,0x60E56BE4L,0x93AA8D17L},{1L,0x9C31501AL,0xB1A238B9L,9L,9L,0xB1A238B9L,0x9C31501AL},{0x93AA8D17L,0L,0x50DA7C5BL,(-3L),0x7885DDF5L,0xC65D83A8L,1L}},{{(-1L),0x7DC59B22L,0x5381A46BL,2L,0x205359FAL,(-1L),0xB43CDD44L},{0x2AB63720L,0x74AFCAD8L,0xC65D83A8L,0xC65D83A8L,0x74AFCAD8L,0x2AB63720L,0x5DB8CA7EL},{0x5381A46BL,0xB43CDD44L,1L,0L,0x9C31501AL,0x90B394C0L,8L}},{{0xBB475EB4L,1L,1L,0x2AB63720L,(-3L),0x74AFCAD8L,(-3L)},{0x9C31501AL,0xB43CDD44L,0xB43CDD44L,0x9C31501AL,0x7DC59B22L,0L,(-1L)},{0x60E56BE4L,0x74AFCAD8L,0x4F978DA6L,1L,0x7885DDF5L,(-1L),0xC65D83A8L}},{{0x90B394C0L,0x7DC59B22L,(-1L),0xB1A238B9L,0x5381A46BL,0xB1A238B9L,(-1L)},{1L,1L,0x93AA8D17L,0x50DA7C5BL,(-1L),0x5DB8CA7EL,(-3L)},{0xD6FE6067L,1L,1L,0xB43CDD44L,0x90B394C0L,2L,8L}},{{0x5DB8CA7EL,0x8609383FL,(-1L),(-3L),(-1L),0x8609383FL,0x5DB8CA7EL},{9L,0xB1A238B9L,0x9C31501AL,1L,0x5381A46BL,8L,0xB43CDD44L},{0xC65D83A8L,0x4F978DA6L,0x66AD1A35L,0L,0x7885DDF5L,0xBB475EB4L,0xBB475EB4L}},{{0x7DC59B22L,0L,0x9C31501AL,0L,0x7DC59B22L,0xD6FE6067L,1L},{0x93AA8D17L,0x50DA7C5BL,(-1L),0x5DB8CA7EL,(-3L),0x0143E532L,0x7885DDF5L},{0L,0xD338A464L,1L,0x205359FAL,0x9C31501AL,0x9C31501AL,0x205359FAL}},{{0x93AA8D17L,0x5DB8CA7EL,0x93AA8D17L,0x60E56BE4L,0x74AFCAD8L,0x4F978DA6L,1L},{0x7DC59B22L,0L,(-1L),0xD6FE6067L,0x205359FAL,1L,9L},{0xC65D83A8L,0x93AA8D17L,0x4F978DA6L,0x8609383FL,0x8609383FL,0x4F978DA6L,0x93AA8D17L}},{{9L,0x5381A46BL,0xB43CDD44L,1L,0L,0x9C31501AL,0x90B394C0L},{0x5DB8CA7EL,0x66AD1A35L,1L,(-1L),1L,0x0143E532L,0L},{0xD6FE6067L,8L,1L,1L,8L,0xD6FE6067L,0xB1A238B9L}}};
int32_t *l_1496 = &g_412.f0;
uint64_t **l_1507 = &g_158;
const int32_t l_1550 = 0L;
uint8_t *l_1558 = &g_1111.f1;
int8_t *l_1572[3][1];
int i, j, k;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 1; j++)
l_1572[i][j] = (void*)0;
}
(*l_1496) ^= ((((0L >= ((g_1485 , ((safe_mul_func_int16_t_s_s((*g_215), (l_1461 >= p_46))) != (((*l_1489) = l_1488) == l_1490))) | ((safe_add_func_int16_t_s_s((l_1495[5][2][2] &= ((g_724.f0 > ((*l_1445) = 0UL)) == 1L)), 0L)) && 0UL))) == (-1L)) && p_46) && 4294967295UL);
(*l_1445) = (safe_div_func_uint64_t_u_u(((l_1418 ^= (safe_div_func_int64_t_s_s((((((g_1501 , (!p_46)) >= (safe_mul_func_int16_t_s_s((safe_mod_func_int64_t_s_s(p_46, ((*l_1488) &= (l_1507 == l_1508)))), (((safe_sub_func_uint8_t_u_u((0x806E57886FAD68F2LL & ((safe_mod_func_uint32_t_u_u(((safe_sub_func_int64_t_s_s((l_1515 != (void*)0), (((safe_add_func_uint8_t_u_u((l_1518[4][1] != l_1528), g_1218.f1)) ^ g_1368[0][3].f7) , g_615))) || 0x53L), (*l_1496))) != g_1521.f5)), p_46)) , p_46) <= (*l_1496))))) , (*g_215)) == g_1525.f3) != 0xD85BBE26L), g_1218.f1))) <= p_46), p_46));
(*l_1496) = ((safe_div_func_uint32_t_u_u(((l_1532[0][0] <= (*l_1445)) | (safe_lshift_func_uint8_t_u_u((safe_mod_func_uint32_t_u_u((l_1474[0] = (safe_sub_func_uint64_t_u_u(0x47BD591F8E029E55LL, ((safe_rshift_func_uint8_t_u_u(p_46, 0)) < 1L)))), p_46)), 1))), (*l_1496))) < ((safe_rshift_func_int8_t_s_u((safe_mul_func_uint16_t_u_u(((((safe_mul_func_uint8_t_u_u((((((safe_lshift_func_int16_t_s_u(((((g_1549[1][2][1] , (l_1458 , p_46)) >= p_46) < p_46) & 0L), 4)) == g_21) ^ p_46) <= 0x2F5BD03574C2031ELL) && (*g_215)), (*l_1445))) , &g_393) != &g_393) , l_1550), 0UL)), g_878.f2)) > l_1461));
(*l_1445) |= ((*g_1222) = (((p_46 = 7UL) ^ (((safe_div_func_uint16_t_u_u((safe_lshift_func_int16_t_s_s(((l_1555 != (((((safe_mod_func_uint64_t_u_u((((++(*l_1558)) > (!((*l_1496) ^ (((safe_mod_func_int8_t_s_s(1L, (g_1564 , (safe_unary_minus_func_uint32_t_u((safe_rshift_func_int8_t_s_s((safe_rshift_func_int8_t_s_s((l_1468 , (g_724.f1 ^ 0xECL)), (l_1474[2] ^= (!((l_1571[1][3][3] = l_1443) == &l_1478[2]))))), 3))))))) , &g_1020) != &g_1020)))) || (*l_1496)), 0x6EDC36D2B99FC1E6LL)) , l_1573[0]) == l_1574) | 0UL) , l_1555)) >= 1UL), 10)), g_1218.f2)) , g_85) ^ l_1458)) | g_1522.f0));
}
}
else
{ /* block id: 675 */
uint8_t l_1582 = 0x7BL;
int32_t l_1583 = 3L;
int8_t *l_1590 = &g_1082[2][1][1];
if (((safe_lshift_func_uint8_t_u_s((p_46 , (safe_lshift_func_int8_t_s_s(((*l_1590) &= (((*g_1143) = (safe_sub_func_int16_t_s_s((((+p_46) | (((l_1582 == p_46) , 0xE39B562FL) == 0xFFC5C7AFL)) , (l_1583 == (safe_div_func_int16_t_s_s((((safe_mul_func_int8_t_s_s(g_1527.f7, (((safe_rshift_func_uint8_t_u_u(((((0xB8L > p_46) && 0L) >= p_46) ^ l_1465), 6)) , &g_216) == &g_825))) , g_126) ^ g_1526.f5), p_46)))), p_46))) < 0x53084AC2L)), l_1434))), 3)) >= (-1L)))
{ /* block id: 678 */
int32_t **l_1591 = &l_1443;
(*l_1445) |= (((*l_1591) = &l_1583) == (l_1592[2] = &l_1434));
(*l_1591) = (*l_1591);
if (p_46)
break;
}
else
{ /* block id: 684 */
(*l_1438) = &l_1477;
}
}
(*g_1107) = (l_1532[1][0] < (+(((safe_unary_minus_func_int16_t_s(0x0E95L)) , l_1595) == (l_1599 = (*l_1508)))));
if (p_46)
{ /* block id: 690 */
int16_t l_1602 = (-10L);
int32_t l_1603 = 1L;
int32_t l_1604 = 0x742B5F81L;
int32_t l_1606 = 0xD9319C5BL;
int32_t l_1610 = 0x890F5174L;
int32_t l_1611 = 5L;
int32_t l_1612 = (-6L);
int32_t l_1614 = 0x972B65E0L;
int32_t l_1615 = 0xBA1549BEL;
int32_t l_1616[3];
int i;
for (i = 0; i < 3; i++)
l_1616[i] = 0x4B37E01BL;
l_1600 = &g_917[5];
++l_1618;
}
else
{ /* block id: 693 */
struct S0 ***l_1641 = &g_966;
struct S0 ****l_1642[1];
struct S0 ** const *l_1644[7] = {&g_966,&g_966,&g_966,&g_966,&g_966,&g_966,&g_966};
int8_t *l_1645 = &g_152;
int32_t l_1648 = 0L;
int i;
for (i = 0; i < 1; i++)
l_1642[i] = &l_1641;
l_1648 = (l_1647 = (safe_div_func_uint64_t_u_u((safe_unary_minus_func_int64_t_s((safe_mod_func_int8_t_s_s((l_1474[0] = (((safe_add_func_int16_t_s_s((l_1613[3] = (p_46 ^ (!((safe_rshift_func_int8_t_s_s((((p_46 & ((((((*l_1528) , ((safe_rshift_func_int16_t_s_u((safe_add_func_uint64_t_u_u(((((*l_1445) = ((((p_46 , ((*l_1488) = p_46)) != p_46) && (safe_lshift_func_int8_t_s_u(((safe_mul_func_int16_t_s_s(((safe_rshift_func_int8_t_s_u((((l_1643 = l_1641) != l_1644[1]) , ((*l_1645) = g_128)), 1)) || g_1646), p_46)) || (*l_1445)), g_85))) != l_1478[6])) || 0xE9FAC844L) , 0x4284E92DCC5B9539LL), p_46)), 2)) & p_46)) != p_46) < p_46) , &g_1020) == (void*)0)) && g_216) || p_46), g_1111.f1)) || p_46)))), g_878.f2)) < l_1532[0][0]) , g_1521.f3)), 2UL)))), p_46)));
return l_1481[3][1];
}
}
else
{ /* block id: 704 */
union U1 ***l_1680 = &g_552;
int32_t l_1683 = 1L;
uint64_t **l_1695 = &g_158;
const uint16_t *l_1719 = &g_204[0];
const uint16_t **l_1718 = &l_1719;
if ((safe_lshift_func_uint8_t_u_u(((safe_lshift_func_uint16_t_u_s(((p_46 | (p_46 < p_46)) ^ 0xB2L), (*g_215))) && 0xC5BBA807L), 5)))
{ /* block id: 705 */
uint8_t *l_1656 = &g_848.f1;
uint16_t *l_1671 = &g_204[1];
int16_t *l_1674 = &l_1660;
int64_t ***l_1677 = &g_393;
int64_t ****l_1678 = (void*)0;
int16_t *l_1682 = &g_827;
int32_t l_1707 = 1L;
int32_t *l_1711[1];
int i;
for (i = 0; i < 1; i++)
l_1711[i] = &g_1416.f0;
if (g_1653)
break;
l_1683 = (((((**g_551) != (l_1659 = ((safe_mul_func_uint8_t_u_u((--(*l_1656)), 1UL)) , l_1659))) >= l_1660) && (safe_lshift_func_int16_t_s_u(((safe_lshift_func_int16_t_s_s((safe_rshift_func_uint16_t_u_s((safe_sub_func_int64_t_s_s(p_46, (safe_lshift_func_uint16_t_u_s(((*l_1671)--), ((*l_1674) = (*g_215)))))), ((*l_1682) &= (safe_lshift_func_int16_t_s_u(((l_1679 = l_1677) != (((g_357 ^= (p_46 | (l_1680 == (void*)0))) == 0xF6E0A61998FC623BLL) , l_1681)), 14))))), g_276.f5)) || l_1683), 8))) && l_1684[1]);
(*l_1438) = &l_1477;
for (g_1131.f0 = 0; (g_1131.f0 >= 0); g_1131.f0 -= 1)
{ /* block id: 718 */
uint64_t ***l_1692 = &l_1691[3][0][0];
uint64_t **l_1693 = &g_158;
uint64_t ***l_1694 = &l_1508;
int32_t *l_1709 = (void*)0;
int32_t **l_1710 = &g_50;
int i;
(*l_1438) = (((safe_sub_func_uint16_t_u_u(0xF994L, 2UL)) , (safe_rshift_func_uint8_t_u_u((safe_rshift_func_int16_t_s_u(((*l_1682) = (((*l_1490) &= (((*l_1692) = l_1691[3][0][0]) == (l_1695 = ((*l_1694) = l_1693)))) > ((safe_unary_minus_func_int32_t_s(l_1478[(g_480 + 6)])) >= p_46))), (((safe_rshift_func_int8_t_s_s(((p_46 >= (((safe_mul_func_int8_t_s_s((g_1564.f0 == (safe_sub_func_uint16_t_u_u((((((safe_lshift_func_uint16_t_u_s((safe_lshift_func_int16_t_s_s(3L, l_1683)), (*l_1435))) ^ p_46) & l_1478[(g_480 + 6)]) > 0xEE95L) <= p_46), l_1707))), g_1520.f6)) && g_1708) , p_46)) ^ p_46), g_1523.f0)) >= g_724.f0) != p_46))), 5))) , &l_1707);
if (p_46)
break;
l_1711[0] = ((*l_1710) = l_1709);
return l_1712;
}
}
else
{ /* block id: 730 */
const uint16_t *l_1717 = &g_204[1];
const uint16_t ** const l_1716 = &l_1717;
int32_t l_1727[2];
int i;
for (i = 0; i < 2; i++)
l_1727[i] = 0x2BC59056L;
if ((l_1474[1] = p_46))
{ /* block id: 732 */
uint16_t l_1713 = 0xA39AL;
l_1713--;
l_1718 = l_1716;
if (g_209.f2)
goto lbl_1439;
}
else
{ /* block id: 736 */
uint64_t l_1723 = 1UL;
uint8_t *l_1726[3][9][2] = {{{&g_1501.f1,&g_1111.f1},{&g_1501.f1,&g_359},{(void*)0,&g_1501.f1},{&g_359,&g_1111.f1},{&g_1380.f1,&g_1380.f1},{(void*)0,&g_1380.f1},{&g_1380.f1,&g_1111.f1},{&g_359,&g_1501.f1},{(void*)0,&g_359}},{{&g_1501.f1,&g_1111.f1},{&g_1501.f1,&g_359},{(void*)0,&g_1501.f1},{&g_359,&g_1111.f1},{&g_1380.f1,&g_1380.f1},{(void*)0,&g_1380.f1},{&g_1380.f1,&g_1111.f1},{&g_359,&g_1501.f1},{(void*)0,&g_359}},{{&g_1501.f1,&g_1111.f1},{(void*)0,&g_1111.f1},{&l_1532[0][0],(void*)0},{&g_1111.f1,&g_1111.f1},{(void*)0,(void*)0},{&l_1532[0][0],(void*)0},{(void*)0,&g_1111.f1},{&g_1111.f1,(void*)0},{&l_1532[0][0],&g_1111.f1}}};
struct S0 **l_1731[7][8][4] = {{{&l_1518[4][1],&l_1518[1][1],(void*)0,&g_967},{(void*)0,&g_967,&g_967,(void*)0},{(void*)0,&g_967,&g_967,&g_967},{&g_967,&l_1518[1][1],&g_967,&g_967},{&g_967,(void*)0,&g_967,&g_967},{&l_1518[4][1],&l_1518[1][1],&l_1518[4][1],&g_967},{&l_1518[4][1],&g_967,&g_967,&l_1518[4][1]},{&g_967,&g_967,&g_967,&g_967}},{{&g_967,&l_1518[1][1],&g_967,&g_967},{(void*)0,&g_967,&g_967,&g_967},{(void*)0,&l_1518[1][1],(void*)0,&g_967},{&l_1518[4][1],&g_967,&l_1518[4][1],&l_1518[4][1]},{(void*)0,&g_967,&g_967,&g_967},{&g_967,&l_1518[1][1],&g_967,&g_967},{(void*)0,(void*)0,&l_1518[4][1],&g_967},{&l_1518[4][1],&l_1518[1][1],(void*)0,&g_967}},{{(void*)0,&g_967,&g_967,(void*)0},{(void*)0,&g_967,&g_967,&g_967},{&g_967,&l_1518[1][1],&g_967,&g_967},{&g_967,(void*)0,&g_967,&g_967},{&l_1518[4][1],&l_1518[1][1],&l_1518[4][1],&g_967},{&l_1518[4][1],&g_967,&g_967,&l_1518[4][1]},{&g_967,&g_967,&g_967,&g_967},{&g_967,&l_1518[1][1],&g_967,&g_967}},{{(void*)0,&g_967,&g_967,&g_967},{(void*)0,&l_1518[1][1],(void*)0,&g_967},{&l_1518[4][1],&g_967,&l_1518[4][1],&l_1518[4][1]},{(void*)0,&g_967,&g_967,&g_967},{&g_967,&l_1518[1][1],&g_967,&g_967},{(void*)0,(void*)0,&l_1518[4][1],&g_967},{&l_1518[4][1],&l_1518[1][1],(void*)0,&g_967},{(void*)0,&g_967,&g_967,(void*)0}},{{(void*)0,&g_967,&g_967,&g_967},{&g_967,&l_1518[1][1],&g_967,&g_967},{&g_967,(void*)0,&g_967,&g_967},{&l_1518[4][1],&l_1518[1][1],&l_1518[4][1],&g_967},{&l_1518[4][1],&g_967,&g_967,&l_1518[4][1]},{&g_967,&g_967,&g_967,&g_967},{&g_967,&l_1518[1][1],&g_967,&g_967},{(void*)0,&g_967,&g_967,&g_967}},{{(void*)0,&l_1518[1][1],(void*)0,&g_967},{&l_1518[4][1],&g_967,&l_1518[4][1],&l_1518[4][1]},{(void*)0,&g_967,&g_967,&g_967},{&g_967,&l_1518[1][1],&g_967,&l_1518[4][1]},{&g_967,&g_967,&l_1518[4][1],&l_1518[1][1]},{&g_967,(void*)0,&g_967,(void*)0},{&g_967,(void*)0,&l_1518[4][1],&g_967},{&g_967,(void*)0,&l_1518[1][1],(void*)0}},{{(void*)0,(void*)0,&l_1518[4][1],&l_1518[1][1]},{&l_1518[4][1],&g_967,&l_1518[4][1],&l_1518[4][1]},{&g_967,&g_967,&g_967,(void*)0},{&g_967,&l_1518[4][1],&l_1518[4][1],&g_967},{&l_1518[4][1],(void*)0,&l_1518[4][1],&l_1518[4][1]},{(void*)0,&g_967,&l_1518[1][1],&l_1518[1][1]},{&g_967,&l_1518[4][1],&l_1518[4][1],&l_1518[1][1]},{&g_967,&g_967,&g_967,&l_1518[4][1]}}};
uint32_t *l_1732[3];
int8_t *l_1748 = &g_152;
uint8_t l_1749 = 1UL;
int32_t l_1750 = 0x76761C19L;
int i, j, k;
for (i = 0; i < 3; i++)
l_1732[i] = &g_279[6][3][0];
l_1723 ^= (l_1643 == (g_1720[4][5] , l_1721));
l_1750 = ((l_1727[1] = (safe_sub_func_uint8_t_u_u(l_1683, l_1465))) , ((((safe_mul_func_uint8_t_u_u((((g_1730 , ((***g_551) , l_1731[4][4][1])) == (*g_965)) | ((g_1165 = (++g_279[6][2][0])) >= ((*g_158) & (safe_mul_func_uint8_t_u_u(g_1501.f1, (l_1474[0] = (((((((safe_sub_func_int8_t_s_s((safe_add_func_int8_t_s_s(((*l_1748) &= (safe_div_func_int32_t_s_s((safe_rshift_func_int16_t_s_s((((safe_sub_func_uint64_t_u_u(l_1747[5], p_46)) != g_1523.f3) != 0xEB7BL), 6)), p_46))), l_1723)), p_46)) , l_1613[1]) < l_1749) ^ 0xE5167E98L) , p_46) >= (*g_158)) && g_1524[1].f0))))))), 0x64L)) <= p_46) < 0x55D0AB9171A3ACB8LL) & g_1520.f0));
}
return l_1751;
}
return l_1712;
}
}
}
for (g_149 = 0; (g_149 <= 21); g_149 = safe_add_func_uint16_t_u_u(g_149, 1))
{ /* block id: 753 */
uint16_t l_1756[2];
union U2 *l_1761[7] = {&g_1485,&g_1485,&g_1485,&g_1485,&g_1485,&g_1485,&g_1485};
uint16_t *l_1764[5][3] = {{&g_149,&g_149,&g_149},{&g_204[1],&g_204[1],&g_204[1]},{&g_149,&g_149,&g_149},{&g_204[1],&g_204[1],&g_204[1]},{&g_149,&g_149,&g_149}};
int32_t l_1766[7];
int32_t l_1769 = 0x76EF261BL;
int i, j;
for (i = 0; i < 2; i++)
l_1756[i] = 0x95FBL;
for (i = 0; i < 7; i++)
l_1766[i] = 0xC2326B4CL;
for (g_1527.f5 = 0; (g_1527.f5 != 26); g_1527.f5 = safe_add_func_uint32_t_u_u(g_1527.f5, 1))
{ /* block id: 756 */
--l_1756[1];
}
for (g_1416.f0 = 0; (g_1416.f0 < 25); ++g_1416.f0)
{ /* block id: 761 */
l_1592[2] = (void*)0;
return l_1761[5];
}
l_1769 = ((*g_1143) |= (safe_mul_func_uint16_t_u_u((l_1766[6] = (g_204[0]--)), 5L)));
return l_1761[0];
}
return l_1770;
}
/* ------------------------------------------ */
/*
* reads : g_22 g_366 g_215 g_216 g_552 g_553 g_551 g_848.f0 g_159 g_50 g_21 g_412.f0 g_968.f3 g_848.f3 g_158 g_1107 g_149 g_362 g_295 g_294 g_480 g_1111 g_852 g_1380 g_1416.f0
* writes: g_22 g_366 g_1082 g_553 g_848.f0 g_159 g_149 g_276.f7 g_295 g_480 g_50 g_852
*/
static union U1 func_47(int32_t ** p_48)
{ /* block id: 19 */
int16_t l_57[2][6] = {{(-1L),0xF073L,0xF073L,(-1L),0xF073L,0xF073L},{(-1L),0xF073L,0xF073L,(-1L),0xF073L,0xF073L}};
const int32_t ** const l_919 = &g_295[0];
int32_t l_1083 = 0x7ECE6F30L;
uint8_t *l_1093 = (void*)0;
int32_t l_1113[3];
int8_t l_1114[8] = {0xEBL,0xEBL,0xEBL,0xEBL,0xEBL,0xEBL,0xEBL,0xEBL};
uint16_t l_1116 = 65535UL;
uint8_t l_1129 = 0xCDL;
int32_t * const l_1142 = &g_85;
uint16_t l_1152[7] = {0x0802L,0x0802L,0x0802L,0x0802L,0x0802L,0x0802L,0x0802L};
int32_t l_1191 = 0x11598E05L;
uint64_t l_1192 = 18446744073709551613UL;
int32_t *l_1219 = &g_1131.f0;
uint32_t l_1267[4];
const int8_t l_1302 = (-1L);
int i, j;
for (i = 0; i < 3; i++)
l_1113[i] = 0xF00A7FA3L;
for (i = 0; i < 4; i++)
l_1267[i] = 0x1F6F8DFEL;
for (g_22 = 0; (g_22 != (-11)); --g_22)
{ /* block id: 22 */
uint8_t l_64 = 0x77L;
uint8_t *l_65 = (void*)0;
uint8_t *l_66 = (void*)0;
uint8_t *l_67 = &l_64;
int32_t l_83[4] = {0x6EC8B7CFL,0x6EC8B7CFL,0x6EC8B7CFL,0x6EC8B7CFL};
int32_t *l_84 = &g_85;
union U2 *l_99 = (void*)0;
union U2 **l_98[5] = {&l_99,&l_99,&l_99,&l_99,&l_99};
uint64_t l_920 = 1UL;
int i;
}
for (g_366 = 1; (g_366 >= 0); g_366 -= 1)
{ /* block id: 468 */
int16_t *l_1079[8][9] = {{&g_825,(void*)0,(void*)0,&l_57[0][1],&l_57[0][1],(void*)0,(void*)0,&g_825,&g_827},{&l_57[0][1],(void*)0,&g_825,&l_57[0][1],(void*)0,&l_57[0][1],&g_827,(void*)0,&l_57[1][5]},{&l_57[0][1],(void*)0,&l_57[0][1],&g_825,&g_827,(void*)0,&g_827,&l_57[1][5],&g_827},{(void*)0,&l_57[1][4],&l_57[0][1],&l_57[0][1],&g_827,&g_827,&l_57[0][1],&l_57[0][1],&l_57[1][4]},{(void*)0,&g_827,&l_57[1][5],&g_827,(void*)0,&g_827,&g_825,&l_57[0][1],(void*)0},{&l_57[0][1],&l_57[1][5],(void*)0,&g_827,&l_57[0][1],(void*)0,&l_57[0][1],&g_825,(void*)0},{&l_57[0][1],&g_827,&g_825,(void*)0,(void*)0,&l_57[0][1],&l_57[0][1],(void*)0,(void*)0},{&g_825,&l_57[1][4],&g_825,&g_827,&g_827,(void*)0,&l_57[0][1],&g_827,(void*)0}};
int32_t l_1080[3];
const int32_t l_1081 = 1L;
uint8_t *l_1094 = &g_359;
int32_t l_1115 = 6L;
int32_t l_1119 = (-2L);
int i, j;
for (i = 0; i < 3; i++)
l_1080[i] = (-1L);
g_1082[1][0][0] = (((l_1080[1] = (*g_215)) ^ l_1081) == 246UL);
(**g_551) = (*g_552);
for (g_848.f0 = 0; (g_848.f0 <= 1); g_848.f0 += 1)
{ /* block id: 474 */
const int32_t *l_1086 = (void*)0;
uint16_t *l_1105 = &g_149;
int64_t l_1106 = 0L;
int i, j;
l_1083 ^= l_57[g_848.f0][(g_848.f0 + 2)];
for (g_159 = 10; (g_159 <= 3); --g_159)
{ /* block id: 478 */
l_1086 = l_1086;
if ((**p_48))
continue;
}
(*g_1107) = (safe_sub_func_uint8_t_u_u((safe_mod_func_int16_t_s_s((((safe_lshift_func_uint16_t_u_u(l_57[g_848.f0][(g_848.f0 + 2)], 9)) , l_1093) == (l_1094 = &g_359)), (((safe_mod_func_int16_t_s_s((((~(((void*)0 != &g_965) & (safe_div_func_int8_t_s_s((safe_mod_func_uint32_t_u_u((0x94L == (((+((*l_1105) = (safe_lshift_func_uint16_t_u_s(l_1080[1], (*g_215))))) < ((((g_412.f0 < 0x3536L) & g_968[1].f3) != (**p_48)) ^ l_1080[1])) > 4L)), l_1081)), g_848.f3)))) , (*g_158)) & (*g_158)), 65533UL)) || (*g_158)) , l_1106))), 0x53L));
}
for (g_848.f0 = 0; (g_848.f0 <= 1); g_848.f0 += 1)
{ /* block id: 488 */
uint16_t l_1110 = 65527UL;
int32_t *l_1112[3][8] = {{&g_366,&g_276.f3,&g_276.f3,&g_366,(void*)0,&g_366,&g_276.f3,&g_276.f3},{&g_276.f3,(void*)0,&g_88,(void*)0,&l_1080[1],&g_366,&l_1080[1],(void*)0},{&g_88,&l_1080[1],&g_88,&g_366,&g_366,&g_88,&l_1080[1],&g_88}};
int i, j;
for (g_149 = 0; (g_149 <= 1); g_149 += 1)
{ /* block id: 491 */
int32_t *l_1109[10] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0};
int i, j;
l_1110 &= l_57[g_848.f0][(g_848.f0 + 2)];
(*g_294) = (*g_362);
for (g_480 = 1; (g_480 >= 0); g_480 -= 1)
{ /* block id: 496 */
return g_1111;
}
}
++l_1116;
l_1119 = (l_1080[1] = l_57[g_848.f0][(g_848.f0 + 4)]);
}
}
for (l_1083 = (-25); (l_1083 <= 22); l_1083++)
{ /* block id: 507 */
const int16_t l_1122 = 1L;
int32_t l_1130 = 0xB99F8FCEL;
int32_t l_1150[6][9] = {{(-9L),0x7E91586AL,5L,1L,3L,0x0357D4BEL,0x95C3A1D7L,0x7E91586AL,0L},{(-9L),0xBC79572CL,0x95C3A1D7L,1L,0x7E91586AL,1L,0x95C3A1D7L,0xBC79572CL,(-9L)},{(-9L),3L,0x9A194994L,1L,0xBC79572CL,0x014C5B56L,0x95C3A1D7L,3L,0xC53803AAL},{(-9L),0x7E91586AL,5L,1L,3L,0x0357D4BEL,0x95C3A1D7L,0x7E91586AL,0L},{(-9L),0xBC79572CL,0x95C3A1D7L,1L,0x7E91586AL,1L,0x95C3A1D7L,0xBC79572CL,(-9L)},{(-9L),3L,0x9A194994L,1L,0xBC79572CL,0x014C5B56L,0x95C3A1D7L,3L,0xC53803AAL}};
uint32_t l_1337 = 0UL;
struct S0 *l_1348 = &g_276;
int i, j;
(*p_48) = (void*)0;
if (l_1122)
continue;
for (g_852 = 21; (g_852 >= (-2)); g_852--)
{ /* block id: 512 */
uint32_t l_1125[8] = {0xE2941C0EL,18446744073709551615UL,0xE2941C0EL,0xE2941C0EL,18446744073709551615UL,0xE2941C0EL,0xE2941C0EL,18446744073709551615UL};
int16_t l_1156 = 0x1DFFL;
int32_t l_1157 = 0L;
int32_t l_1161 = (-9L);
int32_t l_1163 = 1L;
int32_t l_1176 = 1L;
int32_t l_1180 = 0xF16F97EFL;
int32_t l_1182 = 0x5248E14DL;
int32_t l_1183 = 0x8F6A016FL;
int32_t l_1184 = 0x47CEA8D2L;
int32_t l_1185[10] = {(-3L),(-3L),(-3L),(-3L),(-3L),(-3L),(-3L),(-3L),(-3L),(-3L)};
struct S0 **l_1235 = &g_967;
uint8_t l_1260 = 255UL;
int64_t l_1305[2];
uint16_t *l_1350[1];
struct S0 *l_1355 = &g_968[3];
struct S0 **l_1354 = &l_1355;
uint8_t *l_1356 = &g_848.f1;
int16_t *l_1357 = &g_827;
int i;
for (i = 0; i < 2; i++)
l_1305[i] = 4L;
for (i = 0; i < 1; i++)
l_1350[i] = &g_204[1];
}
}
return g_1380;
}
/* ------------------------------------------ */
/*
* reads : g_73.f3 g_158 g_128 g_159 g_209.f0 g_276.f3 g_965 g_149 g_209.f4 g_412.f0 g_878.f4 g_983 g_992 g_412.f3 g_983.f2 g_11 g_552 g_553 g_412 g_848.f1 g_1019 g_204 g_366 g_1032 g_466 g_1020 g_215 g_216 g_1061
* writes: g_965 g_466 g_152 g_276.f3 g_412.f0 g_878.f4 g_1019 g_615 g_149 g_366 g_1061 g_295 g_968.f1
*/
static union U2 ** func_53(const int32_t ** const p_54, uint8_t p_55, union U2 ** p_56)
{ /* block id: 388 */
uint32_t *l_921[7][8] = {{&g_615,&g_279[5][0][0],&g_279[3][3][0],(void*)0,&g_279[5][0][0],(void*)0,&g_279[3][3][0],&g_279[5][0][0]},{&g_615,&g_279[3][3][0],&g_615,&g_615,(void*)0,(void*)0,&g_615,&g_615},{&g_279[5][0][0],&g_279[5][0][0],(void*)0,&g_279[1][1][0],&g_615,(void*)0,&g_615,&g_279[1][1][0]},{&g_615,&g_279[1][1][0],&g_615,(void*)0,&g_279[1][1][0],&g_279[3][3][0],&g_279[3][3][0],&g_279[1][1][0]},{&g_279[1][1][0],&g_279[3][3][0],&g_279[3][3][0],&g_279[1][1][0],(void*)0,&g_615,&g_279[1][1][0],&g_615},{&g_279[1][1][0],&g_615,(void*)0,&g_615,&g_279[1][1][0],(void*)0,&g_279[5][0][0],&g_279[5][0][0]},{&g_615,&g_615,(void*)0,(void*)0,&g_615,&g_615,&g_279[3][3][0],&g_615}};
int32_t l_923[9] = {0x919B631FL,0x919B631FL,0x919B631FL,0x919B631FL,0x919B631FL,0x919B631FL,0x919B631FL,0x919B631FL,0x919B631FL};
uint32_t l_925 = 4294967291UL;
int64_t l_939 = 1L;
uint64_t l_949[10] = {4UL,0x9538D9B606BEDE21LL,4UL,1UL,1UL,4UL,0x9538D9B606BEDE21LL,4UL,1UL,1UL};
int32_t l_957 = (-5L);
union U1 ****l_1009 = &g_551;
union U1 *****l_1008 = &l_1009;
int32_t *l_1067 = &g_88;
int32_t *l_1068 = (void*)0;
int32_t *l_1069 = &g_968[1].f1;
int32_t *l_1070 = &g_366;
int32_t *l_1071 = (void*)0;
int32_t *l_1072 = &g_412.f0;
int32_t *l_1073 = &l_923[0];
int32_t *l_1074[4][3][1] = {{{&g_209.f4},{&g_21},{(void*)0}},{{&g_968[1].f7},{(void*)0},{&g_21}},{{&g_209.f4},{&g_21},{(void*)0}},{{&g_968[1].f7},{(void*)0},{&g_21}}};
uint64_t l_1075 = 0x8D687264AAF44F77LL;
int i, j, k;
if (((void*)0 != l_921[6][3]))
{ /* block id: 389 */
int32_t *l_922 = &g_852;
int32_t *l_924[1][5][5] = {{{(void*)0,&g_22,&g_878.f4,&g_878.f4,&g_22},{(void*)0,&g_22,&g_878.f4,&g_878.f4,&g_88},{(void*)0,&g_88,&g_22,&g_22,&g_88},{(void*)0,&g_88,&g_22,&g_22,&g_88},{(void*)0,&g_88,&g_22,&g_22,&g_88}}};
int i, j, k;
l_925++;
}
else
{ /* block id: 391 */
int32_t l_928 = 2L;
int32_t *l_929 = &l_923[5];
int32_t *l_930 = &g_276.f3;
int32_t *l_931 = &l_923[1];
int32_t *l_932 = &g_848.f0;
int32_t *l_933 = &g_276.f3;
int32_t l_934 = 0x5B23CE4FL;
int32_t *l_935 = &l_934;
int32_t *l_936 = &g_209.f4;
int32_t *l_937 = &g_276.f1;
int32_t *l_938 = (void*)0;
int32_t *l_940 = &g_412.f0;
int32_t *l_941[8] = {(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0,(void*)0};
uint32_t l_942[7];
uint64_t *l_956[6][7][1] = {{{&g_159},{&g_128},{&g_159},{&l_949[1]},{&g_159},{&g_159},{&g_878.f1}},{{(void*)0},{&l_949[9]},{(void*)0},{(void*)0},{&l_949[9]},{(void*)0},{&g_878.f1}},{{&g_159},{&g_159},{&l_949[1]},{&g_159},{&g_128},{&g_159},{&l_949[1]}},{{&g_159},{&g_159},{&g_878.f1},{(void*)0},{&l_949[9]},{(void*)0},{(void*)0}},{{&l_949[9]},{(void*)0},{&g_878.f1},{&g_159},{&g_159},{&l_949[1]},{&g_159}},{{&g_128},{&g_159},{&l_949[1]},{&g_159},{&g_159},{&g_878.f1},{(void*)0}}};
uint8_t *l_958[2][5] = {{&g_848.f1,&g_848.f1,&g_848.f1,&g_848.f1,&g_848.f1},{&g_359,&g_359,&g_359,&g_359,&g_359}};
struct S0 ****l_969 = &g_965;
int8_t *l_970 = &g_466;
int8_t *l_971 = &g_152;
int i, j, k;
for (i = 0; i < 7; i++)
l_942[i] = 0xA1E8508EL;
l_942[0]--;
(*l_930) = (safe_rshift_func_uint16_t_u_s((l_923[5] == (p_55 = (l_949[1] != (safe_mod_func_uint32_t_u_u(g_73[2].f3, ((*l_935) = (safe_mod_func_uint64_t_u_u((*g_158), (l_957 ^= (safe_sub_func_int32_t_s_s(4L, g_209.f0))))))))))), (safe_mul_func_int8_t_s_s(((*l_971) = (((safe_rshift_func_int8_t_s_s((safe_rshift_func_int8_t_s_u(((*l_970) = ((((*l_930) , (((*l_969) = g_965) != (void*)0)) > g_149) , (-1L))), (*l_931))), (*l_933))) , l_925) && (*l_936))), 9UL))));
}
for (g_412.f0 = (-13); (g_412.f0 < (-18)); g_412.f0 = safe_sub_func_uint64_t_u_u(g_412.f0, 4))
{ /* block id: 403 */
int64_t l_986[6];
int32_t l_1022[10] = {(-5L),(-5L),0x50EAA295L,(-5L),(-5L),0x50EAA295L,(-5L),(-5L),0x50EAA295L,(-5L)};
int32_t l_1024 = 0xC648E250L;
int32_t *l_1036 = &g_276.f0;
int i;
for (i = 0; i < 6; i++)
l_986[i] = (-1L);
for (g_878.f4 = 0; (g_878.f4 <= 6); g_878.f4 += 1)
{ /* block id: 406 */
uint32_t l_980 = 18446744073709551609UL;
int32_t l_1014 = 0x89F3E84FL;
int32_t *l_1035 = &g_85;
int32_t **l_1034 = &l_1035;
int8_t l_1037 = 0x13L;
int8_t *l_1038[9] = {&g_466,&g_466,&g_466,&g_466,&g_466,&g_466,&g_466,&g_466,&g_466};
int64_t *l_1045 = &l_939;
int32_t l_1051 = 0x49AF8935L;
int32_t l_1052 = 2L;
int32_t l_1053 = 0x83F2D516L;
int32_t l_1056 = 9L;
int32_t l_1058 = (-1L);
int32_t l_1059 = 7L;
int32_t l_1060[6];
uint8_t l_1066 = 0xF2L;
int i;
for (i = 0; i < 6; i++)
l_1060[i] = 0x10D67348L;
for (l_925 = 2; (l_925 <= 8); l_925 += 1)
{ /* block id: 409 */
int32_t l_991 = 1L;
const uint32_t l_1010 = 5UL;
union U2 *l_1031 = (void*)0;
union U2 **l_1030 = &l_1031;
int i;
if (l_923[(g_878.f4 + 1)])
{ /* block id: 410 */
int64_t *l_989 = &l_939;
int32_t *l_990[2][3][5] = {{{&g_88,&l_923[(g_878.f4 + 2)],&l_923[8],&g_968[1].f7,&l_923[8]},{&g_88,&g_88,&g_276.f3,&g_968[1].f7,(void*)0},{&l_923[(g_878.f4 + 2)],&g_88,&l_923[8],&g_878.f4,(void*)0}},{{&g_88,&l_923[(g_878.f4 + 2)],&l_923[8],&g_968[1].f7,&l_923[8]},{&g_88,&g_88,&g_276.f3,&g_968[1].f7,(void*)0},{&l_923[(g_878.f4 + 2)],&g_88,&l_923[8],&g_878.f4,(void*)0}}};
union U1 ** const *l_1002 = &g_552;
union U1 ** const **l_1001 = &l_1002;
int8_t *l_1005 = (void*)0;
int8_t *l_1006 = (void*)0;
int8_t *l_1007 = &g_466;
int i, j, k;
l_991 |= (safe_mul_func_int8_t_s_s(0xABL, (safe_sub_func_int16_t_s_s((l_923[(g_878.f4 + 2)] <= (l_980 = (&g_551 == &g_551))), ((g_983[0][0] , l_923[(g_878.f4 + 2)]) ^ (p_55 != (((*l_989) ^= (safe_mul_func_int8_t_s_s((l_986[2] != ((safe_sub_func_uint16_t_u_u(l_923[(g_878.f4 + 1)], 0x27DCL)) & (-9L))), l_923[8]))) >= p_55)))))));
if ((((*l_1007) = (((l_991 , ((void*)0 == &l_921[g_878.f4][(g_878.f4 + 1)])) < (g_992 , (safe_lshift_func_int8_t_s_s(g_412.f3, 2)))) , ((safe_mul_func_uint16_t_u_u(((safe_lshift_func_uint8_t_u_u(l_980, 2)) <= ((void*)0 == l_1001)), ((safe_rshift_func_uint16_t_u_s(((0x34CEL ^ 0x6883L) && g_983[0][0].f2), l_980)) <= g_11[0][0][5]))) == 0x6E20D8DC121DDDF5LL))) <= (-1L)))
{ /* block id: 415 */
int8_t l_1011 = 1L;
uint16_t *l_1023 = &g_149;
int32_t l_1025 = 0x7686CB68L;
int32_t l_1026 = 0x337CC337L;
uint8_t l_1027[7] = {0xF9L,9UL,9UL,0xF9L,9UL,9UL,0xF9L};
int i;
l_1024 = (((****l_1001) , l_1008) != (((((g_848.f1 > l_1010) != (((*l_1023) |= ((l_1011 || ((g_615 = (l_1022[2] = (((safe_rshift_func_int8_t_s_s((-10L), 0)) != (l_1014 & ((((((safe_lshift_func_int16_t_s_u((safe_lshift_func_int16_t_s_s(((g_1019 = g_1019) != &g_1020), 7)), 0)) & 255UL) <= g_204[1]) , l_939) , 65535UL) || p_55))) > 0xA0AB679DL))) < p_55)) , l_1011)) == g_366)) ^ 0xC3992BB49041C81ELL) , l_1014) , (void*)0));
l_1014 = p_55;
--l_1027[0];
return p_56;
}
else
{ /* block id: 424 */
return p_56;
}
}
else
{ /* block id: 427 */
return g_1032[4][1];
}
}
l_1014 = (p_55 >= ((((((*l_1034) = &g_85) != l_1036) || (((-9L) == (g_466 |= (l_923[6] < l_1037))) , (safe_rshift_func_int16_t_s_u(p_55, 8)))) , ((*l_1045) = ((p_55 , (((safe_lshift_func_uint16_t_u_s((safe_mul_func_int8_t_s_s((((*g_1019) == (void*)0) & 1UL), p_55)), 10)) && (*g_215)) , l_1022[4])) , 0xD691F5F92ADFCFE3LL))) , l_1024));
for (g_366 = 0; (g_366 <= 6); g_366 += 1)
{ /* block id: 437 */
int64_t l_1048 = (-6L);
int32_t l_1049 = 5L;
int32_t l_1050 = 0xA5DB60FFL;
int32_t l_1054 = (-1L);
int32_t l_1055 = 0x88543F28L;
int32_t l_1057[10][3][2] = {{{(-10L),0x542F505FL},{0L,0x0532874BL},{0x542F505FL,0x0532874BL}},{{0L,0x542F505FL},{(-10L),(-10L)},{(-10L),0x542F505FL}},{{0L,0x0532874BL},{0x542F505FL,0x0532874BL},{0L,0x542F505FL}},{{(-10L),(-10L)},{(-10L),0x542F505FL},{0L,0x0532874BL}},{{0x542F505FL,0x0532874BL},{0L,0x542F505FL},{(-10L),(-10L)}},{{(-10L),0x542F505FL},{0L,0x0532874BL},{0x542F505FL,0x0532874BL}},{{0L,0x542F505FL},{(-10L),(-10L)},{(-10L),0x542F505FL}},{{0L,0x0532874BL},{0x542F505FL,0x0532874BL},{0L,0x542F505FL}},{{(-10L),(-10L)},{(-10L),0x542F505FL},{0L,0x0532874BL}},{{0x542F505FL,0x0532874BL},{0L,0x542F505FL},{0x542F505FL,0x542F505FL}}};
int i, j, k;
if (l_925)
break;
for (g_466 = 3; (g_466 <= 8); g_466 += 1)
{ /* block id: 441 */
int32_t *l_1046 = (void*)0;
int32_t *l_1047[2][4][7] = {{{&g_968[1].f3,(void*)0,&g_412.f0,&l_1014,&g_412.f0,(void*)0,&g_968[1].f3},{&l_1022[4],&g_968[1].f3,&l_957,&l_1014,(void*)0,&g_852,&g_968[1].f3},{&g_412.f0,&l_1022[9],(void*)0,&g_968[1].f3,&l_1022[4],(void*)0,(void*)0},{(void*)0,(void*)0,&l_957,(void*)0,(void*)0,&g_276.f1,&g_22}},{{&g_22,(void*)0,&g_412.f0,&g_968[1].f3,&l_1014,(void*)0,&l_1022[4]},{(void*)0,&l_1022[9],&l_1014,&g_276.f7,&l_957,&l_957,&g_276.f7},{&g_22,&g_968[1].f3,&g_22,&l_957,&g_852,&l_1022[9],&g_276.f7},{(void*)0,(void*)0,(void*)0,&g_276.f1,&g_276.f7,&g_22,&l_1022[4]}}};
int i, j, k;
g_1061--;
if (l_923[g_878.f4])
break;
(*p_54) = &l_923[(g_366 + 2)];
if (p_55)
break;
}
for (l_1055 = 5; (l_1055 >= 0); l_1055 -= 1)
{ /* block id: 449 */
int i;
l_923[5] = (safe_mod_func_uint64_t_u_u(0x51F2EA50C156D4F2LL, l_986[l_1055]));
for (l_1050 = 0; (l_1050 <= 5); l_1050 += 1)
{ /* block id: 453 */
return &g_1033;
}
}
}
if (l_1066)
break;
}
}
++l_1075;
(*l_1069) = 5L;
return &g_1033;
}
/* ------------------------------------------ */
/*
* reads : g_73.f4 g_88 g_22 g_85 g_11 g_150 g_126 g_128 g_82 g_73.f3 g_20 g_149 g_73.f2 g_73.f0 g_158 g_159 g_204 g_215 g_209.f2 g_334 g_216 g_276 g_21 g_294 g_295 g_466 g_412.f1 g_358 g_551 g_552 g_587 g_553 g_412 g_209.f0 g_152 g_608 g_359 g_625 g_366 g_673 g_357 g_608.f3 g_362 g_209.f4 g_480 g_279 g_209.f3 g_50 g_816 g_412.f3 g_852 g_615 g_875 g_878
* writes: g_128 g_88 g_149 g_152 g_158 g_126 g_204 g_393 g_50 g_551 g_358 g_412.f1 g_295 g_552 g_615 g_359 g_159 g_480 g_466 g_366 g_412.f0 g_85 g_279 g_825 g_827 g_852 g_695 g_276.f7
*/
static int64_t func_58(int32_t p_59, const int32_t * p_60, union U2 ** p_61, int32_t p_62, uint16_t p_63)
{ /* block id: 29 */
int16_t l_114 = 0x4B92L;
uint8_t *l_125 = &g_126;
uint64_t *l_127 = &g_128;
int32_t l_129[7][10] = {{0x570EA9D5L,(-1L),(-1L),0x570EA9D5L,(-6L),(-1L),1L,(-6L),(-6L),1L},{(-6L),0x570EA9D5L,(-1L),(-1L),0x570EA9D5L,(-6L),(-1L),1L,(-6L),(-6L)},{0x570EA9D5L,1L,0x6BE185DEL,0x570EA9D5L,0x570EA9D5L,0x6BE185DEL,1L,0x570EA9D5L,0x7BF9FC00L,1L},{0x570EA9D5L,(-6L),(-1L),1L,(-6L),(-6L),1L,(-1L),(-6L),0x570EA9D5L},{(-6L),1L,(-1L),(-6L),0x570EA9D5L,(-1L),(-1L),0x570EA9D5L,(-6L),(-1L)},{0x570EA9D5L,0x570EA9D5L,0x6BE185DEL,1L,0x570EA9D5L,0x7BF9FC00L,1L,1L,0x7BF9FC00L,0x570EA9D5L},{0x570EA9D5L,(-1L),(-1L),0x570EA9D5L,(-6L),(-1L),1L,(-6L),(-6L),1L}};
int16_t *l_130 = &l_114;
int32_t l_131 = 0x571DCDCBL;
int32_t *l_133 = (void*)0;
int32_t *l_134 = &l_131;
uint64_t l_210 = 5UL;
int64_t *l_391[1][8][4] = {{{&g_357,&g_357,&g_357,&g_357},{(void*)0,&g_357,&g_357,&g_357},{&g_357,(void*)0,&g_357,&g_357},{(void*)0,(void*)0,&g_357,&g_357},{&g_357,(void*)0,&g_357,&g_357},{&g_357,&g_357,&g_357,&g_357},{(void*)0,&g_357,&g_357,&g_357},{&g_357,(void*)0,&g_357,&g_357}}};
int64_t ** const l_390 = &l_391[0][1][2];
int8_t l_405[5];
uint64_t l_406 = 1UL;
uint64_t l_426 = 0xB11F8E3621BBABEFLL;
union U1 **l_453 = (void*)0;
int64_t l_559 = (-1L);
union U1 **** const l_564 = &g_551;
union U1 **** const *l_563 = &l_564;
uint8_t l_592 = 0xAFL;
uint32_t *l_692 = (void*)0;
int32_t *l_702 = (void*)0;
struct S0 *l_717 = &g_276;
struct S0 **l_716 = &l_717;
uint32_t l_748 = 0xB8F1D9E6L;
union U1 *l_849 = &g_848;
int32_t l_876 = 0x0982122BL;
int i, j, k;
for (i = 0; i < 5; i++)
l_405[i] = 0xE0L;
(*l_134) = (safe_mod_func_int8_t_s_s(((safe_mul_func_int8_t_s_s(((((safe_div_func_int16_t_s_s(g_73[2].f4, (safe_sub_func_int8_t_s_s((safe_mul_func_int8_t_s_s((safe_sub_func_uint64_t_u_u((safe_add_func_int16_t_s_s((((*p_60) , l_114) , ((((safe_rshift_func_int16_t_s_u(((((*l_130) = (((safe_sub_func_uint16_t_u_u((safe_add_func_int32_t_s_s(l_114, 0UL)), (safe_mod_func_uint8_t_u_u(l_114, g_88)))) != (safe_add_func_uint64_t_u_u((l_129[3][2] = ((*l_127) = ((l_125 == &g_82) == p_62))), g_22))) > p_62)) != g_88) <= 9UL), g_85)) || 0xB5F6DFA604D7DB42LL) != 0L) & 0x5B50DB93F61EF617LL)), 0x9AD5L)), l_131)), 0x70L)), g_85)))) , &g_50) != (void*)0) != 0L), g_11[0][6][3])) | 0x6A1DL), 0x08L));
lbl_395:
for (g_88 = 0; (g_88 <= 8); g_88 += 1)
{ /* block id: 36 */
int16_t l_141 = 0xE38CL;
uint16_t *l_148[4] = {&g_149,&g_149,&g_149,&g_149};
int32_t *l_153 = (void*)0;
int i;
l_129[5][2] |= (safe_mul_func_uint16_t_u_u((g_152 = ((p_59 || (-5L)) , ((safe_mod_func_int16_t_s_s((((0xAEDA2CA1CAAA0BFBLL || ((safe_div_func_int8_t_s_s((l_141 != ((p_59 , (((*l_130) = (safe_mul_func_uint16_t_u_u(((p_63 & (safe_mod_func_int16_t_s_s(((((safe_mul_func_uint16_t_u_u((g_149 = (p_62 ^ g_11[1][6][2])), (((((void*)0 != g_150[1]) == p_62) >= 255UL) || (*p_60)))) & 2UL) , (*l_134)) , g_126), p_63))) >= g_128), 9UL))) >= 0xABAFL)) > g_82)), g_88)) != 0L)) , (*l_134)) && 4UL), g_11[1][5][6])) && p_59))), p_63));
for (g_128 = 0; (g_128 <= 8); g_128 += 1)
{ /* block id: 43 */
uint64_t *l_154 = &g_128;
uint64_t **l_155 = &l_127;
uint64_t *l_157[10] = {&g_128,&g_128,&g_128,&g_128,&g_128,&g_128,&g_128,&g_128,&g_128,&g_128};
uint64_t **l_156[8][5][6] = {{{&l_154,&l_157[4],&l_157[4],&l_157[2],&l_157[2],&l_157[4]},{&l_157[4],&l_157[4],&l_154,&l_154,&l_157[0],&l_157[2]},{&l_157[5],&l_154,&l_157[3],&l_154,&l_157[0],&l_157[5]},{&l_157[2],&l_154,&l_157[2],&l_154,&l_154,&l_157[4]},{&l_157[3],&l_154,&l_157[5],&l_157[4],&l_157[1],&l_157[1]}},{{&l_157[4],&l_157[1],&l_157[1],&l_157[4],&l_157[5],&l_154},{&l_157[3],&l_157[4],&l_154,&l_154,&l_157[2],&l_154},{&l_157[2],&l_157[5],&l_154,&l_157[5],&l_157[2],&l_157[0]},{&l_154,&l_157[4],&l_157[0],&l_157[0],&l_157[5],&l_154},{&l_154,&l_157[1],&l_157[4],&l_157[4],&l_157[1],&l_154}},{{&l_157[0],&l_154,&l_157[0],&l_157[2],&l_154,&l_157[0]},{&l_157[1],&l_154,&l_154,&l_154,&l_154,&l_154},{&l_157[1],&l_157[0],&l_154,&l_157[2],&l_157[0],&l_154},{&l_157[0],&l_154,&l_157[1],&l_157[4],&l_157[4],&l_157[1]},{&l_154,&l_154,&l_157[5],&l_157[0],&l_157[0],&l_157[4]}},{{&l_154,&l_157[0],&l_157[2],&l_157[5],&l_154,&l_157[5]},{&l_157[2],&l_154,&l_157[2],&l_154,&l_154,&l_157[4]},{&l_157[3],&l_154,&l_157[5],&l_157[4],&l_157[1],&l_157[1]},{&l_157[4],&l_157[1],&l_157[1],&l_157[4],&l_157[5],&l_154},{&l_157[3],&l_157[4],&l_154,&l_154,&l_157[2],&l_154}},{{&l_157[2],&l_157[5],&l_154,&l_157[5],&l_157[2],&l_157[0]},{&l_154,&l_157[4],&l_157[0],&l_157[0],&l_157[5],&l_154},{&l_154,&l_157[1],&l_157[4],&l_157[4],&l_157[1],&l_154},{&l_157[0],&l_154,&l_157[0],&l_157[2],&l_154,&l_157[0]},{&l_157[1],&l_154,&l_154,&l_154,&l_154,&l_154}},{{&l_157[1],&l_157[0],&l_154,&l_157[2],&l_157[0],&l_154},{&l_157[0],&l_154,&l_157[1],&l_157[4],&l_157[4],&l_157[1]},{&l_154,&l_154,&l_157[5],&l_157[0],&l_157[0],&l_157[4]},{&l_154,&l_157[0],&l_157[2],&l_157[5],&l_154,&l_157[5]},{&l_157[2],&l_154,&l_157[2],&l_154,&l_154,&l_157[4]}},{{&l_157[3],&l_154,&l_157[5],&l_157[4],&l_157[1],&l_157[1]},{&l_157[4],&l_157[1],&l_157[1],&l_157[4],&l_157[5],&l_154},{&l_157[3],&l_157[4],&l_154,&l_154,&l_157[2],&l_154},{&l_157[2],&l_157[5],&l_154,&l_157[5],&l_157[2],&l_157[0]},{&l_154,&l_157[4],&l_157[0],&l_157[0],&l_154,&l_157[5]}},{{&l_157[5],&l_157[4],&l_157[1],&l_157[1],&l_157[4],&l_157[5]},{&l_154,&l_157[0],&l_154,&l_157[4],&l_157[5],&l_157[0]},{&l_157[4],&l_157[0],&l_157[3],&l_157[5],&l_157[3],&l_157[0]},{&l_157[4],&l_157[0],&l_157[5],&l_157[4],&l_154,&l_157[0]},{&l_154,&l_157[5],&l_157[4],&l_157[1],&l_157[1],&l_157[4]}}};
int32_t *l_174 = &l_129[3][2];
int32_t l_175 = (-1L);
int i, j, k;
l_175 &= ((*l_134) >= (((((*l_155) = l_154) == (g_158 = l_154)) & (safe_add_func_int16_t_s_s(((0xCAL || ((safe_rshift_func_int8_t_s_u((safe_rshift_func_uint16_t_u_u(g_73[2].f3, 6)), 4)) <= (((*l_174) = ((safe_add_func_int16_t_s_s((safe_add_func_uint8_t_u_u(0x21L, (safe_mul_func_uint16_t_u_u((*l_134), (3UL <= (safe_rshift_func_int16_t_s_u(((*l_130) = 0xDD04L), p_62))))))), (*l_134))) >= p_63)) | (*l_134)))) , g_20), g_149))) , g_73[2].f2));
}
}
if (((p_63 <= (safe_rshift_func_int16_t_s_u(((safe_mul_func_uint16_t_u_u(((0xD8A1F48489ECFC60LL != ((!(((*l_125) = ((l_129[3][2] = ((*l_134) = (g_73[2].f2 && ((*p_60) > ((safe_unary_minus_func_int32_t_s((safe_add_func_int16_t_s_s(((*l_130) = ((void*)0 == &g_128)), ((safe_lshift_func_uint16_t_u_s(0UL, 0)) == ((((((safe_rshift_func_uint8_t_u_s((safe_mod_func_int64_t_s_s(p_62, p_63)), 0)) >= p_63) , p_63) < 0x16L) , g_73[2].f0) > (-10L))))))) > (*l_134)))))) <= g_22)) || p_62)) < 254UL)) , (*l_134)), 0x6E71L)) > 0xC6L), 3))) < p_63))
{ /* block id: 55 */
uint16_t l_200 = 5UL;
int8_t *l_201[2];
uint16_t *l_202 = (void*)0;
uint16_t *l_203 = &g_204[1];
int32_t l_227 = 5L;
int32_t l_230 = 0xF2DA2A86L;
int32_t l_231 = 0x35D59E72L;
int32_t l_236 = 0x011B648EL;
int32_t l_237 = (-1L);
int32_t l_238 = 0x4E36C9BFL;
int32_t l_239 = 0L;
int32_t l_240[7];
int8_t l_241[4][5] = {{(-3L),0x8CL,0x8CL,(-3L),(-3L)},{2L,0x78L,2L,0x78L,2L},{(-3L),(-3L),0x8CL,0x8CL,(-3L)},{(-1L),0x78L,(-1L),0x78L,(-1L)}};
int16_t l_289[8] = {(-10L),0x17F1L,(-10L),(-10L),0x17F1L,(-10L),(-10L),0x17F1L};
uint32_t l_371 = 0x670CA061L;
int8_t l_387 = 1L;
uint32_t l_415[7][4][1] = {{{1UL},{0xF1D9611BL},{1UL},{1UL}},{{0xF1D9611BL},{1UL},{1UL},{0xF1D9611BL}},{{1UL},{1UL},{0xF1D9611BL},{1UL}},{{1UL},{0xF1D9611BL},{1UL},{1UL}},{{0xF1D9611BL},{1UL},{1UL},{0xF1D9611BL}},{{1UL},{1UL},{0xF1D9611BL},{1UL}},{{1UL},{0xF1D9611BL},{1UL},{1UL}}};
int16_t *l_648 = &l_289[3];
int i, j, k;
for (i = 0; i < 2; i++)
l_201[i] = (void*)0;
for (i = 0; i < 7; i++)
l_240[i] = 0xAE8CD262L;
if (((g_149 ^ ((((safe_div_func_uint16_t_u_u(g_22, ((*l_203) |= ((safe_mod_func_uint64_t_u_u((*l_134), (safe_mod_func_uint16_t_u_u((p_62 | (safe_rshift_func_int8_t_s_u((-6L), (safe_add_func_int8_t_s_s((&p_63 != (void*)0), (g_152 = (((*g_158) || ((*p_61) == (void*)0)) < l_200))))))), g_85)))) < (*l_134))))) , l_127) == &g_128) , g_159)) >= p_62))
{ /* block id: 58 */
union U2 *l_208 = &g_209;
union U2 **l_207 = &l_208;
uint32_t l_217 = 0x72FEA18CL;
int32_t l_218 = 0x6EA20896L;
int32_t l_225 = 0x207D733AL;
int32_t l_226 = 0x285D8708L;
int32_t l_228 = (-1L);
int32_t l_229 = (-6L);
int32_t l_232 = 1L;
int32_t l_233 = 0xAB014F3CL;
int32_t l_234[8] = {0x4D29C7E7L,0x4D29C7E7L,0x4D29C7E7L,0x4D29C7E7L,0x4D29C7E7L,0x4D29C7E7L,0x4D29C7E7L,0x4D29C7E7L};
int32_t l_242 = (-1L);
uint16_t l_243 = 1UL;
int32_t *l_248 = (void*)0;
int32_t *l_249 = &l_231;
int32_t *l_250 = &l_237;
int32_t *l_251 = &l_227;
int32_t *l_252 = &l_231;
int32_t *l_253 = &g_209.f4;
int32_t *l_254[5][10] = {{&l_234[6],&l_129[3][2],&l_234[6],&l_238,&l_131,&l_237,&l_234[6],&l_232,&l_232,&l_234[6]},{&l_131,&l_231,&l_237,&l_237,&l_231,&l_131,&l_234[6],&l_232,&l_239,&l_129[5][2]},{&l_129[3][2],&l_129[5][2],&l_234[6],&l_230,&l_232,&l_230,&l_234[6],&l_129[5][2],&l_129[3][2],&l_131},{&l_129[3][2],&l_237,(void*)0,&l_234[6],&l_230,&l_131,&l_131,&l_230,&l_234[6],(void*)0},{&l_131,&l_131,&l_230,&l_234[6],(void*)0,&l_237,&l_129[3][2],&l_234[6],&l_129[3][2],&l_237}};
uint8_t l_255 = 0x89L;
uint16_t *l_284 = &g_204[1];
uint32_t l_307 = 5UL;
const uint64_t *l_324 = &l_210;
int i, j;
l_218 = ((safe_sub_func_uint16_t_u_u((((((((*l_127) = (p_61 == l_207)) >= l_210) , (0xC7L > p_63)) >= (safe_sub_func_uint32_t_u_u((((safe_mul_func_int16_t_s_s(0x681FL, ((g_215 == (void*)0) < l_200))) < g_209.f2) <= 0x3109E43A77B9CB57LL), g_204[1]))) && 0x2258DF76L) > l_217), p_63)) || 0x215FF56717282AECLL);
for (p_63 = 0; (p_63 == 13); p_63++)
{ /* block id: 63 */
int32_t *l_221 = (void*)0;
int32_t *l_222 = &g_88;
int32_t *l_223 = &l_129[3][2];
int32_t *l_224[6] = {(void*)0,(void*)0,&l_131,(void*)0,(void*)0,&l_131};
int32_t l_235 = 0L;
const int32_t *l_247 = &l_129[4][9];
const int32_t **l_246 = &l_247;
int i;
l_243++;
(*l_246) = p_60;
if (l_230)
continue;
}
--l_255;
}
else
{ /* block id: 121 */
int32_t l_367 = (-1L);
int32_t *l_368 = &l_240[3];
int32_t *l_369 = &l_238;
int32_t *l_370[8][1];
int i, j;
for (i = 0; i < 8; i++)
{
for (j = 0; j < 1; j++)
l_370[i][j] = &g_209.f4;
}
l_371++;
}
if ((g_204[1] ^ (((--(*l_125)) == p_63) || (&g_152 != &l_241[2][3]))))
{ /* block id: 125 */
int32_t l_386[10][3] = {{6L,6L,0x9167D51CL},{0xCD481D4BL,0xC27F9AC8L,0xE31FD890L},{0x33DA6A2FL,6L,0x33DA6A2FL},{0x33DA6A2FL,0xCD481D4BL,6L},{0xCD481D4BL,0x33DA6A2FL,0x33DA6A2FL},{6L,0x33DA6A2FL,0xE31FD890L},{0xC27F9AC8L,0xCD481D4BL,0x9167D51CL},{6L,6L,0x9167D51CL},{0xCD481D4BL,0xC27F9AC8L,0xE31FD890L},{0x33DA6A2FL,6L,0x33DA6A2FL}};
int16_t l_444 = 0x34F7L;
int i, j;
if ((safe_mul_func_int8_t_s_s((((*p_60) , g_334) , (((safe_unary_minus_func_uint32_t_u(((safe_mul_func_int16_t_s_s((((((safe_lshift_func_int8_t_s_u((safe_unary_minus_func_int64_t_s(((g_216 ^ ((safe_mul_func_int8_t_s_s(((&p_63 == (void*)0) ^ ((l_386[5][0] == l_371) <= l_387)), g_159)) ^ (*g_158))) , g_73[2].f3))), p_62)) != p_63) | l_237) ^ (*l_134)) | p_59), 0x6116L)) , (*l_134)))) , l_134) == &p_62)), 0x38L)))
{ /* block id: 126 */
for (l_237 = (-3); (l_237 == (-9)); l_237 = safe_sub_func_int64_t_s_s(l_237, 2))
{ /* block id: 129 */
int64_t ***l_394 = &g_393;
(*l_394) = l_390;
}
if (g_22)
goto lbl_395;
}
else
{ /* block id: 133 */
int16_t l_400 = 9L;
int32_t l_401 = 0xD58091EFL;
int32_t l_402 = 0xDC57BA03L;
int32_t l_403 = 0L;
int32_t l_404[9];
int32_t *l_418 = (void*)0;
int32_t *l_419 = &l_404[8];
int32_t *l_420 = &g_276.f7;
int32_t *l_421 = (void*)0;
int32_t *l_422 = &g_209.f4;
int32_t *l_423 = (void*)0;
int32_t *l_424 = &l_402;
int32_t *l_425[8][8] = {{&l_238,(void*)0,&l_227,(void*)0,&l_227,(void*)0,&l_238,&l_238},{&l_238,&g_276.f7,&g_22,&g_22,&g_276.f7,&l_238,&l_227,&l_238},{&g_276.f7,&l_238,&l_227,&l_238,&g_276.f7,&g_22,&g_22,&g_276.f7},{&l_238,(void*)0,(void*)0,&l_238,&l_403,&g_276.f7,&l_403,&l_238},{(void*)0,&l_403,(void*)0,&g_22,&l_227,&l_227,&g_22,(void*)0},{&l_403,&l_403,&l_227,&g_276.f7,(void*)0,&g_276.f7,&l_227,&l_403},{&l_403,(void*)0,&g_22,&l_227,&l_227,&g_22,(void*)0,&l_403},{(void*)0,&l_238,&l_403,&g_276.f7,&l_403,&l_238,(void*)0,(void*)0}};
int i, j;
for (i = 0; i < 9; i++)
l_404[i] = 3L;
for (l_236 = 0; (l_236 >= 0); l_236 -= 1)
{ /* block id: 136 */
struct S0 *l_397 = &g_276;
struct S0 **l_396 = &l_397;
int32_t *l_398 = &g_276.f3;
int32_t *l_399[3][1];
uint64_t **l_409 = (void*)0;
int i, j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 1; j++)
l_399[i][j] = &l_231;
}
for (l_200 = 0; (l_200 <= 1); l_200 += 1)
{ /* block id: 139 */
return p_62;
}
(*l_396) = &g_276;
++l_406;
l_239 |= ((void*)0 == l_409);
for (p_59 = 0; (p_59 >= 0); p_59 -= 1)
{ /* block id: 147 */
const union U1 *l_411[6] = {&g_412,&g_412,&g_412,&g_412,&g_412,&g_412};
const union U1 **l_410 = &l_411[5];
int32_t l_413 = 0xD12CA628L;
int32_t l_414[2];
int i;
for (i = 0; i < 2; i++)
l_414[i] = 0L;
(*l_410) = (void*)0;
if (l_402)
continue;
l_415[5][1][0]++;
}
}
(*l_134) &= (*p_60);
l_426++;
}
(*l_134) = (safe_sub_func_int8_t_s_s((((!(((l_386[5][0] = ((safe_lshift_func_uint8_t_u_u(((g_276 , p_63) > ((((safe_add_func_uint32_t_u_u(((safe_rshift_func_int16_t_s_s(((safe_div_func_uint32_t_u_u(((((safe_sub_func_uint16_t_u_u((((((((*p_60) , ((((void*)0 == &l_227) >= l_386[5][0]) || (l_227 = (safe_sub_func_uint8_t_u_u(g_276.f1, (254UL >= (l_444 || (-9L)))))))) >= l_386[7][0]) , p_63) | 0xF8BA1343L) , 1L) | 0UL), 65529UL)) ^ 0x6492L) & 0x8EL) & l_240[6]), l_444)) < 251UL), 3)) ^ p_62), g_276.f1)) & l_387) || 0x944CECB1L) , 0x6B176C4FL)), 7)) & 4L)) != p_62) & 0x9158L)) != (-6L)) <= g_22), p_59));
}
else
{ /* block id: 159 */
int32_t **l_445 = &g_50;
int32_t l_449 = 0xC1CC4B84L;
int32_t l_489 = 0xB60CDC74L;
int32_t l_490 = 0x98B10D6AL;
int32_t l_491 = 0xC105F127L;
int32_t l_540 = 0L;
int32_t l_542 = 1L;
int32_t l_544[10][1] = {{0xC65D68EAL},{0xF31D62F5L},{0xC65D68EAL},{0xF31D62F5L},{0xC65D68EAL},{0xF31D62F5L},{0xC65D68EAL},{0xF31D62F5L},{0xC65D68EAL},{0xF31D62F5L}};
uint64_t * const *l_585 = &g_158;
union U1 **l_609 = &g_553;
uint16_t l_614 = 65535UL;
uint16_t **l_624 = &l_203;
uint64_t l_645 = 0x3DC8476E65974876LL;
int64_t l_676 = 1L;
int i, j;
(*l_445) = (void*)0;
if ((g_209.f2 <= 1UL))
{ /* block id: 161 */
int16_t l_452 = 0xBFDCL;
int32_t *l_455 = (void*)0;
int32_t l_467 = 0x331A4846L;
for (l_114 = 20; (l_114 == (-27)); l_114 = safe_sub_func_uint32_t_u_u(l_114, 2))
{ /* block id: 164 */
uint32_t l_448 = 1UL;
union U1 **l_454 = (void*)0;
union U2 *l_462 = &g_209;
(*l_134) |= ((g_21 && ((0x7B8EL > (*g_215)) || (0UL < ((((l_448 , l_449) & l_415[1][2][0]) ^ 0x4C97F87A1B26B88DLL) & (((safe_lshift_func_uint16_t_u_s(((*l_203) = 0x2500L), l_452)) , l_453) != l_454))))) , (*p_60));
(*l_445) = l_455;
(*l_134) = ((((g_152 = (safe_add_func_uint64_t_u_u((safe_lshift_func_uint8_t_u_u(0x9EL, 5)), (safe_add_func_int64_t_s_s((p_63 != 0xFEF09CB9L), ((void*)0 == l_462)))))) >= 0x2BL) , ((*l_203) &= (+(((*g_294) != &l_231) != (safe_div_func_int8_t_s_s(g_209.f2, g_466)))))) == p_62);
}
l_467 = (-1L);
}
else
{ /* block id: 173 */
int32_t l_468 = 2L;
int32_t l_482 = 9L;
int32_t l_485[10] = {1L,0L,1L,0xBC6A1F93L,0xBC6A1F93L,1L,0L,1L,0xBC6A1F93L,0xBC6A1F93L};
uint16_t l_509 = 0x66C6L;
uint8_t l_546[3][9][5] = {{{1UL,255UL,0x97L,0UL,0x9CL},{0x64L,246UL,255UL,246UL,0x64L},{1UL,0UL,0UL,4UL,246UL},{0x0AL,0x04L,247UL,0x1EL,255UL},{1UL,3UL,1UL,0UL,246UL},{255UL,0x1EL,246UL,9UL,0x64L},{246UL,1UL,247UL,0x4CL,0x9CL},{0xDEL,4UL,1UL,0x50L,1UL},{0x3DL,255UL,1UL,0x04L,255UL}},{{0x50L,1UL,247UL,247UL,1UL},{0xFCL,0x50L,246UL,255UL,0xB9L},{3UL,0x00L,1UL,0x64L,0x22L},{0xFFL,3UL,247UL,0x00L,0x04L},{3UL,0x0AL,0UL,0xDEL,255UL},{0xFCL,0x4CL,255UL,1UL,0x97L},{0x50L,0x3DL,0x97L,255UL,0xECL},{0x3DL,0UL,255UL,255UL,0x0AL},{0xDEL,0xFFL,0UL,1UL,0UL}},{{246UL,246UL,0xD5L,0xDEL,3UL},{255UL,0x97L,0x4CL,0x00L,0xFCL},{1UL,5UL,1UL,0x64L,4UL},{0x0AL,0x97L,246UL,255UL,0xFFL},{0UL,0xD5L,0x97L,1UL,4UL},{255UL,1UL,255UL,0x9CL,255UL},{0x00L,0x22L,0UL,255UL,255UL},{0xECL,0UL,9UL,4UL,4UL},{3UL,4UL,3UL,0x3DL,0xFFL}}};
union U1 ***l_554 = &g_552;
uint32_t l_560 = 4294967287UL;
union U1 ****l_566 = &g_551;
union U1 **** const *l_565 = &l_566;
int i, j, k;
if ((*p_60))
{ /* block id: 174 */
uint8_t l_492 = 0x50L;
(*l_134) = (*p_60);
if (l_468)
{ /* block id: 176 */
return p_59;
}
else
{ /* block id: 178 */
int32_t *l_469 = &l_131;
int32_t *l_470 = &l_236;
int32_t *l_471 = &l_236;
int32_t *l_472 = &l_238;
int32_t *l_473 = &g_209.f4;
int32_t *l_474 = &g_88;
int32_t *l_475 = &l_231;
int32_t *l_476 = &l_227;
int32_t *l_477 = (void*)0;
int32_t *l_478 = (void*)0;
int32_t *l_479 = &l_449;
int32_t *l_481 = &g_366;
int32_t *l_483 = (void*)0;
int32_t *l_484 = &l_230;
int32_t *l_486 = &l_449;
int32_t *l_487 = (void*)0;
int32_t *l_488[1][6] = {{&l_129[1][8],&l_129[1][8],(void*)0,&l_129[1][8],&l_129[1][8],(void*)0}};
uint64_t l_495 = 0xA9C668836697AC77LL;
int i, j;
l_492++;
return l_495;
}
}
else
{ /* block id: 182 */
uint32_t l_512 = 0x555C8C7DL;
int32_t l_515 = 0x6C42F099L;
int32_t l_528 = 0x1CFCEFBEL;
int32_t l_533 = 1L;
int32_t l_536 = 0xCFADAD94L;
int32_t l_537 = 4L;
int32_t l_538 = 0x930061DAL;
int32_t l_539 = 0x2FB35078L;
int32_t l_541 = 2L;
int32_t l_543 = 0x7D556F10L;
int32_t l_545[2];
int32_t *l_555 = (void*)0;
int32_t *l_556 = &l_129[3][2];
int32_t *l_557 = (void*)0;
int32_t *l_558[5][6][4] = {{{&l_482,&l_482,&l_485[5],&l_539},{(void*)0,&l_489,&l_227,&l_544[8][0]},{(void*)0,&l_485[5],&l_449,&l_227},{&l_236,&l_485[5],&g_366,&l_544[8][0]},{&l_485[5],&l_489,&l_237,&l_539},{&l_540,&l_482,&l_515,(void*)0}},{{&l_227,(void*)0,&l_227,&l_485[5]},{&g_412.f0,&l_449,&l_545[0],&l_227},{&l_544[4][0],&l_545[0],(void*)0,&l_449},{&l_485[5],&l_482,(void*)0,&g_366},{&l_544[4][0],&l_482,&l_545[0],&l_237},{&g_412.f0,&g_22,&l_227,&l_515}},{{&l_227,&l_515,&l_515,&l_227},{&l_540,&l_544[8][0],&l_237,&l_545[0]},{&l_485[5],&l_129[3][2],&g_366,(void*)0},{&l_236,&l_482,&l_449,(void*)0},{(void*)0,&l_129[3][2],&l_227,&l_545[0]},{(void*)0,&l_544[8][0],&l_485[5],&l_227}},{{&l_482,&l_515,(void*)0,&l_515},{&l_485[5],&g_22,&l_539,&l_237},{&g_22,&l_482,&l_544[8][0],&g_366},{(void*)0,&l_482,&l_227,&l_449},{(void*)0,&l_545[0],&l_544[8][0],&l_227},{&g_22,&l_449,&l_539,&l_485[5]}},{{&l_485[5],(void*)0,(void*)0,(void*)0},{&l_482,&l_482,&l_485[5],&l_539},{(void*)0,&l_489,&l_227,&l_544[8][0]},{(void*)0,&l_485[5],&l_449,&l_227},{&l_236,&l_485[5],&g_366,&l_544[8][0]},{&l_485[5],&l_489,&l_237,&l_539}}};
int i, j, k;
for (i = 0; i < 2; i++)
l_545[i] = 0xD50BE7E9L;
if ((safe_sub_func_int8_t_s_s(((safe_sub_func_int8_t_s_s(g_412.f1, (((void*)0 == &p_59) & g_126))) ^ ((*l_203) = ((*l_134) > (safe_sub_func_uint64_t_u_u(l_485[1], (safe_sub_func_int64_t_s_s(((((safe_sub_func_uint16_t_u_u(p_62, (safe_lshift_func_int16_t_s_u(((safe_unary_minus_func_uint16_t_u(p_63)) > 1UL), l_509)))) , 18446744073709551615UL) == p_59) >= 0xCCL), p_59))))))), 0L)))
{ /* block id: 184 */
int8_t l_510 = 0x89L;
int32_t *l_511[1][7];
int i, j;
for (i = 0; i < 1; i++)
{
for (j = 0; j < 7; j++)
l_511[i][j] = &g_366;
}
(*l_134) ^= l_231;
++l_512;
}
else
{ /* block id: 187 */
int32_t *l_516 = (void*)0;
int32_t *l_517 = &g_276.f7;
int32_t *l_518 = &l_485[6];
int32_t *l_519 = &l_129[3][2];
int32_t *l_520 = &l_129[3][2];
int32_t *l_521 = &g_276.f7;
int32_t *l_522 = &g_276.f3;
int32_t *l_523 = &g_209.f4;
int32_t *l_524 = &l_239;
int32_t *l_525 = &l_236;
int32_t *l_526 = &l_485[1];
int32_t *l_527 = &l_129[4][1];
int32_t *l_529 = &l_240[3];
int32_t l_530 = 0L;
int32_t *l_531 = &g_209.f4;
int32_t *l_532 = &g_412.f0;
int32_t *l_534[6][8][5] = {{{&l_449,&l_237,&l_239,&g_276.f1,&g_22},{&l_530,&l_533,&g_209.f4,&g_276.f1,&l_515},{&l_489,&l_485[1],&l_530,&l_482,(void*)0},{&l_236,&l_449,&g_276.f1,(void*)0,&g_412.f0},{&l_129[5][9],&g_22,&l_129[3][2],&g_22,&l_449},{(void*)0,&l_129[1][6],(void*)0,&l_489,&l_237},{&l_482,(void*)0,&l_239,(void*)0,&l_239},{&l_239,&l_237,&l_129[3][0],&l_491,&l_239}},{{&l_515,(void*)0,&g_21,&l_482,&g_21},{&g_412.f0,&g_412.f0,&l_227,&l_236,(void*)0},{&l_482,&l_485[1],(void*)0,&g_276.f3,(void*)0},{&g_22,&g_366,&g_412.f0,&l_449,&l_239},{&l_131,&l_485[1],&l_129[1][6],&g_276.f1,(void*)0},{(void*)0,&g_412.f0,&l_533,&g_276.f3,&l_489},{&l_231,(void*)0,&l_491,&l_530,&l_131},{&l_131,&g_276.f1,(void*)0,&l_237,(void*)0}},{{&l_485[3],&g_22,&l_236,&l_227,&g_276.f7},{(void*)0,&l_489,&g_88,&l_240[1],&g_209.f4},{&g_412.f0,&l_240[3],&l_449,&l_227,&g_276.f7},{&l_485[3],&g_276.f3,&l_240[3],&g_276.f1,&l_230},{&g_276.f1,&l_230,&l_489,&l_129[3][2],&l_449},{&g_276.f3,&g_366,(void*)0,&l_485[1],&l_449},{&l_515,&l_131,(void*)0,&l_236,&l_230},{&l_131,&l_236,&l_530,&l_240[4],&g_276.f7}},{{&l_129[3][2],&l_239,&l_491,&l_236,&g_209.f4},{&g_22,&l_449,&g_88,&g_22,&g_276.f7},{&l_129[2][0],&l_227,&l_489,&l_489,(void*)0},{&l_129[1][6],&l_131,&g_22,&l_230,&l_131},{&l_449,&l_240[4],&l_482,&l_489,&l_489},{&l_530,&g_22,&l_530,(void*)0,(void*)0},{(void*)0,&l_491,&l_129[3][0],&l_237,&l_239},{&l_239,&l_129[2][0],(void*)0,(void*)0,(void*)0}},{{(void*)0,&l_482,&l_129[3][0],&l_239,(void*)0},{&l_533,&g_22,&l_530,&g_209.f4,&g_21},{&l_227,&g_276.f1,&l_482,&l_129[2][0],&l_239},{&g_366,&l_533,&g_22,&g_276.f3,&l_240[4]},{&l_227,&l_239,&l_489,&g_21,&g_276.f1},{&l_449,&l_515,&g_88,&g_412.f0,(void*)0},{&l_533,(void*)0,&l_491,&l_485[1],&l_129[5][9]},{&l_490,&l_449,&l_530,(void*)0,&l_239}},{{&l_485[0],&g_21,(void*)0,&l_533,&l_240[1]},{&l_239,&l_239,(void*)0,(void*)0,&l_449},{&l_239,&l_240[3],&l_489,&g_209.f4,&l_489},{&l_485[0],&l_227,&l_240[3],&l_490,&g_22},{&l_490,&l_449,&l_449,&l_239,&g_22},{&l_533,&g_88,&g_88,(void*)0,&g_209.f4},{(void*)0,&g_88,&l_485[1],&g_412.f0,&l_239},{&l_491,(void*)0,&l_236,&l_491,&l_236}}};
int8_t l_535 = (-1L);
union U1 ***l_549 = (void*)0;
union U1 ****l_550[9][5] = {{&l_549,&l_549,&l_549,&l_549,&l_549},{&l_549,&l_549,&l_549,&l_549,&l_549},{&l_549,&l_549,&l_549,&l_549,&l_549},{&l_549,&l_549,&l_549,&l_549,&l_549},{&l_549,&l_549,&l_549,&l_549,&l_549},{&l_549,&l_549,&l_549,&l_549,&l_549},{&l_549,&l_549,&l_549,&l_549,&l_549},{&l_549,&l_549,&l_549,&l_549,&l_549},{&l_549,&l_549,&l_549,&l_549,&l_549}};
int i, j, k;
l_546[0][0][3]--;
l_554 = (g_551 = l_549);
return p_59;
}
l_560++;
}
l_565 = l_563;
for (g_126 = (-17); (g_126 <= 38); g_126 = safe_add_func_int8_t_s_s(g_126, 4))
{ /* block id: 198 */
uint8_t l_578 = 0x60L;
uint8_t *l_581 = &g_358;
uint8_t *l_582 = &g_412.f1;
int32_t *l_583 = &l_231;
if ((0x1F0673AEL || ((*l_583) = (safe_lshift_func_int8_t_s_u((safe_mul_func_int16_t_s_s((((*l_582) = (0x8C4D219DL > (((*l_134) = (*g_215)) , ((+((*g_158) | (l_485[1] = (((p_59 , (safe_mod_func_uint32_t_u_u((safe_div_func_int64_t_s_s(l_578, (safe_sub_func_uint8_t_u_u(((*l_581) |= l_415[5][1][0]), (l_578 == (*g_158)))))), (*l_134)))) , p_63) , 0x6DB6F6E9DD836228LL)))) > 0xE5L)))) == l_560), 1UL)), 4)))))
{ /* block id: 204 */
union U1 **l_584 = &g_553;
(*l_134) = ((((*l_134) , l_584) != (*g_551)) & ((void*)0 == l_585));
(*g_587) = ((+p_63) , (*g_294));
}
else
{ /* block id: 207 */
int32_t *l_597 = (void*)0;
int32_t *l_598 = &l_240[5];
int64_t *l_607 = (void*)0;
(*l_598) &= (((safe_mul_func_int8_t_s_s(((*l_583) |= p_59), (0x57852AE5L & (safe_mod_func_int64_t_s_s((((***g_551) , ((p_63 & (l_546[0][0][3] == ((((l_592 > (((safe_lshift_func_uint16_t_u_s((l_227 = (((safe_lshift_func_uint16_t_u_u(((*l_203) = g_276.f2), p_63)) != (*g_158)) , 65535UL)), (*l_134))) != l_449) , p_63)) ^ g_11[0][6][5]) <= l_546[0][0][3]) > 0L))) , (*p_60))) > g_209.f2), p_59))))) == g_209.f0) ^ g_209.f0);
(*l_598) &= (safe_add_func_int8_t_s_s((safe_rshift_func_uint16_t_u_s(((+(p_62 & (((((!(safe_div_func_int32_t_s_s(((g_615 = ((((*l_583) <= ((g_152 |= (((*l_390) = l_607) == l_607)) > (0x63L | (((**l_564) = (*g_551)) != (g_608 , (l_609 = l_609)))))) || (safe_mul_func_uint8_t_u_u((safe_mul_func_uint16_t_u_u((*l_583), 0xCDEFL)), l_614))) > l_371)) , (*p_60)), (*l_583)))) & g_204[1]) ^ p_62) , 4294967288UL) != l_415[5][1][0]))) == g_276.f6), 7)), g_412.f1));
return l_241[2][3];
}
for (l_490 = 5; (l_490 >= 0); l_490 -= 1)
{ /* block id: 222 */
const int32_t **l_616[3][1];
int i, j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 1; j++)
l_616[i][j] = &g_295[0];
}
if (l_491)
break;
(*g_294) = p_60;
(*l_134) = (*p_60);
if (l_289[3])
continue;
}
l_485[0] = (safe_rshift_func_int16_t_s_u((safe_unary_minus_func_uint64_t_u(p_63)), ((p_62 < (((*p_60) & ((((p_62 && ((*l_583) == (4294967295UL > l_560))) == (g_359++)) , (safe_rshift_func_uint8_t_u_u((((**l_585) ^= (((p_62 , l_624) == g_625) | p_63)) ^ 7UL), 7))) < p_59)) & l_482)) ^ l_240[3])));
}
for (l_114 = 0; (l_114 != (-17)); l_114 = safe_sub_func_int16_t_s_s(l_114, 1))
{ /* block id: 234 */
uint32_t l_642[10];
int i;
for (i = 0; i < 10; i++)
l_642[i] = 0UL;
for (l_131 = 0; (l_131 <= 6); l_131 += 1)
{ /* block id: 237 */
uint64_t l_632 = 0xC7280F2F9C2BC065LL;
int16_t *l_643 = &l_289[4];
int16_t *l_644 = &g_480;
int i;
l_240[l_131] = (safe_sub_func_uint16_t_u_u((safe_sub_func_int16_t_s_s(0x5D94L, (l_632 | ((*l_127)--)))), ((*l_644) = ((*l_643) |= (((void*)0 == &g_279[6][0][0]) | ((~(*g_215)) != (safe_mul_func_uint16_t_u_u(((*l_203) ^= (safe_mod_func_int8_t_s_s(((((*l_134) , 0L) || (*l_134)) || ((safe_rshift_func_int8_t_s_s(l_642[4], 1)) ^ (*l_134))), g_366))), (*l_134)))))))));
if (l_238)
break;
return l_645;
}
l_482 ^= ((safe_mul_func_uint8_t_u_u((((void*)0 == l_648) >= (((safe_mod_func_uint8_t_u_u((safe_mod_func_uint16_t_u_u(((safe_mul_func_int16_t_s_s(l_560, (*g_215))) , (l_237 & (((((safe_div_func_uint64_t_u_u((safe_sub_func_int32_t_s_s(((*l_134) ^= l_227), ((18446744073709551606UL ^ ((*p_60) != (((*p_61) == (void*)0) || p_62))) < p_62))), l_289[3])) ^ g_21) | l_485[1]) , p_63) && p_62))), g_22)), l_509)) >= (-1L)) ^ g_159)), l_642[4])) & (*g_158));
if ((*p_60))
continue;
for (l_426 = 22; (l_426 > 29); ++l_426)
{ /* block id: 251 */
int32_t l_672 = 0x99567F84L;
uint32_t *l_674 = &g_615;
int32_t *l_677 = &l_485[1];
l_540 = ((safe_div_func_uint8_t_u_u(p_63, (0xE5L && ((*l_125) &= (safe_sub_func_int32_t_s_s((*p_60), (l_642[4] , p_59))))))) > ((safe_sub_func_uint8_t_u_u(((((((g_152 &= ((((g_466 = (safe_rshift_func_uint16_t_u_s((safe_unary_minus_func_int64_t_s((0x1AAC1D8DL != (9L == ((*l_674) = ((((safe_rshift_func_uint8_t_u_s(p_62, (((*l_134) &= (-1L)) & l_672))) , l_134) != g_673) != l_227)))))), g_357))) || (*l_134)) , p_59) ^ 0x9B05L)) == p_63) , l_546[1][5][2]) <= g_357) != g_128) ^ l_546[0][0][3]), 0UL)) & 0UL));
(*l_134) &= (*p_60);
if (l_676)
continue;
(*l_677) = ((*l_134) = l_546[0][0][3]);
}
}
}
}
}
else
{ /* block id: 266 */
const uint64_t l_680[7] = {0UL,0UL,5UL,0UL,0UL,5UL,0UL};
int32_t l_683[5][7] = {{0xF8A70DBCL,0xF8A70DBCL,0x1E6BA576L,1L,0xF4B5340CL,0x42DFC3AAL,(-10L)},{1L,0xF8A70DBCL,0x665085ECL,0x42DFC3AAL,0x42DFC3AAL,0x665085ECL,0xF8A70DBCL},{0x665085ECL,0L,0xF8A70DBCL,0xAED900EAL,0xF4B5340CL,0xF0D20C3BL,1L},{0x665085ECL,(-10L),0xE334EB75L,0xF8A70DBCL,0xE334EB75L,(-10L),0x665085ECL},{1L,0xF0D20C3BL,0xF4B5340CL,0xAED900EAL,0xF8A70DBCL,0L,0x665085ECL}};
uint16_t *l_754 = &g_204[1];
uint16_t **l_753 = &l_754;
struct S0 **l_777 = &l_717;
int64_t l_822 = 0xFEBB2EA5648D9233LL;
uint32_t l_873 = 3UL;
const int32_t **l_918 = &g_295[0];
int i, j;
if ((*p_60))
{ /* block id: 267 */
uint32_t l_704 = 0xCC6AFD04L;
const union U1 *l_723 = &g_724;
const union U1 **l_722 = &l_723;
int32_t l_725 = 0xD2924E21L;
const int32_t **l_726 = &g_295[0];
int32_t l_743[10] = {(-1L),(-1L),7L,(-1L),(-1L),7L,(-1L),(-1L),7L,(-1L)};
union U1 * const ** const l_771 = (void*)0;
union U1 * const ** const *l_770 = &l_771;
union U1 * const ** const **l_769[3][3] = {{&l_770,&l_770,&l_770},{&l_770,&l_770,&l_770},{&l_770,&l_770,&l_770}};
struct S0 **l_774 = &l_717;
int64_t *l_791[9] = {&g_357,&g_357,&g_357,&g_357,&g_357,&g_357,&g_357,&g_357,&g_357};
uint64_t l_823 = 0x7F17F234E2063602LL;
int64_t l_880 = 1L;
int16_t l_888[6] = {(-2L),0L,0L,(-2L),0L,0L};
int i, j;
for (g_366 = 7; (g_366 >= 12); g_366 = safe_add_func_int8_t_s_s(g_366, 6))
{ /* block id: 270 */
(*l_134) = l_680[3];
}
if ((*p_60))
{ /* block id: 273 */
union U2 *l_688 = (void*)0;
uint32_t *l_691 = (void*)0;
int32_t l_703 = 0xDDCE03BAL;
if ((safe_mul_func_uint16_t_u_u(g_608.f3, ((l_683[3][3] &= 2L) > l_680[3]))))
{ /* block id: 275 */
int64_t l_693 = (-8L);
int32_t l_694 = 0L;
for (g_128 = 0; (g_128 <= 44); g_128 = safe_add_func_uint64_t_u_u(g_128, 5))
{ /* block id: 278 */
uint32_t *l_690[2][8][1] = {{{&g_279[1][1][0]},{&g_615},{&g_279[1][1][0]},{(void*)0},{&g_279[1][1][0]},{(void*)0},{&g_279[1][1][0]},{&g_615}},{{&g_279[1][1][0]},{(void*)0},{&g_279[1][1][0]},{(void*)0},{&g_279[1][1][0]},{&g_615},{&g_279[1][1][0]},{(void*)0}}};
uint32_t **l_689 = &l_690[1][0][0];
int32_t *l_696 = (void*)0;
int32_t *l_697 = &g_412.f0;
int i, j, k;
(*l_697) = (l_694 = ((*l_134) = ((*p_60) < ((((void*)0 == l_688) && (l_680[1] , ((((*l_689) = &g_615) == (l_692 = l_691)) > (*g_215)))) < (l_693 || l_693)))));
(*l_134) |= (safe_lshift_func_int16_t_s_u((*g_215), 6));
}
}
else
{ /* block id: 286 */
for (g_85 = 0; (g_85 >= 23); g_85 = safe_add_func_uint64_t_u_u(g_85, 1))
{ /* block id: 289 */
(*g_362) = l_702;
}
++l_704;
}
}
else
{ /* block id: 294 */
return l_680[3];
}
(*l_726) = (((safe_sub_func_int32_t_s_s((p_59 > (!(safe_div_func_uint32_t_u_u(l_704, 1UL)))), (safe_rshift_func_uint16_t_u_s((l_704 > (((l_716 == &l_717) & ((safe_lshift_func_uint8_t_u_u((((l_725 = ((((safe_sub_func_uint32_t_u_u((((**g_551) == ((*l_722) = (*g_552))) > (*l_134)), 1L)) && 0x94F056B6L) && l_683[3][3]) > (*g_215))) >= l_704) , p_63), g_209.f4)) >= 7UL)) > p_62)), p_63)))) || g_209.f4) , (*g_362));
for (g_480 = 0; (g_480 >= (-6)); g_480 = safe_sub_func_int8_t_s_s(g_480, 6))
{ /* block id: 302 */
uint64_t l_740[5] = {1UL,1UL,1UL,1UL,1UL};
int32_t l_745 = (-6L);
int32_t l_746 = 0xF60906D5L;
int32_t l_747 = (-1L);
struct S0 **l_775 = &l_717;
int64_t *l_790 = &g_357;
union U1 *l_846 = &g_412;
uint8_t l_868 = 251UL;
struct S0 ***l_877 = &l_777;
int32_t l_881 = (-6L);
int32_t l_882 = 0x1938DDECL;
int32_t l_883 = 0x8E4B8C76L;
int32_t l_885 = 0xA590D79BL;
int32_t l_886 = 0x56437A5CL;
int32_t l_887[5] = {0x91FAC675L,0x91FAC675L,0x91FAC675L,0x91FAC675L,0x91FAC675L};
int i;
for (l_114 = 4; (l_114 >= 0); l_114 -= 1)
{ /* block id: 305 */
int32_t *l_737 = &l_683[3][3];
int32_t l_744[1][4][6] = {{{1L,1L,1L,1L,1L,1L},{1L,1L,1L,1L,1L,1L},{1L,1L,1L,1L,1L,1L},{1L,1L,1L,1L,1L,1L}}};
uint32_t l_767 = 0UL;
union U1 * const ** const **l_768 = (void*)0;
int16_t *l_824 = &g_825;
int16_t *l_826 = &g_827;
const uint16_t l_853[8] = {0x4330L,0x4330L,0x4330L,0x4330L,0x4330L,0x4330L,0x4330L,0x4330L};
int i, j, k;
(*l_134) &= (&p_60 != &g_295[0]);
if ((safe_div_func_uint8_t_u_u((((safe_mul_func_int16_t_s_s((safe_div_func_uint32_t_u_u(l_405[l_114], ((*l_737) |= ((*l_134) = (((safe_rshift_func_uint8_t_u_u((g_480 != (0xA2L < l_405[l_114])), 2)) >= (g_73[2].f3 <= (g_279[8][2][0] || 0x5500L))) , 5L))))), (safe_rshift_func_uint16_t_u_s(0x6282L, l_740[2])))) >= l_740[3]) && 0xA025L), 0x4CL)))
{ /* block id: 309 */
int32_t *l_741 = &g_209.f4;
int32_t *l_742[2];
uint32_t *l_766[9] = {&g_615,&g_615,&g_615,&g_615,&g_615,&g_615,&g_615,&g_615,&g_615};
int i;
for (i = 0; i < 2; i++)
l_742[i] = (void*)0;
--l_748;
l_769[0][1] = (((safe_add_func_int32_t_s_s(((l_753 != g_625) ^ (g_357 && g_209.f3)), (l_767 = (((g_279[1][1][0] = (safe_mod_func_uint32_t_u_u(g_279[1][1][0], (((p_62 || ((safe_div_func_int8_t_s_s((safe_lshift_func_int8_t_s_s((~(&g_158 != (((*l_737) >= ((g_615 = (safe_lshift_func_int8_t_s_s((safe_sub_func_int32_t_s_s(0x4CC9E827L, l_747)), g_358))) || (*p_60))) , (void*)0))), g_88)), (*l_737))) , (*l_737))) < 8UL) & 0x1EE9FCADL)))) >= 3L) | (*l_134))))) & p_62) , l_768);
}
else
{ /* block id: 315 */
struct S0 ***l_776[10] = {&l_775,&l_775,&l_775,&l_775,&l_775,&l_775,&l_775,&l_775,&l_775,&l_775};
int32_t l_811 = 4L;
int32_t *l_812[7] = {&g_85,&g_85,&g_85,&g_85,&g_85,&g_85,&g_85};
int32_t l_813 = 0x67C2191FL;
uint32_t *l_821 = &l_767;
int i;
l_744[0][3][0] |= (((safe_add_func_uint32_t_u_u((l_774 != (l_777 = l_775)), (safe_mul_func_uint16_t_u_u((safe_mod_func_int8_t_s_s((safe_lshift_func_uint16_t_u_u(0x99B0L, (l_683[2][1] = (safe_lshift_func_uint8_t_u_u((((safe_sub_func_uint64_t_u_u((safe_rshift_func_uint8_t_u_u((((((l_791[0] = l_790) != (((safe_mul_func_uint8_t_u_u(((safe_lshift_func_int16_t_s_u((*g_215), 0)) < (safe_lshift_func_uint16_t_u_u((((l_813 = ((safe_mod_func_int32_t_s_s((safe_div_func_uint8_t_u_u((safe_add_func_uint32_t_u_u((safe_mul_func_int8_t_s_s(((g_209.f0 || ((safe_mod_func_int32_t_s_s(((*g_158) ^ (l_811 &= (((safe_unary_minus_func_int16_t_s((safe_mul_func_uint8_t_u_u(g_204[1], (l_405[l_114] |= p_59))))) ^ p_59) < 0x6E7DDEBEE8EE6434LL))), (*g_50))) > 250UL)) && g_480), 0xCBL)), (*p_60))), p_63)), (*p_60))) & (*p_60))) , l_405[l_114]) , p_63), 8))), 255UL)) , l_813) , l_790)) | g_128) , l_680[3]) == (-1L)), g_276.f5)), (*l_737))) >= p_62) && 6L), 0))))), g_209.f0)), (-1L))))) <= g_209.f2) >= l_746);
l_811 = (safe_lshift_func_int16_t_s_s((((((((g_816 == (void*)0) ^ (safe_rshift_func_int16_t_s_s((((*g_158) , 0L) || (l_746 && (p_63 != ((void*)0 == (*l_564))))), ((safe_mod_func_uint32_t_u_u(((*l_821) = ((*p_60) , p_63)), g_412.f3)) , (*l_737))))) < l_822) != (*l_134)) >= (*l_737)) ^ 0x7DD9913C05644877LL) ^ (*g_158)), 8));
(*l_737) ^= 0x419E1916L;
return l_823;
}
if ((((((*l_826) = ((*l_824) = 0xF5E4L)) <= (safe_add_func_uint16_t_u_u((safe_rshift_func_uint8_t_u_u(g_21, ((((**l_774) , (safe_sub_func_int32_t_s_s(((p_63 & (g_216 , g_216)) < (!(0x305E83D8L >= (*p_60)))), (p_62 && (-6L))))) <= p_59) | p_63))), p_63))) <= g_276.f1) < 0x944AL))
{ /* block id: 330 */
union U1 *l_847 = &g_848;
int8_t *l_850 = &l_405[l_114];
uint64_t *l_851[7] = {&l_210,&l_210,&l_210,&l_210,&l_210,&l_210,&l_210};
int i;
(*l_134) = (safe_rshift_func_int8_t_s_s((((l_725 &= (0xB5L != ((!((!(((~(((safe_add_func_uint64_t_u_u(0xE702131F4ABCCE0BLL, (((safe_mod_func_uint16_t_u_u((safe_div_func_uint64_t_u_u((g_852 &= (((((((l_847 = l_846) != l_849) , p_59) <= ((*l_850) = (p_59 == ((*g_50) <= (((**l_753) |= (18446744073709551615UL | 0x8CB2608ABDCBECF9LL)) ^ (*g_215)))))) & 0xB53313E1L) && 0x71B0E2A01FD55994LL) , (*g_158))), 0x9BF63B5C4E883204LL)), (*l_737))) , (*g_158)) >= l_683[0][2]))) < 0x49ADF03810D97E79LL) & (*l_737))) > p_63) < p_59)) < 249UL)) | 0xC6F65813L))) != 0x9F81526076ACE301LL) , l_853[0]), g_22));
(*l_134) ^= (~(5UL != (safe_lshift_func_uint16_t_u_u(p_62, 6))));
}
else
{ /* block id: 338 */
int8_t *l_867[8][7][4] = {{{&g_152,&g_466,&g_152,&l_405[l_114]},{&g_152,(void*)0,&g_152,&l_405[2]},{&g_152,&g_152,&g_152,&l_405[l_114]},{&g_152,&l_405[l_114],&g_152,&g_152},{&g_152,&l_405[2],&g_152,(void*)0},{&g_152,&l_405[l_114],&g_152,&g_466},{&g_152,&l_405[0],&g_152,&g_466}},{{&g_152,&g_466,&g_152,&l_405[0]},{&g_152,&g_466,&g_152,&l_405[l_114]},{&g_152,(void*)0,&g_152,&l_405[2]},{&g_152,&g_152,&g_152,&l_405[l_114]},{&g_152,&l_405[l_114],&g_152,&g_152},{&g_152,&l_405[2],&g_152,(void*)0},{&g_152,&l_405[l_114],&g_152,&g_466}},{{&g_152,&l_405[0],&g_152,&g_466},{&g_152,&g_466,&g_152,&l_405[0]},{&g_152,&g_466,&g_152,&l_405[l_114]},{&g_152,(void*)0,&g_152,&l_405[2]},{&g_152,&g_152,&g_152,&l_405[l_114]},{&g_152,&l_405[l_114],&g_152,&g_152},{&g_152,&l_405[2],&g_152,(void*)0}},{{&g_152,&l_405[l_114],&g_152,&g_466},{&g_152,&l_405[0],&g_152,&g_466},{&g_152,&g_466,&g_152,&l_405[0]},{&g_152,&g_466,&g_152,&l_405[l_114]},{&g_152,(void*)0,&g_152,&l_405[2]},{&g_152,&g_152,&g_152,&l_405[l_114]},{&g_152,&l_405[l_114],&g_152,&g_152}},{{&g_152,&l_405[2],&g_152,(void*)0},{&g_152,&l_405[l_114],&g_152,&g_466},{&g_152,&l_405[0],&g_152,&g_466},{&g_152,&g_466,&g_152,&l_405[0]},{&g_152,&g_466,&g_152,&l_405[l_114]},{&g_152,(void*)0,&g_152,&l_405[2]},{&g_152,&g_152,&g_152,&l_405[l_114]}},{{&g_152,&l_405[l_114],&g_152,&g_152},{&g_152,&l_405[2],&g_152,(void*)0},{&g_152,&l_405[l_114],&g_152,&g_466},{&g_152,&l_405[0],&g_152,&g_466},{&g_152,&g_466,&g_152,&l_405[0]},{&g_152,&g_466,&g_152,&l_405[l_114]},{&g_152,(void*)0,&g_152,&l_405[2]}},{{&g_152,&g_152,&g_152,&l_405[l_114]},{&g_152,&l_405[l_114],&g_152,&g_152},{&g_152,&l_405[2],&g_152,(void*)0},{&g_152,&l_405[l_114],&g_152,&g_466},{&g_152,&l_405[0],&g_152,&g_466},{&g_152,&g_466,&g_152,&l_405[0]},{&g_152,&g_466,&g_152,&l_405[l_114]}},{{&g_152,(void*)0,&g_152,&l_405[2]},{&g_152,&g_152,&g_152,&l_405[l_114]},{&g_152,&l_405[l_114],&g_152,&g_152},{&g_152,&l_405[2],&g_152,(void*)0},{&g_152,&l_405[l_114],&g_152,&g_466},{&g_152,&l_405[0],&g_152,&g_466},{&g_152,&g_466,&g_152,&l_405[0]}}};
uint32_t *l_871 = &g_615;
uint32_t *l_872 = &l_767;
int i, j, k;
l_873 |= (((*l_134) |= (*p_60)) >= ((*l_872) |= ((safe_div_func_int32_t_s_s(((p_62 ^ g_126) < ((safe_rshift_func_int8_t_s_s((((*l_871) &= (safe_mul_func_int16_t_s_s((((**l_777) , p_63) == (safe_lshift_func_uint16_t_u_s(((*l_754) = (safe_div_func_uint16_t_u_u((((g_466 = l_822) , (l_683[1][0] = (p_62 > ((l_868 , (safe_sub_func_uint32_t_u_u((p_62 | p_62), l_680[3]))) > 0x30E0L)))) || (*l_737)), 0xEF3BL))), 9))), p_62))) , 0x48L), g_279[1][0][0])) == g_279[1][1][0])), (*p_60))) == g_279[2][0][0])));
}
if (l_704)
{ /* block id: 347 */
int64_t **l_874[1][2];
int i, j;
for (i = 0; i < 1; i++)
{
for (j = 0; j < 2; j++)
l_874[i][j] = &l_791[0];
}
(*g_875) = l_874[0][1];
return l_876;
}
else
{ /* block id: 350 */
(*g_294) = &l_683[3][3];
}
}
for (l_876 = 0; (l_876 <= 0); l_876 += 1)
{ /* block id: 356 */
int32_t *l_879[1][9][6] = {{{&g_878.f4,(void*)0,&g_21,&g_878.f4,&g_21,(void*)0},{&g_878.f4,(void*)0,&g_21,&g_878.f4,&g_21,(void*)0},{&g_878.f4,(void*)0,&g_21,&g_878.f4,&g_21,(void*)0},{&g_878.f4,(void*)0,&g_21,&g_878.f4,&g_21,(void*)0},{&g_878.f4,(void*)0,&g_21,&g_878.f4,&g_21,(void*)0},{&g_878.f4,(void*)0,&g_21,&g_878.f4,&g_21,(void*)0},{&g_878.f4,(void*)0,&g_21,&g_878.f4,&g_21,(void*)0},{&g_878.f4,(void*)0,&g_21,&g_878.f4,&g_21,(void*)0},{&g_878.f4,(void*)0,&g_21,&g_878.f4,&g_21,(void*)0}}};
int8_t l_884 = 0xBBL;
uint8_t l_889 = 0x96L;
int i, j, k;
for (l_114 = 0; (l_114 <= 0); l_114 += 1)
{ /* block id: 359 */
l_877 = &l_716;
}
g_695[l_876][l_876] = (g_878 , &l_129[0][6]);
l_889++;
for (g_276.f7 = 0; (g_276.f7 >= 0); g_276.f7 -= 1)
{ /* block id: 366 */
int32_t **l_892 = &l_879[0][6][4];
uint32_t *l_915[5] = {&g_279[4][1][0],&g_279[4][1][0],&g_279[4][1][0],&g_279[4][1][0],&g_279[4][1][0]};
const int32_t l_916 = 0x8E0E4F65L;
int i, j, k;
(*l_726) = ((*l_892) = &l_129[(l_876 + 1)][(l_876 + 6)]);
(*l_134) ^= (safe_add_func_uint32_t_u_u((safe_rshift_func_uint16_t_u_s((safe_sub_func_uint8_t_u_u(((safe_sub_func_uint64_t_u_u(p_62, p_62)) != (((safe_sub_func_uint8_t_u_u(255UL, ((*l_125) = (p_59 , (!p_59))))) <= (safe_mod_func_int64_t_s_s(((+((g_827 = (*g_215)) , (safe_add_func_int8_t_s_s(0L, g_412.f3)))) ^ (safe_lshift_func_uint8_t_u_u((safe_mod_func_int64_t_s_s(((safe_mod_func_uint32_t_u_u((g_279[1][1][0] |= (g_615 = 0x33166834L)), 1L)) == p_59), p_59)), 7))), l_873))) >= 2UL)), p_59)), p_62)), (-7L)));
if (l_916)
continue;
l_683[3][3] = (*p_60);
}
}
(*l_134) = 1L;
}
}
else
{ /* block id: 380 */
return l_873;
}
(*l_134) |= (-1L);
(*l_918) = (*g_362);
}
(*l_134) = (*l_134);
return p_62;
}
/* ------------------------------------------ */
/*
* reads :
* writes:
*/
static uint64_t func_68(uint8_t * p_69, uint32_t p_70, uint32_t p_71, uint64_t p_72)
{ /* block id: 26 */
int32_t *l_86 = (void*)0;
int32_t *l_87 = &g_88;
int32_t *l_89 = &g_88;
int32_t *l_90 = &g_88;
int32_t l_91 = (-2L);
int32_t *l_92 = &g_88;
int32_t *l_93[4][5] = {{&g_88,&g_88,(void*)0,&l_91,(void*)0},{&g_22,&g_22,&g_22,&g_21,&g_22},{&g_88,&g_88,(void*)0,&l_91,(void*)0},{&g_22,&g_22,&g_22,&g_21,&g_22}};
int64_t l_94[1][1];
uint16_t l_95 = 65535UL;
int i, j;
for (i = 0; i < 1; i++)
{
for (j = 0; j < 1; j++)
l_94[i][j] = 0L;
}
l_95--;
return p_70;
}
/* ---------------------------------------- */
int main (int argc, char* argv[])
{
int i, j, k;
int print_hash_value = 0;
if (argc == 2 && strcmp(argv[1], "1") == 0) print_hash_value = 1;
platform_main_begin();
crc32_gentab();
func_1();
for (i = 0; i < 2; i++)
{
for (j = 0; j < 8; j++)
{
for (k = 0; k < 9; k++)
{
transparent_crc(g_11[i][j][k], "g_11[i][j][k]", print_hash_value);
if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
}
}
}
transparent_crc(g_20, "g_20", print_hash_value);
transparent_crc(g_21, "g_21", print_hash_value);
transparent_crc(g_22, "g_22", print_hash_value);
for (i = 0; i < 3; i++)
{
transparent_crc(g_73[i].f0, "g_73[i].f0", print_hash_value);
transparent_crc(g_73[i].f2, "g_73[i].f2", print_hash_value);
transparent_crc(g_73[i].f3, "g_73[i].f3", print_hash_value);
transparent_crc(g_73[i].f4, "g_73[i].f4", print_hash_value);
if (print_hash_value) printf("index = [%d]\n", i);
}
transparent_crc(g_82, "g_82", print_hash_value);
transparent_crc(g_85, "g_85", print_hash_value);
transparent_crc(g_88, "g_88", print_hash_value);
transparent_crc(g_126, "g_126", print_hash_value);
transparent_crc(g_128, "g_128", print_hash_value);
transparent_crc(g_149, "g_149", print_hash_value);
transparent_crc(g_152, "g_152", print_hash_value);
transparent_crc(g_159, "g_159", print_hash_value);
for (i = 0; i < 2; i++)
{
transparent_crc(g_204[i], "g_204[i]", print_hash_value);
if (print_hash_value) printf("index = [%d]\n", i);
}
transparent_crc(g_209.f0, "g_209.f0", print_hash_value);
transparent_crc(g_209.f2, "g_209.f2", print_hash_value);
transparent_crc(g_209.f3, "g_209.f3", print_hash_value);
transparent_crc(g_209.f4, "g_209.f4", print_hash_value);
transparent_crc(g_216, "g_216", print_hash_value);
transparent_crc(g_276.f0, "g_276.f0", print_hash_value);
transparent_crc(g_276.f1, "g_276.f1", print_hash_value);
transparent_crc(g_276.f2, "g_276.f2", print_hash_value);
transparent_crc(g_276.f3, "g_276.f3", print_hash_value);
transparent_crc(g_276.f4, "g_276.f4", print_hash_value);
transparent_crc(g_276.f5, "g_276.f5", print_hash_value);
transparent_crc(g_276.f6, "g_276.f6", print_hash_value);
transparent_crc(g_276.f7, "g_276.f7", print_hash_value);
for (i = 0; i < 10; i++)
{
for (j = 0; j < 4; j++)
{
for (k = 0; k < 1; k++)
{
transparent_crc(g_279[i][j][k], "g_279[i][j][k]", print_hash_value);
if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
}
}
}
transparent_crc(g_334.f0, "g_334.f0", print_hash_value);
transparent_crc(g_334.f1, "g_334.f1", print_hash_value);
transparent_crc(g_334.f2, "g_334.f2", print_hash_value);
transparent_crc(g_334.f3, "g_334.f3", print_hash_value);
for (i = 0; i < 1; i++)
{
transparent_crc(g_338[i], "g_338[i]", print_hash_value);
if (print_hash_value) printf("index = [%d]\n", i);
}
transparent_crc(g_357, "g_357", print_hash_value);
transparent_crc(g_358, "g_358", print_hash_value);
transparent_crc(g_359, "g_359", print_hash_value);
transparent_crc(g_366, "g_366", print_hash_value);
transparent_crc(g_412.f0, "g_412.f0", print_hash_value);
transparent_crc(g_412.f1, "g_412.f1", print_hash_value);
transparent_crc(g_412.f2, "g_412.f2", print_hash_value);
transparent_crc(g_412.f3, "g_412.f3", print_hash_value);
transparent_crc(g_466, "g_466", print_hash_value);
transparent_crc(g_480, "g_480", print_hash_value);
transparent_crc(g_608.f0, "g_608.f0", print_hash_value);
transparent_crc(g_608.f1, "g_608.f1", print_hash_value);
transparent_crc(g_608.f2, "g_608.f2", print_hash_value);
transparent_crc(g_608.f3, "g_608.f3", print_hash_value);
transparent_crc(g_615, "g_615", print_hash_value);
transparent_crc(g_724.f0, "g_724.f0", print_hash_value);
transparent_crc(g_724.f1, "g_724.f1", print_hash_value);
transparent_crc(g_724.f2, "g_724.f2", print_hash_value);
transparent_crc(g_724.f3, "g_724.f3", print_hash_value);
transparent_crc(g_825, "g_825", print_hash_value);
transparent_crc(g_827, "g_827", print_hash_value);
transparent_crc(g_848.f1, "g_848.f1", print_hash_value);
transparent_crc(g_852, "g_852", print_hash_value);
transparent_crc(g_878.f0, "g_878.f0", print_hash_value);
transparent_crc(g_878.f2, "g_878.f2", print_hash_value);
transparent_crc(g_878.f3, "g_878.f3", print_hash_value);
transparent_crc(g_878.f4, "g_878.f4", print_hash_value);
for (i = 0; i < 5; i++)
{
transparent_crc(g_968[i].f0, "g_968[i].f0", print_hash_value);
transparent_crc(g_968[i].f1, "g_968[i].f1", print_hash_value);
transparent_crc(g_968[i].f2, "g_968[i].f2", print_hash_value);
transparent_crc(g_968[i].f3, "g_968[i].f3", print_hash_value);
transparent_crc(g_968[i].f4, "g_968[i].f4", print_hash_value);
transparent_crc(g_968[i].f5, "g_968[i].f5", print_hash_value);
transparent_crc(g_968[i].f6, "g_968[i].f6", print_hash_value);
transparent_crc(g_968[i].f7, "g_968[i].f7", print_hash_value);
if (print_hash_value) printf("index = [%d]\n", i);
}
for (i = 0; i < 8; i++)
{
for (j = 0; j < 1; j++)
{
transparent_crc(g_983[i][j].f0, "g_983[i][j].f0", print_hash_value);
transparent_crc(g_983[i][j].f1, "g_983[i][j].f1", print_hash_value);
transparent_crc(g_983[i][j].f2, "g_983[i][j].f2", print_hash_value);
transparent_crc(g_983[i][j].f3, "g_983[i][j].f3", print_hash_value);
if (print_hash_value) printf("index = [%d][%d]\n", i, j);
}
}
transparent_crc(g_992.f0, "g_992.f0", print_hash_value);
transparent_crc(g_992.f2, "g_992.f2", print_hash_value);
transparent_crc(g_992.f3, "g_992.f3", print_hash_value);
transparent_crc(g_992.f4, "g_992.f4", print_hash_value);
transparent_crc(g_1061, "g_1061", print_hash_value);
for (i = 0; i < 8; i++)
{
for (j = 0; j < 8; j++)
{
for (k = 0; k < 4; k++)
{
transparent_crc(g_1082[i][j][k], "g_1082[i][j][k]", print_hash_value);
if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
}
}
}
transparent_crc(g_1111.f1, "g_1111.f1", print_hash_value);
transparent_crc(g_1131.f0, "g_1131.f0", print_hash_value);
transparent_crc(g_1131.f1, "g_1131.f1", print_hash_value);
transparent_crc(g_1131.f2, "g_1131.f2", print_hash_value);
transparent_crc(g_1131.f3, "g_1131.f3", print_hash_value);
transparent_crc(g_1165, "g_1165", print_hash_value);
transparent_crc(g_1218.f0, "g_1218.f0", print_hash_value);
transparent_crc(g_1218.f2, "g_1218.f2", print_hash_value);
transparent_crc(g_1218.f3, "g_1218.f3", print_hash_value);
transparent_crc(g_1218.f4, "g_1218.f4", print_hash_value);
transparent_crc(g_1341.f1, "g_1341.f1", print_hash_value);
transparent_crc(g_1345.f0, "g_1345.f0", print_hash_value);
transparent_crc(g_1345.f2, "g_1345.f2", print_hash_value);
transparent_crc(g_1345.f3, "g_1345.f3", print_hash_value);
transparent_crc(g_1345.f4, "g_1345.f4", print_hash_value);
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
{
transparent_crc(g_1353[i][j].f0, "g_1353[i][j].f0", print_hash_value);
transparent_crc(g_1353[i][j].f2, "g_1353[i][j].f2", print_hash_value);
transparent_crc(g_1353[i][j].f3, "g_1353[i][j].f3", print_hash_value);
transparent_crc(g_1353[i][j].f4, "g_1353[i][j].f4", print_hash_value);
if (print_hash_value) printf("index = [%d][%d]\n", i, j);
}
}
for (i = 0; i < 2; i++)
{
for (j = 0; j < 8; j++)
{
transparent_crc(g_1368[i][j].f0, "g_1368[i][j].f0", print_hash_value);
transparent_crc(g_1368[i][j].f1, "g_1368[i][j].f1", print_hash_value);
transparent_crc(g_1368[i][j].f2, "g_1368[i][j].f2", print_hash_value);
transparent_crc(g_1368[i][j].f3, "g_1368[i][j].f3", print_hash_value);
transparent_crc(g_1368[i][j].f4, "g_1368[i][j].f4", print_hash_value);
transparent_crc(g_1368[i][j].f5, "g_1368[i][j].f5", print_hash_value);
transparent_crc(g_1368[i][j].f6, "g_1368[i][j].f6", print_hash_value);
transparent_crc(g_1368[i][j].f7, "g_1368[i][j].f7", print_hash_value);
if (print_hash_value) printf("index = [%d][%d]\n", i, j);
}
}
transparent_crc(g_1380.f0, "g_1380.f0", print_hash_value);
transparent_crc(g_1380.f1, "g_1380.f1", print_hash_value);
transparent_crc(g_1380.f2, "g_1380.f2", print_hash_value);
transparent_crc(g_1380.f3, "g_1380.f3", print_hash_value);
transparent_crc(g_1416.f0, "g_1416.f0", print_hash_value);
transparent_crc(g_1416.f1, "g_1416.f1", print_hash_value);
transparent_crc(g_1416.f2, "g_1416.f2", print_hash_value);
transparent_crc(g_1416.f3, "g_1416.f3", print_hash_value);
transparent_crc(g_1459.f0, "g_1459.f0", print_hash_value);
transparent_crc(g_1459.f1, "g_1459.f1", print_hash_value);
transparent_crc(g_1459.f2, "g_1459.f2", print_hash_value);
transparent_crc(g_1459.f3, "g_1459.f3", print_hash_value);
transparent_crc(g_1459.f4, "g_1459.f4", print_hash_value);
transparent_crc(g_1459.f5, "g_1459.f5", print_hash_value);
transparent_crc(g_1459.f6, "g_1459.f6", print_hash_value);
transparent_crc(g_1459.f7, "g_1459.f7", print_hash_value);
transparent_crc(g_1485.f0, "g_1485.f0", print_hash_value);
transparent_crc(g_1485.f2, "g_1485.f2", print_hash_value);
transparent_crc(g_1485.f3, "g_1485.f3", print_hash_value);
transparent_crc(g_1485.f4, "g_1485.f4", print_hash_value);
transparent_crc(g_1501.f0, "g_1501.f0", print_hash_value);
transparent_crc(g_1501.f1, "g_1501.f1", print_hash_value);
transparent_crc(g_1501.f2, "g_1501.f2", print_hash_value);
transparent_crc(g_1501.f3, "g_1501.f3", print_hash_value);
for (i = 0; i < 7; i++)
{
transparent_crc(g_1519[i].f0, "g_1519[i].f0", print_hash_value);
transparent_crc(g_1519[i].f1, "g_1519[i].f1", print_hash_value);
transparent_crc(g_1519[i].f2, "g_1519[i].f2", print_hash_value);
transparent_crc(g_1519[i].f3, "g_1519[i].f3", print_hash_value);
transparent_crc(g_1519[i].f4, "g_1519[i].f4", print_hash_value);
transparent_crc(g_1519[i].f5, "g_1519[i].f5", print_hash_value);
transparent_crc(g_1519[i].f6, "g_1519[i].f6", print_hash_value);
transparent_crc(g_1519[i].f7, "g_1519[i].f7", print_hash_value);
if (print_hash_value) printf("index = [%d]\n", i);
}
transparent_crc(g_1520.f0, "g_1520.f0", print_hash_value);
transparent_crc(g_1520.f1, "g_1520.f1", print_hash_value);
transparent_crc(g_1520.f2, "g_1520.f2", print_hash_value);
transparent_crc(g_1520.f3, "g_1520.f3", print_hash_value);
transparent_crc(g_1520.f4, "g_1520.f4", print_hash_value);
transparent_crc(g_1520.f5, "g_1520.f5", print_hash_value);
transparent_crc(g_1520.f6, "g_1520.f6", print_hash_value);
transparent_crc(g_1520.f7, "g_1520.f7", print_hash_value);
transparent_crc(g_1521.f0, "g_1521.f0", print_hash_value);
transparent_crc(g_1521.f1, "g_1521.f1", print_hash_value);
transparent_crc(g_1521.f2, "g_1521.f2", print_hash_value);
transparent_crc(g_1521.f3, "g_1521.f3", print_hash_value);
transparent_crc(g_1521.f4, "g_1521.f4", print_hash_value);
transparent_crc(g_1521.f5, "g_1521.f5", print_hash_value);
transparent_crc(g_1521.f6, "g_1521.f6", print_hash_value);
transparent_crc(g_1521.f7, "g_1521.f7", print_hash_value);
transparent_crc(g_1522.f0, "g_1522.f0", print_hash_value);
transparent_crc(g_1522.f1, "g_1522.f1", print_hash_value);
transparent_crc(g_1522.f2, "g_1522.f2", print_hash_value);
transparent_crc(g_1522.f3, "g_1522.f3", print_hash_value);
transparent_crc(g_1522.f4, "g_1522.f4", print_hash_value);
transparent_crc(g_1522.f5, "g_1522.f5", print_hash_value);
transparent_crc(g_1522.f6, "g_1522.f6", print_hash_value);
transparent_crc(g_1522.f7, "g_1522.f7", print_hash_value);
transparent_crc(g_1523.f0, "g_1523.f0", print_hash_value);
transparent_crc(g_1523.f1, "g_1523.f1", print_hash_value);
transparent_crc(g_1523.f2, "g_1523.f2", print_hash_value);
transparent_crc(g_1523.f3, "g_1523.f3", print_hash_value);
transparent_crc(g_1523.f4, "g_1523.f4", print_hash_value);
transparent_crc(g_1523.f5, "g_1523.f5", print_hash_value);
transparent_crc(g_1523.f6, "g_1523.f6", print_hash_value);
transparent_crc(g_1523.f7, "g_1523.f7", print_hash_value);
for (i = 0; i < 7; i++)
{
transparent_crc(g_1524[i].f0, "g_1524[i].f0", print_hash_value);
transparent_crc(g_1524[i].f1, "g_1524[i].f1", print_hash_value);
transparent_crc(g_1524[i].f2, "g_1524[i].f2", print_hash_value);
transparent_crc(g_1524[i].f3, "g_1524[i].f3", print_hash_value);
transparent_crc(g_1524[i].f4, "g_1524[i].f4", print_hash_value);
transparent_crc(g_1524[i].f5, "g_1524[i].f5", print_hash_value);
transparent_crc(g_1524[i].f6, "g_1524[i].f6", print_hash_value);
transparent_crc(g_1524[i].f7, "g_1524[i].f7", print_hash_value);
if (print_hash_value) printf("index = [%d]\n", i);
}
transparent_crc(g_1525.f0, "g_1525.f0", print_hash_value);
transparent_crc(g_1525.f1, "g_1525.f1", print_hash_value);
transparent_crc(g_1525.f2, "g_1525.f2", print_hash_value);
transparent_crc(g_1525.f3, "g_1525.f3", print_hash_value);
transparent_crc(g_1525.f4, "g_1525.f4", print_hash_value);
transparent_crc(g_1525.f5, "g_1525.f5", print_hash_value);
transparent_crc(g_1525.f6, "g_1525.f6", print_hash_value);
transparent_crc(g_1525.f7, "g_1525.f7", print_hash_value);
transparent_crc(g_1526.f0, "g_1526.f0", print_hash_value);
transparent_crc(g_1526.f1, "g_1526.f1", print_hash_value);
transparent_crc(g_1526.f2, "g_1526.f2", print_hash_value);
transparent_crc(g_1526.f3, "g_1526.f3", print_hash_value);
transparent_crc(g_1526.f4, "g_1526.f4", print_hash_value);
transparent_crc(g_1526.f5, "g_1526.f5", print_hash_value);
transparent_crc(g_1526.f6, "g_1526.f6", print_hash_value);
transparent_crc(g_1526.f7, "g_1526.f7", print_hash_value);
transparent_crc(g_1527.f0, "g_1527.f0", print_hash_value);
transparent_crc(g_1527.f1, "g_1527.f1", print_hash_value);
transparent_crc(g_1527.f2, "g_1527.f2", print_hash_value);
transparent_crc(g_1527.f3, "g_1527.f3", print_hash_value);
transparent_crc(g_1527.f4, "g_1527.f4", print_hash_value);
transparent_crc(g_1527.f5, "g_1527.f5", print_hash_value);
transparent_crc(g_1527.f6, "g_1527.f6", print_hash_value);
transparent_crc(g_1527.f7, "g_1527.f7", print_hash_value);
for (i = 0; i < 1; i++)
{
for (j = 0; j < 6; j++)
{
for (k = 0; k < 8; k++)
{
transparent_crc(g_1529[i][j][k].f0, "g_1529[i][j][k].f0", print_hash_value);
transparent_crc(g_1529[i][j][k].f1, "g_1529[i][j][k].f1", print_hash_value);
transparent_crc(g_1529[i][j][k].f2, "g_1529[i][j][k].f2", print_hash_value);
transparent_crc(g_1529[i][j][k].f3, "g_1529[i][j][k].f3", print_hash_value);
transparent_crc(g_1529[i][j][k].f4, "g_1529[i][j][k].f4", print_hash_value);
transparent_crc(g_1529[i][j][k].f5, "g_1529[i][j][k].f5", print_hash_value);
transparent_crc(g_1529[i][j][k].f6, "g_1529[i][j][k].f6", print_hash_value);
transparent_crc(g_1529[i][j][k].f7, "g_1529[i][j][k].f7", print_hash_value);
if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
}
}
}
for (i = 0; i < 5; i++)
{
for (j = 0; j < 3; j++)
{
for (k = 0; k < 6; k++)
{
transparent_crc(g_1549[i][j][k].f0, "g_1549[i][j][k].f0", print_hash_value);
transparent_crc(g_1549[i][j][k].f2, "g_1549[i][j][k].f2", print_hash_value);
transparent_crc(g_1549[i][j][k].f3, "g_1549[i][j][k].f3", print_hash_value);
transparent_crc(g_1549[i][j][k].f4, "g_1549[i][j][k].f4", print_hash_value);
if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
}
}
}
transparent_crc(g_1564.f0, "g_1564.f0", print_hash_value);
transparent_crc(g_1564.f2, "g_1564.f2", print_hash_value);
transparent_crc(g_1564.f3, "g_1564.f3", print_hash_value);
transparent_crc(g_1564.f4, "g_1564.f4", print_hash_value);
transparent_crc(g_1598, "g_1598", print_hash_value);
transparent_crc(g_1646, "g_1646", print_hash_value);
transparent_crc(g_1653, "g_1653", print_hash_value);
transparent_crc(g_1708, "g_1708", print_hash_value);
for (i = 0; i < 8; i++)
{
for (j = 0; j < 6; j++)
{
transparent_crc(g_1720[i][j].f0, "g_1720[i][j].f0", print_hash_value);
transparent_crc(g_1720[i][j].f1, "g_1720[i][j].f1", print_hash_value);
transparent_crc(g_1720[i][j].f2, "g_1720[i][j].f2", print_hash_value);
transparent_crc(g_1720[i][j].f3, "g_1720[i][j].f3", print_hash_value);
transparent_crc(g_1720[i][j].f4, "g_1720[i][j].f4", print_hash_value);
transparent_crc(g_1720[i][j].f5, "g_1720[i][j].f5", print_hash_value);
transparent_crc(g_1720[i][j].f6, "g_1720[i][j].f6", print_hash_value);
transparent_crc(g_1720[i][j].f7, "g_1720[i][j].f7", print_hash_value);
if (print_hash_value) printf("index = [%d][%d]\n", i, j);
}
}
transparent_crc(g_1730.f0, "g_1730.f0", print_hash_value);
transparent_crc(g_1730.f1, "g_1730.f1", print_hash_value);
transparent_crc(g_1730.f2, "g_1730.f2", print_hash_value);
transparent_crc(g_1730.f3, "g_1730.f3", print_hash_value);
transparent_crc(g_1730.f4, "g_1730.f4", print_hash_value);
transparent_crc(g_1730.f5, "g_1730.f5", print_hash_value);
transparent_crc(g_1730.f6, "g_1730.f6", print_hash_value);
transparent_crc(g_1730.f7, "g_1730.f7", print_hash_value);
for (i = 0; i < 9; i++)
{
transparent_crc(g_1775[i].f0, "g_1775[i].f0", print_hash_value);
transparent_crc(g_1775[i].f2, "g_1775[i].f2", print_hash_value);
transparent_crc(g_1775[i].f3, "g_1775[i].f3", print_hash_value);
transparent_crc(g_1775[i].f4, "g_1775[i].f4", print_hash_value);
if (print_hash_value) printf("index = [%d]\n", i);
}
transparent_crc(g_1850.f0, "g_1850.f0", print_hash_value);
transparent_crc(g_1850.f1, "g_1850.f1", print_hash_value);
transparent_crc(g_1850.f2, "g_1850.f2", print_hash_value);
transparent_crc(g_1850.f3, "g_1850.f3", print_hash_value);
transparent_crc(g_1850.f4, "g_1850.f4", print_hash_value);
transparent_crc(g_1850.f5, "g_1850.f5", print_hash_value);
transparent_crc(g_1850.f6, "g_1850.f6", print_hash_value);
transparent_crc(g_1850.f7, "g_1850.f7", print_hash_value);
transparent_crc(g_1903.f0, "g_1903.f0", print_hash_value);
transparent_crc(g_1903.f1, "g_1903.f1", print_hash_value);
transparent_crc(g_1903.f2, "g_1903.f2", print_hash_value);
transparent_crc(g_1903.f3, "g_1903.f3", print_hash_value);
transparent_crc(g_1942.f0, "g_1942.f0", print_hash_value);
transparent_crc(g_1942.f1, "g_1942.f1", print_hash_value);
transparent_crc(g_1942.f2, "g_1942.f2", print_hash_value);
transparent_crc(g_1942.f3, "g_1942.f3", print_hash_value);
transparent_crc(g_1942.f4, "g_1942.f4", print_hash_value);
transparent_crc(g_1942.f5, "g_1942.f5", print_hash_value);
transparent_crc(g_1942.f6, "g_1942.f6", print_hash_value);
transparent_crc(g_1942.f7, "g_1942.f7", print_hash_value);
for (i = 0; i < 7; i++)
{
for (j = 0; j < 2; j++)
{
for (k = 0; k < 7; k++)
{
transparent_crc(g_1983[i][j][k].f0, "g_1983[i][j][k].f0", print_hash_value);
transparent_crc(g_1983[i][j][k].f1, "g_1983[i][j][k].f1", print_hash_value);
transparent_crc(g_1983[i][j][k].f2, "g_1983[i][j][k].f2", print_hash_value);
transparent_crc(g_1983[i][j][k].f3, "g_1983[i][j][k].f3", print_hash_value);
transparent_crc(g_1983[i][j][k].f4, "g_1983[i][j][k].f4", print_hash_value);
transparent_crc(g_1983[i][j][k].f5, "g_1983[i][j][k].f5", print_hash_value);
transparent_crc(g_1983[i][j][k].f6, "g_1983[i][j][k].f6", print_hash_value);
transparent_crc(g_1983[i][j][k].f7, "g_1983[i][j][k].f7", print_hash_value);
if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
}
}
}
for (i = 0; i < 10; i++)
{
for (j = 0; j < 8; j++)
{
transparent_crc(g_2006[i][j].f0, "g_2006[i][j].f0", print_hash_value);
transparent_crc(g_2006[i][j].f2, "g_2006[i][j].f2", print_hash_value);
transparent_crc(g_2006[i][j].f3, "g_2006[i][j].f3", print_hash_value);
transparent_crc(g_2006[i][j].f4, "g_2006[i][j].f4", print_hash_value);
if (print_hash_value) printf("index = [%d][%d]\n", i, j);
}
}
transparent_crc(g_2023.f0, "g_2023.f0", print_hash_value);
transparent_crc(g_2023.f1, "g_2023.f1", print_hash_value);
transparent_crc(g_2023.f2, "g_2023.f2", print_hash_value);
transparent_crc(g_2023.f3, "g_2023.f3", print_hash_value);
transparent_crc(g_2023.f4, "g_2023.f4", print_hash_value);
transparent_crc(g_2023.f5, "g_2023.f5", print_hash_value);
transparent_crc(g_2023.f6, "g_2023.f6", print_hash_value);
transparent_crc(g_2023.f7, "g_2023.f7", print_hash_value);
transparent_crc(g_2177.f0, "g_2177.f0", print_hash_value);
transparent_crc(g_2177.f1, "g_2177.f1", print_hash_value);
transparent_crc(g_2177.f2, "g_2177.f2", print_hash_value);
transparent_crc(g_2177.f3, "g_2177.f3", print_hash_value);
transparent_crc(g_2211.f0, "g_2211.f0", print_hash_value);
transparent_crc(g_2211.f1, "g_2211.f1", print_hash_value);
transparent_crc(g_2211.f2, "g_2211.f2", print_hash_value);
transparent_crc(g_2211.f3, "g_2211.f3", print_hash_value);
for (i = 0; i < 3; i++)
{
transparent_crc(g_2230[i].f0, "g_2230[i].f0", print_hash_value);
transparent_crc(g_2230[i].f1, "g_2230[i].f1", print_hash_value);
transparent_crc(g_2230[i].f2, "g_2230[i].f2", print_hash_value);
transparent_crc(g_2230[i].f3, "g_2230[i].f3", print_hash_value);
if (print_hash_value) printf("index = [%d]\n", i);
}
for (i = 0; i < 5; i++)
{
for (j = 0; j < 7; j++)
{
for (k = 0; k < 5; k++)
{
transparent_crc(g_2241[i][j][k].f0, "g_2241[i][j][k].f0", print_hash_value);
transparent_crc(g_2241[i][j][k].f2, "g_2241[i][j][k].f2", print_hash_value);
transparent_crc(g_2241[i][j][k].f3, "g_2241[i][j][k].f3", print_hash_value);
transparent_crc(g_2241[i][j][k].f4, "g_2241[i][j][k].f4", print_hash_value);
if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
}
}
}
for (i = 0; i < 3; i++)
{
transparent_crc(g_2243[i].f0, "g_2243[i].f0", print_hash_value);
transparent_crc(g_2243[i].f2, "g_2243[i].f2", print_hash_value);
transparent_crc(g_2243[i].f3, "g_2243[i].f3", print_hash_value);
transparent_crc(g_2243[i].f4, "g_2243[i].f4", print_hash_value);
if (print_hash_value) printf("index = [%d]\n", i);
}
transparent_crc(g_2299.f0, "g_2299.f0", print_hash_value);
transparent_crc(g_2299.f2, "g_2299.f2", print_hash_value);
transparent_crc(g_2299.f3, "g_2299.f3", print_hash_value);
transparent_crc(g_2299.f4, "g_2299.f4", print_hash_value);
for (i = 0; i < 9; i++)
{
for (j = 0; j < 8; j++)
{
for (k = 0; k < 3; k++)
{
transparent_crc(g_2301[i][j][k].f0, "g_2301[i][j][k].f0", print_hash_value);
transparent_crc(g_2301[i][j][k].f1, "g_2301[i][j][k].f1", print_hash_value);
transparent_crc(g_2301[i][j][k].f2, "g_2301[i][j][k].f2", print_hash_value);
transparent_crc(g_2301[i][j][k].f3, "g_2301[i][j][k].f3", print_hash_value);
if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
}
}
}
transparent_crc(g_2314, "g_2314", print_hash_value);
transparent_crc(g_2354, "g_2354", print_hash_value);
for (i = 0; i < 6; i++)
{
for (j = 0; j < 10; j++)
{
for (k = 0; k < 4; k++)
{
transparent_crc(g_2459[i][j][k].f0, "g_2459[i][j][k].f0", print_hash_value);
transparent_crc(g_2459[i][j][k].f2, "g_2459[i][j][k].f2", print_hash_value);
transparent_crc(g_2459[i][j][k].f3, "g_2459[i][j][k].f3", print_hash_value);
transparent_crc(g_2459[i][j][k].f4, "g_2459[i][j][k].f4", print_hash_value);
if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
}
}
}
transparent_crc(g_2482, "g_2482", print_hash_value);
transparent_crc(g_2528.f0, "g_2528.f0", print_hash_value);
transparent_crc(g_2528.f1, "g_2528.f1", print_hash_value);
transparent_crc(g_2528.f2, "g_2528.f2", print_hash_value);
transparent_crc(g_2528.f3, "g_2528.f3", print_hash_value);
transparent_crc(g_2623.f0, "g_2623.f0", print_hash_value);
transparent_crc(g_2623.f1, "g_2623.f1", print_hash_value);
transparent_crc(g_2623.f2, "g_2623.f2", print_hash_value);
transparent_crc(g_2623.f3, "g_2623.f3", print_hash_value);
transparent_crc(g_2643.f0, "g_2643.f0", print_hash_value);
transparent_crc(g_2643.f1, "g_2643.f1", print_hash_value);
transparent_crc(g_2643.f2, "g_2643.f2", print_hash_value);
transparent_crc(g_2643.f3, "g_2643.f3", print_hash_value);
transparent_crc(g_2654.f0, "g_2654.f0", print_hash_value);
transparent_crc(g_2654.f1, "g_2654.f1", print_hash_value);
transparent_crc(g_2654.f2, "g_2654.f2", print_hash_value);
transparent_crc(g_2654.f3, "g_2654.f3", print_hash_value);
for (i = 0; i < 7; i++)
{
for (j = 0; j < 7; j++)
{
for (k = 0; k < 5; k++)
{
transparent_crc(g_2677[i][j][k].f0, "g_2677[i][j][k].f0", print_hash_value);
transparent_crc(g_2677[i][j][k].f1, "g_2677[i][j][k].f1", print_hash_value);
transparent_crc(g_2677[i][j][k].f2, "g_2677[i][j][k].f2", print_hash_value);
transparent_crc(g_2677[i][j][k].f3, "g_2677[i][j][k].f3", print_hash_value);
transparent_crc(g_2677[i][j][k].f4, "g_2677[i][j][k].f4", print_hash_value);
transparent_crc(g_2677[i][j][k].f5, "g_2677[i][j][k].f5", print_hash_value);
transparent_crc(g_2677[i][j][k].f6, "g_2677[i][j][k].f6", print_hash_value);
transparent_crc(g_2677[i][j][k].f7, "g_2677[i][j][k].f7", print_hash_value);
if (print_hash_value) printf("index = [%d][%d][%d]\n", i, j, k);
}
}
}
transparent_crc(g_2696.f0, "g_2696.f0", print_hash_value);
transparent_crc(g_2696.f2, "g_2696.f2", print_hash_value);
transparent_crc(g_2696.f3, "g_2696.f3", print_hash_value);
transparent_crc(g_2696.f4, "g_2696.f4", print_hash_value);
for (i = 0; i < 5; i++)
{
for (j = 0; j < 1; j++)
{
transparent_crc(g_2704[i][j].f0, "g_2704[i][j].f0", print_hash_value);
transparent_crc(g_2704[i][j].f1, "g_2704[i][j].f1", print_hash_value);
transparent_crc(g_2704[i][j].f2, "g_2704[i][j].f2", print_hash_value);
transparent_crc(g_2704[i][j].f3, "g_2704[i][j].f3", print_hash_value);
if (print_hash_value) printf("index = [%d][%d]\n", i, j);
}
}
transparent_crc(g_2727.f0, "g_2727.f0", print_hash_value);
transparent_crc(g_2727.f2, "g_2727.f2", print_hash_value);
transparent_crc(g_2727.f3, "g_2727.f3", print_hash_value);
transparent_crc(g_2727.f4, "g_2727.f4", print_hash_value);
transparent_crc(g_2745.f0, "g_2745.f0", print_hash_value);
transparent_crc(g_2745.f1, "g_2745.f1", print_hash_value);
transparent_crc(g_2745.f2, "g_2745.f2", print_hash_value);
transparent_crc(g_2745.f3, "g_2745.f3", print_hash_value);
transparent_crc(g_2745.f4, "g_2745.f4", print_hash_value);
transparent_crc(g_2745.f5, "g_2745.f5", print_hash_value);
transparent_crc(g_2745.f6, "g_2745.f6", print_hash_value);
transparent_crc(g_2745.f7, "g_2745.f7", print_hash_value);
transparent_crc(g_2864.f0, "g_2864.f0", print_hash_value);
transparent_crc(g_2864.f1, "g_2864.f1", print_hash_value);
transparent_crc(g_2864.f2, "g_2864.f2", print_hash_value);
transparent_crc(g_2864.f3, "g_2864.f3", print_hash_value);
transparent_crc(g_2864.f4, "g_2864.f4", print_hash_value);
transparent_crc(g_2864.f5, "g_2864.f5", print_hash_value);
transparent_crc(g_2864.f6, "g_2864.f6", print_hash_value);
transparent_crc(g_2864.f7, "g_2864.f7", print_hash_value);
transparent_crc(g_2917, "g_2917", print_hash_value);
transparent_crc(g_2937.f0, "g_2937.f0", print_hash_value);
transparent_crc(g_2937.f2, "g_2937.f2", print_hash_value);
transparent_crc(g_2937.f3, "g_2937.f3", print_hash_value);
transparent_crc(g_2937.f4, "g_2937.f4", print_hash_value);
transparent_crc(g_2944.f0, "g_2944.f0", print_hash_value);
transparent_crc(g_2944.f1, "g_2944.f1", print_hash_value);
transparent_crc(g_2944.f2, "g_2944.f2", print_hash_value);
transparent_crc(g_2944.f3, "g_2944.f3", print_hash_value);
transparent_crc(g_3025, "g_3025", print_hash_value);
transparent_crc(g_3045.f0, "g_3045.f0", print_hash_value);
transparent_crc(g_3045.f1, "g_3045.f1", print_hash_value);
transparent_crc(g_3045.f2, "g_3045.f2", print_hash_value);
transparent_crc(g_3045.f3, "g_3045.f3", print_hash_value);
transparent_crc(g_3088.f0, "g_3088.f0", print_hash_value);
transparent_crc(g_3088.f1, "g_3088.f1", print_hash_value);
transparent_crc(g_3088.f2, "g_3088.f2", print_hash_value);
transparent_crc(g_3088.f3, "g_3088.f3", print_hash_value);
transparent_crc(g_3088.f4, "g_3088.f4", print_hash_value);
transparent_crc(g_3088.f5, "g_3088.f5", print_hash_value);
transparent_crc(g_3088.f6, "g_3088.f6", print_hash_value);
transparent_crc(g_3088.f7, "g_3088.f7", print_hash_value);
for (i = 0; i < 9; i++)
{
transparent_crc(g_3125[i].f0, "g_3125[i].f0", print_hash_value);
transparent_crc(g_3125[i].f1, "g_3125[i].f1", print_hash_value);
transparent_crc(g_3125[i].f2, "g_3125[i].f2", print_hash_value);
transparent_crc(g_3125[i].f3, "g_3125[i].f3", print_hash_value);
transparent_crc(g_3125[i].f4, "g_3125[i].f4", print_hash_value);
transparent_crc(g_3125[i].f5, "g_3125[i].f5", print_hash_value);
transparent_crc(g_3125[i].f6, "g_3125[i].f6", print_hash_value);
transparent_crc(g_3125[i].f7, "g_3125[i].f7", print_hash_value);
if (print_hash_value) printf("index = [%d]\n", i);
}
transparent_crc(g_3131, "g_3131", print_hash_value);
transparent_crc(g_3132.f0, "g_3132.f0", print_hash_value);
transparent_crc(g_3132.f2, "g_3132.f2", print_hash_value);
transparent_crc(g_3132.f3, "g_3132.f3", print_hash_value);
transparent_crc(g_3132.f4, "g_3132.f4", print_hash_value);
transparent_crc(g_3143.f0, "g_3143.f0", print_hash_value);
transparent_crc(g_3143.f1, "g_3143.f1", print_hash_value);
transparent_crc(g_3143.f2, "g_3143.f2", print_hash_value);
transparent_crc(g_3143.f3, "g_3143.f3", print_hash_value);
transparent_crc(g_3143.f4, "g_3143.f4", print_hash_value);
transparent_crc(g_3143.f5, "g_3143.f5", print_hash_value);
transparent_crc(g_3143.f6, "g_3143.f6", print_hash_value);
transparent_crc(g_3143.f7, "g_3143.f7", print_hash_value);
transparent_crc(g_3223, "g_3223", print_hash_value);
transparent_crc(g_3258.f0, "g_3258.f0", print_hash_value);
transparent_crc(g_3258.f2, "g_3258.f2", print_hash_value);
transparent_crc(g_3258.f3, "g_3258.f3", print_hash_value);
transparent_crc(g_3258.f4, "g_3258.f4", print_hash_value);
transparent_crc(g_3259.f0, "g_3259.f0", print_hash_value);
transparent_crc(g_3259.f1, "g_3259.f1", print_hash_value);
transparent_crc(g_3259.f2, "g_3259.f2", print_hash_value);
transparent_crc(g_3259.f3, "g_3259.f3", print_hash_value);
transparent_crc(g_3284.f0, "g_3284.f0", print_hash_value);
transparent_crc(g_3284.f1, "g_3284.f1", print_hash_value);
transparent_crc(g_3284.f2, "g_3284.f2", print_hash_value);
transparent_crc(g_3284.f3, "g_3284.f3", print_hash_value);
transparent_crc(g_3284.f4, "g_3284.f4", print_hash_value);
transparent_crc(g_3284.f5, "g_3284.f5", print_hash_value);
transparent_crc(g_3284.f6, "g_3284.f6", print_hash_value);
transparent_crc(g_3284.f7, "g_3284.f7", print_hash_value);
transparent_crc(g_3291.f0, "g_3291.f0", print_hash_value);
transparent_crc(g_3291.f1, "g_3291.f1", print_hash_value);
transparent_crc(g_3291.f2, "g_3291.f2", print_hash_value);
transparent_crc(g_3291.f3, "g_3291.f3", print_hash_value);
transparent_crc(g_3320.f0, "g_3320.f0", print_hash_value);
transparent_crc(g_3320.f2, "g_3320.f2", print_hash_value);
transparent_crc(g_3320.f3, "g_3320.f3", print_hash_value);
transparent_crc(g_3320.f4, "g_3320.f4", print_hash_value);
transparent_crc(g_3336, "g_3336", print_hash_value);
transparent_crc(g_3361, "g_3361", print_hash_value);
transparent_crc(g_3369, "g_3369", print_hash_value);
platform_main_end(crc32_context ^ 0xFFFFFFFFUL, print_hash_value);
return 0;
}
/************************ statistics *************************
XXX max struct depth: 1
breakdown:
depth: 0, occurrence: 890
depth: 1, occurrence: 15
XXX total union variables: 39
XXX non-zero bitfields defined in structs: 1
XXX zero bitfields defined in structs: 0
XXX const bitfields defined in structs: 0
XXX volatile bitfields defined in structs: 1
XXX structs with bitfields in the program: 52
breakdown:
indirect level: 0, occurrence: 15
indirect level: 1, occurrence: 9
indirect level: 2, occurrence: 9
indirect level: 3, occurrence: 12
indirect level: 4, occurrence: 3
indirect level: 5, occurrence: 4
XXX full-bitfields structs in the program: 0
breakdown:
XXX times a bitfields struct's address is taken: 24
XXX times a bitfields struct on LHS: 0
XXX times a bitfields struct on RHS: 17
XXX times a single bitfield on LHS: 0
XXX times a single bitfield on RHS: 6
XXX max expression depth: 44
breakdown:
depth: 1, occurrence: 285
depth: 2, occurrence: 72
depth: 3, occurrence: 6
depth: 4, occurrence: 3
depth: 5, occurrence: 3
depth: 6, occurrence: 2
depth: 7, occurrence: 1
depth: 12, occurrence: 2
depth: 13, occurrence: 2
depth: 14, occurrence: 2
depth: 15, occurrence: 1
depth: 16, occurrence: 2
depth: 17, occurrence: 2
depth: 18, occurrence: 3
depth: 19, occurrence: 4
depth: 20, occurrence: 2
depth: 21, occurrence: 3
depth: 22, occurrence: 3
depth: 23, occurrence: 2
depth: 24, occurrence: 2
depth: 25, occurrence: 2
depth: 26, occurrence: 3
depth: 27, occurrence: 2
depth: 28, occurrence: 3
depth: 29, occurrence: 2
depth: 30, occurrence: 1
depth: 31, occurrence: 4
depth: 32, occurrence: 1
depth: 34, occurrence: 1
depth: 36, occurrence: 1
depth: 37, occurrence: 1
depth: 40, occurrence: 1
depth: 44, occurrence: 1
XXX total number of pointers: 823
XXX times a variable address is taken: 1937
XXX times a pointer is dereferenced on RHS: 370
breakdown:
depth: 1, occurrence: 325
depth: 2, occurrence: 37
depth: 3, occurrence: 6
depth: 4, occurrence: 2
XXX times a pointer is dereferenced on LHS: 442
breakdown:
depth: 1, occurrence: 409
depth: 2, occurrence: 26
depth: 3, occurrence: 6
depth: 4, occurrence: 1
XXX times a pointer is compared with null: 65
XXX times a pointer is compared with address of another variable: 11
XXX times a pointer is compared with another pointer: 22
XXX times a pointer is qualified to be dereferenced: 14814
XXX max dereference level: 5
breakdown:
level: 0, occurrence: 0
level: 1, occurrence: 2132
level: 2, occurrence: 330
level: 3, occurrence: 108
level: 4, occurrence: 25
level: 5, occurrence: 10
XXX number of pointers point to pointers: 281
XXX number of pointers point to scalars: 489
XXX number of pointers point to structs: 13
XXX percent of pointers has null in alias set: 31.5
XXX average alias set size: 1.66
XXX times a non-volatile is read: 2423
XXX times a non-volatile is write: 1321
XXX times a volatile is read: 213
XXX times read thru a pointer: 54
XXX times a volatile is write: 37
XXX times written thru a pointer: 0
XXX times a volatile is available for access: 1.12e+04
XXX percentage of non-volatile access: 93.7
XXX forward jumps: 3
XXX backward jumps: 16
XXX stmts: 283
XXX max block depth: 5
breakdown:
depth: 0, occurrence: 37
depth: 1, occurrence: 34
depth: 2, occurrence: 35
depth: 3, occurrence: 38
depth: 4, occurrence: 60
depth: 5, occurrence: 79
XXX percentage a fresh-made variable is used: 15.9
XXX percentage an existing variable is used: 84.1
FYI: the random generator makes assumptions about the integer size. See platform.info for more details.
********************* end of statistics **********************/
|
d509a6e57faf410c0d141a3c5ae64cf5b3bac194
|
097ceb90d8686616cbe743f79df5ff1bf1ab914f
|
/User/bsp/liquid_sensor/bsp_liquid_sensor.h
|
5794976346c867dfd480c53e7af145df5651a913
|
[
"MIT"
] |
permissive
|
chery-kai/air_clean_mcu_v1.2
|
faef056f74d92041aa1ee18c51adc0aa779bc94e
|
bb11c4d87f9c1a49f102e2c187d1c9bcc0be2f5c
|
refs/heads/master
| 2020-03-18T21:15:21.351430 | 2018-05-29T09:16:29 | 2018-05-29T09:16:29 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 3,395 |
h
|
bsp_liquid_sensor.h
|
#ifndef __LIQUID_SENSOR_H
#define __LIQUID_SENSOR_H
#include "stm32f10x.h"
/*
//相关引脚对应的液位都是低电平有效
原液箱液位传感器:
LOW_Y: PD8 //原液箱低液位
MID_Y: PD9 //原液箱中液位
HIGH_Y: PD10 //原液箱高液位
工作仓液位传感器:
LOW_W: PD11 //工作箱低液位
HIGH_W: PD12 //工作箱高液位
*/
//液箱液位传感器(三挡)
#define LIQUID_LEVEL_SENSOR_ORG_LOW 0
#define LIQUID_LEVEL_SENSOR_ORG_MID 1
#define LIQUID_LEVEL_SENSOR_ORG_HIGH 2
//工作仓液位传感器(三挡)
//#define LIQUID_LEVEL_SENSOR_WORK_LOW 3
//#define LIQUID_LEVEL_SENSOR_WORK_MID 4
//#define LIQUID_LEVEL_SENSOR_WORK_HIGH 5
#define LIQUID_LEVEL_SENSOR_WORK_LOW 3
#define LIQUID_LEVEL_SENSOR_WORK_HIGH 4
#define LIQUID_LEVEL_SENSOR_WORK_OVERFLOW 5
/* 定义liquid_sensor连接的GPIO端口, 用户只需要修改下面的代码即可改变控制液位传感器的引脚 */
#define macLIQUID_SENSOR_GPIO_PORT GPIOD /* GPIO端口 */
#define macLIQUID_SENSOR_GPIO_CLK RCC_APB2Periph_GPIOD /* GPIO端口时钟 */
//原液箱液位对应引脚号
//手动版
//#define macSENSOR_LOW_Y_GPIO_PIN GPIO_Pin_11 /* LOW_Y引脚号 */
//#define macSENSOR_MID_Y_GPIO_PIN GPIO_Pin_12 /* MID_Y引脚号 */
//#define macSENSOR_HIGH_Y_GPIO_PIN GPIO_Pin_13 /* HIGH_Y引脚号 */
//自动版
#define macSENSOR_LOW_Y_GPIO_PIN GPIO_Pin_11 /* LOW_Y引脚号 */
#define macSENSOR_HIGH_Y_GPIO_PIN GPIO_Pin_13 /* HIGH_Y引脚号 */
//工作仓液位对应引脚号
#define macSENSOR_LOW_W_GPIO_PIN GPIO_Pin_14 /* LOW_W引脚号 */
#define macSENSOR_HIGH_W_GPIO_PIN GPIO_Pin_15 /* HIGH_W引脚号 */
//工作仓溢出液位点
#define macSENSOR_MID_W_GPIO_PIN GPIO_Pin_12 /* MID_W引脚号 */
//手动版
//#define macSENSOR_LOW_Y_Read() GPIO_ReadInputDataBit(macLIQUID_SENSOR_GPIO_PORT, macSENSOR_LOW_Y_GPIO_PIN)
//#define macSENSOR_MID_Y_Read() GPIO_ReadInputDataBit(macLIQUID_SENSOR_GPIO_PORT, macSENSOR_MID_Y_GPIO_PIN)
//#define macSENSOR_HIGH_Y_Read() GPIO_ReadInputDataBit(macLIQUID_SENSOR_GPIO_PORT, macSENSOR_HIGH_Y_GPIO_PIN)
//自动版
#define macSENSOR_LOW_Y_Read() GPIO_ReadInputDataBit(macLIQUID_SENSOR_GPIO_PORT, macSENSOR_LOW_Y_GPIO_PIN)
#define macSENSOR_HIGH_Y_Read() GPIO_ReadInputDataBit(macLIQUID_SENSOR_GPIO_PORT, macSENSOR_HIGH_Y_GPIO_PIN)
#define macSENSOR_LOW_W_Read() GPIO_ReadInputDataBit(macLIQUID_SENSOR_GPIO_PORT, macSENSOR_LOW_W_GPIO_PIN)
#define macSENSOR_HIGH_W_Read() GPIO_ReadInputDataBit(macLIQUID_SENSOR_GPIO_PORT, macSENSOR_HIGH_W_GPIO_PIN)
/*
//工作仓中液位
#define macSENSOR_MID_W_Read() GPIO_ReadInputDataBit(macLIQUID_SENSOR_GPIO_PORT, macSENSOR_MID_W_GPIO_PIN)
*/
//工作仓溢出液位 (overflow)
#define macSENSOR_OFL_W_Read() GPIO_ReadInputDataBit(macLIQUID_SENSOR_GPIO_PORT, macSENSOR_MID_W_GPIO_PIN)
#define HIGH_LEV 1
#define LOW_LEV 0
void LIQUID_SENSOR_GPIO_Config(void);
char get_liquid_level_sensor_status(char sensor);
#endif /* __LIQUID_SENSOR_H */
|
f215078becf92d04efc38f92d5c7077cad2be519
|
d7441eac9bb26ccb163601b6143784b7ce3deb59
|
/公共部分/fox.c
|
0f23722e750bfb12e6e75a4e0ab9fd5d5fc201d5
|
[] |
no_license
|
zzh1996/pp11
|
0a0d4a78ff65e503a56f0d2b3051c50a92e75c18
|
6e22d028d3d4c3b27de5b603ff25630a73398f67
|
refs/heads/master
| 2020-04-11T22:32:33.323796 | 2018-12-19T07:24:38 | 2018-12-19T07:24:38 | 162,139,670 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 5,026 |
c
|
fox.c
|
#include <mpi.h>
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
int rank, size;
int sqrtp;
MPI_Comm matcomm, rowcomm, colcomm;
int matrank;
int n, block;
int row, col;
void read_mat(FILE *fp, double *mat)
{
int coords[2];
int dst;
if (matrank == 0)
{
double *buf = malloc(sizeof(double) * block);
for (int i = 0; i < n; i++)
{
coords[0] = i / block;
for (int j = 0; j < sqrtp; j++)
{
coords[1] = j;
MPI_Cart_rank(matcomm, coords, &dst);
for (int k = 0; k < block; k++)
{
fscanf(fp, "%lf", &buf[k]);
//printf("%d %d %d %f\n",i,j,k,buf[k]);
}
if (dst == 0)
{
memcpy(&mat[i * block], buf, sizeof(double) * block);
}
else
{
MPI_Send(buf, block, MPI_DOUBLE, dst, 0, matcomm);
}
}
}
free(buf);
}
else
{
for (int i = 0; i < block; i++)
{
MPI_Recv(&mat[i * block], block, MPI_DOUBLE, 0, 0, matcomm, MPI_STATUS_IGNORE);
}
}
}
void print_mat(double *mat)
{
int coords[2];
int src;
if (matrank != 0)
{
for (int i = 0; i < block; i++)
{
MPI_Send(&mat[i * block], block, MPI_DOUBLE, 0, 0, matcomm);
}
}
else
{
double *buf = malloc(sizeof(double) * block);
for (int i = 0; i < n; i++)
{
coords[0] = i / block;
for (int j = 0; j < sqrtp; j++)
{
coords[1] = j;
MPI_Cart_rank(matcomm, coords, &src);
if (src == 0)
{
memcpy(buf, &mat[i * block], sizeof(double) * block);
}
else
{
MPI_Recv(buf, block, MPI_DOUBLE, src, 0, matcomm, MPI_STATUS_IGNORE);
}
for (int k = 0; k < block; k++)
{
printf("%8.2f ", buf[k]);
}
}
printf("\n");
}
free(buf);
}
}
void fox(double *A, double *B, double *C)
{
memset(C, 0, sizeof(double) * block * block);
double *buf = malloc(sizeof(double) * block * block);
for (int i = 0; i < sqrtp; i++)
{
int root = (row + i) % sqrtp;
if (root == col)
{ // I should bcast
MPI_Bcast(A, block * block, MPI_DOUBLE, root, rowcomm);
memcpy(buf, A, sizeof(double) * block * block);
}
else
{ // I should recv
MPI_Bcast(buf, block * block, MPI_DOUBLE, root, rowcomm);
}
for (int a = 0; a < block; a++)
for (int b = 0; b < block; b++)
for (int c = 0; c < block; c++)
C[a * block + b] += buf[a * block + c] * B[c * block + b];
MPI_Sendrecv_replace(B, block * block, MPI_DOUBLE, (row - 1 + sqrtp) % sqrtp,
0, (row + 1) % sqrtp, 0, colcomm, MPI_STATUS_IGNORE);
}
}
int main(int argc, char **argv)
{
double t1, t2;
int dims[2];
int periods[2];
int coords[2];
int remain_dims[2];
FILE *fp;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
t1 = MPI_Wtime();
sqrtp = (int)sqrt(size);
if (rank == 0)
{
if (sqrtp * sqrtp != size)
{
printf("p is not square!\n");
MPI_Abort(MPI_COMM_WORLD, -1);
}
}
dims[0] = dims[1] = sqrtp;
periods[0] = periods[1] = 1;
MPI_Cart_create(MPI_COMM_WORLD, 2, dims, periods, 1, &matcomm);
MPI_Comm_rank(matcomm, &matrank);
MPI_Cart_coords(matcomm, matrank, 2, coords);
row = coords[0];
col = coords[1];
remain_dims[0] = 0;
remain_dims[1] = 1;
MPI_Cart_sub(matcomm, remain_dims, &rowcomm);
remain_dims[0] = 1;
remain_dims[1] = 0;
MPI_Cart_sub(matcomm, remain_dims, &colcomm);
// load matrix
if (rank == 0)
{
fp = fopen(argv[1], "r");
fscanf(fp, "%d", &n);
}
MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD);
block = n / sqrtp;
if (rank == 0)
{
if (sqrtp * block != n)
{
printf("n=%d cannot be divided by sqrt(p)=%d!\n", n, sqrtp);
MPI_Abort(MPI_COMM_WORLD, -1);
}
}
double *A = malloc(sizeof(double) * block * block);
double *B = malloc(sizeof(double) * block * block);
double *C = malloc(sizeof(double) * block * block);
read_mat(fp, A);
read_mat(fp, B);
if (rank == 0)
fclose(fp);
// core algo
fox(A, B, C);
t2 = MPI_Wtime();
print_mat(C);
if (rank == 0)
printf("Total time: %f\n", t2 - t1);
free(A);
free(B);
free(C);
MPI_Finalize();
return 0;
}
|
1d6b72ae49bc1e3559ccaf34a865130e8145736b
|
83bf23c58e54169e505a926360a87f0421e3a3ee
|
/微观世界大冒险游戏资源/932740/assets/B/B_128.h
|
8e0340e7c4a642308c4635447df7d9df8c2da473
|
[] |
no_license
|
silentbo/BubbleProject
|
df6e747c071207f6154232bc9249b7f9e1cc55d7
|
c96cb304c29293f34200e67a27f12cd6e3370995
|
refs/heads/master
| 2021-01-01T19:37:28.427637 | 2017-11-05T12:39:15 | 2017-11-05T12:39:15 | 98,628,979 | 2 | 0 | null | 2017-07-28T09:12:51 | 2017-07-28T08:42:33 | null |
UTF-8
|
C
| false | false | 384 |
h
|
B_128.h
|
{
9,
{
{20,-193,344,0,true,2,true,-120,177,0.75,0},
{23,251,479,0,true,-2,true,201,432,1,0},
{11,238,32,0,true,-1.5,true,247,226,1.5,0},
{0,160,342,0,false,0,false,0,0,0,0},
{0,62,75,0,false,0,false,0,0,0,0},
{1,37,586,0,false,0,false,0,0,0,0},
{2,95,639,0,false,0,false,0,0,0,0},
{2,138,589,0,false,0,false,0,0,0,0},
{2,118,513,0,false,0,false,0,0,0,0},
}
},
|
fad13ae66c1b94a593d54a00a2f61dd3c02c024b
|
8216066d880675426e797b7c8dae5ad8014eb3d6
|
/core/caller.c
|
8fd3d1414f3571f4b61702e17b0d3b9fd2323577
|
[] |
no_license
|
Walter-Dalla/skef
|
0656affbb765da8cc13dc9a3562bc326223ea215
|
36e27876d49f92c8b93a9b1284f9308d8657c3fc
|
refs/heads/master
| 2020-04-02T07:18:25.869204 | 2018-10-10T20:44:44 | 2018-10-10T20:44:44 | 154,190,128 | 1 | 0 | null | 2018-10-22T17:54:31 | 2018-10-22T17:54:31 | null |
UTF-8
|
C
| false | false | 1,772 |
c
|
caller.c
|
/*
caller.c ->
~ Gabriel Julio dos Santos
*/
#include "includes/includes.h"
typedef struct {
char* _LineAUX_;
char* _LineFunction_;
int _LineCounter_;
} Skf_FileObject;
void __parse__(){
fp = fopen(f, "r");
fseek(fp, 0L, SEEK_END);
_FileSize_ = ftell(fp);
fseek(fp, 0L, SEEK_SET);
Skf_FileObject *FileObject = (Skf_FileObject*)malloc(2*_FileSize_);
FileObject->_LineAUX_ = (char*)malloc(2*_FileSize_);
FileObject->_LineFunction_ = (char*)malloc(2*_FileSize_);
FileObject->_LineCounter_ = 0;
while ( fgets(FileObject->_LineAUX_, 2*_FileSize_, fp) != NULL ){
FileObject->_LineCounter_ ++;
if ( *FileObject->_LineAUX_ == '\0' || *FileObject->_LineAUX_ == '\n' ){
continue;
}
if ( *FileObject->_LineAUX_ == EOF ){
free(FileObject->_LineAUX_);
exit(0);
}
FileObject->_LineAUX_ = _RemoveSpace_init_(FileObject->_LineAUX_);
if ( *FileObject->_LineAUX_ == '\n' ){ continue; }
FileObject->_LineFunction_ = _Identify_FunctionCall_(FileObject->_LineAUX_);
if ( strcmp("[NAME_NOT_FOUND]", FileObject->_LineFunction_) == 0 ){
__skf_error__(2, FileObject->_LineAUX_, f, FileObject->_LineCounter_);
exit(1);
}
else if ( strcmp("print", FileObject->_LineFunction_) == 0 ){
//____SKF_print_(FileObject->_LineAUX_, FileObject->_LineCounter_);
continue;
}
else if ( strcmp("var", FileObject->_LineFunction_) == 0 ){
//____SKF_var_(FileObject->_LineAUX_, FileObject->_LineCounter_);
continue;
}
}
//free(FileObject->_LineAUX_);
//free(FileObject->_LineFunction_);
free(FileObject);
}
|
199fd8a84a495c6e012c69888a494faa740a9be5
|
32e48bb5c7b9714e25bc9312f185a85e02338cc5
|
/kernel/include/uapi/micro/fb.h
|
cb15d657b2d3f292cefae60e58fa0d6f1d7ca27a
|
[
"BSD-2-Clause"
] |
permissive
|
thebigcx/micro
|
3e31cc30822c89bed342797ca407079bdf52a3c4
|
6400dfe82b1dcf42d2ef976ac5f7eb1f9a4a5c7c
|
refs/heads/master
| 2023-08-25T18:25:17.336079 | 2021-10-17T01:31:27 | 2021-10-17T01:31:27 | 397,209,343 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 121 |
h
|
fb.h
|
#pragma once
struct fbinfo
{
unsigned int xres;
unsigned int yres;
unsigned int bpp;
};
#define FBIOGINFO 0
|
4e2dc2c65a79463a5862606dcf4adfb31cfde4ec
|
062d9d4961cc5e2680d5b671c2c7b89b1b12ce79
|
/learned_binaries/mutants/15params_add15.1mut.c
|
604c6281e51cd6b35bc0e1d97f06e600c9e3bb35
|
[] |
no_license
|
commial/Sibyl-tests
|
2a79f20dd76b57cc7678acc18737ad697e2c0bc8
|
b1c5525e126ceb3bbdbf3e88ed5f6ee5414987b8
|
refs/heads/master
| 2021-01-19T05:07:52.960757 | 2017-05-30T11:38:10 | 2017-05-30T11:38:10 | 60,625,092 | 2 | 1 | null | 2016-10-03T10:53:37 | 2016-06-07T15:32:00 |
Shell
|
UTF-8
|
C
| false | false | 492 |
c
|
15params_add15.1mut.c
|
unsigned int add15(unsigned int a, unsigned int b, unsigned int c, unsigned int d, unsigned int e, unsigned int f, unsigned int g, unsigned int h, unsigned int i, unsigned int j, unsigned int k, unsigned int l, unsigned int m, unsigned int n, unsigned int o)
{
return (((((((((((((a + b) + c) + d) + e) + f) + g) + h) + i) + j) + k) + l) + m) + n) * o;
}
int main(void)
{
return add15(2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2) + add15(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
}
|
2664c5bfcec2ecd17a86a9e3851ea1b54b415da3
|
6f45bd8f6a3520f07334c82c7eeea0995ca39670
|
/Geo_Viserion/L5_Application/periodic_scheduler/geoHBtx.h
|
0945330df057e55b47ad807b1674b68cbbf53965
|
[] |
no_license
|
manojrameshrao/self-driving-car-viserion
|
b7542cda2b337705655a148bad1d2f8e1750fa7b
|
680d5cba515e0892f734c90b4bf514d404741c20
|
refs/heads/master
| 2020-03-13T00:06:40.551689 | 2017-11-21T22:40:41 | 2017-11-21T22:40:41 | 130,880,327 | 1 | 3 | null | null | null | null |
UTF-8
|
C
| false | false | 164 |
h
|
geoHBtx.h
|
/*
* geoHBtx.h
*
* Created on: 22-Oct-2017
* Author: Admin
*/
#ifndef GEOHBTX_H_
#define GEOHBTX_H_
void geo_heartbeat(void);
#endif /* GEOHBTX_H_ */
|
4d0d1ca025d3834ddbc80a83fa85810bde4ddc58
|
b1131852081662880b5664c6d2123e7d9624aa5c
|
/Instance place backtrack.c
|
c26fd42560dd75a06507fad8652ec9546e239028
|
[
"MIT"
] |
permissive
|
subhankarmaji/Data-Structure-Algorithms
|
31f2264a64b188c4e074b5490de0ff8ee2f116c2
|
03d44c4e33b46db578807cc166bfc1f1d5303caf
|
refs/heads/master
| 2022-12-24T13:10:41.850466 | 2020-10-01T15:39:18 | 2020-10-01T15:39:18 | 300,331,427 | 0 | 0 |
MIT
| 2020-10-01T15:38:15 | 2020-10-01T15:38:14 | null |
UTF-8
|
C
| false | false | 769 |
c
|
Instance place backtrack.c
|
#include<stdio.h>
#include<stdbool.h>
#include<stdlib.h>
void ini(int n){
int array[2*n],i;
for(i=0;i<(2*n);i++){
array[i]=0;
}
if(fill(n,n,array)){
printf("Array is: [");
for(i=0;i<(2*n);i++){
printf(" %d",array[i]);
}
printf(" ]");
}else{
printf("Not Possible!");
}
}
fill(int n, int a, int array[])
{
if(a==0){
return true;
}
int i;
for(i=0;i<2*n-a-1;i++){
if(array[i]==0 && array[i+(a+1)]==0){
array[i]=array[i+(a+1)]=a;
if(fill(n,a-1,array)){
return true;
}
array[i]=array[i+(a+1)]=0;
}
}
return false;
}
int main(){
ini(7);
return false;
}
|
228298b5a0afcbf9ba28d49ed91f1ff2f1b6c121
|
616f7d12aa72c96fb19968ba83dc5d9daf3e3734
|
/ex/final/chap14/sigset/sigaction_3.c
|
b71fb186452dd14bac3e41ad8e888b389887fc53
|
[] |
no_license
|
frics/2021_SSU_LSP
|
880be9e5e42f19a414b3d67d27f75c32a58a60b5
|
39e2ad1c601c40963e9cf846a908f3191559648b
|
refs/heads/master
| 2023-06-06T03:06:45.234506 | 2021-07-01T07:31:35 | 2021-07-01T07:31:35 | 357,829,203 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,163 |
c
|
sigaction_3.c
|
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<signal.h>
#include<sys/types.h>
#include<sys/wait.h>
static void signal_handler1(int signo);
static void signal_handler2(int signo);
int main(void){
struct sigaction act_int, act_quit;
act_int.sa_handler = signal_handler1;
sigemptyset(&act_int.sa_mask);
sigaddset(&act_int.sa_mask, SIGQUIT);
act_int.sa_flags = 0;
sigaction(SIGINT, &act_int, NULL);
act_quit.sa_handler = signal_handler2;
sigemptyset(&act_quit.sa_mask);
sigaddset(&act_quit.sa_mask, SIGINT);
act_quit.sa_flags = 0;
sigaction(SIGQUIT, &act_quit, NULL);
pause();
raise(SIGQUIT);
exit(0);
}
static void signal_handler1(int signo){
printf("sig handler of SIGINT : %d\n", signo);
printf("SIGQUIT signal is blocked : %d\n", signo);
printf("sleeping 3 sec\n");
sleep(3);
printf("SIGINT handler is end\n");
}
static void signal_handler2(int signo){
printf("sig handler of SIGQUIT : %d\n", signo);
printf("SIGINT signal is blocked : %d\n", signo);
printf("sleeping 3 sec\n");
sleep(3);
printf("SIGQUIT handler is end\n");
}
|
3d30254cc7d3e1b3a66dd8bf7d11560c6bebf621
|
adb6b5a8d66faf15589770566b7c134c4dd9800c
|
/includes/wolf3d.h
|
cb0d915b4214ade831a6ccda39c0acd17f9e14aa
|
[] |
no_license
|
schaaban42/wolf3d
|
330bc1ae43dda6472a6d3d8e15a13bb4d5278024
|
e5e09113bfb56b0e237532105d47b14c921ebd0f
|
refs/heads/master
| 2020-03-08T04:30:15.067718 | 2018-06-08T00:12:47 | 2018-06-08T00:12:47 | 127,923,595 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 4,466 |
h
|
wolf3d.h
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* wolf3d.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: schaaban <schaaban@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/04/03 17:24:15 by schaaban #+# #+# */
/* Updated: 2018/06/08 01:50:54 by schaaban ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef WOLF3D_H
# define WOLF3D_H
# include "libft.h"
# include "SDL.h"
# include <unistd.h>
# include <stdio.h>
# include <math.h>
# include <fcntl.h>
# define WALL_SIZE 16
# define MAX_TEX 12
# define W_PI (double)3.14159265358979
# define W_R0 0.0
# define W_R60 W_PI / 3
# define W_R90 W_PI * 0.5
# define W_R150 (5.0 * W_PI) / 6
# define W_R180 W_PI
# define W_R270 (3 * W_PI) * 0.5
# define W_R360 W_PI * 2.0
# define DELTA wolf->delta
# define MOUSE_SEN 0.04
# define W_ERROR_SDL_INIT 0
# define W_ERROR_MALLOC 1
# define W_ERROR_FILE 2
# define W_ERROR_READ 6
# define W_ERROR_OPEN 3
# define W_ERROR_CLOSE 4
# define W_ERROR_ARGS 5
# define W_ERROR_RAY 6
# define W_ERROR_TEX_S 7
# define W_ERROR_TEX 8
# define W_HORIZONTAL 0
# define W_VERTICAL 1
# define O_NORTH 0
# define O_EAST 1
# define O_WEST 2
# define O_SOUTH 3
# define MM_SIZE_X wolf->minimap_size[0]
# define MM_SIZE_Y wolf->minimap_size[1]
# define MM_POS_X wolf->plan_w - MM_SIZE_X - 20
# define MM_POS_Y 20
# define MM_O_X MM_POS_X + (MM_SIZE_X / 2)
# define MM_O_Y MM_POS_Y + (MM_SIZE_Y / 2)
# define SKY_W 600
# define SKY_H 200
# define P_BASE_SPEED 4 * WALL_SIZE
# define P_SPRINT_SPEED 7 * WALL_SIZE
# define P_BASE_FOV W_R60
# define P_SPRINT_FOV P_BASE_FOV * 1.05
typedef struct s_player
{
double pos[2];
double mv[2];
double angle;
double dist_pp;
double speed;
int run;
} t_player;
typedef struct s_ray
{
double pos[2];
double a_h[2];
double a_v[2];
double angle;
double dist;
int wall_x;
int map_v[3];
int side;
double w_start;
double w_size;
double w_end;
double fog;
} t_ray;
typedef struct s_wolf
{
SDL_Event event;
SDL_Window *win;
SDL_Surface *render;
Uint8 *keys;
int fd;
int exit;
int plan_w;
int plan_h;
double time_step;
double delta;
double frequency;
double fov;
Uint32 ***tex;
t_ray **rays;
int **map;
int map_w;
int map_h;
int night;
int drunk;
int minimap;
int minimap_full;
int minimap_size[2];
int mm_wall_size;
t_player *player;
} t_wolf;
void process_inputs(t_wolf *wolf);
void init_file_read(int argc, char **argv, t_wolf *wolf);
void init_values(t_wolf *wolf);
void game_loop(t_wolf *wolf);
void parse_file(t_wolf *wolf);
void ft_put_pixel(int x, int y, Uint32 color, t_wolf *wolf);
void ft_draw_v_line(int x, int y1, int y2,
Uint32 color, t_wolf *wolf);
void ft_draw_rect(int p[4], Uint32 color, t_wolf *wolf);
void ft_draw_f_c(int x, int y1, int y2, t_wolf *wolf);
void ft_clear_win(t_wolf *wolf);
void minimap_pixel(int x, int y, Uint32 color, t_wolf *wolf);
void mm_draw_rect(int p[4], Uint32 color, t_wolf *wolf);
void mm_draw_line(int cc[6], t_wolf *wolf);
int ft_get_color(int r, int g, int b);
int ft_get_color_fog(int color, int fog);
int color_gradient(int cs, int ce, double value);
Uint32 **ft_read_ppm(int fd, t_wolf *wolf);
void ft_fill_tex(int index, SDL_Surface *sf, t_wolf *wolf);
int a_is_left(double angle);
int a_is_up(double angle);
int get_closer_h(double pos[2], t_ray *ray);
int get_closer_v(double pos[2], t_ray *ray);
double ft_raylen(double *r, double *p);
void ray_cast(double pos[2], t_ray *ray, t_wolf *wolf);
void draw_minimap(t_wolf *wolf);
void ft_draw(t_wolf *wolf);
void ft_update(t_wolf *wolf);
void ft_exit(t_wolf *wolf);
void error_handler(int error, t_wolf *wolf);
#endif
|
b5514093025c5da12c459f9b0e7589c95affbfa0
|
a895f21b19eae359262980d269b3d4ff2c9ec3a7
|
/parser.c
|
0a489c2b4c708611f5e546167e9ea8962fa7c7a3
|
[] |
no_license
|
syu39310/tcc
|
01149a20df5768958e0b4a6adc5660cb6c570a2a
|
a71f742256c32f8867d589a49bd2977053505fe6
|
refs/heads/master
| 2022-12-04T19:31:50.409164 | 2020-08-19T12:58:17 | 2020-08-19T12:58:17 | 260,519,200 | 1 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 8,501 |
c
|
parser.c
|
#include "tcc.h"
// 現在着目しているトークン
Token *token;
// ローカル変数
Var *locals;
// 次のトークンが期待値のときには、真を返す。それ以外の場合には偽を返す。
bool equal(Token *tok, char *op) {
return strlen(op) == tok->len &&
!strncmp(tok->str, op, tok->len);
}
// 次のトークンが期待値のときには、トークンを1つ読み進めて
// トークンを返す。それ以外の場合にはエラー。
Token *skip(char *op) {
if (equal(token, op)) {
token = token->next;
return token;
}
error_tok(token, "expected '%s'", op);
}
// 次のトークンが期待値のときには、トークンを1つ読み進めて
// 真を返す。それ以外の場合には偽を返す。
bool consume(char *op) {
if (equal(token, op)) {
token = token->next;
return true;
}
return false;
}
// 次のトークンが期待しているトークン種類のときには、トークンを読み進めて現在のトークンを返す。
// それ以外の場合にはNULLを返す。
Token *consume_kind(TokenKind kind) {
if (token->kind != kind)
return NULL;
Token *result = token;
token = token->next;
return result;
}
// 次のトークンが期待の種類の場合、トークンを1つ読み進めてそのトークンを返す。
// それ以外の場合にはエラーを報告する。
Token *expect_kind(TokenKind kind, char *errArg) {
if (token->kind != kind)
error_at(token->str, "%sではありません", errArg);
Token *result = token;
token = token->next;
return result;
}
int expect_number() {
return expect_kind(TK_NUM, "数")->val;
}
char *expect_ident() {
return get_token_str(expect_kind(TK_IDENT, "識別子"));
}
// 変数を名前で検索する。見つからなかった場合はNULLを返す。
Var *find_var(Token *tok) {
for (Var *var = locals; var; var = var->next)
if (var->len == tok->len && !memcmp(tok->str, var->name, var->len))
return var;
return NULL;
}
bool at_eof() {
return token->kind == TK_EOF;
}
Node *new_node(NodeKind kind, Token *tok) {
Node *node = calloc(1, sizeof(Node));
node->kind = kind;
node->token = tok;
return node;
}
Node *new_binary(NodeKind kind, Node *lhs, Node *rhs, Token *tok) {
Node *node = new_node(kind, tok);
node->lhs = lhs;
node->rhs = rhs;
return node;
}
Node *new_num(int val, Token *tok) {
Node *node = new_node(ND_NUM, tok);
node->val = val;
return node;
}
Var *new_var(Token *tok) {
Var *var = calloc(1, sizeof(Var));
var->name = get_token_str(tok);
var->len =tok->len;
return var;
}
Var *node_to_var(Node *node) {
return new_var(node->token);
}
Function *funcdef();
Node *compound_stmt();
Node *stmt();
Node *expr();
Node *assign();
Node *equality();
Node *relational();
Node *add();
Node *mul();
Node *unary();
Node *primary();
// グローバルに置いているcode[]にparse結果を設定する。
// parse = stmt*
Function *parse(Token *argToken) {
token = argToken;
Function head;
head.next = NULL;
Function *cur = &head;
while (!at_eof()) {
cur->next = funcdef();
cur = cur->next;
}
return head.next;
}
// funcdef = "int" ident(assign? (, assign)*?) compound_stmt
Function *funcdef() {
locals = NULL;
skip("int");
Function *func = calloc(1, sizeof(Function));
func->name = expect_ident();
skip("(");
// params
Var head;
head.next = NULL;
Var *cur = &head;
while(!consume(")")) {
Node *assign_node = assign();
cur->next = node_to_var(assign_node);
cur = cur->next;
consume(",");
}
func->params = locals;
// body
func->body = compound_stmt();
// locals
func->locals = locals;
//func->stack_size;
return func;
}
// compound_stmt = {stmt*}
Node *compound_stmt() {
skip("{");
Node head;
head.next = NULL;
Node *cur = &head;
while (!consume("}")) {
cur->next = stmt();
cur = cur->next;
}
return head.next;
}
// stmt = expr ";"
// | "{" stmt* "}"
// | "if" "(" expr ")" stmt ("else" stmt)?
// | "while" "(" expr ")" stmt
// | "for" "(" expr? ";" expr? ";" expr? ")" stmt
// | "return" expr ";"
Node *stmt() {
if (consume("{")) {
Node head;
head.next = NULL;
Node *cur = &head;
while(!consume("}")) {
cur->next = stmt();
cur = cur->next;
}
Node *node = new_node(ND_BLOCK, token);
node->body = head.next;
return node;
}
// 制御構文
if (consume("if")) {
Node *node = new_node(ND_IF, token);
skip("(");
node->cond = expr();
skip(")");
node->then = stmt();
if (consume("else")) {
node->els = stmt();
}
return node;
}
if(consume("while")) {
Node *node = new_node(ND_FOR, token);
skip("(");
node->cond = expr();
skip(")");
node->then = stmt();
return node;
}
if(consume("for")) {
Node *node = new_node(ND_FOR, token);
skip("(");
if (!consume(";")) {
node->init = expr();
skip(";");
}
if (!consume(";")) {
node->cond = expr();
skip(";");
}
if (!consume(")")) {
node->inc = expr();
skip(")");
}
node->then = stmt();
return node;
}
// return文
if (consume_kind(TK_RETURN)) {
Node *node = calloc(1, sizeof(Node));
node->kind = ND_RETURN;
node->lhs = expr();
skip(";");
return node;
}
Node *node = expr();
skip(";");
return node;
}
Node *expr() {
return assign();
}
Node *assign() {
Node *node = equality();
if (consume("="))
node = new_binary(ND_ASSIGN, node, assign(), token);
return node;
}
// equality = relational ("==" relational | "!=" relational)*
Node *equality() {
Node *node = relational();
for (;;) {
if (consume("=="))
node = new_binary(ND_EQ, node, relational(), token);
else if (consume("!="))
node = new_binary(ND_NE, node, relational(), token);
else
return node;
}
}
// relational = add ("<" add | "<=" add | ">" add | ">=" add)*
Node *relational() {
Node *node = add();
for (;;) {
if (consume("<"))
node = new_binary(ND_LT, node, add(), token);
else if (consume("<="))
node = new_binary(ND_LE, node, add(), token);
else if (consume(">"))
node = new_binary(ND_LT, add(), node, token);
else if (consume(">="))
node = new_binary(ND_LE, add(), node, token);
else
return node;
}
}
Node *add() {
Node *node = mul();
for (;;) {
if (consume("+"))
node = new_binary(ND_ADD, node, mul(), token);
else if (consume("-"))
node = new_binary(ND_SUB, node, mul(), token);
else
return node;
}
}
Node *mul() {
Node *node = unary();
for (;;) {
if (consume("*"))
node = new_binary(ND_MUL, node, unary(), token);
else if (consume("/"))
node = new_binary(ND_DIV, node, unary(), token);
else
return node;
}
}
Node *unary() {
if (consume("+"))
return unary();
if (consume("-"))
return new_binary(ND_SUB, new_num(0, token), primary(), token);
return primary();
}
// num
// | ident ("(" num? ("," num)?* ")")?
// | "(" expr ")"
Node *primary() {
// 次のトークンが"("なら、"(" expr ")"のはず
if (consume("(")) {
Node *node = expr();
skip(")");
return node;
}
Token *tok = consume_kind(TK_IDENT);
if (tok) {
if (consume("(")) {
Node head;
head.next = NULL;
Node *cur = &head;
for (int i=0; i <= 6; i++) {
if (consume(")")) {
break;
} if (i != 0) {
skip(",");
}
cur->next = assign();
cur = cur->next;
}
Node *node = new_node(ND_FUNCALL, tok);
node->args = head.next;
return node;
}
Node *node = calloc(1, sizeof(Node));
node->kind = ND_VAR;
Var *var = find_var(tok);
if (var) {
node->offset = var->offset;
} else {
var = calloc(1, sizeof(Var));
var->next = locals;
var->name = tok->str;
var->len = tok->len;
var->offset = locals==NULL ? 0 : locals->offset+8;
node->offset = var->offset;
locals = var;
}
node->token = tok;
return node;
}
// そうでなければ数値のはず
return new_num(expect_number(), token);
}
|
35318658096baaf19106c228d8b440701f30bc38
|
eecb7d2378c6138979f69b102735b5b5d545a639
|
/kernel-module/main.c
|
e0c8e165963f72c6eec7e2cac4390d1f284bbb51
|
[
"MIT"
] |
permissive
|
neojski/random
|
2afa45abdeb1faf6a4809d75b86d0df726d750b2
|
3c63fb2f50ceea8cb06c2e2e80761ecc67dbd17d
|
refs/heads/gh-pages
| 2022-11-23T03:53:13.831243 | 2022-10-24T09:48:20 | 2022-10-24T09:48:20 | 11,691,611 | 2 | 0 |
MIT
| 2019-10-22T21:50:38 | 2013-07-26T18:05:39 |
Standard ML
|
UTF-8
|
C
| false | false | 2,379 |
c
|
main.c
|
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
// This is based on https://www.apriorit.com/dev-blog/195-simple-driver-for-linux-os
// See also: https://linux-kernel-labs.github.io/master/labs/device_drivers.html
static const char data[] = "Hello world from kernel mode!\n\0";
static ssize_t device_file_read(struct file *file_ptr, char __user *user_buffer, size_t count, loff_t *offset) {
struct inode* inode = file_ptr->f_inode;
printk(KERN_NOTICE "tomasz-driver: Device major number = %i, minor number = %i\n", imajor(inode), iminor(inode));
printk(KERN_NOTICE "tomasz-driver: Device file is read at offset = %i, read bytes count = %u\n", (int)*offset, (unsigned int)count);
if (*offset + count > sizeof(data)) {
count = sizeof(data) - *offset;
}
count = 1; // intentional. Run `strace cat device` to see that it returns 1 character at a time
if (copy_to_user(user_buffer, data + *offset, count) != 0)
return -EFAULT;
*offset += count;
return count;
}
static struct file_operations simple_driver_fops = {
.owner = THIS_MODULE,
.read = device_file_read,
};
static int device_file_major_number = 0;
static const char device_name[] = "tomasz-driver";
static int register_device(void) {
int result = 0;
printk(KERN_NOTICE "tomasz-driver: register_device() is called.\n");
result = register_chrdev(0, device_name, &simple_driver_fops);
if (result < 0) {
printk(KERN_WARNING "tomasz-driver: can't register character device with errorcode = %i\n", result);
return result;
}
device_file_major_number = result;
printk(KERN_NOTICE "tomasz-driver: registered character device with major number = %i\n", device_file_major_number);
return 0;
}
void unregister_device(void) {
printk(KERN_NOTICE "tomasz-driver: unregister_device() is called\n");
if (device_file_major_number != 0) {
unregister_chrdev(device_file_major_number, device_name);
}
}
static int __init demo_init(void) {
int result;
printk(KERN_NOTICE "Hello World! I'm loaded at 0x%p.\n", demo_init);
result = register_device();
return result;
}
static void __exit demo_exit(void) {
printk(KERN_NOTICE "Goodbye, people! I'm unloading from 0x%p.\n", demo_exit);
unregister_device();
}
module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Tomasz");
|
8d9dc7b540ce7499899aa28e34481131c94295a1
|
e78efff6eaa153e76e37671b3bae0d1eb58bf2bc
|
/ordinarioPuente.c
|
5425cb8f2fd2ac680dd11b4dea0e91e38482530f
|
[] |
no_license
|
pugalol4/ordinario
|
105b3c850883277bf03db3115e1d133992af23f0
|
c8e4e6f4cc6a41a4b5676823b5aade7c288df071
|
refs/heads/master
| 2020-06-12T11:20:10.397428 | 2019-06-28T19:49:29 | 2019-06-28T19:49:29 | 194,282,982 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 4,368 |
c
|
ordinarioPuente.c
|
#include <18F4620.h>
#include <stdio.h>
#include <stdlib.h>
#fuses HS, NOFCMEN, NOIESO, PUT, NOBROWNOUT, NOWDT
#fuses NOPBADEN, NOMCLR, STVREN, NOLVP, NODEBUG
#use delay(clock=4000000)
#use rs232(baud=9600,parity=N,xmit=PIN_C6,rcv=PIN_C7,bits=8,stream=PORT1)
int a=0;
int contadorGlobal1=1, cont=0;
int contadorGlobal2=1;
int contadorGlobal3=1;
char caracter[22];
char cadena2[22],cadena3[22],cadena4[22],cadena5[22];
int bandera2=0;
int bandera1=0;
int calculo=0;
int i=0;
int j=1;
int inicio=0;
int16 contadorms=0;
int contadorval=0;
#INT_TIMER0
void TIMER0(){
contadorGlobal1*=2;
if(cont%3==0)
contadorGlobal2*=2;
if(cont%5==0)
contadorGlobal3*=2;
cont++;
if(cont==15)
cont=1;
set_timer0(3036);
}
void main(void) {
setup_oscillator(OSC_4MHZ);
setup_timer_0(RTCC_INTERNAL | RTCC_DIV_8 );
enable_interrupts(INT_TIMER0 );
enable_interrupts(GLOBAL);
set_timer0(15536);
while (1) {
if(kbhit()){
caracter[i]=getch();
if(caracter[i]>=48 && caracter[i]<=57 || caracter[i] == 59){
printf("%c",caracter[i]);
bandera1=1;
i++;
if(caracter[i-1]==59)
contadorval++;
if(caracter[i]==60){
bandera2=1;
}
else
{
bandera2=0;
}
}else if(contadorval=3)
{
if(caracter[i]>=65 && caracter[i]<=90 || caracter[i]>=97 && caracter[i]<=122 || caracter[i]==60 || caracter[i]==62 || caracter[i]==13 || caracter[i]==59){
printf("%c",caracter[i]);
bandera1=1;
i++;
}
}
else
bandera1=0;
}
if(bandera2=1)
{
do{
cadena2[j]=j;
j++;
}while(caracter[j]!=59);
do{
cadena3[j];
j++;
}while(caracter[j]!=59);
do{
cadena4[j];
j++;
}while(caracter[j]!=59);
do{
cadena5[j];
j++;
}while(caracter[j]!=59);
}
output_a(contadorglobal1);
if(contadorglobal1==256)
contadorglobal1=1;
output_b(contadorglobal2);
if(contadorglobal2==256)
contadorglobal2=1;
output_d(contadorglobal3);
if(contadorglobal3==256)
contadorglobal3=1;
/* contadoranillob=contadoranillob>>1;
if(contadoranillob==0)
{ contadoranillob=0x80;}
output_d(contadoranillob);
//-----------------------------------//
if((contadoranillob&0x20)==0x20) //& funciona para apuntar a un bit en especifico ignorando a los demas
{
output_b(contadoranillob);
}
else
{output_b(0);}
//--------------------------//
delay_ms(100);
*/
/*a=1;
switch(a)
{
case 1 :case 8:
output_b(contadoranillob);
if(contadoranillob==0x80)
{ contadoranillob=1;}
else
contadoranillob=contadoranillob<<1;
delay_ms(100);
break;
case 2 : case 16:
if(contadoranilloc==0)
{ contadoranilloc=0x80;}
else
contadoranilloc=contadoranilloc>>1;
output_c(contadoranilloc);
delay_ms(100);
break;
case 4 : case 32:
output_d(contadoranillod);
if(contadoranillod==0xc0)
{ contadoranillod=3;}
else
contadoranillod=contadoranillod<<2;
delay_ms(300);
break;
}
/* if(input_a()==1)
{
contadoranillob=contadoranillob<<1;
if(contadoranillob==0x80)
{ contadoranillob=1;}
output_d(contadoranillob);
delay_ms(100);
}
*/
}
}
|
92d8087185c18e7a7a12307d5b5bbf35562cc6cd
|
71e5f96a29f5d643ab888b37677d38c33f8d765d
|
/include/cleric_spells.h
|
197489e24ab9214af534cf1e49d8c08d2e58c3a7
|
[
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
Cherno-SuS/SunderingShadows
|
5f755fbebb79dc0b9d1c2a0541408be4afeb8b67
|
c3b4370beb2c4351ecc60826850c94892a42b685
|
refs/heads/main
| 2023-04-21T09:52:14.580024 | 2021-03-23T12:09:55 | 2021-03-23T12:09:55 | 349,490,686 | 0 | 0 |
NOASSERTION
| 2021-03-23T12:09:56 | 2021-03-19T16:40:12 | null |
UTF-8
|
C
| false | false | 957 |
h
|
cleric_spells.h
|
string * HEALS = ({"/cmds/spells/c/_cure_light_wounds.c",
"/cmds/spells/c/_cure_moderate_wounds.c",
"/cmds/spells/c/_cure_serious_wounds.c",
"/cmds/spells/c/_cure_critical_wounds.c",
"/cmds/spells/m/_mass_cure_light_wounds.c",
"/cmds/spells/h/_heal.c",
"/cmds/spells/m/_mass_cure_serious_wounds.c",
"/cmds/spells/m/_mass_cure_critical_wounds.c",
"/cmds/spells/m/_mass_heal.c"});
string * HARMS = ({"/cmds/spells/c/_cause_light_wounds.c",
"/cmds/spells/c/_cause_moderate_wounds.c",
"/cmds/spells/c/_cause_serious_wounds.c",
"/cmds/spells/c/_cause_critical_wounds.c",
"/cmds/spells/m/_mass_cause_light_wounds.c",
"/cmds/spells/h/_harm.c",
"/cmds/spells/m/_mass_cause_serious_wounds.c",
"/cmds/spells/m/_mass_cause_critical_wounds.c",
"/cmds/spells/m/_mass_harm.c"});
|
048e1c7f412d5aef20e7b3830734e21d0df63c9b
|
b7d043108771df89b094fbd44862e515e802dd78
|
/project03/threads.h
|
65d19f1a182e74018ad10411f73897efa19d1b7b
|
[
"MIT"
] |
permissive
|
mpberk/cse531-projects
|
78b56c85fa2d1fae3a92ed03effaf596bbd1b5b8
|
016e4ad8ae4959e75fd02d16d81db6ea5dba5036
|
refs/heads/master
| 2023-01-31T13:58:25.633002 | 2020-12-14T22:15:00 | 2020-12-14T22:15:00 | 294,236,814 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 2,288 |
h
|
threads.h
|
#ifndef THREADS_H
#define THREADS_H
#include "q.h"
#include "TCB.h"
// Global queue of TCBs
q_element *ReadyQ;
// Global pointer to thread under execution
q_element *Curr_Thread;
// Global thread id count
int id_count = 0;
// Get ID of thread
int get_id (q_element *thread)
{
return ((TCB_t*)(thread->payload))->thread_id;
// thread : pointer to q_element
// thread->payload : void pointer to tcb
// (TCB_t*)(thread->payload) : TCB_t pointer to tcb
// ((TCB_t*)(thread->payload))->thread_id : id
};
// Get pointer to context from thread
ucontext_t *get_context_ptr(q_element *item)
{
return &(((TCB_t*)(item->payload))->context);
// item : pointer to q_element
// item->payload : void pointer to tcb
// (TCB_t*)(item->payload) : TCB_t pointer to tcb
// ((TCB_t*)(item->payload))->context : context that exists in TCB
// &(((TCB_t*)(item->payload))->context) : pointer to context
};
void start_thread(void *function, void *args)
{
// allocate a stack (via malloc) of a certain size (choose 8192)
int stack_size = 8192;
void *stack = malloc(stack_size);
// allocate a TCB (via malloc)
TCB_t *tcb = (TCB_t*) malloc(sizeof(TCB_t));
q_element *thread = NewItem();
thread->payload = (void*) tcb;
// call init_TCB with appropriate arguments
init_TCB(tcb, function, args, stack, stack_size);
// Add a thread_id (use a counter)
tcb->thread_id = id_count;
id_count++;
// call addQ to add this TCB into the "ReadyQ" which is a global head pointer
AddQueue(&ReadyQ, thread);
};
void run()
{
Curr_Thread = DelQueue(&ReadyQ);
ucontext_t parent; // get a place to store the main context, for faking
getcontext(&parent); // magic sauce
swapcontext(&parent, get_context_ptr(Curr_Thread)); // start the first round
};
void yield() // similar to run
{
q_element *Prev_Thread;
AddQueue(&ReadyQ, Curr_Thread);
Prev_Thread = Curr_Thread;
Curr_Thread = DelQueue(&ReadyQ);
// swap the context, from Prev_Thread to the thread pointed to Curr_Thread
swapcontext(get_context_ptr(Prev_Thread), get_context_ptr(Curr_Thread));
};
#endif
|
74408e86d8446b932d7f631ba4be8c04d1ef2393
|
2cfa6c33349091a0738b8877fe9d3fdb48d935a4
|
/soal2/soal2c.c
|
f51f92fa944814f4f72701ab23c2942c991c31d1
|
[] |
no_license
|
axelbrians/soal-shift-sisop-modul-3-E06-2021
|
07ea05bfd694869975f79c01e94be29137200d38
|
49a2921df7035020796c179a160803ed9f7c5098
|
refs/heads/master
| 2023-04-28T10:57:28.659842 | 2021-05-23T14:46:18 | 2021-05-23T14:46:18 | 364,182,991 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,639 |
c
|
soal2c.c
|
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <wait.h>
int pid;
int pipe1[2];
int pipe2[2];
int main(){
// create pipe1
if (pipe(pipe1) == -1) {
perror("bad pipe1");
exit(1);
}
// fork (ps aux)
if ((pid = fork()) == -1) {
perror("bad fork1");
exit(1);
}else if (pid == 0) {
// input from stdin
// output to pipe1
dup2(pipe1[1], 1);
// close fds
close(pipe1[0]);
close(pipe1[1]);
// exec
execlp("ps", "ps", "aux", NULL);
// exec didn't work, exit
perror("bad exec ps");
exit(1);
}
// parent
// create pipe2
if (pipe(pipe2) == -1) {
perror("bad pipe2");
exit(1);
}
// fork (sort -nrk 3,3)
if ((pid = fork()) == -1) {
perror("bad fork2");
exit(1);
} else if (pid == 0) {
// input from pipe1
dup2(pipe1[0], 0);
// output to pipe2
dup2(pipe2[1], 1);
// close fds
close(pipe1[0]);
close(pipe1[1]);
close(pipe2[0]);
close(pipe2[1]);
// exec
execlp("sort", "sort", "-nrk 3,3", NULL);
// exec didn't work, exit
perror("bad exec sort -nrk 3,3");
exit(1);
}
// parent
// close unused fds
close(pipe1[0]);
close(pipe1[1]);
// fork (head -5)
if ((pid = fork()) == -1) {
perror("bad fork3");
exit(1);
}else if (pid == 0){
// input from pipe2
dup2(pipe2[0], 0);
// output to stdout (already done)
// close fds
close(pipe2[0]);
close(pipe2[1]);
// exec
execlp("head", "head", "-5", NULL);
// exec didn't work, exit
perror("bad exec head -5");
exit(1);
}
// parent
}
|
0ab9f2d0a1d06b3ceef759cec06595289da191a9
|
9377a612b82a784551fce5aa26b08bd9f386aba5
|
/SysTick Basic/main.c
|
0c067a05300d86f5b6bd25a73e314c24c0fb5dd7
|
[] |
no_license
|
srchauhan97/STM32F4_Systick
|
d0489162c024167832b09aa399e22f5c57f861f1
|
b512c8e755943ba19dc49868f866b9f91e25098e
|
refs/heads/master
| 2022-10-12T19:03:07.543332 | 2020-06-14T20:30:47 | 2020-06-14T20:30:47 | 272,278,364 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,146 |
c
|
main.c
|
#include "stm32f4xx.h"
void SystickDelayMs(uint8_t Count)
{
//now since clock is 16Mhz, so 16 000 000 cycles per second
//so 16000 cycles per 1mili second
//so we will load the Systick with 1msec value
SysTick->LOAD |= 16000-1;
SysTick->VAL = 0;
//5= 101, so Clocksource bit which is 3rd bit is set, enable bit whnich is 1st bit is set in Control register
SysTick->CTRL |= 5;
for(int i=0;i<Count;i++)
{
while(!((SysTick->CTRL >> 16) & 0x1));
}
//now disable the Systick
SysTick->CTRL = 0;
}
void SystickDelayS(uint8_t Count)
{
//now since clock is 16Mhz, so 16 000 000 cycles per second
//so we will load the Systick with 1msec value
SysTick->LOAD |= 16000000-1;
SysTick->VAL = 0;
//now run for no of seconds.
for(int i=0;i<Count;i++)
{
while((!(SysTick->CTRL) >> 16) & 0x1);
}
SysTick->CTRL = 0;
}
int main(void)
{
//Enable clock for led
//led is connected to PA5, Port A is in AHB bus
RCC->AHB1ENR |= (1 << 1);
//give gpio configurations
GPIOA->MODER |= ( 1 << 10);
GPIOA->OSPEEDR |= (1 << 10);
while(1)
{
//Check if flag is set
SystickDelayMs((uint8_t)500);
GPIOA->ODR ^= 1<< 5;
}
}
|
e132508edbdacde52d5ce7030bf9e7fbcb9007dc
|
967ca495117c6ad831e9657a5637d84be0b5fbfa
|
/Node_2/main.c
|
e1a89fa4bdfcdde8f99375cad979a2cd7b62e96f
|
[] |
no_license
|
kennyhn/TTK4155H18
|
38fcab36f79cc9efb4208cc5a2ac3c46f43d0fc7
|
67b660bc3f97c95d343c578f32d6f6be78a96402
|
refs/heads/master
| 2020-03-27T13:09:17.382311 | 2019-12-24T00:18:06 | 2019-12-24T00:18:06 | 146,593,274 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 778 |
c
|
main.c
|
#include "uart_node2.h"
#include "mcp2515_node2.h"
#include "can_node2.h"
#include "pwm_node2.h"
#include "adc_node2.h"
#include "TWI_Master_node2.h"
#include "motor_node2.h"
#include "game_node2.h"
#include <util/delay.h>
#include <avr/io.h>
#include <stdio.h>
int main(){
USART_Init(MYUBRR);
can_interrupt_init();
//Using cli and sei to call the init functions without interrupt-handling
cli();
adc_init();
can_normal_init();
pwm_init();
TWI_Master_Initialise();
motor_init();
sei();
timer_interrupt_init();
set_motor_start_point();
adc_read(); //To prevent first read to be zero
_delay_ms(4); //To prevent first read to be zero
can_data_receive();
while(1){
if(can_message_received){
play_game();
}
}
return 0;
}
|
e00506d1093b7ecafcdf3a7ffa6bcbe5bbfffb8e
|
28850ae66ff3f35329c0e8e9210b037f18f9797c
|
/c-program/example/struct/struct_space_usage.c
|
6925e18bd42f27f85a63c5f41419c2645c4da3e6
|
[] |
no_license
|
falconkaze/2018-notebook
|
cc95ee7994711a9a2ad0b18f04f2a980431f5c43
|
0c74a078a00266dc4a0a61965393a1986e54e044
|
refs/heads/master
| 2021-04-09T13:04:28.749171 | 2020-07-16T09:46:57 | 2020-07-16T09:46:57 | 125,622,416 | 3 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 298 |
c
|
struct_space_usage.c
|
#include<stdio.h>
struct CharDoubleInt{
char c;
double d;
int i;
} char_double_int;
struct DoubleCharInt {
double d;
char c;
int i;
} double_char_int;
int main(){
printf("char double int:%d\n", sizeof(char_double_int));
printf("double char int:%d\n", sizeof(double_char_int));
}
|
5d67d362e8822eafb3fee2945f703fb2e82d7e68
|
43151aaac0800dd1b46e3ce27cdeef3695e64271
|
/test/02_TestScript/Dem_UnitTest/incVar/var1/DemTest_InternalDebounceCallback.h
|
f8525268ef20328e9e9bc85eab7f8fb9fb444a6b
|
[] |
no_license
|
tuanphong160896/AutoReview
|
746f602e65f8e1739853117b844450cde785692c
|
7ccb4de81926ba76625bb15df8e459d25ab3fddf
|
refs/heads/master
| 2020-03-26T20:24:20.472728 | 2018-09-21T00:50:56 | 2018-09-21T00:50:56 | 145,321,957 | 1 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 3,162 |
h
|
DemTest_InternalDebounceCallback.h
|
/*
**********************************************************************************************************************
*
* COPYRIGHT RESERVED, 2010 Robert Bosch GmbH. All rights reserved.
* The reproduction, distribution and utilization of this document as well as the communication of its contents to
* others without explicit authorization is prohibited. Offenders will be held liable for the payment of damages.
* All rights reserved in the event of the grant of a patent, utility model or design.
*
**********************************************************************************************************************
*/
/********************************************************************************************************************/
/* */
/* TOOL-GENERATED SOURCECODE, DO NOT CHANGE */
/* */
/********************************************************************************************************************/
#ifndef DEMTEST_INTERNALDEBOUNCECALLBACK_H
#define DEMTEST_INTERNALDEBOUNCECALLBACK_H
/* ---------------------------------------- */
/* DEM_CFG_DEBMONINTBASE */
/* ---------------------------------------- */
Std_ReturnType CB_DemGetFaultDetectionCounter_Monitoring_08(sint8 * const faultDetCtr);
Std_ReturnType CB_DemGetFaultDetectionCounter_Monitoring_13(sint8 * const faultDetCtr);
Std_ReturnType CB_DemGetFaultDetectionCounter_Monitoring_14(sint8 * const faultDetCtr);
Std_ReturnType CB_DemGetFaultDetectionCounter_Monitoring_16(sint8 * const faultDetCtr);
Std_ReturnType CB_DemGetFaultDetectionCounter_Monitoring_17(sint8 * const faultDetCtr);
Std_ReturnType CB_DemGetFaultDetectionCounter_Monitoring_22(sint8 * const faultDetCtr);
Std_ReturnType CB_DemGetFaultDetectionCounter_Monitoring_24(sint8 * const faultDetCtr);
Std_ReturnType CB_DemGetFaultDetectionCounter_Monitoring_25(sint8 * const faultDetCtr);
Std_ReturnType CB_DemGetFaultDetectionCounter_Monitoring_27(sint8 * const faultDetCtr);
Std_ReturnType CB_DemGetFaultDetectionCounter_Monitoring_31(sint8 * const faultDetCtr);
void CB_DemGetFaultDetectionCounter_SetValueToReturn (Std_ReturnType returnValue, sint8 returnParamFdc);
void CB_DemGetFaultDetectionCounter_SetValueToReturnForEvent (Dem_EventIdType EventId, Std_ReturnType returnValue, sint8 returnParamFdc);
#endif
|
6dc2c124c347f08c2c5fb1f905687a01b4c37adf
|
6408c9e56e93cd482c3c1c7588adc3b505b999b2
|
/exspawn.h
|
d6291c5a7f3a6c1c8b1156b64c33f1e02add250d
|
[] |
no_license
|
philip-davis/spawn_intercept
|
45649a6f2c9643d21331fbdaf48b658c9f354672
|
6078dc0e118271897fd83910b64365eeb6e69806
|
refs/heads/master
| 2023-01-30T10:55:58.594313 | 2020-12-07T18:36:57 | 2020-12-07T18:36:57 | 319,404,671 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 269 |
h
|
exspawn.h
|
#ifndef EXSPAWN_H
#define EXSPAWN_H
int signal_spawn_done(const char *spool_prefix, int jid);
int despool_cmd(char **command, const char *spool);
int enspool_cmd(int jid, const char *command, char *argv[], int nprocs, const char *spool, const char *prefix);
#endif
|
bcdd3399b96b613ba769e58d2feb79c1317aa718
|
7e1f97967b73f6e5ef028d910ee798925b788a67
|
/kernel-ex/kernel-api-ex/chapter9/dput/dput.c
|
13dec2392bd9dc7e106756c26061084c5bc8358c
|
[] |
no_license
|
fjrti/snippets
|
e7744e2624506ce984cc9aec5aba4d7a3511dbdc
|
defc0b3ca3bb214eae963f75c0d1ccb066fccc1b
|
refs/heads/master
| 2022-04-29T21:54:16.188735 | 2022-04-15T09:08:35 | 2022-04-15T09:08:35 | 89,904,548 | 3 | 1 | null | null | null | null |
UTF-8
|
C
| false | false | 996 |
c
|
dput.c
|
/********************************************************************************
* File Name: dput.c
* Description: 第9章实例训练
* Reference book:《Linux内核API完全参考手册》邱铁，周玉，邓莹莹 ，机械工业出版社.2010.9
* E_mail:openlinux2100@gmail.com
*
********************************************************************************/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/fs_struct.h>
#include <linux/path.h>
#include <linux/sched.h>
MODULE_LICENSE("GPL");
int dput_init(void)
{
struct dentry *dentry_pwd = current->fs->pwd.dentry;
printk("Before \"dput\", the d_count of current dentry is %d\n",dentry_pwd->d_count);
dput(dentry_pwd);
printk("After \"dput\", the d_count of current dentry is %d\n",dentry_pwd->d_count);
return 0;
}
void dput_exit(void)
{
printk("<0>Goodbye dput_test\n");
}
module_init(dput_init);
module_exit(dput_exit);
|
d2fa78c3c722974e28056f2059758d55e01a1866
|
129edbeb2431db2be2cb42b6f9555c267789735e
|
/daa4new.c
|
a07bd85f6349c5cc7b9350e3a21d808be3687f5d
|
[] |
no_license
|
tejalchavan17/daa4
|
eb617fcbe87ad079e421edd80c054f24e4d15e7a
|
706c8970ca13f394e6fd6c0cd76ceb681f48af04
|
refs/heads/master
| 2020-04-12T19:58:37.758635 | 2018-12-21T14:24:42 | 2018-12-21T14:24:42 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 4,274 |
c
|
daa4new.c
|
#include<stdio.h>
#define INFINITY 9999
void dijkstra(int G[50][50],int n,int startnode);
void mindist(int n,int distance[],int visited[],int cost[][50],int previous[],int startnode);
void print(int n,int startnode,int distance[],int previous[]);
void main()
{
int G[50][50],i,j,n,s;
printf("Enter no. of vertices:");
scanf("%d",&n);
printf("\nEnter the Edge weight matrix:\n");
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&G[i][j]);
printf("\nEnter the starting node:");
scanf("%d",&s);
dijkstra(G,n,s);
}
void dijkstra(int G[50][50],int n,int startnode)
{
int cost[50][50],distance[50],previous[50];
int visited[50],count,mindistance,nextnode,i,j;
//previous[] stores the predecessor of each node
//count gives the number of nodes seen so far
//create the cost matrix
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(G[i][j]==0)
cost[i][j]=INFINITY;
else
cost[i][j]=G[i][j];
//initialize previous[],distance[] and visited[]
for(i=0;i<n;i++)
{
distance[i]=cost[startnode][i];
previous[i]=startnode;
visited[i]=0;
}
for(i=0;i<n;i++)
{
if(G[startnode][i]==0)
previous[i]=-1;
}
distance[startnode]=0;
visited[startnode]=1;
count=0;
printf("\nFrom:\t");
for(i=0;i<n;i++)
printf("%d\t",startnode);
printf("\nVia:\t");
for(i=0;i<n;i++)
{
if(previous[i]!=-1)
printf("%d\t",previous[i]);
else
printf("-\t");
}
printf("\nTo:\t");
for(i=0;i<n;i++)
printf("%d\t",i);
printf("\nWeight:\t");
for(i=0;i<n;i++)
{
if(i==startnode)
printf("-\t");
else
printf("%d\t",distance[i]);
}
printf("\nNode %d is visited\n",startnode);
while(count<n-1)
{
printf("\nFrom:\t");
for(i=0;i<n;i++)
printf("%d\t",startnode);
mindist(n,distance,visited,cost,previous,startnode);
count++;
}
print(n,startnode,distance,previous);
}
void mindist(int n,int distance[],int visited[],int cost[][50],int previous[],int startnode)
{
int mindistance,i,nextnode;
mindistance=INFINITY;
//nextnode gives the node at minimum distance
for(i=0;i<n;i++)
if(distance[i]<mindistance&&visited[i]!=1)
{
mindistance=distance[i];
nextnode=i;
}
//check if a better path exists through nextnode
visited[nextnode]=1;
printf("\nVia:\t");
for(i=0;i<n;i++)
{
if(visited[i]!=1)
{
if(mindistance+cost[nextnode][i]<distance[i])
{
distance[i]=mindistance+cost[nextnode][i];
previous[i]=nextnode;
}
}
if(previous[i]!=-1)
printf("%d\t",previous[i]);
else
printf("-\t");
}
printf("\nTo:\t");
for(i=0;i<n;i++)
printf("%d\t",i);
printf("\nweight:\t");
for(i=0;i<n;i++)
{
if(i==startnode)
printf("-\t");
else
printf("%d\t",distance[i]);
}
printf("\nNode %d is visited\n",nextnode);
}
void print(int n,int startnode,int distance[],int previous[])
{
int i,j;
printf("\nResult:");
printf("\nFrom:\t");
for(i=0;i<n;i++)
printf("%d\t",startnode);
printf("\nVia:\t");
for(i=0;i<n;i++)
{
if(previous[i]!=-1)
printf("%d\t",previous[i]);
else
printf("-\t");
}
printf("\nTo:\t");
for(i=0;i<n;i++)
printf("%d\t",i);
printf("\nweight:\t");
for(i=0;i<n;i++)
{
if(i==startnode)
printf("-\t");
else
printf("%d\t",distance[i]);
}
}
/*Output
tejal@ubuntu:~/Desktop$ gcc daa4new.c
tejal@ubuntu:~/Desktop$ ./a.out
Enter no. of vertices:5
Enter the adjacency matrix:
0 3 0 7 0
3 0 4 2 0
0 4 0 5 6
7 2 5 0 4
0 0 6 4 0
Enter the starting node:0
From: 0 0 0 0 0
Via: - 0 - 0 -
To: 0 1 2 3 4
Weight: - 3 9999 7 9999
Node 0 is visited
From: 0 0 0 0 0
Via: - 0 1 1 -
To: 0 1 2 3 4
weight: - 3 7 5 9999
Node 1 is visited
From: 0 0 0 0 0
Via: - 0 1 1 3
To: 0 1 2 3 4
weight: - 3 7 5 9
Node 3 is visited
From: 0 0 0 0 0
Via: - 0 1 1 3
To: 0 1 2 3 4
weight: - 3 7 5 9
Node 2 is visited
Result:
From: 0 0 0 0 0
Via: - 0 1 1 3
To: 0 1 2 3 4
weight: - 3 7 5 9 */
|
7581d45a319f35d7ef1eed8e312a6634da191c41
|
53792c35f556959709ea8f0a3486c702ddc3021f
|
/MotorControl/low_level.h
|
7dad0b7925545c9fe19d46162db3458826542f42
|
[
"MIT"
] |
permissive
|
yucnet/ODriveFirmware
|
fa617fddfff06467199365ac05d823d93761252a
|
d83d01522237b2395b844a54e13ac40bc7300ffd
|
refs/heads/master
| 2020-07-28T19:43:22.544828 | 2016-11-13T07:58:48 | 2016-11-13T07:58:48 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 385 |
h
|
low_level.h
|
#ifndef __LOW_LEVEL_H
#define __LOW_LEVEL_H
#include "drv8301.h"
typedef struct Motor_s {
DRV8301_Obj gate_driver;
float shunt_conductance;
float maxcurrent;
} Motor_t;
extern Motor_t motor_configs[];
extern const int num_motors;
void init_motor_control();
//@TODO move motor thread to high level file
void motor_thread(void const * argument);
#endif //__LOW_LEVEL_H
|
fcbad30f1a37769392685d19447fb2b24febd64b
|
9b9c0f0fda26f7b1735e24142c2f9a7c4ea20c79
|
/headers/dijkstra.h
|
f5f793782de97d6ae687fbe98724802eef93c987
|
[] |
no_license
|
Rav263/Network_ASVK
|
e165582638c05c5a4ae978eb35c2a8f9829468e4
|
b7706e6a7d4ce05f67d017e52ea059b513d25339
|
refs/heads/master
| 2020-04-30T14:14:01.843893 | 2019-04-10T22:13:58 | 2019-04-10T22:13:58 | 176,884,418 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 121 |
h
|
dijkstra.h
|
#include "network.h"
#ifndef DIJKSTRA_H_
#define DIJKSTRA_H_
Mass calc_path(Path &, Graph &, Vertex, Vertex);
#endif
|
7a36946c5341159fe0c2579c93c5ea43d9569416
|
aa7e7264cdf063c82cf28161d8693ca437980d85
|
/a33g526_fw/src/lib/abov_hal/Source/a33g52x_timer.c
|
a7e651895fb765188d6035f79335c59b4d48e8b9
|
[
"Apache-2.0"
] |
permissive
|
chcbaram/ABOV_A33G526
|
a4ba02f41b20231b1654a923661701cf3ea5a7ce
|
7b38453979b973ce1e3f1feecb525ee5607b04bd
|
refs/heads/main
| 2023-06-27T17:46:09.976197 | 2021-08-05T14:46:26 | 2021-08-05T14:46:26 | 389,329,572 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 20,915 |
c
|
a33g52x_timer.c
|
/**
**********************(C) Copyright 2017 ABOV Semiconductor Co., Ltd *******************
* @ File : a33g52x_timer.c
*
* @ Author : Application Team, ABOV Semiconductor Co., Ltd
*
* @ Version : V1.0.10
*
* @ date: 2020-11-16
*
* @ Description
* ABOV Semiconductor is supplying this software for use with HART-m310
* processor. This software contains the confidential and proprietary information
* of ABOV Semiconductor Co., Ltd ("Confidential Information").
*
*
**************************************************************************************
* DISCLAIMER
*
* THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
* WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
* TIME. AS A RESULT, ABOV SEMICONDUCTOR DISCLAIMS ALL LIABILITIES FROM ANY
* DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
* FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
* CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
*
**************************************************************************************
*/
#include <stdint.h>
#include "A33G52x.h"
#include "a33g52x_timer.h"
#include "a33g52x_pcu.h"
#include "a33g52x_nvic.h"
uint32_t g_TnO_PORT[10][4] = {
{PCB_BASE, PIN_0, PB0_MUX_T0O, PUSHPULL_OUTPUT}, // T0O
{PCB_BASE, PIN_1, PB1_MUX_T1O, PUSHPULL_OUTPUT}, // T1O
{PCB_BASE, PIN_2, PB2_MUX_T2O, PUSHPULL_OUTPUT}, // T2O
{PCB_BASE, PIN_3, PB3_MUX_T3O, PUSHPULL_OUTPUT}, // T3O
{PCB_BASE, PIN_4, PB4_MUX_T4O, PUSHPULL_OUTPUT}, // T4O
{PCB_BASE, PIN_5, PB5_MUX_T5O, PUSHPULL_OUTPUT}, // T5O
{PCB_BASE, PIN_6, PB6_MUX_T6O, PUSHPULL_OUTPUT}, // T6O
{PCB_BASE, PIN_7, PB7_MUX_T7O, PUSHPULL_OUTPUT}, // T7O
{PCB_BASE, PIN_8, PB8_MUX_T8O, PUSHPULL_OUTPUT}, // T8O
{PCB_BASE, PIN_9, PB9_MUX_T9O, PUSHPULL_OUTPUT}, // T9O
};
uint32_t g_TnC_PORT[10][4] = {
{PCA_BASE, PIN_6, PA6_MUX_T0C, LOGIC_INPUT}, // T0C
{PCA_BASE, PIN_7, PA7_MUX_T1C, LOGIC_INPUT}, // T1C
{PCA_BASE, PIN_8, PA8_MUX_T2C, LOGIC_INPUT}, // T2C
{PCA_BASE, PIN_9, PA9_MUX_T3C, LOGIC_INPUT}, // T3C
{PCA_BASE, PIN_10, PA10_MUX_T4C, LOGIC_INPUT}, // T4C
{PCA_BASE, PIN_11, PA11_MUX_T5C, LOGIC_INPUT}, // T5C
{PCA_BASE, PIN_12, PA12_MUX_T6C, LOGIC_INPUT}, // T6C
{PCA_BASE, PIN_13, PA13_MUX_T7C, LOGIC_INPUT}, // T7C
{PCA_BASE, PIN_14, PA14_MUX_T8C, LOGIC_INPUT}, // T8C
{PCA_BASE, PIN_15, PA15_MUX_T9C, LOGIC_INPUT}, // T9C
};
/**
*********************************************************************************************************
* @ Name : TIMER_ConfigureGPIO
*
* @ Parameters
* - timer : TIMER0~TIMER9
* - mode : TIMER_MODE_PERIODIC, TIMER_MODE_PWM, TIMER_MODE_ONE_SHOT, TIMER_MODE_CAPTURE
*
*
*********************************************************************************************************
*/
void TIMER_ConfigureGPIO (TIMER_Type * const timer, int mode)
{
int timer_no;
PCU_Type *port_base_addr;
uint32_t pin_no;
uint32_t mux_info;
uint32_t dir_type;
//--------------------------------------------------------------------------------
// get timer_no
//--------------------------------------------------------------------------------
timer_no = TIMER_Get_Object_Number(timer);
//--------------------------------------------------------------------------------
// setting info
//--------------------------------------------------------------------------------
if ((mode == TIMER_MODE_PERIODIC) || (mode == TIMER_MODE_PWM) || (mode == TIMER_MODE_ONE_SHOT))
{
port_base_addr = (PCU_Type *) g_TnO_PORT[timer_no][0];
pin_no = g_TnO_PORT[timer_no][1];
mux_info = g_TnO_PORT[timer_no][2];
dir_type = g_TnO_PORT[timer_no][3];
}
else if (mode == TIMER_MODE_CAPTURE)
{
port_base_addr = (PCU_Type *) g_TnC_PORT[timer_no][0];
pin_no = g_TnC_PORT[timer_no][1];
mux_info = g_TnC_PORT[timer_no][2];
dir_type = g_TnC_PORT[timer_no][3];
}
//--------------------------------------------------------------------------------
// setting
//--------------------------------------------------------------------------------
PCU_ConfigureFunction (port_base_addr, pin_no, mux_info);
PCU_SetDirection(port_base_addr, pin_no, (PORT_Type)dir_type);
PCU_ConfigurePullupdown (port_base_addr, pin_no, PUPD_DISABLE);
}
/**
*********************************************************************************************************
* @ Name : TIMER_ConfigureExternalSource
*
* @ Parameters
* - timer : TIMER0~TIMER9
*
*
*********************************************************************************************************
*/
void TIMER_ConfigureExternalSource (TIMER_Type * const timer)
{
int timer_no;
PCU_Type *port_base_addr;
uint32_t pin_no;
uint32_t mux_info;
uint32_t dir_type;
//--------------------------------------------------------------------------------
// get timer_no
//--------------------------------------------------------------------------------
timer_no = TIMER_Get_Object_Number(timer);
//--------------------------------------------------------------------------------
// setting info
//--------------------------------------------------------------------------------
port_base_addr = (PCU_Type *) g_TnC_PORT[timer_no][0];
pin_no = g_TnC_PORT[timer_no][1];
mux_info = g_TnC_PORT[timer_no][2];
dir_type = g_TnC_PORT[timer_no][3];
//--------------------------------------------------------------------------------
// setting
//--------------------------------------------------------------------------------
PCU_ConfigureFunction (port_base_addr, pin_no, mux_info);
PCU_SetDirection(port_base_addr, pin_no, (PORT_Type)dir_type);
PCU_ConfigurePullupdown (port_base_addr, pin_no, PUPD_DISABLE);
}
/**
*********************************************************************************************************
* @ Name : TIMER_Get_Object_Number
*
* @ Parameters
* - pwm : TIMER0~TIMER9
*
* @ Return
* - timer_no
*
*
*********************************************************************************************************
*/
int TIMER_Get_Object_Number (TIMER_Type * const timer)
{
int timer_no;
if (timer == T0) timer_no = 0;
else if (timer == T1) timer_no = 1;
else if (timer == T2) timer_no = 2;
else if (timer == T3) timer_no = 3;
else if (timer == T4) timer_no = 4;
else if (timer == T5) timer_no = 5;
else if (timer == T6) timer_no = 6;
else if (timer == T7) timer_no = 7;
else if (timer == T8) timer_no = 8;
else if (timer == T9) timer_no = 9;
return (timer_no);
}
/**
*********************************************************************************************************
* @ Name : TIMER_Init
*
* @ Parameters
* - pwm : TIMER0~TIMER9
* - mode : TIMER_MODE_PERIODIC, TIMER_MODE_PWM, TIMER_MODE_ONE_SHOT, TIMER_MODE_CAPTURE
* - p_config
* # start_level_after_counter_clear = TIMER_START_LEVEL_HIGH, TIMER_START_LEVEL_LOW
* # clock_select = TIMER_CLKSEL_TCLK_DIV_BY_2 ~ TIMER_CLKSEL_EXTERNAL_SOURCE
* # capture_clear_mode = TIMER_CAPTURE_RISING_EDGE_CLEAR, TIMER_CAPTURE_FALLING_EDGE_CLEAR
* # GRA = 16-bit value
* # GRB = 16-bit value
*
*********************************************************************************************************
*/
void TIMER_Init (TIMER_Type * const timer, int mode, TIMER_CONFIG * p_config)
{
uint32_t reg_val;
//--------------------------------------------------------------------------------
// init timer
//
// @ T0CMD = 0x4000_0C04
// @ T1CMD = 0x4000_0C24
// @ T2CMD = 0x4000_0C44
// @ T3CMD = 0x4000_0C64
//
// @ T4CMD = 0x4000_0C84
// @ T5CMD = 0x4000_0CA4
// @ T6CMD = 0x4000_0CC4
// @ T7CMD = 0x4000_0CE4
//
// @ T8CMD = 0x4000_0D04
// @ T9CMD = 0x4000_0D24
//
//
//--------------------------------------------------------------------------------
timer->CMD = TnCMD_TCLR;
timer->CMD = 0;
//--------------------------------------------------------------------------------
// mode setting
//
// @ T0CON = 0x4000_0C00
// @ T1CON = 0x4000_0C20
// @ T2CON = 0x4000_0C40
// @ T3CON = 0x4000_0C60
//
// @ T4CON = 0x4000_0C80
// @ T5CON = 0x4000_0CA0
// @ T6CON = 0x4000_0CC0
// @ T7CON = 0x4000_0CE0
//
// @ T8CON = 0x4000_0D00
// @ T9CON = 0x4000_0D20
//
//--------------------------------------------------------------------------------
//
// TSTRT, TCS, CAPM, TMODE
//
//--------------------------------------------------------------------------------
reg_val = 0;
// TSTRT (start level)
if (p_config->start_level_after_counter_clear == TIMER_START_LEVEL_HIGH)
reg_val |= TnCON_TSTRT;
// TCS (select clock)
if (p_config->clock_select == TIMER_CLKSEL_TCLK_DIV_BY_2)
{
reg_val |= TnCON_TCS_TCLK_DIV_BY_2;
}
else if (p_config->clock_select == TIMER_CLKSEL_TCLK_DIV_BY_4)
{
reg_val |= TnCON_TCS_TCLK_DIV_BY_4;
}
else if (p_config->clock_select == TIMER_CLKSEL_TCLK_DIV_BY_16)
{
reg_val |= TnCON_TCS_TCLK_DIV_BY_16;
}
else if (p_config->clock_select == TIMER_CLKSEL_TCLK_DIV_BY_64)
{
reg_val |= TnCON_TCS_TCLK_DIV_BY_64;
}
else if (p_config->clock_select == TIMER_CLKSEL_PMUPCSR)
{
reg_val |= TnCON_TCS_PMUPCSR;
}
else if (p_config->clock_select == TIMER_CLKSEL_EXTERNAL_SOURCE)
{
reg_val |= TnCON_TCS_TnC;
}
// TMODE, CAPM (Periodic, PWM, One-shot, Capture (clear mode))
if (mode == TIMER_MODE_PERIODIC)
{
reg_val |= TnCON_TMODE_PERIODIC;
}
else if (mode == TIMER_MODE_PWM)
{
reg_val |= TnCON_TMODE_PWM;
}
else if (mode == TIMER_MODE_ONE_SHOT)
{
reg_val |= TnCON_TMODE_ONE_SHOT;
}
else if (mode == TIMER_MODE_CAPTURE)
{
reg_val |= TnCON_TMODE_CAPTURE;
if (p_config->capture_clear_mode == TIMER_CAPTURE_RISING_EDGE_CLEAR) reg_val |= TnCON_CAPM_RISING_EDGE_CLEAR;
else if (p_config->capture_clear_mode == TIMER_CAPTURE_FALLING_EDGE_CLEAR) reg_val |= TnCON_CAPM_FALLING_EDGE_CLEAR;
}
timer->CON = reg_val;
//--------------------------------------------------------------------------------
// prescale
//
// @ T0PRS = 0x4000_0C10
// @ T1PRS = 0x4000_0C30
// @ T2PRS = 0x4000_0C50
// @ T3PRS = 0x4000_0C70
//
// @ T4PRS = 0x4000_0C90
// @ T5PRS = 0x4000_0CB0
// @ T6PRS = 0x4000_0CD0
// @ T7PRS = 0x4000_0CF0
//
// @ T8PRS = 0x4000_0D10
// @ T9PRS = 0x4000_0D30
//
//--------------------------------------------------------------------------------
timer->PRS = p_config->PRS;
//--------------------------------------------------------------------------------
// TnGRA
//
// @ T0GRA = 0x4000_0C08
// @ T1GRA = 0x4000_0C28
// @ T2GRA = 0x4000_0C48
// @ T3GRA = 0x4000_0C68
//
// @ T4GRA = 0x4000_0C88
// @ T5GRA = 0x4000_0CA8
// @ T6GRA = 0x4000_0CC8
// @ T7GRA = 0x4000_0CE8
//
// @ T8GRA = 0x4000_0D08
// @ T9GRA = 0x4000_0D28
//
//--------------------------------------------------------------------------------
timer->GRA = p_config->GRA;
//--------------------------------------------------------------------------------
// TnGRB
//
// @ T0GRB = 0x4000_0C0C
// @ T1GRB = 0x4000_0C2C
// @ T2GRB = 0x4000_0C4C
// @ T3GRB = 0x4000_0C6C
//
// @ T4GRB = 0x4000_0C8C
// @ T5GRB = 0x4000_0CAC
// @ T6GRB = 0x4000_0CCC
// @ T7GRB = 0x4000_0CEC
//
// @ T8GRB = 0x4000_0D0C
// @ T9GRB = 0x4000_0D2C
//
//--------------------------------------------------------------------------------
timer->GRB = p_config->GRB;
//--------------------------------------------------------------------------------
// push data into compare-buffer
//
// @ T0CMD = 0x4000_0C04
// @ T1CMD = 0x4000_0C24
// @ T2CMD = 0x4000_0C44
// @ T3CMD = 0x4000_0C64
//
// @ T4CMD = 0x4000_0C84
// @ T5CMD = 0x4000_0CA4
// @ T6CMD = 0x4000_0CC4
// @ T7CMD = 0x4000_0CE4
//
// @ T8CMD = 0x4000_0D04
// @ T9CMD = 0x4000_0D24
//
//--------------------------------------------------------------------------------
timer->CMD = TnCMD_TCLR;
//--------------------------------------------------------------------------------
// TnCNT
//
// @ T0CNT = 0x4000_0C14
// @ T1CNT = 0x4000_0C34
// @ T2CNT = 0x4000_0C54
// @ T3CNT = 0x4000_0C74
//
// @ T4CNT = 0x4000_0C94
// @ T5CNT = 0x4000_0CB4
// @ T6CNT = 0x4000_0CD4
// @ T7CNT = 0x4000_0CF4
//
// @ T8CNT = 0x4000_0D14
// @ T9CNT = 0x4000_0D34
//
//--------------------------------------------------------------------------------
timer->CNT = 0;
}
/**
*********************************************************************************************************
* @ Name : TIMER_ConfigureInterrupt
*
* @ Parameters
* - pwm : TIMER0~TIMER9
* - intr_mask : TnCON_TOVE, TnCON_TIE1, TnCON_TIE0
* - enable : INTR_ENABLE, INTR_DISABLE
*
*
*********************************************************************************************************
*/
void TIMER_ConfigureInterrupt (TIMER_Type * const timer, uint32_t intr_mask, uint32_t enable)
{
uint32_t reg_val;
//-----------------------------------------------------------------------------------------
// disable interrupt
//
// @ T0CON = 0x4000_0C00
// @ T1CON = 0x4000_0C20
// @ T2CON = 0x4000_0C40
// @ T3CON = 0x4000_0C60
//
// @ T4CON = 0x4000_0C80
// @ T5CON = 0x4000_0CA0
// @ T6CON = 0x4000_0CC0
// @ T7CON = 0x4000_0CE0
//
// @ T8CON = 0x4000_0D00
// @ T9CON = 0x4000_0D20
//
//-----------------------------------------------------------------------------------------
reg_val = timer->CON;
reg_val &= ~TnCON_INTR_MASK;
timer->CON = reg_val;
//-----------------------------------------------------------------------------------------
// clear interrupt flag
//
// @ T0CON = 0x4000_0C00
// @ T1CON = 0x4000_0C20
// @ T2CON = 0x4000_0C40
// @ T3CON = 0x4000_0C60
//
// @ T4CON = 0x4000_0C80
// @ T5CON = 0x4000_0CA0
// @ T6CON = 0x4000_0CC0
// @ T7CON = 0x4000_0CE0
//
// @ T8CON = 0x4000_0D00
// @ T9CON = 0x4000_0D20
//
//-----------------------------------------------------------------------------------------
reg_val = timer->CON;
reg_val |= TnCON_IFLAG_MASK;
timer->CON = reg_val;
//-----------------------------------------------------------------------------------------
// enable interrupt
//
// @ T0CON = 0x4000_0C00
// @ T1CON = 0x4000_0C20
// @ T2CON = 0x4000_0C40
// @ T3CON = 0x4000_0C60
//
// @ T4CON = 0x4000_0C80
// @ T5CON = 0x4000_0CA0
// @ T6CON = 0x4000_0CC0
// @ T7CON = 0x4000_0CE0
//
// @ T8CON = 0x4000_0D00
// @ T9CON = 0x4000_0D20
//
//-----------------------------------------------------------------------------------------
if (enable == INTR_ENABLE)
{
reg_val |= (intr_mask&TnCON_INTR_MASK);
timer->CON = reg_val;
}
}
/**
*********************************************************************************************************
* @ Name : _TIMER_Init
*
* @ Parameter
* - timer_no : 0~9
*
* - mode : TIMER_MODE_PERIODIC, TIMER_MODE_PWM, TIMER_MODE_ONE_SHOT, TIMER_MODE_CAPTURE
*
* - p_TIMER_config
* # clock_select = TIMER_CLKSEL_TCLK_DIV_BY_2 ~ TIMER_CLKSEL_EXTERNAL_SOURCE
* # capture_clear_mode = TIMER_CAPTURE_RISING_EDGE_CLEAR, TIMER_CAPTURE_FALLING_EDGE_CLEAR
* # GRA = 16-bit value
* # GRB = 16-bit value
*
*********************************************************************************************************
*/
void _TIMER_Init (int timer_no, int mode, TIMER_CONFIG * p_TIMER_config)
{
TIMER_Type * timer;
NVIC_IntrConfig nvic_config;
//--------------------------------------------------------------------------------
// check timer_no
//--------------------------------------------------------------------------------
if ((timer_no < 0) || (timer_no > 9)) return;
//--------------------------------------------------------------------------------
// get object
//--------------------------------------------------------------------------------
timer = TIMER_Get_Object(timer_no);
//--------------------------------------------------------------------------------
// configure GPIO
//--------------------------------------------------------------------------------
TIMER_ConfigureGPIO(timer, mode);
//--------------------------------------------------------------------------------
// configure GPIO - clock source selection
//--------------------------------------------------------------------------------
if (p_TIMER_config->clock_select == TIMER_CLKSEL_EXTERNAL_SOURCE)
{
TIMER_ConfigureExternalSource (timer);
}
//--------------------------------------------------------------------------------
// mode setting
//--------------------------------------------------------------------------------
TIMER_Init (timer, mode, p_TIMER_config);
//------------------------------------------------------------------------------
// interrupt setting (peripheral)
//
//
//------------------------------------------------------------------------------
TIMER_ConfigureInterrupt (timer, (TnCON_TIE0|TnCON_TIE1), INTR_ENABLE);
// TIMER_ConfigureInterrupt (timer, (TnCON_TOVE |TnCON_TIE0|TnCON_TIE1), INTR_ENABLE);
// TIMER_ConfigureInterrupt (timer, (TnCON_TOVE), INTR_ENABLE);
//------------------------------------------------------------------------------
// interrupt setting (interrupt module)
//
// IRQ_TIMER0=5
// IRQ_TIMER1=6
// IRQ_TIMER2=7
// IRQ_TIMER3=8
//
// IRQ_TIMER4=9
// IRQ_TIMER5=10
// IRQ_TIMER6=11
// IRQ_TIMER7=12
//
// IRQ_TIMER8=13
// IRQ_TIMER9=14
//
//------------------------------------------------------------------------------
nvic_config.nIRQ_Number = (IRQ_TIMER0+timer_no);
nvic_config.Preemption_Priority= PRIO_TIMER0_PREEMPTION;
nvic_config.Subpriority= PRIO_TIMER0_SUBPRIORITY;
nvic_config.IntrEnable = INTR_ENABLE;
NVIC_ConfigureInterrupt (NVIC, &nvic_config);
}
/**
*********************************************************************************************************
* @ Name : TIMER_Get_Object
*
* @ Parameter
* - timer_no : 0~9
*
* @ Return
* TIMER-register-band object
*
*
*********************************************************************************************************
*/
TIMER_Type * TIMER_Get_Object (int timer_no)
{
TIMER_Type * p_obj;
switch (timer_no)
{
case 0:
p_obj = T0;
break;
case 1:
p_obj = T1;
break;
case 2:
p_obj = T2;
break;
case 3:
p_obj = T3;
break;
case 4:
p_obj = T4;
break;
case 5:
p_obj = T5;
break;
case 6:
p_obj = T6;
break;
case 7:
p_obj = T7;
break;
case 8:
p_obj = T8;
break;
case 9:
p_obj = T9;
break;
default:
p_obj = (TIMER_Type *) 0;
break;
}
return (p_obj);
}
/**
*********************************************************************************************************
* @ Name : TIMER_Start
*
* @ Parameter
* - timer_no : 0~9
*
* @ Return
*
*
*
*********************************************************************************************************
*/
void TIMER_Start (int timer_no)
{
TIMER_Type * timer;
//--------------------------------------------------------------------------------
// check timer_no
//--------------------------------------------------------------------------------
if ((timer_no < 0) || (timer_no > 9)) return;
//--------------------------------------------------------------------------------
// get object
//--------------------------------------------------------------------------------
timer = TIMER_Get_Object(timer_no);
//--------------------------------------------------------------------------------
// start
//--------------------------------------------------------------------------------
timer->CMD = TnCMD_TEN;
}
/**
*********************************************************************************************************
* @ Name : TIMER_Stop
*
* @ Parameter
* - timer_no : 0~9
*
* @ Return
*
*
*
*********************************************************************************************************
*/
void TIMER_Stop (int timer_no)
{
TIMER_Type * timer;
//--------------------------------------------------------------------------------
// check timer_no
//--------------------------------------------------------------------------------
if ((timer_no < 0) || (timer_no > 9)) return;
//--------------------------------------------------------------------------------
// get object
//--------------------------------------------------------------------------------
timer = TIMER_Get_Object(timer_no);
//--------------------------------------------------------------------------------
// stop
//--------------------------------------------------------------------------------
timer->CMD = 0;
}
|
587347bd23e312abb01acf44ce21aa480f2e17f1
|
0410ed34e99bb467ea28358e9551ec284751871a
|
/c y c++/diccionario.c
|
a0c8376b52781e19b4edb569c36b591c12d6e3f8
|
[] |
no_license
|
ulisesrendon/practicandocplusplus
|
a9ff8f7b0e1d9f202af2a70252c6aedf467acb20
|
380bea9d78a3250b239b2db9ff2bd2081ce7fa13
|
refs/heads/main
| 2023-07-20T04:13:48.815981 | 2021-06-24T08:00:51 | 2021-06-24T08:00:51 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 3,671 |
c
|
diccionario.c
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void verPalabras();
int editarpalabra();
int buscarPalabra();
char *diccionario[9][2] = {
{
"c","C es un lenguaje de programación originalmente desarrollado por Dennis M. Ritchie entre 1969 y 1972 en los Laboratorios Bell,"
},
{
"php","PHP es un lenguaje de programación de uso general de código del lado del servidor originalmente diseñado para el desarrollo web de contenido dinámico."
},
{
"java","Java es un lenguaje de programación de propósito general, concurrente, orientado a objetos que fue diseñado específicamente para tener tan pocas dependencias de implementación como fuera posible."
},
{
"javaScript","JavaScriptes un lenguaje de programación interpretado, dialecto del estándar ECMAScript. Se define como orientado a objetos,3 basado en prototipos, imperativo, débilmente tipado y dinámico."
},
{
"c++","C++ es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al lenguaje de programación C mecanismos que permiten la manipulación de objetos."
},
{
"c#"," c# es un lenguaje de programación orientado a objetos desarrollado y estandarizado por Microsoft como parte de su plataforma .NET, que después fue aprobado como un estándar por la ECMA"
},
{
"ruby"," Ruby es un lenguaje de programación interpretado, reflexivo y orientado a objetos, creado por el programador japonés Yukihiro Matsumoto, quien comenzó a trabajar en Ruby en 1993, y lo presentó públicamente en 1995. "
},
{
"python","Python es un lenguaje de programación interpretado cuya filosofía hace hincapié en una sintaxis que favorezca un código legible"
},
{
".net","NET es un framework de Microsoft que hace un énfasis en la transparencia de redes, con independencia de plataforma de hardware y que permita un rápido desarrollo de aplicaciones."
}
};
char pal[20];
char edit[30];
int main(int argc, const char * argv[]) {
char palabra;
int n;
do{
printf("1.- Ver todas las palabras \n");
printf("2.- Buscar palabra \n");
printf("3.- Sustituir palabra \n");
scanf("%d",&n);
switch(n) {
case 1:
verPalabras();
break;
case 2:
buscarPalabra();
break;
case 3:
editarpalabra();
break;
default :
printf("Opcion no valida \n" );
}
getchar();
printf(" Desea seguir en este programa (s/n): ");
palabra = getchar();
getchar();
}while(palabra == 's');
return 0;
}
void verPalabras(){
int i;
for(i=0; diccionario[i][0]; i++)
printf("%d.- %s \n",i+1,diccionario[i][0] );
}
int editarpalabra(){
int i;
getchar();
printf("Que palabra quieres cambiar: ");
scanf("%s",pal);
printf("Por que palabra quiere sustituirla: ");
scanf("%s",edit);
for(i= 0; diccionario[i][0];i++)
if(!strcmp(diccionario[i][0],pal)){
diccionario[i][0] = edit;
return 1;
}
printf("Palabra no encontrada. \n ");
return 0;
}
int buscarPalabra(){
int i;
getchar();
printf("Que palabra quieres buscar: ");
scanf("%s",pal);
for(i= 0; diccionario[i][0];i++)
if(!strcmp(diccionario[i][0],pal)){
printf("%s \n",diccionario[i][1]);
return 1;
}
printf("Palabra no encontrada. \n ");
return 0;
}
|
67003f90a6bb0b4c649ba4c990f09566ebf854b7
|
9a157272eec19ec6bdd255e6861aa4bb24d106bb
|
/sources/dialogue/dialogue_kakashi.c
|
bd7f4a8b0474e695e5e5e98435bc7a65b951a38f
|
[] |
no_license
|
Lucsc/RPG
|
93226d7cc75ac812f0c35eb87e9d47c5b3fd959e
|
fe681ea19d1385a8dc2d3e6d3d6a5ad18e0f731a
|
refs/heads/main
| 2023-07-13T05:44:52.786256 | 2021-08-31T11:36:59 | 2021-08-31T11:36:59 | 401,672,299 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,776 |
c
|
dialogue_kakashi.c
|
/*
** EPITECH PROJECT, 2021
** rpg
** File description:
** dialogue_kakashi
*/
#include "struct.h"
#include "define.h"
#include "function.h"
static int check_dialogue(rpg_t *rpg)
{
if (rpg->dialogue.real_dialogue == 6 && rpg->quest.side_quest == 1 ||
rpg->dialogue.real_dialogue == 10 && rpg->quest.side_quest == 4 ||
rpg->dialogue.real_dialogue == 14 && rpg->quest.side_quest == 6)
return (1);
return (0);
}
void key_move(rpg_t *rpg)
{
if (sfKeyboard_isKeyPressed(sfKeyLeft) ||
sfKeyboard_isKeyPressed(sfKeyRight) ||
sfKeyboard_isKeyPressed(sfKeyDown) ||
sfKeyboard_isKeyPressed(sfKeyUp)) {
if (rpg->dialogue.speaking == 0)
rpg->dialogue.speaking = 1;
else
rpg->dialogue.speaking = 0;
if (rpg->dialogue.real_dialogue <= 13)
rpg->dialogue.real_dialogue++;
}
}
static void event_dialogue_kakashi(rpg_t *rpg, sfEvent event)
{
while (sfRenderWindow_pollEvent(rpg->win.window, &event)) {
if (event.type == sfEvtClosed || sfKeyboard_isKeyPressed(sfKeyN)) {
sfMusic_destroy(rpg->music.menu_mus);
sfMusic_destroy(rpg->music.pause_music);
sfMusic_destroy(rpg->music.peace_music);
sfRenderWindow_close(rpg->win.window);
}
key_move(rpg);
}
}
void dialogue_kakashi(rpg_t *rpg)
{
sfEvent event;
sfSprite_setPosition(rpg->dialogue.kakashi_sprt, (sfVector2f) {1400, 200});
sfRenderWindow_setView(rpg->win.window,
sfRenderWindow_getDefaultView(rpg->win.window));
while (sfRenderWindow_isOpen(rpg->win.window)) {
event_dialogue_kakashi(rpg, event);
if (check_dialogue(rpg) == 1)
break;
draw_dialogue_kakashi(rpg);
}
}
|
f62f58546daa00e3a940bdd0f52960d744e5775d
|
79b6f2e09c0dd5ddaf4c42afb1b2e76823f5fc65
|
/libs/libft/ft_printf/flags/flag_i.c
|
cdf6ea7d9d7d1f13c57bd2238ab76b65a776cc1d
|
[] |
no_license
|
frouinc/ft_ssl_md5
|
4bc81e0f3661668d289efb970f291110b258195c
|
b016a520dc438c2ef0a75f1d8d705b484a768264
|
refs/heads/master
| 2020-09-30T18:20:37.438685 | 2020-09-01T09:43:20 | 2020-09-01T09:43:20 | 227,346,360 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 977 |
c
|
flag_i.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* flag_i.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: cfrouin <cfrouin@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2020/06/18 13:55:57 by cfrouin #+# #+# */
/* Updated: 2020/06/18 13:56:22 by cfrouin ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
int flag_i(t_printf_data **data)
{
return (flag_d(data));
}
|
9852e52d22d13adb1d9fb8ed425b06bd85ba2da8
|
144fdeec6dec6ed22e702f8902f94d77ba0d6059
|
/tests/com.oracle.truffle.llvm.tests.libc/libc/malloc/primitive-arrays/float.c
|
c28dad0d3ca34d9be9663de30f1dcc4db9ec41db
|
[
"BSD-3-Clause",
"NCSA",
"MIT"
] |
permissive
|
pointhi/sulong
|
cb9dc61f54a113e988911f1e3654d6e5792c2859
|
5446c54d360f486f9e97590af5f466cf1f5cd1f7
|
refs/heads/master
| 2021-01-16T22:17:36.966183 | 2018-07-03T16:12:12 | 2018-07-03T16:12:12 | 67,107,046 | 1 | 1 | null | 2016-09-01T07:06:28 | 2016-09-01T07:06:28 | null |
UTF-8
|
C
| false | false | 146 |
c
|
float.c
|
#include <stdlib.h>
int main() {
volatile float *arr = malloc(10 * sizeof(float));
arr[5] = 1.3;
arr[4] = 4.8;
return arr[5] + arr[4];
}
|
20ea8aeca23325c711c3c97d49e7edd1924c6185
|
1021b15abb27c313219eac8c21afbcb9f2dfdb2b
|
/vice.h
|
fe894d5f17671730d7cf33e91fab0fc8e4a826c8
|
[] |
no_license
|
tj90241/irix-vice
|
025e37676d4c9abf0723657cf2ba6d1c0c004de7
|
72bee33e12bd0f075defea2639a8a700c426b4b9
|
refs/heads/master
| 2021-01-10T02:41:06.980308 | 2016-02-13T03:36:01 | 2016-02-13T03:36:04 | 51,632,819 | 3 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 792 |
h
|
vice.h
|
#ifndef VICE_H_
#define VICE_H_
#include <stdint.h>
struct vice {
int vice_fd;
uint8_t *regs;
};
/* VICE */
int vice_init(struct vice *vice);
void vice_deinit(struct vice *vice);
unsigned vice_get_revision(struct vice *vice);
/* VICE MSP */
#define VICE_MSP_CONTROL_RESET 0x0
#define VICE_MSP_CONTROL_GO 0x1
#define VICE_MSP_CONTROL_OPERATIONAL 0x2
uint32_t vice_msp_read_pc(struct vice *vice);
uint32_t vice_msp_read_status(struct vice *vice);
void vice_msp_reset(struct vice *vice);
void vice_msp_start(struct vice *vice, uint32_t pc);
void vice_msp_write_control(struct vice *vice, uint32_t control);
int vice_msp_iram_read(struct vice *vice, void *ptr, uint32_t offset, uint32_t len);
int vice_msp_iram_write(struct vice *vice, void *ptr, uint32_t offset, uint32_t len);
#endif
|
e93f7792516bb6d8b8a9f3e76c2df7f944cc2f66
|
b9835c91fcd2d5b7a6d79e4fb9b47daf13763a1a
|
/lib/src/BoxFramework/VEXTypes.H
|
981cca3245a1df37cfed7edeecd7519aad341c4c
|
[] |
no_license
|
drhandwerk/grad510
|
ea51e3a62fb83dc31fb4db72de8d6cde0c08b616
|
0867c010dff5a5a9acace0104c2bdf907a0d6399
|
refs/heads/master
| 2020-03-23T13:10:16.931745 | 2018-07-19T16:10:15 | 2018-07-19T16:10:15 | 141,603,468 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 6,680 |
h
|
VEXTypes.H
|
#ifndef _VEXTYPES_H_
#define _VEXTYPES_H_
/******************************************************************************/
/**
* \file VEXTypes.H
*
* \brief Types for vector extension operations
*
*//*+*************************************************************************/
/*******************************************************************************
*
* NOTATION
*
* Something more similar to GNU notation is used for labeling the typs and
* definitions defined herein.
*
* Intel notation
* ==============
*
* Floating point functions:
* _mm_add_xy()
* x : s - single value
* : p - packed (or vector)
* y : f - 32-bit floating point
* : d - 64-bit floating point
*
* Variables:
* _m128i - integer vector (signed or unsigned)
* _m128 - 32-bit floating point vector
* _m128d - 64-bit floating point vector
* _m256...
*
* GNU notation
* ============
*
* Floating point functions are similar to Intel
*
* Variables:
* vxyz
* x : 0-9 - number of scalars in a vector
* y : q - 8-bit
* : h - 16-bit
* : s - 32-bit
* : d - 64-bit
* z : i - integer (signed or unsigned)
* : f - floating point
*
* Chombo generalized notation
* ===========================
*
* v - (vector) the size of the register on the CPU (i.e., either 128 or 256
* bits)
* r - (real) either sf or df (see y for GNU notation) depending on if the
* code is compiled for 32-bit or 64-bit floating point numbers
*
* In generalized functions:
* _mm_yz(add) - y and z as defined for GNU notation. All function
* generalizations assume packed vectors. For scalar equivalents, you
* must explicitly call the appropriate vector intrinsic.
* _mm_r(add) - Using r to define sf or df
*
* In generalized variables:
* __mvr - a floating-point type, as defined by the build system, that
* fits in the vector register
* CHvr_t - union of __mvr to allow access to components
*
* Integers will not be generalized until AVX2 is commonplace
*
******************************************************************************/
#include <stdint.h>
#include "Config.H"
#ifdef CHDEF_SYSTEM_X86VECEXT_INTEL_H
#include CHDEF_SYSTEM_X86VECEXT_INTEL_H
#elif (CHDEF_SYSTEM_X86VECEXT_COMPILER_BITS & CHDEF_BIT_AVX)
#include CHDEF_SYSTEM_X86VECEXT_AVX_H
#elif (CHDEF_SYSTEM_X86VECEXT_COMPILER_BITS & CHDEF_BIT_SSE2)
#include CHDEF_SYSTEM_X86VECEXT_SSE2_H
#endif
/*--------------------------------------------------------------------*
* SSE2
*--------------------------------------------------------------------*/
#if (CHDEF_SYSTEM_X86VECEXT_COMPILER_BITS & CHDEF_BIT_SSE2)
//--128 bit
union CH128i32_t
{
__m128i m;
uint32_t u[4];
int32_t i[4];
};
union CH128i64_t
{
__m128i m;
uint64_t u[2];
int64_t i[2];
};
union CH128sf_t
{
__m128 m;
float f[4];
};
union CH128df_t
{
__m128d m;
double f[2];
};
#ifdef USE_SINGLE_PRECISION
typedef CH128i32_t CH128i_t; // Same size int as float
typedef CH128sf_t CH128r_t;
typedef __m128 __m128r;
#else
typedef CH128i64_t CH128i_t; // Same size int as float
typedef CH128df_t CH128r_t;
typedef __m128d __m128r;
#endif
#endif
/*--------------------------------------------------------------------*
* AVX
*--------------------------------------------------------------------*/
#if (CHDEF_SYSTEM_X86VECEXT_COMPILER_BITS & CHDEF_BIT_AVX)
//--256 bit
union CH256i32_t
{
__m256i m;
uint32_t u[8];
int32_t i[8];
};
union CH256i64_t
{
__m256i m;
uint64_t u[4];
int64_t i[4];
};
union CH256sf_t
{
__m256 m;
float f[8];
};
union CH256df_t
{
__m256d m;
double f[4];
};
#ifdef USE_SINGLE_PRECISION
typedef CH256i32_t CH256i_t; // Same size int as float
typedef CH256sf_t CH256r_t;
typedef __m256 __m256r;
#else
typedef CH256i64_t CH256i_t; // Same size int as float
typedef CH256df_t CH256r_t;
typedef __m256d __m256r;
#endif
#endif
/*==============================================================================
*
* Now define types independent of register size
*
* *** WARNING ***
*
* Integer types are *not* generalized because arithmetic is not supported
* unless AVX2 is available. I suggest using __m128i everywhere or using
* defines in the code until AVX2 is commonplace.
*
*============================================================================*/
//--256 bit registers
#if (CHDEF_SYSTEM_X86VECEXT_COMPILER_BITS & CHDEF_BIT_AVX)
// Alignement requirements for aligned loads/stores
#define CH_VECLS_ALIGN 32
#define VecSz_s 8
#define VecSz_d 4
#ifdef USE_SINGLE_PRECISION
#define VecSz_r 8
#else
#define VecSz_r 4
#endif
typedef CH256i_t CHvi_t; // Same size int as float
typedef CH256r_t CHvr_t;
typedef __m256r __mvr;
typedef __m256i __mvi;
//--128 bit registers
#elif (CHDEF_SYSTEM_X86VECEXT_COMPILER_BITS & CHDEF_BIT_SSE2)
// Alignement requirements for aligned loads/stores
#define CH_VECLS_ALIGN 16
#define VecSz_s 4
#define VecSz_d 2
#ifdef USE_SINGLE_PRECISION
#define VecSz_r 4
#else
#define VecSz_r 2
#endif
typedef CH128i_t CHvi_t; // Same size int as float
typedef CH128r_t CHvr_t;
typedef __m128r __mvr;
typedef __m128i __mvi;
#endif
/*==============================================================================
*
* Name macros
*
* *** WARNING ***
*
* Integer types are *not* generalized because arithmetic is not supported
* unless AVX2 is available. I suggest using __m128i everywhere or using
* defines in the code until AVX2 is commonplace.
*
*============================================================================*/
#if (CHDEF_SYSTEM_X86VECEXT_COMPILER_BITS & CHDEF_BIT_AVX)
#define _mm_i8(x) _mm256_ ## x ## _epi8
#define _mm_i16(x) _mm256_ ## x ## _epi16
#define _mm_i32(x) _mm256_ ## x ## _epi32
#define _mm_i64(x) _mm256_ ## x ## _epi64
#define _mm_si(x) _mm256_ ## x ## _si256
#define _mm_sf(x) _mm256_ ## x ## _ps
#define _mm_df(x) _mm256_ ## x ## _pd
#ifdef USE_SINGLE_PRECISION
#define _mm_vr(x) _mm256_ ## x ## _ps
#else // DOUBLE
#define _mm_vr(x) _mm256_ ## x ## _pd
#endif
#else
#define _mm_i8(x) _mm_ ## x ## _epi8
#define _mm_i16(x) _mm_ ## x ## _epi16
#define _mm_i32(x) _mm_ ## x ## _epi32
#define _mm_i64(x) _mm_ ## x ## _epi64
#define _mm_si(x) _mm_ ## x ## _si128
#define _mm_sf(x) _mm_ ## x ## _ps
#define _mm_df(x) _mm_ ## x ## _pd
#ifdef USE_SINGLE_PRECISION
#define _mm_vr(x) _mm_ ## x ## _ps
#else // DOUBLE
#define _mm_vr(x) _mm_ ## x ## _pd
#endif
#endif
#endif /* ! defined _VEXTYPES_H_ */
|
38f2803294d2dcb55777edbb4d04754482137995
|
441d233eeb4ba1fa33032e554f8d4d4c8fe2ebaa
|
/srcs/ft_assstart.c
|
bff5afcb6918b41fa1cf02b7ed346ca2025f01d5
|
[] |
no_license
|
TalPat/lem-in
|
312061728c70c0f3673348abd5f581121490cbe8
|
91851c6c3a201729d7d2ef58e798a6f4bbab6cb6
|
refs/heads/master
| 2020-03-24T23:22:41.594076 | 2018-08-09T15:01:30 | 2018-08-09T15:01:30 | 143,130,883 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,709 |
c
|
ft_assstart.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_assstart.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tpatter <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/08/03 13:04:08 by tpatter #+# #+# */
/* Updated: 2018/08/08 14:16:15 by tpatter ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft.h"
#include "lem_in.h"
#include <stdlib.h>
int ft_numstarts(t_list *map)
{
int count;
t_list *tmp;
count = 0;
tmp = map;
while (tmp)
{
if (!ft_strcmp(tmp->content, "##start"))
count++;
tmp = tmp->next;
}
return (count);
}
void ft_assandrem(t_lem *lem)
{
t_list *tmp;
t_list *prev;
tmp = lem->map;
while (tmp)
{
if (!ft_strcmp(tmp->content, "##start"))
{
ft_lstremove(tmp, prev, lem);
tmp = tmp->next;
if (ft_validroom(tmp->content))
lem->start = ft_strdup(tmp->content);
else
{
lem->start = NULL;
lem->err = 1;
}
}
prev = tmp;
tmp = tmp->next;
}
}
void ft_assstart(t_lem *lem)
{
int numstarts;
numstarts = ft_numstarts(lem->map);
if (numstarts != 1)
{
lem->err = 1;
lem->start = NULL;
}
else
{
ft_assandrem(lem);
}
}
|
d662c7786cc60fbd7bfd7eef6c5543b60d6ce377
|
e2b1bc9ce21f51a2c81cefcdf9314f9f4a2d6db9
|
/TestCustomBorder/stdafx.h
|
af5a3c7959fa508df6b9a1658591e8d7771aa96f
|
[] |
no_license
|
tongko/CSharpCustomBorderForm
|
af1af986da1829e4c9d8d262620cb6ff3d9e4644
|
f9293e394f5c9808eac7110ca403874c3e1beffa
|
refs/heads/master
| 2021-01-16T17:47:40.878727 | 2014-03-12T11:59:44 | 2014-03-12T11:59:44 | 16,683,918 | 2 | 1 | null | null | null | null |
UTF-8
|
C
| false | false | 953 |
h
|
stdafx.h
|
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//
#pragma once
#pragma comment(lib, "dwmapi.lib")
#pragma comment(lib, "UxTheme.lib")
#include "targetver.h"
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
// Windows Header Files:
#include <windows.h>
// C RunTime Header Files
#include <dwmapi.h>
#include <Uxtheme.h>
#include <vssym32.h>
#include <windowsx.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>
#include <strsafe.h>
// TODO: reference additional headers your program requires here
#include "Resource.h"
#include "NativeWnd.h"
//#include "SkinWindow.h"
#define RECTWIDTH(x) (x.right - x.left)
#define RECTHEIGHT(y) (y.bottom - y.top)
#define LEFTEXTENDWIDTH 8
#define RIGHTEXTENDWIDTH 8
#define TOPEXTENDWIDTH 27
#define BOTTOMEXTENDWIDTH 20
|
d6274231e08d1820ebac121e5193b94769fe4f4c
|
8950915dc50cb6a0ba72d1a321e17cce963b8db7
|
/nbody2/tests/test_vec3.c
|
bfeffbe51bf76fb5d6509dcb4a9cc28c0fff83f5
|
[] |
no_license
|
tmalthouse/nbody2
|
beaaa0bfa99516f5691810d9d5ce0a243700bb1e
|
4fa7795c2c16e0ad3a1f2eeec4f0ba2adc113265
|
refs/heads/master
| 2021-01-21T15:26:46.371951 | 2017-08-24T23:45:43 | 2017-08-24T23:45:43 | 91,843,057 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 2,734 |
c
|
test_vec3.c
|
//
// test_vec3.c
// nbody2
//
// Created by Thomas Malthouse on 6/6/17.
// Copyright © 2017 Thomas Malthouse. All rights reserved.
//
#include "test_vec3.h"
#include <time.h>
#include <stdlib.h>
#include <sys/types.h>
#ifndef __APPLE__
#include <bsd/stdlib.h>
#endif
extern const char *current_test_func;
#define FLOAT_TOL (0.05)
#define INIT_TEST current_test_func = __FUNCTION__; printf("Testing %s:\n", current_test_func);
bool test_vec3_eq() {
INIT_TEST;
int status = 0;
status += !vec3_eq(vec3_0, vec3_0);
status += vec3_eq(vec3_0, vec3_I);
return !status;
}
bool test_vabs() {
INIT_TEST;
int status = 0;
status += !(vabs(vec3_I) - 1 < FLOAT_TOL);
status += !(vabs((vec3){3.0,4.0,0.0}) - 5 < FLOAT_TOL);
return !status;
}
bool test_inv_vabs() {
INIT_TEST;
int status = 0;
status += inv_vabs((vec3){4,0,0}) - 0.5 > FLOAT_TOL;
status += inv_vabs((vec3) {3,4,0}) - 0.2 > FLOAT_TOL;
return !status;
}
static int rand_sint() {
int sign = rand()%2?1:-1;
return sign * arc4random();
}
bool test_fastinvsqrt() {
INIT_TEST;
int status = 0;
status += fabs(fastinvsqrt(4)-0.5) > FLOAT_TOL;
status += fabs(fastinvsqrt(1)-1) > FLOAT_TOL;
status += fabs(fastinvsqrt(100) - 0.1) > FLOAT_TOL;
status += fabs(fastinvsqrt(0.25) - 2) > FLOAT_TOL;
double avg_diff = 0;
for (uint i=0; i<5000; i++) {
double x = arc4random_uniform(2<<16);
double diff = fabs(fastsqrt(x) - sqrt(x));
status += diff > FLOAT_TOL;
avg_diff += diff * (1.0/5000.0);
}
printf("Avg error: %.12f\n", avg_diff);
return !status;
}
time_t benchmark_vec3_normalize() {
puts("Beginning normalization benchmark...");
int count = 100000000;
srand((uint)time(NULL));
vec3 *vecs = malloc(sizeof(vec3) * count);
vec3 *nrms = malloc(sizeof(vec3) * count);
for (uint i=0; i<count; i++) {
vecs[i] = (vec3){rand_sint(),rand_sint(),rand_sint()};
}
printf("Created %'d vectors.\n", count);
clock_t start = clock();
for (uint i=0; i<count; i++) {
nrms[i] = vec3_normalize(vecs[i]);
}
clock_t diff = clock() - start;
double t = 1000*(double)diff/CLOCKS_PER_SEC;
printf("Time to normalize %'d vectors: %f ms\n", count, t);
printf("Time per vector: %u ns\n", (uint)(t*1000000/count));
puts("Verifying accuracy:");
int status = 0;
for (uint i=0; i<count; i++) {
status += fabs(vabs(nrms[i])-1)>FLOAT_TOL;
}
printf("%'d vectors normalized incorrectly.\n", status);
return diff;
}
void grapherthing() {
FILE *f = fopen("/Users/Thomas/Desktop/graph.csv", "w");
for (uint i=0; i<100000; i+=10) {
fprintf(f,"%d, %f\n\n", i, vabs(vec3_normalize((vec3)(i))));
}
fclose(f);
}
|
d255784e8e31b5178cc173650898aae1ad5c7390
|
2d7a043238e7f699ee8e97d23860b1591b99ee7b
|
/test/plugins/cadence/opus_dec/opus_header.h
|
b631fae7dbbaf5430d7da9ffadaf9957936986cb
|
[
"MIT"
] |
permissive
|
liuwenye2010/xaf-hostless
|
7a9b44036d5fc303ea91a002444923a49ce022ec
|
0e0b68db0593a91f92c8591558672ac1875df687
|
refs/heads/master
| 2023-07-17T04:46:02.848795 | 2021-08-31T17:56:25 | 2021-08-31T18:01:05 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 3,256 |
h
|
opus_header.h
|
/*
* Copyright (c) 2015-2021 Cadence Design Systems Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
/* Copyright (C)2012 Xiph.Org Foundation
File: opus_header.h
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 FOUNDATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef OPUS_HEADER_H
#define OPUS_HEADER_H
//#include <ogg/ogg.h>
#if !defined(ogg_uint32_t)
typedef unsigned int ogg_uint32_t;
#endif
#if !defined(ogg_uint16_t)
typedef unsigned short ogg_uint16_t;
#endif
typedef struct {
int version;
int channels; /* Number of channels: 1..255 */
int preskip;
ogg_uint32_t input_sample_rate;
int gain; /* in dB S7.8 should be zero whenever possible */
int channel_mapping;
/* The rest is only used if channel_mapping != 0 */
int nb_streams;
int nb_coupled;
unsigned char stream_map[255];
} OpusHeader;
int opus_header_parse(const unsigned char *header, int len, OpusHeader *h);
int opus_header_to_packet(const OpusHeader *h, unsigned char *packet, int len);
extern const int wav_permute_matrix[8][8];
#endif
|
4ed985a4e0a9ef3bab3efc3127814c09b0608eb6
|
3feadb11bad5a3484c7d94b623013371d37faf4d
|
/sys/sys/idt.c
|
271e34580a8459284d54cdbf648db564023e7a6a
|
[] |
no_license
|
cwolsen7905/UbixOS
|
c08cd212ee56b9c950dbd5f0cdbba1410bf34ab7
|
2f6063103347a8e8c369aacdd1399911bb4a4776
|
refs/heads/master
| 2022-04-15T02:52:02.720317 | 2020-04-17T18:09:58 | 2020-04-17T18:09:58 | 256,574,503 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 21,685 |
c
|
idt.c
|
/*-
* Copyright (c) 2002-2018 The UbixOS Project.
* All rights reserved.
*
* This was developed by Christopher W. Olsen for the UbixOS Project.
*
* 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, the following disclaimer and the list of authors.
* 2) Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions, the following disclaimer and the list of authors in the documentation and/or
* other materials provided with the distribution.
* 3) Neither the name of the UbixOS Project nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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.
*/
#include <ubixos/syscall.h>
#include <ubixos/syscall_posix.h>
#include <sys/idt.h>
#include <sys/gdt.h>
#include <sys/io.h>
#include <ubixos/sched.h>
#include <isa/8259.h>
#include <lib/kprintf.h>
#include <lib/kmalloc.h>
#include <vmm/vmm.h>
#include <ubixos/kpanic.h>
#include <ubixos/endtask.h>
#include <string.h>
#include <sys/trap.h>
#define FP_TO_LINEAR(seg, off) ((void*) ((((uint16_t) (seg)) << 4) + ((uint16_t) (off))))
static uint32_t gpfStack = 0x0;
void intNull();
void _divideError();
void __divideError(struct trapframe *);
void _debug();
void __debug(struct trapframe *);
void _nmi();
void __nmi(struct trapframe *);
static void _int3();
static void _int4();
static void _int5();
static void _int6();
static void _int7();
void _doubleFault();
void __doubleFault(struct trapframe *);
static void _int9();
static void _int10();
static void _int11();
static void _int12();
void _gpf();
void __gpf(struct trapframe *);
void _floatingPoint();
void __floatingPoint(struct trapframe *);
void _alignmentCheck();
void __alignmentCheck(struct trapframe *);
void _machineCheck();
void __machineCheck(struct trapframe *);
void _simd();
void __simd(struct trapframe *);
void _virtualization();
void __virtualization(struct trapframe *);
void _security();
void __security(struct trapframe *);
static ubixDescriptorTable(ubixIDT, 256) {};
static struct {
unsigned short limit __attribute__((packed));
union descriptorTableUnion *idt __attribute__((packed));
} loadidt = { (256 * sizeof(union descriptorTableUnion) - 1), ubixIDT };
/************************************************************************
Function: int idtInit()
Description: This function is used to enable our IDT subsystem
Notes:
02/20/2004 - Approved for quality
************************************************************************/
int idt_init() {
struct tssStruct *sfTSS = (struct tssStruct *) 0x6200;
struct tssStruct *gpfTSS = (struct tssStruct *) 0x5200;
/* Load the IDT into the system */
asm volatile(
"cli \n"
"lidt (%0) \n" /* Load the IDT */
"pushfl \n" /* Clear the NT flag */
"andl $0xffffbfff,(%%esp) \n"
"popfl \n"
"sti \n"
:
: "r" ((char *)&loadidt)
);
for (int i = 0;i < 256;i++)
setVector(intNull, i, dPresent + dTrap + dDpl3);
/* Set up the basic vectors for the reserved ints */
setVector(_divideError, 0, dPresent + dInt + dDpl0);
setVector(_debug, 1, dPresent + dInt + dDpl0);
setVector(_nmi, 2, dPresent + dInt + dDpl0);
setVector(_int3, 3, dPresent + dInt + dDpl0);
setVector(_int4, 4, dPresent + dInt + dDpl0);
setVector(_int5, 5, dPresent + dInt + dDpl0);
setVector(_int6, 6, dPresent + dTrap + dDpl0);
setVector(_int7, 7, dPresent + dInt + dDpl0);
setVector(_doubleFault, 8, dPresent + dInt + dDpl0);
//setTaskVector(8, dPresent + dTask + dDpl0, 0x40);
setVector(_int9, 9, dPresent + dInt + dDpl0);
setVector(_int10, 10, dPresent + dInt + dDpl0);
setVector(_int11, 11, dPresent + dInt + dDpl0);
setVector(_int12, 12, dPresent + dInt + dDpl0);
//setVector(_gpf, 13, dPresent + dInt + dDpl0);
setTaskVector(13, dPresent + dTask + dDpl0, 0x38);
setVector(_vmm_pageFault, 14, dPresent + dInt + dDpl0);
setVector(_floatingPoint, 16, dPresent + dInt + dDpl0);
setVector(_alignmentCheck, 17, dPresent + dInt + dDpl0);
setVector(_machineCheck, 18, dPresent + dInt + dDpl0);
setVector(_simd, 19, dPresent + dInt + dDpl0);
setVector(_virtualization, 20, dPresent + dInt + dDpl0);
setVector(_security, 30, dPresent + dInt + dDpl0);
setVector(_sys_call_posix, 0x80, dPresent + dTrap + dDpl3);
setVector(_sys_call, 0x81, dPresent + dTrap + dDpl3);
setVector(timerInt, 0x68, (dInt + dPresent + dDpl0));
memset(gpfTSS, 0x0, sizeof(struct tssStruct));
gpfStack = 0x1D000;//(uint32_t)vmm_getFreeKernelPage(sysID, 1) + (PAGE_SIZE - 0x4);
gpfTSS->back_link = 0x0;
gpfTSS->esp0 = 0x0;
gpfTSS->ss0 = 0x0;
gpfTSS->esp1 = 0x0;
gpfTSS->ss1 = 0x0;
gpfTSS->esp2 = 0x0;
gpfTSS->ss2 = 0x0;
gpfTSS->cr3 = (unsigned int) kernelPageDirectory;
gpfTSS->eip = (unsigned int) &_gpf;
gpfTSS->eflags = 0x206;
gpfTSS->esp = gpfStack; //0x1D000;
gpfTSS->ebp = 0x0; // 0x1D000;
gpfTSS->esi = 0x0;
gpfTSS->edi = 0x0;
gpfTSS->es = 0x10;
gpfTSS->cs = 0x08;
gpfTSS->ss = 0x10;
gpfTSS->ds = 0x10;
gpfTSS->fs = 0x10;
gpfTSS->gs = 0x10;
gpfTSS->ldt = 0x0;
gpfTSS->trace_bitmap = 0x0000;
gpfTSS->io_map = 0x8000;
/*
memset(sfTSS, 0x0, sizeof(struct tssStruct));
sfTSS->cr3 = (unsigned int) kernelPageDirectory;
sfTSS->eip = (unsigned int) &__int8;
sfTSS->eflags = 0x206;
sfTSS->esp = 0x1C000;
sfTSS->ebp = 0x1C000;
sfTSS->es = 0x10;
sfTSS->cs = 0x08;
sfTSS->ss = 0x10;
sfTSS->ds = 0x10;
sfTSS->fs = 0x10;
sfTSS->gs = 0x10;
sfTSS->io_map = 0x8000;
*/
/* Print out information for the IDT */
kprintf("idt0 - Address: [0x%X]\n", &ubixIDT);
/* Return so we know all went well */
return (0x0);
}
/* Sets Up IDT Vector */
void setVector(void *handler, unsigned char interrupt, unsigned short controlMajor) {
unsigned short codesegment = 0x08;
asm volatile ("movw %%cs,%0":"=g" (codesegment));
ubixIDT[interrupt].gate.offsetLow = (unsigned short) (((unsigned long) handler) & 0xffff);
ubixIDT[interrupt].gate.selector = codesegment;
ubixIDT[interrupt].gate.access = controlMajor;
ubixIDT[interrupt].gate.offsetHigh = (unsigned short) (((unsigned long) handler) >> 16);
}
/************************************************************************
Function: void setTaskVector(uInt8,uInt16,uInt8);
Description: This Function Sets Up An IDT Task Vector
Notes:
************************************************************************/
void setTaskVector(uInt8 interrupt, uInt16 controlMajor, uInt8 selector) {
uInt16 codesegment = 0x08;
asm volatile ("movw %%cs,%0":"=g" (codesegment));
ubixIDT[interrupt].gate.offsetLow = 0x0;
ubixIDT[interrupt].gate.selector = selector;
ubixIDT[interrupt].gate.access = controlMajor;
ubixIDT[interrupt].gate.offsetHigh = 0x0;
}
/* Null Intterupt Descriptor */
void _intNull(struct trapframe *frame) {
die_if_kernel("invalid exception", frame, 0x0);
}
asm(
".globl intNull \n"
"intNull: \n"
" pushl $0x0 \n"
" pushl $0x0 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call _intNull \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n"
);
void __divideError(struct trapframe *frame) {
die_if_kernel("Divid-by-Zero", frame, 0);
endTask(_current->id);
sched_yield();
}
asm(
".globl _divideError \n"
"_divideError: \n"
" pushl $0x0 \n"
" pushl $0x6 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call _divideError \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n"
);
void __debug(struct trapframe *frame) {
die_if_kernel("debug", frame, 0x2);
endTask(_current->id);
sched_yield();
}
asm(
".globl _debug \n"
"_debug: \n"
" pushl $0x0 \n"
" pushl $0x6 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call _debug \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n"
);
void __nmi(struct trapframe *frame) {
die_if_kernel("nmi", frame, 0x2);
endTask(_current->id);
sched_yield();
}
asm(
".globl _nmi \n"
"_nmi: \n"
" pushl $0x0 \n"
" pushl $0x6 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call _nmi \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n"
);
static void _int3() {
kpanic("int3: Breakpoint [%i]\n", _current->id);
endTask(_current->id);
sched_yield();
}
static void _int4() {
kpanic("int4: Overflow [%i]\n", _current->id);
endTask(_current->id);
sched_yield();
}
static void _int5() {
kpanic("int5: Bounds check [%i]\n", _current->id);
endTask(_current->id);
sched_yield();
}
void __int6(struct trapframe *frame) {
die_if_kernel("invalid_opcode", frame, 6);
endTask(_current->id);
sched_yield();
}
asm(
".globl _int6 \n"
"_int6: \n"
" pushl $0x0 \n"
" pushl $0x6 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call __int6 \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n" /* Exit interrupt */
);
void __doubleFault(struct trapframe *frame) {
die_if_kernel("double fault", frame, 0x8);
endTask(_current->id);
sched_yield();
}
asm(
".globl _doubleFault \n"
"_doubleFault: \n"
" pushl $0x8 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call __doubleFault \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n" /* Exit interrupt */
);
static void _int9() {
kpanic("int9: Coprocessor Segment Overrun! [%i]\n", _current->id);
endTask(_current->id);
sched_yield();
}
static void _int10() {
kpanic("int10: Invalid TSS! [%i]\n", _current->id);
endTask(_current->id);
sched_yield();
}
static void _int11() {
kpanic("int11: Segment Not Present! [%i]\n", _current->id);
endTask(_current->id);
sched_yield();
}
static void _int12() {
kpanic("int12: Stack-Segment Fault! [%i]\n", _current->id);
endTask(_current->id);
sched_yield();
}
void __gpf(struct trapframe *frame) {
uint8_t *ip = 0x0;
uint16_t *stack = 0x0, *ivt = 0x0;
uint32_t *stack32 = 0x0;
bool isOperand32 = FALSE, isAddress32 = FALSE;
struct tssStruct *gpfTSS = (struct tssStruct *) 0x5200;
gpfEnter:
kprintf("DF");
ip = FP_TO_LINEAR(_current->tss.cs, _current->tss.eip);
ivt = (uint16_t *) 0x0;
stack = (uint16_t *) FP_TO_LINEAR(_current->tss.ss, _current->tss.esp);
stack32 = (uint32_t *) stack;
gpfStart: switch (ip[0]) {
case 0xCD: /* INT n */
switch (ip[1]) {
case 0x69:
kprintf("Exit Bios [0x%X]\n", _current->id);
//while (1) asm("hlt");
_current->state = DEAD;
break;
case 0x20:
case 0x21:
kpanic("GPF OP 0x20/0x21\n");
break;
default:
stack -= 3;
_current->tss.esp = ((_current->tss.esp & 0xffff) - 6) & 0xffff;
stack[0] = (uint16_t) (_current->tss.eip + 2);
stack[1] = _current->tss.cs;
stack[2] = (uint16_t) _current->tss.eflags;
if (_current->oInfo.v86If)
stack[2] |= EFLAG_IF;
else
stack[2] &= ~EFLAG_IF;
_current->tss.cs = ivt[ip[1] * 2 + 1] & 0xFFFF;
_current->tss.eip = ivt[ip[1] * 2] & 0xFFFF;
break;
}
break;
case 0x66:
isOperand32 = TRUE;
ip++;
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
kprintf("0x66");
goto gpfStart;
break;
case 0x67:
isAddress32 = TRUE;
ip++;
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
kprintf("0x67");
goto gpfStart;
break;
case 0xF0:
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
kpanic("GPF OP 0xF0\n");
break;
case 0x9C:
if (isOperand32 == TRUE) {
_current->tss.esp = ((_current->tss.esp & 0xffff) - 4) & 0xffff;
stack32--;
stack32[0] = _current->tss.eflags & 0xDFF;
if (_current->oInfo.v86If == TRUE)
stack32[0] |= EFLAG_IF;
else
stack32[0] &= ~EFLAG_IF;
}
else {
_current->tss.esp = ((_current->tss.esp & 0xffff) - 2) & 0xffff;
stack--;
stack[0] = (uInt16) _current->tss.eflags;
if (_current->oInfo.v86If == TRUE)
stack[0] |= EFLAG_IF;
else
stack[0] &= ~EFLAG_IF;
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
}
break;
case 0x9D:
if (isOperand32 == TRUE) {
_current->tss.eflags = EFLAG_IF | EFLAG_VM | (stack32[0] & 0xDFF);
_current->oInfo.v86If = (stack32[0] & EFLAG_IF) != 0;
_current->tss.esp = ((_current->tss.esp & 0xffff) + 4) & 0xffff;
}
else {
_current->tss.eflags = EFLAG_IF | EFLAG_VM | stack[0];
_current->oInfo.v86If = (stack[0] & EFLAG_IF) != 0;
_current->tss.esp = ((_current->tss.esp & 0xffff) + 2) & 0xffff;
}
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
/* kprintf("popf [0x%X]\n",_current->id); */
break;
case 0xFA:
_current->oInfo.v86If = FALSE;
_current->tss.eflags &= ~EFLAG_IF;
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
_current->oInfo.timer = 0x1;
break;
case 0xFB:
_current->oInfo.v86If = TRUE;
_current->tss.eflags |= EFLAG_IF;
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
_current->oInfo.timer = 0x0;
/* kprintf("sti [0x%X]\n",_current->id); */
break;
case 0xCF:
_current->tss.eip = stack[0];
_current->tss.cs = stack[1];
_current->tss.eflags = EFLAG_IF | EFLAG_VM | stack[2];
_current->oInfo.v86If = (stack[2] & EFLAG_IF) != 0;
_current->tss.esp = ((_current->tss.esp & 0xffff) + 6) & 0xffff;
kprintf("iret [0x%X]\n",_current->id);
break;
case 0xEC: /* IN AL,DX */
_current->tss.eax = (_current->tss.eax & ~0xFF) | inportByte(_current->tss.edx);
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
break;
case 0xED: /* IN AX,DX */
_current->tss.eax = (_current->tss.eax & ~0xFFFF) | inportWord(_current->tss.edx);
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
break;
case 0xEE: /* OUT DX,AL */
outportByte(_current->tss.edx, _current->tss.eax & 0xFF);
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
break;
case 0xEF:
outportWord(_current->tss.edx, _current->tss.eax);
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
break;
case 0xF4:
_current->tss.eip = (uInt16) (_current->tss.eip + 1);
break;
default: /* something wrong */
kprintf("NonHandled OpCode [0x%X:0x%X]\n", _current->id, ip[0]);
//_current->state = DEAD;
break;
}
kprintf("RET1");
irqEnable(0);
sched_yield();
kprintf("RET2");
goto gpfEnter;
}
asm(
".globl _gpf \n"
"_gpf: \n"
" cli \n"
" pushl $0x13 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call __gpf \n"
" add $0x4,%esp \n"
" mov %esp,%eax \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" sti \n"
" iret \n" /* Exit interrupt */
);
void __floatingPoint(struct trapframe *frame) {
die_if_kernel("floating point", frame, 0x10);
endTask(_current->id);
sched_yield();
}
asm(
".globl _floatingPoint \n"
"_floatingPoint: \n"
" pushl $0x0 \n"
" pushl $0x10 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call __floatingPoint \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n"
);
void __alignmentCheck(struct trapframe *frame) {
die_if_kernel("alignment check", frame, 0x11);
endTask(_current->id);
sched_yield();
}
asm(
".globl _alignmentCheck \n"
"_alignmentCheck: \n"
" pushl $0x11 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call __alignmentCheck \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n"
);
void __machineCheck(struct trapframe *frame) {
die_if_kernel("machine check", frame, 0x12);
endTask(_current->id);
sched_yield();
}
asm(
".globl _machineCheck \n"
"_machineCheck: \n"
" pushl $0x0\n"
" pushl $0x12 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call __machineCheck \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n"
);
void __simd(struct trapframe *frame) {
die_if_kernel("simd", frame, 0x13);
endTask(_current->id);
sched_yield();
}
asm(
".globl _simd \n"
"_simd: \n"
" iret\n"
" pushl $0x0\n"
" pushl $0x13 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call __simd \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n"
);
void __virtualization(struct trapframe *frame) {
die_if_kernel("virtualization", frame, 0x14);
endTask(_current->id);
sched_yield();
}
asm(
".globl _virtualization \n"
"_virtualization: \n"
" pushl $0x0 \n"
" pushl $0x14 \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call __virtualization \n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n"
);
void __security(struct trapframe *frame) {
die_if_kernel("security exception", frame, 0x1E);
endTask(_current->id);
sched_yield();
}
asm(
".globl _security \n"
"_security: \n"
" pushl $0x1E \n"
" pushal \n" /* Save all registers */
" push %ds \n"
" push %es \n"
" push %fs \n"
" push %gs \n"
" push %esp \n"
" call __security\n"
" pop %gs \n"
" pop %fs \n"
" pop %es \n"
" pop %ds \n"
" popal \n"
" iret \n"
);
/* Removed static however this is the only place it's called from */
void mathStateRestore() {
if (_usedMath != 0x0) {
asm(
"fnsave %0"
:
: "m" (_usedMath->i387)
);
}
if (_current->usedMath != 0x0) {
asm(
"frstor %0"
:
: "m" (_current->i387)
);
}
else {
asm("fninit");
_current->usedMath = 0x1;
}
_usedMath = _current;
//Return
}
asm(
".globl _int7 \n"
"_int7: \n"
" pushl %eax \n"
" clts \n"
" movl _current,%eax \n"
" cmpl _usedMath,%eax \n"
" je mathDone \n"
" call mathStateRestore \n"
"mathDone: \n"
" popl %eax \n"
" iret \n"
);
|
8f7bdd295367b4b996a059474e781ea5c1065887
|
fd0c132f979ecd77168511c6f4d276c480147e57
|
/ios/Classes/Native/mscorlib_System_Collections_Generic_List_1_Enumera2453438371MethodDeclarations.h
|
754adfb7037e8067cd2543b253a5629026389553
|
[] |
no_license
|
ping203/gb
|
9a4ab562cc6e50145660d2499f860e07a0b6e592
|
e1f69a097928c367042192619183d7445de90d85
|
refs/heads/master
| 2020-04-23T02:29:53.957543 | 2017-02-17T10:33:25 | 2017-02-17T10:33:25 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 2,395 |
h
|
mscorlib_System_Collections_Generic_List_1_Enumera2453438371MethodDeclarations.h
|
#pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include <assert.h>
#include <exception>
#include "codegen/il2cpp-codegen.h"
#include "mscorlib_System_Collections_Generic_List_1_Enumera1593300101MethodDeclarations.h"
// System.Void System.Collections.Generic.List`1/Enumerator<SettingItem>::.ctor(System.Collections.Generic.List`1<T>)
#define Enumerator__ctor_m1253662546(__this, ___l0, method) (( void (*) (Enumerator_t2453438371 *, List_1_t2918708697 *, const MethodInfo*))Enumerator__ctor_m3769601633_gshared)(__this, ___l0, method)
// System.Void System.Collections.Generic.List`1/Enumerator<SettingItem>::System.Collections.IEnumerator.Reset()
#define Enumerator_System_Collections_IEnumerator_Reset_m2554277464(__this, method) (( void (*) (Enumerator_t2453438371 *, const MethodInfo*))Enumerator_System_Collections_IEnumerator_Reset_m3440386353_gshared)(__this, method)
// System.Object System.Collections.Generic.List`1/Enumerator<SettingItem>::System.Collections.IEnumerator.get_Current()
#define Enumerator_System_Collections_IEnumerator_get_Current_m1368364808(__this, method) (( Il2CppObject * (*) (Enumerator_t2453438371 *, const MethodInfo*))Enumerator_System_Collections_IEnumerator_get_Current_m2853089017_gshared)(__this, method)
// System.Void System.Collections.Generic.List`1/Enumerator<SettingItem>::Dispose()
#define Enumerator_Dispose_m3423421925(__this, method) (( void (*) (Enumerator_t2453438371 *, const MethodInfo*))Enumerator_Dispose_m3736175406_gshared)(__this, method)
// System.Void System.Collections.Generic.List`1/Enumerator<SettingItem>::VerifyState()
#define Enumerator_VerifyState_m809924448(__this, method) (( void (*) (Enumerator_t2453438371 *, const MethodInfo*))Enumerator_VerifyState_m825848279_gshared)(__this, method)
// System.Boolean System.Collections.Generic.List`1/Enumerator<SettingItem>::MoveNext()
#define Enumerator_MoveNext_m40152340(__this, method) (( bool (*) (Enumerator_t2453438371 *, const MethodInfo*))Enumerator_MoveNext_m3604048390_gshared)(__this, method)
// T System.Collections.Generic.List`1/Enumerator<SettingItem>::get_Current()
#define Enumerator_get_Current_m2706507917(__this, method) (( SettingItem_t3549587565 * (*) (Enumerator_t2453438371 *, const MethodInfo*))Enumerator_get_Current_m4242858252_gshared)(__this, method)
|
c857a0f74b612e344bea759ddc24a6a55f08f7d7
|
1cdaf2d7e9ff154efa3025e48f68a2ca64d48a83
|
/src/event_cam.c
|
19c84c5e665bb27ac4d05a5bbb47c3f0ced9918c
|
[] |
no_license
|
missmaelyss/rtv1
|
8b22814722e480f82af0d214ea64e632536f488b
|
f551d955e69dc4d6f82d0e649409edad1626b699
|
refs/heads/master
| 2021-06-15T22:53:18.151602 | 2020-06-02T14:55:57 | 2020-06-02T14:55:57 | 92,851,856 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 2,172 |
c
|
event_cam.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* event_cam.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ele-cren <ele-cren@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/07/26 10:27:33 by ele-cren #+# #+# */
/* Updated: 2017/07/26 14:43:27 by ele-cren ### ########.fr */
/* */
/* ************************************************************************** */
#include <rt.h>
static void ft_event_cam_dub(t_env *env)
{
if (env->sdl.event.key.keysym.sym == SDLK_w)
{
env->cam.pos.y += env->cam.inc;
SDL_DestroyTexture(env->sdl.draw);
ft_browse_pixels(env);
}
if (env->sdl.event.key.keysym.sym == SDLK_SPACE)
{
env->cam.pos.z += env->cam.inc;
SDL_DestroyTexture(env->sdl.draw);
ft_browse_pixels(env);
}
if (env->sdl.event.key.keysym.sym == SDLK_LCTRL)
{
env->cam.pos.z -= env->cam.inc;
SDL_DestroyTexture(env->sdl.draw);
ft_browse_pixels(env);
}
}
void ft_event_cam_rlf(t_env *env)
{
if (env->sdl.event.key.keysym.sym == SDLK_KP_PLUS)
env->cam.inc += 2;
if (env->sdl.event.key.keysym.sym == SDLK_KP_MINUS)
env->cam.inc -= 2;
if (env->sdl.event.key.keysym.sym == SDLK_KP_MINUS)
env->cam.inc = (env->cam.inc < 10) ? 10 : env->cam.inc;
if (env->sdl.event.key.keysym.sym == SDLK_d)
{
env->cam.pos.x += env->cam.inc;
SDL_DestroyTexture(env->sdl.draw);
ft_browse_pixels(env);
}
if (env->sdl.event.key.keysym.sym == SDLK_a)
{
env->cam.pos.x -= env->cam.inc;
SDL_DestroyTexture(env->sdl.draw);
ft_browse_pixels(env);
}
if (env->sdl.event.key.keysym.sym == SDLK_s)
{
env->cam.pos.y -= env->cam.inc;
SDL_DestroyTexture(env->sdl.draw);
ft_browse_pixels(env);
}
ft_event_cam_dub(env);
}
|
51dfa24b56faebca4c93ed5002e332417207c909
|
fe3939e260d0fa25dde549cf40c4da8c6cc9520b
|
/osdrv/ezcfg/ezcfg-0.1/ezcd/src/ezcm.c
|
2e69aeaac25f21d8ee26428ec4dcafc269ee3712
|
[
"Apache-2.0"
] |
permissive
|
zetalabs/hi3520d
|
20969a2a3fa55aa4dd6b8caeb86610a4ad1e0576
|
27374d155c4bcc1904d377dd3328f4d47b2cbc3d
|
refs/heads/master
| 2021-01-19T00:20:43.488086 | 2015-12-21T06:56:54 | 2015-12-21T06:56:54 | 48,212,258 | 2 | 1 | null | null | null | null |
UTF-8
|
C
| false | false | 1,990 |
c
|
ezcm.c
|
/* ============================================================================
* Project Name : ezbox Configuration Daemon
* Module Name : ezcm.c
*
* Description : ezbox config interface
*
* Copyright (C) 2008-2013 by ezbox-project
*
* History Rev Description
* 2010-06-13 0.1 Write it from scratch
* 2011-12-02 0.2 Modify it to use ezcfg API
* ============================================================================
*/
#include <stddef.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/un.h>
#include <fcntl.h>
#include <assert.h>
#include <errno.h>
#include <syslog.h>
#include <ctype.h>
#include <stdarg.h>
#include "ezcd.h"
static void ezcm_show_usage(void)
{
printf("Usage: ezcm [-q] <command> [args]\n");
printf("\n");
printf(" [-q]--\n");
printf(" run in quiet mode\n");
printf(" <command>--\n");
printf(" ezcfg control supported commands\n");
printf(" [args]--\n");
printf(" ezcfg control command arguments\n");
printf("\n");
}
int ezcm_main(int argc, char **argv)
{
int rc = 0;
int i;
bool quiet_mode = false;
char buf[EZCFG_CTRL_MAX_MESSAGE_SIZE];
int buf_len;
if (argc < 2) {
printf("need more arguments.\n");
ezcm_show_usage();
return -EZCFG_E_ARGUMENT ;
}
#if 0
rc = ezcfg_api_ctrl_set_config_file(EZCD_CONFIG_FILE_PATH);
if (rc < 0) {
printf("ERROR\n");
return rc;
}
#endif
if (utils_init_ezcfg_api(EZCD_CONFIG_FILE_PATH) == false) {
printf("ERROR\n");
return -EZCFG_E_RESOURCE;
}
i = 1;
if (strcmp(argv[i], "-q") == 0) {
quiet_mode = true;
i++;
}
buf_len = sizeof(buf);
rc = ezcfg_api_ctrl_exec(&(argv[i]), buf, buf_len);
if (quiet_mode == false) {
if (rc < 0) {
printf("ERROR\n");
}
else {
printf("%s=%s\n", argv[i], buf);
}
}
return rc;
}
|
bc542abaa59d121b8882b196d32c4e05bdd588b1
|
63f4f7156e156a58e614f5fd4409df4d3ff78dd1
|
/volumes/bundler/gems/sequel_pg-1.6.14/ext/sequel_pg/sequel_pg.c
|
bfc2a3e276fc254964a1b15ea59a6d81d568e878
|
[
"MIT"
] |
permissive
|
ibanzajoe/m3fasdf
|
3a42fe68eb253b288c59cc116cc0ace47392d802
|
c890dfabbf26a668b8cd47498d69c1d51a371870
|
refs/heads/master
| 2021-01-20T22:31:34.190143 | 2016-07-20T02:48:19 | 2016-07-20T02:48:19 | 63,744,702 | 0 | 1 | null | null | null | null |
UTF-8
|
C
| false | false | 34,200 |
c
|
sequel_pg.c
|
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <libpq-fe.h>
#include <ruby.h>
#if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
#define SPG_ENCODING 1
#include <ruby/encoding.h>
#define ENC_INDEX ,enc_index
#else
#define ENC_INDEX
#endif
#ifndef SPG_MAX_FIELDS
#define SPG_MAX_FIELDS 256
#endif
#define SPG_MICROSECONDS_PER_DAY_LL 86400000000ULL
#define SPG_MICROSECONDS_PER_DAY 86400000000.0
#define SPG_MINUTES_PER_DAY 1440.0
#define SPG_SECONDS_PER_DAY 86400.0
#define SPG_DT_ADD_USEC if (usec != 0) { dt = rb_funcall(dt, spg_id_op_plus, 1, spg_id_Rational ? rb_funcall(rb_cObject, spg_id_Rational, 2, INT2NUM(usec), ULL2NUM(SPG_MICROSECONDS_PER_DAY_LL)) : rb_float_new(usec/SPG_MICROSECONDS_PER_DAY)); }
#define SPG_NO_TZ 0
#define SPG_DB_LOCAL 1
#define SPG_DB_UTC 2
#define SPG_APP_LOCAL 4
#define SPG_APP_UTC 8
#define SPG_YIELD_NORMAL 0
#define SPG_YIELD_COLUMN 1
#define SPG_YIELD_COLUMNS 2
#define SPG_YIELD_FIRST 3
#define SPG_YIELD_ARRAY 4
#define SPG_YIELD_KV_HASH 5
#define SPG_YIELD_MKV_HASH 6
#define SPG_YIELD_KMV_HASH 7
#define SPG_YIELD_MKMV_HASH 8
#define SPG_YIELD_MODEL 9
#define SPG_YIELD_KV_HASH_GROUPS 10
#define SPG_YIELD_MKV_HASH_GROUPS 11
#define SPG_YIELD_KMV_HASH_GROUPS 12
#define SPG_YIELD_MKMV_HASH_GROUPS 13
/* Whether the data objects are structs instead of just pointers */
static int unwrap_structs;
/* External functions defined by ruby-pg when data objects are structs */
PGconn* pg_get_pgconn(VALUE);
PGresult* pgresult_get(VALUE);
/* Normalize access to data objects for both old and new versions of pg gem */
#define GetPGconn(_val, _var) if (unwrap_structs) {Check_Type(_val, T_DATA); _var = pg_get_pgconn(_val);} else {Data_Get_Struct(_val, PGconn, _var);}
#define GetPGresult(_val, _var) if (unwrap_structs) {Check_Type(_val, T_DATA); _var = pgresult_get(_val);} else {Data_Get_Struct(_val, PGresult, _var);}
static VALUE spg_Sequel;
static VALUE spg_Blob;
static VALUE spg_BigDecimal;
static VALUE spg_Date;
static VALUE spg_SQLTime;
static VALUE spg_PGError;
static VALUE spg_sym_utc;
static VALUE spg_sym_local;
static VALUE spg_sym_map;
static VALUE spg_sym_first;
static VALUE spg_sym_array;
static VALUE spg_sym_hash;
static VALUE spg_sym_hash_groups;
static VALUE spg_sym_model;
static VALUE spg_sym__sequel_pg_type;
static VALUE spg_sym__sequel_pg_value;
static VALUE spg_nan;
static VALUE spg_pos_inf;
static VALUE spg_neg_inf;
static ID spg_id_Rational;
static ID spg_id_new;
static ID spg_id_local;
static ID spg_id_year;
static ID spg_id_month;
static ID spg_id_day;
static ID spg_id_output_identifier;
static ID spg_id_datetime_class;
static ID spg_id_application_timezone;
static ID spg_id_to_application_timestamp;
static ID spg_id_timezone;
static ID spg_id_op_plus;
static ID spg_id_utc;
static ID spg_id_utc_offset;
static ID spg_id_localtime;
static ID spg_id_new_offset;
static ID spg_id_convert_infinite_timestamps;
static ID spg_id_infinite_timestamp_value;
static ID spg_id_call;
static ID spg_id_get;
static ID spg_id_opts;
static ID spg_id_db;
static ID spg_id_conversion_procs;
static ID spg_id_columns;
static ID spg_id_encoding;
static ID spg_id_values;
#if HAVE_PQSETSINGLEROWMODE
static ID spg_id_get_result;
static ID spg_id_clear;
static ID spg_id_check;
#endif
#if SPG_ENCODING
static int enc_get_index(VALUE val)
{
int i = ENCODING_GET_INLINED(val);
if (i == ENCODING_INLINE_MAX) {
i = NUM2INT(rb_ivar_get(val, spg_id_encoding));
}
return i;
}
#endif
static VALUE read_array(int *index, char *c_pg_array_string, int array_string_length, char *word, VALUE converter
#ifdef SPG_ENCODING
, int enc_index
#endif
)
{
int word_index = 0;
/* The current character in the input string. */
char c;
/* 0: Currently outside a quoted string, current word never quoted
* 1: Currently inside a quoted string
* -1: Currently outside a quoted string, current word previously quoted */
int openQuote = 0;
/* Inside quoted input means the next character should be treated literally,
* instead of being treated as a metacharacter.
* Outside of quoted input, means that the word shouldn't be pushed to the array,
* used when the last entry was a subarray (which adds to the array itself). */
int escapeNext = 0;
VALUE array = rb_ary_new();
RB_GC_GUARD(array);
/* Special case the empty array, so it doesn't need to be handled manually inside
* the loop. */
if(((*index) < array_string_length) && c_pg_array_string[(*index)] == '}')
{
return array;
}
for(;(*index) < array_string_length; ++(*index))
{
c = c_pg_array_string[*index];
if(openQuote < 1)
{
if(c == ',' || c == '}')
{
if(!escapeNext)
{
if(openQuote == 0 && word_index == 4 && !strncmp(word, "NULL", word_index))
{
rb_ary_push(array, Qnil);
}
else
{
VALUE rword = rb_tainted_str_new(word, word_index);
RB_GC_GUARD(rword);
#ifdef SPG_ENCODING
rb_enc_associate_index(rword, enc_index);
#endif
if (RTEST(converter)) {
rword = rb_funcall(converter, spg_id_call, 1, rword);
}
rb_ary_push(array, rword);
}
}
if(c == '}')
{
return array;
}
escapeNext = 0;
openQuote = 0;
word_index = 0;
}
else if(c == '"')
{
openQuote = 1;
}
else if(c == '{')
{
(*index)++;
rb_ary_push(array, read_array(index, c_pg_array_string, array_string_length, word, converter
#ifdef SPG_ENCODING
, enc_index
#endif
));
escapeNext = 1;
}
else
{
word[word_index] = c;
word_index++;
}
}
else if (escapeNext) {
word[word_index] = c;
word_index++;
escapeNext = 0;
}
else if (c == '\\')
{
escapeNext = 1;
}
else if (c == '"')
{
openQuote = -1;
}
else
{
word[word_index] = c;
word_index++;
}
}
return array;
}
static VALUE parse_pg_array(VALUE self, VALUE pg_array_string, VALUE converter) {
/* convert to c-string, create additional ruby string buffer of
* the same length, as that will be the worst case. */
char *c_pg_array_string = StringValueCStr(pg_array_string);
int array_string_length = RSTRING_LEN(pg_array_string);
VALUE buf = rb_str_buf_new(array_string_length);
RB_GC_GUARD(buf);
char *word = RSTRING_PTR(buf);
int index = 1;
if (array_string_length == 0) {
rb_raise(rb_eArgError, "unexpected PostgreSQL array format, empty");
}
switch (c_pg_array_string[0]) {
case '[':
/* Skip explicit subscripts, scanning until opening array */
for(;index < array_string_length && c_pg_array_string[index] != '{'; ++index)
/* nothing */;
if (index >= array_string_length) {
rb_raise(rb_eArgError, "unexpected PostgreSQL array format, no {");
} else {
++index;
}
case '{':
break;
default:
rb_raise(rb_eArgError, "unexpected PostgreSQL array format, doesn't start with { or [");
}
return read_array(&index, c_pg_array_string, array_string_length, word, converter
#ifdef SPG_ENCODING
, enc_get_index(pg_array_string)
#endif
);
}
static VALUE spg_time(const char *s) {
VALUE now;
int hour, minute, second, tokens, i;
char subsec[7];
int usec = 0;
tokens = sscanf(s, "%2d:%2d:%2d.%6s", &hour, &minute, &second, subsec);
if(tokens == 4) {
for(i=0; i<6; i++) {
if(subsec[i] == '-') {
subsec[i] = '\0';
}
}
usec = atoi(subsec);
usec *= (int) pow(10, (6 - strlen(subsec)));
} else if(tokens < 3) {
rb_raise(rb_eArgError, "unexpected time format");
}
now = rb_funcall(spg_SQLTime, spg_id_new, 0);
return rb_funcall(spg_SQLTime, spg_id_local, 7, rb_funcall(now, spg_id_year, 0), rb_funcall(now, spg_id_month, 0), rb_funcall(now, spg_id_day, 0), INT2NUM(hour), INT2NUM(minute), INT2NUM(second), INT2NUM(usec));
}
static VALUE spg_timestamp_error(const char *s, VALUE self, const char *error_msg) {
VALUE db;
db = rb_funcall(self, spg_id_db, 0);
if(RTEST(rb_funcall(db, spg_id_convert_infinite_timestamps, 0))) {
if((strcmp(s, "infinity") == 0) || (strcmp(s, "-infinity") == 0)) {
return rb_funcall(db, spg_id_infinite_timestamp_value, 1, rb_tainted_str_new2(s));
}
}
rb_raise(rb_eArgError, "%s", error_msg);
}
static VALUE spg_date(const char *s, VALUE self) {
int year, month, day;
if(3 != sscanf(s, "%d-%2d-%2d", &year, &month, &day)) {
return spg_timestamp_error(s, self, "unexpected date format");
}
return rb_funcall(spg_Date, spg_id_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
}
static VALUE spg_timestamp(const char *s, VALUE self) {
VALUE dtc, dt, rtz, db;
int tz = SPG_NO_TZ;
int year, month, day, hour, min, sec, usec, tokens, utc_offset;
int usec_start, usec_stop;
char offset_sign = 0;
int offset_hour = 0;
int offset_minute = 0;
int offset_seconds = 0;
double offset_fraction = 0.0;
db = rb_funcall(self, spg_id_db, 0);
rtz = rb_funcall(db, spg_id_timezone, 0);
if (rtz != Qnil) {
if (rtz == spg_sym_local) {
tz += SPG_DB_LOCAL;
} else if (rtz == spg_sym_utc) {
tz += SPG_DB_UTC;
} else {
return rb_funcall(db, spg_id_to_application_timestamp, 1, rb_str_new2(s));
}
}
rtz = rb_funcall(spg_Sequel, spg_id_application_timezone, 0);
if (rtz != Qnil) {
if (rtz == spg_sym_local) {
tz += SPG_APP_LOCAL;
} else if (rtz == spg_sym_utc) {
tz += SPG_APP_UTC;
} else {
return rb_funcall(db, spg_id_to_application_timestamp, 1, rb_str_new2(s));
}
}
if (0 != strchr(s, '.')) {
tokens = sscanf(s, "%d-%2d-%2d %2d:%2d:%2d.%n%d%n%c%02d:%02d",
&year, &month, &day, &hour, &min, &sec,
&usec_start, &usec, &usec_stop,
&offset_sign, &offset_hour, &offset_minute);
if(tokens < 7) {
return spg_timestamp_error(s, self, "unexpected datetime format");
}
usec *= (int) pow(10, (6 - (usec_stop - usec_start)));
} else {
tokens = sscanf(s, "%d-%2d-%2d %2d:%2d:%2d%c%02d:%02d",
&year, &month, &day, &hour, &min, &sec,
&offset_sign, &offset_hour, &offset_minute);
if (tokens == 3) {
hour = 0;
min = 0;
sec = 0;
} else if (tokens < 6) {
return spg_timestamp_error(s, self, "unexpected datetime format");
}
usec = 0;
}
if (offset_sign == '-') {
offset_hour *= -1;
offset_minute *= -1;
}
dtc = rb_funcall(spg_Sequel, spg_id_datetime_class, 0);
if (dtc == rb_cTime) {
if (offset_sign) {
/* Offset given, convert to local time if not already in local time.
* While PostgreSQL generally returns timestamps in local time, it's unwise to rely on this.
*/
dt = rb_funcall(rb_cTime, spg_id_local, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
utc_offset = NUM2INT(rb_funcall(dt, spg_id_utc_offset, 0));
offset_seconds = offset_hour * 3600 + offset_minute * 60;
if (utc_offset != offset_seconds) {
dt = rb_funcall(dt, spg_id_op_plus, 1, INT2NUM(utc_offset - offset_seconds));
}
if (tz & SPG_APP_UTC) {
dt = rb_funcall(dt, spg_id_utc, 0);
}
return dt;
} else if (tz == SPG_NO_TZ) {
return rb_funcall(rb_cTime, spg_id_local, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
}
/* No offset given, and some timezone combination given */
if (tz & SPG_DB_UTC) {
dt = rb_funcall(rb_cTime, spg_id_utc, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
if (tz & SPG_APP_LOCAL) {
return rb_funcall(dt, spg_id_localtime, 0);
} else {
return dt;
}
} else {
dt = rb_funcall(rb_cTime, spg_id_local, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
if (tz & SPG_APP_UTC) {
return rb_funcall(dt, spg_id_utc, 0);
} else {
return dt;
}
}
} else {
/* datetime.class == DateTime */
if (offset_sign) {
/* Offset given, handle correct local time.
* While PostgreSQL generally returns timestamps in local time, it's unwise to rely on this.
*/
offset_fraction = offset_hour/24.0 + offset_minute/SPG_MINUTES_PER_DAY;
dt = rb_funcall(dtc, spg_id_new, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), rb_float_new(offset_fraction));
SPG_DT_ADD_USEC
if (tz & SPG_APP_LOCAL) {
utc_offset = NUM2INT(rb_funcall(rb_funcall(rb_cTime, spg_id_new, 0), spg_id_utc_offset, 0))/SPG_SECONDS_PER_DAY;
dt = rb_funcall(dt, spg_id_new_offset, 1, rb_float_new(utc_offset));
} else if (tz & SPG_APP_UTC) {
dt = rb_funcall(dt, spg_id_new_offset, 1, INT2NUM(0));
}
return dt;
} else if (tz == SPG_NO_TZ) {
dt = rb_funcall(dtc, spg_id_new, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec));
SPG_DT_ADD_USEC
return dt;
}
/* No offset given, and some timezone combination given */
if (tz & SPG_DB_LOCAL) {
offset_fraction = NUM2INT(rb_funcall(rb_funcall(rb_cTime, spg_id_local, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec)), spg_id_utc_offset, 0))/SPG_SECONDS_PER_DAY;
dt = rb_funcall(dtc, spg_id_new, 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), rb_float_new(offset_fraction));
SPG_DT_ADD_USEC
if (tz & SPG_APP_UTC) {
return rb_funcall(dt, spg_id_new_offset, 1, INT2NUM(0));
} else {
return dt;
}
} else {
dt = rb_funcall(dtc, spg_id_new, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec));
SPG_DT_ADD_USEC
if (tz & SPG_APP_LOCAL) {
offset_fraction = NUM2INT(rb_funcall(rb_funcall(rb_cTime, spg_id_local, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec)), spg_id_utc_offset, 0))/SPG_SECONDS_PER_DAY;
return rb_funcall(dt, spg_id_new_offset, 1, rb_float_new(offset_fraction));
} else {
return dt;
}
}
}
}
static VALUE spg_fetch_rows_set_cols(VALUE self, VALUE ignore) {
return Qnil;
}
static VALUE spg__col_value(VALUE self, PGresult *res, long i, long j, VALUE* colconvert
#ifdef SPG_ENCODING
, int enc_index
#endif
) {
char *v;
VALUE rv;
size_t l;
if(PQgetisnull(res, i, j)) {
rv = Qnil;
} else {
v = PQgetvalue(res, i, j);
switch(PQftype(res, j)) {
case 16: /* boolean */
rv = *v == 't' ? Qtrue : Qfalse;
break;
case 17: /* bytea */
v = (char *)PQunescapeBytea((unsigned char*)v, &l);
rv = rb_funcall(spg_Blob, spg_id_new, 1, rb_str_new(v, l));
PQfreemem(v);
break;
case 20: /* integer */
case 21:
case 23:
case 26:
rv = rb_cstr2inum(v, 10);
break;
case 700: /* float */
case 701:
if (strcmp("NaN", v) == 0) {
rv = spg_nan;
} else if (strcmp("Infinity", v) == 0) {
rv = spg_pos_inf;
} else if (strcmp("-Infinity", v) == 0) {
rv = spg_neg_inf;
} else {
rv = rb_float_new(rb_cstr_to_dbl(v, Qfalse));
}
break;
case 1700: /* numeric */
rv = rb_funcall(spg_BigDecimal, spg_id_new, 1, rb_str_new(v, PQgetlength(res, i, j)));
break;
case 1082: /* date */
rv = spg_date(v, self);
break;
case 1083: /* time */
case 1266:
rv = spg_time(v);
break;
case 1114: /* timestamp */
case 1184:
rv = spg_timestamp(v, self);
break;
case 18: /* char */
case 25: /* text */
case 1043: /* varchar*/
rv = rb_tainted_str_new(v, PQgetlength(res, i, j));
#ifdef SPG_ENCODING
rb_enc_associate_index(rv, enc_index);
#endif
break;
default:
rv = rb_tainted_str_new(v, PQgetlength(res, i, j));
#ifdef SPG_ENCODING
rb_enc_associate_index(rv, enc_index);
#endif
if (colconvert[j] != Qnil) {
rv = rb_funcall(colconvert[j], spg_id_call, 1, rv);
}
}
}
return rv;
}
static VALUE spg__col_values(VALUE self, VALUE v, VALUE *colsyms, long nfields, PGresult *res, long i, VALUE *colconvert
#ifdef SPG_ENCODING
, int enc_index
#endif
) {
long j;
VALUE cur;
long len = RARRAY_LEN(v);
VALUE a = rb_ary_new2(len);
for (j=0; j<len; j++) {
cur = rb_ary_entry(v, j);
rb_ary_store(a, j, cur == Qnil ? Qnil : spg__col_value(self, res, i, NUM2LONG(cur), colconvert ENC_INDEX));
}
return a;
}
static long spg__field_id(VALUE v, VALUE *colsyms, long nfields) {
long j;
for (j=0; j<nfields; j++) {
if (colsyms[j] == v) {
return j;
}
}
return -1;
}
static VALUE spg__field_ids(VALUE v, VALUE *colsyms, long nfields) {
long i;
long j;
VALUE cur;
long len = RARRAY_LEN(v);
VALUE pg_columns = rb_ary_new2(len);
for (i=0; i<len; i++) {
cur = rb_ary_entry(v, i);
j = spg__field_id(cur, colsyms, nfields);
rb_ary_store(pg_columns, i, j == -1 ? Qnil : LONG2NUM(j));
}
return pg_columns;
}
static void spg_set_column_info(VALUE self, PGresult *res, VALUE *colsyms, VALUE *colconvert) {
long i;
long j;
long nfields;
VALUE conv_procs = 0;
nfields = PQnfields(res);
for(j=0; j<nfields; j++) {
colsyms[j] = rb_funcall(self, spg_id_output_identifier, 1, rb_str_new2(PQfname(res, j)));
i = PQftype(res, j);
switch (i) {
case 16:
case 17:
case 20:
case 21:
case 23:
case 26:
case 700:
case 701:
case 790:
case 1700:
case 1082:
case 1083:
case 1266:
case 1114:
case 1184:
case 18:
case 25:
case 1043:
colconvert[j] = Qnil;
break;
default:
if (conv_procs == 0) {
conv_procs = rb_funcall(rb_funcall(self, spg_id_db, 0), spg_id_conversion_procs, 0);
}
colconvert[j] = rb_funcall(conv_procs, spg_id_get, 1, INT2NUM(i));
break;
}
}
}
static VALUE spg_yield_hash_rows(VALUE self, VALUE rres, VALUE ignore) {
PGresult *res;
VALUE colsyms[SPG_MAX_FIELDS];
VALUE colconvert[SPG_MAX_FIELDS];
long ntuples;
long nfields;
long i;
long j;
VALUE h;
VALUE opts;
VALUE pg_type;
VALUE pg_value;
char type = SPG_YIELD_NORMAL;
if (!RTEST(rres)) {
return self;
}
GetPGresult(rres, res);
#ifdef SPG_ENCODING
int enc_index;
enc_index = enc_get_index(rres);
#endif
ntuples = PQntuples(res);
nfields = PQnfields(res);
if (nfields > SPG_MAX_FIELDS) {
rb_raise(rb_eRangeError, "more than %d columns in query (%ld columns detected)", SPG_MAX_FIELDS, nfields);
}
spg_set_column_info(self, res, colsyms, colconvert);
rb_ivar_set(self, spg_id_columns, rb_ary_new4(nfields, colsyms));
opts = rb_funcall(self, spg_id_opts, 0);
if (rb_type(opts) == T_HASH) {
pg_type = rb_hash_aref(opts, spg_sym__sequel_pg_type);
pg_value = rb_hash_aref(opts, spg_sym__sequel_pg_value);
if (SYMBOL_P(pg_type)) {
if (pg_type == spg_sym_map) {
if (SYMBOL_P(pg_value)) {
type = SPG_YIELD_COLUMN;
} else if (rb_type(pg_value) == T_ARRAY) {
type = SPG_YIELD_COLUMNS;
}
} else if (pg_type == spg_sym_first) {
type = SPG_YIELD_FIRST;
} else if (pg_type == spg_sym_array) {
type = SPG_YIELD_ARRAY;
} else if ((pg_type == spg_sym_hash || pg_type == spg_sym_hash_groups) && rb_type(pg_value) == T_ARRAY) {
VALUE pg_value_key, pg_value_value;
pg_value_key = rb_ary_entry(pg_value, 0);
pg_value_value = rb_ary_entry(pg_value, 1);
if (SYMBOL_P(pg_value_key)) {
if (SYMBOL_P(pg_value_value)) {
type = pg_type == spg_sym_hash_groups ? SPG_YIELD_KV_HASH_GROUPS : SPG_YIELD_KV_HASH;
} else if (rb_type(pg_value_value) == T_ARRAY) {
type = pg_type == spg_sym_hash_groups ? SPG_YIELD_KMV_HASH_GROUPS : SPG_YIELD_KMV_HASH;
}
} else if (rb_type(pg_value_key) == T_ARRAY) {
if (SYMBOL_P(pg_value_value)) {
type = pg_type == spg_sym_hash_groups ? SPG_YIELD_MKV_HASH_GROUPS : SPG_YIELD_MKV_HASH;
} else if (rb_type(pg_value_value) == T_ARRAY) {
type = pg_type == spg_sym_hash_groups ? SPG_YIELD_MKMV_HASH_GROUPS : SPG_YIELD_MKMV_HASH;
}
}
} else if (pg_type == spg_sym_model && rb_type(pg_value) == T_CLASS) {
type = SPG_YIELD_MODEL;
}
}
}
switch(type) {
case SPG_YIELD_NORMAL:
/* Normal, hash for entire row */
for(i=0; i<ntuples; i++) {
h = rb_hash_new();
for(j=0; j<nfields; j++) {
rb_hash_aset(h, colsyms[j], spg__col_value(self, res, i, j, colconvert ENC_INDEX));
}
rb_yield(h);
}
break;
case SPG_YIELD_COLUMN:
/* Single column */
j = spg__field_id(pg_value, colsyms, nfields);
if (j == -1) {
for(i=0; i<ntuples; i++) {
rb_yield(Qnil);
}
} else {
for(i=0; i<ntuples; i++) {
rb_yield(spg__col_value(self, res, i, j, colconvert ENC_INDEX));
}
}
break;
case SPG_YIELD_COLUMNS:
/* Multiple columns as an array */
h = spg__field_ids(pg_value, colsyms, nfields);
for(i=0; i<ntuples; i++) {
rb_yield(spg__col_values(self, h, colsyms, nfields, res, i, colconvert ENC_INDEX));
}
break;
case SPG_YIELD_FIRST:
/* First column */
for(i=0; i<ntuples; i++) {
rb_yield(spg__col_value(self, res, i, 0, colconvert ENC_INDEX));
}
break;
case SPG_YIELD_ARRAY:
/* Array of all columns */
for(i=0; i<ntuples; i++) {
h = rb_ary_new2(nfields);
for(j=0; j<nfields; j++) {
rb_ary_store(h, j, spg__col_value(self, res, i, j, colconvert ENC_INDEX));
}
rb_yield(h);
}
break;
case SPG_YIELD_KV_HASH:
case SPG_YIELD_KV_HASH_GROUPS:
/* Hash with single key and single value */
{
VALUE k, v;
h = rb_hash_new();
k = spg__field_id(rb_ary_entry(pg_value, 0), colsyms, nfields);
v = spg__field_id(rb_ary_entry(pg_value, 1), colsyms, nfields);
if(type == SPG_YIELD_KV_HASH) {
for(i=0; i<ntuples; i++) {
rb_hash_aset(h, spg__col_value(self, res, i, k, colconvert ENC_INDEX), spg__col_value(self, res, i, v, colconvert ENC_INDEX));
}
} else {
VALUE kv, vv, a;
for(i=0; i<ntuples; i++) {
kv = spg__col_value(self, res, i, k, colconvert ENC_INDEX);
vv = spg__col_value(self, res, i, v, colconvert ENC_INDEX);
a = rb_hash_lookup(h, kv);
if(!RTEST(a)) {
rb_hash_aset(h, kv, rb_ary_new3(1, vv));
} else {
rb_ary_push(a, vv);
}
}
}
rb_yield(h);
}
break;
case SPG_YIELD_MKV_HASH:
case SPG_YIELD_MKV_HASH_GROUPS:
/* Hash with array of keys and single value */
{
VALUE k, v;
h = rb_hash_new();
k = spg__field_ids(rb_ary_entry(pg_value, 0), colsyms, nfields);
v = spg__field_id(rb_ary_entry(pg_value, 1), colsyms, nfields);
if(type == SPG_YIELD_MKV_HASH) {
for(i=0; i<ntuples; i++) {
rb_hash_aset(h, spg__col_values(self, k, colsyms, nfields, res, i, colconvert ENC_INDEX), spg__col_value(self, res, i, v, colconvert ENC_INDEX));
}
} else {
VALUE kv, vv, a;
for(i=0; i<ntuples; i++) {
kv = spg__col_values(self, k, colsyms, nfields, res, i, colconvert ENC_INDEX);
vv = spg__col_value(self, res, i, v, colconvert ENC_INDEX);
a = rb_hash_lookup(h, kv);
if(!RTEST(a)) {
rb_hash_aset(h, kv, rb_ary_new3(1, vv));
} else {
rb_ary_push(a, vv);
}
}
}
rb_yield(h);
}
break;
case SPG_YIELD_KMV_HASH:
case SPG_YIELD_KMV_HASH_GROUPS:
/* Hash with single keys and array of values */
{
VALUE k, v;
h = rb_hash_new();
k = spg__field_id(rb_ary_entry(pg_value, 0), colsyms, nfields);
v = spg__field_ids(rb_ary_entry(pg_value, 1), colsyms, nfields);
if(type == SPG_YIELD_KMV_HASH) {
for(i=0; i<ntuples; i++) {
rb_hash_aset(h, spg__col_value(self, res, i, k, colconvert ENC_INDEX), spg__col_values(self, v, colsyms, nfields, res, i, colconvert ENC_INDEX));
}
} else {
VALUE kv, vv, a;
for(i=0; i<ntuples; i++) {
kv = spg__col_value(self, res, i, k, colconvert ENC_INDEX);
vv = spg__col_values(self, v, colsyms, nfields, res, i, colconvert ENC_INDEX);
a = rb_hash_lookup(h, kv);
if(!RTEST(a)) {
rb_hash_aset(h, kv, rb_ary_new3(1, vv));
} else {
rb_ary_push(a, vv);
}
}
}
rb_yield(h);
}
break;
case SPG_YIELD_MKMV_HASH:
case SPG_YIELD_MKMV_HASH_GROUPS:
/* Hash with array of keys and array of values */
{
VALUE k, v;
h = rb_hash_new();
k = spg__field_ids(rb_ary_entry(pg_value, 0), colsyms, nfields);
v = spg__field_ids(rb_ary_entry(pg_value, 1), colsyms, nfields);
if(type == SPG_YIELD_MKMV_HASH) {
for(i=0; i<ntuples; i++) {
rb_hash_aset(h, spg__col_values(self, k, colsyms, nfields, res, i, colconvert ENC_INDEX), spg__col_values(self, v, colsyms, nfields, res, i, colconvert ENC_INDEX));
}
} else {
VALUE kv, vv, a;
for(i=0; i<ntuples; i++) {
kv = spg__col_values(self, k, colsyms, nfields, res, i, colconvert ENC_INDEX);
vv = spg__col_values(self, v, colsyms, nfields, res, i, colconvert ENC_INDEX);
a = rb_hash_lookup(h, kv);
if(!RTEST(a)) {
rb_hash_aset(h, kv, rb_ary_new3(1, vv));
} else {
rb_ary_push(a, vv);
}
}
}
rb_yield(h);
}
break;
case SPG_YIELD_MODEL:
/* Model object for entire row */
for(i=0; i<ntuples; i++) {
h = rb_hash_new();
for(j=0; j<nfields; j++) {
rb_hash_aset(h, colsyms[j], spg__col_value(self, res, i, j, colconvert ENC_INDEX));
}
/* Abuse local variable */
pg_type = rb_obj_alloc(pg_value);
rb_ivar_set(pg_type, spg_id_values, h);
rb_yield(pg_type);
}
break;
}
return self;
}
static VALUE spg_supports_streaming_p(VALUE self) {
return
#if HAVE_PQSETSINGLEROWMODE
Qtrue;
#else
Qfalse;
#endif
}
#if HAVE_PQSETSINGLEROWMODE
static VALUE spg_set_single_row_mode(VALUE self) {
PGconn *conn;
GetPGconn(self, conn);
if (PQsetSingleRowMode(conn) != 1) {
rb_raise(spg_PGError, "cannot set single row mode");
}
return Qnil;
}
static VALUE spg__yield_each_row(VALUE self) {
PGconn *conn;
PGresult *res;
VALUE rres;
VALUE rconn;
VALUE colsyms[SPG_MAX_FIELDS];
VALUE colconvert[SPG_MAX_FIELDS];
long nfields;
long j;
VALUE h;
VALUE opts;
VALUE pg_type;
VALUE pg_value = Qnil;
char type = SPG_YIELD_NORMAL;
rconn = rb_ary_entry(self, 1);
self = rb_ary_entry(self, 0);
GetPGconn(rconn, conn);
rres = rb_funcall(rconn, spg_id_get_result, 0);
rb_funcall(rres, spg_id_check, 0);
GetPGresult(rres, res);
#ifdef SPG_ENCODING
int enc_index;
enc_index = enc_get_index(rres);
#endif
/* Only handle regular and model types. All other types require compiling all
* of the results at once, which is not a use case for streaming. The streaming
* code does not call this function for the other types. */
opts = rb_funcall(self, spg_id_opts, 0);
if (rb_type(opts) == T_HASH) {
pg_type = rb_hash_aref(opts, spg_sym__sequel_pg_type);
pg_value = rb_hash_aref(opts, spg_sym__sequel_pg_value);
if (SYMBOL_P(pg_type) && pg_type == spg_sym_model && rb_type(pg_value) == T_CLASS) {
type = SPG_YIELD_MODEL;
}
}
nfields = PQnfields(res);
if (nfields > SPG_MAX_FIELDS) {
rb_funcall(rres, spg_id_clear, 0);
rb_raise(rb_eRangeError, "more than %d columns in query", SPG_MAX_FIELDS);
}
spg_set_column_info(self, res, colsyms, colconvert);
rb_ivar_set(self, spg_id_columns, rb_ary_new4(nfields, colsyms));
while (PQntuples(res) != 0) {
h = rb_hash_new();
for(j=0; j<nfields; j++) {
rb_hash_aset(h, colsyms[j], spg__col_value(self, res, 0, j, colconvert ENC_INDEX));
}
rb_funcall(rres, spg_id_clear, 0);
if(type == SPG_YIELD_MODEL) {
/* Abuse local variable */
pg_type = rb_obj_alloc(pg_value);
rb_ivar_set(pg_type, spg_id_values, h);
rb_yield(pg_type);
} else {
rb_yield(h);
}
rres = rb_funcall(rconn, spg_id_get_result, 0);
rb_funcall(rres, spg_id_check, 0);
GetPGresult(rres, res);
}
rb_funcall(rres, spg_id_clear, 0);
return self;
}
static VALUE spg__flush_results(VALUE rconn) {
PGconn *conn;
PGresult *res;
VALUE error = 0;
GetPGconn(rconn, conn);
while ((res = PQgetResult(conn)) != NULL) {
if (!error) {
switch (PQresultStatus(res))
{
case PGRES_BAD_RESPONSE:
case PGRES_FATAL_ERROR:
case PGRES_NONFATAL_ERROR:
error = rb_str_new2(PQresultErrorMessage(res));
break;
default:
break;
}
}
PQclear(res);
}
if (error) {
VALUE exception = rb_exc_new3(spg_PGError, error);
rb_iv_set(exception, "@connection", rconn);
rb_exc_raise(exception);
}
return rconn;
}
static VALUE spg_yield_each_row(VALUE self, VALUE rconn) {
VALUE v;
v = rb_ary_new3(2, self, rconn);
return rb_ensure(spg__yield_each_row, v, spg__flush_results, rconn);
}
#endif
void Init_sequel_pg(void) {
VALUE c, spg_Postgres;
ID cg;
cg = rb_intern("const_get");
spg_id_new = rb_intern("new");
spg_id_local = rb_intern("local");
spg_id_year = rb_intern("year");
spg_id_month = rb_intern("month");
spg_id_day = rb_intern("day");
spg_id_output_identifier = rb_intern("output_identifier");
spg_id_datetime_class = rb_intern("datetime_class");
spg_id_application_timezone = rb_intern("application_timezone");
spg_id_to_application_timestamp = rb_intern("to_application_timestamp");
spg_id_timezone = rb_intern("timezone");
spg_id_op_plus = rb_intern("+");
spg_id_utc = rb_intern("utc");
spg_id_utc_offset = rb_intern("utc_offset");
spg_id_localtime = rb_intern("localtime");
spg_id_new_offset = rb_intern("new_offset");
spg_id_convert_infinite_timestamps = rb_intern("convert_infinite_timestamps");
spg_id_infinite_timestamp_value = rb_intern("infinite_timestamp_value");
spg_id_call = rb_intern("call");
spg_id_get = rb_intern("[]");
spg_id_opts = rb_intern("opts");
spg_id_db = rb_intern("db");
spg_id_conversion_procs = rb_intern("conversion_procs");
spg_id_columns = rb_intern("@columns");
spg_id_encoding = rb_intern("@encoding");
spg_id_values = rb_intern("@values");
spg_sym_utc = ID2SYM(rb_intern("utc"));
spg_sym_local = ID2SYM(rb_intern("local"));
spg_sym_map = ID2SYM(rb_intern("map"));
spg_sym_first = ID2SYM(rb_intern("first"));
spg_sym_array = ID2SYM(rb_intern("array"));
spg_sym_hash = ID2SYM(rb_intern("hash"));
spg_sym_hash_groups = ID2SYM(rb_intern("hash_groups"));
spg_sym_model = ID2SYM(rb_intern("model"));
spg_sym__sequel_pg_type = ID2SYM(rb_intern("_sequel_pg_type"));
spg_sym__sequel_pg_value = ID2SYM(rb_intern("_sequel_pg_value"));
spg_Sequel = rb_funcall(rb_cObject, cg, 1, rb_str_new2("Sequel"));
spg_Blob = rb_funcall(rb_funcall(spg_Sequel, cg, 1, rb_str_new2("SQL")), cg, 1, rb_str_new2("Blob"));
spg_SQLTime= rb_funcall(spg_Sequel, cg, 1, rb_str_new2("SQLTime"));
spg_BigDecimal = rb_funcall(rb_cObject, cg, 1, rb_str_new2("BigDecimal"));
spg_Date = rb_funcall(rb_cObject, cg, 1, rb_str_new2("Date"));
spg_Postgres = rb_funcall(spg_Sequel, cg, 1, rb_str_new2("Postgres"));
spg_PGError = rb_funcall(rb_cObject, cg, 1, rb_str_new2("PGError"));
spg_nan = rb_eval_string("0.0/0.0");
spg_pos_inf = rb_eval_string("1.0/0.0");
spg_neg_inf = rb_eval_string("-1.0/0.0");
rb_global_variable(&spg_Sequel);
rb_global_variable(&spg_Blob);
rb_global_variable(&spg_BigDecimal);
rb_global_variable(&spg_Date);
rb_global_variable(&spg_SQLTime);
rb_global_variable(&spg_PGError);
rb_global_variable(&spg_nan);
rb_global_variable(&spg_pos_inf);
rb_global_variable(&spg_neg_inf);
/* Check for 1.8-1.9.2 stdlib date that needs Rational for usec accuracy */
if (rb_eval_string("Date.today.instance_variable_get(:@ajd)") != Qnil) {
spg_id_Rational = rb_intern("Rational");
}
if (rb_eval_string("defined?(PG::TypeMapAllStrings)") != Qnil) {
unwrap_structs = 1;
}
c = rb_funcall(spg_Postgres, cg, 1, rb_str_new2("Dataset"));
rb_define_private_method(c, "yield_hash_rows", spg_yield_hash_rows, 2);
rb_define_private_method(c, "fetch_rows_set_cols", spg_fetch_rows_set_cols, 1);
rb_define_singleton_method(spg_Postgres, "supports_streaming?", spg_supports_streaming_p, 0);
#if HAVE_PQSETSINGLEROWMODE
spg_id_get_result = rb_intern("get_result");
spg_id_clear = rb_intern("clear");
spg_id_check = rb_intern("check");
rb_define_private_method(c, "yield_each_row", spg_yield_each_row, 1);
c = rb_funcall(spg_Postgres, cg, 1, rb_str_new2("Adapter"));
rb_define_private_method(c, "set_single_row_mode", spg_set_single_row_mode, 0);
#endif
rb_define_singleton_method(spg_Postgres, "parse_pg_array", parse_pg_array, 2);
rb_require("sequel_pg/sequel_pg");
}
|
c40c06dfe2d87ea8a1fdf5a06df1b3d6d686901a
|
53eeb142a3350ae68e419dc4f62592275a3b415f
|
/include/tlb.h
|
dd2d74d632c373cde73dd3455d6d1acaec12d3cf
|
[] |
no_license
|
redpfire/integratorcp-unix
|
b1784036dc696eb9c99ed4c4ba083179edca3152
|
65ec4da7badb855fa4ffc6322392defea426609a
|
refs/heads/master
| 2020-03-22T06:35:53.317460 | 2018-07-06T11:50:26 | 2018-07-06T11:50:26 | 139,645,307 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,529 |
h
|
tlb.h
|
#include <inttype.h>
/* first level table */
#define TLB_FAULT 0x000 /* entry is unmapped (bits 32:2 can be used for anything) but access generates an ABORT */
#define TLB_SECTION 0x002 /* entry maps 1MB chunk */
#define TLB_COARSE 0x001 /* sub-table */
#define TLB_DOM_NOACCESS 0x00 /* generates fault on access */
#define TLB_DOM_CLIENT 0x01 /* checked against permission bits in TLB entry */
#define TLB_DOM_RESERVED 0x02 /* reserved */
#define TLB_DOM_MANAGER 0x03 /* no permissions */
#define TLB_STDFLAGS 0xc00 /* normal flags */
/* second level coarse table */
#define TLB_C_LARGEPAGE 0x1 /* 64KB page */
#define TLB_C_SMALLPAGE 0x2 /* 4KB page */
/* AP (access permission) flags for coarse table [see page 731 in ARM_ARM] */
#define TLB_C_AP_NOACCESS (0x00<<4) /* no access */
#define TLB_C_AP_PRIVACCESS (0x01<<4) /* only system access RWXX */
#define TLB_C_AP_UREADONLY (0x02<<4) /* user read only RWRX */
#define TLB_C_AP_FULLACCESS (0x03<<4) /* RWRW */
/* AP (access permission) flags [see page 709 in ARM_ARM; more listed] */
#define TLB_AP_NOACCESS (0x00<<10) /* no access */
#define TLB_AP_PRIVACCESS (0x01<<10) /* only system access RWXX */
#define TLB_AP_UREADONLY (0x02<<10) /* user read only RWRX */
#define TLB_AP_FULLACCESS (0x03<<10) /* RWRW */
void arm_tlbset0(uint32_t base);
void arm_tlbset1(uint32_t base);
void arm_tlbsetmode(uint32_t val);
void arm_tlbsetdom(uint32_t val);
uint32_t arm_tlbgetctrl();
void arm_tlbsetctrl(uint32_t ctrl);
|
0abe3ea46eeb81c879762de0036708e3536f4577
|
219b870e11118f39f86b0feae679b3cac7521608
|
/waypoint_qball2/slprj/_sfprj/mission_server_waypoint_qball2/_self/sfun/src/mission_server_waypoint_qball2_sfun.c
|
485dc3fa83e585609cd606439603d9b5f7d72814
|
[] |
no_license
|
TylerZhang0423/Autonomous-Movement-for-WMRs
|
6e46bdcfffb246b28d0dddb0b79c6784d6a51205
|
9579752f494bca53b4c926e26815df8694d0c0a6
|
refs/heads/master
| 2020-04-26T08:34:21.498224 | 2019-03-02T09:30:56 | 2019-03-02T09:30:56 | 173,426,908 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 12,910 |
c
|
mission_server_waypoint_qball2_sfun.c
|
/* Include files */
#include "mission_server_waypoint_qball2_sfun.h"
#include "mission_server_waypoint_qball2_sfun_debug_macros.h"
#include "c1_mission_server_waypoint_qball2.h"
#include "c3_mission_server_waypoint_qball2.h"
/* Type Definitions */
/* Named Constants */
/* Variable Declarations */
/* Variable Definitions */
uint32_T _mission_server_waypoint_qball2MachineNumber_;
/* Function Declarations */
/* Function Definitions */
void mission_server_waypoint_qball2_initializer(void)
{
}
void mission_server_waypoint_qball2_terminator(void)
{
}
/* SFunction Glue Code */
unsigned int sf_mission_server_waypoint_qball2_method_dispatcher(SimStruct
*simstructPtr, unsigned int chartFileNumber, const char* specsCksum, int_T
method, void *data)
{
if (chartFileNumber==1) {
c1_mission_server_waypoint_qball2_method_dispatcher(simstructPtr, method,
data);
return 1;
}
if (chartFileNumber==3) {
c3_mission_server_waypoint_qball2_method_dispatcher(simstructPtr, method,
data);
return 1;
}
return 0;
}
unsigned int sf_mission_server_waypoint_qball2_process_testpoint_info_call( int
nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] )
{
#ifdef MATLAB_MEX_FILE
char commandName[32];
char machineName[128];
if (nrhs < 3 || !mxIsChar(prhs[0]) || !mxIsChar(prhs[1]))
return 0;
/* Possible call to get testpoint info. */
mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char));
commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0';
if (strcmp(commandName,"get_testpoint_info"))
return 0;
mxGetString(prhs[1], machineName, sizeof(machineName)/sizeof(char));
machineName[(sizeof(machineName)/sizeof(char)-1)] = '\0';
if (!strcmp(machineName, "mission_server_waypoint_qball2")) {
unsigned int chartFileNumber;
chartFileNumber = (unsigned int)mxGetScalar(prhs[2]);
switch (chartFileNumber) {
case 1:
{
extern mxArray *sf_c1_mission_server_waypoint_qball2_get_testpoint_info
(void);
plhs[0] = sf_c1_mission_server_waypoint_qball2_get_testpoint_info();
break;
}
case 3:
{
extern mxArray *sf_c3_mission_server_waypoint_qball2_get_testpoint_info
(void);
plhs[0] = sf_c3_mission_server_waypoint_qball2_get_testpoint_info();
break;
}
default:
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
}
return 1;
}
return 0;
#else
return 0;
#endif
}
unsigned int sf_mission_server_waypoint_qball2_process_check_sum_call( int nlhs,
mxArray * plhs[], int nrhs, const mxArray * prhs[] )
{
#ifdef MATLAB_MEX_FILE
char commandName[20];
if (nrhs<1 || !mxIsChar(prhs[0]) )
return 0;
/* Possible call to get the checksum */
mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char));
commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0';
if (strcmp(commandName,"sf_get_check_sum"))
return 0;
plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL);
if (nrhs>1 && mxIsChar(prhs[1])) {
mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char));
commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0';
if (!strcmp(commandName,"machine")) {
((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3481663297U);
((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1265207950U);
((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3864477944U);
((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(560576562U);
} else if (!strcmp(commandName,"exportedFcn")) {
((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U);
((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U);
((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U);
((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U);
} else if (!strcmp(commandName,"makefile")) {
((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3944709101U);
((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2654201076U);
((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2192031013U);
((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3266425048U);
} else if (nrhs==3 && !strcmp(commandName,"chart")) {
unsigned int chartFileNumber;
chartFileNumber = (unsigned int)mxGetScalar(prhs[2]);
switch (chartFileNumber) {
case 1:
{
extern void sf_c1_mission_server_waypoint_qball2_get_check_sum(mxArray
*plhs[]);
sf_c1_mission_server_waypoint_qball2_get_check_sum(plhs);
break;
}
case 3:
{
extern void sf_c3_mission_server_waypoint_qball2_get_check_sum(mxArray
*plhs[]);
sf_c3_mission_server_waypoint_qball2_get_check_sum(plhs);
break;
}
default:
((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0);
((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0);
((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0);
((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0);
}
} else if (!strcmp(commandName,"target")) {
((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3084158392U);
((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2524169757U);
((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2812955680U);
((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(245732821U);
} else {
return 0;
}
} else {
((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1008512670U);
((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1986449635U);
((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3109432061U);
((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2130845262U);
}
return 1;
#else
return 0;
#endif
}
unsigned int sf_mission_server_waypoint_qball2_autoinheritance_info( int nlhs,
mxArray * plhs[], int nrhs, const mxArray * prhs[] )
{
#ifdef MATLAB_MEX_FILE
char commandName[32];
char aiChksum[64];
if (nrhs<3 || !mxIsChar(prhs[0]) )
return 0;
/* Possible call to get the autoinheritance_info */
mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char));
commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0';
if (strcmp(commandName,"get_autoinheritance_info"))
return 0;
mxGetString(prhs[2], aiChksum,sizeof(aiChksum)/sizeof(char));
aiChksum[(sizeof(aiChksum)/sizeof(char)-1)] = '\0';
{
unsigned int chartFileNumber;
chartFileNumber = (unsigned int)mxGetScalar(prhs[1]);
switch (chartFileNumber) {
case 1:
{
if (strcmp(aiChksum, "IpbYKoUWx6La7nabftny7D") == 0) {
extern mxArray
*sf_c1_mission_server_waypoint_qball2_get_autoinheritance_info(void);
plhs[0] =
sf_c1_mission_server_waypoint_qball2_get_autoinheritance_info();
break;
}
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
break;
}
case 3:
{
if (strcmp(aiChksum, "GgKRvbU3PuLWtBrdJ6yy8B") == 0) {
extern mxArray
*sf_c3_mission_server_waypoint_qball2_get_autoinheritance_info(void);
plhs[0] =
sf_c3_mission_server_waypoint_qball2_get_autoinheritance_info();
break;
}
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
break;
}
default:
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
}
}
return 1;
#else
return 0;
#endif
}
unsigned int sf_mission_server_waypoint_qball2_get_eml_resolved_functions_info
( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] )
{
#ifdef MATLAB_MEX_FILE
char commandName[64];
if (nrhs<2 || !mxIsChar(prhs[0]))
return 0;
/* Possible call to get the get_eml_resolved_functions_info */
mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char));
commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0';
if (strcmp(commandName,"get_eml_resolved_functions_info"))
return 0;
{
unsigned int chartFileNumber;
chartFileNumber = (unsigned int)mxGetScalar(prhs[1]);
switch (chartFileNumber) {
case 1:
{
extern const mxArray
*sf_c1_mission_server_waypoint_qball2_get_eml_resolved_functions_info
(void);
mxArray *persistentMxArray = (mxArray *)
sf_c1_mission_server_waypoint_qball2_get_eml_resolved_functions_info();
plhs[0] = mxDuplicateArray(persistentMxArray);
mxDestroyArray(persistentMxArray);
break;
}
case 3:
{
extern const mxArray
*sf_c3_mission_server_waypoint_qball2_get_eml_resolved_functions_info
(void);
mxArray *persistentMxArray = (mxArray *)
sf_c3_mission_server_waypoint_qball2_get_eml_resolved_functions_info();
plhs[0] = mxDuplicateArray(persistentMxArray);
mxDestroyArray(persistentMxArray);
break;
}
default:
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
}
}
return 1;
#else
return 0;
#endif
}
unsigned int sf_mission_server_waypoint_qball2_third_party_uses_info( int nlhs,
mxArray * plhs[], int nrhs, const mxArray * prhs[] )
{
char commandName[64];
char tpChksum[64];
if (nrhs<3 || !mxIsChar(prhs[0]))
return 0;
/* Possible call to get the third_party_uses_info */
mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char));
commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0';
mxGetString(prhs[2], tpChksum,sizeof(tpChksum)/sizeof(char));
tpChksum[(sizeof(tpChksum)/sizeof(char)-1)] = '\0';
if (strcmp(commandName,"get_third_party_uses_info"))
return 0;
{
unsigned int chartFileNumber;
chartFileNumber = (unsigned int)mxGetScalar(prhs[1]);
switch (chartFileNumber) {
case 1:
{
if (strcmp(tpChksum, "Iynp9aDDBLsTwee4BvyOTD") == 0) {
extern mxArray
*sf_c1_mission_server_waypoint_qball2_third_party_uses_info(void);
plhs[0] = sf_c1_mission_server_waypoint_qball2_third_party_uses_info();
break;
}
}
case 3:
{
if (strcmp(tpChksum, "1dEEoiCAmVutnBhLwrRp2B") == 0) {
extern mxArray
*sf_c3_mission_server_waypoint_qball2_third_party_uses_info(void);
plhs[0] = sf_c3_mission_server_waypoint_qball2_third_party_uses_info();
break;
}
}
default:
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
}
}
return 1;
}
unsigned int sf_mission_server_waypoint_qball2_updateBuildInfo_args_info( int
nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] )
{
char commandName[64];
char tpChksum[64];
if (nrhs<3 || !mxIsChar(prhs[0]))
return 0;
/* Possible call to get the updateBuildInfo_args_info */
mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char));
commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0';
mxGetString(prhs[2], tpChksum,sizeof(tpChksum)/sizeof(char));
tpChksum[(sizeof(tpChksum)/sizeof(char)-1)] = '\0';
if (strcmp(commandName,"get_updateBuildInfo_args_info"))
return 0;
{
unsigned int chartFileNumber;
chartFileNumber = (unsigned int)mxGetScalar(prhs[1]);
switch (chartFileNumber) {
case 1:
{
if (strcmp(tpChksum, "Iynp9aDDBLsTwee4BvyOTD") == 0) {
extern mxArray
*sf_c1_mission_server_waypoint_qball2_updateBuildInfo_args_info(void);
plhs[0] =
sf_c1_mission_server_waypoint_qball2_updateBuildInfo_args_info();
break;
}
}
case 3:
{
if (strcmp(tpChksum, "1dEEoiCAmVutnBhLwrRp2B") == 0) {
extern mxArray
*sf_c3_mission_server_waypoint_qball2_updateBuildInfo_args_info(void);
plhs[0] =
sf_c3_mission_server_waypoint_qball2_updateBuildInfo_args_info();
break;
}
}
default:
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
}
}
return 1;
}
void mission_server_waypoint_qball2_debug_initialize(struct
SfDebugInstanceStruct* debugInstance)
{
_mission_server_waypoint_qball2MachineNumber_ = sf_debug_initialize_machine
(debugInstance,"mission_server_waypoint_qball2","sfun",0,2,0,0,0);
sf_debug_set_machine_event_thresholds(debugInstance,
_mission_server_waypoint_qball2MachineNumber_,0,0);
sf_debug_set_machine_data_thresholds(debugInstance,
_mission_server_waypoint_qball2MachineNumber_,0);
}
void mission_server_waypoint_qball2_register_exported_symbols(SimStruct* S)
{
}
static mxArray* sRtwOptimizationInfoStruct= NULL;
mxArray* load_mission_server_waypoint_qball2_optimization_info(void)
{
if (sRtwOptimizationInfoStruct==NULL) {
sRtwOptimizationInfoStruct = sf_load_rtw_optimization_info(
"mission_server_waypoint_qball2", "mission_server_waypoint_qball2");
mexMakeArrayPersistent(sRtwOptimizationInfoStruct);
}
return(sRtwOptimizationInfoStruct);
}
void unload_mission_server_waypoint_qball2_optimization_info(void)
{
if (sRtwOptimizationInfoStruct!=NULL) {
mxDestroyArray(sRtwOptimizationInfoStruct);
sRtwOptimizationInfoStruct = NULL;
}
}
|
1546d3b5370f6c60c1d52b620699a80d7ac6ad00
|
ea02c5d09c489c747f92a8a17acc0e7041365faa
|
/pkg/wfc3/calwf3/lib/ucalver.c
|
d2f9eb007ec808c226b3012bdd56371acc1a49ac
|
[
"BSD-3-Clause"
] |
permissive
|
spacetelescope/hstcal
|
c7df2c9d1eb25f36544ec8413ab043ee0a0d6610
|
ee90b6885add5fb59980a9f6a29cbecd20cb56b1
|
refs/heads/master
| 2023-08-17T06:32:39.791116 | 2023-08-15T14:37:02 | 2023-08-15T14:37:02 | 52,045,996 | 12 | 26 |
BSD-3-Clause
| 2023-08-30T14:33:46 | 2016-02-18T23:16:28 |
C
|
UTF-8
|
C
| false | false | 637 |
c
|
ucalver.c
|
# include "hstio.h"
# include "wf3version.h" /* defines WF3_CAL_VER */
/* This routine updates the CAL_VER primary header keyword, or adds it
to the header if it's not already present. This keyword gives the
current version number and date that was used.
This routine is used to limit the number of files which need to
be recompiled when the version number is changed. WJH 27 July 1999
*/
void UCalVer (Hdr *phdr) {
/* argument:
Hdr *phdr io: pointer to header; CAL_VER will be updated
*/
int PutKeyStr (Hdr *, char *, char *, char *);
PutKeyStr (phdr, "CAL_VER", WF3_CAL_VER, "version number and date");
}
|
faf0be7330e7645eb7d50ba44fee13b76835deb6
|
efb25a20ecddb3a0a8795bc616069fc1a94e5375
|
/sdk_k64f/boards/frdmk64f/driver_examples/pdb/dac_trigger/pdb_dac_trigger.c
|
9e01d886b79f255c59e7debeac6741c6d32bcfef
|
[
"MIT"
] |
permissive
|
Sir-Branch/k64f-starter-template
|
f6119d67a4d661affca4ca8b5b72a971d0a65754
|
f8959fd185f090363d180d69f84c2727e37cbeeb
|
refs/heads/master
| 2022-12-18T22:24:58.356426 | 2020-09-08T02:52:56 | 2020-09-08T02:52:56 | 289,200,355 | 1 | 0 |
MIT
| 2020-08-24T02:16:20 | 2020-08-21T06:55:08 |
C
|
UTF-8
|
C
| false | false | 8,601 |
c
|
pdb_dac_trigger.c
|
/*
* Copyright (c) 2013 - 2015, Freescale Semiconductor, Inc.
* Copyright 2016-2017 NXP
* All rights reserved.
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include "fsl_debug_console.h"
#include "board.h"
#include "fsl_pdb.h"
#include "fsl_dac.h"
#include "pin_mux.h"
#include "clock_config.h"
/*******************************************************************************
* Definitions
******************************************************************************/
#define DEMO_PDB_BASE PDB0
#define DEMO_PDB_IRQ_ID PDB0_IRQn
#define DEMO_PDB_IRQ_HANDLER PDB0_IRQHandler
#define DEMO_PDB_DELAY_VALUE 1000U
#define DEMO_PDB_MODULUS_VALUE 1000U
#define DEMO_PDB_DAC_INTERVAL_VALUE 800U
#define DEMO_DAC_BASE DAC0
#define DEMO_DAC_CHANNEL kPDB_DACTriggerChannel0
#define DEMO_DAC_IRQ_ID DAC0_IRQn
#define DEMO_DAC_IRQ_HANDLER DAC0_IRQHandler
#define DEMO_DAC_USED_BUFFER_SIZE DAC_DATL_COUNT
/*******************************************************************************
* Prototypes
******************************************************************************/
/*!
* @brief Initialize the DAC.
*/
static void DEMO_InitPDB_DAC(void);
/*******************************************************************************
* Variables
******************************************************************************/
volatile uint32_t g_PdbDelayInterruptCounter;
volatile uint32_t g_PdbDelayInterruptFlag;
#if defined(FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION) && FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION
volatile bool g_DacBufferWatermarkInterruptFlag;
#endif /* FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION */
volatile bool g_DacBufferReadPointerTopPositionInterruptFlag;
volatile bool g_DacBufferReadPointerBottomPositionInterruptFlag;
/*******************************************************************************
* Code
******************************************************************************/
void static DEMO_InitPDB_DAC(void)
{
dac_config_t dacConfigStruct;
dac_buffer_config_t dacBufferConfigStruct;
uint8_t index = 0U;
uint16_t dacValue;
uint32_t mask;
/* Configure the DAC. */
/*
* dacConfigStruct.referenceVoltageSource = kDAC_ReferenceVoltageSourceVref2;
* dacConfigStruct.enableLowPowerMode = false;
*/
DAC_GetDefaultConfig(&dacConfigStruct);
DAC_Init(DEMO_DAC_BASE, &dacConfigStruct);
DAC_Enable(DEMO_DAC_BASE, true);
/* Configure the DAC buffer. */
DAC_GetDefaultBufferConfig(&dacBufferConfigStruct);
dacBufferConfigStruct.triggerMode = kDAC_BufferTriggerByHardwareMode;
DAC_SetBufferConfig(DEMO_DAC_BASE, &dacBufferConfigStruct);
/* Make sure the read pointer to the start. */
DAC_SetBufferReadPointer(DEMO_DAC_BASE, 0U);
dacValue = 0U;
for (index = 0U; index < DEMO_DAC_USED_BUFFER_SIZE; index++)
{
DAC_SetBufferValue(DEMO_DAC_BASE, index, dacValue);
dacValue += (0xFFFU / DEMO_DAC_USED_BUFFER_SIZE);
}
/* Clear flags. */
#if defined(FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION) && FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION
g_DacBufferWatermarkInterruptFlag = false;
#endif /* FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION */
g_DacBufferReadPointerTopPositionInterruptFlag = false;
g_DacBufferReadPointerBottomPositionInterruptFlag = false;
/* Enable interrupts. */
mask = 0U;
#if defined(FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION) && FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION
mask |= kDAC_BufferWatermarkInterruptEnable;
#endif /* FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION */
mask |= kDAC_BufferReadPointerTopInterruptEnable | kDAC_BufferReadPointerBottomInterruptEnable;
DAC_EnableBuffer(DEMO_DAC_BASE, true);
DAC_EnableBufferInterrupts(DEMO_DAC_BASE, mask);
PRINTF("\r\nDAC Buffer Information\r\n");
PRINTF("\t Buffer index max : %d\r\n", dacBufferConfigStruct.upperLimit);
#if defined(FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION) && FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION
PRINTF("\t Buffer watermark : %d\r\n",
dacBufferConfigStruct.upperLimit - (uint8_t)(dacBufferConfigStruct.watermark) - 1U);
#endif /* FSL_FEATURE_DAC_HAS_WATERMARK_SETECTION */
}
/*!
* @brief ISR for PDB interrupt function
*/
void DEMO_PDB_IRQ_HANDLER(void)
{
PDB_ClearStatusFlags(DEMO_PDB_BASE, kPDB_DelayEventFlag);
g_PdbDelayInterruptCounter++;
g_PdbDelayInterruptFlag = true;
/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
exception return operation might vector to incorrect interrupt */
#if defined __CORTEX_M && (__CORTEX_M == 4U)
__DSB();
#endif
}
/*!
* @brief ISR for DAC interrutp function
*/
void DEMO_DAC_IRQ_HANDLER(void)
{
uint32_t flags = DAC_GetBufferStatusFlags(DEMO_DAC_BASE);
#if defined(FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION) && FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION
if (kDAC_BufferWatermarkFlag == (kDAC_BufferWatermarkFlag & flags))
{
g_DacBufferWatermarkInterruptFlag = true;
}
#endif /* FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION */
if (kDAC_BufferReadPointerTopPositionFlag == (kDAC_BufferReadPointerTopPositionFlag & flags))
{
g_DacBufferReadPointerTopPositionInterruptFlag = true;
}
if (kDAC_BufferReadPointerBottomPositionFlag == (kDAC_BufferReadPointerBottomPositionFlag & flags))
{
g_DacBufferReadPointerBottomPositionInterruptFlag = true;
}
/* Clear flags. */
DAC_ClearBufferStatusFlags(DEMO_DAC_BASE, flags);
/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping
exception return operation might vector to incorrect interrupt */
#if defined __CORTEX_M && (__CORTEX_M == 4U)
__DSB();
#endif
}
/*!
* @brief Main function
*/
int main(void)
{
pdb_config_t pdbConfigStruct;
pdb_dac_trigger_config_t pdbDacTriggerConfigStruct;
uint8_t index = 0U;
BOARD_InitPins();
BOARD_BootClockRUN();
BOARD_InitDebugConsole();
EnableIRQ(DEMO_PDB_IRQ_ID);
EnableIRQ(DEMO_DAC_IRQ_ID);
PRINTF("\r\nPDB DAC trigger Example.\r\n");
/* Configure the PDB counter. */
/*
* pdbConfigStruct.loadValueMode = kPDB_LoadValueImmediately;
* pdbConfigStruct.prescalerDivider = kPDB_PrescalerDivider1;
* pdbConfigStruct.dividerMultiplicationFactor = kPDB_DividerMultiplicationFactor1;
* pdbConfigStruct.triggerInputSource = kPDB_TriggerSoftware;
* pdbConfigStruct.enableContinuousMode = false;
*/
PDB_GetDefaultConfig(&pdbConfigStruct);
PDB_Init(DEMO_PDB_BASE, &pdbConfigStruct);
/* Configure the delay interrupt. */
PDB_SetModulusValue(DEMO_PDB_BASE, DEMO_PDB_MODULUS_VALUE);
PDB_SetCounterDelayValue(DEMO_PDB_BASE, DEMO_PDB_DELAY_VALUE);
PDB_EnableInterrupts(DEMO_PDB_BASE, kPDB_DelayInterruptEnable);
/* Configure the DAC trigger. */
pdbDacTriggerConfigStruct.enableExternalTriggerInput = false;
pdbDacTriggerConfigStruct.enableIntervalTrigger = true;
PDB_SetDACTriggerConfig(DEMO_PDB_BASE, DEMO_DAC_CHANNEL, &pdbDacTriggerConfigStruct);
PDB_SetDACTriggerIntervalValue(DEMO_PDB_BASE, DEMO_DAC_CHANNEL, DEMO_PDB_DAC_INTERVAL_VALUE);
PDB_DoLoadValues(DEMO_PDB_BASE);
/* Configure the DAC. */
DEMO_InitPDB_DAC();
PRINTF("Type any key into terminal to trigger the DAC buffer through PDB ...\r\n");
g_PdbDelayInterruptCounter = 0U;
while (1)
{
if (0U == index)
{
PRINTF("\r\n");
}
PRINTF("DAC Buffer Index %2d: ", index);
#if defined(FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION) && FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION
if (g_DacBufferWatermarkInterruptFlag)
{
PRINTF("WatermarkEvent \t");
g_DacBufferWatermarkInterruptFlag = false;
}
#endif /* FSL_FEATURE_DAC_HAS_WATERMARK_SELECTION */
if (g_DacBufferReadPointerTopPositionInterruptFlag)
{
PRINTF("ReadPointerTopPositionEvent \t");
g_DacBufferReadPointerTopPositionInterruptFlag = false;
}
if (g_DacBufferReadPointerBottomPositionInterruptFlag)
{
PRINTF("ReadPointerBottomPositionEvent \t");
g_DacBufferReadPointerBottomPositionInterruptFlag = false;
}
PRINTF("\r\n");
/* Trigger the PDB and then trigger the buffer, move the pointer. */
GETCHAR();
g_PdbDelayInterruptFlag = false;
PDB_DoSoftwareTrigger(DEMO_PDB_BASE);
while (!g_PdbDelayInterruptFlag)
{
}
index++;
if (index >= DEMO_DAC_USED_BUFFER_SIZE)
{
index = 0U;
}
}
}
|
e58f703e122a2afa1f3777e1f977747e4c8ec451
|
f0299ee5631c4333c3db31d567d8ef5ea7d9ec1f
|
/code_and_samples/cbmp.h
|
fceb3fdab9a045c2baa6f99f42d5d0344baf8b8a
|
[] |
no_license
|
s204475/ComputerSystems_A1
|
a274c3ef21876796b740e1b66a950378acd33517
|
91a9e11f56023d0e28f57d82b4eeb84e8f7dee1b
|
refs/heads/main
| 2023-08-03T02:59:22.509299 | 2021-10-06T10:40:17 | 2021-10-06T10:40:17 | 406,726,516 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 392 |
h
|
cbmp.h
|
#ifndef CBMP_CBMP_H
#define CBMP_CBMP_H
#define BMP_WIDTH 950
#define BMP_HEIGTH 950
#define BMP_CHANNELS 3
// Public function declarations
void read_bitmap(char * input_file_path, unsigned char output_image_array[BMP_WIDTH][BMP_HEIGTH][BMP_CHANNELS]);
void write_bitmap(unsigned char input_image_array[BMP_WIDTH][BMP_HEIGTH][BMP_CHANNELS], char * output_file_path);
#endif // CBMP_CBMP_H
|
b623663a413d74451fbb393a088ce473802e4086
|
11a1bd01162a609b8d09b7f0639511c9b318601f
|
/.#MP3.c
|
f53109f46a0807a9791c4d916f5faf867c794b56
|
[] |
no_license
|
clemus55/cisc361
|
89e6378d6ec6cec326b4f3abddc04e51a41aa9bb
|
439c6c58d06a618c7cc60a00532b210d59ce7493
|
refs/heads/master
| 2020-07-29T18:34:50.757760 | 2019-09-21T03:58:38 | 2019-09-21T03:58:38 | 209,919,027 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 44 |
c
|
.#MP3.c
|
clemus@cisc210.cis.udel.edu.18157:1565911005
|
8ef067d1fd53c5ef75d8d95c5a5ed640fd0d0ef6
|
f1910b252cde8cea27235bd93d0d6eee4d70d185
|
/ShouHon/GameData/Backgrounds.h
|
060838da8ee9c1c396d09ad48cbdd353cd7037e8
|
[
"Apache-2.0"
] |
permissive
|
Pharap/ShouHon
|
a3618bd5e8b89cccbbb793cd5259c3c56a52d384
|
d2587a4692cbd05b22766b8c494cc9fddd459479
|
refs/heads/master
| 2022-06-01T18:16:11.812138 | 2022-05-10T17:50:06 | 2022-05-10T17:50:06 | 207,616,484 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 12,371 |
h
|
Backgrounds.h
|
#pragma once
const uint8_t Backgrounds[] PROGMEM =
{
128, 64,
// BG 0
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xFC, 0xFC, 0xFC, 0xFC, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xFC, 0xFC, 0xFC, 0xFC, 0xF8, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xF0, 0x78, 0x1C, 0x0E, 0x07, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xE0, 0xF8, 0xFC, 0xFC, 0xF8, 0xE0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0E, 0x1C, 0x78, 0xF0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xF8, 0x7F, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x1F, 0x7F, 0x7E, 0x3E, 0x1C, 0x0C, 0x80, 0x80, 0xC0, 0xC0, 0xE0, 0xE0, 0xE6, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE6, 0xE0, 0xE0, 0xC0, 0xC0, 0x80, 0x80, 0x0C, 0x1C, 0x3E, 0x7E, 0x7F, 0x1F, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0F, 0x7F, 0xF8, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xFE, 0xFF, 0xE3, 0xC0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x3C, 0x66, 0xC2, 0x80, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x03, 0x01, 0xE1, 0xF8, 0x1C, 0xCE, 0xE6, 0xF3, 0x7B, 0x3B, 0x3B, 0x7B, 0xF3, 0xE6, 0xCE, 0x1C, 0xF8, 0xE1, 0x01, 0x03, 0x03, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0xC0, 0x80, 0xC2, 0x66, 0x3C, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xC0, 0xE3, 0xE7, 0xE6, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0F, 0x1F, 0xFF, 0xFF, 0x1F, 0x0F, 0x07, 0x07, 0x07, 0x87, 0x87, 0x07, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x0E, 0x1C, 0x38, 0x70, 0xE0, 0xC0, 0xC0, 0x80, 0x87, 0x1F, 0x38, 0x73, 0x67, 0xCF, 0xDE, 0xDC, 0xDC, 0xDE, 0xCF, 0x67, 0x73, 0x38, 0x1F, 0x87, 0x80, 0xC0, 0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x0F, 0x1F, 0xFF, 0xFF, 0x1F, 0x0F, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0F, 0x1F, 0x38, 0x3C, 0x0E, 0x07, 0x03, 0x03, 0x07, 0x8E, 0xDC, 0xF8, 0x70, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x07, 0x07, 0x07, 0x07, 0x87, 0xFF, 0xFF, 0xFF, 0xFF, 0x87, 0x07, 0x07, 0x07, 0x07, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xFC, 0x7E, 0x7F, 0x7F, 0x7F, 0x3E, 0x1C, 0x00, 0x00, 0x00, 0xC0, 0xF8, 0x7F, 0x0F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x1E, 0x3F, 0x3F, 0x1E, 0x0C, 0x01, 0x00, 0x80, 0x80, 0x81, 0x83, 0xC7, 0xEE, 0x7C, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0F, 0x1F, 0x39, 0x70, 0xE0, 0xC0, 0x80, 0x00, 0x80, 0xC0, 0xE0, 0x78, 0x3E, 0x0F, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x1F, 0x3F, 0x3F, 0x3F, 0x1F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0F, 0x0F, 0x0F, 0x0F, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// BG 1
0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x1, 0xFD, 0x5, 0x35, 0x35, 0x5, 0x85, 0xC5, 0xC5, 0x85, 0x5, 0x5, 0xFD, 0x1, 0x77, 0x77, 0x00, 0xFE, 0x2, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0x2, 0xFE, 0x00, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x1, 0x55, 0x1, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x1, 0x55, 0x1, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x00, 0xFE, 0x2, 0xFA, 0xFA, 0x2, 0xFE, 0x00, 0x00, 0xFE, 0x2, 0xFA, 0xFA, 0x2, 0xFE, 0x00, 0x77, 0x7, 0xE7, 0xA7, 0xA7, 0xE7, 0x7, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x60, 0x6F, 0x68, 0x6A, 0x6A, 0x6B, 0x6B, 0x6B, 0x6B, 0x6B, 0x6B, 0x68, 0x6F, 0x60, 0x77, 0x77, 0x00, 0xBF, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xBE, 0xB2, 0xB2, 0xBF, 0x00, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x70, 0x75, 0x70, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x75, 0x70, 0x75, 0x70, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x00, 0x7F, 0x40, 0x5F, 0x5F, 0x40, 0x7F, 0x00, 0x00, 0x7F, 0x40, 0x5F, 0x5F, 0x40, 0x7F, 0x00, 0x77, 0x70, 0x77, 0x75, 0x75, 0x77, 0x70, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0x6, 0xF9, 0xFD, 0x86, 0x7A, 0x7A, 0x7A, 0x7A, 0x7A, 0x7A, 0x7A, 0x7A, 0x86, 0xFD, 0xFB, 0x7, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xA0, 0xDF, 0xBF, 0x7F, 0x43, 0x5B, 0x5B, 0x5B, 0x5B, 0x5B, 0x5B, 0x43, 0x7F, 0xBF, 0x9F, 0x60, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F, 0xBE, 0xDD, 0xEB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F,
};
|
3c20fe5a3c04361e6cfa3925a280d6925faf3645
|
b67e749f6f1dc705bf22737c9892f1ce9a04521e
|
/Pods/Headers/Private/CZCommonLib/UIColor+YYOUHexString.h
|
46e506df639d5f5ae4fa61b5ac11b2c0a313b57d
|
[] |
no_license
|
sweetlyGit/YYOUCarOWnerAPP
|
3f877edb55df8a3254479986e07319044e028377
|
a5013383c903963d6ca1a4bee0674ba7ac5e9858
|
refs/heads/master
| 2020-04-10T21:52:59.506712 | 2018-12-12T06:35:21 | 2018-12-12T06:35:21 | 161,309,239 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 134 |
h
|
UIColor+YYOUHexString.h
|
../../../../YYOUCarOwnerAPP/YYOUCarOwnerAPP/YYOUCarComponentLib/CZCommonLib/CZCommonLib/Classes/CommonCategory/UIColor+YYOUHexString.h
|
bf8c40ed803e1c56fa23e7a70e6d466b6e934184
|
c95bb2e91ecc8f3debbe968240ea80843e8b1858
|
/get_hook.c
|
704e187e08c7f5bf8e3c36132dd5c50a5834a22e
|
[] |
no_license
|
solo4games/projects-school
|
ddbb59c8efded665226f47ec8c81388238a3299f
|
9e8ed375cde18f6a930218e64fbc18be13a2b186
|
refs/heads/main
| 2023-03-27T00:56:30.781236 | 2021-03-29T11:41:56 | 2021-03-29T11:41:56 | 337,801,836 | 1 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,951 |
c
|
get_hook.c
|
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_hook.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lbrandy <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/03/21 10:35:49 by lbrandy #+# #+# */
/* Updated: 2021/03/21 13:10:03 by lbrandy ### ########.fr */
/* */
/* ************************************************************************** */
#include "cub3d.h"
int ft_press_but(int keycode, t_all *all)
{
if (keycode == 13)
all->hooks->key_w = 1;
if (keycode == 0)
all->hooks->key_a = 1;
if (keycode == 1)
all->hooks->key_s = 1;
if (keycode == 2)
all->hooks->key_d = 1;
if (keycode == 53)
all->hooks->key_esc = 1;
if (keycode == 124)
all->hooks->key_rot_right = 1;
if (keycode == 123)
all->hooks->key_rot_left = 1;
all->hooks->flag = 1;
return (0);
}
int ft_release_but(int keycode, t_all *all)
{
if (keycode == 13)
all->hooks->key_w = 0;
if (keycode == 0)
all->hooks->key_a = 0;
if (keycode == 1)
all->hooks->key_s = 0;
if (keycode == 2)
all->hooks->key_d = 0;
if (keycode == 53)
all->hooks->key_esc = 0;
if (keycode == 124)
all->hooks->key_rot_right = 0;
if (keycode == 123)
all->hooks->key_rot_left = 0;
if (all->hooks->key_rot_left == 0 && all->hooks->key_rot_left == 0 &&
all->hooks->key_esc == 0 && all->hooks->key_d == 0 &&
all->hooks->key_s == 0 && all->hooks->key_a == 0 &&
all->hooks->key_w == 0)
all->hooks->flag = 0;
return (0);
}
|
b4cd7199a32e61b21687b64b9790dee665e014eb
|
b7105dac47c199fa73ad750a49959affa3eaff25
|
/XiaoCongModbus/httpserver.h
|
bd398581829037ee3557004668ef5be8936ff5be
|
[] |
no_license
|
tsyj11/WeChatXiaoCong
|
1b54e03b1fd83221a3edb42f860b69288b227000
|
127c7a5445b99a9ee59d82a35adf1fec7201ed9b
|
refs/heads/master
| 2020-09-07T13:23:45.769352 | 2019-11-16T01:29:34 | 2019-11-16T01:29:34 | 220,794,447 | 0 | 1 | null | null | null | null |
UTF-8
|
C
| false | false | 3,479 |
h
|
httpserver.h
|
char temphtml[1600];
void sendIndex()
{
sprintf(temphtml, "<html><head><meta charset='utf-8'><title>配置</title></head><body><form action='/' method='POST'><fieldset><legend align='center'>网页配置</legend><table align='center'><tr><td>设备SN号</td><td><p>%s</p></td></tr><tr><td>设备名字</td><td><input type='text' name='name' value='%s'></td></tr><tr><td>路由SSID:</td><td><input type='text' name='ssid' value='%s'></td></tr><tr><td>路由密码:</td><td><input type='text' name='pwd' value='%s'></td></tr><tr><td>登陆账号:</td><td><input type='text' name='wacc' value='%s'></td></tr><tr><td>登陆密码:</td><td><input type='text' name='wpwd' value='%s'></td></tr><tr><td>微信ID:</td><td><input type='text' name='wxid' value='%s'></td></tr><tr><td>手机appid:</td><td><input type='text' name='appid' value='%s'></td></tr><tr><td>手机管理员:</td><td><input type='text' name='gsmTo' value='%s'></td></tr><tr><td>配对码:</td><td><input type='text' name='code' value='%s'></td></tr><tr><td colspan='2' align='center'><button type='submit'>更新</button></td></tr></table></fieldset></form><fieldset><legend align='center'>固件更新</legend><table align='center'><tr><td colspan='2' align='center'><button onclick='window.location.href="/update"'>升级</button></td></tr></table></fieldset></body></html>", clientID, mSavePara.Para.nickname, mSavePara.Para.stassid, mSavePara.Para.stapasswd, mSavePara.Para.authname, mSavePara.Para.authpasswd, mSavePara.Para.openID, mSavePara.Para.appid, mSavePara.Para.gsmTo[0], mSavePara.Para.usercode);
httpserver.send_P(200, "text/html", temphtml);
}
void HttpServerInit() {
httpserver.on("/", HTTP_GET, []() {
sendIndex();
});
httpserver.on("/", HTTP_POST, []() {
String name = httpserver.arg("name");
String stassid = httpserver.arg("ssid");
String stapasswd = httpserver.arg("pwd");
String authname = httpserver.arg("wacc");
String authpasswd = httpserver.arg("wpwd");
String appid = httpserver.arg("appid");
String openid = httpserver.arg("wxid");
String usercode = httpserver.arg("code");
String gsmTo = httpserver.arg("gsmTo");
gsmTo.trim();
name.trim();
stassid.trim();
stapasswd.trim();
authname.trim();
authpasswd.trim();
openid.trim();
appid.trim();
usercode.trim();
if (name.length() < sizeof(mSavePara.Para.nickname) - 1) strcpy(mSavePara.Para.nickname, name.c_str());
if (authname.length() < sizeof(mSavePara.Para.authname) - 1) strcpy(mSavePara.Para.authname, authname.c_str());
if (authpasswd.length() < sizeof(mSavePara.Para.authpasswd) - 1) strcpy(mSavePara.Para.authpasswd, authpasswd.c_str());
if (stassid.length() < sizeof(mSavePara.Para.stassid) - 1) strcpy(mSavePara.Para.stassid, stassid.c_str());
if (stapasswd.length() < sizeof(mSavePara.Para.stapasswd) - 1) strcpy(mSavePara.Para.stapasswd, stapasswd.c_str());
if (openid.length() < sizeof(mSavePara.Para.openID) - 1) strcpy(mSavePara.Para.openID, openid.c_str());
if (appid.length() < sizeof(mSavePara.Para.appid) - 1) strcpy(mSavePara.Para.appid, appid.c_str());
if (gsmTo.length() < sizeof(mSavePara.Para.gsmTo[0]) - 1) strcpy(mSavePara.Para.gsmTo[0], gsmTo.c_str());
if (usercode.length() > 0 && usercode.length() < sizeof(mSavePara.Para.usercode) - 1) strcpy(mSavePara.Para.usercode, usercode.c_str());
CheckSaveConfig();
sendIndex();
});
httpserver.onNotFound([]() {
sendIndex();
});
httpUpdater.setup(&httpserver);
httpserver.begin();
}
|
a1a13ea700a7cc8e2087f2576f841a0313b16d78
|
83ff162589191b9bd9b3f25dc18e3eff41f98152
|
/UART/main.c
|
5a9d2ef7c24b13d7c98873628510f0c70edb9bd4
|
[] |
no_license
|
Arv1k/stm32
|
4dc5974ab0c61e84a1a71187d698b6178de0ed4f
|
b70f2560998fb2f36f569594b7fc5026d78ad38f
|
refs/heads/master
| 2022-11-25T05:17:22.011256 | 2020-07-17T20:27:11 | 2020-07-17T20:27:11 | 186,613,294 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 5,548 |
c
|
main.c
|
/*
* This example demonstrates using USART
*/
#include "stm32f0xx_ll_rcc.h"
#include "stm32f0xx_ll_system.h"
#include "stm32f0xx_ll_bus.h"
#include "stm32f0xx_ll_gpio.h"
#include "stm32f0xx_ll_usart.h"
#include "xprintf.h"
#include "oled_driver.h"
char mail[64] = "";
char word_is_full = 0;
/**
* System Clock Configuration
* The system Clock is configured as follow :
* System Clock source = PLL (HSI/2)
* SYSCLK(Hz) = 48000000
* HCLK(Hz) = 48000000
* AHB Prescaler = 1
* APB1 Prescaler = 1
* HSI Frequency(Hz) = 8000000
* PLLMUL = 12
* Flash Latency(WS) = 1
*/
static void rcc_config()
{
/* Set FLASH latency */
LL_FLASH_SetLatency(LL_FLASH_LATENCY_1);
/* Enable HSI and wait for activation*/
LL_RCC_HSI_Enable();
while (LL_RCC_HSI_IsReady() != 1);
/* Main PLL configuration and activation */
LL_RCC_PLL_ConfigDomain_SYS(LL_RCC_PLLSOURCE_HSI_DIV_2,
LL_RCC_PLL_MUL_12);
LL_RCC_PLL_Enable();
while (LL_RCC_PLL_IsReady() != 1);
/* Sysclk activation on the main PLL */
LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_1);
LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_PLL);
while (LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_PLL);
/* Set APB1 prescaler */
LL_RCC_SetAPB1Prescaler(LL_RCC_APB1_DIV_1);
/* Update CMSIS variable (which can be updated also
* through SystemCoreClockUpdate function) */
SystemCoreClock = 48000000;
}
/*
* Clock on GPIOC and set two led pins
*/
static void gpio_config(void)
{
LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOA);
LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOC);
LL_GPIO_SetPinMode(GPIOC, LL_GPIO_PIN_8, LL_GPIO_MODE_OUTPUT);
LL_GPIO_SetPinMode(GPIOC, LL_GPIO_PIN_9, LL_GPIO_MODE_OUTPUT);
return;
}
/*
* Initialize USART module and associated pins
*/
static void usart_config(void)
{
/*
* Setting USART pins
*/
LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOA);
//USART1_TX
LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_9, LL_GPIO_MODE_ALTERNATE);
LL_GPIO_SetAFPin_8_15(GPIOA, LL_GPIO_PIN_9, LL_GPIO_AF_1);
LL_GPIO_SetPinSpeed(GPIOA, LL_GPIO_PIN_9, LL_GPIO_SPEED_FREQ_HIGH);
//USART1_RX
LL_GPIO_SetPinMode(GPIOA, LL_GPIO_PIN_10, LL_GPIO_MODE_ALTERNATE);
LL_GPIO_SetAFPin_8_15(GPIOA, LL_GPIO_PIN_10, LL_GPIO_AF_1);
LL_GPIO_SetPinSpeed(GPIOA, LL_GPIO_PIN_10, LL_GPIO_SPEED_FREQ_HIGH);
/*
* USART Set clock source
*/
LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_USART1);
LL_RCC_SetUSARTClockSource(LL_RCC_USART1_CLKSOURCE_PCLK1);
/*
* USART Setting
*/
LL_USART_SetTransferDirection(USART1, LL_USART_DIRECTION_TX_RX);
LL_USART_SetParity(USART1, LL_USART_PARITY_NONE);
LL_USART_SetDataWidth(USART1, LL_USART_DATAWIDTH_8B);
LL_USART_SetStopBitsLength(USART1, LL_USART_STOPBITS_1);
LL_USART_SetTransferBitOrder(USART1, LL_USART_BITORDER_LSBFIRST);
LL_USART_SetBaudRate(USART1, SystemCoreClock, LL_USART_OVERSAMPLING_16, 115200);
LL_USART_EnableIT_IDLE(USART1);
LL_USART_EnableIT_RXNE(USART1);
/*
* USART turn on
*/
LL_USART_Enable(USART1);
while (!(LL_USART_IsActiveFlag_TEACK(USART1) && LL_USART_IsActiveFlag_REACK(USART1)));
/*
* Turn on NVIC interrupt line
*/
NVIC_SetPriority(USART1_IRQn, 0);
NVIC_EnableIRQ(USART1_IRQn);
return;
}
static void send_message(char* buffer)
{
uint32_t i = 0;
while (buffer[i] != '\0')
{
while(!LL_USART_IsActiveFlag_TXE(USART1));
LL_USART_TransmitData8(USART1, buffer[i]);
i++;
//while (!LL_USART_IsActiveFlag_TC(USART1));
}
while (!LL_USART_IsActiveFlag_TC(USART1));
LL_GPIO_SetOutputPin(GPIOC, LL_GPIO_PIN_8);
return;
}
void USART1_IRQHandler(void)
{
static uint32_t i = 0;
if(LL_USART_IsActiveFlag_RXNE(USART1))
{
mail[i] = LL_USART_ReceiveData8(USART1);
i++;
LL_GPIO_SetOutputPin(GPIOC, LL_GPIO_PIN_9);
}
if (LL_USART_IsActiveFlag_IDLE(USART1))
{
word_is_full = 1;
mail[i] = '\0';
i = 0;
LL_USART_ClearFlag_IDLE(USART1);
}
}
static void decoder(void)
{
int i = 0;
while(mail[i] != '\0')
{
if (mail[i] > 'G')
mail[i] -= 7;
else
{
if (mail[i] == 'G')
mail[i] = 'Z';
if (mail[i] == 'F')
mail[i] = 'Y';
if (mail[i] == 'E')
mail[i] = 'X';
if (mail[i] == 'D')
mail[i] = 'W';
if (mail[i] == 'C')
mail[i] = 'V';
if (mail[i] == 'B')
mail[i] = 'U';
if (mail[i] == 'A')
mail[i] = 'T';
}
i++;
}
return;
}
static void printf_config(void)
{
xdev_out(oled_putc);
return;
}
int main(void)
{
rcc_config();
gpio_config();
oled_config();
printf_config();
usart_config();
//xprintf("Airat pidoras\n");
//oled_update();
//send_message("123");
//xprintf("%s", mail);
//oled_update();
while(1)
{
if(word_is_full == 1)
{
decoder();
xprintf("%s\n", mail);
oled_update();
word_is_full = 0;
}
}
return 0;
}
|
ae2aa5053dcc598da07221fa43195a3899973b7a
|
7cb8b58bf4fd50769178c98bdf45ea75d6b66bab
|
/player.h
|
50bdf34d9689daf55105476868c977d6d4f7f1a0
|
[] |
no_license
|
yutaro0o/twinspsychics
|
1f4377de262b045b03831d8dba26c2e60e32563e
|
0f409d796193b7efe30f071948ddf50b2d85bd80
|
refs/heads/master
| 2020-12-06T12:19:45.819681 | 2020-01-28T06:55:57 | 2020-01-28T06:55:57 | 232,462,819 | 0 | 0 | null | null | null | null |
SHIFT_JIS
|
C
| false | false | 2,450 |
h
|
player.h
|
#ifndef _PLAYER_H_
#define _PLAYER_H_
#include "mydef.h"
enum CHARA_IMAGE {
CHARA_KIND_1 = 0,
CHARA_KIND_2 = 3,
CHARA_KIND_3 = 6
};//キャラの種類の列挙型
struct STRUCT_CHARACTOR
{
char FilePath[128];
int Handle[CHARA_YOKO_NUM * CHARA_TATE_NUM];//画像のハンドル
int X[CHARA_YOKO_NUM * CHARA_TATE_NUM];//横の位置
int Y[CHARA_YOKO_NUM * CHARA_TATE_NUM];//縦の位置
int Width[CHARA_YOKO_NUM * CHARA_TATE_NUM];//横のサイズ
int Height[CHARA_YOKO_NUM * CHARA_TATE_NUM];//縦のサイズ
int C_Width[CHARA_YOKO_NUM * CHARA_TATE_NUM];//横の中心位置
int C_Height[CHARA_YOKO_NUM * CHARA_TATE_NUM];//縦の中心位置
};//CHARA構造体
typedef STRUCT_CHARACTOR CHARA;
struct STRUCT_PLAYER
{
int Handle[CHARA_MOTION_NUM];//画像のハンドル
int X;//横の位置
int Y;//縦の位置
int Width;//横のサイズ
int Height;//縦のサイズ
int C_Width;//横の中心位置
int C_Height;//縦の中心位置
int NowHandleNum;//現在の画像のハンドル
int NowHandleCnt;//現在のハンドルカウント
int NowHandleCntMAX;//現在のハンドルカウントMAX
int Speed;//速度
int MoveDist;//移動距離
BOOL CanMoveLeft; //左に行けるか
BOOL CanMoveRight;//右に行けるか
BOOL CanMoveUp;//上に行けるか
BOOL CanMoveDown;//下に行けるか
int atariX;//当たり判定のX位置
int atariY;//当たり判定のY位置
int atariWidth;//当たり判定の幅
int atariHeight;//当たり判定の高さ
RECT atariRect;//当たり判定の矩形領域
};//PLAYER構造体
typedef STRUCT_PLAYER PLAYER;
extern CHARA CharaImage;
extern PLAYER Myplayer;
extern PLAYER Myplayer2;
BOOL MY_CHARA_LOAD_BUNKATSU(CHARA*, int, int, int, int, int, const char *);//CHARAを分割して読み込む設定をする関数
BOOL MY_INIT_PLAYER(PLAYER *, CHARA, int *, int, int, int);//プレイヤーを初期化する関数
void MY_PLAY_PLAYER_OPERATION(void);
BOOL MY_CHECK_RECT_ATARI_CHARA_MAP_ATARIBASHO(RECT, RECT map[MAP_TATE_NUM][MAP_YOKO_NUM], int *, int *);
void MY_SET_PLAYER_ATARI(PLAYER *);//プレイヤーの当たり判定の領域を設定する関数
BOOL MY_CHECK_RECT_ATARI(RECT, RECT);//領域の当たり判定をする関数
BOOL MY_CHECK_RECT_ATARI_CHARA_MAP(RECT, RECT[MAP_TATE_NUM][MAP_YOKO_NUM]);//マップとの当たり判定をする関数
void MY_PLAY_PLAYER_DRAW(void);
void MY_PLAY_PLAYER_DRAW2(void);
BOOL MY_PLAY_INIT(void);
#endif
|
9fa20b1aa9a4b4bbb3ee4e833899991da21689dd
|
314de55e869998adb1d563f0eb26a98705b3ddb9
|
/PSU/PSU_my_sokoban_2018/srcs/display_usage.c
|
d1060ec72e1456cf8c414a46bb2181137e85b49f
|
[] |
no_license
|
BBryan-S/Tek1
|
f678decb060bf4e515e3876e53e417eccb8ed7eb
|
b559715a305d3ede14f79695f4566761c2260d40
|
refs/heads/master
| 2023-03-19T00:27:21.439087 | 2020-08-31T09:03:50 | 2020-08-31T09:03:50 | 291,504,287 | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 446 |
c
|
display_usage.c
|
/*
** EPITECH PROJECT, 2018
** display_usage.c
** File description:
** display_usage
*/
#include "../include/lib.h"
int display_usage(void)
{
my_putstr("USAGE\n ./my_sokoban map\n");
my_putstr("DESCRIPTION\n map file representing the warehouse map, ");
my_putstr("containing ‘#’ for walls,\n ‘P’ for the player, ");
my_putstr("‘X’ for boxes and ‘O’ for storage locations.\n");
return (0);
}
|
ce6691c05c2be61d6abb5d11458334ee78843f75
|
7d33f1f87e4303abf2db48353304c94e67134ed1
|
/Jokoa/source/spriteak.c
|
2580aac082b9e1dc4b6fae93319c1b0652a482c6
|
[] |
no_license
|
cubedtear/Nonograma
|
b129277999a465eb4fd881356e2af656ca7bd780
|
162648c6f24c5cecf8326056f084445a68b7a3c9
|
refs/heads/master
| 2021-01-14T08:47:05.455431 | 2015-05-22T15:06:25 | 2015-05-22T15:06:25 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C
| false | false | 1,918 |
c
|
spriteak.c
|
/*---------------------------------------------------------------------------------
Kode hau garatu da dovotoren "Simple sprite demo" adibidean eta Jaeden Ameronen beste
adibide batean oinarrituta.
---------------------------------------------------------------------------------*/
#include <nds.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "spriteak.h"
#include "definizioak.h"
u16* gfx_beltza;
void memoriaErreserbatu()
{
gfx_beltza= oamAllocateGfx(&oamMain, SpriteSize_16x16, SpriteColorFormat_256Color);
}
void PaletaNagusiaEzarri() {
SPRITE_PALETTE[1] = RGB15(0,0,0);
}
u8 beltza[256] =
{
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
};
void SpriteakMemorianGorde(){
int i;
for(i = 0; i < 16 * 16 / 2; i++)
{
gfx_beltza[i] = beltza[i*2] | (beltza[(i*2)+1]<<8);
}
}
void ErakutsiBeltza(int indizea, int x, int y)
{
oamSet(&oamMain,
indizea,
x, y,
0,
0,
SpriteSize_16x16,
SpriteColorFormat_256Color,
gfx_beltza,
-1,
false,
false,
false, false,
false
);
oamUpdate(&oamMain);
}
void EzabatuBeltza(int indizea, int x, int y)
{
oamSet(&oamMain,
indizea,
x, y,
0,
0,
SpriteSize_16x16,
SpriteColorFormat_256Color,
gfx_beltza,
-1,
false,
true,
false, false,
false
);
oamUpdate(&oamMain);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.