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