instruction
stringlengths 27
1.88k
| output
stringlengths 21
2.78k
|
|---|---|
void qat_hal_reset_timestamp(byte **param_1)
{
uint uVar1;
byte local_d;
uVar1 = GET_GLB_CSR(param_1,MISC_CONTROL);
if ((MC_TIMESTAMP_ENABLE & uVar1) != 0) {
SET_GLB_CSR(param_1,MISC_CONTROL,~MC_TIMESTAMP_ENABLE & uVar1);
}
for (local_d = 0; local_d < **param_1; local_d = local_d + 1) {
qat_hal_wr_ae_csr(param_1,local_d,TIMESTAMP_LOW,0);
qat_hal_wr_ae_csr(param_1,local_d,TIMESTAMP_HIGH,0);
}
SET_GLB_CSR(param_1,MISC_CONTROL,MC_TIMESTAMP_ENABLE | uVar1);
return;
}
|
void qat_hal_reset_timestamp(struct icp_qat_fw_loader_handle *handle)
{
unsigned int misc_ctl;
unsigned char ae;
/* stop the timestamp timers */
misc_ctl = GET_GLB_CSR(handle, MISC_CONTROL);
if (misc_ctl & MC_TIMESTAMP_ENABLE)
SET_GLB_CSR(handle, MISC_CONTROL, misc_ctl &
(~MC_TIMESTAMP_ENABLE));
for (ae = 0; ae < handle->hal_handle->ae_max_num; ae++) {
qat_hal_wr_ae_csr(handle, ae, TIMESTAMP_LOW, 0);
qat_hal_wr_ae_csr(handle, ae, TIMESTAMP_HIGH, 0);
}
/* start timestamp timers */
SET_GLB_CSR(handle, MISC_CONTROL, misc_ctl | MC_TIMESTAMP_ENABLE);
}
|
undefined4 LSM6DSM_ACC_GYRO_R_XLDA(undefined8 param_1,uint *param_2)
{
int iVar1;
undefined4 uVar2;
iVar1 = LSM6DSM_ACC_GYRO_ReadReg(param_1,0x1e,param_2);
uVar2 = MEMS_ERROR;
if (iVar1 != 0) {
*param_2 = *param_2 & 1;
uVar2 = MEMS_SUCCESS;
}
return uVar2;
}
|
status_t LSM6DSM_ACC_GYRO_R_XLDA(void *handle, LSM6DSM_ACC_GYRO_XLDA_t *value)
{
if( !LSM6DSM_ACC_GYRO_ReadReg(handle, 0X1E, (u8_t *)value) )
return MEMS_ERROR;
*value &= 0x01;
return MEMS_SUCCESS;
}
|
void norm2diff_h2matrix(undefined8 *param_1,undefined8 param_2)
{
norm2diff_matrix(mvm_h2matrix_avector,param_1,mvm_h2matrix_avector & 0xffffffff,param_2,
**(undefined4 **)param_1[1],**(undefined4 **)*param_1);
return;
}
|
real
norm2diff_h2matrix(pch2matrix a, pch2matrix b)
{
return norm2diff_matrix((mvm_t) mvm_h2matrix_avector, (void *) a,
(mvm_t) mvm_h2matrix_avector, (void *) b,
a->rb->t->size, a->cb->t->size);
}
|
void printTime(void)
{
double dVar1;
FILE *__stream;
long in_FS_OFFSET;
undefined local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
gettimeofday((timeval *)local_38,(__timezone_ptr_t)0x0);
dVar1 = time_start;
__stream = fopen("/tmp/utimer","w");
if (__stream != (FILE *)0x0) {
fprintf(__stream,"[%12f]\n",((double)local_38._8_4_ * __LC2 + (double)local_38._0_8_) - dVar1);
fclose(__stream);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void printTime (int s) {
struct timeval tv;
double time_next;
FILE* fd;
gettimeofday (&tv,NULL);
time_next = tv.tv_sec + tv.tv_usec*1E-6 - time_start;
if ((fd = fopen ("/tmp/utimer","w")) != NULL) {
fprintf (fd,"[%12f]\n",time_next);
fclose (fd);
}
}
|
void it87_read_value(long *param_1,undefined4 param_2)
{
outb_p(param_2,IT87_ADDR_REG_OFFSET + *param_1);
inb_p(IT87_DATA_REG_OFFSET + *param_1);
return;
}
|
int it87_read_value(struct it87_data *data, u8 reg)
{
outb_p(reg, data->addr + IT87_ADDR_REG_OFFSET);
return inb_p(data->addr + IT87_DATA_REG_OFFSET);
}
|
undefined8 t2(void)
{
int iVar1;
iVar1 = atomic_load_explicit(vars,memory_order_seq_cst);
atomic_store_explicit(&atom_2_r1_1,iVar1 == 1,memory_order_seq_cst);
atomic_store_explicit(&atom_2_r1_2,iVar1 == 2,memory_order_seq_cst);
atomic_store_explicit(&atom_2_r1_0,iVar1 == 0,memory_order_seq_cst);
return 0;
}
|
void *t2(void *arg){
label_3:;
int v6_r1 = atomic_load_explicit(&vars[0], memory_order_seq_cst);
int v35 = (v6_r1 == 1);
atomic_store_explicit(&atom_2_r1_1, v35, memory_order_seq_cst);
int v36 = (v6_r1 == 2);
atomic_store_explicit(&atom_2_r1_2, v36, memory_order_seq_cst);
int v37 = (v6_r1 == 0);
atomic_store_explicit(&atom_2_r1_0, v37, memory_order_seq_cst);
return NULL;
}
|
undefined8 main(void)
{
int iVar1;
time_t tVar2;
puts("\nBeginning Random Number generation from the set 1, 4, 7, 10, 13, 16....\n");
tVar2 = time((time_t *)0x0);
srand((uint)tVar2);
iVar1 = rand();
printf("Random Number is: %d\n\n",(ulong)((iVar1 % 6) * 3 + 1));
return 0;
}
|
int main ()
{
int rand1;
printf ("\nBeginning Random Number generation from the set 1, 4, 7, 10, 13, 16....\n\n");
srand (time(NULL));
rand1 = rand ();
rand1 = ((rand1 % 6) * 3) + 1;
printf ("Random Number is: %d\n\n", rand1);
return 0;
}
|
void shoebill_start(void)
{
shoe._0_4_ = 1;
pthread_mutex_unlock((pthread_mutex_t *)(shoe + 8));
pthread_mutex_unlock((pthread_mutex_t *)(shoe + 4));
return;
}
|
void shoebill_start()
{
shoe.running = 1;
pthread_mutex_unlock(&shoe.via_clock_thread_lock);
pthread_mutex_unlock(&shoe.cpu_thread_lock);
}
|
void main(void)
{
f(u);
return;
}
|
int main(void) {
return f(u);
}
|
undefined8 zztGetDisplayColor(undefined8 param_1,undefined4 param_2,undefined4 param_3)
{
int iVar1;
undefined4 *puVar2;
undefined8 uVar3;
puVar2 = (undefined4 *)zztBoardGetCurPtr();
iVar1 = zztBoardDecompress(puVar2);
uVar3 = 0x3f;
if (iVar1 != 0) {
uVar3 = zztTileGetDisplayColor(*puVar2,param_2,param_3);
}
return uVar3;
}
|
u_int8_t zztGetDisplayColor(ZZTworld * world, int x, int y) {
ZZTboard* brd = zztBoardGetCurPtr(world);
if (!zztBoardDecompress(brd))
return '?';
return zztTileGetDisplayColor(brd->bigboard, x, y);
}
|
void d_listnoun(void)
{
int iVar1;
long lVar2;
writestr(" NOUN ");
padout(0x15);
writeln(" LOCATION ");
writestr(" ------");
padout(0x15);
writeln(" ----------");
writeln(&_LC4);
iVar1 = print_objid(1);
padout(0x1b - iVar1);
writestr(&_LC5);
print_objid(loc);
writeln(&_LC6);
if (-1 < maxnoun - first_noun) {
lVar2 = 0;
do {
iVar1 = print_objid(first_noun + (int)lVar2);
if (0 < 0x1b - iVar1) {
padout();
}
writestr(&_LC5);
print_objid(*(undefined4 *)(noun + lVar2 * 4));
writeln(&_LC6);
lVar2 = lVar2 + 1;
} while ((int)lVar2 <= maxnoun - first_noun);
}
return;
}
|
void d_listnoun(void)
{
int i;
int len;
writestr(" NOUN ");padout(27 -6);writeln(" LOCATION ");
writestr(" ------");padout(27 -6);writeln(" ----------");
writeln("");
len=27 -print_objid(1);
padout(len);
writestr("[");
print_objid(loc);
writeln("]");
for(i=0;i<=maxnoun-first_noun;i++) {
len=print_objid(i+first_noun);
len=27 -len;
if (len>0) padout(len);
writestr("[");
print_objid(noun[i].location);
writeln("]");
}
}
|
bool makeLogfilename(char *param_1,ulong param_2,undefined8 param_3,int param_4)
{
int iVar1;
undefined *puVar2;
bool bVar3;
puVar2 = &_LC0;
if (param_4 == 0) {
puVar2 = &_LC1;
}
iVar1 = snprintf(param_1,param_2,"%s/jd_proc_%.5lu_std%s.log",prog_state,param_3,puVar2);
bVar3 = false;
if (0 < iVar1) {
bVar3 = (ulong)(long)iVar1 < param_2;
}
return bVar3;
}
|
int makeLogfilename(char* buf, size_t bufsize, size_t jobindex, int is_stderr) {
int ret = snprintf(buf, bufsize, "%s/jd_proc_%.5lu_std%s.log",
prog_state.tempdir, (unsigned long) jobindex, is_stderr ? "err" : "out");
return ret > 0 && (size_t) ret < bufsize;
}
|
double mu(ulong param_1,long param_2,long param_3,long param_4)
{
ulong uVar1;
double *pdVar2;
double dVar3;
double dVar4;
if (param_1 == 0) {
dVar3 = 0.0;
}
else {
pdVar2 = (double *)(param_3 + param_4 * 8);
uVar1 = 0;
dVar3 = 0.0;
do {
dVar3 = dVar3 + *pdVar2;
uVar1 = uVar1 + 1;
pdVar2 = pdVar2 + param_2;
} while (param_1 != uVar1);
}
if ((long)param_1 < 0) {
dVar4 = (double)(param_1 >> 1 | (ulong)((uint)param_1 & 1));
dVar4 = dVar4 + dVar4;
}
else {
dVar4 = (double)param_1;
}
return dVar3 / dVar4;
}
|
double
mu(size_t r, size_t c, double X[r][c], size_t l)
{
size_t i;
double m;
m = 0.0;
for (i = 0; i < r; i++)
m += X[i][l];
return m / r;
}
|
bool is_center(void)
{
return engine._0_4_ != 1 || engine._8_8_ != 0;
}
|
bool is_center()
{
return !(engine.center_top == 1 &&
engine.center_left == 0);
}
|
undefined8 SetMat4(void)
{
return 0;
}
|
mat4 SetMat4(GLfloat p0, GLfloat p1, GLfloat p2, GLfloat p3,
GLfloat p4, GLfloat p5, GLfloat p6, GLfloat p7,
GLfloat p8, GLfloat p9, GLfloat p10, GLfloat p11,
GLfloat p12, GLfloat p13, GLfloat p14, GLfloat p15
)
{
mat4 m;
m.m[0] = p0;
m.m[1] = p1;
m.m[2] = p2;
m.m[3] = p3;
m.m[4] = p4;
m.m[5] = p5;
m.m[6] = p6;
m.m[7] = p7;
m.m[8] = p8;
m.m[9] = p9;
m.m[10] = p10;
m.m[11] = p11;
m.m[12] = p12;
m.m[13] = p13;
m.m[14] = p14;
m.m[15] = p15;
return m;
}
|
undefined8 FreePath(undefined8 param_1,int *param_2)
{
myfree(param_1,*param_2 << 2);
return 0;
}
|
int *FreePath(int *path, NJ_t *NJ) {
myfree(path, sizeof(int)*NJ->maxnodes);
return(NULL);
}
|
undefined8 * wgRnaLoad(undefined8 *param_1)
{
undefined4 uVar1;
undefined8 *puVar2;
undefined8 uVar3;
puVar2 = (undefined8 *)needMem(0x50);
uVar1 = sqlSigned(*param_1);
*(undefined4 *)(puVar2 + 9) = uVar1;
uVar3 = cloneString(param_1[1]);
puVar2[8] = uVar3;
uVar3 = sqlUnsigned(param_1[2]);
puVar2[7] = uVar3;
uVar3 = sqlUnsigned(param_1[3]);
puVar2[6] = uVar3;
uVar3 = cloneString(param_1[4]);
puVar2[5] = uVar3;
uVar3 = sqlUnsigned(param_1[5]);
puVar2[4] = uVar3;
strcpy((char *)(ulong)*(uint *)(puVar2 + 3),(char *)param_1[6]);
uVar3 = sqlUnsigned(param_1[7]);
puVar2[2] = uVar3;
uVar3 = sqlUnsigned(param_1[8]);
puVar2[1] = uVar3;
uVar3 = cloneString(param_1[9]);
*puVar2 = uVar3;
return puVar2;
}
|
struct wgRna *wgRnaLoad(char **row)
{
struct wgRna *ret;
(ret = needMem(sizeof(*ret)));
ret->bin = sqlSigned(row[0]);
ret->chrom = cloneString(row[1]);
ret->chromStart = sqlUnsigned(row[2]);
ret->chromEnd = sqlUnsigned(row[3]);
ret->name = cloneString(row[4]);
ret->score = sqlUnsigned(row[5]);
strcpy(ret->strand, row[6]);
ret->thickStart = sqlUnsigned(row[7]);
ret->thickEnd = sqlUnsigned(row[8]);
ret->type = cloneString(row[9]);
return ret;
}
|
undefined8 import(char *param_1)
{
size_t sVar1;
undefined8 uVar2;
FILE *__stream;
__stream = stdin;
if ((((param_1 != (char *)0x0) && (sVar1 = strlen(param_1), __stream = stdin, (int)sVar1 != 0)) &&
((*param_1 != '-' || (param_1[1] != '\0')))) &&
(__stream = fopen(param_1,"r+"), __stream == (FILE *)0x0)) {
perror("fopen");
return 0;
}
db_already_readed = 0;
db_file = __stream;
uVar2 = db_read();
if ((int)uVar2 != 0) {
fclose(__stream);
db_file = (FILE *)0x0;
db_open();
db_write(1);
need_write = need_write + 1;
return 1;
}
return uVar2;
}
|
int import(const char *filename)
{
FILE *file;
int result=1;
char buf[1024];
char name[1024], value[1024];
if (!filename || (!strlen(filename)) || (!strcmp("-", filename)) )
file=stdin;
else {
file = fopen(filename, "r+");
if (!file) {
perror("fopen");
result=0;
};
};
if (! result )
return 0;
db_file = file;
db_already_readed = 0;
if ( ! db_read() )
return 0;
fclose(file);
db_file = NULL;
db_open();
db_write(1);
need_write++;
return result;
}
|
long fiftyoneDegreesInitProviderWithPropertyArray
(undefined8 param_1,long param_2,undefined8 param_3,undefined4 param_4,
undefined4 param_5,undefined4 param_6)
{
long lVar1;
long lVar2;
lVar1 = fiftyoneDegreesMalloc(4);
lVar2 = DATA_SET_INIT_STATUS_INSUFFICIENT_MEMORY;
if (lVar1 != 0) {
lVar2 = fiftyoneDegreesInitWithPropertyArray(param_1,lVar1,param_3,param_4);
if (lVar2 == DATA_SET_INIT_STATUS_SUCCESS) {
fiftyoneDegreesMutexCreate(param_2 + 4);
fiftyoneDegreesSignalCreate(param_2);
lVar2 = initProvider(param_2,lVar1,param_5,param_6);
}
else {
fiftyoneDegreesFree(lVar1);
}
}
return lVar2;
}
|
fiftyoneDegreesDataSetInitStatus fiftyoneDegreesInitProviderWithPropertyArray(
const char *fileName,
fiftyoneDegreesProvider *provider,
const char** properties,
int32_t count,
int poolSize,
int cacheSize) {
fiftyoneDegreesDataSetInitStatus status = DATA_SET_INIT_STATUS_NOT_SET;
fiftyoneDegreesDataSet *dataSet;
dataSet = (fiftyoneDegreesDataSet *)fiftyoneDegreesMalloc(sizeof(fiftyoneDegreesDataSet));
if (dataSet == NULL) {
return DATA_SET_INIT_STATUS_INSUFFICIENT_MEMORY;
}
status = fiftyoneDegreesInitWithPropertyArray(fileName, dataSet, properties, count);
if (status != DATA_SET_INIT_STATUS_SUCCESS) {
fiftyoneDegreesFree(dataSet);
return status;
}
fiftyoneDegreesMutexCreate(&provider->lock);
fiftyoneDegreesSignalCreate((fiftyoneDegreesSignal*)&provider->signal);
return initProvider(provider, dataSet, poolSize, cacheSize);
}
|
void PrintVersion(FILE *param_1)
{
undefined8 uVar1;
uVar1 = dialog_version();
fprintf(param_1,"Version: %s\n",uVar1);
return;
}
|
void
PrintVersion(FILE *fp)
{
fprintf(fp, "Version: %s\n", dialog_version());
}
|
uint pfctl_test_altqsupport(int param_1,uint param_2)
{
int iVar1;
uint uVar2;
undefined4 extraout_var;
long in_FS_OFFSET;
undefined4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_14 = PFIOC_ALTQ_VERSION;
iVar1 = ioctl(param_1,(ulong)DIOCGETALTQS,&local_14);
uVar2 = 1;
if (CONCAT44(extraout_var,iVar1) != 0) {
if (errno == ENODEV) {
uVar2 = param_2 & PF_OPT_VERBOSE;
if (uVar2 != 0) {
fprintf((FILE *)(ulong)stderr,"No ALTQ support in kernel\nALTQ related functions disabled\n"
);
uVar2 = 0;
}
}
else {
err(1,"DIOCGETALTQS");
uVar2 = 1;
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int
pfctl_test_altqsupport(int dev, int opts)
{
struct pfioc_altq pa;
pa.version = PFIOC_ALTQ_VERSION;
if (ioctl(dev, DIOCGETALTQS, &pa)) {
if (errno == ENODEV) {
if (opts & PF_OPT_VERBOSE)
fprintf(stderr, "No ALTQ support in kernel\n"
"ALTQ related functions disabled\n");
return (0);
} else
err(1, "DIOCGETALTQS");
}
return (1);
}
|
void glGetVertexAttribPointervARB(void)
{
/* WARNING: Could not recover jumptable at 0x0010000b. Too many branches */
/* WARNING: Treating indirect jump as call */
(**_glapi_Dispatch)();
return;
}
|
__attribute__((visibility("default"))) void glGetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid ** pointer)
{
(*((_glapi_Dispatch)->GetVertexAttribPointervNV)) (index, pname, pointer);;
}
|
void main(undefined8 param_1,undefined8 *param_2)
{
char *pcVar1;
__ssize_t _Var2;
size_t sVar3;
undefined *puVar4;
fA = fopen((char *)param_2[1],"r");
fB = fopen((char *)param_2[2],"r");
puVar4 = (undefined *)param_2[3];
if (puVar4 == (undefined *)0x0) {
puVar4 = &_LC0;
}
if (fA == (FILE *)0x0) {
printf("%s file1 file2 [sep]\n",*param_2);
/* WARNING: Subroutine does not return */
exit(EXIT_FAILURE);
}
while( true ) {
_Var2 = getline(&u,(size_t *)&len,fA);
pcVar1 = u;
read = (int)_Var2;
if (read == -1) {
fclose(fB);
fclose(fA);
/* WARNING: Subroutine does not return */
exit(EXIT_SUCCESS);
}
sVar3 = strlen(u);
pcVar1[(long)(int)sVar3 + -1] = '\0';
rewind(fB);
if (fB == (FILE *)0x0) break;
while( true ) {
_Var2 = getline((char **)&i,(size_t *)&len,fB);
read = (int)_Var2;
if (read == -1) break;
if (puVar4 == (undefined *)0x0) {
printf("%s%s",u,i);
}
else {
printf("%s%s%s",u,puVar4,i);
}
}
}
printf("%s file1 file2 [sep]\n",*param_2);
/* WARNING: Subroutine does not return */
exit(EXIT_FAILURE);
}
|
int main(int argc, char *argv[])
{
char * usage = "%s file1 file2 [sep]\n";
fA = fopen(argv[1], "r");
fB = fopen(argv[2], "r");
char * sep = argv[3];
if(sep == NULL)
sep = "";
if (fA == NULL)
{
printf(usage, argv[0]);
exit(EXIT_FAILURE);
}
while ((read = getline(&u, &len, fA)) != -1)
{
u[strlen(u)-1] = 0;
rewind(fB);
if (fB == NULL)
{
printf(usage, argv[0]);
exit(EXIT_FAILURE);
}
while ((read = getline(&i, &len, fB)) != -1)
{
if(sep != NULL)
{
printf("%s%s%s", u, sep, i);
}
else
{
printf("%s%s", u, i);
}
}
}
fclose(fB);
fclose(fA);
exit(EXIT_SUCCESS);
}
|
void jttomutf8(undefined4 param_1,undefined4 param_2)
{
tocesu8a(param_1,param_2,1);
return;
}
|
A jttomutf8(J jt, A w){return tocesu8a(jt,w,1);}
|
undefined8 highscore_load(undefined8 *param_1)
{
int iVar1;
char *pcVar2;
FILE *__stream;
undefined8 uVar3;
long in_FS_OFFSET;
undefined8 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = (char *)highscore_retrieve_file();
local_28 = 0;
__stream = fopen(pcVar2,"r");
if (__stream == (FILE *)0x0) {
__stream = fopen(pcVar2,"w+");
if (__stream == (FILE *)0x0) {
pcVar2 = (char *)gettext("load: Failed to open highscore file\n");
fprintf((FILE *)(ulong)stderr,pcVar2);
uVar3 = 0;
goto LAB_00100071;
}
}
iVar1 = fscanf(__stream,"%ld",&local_28);
if (iVar1 != 1) {
pcVar2 = (char *)gettext("load: Failed to parse highscore file\n");
fprintf((FILE *)(ulong)stderr,pcVar2);
local_28 = 0;
}
fclose(__stream);
uVar3 = local_28;
if (param_1 != (undefined8 *)0x0) {
*param_1 = local_28;
}
LAB_00100071:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
long highscore_load(struct gamestate *g)
{
const char *hsfile = highscore_retrieve_file();
long result = 0;
FILE *fd = fopen(hsfile, "r");
if (fd == NULL)
fd = fopen(hsfile, "w+");
if (fd == NULL) {
fprintf(stderr, gettext("load: Failed to open highscore file\n"));
return 0;
}
if (fscanf(fd, "%ld", &result) != 1) {
fprintf(stderr, gettext("load: Failed to parse highscore file\n"));
result = 0;
}
fclose(fd);
if (g) g->score_high = result;
return result;
}
|
void pll_reset(void)
{
vw_pll_state(&integrator,&last_sample,&ramp);
*integrator = 0;
*last_sample = 0;
*ramp = 0;
callback_ran = 0;
callback_bit = 0;
return;
}
|
void pll_reset() {
vw_pll_state(&integrator, &last_sample, &ramp);
*integrator = 0;
*last_sample = 0;
*ramp = 0;
callback_ran = 0;
callback_bit = 0;
}
|
undefined8 delete_note(int param_1,long param_2,undefined8 param_3)
{
int iVar1;
long in_FS_OFFSET;
int local_28;
undefined8 local_20;
char *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = "delete from notes where id=?;";
sqlite3_prepare_v2(param_3,"delete from notes where id=?;",0xffffffff,&local_20,0);
for (local_28 = 0; local_28 < param_1; local_28 = local_28 + 1) {
iVar1 = atoi(*(char **)(param_2 + (long)local_28 * 8));
if (iVar1 == 0) {
puts("WRONG ID!!!");
}
else {
sqlite3_bind_int(local_20,1,iVar1);
sqlite3_step(local_20);
sqlite3_reset(local_20);
}
}
sqlite3_finalize(local_20);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return 0;
}
|
int delete_note(int argc,char* argv[], sqlite3 *db){
sqlite3_stmt *stmt;
int id;
int i;
char *cmd="delete from notes where id=?;";
sqlite3_prepare_v2(db, cmd, -1, &stmt, NULL);
for(i=0;i<argc;i++) {
id=atoi(argv[i]);
if(!id) {
puts("WRONG ID!!!");
continue;
}
sqlite3_bind_int( stmt, 1, id);
sqlite3_step(stmt);
sqlite3_reset(stmt);
}
sqlite3_finalize(stmt);
return 0;
}
|
undefined4 global_end(undefined8 *param_1)
{
undefined4 uVar1;
IDAT_list_end((undefined4 *)((long)param_1 + 4));
uVar1 = *(undefined4 *)param_1;
CLEAR(*param_1);
return uVar1;
}
|
int
global_end(struct global *global)
{
int rc;
IDAT_list_end(&global->idat_cache);
rc = global->status_code;
CLEAR(*global);
return rc;
}
|
void jz4740_pwm_disable(undefined8 param_1,undefined4 *param_2)
{
uint uVar1;
uVar1 = jz4740_timer_get_ctrl(*param_2);
jz4740_timer_set_duty(*param_2,0xffff);
jz4740_timer_set_period(*param_2,0);
jz4740_timer_set_ctrl(*param_2,~JZ_TIMER_CTRL_PWM_ENABLE & uVar1);
jz4740_timer_disable(*param_2);
return;
}
|
void jz4740_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
{
uint32_t ctrl = jz4740_timer_get_ctrl(pwm->hwpwm);
/*
* Set duty > period. This trick allows the TCU channels in TCU2 mode to
* properly return to their init level.
*/
jz4740_timer_set_duty(pwm->hwpwm, 0xffff);
jz4740_timer_set_period(pwm->hwpwm, 0x0);
/*
* Disable PWM output.
* In TCU2 mode (channel 1/2 on JZ4750+), this must be done before the
* counter is stopped, while in TCU1 mode the order does not matter.
*/
ctrl &= ~JZ_TIMER_CTRL_PWM_ENABLE;
jz4740_timer_set_ctrl(pwm->hwpwm, ctrl);
/* Stop counter */
jz4740_timer_disable(pwm->hwpwm);
}
|
ulong load_bytecode(char *param_1)
{
FILE *__stream;
ulong uVar1;
memset((void *)(ulong)bytecode,0,0x1000);
memset((void *)(ulong)decoded,0,0x1000);
dasm = (undefined (*) [16])malloc(0x18);
*(undefined8 *)dasm[1] = 0;
*dasm = (undefined [16])0x0;
__stream = fopen(param_1,"rb");
if (__stream == (FILE *)0x0) {
file_not_found(param_1);
}
fseek(__stream,0,SEEK_END);
uVar1 = ftell(__stream);
fseek(__stream,0,SEEK_SET);
fread((void *)(ulong)bytecode,1,uVar1 & 0xffffffff,__stream);
fclose(__stream);
printf("%s size: %u\n",param_1,uVar1 & 0xffffffff);
return uVar1 & 0xffffffff;
}
|
int load_bytecode(char *name){
FILE *fp;
unsigned size;
memset(bytecode,0,(4096));
memset(decoded,0,(4096));
dasm=(dasm_t*)malloc(sizeof(dasm_t));
dasm->addr=0;
dasm->next=NULL;
dasm->line=NULL;
fp=fopen(name,"rb");
if (!fp) file_not_found(name);
fseek(fp,0L,SEEK_END);
size=ftell(fp);
fseek(fp,0L,SEEK_SET);
fread(bytecode,1,size,fp);
fclose(fp);
printf("%s size: %u\n",name,size);
return size;
}
|
undefined8 rds_ib_update_ipaddr(long param_1,long *param_2)
{
long lVar1;
undefined8 uVar2;
lVar1 = rds_ib_get_device(*(undefined4 *)(*param_2 + 0xc));
if (lVar1 == 0) {
uVar2 = rds_ib_add_ipaddr(param_1,*(undefined4 *)(*param_2 + 0xc));
}
else if (lVar1 == param_1) {
rds_ib_dev_put(param_1);
uVar2 = 0;
}
else {
rds_ib_remove_ipaddr(lVar1,*(undefined4 *)(*param_2 + 0xc));
rds_ib_dev_put(lVar1);
uVar2 = rds_ib_add_ipaddr(param_1,*(undefined4 *)(*param_2 + 0xc));
}
return uVar2;
}
|
int rds_ib_update_ipaddr(struct rds_ib_device *rds_ibdev,
struct in6_addr *ipaddr)
{
struct rds_ib_device *rds_ibdev_old;
rds_ibdev_old = rds_ib_get_device(ipaddr->s6_addr32[3]);
if (!rds_ibdev_old)
return rds_ib_add_ipaddr(rds_ibdev, ipaddr->s6_addr32[3]);
if (rds_ibdev_old != rds_ibdev) {
rds_ib_remove_ipaddr(rds_ibdev_old, ipaddr->s6_addr32[3]);
rds_ib_dev_put(rds_ibdev_old);
return rds_ib_add_ipaddr(rds_ibdev, ipaddr->s6_addr32[3]);
}
rds_ib_dev_put(rds_ibdev_old);
return 0;
}
|
void vlc_plugin_symbol_compare(uint *param_1,uint *param_2)
{
strcmp((char *)(ulong)*param_1,(char *)(ulong)*param_2);
return;
}
|
int vlc_plugin_symbol_compare(const void *a, const void *b)
{
const struct vlc_plugin_symbol *sa = a , *sb = b;
return strcmp(sa->name, sb->name);
}
|
void add_error(char *param_1)
{
size_t __n;
size_t sVar1;
int extraout_var;
char *pcVar2;
if (param_1 == (char *)0x0) {
return;
}
__n = strlen(param_1);
if (__n == 0) {
return;
}
sVar1 = 0;
if (errors != (char *)0x0) {
sVar1 = strlen(errors);
}
llog(LOG_DEBUG,"Adding error \'%s\'",param_1);
if (errors == (char *)0x0) {
errors = (char *)malloc((ulong)((int)__n + 1));
pcVar2 = "Couldn\'t allocate string for error holding.";
if (errors != (char *)0x0) {
memset(errors,0,__n + 1);
strncpy(errors,param_1,__n);
return;
}
}
else {
errors = (char *)realloc(errors,sVar1 + 2 + __n);
if (errors == (char *)0x0) {
llog(LOG_ERR,"Couldn\'t reallocate error holding var.");
}
snprintf(errors,__n + 1,"%s\n",param_1);
if (-1 < extraout_var) {
return;
}
pcVar2 = "Error adding new error to error buffer.";
}
llog(LOG_ERR,pcVar2);
return;
}
|
void add_error(char *e) {
size_t elen = 0, curlen = 0;
if(e == NULL) {
return;
}
elen = strlen(e);
if(elen == 0) {
return;
}
if(errors != NULL) {
curlen = strlen(errors);
}
llog(LOG_DEBUG, "Adding error '%s'", e);
if(errors == NULL) {
errors = (char *) malloc(sizeof(char) * (elen + 1));
if(errors == NULL) {
llog(LOG_ERR, "Couldn't allocate string for error holding.");
return;
}
memset(errors, 0, (elen + 1));
strncpy(errors, e, elen);
} else {
errors = (char *) realloc(errors, (curlen + elen + 2));
if(errors == NULL) {
llog(LOG_ERR, "Couldn't reallocate error holding var.");
}
if(snprintf(errors, (elen + 1), "%s\n", e) < 0) {
llog(LOG_ERR, "Error adding new error to error buffer.");
}
}
}
|
void test_7_store_nul_0(char *param_1)
{
size_t sVar1;
sVar1 = strlen(param_1);
if (sVar1 != 6) {
return;
}
strcpy(&a7,param_1);
a7 = 0;
return;
}
|
__attribute__ ((noipa)) void test_7_store_nul_0 (const char *s) { extern char a7[7]; char *d = a7; size_t len = 7 - 1; size_t idx = 0; if (strlen (s) == len) { strcpy (d, s); d[idx] = 0; if (strlen (d) != idx) abort (); } }
|
void sort4var2(undefined8 param_1,int param_2)
{
if (param_2 < 10) {
insertion_sort(param_1,param_2);
return;
}
quick_sort4var2(param_1,0,param_2);
insertion_sort(param_1,param_2);
return;
}
|
void sort4var2(int32_t *a, int32_t n) {
if (n > 9) quick_sort4var2(a, 0, n);
insertion_sort(a, n);
}
|
void catch(uint param_1)
{
if (SIGINT != param_1) {
nocbreak();
nl();
endwin();
printf("Died on signal %d\n",(ulong)param_1);
/* WARNING: Subroutine does not return */
exit(2);
}
signal(param_1,catch);
return;
}
|
void catch(int sig)
{
if (sig == SIGINT) {
signal(sig, catch);
return;
}
nocbreak();nl();endwin();
printf("Died on signal %d\n", sig);
exit(2);
}
|
void katana_print_position(undefined4 *param_1)
{
katana_print(0,"Loaction %d.%d - %d.%d",param_1[3],param_1[2],param_1[1],*param_1);
return;
}
|
void katana_print_position(KATANALTYPE* yyloc)
{
katana_print(NULL,
"Loaction %d.%d - %d.%d",
yyloc->first_line,
yyloc->first_column,
yyloc->last_line,
yyloc->last_column
);
}
|
void tcp_ecn_send_synack(undefined8 param_1,undefined8 param_2)
{
uint *puVar1;
uint *puVar2;
long lVar3;
puVar1 = (uint *)tcp_sk(param_1);
puVar2 = (uint *)TCP_SKB_CB(param_2);
*puVar2 = *puVar2 & ~TCPHDR_CWR;
if ((TCP_ECN_OK & *puVar1) == 0) {
puVar1 = (uint *)TCP_SKB_CB(param_2);
*puVar1 = *puVar1 & ~TCPHDR_ECE;
}
else {
lVar3 = tcp_ca_needs_ecn(param_1);
if ((lVar3 == 0) && (lVar3 = tcp_bpf_ca_needs_ecn(param_1), lVar3 == 0)) {
return;
}
INET_ECN_xmit(param_1);
}
return;
}
|
void tcp_ecn_send_synack(struct sock *sk, struct sk_buff *skb)
{
const struct tcp_sock *tp = tcp_sk(sk);
TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_CWR;
if (!(tp->ecn_flags & TCP_ECN_OK))
TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_ECE;
else if (tcp_ca_needs_ecn(sk) ||
tcp_bpf_ca_needs_ecn(sk))
INET_ECN_xmit(sk);
}
|
void matrix_init_kb(void)
{
setPinOutput(D1);
setPinOutput(E2);
matrix_init_user();
return;
}
|
void matrix_init_kb(void) {
setPinOutput(D1);
setPinOutput(E2);
matrix_init_user();
}
|
void tan_lo(void)
{
undefined4 uVar1;
uVar1 = cnstDI();
tanII(uVar1);
return;
}
|
double tan_lo(double x) {
INTERVAL Y;
Y = tanII(cnstDI(x));
return(Y.lo);
}
|
void drawMesh(int param_1,undefined4 *param_2)
{
undefined4 *puVar1;
undefined4 *puVar2;
glBegin(GL_TRIANGLES);
if (1 < param_1) {
puVar1 = param_2;
do {
puVar2 = puVar1 + 0xc;
glNormal3f(*puVar1,puVar1[1],puVar1[2]);
glVertex3f(puVar1[3],puVar1[4],puVar1[5]);
glVertex3f(puVar1[6],puVar1[7],puVar1[8]);
glVertex3f(puVar1[9],puVar1[10],puVar1[0xb]);
fflush((FILE *)(ulong)stdout);
puVar1 = puVar2;
} while (param_2 + (ulong)(param_1 - 2) * 0xc + 0xc != puVar2);
}
glEnd();
return;
}
|
void drawMesh(int numMesh, float mesh[][12])
{
glBegin(GL_TRIANGLES);
int ii;
for(ii = 0; ii < numMesh - 1; ii++)
{
{
glNormal3f(mesh[ii][0], mesh[ii][1], mesh[ii][2]);
int jj;
for(jj = 1; jj < 4; jj++) glVertex3f(mesh[ii][jj * 3 + 0], mesh[ii][jj * 3 + 1], mesh[ii][jj * 3 + 2]);
fflush(stdout);
}
}
glEnd();
}
|
undefined8 main(void)
{
__pid_t _Var1;
undefined4 extraout_var;
_Var1 = fork();
if (CONCAT44(extraout_var,_Var1) == 0) {
officeparser("test.docx","/home/host1/git/emlproj/appendix","office",0x100000);
officeparser("05-Agile.pptx","/home/host1/git/emlproj/appendix","office","ppt.txt");
officeparser("test.xlsx","/home/host1/git/emlproj/appendix","office","xls.txt");
officeparser(&_LC9,"/home/host1/git/emlproj/appendix","office","pdf.txt");
}
return 0;
}
|
int main(int argc, char* argv[])
{
int ret=1;
while(ret--)
{
if(fork()==0)
{
officeparser("test.docx","/home/host1/git/emlproj/appendix","office", "doc.txt");
officeparser("05-Agile.pptx","/home/host1/git/emlproj/appendix","office", "ppt.txt");
officeparser("test.xlsx","/home/host1/git/emlproj/appendix","office", "xls.txt");
officeparser("大家好 这是我的 拍拍拍.pdf","/home/host1/git/emlproj/appendix","office", "pdf.txt");
return 0;
}
}
return 0;
}
|
void mysystem(undefined8 param_1)
{
long in_FS_OFFSET;
char acStack_428 [1032];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
snprintf(acStack_428,0x3ff,"echo \"`date`: %.900s\" 1>>%s 2>&1",param_1,logtxt);
system(acStack_428);
snprintf(acStack_428,0x3ff,"%.900s 1>>%s 2>&1",param_1,logtxt);
system(acStack_428);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int mysystem(const char *s)
{
char cmd[1024];
snprintf(cmd, 1023, "echo \"`date`: %.900s\" 1>>%s 2>&1", s, logtxt);
system(cmd);
snprintf(cmd, 1023, "%.900s 1>>%s 2>&1", s, logtxt);
return (system(cmd));
}
|
void * varray_new(undefined4 param_1,undefined4 param_2)
{
void *__ptr;
long lVar1;
void *pvVar2;
__ptr = malloc(4);
pvVar2 = __ptr;
if (__ptr != (void *)0x0) {
lVar1 = varray_init(__ptr,param_1,param_2);
if (lVar1 == 0) {
pvVar2 = (void *)0x0;
free(__ptr);
}
}
return pvVar2;
}
|
varray *varray_new(int element_size, int initial_allocation)
{
varray *va;
va = malloc(sizeof(varray));
if (va == NULL)
return NULL;
if (varray_init(va, element_size, initial_allocation) == NULL) {
free(va);
return NULL;
}
return va;
}
|
void generate_random_string(char *param_1,int param_2)
{
int iVar1;
time_t tVar2;
char *pcVar3;
char *pcVar4;
if (init_1925 == 0) {
tVar2 = time((time_t *)0x0);
srand((uint)tVar2);
init_1925 = 1;
}
if (1 < param_2) {
pcVar3 = param_1;
do {
pcVar4 = pcVar3 + 1;
iVar1 = rand();
*pcVar3 = (char)iVar1 + (char)(iVar1 / 0x1a) * -0x1a + 'A';
pcVar3 = pcVar4;
} while (pcVar4 != param_1 + (ulong)(param_2 - 2) + 1);
param_1 = param_1 + (param_2 + -1);
}
*param_1 = '\0';
return;
}
|
void generate_random_string(char *str, int size)
{
int i;
static int init = 0;
if (!init) {
srand(time(NULL));
init = 1;
}
for (i = 0; i < (size-1); ++i) {
str[i] = 'A' + (rand() % 26);
}
str[i] = 0;
}
|
undefined4 os_sem_destroy(sem_t *param_1)
{
int iVar1;
undefined4 uVar2;
undefined4 extraout_var;
iVar1 = sem_destroy(param_1);
uVar2 = os_resultSuccess;
if (CONCAT44(extraout_var,iVar1) != 0) {
uVar2 = os_resultFail;
}
return uVar2;
}
|
os_result os_sem_destroy (sem_t *sem)
{
return (sem_destroy (sem) == 0) ? os_resultSuccess : os_resultFail;
}
|
void HeapInsert(undefined4 param_1)
{
int iVar1;
int iVar2;
int local_c;
if (nHeapLength <= nHeapCount) {
HeapExpand();
}
nHeapCount = nHeapCount + 1;
local_c = nHeapCount;
while (1 < local_c) {
iVar2 = local_c >> 1;
iVar1 = MergeCompareFn(*(undefined4 *)(pplpHeap + (long)iVar2 * 4 + -4),param_1);
if (iVar1 != 1) break;
*(undefined4 *)(pplpHeap + (long)local_c * 4 + -4) =
*(undefined4 *)(pplpHeap + (long)iVar2 * 4 + -4);
local_c = iVar2;
}
*(undefined4 *)((long)local_c * 4 + -4 + pplpHeap) = param_1;
return;
}
|
void HeapInsert
(
LINEARPLANP plpNode
)
{
int i;
if(nHeapCount>=nHeapLength)
HeapExpand();
nHeapCount++;
for(i=nHeapCount;i>1&&MergeCompareFn(pplpHeap[((i)>>1)-1],plpNode)==1;i=((i)>>1))
pplpHeap[i-1]=pplpHeap[((i)>>1)-1];
pplpHeap[i-1]=plpNode;
}
|
bool isOdd(int param_1)
{
return param_1 % 2 == 1;
}
|
bool isOdd(int number)
{
return number % 2 == 1 ? true : false;
}
|
int vdso_mremap(undefined8 param_1,long *param_2)
{
if (*param_2 - param_2[1] != (long)(vdso_total_pages + -1 << ((byte)PAGE_SHIFT & 0x1f))) {
return -EINVAL;
}
**current = param_2[1];
return 0;
}
|
int vdso_mremap(const struct vm_special_mapping *sm,
struct vm_area_struct *new_vma)
{
unsigned long new_size = new_vma->vm_end - new_vma->vm_start;
unsigned long vdso_size;
/* without VVAR page */
vdso_size = (vdso_total_pages - 1) << PAGE_SHIFT;
if (vdso_size != new_size)
return -EINVAL;
current->mm->context.vdso = new_vma->vm_start;
return 0;
}
|
void _MGD_MD5Init(undefined8 *param_1)
{
undefined8 *puVar1;
puVar1 = (undefined8 *)param_1[1];
puVar1[1] = 0;
*puVar1 = 0;
param_1 = (undefined8 *)*param_1;
*param_1 = 0xefcdab8967452301;
param_1[1] = 0x1032547698badcfe;
return;
}
|
void _MGD_MD5Init(_MGD_MD5_CTX * context)
{
context->count[0] = context->count[1] = 0;
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
}
|
undefined8 map_accel_slope_int(int *param_1,undefined8 param_2)
{
undefined8 uVar1;
long in_FS_OFFSET;
uint local_18;
uint local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = 0;
if (*param_1 == 0) {
uVar1 = bmi055_get_accel_regs(0x19,&local_18,1,param_2);
if ((int)uVar1 != 0) goto LAB_0010006d;
uVar1 = 0x19;
}
else {
if (*param_1 != 1) {
uVar1 = 0xfffffffa;
goto LAB_0010006d;
}
uVar1 = bmi055_get_accel_regs(0x1b,&local_18,1,param_2);
if ((int)uVar1 != 0) goto LAB_0010006d;
uVar1 = 0x1b;
}
local_14 = local_18 | 4;
uVar1 = bmi055_set_accel_regs(uVar1,&local_14,1,param_2);
LAB_0010006d:
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int8_t map_accel_slope_int(const struct bmi055_accel_int_sett *acc_int_config, const struct bmi055_dev *dev)
{
int8_t rslt;
uint8_t reg_addr = 0;
uint8_t data = 0;
uint8_t reg_data;
if (acc_int_config->acc_int_channel == 0x00U) {
reg_addr = 0x19U;
rslt = bmi055_get_accel_regs(reg_addr, &data, 1, dev);
if (rslt == 0) {
reg_data = ((data & ~(0x04U)) | ((0x01U << 0x02U) & 0x04U));
}
} else if (acc_int_config->acc_int_channel == 0x01U) {
reg_addr = 0x1BU;
rslt = bmi055_get_accel_regs(reg_addr, &data, 1, dev);
if (rslt == 0) {
reg_data = ((data & ~(0x04U)) | ((0x01U << 0x02U) & 0x04U));
}
} else {
rslt = -6;
}
if (rslt == 0) {
rslt = bmi055_set_accel_regs(reg_addr, ®_data, 1, dev);
}
return rslt;
}
|
void close_command(void)
{
close(server_socket);
return;
}
|
void close_command() {
close(server_socket);
}
|
void new_configuration(void)
{
malloc(4);
return;
}
|
configuration_t *new_configuration()
{
configuration_t *cfg = NULL;
cfg = (configuration_t *)malloc(sizeof(configuration_t));
return(cfg);
}
|
int ff_hevc_compute_poc(undefined4 *param_1,int param_2,int param_3,int param_4)
{
int iVar1;
int iVar2;
iVar1 = 1 << ((byte)*param_1 & 0x1f);
iVar2 = param_2 % iVar1;
param_2 = param_2 - iVar2;
if ((param_3 < iVar2) && (iVar1 / 2 <= iVar2 - param_3)) {
param_2 = param_2 + iVar1;
}
else if ((iVar2 < param_3) && (iVar1 / 2 < param_3 - iVar2)) {
param_2 = param_2 - iVar1;
}
if (HEVC_NAL_BLA_W_LP == param_4) {
param_2 = 0;
}
else if (HEVC_NAL_BLA_W_RADL == param_4) {
param_2 = 0;
}
else if (HEVC_NAL_BLA_N_LP == param_4) {
param_2 = 0;
}
return param_2 + param_3;
}
|
int ff_hevc_compute_poc(const HEVCSPS *sps, int pocTid0, int poc_lsb, int nal_unit_type)
{
int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
int prev_poc_lsb = pocTid0 % max_poc_lsb;
int prev_poc_msb = pocTid0 - prev_poc_lsb;
int poc_msb;
if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
poc_msb = prev_poc_msb + max_poc_lsb;
else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
poc_msb = prev_poc_msb - max_poc_lsb;
else
poc_msb = prev_poc_msb;
// For BLA picture types, POCmsb is set to 0.
if (nal_unit_type == HEVC_NAL_BLA_W_LP ||
nal_unit_type == HEVC_NAL_BLA_W_RADL ||
nal_unit_type == HEVC_NAL_BLA_N_LP)
poc_msb = 0;
return poc_msb + poc_lsb;
}
|
long array_remove_idx(long param_1,int param_2)
{
void **__dest;
int iVar1;
__dest = (void **)(param_1 + (long)param_2 * 8);
iVar1 = array_length();
free(*__dest);
memmove(__dest,(void *)(param_1 + 8 + (long)param_2 * 8),(ulong)(uint)((iVar1 - param_2) * 8));
return param_1;
}
|
char **array_remove_idx(char **strings, int idx)
{
int len = array_length(strings);
free(strings[idx]);
memmove(&strings[idx],&strings[idx+1],(len - idx)*sizeof(char*));
return strings;
}
|
bool stop_timer(uint param_1)
{
int iVar1;
undefined4 extraout_var;
long in_FS_OFFSET;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
memset((itimerspec *)&stack0xffffffffffffffdc,0,4);
iVar1 = timer_settime((timer_t)(ulong)param_1,0,(itimerspec *)&stack0xffffffffffffffdc,
(itimerspec *)0x0);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return CONCAT44(extraout_var,iVar1) != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
bool stop_timer(timer_t timer_id) {
struct itimerspec t_spec;
memset(&t_spec, 0, sizeof(t_spec));
return 0 != timer_settime(timer_id, 0, &t_spec, NULL);
}
|
void pr_fail_args_errno(undefined4 *param_1,undefined8 param_2,undefined4 param_3)
{
pr_msg_fail(9,*param_1,param_2,param_3);
return;
}
|
void pr_fail_args_errno(const stress_args_t *args, const char *msg, int err)
{
pr_msg_fail((0x00000000000008ULL) | (0x00000000000001ULL), args->name, msg, err);
}
|
void test_refs_reflog_drop__can_persist_deletion_on_disk(void)
{
undefined4 uVar1;
cl_assert(2 < entrycount);
uVar1 = git_reflog_drop(g_reflog,0,1);
cl_git_pass(uVar1);
uVar1 = git_reflog_entrycount(g_reflog);
cl_assert_equal_sz(entrycount + -1,uVar1);
uVar1 = git_reflog_write(g_reflog);
cl_git_pass(uVar1);
git_reflog_free(g_reflog);
git_reflog_read(&g_reflog,g_repo,&_LC0);
uVar1 = git_reflog_entrycount(g_reflog);
cl_assert_equal_sz(entrycount + -1,uVar1);
return;
}
|
void test_refs_reflog_drop__can_persist_deletion_on_disk(void)
{
cl_assert(entrycount > 2);
cl_git_pass(git_reflog_drop(g_reflog, 0, 1));
cl_assert_equal_sz(entrycount - 1, git_reflog_entrycount(g_reflog));
cl_git_pass(git_reflog_write(g_reflog));
git_reflog_free(g_reflog);
git_reflog_read(&g_reflog, g_repo, "HEAD");
cl_assert_equal_sz(entrycount - 1, git_reflog_entrycount(g_reflog));
}
|
void namefastcmp_locale(undefined8 param_1,undefined4 param_2,undefined4 param_3)
{
uint uVar1;
undefined4 uVar2;
undefined4 uVar3;
undefined4 *puVar4;
undefined4 *puVar5;
size_t sVar6;
size_t sVar7;
puVar4 = (undefined4 *)DatumGetName();
puVar5 = (undefined4 *)DatumGetName(param_2);
uVar1 = NameStr(*puVar5);
sVar6 = strlen((char *)(ulong)uVar1);
uVar2 = NameStr(*puVar5);
uVar1 = NameStr(*puVar4);
sVar7 = strlen((char *)(ulong)uVar1);
uVar3 = NameStr(*puVar4);
varstrfastcmp_locale(uVar3,sVar7 & 0xffffffff,uVar2,sVar6 & 0xffffffff,param_3);
return;
}
|
int
namefastcmp_locale(Datum x, Datum y, SortSupport ssup)
{
Name arg1 = DatumGetName(x);
Name arg2 = DatumGetName(y);
return varstrfastcmp_locale(NameStr(*arg1), strlen(NameStr(*arg1)),
NameStr(*arg2), strlen(NameStr(*arg2)),
ssup);
}
|
void start_devices(void)
{
long lVar1;
long lVar2;
if (0 < num_drm_fds) {
lVar2 = 0;
do {
lVar1 = drmSetMaster(*(undefined4 *)(drm_fds + lVar2 * 4));
if (lVar1 < 0) {
die("failed to set DRM master");
}
lVar2 = lVar2 + 1;
} while ((int)lVar2 < num_drm_fds);
return;
}
return;
}
|
void
start_devices(void)
{
int i;
for (i = 0; i < num_drm_fds; ++i) {
if (drmSetMaster(drm_fds[i]) < 0)
die("failed to set DRM master");
}
}
|
void mips_simple_read_d(undefined8 param_1,long param_2,uint *param_3)
{
long in_FS_OFFSET;
uint local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
mips_simple_read_w(param_1,param_2,&local_24);
if (param_3 == (uint *)0x0) {
mips_simple_read_w(param_1,param_2 + 4,&local_24);
}
else {
*param_3 = local_24;
mips_simple_read_w(param_1,param_2 + 4,&local_24);
*param_3 = *param_3 | local_24;
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
uint64_t mips_simple_read_d(MIPS_Memory *m, MIPS_Addr a, int *stat)
{
int hstat;
uint32_t w0 = mips_simple_read_w(m, a, &hstat);
if ( stat != NULL )
*stat = hstat;
uint32_t w1 = mips_simple_read_w(m, a + 4, &hstat);
if ( stat != NULL )
*stat |= hstat;
return ((uint64_t)w0 << 32) | w1;
}
|
void sbcSp8(void)
{
undefined4 uVar1;
uVar1 = stack();
uVar1 = readmem65816(uVar1);
sbc8(uVar1);
return;
}
|
void sbcSp8(void)
{
sbc8(readmem65816(stack()));
}
|
void track_shm_data(undefined8 param_1)
{
void *pvVar1;
if (num_data == shm_data_size) {
pvVar1 = realloc(shm_data,(ulong)(shm_data_size * 8 + 0x2000));
if (pvVar1 == (void *)0x0) {
set_error("Cannot realloc shm data tracker");
/* WARNING: Subroutine does not return */
exit(1);
}
shm_data_size = shm_data_size + 0x400;
shm_data = pvVar1;
}
*(undefined8 *)((long)shm_data + (long)num_data * 8) = param_1;
num_data = num_data + 1;
return;
}
|
void
track_shm_data(int *data) {
if (num_data == shm_data_size) {
void *tmp = realloc(shm_data, sizeof(int*)*(shm_data_size + 1024));
if (tmp != NULL) {
shm_data = tmp;
} else {
set_error("Cannot realloc shm data tracker");
exit(1);
}
shm_data_size += 1024;
}
shm_data[num_data] = data;
num_data++;
}
|
undefined8 add_dev(char *param_1,uint *param_2)
{
int iVar1;
undefined4 uVar2;
long lVar3;
undefined4 extraout_var;
char *__s1;
char **ppcVar4;
undefined4 extraout_var_00;
long in_FS_OFFSET;
__ino_t local_30;
local_30 = *(__ino_t *)(in_FS_OFFSET + 0x28);
lVar3 = S_ISLNK(*param_2);
if (((lVar3 == 0) ||
(iVar1 = stat(param_1,(stat *)&stack0xffffffffffffffc8),
param_2 = (uint *)&stack0xffffffffffffffc8, CONCAT44(extraout_var,iVar1) == 0)) &&
((*param_2 & S_IFMT) == S_IFBLK)) {
__s1 = strdup(param_1);
ppcVar4 = (char **)malloc(0x18);
iVar1 = strncmp(__s1,"/dev/./",7);
if (CONCAT44(extraout_var_00,iVar1) == 0) {
strcpy(__s1 + 4,param_1 + 6);
}
if (ppcVar4 != (char **)0x0) {
uVar2 = major(param_2[1]);
*(undefined4 *)((long)ppcVar4 + 0x14) = uVar2;
uVar2 = minor(param_2[1]);
*(undefined4 *)(ppcVar4 + 2) = uVar2;
*ppcVar4 = __s1;
ppcVar4[1] = (char *)devlist;
devlist = ppcVar4;
}
}
if (local_30 != *(__ino_t *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return 0;
}
|
int add_dev(const char *name, const struct stat *stb, int flag, struct FTW *s)
{
struct stat st;
if (S_ISLNK(stb->st_mode)) {
if (stat(name, &st) != 0)
return 0;
stb = &st;
}
if ((stb->st_mode&S_IFMT)== S_IFBLK) {
char *n = strdup(name);
struct devmap *dm = malloc(sizeof(*dm));
if (strncmp(n, "/dev/./", 7)==0)
strcpy(n+4, name+6);
if (dm) {
dm->major = major(stb->st_rdev);
dm->minor = minor(stb->st_rdev);
dm->name = n;
dm->next = devlist;
devlist = dm;
}
}
return 0;
}
|
undefined8 undefined_6916(void)
{
return *(undefined8 *)(functions + 0xd820);
}
|
void* undefined_6916 () { return (void*)functions[6916].pointer; }
|
void finish(FILE *param_1)
{
if (0 < spaceAccumulator) {
fprintf(param_1,"%+d",(ulong)(uint)-spaceAccumulator);
}
fputc(10,param_1);
fflush(param_1);
return;
}
|
void finish(FILE *out) {
if (spaceAccumulator > 0) {
fprintf(out, "%+d", -spaceAccumulator);
}
fputs("\n", out);
fflush(out);
}
|
undefined4 ropFSTSW_AX(undefined8 param_1,undefined8 param_2)
{
undefined4 in_R9D;
if (codegen_fpu_entered == 0) {
uop_gen_imm(0xc0000080,param_2,cpu_state);
}
codegen_fpu_entered = 1;
codegen_mmx_entered = 0;
uop_gen_reg_dst_src1(0x10000022,param_2,IREG_AX,IREG_NPXS);
return in_R9D;
}
|
uint32_t ropFSTSW_AX(codeblock_t *block, ir_data_t *ir, uint8_t opcode, uint32_t rmdat, uint32_t op_32, uint32_t op_pc)
{
do { if (!codegen_fpu_entered) uop_gen_imm(((1 << 30) | 0x80 | (1 << 31)), ir, cpu_state.oldpc); codegen_fpu_entered = 1; codegen_mmx_entered = 0; } while (0);
uop_gen_reg_dst_src1(((1 << 28) | 0x22), ir, IREG_AX, IREG_NPXS);
return op_pc;
}
|
undefined8 EVP_AEAD_max_tag_len(undefined8 *param_1)
{
return *param_1;
}
|
size_t
EVP_AEAD_max_tag_len(const EVP_AEAD *aead)
{
return aead->max_tag_len;
}
|
void print(void)
{
printf("hello");
return;
}
|
print()
{
int a,b;
printf("hello");
a = b;
}
|
void tpm_continue_selftest(undefined8 param_1)
{
long in_FS_OFFSET;
undefined4 local_38;
undefined4 local_34;
undefined4 local_30;
undefined4 local_2c;
undefined4 local_28;
undefined4 local_24;
undefined4 local_20;
undefined4 local_1c;
undefined4 local_18;
undefined4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_38 = 0;
local_34 = 0xc1;
local_30 = 0;
local_2c = 0;
local_28 = 0;
local_24 = 10;
local_20 = 0;
local_1c = 0;
local_18 = 0;
local_14 = 0x53;
tpm_transmit(param_1,&local_38,0x28);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void tpm_continue_selftest(struct tpm_chip *chip)
{
u8 data[] = {
0, 193, /* TPM_TAG_RQU_COMMAND */
0, 0, 0, 10, /* length */
0, 0, 0, 83, /* TPM_ORD_GetCapability */
};
tpm_transmit(chip, data, sizeof(data));
}
|
int list_find(long **param_1,long param_2)
{
long lVar1;
long *plVar2;
int iVar3;
if (param_1[2] == (long *)0x0) {
plVar2 = (long *)*param_1[1];
if (plVar2 != *param_1) {
iVar3 = 0;
do {
if (*plVar2 == param_2) goto LAB_00100077;
plVar2 = (long *)plVar2[1];
iVar3 = iVar3 + 1;
} while (plVar2 != *param_1);
}
}
else {
plVar2 = (long *)*param_1[1];
if (plVar2 != *param_1) {
iVar3 = 0;
do {
lVar1 = (*(code *)param_1[2])(param_2,*plVar2);
if (lVar1 == 0) {
LAB_00100077:
if (*param_1 != plVar2) {
return iVar3;
}
return -1;
}
plVar2 = (long *)plVar2[1];
iVar3 = iVar3 + 1;
} while (*param_1 != plVar2);
}
}
return -1;
}
|
int list_find(const list_t *l, const void *data) {
struct list_entry_s *el;
int pos = 0;
if (l->attrs.comparator != NULL) {
for (el = l->head_sentinel->next; el != l->tail_sentinel; el = el->next, pos++) {
if (l->attrs.comparator(data, el->data) == 0) break;
}
} else {
for (el = l->head_sentinel->next; el != l->tail_sentinel; el = el->next, pos++) {
if (el->data == data) break;
}
}
if (el == l->tail_sentinel) return -1;
return pos;
}
|
undefined8 clLambda_r1(long param_1)
{
undefined8 *puVar1;
undefined4 uVar2;
undefined8 uVar3;
long in_FS_OFFSET;
undefined4 local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
va_start(local_14,param_1);
if (param_1 != 0) {
uVar2 = _clVlist(param_1,&local_14);
clExtraArgs(uVar2,0);
}
va_end(local_14);
puVar1 = CL_current_values;
uVar3 = clSymbolValue(clstarDEFAULT_ELEMENT_TYPEstar,0);
*puVar1 = uVar3;
puVar1 = CL_current_values;
CL_current_values[1] = 0;
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return *puVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
clObject clLambda_r1 (clObject CLcurrent_ap, ...)
{ { va_list _ap; clObject CLparse_temp_ap; ; (void) CLparse_temp_ap; va_start(_ap, CLcurrent_ap); ;
if ((!(((CLcurrent_ap))==(((clObject) 0))))) clExtraArgs(_clVlist(CLcurrent_ap, &_ap), ((clObject) 0));
va_end(_ap); }
return((((CL_current_values[0])=((clSymbolValue(clstarDEFAULT_ELEMENT_TYPEstar, ((clObject) 0))))), ((CL_current_values[1])=(((clObject) 0))), CL_current_values[0])
); }
|
void e4000_dvb_sleep(undefined4 *param_1)
{
e4000_sleep(*param_1);
return;
}
|
int e4000_dvb_sleep(struct dvb_frontend *fe)
{
return e4000_sleep(fe->tuner_priv);
}
|
double f_solvevf(double param_1,double param_2,undefined8 param_3,double param_4,double param_5,
int *param_6)
{
int iVar1;
double dVar2;
double dVar3;
double dVar4;
iVar1 = 0;
dVar4 = (param_1 * param_4) / (_LC0 - param_4 * param_2);
dVar2 = _LC0;
if (0 < *param_6) {
do {
if (dVar2 < *(double *)(param_6 + 2)) {
return param_5;
}
iVar1 = iVar1 + 1;
dVar2 = (double)f_lnsum(param_4,2);
dVar3 = (double)f_logit(param_4,dVar4,param_3,2,0);
param_5 = dVar4 - ((dVar4 - param_1) - dVar2 * param_2) / (_LC0 - dVar3 * param_2);
dVar2 = (double)((ulong)(param_5 - dVar4) & __LC1);
dVar4 = param_5;
} while (iVar1 < *param_6);
}
mexErrMsgTxt("Failed to converge in v=a+b*logsum(v,c) solution (see function.c/f_solvef)!");
return param_5;
}
|
double f_solvevf(double a, double b, double c, double eta, MPstruct *mp){
int it;
double v,v1,cp=1.0;
v=a*eta/(1-b*eta);
for (it=0;((it<mp[0].maxit) && (cp>=mp[0].ctol));it++){
v1 = v-(v-a-b*f_lnsum(2, eta, v, c))/(1-b*f_logit(2, eta, NULL, v, c));
cp=fabs(v1-v);
v=v1;
}
if (it>=mp[0].maxit) mexErrMsgTxt("Failed to converge in v=a+b*logsum(v,c) solution (see function.c/f_solvef)!");
return (v1);
}
|
void LoadTrimDACs(undefined8 param_1)
{
undefined4 uVar1;
uint uVar2;
for (uVar2 = 0; uVar2 < 4; uVar2 = uVar2 + 1) {
uVar1 = I2Cread(param_1,*(undefined4 *)(trimadrs + (long)(int)uVar2 * 4));
WriteTrimDAC(param_1,uVar2,uVar1);
}
return;
}
|
void LoadTrimDACs( struct CORE_OBJ *c )
{
register U8 i;
for ( i = 0; i < sizeof(trimchan); i++ )
WriteTrimDAC( c, i, I2Cread( c, trimadrs[i] ) );
}
|
undefined8 c_vector_remove_unordered_float32p(ulong *param_1,ulong param_2)
{
undefined8 local_10;
local_10 = 0;
if ((param_1 != (ulong *)0x0) && (param_2 < *param_1)) {
local_10 = *(undefined8 *)(param_1[2] + param_2 * 8);
*param_1 = *param_1 - 1;
*(undefined8 *)(param_2 * 8 + param_1[2]) = *(undefined8 *)(param_1[2] + *param_1 * 8);
*(int *)(param_1 + 1) = *(int *)(param_1 + 1) + 1;
}
return local_10;
}
|
c_float32_t* c_vector_remove_unordered_float32p(c_vector_float32p_t vector, c_uint64_t index) { c_float32_t* item = 0; if (vector && index < vector->size) { item = vector->items[index]; --vector->size; vector->items[index] = vector->items[vector->size]; ++vector->timestamp; } return item; }
|
void lima_sched_slab_fini(void)
{
lima_fence_slab_refcnt = lima_fence_slab_refcnt + -1;
if (lima_fence_slab_refcnt != 0) {
return;
}
kmem_cache_destroy(lima_fence_slab);
lima_fence_slab = 0;
return;
}
|
void lima_sched_slab_fini(void)
{
if (!--lima_fence_slab_refcnt) {
kmem_cache_destroy(lima_fence_slab);
lima_fence_slab = NULL;
}
}
|
undefined8 ic_body_init(undefined8 *param_1)
{
int iVar1;
if (param_1 == (undefined8 *)0x0) {
puts("ic_body_init: body was null");
return 0;
}
iVar1 = ic_pvector_init(param_1 + 1,0);
if (iVar1 != 0) {
*param_1 = 0;
return 1;
}
puts("ic_body_init: call to ic_pvector_init failed");
return 0;
}
|
unsigned int ic_body_init(struct ic_body *body) {
if (!body) {
puts("ic_body_init: body was null");
return 0;
};
if (!ic_pvector_init(&(body->contents), 0)) {
puts("ic_body_init: call to ic_pvector_init failed");
return 0;
}
body->scope = 0;
return 1;
}
|
void compress_output(int *param_1)
{
int iVar1;
int iVar2;
int *piVar3;
undefined4 uVar4;
long lVar5;
long lVar6;
long in_FS_OFFSET;
undefined4 auStack_58 [10];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = *(int *)(long)param_1[6];
if (0 < *param_1) {
lVar5 = 0;
do {
piVar3 = *(int **)(*(long *)(param_1 + 4) + lVar5 * 8);
iVar2 = piVar3[1];
lVar6 = (long)*piVar3;
uVar4 = (***(code ***)(param_1 + 2))
((ulong)param_1 & 0xffffffff,
*(undefined4 *)(*(long *)((int *)(long)iVar1 + 2) + lVar6 * 4),
iVar2 * *(int *)(long)iVar1,iVar2,0);
auStack_58[lVar6] = uVar4;
lVar5 = lVar5 + 1;
} while ((int)lVar5 < *param_1);
}
compress_data(param_1,auStack_58);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
boolean
compress_output (j_compress_ptr cinfo, JSAMPIMAGE input_buf)
{
j_lossless_c_ptr losslsc = (j_lossless_c_ptr) cinfo->codec;
c_diff_ptr diff = (c_diff_ptr) losslsc->diff_private;
int comp, ci ;
JSAMPARRAY buffer[10];
jpeg_component_info *compptr;
for (comp = 0; comp < cinfo->comps_in_scan; comp++) {
compptr = cinfo->cur_comp_info[comp];
ci = compptr->component_index;
buffer[ci] = (*cinfo->mem->access_virt_sarray)
((j_common_ptr) cinfo, diff->whole_image[ci],
diff->iMCU_row_num * compptr->v_samp_factor,
(JDIMENSION) compptr->v_samp_factor, 0);
}
return compress_data(cinfo, buffer);
}
|
undefined8 main(void)
{
uint uVar1;
long in_FS_OFFSET;
undefined4 local_100;
undefined4 local_fc;
char local_f8 [112];
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
puts("Say something cool from which to copy:");
fgets(local_88,100,(FILE *)(ulong)stdin);
printf("Ok, now from which ch forward do you want me to copy?: ");
scanf("%d",&local_100);
printf("\nAnd at which ch would you like me to stop?: ");
scanf("%d",&local_fc);
puts("\n\nCool!");
uVar1 = substr(local_f8,local_88,local_100,local_fc);
printf("So you should have %d characters left..",(ulong)uVar1);
puts("\n\tWhich should be..");
puts(local_f8);
puts("\n");
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int main(void)
{
char dest[100];
char string[100];
int start;
int len;
puts("Say something cool from which to copy:");
fgets(string, 100, stdin);
printf("Ok, now from which ch forward do you want me to copy?: ");
scanf("%d", &start);
printf("\nAnd at which ch would you like me to stop?: ");
scanf("%d", &len);
puts("\n\nCool!");
printf("So you should have %d characters left..", substr(dest, string, start, len));
puts("\n\tWhich should be..");
puts(dest);
puts("\n");
return 0;
}
|
void array_init(undefined8 *param_1,undefined8 param_2,undefined8 param_3)
{
param_1[4] = 0;
*param_1 = param_2;
param_1[3] = 0;
param_1[2] = 0;
param_1[1] = param_3;
return;
}
|
void array_init (ARRAY *arr, long ElementSize, long AllocationStep)
{
arr->D = NULL;
arr->ElementSize = ElementSize;
arr->Size = 0;
arr->Used = 0;
arr->AllocationStep = AllocationStep;
}
|
void data_setspecialflag(int param_1)
{
*(undefined4 *)(*(long *)(buffer + (long)param_1 * 8) + 0xc) = 1;
return;
}
|
void data_setspecialflag(int p) {
buffer[p][3] = 1;
}
|
void SV_Netchan_Transmit(long *param_1,undefined4 *param_2)
{
undefined8 *puVar1;
undefined8 *puVar2;
MSG_WriteByte(param_2,svc_EOF);
if ((*param_1 == 0) && (param_1[4] == 0)) {
Netchan_Transmit(param_1,param_2[1],*param_2);
return;
}
Com_DPrintf("#462 SV_Netchan_Transmit: unsent fragments, stacked\n");
puVar2 = (undefined8 *)Z_Malloc(0x18);
MSG_Copy(puVar2 + 2,*(undefined4 *)((long)puVar2 + 0xc),4,param_2);
puVar1 = (undefined8 *)param_1[3];
*puVar2 = 0;
*puVar1 = puVar2;
param_1[3] = (long)puVar2;
return;
}
|
void SV_Netchan_Transmit( client_t *client, msg_t *msg)
{
MSG_WriteByte( msg, svc_EOF );
if(client->netchan.unsentFragments || client->netchan_start_queue)
{
netchan_buffer_t *netbuf;
Com_DPrintf("#462 SV_Netchan_Transmit: unsent fragments, stacked\n");
netbuf = (netchan_buffer_t *) Z_Malloc(sizeof(netchan_buffer_t));
// store the msg, we can't store it encoded, as the encoding depends on stuff we still have to finish sending
MSG_Copy(&netbuf->msg, netbuf->msgBuffer, sizeof( netbuf->msgBuffer ), msg);
#ifdef LEGACY_PROTOCOL
if(client->compat)
{
Q_strncpyz(netbuf->clientCommandString, client->lastClientCommandString,
sizeof(netbuf->clientCommandString));
}
#endif
netbuf->next = NULL;
// insert it in the queue, the message will be encoded and sent later
*client->netchan_end_queue = netbuf;
client->netchan_end_queue = &(*client->netchan_end_queue)->next;
}
else
{
#ifdef LEGACY_PROTOCOL
if(client->compat)
SV_Netchan_Encode(client, msg, client->lastClientCommandString);
#endif
Netchan_Transmit( &client->netchan, msg->cursize, msg->data );
}
}
|
void sljit_set_target(undefined4 *param_1,undefined4 param_2)
{
long lVar1;
lVar1 = SLJIT_LIKELY(param_1 != (undefined4 *)0x0);
if (lVar1 != 0) {
param_1[1] = ~JUMP_LABEL & param_1[1];
param_1[1] = param_1[1] | JUMP_ADDR;
*param_1 = param_2;
}
return;
}
|
void sljit_set_target(struct sljit_jump *jump, sljit_uw target)
{
if (SLJIT_LIKELY(!!jump)) {
jump->flags &= ~JUMP_LABEL;
jump->flags |= JUMP_ADDR;
jump->u.target = target;
}
}
|
void PrintOneLine(char *param_1,long param_2,int param_3,FILE **param_4)
{
char cVar1;
uint uVar2;
long lVar3;
int iVar4;
ulong uVar5;
char *pcVar6;
long in_FS_OFFSET;
byte bVar7;
char acStack_1048 [4104];
long local_40;
bVar7 = 0;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (**measure == '\0') {
strcpy(*measure," ");
}
lVar3 = -1;
pcVar6 = *measure;
do {
if (lVar3 == 0) break;
lVar3 = lVar3 + -1;
cVar1 = *pcVar6;
pcVar6 = pcVar6 + (ulong)bVar7 * -2 + 1;
} while (cVar1 != '\0');
if (6 < (int)(~(uint)lVar3 - 1)) {
iVar4 = 1;
do {
putc(0x20,*param_4);
iVar4 = iVar4 + 1;
} while (iVar4 != ~(uint)lVar3 - 6);
}
fputs(param_1,*param_4);
if (0 < param_3) {
uVar5 = 1;
do {
iVar4 = IsItATransistor(*(undefined4 *)(measure + uVar5 * 3 + 2),1,uVar5 & 0xffffffff,0);
if ((iVar4 == 0) || (measure[uVar5 * 3 + 1] == (char *)0x0)) {
uVar2 = extended2engineer(param_2 + uVar5 * 8);
sprintf(acStack_1048,"%7.3f",*(undefined8 *)(param_2 + uVar5 * 8));
fprintf(*param_4,"%se%i | ",acStack_1048,(ulong)uVar2);
}
uVar5 = uVar5 + 1;
} while (uVar5 != (ulong)(param_3 - 1) + 2);
}
putc(10,*param_4);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
void PrintOneLine(char *lkk1, double *stats, int num_measures, FILE **fSummary)
{
int i, j;
char laux[4096];
int FORLIM;
if (*measure[0].data == '\0')
strcpy(measure[0].data, " ");
FORLIM = (int)strlen(measure[0].data) - 6;
for (i = 1; i <= FORLIM; i++)
putc(' ', *fSummary);
fputs(lkk1, *fSummary);
for (i = 1; i <= num_measures; i++) {
if ((!IsItATransistor(measure[i].search, 1, i, '\0')) || measure[i].column1 == 0) {
j = extended2engineer(&stats[i]);
sprintf(laux, "%7.3f", stats[i]);
fprintf(*fSummary, "%se%i | ", laux, j);
}
}
putc('\n', *fSummary);
}
|
byte * strcasestr_l(byte *param_1,byte *param_2,uint param_3)
{
byte bVar1;
int iVar2;
int iVar3;
undefined4 extraout_var;
ulong uVar4;
byte *pbVar5;
byte bVar6;
bVar6 = 0;
FIX_LOCALE(param_3);
if (*param_2 != 0) {
iVar2 = tolower_l((uint)*param_2,(__locale_t)(ulong)param_3);
uVar4 = 0xffffffffffffffff;
pbVar5 = param_2 + 1;
do {
if (uVar4 == 0) break;
uVar4 = uVar4 - 1;
bVar1 = *pbVar5;
pbVar5 = pbVar5 + (ulong)bVar6 * -2 + 1;
} while (bVar1 != 0);
bVar6 = *param_1;
pbVar5 = param_1 + 1;
if (bVar6 == 0) {
param_1 = (byte *)0x0;
}
else {
do {
iVar3 = tolower_l((uint)bVar6,(__locale_t)(ulong)param_3);
if (((char)iVar3 == (char)iVar2) &&
(iVar3 = strncasecmp_l((char *)pbVar5,(char *)(param_2 + 1),~uVar4 - 1,
(__locale_t)(ulong)param_3), CONCAT44(extraout_var,iVar3) == 0)) {
return pbVar5 + -1;
}
bVar6 = *pbVar5;
pbVar5 = pbVar5 + 1;
} while (bVar6 != 0);
param_1 = (byte *)0x0;
}
}
return param_1;
}
|
char *
strcasestr_l(const char *s, const char *find, locale_t locale)
{
char c, sc;
size_t len;
FIX_LOCALE(locale);
if ((c = *find++) != 0) {
c = tolower_l((unsigned char)c, locale);
len = strlen(find);
do {
do {
if ((sc = *s++) == 0)
return (NULL);
} while ((char)tolower_l((unsigned char)sc, locale) != c);
} while (strncasecmp_l(s, find, len, locale) != 0);
s--;
}
return ((char *)s);
}
|
undefined4 * alloc2(void)
{
undefined4 *puVar1;
puVar1 = (undefined4 *)malloc(4);
*puVar1 = 9;
return puVar1;
}
|
struct item *alloc2(void)
{
struct item *i = malloc(sizeof *i);
i->a = 9;
return i;
}
|
bool vcgtq_s64(long param_1,long param_2)
{
return param_2 < param_1;
}
|
uint64x2
vcgtq_s64 (int64x2_t a, int64x2_t b)
{
return (uint64x2_t) (a > b);
}
|
fsdirConnect(undefined8 param_1,undefined8 param_2,int param_3,undefined8 param_4,void **param_5,
undefined8 *param_6)
{
undefined4 uVar1;
undefined8 uVar2;
void *__s;
if (param_3 == 3) {
__s = (void *)sqlite3_malloc(4);
uVar1 = SQLITE_NOMEM;
if (__s != (void *)0x0) {
memset(__s,0,4);
*param_5 = __s;
sqlite3_declare_vtab(param_1,"CREATE TABLE xyz(dir, name);");
uVar1 = SQLITE_OK;
}
}
else {
uVar2 = sqlite3_mprintf("wrong number of arguments");
*param_6 = uVar2;
uVar1 = SQLITE_ERROR;
}
return uVar1;
}
|
int fsdirConnect(
sqlite3 *db,
void *pAux,
int argc, const char *const*argv,
sqlite3_vtab **ppVtab,
char **pzErr
){
FsdirVtab *pTab;
if( argc!=3 ){
*pzErr = sqlite3_mprintf("wrong number of arguments");
return SQLITE_ERROR;
}
pTab = (FsdirVtab *)sqlite3_malloc(sizeof(FsdirVtab));
if( !pTab ) return SQLITE_NOMEM;
memset(pTab, 0, sizeof(FsdirVtab));
*ppVtab = &pTab->base;
sqlite3_declare_vtab(db, "CREATE TABLE xyz(dir, name);");
return SQLITE_OK;
}
|
undefined4 snd_ctl_event_elem_get_mask(undefined8 param_1)
{
long in_FS_OFFSET;
undefined4 local_2c;
undefined8 local_28;
undefined4 local_20;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = snd_ctl_event_elem_get_mask_INDEX;
local_28 = param_1;
syscall((ulong)SYS_proxy,&local_28,&local_2c);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_2c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
unsigned int snd_ctl_event_elem_get_mask(const snd_ctl_event_t * obj) {
snd_ctl_event_elem_get_mask_INDEXED packed_data;
packed_data.func = snd_ctl_event_elem_get_mask_INDEX;
packed_data.args.a1 = (snd_ctl_event_t *)obj;
unsigned int ret;
syscall(SYS_proxy, (void *)&packed_data, &ret);
return ret;
}
|
int groestl_Hash(undefined4 param_1,undefined8 param_2,undefined4 param_3,undefined8 param_4)
{
long in_FS_OFFSET;
undefined local_18 [4];
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_14 = groestl_Init(local_18,param_1);
if ((local_14 == 0) && (local_14 = groestl_Update(local_18,param_2,param_3), local_14 == 0)) {
local_14 = groestl_Final(local_18,param_4);
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_14;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int groestl_Hash(int hashbitlen,
const groestl_BitSequence* data,
groestl_DataLength databitlen,
groestl_BitSequence* hashval) {
int ret;
groestl_hashState ctx;
if ((ret = groestl_Init(&ctx, hashbitlen)))
return ret;
if ((ret = groestl_Update(&ctx, data, databitlen)))
return ret;
ret = groestl_Final(&ctx, hashval);
return ret;
}
|
void xpad_stop_input(undefined4 *param_1)
{
usb_kill_urb(*param_1);
return;
}
|
void xpad_stop_input(struct usb_xpad *xpad)
{
usb_kill_urb(xpad->irq_in);
}
|
void HPcoord_to_dotcoord(int *param_1,int *param_2)
{
*param_2 = (*param_1 - xmin) * HP_to_xdots;
param_2[1] = (param_1[1] - ymin) * HP_to_ydots;
return;
}
|
void HPcoord_to_dotcoord (HPGL_Pt *HP_P, DevPt *DevP)
{
DevP->x = (int) ((HP_P->x - xmin) * HP_to_xdots);
DevP->y = (int) ((HP_P->y - ymin) * HP_to_ydots);
}
|
void CRC(undefined8 param_1,undefined4 param_2)
{
UpdateCRC(0,param_1,param_2);
return;
}
|
unsigned long CRC(const unsigned char* buf, int len) {
return UpdateCRC(0L, buf, len);
}
|
void do_query(wchar_t *param_1)
{
int iVar1;
undefined4 extraout_var;
size_t sVar2;
char *pcVar3;
while( true ) {
iVar1 = isspace(*param_1);
if (CONCAT44(extraout_var,iVar1) == 0) break;
param_1 = param_1 + 1;
}
sVar2 = wcstombs((char *)0x0,param_1,0);
sVar2 = (size_t)((int)sVar2 + 1);
pcVar3 = (char *)malloc(sVar2);
if (pcVar3 != (char *)0x0) {
wcstombs(pcVar3,param_1,sVar2);
create_query_window(pcVar3,VINK_XMPP);
current_window = windows._0_8_ + -1;
return;
}
pcVar3 = strerror(errno);
do_log(windows._8_8_,L"-!- malloc failed: %s",(ulong)pcVar3 & 0xffffffff);
return;
}
|
void
do_query (wchar_t *args)
{
char *address;
size_t length;
while (isspace (*args))
++args;
length = wcstombs (NULL, args, 0) + 1;
address = malloc (length);
if (!address)
{
do_log (&(&windows)->array_elements[(0)], L"-!- malloc failed: %s", strerror (errno));
return;
}
wcstombs (address, args, length);
create_query_window (address, VINK_XMPP);
current_window = (&windows)->array_element_count - 1;
}
|
void debug(void)
{
fprintf((FILE *)(ulong)stdout,"g_repertoire : %s\n",g_repertoire);
fprintf((FILE *)(ulong)stdout,"g_fichier : %s\n",g_fichier);
fprintf((FILE *)(ulong)stdout,"g_extension : %s\n",g_extension);
fprintf((FILE *)(ulong)stdout,"g_taille : %d\n",(ulong)g_taille);
return;
}
|
void debug()
{
fprintf(stdout, "g_repertoire : %s\n", g_repertoire);
fprintf(stdout, "g_fichier : %s\n", g_fichier);
fprintf(stdout, "g_extension : %s\n", g_extension);
fprintf(stdout, "g_taille : %d\n", g_taille);
}
|
void setnonblocking(int param_1)
{
uint uVar1;
int iVar2;
uVar1 = fcntl(param_1,F_GETFL,0);
if (uVar1 == 0xffffffff) {
fs_log(LOG_ERR,"fcntl F_GETFL");
return;
}
iVar2 = fcntl(param_1,F_SETFL,(ulong)(uVar1 | O_NONBLOCK));
if (iVar2 != -1) {
return;
}
fs_log(LOG_ERR,"fcntl F_SETFL: O_NONBLOCK");
return;
}
|
void setnonblocking(int fd) {
int flag = 0;
flag = fcntl(fd, F_GETFL, 0);
if (flag == -1) {
fs_log(LOG_ERR, "fcntl F_GETFL");
return;
}
if( fcntl(fd, F_SETFL, flag|O_NONBLOCK) == -1 ) {
fs_log(LOG_ERR, "fcntl F_SETFL: O_NONBLOCK");
return;
}
}
|
void Lisp_StringGreater(undefined8 param_1)
{
LispStringCompare(param_1,5,0);
return;
}
|
LispObj *
Lisp_StringGreater(LispBuiltin *builtin)
{
return (LispStringCompare(builtin, 5, 0));
}
|
undefined4 list_hashcomputer_int8_t(undefined4 *param_1)
{
return *param_1;
}
|
list_hash_t list_hashcomputer_int8_t(const void *el) { return (list_hash_t)(*(int8_t *)el); }
|
undefined8 res_init(void)
{
_res = 0;
__dns_readstartfiles();
return 0;
}
|
int res_init(void) {
_res.nscount=0;
__dns_readstartfiles();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.