Dataset Viewer
instruction
stringlengths 27
1.78k
| output
stringlengths 21
2.78k
|
|---|---|
int XXsockRead(int param_1,void *param_2,uint param_3)
{
int iVar1;
ssize_t sVar2;
uint uVar3;
size_t __nbytes;
__nbytes = (size_t)param_3;
uVar3 = param_3;
if (0 < (int)param_3) {
do {
uVar3 = (uint)__nbytes;
sVar2 = read(param_1,param_2,__nbytes);
iVar1 = (int)sVar2;
if (iVar1 < 0) {
return -1;
}
if (iVar1 == 0) break;
uVar3 = uVar3 - iVar1;
__nbytes = (size_t)uVar3;
param_2 = (void *)((long)param_2 + (long)iVar1);
} while (0 < (int)uVar3);
}
return param_3 - uVar3;
} | int XXsockRead(int sockfd,char *buf,size_t nbytes)
{
int
nleft,
nread;
nleft=nbytes;
while (nleft > 0)
{
nread=read(sockfd,buf,nleft);
if (nread < 0)
return (-1);
else if (nread == 0)
break;
nleft -= nread;
buf += nread;
}
return (nbytes-nleft);
} |
void mat_identity(undefined4 *param_1)
{
*param_1 = DAT_0010011c;
param_1[1] = 0;
param_1[2] = 0;
param_1[3] = 0;
param_1[4] = 0;
param_1[5] = DAT_0010011c;
param_1[6] = 0;
param_1[7] = 0;
param_1[8] = 0;
param_1[9] = 0;
param_1[10] = DAT_0010011c;
param_1[0xb] = 0;
param_1[0xc] = 0;
param_1[0xd] = 0;
param_1[0xe] = 0;
param_1[0xf] = DAT_0010011c;
return;
} | void mat_identity(float *matrix) {
matrix[0] = 1;
matrix[1] = 0;
matrix[2] = 0;
matrix[3] = 0;
matrix[4] = 0;
matrix[5] = 1;
matrix[6] = 0;
matrix[7] = 0;
matrix[8] = 0;
matrix[9] = 0;
matrix[10] = 1;
matrix[11] = 0;
matrix[12] = 0;
matrix[13] = 0;
matrix[14] = 0;
matrix[15] = 1;
} |
void __INIT_java_lang_RuntimeException(void)
{
undefined4 uVar1;
pthread_t pVar2;
staticInitializerLock(__TIB_java_lang_RuntimeException);
uVar1 = __TIB_java_lang_RuntimeException._0_4_;
__TIB_java_lang_RuntimeException._0_4_ = 1;
staticInitializerUnlock(__TIB_java_lang_RuntimeException);
pVar2 = pthread_self();
if (uVar1 == 0) {
__TIB_java_lang_RuntimeException._8_8_ = (long)(int)pVar2;
__INIT_IMPL_java_lang_RuntimeException();
return;
}
if ((__TIB_java_lang_RuntimeException._8_8_ != (long)(int)pVar2) &&
(__TIB_java_lang_RuntimeException._16_4_ == 0)) {
do {
/* WARNING: Do nothing block with infinite loop */
} while( true );
}
return;
} | void __INIT_java_lang_RuntimeException()
{
staticInitializerLock(&__TIB_java_lang_RuntimeException);
int initBegan = __TIB_java_lang_RuntimeException.classInitializationBegan;
__TIB_java_lang_RuntimeException.classInitializationBegan = 1;
staticInitializerUnlock(&__TIB_java_lang_RuntimeException);
JAVA_LONG curThreadId = (JAVA_LONG)pthread_self();
if (initBegan) {
if (__TIB_java_lang_RuntimeException.initializerThreadId != curThreadId) {
while (!__TIB_java_lang_RuntimeException.classInitialized) {
}
}
} else {
__TIB_java_lang_RuntimeException.initializerThreadId = curThreadId;
__INIT_IMPL_java_lang_RuntimeException();
}
} |
void lb_update_tx_stats(int param_1,undefined4 *param_2,undefined4 *param_3,byte param_4)
{
long lVar1;
int *piVar2;
int *piVar3;
lVar1 = this_cpu_ptr(*param_2);
piVar2 = (int *)this_cpu_ptr(*param_3);
piVar3 = (int *)(*(long *)(lVar1 + 8) + (ulong)param_4 * 4);
u64_stats_update_begin(lVar1);
*piVar2 = *piVar2 + param_1;
*piVar3 = *piVar3 + param_1;
u64_stats_update_end(lVar1);
return;
} | void lb_update_tx_stats(unsigned int tx_bytes, struct lb_priv *lb_priv,
struct lb_port_priv *lb_port_priv,
unsigned char hash)
{
struct lb_pcpu_stats *pcpu_stats;
struct lb_stats *port_stats;
struct lb_stats *hash_stats;
pcpu_stats = this_cpu_ptr(lb_priv->pcpu_stats);
port_stats = this_cpu_ptr(lb_port_priv->pcpu_stats);
hash_stats = &pcpu_stats->hash_stats[hash];
u64_stats_update_begin(&pcpu_stats->syncp);
port_stats->tx_bytes += tx_bytes;
hash_stats->tx_bytes += tx_bytes;
u64_stats_update_end(&pcpu_stats->syncp);
} |
undefined8 ucg_clip_is_x_visible(long *param_1)
{
undefined8 uVar1;
if (param_1[2] - param_1[1] < 0) {
uVar1 = 0;
}
else if (param_1[2] - param_1[1] < *param_1) {
uVar1 = 1;
}
else {
uVar1 = 0;
}
return uVar1;
} | ucg_int_t ucg_clip_is_x_visible(ucg_t *ucg)
{
ucg_int_t t;
t = ucg->arg.pixel.pos.x;
t -= ucg->clip_box.ul.x;
if ( t < 0 )
return 0;
if ( t >= ucg->clip_box.size.w )
return 0;
return 1;
} |
undefined8 sd_getbrightness(undefined4 *param_1,undefined4 *param_2)
{
*param_2 = *param_1;
return 0;
} | int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
{
struct sd *sd = (struct sd *) gspca_dev;
*val = sd->brightness;
return 0;
} |
int consock(char *param_1,char *param_2)
{
uint16_t uVar1;
int __fd;
long lVar2;
undefined6 extraout_var;
long in_FS_OFFSET;
undefined local_1c [20];
local_1c._12_8_ = *(long *)(in_FS_OFFSET + 0x28);
lVar2 = strtol(param_2,(char **)0x0,0);
__fd = socket(AF_INET,SOCK_STREAM,0);
local_1c._8_4_ = AF_INET;
uVar1 = htons((uint16_t)lVar2);
local_1c._4_4_ = (undefined4)CONCAT62(extraout_var,uVar1);
inet_pton(AF_INET,param_1,local_1c);
connect(__fd,(sockaddr *)local_1c,0xc);
if (local_1c._12_8_ != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __fd;
} | int consock(const char *addr,const char *portnum){
struct sockaddr_in server;
int sock;
long port;
port = strtol(portnum,NULL,0);
sock = socket(AF_INET,SOCK_STREAM,0);
server.sin_family = AF_INET;
server.sin_port = htons(port);
inet_pton(AF_INET,addr,&server.sin_addr.s_addr);
connect(sock,(struct sockaddr *)&server,sizeof(server));
return sock;
} |
undefined8 test_3a(undefined8 param_1)
{
uint uVar1;
prep();
uVar1 = duk_has_prop_index(param_1,0,0x7a69);
printf("obj[31337] -> rc=%d\n",(ulong)uVar1);
uVar1 = duk_has_prop_index(param_1,0,0x7b);
printf("obj[123] -> rc=%d\n",(ulong)uVar1);
uVar1 = duk_has_prop_index(param_1,1,0x7a69);
printf("arr[31337] -> rc=%d\n",(ulong)uVar1);
uVar1 = duk_has_prop_index(param_1,1,2);
printf("arr[2] -> rc=%d\n",(ulong)uVar1);
uVar1 = duk_get_top(param_1);
printf("final top: %d\n",(ulong)uVar1);
return 0;
} | int test_3a(duk_context *ctx) {
int rc;
prep(ctx);
rc = duk_has_prop_index(ctx, 0, 31337);
printf("obj[31337] -> rc=%d\n", rc);
rc = duk_has_prop_index(ctx, 0, 123);
printf("obj[123] -> rc=%d\n", rc);
rc = duk_has_prop_index(ctx, 1, 31337);
printf("arr[31337] -> rc=%d\n", rc);
rc = duk_has_prop_index(ctx, 1, 2);
printf("arr[2] -> rc=%d\n", rc);
printf("final top: %d\n", duk_get_top(ctx));
return 0;
} |
void rue_attach_post(undefined4 *param_1)
{
undefined8 uVar1;
uVar1 = uether_getsc();
rue_reset(uVar1);
rue_read_mem(uVar1,RUE_EEPROM_IDR0,*param_1,ETHER_ADDR_LEN);
return;
} | void
rue_attach_post(struct usb_ether *ue)
{
struct rue_softc *sc = uether_getsc(ue);
/* reset the adapter */
rue_reset(sc);
/* get station address from the EEPROM */
rue_read_mem(sc, RUE_EEPROM_IDR0, ue->ue_eaddr, ETHER_ADDR_LEN);
} |
bool mfcb_contains(char **param_1,char *param_2)
{
int iVar1;
size_t sVar2;
long *plVar3;
undefined8 uVar4;
long lVar5;
long lVar6;
undefined4 extraout_var;
char *__s1;
bool bVar7;
bVar7 = false;
__s1 = *param_1;
if (__s1 != (char *)0x0) {
sVar2 = strlen(param_2);
while( true ) {
lVar6 = _points_to_int_node(__s1);
if (lVar6 == 0) break;
plVar3 = (long *)_get_node_ptr(__s1);
lVar6 = *plVar3;
uVar4 = _get_node_ptr(__s1);
lVar5 = _get_direction(uVar4,param_2,sVar2);
__s1 = *(char **)(lVar6 + lVar5 * 8);
}
iVar1 = strcmp(__s1,param_2);
bVar7 = CONCAT44(extraout_var,iVar1) == 0;
}
return bVar7;
} | int mfcb_contains(const mfcb_t *t, const char *s)
{
if (t->root == 0)
return 0;
size_t s_len = strlen(s);
intptr_t p = t->root;
while (_points_to_int_node(p))
p = _get_node_ptr(p)->children[_get_direction(_get_node_ptr(p), s, s_len)];
return strcmp((const char *)p, s) == 0;
} |
void socks5_mkconnect(undefined8 param_1)
{
socks5_mkcommand_plain(socks5_cmd_connect,param_1);
return;
} | struct evbuffer *socks5_mkconnect(redsocks_client *client)
{
return socks5_mkcommand_plain(socks5_cmd_connect, &client->destaddr);
} |
undefined4 tLoserTreeCreate(int **param_1,int param_2,undefined8 param_3,int param_4)
{
undefined4 uVar1;
int *piVar2;
int local_10;
local_10 = param_2 * 2;
piVar2 = (int *)calloc(1,(ulong)(uint)((local_10 + 8) * 4));
*param_1 = piVar2;
if (*param_1 == (int *)0x0) {
pError("allocate memory for losertree failed. out of memory");
uVar1 = TSDB_CODE_CLI_OUT_OF_MEMORY;
}
else {
*(int **)(*param_1 + 6) = *param_1 + 8;
**param_1 = param_2;
(*param_1)[1] = local_10;
*(undefined8 *)(*param_1 + 4) = param_3;
(*param_1)[2] = param_4;
tLoserTreeInit(*param_1);
while (local_10 = local_10 + -1, uVar1 = TSDB_CODE_SUCCESS, param_2 <= local_10) {
tLoserTreeAdjust(*param_1,local_10);
}
}
return uVar1;
} | uint8_t tLoserTreeCreate(SLoserTreeInfo** pTree, int32_t numOfEntries, void* param, __merge_compare_fn_t compareFn) {
int32_t totalEntries = numOfEntries << 1;
*pTree = (SLoserTreeInfo*)calloc(1, sizeof(SLoserTreeInfo) + sizeof(SLoserTreeNode) * totalEntries);
if ((*pTree) == NULL) {
pError("allocate memory for losertree failed. out of memory");
return TSDB_CODE_CLI_OUT_OF_MEMORY;
}
(*pTree)->pNode = (SLoserTreeNode*)(((char*)(*pTree)) + sizeof(SLoserTreeInfo));
(*pTree)->numOfEntries = numOfEntries;
(*pTree)->totalEntries = totalEntries;
(*pTree)->param = param;
(*pTree)->comparaFn = compareFn;
// set initial value for loser tree
tLoserTreeInit(*pTree);
#ifdef _DEBUG_VIEW
printf("the initial value of loser tree:\n");
tLoserTreeDisplay(*pTree);
#endif
for (int32_t i = totalEntries - 1; i >= numOfEntries; i--) {
tLoserTreeAdjust(*pTree, i);
}
#if defined(_DEBUG_VIEW)
printf("after adjust:\n");
tLoserTreeDisplay(*pTree);
printf("initialize local reducer completed!\n");
#endif
return TSDB_CODE_SUCCESS;
} |
undefined8 handle_options(uint *param_1)
{
long lVar1;
char *__nptr;
longlong lVar2;
undefined8 uVar3;
long in_FS_OFFSET;
short local_36;
uint local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
while( true ) {
lVar1 = do_read_check(param_1,&local_36,2);
if (lVar1 != 0) break;
if (local_36 == TRACECMD_OPTION_DONE) {
uVar3 = 0;
goto LAB_00100115;
}
lVar1 = do_read_check(param_1,&local_34,4);
if (lVar1 != 0) break;
local_34 = __data2host4(param_1[4],local_34);
printf("size=%d\n",(ulong)local_34);
__nptr = (char *)malloc_or_die(local_34);
lVar1 = do_read_check(param_1,__nptr,local_34);
if (lVar1 != 0) break;
if (local_36 == 0x80) {
if ((TRACECMD_FL_IGNORE_DATE & *param_1) == 0) {
lVar2 = strtoll(__nptr,(char **)0x0,0);
*(longlong *)(param_1 + 2) = lVar2 * 1000;
}
}
else {
warning("unknown option %d");
}
free(__nptr);
}
uVar3 = 0xffffffff;
LAB_00100115:
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | int handle_options(struct tracecmd_input *handle)
{
unsigned long long offset;
unsigned short option;
unsigned int size;
char *buf;
for (;;) {
if (do_read_check(handle, &option, 2))
return -1;
if (option == TRACECMD_OPTION_DONE)
break;
if (do_read_check(handle, &size, 4))
return -1;
size = __data2host4(handle->pevent, size);
printf("size=%d\n", size);
buf = malloc_or_die(size);
if (do_read_check(handle, buf, size))
return -1;
switch (option) {
case TRACECMD_OPTION_DATE:
if (handle->flags & TRACECMD_FL_IGNORE_DATE)
break;
offset = strtoll(buf, NULL, 0);
offset *= 1000;
handle->ts_offset = offset;
break;
default:
warning("unknown option %d", option);
break;
}
free(buf);
}
return 0;
} |
void SHA512_Data(void *param_1,size_t param_2,undefined8 param_3)
{
long in_FS_OFFSET;
undefined local_34 [20];
local_34._4_8_ = *(ulonglong *)(in_FS_OFFSET + 0x28);
SHA512_Init((SHA512_CTX *)local_34);
SHA512_Update((SHA512_CTX *)local_34,param_1,param_2);
SHA512_End((SHA512_CTX *)local_34,param_3);
if (local_34._4_8_ == *(ulonglong *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | char* SHA512_Data(const sha2_byte* data, size_t len, char digest[(64 * 2 + 1)]) {
SHA512_CTX context;
SHA512_Init(&context);
SHA512_Update(&context, data, len);
return SHA512_End(&context, digest);
} |
long bdd_nand(void)
{
long lVar1;
lVar1 = bdd_and();
if (lVar1 != 0) {
lVar1 = (long)(int)((uint)lVar1 ^ 1);
}
return lVar1;
} | bdd
bdd_nand(bdd_manager bddm, bdd f, bdd g)
{
bdd temp;
if ((temp=bdd_and(bddm, f, g)))
return (((bdd)((pointer)((INT_PTR)(temp) ^ 0x1))));
return ((bdd)0);
} |
undefined8 cmd_page_up(undefined4 *param_1)
{
long lVar1;
undefined8 uVar2;
long in_FS_OFFSET;
undefined4 local_18;
undefined local_14 [4];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = buffer_tstflags(param_1[2],8);
if (lVar1 == 0) {
view_get_portsize(*param_1,&local_18,local_14);
uVar2 = _cmd_up(param_1,local_18);
}
else {
win_set_commandmode(param_1[1],0);
uVar2 = 0;
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | POE_ERR cmd_page_up(cmd_ctx* ctx)
{
;
POE_ERR err = (0);
if (buffer_tstflags(ctx->targ_buf, (1<<3))) {
win_set_commandmode(ctx->wnd, false);
}
else {
int ht, wd;
view_get_portsize(ctx->targ_view, &ht, &wd);
err = _cmd_up(ctx, ht);
}
{ return (err); };
} |
void prim_intfromstr(long **param_1,undefined4 *param_2,undefined8 param_3,long *param_4)
{
long lVar1;
undefined4 uVar2;
lVar1 = param_4[1];
if (VALUE_STRING != *param_4) {
runtime_error(param_3,"argument of #intfromstr must be a string");
}
uVar2 = int_from_cstr(*(undefined4 *)(**param_1 + lVar1 * 4));
param_2[1] = VALUE_INT;
*param_2 = uVar2;
return;
} | void prim_intfromstr(Scheduler *sched, Process *proc,Definition *expr, Value args[]) {
Value sarg = args[0];
if (((sarg).ctl) != VALUE_STRING)
runtime_error(expr,"argument of #intfromstr must be a string");
String str = (sched->string_pool->pool[((sarg).val._int)]);
int val = int_from_cstr(str.str);
Value vval;
(((vval).val._int) = (val));
(((proc->val).ctl)= (VALUE_INT) );
(((proc->val).val._int) = (((vval).val._int)));
} |
void dir_update(long *param_1,uint param_2)
{
long in_FS_OFFSET;
undefined4 local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if (param_1 != (long *)0x0) {
if (*param_1 != 0) {
local_24 = **(undefined4 **)(param_1[3] + param_1[1] * 8);
if ((char)(param_2 ^ *(uint *)(param_1 + 2)) == '\0') {
if (((param_2 ^ *(uint *)(param_1 + 2)) & 0x100) != 0) {
dir_filter();
}
}
else {
dir_sort();
dir_filter(param_1,param_2);
}
dir_update_cf(param_1,&local_24);
*(uint *)(param_1 + 2) = param_2;
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | void
dir_update(struct dir *dir, unsigned int flag)
{
struct stat st;
if (dir == NULL || ((dir)->size == 0)) {
return;
}
st = dir->fi[dir->cf]->st;
if ((flag & 0xFF) != (dir->flag & 0xFF)) {
dir_sort(dir, flag);
dir_filter(dir, flag);
} else if ((flag & 0x100) != (dir->flag & 0x100)) {
dir_filter(dir, flag);
}
dir_update_cf(dir, &st);
dir->flag = flag;
} |
void type_has_template_cons_basic_initializer(undefined8 param_1,undefined8 param_2)
{
template_cons_basic_initializer(param_1,param_2,allow_alternate_memory_manager_1926);
return;
} | tval *type_has_template_cons_basic_initializer(const type_t *type, tval *cons)
{
static const int allow_alternate_memory_manager =
1;
return template_cons_basic_initializer(type, (template_cons_t *) cons, allow_alternate_memory_manager);
} |
undefined8 t0(void)
{
atomic_store_explicit(vars,1,memory_order_seq_cst);
atomic_load_explicit(vars + 4,memory_order_seq_cst);
atomic_load_explicit(vars + 8,memory_order_seq_cst);
atomic_store_explicit(vars + 0xc,1,memory_order_seq_cst);
return 0;
} | void *t0(void *arg){
label_1:;
atomic_store_explicit(&vars[0], 1, memory_order_seq_cst);
int v2_r3 = atomic_load_explicit(&vars[1], memory_order_seq_cst);
int v4_r5 = atomic_load_explicit(&vars[2], memory_order_seq_cst);
int v5_r7 = v4_r5 ^ v4_r5;
atomic_store_explicit(&vars[3+v5_r7], 1, memory_order_seq_cst);
return NULL;
} |
void init_getbits(void)
{
bitbuf = 0;
subbitbuf = 0;
bitcount = 0;
fillbuf(0x20);
return;
} | void init_getbits (void)
{
bitbuf = 0;
subbitbuf = 0;
bitcount = 0;
fillbuf ((8 * sizeof (ushort)));
} |
void old_str_extract(char *param_1,char *param_2,char *param_3,char *param_4)
{
char cVar1;
int iVar2;
ulong uVar3;
ulong uVar4;
uint uVar5;
char *pcVar6;
byte bVar7;
bVar7 = 0;
if ((param_4 != (char *)0x0 && param_1 != (char *)0x0) && (param_3 != (char *)0x0)) {
uVar3 = 0xffffffffffffffff;
pcVar6 = param_3;
do {
if (uVar3 == 0) break;
uVar3 = uVar3 - 1;
cVar1 = *pcVar6;
pcVar6 = pcVar6 + 1;
} while (cVar1 != '\0');
while (iVar2 = strncmp(param_1,param_3,~uVar3 - 1), iVar2 != 0) {
if (*param_1 == '\0') {
return;
}
param_1 = param_1 + 1;
}
uVar4 = 0xffffffffffffffff;
pcVar6 = param_4;
do {
if (uVar4 == 0) break;
uVar4 = uVar4 - 1;
cVar1 = *pcVar6;
pcVar6 = pcVar6 + (ulong)bVar7 * -2 + 1;
} while (cVar1 != '\0');
uVar5 = 0;
pcVar6 = param_1 + (~uVar3 - 1);
while (iVar2 = strncmp(pcVar6,param_4,~uVar4 - 1), iVar2 != 0) {
if (*pcVar6 == '\0') {
return;
}
uVar5 = uVar5 + 1;
pcVar6 = pcVar6 + 1;
}
strncpy(param_2,pcVar6 + -(long)(int)uVar5,(ulong)uVar5);
param_2[(int)uVar5] = '\0';
}
return;
} | void old_str_extract(const char *input, char *output, const char *start, const char *end)
{
if (!start || !end || !input)
return;
int i = 0, tmp;
char *proc = (char *)input;
size_t stl = strlen(start);
size_t edl = strlen(end);
while ((tmp = strncmp(proc, start, stl)) && *proc)
proc++;
if (tmp)
return;
proc += stl;
while ((tmp = strncmp(proc, end, edl)) && *proc++)
i++;
if (tmp)
return;
proc -= i;
strncpy(output, proc, i);
output[i] = 0;
} |
int FP_LOAD_REG(int param_1)
{
undefined4 uVar1;
if ((CODEBLOCK_STATIC_TOP & *(uint *)(codeblock + block_current * 4)) == 0) {
addbyte(0x8b);
addbyte(0x5d);
uVar1 = cpu_state_offset(TOP);
addbyte(uVar1);
if (param_1 != 0) {
addbyte(0x83);
addbyte(0xc3);
addbyte(param_1);
addbyte(0x83);
addbyte(0xe3);
addbyte(7);
}
addbyte(0xdd);
addbyte(0x44);
addbyte(0xdd);
uVar1 = cpu_state_offset(ST);
addbyte(uVar1);
}
else {
addbyte(0xdd);
addbyte(0x45);
uVar1 = cpu_state_offset(*(undefined8 *)(ST + (ulong)(param_1 + cpu_state & 7) * 8));
addbyte(uVar1);
}
addbyte(0xd9);
addbyte(0x1c);
addbyte(0x24);
addbyte(0x8b);
addbyte(REG_EBX * 8 + 4);
addbyte(0x24);
return REG_EBX;
} | int FP_LOAD_REG(int reg)
{
if (codeblock[block_current].flags & CODEBLOCK_STATIC_TOP)
{
addbyte(0xdd);
addbyte(0x45);
addbyte(cpu_state_offset(ST[(cpu_state.TOP + reg) & 7]));
}
else
{
addbyte(0x8b);
addbyte(0x5d);
addbyte(cpu_state_offset(TOP));
if (reg)
{
addbyte(0x83);
addbyte(0xc3);
addbyte(reg);
addbyte(0x83);
addbyte(0xe3);
addbyte(7);
}
addbyte(0xdd);
addbyte(0x44);
addbyte(0xdd);
addbyte(cpu_state_offset(ST));
}
addbyte(0xd9);
addbyte(0x1c);
addbyte(0x24);
addbyte(0x8b);
addbyte(0x04 | (REG_EBX << 3));
addbyte(0x24);
return REG_EBX;
} |
undefined8 tx_take(long param_1)
{
undefined4 uVar1;
undefined4 uVar2;
undefined8 *puVar3;
undefined8 uVar4;
PRINTD(DBG_FLOW | DBG_TX,"tx_take %p",param_1);
spin_lock_irqsave(param_1,0);
if ((*(long *)(param_1 + 0x18) != 0) && (**(long **)(param_1 + 0x10) != 0)) {
tx_complete(param_1);
puVar3 = *(undefined8 **)(param_1 + 0x10);
uVar1 = *(undefined4 *)(param_1 + 8);
uVar2 = *(undefined4 *)(param_1 + 0xc);
*puVar3 = 0;
*(long *)(param_1 + 0x18) = *(long *)(param_1 + 0x18) + -1;
uVar4 = NEXTQ(puVar3,uVar2,uVar1);
*(undefined8 *)(param_1 + 0x10) = uVar4;
spin_unlock_irqrestore(param_1,0);
return 0;
}
spin_unlock_irqrestore(param_1,0);
return 0xffffffff;
} | int tx_take (amb_dev * dev) {
amb_txq * txq = &dev->txq;
unsigned long flags;
PRINTD (DBG_FLOW|DBG_TX, "tx_take %p", dev);
spin_lock_irqsave (&txq->lock, flags);
if (txq->pending && txq->out.ptr->handle) {
// deal with TX completion
tx_complete (dev, txq->out.ptr);
// mark unused again
txq->out.ptr->handle = 0;
// remove item
txq->pending--;
txq->out.ptr = NEXTQ (txq->out.ptr, txq->out.start, txq->out.limit);
spin_unlock_irqrestore (&txq->lock, flags);
return 0;
} else {
spin_unlock_irqrestore (&txq->lock, flags);
return -1;
}
} |
void task(uint param_1)
{
uint uVar1;
uint uVar2;
uint uVar3;
ulong uVar4;
if (0 < (int)param_1) {
uVar4 = 0;
do {
uVar1 = shared_resource + 10000;
do {
uVar2 = shared_resource + 1;
usleep(1);
shared_resource = uVar2;
} while (uVar1 != uVar2);
uVar2 = getpid();
uVar3 = (int)uVar4 + 1;
printf("Process [%d]: loop = %d, count = %d / j = %d\n",(ulong)uVar2,(ulong)param_1,uVar4,
(ulong)uVar1);
uVar4 = (ulong)uVar3;
} while (param_1 != uVar3);
return;
}
return;
} | void task(int loop) {
int i, j, tmp;
for (i=0; i<loop; i++) {
for (j=0; j<10000; j++) {
tmp = shared_resource;
tmp += 1;
usleep(1);
shared_resource = tmp;
}
printf("Process [%d]: loop = %d, count = %d / j = %d\n", getpid(), loop, i, tmp);
}
} |
double uniformVar(void)
{
double extraout_XMM0_Qa;
random();
return extraout_XMM0_Qa / (double)RAND_MAX;
} | double uniformVar(void) {
return random() / (double)RAND_MAX;
} |
void mult(long param_1,long param_2,long param_3,int param_4)
{
long lVar1;
if ((long)param_4 != 0) {
lVar1 = 0;
do {
*(int *)(param_3 + lVar1 * 4) = *(int *)(param_1 + lVar1 * 4) * *(int *)(param_2 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (lVar1 != param_4);
}
return;
} | void mult(cplx* buf1, cplx* buf2, cplx* out, int n) {
for (size_t i = 0; i < n; i++)
out[i] = buf1[i] * buf2[i];
} |
undefined8 test_term(int *param_1,undefined8 param_2)
{
int iVar1;
undefined4 uVar2;
size_t sVar3;
assert(param_1 != (int *)0x0);
iVar1 = *param_1;
if (iVar1 == 0x81) {
uVar2 = test_term_list(param_1[6],param_2);
assert(uVar2);
}
else if (iVar1 != 0x82) {
if (iVar1 != 0x80) {
assert(0);
return 1;
}
sVar3 = strlen((char *)(ulong)**(uint **)(param_1 + 4));
assert(0 < (int)sVar3);
return 1;
}
uVar2 = test_constant(param_1[2],param_2);
assert(uVar2);
return 1;
} | bool test_term(const clp_term* t, const constants* cs){
assert(t != NULL);
switch(t->type){
case variable_term:
assert(strlen(t->val.var->name) > 0);
break;
case function_term:
assert(test_term_list(t->args, cs));
case constant_term:
assert(test_constant(t->val.constant, cs));
break;
default:
assert(false);
}
return true;
} |
void utest_register_utf8rchr_a(void)
{
long lVar1;
size_t sVar2;
char *__s;
lVar1 = (long)(int)utest_state._0_4_;
utest_state._0_4_ = utest_state._0_4_ + 1;
sVar2 = strlen("utf8rchr.a");
sVar2 = (size_t)((int)sVar2 + 1);
__s = (char *)malloc(sVar2);
utest_state._8_8_ = realloc((void *)utest_state._8_8_,(ulong)(uint)(utest_state._0_4_ << 4));
*(undefined4 **)(utest_state._8_8_ + lVar1 * 0x10 + 8) = &utest_utf8rchr_a;
*(char **)(lVar1 * 0x10 + utest_state._8_8_) = __s;
snprintf(__s,sVar2,"%s","utf8rchr.a");
return;
} | void utest_register_utf8rchr_a(void) { const size_t index = utest_state.tests_length++; const char *name_part = "utf8rchr" "." "a"; const size_t name_size = strlen(name_part) + 1; char *name = ((char *)malloc(name_size)); utest_state.tests = ((struct utest_test_state_s *)realloc(((void *)utest_state.tests), sizeof(struct utest_test_state_s) * utest_state.tests_length)); utest_state.tests[index].func = &utest_utf8rchr_a; utest_state.tests[index].name = name; snprintf(name, name_size, "%s", name_part); } |
void uper_c_source_f_decode_inner(undefined8 param_1,int *param_2)
{
undefined4 *puVar1;
int iVar2;
undefined4 uVar3;
long lVar4;
iVar2 = decoder_read_non_negative_binary_integer(param_1,1);
*param_2 = iVar2 + 1;
if (iVar2 + 1 < 1) {
return;
}
lVar4 = 0;
do {
puVar1 = *(undefined4 **)(*(long *)(param_2 + 2) + lVar4 * 8);
lVar4 = lVar4 + 1;
uVar3 = decoder_read_bool(param_1);
*puVar1 = uVar3;
} while ((int)lVar4 < *param_2);
return;
} | void uper_c_source_f_decode_inner(
struct decoder_t *decoder_p,
struct uper_c_source_f_t *dst_p)
{
uint8_t i;
uint8_t i_2;
dst_p->length = decoder_read_non_negative_binary_integer(
decoder_p,
1);
dst_p->length += 1u;
for (i = 0; i < dst_p->length; i++) {
for (i_2 = 0; i_2 < 1; i_2++) {
dst_p->elements[i].elements[i_2] = decoder_read_bool(decoder_p);
}
}
} |
void uart_send_string(char *param_1)
{
char cVar1;
if (*param_1 != '\0') {
param_1 = param_1 + 1;
do {
uart_send();
cVar1 = *param_1;
param_1 = param_1 + 1;
} while (cVar1 != '\0');
}
return;
} | void uart_send_string(char* str)
{
for (int i = 0; str[i] != '\0'; i ++) {
uart_send((char)str[i]);
}
} |
undefined8 main(void)
{
initialize();
test_loop();
report_and_exit();
return 0;
} | int main()
{
initialize();
test_loop();
report_and_exit();
return 0;
} |
void ping1(uint param_1,long *param_2,undefined8 *param_3,long *param_4)
{
ssize_t sVar1;
long lVar2;
undefined8 uVar3;
long in_FS_OFFSET;
undefined4 local_3c;
undefined4 local_38;
undefined4 local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
gettimeofday((timeval *)&local_3c,(__timezone_ptr_t)0x0);
sVar1 = send(param_1,(timeval *)&local_3c,4,0);
if ((int)sVar1 == -1) {
fprintf((FILE *)(ulong)stderr,"[ping]: send failed at socket %d!\n",(ulong)param_1);
/* WARNING: Subroutine does not return */
exit(1);
}
recebe_mesmo(param_1,&local_34,4);
gettimeofday((timeval *)&local_38,(__timezone_ptr_t)0x0);
lVar2 = timerdiff(local_38,local_3c);
*param_4 = lVar2;
lVar2 = timerabs(local_3c);
*param_2 = *param_4 / 2 + lVar2;
uVar3 = timerabs(local_34);
*param_3 = uVar3;
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | void ping1(int socket, long long *local, long long *remote, long *delta)
{
struct timeval t0, t1, tremote;
int teste;
gettimeofday(&t0, NULL);
teste = send(socket, (void *) &t0, sizeof(t0), 0);
if (teste == -1) {
fprintf(stderr, "[ping]: send failed at socket %d!\n", socket);
exit(1);
}
recebe_mesmo(socket, (char *) &tremote, sizeof(tremote));
gettimeofday(&t1, NULL);
*delta = timerdiff(t1, t0);
*local = timerabs(t0) + *delta / 2;
*remote = timerabs(tremote);
} |
void addthread(long *param_1,long *param_2,long *param_3,undefined8 param_4)
{
long **pplVar1;
int iVar2;
undefined4 uVar3;
undefined auVar4 [16];
if (*param_2 == gen) {
decref((ulong)param_3 & 0xffffffff);
}
else {
*param_2 = gen;
iVar2 = *(int *)(param_2 + 1);
if (iVar2 == 0x82) {
auVar4 = thread(param_2[3],(ulong)param_3 & 0xffffffff);
addthread(param_1,auVar4._0_8_,auVar4._8_8_,param_4);
}
else {
if (iVar2 < 0x83) {
if (iVar2 == 0x80) {
uVar3 = incref((ulong)param_3 & 0xffffffff);
auVar4 = thread(param_2[3],uVar3);
addthread(param_1,auVar4._0_8_,auVar4._8_8_,param_4);
auVar4 = thread(param_2[2],(ulong)param_3 & 0xffffffff);
addthread(param_1,auVar4._0_8_,auVar4._8_8_,param_4);
return;
}
if (iVar2 == 0x81) {
uVar3 = update((ulong)param_3 & 0xffffffff,*(undefined4 *)((long)param_2 + 0xc),param_4);
auVar4 = thread(param_2 + 4,uVar3);
addthread(param_1,auVar4._0_8_,auVar4._8_8_,param_4);
return;
}
}
pplVar1 = (long **)(param_1[1] + *param_1 * 0x10);
*pplVar1 = param_2;
pplVar1[1] = param_3;
*param_1 = *param_1 + 1;
}
}
return;
} | void
addthread(ThreadList *l, Thread t, char *sp)
{
if(t.pc->gen == gen) {
decref(t.sub);
return;
}
t.pc->gen = gen;
switch(t.pc->opcode) {
default:
l->t[l->n] = t;
l->n++;
break;
case Jmp:
addthread(l, thread(t.pc->x, t.sub), sp);
break;
case Split:
addthread(l, thread(t.pc->x, incref(t.sub)), sp);
addthread(l, thread(t.pc->y, t.sub), sp);
break;
case Save:
addthread(l, thread(t.pc+1, update(t.sub, t.pc->n, sp)), sp);
break;
}
} |
void bubbleSort(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
uint uVar3;
ulong uVar4;
printf("size %d\n");
if (1 < param_2) {
uVar4 = (ulong)(param_2 - 1);
do {
uVar3 = (int)uVar4 - 1;
uVar4 = (ulong)uVar3;
piVar2 = param_1;
do {
iVar1 = *piVar2;
if (piVar2[1] < iVar1) {
*piVar2 = piVar2[1];
piVar2[1] = iVar1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + uVar4 + 1);
} while (uVar3 != 0);
printA(param_1,param_2);
return;
}
return;
} | void bubbleSort(int *a,int n) {
int t;
printf("size %d\n",n);
if(n <=1) {
return;
}
for (int i=0; i < n-1; i++){
for(int j=0; j < n-1-i; j++){
if (a[j] > a[j+1]) {
t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
printA(a,n);
} |
undefined8 opt_store_double_lim(char *param_1,double *param_2)
{
double dVar1;
double dVar2;
undefined8 uVar3;
long in_FS_OFFSET;
double dVar4;
char *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
assert(param_2 != (double *)0x0 && param_1 != (char *)0x0);
errno = 0;
dVar4 = strtod(param_1,&local_28);
if ((local_28 == param_1) || (*local_28 != '\0')) {
opt_err("the value of %s must be a number");
}
if (((errno == ERANGE) || (dVar4 < param_2[1])) || (param_2[2] <= dVar4 && dVar4 != param_2[2])) {
opt_err_pfx();
dVar1 = param_2[2];
dVar2 = param_2[1];
uVar3 = opt_name();
fprintf((FILE *)(ulong)stderr,"the value of %s must be in the range %g to %g",dVar2,dVar1,uVar3)
;
opt_err_sfx();
}
*param_2 = dVar4;
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return 0;
} | int opt_store_double_lim(char *arg, void *data)
{
char *end;
double val;
double *p = data;
assert(arg && data);
errno = 0;
val = strtod(arg, &end);
if (end == arg || end[0])
opt_err("the value of %s must be a number");
if (errno == ERANGE || val < p[1] || val > p[2]) {
opt_err_pfx();
fprintf(stderr, "the value of %s must be in the range %g to %g",
opt_name(), p[1], p[2]);
opt_err_sfx();
}
p[0] = val;
return 0;
} |
void ReadNumber(FILE *param_1,int *param_2)
{
char cVar1;
int iVar2;
undefined4 extraout_var;
undefined4 extraout_var_00;
int iVar3;
int __c;
int iVar4;
iVar4 = 1;
cVar1 = ReadWhiteSpace();
if (cVar1 == '-') {
iVar4 = -1;
cVar1 = ReadWhiteSpace(param_1);
}
iVar3 = cVar1 + -0x30;
iVar2 = isdigit((int)cVar1);
if (CONCAT44(extraout_var,iVar2) == 0) {
iVar3 = 0;
nc_error("ReadNumber: digit expected");
}
while( true ) {
iVar2 = getc(param_1);
__c = (int)(char)iVar2;
iVar2 = isdigit(__c);
if (CONCAT44(extraout_var_00,iVar2) == 0) break;
iVar3 = __c + -0x30 + iVar3 * 10;
}
ungetc(__c,param_1);
*param_2 = iVar3 * iVar4;
return;
} | void ReadNumber (FILE *file, int *result)
{
register int number = 0;
register char digit;
register int vorz = 1;
if ((digit = ReadWhiteSpace(file)) == '-')
{
vorz = -1;
digit = ReadWhiteSpace(file);
}
if (isdigit((int)digit))
number = digit - '0';
else
nc_error("ReadNumber: digit expected");
while (isdigit((int)(digit = getc(file))))
number = number * 10 + digit - '0';
ungetc(digit, file);
*result = vorz * number;
} |
void * ap_str_getmem(size_t param_1,long param_2)
{
void *pvVar1;
pvVar1 = malloc(param_1);
if (pvVar1 != (void *)0x0) {
return pvVar1;
}
if (param_2 != 0) {
ap_log_do_syslog(LOG_ERR,param_2);
}
/* WARNING: Subroutine does not return */
exit(1);
} | void *ap_str_getmem(int size, char *errmsg)
{
void *ptr;
ptr = malloc(size);
if ( ptr == NULL )
{
if (errmsg != NULL)
ap_log_do_syslog(LOG_ERR, errmsg);
exit(1);
}
return ptr;
} |
void VIRTUAL_model__MSignature__mparameters_61d(void)
{
model__MSignature__mparameters_61d();
return;
} | void VIRTUAL_model__MSignature__mparameters_61d(val* self, val* p0) {
model__MSignature__mparameters_61d(self, p0);
RET_LABEL:;
} |
void make_temp_dir(void)
{
uint uVar1;
undefined4 uVar2;
int iVar3;
time_t tVar4;
undefined4 extraout_var;
long in_FS_OFFSET;
int local_34;
char local_2e [14];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
tVar4 = time((time_t *)0x0);
uVar1 = getpid();
srand(uVar1 ^ (uint)tVar4);
for (local_34 = 0; local_34 < 1000; local_34 = local_34 + 1) {
uVar1 = rand();
sprintf(local_2e,"/tmp/%08x",(ulong)uVar1);
uVar2 = str_dup(root_dir);
temp_dir = str_concat(uVar2,local_2e);
iVar3 = mkdir((char *)(ulong)temp_dir,0x1ff);
if (CONCAT44(extraout_var,iVar3) == 0) goto LAB_001000c6;
free((void *)(ulong)temp_dir);
}
cmd_error("failed to create temporary directory.\n");
LAB_001000c6:
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
} | void make_temp_dir(void)
{
int rep;
srand((int)time(NULL) ^ (int)getpid());
for (rep = 0; rep < 1000; rep++) {
char randbuf[sizeof("/tmp/01234567")];
sprintf(randbuf, "/tmp/%08x", rand());
temp_dir = str_concat(str_dup(root_dir), randbuf);
if (mkdir(temp_dir, 0777) == 0) {
return;
}
free(temp_dir);
}
cmd_error("failed to create temporary directory.\n");
} |
void print_double_params(void)
{
printf("sign = %d\n",0);
printf("exponent = %d\n",(ulong)(uint)-IEEE754_DOUBLE_BIAS);
printf("fraction [hex] = %013llx\n",0);
return;
} | void print_double_params(const double x) {
IEEE754_double number = {.value = x};
printf("sign = %d\n", number.fields.sign);
printf("exponent = %d\n", number.fields.exp_bias - IEEE754_DOUBLE_BIAS);
printf("fraction [hex] = %013llx\n", number.fields.fraction);
} |
int fclose(FILE *__stream)
{
int iVar1;
fflush(__stream);
iVar1 = close(*(int *)&__stream->field_0x4);
free((void *)(ulong)(uint)__stream->_flags);
memset(__stream,0,8);
return iVar1;
} | int fclose(FILE *fp)
{
int ret;
fflush(fp);
ret = close(fp->fd);
free(fp->buf);
memset(fp, 0, sizeof(*fp));
return ret;
} |
undefined8 main(void)
{
undefined8 *puVar1;
int iVar2;
long in_FS_OFFSET;
int local_3c;
undefined4 local_38;
undefined4 local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
scanf("%d",&local_3c);
if (0 < local_3c) {
iVar2 = 0;
do {
iVar2 = iVar2 + 1;
scanf("%lld",&local_38);
scanf("%lld",&local_34);
prime(local_38,local_34);
puVar1 = (undefined8 *)malloc(0x10);
*puVar1 = 0;
puVar1[1] = 0;
*q = puVar1;
q = puVar1;
} while (iVar2 < local_3c);
}
printf("\n");
show();
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | main(){
int i,t;
L m,n;
scanf("%d",&t);
for(i=0;i<t;i++){
scanf("%lld",&m);
scanf("%lld",&n);
prime(m,n);
struct node *temp;
temp=(struct node*)malloc(sizeof(struct node));
temp->info=0;
temp->link=NULL;
q->link=temp;
q=temp;
}
printf("\n");
show();
return 0;
} |
undefined4 preliminary_check_icube_IB(long param_1,long param_2)
{
int iVar1;
undefined4 uVar2;
long *plVar3;
long lVar4;
long lVar5;
long *plVar6;
lVar5 = param_2 * 0x28;
q = lVar5 + *(long *)(network + param_1 * 8) + 0x20;
iVar1 = queue_len();
uVar2 = B_FALSE;
if (iVar1 != 0) {
plVar3 = (long *)head_queue(q);
ph = plVar3;
uVar2 = B_FALSE;
if ((*plVar3 == RR) || (*plVar3 == RR_TAIL)) {
plVar6 = (long *)(param_1 * 8 + network);
d_p = *(int *)(*plVar6 + lVar5);
if (d_p == -1) {
if (*(long *)(lVar5 + *plVar6 + 0x10) == LLONG_MAX) {
*(undefined8 *)(lVar5 + *plVar6 + 0x10) = sim_clock;
}
id = param_1;
curr_p = param_2;
lVar4 = check_rr(pkt_space + plVar3[1] * 4,&d_d,&d_w);
uVar2 = B_TRUE;
if (lVar4 != 0) {
lVar4 = *(long *)(network + param_1 * 8);
*(undefined8 *)(*(long *)(lVar4 + 0x18 + p_con * 0x28) + param_2 * 8) =
*(undefined8 *)(lVar4 + 0x10 + lVar5);
uVar2 = B_FALSE;
}
}
else if (*(long *)((long)d_p * 0x28 + *plVar6 + 8) != param_2) {
/* WARNING: Subroutine does not return */
panic("Output port should be reserved for me");
}
}
}
return uVar2;
} | bool_t preliminary_check_icube_IB (long i, port_type s_p) {
q = &(network[i].p[s_p].q);
if (!queue_len(q))
return B_FALSE;
ph = head_queue(q);
if ((ph->pclass != RR) && (ph->pclass != RR_TAIL))
return B_FALSE;
if ((d_p = network[i].p[s_p].aop) != (-1)) {
if (network[i].p[d_p].sip != s_p)
panic("Output port should be reserved for me");
return B_FALSE;
}
if (network[i].p[s_p].tor == LLONG_MAX)
network[i].p[s_p].tor = sim_clock;
id=i;
curr_p=s_p;
if (check_rr(&pkt_space[ph->packet], &d_d, &d_w)) {
network[i].p[p_con].req[s_p] = network[i].p[s_p].tor;
return B_FALSE;
}
return B_TRUE;
} |
void print_align_2_b2(char *param_1,undefined4 *param_2)
{
int iVar1;
iVar1 = sprintf(param_1,"size %d offset %d align %d value ",4,0,4);
print_b2(param_1 + iVar1,*param_2);
return;
} | int print_align_2_b2(char* buf, struct align_2_b2* p) { struct {char ch; struct align_2_b2 v;} s; int off = sprintf(buf, "size %d offset %d align %d value ", (int) sizeof(s.v), (int) (((char*) &p->v) - (char*) p), (int) (((char*) &s.v) - (char*) &s)); return print_b2(buf+off, p->v); } |
long uprv_uint16Comparator(undefined8 param_1,long *param_2,long *param_3)
{
return *param_2 - *param_3;
} | extern __attribute__((visibility("default"))) int32_t
uprv_uint16Comparator(const void *context, const void *left, const void *right) {
return (int32_t)*(const uint16_t *)left - (int32_t)*(const uint16_t *)right;
} |
void merge_a_z_j_u(void)
{
if (u < j) {
tq = u;
merge_a_z_j_v();
}
else {
tq = j;
merge_a_z_k_u();
}
return;
} | void merge_a_z_j_u()
{
if(j>u)
{
tq=u;
merge_a_z_j_v();
}
else
{
tq=j;
merge_a_z_k_u();
}
} |
void drawTriangle(void)
{
glClearColor(_LC0,_LC0,_LC0,_LC0);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(_LC1,_LC1,_LC1);
glOrtho(_LC2,_LC1,_LC2,_LC1,_LC2,_LC1);
glBegin(GL_TRIANGLES);
glVertex3f(_LC3,0,0);
glVertex3f(_LC4,0,0);
glVertex3f(0,0xffffffff,0);
glEnd();
glFlush();
return;
} | void drawTriangle()
{
glClearColor(0.4, 0.4, 0.4, 0.4);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
glBegin(GL_TRIANGLES);
glVertex3f(-0.7, 0.7, 0);
glVertex3f(0.7, 0.7, 0);
glVertex3f(0, -1, 0);
glEnd();
glFlush();
} |
void UCNV_TO_U_CALLBACK_SUBSTITUTE
(char *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4,long param_5,
undefined4 *param_6)
{
if ((param_5 <= UCNV_IRREGULAR) &&
((param_1 == (char *)0x0 || ((*param_1 == 'i' && (param_5 == UCNV_UNASSIGNED)))))) {
*param_6 = U_ZERO_ERROR;
ucnv_cbToUWriteSub(param_2,0,param_6);
}
return;
} | extern __attribute__((visibility("default"))) void
UCNV_TO_U_CALLBACK_SUBSTITUTE (
const void *context,
UConverterToUnicodeArgs *toArgs,
const char* codeUnits,
int32_t length,
UConverterCallbackReason reason,
UErrorCode * err)
{
if (reason <= UCNV_IRREGULAR)
{
if (context == ((void *)0) || (*((char*)context) == 'i' && reason == UCNV_UNASSIGNED))
{
*err = U_ZERO_ERROR;
ucnv_cbToUWriteSub(toArgs,0,err);
}
}
} |
void uart_flush_rx_fifo(void)
{
uint uVar1;
while( true ) {
uVar1 = GET32(0x20201018);
if ((uVar1 & 0x10) != 0) break;
GET32(0x20201000);
}
return;
} | void uart_flush_rx_fifo ( void )
{
while(1)
{
if(GET32((0x20201000 +0x18))&0x10) break;
GET32((0x20201000 +0x00));
}
} |
long get_sysroot(int param_1,long param_2)
{
long lVar1;
size_t sVar2;
long *plVar3;
if (1 < param_1) {
plVar3 = (long *)(param_2 + 8);
do {
lVar1 = CONST_STRNEQ(*plVar3,"--sysroot=");
if (lVar1 != 0) {
lVar1 = *plVar3;
sVar2 = strlen("--sysroot=");
return (int)sVar2 + lVar1;
}
plVar3 = plVar3 + 1;
} while (plVar3 != (long *)(param_2 + 0x10 + (ulong)(param_1 - 2) * 8));
}
lVar1 = get_relative_sysroot(BINDIR);
if (lVar1 != 0) {
return lVar1;
}
lVar1 = get_relative_sysroot(TOOLBINDIR);
if (lVar1 == 0) {
lVar1 = TARGET_SYSTEM_ROOT;
}
return lVar1;
} | const char *
get_sysroot (int argc, char **argv)
{
int i;
const char *path;
for (i = 1; i < argc; i++)
if (CONST_STRNEQ (argv[i], "--sysroot="))
return argv[i] + strlen ("--sysroot=");
path = get_relative_sysroot (BINDIR);
if (path)
return path;
path = get_relative_sysroot (TOOLBINDIR);
if (path)
return path;
return TARGET_SYSTEM_ROOT;
} |
void test(undefined4 param_1)
{
va_start(0,param_1);
dummy(0);
va_end(0);
va_start(0,param_1);
dummy(0);
va_end(0);
return;
} | void test (int fmt, ...)
{
ScanfState state, *statep;
statep = &state;
va_start (statep->ap, fmt);
dummy (statep->ap);
va_end (statep->ap);
va_start (state.ap, fmt);
dummy (state.ap);
va_end (state.ap);
return;
} |
void snd_korg1212_remove(void)
{
undefined4 uVar1;
uVar1 = pci_get_drvdata();
snd_card_free(uVar1);
return;
} | void snd_korg1212_remove(struct pci_dev *pci)
{
snd_card_free(pci_get_drvdata(pci));
} |
void Encrypt(long param_1,long param_2)
{
uint uVar1;
long lVar2;
long lVar3;
lVar2 = 0;
do {
uVar1 = READ_ROUND_KEY_BYTE(*(undefined4 *)(param_2 + lVar2));
*(uint *)(param_1 + lVar2) = *(uint *)(param_1 + lVar2) ^ uVar1;
lVar2 = lVar2 + 4;
} while (lVar2 != 0x40);
lVar2 = param_2 + 0x40;
do {
lVar3 = lVar2 + 0x40;
aes_enc_round(param_1,lVar2);
lVar2 = lVar3;
} while (lVar3 != param_2 + 0x280);
aes_enc_lastround(param_1,lVar3);
return;
} | void Encrypt(uint8_t *block, uint8_t *roundKeys)
{
uint8_t i;
for (i = 0; i < 16; ++i)
{
block[i] ^= READ_ROUND_KEY_BYTE(roundKeys[i]);
}
for (i = 1; i < 10; ++i)
{
aes_enc_round(block, roundKeys + 16 * i);
}
aes_enc_lastround(block, roundKeys + 16 * 10);
} |
void log_message(void)
{
return;
} | void log_message(const char *message) {
if ((sysl > 3) && (message != NULL)) {
}
} |
void usb_delay_ms(undefined8 param_1,undefined4 param_2)
{
mydelay(param_2);
return;
} | void usb_delay_ms(usbbus_t *bus,int ms)
{
mydelay(ms);
} |
float fmaxf(float __x,float __y)
{
n_float = n_float + 1;
return __x;
} | float (fmaxf)(float x, float y) { n_float++; } |
void dccsend_accepted(long *param_1)
{
net_hook(*(undefined4 *)(param_1 + 1),0,param_1,_dccsend_data,_dccsend_error);
if (*param_1 != 0) {
_dccsend_sendpacket(param_1);
}
return;
} | void dccsend_accepted(struct dccproxy *p) {
net_hook(p->sendee_sock, 0x00, (void *)p,
((void (*)(void *, int)) (_dccsend_data)),
((void (*)(void *, int, int)) (_dccsend_error)));
if (p->bufsz)
_dccsend_sendpacket(p);
} |
undefined4 restore_time(void)
{
undefined4 in_ECX;
if (warned_1956 != 0) {
warned_1956 = 1;
return in_ECX;
}
lafe_warnc(0,"Can\'t restore access times on this platform");
warned_1956 = 1;
return in_ECX;
} | int
restore_time(struct cpio *cpio, struct archive_entry *entry,
const char *name, int fd)
{
#ifndef HAVE_UTIMES
static int warned = 0;
(void)cpio; /* UNUSED */
(void)entry; /* UNUSED */
(void)name; /* UNUSED */
if (!warned)
lafe_warnc(0, "Can't restore access times on this platform");
warned = 1;
return (fd);
#else
#if defined(_WIN32) && !defined(__CYGWIN__)
struct __timeval times[2];
#else
struct timeval times[2];
#endif
if (!cpio->option_atime_restore)
return (fd);
times[1].tv_sec = archive_entry_mtime(entry);
times[1].tv_usec = archive_entry_mtime_nsec(entry) / 1000;
times[0].tv_sec = archive_entry_atime(entry);
times[0].tv_usec = archive_entry_atime_nsec(entry) / 1000;
#if defined(HAVE_FUTIMES) && !defined(__CYGWIN__)
if (fd >= 0 && futimes(fd, times) == 0)
return (fd);
#endif
/*
* Some platform cannot restore access times if the file descriptor
* is still opened.
*/
if (fd >= 0) {
close(fd);
fd = -1;
}
#ifdef HAVE_LUTIMES
if (lutimes(name, times) != 0)
#else
if ((AE_IFLNK != archive_entry_filetype(entry))
&& utimes(name, times) != 0)
#endif
lafe_warnc(errno, "Can't update time for %s", name);
#endif
return (fd);
} |
undefined8 SceneGetCamera(undefined8 *param_1)
{
return *param_1;
} | Camera* SceneGetCamera(Scene* self){
return self->camera;
} |
uint fc8050_i2c_dataread(ulong param_1,undefined2 param_2,undefined8 param_3,undefined2 param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
long in_FS_OFFSET;
undefined2 local_3c [5];
undefined local_31;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_31 = 1;
local_3c[0] = param_2;
uVar1 = i2c_bulkwrite(param_1,0,&local_31,1);
uVar2 = i2c_bulkwrite(param_1 & 0xffffffff,1,local_3c,2);
uVar3 = i2c_dataread(param_1 & 0xffffffff,2,param_3,param_4);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar3 | uVar1 | uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | int fc8050_i2c_dataread(HANDLE hDevice, unsigned short addr, unsigned char* data, unsigned short length)
{
int res;
unsigned char command = 0x01 | 0x00 | 0x00;
res = i2c_bulkwrite(hDevice, 0x0000, &command, 1);
res |= i2c_bulkwrite(hDevice, 0x0001, (unsigned char*)&addr, 2);
res |= i2c_dataread(hDevice, 0x0002, data, length);
return res;
} |
void unlock_wrapper(pthread_mutex_t *param_1)
{
int iVar1;
iVar1 = pthread_mutex_unlock(param_1);
assert(iVar1 == 0);
return;
} | void unlock_wrapper(pthread_mutex_t *lk) {
int rc = pthread_mutex_unlock(lk);
assert(rc == 0);
} |
void sc_flops_snap(undefined4 *param_1,undefined4 *param_2)
{
sc_flops_count();
*param_2 = *param_1;
return;
} | void
sc_flops_snap (sc_flopinfo_t * fi, sc_flopinfo_t * snapshot)
{
sc_flops_count (fi);
*snapshot = *fi;
} |
void _BIG5_mbsnrtowcs(void)
{
__mbsnrtowcs_std();
return;
} | size_t
_BIG5_mbsnrtowcs(wchar_t * __restrict dst, const char ** __restrict src,
size_t nms, size_t len, mbstate_t * __restrict ps)
{
return (__mbsnrtowcs_std(dst, src, nms, len, ps, _BIG5_mbrtowc));
} |
void emit_funcall(int *param_1,undefined8 *param_2,int param_3)
{
int iVar1;
undefined4 uVar2;
long lVar3;
iVar1 = emit_arguments(param_1);
if (param_3 == 0) {
x86_call_reg(param_1[6],*(undefined4 *)*param_2);
}
else {
uVar2 = JIT_BUFFER_OFFSET(param_1);
*(undefined4 *)(param_2 + 1) = uVar2;
lVar3 = JIT_GET_ADDR(param_1,*(undefined4 *)*param_2);
x86_call_imm(param_1[6],lVar3 + -4);
}
if ((long)iVar1 + *(long *)(param_1 + 4) != 0) {
x86_alu_reg_imm(param_1[6],X86_ADD,X86_ESP,*(long *)(param_1 + 4) + (long)iVar1);
}
JIT_FREE(param_1[2]);
iVar1 = emit_pop_caller_saved_regs(param_1,param_2);
*param_1 = *param_1 - iVar1;
return;
} | void emit_funcall(struct jit * jit, struct jit_op * op, int imm)
{
int stack_correction = emit_arguments(jit);
if (!imm) {
x86_call_reg(jit->ip, op->r_arg[0]);
} else {
op->patch_addr = JIT_BUFFER_OFFSET(jit);
x86_call_imm(jit->ip, JIT_GET_ADDR(jit, op->r_arg[0]) - 4);
}
if (jit->prepared_args.stack_size + stack_correction)
x86_alu_reg_imm(jit->ip, X86_ADD, X86_ESP, jit->prepared_args.stack_size + stack_correction);
JIT_FREE(jit->prepared_args.args);
jit->push_count -= emit_pop_caller_saved_regs(jit, op);
} |
int BlockCompare(int *param_1,int *param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
piVar1 = *(int **)(block_lines + (long)*param_1 * 8);
piVar2 = *(int **)(block_lines + (long)*param_2 * 8);
if (piVar1 == piVar2) {
return 0;
}
if (piVar1 == (int *)0x0) {
return -1;
}
if (piVar2 == (int *)0x0) {
return 1;
}
iVar3 = *piVar1;
if (iVar3 == *piVar2) {
if (piVar1[2] != piVar2[2]) {
return piVar1[2] - piVar2[2];
}
iVar3 = memcmp(piVar1 + 3,piVar2 + 3,(ulong)(uint)(iVar3 * 4));
return iVar3;
}
return iVar3 - *piVar2;
} | int BlockCompare(const void *p1, const void *p2)
{
int blk_num1 = ((const uint16_g *) p1)[0];
int blk_num2 = ((const uint16_g *) p2)[0];
const uint16_g *A = block_lines[blk_num1];
const uint16_g *B = block_lines[blk_num2];
if (A == B)
return 0;
if (A == NULL) return -1;
if (B == NULL) return +1;
if (A[0] != B[0])
{
return A[0] - B[0];
}
if (A[2] != B[2])
{
return A[2] - B[2];
}
return memcmp(A+3, B+3, A[0] * sizeof(uint16_g));
} |
undefined8 ht_adddup(void)
{
undefined8 uVar1;
int in_ECX;
if (0 < in_ECX) {
uVar1 = ht_newz();
return uVar1;
}
return 0xffffffff;
} | int ht_adddup(ht_tab *ht, const char *s, void *d, int d_size) {
if (d_size<=0) return -1;
return ht_newz(ht,s,d,d_size);
} |
undefined * s390_irgen_EFPC(undefined4 param_1)
{
undefined4 uVar1;
uVar1 = get_fpc_w0();
put_gpr_w1(param_1,uVar1);
return &_LC0;
} | const HChar *
s390_irgen_EFPC(UChar r1)
{
put_gpr_w1(r1, get_fpc_w0());
return "efpc";
} |
void Ft_Gpu_CoCmd_Memcpy(undefined8 param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4
)
{
Ft_Gpu_CoCmd_StartFunc(param_1,0x10);
Ft_Gpu_Copro_SendCmd(param_1,0xffffff1d);
Ft_Gpu_Copro_SendCmd(param_1,param_2);
Ft_Gpu_Copro_SendCmd(param_1,param_3);
Ft_Gpu_Copro_SendCmd(param_1,param_4);
Ft_Gpu_CoCmd_EndFunc(param_1,0x10);
return;
} | ft_void_t Ft_Gpu_CoCmd_Memcpy(Ft_Gpu_Hal_Context_t *phost,ft_uint32_t dest, ft_uint32_t src, ft_uint32_t num)
{
Ft_Gpu_CoCmd_StartFunc(phost,(4)*4);
Ft_Gpu_Copro_SendCmd(phost, 4294967069UL);
Ft_Gpu_Copro_SendCmd(phost, dest);
Ft_Gpu_Copro_SendCmd(phost, src);
Ft_Gpu_Copro_SendCmd(phost, num);
Ft_Gpu_CoCmd_EndFunc(phost,((4)*4));
} |
bool time_after(long *param_1,long *param_2,long *param_3)
{
bool bVar1;
bVar1 = true;
if ((*param_3 <= *param_2 + *param_1) && (bVar1 = false, *param_3 == *param_2 + *param_1)) {
return param_2[1] + param_1[1] < param_3[1];
}
return bVar1;
} | int time_after(struct timeval *last,
struct timeval *tout,
struct timeval *now)
{
if (now->tv_sec > last->tv_sec + tout->tv_sec)
return 1;
if (now->tv_sec == last->tv_sec + tout->tv_sec) {
if (now->tv_usec > last->tv_usec + tout->tv_usec)
return 1;
}
return 0;
} |
undefined8 tcp_rpcc_init_crypto(int *param_1)
{
byte *pbVar1;
long lVar2;
time_t tVar3;
uint *puVar4;
undefined8 uVar5;
pbVar1 = (byte *)TCP_RPC_DATA();
if ((*pbVar1 & 2) == 0) {
uVar5 = tcp_rpcc_init_fake_crypto(param_1);
}
else {
lVar2 = TCP_RPC_DATA(param_1);
tVar3 = time((time_t *)0x0);
*(int *)(lVar2 + 4) = (int)tVar3;
lVar2 = TCP_RPC_DATA(param_1);
aes_generate_nonce(*(undefined4 *)(lVar2 + 8));
memset(buf_1957,0,0x14);
lVar2 = TCP_RPC_DATA(param_1);
memcpy((void *)(ulong)(uint)buf_1957._16_4_,(void *)(ulong)*(uint *)(lVar2 + 8),0x10);
lVar2 = TCP_RPC_DATA(param_1);
buf_1957._12_4_ = *(undefined4 *)(lVar2 + 4);
buf_1957._8_4_ = RPC_NONCE;
buf_1957._4_4_ = get_crypto_key_id();
buf_1957._0_4_ = RPC_CRYPTO_AES;
tcp_rpc_conn_send_data(param_1,0x14,buf_1957);
puVar4 = (uint *)TCP_RPC_DATA(param_1);
assert((*puVar4 & 0xe) == 2);
puVar4 = (uint *)TCP_RPC_DATA(param_1);
*puVar4 = *puVar4 | 4;
assert(*param_1 == 0);
uVar5 = 1;
}
return uVar5;
} | int tcp_rpcc_init_crypto (struct connection *c) {
if (!(TCP_RPC_DATA(c)->crypto_flags & 2)) {
return tcp_rpcc_init_fake_crypto (c);
}
TCP_RPC_DATA(c)->nonce_time = time (0);
aes_generate_nonce (TCP_RPC_DATA(c)->nonce);
static struct tcp_rpc_nonce_packet buf;
memset (&buf, 0, sizeof (buf));
memcpy (buf.crypto_nonce, TCP_RPC_DATA(c)->nonce, 16);
buf.crypto_ts = TCP_RPC_DATA(c)->nonce_time;
buf.type = RPC_NONCE;
buf.key_select = get_crypto_key_id ();
buf.crypto_schema = RPC_CRYPTO_AES;
tcp_rpc_conn_send_data (c, sizeof (buf), &buf);
assert ((TCP_RPC_DATA(c)->crypto_flags & 14) == 2);
TCP_RPC_DATA(c)->crypto_flags |= 4;
assert (!c->crypto);
/* struct raw_message x;
assert (!c->out_p.total_bytes);
x = c->out_p;
c->out_p = c->out;
c->out = x;*/
return 1;
} |
void zm_printCallerRecursive
(undefined *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
{
long lVar1;
long in_FS_OFFSET;
undefined local_34 [4];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = zm_queueFindPop(param_3,param_4,zm_matchCaller);
if (param_1 == (undefined *)0x0) {
param_1 = local_34;
zm_initPrint(param_1,stdout,0);
}
zm_checkFoundCaller(param_2,param_3,param_4,lVar1);
if (lVar1 != 0) {
zm_addIndent(param_1,4);
zm_print(param_1,&_LC0);
zm_printStateCompact(param_1,lVar1);
zm_printCallerRecursive(param_1,param_2,param_3,lVar1);
zm_addIndent(param_1,0xfffffffc);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | void zm_printCallerRecursive(zm_Print *out, zm_VM *vm,
zm_StateQueue *qiter,
zm_State *state)
{
zm_State *caller = zm_queueFindPop(qiter, state, zm_matchCaller);
zm_Print defaultout; if (!out) { out = &defaultout; zm_initPrint(out, stdout, 0); };
zm_checkFoundCaller(vm, qiter, state, caller);
if (!caller)
return;
zm_addIndent(out, 4);
zm_print(out, " | \n");
zm_printStateCompact(out, caller);
zm_printCallerRecursive(out, vm, qiter, caller);
zm_addIndent(out, -4);
} |
void vmci_transport_notify_recv_init(undefined8 param_1,undefined8 param_2,undefined8 param_3)
{
undefined8 *puVar1;
puVar1 = (undefined8 *)vmci_trans();
/* WARNING: Could not recover jumptable at 0x0010002b. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)*puVar1)(param_1,param_2,param_3);
return;
} | int vmci_transport_notify_recv_init(
struct vsock_sock *vsk,
size_t target,
struct vsock_transport_recv_notify_data *data)
{
return vmci_trans(vsk)->notify_ops->recv_init(
&vsk->sk, target,
(struct vmci_transport_recv_notify_data *)data);
} |
void data_segment_gdata(void)
{
output_line("\t.area SMALLC_GENERATED_DATA (REL,CON,DSEG)");
return;
} | void data_segment_gdata(void) {
output_line ("\t.area SMALLC_GENERATED_DATA (REL,CON,DSEG)");
} |
uint L_Servo_ClearInterrupt(void)
{
_DAT_40040110 = _DAT_40040110 & 1;
return _DAT_40040110;
} | uint8 L_Servo_ClearInterrupt(void)
{
uint8 maskedStatus = (uint8)((* (reg32 *) 0x40040110u) & 0x01u);
(* (reg32 *) 0x40040110u) = maskedStatus;
return maskedStatus >> 0;
} |
undefined8 vidioc_g_input(undefined8 param_1,undefined8 *param_2,undefined4 *param_3)
{
*param_3 = **(undefined4 **)*param_2;
DEB_EE();
return 0;
} | int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
{
struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
struct mxb *mxb = (struct mxb *)dev->ext_priv;
*i = mxb->cur_input;
DEB_EE(("VIDIOC_G_INPUT %d.\n", *i));
return 0;
} |
void DestroySubgraph(int **param_1)
{
void *__ptr;
int *piVar1;
long lVar2;
long lVar3;
void *__ptr_00;
piVar1 = *param_1;
if (piVar1 == (int *)0x0) {
return;
}
__ptr_00 = *(void **)(piVar1 + 4);
if (0 < *piVar1) {
lVar3 = 0;
do {
while( true ) {
lVar2 = lVar3 * 0x28;
__ptr = *(void **)((long)__ptr_00 + lVar2 + 0x20);
if (__ptr != (void *)0x0) {
free(__ptr);
piVar1 = *param_1;
__ptr_00 = *(void **)(piVar1 + 4);
}
if (*(long *)((long)__ptr_00 + lVar2 + 0x18) == 0) break;
lVar3 = lVar3 + 1;
DestroySet((long)__ptr_00 + lVar2 + 0x18);
piVar1 = *param_1;
__ptr_00 = *(void **)(piVar1 + 4);
if (*piVar1 <= (int)lVar3) goto LAB_0010006e;
}
lVar3 = lVar3 + 1;
} while ((int)lVar3 < *piVar1);
}
LAB_0010006e:
free(__ptr_00);
free(*(void **)(*param_1 + 2));
free(*param_1);
*param_1 = (int *)0x0;
return;
} | void DestroySubgraph(Subgraph **sg){
int i;
if ((*sg)!=NULL)
{
for (i=0; i < (*sg)->nnodes; i++)
{
if ((*sg)->node[i].feat != NULL)
free((*sg)->node[i].feat);
if ((*sg)->node[i].adj != NULL)
DestroySet(&(*sg)->node[i].adj);
}
free((*sg)->node);
free((*sg)->ordered_list_of_nodes);
free((*sg));
*sg = NULL;
}
} |
undefined4 ngx_rtmp_mp4_postconfiguration(undefined4 *param_1)
{
undefined8 uVar1;
undefined8 *puVar2;
undefined4 *puVar3;
uVar1 = ngx_rtmp_conf_get_module_main_conf(param_1,ngx_rtmp_play_module);
puVar2 = (undefined8 *)ngx_array_push(uVar1);
if (puVar2 != (undefined8 *)0x0) {
puVar3 = (undefined4 *)ngx_pcalloc(*param_1,0x24);
if (puVar3 != (undefined4 *)0x0) {
*puVar2 = puVar3;
ngx_str_set(puVar3 + 8,"mp4-format");
ngx_str_set(puVar3 + 7,&_LC1);
ngx_str_set(puVar3 + 6,&_LC2);
puVar3[5] = ngx_rtmp_mp4_init;
puVar3[4] = ngx_rtmp_mp4_done;
puVar3[3] = ngx_rtmp_mp4_seek;
puVar3[2] = ngx_rtmp_mp4_start;
puVar3[1] = ngx_rtmp_mp4_stop;
*puVar3 = ngx_rtmp_mp4_send;
return NGX_OK;
}
}
return NGX_ERROR;
} | ngx_int_t
ngx_rtmp_mp4_postconfiguration(ngx_conf_t *cf)
{
ngx_rtmp_play_main_conf_t *pmcf;
ngx_rtmp_play_fmt_t **pfmt, *fmt;
pmcf = ngx_rtmp_conf_get_module_main_conf(cf, ngx_rtmp_play_module);
pfmt = ngx_array_push(&pmcf->fmts);
if (pfmt == NULL) {
return NGX_ERROR;
}
fmt = ngx_pcalloc(cf->pool, sizeof(ngx_rtmp_play_fmt_t));
if (fmt == NULL) {
return NGX_ERROR;
}
*pfmt = fmt;
ngx_str_set(&fmt->name, "mp4-format");
ngx_str_set(&fmt->pfx, "mp4:");
ngx_str_set(&fmt->sfx, ".mp4");
fmt->init = ngx_rtmp_mp4_init;
fmt->done = ngx_rtmp_mp4_done;
fmt->seek = ngx_rtmp_mp4_seek;
fmt->start = ngx_rtmp_mp4_start;
fmt->stop = ngx_rtmp_mp4_stop;
fmt->send = ngx_rtmp_mp4_send;
return NGX_OK;
} |
char * convert(char *param_1)
{
int iVar1;
char *__dest;
char *pcVar2;
__dest = (char *)malloc(9);
pcVar2 = (char *)malloc(3);
strncpy(__dest,param_1,8);
strncpy(pcVar2,param_1,2);
iVar1 = atoi(pcVar2);
free(pcVar2);
if ((param_1[8] == 'A') && (iVar1 == 0xc)) {
*__dest = '0';
__dest[1] = '0';
}
else if ((param_1[8] == 'P') && (iVar1 != 0xc)) {
pcVar2 = (char *)malloc(3);
sprintf(pcVar2,"%d",(ulong)(iVar1 + 0xc));
*__dest = *pcVar2;
__dest[1] = pcVar2[1];
free(pcVar2);
}
return __dest;
} | char* convert(char *hour)
{
int h;
char t;
char *nh, *ch;
nh = malloc(8 * sizeof(char) + 1);
ch = malloc(2 * sizeof(char) + 1);
strncpy(nh, hour, 8);
strncpy(ch, hour, 2);
h = atoi(ch);
free(ch);
t = hour[8];
if (t == 'A' && h == 12) {
nh[0] = '0';
nh[1] = '0';
}
else if (t == 'P' && h != 12) {
char *nc;
nc = malloc(2 * sizeof(char) + 1);
h += 12;
sprintf(nc, "%d", h);
nh[0] = nc[0];
nh[1] = nc[1];
free(nc);
}
return nh;
} |
undefined8 dd2(undefined8 param_1,double param_2,undefined8 param_3,int param_4)
{
int iVar1;
int extraout_EAX;
undefined4 *puVar2;
long in_FS_OFFSET;
double __x;
undefined8 uVar3;
long local_48;
long local_40;
undefined4 *local_38;
int local_30;
int local_2c;
int local_28;
int local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
puVar2 = (undefined4 *)GFS_DOMAIN(_sim);
local_38 = (undefined4 *)gfs_variable_from_name(*puVar2,param_3);
uVar3 = DAT_001001a0;
if (local_38 != (undefined4 *)0x0) {
g_return_val_if_fail(_cell != 0,0);
local_48 = ftt_cell_face(_cell,param_4 * 2);
local_40 = ftt_cell_face(_cell,param_4 * 2 + 1);
uVar3 = DAT_001001a0;
if ((local_48 != 0) && (local_40 != 0)) {
gfs_face_gradient(&local_48,&local_30,*local_38,0xffffffff);
gfs_face_gradient(&local_40,&local_28,*local_38,0xffffffff);
iVar1 = GFS_VALUE(_cell,local_38);
__x = (double)ftt_cell_size(_cell);
pow(__x,param_2);
uVar3 = gfs_dimensional_value
(local_38,(long)((local_30 + local_28) - iVar1 * (local_2c + local_24)) /
(long)extraout_EAX & 0xffffffff);
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | double dd2 (const gchar * name, FttComponent c) {
GfsVariable * v = gfs_variable_from_name (GFS_DOMAIN (_sim)->variables, name);
if (v == NULL)
return 0.;
g_return_val_if_fail (_cell != NULL, 0.);
FttCellFace f1 = ftt_cell_face (_cell, 2*c);
FttCellFace f2 = ftt_cell_face (_cell, 2*c + 1);
if (f1.neighbor && f2.neighbor) {
GfsGradient g1, g2;
gfs_face_gradient (&f1, &g1, v->i, -1);
gfs_face_gradient (&f2, &g2, v->i, -1);
return gfs_dimensional_value (v, (g1.b + g2.b - (g1.a + g2.a)*GFS_VALUE (_cell, v))
/pow (_sim->physical_params.L*ftt_cell_size (_cell), 2.));
}
return 0.;
} |
int vfio_register_iommu_notifier(undefined8 *param_1,undefined8 param_2,undefined8 param_3)
{
undefined4 *puVar1;
long **pplVar2;
int iVar3;
long lVar4;
int iVar5;
bool bVar6;
iVar3 = vfio_group_add_container_user();
iVar5 = -EINVAL;
if (iVar3 == 0) {
puVar1 = (undefined4 *)*param_1;
bVar6 = false;
pplVar2 = *(long ***)(puVar1 + 2);
if (pplVar2 != (long **)0x0) {
bVar6 = **pplVar2 != 0;
}
lVar4 = likely(bVar6);
if (lVar4 == 0) {
iVar5 = -ENOTTY;
}
else {
iVar5 = (*(code *)**pplVar2)(*puVar1,param_2,param_3);
}
vfio_group_try_dissolve_container(param_1);
}
return iVar5;
} | int vfio_register_iommu_notifier(struct vfio_group *group,
unsigned long *events,
struct notifier_block *nb)
{
struct vfio_container *container;
struct vfio_iommu_driver *driver;
int ret;
ret = vfio_group_add_container_user(group);
if (ret)
return -EINVAL;
container = group->container;
driver = container->iommu_driver;
if (likely(driver && driver->ops->register_notifier))
ret = driver->ops->register_notifier(container->iommu_data,
events, nb);
else
ret = -ENOTTY;
vfio_group_try_dissolve_container(group);
return ret;
} |
void dictSliceHash(undefined8 *param_1)
{
dictGenHashFunction(*(undefined4 *)(param_1 + 1),*param_1);
return;
} | unsigned int dictSliceHash(const void *key) {
const struct slice *s = key;
return dictGenHashFunction(s->data, (int)s->len);
} |
void freed_request(long *param_1,uint param_2)
{
uint uVar1;
int *piVar2;
long lVar3;
uVar1 = rw_is_sync(param_2);
piVar2 = (int *)(param_1[2] + (long)(int)uVar1 * 4);
*piVar2 = *piVar2 + -1;
if ((REQ_ELVPRIV & param_2) != 0) {
*(int *)(param_1 + 1) = *(int *)(param_1 + 1) + -1;
}
__freed_request(param_1,uVar1);
lVar3 = unlikely(*(undefined4 *)(*param_1 + (long)(int)(uVar1 ^ 1) * 4));
if (lVar3 != 0) {
__freed_request(param_1,uVar1 ^ 1);
}
return;
} | void freed_request(struct request_queue *q, unsigned int flags)
{
struct request_list *rl = &q->rq;
int sync = rw_is_sync(flags);
rl->count[sync]--;
if (flags & REQ_ELVPRIV)
rl->elvpriv--;
__freed_request(q, sync);
if (unlikely(rl->starved[sync ^ 1]))
__freed_request(q, sync ^ 1);
} |
void in6_lltable_delete_entry(undefined8 param_1,uint *param_2)
{
*param_2 = *param_2 | LLE_DELETED;
EVENTHANDLER_INVOKE(0,lle_event,param_2,LLENTRY_DELETED);
llentry_free(param_2);
return;
} | void
in6_lltable_delete_entry(struct lltable *llt, struct llentry *lle)
{
#pragma unused(llt)
lle->la_flags |= LLE_DELETED;
EVENTHANDLER_INVOKE(NULL, lle_event, lle, LLENTRY_DELETED);
#ifdef DIAGNOSTIC
log(LOG_INFO, "ifaddr cache = %p is deleted\n", lle);
#endif
llentry_free(lle);
} |
void mark_free(ulong param_1,long param_2)
{
long in_FS_OFFSET;
ulong local_28;
ulong local_20;
long local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = param_1;
if (map_debug != 0) {
printf("mark_free range=(%p-%p) len=%zu\n",param_1,param_2 + param_1,param_2);
}
for (; local_20 < param_2 + param_1; local_20 = local_20 + PAGE_SIZE) {
reify_bmap(local_20);
local_18 = level_bmap(1,local_20,&local_28);
*(byte *)(local_18 + (local_28 >> 3)) =
*(byte *)(local_18 + (local_28 >> 3)) & ~(byte)(1 << ((byte)local_28 & 7));
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} | void mark_free(uintptr_t start_of_range, size_t len)
{
if (map_debug) {
printf("mark_free range=(%p-%p) len=%zu\n",
(void*)start_of_range, (void*)(start_of_range + len), len);
}
for (uintptr_t addr = start_of_range; addr < start_of_range + len; addr += PAGE_SIZE) {
reify_bmap((char*)addr);
uintptr_t offset;
char *bmap = (char*)level_bmap(1, addr, &offset);
bmap[offset >> 3] &= ~(1 << (offset & 7));
}
} |
void wakeup(undefined8 param_1)
{
acquire(&ptable);
wakeup1(param_1);
release(&ptable);
return;
} | void
wakeup (void *chan)
{
acquire (&ptable.lock);
wakeup1 (chan);
release (&ptable.lock);
} |
int prio_enqueue(undefined8 param_1,int *param_2)
{
int iVar1;
undefined8 uVar2;
long lVar3;
long in_FS_OFFSET;
int local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = prio_classify(param_1,param_2,&local_24);
local_24 = qdisc_enqueue(param_1,uVar2);
if (local_24 == NET_XMIT_SUCCESS) {
iVar1 = qdisc_pkt_len(param_1);
param_2[3] = param_2[3] + iVar1;
param_2[2] = param_2[2] + 1;
param_2[1] = param_2[1] + 1;
iVar1 = NET_XMIT_SUCCESS;
}
else {
lVar3 = net_xmit_drop_count(local_24);
iVar1 = local_24;
if (lVar3 != 0) {
*param_2 = *param_2 + 1;
}
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar1;
} | int
prio_enqueue(struct sk_buff *skb, struct Qdisc *sch)
{
struct Qdisc *qdisc;
int ret;
qdisc = prio_classify(skb, sch, &ret);
#ifdef CONFIG_NET_CLS_ACT
if (qdisc == NULL) {
if (ret & __NET_XMIT_BYPASS)
sch->qstats.drops++;
kfree_skb(skb);
return ret;
}
#endif
ret = qdisc_enqueue(skb, qdisc);
if (ret == NET_XMIT_SUCCESS) {
sch->bstats.bytes += qdisc_pkt_len(skb);
sch->bstats.packets++;
sch->q.qlen++;
return NET_XMIT_SUCCESS;
}
if (net_xmit_drop_count(ret))
sch->qstats.drops++;
return ret;
} |
int simple_dvb_calc_regs(long *param_1,undefined4 *param_2,undefined4 *param_3,int param_4)
{
undefined4 *puVar1;
int iVar2;
undefined4 uVar3;
long lVar4;
puVar1 = (undefined4 *)param_1[1];
if (param_4 < 5) {
iVar2 = -EINVAL;
}
else {
lVar4 = simple_dvb_configure(param_1,param_3 + 1,param_2);
if (lVar4 == 0) {
iVar2 = -EINVAL;
}
else {
*param_3 = puVar1[4];
*(long *)(puVar1 + 2) = lVar4;
if (*param_1 == FE_OFDM) {
uVar3 = *param_2;
}
else {
uVar3 = 0;
}
*puVar1 = uVar3;
iVar2 = 5;
}
}
return iVar2;
} | int simple_dvb_calc_regs(struct dvb_frontend *fe,
struct dvb_frontend_parameters *params,
u8 *buf, int buf_len)
{
struct tuner_simple_priv *priv = fe->tuner_priv;
u32 frequency;
if (buf_len < 5)
return -EINVAL;
frequency = simple_dvb_configure(fe, buf+1, params);
if (frequency == 0)
return -EINVAL;
buf[0] = priv->i2c_props.addr;
priv->frequency = frequency;
priv->bandwidth = (fe->ops.info.type == FE_OFDM) ?
params->u.ofdm.bandwidth : 0;
return 5;
} |
void printformula(int *param_1)
{
int *piVar1;
int iVar2;
uint uVar3;
uVar3 = length();
if (-1 < (int)uVar3) {
piVar1 = param_1 + (ulong)uVar3 + 1;
do {
iVar2 = *param_1;
if (iVar2 == 0x82) {
putchar(0x29);
}
else if (iVar2 < 0x83) {
if (iVar2 == 0x80) {
printf("OR(");
}
else {
if (iVar2 != 0x81) goto LAB_00100094;
putchar(0x2e);
}
}
else if (iVar2 == 0x83) {
printf("AND(");
}
else {
LAB_00100094:
printf("%d,");
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
putchar(10);
return;
} | void printformula(int *formula)
{
int j;
int n = length(formula);
for(j = 0; j <= n; j++) {
switch(formula[j]) {
case OP_AND:
printf("AND(");
break;
case OP_OR:
printf("OR(");
break;
case OP_CLOSE:
printf(")");
break;
case OP_FIN:
printf(".");
break;
default:
printf("%d,", formula[j]);
}
}
printf("\n");
} |
undefined8 * MAP_Last(undefined8 *param_1)
{
undefined8 *puVar1;
if ((param_1 != &map_sentinel) && (param_1 != (undefined8 *)0x0)) {
do {
puVar1 = param_1;
param_1 = (undefined8 *)*puVar1;
} while (param_1 != &map_sentinel);
return puVar1;
}
return (undefined8 *)0x0;
} | MAP* MAP_Last (MAP *root)
{
if (root == NULL || root == &map_sentinel)
return NULL;
while (root->r != &map_sentinel) root = root->r;
return root;
} |
char ** splitAtChar(char param_1,char *param_2)
{
int iVar1;
char **ppcVar2;
char *__s;
size_t sVar3;
char *__dest;
uint uVar4;
long lVar5;
char **ppcVar6;
int iVar7;
char *__s_00;
iVar1 = charCount((int)param_1);
ppcVar2 = (char **)malloc((ulong)(iVar1 * 8 + 1));
if (ppcVar2 == (char **)0x0) {
Error("splitAtChar","Memory allocation error.");
}
lVar5 = 0;
__s = strdup(param_2);
while( true ) {
sVar3 = strlen(__s);
if ((int)sVar3 <= (int)lVar5) break;
if (__s[lVar5] == param_1) {
__s[lVar5] = '\0';
}
lVar5 = lVar5 + 1;
}
iVar7 = 0;
ppcVar6 = ppcVar2;
__s_00 = __s;
do {
iVar7 = iVar7 + 1;
sVar3 = strlen(__s_00);
uVar4 = (int)sVar3 + 1;
__dest = (char *)malloc((ulong)uVar4);
*ppcVar6 = __dest;
strcpy(__dest,__s_00);
ppcVar6 = ppcVar6 + 1;
__s_00 = __s_00 + (int)uVar4;
} while (iVar7 <= iVar1);
free(__s);
return ppcVar2;
} | char ** splitAtChar(char c, char * s) {
int k = charCount(c,s);
char ** result = (char **) malloc(sizeof(char *) * k+1);
if (result == NULL) {
Error("splitAtChar", "Memory allocation error.");
}
char * tmp = strdup(s);
char * tmp2 = tmp;
int i;
for (i = 0; i < strlen(tmp); i++)
if (tmp[i] == c) tmp[i] = 0;
i = 0;
do {
int l = strlen(tmp)+1;
result[i] = (char *) malloc(sizeof(char) * l);
strcpy(result[i], tmp);
tmp += l;
i++;
} while (i < k+1);
free(tmp2);
return result;
} |
void MakeCtString(undefined8 param_1,undefined4 param_2,undefined4 param_3,long param_4,
undefined4 param_5,undefined8 param_6,undefined4 param_7,uint param_8,
undefined8 param_9)
{
if ((param_4 == 0) || ((param_8 & 1) == 0)) {
MakeCtStringOld(param_1,param_2,param_3,param_6,param_7,param_8,param_9);
}
else {
MakeCtStringNew(param_1,param_2,param_3,param_4,param_5,param_6,param_7,param_8,param_9);
}
return;
} | int MakeCtString( AT_NUMB *LinearCT, int nLenCT, int bAddDelim,
S_CHAR *nNum_H, int num_atoms,
char *szLinearCT, int nLen_szLinearCT, int nCtMode, int *bOverflow)
{
if ( !nNum_H || !(nCtMode & 1) ) {
return MakeCtStringOld( LinearCT, nLenCT, bAddDelim,
szLinearCT, nLen_szLinearCT, nCtMode, bOverflow);
} else {
return MakeCtStringNew( LinearCT, nLenCT, bAddDelim,
nNum_H, num_atoms,
szLinearCT, nLen_szLinearCT, nCtMode, bOverflow);
}
} |
int fputs(char *__s,FILE *__stream)
{
char cVar1;
char *pcVar2;
cVar1 = *__s;
pcVar2 = __s;
if (cVar1 == '\0') {
return 0;
}
do {
pcVar2 = pcVar2 + 1;
fputc((int)cVar1,__stream);
cVar1 = *pcVar2;
} while (cVar1 != '\0');
return (int)pcVar2 - (int)__s;
} | int fputs(const char *str, FILE *file)
{
const char *c;
for (c = str; *c; c++)
fputc(*c, file);
return c - str;
} |
uint ByteUpdateCrc(int param_1,uint param_2)
{
param_2 = param_2 ^ param_1 >> 8;
param_2 = (int)param_2 >> 4 ^ param_2;
return param_1 << 8 ^ param_2 ^ param_2 << 0xc ^ param_2 << 5;
} | uint16_t ByteUpdateCrc(uint16_t crc, uint8_t data) {
uint16_t x = (crc >> 8) ^ data;
x ^= x >> 4;
crc = (crc << 8) ^ (x << 12) ^ (x <<5) ^ x;
return crc;
} |
undefined8 t1(void)
{
int iVar1;
iVar1 = atomic_load_explicit(vars + 4,memory_order_seq_cst);
atomic_store_explicit(vars,1,memory_order_seq_cst);
atomic_store_explicit(&atom_1_r2_1,iVar1 == 1,memory_order_seq_cst);
return 0;
} | void *t1(void *arg){
label_2:;
int v2_r2 = atomic_load_explicit(&vars[1], memory_order_seq_cst);
atomic_store_explicit(&vars[0], 1, memory_order_seq_cst);
int v7 = (v2_r2 == 1);
atomic_store_explicit(&atom_1_r2_1, v7, memory_order_seq_cst);
return NULL;
} |
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(param_1);
}
else {
target_laser_off(param_1);
}
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 CheckGamma22TableWord(void)
{
CheckGammaWordTable(_LC0);
return;
} | cmsInt32Number CheckGamma22TableWord(void)
{
return CheckGammaWordTable(2.2);
} |
void dwc3_debugfs_create_endpoint_files(undefined8 param_1,undefined8 param_2)
{
int iVar1;
undefined8 *puVar2;
long lVar3;
lVar3 = 0;
while( true ) {
iVar1 = ARRAY_SIZE(dwc3_ep_file_map);
if (iVar1 <= (int)lVar3) break;
puVar2 = (undefined8 *)(lVar3 * 0x10 + dwc3_ep_file_map);
debugfs_create_file(*puVar2,S_IRUGO,param_2,param_1,puVar2[1]);
lVar3 = lVar3 + 1;
}
return;
} | void dwc3_debugfs_create_endpoint_files(struct dwc3_ep *dep,
struct dentry *parent)
{
int i;
for (i = 0; i < ARRAY_SIZE(dwc3_ep_file_map); i++) {
const struct file_operations *fops = dwc3_ep_file_map[i].fops;
const char *name = dwc3_ep_file_map[i].name;
debugfs_create_file(name, S_IRUGO, parent, dep, fops);
}
} |
undefined8 DIDiskImageGetUniqueIDDict(void)
{
if (verbose == 0) {
return 0;
}
puts("STUB: DIDiskImageGetUniqueIDDict called");
return 0;
} | void* DIDiskImageGetUniqueIDDict(void) { if (verbose) puts("STUB: DIDiskImageGetUniqueIDDict called"); return NULL; } |
undefined8 main(void)
{
__pid_t _Var1;
uint uVar2;
uint uVar3;
int extraout_var;
int iVar5;
int extraout_var_00;
uint uVar6;
int iVar7;
long lVar4;
iVar7 = 2;
uVar6 = 0x14;
puts("in main function");
_Var1 = fork();
lVar4 = CONCAT44(extraout_var,_Var1);
iVar5 = extraout_var;
while( true ) {
if (iVar5 < 0) {
perror("can not fork");
/* WARNING: Subroutine does not return */
exit(errno);
}
if (lVar4 == 0) {
g_num = g_num + 1;
uVar6 = uVar6 + 1;
}
printf("var: g_num = %d, num = %d\n",(ulong)g_num,(ulong)uVar6);
uVar2 = getpid();
uVar3 = getppid();
printf("ppid = %d, pid = %d\n",(ulong)uVar3,(ulong)uVar2);
if (iVar7 == 1) break;
iVar7 = 1;
_Var1 = fork();
lVar4 = CONCAT44(extraout_var_00,_Var1);
iVar5 = extraout_var_00;
}
return 0;
} | int main(void)
{
int num = 20;
printf("in main function\n");
pid_t pid;
int i = 0;
for (i = 0; i < 2; i++) {
if ((pid = fork()) < 0) {
perror("can not fork");
exit(errno);
} else if (pid == 0) {
g_num++;
num++;
} else {
;
}
printf("var: g_num = %d, num = %d\n", g_num, num);
printf("ppid = %d, pid = %d\n", getppid(), getpid());
}
return 0;
} |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 118