instruction
stringlengths
27
1.88k
output
stringlengths
21
2.78k
void common_hrtimer_try_to_cancel(void) { hrtimer_try_to_cancel(); return; }
int common_hrtimer_try_to_cancel(struct k_itimer *timr) { return hrtimer_try_to_cancel(&timr->it.real.timer); }
void speedTransition(int param_1,int param_2) { int local_10; if (param_1 < param_2) { local_10 = 0; while (local_10 < param_2 - param_1) { local_10 = local_10 + 1; wait1Msec(10); } } else if (param_2 < param_1) { local_10 = param_1 - param_2; while (0 < local_10) { local_10 = local_10 + -1; wait1Msec(10); } } return; }
void speedTransition(int currentSpeed, int newSpeed, int motorPow) { int diff; int diffProg; if (newSpeed > currentSpeed) { diff = newSpeed - currentSpeed; diffProg = 0; while (diffProg < diff) { currentSpeed+=1; diffProg+=1; motorPow=currentSpeed; wait1Msec(10); } } else if (newSpeed < currentSpeed) { diff = currentSpeed - newSpeed; diffProg = diff; while (diffProg > 0) { currentSpeed-=1; diffProg-=1; motorPow = currentSpeed; wait1Msec(10); } } }
void view_adjust(int param_1) { int iVar1; iVar1 = viewleft + param_1; if (iVar1 < 0) { param_1 = -viewleft; iVar1 = 0; } cursorx = cursorx - param_1; viewleft = iVar1; async_dirty = 1; cursorvalid = 0; return; }
void view_adjust(int shift) { if (viewleft + shift < 0) shift = -viewleft; cursorx -= shift; viewleft += shift; async_dirty = 1; cursorvalid = 0; }
undefined8 kv_parse(undefined8 param_1,char *param_2) { char cVar1; char *pcVar2; long lVar3; char *local_20 [2]; local_20[0] = param_2; do { while( true ) { cVar1 = *local_20[0]; if ((cVar1 == '\t') || (cVar1 == ' ')) { pcVar2 = local_20[0] + 1; do { do { local_20[0] = pcVar2; cVar1 = *local_20[0]; pcVar2 = local_20[0] + 1; } while (cVar1 == ' '); } while (cVar1 == '\t'); } if (cVar1 == '\0') { return 0; } if (cVar1 != '[') break; lVar3 = kv_parse_group(param_1,local_20); if (lVar3 != 0) { return 0xffffffff; } } if ((cVar1 == '#') || (cVar1 == '\n')) { lVar3 = kv_parse_comment(); } else { lVar3 = kv_parse_key(); if (lVar3 != 0) { return 0xffffffff; } lVar3 = kv_parse_val(param_1,local_20); } } while (lVar3 == 0); return 0xffffffff; }
int kv_parse(struct kv_parser *parser, const char *buf) { struct kv_str group; for (;;) { while (*buf == ' ' || *buf == '\t') ++buf; if (*buf == 0) { return 0; } else if (*buf == '[') { if (kv_parse_group(parser, &buf) != 0) return -1; } else if (*buf == '#' || *buf == '\n') { if (kv_parse_comment(parser, &buf) != 0) return -1; } else { if (kv_parse_key(parser, &buf) != 0) return -1; if (kv_parse_val(parser, &buf) != 0) return -1; } } }
undefined8 cvmx_pcie_get_mem_base_address(void) { return 0; }
uint64_t cvmx_pcie_get_mem_base_address(int pcie_port) { cvmx_pcie_address_t pcie_addr; pcie_addr.u64 = 0; pcie_addr.mem.upper = 0; pcie_addr.mem.io = 1; pcie_addr.mem.did = 3; pcie_addr.mem.subdid = 3 + pcie_port; return pcie_addr.u64; }
void SetMagicPolicyExt(int param_1,int param_2) { undefined4 uVar1; undefined4 uVar2; undefined4 uVar3; undefined4 uVar4; uVar1 = In_Video_Reg(0xf7); uVar2 = In_Video_Reg(0xfa); Out_Video_Reg(0xf7,0); if (param_2 == 1) { uVar4 = 0xffffffdf; uVar3 = 0x20; } else if (param_2 == 2) { uVar4 = 0xffffffbf; uVar3 = 0x40; } else { uVar4 = 0xffffffef; if (param_2 == 3) { uVar4 = 0xffffff7f; } uVar3 = 0x10; if (param_2 == 3) { uVar3 = 0x80; } } Out_Video_Reg(0xfa,0x48); if (param_1 == 1) { Out_SEQ_Reg_M(0x4c,uVar3,uVar4); } else { Out_SEQ_Reg_M(0x4c,0,uVar4); } Out_Video_Reg(0xf7,uVar1); Out_Video_Reg(0xfa,uVar2); return; }
void SetMagicPolicyExt(u16 wMatch, u8 bWhichWindow) { u8 bData; u8 b3CE_F7, b3CE_FA; b3CE_F7 = In_Video_Reg( 0xF7 ); b3CE_FA = In_Video_Reg( 0xFA ); Out_Video_Reg( 0xF7, 0x00 ); bData = 0x10; if ( bWhichWindow == 1 ) { bData <<= 1; } else if ( bWhichWindow == 2 ) { bData <<= 2; } else if ( bWhichWindow == 3 ) { bData <<= 3; } Out_Video_Reg( 0xFA, 0x48 ); if ( wMatch == 1 ) { Out_SEQ_Reg_M( 0x4C, bData, ~bData ); } else { Out_SEQ_Reg_M( 0x4C, 0x00, ~bData ); } Out_Video_Reg( 0xF7, b3CE_F7 ); Out_Video_Reg( 0xFA, b3CE_FA ); }
void * ft_strdup(char *param_1) { int iVar1; void *pvVar2; char cVar3; long lVar4; iVar1 = ft_strlen(); pvVar2 = malloc((ulong)(iVar1 + 1)); if (pvVar2 == (void *)0x0) { pvVar2 = (void *)0x0; } else { cVar3 = *param_1; if (cVar3 == '\0') { lVar4 = 0; } else { lVar4 = 0; do { *(char *)((long)pvVar2 + lVar4) = cVar3; lVar4 = lVar4 + 1; cVar3 = param_1[lVar4]; } while (cVar3 != '\0'); } *(undefined *)((long)pvVar2 + lVar4) = 0; } return pvVar2; }
char *ft_strdup(const char *s) { size_t i; char *str; str = (char *)malloc(sizeof(char) * ft_strlen(s) + 1); if (!str) return (NULL); i = 0; while (s[i] != '\0') { str[i] = s[i]; i++; } str[i] = '\0'; return (str); }
void tcp_set_blocking(int param_1,char param_2) { uint local_c; local_c = fcntl(param_1,F_GETFL,0); if (param_2 == '\0') { local_c = local_c | O_NONBLOCK; } else { local_c = local_c & ~O_NONBLOCK; } fcntl(param_1,F_SETFL,(ulong)local_c); return; }
void tcp_set_blocking(int sock,char block) { int flags; flags=fcntl(sock,F_GETFL, 0); if (block) flags&=~O_NONBLOCK; else flags|=O_NONBLOCK; fcntl(sock,F_SETFL, flags); }
ulong is_end_tag(undefined8 param_1,uint param_2) { ulong uVar1; long in_FS_OFFSET; undefined4 local_2c; int local_28 [6]; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); uVar1 = t3_seeprom_read(param_1,param_2 & 0xfffffffc,&local_2c); if ((int)uVar1 == 0) { local_28[0] = cpu_to_le32(local_2c); uVar1 = (ulong)(local_28[param_2 & 3] == 0x78); } if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) { return uVar1; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
int is_end_tag(adapter_t * adapter, u32 offset) { u32 read_offset, shift, ret, tmp; u8 buf[4]; read_offset = offset & 0xfffffffc; shift = offset & 0x03; ret = t3_seeprom_read(adapter, read_offset, &tmp); if (ret) return ret; *((u32 *)buf) = cpu_to_le32(tmp); if (buf[shift] == 0x78) return 1; else return 0; }
long * Lisp_Clrhash(undefined8 *param_1) { long *plVar1; int *piVar2; undefined4 uVar3; undefined8 *puVar4; undefined8 *puVar5; plVar1 = *(long **)(lisp__data._8_8_ + lisp__data._0_8_ * 8); if ((((ulong)plVar1 & 1) != 0) || (*plVar1 != LispHashTable_t)) { uVar3 = LispStrObj(plVar1); LispDestroy("%s: %s is not a hash-table",**(undefined4 **)*param_1,uVar3); } piVar2 = (int *)plVar1[1]; puVar4 = *(undefined8 **)(piVar2 + 4); puVar5 = puVar4 + (long)*piVar2 * 4; for (; puVar4 < puVar5; puVar4 = puVar4 + 4) { free((void *)puVar4[3]); free((void *)puVar4[2]); puVar4[2] = 0; puVar4[3] = 0; *puVar4 = 0; puVar4[1] = 0; } *(undefined8 *)(piVar2 + 2) = 0; return plVar1; }
LispObj * Lisp_Clrhash(LispBuiltin *builtin) { LispHashTable *hash; LispHashEntry *entry, *last; LispObj *hash_table = lisp__data.stack.values[lisp__data.stack.base + (0)]; if (!((((unsigned long)(hash_table) & 0x01) == 0) && ((hash_table)->type == LispHashTable_t))) LispDestroy("%s: %s is not a hash-table", (builtin->symbol)->data.atom->string, LispStrObj(hash_table)); hash = hash_table->data.hash.table; for (entry = hash->entries, last = entry + hash->num_entries; entry < last; entry++) { free(entry->keys); free(entry->values); entry->keys = entry->values = NULL; entry->count = entry->cache = 0; } hash->count = 0; return (hash_table); }
int * node_exact_match(char *param_1,undefined8 param_2) { int iVar1; int *piVar2; char *__s1; undefined4 extraout_var; long lVar3; piVar2 = (int *)node_top(param_2); if (*param_1 != '\0') { do { lVar3 = node_get(piVar2,TEXT); __s1 = ""; if (lVar3 != 0) { __s1 = (char *)node_get(piVar2,TEXT); } iVar1 = strcmp(__s1,param_1); if (CONCAT44(extraout_var,iVar1) == 0) { return piVar2; } if (piVar2 == (int *)0x0) { return (int *)0x0; } iVar1 = *piVar2; piVar2 = (int *)(long)iVar1; } while (iVar1 != 0); } return (int *)0x0; }
Node *node_exact_match (char *match, Node *where) { Node *node; node = node_top (where); if (!match[0]) return 0; do { if (strcmp (((node_get (node, TEXT))?(node_get (node, TEXT)):""), match) == 0) return node; } while ((node = (((node))?((node)->down):0))); return 0; }
undefined8 tv8532_getcolors(undefined8 *param_1) { *param_1 = 0; return 0; }
__u16 tv8532_getcolors(struct usb_spca50x *spca50x) { spca50x->colour = 0; return spca50x->colour; }
undefined8 main(void) { void *__ptr; __ptr = (void *)tpl_peek(1,"test85.tpl"); if (__ptr != (void *)0x0) { printf("%s\n",__ptr); free(__ptr); } return 0; }
int main() { char *fmt; fmt = tpl_peek((1 << 0), "test85.tpl"); if (fmt) { printf("%s\n",fmt); free(fmt); } return 0; }
ulong jstn_set_token_value(long *param_1,long param_2,undefined8 param_3) { ulong uVar1; *(undefined4 *)(param_1 + 3) = JSTN_STATE_IDLE; if ((param_1[1] == *param_1) && (*(int *)(param_1 + 2) != 0)) { uVar1 = jstn_set_token_partial_value(param_1,param_2,param_3); } else { param_1[1] = param_2; *(int *)(param_1 + 2) = (int)param_3 - (int)param_2; uVar1 = (ulong)JSTN_SUCCESS; } return uVar1; }
jstnres_t jstn_set_token_value(jstn_parser *parser, const char *start, const char* end) { parser->state = JSTN_STATE_IDLE; jstn_token_t* token = &parser->token; if (token->value != parser->buf || token->len == 0) { token->value = start; token->len = end - start; return JSTN_SUCCESS; } else { return jstn_set_token_partial_value(parser, start, end); } }
void crypt_free(void) { xfree(); return; }
void crypt_free(void *ctx) { aes_context *aesctx = (aes_context *)ctx; xfree(aesctx); }
void tumbler_cleanup(long **param_1) { long *plVar1; long lVar2; plVar1 = *param_1; if (plVar1 != (long *)0x0) { if (*plVar1 < 0) { lVar2 = plVar1[1]; } else { free_irq(*plVar1,param_1); lVar2 = plVar1[1]; } if (-1 < lVar2) { free_irq(lVar2,param_1); } tumbler_gpio_free(plVar1 + 4); tumbler_gpio_free((long)plVar1 + 0x1c); tumbler_gpio_free(plVar1 + 3); tumbler_gpio_free((long)plVar1 + 0x14); snd_pmac_keywest_cleanup(plVar1 + 2); kfree(plVar1); *param_1 = (long *)0x0; } return; }
void tumbler_cleanup(struct snd_pmac *chip) { struct pmac_tumbler *mix = chip->mixer_data; if (! mix) return; if (mix->headphone_irq >= 0) free_irq(mix->headphone_irq, chip); if (mix->lineout_irq >= 0) free_irq(mix->lineout_irq, chip); tumbler_gpio_free(&mix->audio_reset); tumbler_gpio_free(&mix->amp_mute); tumbler_gpio_free(&mix->hp_mute); tumbler_gpio_free(&mix->hp_detect); snd_pmac_keywest_cleanup(&mix->i2c); kfree(mix); chip->mixer_data = NULL; }
void command_config_spi_without_cs(undefined4 *param_1) { oid_alloc(*param_1,command_config_spi,4); return; }
void command_config_spi_without_cs(uint32_t *args) { struct spidev_s *spi = oid_alloc(args[0], command_config_spi, sizeof(*spi)); }
int deleteElement(long param_1,int param_2) { int iVar1; undefined4 *puVar2; iVar1 = findElement(); if (iVar1 == -1) { printf("Element not found"); } if (iVar1 < param_2 + -1) { puVar2 = (undefined4 *)(param_1 + (long)iVar1 * 4); do { *puVar2 = puVar2[1]; puVar2 = puVar2 + 1; } while (puVar2 != (undefined4 *) (param_1 + 4 + ((ulong)(uint)((param_2 + -2) - iVar1) + (long)iVar1) * 4)); } return param_2 + -1; }
int deleteElement (int array[], int n, int key) { int pos = findElement(array, n, key); if (pos == -1) { printf("Element not found"); } int i; for (i = pos; i < n-1; i++) array[i] = array[i+1]; return n-1; }
void * varray_new(undefined4 param_1,undefined4 param_2) { void *__ptr; long lVar1; __ptr = malloc(4); if (__ptr == (void *)0x0) { __ptr = (void *)0x0; } else { lVar1 = varray_init(__ptr,param_1,param_2); if (lVar1 == 0) { free(__ptr); __ptr = (void *)0x0; } } return __ptr; }
varray *varray_new(int element_size, int initial_allocation) { varray *va; va = malloc(sizeof(varray)); if (va == NULL) return NULL; if (varray_init(va, element_size, initial_allocation) == NULL) { free(va); return NULL; } return va; }
void dupl(void) { if (flag == 0) { return; } flag = 0; line(from,&key,1); return; }
dupl() { if(flag) { flag = 0; line(from, &key, 1); } }
void jinit_phuff_encoder(undefined8 *param_1) { uint uVar1; code *pcVar2; long lVar3; long lVar4; undefined4 uVar5; undefined8 *puVar6; ulong uVar7; bool bVar8; pcVar2 = *(code **)param_1[1]; uVar5 = SIZEOF(phuff_entropy_encoder); puVar6 = (undefined8 *)(*pcVar2)((ulong)param_1 & 0xffffffff,JPOOL_IMAGE,uVar5); uVar5 = start_pass_phuff; *param_1 = puVar6; *(undefined4 *)(puVar6 + 3) = uVar5; if (0 < NUM_HUFF_TBLS) { lVar3 = puVar6[2]; lVar4 = puVar6[1]; uVar1 = NUM_HUFF_TBLS - 1; uVar7 = 0; do { *(undefined8 *)(lVar3 + uVar7 * 8) = 0; *(undefined8 *)(lVar4 + uVar7 * 8) = 0; bVar8 = uVar1 != uVar7; uVar7 = uVar7 + 1; } while (bVar8); } *puVar6 = 0; return; }
void jinit_phuff_encoder (j_compress_ptr cinfo) { phuff_entropy_ptr entropy; int i; entropy = (phuff_entropy_ptr) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, SIZEOF(phuff_entropy_encoder)); cinfo->entropy = (struct jpeg_entropy_encoder *) entropy; entropy->pub.start_pass = start_pass_phuff; /* Mark tables unallocated */ for (i = 0; i < NUM_HUFF_TBLS; i++) { entropy->derived_tbls[i] = NULL; entropy->count_ptrs[i] = NULL; } entropy->bit_buffer = NULL; /* needed only in AC refinement scan */ }
void m68k_op_cas_8_pi7(void) { uint *puVar1; int iVar2; uint uVar3; uint uVar4; if ((m68ki_cpu[0] & 0xc) == 0) { m68ki_exception_illegal(); return; } uVar3 = m68ki_read_imm_16(); uVar4 = m68ki_cpu._16_4_ | 1; iVar2 = *(int *)(m68ki_cpu._8_8_ + 0x3c); *(int *)(m68ki_cpu._8_8_ + 0x3c) = iVar2 + 2; uVar4 = m68ki_read_8_fc(iVar2,uVar4); puVar1 = (uint *)(m68ki_cpu._8_8_ + (ulong)(uVar3 & 7) * 4); m68ki_cpu._20_4_ = uVar4 - *(byte *)puVar1; m68ki_cpu._32_8_ = ZEXT48(m68ki_cpu._20_4_ & 0xff); m68ki_cpu._24_4_ = (*puVar1 ^ uVar4) & (uVar4 ^ m68ki_cpu._20_4_); m68ki_cpu._28_4_ = m68ki_cpu._20_4_; if ((m68ki_cpu._20_4_ & 0xff) != 0) { *puVar1 = uVar4 | *puVar1 & 0xffffff00; return; } m68ki_remaining_cycles = m68ki_remaining_cycles + -3; m68ki_write_8_fc(iVar2,m68ki_cpu._16_4_ | 1, *(undefined *)(m68ki_cpu._8_8_ + (ulong)(uVar3 >> 6 & 7) * 4)); return; }
void m68k_op_cas_8_pi7(void) { if(((m68ki_cpu.cpu_type) & (4 | 8))) { unsigned int word2 = m68ki_read_imm_16(); unsigned int ea = (((m68ki_cpu.dar+8)[7]+=2)-2); unsigned int dest = m68ki_read_8_fc (ea, m68ki_cpu.s_flag | 1); unsigned int* compare = &m68ki_cpu.dar[word2 & 7]; unsigned int res = dest - ((*compare) & 0xff); ; m68ki_cpu.n_flag = (res); m68ki_cpu.not_z_flag = ((res) & 0xff); m68ki_cpu.v_flag = ((*compare^dest) & (res^dest)); m68ki_cpu.c_flag = (res); if(m68ki_cpu.not_z_flag) *compare = ((*compare) & ~0xff) | dest; else { m68ki_remaining_cycles -= (3); m68ki_write_8_fc (ea, m68ki_cpu.s_flag | 1, ((m68ki_cpu.dar[(word2 >> 6) & 7]) & 0xff)); } return; } m68ki_exception_illegal(); }
void main(void) { char *pcVar1; puts(&_LC0); puts("<HTML>\n<HEAD>\n<TITLE>CGI.c</TITLE>\n</HEAD>"); puts("<BODY BGCOLOR=\"#FFFFFF\">\n<P ALIGN=CENTER>"); pcVar1 = getenv("SERVER_NAME"); printf("<BR>SERVER_NAME=%s\n",pcVar1); pcVar1 = getenv("SERVER_SOFTWARE"); printf("<BR>SERVER_SOFTWARE=%s\n",pcVar1); pcVar1 = getenv("REQUEST_METHOD"); printf("<BR>REQUEST_METHOD=%s\n",pcVar1); pcVar1 = getenv("HTTP_REFERED"); printf("<BR>HTTP_REFERED=%s\n",pcVar1); pcVar1 = getenv("SCRIPT_NAME"); printf("<BR>SCRIPT_NAME=%s\n",pcVar1); pcVar1 = getenv("QUERY_STRING"); printf("<BR>QUERY_STRING=%s\n",pcVar1); pcVar1 = getenv("REMOTE_HOST"); printf("<BR>REMOTE_HOST=%s\n",pcVar1); printf("</P>\n</BODY>\n</HTML>"); return; }
void main(void){ printf("Content‐type:text/html\n\n"); printf("<HTML>\n<HEAD>\n<TITLE>CGI.c</TITLE>\n</HEAD>\n"); printf("<BODY BGCOLOR=\"#FFFFFF\">\n<P ALIGN=CENTER>\n"); printf("<BR>SERVER_NAME=%s\n",getenv("SERVER_NAME")); printf("<BR>SERVER_SOFTWARE=%s\n",getenv("SERVER_SOFTWARE")); printf("<BR>REQUEST_METHOD=%s\n",getenv("REQUEST_METHOD")); printf("<BR>HTTP_REFERED=%s\n",getenv("HTTP_REFERED")); printf("<BR>SCRIPT_NAME=%s\n",getenv("SCRIPT_NAME")); printf("<BR>QUERY_STRING=%s\n",getenv("QUERY_STRING")); printf("<BR>REMOTE_HOST=%s\n",getenv("REMOTE_HOST")); printf("</P>\n</BODY>\n</HTML>"); }
void ajTableSetDestroy(undefined8 *param_1,undefined8 param_2,undefined8 param_3) { if (param_1 != (undefined8 *)0x0) { *param_1 = param_2; param_1[1] = param_3; } return; }
void ajTableSetDestroy(AjOTable* table, void (*keydel)(void** Pkey), void (*valdel)(void** Pvalue)) { if(!table) return; table->Fkeydel = keydel; table->Fvaldel = valdel; return; }
long AnswerAppendDestructive(long param_1,long param_2) { long *plVar1; if (param_1 != 0) { plVar1 = (long *)AnswerLast(param_1); *plVar1 = param_2; param_2 = param_1; } return param_2; }
Answer *AnswerAppendDestructive(Answer *an1, Answer *an2) { if (an1) { AnswerLast(an1)->next = an2; return(an1); } else return(an2); }
undefined8 address_list_decode(int **param_1,undefined8 param_2) { int *piVar1; int iVar2; int *__ptr; long lVar3; undefined8 local_30; __ptr = *param_1; local_30 = param_2; while( true ) { if (__ptr == (int *)0x0) { lVar3 = 1; iVar2 = 1; piVar1 = (int *)realloc((void *)0x0,0x14); } else { iVar2 = *__ptr + 1; lVar3 = (long)iVar2; piVar1 = (int *)realloc(__ptr,(ulong)(iVar2 * 4 + 0x10)); } if (piVar1 == (int *)0x0) break; *piVar1 = iVar2; lVar3 = address_decode(*(long *)(piVar1 + 2) + -4 + lVar3 * 4,&local_30); __ptr = piVar1; if (lVar3 == 0) { *param_1 = piVar1; return 0; } } *param_1 = __ptr; return 0xffffffff; }
int address_list_decode(address_list_t **ptr_addrs, const uint8_t *data) { address_list_t *addrs = *ptr_addrs; do { const int n = addrs ? (addrs->nadrs + 1) : 1; const int l = sizeof(address_list_t) + n * sizeof(address_t); address_list_t *p = realloc(addrs, l); if (!p) { *ptr_addrs = addrs; return -1; } addrs = p; addrs->nadrs = n; } while (address_decode(&addrs->called_adr[addrs->nadrs-1], &data)); *ptr_addrs = addrs; return 0; }
long g_global_register_match(void) { int iVar1; long lVar2; md_init(_match_clvl,0x20); lVar2 = 0; if (*_match_clvl < 0x4000) { iVar1 = md_alloc(_match_clvl,4); lVar2 = (long)iVar1; } return lVar2; }
__g_match g_global_register_match(void) { md_init(_match_clvl, 32); if (_match_clvl->offset >= 16384) { return NULL; } return (__g_match ) md_alloc(_match_clvl, sizeof(_g_match)); }
void cm_event_rep_get(undefined4 *param_1,undefined4 *param_2) { param_1[10] = param_2[10]; param_1[9] = param_2[9]; param_1[8] = param_2[8]; param_1[7] = param_2[7]; param_1[6] = param_2[6]; param_1[5] = param_2[5]; param_1[4] = param_2[4]; param_1[3] = param_2[3]; param_1[2] = param_2[2]; param_1[1] = param_2[1]; *param_1 = *param_2; return; }
void cm_event_rep_get(struct ib_cm_rep_event_param *urep, struct ib_ucm_rep_event_resp *krep) { urep->remote_ca_guid = krep->remote_ca_guid; urep->remote_qkey = krep->remote_qkey; urep->remote_qpn = krep->remote_qpn; urep->starting_psn = krep->starting_psn; urep->responder_resources = krep->responder_resources; urep->initiator_depth = krep->initiator_depth; urep->target_ack_delay = krep->target_ack_delay; urep->failover_accepted = krep->failover_accepted; urep->flow_control = krep->flow_control; urep->rnr_retry_count = krep->rnr_retry_count; urep->srq = krep->srq; }
void cutils_cdar_DynamicArray_long_long_set (undefined8 param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4) { cutils_cdar_DynamicArray_void_ptr_set(param_1,param_2,param_3,param_4); return; }
bool cutils_cdar_DynamicArray_long_long_set(cutils_cdar_DynamicArray_long_long*d,size_t i,size_t c,long long*a){return cutils_cdar_DynamicArray_void_ptr_set(d,i,c,a);}
void nouveau_fbcon_copyarea(long *param_1,undefined8 param_2) { int iVar1; long lVar2; long *plVar3; long lVar4; int iVar5; lVar2 = nouveau_drm(*(undefined4 *)param_1[2]); plVar3 = (long *)nv_device(*(undefined4 *)(lVar2 + 4)); if (*param_1 == FBINFO_STATE_RUNNING) { iVar5 = -ENODEV; iVar1 = in_interrupt(); if ((iVar1 == 0) && ((FBINFO_HWACCEL_DISABLED & *(uint *)(param_1 + 1)) == 0)) { lVar4 = mutex_trylock(lVar2); if (lVar4 != 0) { if (*plVar3 < NV_50) { iVar5 = nv04_fbcon_copyarea(param_1,param_2); } else if (*plVar3 < NV_C0) { iVar5 = nv50_fbcon_copyarea(); } else { iVar5 = nvc0_fbcon_copyarea(); } mutex_unlock(lVar2); } } if (iVar5 != 0) { if (iVar5 + ENODEV != 0) { nouveau_fbcon_gpu_lockup(param_1); } cfb_copyarea(param_1,param_2); return; } } return; }
void nouveau_fbcon_copyarea(struct fb_info *info, const struct fb_copyarea *image) { struct nouveau_fbdev *fbcon = info->par; struct nouveau_drm *drm = nouveau_drm(fbcon->dev); struct nouveau_device *device = nv_device(drm->device); int ret; if (info->state != FBINFO_STATE_RUNNING) return; ret = -ENODEV; if (!in_interrupt() && !(info->flags & FBINFO_HWACCEL_DISABLED) && mutex_trylock(&drm->client.mutex)) { if (device->card_type < NV_50) ret = nv04_fbcon_copyarea(info, image); else if (device->card_type < NV_C0) ret = nv50_fbcon_copyarea(info, image); else ret = nvc0_fbcon_copyarea(info, image); mutex_unlock(&drm->client.mutex); } if (ret == 0) return; if (ret != -ENODEV) nouveau_fbcon_gpu_lockup(info); cfb_copyarea(info, image); }
undefined8 snd_ensoniq_midi_output_open(undefined8 *param_1) { uint *puVar1; undefined4 uVar2; undefined8 uVar3; puVar1 = *(uint **)*param_1; spin_lock_irq(puVar1 + 1); *puVar1 = *puVar1 | ES_MODE_OUTPUT; *(undefined8 **)(puVar1 + 6) = param_1; if ((ES_MODE_INPUT & *puVar1) == 0) { uVar2 = ES_REG(puVar1,UART_CONTROL); uVar3 = ES_CNTRL(3); outb(uVar3,uVar2); uVar2 = ES_REG(puVar1,UART_CONTROL); *(undefined8 *)(puVar1 + 4) = 0; outb(*(undefined8 *)(puVar1 + 4),uVar2); uVar2 = ES_REG(puVar1,CONTROL); puVar1[2] = puVar1[2] | ES_UART_EN; outl(puVar1[2],uVar2); } spin_unlock_irq(puVar1 + 1); return 0; }
int snd_ensoniq_midi_output_open(struct snd_rawmidi_substream *substream) { struct ensoniq *ensoniq = substream->rmidi->private_data; spin_lock_irq(&ensoniq->reg_lock); ensoniq->uartm |= ES_MODE_OUTPUT; ensoniq->midi_output = substream; if (!(ensoniq->uartm & ES_MODE_INPUT)) { outb(ES_CNTRL(3), ES_REG(ensoniq, UART_CONTROL)); outb(ensoniq->uartc = 0, ES_REG(ensoniq, UART_CONTROL)); outl(ensoniq->ctrl |= ES_UART_EN, ES_REG(ensoniq, CONTROL)); } spin_unlock_irq(&ensoniq->reg_lock); return 0; }
void g2_clear_palette(uint param_1) { uint uVar1; int *piVar2; int *piVar3; long lVar4; piVar2 = (int *)g2_get_device_pointer(); if (piVar2 == (int *)0x0) { fprintf((FILE *)(ulong)stderr,"g2_clear_palette: No such device: %d\n",(ulong)param_1); uVar1 = __g2_last_device; } else if (*piVar2 == 0x80) { piVar3 = *(int **)(piVar2 + 2); lVar4 = 0; uVar1 = param_1; if (0 < *piVar3) { do { g2_clear_palette(*(undefined4 *)(*(long *)(piVar3 + 2) + lVar4 * 4)); piVar3 = *(int **)(piVar2 + 2); lVar4 = lVar4 + 1; uVar1 = param_1; } while ((int)lVar4 < *piVar3); } } else { uVar1 = param_1; if (*piVar2 == 0x81) { g2_clear_palette_pd(piVar2[4]); uVar1 = param_1; } } __g2_last_device = uVar1; return; }
void g2_clear_palette(int dev) { g2_device *devp; int i; if((devp=g2_get_device_pointer(dev))==NULL) { fprintf(stderr, "g2_clear_palette: No such device: %d\n", dev); return; } switch(devp->t) { case g2_PD: g2_clear_palette_pd(devp->d.pd); break; case g2_VD: for(i=0;i<devp->d.vd->N;i++) g2_clear_palette(devp->d.vd->dix[i]); break; case g2_ILLEGAL: break; case g2_NDEV: break; } __g2_last_device=dev; }
int my_strncasecmp(byte *param_1,byte *param_2,long param_3) { byte *pbVar1; int iVar2; int iVar3; undefined4 extraout_var; undefined4 extraout_var_00; byte *pbVar4; pbVar1 = param_1 + param_3 + -1; pbVar4 = param_1; if (param_1 < pbVar1) { do { pbVar4 = param_1; if ((*param_1 == 0) || (*param_2 == 0)) break; iVar2 = tolower((uint)*param_1); iVar3 = tolower((uint)*param_2); if (CONCAT44(extraout_var,iVar2) != CONCAT44(extraout_var_00,iVar3)) break; param_1 = param_1 + 1; param_2 = param_2 + 1; pbVar4 = pbVar1; } while (pbVar1 != param_1); } iVar2 = tolower((uint)*pbVar4); iVar3 = tolower((uint)*param_2); return iVar2 - iVar3; }
int my_strncasecmp(const char *str1, const char *str2, size_t len) { register const unsigned char *s1 = (unsigned char *) str1, *s2 = (unsigned char *) str2, *e; int ret; for (e = s1 + len - 1; s1 < e && *s1 != '\0' && *s2 != '\0' && tolower(*s1) == tolower(*s2); s1++, s2++) ; ret = tolower(*s1) - tolower(*s2); return (ret); }
long * NEW_abstract_compiler__CodeWriter(long param_1) { long *plVar1; long lVar2; plVar1 = (long *)nit_alloc(0x10); plVar1[2] = param_1; plVar1[1] = (long)&class_abstract_compiler__CodeWriter; lVar2 = NEW_list__List(&type_list__Liststring__String); (**(code **)(**(long **)(lVar2 + 8) + COLOR_list__List__init * 8))(lVar2); *(long *)(*plVar1 + COLOR_abstract_compiler__CodeWriter___64dlines * 8) = lVar2; lVar2 = NEW_list__List(&type_list__Liststring__String); (**(code **)(**(long **)(lVar2 + 8) + COLOR_list__List__init * 8))(lVar2); *(long *)(*plVar1 + COLOR_abstract_compiler__CodeWriter___64ddecl_lines * 8) = lVar2; return plVar1; }
val* NEW_abstract_compiler__CodeWriter(const struct type* type) { val* self ; val* var ; val* var1 ; self = nit_alloc(sizeof(struct instance) + 3*sizeof(nitattribute_t)); self->type = type; self->class = &class_abstract_compiler__CodeWriter; var = NEW_list__List(&type_list__Liststring__String); ((void (*)(val*))(var->class->vft[COLOR_list__List__init]))(var) ; self->attrs[COLOR_abstract_compiler__CodeWriter___64dlines].val = var; var1 = NEW_list__List(&type_list__Liststring__String); ((void (*)(val*))(var1->class->vft[COLOR_list__List__init]))(var1) ; self->attrs[COLOR_abstract_compiler__CodeWriter___64ddecl_lines].val = var1; return self; }
int skd_bdev_getgeo(undefined8 *param_1,undefined8 *param_2) { undefined4 *puVar1; int iVar2; puVar1 = *(undefined4 **)((undefined4 *)*param_1 + 2); dev_dbg(*(undefined8 *)(puVar1 + 4),"%s: CMD[%s] getgeo device\n",*(undefined4 *)*param_1,*current ); if (*(long *)(puVar1 + 2) == 0) { return -EIO; } iVar2 = get_capacity(*puVar1); *param_2 = 0xff00000040; *(int *)(param_2 + 1) = iVar2 / 0x3fc0; return 0; }
int skd_bdev_getgeo(struct block_device *bdev, struct hd_geometry *geo) { struct skd_device *skdev; u64 capacity; skdev = bdev->bd_disk->private_data; dev_dbg(&skdev->pdev->dev, "%s: CMD[%s] getgeo device\n", bdev->bd_disk->disk_name, current->comm); if (skdev->read_cap_is_valid) { capacity = get_capacity(skdev->disk); geo->heads = 64; geo->sectors = 255; geo->cylinders = (capacity) / (255 * 64); return 0; } return -EIO; }
bool is_serialized_buffer_empty(long *param_1) { return *param_1 == 0; }
char is_serialized_buffer_empty(ser_buff_t *b){ if(b->next == 0) return 1; return 0; }
void havege_init(void *param_1) { memset(param_1,0,4); havege_fill(param_1); return; }
void havege_init( havege_state *hs ) { memset( hs, 0, sizeof( havege_state ) ); havege_fill( hs ); }
void addWorkList(undefined4 param_1) { undefined4 uVar1; int iVar2; long lVar3; long lVar4; uVar1 = temp2Node(param_1); lVar3 = G_look(c._20_4_,uVar1); lVar4 = Temp_look(c._16_4_,param_1); if (lVar4 == 0) { iVar2 = moveRelated(param_1); if ((iVar2 == 0) && (lVar3 < (long)c._0_8_)) { uVar1 = L(param_1,0); c._12_4_ = tempMinus(c._12_4_,uVar1); uVar1 = L(param_1,0); c._8_4_ = tempUnion(c._8_4_,uVar1); } } return; }
void addWorkList(Temp_temp t) { long degree = (long)G_look(c.degree, temp2Node(t)); if (Temp_look(c.precolored, t) == NULL && (!moveRelated(t)) && (degree < c.K)) { c.freezeWorklist = tempMinus(c.freezeWorklist, L(t, NULL)); c.simplifyWorklist = tempUnion(c.simplifyWorklist, L(t, NULL)); } }
void nvkm_fifo_preinit(undefined4 *param_1) { nvkm_mc_reset(*param_1,NVKM_ENGINE_FIFO); return; }
void nvkm_fifo_preinit(struct nvkm_engine *engine) { nvkm_mc_reset(engine->subdev.device, NVKM_ENGINE_FIFO); }
void INSTR_FIN(long param_1) { assert(param_1 != 0); printf("Fin\n"); return; }
void INSTR_FIN(JCONTEXT *context) { assert(context!=NULL); printf("Fin\n"); }
void init_path_block(void) { int iVar1; iVar1 = (-(uint)(x_small_buffers == 0) & 0xff000) + 0x1000; first_path_block = (long *)alloc_path_block(iVar1); next_entry = *first_path_block; path_block_end = iVar1 + next_entry; space_used = 0; last_path_block = first_path_block; space_allocated = iVar1; if (using_fiemap != 0) { fiemap = fiemap_alloc(); } return; }
void init_path_block() { int bsize = 1024 * 1024; if (x_small_buffers) { bsize = 4096; } first_path_block = alloc_path_block(bsize); next_entry = first_path_block->ptr; path_block_end = first_path_block->ptr + bsize; last_path_block = first_path_block; space_used = 0; space_allocated = bsize; if (using_fiemap) { fiemap = fiemap_alloc(); } }
long avm_getactual(int param_1) { return stack + (ulong)(uint)(topsp + 5 + param_1) * 4; }
avm_memcell *avm_getactual(unsigned i){ return &stack[topsp + 4 + 1 + i]; }
undefined8 read_array(char **param_1) { char *pcVar1; char cVar2; int iVar3; long lVar4; char *pcVar5; size_t __n; if (param_1 == (char **)0x0) { return 0; } pcVar5 = *param_1; if (pcVar5 != (char *)0x0) { assert(1); cVar2 = *pcVar5; while (cVar2 != '\0') { lVar4 = ELFTC_ISDIGIT(); if (lVar4 == 0) { if (*pcVar5 != '_') { return 0; } __n = (long)pcVar5 - (long)*param_1; assert(__n != 0); dest_cstring(param_1 + 2); iVar3 = init_cstring(param_1 + 2,__n + 3); if (iVar3 == 0) { return 0; } strncpy(param_1[2] + 1,*param_1,__n); *param_1[2] = '['; param_1[2][__n + 1] = ']'; *(undefined4 *)(param_1 + 1) = 1; *param_1 = pcVar5 + 1; return 1; } pcVar1 = pcVar5 + 1; pcVar5 = pcVar5 + 1; cVar2 = *pcVar1; } } return 0; }
bool read_array(struct demangle_data *d) { size_t len; const char *end; if (d == NULL || d->p == NULL) return (false); end = d->p; assert(end != NULL); for (;;) { if (*end == '\0') return (false); if (ELFTC_ISDIGIT(*end) == 0) break; ++end; } if (*end != '_') return (false); len = end - d->p; assert(len > 0); dest_cstring(&d->array_str); if (init_cstring(&d->array_str, len + 3) == false) return (false); strncpy(d->array_str.buf + 1, d->p, len); *d->array_str.buf = '['; *(d->array_str.buf + len + 1) = ']'; d->array = true; d->p = end + 1; return (true); }
ulong e4i_swrite_id(uint *param_1,undefined8 param_2,undefined4 param_3,undefined4 param_4, undefined4 param_5) { uint uVar1; undefined4 uVar2; ulong uVar3; if ((E4I_F_CHS & *param_1) == 0) { return (ulong)E4I_E_ACCESS; } uVar1 = param_1[1]; uVar2 = __e4i_s2b(param_1,param_3,param_4,param_5); uVar3 = __e4i_write(param_1,param_2,uVar2,uVar1,0,uVar1); return uVar3; }
int e4i_swrite_id(struct e4i_t *e, uint8_t *buf, int cyl, int head, int sect) { if (!(e->flags & E4I_F_CHS)) { return E4I_E_ACCESS; } return __e4i_write(e, buf, __e4i_s2b(e, cyl, head, sect), e->id_size, 0, e->id_size); }
bool pdc_is_idle(int *param_1) { long lVar1; if (*param_1 < 8) { lVar1 = pdc_get_status0(); } else { lVar1 = pdc_get_status2(); } return DMA_STATUS_IDLE == lVar1; }
bool pdc_is_idle(struct pch_dma_chan *pd_chan) { u32 sts; if (pd_chan->chan.chan_id < 8) sts = pdc_get_status0(pd_chan); else sts = pdc_get_status2(pd_chan); if (sts == DMA_STATUS_IDLE) return true; else return false; }
ulong obs_key_from_name(undefined8 param_1) { int iVar1; undefined4 extraout_var; long lVar2; ulong uVar3; long in_FS_OFFSET; uint local_14; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); if (obs != (undefined4 *)0x0) { iVar1 = pthread_once(obs + 1,(__init_routine *)(ulong)init_name_map); if (CONCAT44(extraout_var,iVar1) == 0) { local_14 = 0; lVar2 = obs_hotkey_name_map_lookup(*obs,param_1,&local_14); uVar3 = (ulong)local_14; if (lVar2 == 0) { uVar3 = (ulong)OBS_KEY_NONE; } goto LAB_00100068; } } uVar3 = obs_key_from_name_fallback(param_1); LAB_00100068: if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) { return uVar3; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
obs_key_t obs_key_from_name(const char *name) { if (!obs) return obs_key_from_name_fallback(name); if (pthread_once(&obs->hotkeys.name_map_init_token, init_name_map)) return obs_key_from_name_fallback(name); int v = 0; if (obs_hotkey_name_map_lookup(obs->hotkeys.name_map, name, &v)) return v; return OBS_KEY_NONE; }
void par_parlist(void) { undefined8 *puVar1; void *pvVar2; long lVar3; int iVar4; if (volumes == (undefined8 *)0x0) { iVar4 = 0; } else { iVar4 = 0; puVar1 = volumes; do { iVar4 = iVar4 + 1; puVar1 = (undefined8 *)puVar1[1]; } while (puVar1 != (undefined8 *)0x0); } pvVar2 = calloc(8,(ulong)(iVar4 + 1)); if (volumes == (undefined8 *)0x0) { iVar4 = 0; } else { lVar3 = 1; puVar1 = volumes; do { *(undefined8 *)((long)pvVar2 + lVar3 * 8 + -8) = *puVar1; puVar1 = (undefined8 *)puVar1[1]; iVar4 = (int)lVar3; lVar3 = lVar3 + 1; } while (puVar1 != (undefined8 *)0x0); } *(undefined8 *)((long)pvVar2 + (long)iVar4 * 8) = 0; return; }
u16 ** par_parlist(void) { u16 **ret; pfile_t *p; int n; for (n = 0, p = volumes; p; p = p->next) n++; ((ret) = (calloc(sizeof(*(ret)), (n + 1)))); for (n = 0, p = volumes; p; p = p->next, n++) ret[n] = p->filename; ret[n] = 0; return ret; }
void ooaofooa_SEN_DE_R9501_Link(undefined4 *param_1,undefined8 *param_2) { undefined4 uVar1; uVar1 = param_1[4]; *param_2 = param_1; *(undefined4 *)(param_2 + 1) = uVar1; *(undefined8 **)(param_1 + 2) = param_2; *param_1 = 0x1cb; return; }
void ooaofooa_SEN_DE_R9501_Link( ooaofooa_SEN_E * supertype, ooaofooa_SEN_DE * subtype ) { subtype->Id = supertype->Id; subtype->SEN_E_R9501 = supertype; supertype->R9501_subtype = subtype; supertype->R9501_object_id = 459; }
uint rop161(uint param_1,uint param_2,uint param_3) { return ~(param_3 ^ (~param_3 & param_2 | param_1)); }
rop_operand rop161(rop_operand D, rop_operand S, rop_operand T) { return ~(((~T & S) | D) ^ T); }
void treeWr(FILE *param_1,void *param_2) { long in_FS_OFFSET; short local_22; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); fwrite(param_2,2,1,param_1); local_22 = 0; do { if (*(long *)(proba + (long)local_22 * 8) != 0) { fwrite(&local_22,2,1,param_1); fwrite((void *)(fg + (long)local_22 * 2),2,1,param_1); fwrite((void *)(fd + (long)local_22 * 2),2,1,param_1); fwrite((void *)(parent + (long)local_22 * 2),2,1,param_1); } local_22 = local_22 + 1; } while (local_22 < 0x1ff); if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
void treeWr(FILE* g, short int* nbNoeud){ fwrite(nbNoeud, sizeof(short int), 1, g); for(short int i=0 ; i<511 ; i++){ if(proba[i] != 0){ fwrite(&i, sizeof(short int), 1, g); fwrite(&fg[i], sizeof(short int), 1, g); fwrite(&fd[i], sizeof(short int), 1, g); fwrite(&parent[i], sizeof(short int), 1, g); } } }
double uniformVar(void) { double extraout_XMM0_Qa; random(); return extraout_XMM0_Qa / (double)RAND_MAX; }
double uniformVar(void) { return random() / (double)RAND_MAX; }
int clar_summary_testsuite (undefined8 param_1,uint *param_2,uint param_3,undefined8 param_4,undefined8 param_5, undefined4 param_6,uint param_7_00,uint param_7,uint param_8) { int iVar1; size_t sVar2; long in_FS_OFFSET; undefined4 local_48; uint local_44; uint *local_40; tm *local_30; char local_28 [24]; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); local_48 = param_6; local_44 = param_3; local_40 = param_2; local_30 = localtime((time_t *)&local_48); sVar2 = strftime(local_28,0x14,"%Y-%m-%dT%H:%M:%S",local_30); if (sVar2 == 0) { iVar1 = -1; } else { iVar1 = fprintf((FILE *)(ulong)*local_40, "\t<testsuite id=\"%d\" name=\"%s\" package=\"%s\" hostname=\"localhost\" timestamp=\"%s\" time=\"%.2f\" tests=\"%d\" failures=\"%d\" errors=\"%d\">\n" ,param_1,(ulong)local_44,param_4,param_5,local_28,(ulong)param_7_00, (ulong)param_7,(ulong)param_8); } if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return iVar1; }
int clar_summary_testsuite(struct clar_summary *summary, int idn, const char *name, const char *pkg, time_t timestamp, double elapsed, int test_count, int fail_count, int error_count) { struct tm *tm = localtime(&timestamp); char iso_dt[20]; if (strftime(iso_dt, sizeof(iso_dt), "%Y-%m-%dT%H:%M:%S", tm) == 0) return -1; return fprintf(summary->fp, "\t<testsuite " " id=\"%d\"" " name=\"%s\"" " package=\"%s\"" " hostname=\"localhost\"" " timestamp=\"%s\"" " time=\"%.2f\"" " tests=\"%d\"" " failures=\"%d\"" " errors=\"%d\">\n", idn, name, pkg, iso_dt, elapsed, test_count, fail_count, error_count); }
void ili9340_fill_rect(int param_1,int param_2,int param_3,int param_4,uint param_5) { int iVar1; int local_28; int local_24; int local_20; int local_1c; int local_18; int local_14; local_1c = param_1; if (width <= param_1) { local_1c = width + -1; } local_20 = param_2; if (height <= param_2) { local_20 = height + -1; } local_24 = param_3; if (width < local_1c + param_3) { local_24 = width - local_1c; } local_28 = param_4; if (height < local_20 + param_4) { local_28 = height - local_20; } ili9340_mkdirty(local_1c,local_20,local_24 + local_1c + -1,local_28 + local_20 + -1); local_18 = (local_1c + width * local_20) * 2; while (local_28 != 0) { for (local_14 = local_24; local_14 != 0; local_14 = local_14 + -1) { iVar1 = local_18 + 1; *(uint *)(framebuffer + (long)local_18 * 4) = (int)param_5 >> 8 & 0xff; local_18 = local_18 + 2; *(uint *)(framebuffer + (long)iVar1 * 4) = param_5 & 0xff; } local_18 = local_18 + (width - local_24) * 2; local_28 = local_28 + -1; } return; }
void ili9340_fill_rect(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t color) { if (x >= width) x = width - 1; if (y >= height) y = height - 1; if (x + w > width) w = width - x; if (y + h > height) h = height - y; ili9340_mkdirty(x, y, x + w - 1, y + h - 1); uint8_t hi = (color >> 8) & 0xff, lo = color & 0xff; uint32_t offset = (y * width + x) << 1; while (h--) { for (uint16_t i = w; i; i--) { framebuffer[offset++] = hi; framebuffer[offset++] = lo; } offset += (width - w) << 1; } }
int dfs(int param_1,int param_2) { long lVar1; int iVar2; int iVar3; uint uVar4; uint *puVar5; lVar1 = (long)param_1 * 4; for (iVar2 = *(int *)(head + (long)param_1 * 4); iVar2 != -1; iVar2 = *(int *)(next + (long)iVar2 * 4)) { iVar3 = *(int *)(to + (long)iVar2 * 4); if (iVar3 != param_2) { iVar3 = dfs(iVar3,param_1); *(int *)(sz + lVar1) = *(int *)(sz + lVar1) + iVar3; if (*(int *)(ans + lVar1) < iVar3) { *(int *)(ans + lVar1) = iVar3; } } } puVar5 = (uint *)(sz + lVar1); uVar4 = *puVar5; if (*(int *)(lVar1 + ans) < (int)(~uVar4 + n)) { *(int *)(lVar1 + ans) = ~uVar4 + n; uVar4 = *puVar5; } return uVar4 + 1; }
int dfs(int now, int prev) { int i, tmp; for (i = head[now]; ~i; i = next[i]) { if (to[i] == prev) continue; tmp = dfs(to[i], now); sz[now] += tmp; if (tmp > ans[now]) ans[now] = tmp; } tmp = n - sz[now] - 1; if (tmp > ans[now]) ans[now] = tmp; return sz[now] + 1; }
int player_level(int *param_1) { return *param_1 / 0x28 + 1; }
int player_level(player* p) { return p->Experience / 40 + 1; }
void end_arguments(void **param_1) { free(param_1[1]); free(*param_1); free(param_1); return; }
void end_arguments(ARGUMENTS* arg) { free(arg->input_file); free(arg->output_file); free(arg); }
void _start(void) { _library_ident("MPT Loader Library"); _library_task("load factory symbol from shared library"); _library_task("create proxy metatypes for library objects"); /* WARNING: Subroutine does not return */ _exit(0); }
extern void _start(void) { _library_ident("MPT Loader Library"); _library_task("load factory symbol from shared library"); _library_task("create proxy metatypes for library objects"); _exit(0); }
undefined4 * vec3i_set3(undefined4 *param_1,undefined4 *param_2) { undefined4 *puVar1; if (param_1 != param_2) { puVar1 = (undefined4 *)vec3i_set(param_1,param_2[2],param_2[1],*param_2); return puVar1; } return param_1; }
t_vec3i * vec3i_set3(t_vec3i * dst, t_vec3i * vec) { if (dst == vec) { return (dst); } return (vec3i_set(dst, vec->x, vec->y, vec->z)); }
void t161add(void) { int iVar1; long lVar2; long in_FS_OFFSET; int local_18; uint local_14; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); v = 0; iVar1 = t161_1add(0xfffffffb,5); if ((((iVar1 != 0) || (iVar1 = t161_2add(5), iVar1 != 0)) || (iVar1 = t161_3add(5), iVar1 != 0)) || ((iVar1 = t161_4add(0xfffffffb), iVar1 != 0 || (iVar1 = t161_5add(0xfffffffb), iVar1 != 0))) ) { __builtin_abort(); } lVar2 = __builtin_add_overflow(0xfffffffb,5,&local_18); if (lVar2 != 0) { bar(); } if (local_18 != 0) { __builtin_abort(); } lVar2 = __builtin_add_overflow(0xfffffffb,5,&local_14); if (lVar2 != 0) { bar(); } if ((v | local_14) != 0) { __builtin_abort(); } if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return; }
__attribute__((noinline, noclone)) void t161add (void) { signed int x = (-5); signed int y = (5); unsigned int r1, r2; v = 0; if (t161_1add (x, y) != (unsigned int) (0) || t161_2add (y) != (unsigned int) (0) || t161_3add (y) != (unsigned int) (0) || t161_4add (x) != (unsigned int) (0) || t161_5add (x) != (unsigned int) (0)) __builtin_abort (); if (__builtin_add_overflow (x, y, &r1)) bar (); if (r1 != (unsigned int) (0)) __builtin_abort (); if (__builtin_add_overflow ((signed int) (-5), (signed int) (5), &r2)) bar (); if (r2 != (unsigned int) (0) || v != 7 * 0) __builtin_abort (); }
undefined4 list_data(undefined4 *param_1) { return *param_1; }
ListValue list_data(ListEntry *listentry) { return listentry->data; }
void UART_writeDecU64(int param_1,long param_2) { int iVar1; char *pcVar2; long in_FS_OFFSET; char local_28 [24]; long local_10; pcVar2 = local_28; local_10 = *(long *)(in_FS_OFFSET + 0x28); if (param_2 != 0) { do { *pcVar2 = ' '; pcVar2 = pcVar2 + 1; } while (pcVar2 != local_28 + param_2); } local_28[param_2] = '\0'; pcVar2 = local_28 + param_2; do { pcVar2 = pcVar2 + -1; iVar1 = param_1 / 10; *pcVar2 = (char)param_1 + (char)iVar1 * -10 + '0'; param_1 = iVar1; } while (iVar1 != 0); UART_write(local_28); if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return; }
void UART_writeDecU64(uint64_t v, uint8_t n) { char buf[22]; uint8_t i; for(i = 0; i < n; ++i) buf[i] = ' '; buf[n] = '\0'; i = n; do { uint8_t d = v % 10; v /= 10; buf[--i] = '0' + d; } while(v != 0); UART_write(buf); }
void bubbleSort(int *param_1,int param_2) { int iVar1; int *piVar2; int iVar3; printf("size %d\n"); if (1 < param_2) { iVar3 = param_2 + -1; do { if (0 < iVar3) { piVar2 = param_1; do { iVar1 = *piVar2; if (piVar2[1] < iVar1) { *piVar2 = piVar2[1]; piVar2[1] = iVar1; } piVar2 = piVar2 + 1; } while (piVar2 != param_1 + (ulong)(iVar3 - 1) + 1); } iVar3 = iVar3 + -1; } while (iVar3 != 0); printA(param_1,param_2); } 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 * make_list(void) { undefined8 *puVar1; undefined8 *puVar2; puVar1 = (undefined8 *)malloc(0x18); puVar2 = (undefined8 *)malloc(0x18); puVar1[2] = 0; puVar1[1] = puVar2; *puVar1 = 0; puVar2[2] = puVar1; puVar2[1] = 0; *puVar2 = 0; return puVar1; }
list_node *make_list() { list_node *start = (list_node *) malloc(sizeof(list_node)); list_node *end = (list_node *) malloc(sizeof(list_node)); start->prev = NULL; start->next = end; start->data = NULL; end->prev = start; end->next = NULL; end->data = NULL; return start; }
undefined4 zip64local_getByte(undefined4 *param_1,ulong param_2,uint *param_3) { int iVar1; undefined4 uVar2; long lVar3; long in_FS_OFFSET; byte local_21; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); iVar1 = (**(code **)(param_1 + 4))(*param_1,param_2,&local_21,1); if (iVar1 == 1) { *param_3 = (uint)local_21; uVar2 = 0; } else { lVar3 = (**(code **)(param_1 + 2))(*param_1,param_2 & 0xffffffff); uVar2 = 0; if (lVar3 != 0) { uVar2 = Z_ERRNO; } } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return uVar2; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def,voidpf filestream,int* pi) { unsigned char c; int err = (int)((*((*pzlib_filefunc_def).zfile_func64.zread_file)) ((*pzlib_filefunc_def).zfile_func64.opaque,filestream,&c,1)); if (err==1) { *pi = (int)c; return (0); } else { if (((*((*pzlib_filefunc_def).zfile_func64.zerror_file)) ((*pzlib_filefunc_def).zfile_func64.opaque,filestream))) return (Z_ERRNO); else return (0); } }
void quit(long param_1) { if (param_1 != 0) { printf("\nFault: %s\n",param_1); } puts("Exiting."); /* WARNING: Subroutine does not return */ exit(EXIT_FAILURE); }
void quit(const char* reason) { if (reason != NULL) { printf("\nFault: %s\n", reason); } printf("Exiting.\n"); exit(EXIT_FAILURE); }
undefined8 hydrogen_thread(undefined8 param_1) { reaction_h(param_1); __sync_add_and_fetch(&hydrogen_atoms_bonded,1); return 0; }
void* hydrogen_thread(void *arg) { struct reaction *reaction = (struct reaction*)arg; reaction_h(reaction); __sync_add_and_fetch(&hydrogen_atoms_bonded, 1); return NULL; }
undefined4 * svn_prop_dup(undefined4 *param_1,undefined8 param_2) { undefined4 *puVar1; puVar1 = (undefined4 *)apr_palloc(param_2,4); *puVar1 = *param_1; svn_prop__members_dup(puVar1,param_2); return puVar1; }
svn_prop_t * svn_prop_dup(const svn_prop_t *prop, apr_pool_t *pool) { svn_prop_t *new_prop = apr_palloc(pool, sizeof(*new_prop)); *new_prop = *prop; svn_prop__members_dup(new_prop, pool); return new_prop; }
void sha256_init(long *param_1) { param_1[1] = 0; *(undefined4 *)*param_1 = 0x6a09e667; *(undefined4 *)(*param_1 + 4) = 0xbb67ae85; *(undefined4 *)(*param_1 + 8) = 0x3c6ef372; *(undefined4 *)(*param_1 + 0xc) = 0xa54ff53a; *(undefined4 *)(*param_1 + 0x10) = 0x510e527f; *(undefined4 *)(*param_1 + 0x14) = 0x9b05688c; *(undefined4 *)(*param_1 + 0x18) = 0x1f83d9ab; *(undefined4 *)(*param_1 + 0x1c) = 0x5be0cd19; return; }
void sha256_init(void *ctx) { struct sha256 *s = ctx; s->len = 0; s->h[0] = 0x6a09e667; s->h[1] = 0xbb67ae85; s->h[2] = 0x3c6ef372; s->h[3] = 0xa54ff53a; s->h[4] = 0x510e527f; s->h[5] = 0x9b05688c; s->h[6] = 0x1f83d9ab; s->h[7] = 0x5be0cd19; }
void ISL29023DataLightIRGetFloat(long *param_1,float *param_2) { long in_FS_OFFSET; long local_28; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); ISL29023DataLightIRGetRaw(param_1,&local_28); *param_2 = (float)local_28 / *(float *)(g_fBetaLookup + *param_1 * 4); if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
void ISL29023DataLightIRGetFloat(tISL29023 *psInst, float *pfIR) { uint16_t i16IR; ISL29023DataLightIRGetRaw(psInst, &i16IR); *pfIR = ((float) i16IR) / g_fBetaLookup[psInst->ui8Range]; }
void v56(undefined4 *param_1) { param_1[1] = *param_1; return; }
void v56(FDC* p) {p->ls = p->data;}
void redtree_ripper_mark(undefined4 *param_1) { rb_gc_mark(*param_1); return; }
void redtree_ripper_mark(void *ptr) { struct redtree_ripper* node = (struct redtree_ripper*)ptr; rb_gc_mark(node->tree_val); }
void t_isalpha_0xd0(void) { int iVar1; undefined4 extraout_var; iVar1 = isalpha(0xd0); Assert_real(CONCAT44(extraout_var,iVar1) == 0, "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/bitfixer/bitfixer/refs/heads/master/dg/z88dk/test/suites/ctype/test_isalpha.c" ,0x415,"isalpha should be 0 for 0xd0"); return; }
void t_isalpha_0xd0() { Assert_real((isalpha(208) == 0), "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/bitfixer/bitfixer/refs/heads/master/dg/z88dk/test/suites/ctype/test_isalpha.c", 1045, ("isalpha should be 0 for 0xd0")); }
void bcm2835_spi_writenb(char *param_1,long param_2) { long lVar1; long lVar2; uint uVar3; char *pcVar4; lVar2 = bcm2835_spi0; lVar1 = bcm2835_spi0 + 8; bcm2835_peri_set_bits(bcm2835_spi0,0x30,0x30); bcm2835_peri_set_bits(lVar2,0x80,0x80); if (param_2 != 0) { pcVar4 = param_1 + param_2; do { do { uVar3 = bcm2835_peri_read(lVar2); } while ((uVar3 & 0x40000) == 0); bcm2835_peri_write_nb(lVar1,(int)*param_1); while( true ) { uVar3 = bcm2835_peri_read(lVar2); if ((uVar3 & 0x20000) == 0) break; bcm2835_peri_read_nb(lVar1); } param_1 = param_1 + 1; } while (param_1 != pcVar4); } while( true ) { uVar3 = bcm2835_peri_read_nb(lVar2); if ((uVar3 & 0x10000) != 0) break; while( true ) { uVar3 = bcm2835_peri_read(lVar2); if ((uVar3 & 0x20000) == 0) break; bcm2835_peri_read_nb(lVar1); } } bcm2835_peri_set_bits(lVar2,0,0x80); return; }
void bcm2835_spi_writenb(char* tbuf, uint32_t len) { volatile uint32_t* paddr = bcm2835_spi0 + 0x0000/4; volatile uint32_t* fifo = bcm2835_spi0 + 0x0004/4; bcm2835_peri_set_bits(paddr, 0x00000030, 0x00000030); bcm2835_peri_set_bits(paddr, 0x00000080, 0x00000080); uint32_t i; for (i = 0; i < len; i++) { while (!(bcm2835_peri_read(paddr) & 0x00040000)) ; bcm2835_peri_write_nb(fifo, tbuf[i]); while (bcm2835_peri_read(paddr) & 0x00020000) (void) bcm2835_peri_read_nb(fifo); } while (!(bcm2835_peri_read_nb(paddr) & 0x00010000)) { while (bcm2835_peri_read(paddr) & 0x00020000) (void) bcm2835_peri_read_nb(fifo); }; bcm2835_peri_set_bits(paddr, 0, 0x00000080); }
void print_number(uint *param_1) { if (param_1 == (uint *)0x0) { putchar(10); return; } do { printf("%d ",(ulong)*param_1); param_1 = *(uint **)(param_1 + 2); } while (param_1 != (uint *)0x0); putchar(10); return; }
void print_number (node * l) { while (l) { printf ("%d ", l->d); l = l->next; } printf ("\n"); }
undefined4 * json_int(undefined4 param_1) { undefined4 uVar1; void *pvVar2; undefined4 *puVar3; pvVar2 = malloc(4); uVar1 = INTTYPE; if ((int)pvVar2 != 0) { puVar3 = (undefined4 *)(long)(int)pvVar2; *puVar3 = param_1; puVar3[1] = uVar1; return puVar3; } return (undefined4 *)0x0; }
JSON json_int(int i) { JSON result = (JSON)malloc(sizeof(JSON_node)); if(! result) return NULL; result->type=INTTYPE; result->iVal=i; return result; }
void test(int param_1,int param_2) { int iVar1; int iVar2; int iVar3; int iVar4; if (param_1 < 1) { iVar2 = 1; if (0 < param_2) { do { hash(1); iVar3 = iVar2 + 1; hash(iVar2); iVar2 = iVar3; } while (iVar3 != param_2 + 1); return; } } else if (0 < param_2) { iVar2 = param_1 + -1; iVar3 = param_1 * 2; iVar4 = 1; if (iVar2 != iVar3 && SBORROW4(iVar2,iVar3) == iVar2 + param_1 * -2 < 0) { iVar2 = iVar3; } do { if (param_1 <= iVar4) { hash(1); hash(iVar4); } if (iVar4 <= iVar2) { hash(1); hash(iVar4); } iVar3 = 1; do { hash(2); hash(iVar4); iVar1 = iVar3 + 1; hash(iVar3); iVar3 = iVar1; } while (param_1 + 1 != iVar1); iVar4 = iVar4 + 1; } while (iVar4 != param_2 + 1); } return; }
void test(int m, int n) { int i, j; if (m >= 1) { for (i=1;i<=n;i++) { if (i >= m) { { hash(1); hash(i); } ; } if (i <= ((2*m) < (m-1) ? (2*m) : (m-1))) { { hash(1); hash(i); } ; } for (j=1;j<=m;j++) { { hash(2); hash(i); hash(j); } ; } } } if (m <= 0) { for (i=1;i<=n;i++) { { hash(1); hash(i); } ; } } }
undefined4 * quicly_encode_path_challenge_frame(undefined4 *param_1,int param_2,void *param_3) { undefined4 uVar1; uVar1 = QUICLY_FRAME_TYPE_PATH_RESPONSE; if (param_2 == 0) { uVar1 = QUICLY_FRAME_TYPE_PATH_CHALLENGE; } *param_1 = uVar1; memcpy(param_1 + 1,param_3,(ulong)QUICLY_PATH_CHALLENGE_DATA_LEN); return param_1 + 1 + (int)QUICLY_PATH_CHALLENGE_DATA_LEN; }
uint8_t *quicly_encode_path_challenge_frame(uint8_t *dst, int is_response, const uint8_t *data) { *dst++ = is_response ? QUICLY_FRAME_TYPE_PATH_RESPONSE : QUICLY_FRAME_TYPE_PATH_CHALLENGE; memcpy(dst, data, QUICLY_PATH_CHALLENGE_DATA_LEN); dst += QUICLY_PATH_CHALLENGE_DATA_LEN; return dst; }
void fixup_post_op(undefined8 param_1,int param_2) { if ((AST_POSTINC != param_2) && (AST_POSTDEC != param_2)) { return; } bcode_op(param_1,OP_UNSTASH); return; }
void fixup_post_op(struct bcode_builder *bbuilder, enum ast_tag tag) { if (tag == AST_POSTINC || tag == AST_POSTDEC) { bcode_op(bbuilder, OP_UNSTASH); } }
void display_bitmap(void) { drawBitmap(0x1e,0x10,logo16_glcd_bmp,0x10,0x10,1); return; }
void display_bitmap() { drawBitmap(30, 16, logo16_glcd_bmp, 16, 16, 1); }
void sylvan_storm_rational_number_equal_norm_rel_d_WRAP (undefined8 param_1,undefined8 param_2,undefined4 *param_3) { undefined4 uVar1; uVar1 = sylvan_storm_rational_number_equal_norm_rel_d_CALL (param_1,param_2,param_3[2],param_3[1],*param_3); param_3[3] = uVar1; return; }
void sylvan_storm_rational_number_equal_norm_rel_d_WRAP(WorkerP *w, Task *__dq_head, TD_sylvan_storm_rational_number_equal_norm_rel_d *t __attribute__((unused))) { t->d.res = sylvan_storm_rational_number_equal_norm_rel_d_CALL(w, __dq_head , t->d.args.arg_1, t->d.args.arg_2, t->d.args.arg_3);}
bool CreateUdpSock(int *param_1,int param_2) { uint16_t uVar1; int iVar2; undefined6 extraout_var; int extraout_var_00; long in_FS_OFFSET; undefined local_2c [20]; local_2c._12_8_ = *(long *)(in_FS_OFFSET + 0x28); assert(0 < param_2 && param_1 != (int *)0x0); memset((sockaddr *)local_2c,0,0xc); local_2c._8_4_ = AF_INET; local_2c._4_4_ = htonl(INADDR_ANY); uVar1 = htons((uint16_t)param_2); local_2c._0_4_ = (undefined4)CONCAT62(extraout_var,uVar1); iVar2 = socket(AF_INET,SOCK_DGRAM,0); *param_1 = iVar2; assert(0 < iVar2); bind(*param_1,(sockaddr *)local_2c,0xc); if (extraout_var_00 < 0) { close(*param_1); } if (local_2c._12_8_ == *(long *)(in_FS_OFFSET + 0x28)) { return extraout_var_00 < 0; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
int CreateUdpSock(int *pnSock,int nPort) { struct sockaddr_in addrin; struct sockaddr *paddr = (struct sockaddr *)&addrin; assert(pnSock != NULL && nPort > 0); memset(&addrin,0,sizeof(addrin)); addrin.sin_family = AF_INET; addrin.sin_addr.s_addr = htonl(INADDR_ANY); addrin.sin_port = htons(nPort); assert((*pnSock = socket(AF_INET,SOCK_DGRAM,0)) > 0); if(bind(*pnSock,paddr,sizeof(addrin)) >= 0) return 0; else { close(*pnSock); return 1; } }
void play_undo(long *param_1) { long lVar1; if (*param_1 < 1) { return; } play_stop_pondering(); pthread_mutex_lock((pthread_mutex_t *)param_1[2]); play_force_restore(param_1); lVar1 = *param_1; *param_1 = lVar1 + -1; board_restore(*(undefined4 *)(param_1 + 4),param_1[3] + (lVar1 + -1) * 4); *(uint *)(param_1 + 1) = *(uint *)(param_1 + 1) ^ 1; pthread_mutex_unlock((pthread_mutex_t *)param_1[2]); return; }
void play_undo(Play *play) { if (play->i_game > 0) { play_stop_pondering(play); pthread_mutex_lock(&(play->ponder)->lock); play_force_restore(play); board_restore(play->board, &play->game[--play->i_game]); play->player ^= 1; pthread_mutex_unlock(&(play->ponder)->lock); } }
void SET_OP(uint param_1,long param_2,long param_3,undefined4 param_4,undefined4 param_5) { long *plVar1; if (599 < param_1) { Fail("/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/106ohm/eigengraph/refs/heads/develop/cilk-5.4.6/cilk2c/operators.c" ,0x30,"i >= 0 && i < MAX_OPERATORS"); } plVar1 = (long *)(Operator + (long)(int)param_1 * 0x20); if (*plVar1 != 0) { Fail("/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/106ohm/eigengraph/refs/heads/develop/cilk-5.4.6/cilk2c/operators.c" ,0x31,"Operator[i].text == NULL"); plVar1 = (long *)(Operator + (long)(int)param_1 * 0x20); } *plVar1 = param_2; plVar1[1] = param_3; *(undefined4 *)(plVar1 + 2) = 1; *(undefined4 *)((long)plVar1 + 0x14) = param_4; *(undefined4 *)(plVar1 + 3) = param_5; return; }
void SET_OP(int i, const char *text, const char *name, int unary, int binary) { ((i >= 0 && i < 600) ? (void)0 : (void)Fail("/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/106ohm/eigengraph/refs/heads/develop/cilk-5.4.6/cilk2c/operators.c", 48, "i >= 0 && i < MAX_OPERATORS")); ((Operator[i].text == NULL) ? (void)0 : (void)Fail("/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/106ohm/eigengraph/refs/heads/develop/cilk-5.4.6/cilk2c/operators.c", 49, "Operator[i].text == NULL")); Operator[i].text = text; Operator[i].name = name; Operator[i].left_assoc = 1; Operator[i].unary_prec = unary; Operator[i].binary_prec = binary; }
ulong afs_fs_set_lock(undefined8 param_1,uint32_t *param_2,uint32_t *param_3,uint32_t param_4, undefined8 param_5) { uint32_t *puVar1; undefined4 uVar2; uint16_t uVar3; uint32_t uVar4; uint32_t **ppuVar5; undefined6 extraout_var; ulong uVar6; _enter(&_LC0); ppuVar5 = (uint32_t **)afs_alloc_flat_call(&afs_RXFSSetLock,0x14,0x18); uVar2 = AFS_FS_PORT; if (ppuVar5 != (uint32_t **)0x0) { ppuVar5[2] = param_3; ppuVar5[3] = param_2; *(undefined4 *)((long)ppuVar5 + 0xc) = FS_SERVICE; uVar3 = htons((uint16_t)uVar2); uVar4 = FSSETLOCK; puVar1 = *ppuVar5; *(int *)(ppuVar5 + 1) = (int)CONCAT62(extraout_var,uVar3); uVar4 = htonl(uVar4); *puVar1 = uVar4; uVar4 = htonl(param_3[2]); puVar1[1] = uVar4; uVar4 = htonl(param_3[1]); puVar1[2] = uVar4; uVar4 = htonl(*param_3); puVar1[3] = uVar4; uVar4 = htonl(param_4); puVar1[4] = uVar4; uVar6 = afs_make_call(param_1,ppuVar5,GFP_NOFS,param_5); return uVar6; } return (ulong)(uint)-ENOMEM; }
int afs_fs_set_lock(struct afs_server *server, struct key *key, struct afs_vnode *vnode, afs_lock_type_t type, const struct afs_wait_mode *wait_mode) { struct afs_call *call; __be32 *bp; _enter(""); call = afs_alloc_flat_call(&afs_RXFSSetLock, 5 * 4, 6 * 4); if (!call) return -ENOMEM; call->key = key; call->reply = vnode; call->service_id = FS_SERVICE; call->port = htons(AFS_FS_PORT); /* marshall the parameters */ bp = call->request; *bp++ = htonl(FSSETLOCK); *bp++ = htonl(vnode->fid.vid); *bp++ = htonl(vnode->fid.vnode); *bp++ = htonl(vnode->fid.unique); *bp++ = htonl(type); return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode); }
size_t mbrlen(char *__s,size_t __n,mbstate_t *__ps) { size_t sVar1; ulong local_10; for (local_10 = 0; (sVar1 = __n, local_10 < __n && (sVar1 = local_10, __s[local_10] != '\0')); local_10 = local_10 + 1) { } return sVar1; }
size_t mbrlen(const char * __restrict p, size_t l, mbstate_t * __restrict v) { size_t i; for (i = 0; i < l; i++) if (p[i] == '\0') return i; return l; }
void flush_stream(char *param_1) { size_t sVar1; sVar1 = strlen(param_1); fioWrite(1,param_1,sVar1 & 0xffffffff); return; }
void flush_stream(const char* buffer) { const char* begin = buffer; const char* end = begin + strlen(begin); # 201 "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/emoon/Score/refs/heads/master/old/src/target/ps2/ee/libc/Stdio/printf.c" fioWrite(1, begin, end - begin); }
int sas7bdat_count_meta_pages(undefined8 *param_1) { long *plVar1; int *piVar2; long *plVar3; int local_40; int local_3c; ulong local_38; plVar1 = (long *)((int **)*param_1)[1]; piVar2 = *(int **)*param_1; local_3c = 1; local_38 = *plVar1 - plVar1[1]; local_40 = *piVar2; while (local_40 = local_40 + -1, -1 < local_40) { plVar3 = *(long **)(*(long *)(piVar2 + 2) + (long)local_40 * 8); if (local_38 < (ulong)(plVar1[2] + *plVar3)) { local_38 = *plVar1 - plVar1[1]; local_3c = local_3c + 1; } local_38 = local_38 - (plVar1[2] + *plVar3); } return local_3c; }
int32_t sas7bdat_count_meta_pages(readstat_writer_t *writer) { sas7bdat_write_ctx_t *ctx = (sas7bdat_write_ctx_t *)writer->module_ctx; sas_header_info_t *hinfo = ctx->hinfo; sas7bdat_subheader_array_t *sarray = ctx->sarray; int i; int pages = 1; size_t bytes_left = hinfo->page_size - hinfo->page_header_size; size_t shp_ptr_size = hinfo->subheader_pointer_size; for (i=sarray->count-1; i>=0; i--) { sas7bdat_subheader_t *subheader = sarray->subheaders[i]; if (subheader->len + shp_ptr_size > bytes_left) { bytes_left = hinfo->page_size - hinfo->page_header_size; pages++; } bytes_left -= (subheader->len + shp_ptr_size); } return pages; }
double rho(double param_1) { double dVar1; double dVar2; double dVar3; double dVar4; double dVar5; if (M + c1 < param_1) { return ((c1 * _LC0 + M * __LC1) * c1) / __LC2 + M * M * _LC3; } if (M <= param_1) { dVar3 = param_1 * param_1; dVar5 = dVar3 * dVar3; dVar1 = c1 * c1; dVar4 = dVar1 * dVar1; dVar2 = M * M; return (dVar3 * dVar5) / (dVar4 * __LC8) + ((((dVar2 * _LC6) / (dVar4 + dVar4) - _LC7 / (dVar1 + dVar1)) * dVar5 + (((dVar2 * dVar2) / (dVar4 + dVar4) + _LC3) - dVar2 / dVar1) * dVar3 + (dVar2 * _LC3 - (((dVar2 * dVar2 - dVar2 * _LC0 * dVar1) + dVar4 * __LC5) * dVar2) / (dVar4 * __LC2)) + ((M * _LC4) / (dVar1 * _LC6) - (M * _LC4 * dVar2) / (dVar4 * _LC6)) * param_1 * dVar3) - (M * _LC4 * param_1 * dVar5) / (_LC0 * dVar4)); } return param_1 * param_1 * _LC3; }
double rho(double d) { double d2,c2,c4,d4,M2,M4; double retval; if (d > (M + c1)) return(M*M/2. + c1 * (5.*c1 + 16.*M)/30.); else if (d >= M) { d2 = d*d; d4 = d2*d2; c2 = c1*c1; c4 = c2*c2; M2 = M*M; M4 = M2*M2; retval = M2/2. - M2 * (M4 - 5.*M2*c2 + 15.*c4)/(30.*c4) +d2*(0.5 + M4/(2*c4) - M2/c2) +d*d2*(4*M/(3*c2) - 4*M2*M/(3*c4)) +d4*(3*M2/(2*c4) - 1/(2*c2)) -4*M*d*d4/(5*c4) + d4*d2/(6*c4); return(retval); } else return(d*d/2.); }
void m68k_op_ori_16_pi(void) { uint uVar1; undefined4 uVar2; uint uVar3; undefined4 uVar4; uVar1 = OPER_I_16(); uVar2 = EA_AY_PI_16(); uVar3 = m68ki_read_16(uVar2); uVar4 = MASK_OUT_ABOVE_16(uVar3 | uVar1); m68ki_write_16(uVar2,uVar4); FLAG_N = NFLAG_16(uVar4); FLAG_Z = uVar4; FLAG_C = CFLAG_CLEAR; FLAG_V = VFLAG_CLEAR; return; }
void m68k_op_ori_16_pi(void) { uint src = OPER_I_16(); uint ea = EA_AY_PI_16(); uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea)); m68ki_write_16(ea, res); FLAG_N = NFLAG_16(res); FLAG_Z = res; FLAG_C = CFLAG_CLEAR; FLAG_V = VFLAG_CLEAR; }
int fl_fread_sector(long param_1,int param_2,int param_3,uint *param_4) { uint uVar1; long lVar2; int local_2c; int local_28; int local_24; local_24 = 0; if (_filelib_init == 0) { fl_init(); } if (((param_1 == 0) || (param_4 == (uint *)0x0)) || (param_2 * param_3 != 0x200)) { local_24 = -1; } else if ((*param_4 & 1) == 0) { local_24 = -1; } else if ((int)param_4[1] < (int)param_4[2]) { local_28 = 0x200; if ((int)param_4[2] < (int)(param_4[1] + 0x200)) { local_28 = param_4[2] - param_4[1]; } uVar1 = param_4[1]; if ((int)uVar1 < 0) { uVar1 = uVar1 + 0x1ff; } if ((int)param_4[1] % 0x200 == 0) { lVar2 = _read_sector(param_4,(long)((int)uVar1 >> 9),param_1); if (lVar2 != 0) { local_2c = 0x200; if (local_28 < 0x200) { local_2c = local_28; } param_4[1] = param_4[1] + local_2c; local_24 = local_2c; } } else { local_24 = -1; } } else { local_24 = -1; } return local_24; }
int fl_fread_sector(unsigned char *buffer, int size, int length, void *f ) { unsigned long sector; unsigned long offset; int copyCount; int count = size * length; int bytesRead = 0; FL_FILE *file = (FL_FILE *)f; { if (_filelib_init==0) fl_init(); }; if (buffer==0 || file==0 || count != 512) return -1; if (!(file->flags & (1 << 0))) return -1; if (file->bytenum >= file->filelength) return -1; if ( (file->bytenum + count) > file->filelength ) count = file->filelength - file->bytenum; sector = file->bytenum / 512; offset = file->bytenum % 512; if (offset != 0) return -1; if (_read_sector(file, sector, buffer)) { copyCount = 512; if (copyCount > (count - bytesRead)) copyCount = (count - bytesRead); bytesRead = copyCount; file->bytenum += copyCount; } return bytesRead; }
void test_diff_racediffiter__cleanup(void) { cl_git_sandbox_cleanup(); return; }
void test_diff_racediffiter__cleanup(void) { cl_git_sandbox_cleanup(); }
void m68k_op_suba_32_d(void) { int *piVar1; piVar1 = (int *)(m68k._0_8_ + 0x20 + (ulong)((int)m68k._8_4_ >> 9 & 7) * 4); *piVar1 = *piVar1 - *(int *)(m68k._0_8_ + (ulong)(m68k._8_4_ & 7) * 4); return; }
void m68k_op_suba_32_d(void) { unsigned int* r_dst = &((m68k.dar+8)[(m68k.ir >> 9) & 7]); *r_dst = (*r_dst - (m68k.dar[m68k.ir & 7])); }
undefined4 AppLayer_start_transfer(int *param_1) { undefined4 uVar1; if (param_1 == (int *)0x0) { uVar1 = 0xffffffff; } else if (*param_1 == 0x80) { uVar1 = AppLayer_send(); } else { uVar1 = 0; if (*param_1 == 0x81) { uVar1 = AppLayer_receive(); llread(param_1[1],0); } } return uVar1; }
int AppLayer_start_transfer(AppLayer* app) { if (app == NULL) return -1; switch(app->status) { case CONN_RECEIVER: { int res = AppLayer_receive(app); llread(app->fd, NULL); return res; break; } case CONN_TRANSMITTER: return AppLayer_send(app); break; } return 0; }
void strings_split_by_string_up_to(void) { strings_split_by_string_up_to_imp(); return; }
List * strings_split_by_string_up_to(char * string, char * split, unsigned int count) { return strings_split_by_string_up_to_imp(string, split, count, strings_bounded_equals); }
char * c_strrstr(char *param_1,char *param_2) { int iVar1; size_t sVar2; undefined4 extraout_var; char *__s1; sVar2 = strlen(param_1); __s1 = param_1 + (long)(int)sVar2 + -1; do { if (__s1 < param_1) { return (char *)0x0; } if (*__s1 == *param_2) { sVar2 = strlen(param_2); iVar1 = memcmp(__s1,param_2,sVar2 & 0xffffffff); if (CONCAT44(extraout_var,iVar1) == 0) { return __s1; } } __s1 = __s1 + -1; } while( true ); }
char * c_strrstr(const char *s, const char *str) { char *p; int len = strlen(s); for (p = s + len - 1; p >= s; p--) { if ((*p == *str) && (memcmp(p, str, strlen(str)) == 0)) { return p; } } return NULL; }
void main(int param_1,long param_2) { ulong uVar1; ulong uVar2; ulong uVar3; long lVar4; long lVar5; if (param_1 != 4) { errx(1); } uVar1 = strtoul(*(char **)(param_2 + 8),(char **)0x0,0x10); uVar2 = strtoul(*(char **)(param_2 + 0x10),(char **)0x0,0x10); uVar3 = strtoul(*(char **)(param_2 + 0x18),(char **)0x0,0x10); printf("victim 0x%lx - gadget 0x%lx - target 0x%lx\n",uVar2,uVar1,uVar3); lVar4 = map_file_copy(binary_path,binary_base,0x2000); put64(lVar4 + uVar1,0xc3); lVar5 = map_at(binary_base + uVar3 & 0xfffffffffffff000,0x1000,PROT_READ | PROT_WRITE); put64(lVar5,binary_base + uVar1); put64((ulong)((uint)uVar3 & 0xfff) + lVar5,lVar5); do { (*(code *)(lVar4 + uVar2))(); } while( true ); }
int main(int argc, char *argv[]) { if (argc != 4) errx(1, "usage: ./attacker <gadget> <victim> <target>"); uint64_t gadget = strtoul(argv[1], NULL, 16); uint64_t victim = strtoul(argv[2], NULL, 16); uint64_t target = strtoul(argv[3], NULL, 16); printf("victim 0x%lx - gadget 0x%lx - target 0x%lx\n", victim, gadget, target); char *binary = map_file_copy(binary_path, binary_base, 0x2000); put64(&binary[gadget], 0xc3); char *binary_got = map_at((binary_base + target) & ~(0x1000 -1), 0x1000, PROT_READ|PROT_WRITE); put64(&binary_got[0x0], binary_base + gadget); put64(&binary_got[target & (0x1000 -1)], (uint64_t)&binary_got[0]); void (*bti)() = (void (*)())&binary[victim]; while (1) bti(); return 0; }
undefined8 a_exec(long *param_1) { long *plVar1; long lVar2; if ((param_1 != (long *)0x0) && (lVar2 = *param_1, lVar2 != 0)) { plVar1 = param_1 + 1; do { spawn(lVar2); lVar2 = *plVar1; plVar1 = plVar1 + 1; } while (lVar2 != 0); return 0; } return 0; }
int a_exec(char * opt[]) { int i; if(opt) for(i=0; opt[i]; i++) if(opt[i]) spawn(opt[i]); return 0; }
void builder_strCopy(void) { undefined4 uVar1; uVar1 = builder_str(); str_copy(uVar1); return; }
String builder_strCopy(Builder builder) { return str_copy(builder_str(builder)); }
undefined8 undefined_1453(void) { return *(undefined8 *)(functions + 0x2d68); }
void* undefined_1453 () { return (void*)functions[1453].pointer; }
void puterrno(undefined8 param_1,ulong param_2,char *param_3) { fprintf((FILE *)(ulong)stderr,"%s:%d: ",param_1,param_2 & 0xffffffff); perror(param_3); return; }
void puterrno(const char *file, int line, const char *msg) { (void)fprintf(stderr, "%s:%d: ", file, line); perror(msg); }