Dataset Viewer
instruction
stringlengths 27
1.88k
| output
stringlengths 21
2.78k
|
|---|---|
uint * init_stack(uint param_1)
{
uint *puVar1;
void *pvVar2;
puVar1 = (uint *)malloc(0xc);
if (puVar1 != (uint *)0x0) {
pvVar2 = calloc((ulong)param_1,4);
*puVar1 = param_1;
puVar1[2] = (uint)pvVar2;
puVar1[1] = 0xffffffff;
}
return puVar1;
} | struct seq_stack *init_stack(int size)
{
struct seq_stack *s = malloc(sizeof(struct seq_stack));
if(s != NULL)
{
s->stack = calloc(size, sizeof(int));
s->size = size;
s->top = -1;
}
return s;
} |
long rs_region_get_chunk_length(undefined8 param_1,undefined4 param_2,undefined4 param_3)
{
int iVar1;
undefined8 *puVar2;
long lVar3;
iVar1 = rs_region_contains_chunk();
if (iVar1 != 0) {
puVar2 = (undefined8 *)_rs_region_get_data(param_1,param_2,param_3);
if (puVar2 != (undefined8 *)0x0) {
lVar3 = rs_endian_uint32(*puVar2);
return lVar3 + -1;
}
}
return 0;
} | uint32_t rs_region_get_chunk_length(RSRegion* self, uint8_t x, uint8_t z)
{
if (!rs_region_contains_chunk(self, x, z))
return 0;
uint32_t* size_int = (uint32_t*)_rs_region_get_data(self, x, z);
if (!size_int)
return 0;
return rs_endian_uint32(size_int[0]) - 1;
} |
void load_GL_ARB_transpose_matrix(code *param_1)
{
if (GLAD_GL_ARB_transpose_matrix != 0) {
glad_glLoadTransposeMatrixfARB = (*param_1)("glLoadTransposeMatrixfARB");
glad_glLoadTransposeMatrixdARB = (*param_1)("glLoadTransposeMatrixdARB");
glad_glMultTransposeMatrixfARB = (*param_1)("glMultTransposeMatrixfARB");
glad_glMultTransposeMatrixdARB = (*param_1)("glMultTransposeMatrixdARB");
return;
}
return;
} | void load_GL_ARB_transpose_matrix(GLADloadproc load) {
if(!GLAD_GL_ARB_transpose_matrix) return;
glad_glLoadTransposeMatrixfARB = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)load("glLoadTransposeMatrixfARB");
glad_glLoadTransposeMatrixdARB = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)load("glLoadTransposeMatrixdARB");
glad_glMultTransposeMatrixfARB = (PFNGLMULTTRANSPOSEMATRIXFARBPROC)load("glMultTransposeMatrixfARB");
glad_glMultTransposeMatrixdARB = (PFNGLMULTTRANSPOSEMATRIXDARBPROC)load("glMultTransposeMatrixdARB");
} |
void srand(uint __seed)
{
_x = __seed;
return;
} | void srand (unsigned int seed) {
_x = seed;
} |
void target_laser_use(long *param_1,undefined8 param_2,long param_3)
{
param_1[1] = param_3;
if (*param_1 < 1) {
target_laser_on();
}
else {
target_laser_off();
}
return;
} | void target_laser_use( gentity_t *self, gentity_t *other, gentity_t *activator ) {
self->activator = activator;
if ( self->nextthink > 0 ) {
target_laser_off( self );
} else {
target_laser_on( self );
}
} |
void safecat(char *param_1,long param_2,char *param_3)
{
size_t sVar1;
size_t sVar2;
sVar1 = strlen(param_1);
sVar2 = strlen(param_3);
if (param_2 - 1U < sVar1 + sVar2) {
errAbort("buffer overflow, size %lld, new string size: %lld",param_2,sVar2 + sVar1);
}
strcat(param_1,param_3);
return;
} | void safecat(char *buf, size_t bufSize, const char *src)
{
size_t blen = strlen(buf);
size_t slen = strlen(src);
if (blen+slen > bufSize-1)
errAbort("buffer overflow, size %lld, new string size: %lld", (long long)bufSize, (long long)(blen+slen));
strcat(buf, src);
} |
undefined4 xdr___rpc_qcsapi_calcmd_tx_power_rsp(XDR *param_1,char **param_2)
{
bool_t bVar1;
undefined4 uVar2;
bVar1 = xdr_vector(param_1,*param_2,4,4,(xdrproc_t)(ulong)(uint)xdr_uint32_t);
uVar2 = FALSE;
if (bVar1 != 0) {
uVar2 = TRUE;
}
return uVar2;
} | bool_t
xdr___rpc_qcsapi_calcmd_tx_power_rsp (XDR *xdrs, __rpc_qcsapi_calcmd_tx_power_rsp *objp)
{
register int32_t *buf;
int i;
if (!xdr_vector (xdrs, (char *)objp->value, 4,
sizeof (uint32_t), (xdrproc_t) xdr_uint32_t))
return FALSE;
return TRUE;
} |
void checkarg(int param_1)
{
if (param_1 != 4) {
if (param_1 == 1) {
printf("Error: Arguments not supplied\n");
printf("Usage: ./replacew <word> <File> <word2replace>\n");
}
else if (param_1 == 2) {
printf("Error: file name & word2replace not supplied\n");
printf("Usage: ./replacew <word> <File> <word2replace>\n");
}
else if (param_1 == 3) {
printf("Error: word2replace not supplied\n");
printf("Usage: ./replacew <word> <File> <word2replace>\n");
}
else {
printf("Error: More than enough argument supplied\n");
}
}
return;
} | void checkarg(int argc)
{
if(argc!=4)
{
if(argc==1) {
printf("Error: Arguments not supplied\n");
printf("Usage: ./replacew <word> <File> <word2replace>\n");
return; }
if(argc==2) {
printf("Error: file name & word2replace not supplied\n");
printf("Usage: ./replacew <word> <File> <word2replace>\n");
return; }
if(argc==3){
printf("Error: word2replace not supplied\n");
printf("Usage: ./replacew <word> <File> <word2replace>\n");
return; }
else { printf("Error: More than enough argument supplied\n");
return;
}
}
} |
void ir_close(void)
{
code **ppcVar1;
ppcVar1 = (code **)input_get_drvdata();
/* WARNING: Could not recover jumptable at 0x00100017. Too many branches */
/* WARNING: Treating indirect jump as call */
(**ppcVar1)(ppcVar1);
return;
} | void ir_close(struct input_dev *idev)
{
struct rc_dev *rdev = input_get_drvdata(idev);
rdev->close(rdev);
} |
long vc4_load_tracker_duplicate_state(undefined4 *param_1)
{
long lVar1;
lVar1 = kmemdup(*param_1,4,GFP_KERNEL);
if (lVar1 != 0) {
__drm_atomic_helper_private_obj_duplicate_state(param_1,lVar1);
}
return lVar1;
} | struct drm_private_state *
vc4_load_tracker_duplicate_state(struct drm_private_obj *obj)
{
struct vc4_load_tracker_state *state;
state = kmemdup(obj->state, sizeof(*state), GFP_KERNEL);
if (!state)
return NULL;
__drm_atomic_helper_private_obj_duplicate_state(obj, &state->base);
return &state->base;
} |
void main(void)
{
__uid_t __uid;
int __status;
int extraout_var;
__uid = geteuid();
setuid(__uid);
if (extraout_var < 0) {
perror("Unable to set UID");
/* WARNING: Subroutine does not return */
exit(EXIT_FAILURE);
}
__status = system("launchctl unload /Library/LaunchDaemons/com.makerbot.conveyor.plist");
if (-1 < __status) {
/* WARNING: Subroutine does not return */
exit(__status);
}
perror("Error in system call");
/* WARNING: Subroutine does not return */
exit(EXIT_FAILURE);
} | int main(int argc, int argv) {
if (setuid(geteuid()) < 0) {
perror("Unable to set UID");
exit(EXIT_FAILURE);
}
int ret = system("launchctl unload /Library/LaunchDaemons/com.makerbot.conveyor.plist");
if (ret < 0) {
perror("Error in system call");
exit(EXIT_FAILURE);
}
exit(ret);
} |
void update_relative_gitdir(undefined8 param_1,undefined8 param_2,undefined8 param_3)
{
undefined4 uVar1;
void *__ptr;
uVar1 = get_git_dir();
__ptr = (void *)reparent_relative_path(param_2,param_3,uVar1);
trace_printf_key(&trace_setup_key,"setup: move $GIT_DIR to \'%s\'",__ptr);
set_git_dir_1(__ptr);
free(__ptr);
return;
} | void update_relative_gitdir(const char *name,
const char *old_cwd,
const char *new_cwd,
void *data)
{
char *path = reparent_relative_path(old_cwd, new_cwd, get_git_dir());
trace_printf_key(&trace_setup_key,
"setup: move $GIT_DIR to '%s'",
path);
set_git_dir_1(path);
free(path);
} |
void hwtimer_decrement(long *param_1,ulong param_2)
{
long lVar1;
if (*param_1 == 0) {
if (param_1[1] == 0) {
return;
}
*param_1 = -(param_2 & 0xffffffff);
}
else {
lVar1 = *param_1 - (param_2 & 0xffffffff);
*param_1 = lVar1;
if (0 < lVar1) {
return;
}
}
if ((param_1[3] != 0) && ((*(byte *)(param_1 + 2) & 0x80) != 0)) {
imux_assert(param_1[3],*(undefined4 *)((long)param_1 + 0x14));
}
if (*param_1 < 0) {
if (param_1[1] < 1) {
*param_1 = 0;
return;
}
lVar1 = *param_1 + param_1[1];
*param_1 = lVar1;
if (lVar1 < 0) {
sim_error("timer count = %d, reload = %d\n");
return;
}
}
return;
} | void hwtimer_decrement (struct hwtimer *timer, unsigned int cycles)
{
if (!timer->count && !timer->reload)
return;
timer->count -= cycles;
if (timer->count <= 0)
{
if (timer->int_dev && timer->flags & 0x80)
{
imux_assert (timer->int_dev, timer->int_line);
}
if (timer->count < 0)
{
if (timer->reload > 0)
{
timer->count += timer->reload;
if (timer->count < 0)
sim_error ("timer count = %d, reload = %d\n", timer->count, timer->reload);
}
else
{
timer->count = 0;
}
}
}
} |
uint get_VCC(void)
{
return cf_clip[7] << 0xf | cf_clip[6] << 0xe | cf_clip[5] << 0xd | cf_clip[4] << 0xc |
cf_clip[3] << 0xb | cf_clip[2] << 10 | cf_clip[1] << 9 | *cf_clip << 8 | cf_comp[7] << 7 |
cf_comp[6] << 6 | cf_comp[5] << 5 | cf_comp[4] << 4 | cf_comp[3] << 3 | cf_comp[2] << 2 |
cf_comp[1] * 2 | *cf_comp;
} | u16 get_VCC(void)
{
register u16 VCC;
VCC = 0x0000
| (cf_clip[0xF % 8] << 0xF)
| (cf_clip[0xE % 8] << 0xE)
| (cf_clip[0xD % 8] << 0xD)
| (cf_clip[0xC % 8] << 0xC)
| (cf_clip[0xB % 8] << 0xB)
| (cf_clip[0xA % 8] << 0xA)
| (cf_clip[0x9 % 8] << 0x9)
| (cf_clip[0x8 % 8] << 0x8)
| (cf_comp[0x7 % 8] << 0x7)
| (cf_comp[0x6 % 8] << 0x6)
| (cf_comp[0x5 % 8] << 0x5)
| (cf_comp[0x4 % 8] << 0x4)
| (cf_comp[0x3 % 8] << 0x3)
| (cf_comp[0x2 % 8] << 0x2)
| (cf_comp[0x1 % 8] << 0x1)
| (cf_comp[0x0 % 8] << 0x0);
return (VCC);
} |
void store_code(undefined4 param_1,int param_2)
{
right_shift_arr(code_cache,param_1,9,-param_2);
code_cache_remainder = code_cache_remainder - param_2;
return;
} | void store_code(int32_t code, uint16_t len) {
right_shift_arr(code_cache, code, 9, -len);
code_cache_remainder -= len;
} |
void put_no_rnd_pixels16_c(long param_1,long param_2,undefined4 param_3,undefined4 param_4)
{
put_pixels8_c();
put_pixels8_c(param_1 + 0x20,param_2 + 0x20,param_3,param_4);
return;
} | void put_no_rnd_pixels16_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){ put_pixels8_c(block , pixels , line_size, h); put_pixels8_c(block+8, pixels+8, line_size, h);} |
void test_arbre(void)
{
undefined8 uVar1;
undefined8 uVar2;
ulong uVar3;
undefined8 uVar4;
long in_FS_OFFSET;
char local_48 [8];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = cree_arbre();
while( true ) {
do {
printf(
"\n1. (I)nsere arbre\n \n 0. (F)inir\n Choix : "
);
saisie_chaine(local_48,2);
uVar1 = compare_contenu;
} while (0x39 < (byte)(local_48[0] - 0x30U));
uVar3 = 1L << (local_48[0] - 0x30U & 0x3f);
if ((uVar3 & 0x40000000400001) != 0) break;
if ((uVar3 & 0x200000002000002) != 0) {
uVar4 = cree_alea_contenu(0);
insere_arbre(uVar2,uVar4,uVar1);
printf("%-20s : ","Ajout : \n");
affiche_contenu(uVar4);
putchar(10);
printf("%-10s : \n","Arbree");
affiche_arbre(uVar2,affiche_contenu);
putchar(10);
}
}
libere_arbre(uVar2,(long)libere_contenu);
mon_free(uVar2);
puts("Fin");
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
} | void test_arbre() {
char rep[8];
contenu *pc;
T_arbre *pa;
pa=cree_arbre();
for(;;) {
printf("\n1. (I)nsere arbre\n \n 0. (F)inir\n Choix : ");
saisie_chaine(rep,2);
switch(rep[0]) {
case 'I': case'i': case'1':
insere_arbre(pa,pc = cree_alea_contenu(0),
(int(*)(void *, void *))compare_contenu);
printf("%-20s : ","Ajout : \n");
affiche_contenu(pc);
printf("\n");
printf("%-10s : \n", "Arbree");
affiche_arbre(pa,(void(*)(void *))affiche_contenu);
printf("\n");
break;
case'F': case'f': case'0':
libere_arbre(pa,(void(*)(void *))libere_contenu);
mon_free(pa);
printf("Fin\n");
return ;
}
}
} |
void uart_send_string(char *param_1)
{
char *pcVar1;
char cVar2;
cVar2 = *param_1;
if (cVar2 != '\0') {
pcVar1 = param_1 + 1;
do {
uart_send((int)cVar2);
cVar2 = *pcVar1;
pcVar1 = pcVar1 + 1;
} while (cVar2 != '\0');
}
return;
} | void uart_send_string(char* str)
{
for (int i = 0; str[i] != '\0'; i ++) {
uart_send((char)str[i]);
}
} |
void g(void)
{
undefined8 *in_R8;
if ((undefined *)*in_R8 != g_list) {
/* WARNING: Subroutine does not return */
abort();
}
*g_list = 0;
return;
} | void g (void *p, char *list, int length, char **elementPtr, char **nextPtr)
{
if (*nextPtr != g_list)
abort ();
**nextPtr = 0;
} |
undefined4 mv64xxx_i2c_execute_msg(undefined4 *param_1,undefined8 param_2,undefined4 param_3)
{
undefined8 local_10;
spin_lock_irqsave(param_1 + 3,local_10);
param_1[4] = MV64XXX_I2C_STATE_WAITING_FOR_START_COND;
*param_1 = param_3;
param_1[1] = 1;
mv64xxx_i2c_send_start(param_1);
spin_unlock_irqrestore(param_1 + 3,local_10);
mv64xxx_i2c_wait_for_completion(param_1);
return param_1[2];
} | int
mv64xxx_i2c_execute_msg(struct mv64xxx_i2c_data *drv_data, struct i2c_msg *msg,
int is_last)
{
unsigned long flags;
spin_lock_irqsave(&drv_data->lock, flags);
drv_data->state = MV64XXX_I2C_STATE_WAITING_FOR_START_COND;
drv_data->send_stop = is_last;
drv_data->block = 1;
mv64xxx_i2c_send_start(drv_data);
spin_unlock_irqrestore(&drv_data->lock, flags);
mv64xxx_i2c_wait_for_completion(drv_data);
return drv_data->rc;
} |
undefined8 bftpd_list_get(undefined8 *param_1,int param_2)
{
int iVar1;
if (0 < param_2) {
iVar1 = 0;
do {
param_1 = (undefined8 *)param_1[1];
if (param_1 == (undefined8 *)0x0) {
return 0;
}
iVar1 = iVar1 + 1;
} while (param_2 != iVar1);
}
return *param_1;
} | void *bftpd_list_get(struct bftpd_list_element *list, int index)
{
struct bftpd_list_element *tmp = list;
int i;
for (i = 0; i < index; i++) {
if (!(tmp->next))
return NULL;
tmp = tmp->next;
}
return tmp->data;
} |
long pci_region_size(long *param_1)
{
return (param_1[1] - *param_1) + 1;
} | u32 pci_region_size(const struct pci_region *r)
{
return r->last - r->first + 1;
} |
undefined8 main(void)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar1 = __VERIFIER_nondet_int();
iVar2 = __VERIFIER_nondet_int();
do {
if (iVar1 < 2) {
return 0;
}
iVar1 = iVar1 + -1;
iVar2 = iVar2 + iVar1;
if (iVar1 < iVar2) {
do {
iVar3 = __VERIFIER_nondet_int();
if (iVar3 == 0) break;
iVar2 = iVar2 + -1;
iVar3 = iVar1;
if (iVar1 + 2 < iVar2) {
do {
iVar4 = __VERIFIER_nondet_int();
iVar1 = iVar3;
if (iVar4 == 0) break;
iVar1 = iVar3 + 1;
iVar2 = iVar2 + -2;
iVar4 = iVar3 + 3;
iVar3 = iVar1;
} while (iVar4 < iVar2);
}
iVar2 = iVar2 + -1;
} while (iVar1 < iVar2);
}
iVar1 = iVar1 + -1;
iVar2 = iVar2 - iVar1;
} while( true );
} | int main() {
int x = __VERIFIER_nondet_int();
int y = __VERIFIER_nondet_int();
while (x >= 2) {
x--; y = y + x;
while (y >= x + 1 && __VERIFIER_nondet_int()) {
y--;
while (y >= x + 3 && __VERIFIER_nondet_int()) {
x++; y = y - 2;
}
y--;
}
x--; y = y - x;
}
return 0;
} |
gf_regress_glm_post(int param_1,void *param_2,long param_3,void *param_4,long param_5,long param_6,
long param_7,undefined8 param_8,undefined8 param_9)
{
long lVar1;
if (param_7 <= param_6) {
sf_format_size(param_8,param_9);
sf_errprintf("max iter (%s) reached; tolerance not achieved (%15.9g > %15.9g)\n",param_9,param_6
,param_7);
return 0xc6;
}
if (param_1 != 2) {
return 0;
}
if (param_5 != 0) {
lVar1 = 0;
do {
*(long *)(param_3 + lVar1 * 8) =
(*(long *)((long)param_4 + lVar1 * 8) / *(long *)((long)param_2 + lVar1 * 8)) *
*(long *)(param_3 + lVar1 * 8);
lVar1 = lVar1 + 1;
} while (param_5 != lVar1);
}
memcpy(param_4,param_2,param_5 * 8);
return 0;
} | ST_retcode gf_regress_glm_post(
GT_bool wcode,
ST_double *wptr,
ST_double *e,
ST_double *wgt,
GT_size nj,
ST_double diff,
ST_double poistol,
GT_size poisiter,
char *buf1)
{
GT_size i;
if ( diff < poistol ) {
if ( wcode == 2 ) {
for (i = 0; i < nj; i++) {
e[i] *= wgt[i] / wptr[i];
}
memcpy(wgt, wptr, nj * sizeof(ST_double));
}
return(0);
}
else {
sf_format_size(poisiter, buf1);
sf_errprintf("max iter (%s) reached; tolerance not achieved (%15.9g > %15.9g)\n",
buf1, diff, poistol);
return(198);
}
} |
void walk_rsdt(long *param_1)
{
int iVar1;
int iVar2;
long lVar3;
undefined4 *puVar4;
undefined4 extraout_var;
long lVar5;
memcmp((void *)(ulong)*(uint *)((long)param_1 + 4),&_LC0,4);
iVar1 = (int)((long)*(int *)param_1 - 8U >> 2);
if (0 < iVar1) {
lVar5 = 0;
do {
lVar3 = le32toh(*(undefined4 *)(*param_1 + lVar5));
if (lVar3 != 0) {
puVar4 = (undefined4 *)acpi_map_sdt(lVar3);
lVar3 = acpi_checksum(puVar4,*puVar4);
if (lVar3 == 0) {
iVar2 = memcmp((void *)(ulong)(uint)puVar4[1],ACPI_SIG_DMAR,4);
if (CONCAT44(extraout_var,iVar2) == 0) {
acpi_handle_dmar(puVar4);
}
}
}
lVar5 = lVar5 + 4;
} while (lVar5 != (ulong)(iVar1 - 1) * 4 + 4);
}
return;
} | void
walk_rsdt(ACPI_TABLE_HEADER *rsdp)
{
ACPI_TABLE_HEADER *sdp;
ACPI_TABLE_RSDT *rsdt;
ACPI_TABLE_XSDT *xsdt;
vm_offset_t addr;
int addr_size, entries, i;
if (memcmp(rsdp->Signature, "RSDT", 4) != 0)
addr_size = sizeof(uint32_t);
else
addr_size = sizeof(uint64_t);
rsdt = (ACPI_TABLE_RSDT *)rsdp;
xsdt = (ACPI_TABLE_XSDT *)rsdp;
entries = (rsdp->Length - sizeof(ACPI_TABLE_HEADER)) / addr_size;
for (i = 0; i < entries; i++) {
if (addr_size == 4)
addr = le32toh(rsdt->TableOffsetEntry[i]);
else
addr = le64toh(xsdt->TableOffsetEntry[i]);
if (addr == 0)
continue;
sdp = (ACPI_TABLE_HEADER *)acpi_map_sdt(addr);
if (acpi_checksum(sdp, sdp->Length)) {
continue;
}
if (!memcmp(sdp->Signature, ACPI_SIG_DMAR, 4))
acpi_handle_dmar(sdp);
}
} |
void parse_file(undefined8 param_1,undefined8 param_2)
{
long lVar1;
undefined4 uVar2;
undefined8 uVar3;
long lVar4;
yyfparse();
while( true ) {
yypsave = 0;
lVar4 = yyparse();
lVar1 = yypsave;
if ((lVar4 != 0) || (yypsave == 0)) break;
uVar3 = function_compile(yypsave);
parse_free(lVar1);
uVar2 = stack_global();
uVar2 = function_run(uVar3,param_2,uVar2);
list_free(uVar2);
function_free(uVar3);
}
return;
} | void parse_file( OBJECT * f, FRAME * frame )
{
yyfparse( f );
for ( ; ; )
{
PARSE * p;
FUNCTION * func;
yypsave = 0;
if ( yyparse() || !( p = yypsave ) )
break;
func = function_compile( p );
parse_free( p );
list_free( function_run( func, frame, stack_global() ) );
function_free( func );
}
} |
void levelTraversal(uint **param_1)
{
uint *puVar1;
long lVar2;
lVar2 = last * 8;
last = last + 1;
*(uint **)(queue + lVar2) = param_1[1];
while (front != last) {
lVar2 = front + 1;
puVar1 = *(uint **)(front * 8 + queue);
front = lVar2;
if (puVar1 != *param_1) {
lVar2 = last * 8;
last = last + 1;
*(undefined8 *)(queue + lVar2) = *(undefined8 *)(puVar1 + 6);
lVar2 = last * 8;
last = last + 1;
*(undefined8 *)(queue + lVar2) = *(undefined8 *)(puVar1 + 4);
printf("%d",(ulong)*puVar1);
if (*(long *)(puVar1 + 2) == BLACK) {
printf("(B) ");
}
else {
printf("(R) ");
}
}
}
return;
} | void levelTraversal(RBTree* tree)
{
queue[last++] = tree->root;
while(front != last) {
RBNode* node = queue[front++];
if (node != tree->nil) {
queue[last++] = node->left;
queue[last++] = node->right;
printf("%d", node->key);
if (node->color == BLACK)
printf("(B) ");
else
printf("(R) ");
}
}
} |
void msg_get_can(void)
{
pfifo1 = canrcvtim_get_ldr();
if (pfifo1 == 0) {
pfifo0 = canrcv_get_ldr();
}
return;
} | struct CANRCVBUF* msg_get_can(void)
{
if ( (pfifo1 = canrcvtim_get_ldr()) != 0)
{
return &pfifo1->R;
}
if ( (pfifo0 = canrcv_get_ldr()) != 0)
{
return pfifo0;
}
return NULL;
} |
ulong xgbe_phy_an_outcome(int *param_1)
{
int iVar1;
ulong uVar2;
iVar1 = *param_1;
if (iVar1 == 0x82) {
uVar2 = xgbe_phy_an37_sgmii_outcome();
return uVar2;
}
if (iVar1 < 0x83) {
if (iVar1 == 0x80) {
uVar2 = xgbe_phy_an73_redrv_outcome();
return uVar2;
}
if (iVar1 == 0x81) {
uVar2 = xgbe_phy_an73_outcome();
return uVar2;
}
}
else if (iVar1 == 0x83) {
uVar2 = xgbe_phy_an37_outcome();
return uVar2;
}
return (ulong)XGBE_MODE_UNKNOWN;
} | enum xgbe_mode xgbe_phy_an_outcome(struct xgbe_prv_data *pdata)
{
switch (pdata->an_mode) {
case XGBE_AN_MODE_CL73:
return xgbe_phy_an73_outcome(pdata);
case XGBE_AN_MODE_CL73_REDRV:
return xgbe_phy_an73_redrv_outcome(pdata);
case XGBE_AN_MODE_CL37:
return xgbe_phy_an37_outcome(pdata);
case XGBE_AN_MODE_CL37_SGMII:
return xgbe_phy_an37_sgmii_outcome(pdata);
default:
return XGBE_MODE_UNKNOWN;
}
} |
int open_bios_socket(void)
{
int iVar1;
int extraout_var;
long in_FS_OFFSET;
sockaddr local_18;
local_18.sa_data._6_8_ = *(long *)(in_FS_OFFSET + 0x28);
local_18.sa_data._2_4_ = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
if ((int)local_18.sa_data._2_4_ < 0) {
iVar1 = -1;
}
else {
memset(&local_18,0,4);
local_18._0_4_ = AF_INET;
bind(local_18.sa_data._2_4_,&local_18,4);
iVar1 = local_18.sa_data._2_4_;
if (extraout_var < 0) {
iVar1 = -1;
}
}
if (local_18.sa_data._6_8_ == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | int open_bios_socket(void)
{
int s;
struct sockaddr_in addr;
s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (s < 0)
return -1;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0)
return -1;
return s;
} |
undefined * get_next_line(int param_1)
{
undefined *puVar1;
ssize_t sVar2;
long lVar3;
undefined *puVar4;
long lVar5;
char cVar6;
puVar1 = (undefined *)malloc(0xa411);
if (puVar1 != (undefined *)0x0) {
sVar2 = read(param_1,&buffer_1924,42000);
if (0 < (int)sVar2) {
if (buffer_1924 != '\0') {
if (buffer_1924 == '\n') {
lVar5 = 0;
puVar4 = puVar1;
}
else {
lVar3 = 1;
cVar6 = buffer_1924;
do {
puVar1[lVar3 + -1] = cVar6;
cVar6 = (&buffer_1924)[lVar3];
lVar5 = (long)(int)lVar3;
lVar3 = lVar3 + 1;
if (cVar6 == '\n') break;
} while (cVar6 != '\0');
puVar4 = puVar1 + lVar5;
}
*puVar4 = 0;
(&buffer_1924)[lVar5] = 0;
return puVar1;
}
}
}
return (undefined *)0x0;
} | char *get_next_line(const int fd)
{
static char buffer[(42000) + 1];
static int ret;
char *s;
int i;
i = 0;
s = malloc((42000) + 1);
if (s == 0)
return (NULL);
ret = read(fd, buffer, (42000));
if (ret <= 0)
return (NULL);
if (buffer[i] == 0)
return (NULL);
while (buffer[i] != '\n' && buffer[i] != '\0')
{
s[i] = buffer[i];
++i;
}
s[i] = '\0';
buffer[i] = '\0';
return (s);
} |
int fxp_to_int(int param_1)
{
int local_c;
local_c = (int)_fxp_half;
if (param_1 < 0) {
local_c = -local_c;
}
local_c = param_1 + local_c;
return local_c >> ((byte)impl & 0x1f);
} | int fxp_to_int(fxp_t fxp)
{
if(fxp >= 0)
{
fxp += _fxp_half;
}
else
{
fxp -= _fxp_half;
}
fxp >>= impl.frac_bits;
return (int) fxp;
} |
double cos(double __x)
{
uint uVar1;
long in_FS_OFFSET;
double dVar2;
ulong uVar3;
undefined8 local_28;
undefined8 local_20;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar1 = (uint)((ulong)__x >> 0x20) & 0x7fffffff;
if (uVar1 < 0x3fe921fc) {
dVar2 = (double)__kernel_cos(__x,0);
}
else if (uVar1 < 0x7ff00000) {
uVar1 = __ieee754_rem_pio2(&local_28);
uVar1 = uVar1 & 3;
if (uVar1 == 1) {
uVar3 = __kernel_sin(local_28,local_20,1);
dVar2 = (double)(uVar3 ^ __LC1);
}
else if (uVar1 == 2) {
uVar3 = __kernel_cos(local_28,local_20);
dVar2 = (double)(uVar3 ^ __LC1);
}
else if (uVar1 == 0) {
dVar2 = (double)__kernel_cos(local_28,local_20);
}
else {
dVar2 = (double)__kernel_sin(local_28,local_20,1);
}
}
else {
dVar2 = __x - __x;
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return dVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | double
cos (double x)
{
double y[2], z = 0.0;
int n, ix;
ix = *(1 + (int *) &x);
ix &= 0x7fffffff;
if (ix <= 0x3fe921fb)
{
return __kernel_cos (x, z);
}
else if (ix >= 0x7ff00000)
{
return x - x;
}
else
{
n = __ieee754_rem_pio2 (x, y);
switch (n & 3)
{
case 0:
{
return __kernel_cos (y[0], y[1]);
}
case 1:
{
return -__kernel_sin (y[0], y[1], 1);
}
case 2:
{
return -__kernel_cos (y[0], y[1]);
}
default:
{
return __kernel_sin (y[0], y[1], 1);
}
}
}
} |
undefined8 iks_tree(char *param_1,size_t param_2,undefined4 *param_3)
{
undefined4 uVar1;
long in_FS_OFFSET;
size_t local_38;
undefined8 local_20;
long local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_38 = param_2;
if (param_2 == 0) {
local_38 = strlen(param_1);
}
local_18 = iks_dom_new(&local_20);
if (local_18 == 0) {
if (param_3 != (undefined4 *)0x0) {
*param_3 = IKS_NOMEM;
}
local_20 = 0;
}
else {
uVar1 = iks_parse(local_18,param_1,local_38,1);
if (param_3 != (undefined4 *)0x0) {
*param_3 = uVar1;
}
iks_parser_delete(local_18);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_20;
} | iks *
iks_tree (const char *xml_str, size_t len, int *err)
{
iksparser *prs;
iks *x;
int e;
if (0 == len) len = strlen (xml_str);
prs = iks_dom_new (&x);
if (!prs) {
if (err) *err = IKS_NOMEM;
return NULL;
}
e = iks_parse (prs, xml_str, len, 1);
if (err) *err = e;
iks_parser_delete (prs);
return x;
} |
undefined8 * SLList_insert(undefined8 *param_1,undefined8 param_2,undefined8 param_3)
{
undefined4 uVar1;
undefined8 *puVar2;
undefined4 uVar3;
uVar1 = VDS_SUCCESS;
if (param_1 == (undefined8 *)0x0) {
puVar2 = (undefined8 *)0x0;
uVar3 = VDS_INVALID_ARGS;
}
else {
puVar2 = (undefined8 *)VdsMalloc(0x10);
uVar3 = VDS_MALLOC_FAIL;
if (puVar2 != (undefined8 *)0x0) {
puVar2[1] = param_2;
*puVar2 = *param_1;
*param_1 = puVar2;
uVar3 = uVar1;
}
}
SAVE_ERR(param_3,uVar3);
return puVar2;
} | SLListNode *SLList_insert(SLListNode **sllHead,
void *pData,
vdsErrCode *err)
{
vdsErrCode tmp_err = VDS_SUCCESS;
SLListNode *new_node = NULL;
if (sllHead) {
new_node = VdsMalloc(sizeof(SLListNode));
if (new_node) {
new_node->pData = pData;
new_node->nxt = *sllHead;
*sllHead = new_node;
} else
tmp_err = VDS_MALLOC_FAIL;
} else
tmp_err = VDS_INVALID_ARGS;
SAVE_ERR(err, tmp_err);
return new_node;
} |
void BIT6HLm(void)
{
BITHLm(0x40);
return;
} | void BIT6HLm() { BITHLm(0x40); } |
void Decrypt(undefined8 *param_1,long param_2)
{
long lVar1;
undefined8 uVar2;
undefined8 uVar3;
uint uVar4;
uint uVar5;
int iVar6;
int iVar7;
long lVar8;
long in_FS_OFFSET;
lVar8 = 0;
lVar1 = *(long *)(in_FS_OFFSET + 0x28);
do {
uVar4 = READ_ROUND_KEY_BYTE(*(undefined4 *)(param_2 + 0x50 + lVar8));
*(uint *)((long)param_1 + lVar8) = *(uint *)((long)param_1 + lVar8) ^ uVar4;
lVar8 = lVar8 + 4;
} while (lVar8 != 0x10);
lVar8 = param_2;
iVar6 = 1;
do {
iVar7 = iVar6 + 1;
rrr_enc_dec_round(param_1,lVar8,iVar6);
lVar8 = lVar8 + 0x30;
iVar6 = iVar7;
} while (iVar7 != 0xd);
uVar2 = *param_1;
uVar3 = param_1[1];
lVar8 = 0;
do {
uVar4 = *(uint *)((long)param_1 + lVar8 + 0x10);
uVar5 = READ_ROUND_KEY_BYTE(*(undefined4 *)(param_2 + 0x20 + lVar8));
*(uint *)((long)param_1 + lVar8) = uVar4 ^ uVar5;
lVar8 = lVar8 + 4;
} while (lVar8 != 0x10);
param_1[2] = uVar2;
param_1[3] = uVar3;
if (lVar1 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | void Decrypt(uint8_t *block, uint8_t *roundKeys)
{
uint8_t i, temp[4] = {0}, key_ctr = 0;
for(i=0;i<4;i++) block[i] ^= READ_ROUND_KEY_BYTE(roundKeys[i+20]);
for(i=1;i<=12;i++)
{
rrr_enc_dec_round(block,roundKeys+key_ctr,i);
key_ctr += 12;
}
for(i=0;i<4;i++) temp[i] = block[i];
for(i=0;i<4;i++) block[i] = block[i+4]^READ_ROUND_KEY_BYTE(roundKeys[i+8]);
for(i=0;i<4;i++) block[i+4] = temp[i];
} |
undefined8 stack_alloc(void)
{
return 0;
} | void *stack_alloc(size_t sz, bool kernel) {
sz = 0;
kernel = 0;
return NULL;
} |
undefined8 a_shmGetShmName(undefined8 *param_1)
{
return *param_1;
} | char *
a_shmGetShmName(
a_shmContext context)
{
return context->shm_name;
} |
void init_lock(void)
{
long in_FS_OFFSET;
pthread_mutexattr_t local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pthread_mutexattr_init(&local_14);
pthread_mutexattr_settype(&local_14,PTHREAD_MUTEX_RECURSIVE);
pthead_mutex_init(&sleep_lock,&local_14);
pthread_mutexattr_destroy(&local_14);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | void init_lock( void ) {
pthread_mutexattr_t attr;
pthread_mutexattr_init( &attr );
pthread_mutexattr_settype( &attr, PTHREAD_MUTEX_RECURSIVE );
pthead_mutex_init( &sleep_lock, &attr );
pthread_mutexattr_destroy( &attr );
} |
undefined8 raw_sigmoid_derivative(undefined8 param_1)
{
double dVar1;
undefined auVar2 [16];
dVar1 = exp((double)CONCAT44((uint)((ulong)param_1 >> 0x20) ^ _UNK_00100054,(uint)param_1 ^ __LC0)
);
dVar1 = (double)(float)(_LC1 / (dVar1 + _LC1));
auVar2._4_12_ = SUB1612((undefined [16])0x0,4);
auVar2._0_4_ = (float)((_LC1 - dVar1) * dVar1);
return auVar2._0_8_;
} | float raw_sigmoid_derivative( float x ) {
float y = 1.0 / ( 1.0 + exp( -x ) );
return y * ( 1.0 - y );
} |
void irc_channel_nick_speaking_add_to_list(long *param_1,undefined8 param_2,int param_3)
{
long lVar1;
code *pcVar2;
int iVar3;
long lVar4;
long lVar5;
code **ppcVar6;
int iVar7;
long lVar8;
lVar8 = (long)param_3;
lVar5 = *param_1;
lVar1 = lVar8 * 8;
lVar4 = *(long *)(lVar5 + lVar1);
ppcVar6 = dogechat_irc_plugin;
if (lVar4 == 0) {
lVar4 = (*dogechat_irc_plugin[5])();
ppcVar6 = dogechat_irc_plugin;
*(long *)(lVar5 + lVar1) = lVar4;
lVar4 = *(long *)(*param_1 + lVar8 * 8);
}
lVar5 = (*ppcVar6[4])(lVar4,param_2);
if (lVar5 != 0) {
(*dogechat_irc_plugin[2])(*(undefined8 *)(*param_1 + lVar8 * 8),lVar5);
}
(*dogechat_irc_plugin[3])(*(undefined8 *)(*param_1 + lVar8 * 8),param_2,&_LC0,0);
iVar3 = (**dogechat_irc_plugin)(*(undefined8 *)(*param_1 + lVar8 * 8));
if (0x80 < iVar3) {
iVar7 = 0;
do {
iVar7 = iVar7 + 1;
pcVar2 = dogechat_irc_plugin[2];
(*dogechat_irc_plugin[1])(*(undefined8 *)(*param_1 + lVar1),0);
(*pcVar2)(*(undefined8 *)(*param_1 + lVar1));
} while (iVar7 != iVar3 + -0x80);
}
return;
} | void
irc_channel_nick_speaking_add_to_list (struct t_irc_channel *channel,
const char *nick_name,
int highlight)
{
int size, to_remove, i;
struct t_dogelist_item *ptr_item;
if (!channel->nicks_speaking[highlight])
channel->nicks_speaking[highlight] = (dogechat_irc_plugin->list_new)();
ptr_item = (dogechat_irc_plugin->list_casesearch)(channel->nicks_speaking[highlight], nick_name)
;
if (ptr_item)
(dogechat_irc_plugin->list_remove)(channel->nicks_speaking[highlight], ptr_item);
(dogechat_irc_plugin->list_add)(channel->nicks_speaking[highlight], nick_name, "end", NULL)
;
size = (dogechat_irc_plugin->list_size)(channel->nicks_speaking[highlight]);
if (size > 128)
{
to_remove = size - 128;
for (i = 0; i < to_remove; i++)
{
(dogechat_irc_plugin->list_remove)(channel->nicks_speaking[highlight], (dogechat_irc_plugin->list_get)(channel->nicks_speaking[highlight], 0))
;
}
}
} |
void display_tape(int param_1)
{
int iVar1;
int iVar2;
bool bVar3;
if (param_1 < 1) {
putchar(0x76);
putchar(10);
}
else {
iVar2 = 0;
do {
iVar1 = iVar2;
putchar(0x20);
iVar2 = iVar1 + 1;
} while (param_1 != iVar2);
putchar(0x76);
putchar(10);
iVar2 = 0;
do {
Left();
bVar3 = iVar1 != iVar2;
iVar2 = iVar2 + 1;
} while (bVar3);
}
iVar2 = 0x4f;
do {
putchar((int)*tape);
Right();
iVar2 = iVar2 + -1;
} while (iVar2 != 0);
if (0 < 0x4f - param_1) {
iVar2 = 0;
do {
Left();
iVar2 = iVar2 + 1;
} while (iVar2 != 0x4f - param_1);
}
putchar(10);
count_1927 = count_1927 + 1;
return;
} | void display_tape(int nLeft) {
int pos;
static int count = 0;
for(pos = 0; pos < nLeft; pos++) {
putchar(' ');
}
putchar('v');
putchar('\n');
for(pos = 0; pos < nLeft; pos++) {
Left();
}
for(pos = 0; pos < 79; pos++) {
putchar(tape->symbol);
Right();
}
for(pos = 0; pos <(79 - nLeft); pos++) {
Left();
}
putchar('\n');
++count;
} |
ulong pcf50633_adc_async_read
(undefined8 param_1,undefined4 param_2,undefined4 param_3,undefined8 param_4,
undefined8 param_5)
{
undefined4 *puVar1;
ulong uVar2;
puVar1 = (undefined4 *)kmalloc(0x18,GFP_KERNEL);
if (puVar1 != (undefined4 *)0x0) {
*puVar1 = param_2;
puVar1[1] = param_3;
*(undefined8 *)(puVar1 + 2) = param_4;
*(undefined8 *)(puVar1 + 4) = param_5;
uVar2 = adc_enqueue_request(param_1,puVar1);
return uVar2;
}
return (ulong)(uint)-ENOMEM;
} | int pcf50633_adc_async_read(struct pcf50633 *pcf, int mux, int avg,
void (*callback)(struct pcf50633 *, void *, int),
void *callback_param)
{
struct pcf50633_adc_request *req;
/* req is freed when the result is ready, in interrupt handler */
req = kmalloc(sizeof(*req), GFP_KERNEL);
if (!req)
return -ENOMEM;
req->mux = mux;
req->avg = avg;
req->callback = callback;
req->callback_param = callback_param;
return adc_enqueue_request(pcf, req);
} |
void _set_no_clock(void)
{
fprintf((FILE *)(ulong)stderr,"_set_no_clock should not be used\n");
/* WARNING: Subroutine does not return */
exit(2);
} | void _set_no_clock( BranchModel *bm, const int index, const double value ){
fprintf(stderr, "_set_no_clock should not be used\n");
exit(2);
} |
void free_itemsets(void)
{
undefined8 *puVar1;
undefined8 *__ptr;
__ptr = first_state;
if (state_table != (void *)0x0) {
free(state_table);
__ptr = first_state;
}
while (__ptr != (undefined8 *)0x0) {
puVar1 = (undefined8 *)*__ptr;
free(__ptr);
__ptr = puVar1;
}
return;
} | free_itemsets()
{
register core *cp,*cptmp;
if(state_table) free((char *) (state_table));
for (cp = first_state; cp; cp = cptmp) {
cptmp=cp->next;
if(cp) free((char *) (cp));
}
} |
void insert_char(int *param_1,uint param_2)
{
long lVar1;
long lVar2;
lVar1 = *(long *)(param_1 + 6);
vc_uniscr_insert();
scr_memmovew(lVar1 + (ulong)param_2 * 2,lVar1,((*param_1 - param_2) - param_1[1]) * 2);
scr_memsetw(lVar1,param_1[4],param_2 * 2);
*(undefined8 *)(param_1 + 2) = 0;
lVar2 = con_should_update(param_1);
if (lVar2 == 0) {
return;
}
do_update_region(param_1,lVar1,*param_1 - param_1[1]);
return;
} | void insert_char(struct vc_data *vc, unsigned int nr)
{
unsigned short *p = (unsigned short *) vc->vc_pos;
vc_uniscr_insert(vc, nr);
scr_memmovew(p + nr, p, (vc->vc_cols - vc->vc_x - nr) * 2);
scr_memsetw(p, vc->vc_video_erase_char, nr * 2);
vc->vc_need_wrap = 0;
if (con_should_update(vc))
do_update_region(vc, (unsigned long) p,
vc->vc_cols - vc->vc_x);
} |
int verb_code(undefined4 param_1)
{
int iVar1;
int iVar2;
iVar1 = verb_authorsyn();
if (iVar1 == 0) {
iVar1 = verb_builtin(param_1);
if (iVar1 != 0) {
iVar2 = verb_authorsyn(*(undefined4 *)(syntbl + *(long *)(auxsyn + (long)iVar1 * 8) * 4));
if (iVar2 != 0) {
iVar1 = iVar2;
}
return iVar1;
}
}
return iVar1;
} | int verb_code(word w)
{
int canon, tmp;
tmp=verb_authorsyn(w);
if (tmp!=0) return tmp;
canon=verb_builtin(w);
if (canon!=0) {
tmp=verb_authorsyn(syntbl[auxsyn[canon]]);
if (tmp!=0) return tmp;
}
return canon;
} |
void m68k_op_jmp_32_al(void)
{
undefined4 uVar1;
uVar1 = m68ki_read_imm_32();
m68ki_jump(uVar1);
return;
} | void m68k_op_jmp_32_al(void)
{
m68ki_jump(m68ki_read_imm_32());
} |
undefined8 vehicle_rt_ir_temp_temp_27_pack(uint *param_1,undefined8 *param_2,ulong param_3)
{
undefined8 uVar1;
uint uVar2;
if (1 < param_3) {
memset(param_1,0,2);
uVar1 = *param_2;
uVar2 = pack_left_shift_u16(uVar1,0,0xff);
*param_1 = *param_1 | uVar2;
uVar2 = pack_right_shift_u16(uVar1,8,0xff);
param_1[1] = param_1[1] | uVar2;
return 2;
}
return 0xffffffea;
} | int vehicle_rt_ir_temp_temp_27_pack(
uint8_t *dst_p,
const struct vehicle_rt_ir_temp_temp_27_t *src_p,
size_t size)
{
uint16_t ir_temperature_27;
if (size < 2u) {
return (-22);
}
memset(&dst_p[0], 0, 2);
ir_temperature_27 = (uint16_t)src_p->ir_temperature_27;
dst_p[0] |= pack_left_shift_u16(ir_temperature_27, 0u, 0xffu);
dst_p[1] |= pack_right_shift_u16(ir_temperature_27, 8u, 0xffu);
return (2);
} |
af_filter_pfir(uint param_1,int param_2,uint param_3,long *param_4,long *param_5,undefined4 *param_6
,uint param_7)
{
undefined4 uVar1;
long lVar2;
long lVar3;
undefined4 *puVar4;
uint uVar5;
lVar2 = *param_4;
lVar3 = *param_5 + (ulong)param_3 * 4;
if (param_2 != 0) {
puVar4 = param_6;
uVar5 = param_2 - 1U;
do {
uVar5 = uVar5 - 1;
uVar1 = af_filter_fir(param_1,lVar2,lVar3);
lVar3 = lVar3 + (long)(int)(param_1 * 2) * 4;
lVar2 = lVar2 + (ulong)param_1 * 4;
*puVar4 = uVar1;
puVar4 = puVar4 + param_7;
} while (uVar5 != 0xffffffff);
return (undefined4 *)((long)param_6 + (ulong)param_7 * 4 * ((ulong)(param_2 - 1U) + 1));
}
return param_6;
} | _ftype_t* af_filter_pfir(unsigned int n, unsigned int d, unsigned int xi, _ftype_t** w, _ftype_t** x, _ftype_t* y, unsigned int s)
{
register _ftype_t* xt = *x + xi;
register _ftype_t* wt = *w;
register int nt = 2*n;
while(d-- > 0){
*y = af_filter_fir(n,wt,xt);
wt+=n;
xt+=nt;
y+=s;
}
return y;
} |
undefined8 lsddb_resolveClassFromId(undefined8 *param_1,undefined4 param_2)
{
undefined4 uVar1;
undefined4 uVar2;
long lVar3;
undefined8 uVar4;
char *pcVar5;
long in_FS_OFFSET;
undefined8 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
sqlite3_reset(RESOLVE_CLASS_FROM_ID_S);
sqlite3_bind_int(RESOLVE_CLASS_FROM_ID_S,1,param_2);
lVar3 = sqlite3_step(RESOLVE_CLASS_FROM_ID_S);
if (lVar3 == SQLITE_ROW) {
uVar1 = sqlite3_column_int(RESOLVE_CLASS_FROM_ID_S,0);
uVar2 = getArr_lsdNodeClassArr();
lVar3 = pickIdx(uVar2,&local_28,uVar1);
if (-1 < lVar3) {
uVar4 = 0;
if (param_1 != (undefined8 *)0x0) {
*param_1 = local_28;
}
goto LAB_0010008a;
}
pcVar5 = "Unable to pick class from array in resolveClassFromId().";
}
else {
pcVar5 = "Class could not be resolved or its plugin is disabled in resolveClassFromId().";
}
uVar1 = gettext(pcVar5);
doLog(ERROR,LOG_COMP,uVar1);
uVar4 = 0xffffffff;
LAB_0010008a:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | int
lsddb_resolveClassFromId (struct LSD_SceneNodeClass** ptrToBind, int classId)
{
sqlite3_reset (RESOLVE_CLASS_FROM_ID_S);
sqlite3_bind_int (RESOLVE_CLASS_FROM_ID_S, 1, classId);
struct LSD_SceneNodeClass* pickedClass;
if (sqlite3_step (RESOLVE_CLASS_FROM_ID_S) == SQLITE_ROW)
{
int arrIdx = sqlite3_column_int (RESOLVE_CLASS_FROM_ID_S, 0);
if (pickIdx (getArr_lsdNodeClassArr (), (void**)&pickedClass,
arrIdx) < 0)
{
doLog (ERROR, LOG_COMP, gettext ("Unable to pick class from array in resolveClassFromId()."));
return -1;
}
}
else
{
doLog (ERROR, LOG_COMP, gettext ("Class could not be resolved or its plugin is disabled in resolveClassFromId()."));
return -1;
}
if (ptrToBind)
*ptrToBind = pickedClass;
return 0;
} |
int vehicle_rt_ir_temp_temp_15_ir_temperature_15_encode(double param_1)
{
return (int)(param_1 / DAT_00100028);
} | int16_t vehicle_rt_ir_temp_temp_15_ir_temperature_15_encode(double value)
{
return (int16_t)(value / 0.1);
} |
undefined8 ext_op_0x80(long *param_1)
{
uint *puVar1;
puVar1 = (uint *)(*param_1 + REG_BC * 4);
*puVar1 = *puVar1 & 0xfffffffe;
return 8;
} | int
ext_op_0x80(gb_cpu *cpu)
{
cpu->regs[REG_BC].hi &= ~(1 << (0));
return 8;
} |
undefined8 get_timeout_msec(void)
{
int iVar1;
int iVar2;
undefined8 uVar3;
iVar2 = time_to_poll;
if (3 < vim_sync) {
iVar2 = get_time();
time_to_sync = iVar2 + 100;
return 100;
}
if (time_to_poll != -1) {
iVar1 = get_time();
uVar3 = MAX(0x1e,(iVar2 - iVar1) + 5);
return uVar3;
}
return 0xffffffffffffffff;
} | long get_timeout_msec() {
if (vim_sync >= 4) {
time_to_sync = 100 + get_time();
return 100;
}
if (time_to_poll == -1) {
return -1;
}
return MAX(30, time_to_poll - get_time() + 5);
} |
void chip8_free(void *param_1)
{
free(param_1);
return;
} | void chip8_free(chip8* c)
{
free(c);
} |
void tegra186_usb2_port_map(undefined4 *param_1)
{
tegra_xusb_find_lane(param_1[1],&_LC0,*param_1);
return;
} | struct tegra_xusb_lane *
tegra186_usb2_port_map(struct tegra_xusb_port *port)
{
return tegra_xusb_find_lane(port->padctl, "usb2", port->index);
} |
void usage(void)
{
fprintf((FILE *)(ulong)stderr,"Usage: %s /dev/<resumedevice> [offset]\n",progname);
/* WARNING: Subroutine does not return */
exit(1);
} | __noreturn usage(void)
{
fprintf(stderr, "Usage: %s /dev/<resumedevice> [offset]\n", progname);
exit(1);
} |
undefined8 is_file(undefined8 param_1)
{
int iVar1;
long lVar2;
undefined8 uVar3;
iVar1 = is_dir(param_1);
if (iVar1 == 0) {
LAB_00100049:
uVar3 = 1;
}
else {
lVar2 = is_symlink(param_1);
if (lVar2 != 0) {
lVar2 = get_symlink_type(param_1);
if (lVar2 != SLT_UNKNOWN) goto LAB_00100049;
}
uVar3 = 0;
}
return uVar3;
} | int
is_file(const char path[])
{
return !is_dir(path)
|| (is_symlink(path) && get_symlink_type(path) != SLT_UNKNOWN);
} |
undefined4 dvda_track_first_sector(undefined4 *param_1)
{
return *param_1;
} | unsigned
dvda_track_first_sector(const DVDA_Track* track)
{
return track->sector.first;
} |
void free_channel(void **param_1)
{
undefined8 *puVar1;
undefined8 *local_18;
if (param_1 != (void **)0x0) {
local_18 = (undefined8 *)param_1[1];
while (local_18 != (undefined8 *)0x0) {
puVar1 = (undefined8 *)*local_18;
free_user(local_18);
local_18 = puVar1;
}
free(*param_1);
free(param_1);
}
return;
} | void free_channel(struct channel* channel) {
if (channel) {
struct user* user_node = channel->users;
while (user_node) {
struct user* tmp_user = user_node;
user_node = user_node->next;
free_user(tmp_user);
};
free(channel->name);
free(channel);
};
} |
int toupper(int __c)
{
int in_ESI;
return __c + in_ESI;
} | long toupper (int a, int b) { return (long)(a+b);} |
long _mustFind(undefined8 param_1,undefined8 param_2,char param_3,undefined4 param_4)
{
long lVar1;
lVar1 = find(param_1,param_2,(int)param_3);
if (lVar1 == 0) {
eset(param_4);
}
return lVar1;
} | char* _mustFind( char *from, char *upto, char c, int err ) {
char* x = find(from, upto, c);
if( x ) return x;
else { eset(err); return 0; }
} |
long vbva_buffer_available(long *param_1)
{
long lVar1;
lVar1 = *param_1 - param_1[1];
if (0 < lVar1) {
return lVar1;
}
return lVar1 + param_1[2];
} | u32 vbva_buffer_available(const struct vbva_buffer *vbva)
{
s32 diff = vbva->data_offset - vbva->free_offset;
return diff > 0 ? diff : vbva->data_len + diff;
} |
void StrInsertSort(int *param_1)
{
int iVar1;
long lVar2;
long lVar3;
long lVar4;
long *plVar5;
long lVar6;
long lVar7;
long lVar8;
if (1 < *param_1) {
lVar7 = 0x10;
lVar8 = 0;
do {
plVar5 = *(long **)(param_1 + 2);
if (*(long *)((long)plVar5 + lVar7) < *(long *)((long)plVar5 + lVar7 + -8)) {
*plVar5 = *(long *)((long)plVar5 + lVar7);
*(undefined8 *)(*(long *)(param_1 + 2) + lVar7) =
*(undefined8 *)(*(long *)(param_1 + 2) + -8 + lVar7);
plVar5 = *(long **)(param_1 + 2);
lVar4 = plVar5[lVar8];
lVar6 = *plVar5;
lVar3 = lVar8;
lVar2 = lVar8;
if (lVar6 < lVar4) {
do {
lVar3 = lVar2 + -1;
plVar5[lVar2 + 1] = lVar4;
plVar5 = *(long **)(param_1 + 2);
lVar4 = plVar5[lVar3];
lVar6 = *plVar5;
lVar2 = lVar3;
} while (lVar6 < lVar4);
}
plVar5[lVar3 + 1] = lVar6;
}
lVar7 = lVar7 + 8;
iVar1 = (int)lVar8;
lVar8 = lVar8 + 1;
} while (iVar1 + 3 <= *param_1);
}
return;
} | void StrInsertSort(SqList* L)
{
int i, j;
for (i = 2; i <= L->length; ++i)
if (L->elem[i] < L->elem[i - 1])
{
L->elem[0] = L->elem[i];
L->elem[i] = L->elem[i - 1];
for (j = i - 2; L->elem[j] > L->elem[0]; --j)
L->elem[j + 1] = L->elem[j];
L->elem[j + 1] = L->elem[0];
}
} |
void stop_ecm_timer(long *param_1)
{
if (*param_1 == 0) {
return;
}
smt_timer_stop(param_1,param_1);
return;
} | void stop_ecm_timer(struct s_smc *smc)
{
if (smc->e.ecm_timer.tm_active)
smt_timer_stop(smc,&smc->e.ecm_timer) ;
} |
undefined4 WriteWadFile(char *param_1)
{
code *pcVar1;
undefined4 uVar2;
int iVar3;
int iVar4;
FILE *pFVar5;
undefined8 uVar6;
char *pcVar7;
PrintMsg(&_LC0);
PrintMsg("Saving WAD as %s\n",param_1);
if (*cur_info != 0) {
wad._4_4_ = PWAD;
}
RecomputeDirectory();
pFVar5 = fopen(param_1,"wb");
out_file = (int)pFVar5;
if (out_file != 0) {
WriteHeader();
(*cur_funcs[5])(DIS_FILEPROGRESS);
(*cur_funcs[4])("glBSP Writing Wad");
uVar6 = UtilFormat("Writing: %s",param_1);
(*cur_funcs[3])(1,uVar6);
pcVar1 = cur_funcs[2];
uVar2 = CountLumpTypes(8,0);
(*pcVar1)(1,uVar2);
(*cur_funcs[1])(1,0);
UtilFree(uVar6);
*cur_comms = 0;
iVar3 = WriteAllLumps();
(**cur_funcs)();
iVar4 = WriteDirectory();
if (((int)wad != iVar3) || ((int)wad != iVar4)) {
InternalError("Write directory count consistency failure (%d,%d,%d)",iVar3,iVar4);
}
return GLBSP_E_OK;
}
pcVar7 = strerror(errno);
SetErrorMsg("Cannot create WAD file: %s [%s]",param_1,(ulong)pcVar7 & 0xffffffff);
return GLBSP_E_WriteError;
} | glbsp_ret_e WriteWadFile(const char *filename)
{
int check1, check2;
char *write_msg;
PrintMsg("\n");
PrintMsg("Saving WAD as %s\n", filename);
if (cur_info->gwa_mode)
wad.kind = PWAD;
RecomputeDirectory();
out_file = fopen(filename, "wb");
if (! out_file)
{
SetErrorMsg("Cannot create WAD file: %s [%s]", filename,
strerror(errno));
return GLBSP_E_WriteError;
}
WriteHeader();
(* cur_funcs->display_open)(DIS_FILEPROGRESS);
(* cur_funcs->display_setTitle)("glBSP Writing Wad");
write_msg = UtilFormat("Writing: %s", filename);
(* cur_funcs->display_setBarText)(1, write_msg);
(* cur_funcs->display_setBarLimit)(1, CountLumpTypes(0x0008, 0));
(* cur_funcs->display_setBar)(1, 0);
UtilFree(write_msg);
cur_comms->file_pos = 0;
check1 = WriteAllLumps();
(* cur_funcs->display_close)();
check2 = WriteDirectory();
if (check1 != wad.num_entries || check2 != wad.num_entries)
InternalError("Write directory count consistency failure (%d,%d,%d)",
check1, check2, wad.num_entries);
return GLBSP_E_OK;
} |
void essiv_skcipher_crypt(undefined4 *param_1,int param_2)
{
undefined8 uVar1;
undefined4 *puVar2;
undefined4 uVar3;
undefined4 uVar4;
uVar1 = crypto_skcipher_reqtfm();
puVar2 = (undefined4 *)crypto_skcipher_ctx(uVar1);
uVar1 = skcipher_request_ctx(param_1);
crypto_cipher_encrypt_one(puVar2[1],*param_1,*param_1);
skcipher_request_set_tfm(uVar1,*puVar2);
skcipher_request_set_crypt(uVar1,param_1[3],param_1[2],param_1[1],*param_1);
uVar3 = essiv_skcipher_done;
uVar4 = skcipher_request_flags(param_1);
skcipher_request_set_callback(uVar1,uVar4,uVar3,param_1);
if (param_2 != 0) {
crypto_skcipher_encrypt();
return;
}
crypto_skcipher_decrypt(uVar1);
return;
} | int essiv_skcipher_crypt(struct skcipher_request *req, bool enc)
{
struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
const struct essiv_tfm_ctx *tctx = crypto_skcipher_ctx(tfm);
struct skcipher_request *subreq = skcipher_request_ctx(req);
crypto_cipher_encrypt_one(tctx->essiv_cipher, req->iv, req->iv);
skcipher_request_set_tfm(subreq, tctx->u.skcipher);
skcipher_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
req->iv);
skcipher_request_set_callback(subreq, skcipher_request_flags(req),
essiv_skcipher_done, req);
return enc ? crypto_skcipher_encrypt(subreq) :
crypto_skcipher_decrypt(subreq);
} |
int strcasecmp(char *__s1,char *__s2)
{
int iVar1;
int iVar2;
char *local_28;
char *local_20;
local_28 = __s2;
for (local_20 = __s1; *local_20 != '\0'; local_20 = local_20 + 1) {
iVar1 = tolower((int)*local_20);
iVar2 = tolower((int)*local_28);
if (iVar1 != iVar2) break;
local_28 = local_28 + 1;
}
iVar1 = tolower((int)*local_20);
iVar2 = tolower((int)*local_28);
return iVar1 - iVar2;
} | int strcasecmp(const char *s1, const char *s2)
{
while (*s1 != '\0' && (tolower(*s1) == tolower(*s2))) {
++s1;
++s2;
}
return tolower((unsigned char) *s1) - tolower((unsigned char) *s2);
} |
void v_create(int param_1)
{
int *piVar1;
piVar1 = (int *)malloc(0x18);
if (param_1 < 0) {
param_1 = -1;
}
*(undefined (*) [16])(piVar1 + 2) = (undefined [16])0x0;
*piVar1 = param_1;
return;
} | t_vertice *v_create(int id){
t_vertice *vertice = (t_vertice*)malloc(sizeof(t_vertice));
if(id < 0)
vertice->id = -1;
else
vertice->id = id;
vertice->a_inicio = NULL;
vertice->next = NULL;
return vertice;
} |
void sleepMilliseconds(uint param_1)
{
long in_FS_OFFSET;
uint local_18;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = param_1 / 1000;
local_14 = (param_1 % 1000) * 1000000;
nanosleep((timespec *)&local_18,(timespec *)0x0);
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | void sleepMilliseconds(unsigned int msecs) {
struct timespec ts;
# 55 "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/ap--/python-seabreeze/refs/heads/master/src/libseabreeze/src/native/system/posix/NativeSystemPOSIX.c"
ts.tv_sec = msecs/1000;
ts.tv_nsec = (msecs % 1000) * 1000000;
nanosleep(&ts, NULL);
} |
void luaC_linkupval(undefined8 param_1,undefined4 *param_2)
{
int *piVar1;
undefined8 *puVar2;
long lVar3;
piVar1 = (int *)G();
puVar2 = (undefined8 *)obj2gco(param_2);
*puVar2 = *(undefined8 *)(piVar1 + 2);
*(undefined8 **)(piVar1 + 2) = puVar2;
lVar3 = isgray(puVar2);
if (lVar3 != 0) {
if (*piVar1 == 1) {
gray2black(puVar2);
luaC_barrier(param_1,param_2,*param_2);
}
else {
makewhite(piVar1,puVar2);
}
}
return;
} | void luaC_linkupval(lua_State*L,UpVal*uv){
global_State*g=G(L);
GCObject*o=obj2gco(uv);
o->gch.next=g->rootgc;
g->rootgc=o;
if(isgray(o)){
if(g->gcstate==1){
gray2black(o);
luaC_barrier(L,uv,uv->v);
}
else{
makewhite(g,o);
}
}
} |
undefined8 os_strncpy(char *param_1,undefined8 param_2,char *param_3,size_t param_4)
{
strncpy(param_1,param_3,param_4);
return 0;
} | int os_strncpy(char *strDest, size_t numberOfElements, const char *strSource, size_t count) {
if( strncpy(strDest , strSource, count) == NULL){
return -1;
}
return 0;
} |
undefined8 esc_state_wait_for_ST(void)
{
return 1;
} | bool
esc_state_wait_for_ST(__attribute__ ((unused)) char c)
{
return true;
} |
void DestroyWindow(int param_1,int param_2)
{
undefined4 *__ptr;
__ptr = (undefined4 *)(long)param_2;
glXDestroyContext(*(undefined8 *)(long)param_1,__ptr[1]);
destroy_window(*(undefined8 *)(long)param_1,*__ptr);
free(__ptr);
return;
} | void DestroyWindow(int display, int window)
{
glutDisplay *glut_dpy = (glutDisplay *)display;
glutWindow *glut_win = (glutWindow *)window;
glXDestroyContext(glut_dpy->x11_dpy, glut_win->glx_ctx);
destroy_window((int)glut_dpy->x11_dpy, glut_win->x11_win);
free(glut_win);
} |
void newline(void)
{
printf("\n");
return;
} | void newline() {
printf("\n");
} |
undefined8 is_dir(char *param_1)
{
int iVar1;
undefined4 extraout_var;
undefined8 uVar2;
long in_FS_OFFSET;
undefined4 local_14;
__dev_t local_10;
local_10 = *(__dev_t *)(in_FS_OFFSET + 0x28);
iVar1 = stat(param_1,(stat *)&local_14);
uVar2 = 0;
if (CONCAT44(extraout_var,iVar1) == 0) {
uVar2 = S_ISDIR(local_14);
}
if (local_10 == *(__dev_t *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | bool is_dir(const char *path)
{
struct stat st;
if (stat(path, &st))
return 0;
return S_ISDIR(st.st_mode);
} |
void atom_getintarg(undefined4 param_1,undefined4 param_2,undefined8 param_3)
{
atom_getfloatarg(param_1,param_2,param_3);
return;
} | t_int atom_getintarg(int which, int argc, const t_atom *argv)
{
return (atom_getfloatarg(which, argc, argv));
} |
bool dyn_string_copy(undefined4 *param_1,undefined4 *param_2)
{
long lVar1;
if (param_1 != param_2) {
lVar1 = dyn_string_resize(param_1,*param_2);
if (lVar1 != 0) {
strcpy((char *)(ulong)(uint)param_1[1],(char *)(ulong)(uint)param_2[1]);
*param_1 = *param_2;
}
return lVar1 != 0;
}
/* WARNING: Subroutine does not return */
abort();
} | int
dyn_string_copy (dyn_string_t dest, dyn_string_t src)
{
if (dest == src)
abort ();
if (dyn_string_resize (dest, src->length) == NULL)
return 0;
strcpy (dest->s, src->s);
dest->length = src->length;
return 1;
} |
undefined8 undefined_3457(void)
{
undefined4 uVar1;
uVar1 = fancy_name(*(undefined4 *)(functions + 0xd818));
log_msg(&DAT_00100092,0x22,__progname,"function #%04d @ 0x%08X (%s)",0xd81,
*(undefined8 *)(functions + 0xd810),uVar1);
return *(undefined8 *)(functions + 0xd810);
} | void* undefined_3457 () { log_msg("INF", 34, __progname, "function #%04d @ 0x%08X (%s)", 3457, functions[3457].pointer, fancy_name(functions[3457].name)); return (void*)functions[3457].pointer; } |
long zm_callerStackHead(long param_1)
{
long lVar1;
int iVar2;
iVar2 = 200000;
do {
lVar1 = zm_getCaller(param_1);
if (lVar1 == 0) {
return param_1;
}
iVar2 = iVar2 + -1;
param_1 = lVar1;
} while (iVar2 != 0);
return 0;
} | zm_State* zm_callerStackHead(zm_State *s)
{
zm_State *caller;
int n = 0;
while (n++ < 200000) {
caller = zm_getCaller(s);
if (caller == NULL)
return s;
s = caller;
}
return NULL;
} |
void lcd_disable_raster(void)
{
uint uVar1;
uVar1 = lcdc_read(LCD_RASTER_CTRL_REG);
if ((LCD_RASTER_ENABLE & uVar1) == 0) {
return;
}
lcdc_write(~LCD_RASTER_ENABLE & uVar1,LCD_RASTER_CTRL_REG);
return;
} | void lcd_disable_raster(struct da8xx_fb_par *par)
{
u32 reg;
reg = lcdc_read(LCD_RASTER_CTRL_REG);
if (reg & LCD_RASTER_ENABLE)
lcdc_write(reg & ~LCD_RASTER_ENABLE, LCD_RASTER_CTRL_REG);
} |
void add_final(long param_1,undefined8 param_2)
{
int iVar1;
long lVar2;
lVar2 = fintypset_get(param_1 + 4,param_2);
if (lVar2 == 0) {
iVar1 = fintypset_set(param_1 + 4,param_2,1);
if (iVar1 == 0) {
vectyp_push(param_1,param_2);
}
}
return;
} | void add_final(struct typset *set, struct typ *t) {
uint32_t *value = fintypset_get(&set->set, t);
if (value == NULL) {
const bool already = fintypset_set(&set->set, t, 1);
if (!already) {
vectyp_push(&set->list, t);
}
}
} |
void xeq(undefined8 param_1)
{
cequal(param_1,eq);
return;
} | NODE *xeq(NODE *args)
{
return (cequal(args,eq));
} |
undefined4 FwSmMakeTestSM3(undefined8 param_1,undefined8 param_2)
{
undefined4 uVar1;
undefined4 uVar2;
uVar1 = FwSmMakeTestSM2(0);
uVar2 = FwSmCreate(1,0,2,3,1);
FwSmSetData(uVar2,param_1);
FwSmAddState(uVar2,1,1,&incrCnt1By1,0,&incrCnt1By2,uVar1);
FwSmAddTransIpsToSta(uVar2,1,&incrCnt2By1);
FwSmAddTransStaToFps(uVar2,2,1,&incrCnt2By1,&retFlag1);
FwSmSetData(uVar1,param_2);
return uVar2;
} | FwSmDesc_t FwSmMakeTestSM3(struct TestSmData* smData, struct TestSmData* esmData) {
const FwSmCounterS1_t nOfPStates = 1;
const FwSmCounterS1_t nOfCStates = 0;
const FwSmCounterS1_t nOfTrans = 2;
const FwSmCounterS1_t nOfActions = 3;
const FwSmCounterS1_t nOfGuards = 1;
FwSmDesc_t p_sm;
FwSmDesc_t p_esm;
p_esm = FwSmMakeTestSM2(NULL);
p_sm = FwSmCreate(nOfPStates, nOfCStates, nOfTrans, nOfActions, nOfGuards);
FwSmSetData(p_sm, smData);
FwSmAddState(p_sm, 1, 1, &incrCnt1By1, NULL, &incrCnt1By2, p_esm);
FwSmAddTransIpsToSta(p_sm, 1, &incrCnt2By1);
FwSmAddTransStaToFps(p_sm, 2, 1, &incrCnt2By1, &retFlag1);
FwSmSetData(p_esm, esmData);
return p_sm;
} |
long * gen_rtvec_v(int param_1,long param_2)
{
long *plVar1;
long lVar2;
if (param_1 == 0) {
return NULL_RTVEC;
}
plVar1 = (long *)rtvec_alloc();
if (0 < param_1) {
lVar2 = 0;
do {
*(undefined4 *)(*plVar1 + lVar2) = *(undefined4 *)(param_2 + lVar2);
lVar2 = lVar2 + 4;
} while (lVar2 != (ulong)(param_1 - 1) * 4 + 4);
}
return plVar1;
} | rtvec
gen_rtvec_v (int n, rtx *argp)
{
int i;
rtvec rt_val;
if (n == 0)
return NULL_RTVEC; /* Don't allocate an empty rtvec... */
rt_val = rtvec_alloc (n); /* Allocate an rtvec... */
for (i = 0; i < n; i++)
rt_val->elem[i] = *argp++;
return rt_val;
} |
void setreportonbreakflag(void)
{
if (local_reportonbreakflag != 0) {
/* WARNING: Subroutine does not return */
exit(1);
}
errmsg(2,0xd9,global_emn,"Will stop at end of current wordscore");
local_reportonbreakflag = 1;
return;
} | void setreportonbreakflag(int sig){
if(local_reportonbreakflag)
exit(1);
errmsg(2, 217, global_emn, "Will stop at end of current wordscore");
local_reportonbreakflag = 1;
return;
} |
undefined8 undefined_7554(void)
{
undefined8 uVar1;
uVar1 = fancy_name(*(undefined4 *)(functions + 0x1d828));
log_msg(&_LC1,0x22,__progname,"function #%04d @ 0x%08X (%s)",0x1d82,
*(undefined8 *)(functions + 0x1d820),uVar1);
return *(undefined8 *)(functions + 0x1d820);
} | void* undefined_7554 () { log_msg("INF", 34, __progname, "function #%04d @ 0x%08X (%s)", 7554, functions[7554].pointer, fancy_name(functions[7554].name)); return (void*)functions[7554].pointer; } |
undefined8 _BMP_guardar_24(FILE *param_1,long *param_2,int param_3,int param_4,uint param_5)
{
long lVar1;
int iVar2;
void *__ptr;
lVar1 = *param_2;
param_4 = param_4 + -1;
if (-1 < param_4) {
iVar2 = param_3 * param_4;
do {
if (0 < param_3) {
__ptr = (void *)(lVar1 + (long)iVar2 * 4);
do {
fwrite(__ptr,3,1,param_1);
__ptr = (void *)((long)__ptr + 4);
} while (__ptr != (void *)(lVar1 + 4 + ((ulong)(param_3 - 1) + (long)iVar2) * 4));
}
if (0 < (int)param_5) {
fwrite(&P_CERO,(ulong)param_5,1,param_1);
}
param_4 = param_4 + -1;
iVar2 = iVar2 - param_3;
} while (param_4 != -1);
}
return 1;
} | int _BMP_guardar_24( FILE* archivo, mapa_t *mapa,uint32_t w, uint32_t h, int npad)
{
int pos=0;
pixel_24 *temp;
temp=mapa->map_24;
int c, f;
for(f=(h-1);f>=0;f--)
{
for(c=0;c<w;c++)
{
pos = c+(f*w);
fwrite((temp+pos),3,1,archivo);
}
if (npad>0) fwrite(&P_CERO,npad,1,archivo);
}
return 1;
} |
undefined8 startListening(undefined4 param_1)
{
int iVar1;
undefined4 local_c;
local_c = param_1;
debugPrintInt("connection listener : startListening : streamID");
iVar1 = pthread_create((pthread_t *)&thread1,(pthread_attr_t *)0x0,
(__start_routine *)(ulong)startThreadLoop,&local_c);
if (iVar1 != 0) {
debugPrint("connection listener : startListening : ERROR creating thread ");
}
debugPrintInt("connection listener : startListening : finished. Returned",iVar1);
return 1;
} | int startListening( int streamID ) {
int *socketIDPntr = &streamID;
int iret1;
debugPrintInt("connection listener : startListening : streamID" , streamID);
iret1 = pthread_create( &thread1, NULL, startThreadLoop, (void*)socketIDPntr);
if (iret1)
{
debugPrint("connection listener : startListening : ERROR creating thread ");
}
debugPrintInt("connection listener : startListening : finished. Returned",iret1);
return 1;
} |
void thread_func(void)
{
pthread_t pVar1;
long in_FS_OFFSET;
int local_20;
sched_param local_1c;
uint local_18;
int local_14;
undefined8 local_10;
local_10 = *(undefined8 *)(in_FS_OFFSET + 0x28);
pVar1 = pthread_self();
local_18 = (uint)pVar1;
memset(&local_1c,0,4);
local_14 = pthread_getschedparam((ulong)local_18,&local_20,&local_1c);
if (local_14 != 0) {
perror("unexpected error: pthread_attr_setinheritsched 2-1: pthread_getschedparam");
/* WARNING: Subroutine does not return */
exit(2);
}
if (local_20 == policy) {
fprintf((FILE *)(ulong)stderr,
"unexpected error: pthread_attr_setinheritsched 2-1: The scheduling attribute is not inherited from creating thread \n"
);
/* WARNING: Subroutine does not return */
exit(1);
}
/* WARNING: Subroutine does not return */
pthread_exit((void *)0x0);
} | void *thread_func()
{
int rc;
int new_policy;
pthread_t self = pthread_self();
struct sched_param param;
memset(¶m, 0, sizeof(param));
rc = pthread_getschedparam(self, &new_policy, ¶m);
if (rc != 0) {
perror("unexpected error: " "pthread_attr_setinheritsched" " " "2-1" ": " "pthread_getschedparam");
exit(2);
}
if (new_policy == policy) {
fprintf(stderr, "unexpected error: " "pthread_attr_setinheritsched" " " "2-1" ": " "The scheduling attribute is not "
"inherited from creating thread \n");
exit(1);
}
pthread_exit(0);
return NULL;
} |
void help(undefined8 param_1)
{
fprintf((FILE *)(ulong)stderr,"usage: %s options* <infile> [-o <outfile>]\n",param_1);
fprintf((FILE *)(ulong)stderr,
" -d Decode (default is Encode)\n -dt Decode Test (Compare with output file)\n -ds Decode Sim (Decode but don\'t write output)\n -c Write to stdout\n -v Verbose\n -o <name> Specify output file\n -0 .. -9 Compression Level\n -1a .. -9a Compression Level (With Arithmetic, *)\n -fe Use fast encoder\n -rh Use RingHuff encoding\n -bf Bench File\n -h This message\n --help This message\n\n*: The arithmetic coder only rarely gives good results\n"
);
return;
} | void help(char *pgm)
{
fprintf(stderr, "usage: %s options* <infile> [-o <outfile>]\n", pgm);
fprintf(stderr,
" -d Decode (default is Encode)\n"
" -dt Decode Test (Compare with output file)\n"
" -ds Decode Sim (Decode but don't write output)\n"
" -c Write to stdout\n"
" -v Verbose\n"
" -o <name> Specify output file\n"
" -0 .. -9 Compression Level\n"
" -1a .. -9a Compression Level (With Arithmetic, *)\n"
" -fe Use fast encoder\n"
" -rh Use RingHuff encoding\n"
" -bf Bench File\n"
" -h This message\n"
" --help This message\n"
"\n"
"*: The arithmetic coder only rarely gives good results\n"
);
} |
undefined8 null_file_isatty(void)
{
return 0;
} | int
null_file_isatty (struct ui_file *file)
{
return 0;
} |
long net_create_acceptor(long param_1,undefined4 param_2,undefined2 param_3)
{
undefined8 *puVar1;
long lVar2;
if (param_1 != 0) {
puVar1 = (undefined8 *)_conv_inet_impl(param_1);
lVar2 = (**(code **)*puVar1)(puVar1,param_2,param_3);
if (lVar2 != 0) {
return lVar2;
}
fprintf((FILE *)(ulong)stderr,"<%s:%d> ",
"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/Chr1sL1/syslib/refs/heads/master/src/net.c"
,0x32a);
fprintf((FILE *)(ulong)stderr,"create acceptor error.");
fprintf((FILE *)(ulong)stderr,"\n");
}
return 0;
} | struct acceptor* net_create_acceptor(struct net_struct* net, unsigned int ip, unsigned short port)
{
struct _acc_impl* aci;
struct _inet_impl* inet;
if(!net) goto error_ret;
inet = _conv_inet_impl(net);
aci = (*inet->_handler->__create_acc_func)(inet, ip, port);
do { if(!aci){ fprintf(stderr, "<%s:%d> ", "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/Chr1sL1/syslib/refs/heads/master/src/net.c", 810); fprintf(stderr, "create acceptor error."); fprintf(stderr, "\n"); goto error_ret; } } while(0);;
return &aci->_the_acc;
error_ret:
return 0;
} |
undefined8 resetGL(undefined4 param_1,undefined4 param_2)
{
long lVar1;
undefined8 uVar2;
lVar1 = isInitializedGL(param_1,param_2);
if (lVar1 == 0) {
uVar2 = 0x1a0;
}
else {
enqueueGL(param_1,param_2,0,0,1,0);
uVar2 = 200;
}
return uVar2;
} | int resetGL(bus_t busnumber, int addr)
{
if (isInitializedGL(busnumber, addr)) {
enqueueGL(busnumber, addr, 0, 0, 1, 0);
return 200;
}
else {
return 416;
}
} |
undefined8 main(int param_1,long param_2)
{
undefined8 uVar1;
if (param_1 == 2) {
error = arquitec(*(undefined8 *)(param_2 + 8));
if (error == 0) {
error = read_data(*(undefined8 *)(param_2 + 8));
if (error == 0) {
error = train(*(undefined8 *)(param_2 + 8));
uVar1 = 0;
if (error != 0) {
printf("Error en el entrenamiento\n");
uVar1 = 1;
}
}
else {
printf("Error en la lectura de datos\n");
uVar1 = 1;
}
}
else {
printf("Error en la definicion de la red\n");
uVar1 = 1;
}
}
else {
printf("Modo de uso: bp <filename>\ndonde filename es el nombre del archivo (sin extension)\n");
uVar1 = 0;
}
return uVar1;
} | int main(int argc, char **argv){
if(argc!=2){
printf("Modo de uso: bp <filename>\ndonde filename es el nombre del archivo (sin extension)\n");
return 0;
}
error=arquitec(argv[1]);
if(error){
printf("Error en la definicion de la red\n");
return 1;
}
error=read_data(argv[1]);
if(error){
printf("Error en la lectura de datos\n");
return 1;
}
error=train(argv[1]);
if(error){
printf("Error en el entrenamiento\n");
return 1;
}
return 0;
} |
void _sort_u8p(undefined4 *param_1)
{
array_sort(*param_1);
_update_u8p(param_1);
return;
} | void _sort_u8p(ch_array_u8p_t* this) { array_sort(this->_array); _update_u8p(this); } |
double Random(void)
{
long extraout_RAX;
drand48();
return (double)extraout_RAX;
} | double Random() {
return (double)drand48();
} |
void rtwn_usb_tx_checksum(undefined8 *param_1)
{
undefined8 uVar1;
*param_1 = 0;
uVar1 = rtwn_usb_calc_tx_checksum(param_1);
*param_1 = uVar1;
return;
} | void
rtwn_usb_tx_checksum(struct rtwn_tx_desc_common *txd)
{
txd->txdw7.usb_checksum = 0;
txd->txdw7.usb_checksum = rtwn_usb_calc_tx_checksum(txd);
} |
undefined4 * get_external_univ(void)
{
undefined4 uVar1;
undefined4 *puVar2;
undefined8 *puVar3;
undefined8 uVar4;
puVar2 = (undefined4 *)alloc_set(VAR);
uVar1 = ExternalDep;
*puVar2 = 1;
puVar2[4] = uVar1;
puVar3 = (undefined8 *)alloc_gen();
uVar1 = VARIABLE;
*(undefined8 **)(puVar2 + 6) = puVar3;
uVar4 = alloc_expr(uVar1);
uVar1 = puVar2[4];
*puVar3 = uVar4;
*(undefined4 *)**(undefined8 **)(puVar2 + 6) = uVar1;
*(undefined8 *)(puVar2 + 2) = 0;
return puVar2;
} | set_t* get_external_univ(void) {
set_t *new;
new = alloc_set(VAR);
((new)->var) = ExternalDep;
((new)->imod) = 1;
((new)->exprs) = alloc_gen();
((((new)->exprs))->u.expr_p) = alloc_expr(VARIABLE);
((((((new)->exprs))->u.expr_p))->symtab_p) = ((new)->var);
((new)->next_s) = NULL;
return new;
} |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 119