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;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.