instruction
stringlengths
27
1.88k
output
stringlengths
21
2.78k
void print_device_serial_ports(uint *param_1) { undefined8 uVar1; uint uVar2; uint uVar3; undefined8 uVar4; undefined *puVar5; uint local_30; if (*param_1 != 0) { puts("Serial ports"); printf_line(0x40); printf(" | ### | x | Dir | %-18s | %-18s | s |\n","Serial port","Connected serial"); printf_line(0x40); for (local_30 = 0; local_30 < *param_1; local_30 = local_30 + 1) { uVar2 = format_status(*(undefined4 *)((ulong)local_30 * 0x18 + *(long *)(param_1 + 2) + 0xc)); if (*(int *)((ulong)local_30 * 0x18 + *(long *)(param_1 + 2) + 8) == -1) { puVar5 = &DAT_00100232; } else { puVar5 = *(undefined **) ((ulong)*(uint *)((ulong)local_30 * 0x18 + *(long *)(param_1 + 2) + 8) * 0x18 + *(long *)(param_1 + 2)); } uVar1 = *(undefined8 *)((ulong)local_30 * 0x18 + *(long *)(param_1 + 2)); uVar4 = dir2opt(*(undefined4 *)((ulong)local_30 * 0x18 + *(long *)(param_1 + 2) + 0x10)); uVar3 = port_lock_symbol(*(undefined4 *) ((ulong)local_30 * 0x18 + *(long *)(param_1 + 2) + 0x14)); printf(" | %3d | %c | %4s | %-18s | %-18s | %c |\n",(ulong)(local_30 + 1),(ulong)uVar3,uVar4, uVar1,puVar5,(ulong)uVar2); } printf_line(0x40); putchar(10); } return; }
void print_device_serial_ports(struct videohub_data *d) { unsigned int i, len = 64; if (!d->serial.num) return; printf("Serial ports\n"); printf_line(len); printf(" | ### | x | Dir | %-18s | %-18s | s |\n", "Serial port", "Connected serial"); printf_line(len); for(i = 0; i < d->serial.num; i++) { printf(" | %3d | %c | %4s | %-18s | %-18s | %c |\n", i + 1, port_lock_symbol(d->serial.port[i].lock), dir2opt(d->serial.port[i].direction), d->serial.port[i].name, d->serial.port[i].routed_to == ((unsigned int) -1) ? "" : d->serial.port[d->serial.port[i].routed_to].name, format_status(d->serial.port[i].status) ); } printf_line(len); printf("\n"); }
void enter_room(undefined4 param_1,undefined4 param_2,undefined8 *param_3,undefined8 param_4) { int iVar1; long lVar2; char *__format; long in_FS_OFFSET; undefined8 local_a0; char local_98 [104]; long local_30; local_30 = *(long *)(in_FS_OFFSET + 0x28); bzero(local_98,100); parse_data_one_arg(param_2,&local_a0); lVar2 = linkedlist_search_userexist(*param_3,param_2,local_a0); if (lVar2 == 0) { iVar1 = linkedlist_enter_room(param_3,param_2,local_a0,param_4); if (iVar1 == 0) { write_socket(param_1,param_2,0x4e,"Room is full or doesn\'t exist\n\n"); goto LAB_00100085; } __format = "Successfully connected to room %s\n\n"; } else { __format = "Already inside room %s\n\n"; } sprintf(local_98,__format,local_a0); write_socket(param_1,param_2,0x53,local_98); LAB_00100085: if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) { return; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
void enter_room (int client_socket, struct frame frame_info, struct room **rooms, struct node *list) { char *room_name, str[100]; bzero (str, 100); parse_data_one_arg (frame_info, &room_name); if (linkedlist_search_userexist (*rooms, frame_info.origin, room_name)) { sprintf (str, "Already inside room %s\n\n", room_name); write_socket (client_socket, frame_info.origin, 'S', str); } else if (!linkedlist_enter_room (rooms, frame_info.origin, room_name, list)) { write_socket (client_socket, frame_info.origin, 'N', "Room is full or doesn't exist\n\n"); } else { sprintf (str, "Successfully connected to room %s\n\n", room_name); write_socket (client_socket, frame_info.origin, 'S', str); } }
void windup(undefined8 *param_1) { *param_1 = 0; sc_open(); return; }
void windup(struct sc_stack *stp) { stp->top=0; sc_open(stp); }
void dtrace_aggregate_count(long *param_1) { *param_1 = *param_1 + 1; return; }
void dtrace_aggregate_count(uint64_t *oval, uint64_t nval, uint64_t arg) { #pragma unused(nval, arg) /* __APPLE__ */ *oval = *oval + 1; }
double swlog2(double __x) { double dVar1; dVar1 = log2(__x); return dVar1; }
double __attribute__((overloadable)) swlog2(double arg1) { return log2(arg1); }
undefined4 poolGetConnReqTime(void) { return *(undefined4 *)(*m_pShm + m_nMySlotId * 4); }
time_t poolGetConnReqTime(void) { if (m_nMySlotId < 0) return -1; return m_pShm->child[m_nMySlotId].conn.tvReqTime.tv_sec; }
void resource_allocation_groupID_set(void) { return; }
void resource_allocation_groupID_set(struct spu *spu, u64 id) { /* No support. */ }
ulong rtl8367c_getAsic1xProcConfig(int param_1,undefined8 param_2) { ulong uVar1; int iVar2; if (10 < param_1) { return (ulong)RT_ERR_PORT_ID; } iVar2 = RTL8367C_DOT1X_PORT0_UNAUTHBH_MASK << ((char)param_1 * '\x02' & 0xeU); if (param_1 < 8) { uVar1 = rtl8367c_getAsicRegBits(RTL8367C_REG_DOT1X_UNAUTH_ACT_W0,iVar2,param_2); return uVar1; } uVar1 = rtl8367c_getAsicRegBits(RTL8367C_REG_DOT1X_UNAUTH_ACT_W1,iVar2,param_2); return uVar1; }
ret_t rtl8367c_getAsic1xProcConfig(rtk_uint32 port, rtk_uint32* pProc) { if(port >= 11) return RT_ERR_PORT_ID; if(port < 8) return rtl8367c_getAsicRegBits(RTL8367C_REG_DOT1X_UNAUTH_ACT_W0, (RTL8367C_DOT1X_PORT0_UNAUTHBH_MASK << ((port & 0x7) << 1)),pProc); else return rtl8367c_getAsicRegBits(RTL8367C_REG_DOT1X_UNAUTH_ACT_W1, (RTL8367C_DOT1X_PORT0_UNAUTHBH_MASK << ((port & 0x7) << 1)),pProc); }
undefined8 * rbsize_init(undefined8 *param_1) { undefined8 uVar1; undefined8 uVar2; undefined4 in_R9D; long in_FS_OFFSET; int param_7; undefined4 param_8; undefined4 uStack_54; undefined8 auStack_30 [2]; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); SetRect(auStack_30); uVar1 = heap_alloc_zero(param_7 * 4); uVar2 = heap_alloc_zero(param_8); param_1[2] = 0; param_1[3] = uVar1; *param_1 = CONCAT44(uStack_54,in_R9D); param_1[1] = uVar2; param_1[4] = 0; param_1[5] = auStack_30[0]; if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return param_1; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
rbsize_result_t rbsize_init(int cleft, int ctop, int cright, int cbottom, int cyBarHeight, int nRows, int nBands) { rbsize_result_t ret; SetRect(&ret.rcClient, cleft, ctop, cright, cbottom); ret.cyBarHeight = cyBarHeight; ret.nRows = 0; ret.cyRowHeights = heap_alloc_zero(nRows * sizeof(int)); ret.nBands = 0; ret.bands = heap_alloc_zero(nBands * sizeof(*ret.bands)); return ret; }
undefined8 sgsstd_chr(undefined8 param_1) { undefined8 uVar1; long in_FS_OFFSET; undefined local_21; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); sgs_FuncName(param_1,&_LC0); uVar1 = sgs_LoadArgs(param_1,&_LC1,&local_21); if ((int)uVar1 != 0) { sgs_PushStringBuf(param_1,&local_21,1); uVar1 = 1; } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return uVar1; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
int sgsstd_chr( sgs_Context* C ) { char c; sgs_FuncName( C, "chr" ); if( !sgs_LoadArgs( C, "c", &c ) ) return 0; sgs_PushStringBuf( C, &c, 1 ); return 1; }
int isl29018_write_raw(undefined8 param_1,int *param_2,int param_3,int param_4,long param_5) { int *piVar1; int iVar2; piVar1 = (int *)iio_priv(); iVar2 = -EINVAL; mutex_lock(piVar1 + 2); if (*(long *)(piVar1 + 4) == 0) { if (param_5 == 0x81) { if ((*param_2 == IIO_LIGHT) && (param_3 == 0)) { iVar2 = isl29018_set_integration_time(piVar1,param_4); } } else if (param_5 == 0x82) { if (*param_2 == IIO_LIGHT) { *piVar1 = param_3; iVar2 = 0; piVar1[1] = param_4; } } else if ((param_5 == 0x80) && (*param_2 == IIO_LIGHT)) { iVar2 = isl29018_set_scale(piVar1,param_3,param_4); } } else { iVar2 = -EBUSY; } mutex_unlock(piVar1 + 2); return iVar2; }
int isl29018_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int val, int val2, long mask) { struct isl29018_chip *chip = iio_priv(indio_dev); int ret = -EINVAL; mutex_lock(&chip->lock); if (chip->suspended) { ret = -EBUSY; goto write_done; } switch (mask) { case IIO_CHAN_INFO_CALIBSCALE: if (chan->type == IIO_LIGHT) { chip->calidirale = val; chip->ucalidirale = val2; ret = 0; } break; case IIO_CHAN_INFO_INT_TIME: if (chan->type == IIO_LIGHT && !val) ret = isl29018_set_integration_time(chip, val2); break; case IIO_CHAN_INFO_SCALE: if (chan->type == IIO_LIGHT) ret = isl29018_set_scale(chip, val, val2); break; default: break; } write_done: mutex_unlock(&chip->lock); return ret; }
long * set_exact_size_cag_float_dlist(undefined8 *param_1) { long *plVar1; long **pplVar2; plVar1 = (long *)set_min_size_cag_float_dlist(); if (plVar1 != (long *)0x0) { pplVar2 = (long **)*param_1; if (*plVar1 != 0) { erase_range_cag_float_dlist(param_1); pplVar2 = (long **)*param_1; } plVar1 = *pplVar2; } return plVar1; }
it_cag_float_dlist set_exact_size_cag_float_dlist(cag_float_dlist *dlist, const size_t size) { it_cag_float_dlist it; it = set_min_size_cag_float_dlist(dlist, size); if (it) { if (it->next) erase_range_cag_float_dlist(dlist, it->next, (dlist)->end_); } else { return NULL; } return (dlist)->end_->prev; }
int lpfc_sli4_mq_put(ulong *param_1,undefined8 param_2) { undefined8 uVar1; undefined4 uVar2; int iVar3; long lVar4; long in_FS_OFFSET; undefined8 local_28; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); lVar4 = unlikely(param_1 == (ulong *)0x0); if (lVar4 == 0) { if ((*param_1 + 1) % (ulong)(long)*(int *)(param_1 + 1) != (long)*(int *)((long)param_1 + 0xc)) { uVar1 = *(undefined8 *)(param_1[5] + *param_1 * 8); lpfc_sli_pcimem_bcopy(param_2,uVar1,*(undefined4 *)(param_1 + 4)); uVar2 = lpfc_mq_doorbell_num_posted; iVar3 = *(int *)(param_1 + 1); local_28 = 0; *(undefined8 *)(param_1[3] + 8) = uVar1; *param_1 = (*param_1 + 1) % (ulong)(long)iVar3; bf_set(uVar2,&local_28,1); bf_set(lpfc_mq_doorbell_id,&local_28,*(undefined4 *)(param_1 + 2)); writel(local_28,*(undefined4 *)param_1[3]); iVar3 = 0; goto LAB_001000d8; } } iVar3 = -ENOMEM; LAB_001000d8: if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return iVar3; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
uint32_t lpfc_sli4_mq_put(struct lpfc_queue *q, struct lpfc_mqe *mqe) { struct lpfc_mqe *temp_mqe; struct lpfc_register doorbell; uint32_t host_index; /* sanity check on queue memory */ if (unlikely(!q)) return -ENOMEM; temp_mqe = q->qe[q->host_index].mqe; /* If the host has not yet processed the next entry then we are done */ if (((q->host_index + 1) % q->entry_count) == q->hba_index) return -ENOMEM; lpfc_sli_pcimem_bcopy(mqe, temp_mqe, q->entry_size); /* Save off the mailbox pointer for completion */ q->phba->mbox = (MAILBOX_t *)temp_mqe; /* Update the host index before invoking device */ host_index = q->host_index; q->host_index = ((q->host_index + 1) % q->entry_count); /* Ring Doorbell */ doorbell.word0 = 0; bf_set(lpfc_mq_doorbell_num_posted, &doorbell, 1); bf_set(lpfc_mq_doorbell_id, &doorbell, q->queue_id); writel(doorbell.word0, q->phba->sli4_hba.MQDBregaddr); return 0; }
void max7359_close(undefined8 param_1) { undefined4 *puVar1; puVar1 = (undefined4 *)input_get_drvdata(param_1); max7359_fall_deepsleep(*puVar1); return; }
void max7359_close(struct input_dev *dev) { struct max7359_keypad *keypad = input_get_drvdata(dev); max7359_fall_deepsleep(keypad->client); }
void J4AC_tv_danmaku_ijk_media_player_misc_IMediaDataSource__readAt (undefined8 *param_1,undefined8 param_2,undefined4 param_3,undefined4 param_4, undefined4 param_5,undefined8 param_6) { (**(code **)*param_1) (param_1,param_2,class_J4AC_tv_danmaku_ijk_media_player_misc_IMediaDataSource,param_3, param_4,param_5,param_6); return; }
jint J4AC_tv_danmaku_ijk_media_player_misc_IMediaDataSource__readAt(JNIEnv *env, jobject thiz, jlong position, jbyteArray buffer, jint offset, jint size) { return (*env)->CallIntMethod(env, thiz, class_J4AC_tv_danmaku_ijk_media_player_misc_IMediaDataSource.method_readAt, position, buffer, offset, size); }
int lshift(int param_1,byte param_2) { return param_1 << (param_2 & 0x1f); }
uint8_t lshift(uint8_t op1, uint8_t op2) { return op1 << op2; }
ColorMode3i(undefined8 *param_1,int param_2,undefined4 param_3,undefined4 param_4,undefined4 param_5 ) { undefined8 uVar1; long lVar2; long lVar3; if ((param_2 == 1) || (param_2 == 3)) { uVar1 = *param_1; lVar2 = command_format_json(&DAT_001000c7,"%d %d %d %d",param_2,param_3,param_4,param_5); if (lVar2 == 0) { uVar1 = 0xffffffff; } else { lVar3 = command_send(lVar2,uVar1); if (lVar3 == 0) { uVar1 = 0; } else { command_free(lVar2); uVar1 = 0xffffffff; } } } else { uVar1 = 0xffffffff; } return uVar1; }
int ColorMode3i(Display *display, int mode, int r0, int r1, int r2) { if (mode != 1 && mode != 3) { return -1; } Command *cmd = NULL; Socket *socket = NULL; socket = display->socket; cmd = command_format_json("CM_D", "%d %d %d %d", mode, r0, r1, r2); if (cmd == NULL) return -1; if (command_send(cmd, socket) != 0) { command_free(cmd); return -1; } return 0; }
void radix__local_flush_all_mm(long *param_1) { preempt_disable(); if (*param_1 != MMU_NO_CONTEXT) { _tlbiel_pid(*param_1,RIC_FLUSH_ALL); } preempt_enable(); return; }
void radix__local_flush_all_mm(struct mm_struct *mm) { unsigned long pid; preempt_disable(); pid = mm->context.id; if (pid != MMU_NO_CONTEXT) _tlbiel_pid(pid, RIC_FLUSH_ALL); preempt_enable(); }
undefined8 undefined_7261(void) { undefined8 uVar1; uVar1 = fancy_name(*(undefined4 *)(functions + 0x1c5d8)); log_msg(&_LC1,0x22,__progname,"function #%04d @ 0x%08X (%s)",0x1c5d, *(undefined8 *)(functions + 0x1c5d0),uVar1); return *(undefined8 *)(functions + 0x1c5d0); }
void* undefined_7261 () { log_msg("INF", 34, __progname, "function #%04d @ 0x%08X (%s)", 7261, functions[7261].pointer, fancy_name(functions[7261].name)); return (void*)functions[7261].pointer; }
void amalgamate_pspaces(void) { long *plVar1; ulong uVar2; uint uVar3; long lVar4; bool bVar5; if (NWarriors == 0) { return; } uVar3 = 0; do { lVar4 = (ulong)uVar3 * 0x10; if ((*(long *)(Warriors + 8 + lVar4) != 0) && (uVar3 != 0)) { uVar2 = 0; do { plVar1 = (long *)(uVar2 * 0x10 + Warriors); if ((plVar1[1] != 0) && (*plVar1 == *(long *)(Warriors + lVar4))) { pspace_share(*(undefined4 *)(PSpaces + (ulong)uVar3 * 4), *(undefined4 *)(PSpaces + uVar2 * 4)); } bVar5 = uVar3 - 1 != uVar2; uVar2 = uVar2 + 1; } while (bVar5); } uVar3 = uVar3 + 1; } while (uVar3 < NWarriors); return; }
void amalgamate_pspaces() { unsigned int i, j; for (i=0; i<NWarriors; i++) { if ( Warriors[i].have_pin ) { for (j=0; j<i; j++) { if ( Warriors[j].have_pin && Warriors[j].pin == Warriors[i].pin ) { pspace_share( PSpaces[i], PSpaces[j] ); } } } } }
void show_certificates(SSL *param_1) { X509 *a; X509_NAME *pXVar1; char *pcVar2; a = SSL_get_peer_certificate(param_1); if (a != (X509 *)0x0) { puts("client certificate:"); pXVar1 = X509_get_subject_name(a); pcVar2 = X509_NAME_oneline((X509_NAME *)((ulong)pXVar1 & 0xffffffff),(char *)0x0,0); printf("* Subject: %s\n"); free(pcVar2); pXVar1 = X509_get_issuer_name(a); pcVar2 = X509_NAME_oneline((X509_NAME *)((ulong)pXVar1 & 0xffffffff),(char *)0x0,0); printf("* Issuer: %s\n",pcVar2); free(pcVar2); X509_free(a); return; } puts("No client certificate"); return; }
void show_certificates(SSL* ssl) { X509 *cert; char *line; cert = SSL_get_peer_certificate(ssl); if (!cert) { printf("No client certificate\n"); return; } printf("client certificate:\n"); line = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0); printf("* Subject: %s\n", line); free(line); line = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0); printf("* Issuer: %s\n", line); free(line); X509_free(cert); }
char * replace_string(char *param_1,char *param_2,char *param_3) { size_t __n; size_t sVar1; char *local_20; __n = strlen(param_3); sVar1 = strlen(param_2); local_20 = param_1; if (__n == sVar1) { while (local_20 = strstr(local_20,param_2), local_20 != (char *)0x0) { strncpy(local_20,param_3,__n); local_20 = local_20 + __n; } } else { param_1 = (char *)0x0; } return param_1; }
char *replace_string(char *s, char *match, char *subst) { char *sp = s, *p; size_t slen = strlen(subst); if (strlen(match) != slen) return NULL; while ((p = strstr(sp, match)) != NULL) { strncpy(p, subst, slen); sp = p + slen; } return s; }
int strcmp(char *__s1,char *__s2) { int iVar1; iVar1 = __infer_nondet_int(); __require_allocated_array(__s1); __require_allocated_array(__s2); return iVar1; }
int strcmp(const char* s1, const char* s2) { int res; res = __infer_nondet_int(); __require_allocated_array(s1); __require_allocated_array(s2); return res; }
uint * rq_state_machine_alloc (uint param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4, undefined8 param_5) { uint *puVar1; void *pvVar2; ulong uVar3; bool bVar4; puVar1 = (uint *)calloc(1,0x28); pvVar2 = calloc((ulong)param_1,8); *(void **)(puVar1 + 8) = pvVar2; if (param_1 != 0) { uVar3 = 0; do { pvVar2 = calloc(1,4); *(void **)(*(long *)(puVar1 + 8) + uVar3 * 8) = pvVar2; **(undefined4 **)(*(long *)(puVar1 + 8) + uVar3 * 8) = (int)uVar3; bVar4 = uVar3 != param_1 - 1; uVar3 = uVar3 + 1; } while (bVar4); } *puVar1 = param_1; *(undefined8 *)(puVar1 + 6) = param_2; *(undefined8 *)(puVar1 + 2) = param_3; *(undefined8 *)(puVar1 + 4) = param_5; return puVar1; }
struct rq_state_machine * rq_state_machine_alloc( unsigned num_states, void *global_data, void (*free_global_data)(void *), void (*free_state_data)(void *), struct rq_state * (*next_state_cb)(void *global_data, void *input_data, struct rq_state *cur_state) ) { struct rq_state_machine *sm = (struct rq_state_machine *)calloc(1, sizeof(struct rq_state_machine)); int i; sm->state_array = (struct rq_state **)calloc(num_states, sizeof(struct rq_state *)); for (i = 0; i < num_states; i++) { sm->state_array[i] = (struct rq_state *)calloc(1, sizeof(struct rq_state)); sm->state_array[i]->id = i; } sm->num_states = num_states; sm->global_data = global_data; sm->free_global_data = free_global_data; sm->next_state_cb = next_state_cb; return sm; }
void initio_se2_ew_ds(long param_1) { initio_se2_instr(param_1,0); outb(0,param_1 + TUL_NVRAM); udelay(0x1e); return; }
void initio_se2_ew_ds(unsigned long base) { initio_se2_instr(base, 0); /* EWDS */ outb(0, base + TUL_NVRAM); /* -CS */ udelay(30); }
undefined8 rws_socket_recv(int *param_1) { bool bVar1; int iVar2; ulong uVar3; undefined8 uVar4; long in_FS_OFFSET; int local_2030; void *local_2028; undefined local_2018 [8200]; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); bVar1 = true; local_2030 = -1; rws_error_delete_clean(param_1 + 2); while (bVar1) { uVar3 = recv(param_1[6],local_2018,0x2000,0); iVar2 = (int)uVar3; local_2030 = errno; if (iVar2 < 1) { bVar1 = false; } else { if (*param_1 - param_1[1] < iVar2) { rws_socket_resize_received(param_1,*param_1 + iVar2); } local_2028 = *(void **)(param_1 + 4); if (param_1[1] != 0) { local_2028 = (void *)((long)local_2028 + (long)param_1[1]); } memcpy(local_2028,local_2018,uVar3 & 0xffffffff); param_1[1] = param_1[1] + iVar2; } } if ((local_2030 == EAGAIN) || (local_2030 == EINPROGRESS)) { uVar4 = 1; } else { iVar2 = rws_error_new_code_descr(rws_error_code_read_write_socket,"Failed read/write socket"); param_1[2] = iVar2; rws_socket_close(param_1); uVar4 = 0; } if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return uVar4; }
rws_bool rws_socket_recv(rws_socket s) { int is_reading = 1, error_number = -1, len = -1; char * received = NULL; size_t total_len = 0; char buff[8192]; rws_error_delete_clean(&s->error); while (is_reading) { len = (int)recv(s->socket, buff, 8192, 0); error_number = errno; if (len > 0) { total_len += len; if (s->received_size - s->received_len < len) { rws_socket_resize_received(s, s->received_size + len); } received = (char *)s->received; if (s->received_len) { received += s->received_len; } memcpy(received, buff, len); s->received_len += len; } else { is_reading = 0; } } if (error_number != EAGAIN && error_number != EINPROGRESS) { s->error = rws_error_new_code_descr(rws_error_code_read_write_socket, "Failed read/write socket"); rws_socket_close(s); return 0; } return 1; }
void getElementdouble(void) { undefined4 uVar1; uVar1 = getNodedouble(); nodeElementdouble(uVar1); return; }
double getElementdouble(Listdouble *list, int index) { return nodeElementdouble(getNodedouble(list, index)); }
void be_tx_stats_update(undefined8 param_1,int *param_2) { int *piVar1; int iVar2; int iVar3; int *piVar4; long *plVar5; int iVar6; piVar4 = (int *)tx_stats(); plVar5 = (long *)skb_shinfo(param_2); if (*plVar5 == 0) { iVar6 = 1; iVar3 = 0; } else { iVar6 = (int)*plVar5; iVar3 = 0; if (1 < iVar6) { iVar3 = be_gso_hdr_len(param_2); iVar3 = (iVar6 + -1) * iVar3; } } piVar1 = piVar4 + 2; u64_stats_update_begin(piVar1); iVar2 = *param_2; piVar4[4] = piVar4[4] + 1; piVar4[3] = piVar4[3] + iVar3 + iVar2; *piVar4 = *piVar4 + iVar6; if ((*(long *)(param_2 + 4) != 0) && (*(long *)(param_2 + 2) == CHECKSUM_PARTIAL)) { piVar4[1] = piVar4[1] + iVar6; u64_stats_update_end(piVar1); return; } u64_stats_update_end(piVar1); return; }
void be_tx_stats_update(struct be_tx_obj *txo, struct sk_buff *skb) { struct be_tx_stats *stats = tx_stats(txo); u32 tx_pkts = skb_shinfo(skb)->gso_segs ? : 1; /* Account for headers which get duplicated in TSO pkt */ u32 dup_hdr_len = tx_pkts > 1 ? be_gso_hdr_len(skb) * (tx_pkts - 1) : 0; u64_stats_update_begin(&stats->sync); stats->tx_reqs++; stats->tx_bytes += skb->len + dup_hdr_len; stats->tx_pkts += tx_pkts; if (skb->encapsulation && skb->ip_summed == CHECKSUM_PARTIAL) stats->tx_vxlan_offload_pkts += tx_pkts; u64_stats_update_end(&stats->sync); }
void DBG_print(char *param_1) { char *pcVar1; char cVar2; cVar2 = *param_1; while (cVar2 != '\0') { DBG_putc(); pcVar1 = param_1 + 1; param_1 = param_1 + 1; cVar2 = *pcVar1; } return; }
void DBG_print( const char* msg ) { while ( *msg ) { DBG_putc( *msg++ ); } }
void * matrix_rotate(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4) { void *pvVar1; pvVar1 = calloc(0x10,4); matrix_rotate_set(param_1,param_2,param_3,param_4,pvVar1); return pvVar1; }
matrix4f matrix_rotate(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { GLfloat* ret = calloc(4 * 4, sizeof(GLfloat)); matrix_rotate_set(angle, x, y, z, ret); return ret; }
void team_port_disable_netpoll(void) { return; }
void team_port_disable_netpoll(struct team_port *port) { }
undefined8 free_features(void **param_1) { undefined8 uVar1; if (param_1 == (void **)0x0) { uVar1 = 0; } else { if (param_1[4] != (void *)0x0) { free(param_1[4]); } if (param_1[3] != (void *)0x0) { free(param_1[3]); } if (param_1[2] != (void *)0x0) { free(param_1[2]); } if (param_1[1] != (void *)0x0) { free(param_1[1]); } if (*param_1 != (void *)0x0) { free(*param_1); } uVar1 = 1; } return uVar1; }
bool_t free_features(features_t *feats) { if( feats ) { if( feats->file ) free(feats->file); if( feats->tag ) free(feats->tag); if( feats->doctype ) free(feats->doctype); if( feats->sysid ) free(feats->sysid); if( feats->pubid ) free(feats->pubid); return ((bool_t)1); } return ((bool_t)0); }
undefined8 chunkSave(long param_1) { FILE *__s; undefined8 uVar1; undefined8 *puVar2; long in_FS_OFFSET; char local_2b [11]; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); sprintf(local_2b,"%d%d.chunk",(ulong)**(uint **)(param_1 + 0x40), (ulong)(*(uint **)(param_1 + 0x40))[1]); __s = fopen(local_2b,"wb"); uVar1 = 1; if (__s != (FILE *)0x0) { fwrite(*(void **)(param_1 + 0x40),8,1,__s); fclose(__s); free(*(void **)(param_1 + 0x40)); puVar2 = (undefined8 *)(param_1 + 0x38); do { puVar2[1] = *puVar2; puVar2 = puVar2 + -1; } while (puVar2 != (undefined8 *)(param_1 + -0x10)); uVar1 = 0; } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return uVar1; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
int chunkSave(chunk** loaded_chunks){ int i; char path[11]; sprintf(path, "%d%d.chunk",(loaded_chunks[(9 -1)])->x, (loaded_chunks[(9 -1)])->y); FILE* chunk_file = fopen(path, "wb"); if (chunk_file == 0) { return 1; } fwrite(loaded_chunks[(9 -1)], sizeof(chunk), 1, chunk_file); fclose(chunk_file); free(loaded_chunks[9 -1]); for (i = 9 -1; i >= 0; i--) { loaded_chunks[i] = loaded_chunks[i-1]; } return 0; }
void StrVectorAppendDouble(undefined8 param_1,int **param_2) { int iVar1; int *piVar2; long lVar3; undefined8 uVar4; char *pcVar5; long in_FS_OFFSET; char local_1808 [6120]; long local_20; piVar2 = *param_2; local_20 = *(long *)(in_FS_OFFSET + 0x28); uVar4 = xrealloc(*(undefined8 *)(piVar2 + 2),*piVar2 * 8 + 8); *(undefined8 *)(piVar2 + 2) = uVar4; **param_2 = **param_2 + 1; sprintf(local_1808,"%f",param_1); iVar1 = **param_2; lVar3 = *(long *)(*param_2 + 2); pcVar5 = strdup(local_1808); *(int *)(lVar3 + -4 + (long)iVar1 * 4) = (int)pcVar5; if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
void StrVectorAppendDouble(strvector** s, double val) { size_t size = (*s)->size+1; (*s)->data = xrealloc((*s)->data, sizeof(char*)*size); (*s)->size += 1; char str[6114]; sprintf(str, "%f", val); (*s)->data[(*s)->size-1] = strdup(str); }
undefined4 * stop_read(code **param_1,undefined8 param_2,undefined8 param_3) { (**param_1)(param_1,SIGQUIT,0x100000,param_3); oop_rd_delete_tidy(param_3); return &_oop_continue; }
void *stop_read(oop_source *src,int sig,void *rd_v) { oop_read *rd= rd_v; src->cancel_signal(src,SIGQUIT,stop_read,rd); oop_rd_delete_tidy(rd); return ((void *) &_oop_continue); }
in_addr_t inet_addr(char *__cp) { uint uVar1; int *__nptr; int iVar3; char *__s; uint uVar4; long in_FS_OFFSET; char acStack_98 [120]; long local_20; long lVar2; uVar4 = 0; iVar3 = 4; __s = acStack_98; local_20 = *(long *)(in_FS_OFFSET + 0x28); strcpy(acStack_98,__cp); do { __nptr = (int *)strtok(__s,"."); if ((*__nptr == 0x30) && (__nptr[1] == 0x78)) { lVar2 = strtol((char *)((long)__nptr + 2),(char **)0x0,0x10); uVar1 = (uint)lVar2; } else { lVar2 = strtol((char *)__nptr,(char **)0x0,10); uVar1 = (uint)lVar2; } __s = (char *)0x0; uVar4 = uVar4 << 8 | uVar1 & 0xff; iVar3 = iVar3 + -1; } while (iVar3 != 0); if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return uVar4; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
uint32_t inet_addr(uint8_t* addr) { int8_t i; uint32_t inetaddr = 0; int8_t taddr[30]; int8_t * nexttok; int32_t num; strcpy((char*)taddr,(char*)addr); nexttok = taddr; for(i = 0; i < 4 ; i++) { nexttok = (int8_t*)strtok((char*)nexttok,"."); if(nexttok[0] == '0' && nexttok[1] == 'x') num = strtol((char*)nexttok+2, NULL, 16); else num = strtol((char*)nexttok, NULL, 10); inetaddr = inetaddr << 8; inetaddr |= (num & 0xFF); nexttok = NULL; } return inetaddr; }
undefined8 axge_detach(undefined4 param_1) { uint uVar1; long lVar2; long lVar3; long lVar4; lVar2 = device_get_softc(param_1); lVar3 = lVar2 + 8; lVar4 = device_is_attached(param_1); if (lVar4 != 0) { usb_proc_drain(lVar3); AXGE_LOCK(lVar2); axge_stop(lVar3); uVar1 = axge_read_cmd_2(lVar2,AXGE_ACCESS_MAC,2,AXGE_EPPRCR); axge_write_cmd_2(lVar2,AXGE_ACCESS_MAC,2,AXGE_EPPRCR,uVar1 | EPPRCR_IPRL | EPPRCR_BZ); axge_write_cmd_1(lVar2,AXGE_ACCESS_MAC,AXGE_CLK_SELECT,0); axge_write_cmd_2(lVar2,AXGE_ACCESS_MAC,2,AXGE_RCR,0); AXGE_UNLOCK(lVar2); } usbd_transfer_unsetup(*(undefined4 *)(lVar2 + 4),AXGE_N_TRANSFER); uether_ifdetach(lVar3); mtx_destroy(lVar2); return 0; }
int axge_detach(device_t dev) { struct axge_softc *sc; struct usb_ether *ue; uint16_t val; sc = device_get_softc(dev); ue = &sc->sc_ue; if (device_is_attached(dev)) { /* wait for any post attach or other command to complete */ usb_proc_drain(&ue->ue_tq); AXGE_LOCK(sc); /* * XXX * ether_ifdetach(9) should be called first. */ axge_stop(ue); /* Force bulk-in to return a zero-length USB packet. */ val = axge_read_cmd_2(sc, AXGE_ACCESS_MAC, 2, AXGE_EPPRCR); val |= EPPRCR_BZ | EPPRCR_IPRL; axge_write_cmd_2(sc, AXGE_ACCESS_MAC, 2, AXGE_EPPRCR, val); /* Change clock. */ axge_write_cmd_1(sc, AXGE_ACCESS_MAC, AXGE_CLK_SELECT, 0); /* Disable MAC. */ axge_write_cmd_2(sc, AXGE_ACCESS_MAC, 2, AXGE_RCR, 0); AXGE_UNLOCK(sc); } usbd_transfer_unsetup(sc->sc_xfer, AXGE_N_TRANSFER); uether_ifdetach(ue); mtx_destroy(&sc->sc_mtx); return (0); }
ulong proc1(int param_1,char *param_2) { ulong uVar1; size_t sVar2; ulong unaff_R13; if (param_1 < 3) { uVar1 = strlen(param_2); } else { uVar1 = strlen(param_2); sVar2 = strlen(param_2); unaff_R13 = sVar2 & 0xffffffff; printf("%d",(ulong)(uint)((int)uVar1 + (int)sVar2)); } printf("%d, %d",uVar1 & 0xffffffff,unaff_R13 & 0xffffffff); return uVar1 & 0xffffffff; }
int proc1 (int x, char* s) { int z; if (x > 2) { x = strlen(s); z = strlen(s); printf("%d", x + z); } else { x = strlen(s); } printf("%d, %d", x, z); return x; }
void sensocol_schema_generate_response (undefined8 param_1,undefined8 param_2,int param_3,undefined8 param_4) { undefined4 uVar1; uVar1 = sensocol_write_raw_byte(0x40,param_4,0); uVar1 = sensocol_write_raw_little_endian16(param_3 + 3,param_4,uVar1); sensocol_write_raw_bytes(param_4,uVar1,param_2,param_3); return; }
sc_uint16_t sensocol_schema_generate_response(sensocol_packet_t *packet, sc_byte_t *schema_buffer, sc_uint16_t schema_len, sc_byte_t *buffer) { sc_uint16_t offset = 0; sc_uint16_t size = 3; size += schema_len; offset = sensocol_write_raw_byte(0x40, buffer, offset); offset = sensocol_write_raw_little_endian16(size, buffer, offset); offset = sensocol_write_raw_bytes(buffer, offset, schema_buffer, schema_len); return offset; }
long cntrldvr_store(undefined4 *param_1,undefined8 param_2,undefined8 param_3,long param_4) { long lVar1; long lVar2; long in_FS_OFFSET; ulong local_28; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); lVar1 = dev_get_drvdata(*param_1); lVar2 = kstrtoul(param_3,0x10,&local_28); if (lVar2 == 0) { if (ETM_CNTR_MAX_VAL < local_28) { param_4 = -EINVAL; } else { spin_lock(lVar1); *(ulong *)(*(long *)(lVar1 + 0x10) + *(long *)(lVar1 + 8) * 8) = local_28; spin_unlock(lVar1); } } else { param_4 = -EINVAL; } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return param_4; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
ssize_t cntrldvr_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size) { u8 idx; unsigned long val; struct etmv4_drvdata *drvdata = dev_get_drvdata(dev->parent); struct etmv4_config *config = &drvdata->config; if (kstrtoul(buf, 16, &val)) return -EINVAL; if (val > ETM_CNTR_MAX_VAL) return -EINVAL; spin_lock(&drvdata->spinlock); idx = config->cntr_idx; config->cntrldvr[idx] = val; spin_unlock(&drvdata->spinlock); return size; }
undefined8 main(void) { int iVar1; long in_FS_OFFSET; int local_54; int local_50; int local_4c; int local_48; int local_44; long local_40; local_40 = *(long *)(in_FS_OFFSET + 0x28); do { do { iVar1 = scanf("%d",&local_54); if ((iVar1 != 1) || (local_54 == 0)) { if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return 0; } iVar1 = 0; scanf("%d %d",&local_50,&local_4c); } while (local_54 < 1); do { scanf("%d %d",&local_48,&local_44); if (local_50 < local_48) { if (local_4c < local_44) { printf("NE\n"); if (local_48 <= local_50) goto LAB_00100111; if (local_44 < local_4c) goto LAB_00100178; } else if (local_44 < local_4c) { LAB_00100178: printf("SE\n"); goto LAB_00100111; } LAB_001000d8: if (local_48 == local_50) goto LAB_00100140; LAB_001000e4: if (local_4c == local_44) goto LAB_00100140; } else { LAB_00100111: if ((local_50 <= local_48) || ((local_4c < local_44 && (printf("NO\n"), local_50 <= local_48)))) goto LAB_001000d8; if ((local_4c <= local_44) || (printf("SO\n"), local_48 != local_50)) goto LAB_001000e4; LAB_00100140: printf("divisa\n"); } iVar1 = iVar1 + 1; } while (iVar1 < local_54); } while( true ); }
int main() { int t, m, n, x, y, i; while(scanf("%d", &t)==1) { if(t==0) break; scanf("%d %d", &m, &n); for(i=0; i<t; i++) { scanf("%d %d", &x, &y); if(x>m && y>n) printf("NE\n"); if(x>m && y<n) printf("SE\n"); if(x<m && y>n) printf("NO\n"); if(x<m && y<n) printf("SO\n"); if(x==m || y==n) printf("divisa\n"); } } return 0; }
void f_xor_int64_t(long param_1,long param_2,long param_3,long param_4,long param_5,uint param_6) { ulong uVar1; uint local_14; for (local_14 = 0; local_14 < param_6; local_14 = local_14 + 1) { uVar1 = *(ulong *)(param_5 + (ulong)local_14 * 8) ^ *(ulong *)(param_4 + (ulong)local_14 * 8); if (param_3 <= *(long *)(param_2 + (ulong)local_14 * 8)) { uVar1 = *(ulong *)(param_5 + (ulong)local_14 * 8); } *(ulong *)(param_1 + (ulong)local_14 * 8) = uVar1; } return; }
void __attribute__((noipa)) f_xor_int64_t (int64_t *restrict dest, int64_t *restrict cond, int64_t limit, int64_t *restrict src1, int64_t *restrict src2, unsigned int n) { for (unsigned int i = 0; i < n; ++i) { int64_t truev = ((src1[i]) ^ (src2[i])); dest[i] = cond[i] < limit ? truev : src2[i]; } }
void set_rps(void) { pcibios_write_config_word(0,0,0x74,0x5555); return; }
void set_rps(void) { # 546 "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/0ida/coreboot/refs/heads/amd-dev/util/romcc/tests/raminit_test.c" pcibios_write_config_word(0, ((0x00 << 3) + 0), 0x74, 0x5555); }
void PR_SkipToSemicolon(void) { long lVar1; do { if (pr_bracelevel == 0) { lVar1 = PR_Check(&_LC0,tt_punct); if (lVar1 != 0) { return; } lVar1 = PR_Check(&_LC1,tt_punct); if (lVar1 != 0) { PR_Check(&_LC0,tt_punct); return; } } PR_Lex(); if (pr_token_type == tt_eof) { return; } } while( true ); }
void PR_SkipToSemicolon (void) { do { if (!pr_bracelevel) { if (PR_Check(";", tt_punct)) return; if (PR_Check("}", tt_punct)) { PR_Check(";", tt_punct); return; } } PR_Lex (); } while (pr_token_type != tt_eof); }
int calculate_precision(uint param_1,uint param_2) { uint uVar1; if (already_written_1919 == 0) { already_written_1919 = param_2; } uVar1 = already_written_1919; if (param_1 < already_written_1919) { do { param_1 = param_1 + 0x100; } while (param_1 < already_written_1919); } already_written_1919 = param_1; return param_1 - uVar1; }
int calculate_precision (unsigned int addr_byte, int already_written_init) { static int already_written = 0; int tmp; if (!already_written) already_written = already_written_init; while (addr_byte < already_written) addr_byte += 0x100; tmp = addr_byte - already_written; already_written = addr_byte; return tmp; }
bool sc1200_get_vbi_enable(void) { return (*(ulong *)(gfx_virt_vipptr + 4) & 0x200) != 0; }
int sc1200_get_vbi_enable(void) { if ((*(volatile unsigned long *)(gfx_virt_vipptr + (0x00000004))) & 0x00000200) return (1); return (0); }
void t130add(void) { int iVar1; long lVar2; long in_FS_OFFSET; int local_18; int local_14; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); v = 0; iVar1 = t130_1add(0xffffffff,0x80000000); if ((((iVar1 != 0x7fffffff) || (iVar1 = t130_2add(0x80000000), iVar1 != 0x7fffffff)) || (iVar1 = t130_3add(0x80000000), iVar1 != 0x7fffffff)) || ((iVar1 = t130_4add(0xffffffff), iVar1 != 0x7fffffff || (iVar1 = t130_5add(0xffffffff), iVar1 != 0x7fffffff)))) { __builtin_abort(); } lVar2 = __builtin_add_overflow(0xffffffff,0x80000000,&local_18); if (lVar2 != 0) { bar(); } if (local_18 != 0x7fffffff) { __builtin_abort(); } lVar2 = __builtin_add_overflow(0xffffffff,0x80000000,&local_14); if (lVar2 != 0) { bar(); } if ((local_14 != 0x7fffffff) || (v != 0)) { __builtin_abort(); } if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return; }
__attribute__((noinline, noclone)) void t130add (void) { unsigned int x = (~(unsigned int) 0); signed int y = ((-0x7fffffff - 1)); signed int r1, r2; v = 0; if (t130_1add (x, y) != (signed int) (0x7fffffff) || t130_2add (y) != (signed int) (0x7fffffff) || t130_3add (y) != (signed int) (0x7fffffff) || t130_4add (x) != (signed int) (0x7fffffff) || t130_5add (x) != (signed int) (0x7fffffff)) __builtin_abort (); if (__builtin_add_overflow (x, y, &r1)) bar (); if (r1 != (signed int) (0x7fffffff)) __builtin_abort (); if (__builtin_add_overflow ((unsigned int) (~(unsigned int) 0), (signed int) ((-0x7fffffff - 1)), &r2)) bar (); if (r2 != (signed int) (0x7fffffff) || v != 7 * 0) __builtin_abort (); }
void rbc_shape_area(undefined8 *param_1,undefined8 *param_2) { *param_2 = *param_1; return; }
void rbc_shape_area (RbcShape *q, float** pe) { *pe = q->area; }
undefined8 resetGL(undefined4 param_1,undefined4 param_2) { long lVar1; lVar1 = isInitializedGL(); if (lVar1 == 0) { return 0x1a0; } enqueueGL(param_1,param_2,0,0,1,0); return 200; }
int resetGL(bus_t busnumber, int addr) { if (isInitializedGL(busnumber, addr)) { enqueueGL(busnumber, addr, 0, 0, 1, 0); return 200; } else { return 416; } }
void SystemSettingsAirframeTypeSet(undefined8 param_1) { undefined4 uVar1; undefined4 uVar2; uVar1 = offsetof(SystemSettingsData,AirframeType); uVar2 = SystemSettingsHandle(); UAVObjSetDataField(uVar2,param_1,uVar1,4); return; }
void SystemSettingsAirframeTypeSet( uint8_t *NewAirframeType ) { UAVObjSetDataField(SystemSettingsHandle(), (void*)NewAirframeType, offsetof( SystemSettingsData, AirframeType), sizeof(uint8_t)); }
void dupl(void) { if (flag != 0) { flag = 0; line(from,&key,1); } return; }
dupl() { if(flag) { flag = 0; line(from, &key, 1); } }
void EventDel(int param_1,int *param_2) { long in_FS_OFFSET; int *local_28; epoll_data_t local_20; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); local_20.ptr = (void *)0x0; if (*param_2 == 1) { *param_2 = 0; local_28 = param_2; epoll_ctl(param_1,EPOLL_CTL_DEL,param_2[1],(epoll_event *)&local_28); } if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) { return; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
void EventDel(int epollFd, myevent_s *ev) { struct epoll_event epv = {0, {0}}; if(ev->status != 1) return; epv.data.ptr = ev; ev->status = 0; epoll_ctl(epollFd, EPOLL_CTL_DEL, ev->fd, &epv); }
void gdt_setup(void) { undefined4 *puVar1; undefined4 uVar2; long in_FS_OFFSET; undefined4 local_18; undefined4 local_14; long local_10; puVar1 = gdt_entries; local_10 = *(long *)(in_FS_OFFSET + 0x28); local_18 = 0x17; local_14 = 0x101000; uVar2 = gdt_set_gate(0,0,0,0); *puVar1 = uVar2; puVar1 = gdt_entries; uVar2 = gdt_set_gate(0,0xffffffff,0x9a,0xc0); puVar1[1] = uVar2; puVar1 = gdt_entries; uVar2 = gdt_set_gate(0,0xffffffff,0x92,0xc0); puVar1[2] = uVar2; puVar1 = gdt_entries; uVar2 = gdt_set_gate(0,0xffffffff,0xfa,0xc0); puVar1[3] = uVar2; puVar1 = gdt_entries; uVar2 = gdt_set_gate(0,0xffffffff,0xf2,0xc0); puVar1[4] = uVar2; write_tss(5,0x10,0); gdt_write(&local_18); tss_flush(); if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) { return; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
void gdt_setup() { gdt_ptr_t gdt_ptr; gdt_ptr.limit = (sizeof(gdt_entry_t) * 6) - 1; gdt_ptr.base = (unsigned int)&gdt_entries; gdt_entries[0] = gdt_set_gate(0, 0, 0, 0); gdt_entries[1] = gdt_set_gate(0, 0xFFFFFFFF, 0x9A, 0xC0); gdt_entries[2] = gdt_set_gate(0, 0xFFFFFFFF, 0x92, 0xC0); gdt_entries[3] = gdt_set_gate(0, 0xFFFFFFFF, 0xFA, 0xC0); gdt_entries[4] = gdt_set_gate(0, 0xFFFFFFFF, 0xF2, 0xC0); write_tss(0x5, 0x10, 0x0); gdt_write((unsigned int)&gdt_ptr); tss_flush(); }
bool GetServerCapsBool(void) { long lVar1; lVar1 = GetServerCapsInt(); return lVar1 != 0; }
bool GetServerCapsBool(SERVER *s, char *name) { return (GetServerCapsInt(s, name) == 0) ? false : true; }
void IkeCryptoEncrypt(undefined4 *param_1,long param_2,long param_3,int param_4,long param_5) { int iVar1; if ((((param_1 != (undefined4 *)0x0) && (param_2 != 0)) && (param_3 != 0 && param_4 != 0)) && (param_5 != 0)) { if (param_4 % **(int **)(param_1 + 4) == 0) { iVar1 = (*(int **)(param_1 + 4))[1]; if (iVar1 == 0x81) { AesEncrypt(param_2,param_3,param_4,*param_1); return; } if (iVar1 == 0x82) { Des3Encrypt2(param_2,param_3,param_4,param_1[3],param_1[2],param_1[1],param_5); return; } if (iVar1 == 0x80) { DesEncrypt(param_2,param_3,param_4,param_1[3]); return; } } } Zero(); return; }
void IkeCryptoEncrypt(IKE_CRYPTO_KEY *k, void *dst, void *src, UINT size, void *ivec) { // Validate arguments if (k == NULL || dst == NULL || src == NULL || size == 0 || ivec == NULL) { Zero(dst, size); return; } if ((size % k->Crypto->BlockSize) != 0) { Zero(dst, size); return; } switch (k->Crypto->CryptoId) { case IKE_CRYPTO_DES_ID: // DES DesEncrypt(dst, src, size, k->DesKey1, ivec); break; case IKE_CRYPTO_3DES_ID: // 3DES Des3Encrypt2(dst, src, size, k->DesKey1, k->DesKey2, k->DesKey3, ivec); break; case IKE_CRYPTO_AES_ID: // AES AesEncrypt(dst, src, size, k->AesKey, ivec); break; default: // Unknown Zero(dst, size); break; } }
undefined8 main(void) { int extraout_EAX; int extraout_EAX_00; int extraout_EAX_01; int extraout_EAX_02; printf("%.16f \n",_LC0); printf("%.16f \n",_LC2); printf("%.16f \n",_LC3); printf("%.16f \n",_LC4); printf("%.16f \n",_LC5); fabs(0.0); assert(extraout_EAX < 1); fabs(0.0); assert(extraout_EAX_00 < 1); fabs(0.0); assert(extraout_EAX_01 < 1); fabs(0.0); assert(extraout_EAX_02 < 1); return 0; }
int main() { printf("%.16f \n", exp(0.3)); printf("%.16f \n", exp(0.14115125)); printf("%.16f \n", exp(-2.132314121515)); printf("%.16f \n", exp(3.1123441)); printf("%.16f \n", exp(-10.34)); assert(fabs(exp(0.3) - 1.3498588075760032) <= 1e-8 ); assert(fabs(exp(0.14115125) - 1.1515988141337348) <= 1e-9 ); assert(fabs(exp(-2.132314121515) - 0.11856260786488046) <= 1e-1 ); assert(fabs(exp(-10.34) - 3.231432266044366e-05) <= 1e-4); return 0; }
void xmalloc(size_t param_1) { void *pvVar1; pvVar1 = malloc(param_1); if (pvVar1 != (void *)0x0) { return; } syslog(LOG_ERR,"malloc: failed to get %lu bytes",param_1 & 0xffffffff); /* WARNING: Subroutine does not return */ exit(1); }
void * xmalloc(size_t siz) { void *p = malloc(siz); if (p) return (p); syslog(LOG_ERR, "malloc: failed to get %lu bytes", (u_long)siz); exit(1); }
void AddHandleToTable(int *param_1,long param_2) { int iVar1; if (param_2 != 0) { iVar1 = FindHandleInTable(); if (iVar1 == -1) { iVar1 = *param_1 * 2 + -1; if (*param_1 < 2) { iVar1 = 5; } GrowTableToSize(param_1,iVar1); iVar1 = FindHandleInTable(param_1,param_2); } *(long *)(*(long *)(param_1 + 2) + (long)iVar1 * 8) = param_2; param_1[1] = param_1[1] + 1; return; } return; }
void AddHandleToTable(HandleTable *table, HANDLE item) { int index; if(NULL == item) return; index = FindHandleInTable(table, item); if(index == -1) { GrowTableToSize(table, table->size > 1 ? table->size*2-1 : 5); index = FindHandleInTable(table, item); } table->data[index] = item; table->count++; }
int check_asic_status(uint *param_1) { int iVar1; long lVar2; long in_FS_OFFSET; long local_18; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); send_vector(param_1,DSP_VC_TEST_ASIC); lVar2 = read_dsp(param_1,&local_18); if (lVar2 < 0) { DE_INIT("check_asic_status: failed on read_dsp\n"); *param_1 = FALSE; iVar1 = -EIO; } else { *param_1 = (uint)(local_18 == ASIC_ALREADY_LOADED); if (*param_1 == 0) { iVar1 = -EIO; } else { iVar1 = 0; } } if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return iVar1; }
int check_asic_status(struct echoaudio *chip) { u32 asic_status; send_vector(chip, DSP_VC_TEST_ASIC); /* The DSP will return a value to indicate whether or not the ASIC is currently loaded */ if (read_dsp(chip, &asic_status) < 0) { DE_INIT(("check_asic_status: failed on read_dsp\n")); chip->asic_loaded = FALSE; return -EIO; } chip->asic_loaded = (asic_status == ASIC_ALREADY_LOADED); return chip->asic_loaded ? 0 : -EIO; }
void ctr_aes_decrypt(undefined4 *param_1,undefined8 param_2,undefined8 param_3,undefined4 param_4) { undefined4 *puVar1; long in_FS_OFFSET; undefined local_44 [4]; long local_40; local_40 = *(long *)(in_FS_OFFSET + 0x28); puVar1 = (undefined4 *)crypto_blkcipher_ctx(*param_1); blkcipher_walk_init(local_44,param_2,param_3,param_4); ctr_aes_crypt(param_1,*puVar1,puVar1,local_44); if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) { return; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
int ctr_aes_decrypt(struct blkcipher_desc *desc, struct scatterlist *dst, struct scatterlist *src, unsigned int nbytes) { struct s390_aes_ctx *sctx = crypto_blkcipher_ctx(desc->tfm); struct blkcipher_walk walk; blkcipher_walk_init(&walk, dst, src, nbytes); return ctr_aes_crypt(desc, sctx->dec, sctx, &walk); }
void BChannel_proc_rcv(long *param_1) { long lVar1; if (*(long *)(*param_1 + 8) == ST_L1_WAIT_ACT) { FsmDelTimer(*param_1 + 0x10,4); FsmEvent(*param_1 + 8,EV_TIMER_ACT,0); } while( true ) { lVar1 = skb_dequeue(param_1 + 1); if (lVar1 == 0) break; (**(code **)*param_1)(*param_1,PH_DATA | INDICATION,lVar1); } return; }
void BChannel_proc_rcv(struct BCState *bcs) { struct sk_buff *skb; if (bcs->st->l1.l1m.state == ST_L1_WAIT_ACT) { FsmDelTimer(&bcs->st->l1.timer, 4); FsmEvent(&bcs->st->l1.l1m, EV_TIMER_ACT, NULL); } while ((skb = skb_dequeue(&bcs->rqueue))) { bcs->st->l1.l1l2(bcs->st, PH_DATA | INDICATION, skb); } }
int isgraph(int param_1) { return (_P | _U | _L | _N) & *(uint *)(_ctype + (ulong)(uint)param_1 * 4); }
int isgraph(int c) { return (_ctype[(unsigned) c] & (_P|_U|_L|_N)); }
int open_log_file(long param_1,int param_2) { int iVar1; long lVar2; if ((param_1 == 0) || (lVar2 = get_log_file(), lVar2 == 0)) { return -1; } if (param_2 != -1) { fd_close(param_2); } iVar1 = open_for_append(lVar2); if (iVar1 != -1) { xa_debug(1,"DEBUG: Using logfile %s [fd %d] for %s",lVar2,iVar1,param_1); n_free(lVar2,0x120, "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/roice/ntripcaster/refs/heads/master/ntripcaster0.1.5/src/log.c" ); return iVar1; } write_log(0,"WARNING: Could not open logfile %s for writing, damn!",lVar2); return -1; }
int open_log_file(char *name, int oldfd) { char *logfile; int outfd; if (!name) return -1; logfile = get_log_file(name); if (!logfile) return -1; if (oldfd != -1) fd_close(oldfd); outfd = open_for_append(logfile); if (outfd == -1) { write_log(0, "WARNING: Could not open logfile %s for writing, damn!", logfile ? logfile : "null"); return -1; } xa_debug(1, "DEBUG: Using logfile %s [fd %d] for %s", logfile, outfd, name); n_free (logfile,288,"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/roice/ntripcaster/refs/heads/master/ntripcaster0.1.5/src/log.c") ; logfile=NULL; return outfd; }
undefined8 musb_gadget_pullup(undefined8 param_1,int param_2) { uint *puVar1; puVar1 = (uint *)gadget_to_musb(); spin_lock_irqsave(puVar1 + 1,0); if (*puVar1 != (uint)(param_2 != 0)) { *puVar1 = (uint)(param_2 != 0); schedule_delayed_work(puVar1 + 2,0); } spin_unlock_irqrestore(puVar1 + 1,0); return 0; }
int musb_gadget_pullup(struct usb_gadget *gadget, int is_on) { struct musb *musb = gadget_to_musb(gadget); unsigned long flags; is_on = !!is_on; /* NOTE: this assumes we are sensing vbus; we'd rather * not pullup unless the B-session is active. */ spin_lock_irqsave(&musb->lock, flags); if (is_on != musb->softconnect) { musb->softconnect = is_on; schedule_delayed_work(&musb->gadget_work, 0); } spin_unlock_irqrestore(&musb->lock, flags); return 0; }
void freeKeyTypeVect(undefined8 param_1,undefined8 param_2) { tbKeyTypeVectDestroy(param_2); return; }
void freeKeyTypeVect(void* parent, void* ptr, CRYPTO_EX_DATA* ad, int idx, long argl, void* argp) { (void)parent; (void)ad; (void)idx; (void)argl; (void)argp; tbKeyTypeVectDestroy((tbKeyTypeVect*)ptr); }
undefined8 main(void) { uint uVar1; printf("%s%u",&DAT_00100068,(ulong)N); printf("%s%u",&DAT_00100090,(ulong)M); uVar1 = calculate(); printf("\n%s%u",&DAT_001000d0,(ulong)uVar1); return 0; }
int main(void) { printf("%s%u","\nБрой предмети: ",N); printf("%s%u","\nМаксимална допустима обща маса: ",M); printf("\n%s%u","Максимална постигната ценност: ",calculate()); return 0; }
void ooaofooa_S_FIP_R31_Link(long *param_1,long *param_2,long **param_3) { undefined4 uVar1; *(undefined4 *)((long)param_3 + 0x14) = *(undefined4 *)((long)param_1 + 4); uVar1 = *(undefined4 *)(param_2 + 1); *param_3 = param_2; param_3[1] = param_1; *(undefined4 *)(param_3 + 2) = uVar1; Escher_SetInsertElement(param_1,param_3); *param_2 = (long)param_3; return; }
void ooaofooa_S_FIP_R31_Link( ooaofooa_S_FPK * aone, ooaofooa_S_SYNC * aoth, ooaofooa_S_FIP * assr ) { assr->FunPack_ID = aone->FunPack_ID; assr->Sync_ID = aoth->Sync_ID; assr->S_FPK_R31_is_contained_in = aone; assr->S_SYNC_R31_contains = aoth; Escher_SetInsertElement( &aone->S_FIP_R31, assr ); aoth->S_FIP_R31 = assr; }
undefined8 main(void) { uint uVar1; long *plVar2; long in_FS_OFFSET; undefined8 local_48; undefined4 uStack_40; undefined4 uStack_3c; undefined local_38 [16]; undefined8 local_28; long local_20; plVar2 = &local_48; local_20 = *(long *)(in_FS_OFFSET + 0x28); local_38._4_12_ = SUB1612((undefined [16])0x0,4); local_38._0_4_ = 10; local_28 = 0; local_48._0_4_ = __LC0; local_48._4_4_ = _UNK_001000b4; uStack_40 = _UNK_001000b8; uStack_3c = _UNK_001000bc; do { uVar1 = *(uint *)plVar2; plVar2 = (long *)((long)plVar2 + 4); printf("%d, ",(ulong)uVar1); } while (plVar2 != &local_20); getchar(); if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return 0; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
main() { int numbers[10] = {1, 7, 8, 2}; int *ptr = numbers; int i; *(ptr + 4) = 10; *ptr--; *(ptr + 3) = *(ptr + 9); ptr++; *ptr = 0; *(numbers + 1) = 1; for (i=0;i<10;i++) { printf("%d, ", *(ptr + i)); } # 27 "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/RobertEviston/CollegeWork/refs/heads/master/C Programming/RevisionPtr.c" int my_array[ ] = {1, 3, 4, 5, -1}; int *p; p = my_array; getchar(); }
void pgmin_free(undefined8 param_1) { pd_unbind(param_1,*pd_this); return; }
void pgmin_free(t_pgmin *x) { pd_unbind(&x->x_obj.te_g.g_pd, pd_this->pd_pgmin_sym); }
undefined4 fifo_pop(ulong *param_1,undefined4 *param_2) { ulong uVar1; undefined4 uVar2; long lVar3; if (param_1 == (ulong *)0x0) { return FIFO_ERROR; } lVar3 = fifo_is_empty(); if (lVar3 != FIFO_FALSE) { return FIFO_ERROR; } uVar1 = *param_1; *param_2 = *(undefined4 *)(param_1[2] + uVar1 * 4); *(int *)((long)param_1 + 0xc) = *(int *)((long)param_1 + 0xc) + -1; uVar2 = FIFO_SUCCESS; *param_1 = (uVar1 + 1) % (ulong)(long)*(int *)(param_1 + 1); return uVar2; }
fifo_result_t fifo_pop(fifo_t * fifo, uint8_t * data) { if (NULL != fifo && FIFO_FALSE == fifo_is_empty(fifo)) { *data = fifo->buffer[fifo->first]; fifo->first = (fifo->first + 1) % fifo->size; --fifo->elements_n; return FIFO_SUCCESS; } else { return FIFO_ERROR; } }
undefined8 key_atob_l(long param_1,long param_2,int param_3) { int iVar1; uint uVar2; long lVar3; long lVar4; undefined8 uVar5; if (param_3 < 1) { uVar5 = 0; } else { uVar5 = 0; lVar3 = 0; do { iVar1 = gethexval((int)*(char *)(param_1 + lVar3)); if (iVar1 < 0) { uVar5 = 0xffffffff; } uVar2 = gethexval((int)*(char *)(param_1 + 1 + lVar3)); if ((int)uVar2 < 0) { uVar5 = 0xffffffff; } lVar4 = lVar3 + 2; *(uint *)(param_2 + (long)((int)lVar3 >> 1) * 4) = iVar1 * 0x10 + (uVar2 & 0xff); lVar3 = lVar4; } while (lVar4 != (ulong)(param_3 - 1U >> 1) * 2 + 2); } return uVar5; }
int32_t key_atob_l(char *asc, uchar *bin, int32_t l) { int32_t i, n1, n2, rc; for (i = rc = 0; i < l; i += 2) { if ((n1 = gethexval(asc[i ])) < 0) rc = -1; if ((n2 = gethexval(asc[i+1])) < 0) rc = -1; bin[i >> 1] = (n1 << 4) + (n2 & 0xff); } return rc; }
void m68k_op_roxl_16_ai(void) { undefined4 uVar1; uint uVar2; int iVar3; undefined4 uVar4; uVar1 = EA_AY_AI_16(); uVar2 = m68ki_read_16(uVar1); iVar3 = XFLAG_AS_1(); iVar3 = ROL_17(iVar3 << 0x10 | uVar2,1); FLAG_X = iVar3 >> 8; FLAG_C = FLAG_X; uVar4 = MASK_OUT_ABOVE_16(iVar3); m68ki_write_16(uVar1,uVar4); FLAG_N = NFLAG_16(uVar4); FLAG_Z = uVar4; FLAG_V = VFLAG_CLEAR; return; }
void m68k_op_roxl_16_ai(void) { uint ea = EA_AY_AI_16(); uint src = m68ki_read_16(ea); uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1); FLAG_C = FLAG_X = res >> 8; res = MASK_OUT_ABOVE_16(res); m68ki_write_16(ea, res); FLAG_N = NFLAG_16(res); FLAG_Z = res; FLAG_V = VFLAG_CLEAR; }
double mad(long param_1) { uint uVar1; long lVar2; uint *puVar3; undefined8 extraout_RAX; double dVar4; uint local_38; assert(param_1 != 0); dVar4 = (double)median(param_1); puVar3 = (uint *)copy_vec(param_1); uVar1 = *puVar3; for (local_38 = 0; local_38 < uVar1; local_38 = local_38 + 1) { lVar2 = *(long *)(puVar3 + 2); fabs((double)*(long *)(*(long *)(puVar3 + 2) + (ulong)local_38 * 8) - dVar4); *(undefined8 *)(lVar2 + (ulong)local_38 * 8) = extraout_RAX; } dVar4 = (double)median(puVar3); free_vec(puVar3); return DAT_001000e8 * dVar4; }
double mad ( const VEC v){ assert(NULL!=v); const double vmedian = median(v); VEC vcopy = copy_vec (v); const unsigned int len = vcopy->n; for ( unsigned int i=0 ; i<len ; i++){ vcopy->x[(i)] = (fabs(vcopy->x[(i)]-vmedian)); } const double devmedian = median(vcopy); free_vec(vcopy); return devmedian * 1.4826; }
undefined4 memorystatus_set_process_is_managed(long param_1,long param_2) { undefined4 uVar1; uint *puVar2; uVar1 = EINVAL; if ((param_1 != 0) && (puVar2 = (uint *)proc_find(param_1), uVar1 = ESRCH, puVar2 != (uint *)0x0)) { proc_list_lock(); if (param_2 == TRUE) { *puVar2 = *puVar2 | P_MEMSTAT_MANAGED; } else { *puVar2 = ~P_MEMSTAT_MANAGED & *puVar2; } proc_rele_locked(puVar2); proc_list_unlock(); uVar1 = 0; } return uVar1; }
int memorystatus_set_process_is_managed(pid_t pid, boolean_t set_managed) { proc_t p = NULL; /* Validate inputs */ if (pid == 0) { return EINVAL; } p = proc_find(pid); if (!p) { return ESRCH; } proc_list_lock(); if (set_managed == TRUE) { p->p_memstat_state |= P_MEMSTAT_MANAGED; } else { p->p_memstat_state &= ~P_MEMSTAT_MANAGED; } proc_rele_locked(p); proc_list_unlock(); return 0; }
undefined8 main(void) { int iVar1; char **ppcVar2; undefined8 uVar3; ppcVar2 = (char **)smart_string_new(); uVar3 = 1; if (ppcVar2 != (char **)0x0) { smart_string_append(ppcVar2,0x100000); smart_string_append(ppcVar2,"www.google.com"); smart_string_append(ppcVar2,&_LC2); smart_string_append(ppcVar2,"tracking=1"); smart_string_append(ppcVar2,&_LC4); smart_string_append(ppcVar2,"browser=chrome"); smart_string_append(ppcVar2,"&sk=true"); iVar1 = smart_string_starts_with(ppcVar2,"https"); if (iVar1 == 0) { puts("only accepting https"); } else { puts(*ppcVar2); } puts(*ppcVar2); smart_string_destroy(ppcVar2); uVar3 = 0; } return uVar3; }
int main() { SmartString* ss = smart_string_new(); if(!ss) { return 1; } smart_string_append(ss, "http://"); smart_string_append(ss, "www.google.com"); smart_string_append(ss, "?"); smart_string_append(ss, "tracking=1"); smart_string_append(ss, "&"); smart_string_append(ss, "browser=chrome"); smart_string_append(ss, "&sk=true"); if(!smart_string_starts_with(ss, "https")) { printf("only accepting https\n"); } else { printf("%s\n", ss->buffer); } printf("%s\n", ss->buffer); smart_string_destroy(ss); return 0; }
void _nakd_mutex_unlock(pthread_mutex_t *param_1) { pthread_mutex_unlock(param_1); return; }
void _nakd_mutex_unlock(pthread_mutex_t *lock, const char *lock_name, const char *file, int line) { pthread_mutex_unlock(lock); }
undefined4 * blk_dev_list_search(undefined8 param_1,undefined8 param_2) { long lVar1; undefined4 *puVar2; long in_FS_OFFSET; undefined8 local_30; undefined8 local_28; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); local_30 = 0; list_iter_init(param_1,&local_30); do { puVar2 = (undefined4 *)list_iter_next(local_30); if (puVar2 == (undefined4 *)0x0) { LAB_00100098: list_iter_release(local_30); if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return puVar2; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); } local_28 = 0; string_create(&local_28,"/dev/"); string_add(local_28,*puVar2); lVar1 = string_compare(local_28,param_2); if (lVar1 == ST_OK) { string_release(local_28); goto LAB_00100098; } string_release(local_28); } while( true ); }
blk_dev_t* blk_dev_list_search(list_t* devs, string* name) { list_iter_t* it = NULL; list_iter_init(devs, &it); blk_dev_t* dev; while ((dev = list_iter_next(it))) { string* dev_devname = NULL; string_create(&dev_devname, "/dev/"); string_add(dev_devname, dev->name); if (string_compare(dev_devname, name) == ST_OK) { string_release(dev_devname); break; } string_release(dev_devname); } list_iter_release(it); return dev; }
void sstack_foreach(ulong *param_1,code *param_2,undefined8 param_3) { long lVar1; ulong uVar2; uVar2 = (ulong)(*(int *)((long)param_1 + 0xc) - *(int *)(param_1 + 1)); if (*param_1 <= uVar2) { do { lVar1 = (*param_2)(uVar2,param_3); if (lVar1 == 0) { return; } uVar2 = uVar2 - (long)*(int *)(param_1 + 1); } while (*param_1 <= uVar2); } return; }
void sstack_foreach(struct sstack_s *stack, sstack_iterator_t iter, void *data) { void *element; for (element = stack->last - stack->size; element >= stack->first && iter(element, data); element -= stack->size); }
undefined4 intel_ddi_compute_output_type(undefined8 param_1,undefined8 param_2,int **param_3) { int iVar1; undefined4 uVar2; iVar1 = **param_3; uVar2 = INTEL_OUTPUT_DP; if ((iVar1 != 0x82) && ((0x82 < iVar1 || ((uVar2 = INTEL_OUTPUT_EDP, iVar1 != 0x80 && (uVar2 = INTEL_OUTPUT_HDMI, iVar1 != 0x81)))))) { MISSING_CASE(**param_3); uVar2 = INTEL_OUTPUT_UNUSED; } return uVar2; }
enum intel_output_type intel_ddi_compute_output_type(struct intel_encoder *encoder, struct intel_crtc_state *crtc_state, struct drm_connector_state *conn_state) { switch (conn_state->connector->connector_type) { case DRM_MODE_CONNECTOR_HDMIA: return INTEL_OUTPUT_HDMI; case DRM_MODE_CONNECTOR_eDP: return INTEL_OUTPUT_EDP; case DRM_MODE_CONNECTOR_DisplayPort: return INTEL_OUTPUT_DP; default: MISSING_CASE(conn_state->connector->connector_type); return INTEL_OUTPUT_UNUSED; } }
bool IsAbortedTransactionBlockState(void) { return *CurrentTransactionState == TBLOCK_ABORT || TBLOCK_SUBABORT == *CurrentTransactionState; }
bool IsAbortedTransactionBlockState(void) { TransactionState s = CurrentTransactionState; if (s->blockState == TBLOCK_ABORT || s->blockState == TBLOCK_SUBABORT) return true; return false; }
void DumpBitBuffer(uint *param_1) { ulong uVar1; uint uVar2; uVar2 = 0x1f; assert(*param_1 < 0x20); fprintf((FILE *)(ulong)stderr,"Buffer: "); do { while( true ) { uVar1 = (ulong)(1 << ((byte)uVar2 & 0x1f) & param_1[1]); if (*param_1 != uVar2) break; uVar2 = uVar2 - 1; fprintf((FILE *)(ulong)stderr,"[%lu]",uVar1); if (uVar2 == 0xffffffff) goto LAB_00100081; } uVar2 = uVar2 - 1; fprintf((FILE *)(ulong)stderr,"%lu",uVar1); } while (uVar2 != 0xffffffff); LAB_00100081: fprintf((FILE *)(ulong)stderr,"\n"); return; }
void DumpBitBuffer( BitBuffer *Buf ) { uint64_t i, offset; assert(Buf->BitOffset < (8 * sizeof(Buf->Buffer))); fprintf(stderr, "Buffer: "); for (i = 0; i < (8 * sizeof(Buf->Buffer)); ++i) { offset = (8 * sizeof(Buf->Buffer)) - i - 1; uint64_t bit = Buf->Buffer & (1 << offset); if (offset == Buf->BitOffset) { fprintf(stderr, "[%lu]", bit); } else { fprintf(stderr, "%lu", bit); } } fprintf(stderr, "\n"); }
void oraImm16(void) { uint uVar1; uVar1 = readmemw65816(pbr | w65816pc); w65816pc = w65816pc + 2; w65816a = uVar1 | w65816a; setzn16(w65816a); return; }
void oraImm16(void) { w65816a.w |= readmemw65816(pbr | w65816pc); w65816pc += 2; setzn16(w65816a.w); }
int nftw(char *__dir,__nftw_func_t __func,int __descriptors,int __flag) { int iVar1; iVar1 = ftw_startup(__dir,1,(ulong)__func & 0xffffffff,__descriptors,__flag); return iVar1; }
int nftw (const char *path, __nftw_func_t func, int descriptors, int flags) { return ftw_startup (path, 1, func, descriptors, flags); }
void ReadMsg(int param_1,void *param_2,size_t param_3) { if ((df != 0) && (((byte)vl & 1) != 0)) { fprintf((FILE *)(ulong)stderr,"entering ReadMsg()\n"); param_3 = param_3 & 0xffffffff; } read(param_1,param_2,param_3); return; }
int ReadMsg(int sock, char *buffer, int size) { if (df && (vl&1)) fprintf(stderr,"entering ReadMsg()\n"); return(read(sock,buffer,size)); }
void r654visit_like_current_type_mark(void) { r654crash(); return; }
void r654visit_like_current_type_mark(T654*C,T0*a1){ r654crash(C); }
int iocache_add(int *param_1,void *param_2,uint param_3) { uint uVar1; int iVar2; if (param_1 != (int *)0x0) { uVar1 = iocache_capacity(); if (uVar1 < param_3) { iVar2 = -1; } else { memcpy((void *)(ulong)(uint)(param_1[1] + *param_1),param_2,(ulong)param_3); iVar2 = param_1[2]; param_1[2] = param_3 + iVar2; iVar2 = (param_3 + iVar2) - param_1[1]; } return iVar2; } return -1; }
int iocache_add(iocache *ioc, char *buf, unsigned int len) { if (!ioc || iocache_capacity(ioc) < len) return -1; memcpy(ioc->ioc_buf + ioc->ioc_offset, buf, len); ioc->ioc_buflen += len; return ioc->ioc_buflen - ioc->ioc_offset; }
void dmlab_player_state(undefined8 param_1,undefined8 param_2,int param_3,int param_4) { trap_DeepmindCallback (DEEPMIND_SET_PLAYER_STATE,param_1,param_2,(long)param_3,(long)param_4,0,0,0,0,0,0,0,0); return; }
void dmlab_player_state(const playerState_t* ps, const float eyePos[3], int team_score, int other_team_score) { trap_DeepmindCallback(DEEPMIND_SET_PLAYER_STATE, (intptr_t)ps, (intptr_t)eyePos, (intptr_t) team_score, (intptr_t)other_team_score, 0, 0, 0, 0, 0, 0, 0, 0); }
long xpltOpenNvc0a(void) { long lVar1; printf("(*)Opening NvcOa device...\n"); lVar1 = OpenDevice("\\\\.\\NvcOa",GENERIC_WRITE + GENERIC_READ,0); if (INVALID_HANDLE_VALUE == lVar1) { printf("(-)Unable to open NvcOa. Sorry.\n"); } else { printf("(+)Successfully opened NvcOa.\n"); } return lVar1; }
HANDLE xpltOpenNvc0a() { HANDLE hDevice; printf("(*)Opening NvcOa device...\n"); hDevice = OpenDevice("\\\\.\\NvcOa", GENERIC_READ + GENERIC_WRITE, 0); if(INVALID_HANDLE_VALUE != hDevice) { printf("(+)Successfully opened NvcOa.\n"); } else { printf("(-)Unable to open NvcOa. Sorry.\n"); } return hDevice; }
void op_ldst(uint *param_1,int param_2) { assert(param_1 != (uint *)0x0); *param_1 = (uint)(0x7f < param_2); param_1[1] = (uint)(param_2 == 0); param_1[2] = 0; return; }
void op_ldst( mc6809__t *cpu, mc6809byte__t const dest ) { assert(cpu != NULL); cpu->cc.n = (dest > 0x7F); cpu->cc.z = (dest == 0x00); cpu->cc.v = false; }
char * strndup(char *__string,size_t __n) { char cVar1; char *pcVar2; ulong uVar3; uVar3 = 0xffffffffffffffff; pcVar2 = __string; do { if (uVar3 == 0) break; uVar3 = uVar3 - 1; cVar1 = *pcVar2; pcVar2 = pcVar2 + 1; } while (cVar1 != '\0'); if (~uVar3 - 1 <= __n) { __n = ~uVar3 - 1; } pcVar2 = (char *)malloc(__n + 1); memcpy(pcVar2,__string,__n); pcVar2[__n] = '\0'; return pcVar2; }
char *strndup(const char *s, size_t n) { size_t slen = strlen(s); size_t minLen = (n > slen) ? slen : n; char *newstr = (char *) malloc(minLen + 1); memcpy(newstr, s, minLen); newstr[minLen] = '\0'; return newstr; }
undefined4 get_text_color(void) { return text_color; }
uint8_t get_text_color(void) { return text_color; }
undefined8 musb_gadget_pullup(undefined8 param_1,int param_2) { uint *puVar1; puVar1 = (uint *)gadget_to_musb(); spin_lock_irqsave(puVar1 + 1,0); if (*puVar1 != (uint)(param_2 != 0)) { *puVar1 = (uint)(param_2 != 0); schedule_delayed_work(puVar1 + 2,0); } spin_unlock_irqrestore(puVar1 + 1,0); return 0; }
int musb_gadget_pullup(struct usb_gadget *gadget, int is_on) { struct musb *musb = gadget_to_musb(gadget); unsigned long flags; is_on = !!is_on; /* NOTE: this assumes we are sensing vbus; we'd rather * not pullup unless the B-session is active. */ spin_lock_irqsave(&musb->lock, flags); if (is_on != musb->softconnect) { musb->softconnect = is_on; schedule_delayed_work(&musb->gadget_work, 0); } spin_unlock_irqrestore(&musb->lock, flags); return 0; }
void ht__summon_monster(undefined8 param_1,long param_2,long param_3) { int iVar1; long lVar2; ulong uVar3; long in_FS_OFFSET; long local_30; long local_28; long local_20; local_20 = *(long *)(in_FS_OFFSET + 0x28); lVar2 = *(long *)(cave + param_2 * 8) + param_3 * 0x18; *(undefined8 *)(lVar2 + 0x10) = 0; pusht(*(undefined8 *)(lVar2 + 8)); *(undefined8 *)(*(long *)(cave + param_2 * 8) + 8 + param_3 * 0x18) = 0; uVar3 = 1; while( true ) { iVar1 = randint(3); if ((ulong)(long)(iVar1 + 2) < uVar3) break; local_28 = char_col; local_30 = char_row; lVar2 = is_in(*(undefined4 *)(char_col * 0x18 + *(long *)(cave + char_row * 8)),water_set); if (lVar2 == 0) { summon_land_monster(); } else { summon_water_monster(&local_30,&local_28,0); } uVar3 = uVar3 + 1; } if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) { return; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
void ht__summon_monster(integer dam, integer y, integer x) { integer i1, ty, tx; cave[y][x].fm = 0; pusht(cave[y][x].tptr); cave[y][x].tptr = 0; for (i1 = 1; i1 <= (2+randint(3)); i1++) { ty = char_row; tx = char_col; if (is_in(cave[ty][tx].fval, water_set)) { summon_water_monster(&ty,&tx,0); } else { summon_land_monster(&ty,&tx,0); } } }
void emit_mulpd__xmm__xmm(undefined4 param_1,undefined4 param_2,undefined4 param_3) { long in_FS_OFFSET; undefined local_34 [4]; long local_30; local_30 = *(long *)(in_FS_OFFSET + 0x28); istate_init2(local_34,0xf,0x59); encode__dest__src(local_34,param_3,param_2,0); emit1(param_1,0x66); istate_emit(local_34,param_1,0); if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) { return; } /* WARNING: Subroutine does not return */ __stack_chk_fail(); }
void emit_mulpd__xmm__xmm (sink_p p, int dest, int src) { istate_s s; istate_init2 (&s, 0x0F, 0x59); encode__dest__src (&s, src, dest, 0); emit1 (p, 0x66); istate_emit (&s, p, 0); }
void NRT_MemInfo_varsize_free(long *param_1,long param_2) { NRT_Free(param_2); if (param_2 == *param_1) { *param_1 = 0; } return; }
void NRT_MemInfo_varsize_free(NRT_MemInfo *mi, void *ptr) { NRT_Free(ptr); if (ptr == mi->data) mi->data = NULL; }
void USBHostResume(long param_1,int param_2) { if (param_2 != 0) { *(byte *)(param_1 + 1) = *(byte *)(param_1 + 1) | 4; return; } *(byte *)(param_1 + 1) = *(byte *)(param_1 + 1) & 0xfb; return; }
void USBHostResume(uint32_t ui32Base, bool bStart) { ; if(bStart) { (*((volatile unsigned char *)(ui32Base + 0x00000001))) |= 0x00000004; } else { (*((volatile unsigned char *)(ui32Base + 0x00000001))) &= ~0x00000004; } }
undefined2 shortValueFromNext(FILE *param_1) { long in_FS_OFFSET; undefined2 local_12; long local_10; local_10 = *(long *)(in_FS_OFFSET + 0x28); fread(&local_12,2,1,param_1); local_12 = CFSwapInt16(local_12); if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) { /* WARNING: Subroutine does not return */ __stack_chk_fail(); } return local_12; }
unsigned short shortValueFromNext(FILE *file) { unsigned short retValue; fread(&retValue, 2, 1, file); retValue = CFSwapInt16(retValue); return retValue; }
void indirect2(void) { print_string(); return; }
void indirect2(char c[]){ print_string(c); }
void collector_stop(void) { __sync_bool_compare_and_swap(&keep_running,1,0); pthread_join((ulong)collectorid,(void **)0x0); return; }
void collector_stop(void) { __sync_bool_compare_and_swap(&keep_running, 1, 0); pthread_join(collectorid, NULL); }
undefined4 phys_to_i64(undefined4 param_1) { return param_1; }
int64_t phys_to_i64(vhpiPhysT phys) { return ((int64_t)phys.high) << 32 | phys.low; }