prog_name
stringlengths 138
138
| strip_func_name
stringlengths 2
176
| prompt
stringclasses 1
value | query
stringlengths 41
170k
| response
stringlengths 12
25k
| hints
stringclasses 1
value |
|---|---|---|---|---|---|
bba09cc2e1eb5efb993454bdf472ff4af0e3b34a78277ac18ade6cbde3628a45_bba09cc2e1eb5efb993454bdf472ff4af0e3b34a78277ac18ade6cbde3628a45.jsonl.gz | sub_4079A0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4079A0(__int64 a1, __int64 a2)
{
float v2; // xmm0_4
__int64 result; // rax
float v4; // xmm0_4
float v5; // [rsp+14h] [rbp-2Ch]
float v6; // [rsp+18h] [rbp-28h]
float v7; // [rsp+1Ch] [rbp-24h]
float v8; // [rsp+20h] [rbp-20h]
float v9; // [rsp+24h] [rbp-1Ch]
__int64 v10; // [rsp+28h] [rbp-18h]
float v11; // [rsp+34h] [rbp-Ch]
float v12; // [rsp+38h] [rbp-8h]
float v13; // [rsp+3Ch] [rbp-4h]
if ( *(int *)(a2 + 8) >= 0 )
{
v10 = a1 + 72 + 40LL * *(int *)(a2 + 8);
if ( *(_BYTE *)v10 != 1 )
*(_DWORD *)(a2 + 8) = -1;
v13 = *(float *)(v10 + 4);
v12 = *(float *)(v10 + 8);
}
else
{
v13 = 30.0;
v12 = 12.0;
}
v9 = v13 - *(float *)a2;
v8 = v12 - *(float *)(a2 + 4);
v2 = sqrt((float)((float)(v8 * v8) + (float)(v9 * v9)));
v7 = v2;
if ( v2 >= 0.1
|| (unsigned __int16)sub_4061E9(*(_QWORD *)(a1 + 56), (int)v13, (int)v12) == 32
|| (unsigned __int16)sub_4061E9(*(_QWORD *)(a1 + 56), (int)v13, (int)v12) == 8776 )
{
v11 = 15.0;
if ( (unsigned __int16)sub_4061E9(*(_QWORD *)(a1 + 56), (int)*(float *)a2, (int)*(float *)(a2 + 4)) == 9650
&& !(unsigned __int16)sub_406241(*(_QWORD *)(a1 + 56), (int)*(float *)a2, (int)*(float *)(a2 + 4)) )
{
v4 = 0.6 * 15.0;
v11 = v4;
}
v6 = (float)((float)((float)(v11 / 86400.0) * v9) / v7) + *(float *)a2;
v5 = (float)((float)((float)(v11 / 86400.0) * v8) / v7) + *(float *)(a2 + 4);
if ( *(int *)(a2 + 8) < 0
|| (result = sub_4061E9(*(_QWORD *)(a1 + 56), (int)v6, (int)v5), (_WORD)result != 32)
&& (result = sub_4061E9(*(_QWORD *)(a1 + 56), (int)v6, (int)v5), (_WORD)result != 8776) )
{
*(float *)a2 = v6;
result = a2;
*(float *)(a2 + 4) = v5;
}
}
else
{
*(float *)a2 = v13;
*(float *)(a2 + 4) = v12;
result = *(unsigned int *)(a2 + 8);
if ( (int)result >= 0 )
{
sub_40629D(a1, 4);
result = (__int64)sub_407312(a1, (_BYTE *)(a1 + 72 + 40LL * *(int *)(a2 + 8)));
}
}
return result;
}
Q:[a1,a2,v5,v6,v7,v8,v9,v11,v12,v13,sub_4079A0,sub_4061E9,sub_406241,sub_40629D,sub_407312,] | A:{'a1': 'game', 'a2': 'squad', 'v5': 'newy', 'v6': 'newx', 'v7': 'd', 'v8': 'dy', 'v9': 'dx_0', 'v11': 'speed', 'v12': 'ty', 'v13': 'tx', 'sub_4079A0': 'squad_step', 'sub_4061E9': 'map_base_0', 'sub_406241': 'map_building', 'sub_40629D': 'game_event_push', 'sub_407312': 'invader_delete'} | |
9aef2261662e8ec0805b58c5a7e0f2418172c3b199557e57d397186470d6f4f6_9aef2261662e8ec0805b58c5a7e0f2418172c3b199557e57d397186470d6f4f6.jsonl.gz | sub_4081E0 | Help user generate meaningful names for variables and functions in the following code snippet. |
char *__fastcall sub_4081E0(__int64 a1, const char *a2, __int64 *a3)
{
__int64 v4; // rax
__int64 v5; // rdx
__int64 v7; // rdx
__int64 *v8; // [rsp+8h] [rbp-48h]
char s; // [rsp+27h] [rbp-29h] BYREF
__int64 arg; // [rsp+28h] [rbp-28h] BYREF
__int64 v12; // [rsp+30h] [rbp-20h]
__int64 v13; // [rsp+38h] [rbp-18h]
char *v14; // [rsp+40h] [rbp-10h]
int v15; // [rsp+4Ch] [rbp-4h]
v8 = a3;
v4 = *a3;
v5 = a3[1];
arg = v4;
v12 = v5;
v13 = a3[2];
v15 = vsnprintf(&s, 1uLL, a2, &arg);
if ( v15 < 0 )
return 0LL;
v14 = (char *)sub_405E55(a1, v15 + 1);
if ( !v14 )
return 0LL;
v7 = v8[1];
arg = *v8;
v12 = v7;
v13 = v8[2];
vsnprintf(v14, v15 + 1, a2, &arg);
sub_4061EA((__int64)v14, (__int64)v14);
return v14;
}
Q:[a3,a1,a2,v8,s,arg,v15,sub_4081E0,sub_4061EA,] | A:{'a3': 'ap', 'a1': 't', 'a2': 'fmt', 'v8': 'apa', 's': 'c', 'arg': 'ap2', 'v15': 'len', 'sub_4081E0': 'talloc_vasprintf', 'sub_4061EA': '_talloc_set_name_const'} | |
0ed12a8f185e514f2f05da4457affdbfa62c67a5c9e59d73f9dcdb648866ef38_0ed12a8f185e514f2f05da4457affdbfa62c67a5c9e59d73f9dcdb648866ef38.jsonl.gz | sub_402D5B | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_402D5B()
{
__int64 result; // rax
qword_4075D0 += 24LL;
sub_4016A9();
sub_401230((_QWORD *)qword_4075D0);
sub_401546(qword_4075D0, qword_4075D0 - 24);
result = qword_4075E8 + 8;
qword_4075E8 += 8LL;
return result;
}
Q:[sub_402D5B,sub_4016A9,sub_401230,sub_401546,] | A:{'sub_402D5B': 'other_dup', 'sub_4016A9': 'check_range', 'sub_401230': 'init_string', 'sub_401546': 'catstr'} | |
2e428f678bb4649d46092cdc472827139571622d9cb2e0251523384fe9462d06_2e428f678bb4649d46092cdc472827139571622d9cb2e0251523384fe9462d06.jsonl.gz | sub_409200 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_409200(std::runtime_error *this)
{
char *v2; // rdi
char *v3; // rdi
*(_QWORD *)this = off_445D40;
v2 = (char *)*((_QWORD *)this + 6);
if ( v2 != (char *)this + 64 )
operator delete(v2, *((_QWORD *)this + 8) + 1LL);
v3 = (char *)*((_QWORD *)this + 2);
if ( v3 != (char *)this + 32 )
operator delete(v3, *((_QWORD *)this + 4) + 1LL);
std::runtime_error::~runtime_error(this);
operator delete(this, 0x60uLL);
}
Q:[sub_409200,] | A:{'sub_409200': '~RenderError'} | |
e21ee1127331112975520015498a17d58c54789e99022cdbe64ddc7645b5d66c_e21ee1127331112975520015498a17d58c54789e99022cdbe64ddc7645b5d66c.jsonl.gz | sub_425B69 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_425B69(__int64 *a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6)
{
__int64 v6; // rcx
__int64 v7; // r8
__int64 v8; // r9
unsigned __int64 v9; // [rsp+18h] [rbp-8h]
v9 = sub_40C28A(a1, 0x100000LL, 4096LL, a4, a5, a6);
sub_425951((__int64)a1, v9, v9, v6, v7, v8);
}
Q:[a1,sub_425B69,sub_40C28A,sub_425951,] | A:{'a1': 'machine', 'sub_425B69': 'syscon_init_auto', 'sub_40C28A': 'rvvm_mmio_zone_auto', 'sub_425951': 'syscon_init'} | |
2c00654bef88d0508fa38ae4f23cd4855f551f44cdb471bbff8963716b7f93f5_2c00654bef88d0508fa38ae4f23cd4855f551f44cdb471bbff8963716b7f93f5.jsonl.gz | sub_413DB5 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_413DB5(__int64 a1, uint16_t a2)
{
_WORD *v3; // [rsp+18h] [rbp-8h]
v3 = (_WORD *)(*(_QWORD *)(a1 + 24) + *(_QWORD *)(a1 + 32) + 6LL);
sub_413C28(a1, 10, 4u);
*v3 = 0;
v3[1] = htons(a2);
*(_QWORD *)(a1 + 32) += 10LL;
return 0LL;
}
Q:[a1,a2,v3,sub_413DB5,sub_413C28,] | A:{'a1': 'buf', 'a2': 'caps', 'v3': 'ptr', 'sub_413DB5': 'add_bearer_caps_avp', 'sub_413C28': 'add_header'} | |
1f4870939c6a06e209cc6778e1d9d9213935f5ce1a00659358f41e29118ddf0a_1f4870939c6a06e209cc6778e1d9d9213935f5ce1a00659358f41e29118ddf0a.jsonl.gz | sub_43218C | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43218C(__int64 a1, __int64 a2, unsigned __int8 *a3, unsigned __int64 a4, unsigned int *a5, int a6)
{
__int64 result; // rax
if ( a6 )
result = sub_4319F0(a1, a2, a3, a4, a5);
else
result = sub_431254(a1, a2, a3, a4, a5);
return result;
}
Q:[a3,a4,a1,a2,a5,a6,sub_43218C,sub_4319F0,sub_431254,] | A:{'a3': 'cSrc', 'a4': 'cSrcSize', 'a1': 'dst', 'a2': 'dstSize', 'a5': 'DTable', 'a6': 'bmi2', 'sub_43218C': 'HUF_decompress1X2_usingDTable_internal', 'sub_4319F0': 'HUF_decompress1X2_usingDTable_internal_bmi2', 'sub_431254': 'HUF_decompress1X2_usingDTable_internal_default'} | |
3d2110cba79424cd08858d638044f28829cd28574ef8db1be145fbeb871b2deb_3d2110cba79424cd08858d638044f28829cd28574ef8db1be145fbeb871b2deb.jsonl.gz | sub_42D583 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42D583(char a1)
{
__int64 result; // rax
if ( a1 <= 31 || a1 == 127 )
result = 46LL;
else
result = (unsigned __int8)a1;
return result;
}
Q:[a1,sub_42D583,] | A:{'a1': 'c', 'sub_42D583': 'safechar_1'} | |
f8ad720e09c911e8439241b65939b6c229dd205d25be7f21b3c7af8e419eebb6_f8ad720e09c911e8439241b65939b6c229dd205d25be7f21b3c7af8e419eebb6.jsonl.gz | sub_409F6E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_409F6E(const char *a1, __int64 a2)
{
int *v2; // rax
char *v3; // rax
__int64 result; // rax
int v5; // [rsp+1Ah] [rbp-26h] BYREF
__int16 v6; // [rsp+1Eh] [rbp-22h]
int fd; // [rsp+20h] [rbp-20h]
unsigned int ii; // [rsp+24h] [rbp-1Ch]
unsigned int n; // [rsp+28h] [rbp-18h]
unsigned int m; // [rsp+2Ch] [rbp-14h]
unsigned int l; // [rsp+30h] [rbp-10h]
unsigned int k; // [rsp+34h] [rbp-Ch]
unsigned int j; // [rsp+38h] [rbp-8h]
unsigned int i; // [rsp+3Ch] [rbp-4h]
v5 = 0;
v6 = 0;
fd = open(a1, 578, 438LL);
if ( fd < 0 )
{
v2 = __errno_location();
v3 = strerror(*v2);
fprintf(stderr, "Error opening file: %s: %s\n", a1, v3);
exit(-1);
}
LOWORD(v5) = 1;
for ( i = 0; *(_DWORD *)(96LL * i + a2) != 515; ++i )
{
for ( j = 0; j < *(_DWORD *)(96LL * i + a2 + 72); ++j )
{
if ( *(_DWORD *)(*(_QWORD *)(96LL * i + a2 + 80) + 56LL * j + 4) == 32 )
{
++HIWORD(v5);
}
else if ( *(_DWORD *)(*(_QWORD *)(96LL * i + a2 + 80) + 56LL * j + 4) == 48 )
{
++v6;
}
else if ( *(_DWORD *)(*(_QWORD *)(96LL * i + a2 + 80) + 56LL * j + 4) )
{
fprintf(
stderr,
"%s: Error invalid sha_len %d\n",
"write_psp_firmware_hash",
*(unsigned int *)(*(_QWORD *)(96LL * i + a2 + 80) + 56LL * j + 4));
exit(-1);
}
}
}
sub_40ABC9((unsigned int)fd, &v5, 6LL);
for ( k = 0; *(_DWORD *)(96LL * k + a2) != 515; ++k )
{
for ( l = 0; l < *(_DWORD *)(96LL * k + a2 + 72); ++l )
{
if ( *(_DWORD *)(*(_QWORD *)(96LL * k + a2 + 80) + 56LL * l + 4) == 32 )
sub_409EFB(fd, *(_QWORD *)(96LL * k + a2 + 80) + 56LL * l);
}
}
for ( m = 0; *(_DWORD *)(96LL * m + a2) != 515; ++m )
{
for ( n = 0; n < *(_DWORD *)(96LL * m + a2 + 72); ++n )
{
if ( *(_DWORD *)(*(_QWORD *)(96LL * m + a2 + 80) + 56LL * n + 4) == 48 )
sub_409EFB(fd, *(_QWORD *)(96LL * m + a2 + 80) + 56LL * n);
}
}
close(fd);
for ( ii = 0; ; ++ii )
{
result = *(unsigned int *)(96LL * ii + a2);
if ( (_DWORD)result == 515 )
break;
if ( *(_DWORD *)(96LL * ii + a2 + 72) )
{
if ( *(_QWORD *)(96LL * ii + a2 + 80) )
{
free(*(void **)(96LL * ii + a2 + 80));
*(_QWORD *)(96LL * ii + a2 + 80) = 0LL;
*(_DWORD *)(96LL * ii + a2 + 72) = 0;
}
}
}
return result;
}
Q:[a1,a2,v5,ii,n,m,l,k,sub_409F6E,sub_40ABC9,sub_409EFB,] | A:{'a1': 'filename', 'a2': 'fw_table', 'v5': 'hash_header', 'ii': 'i_2', 'n': 'j_1', 'm': 'i_1', 'l': 'j_0', 'k': 'i_0', 'sub_409F6E': 'write_psp_firmware_hash', 'sub_40ABC9': 'write_or_fail', 'sub_409EFB': 'write_one_psp_firmware_hash_entry'} | |
44e8aed08fe933b793e356a871e8f31cdd3a534e9dca1fb63610d519aee2b0ea_44e8aed08fe933b793e356a871e8f31cdd3a534e9dca1fb63610d519aee2b0ea.jsonl.gz | sub_457B1E | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_457B1E(__int64 a1, void *a2)
{
operator delete(a2);
}
Q:[sub_457B1E,] | A:{'sub_457B1E': 'deallocate'} | |
d6f1c4fccbb8fc2066c0c7749389636df7b33c67e152dc8852a86b3a79bd4c3d_d6f1c4fccbb8fc2066c0c7749389636df7b33c67e152dc8852a86b3a79bd4c3d.jsonl.gz | sub_430FC7 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_430FC7(__int64 a1)
{
__int64 v2; // [rsp+18h] [rbp-8h]
v2 = off_79D3A0(384LL);
if ( !v2 )
return 1LL;
*(_QWORD *)(a1 + 8) = sub_4A008B;
*(_QWORD *)(a1 + 16) = v2;
*(_QWORD *)(a1 + 32) = 0LL;
*(_QWORD *)(a1 + 24) = sub_4A7EED;
*(_BYTE *)(a1 + 129) = 2;
*(_QWORD *)(a1 + 72) = 0LL;
*(_QWORD *)(a1 + 40) = sub_4A04FF;
*(_QWORD *)(a1 + 64) = sub_4A0531;
*(_QWORD *)(a1 + 48) = sub_4A054C;
*(_QWORD *)(a1 + 56) = sub_4A056F;
return 0LL;
}
Q:[a1,v2,sub_430FC7,sub_4A008B,sub_4A7EED,sub_4A04FF,sub_4A0531,sub_4A054C,sub_4A056F,] | A:{'a1': 'ud', 'v2': 'info', 'sub_430FC7': 'M68K_global_init', 'sub_4A008B': 'M68K_printInst', 'sub_4A7EED': 'M68K_getInstruction', 'sub_4A04FF': 'M68K_reg_name', 'sub_4A0531': 'M68K_get_insn_id', 'sub_4A054C': 'M68K_insn_name', 'sub_4A056F': 'M68K_group_name'} | |
c305b540beeb91de0683f14151efc79b8231667323725757dad9e744300ff63d_c305b540beeb91de0683f14151efc79b8231667323725757dad9e744300ff63d.jsonl.gz | sub_410BFA | Help user generate meaningful names for variables and functions in the following code snippet. |
int sub_410BFA()
{
__int64 v0; // rax
v0 = *((_QWORD *)dest + 16);
if ( v0 )
LODWORD(v0) = sub_40EE55(*((_QWORD *)dest + 16), *(_DWORD *)(*((_QWORD *)dest + 16) + 384LL) == 0);
return v0;
}
Q:[sub_410BFA,sub_40EE55,] | A:{'sub_410BFA': 'togglefullscreen', 'sub_40EE55': 'setfullscreen'} | |
29fe55199f7a59edb5da76ece7916ac4cb5a36de96cf9c076de382553a47c236_29fe55199f7a59edb5da76ece7916ac4cb5a36de96cf9c076de382553a47c236.jsonl.gz | sub_44CF3D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_44CF3D(unsigned int a1, __int64 a2, unsigned int a3)
{
__int64 result; // rax
if ( isatty(a1) == 1 )
result = sub_44CF89(a1, a2, a3);
else
result = sub_44CBEB(1, 24);
return result;
}
Q:[a3,a1,a2,sub_44CF3D,sub_44CF89,sub_44CBEB,] | A:{'a3': 'tout', 'a1': 'did', 'a2': 'readbuf', 'sub_44CF3D': 'SQ_Device_Read', 'sub_44CF89': 'SQ_Device_Read_TTY', 'sub_44CBEB': 'getError'} | |
478a2aa13acc374840c7ee6e5c5fbe474149f49bc9a75c7cb03bfe92ae1487ca_478a2aa13acc374840c7ee6e5c5fbe474149f49bc9a75c7cb03bfe92ae1487ca.jsonl.gz | sub_4063D0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4063D0(__int64 a1)
{
return sub_4062F2(a1);
}
Q:[a1,sub_4063D0,sub_4062F2,] | A:{'a1': 'p', 'sub_4063D0': 'castExpr', 'sub_4062F2': 'unaryExpr'} | |
7898a45514a51514556e8ce9f1e754c503d76053495f12f406c42d8c77ac7056_7898a45514a51514556e8ce9f1e754c503d76053495f12f406c42d8c77ac7056.jsonl.gz | sub_401445 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_401445(__int64 a1, __int64 a2)
{
return sub_40224D(a1, a2);
}
Q:[a1,a2,sub_401445,sub_40224D,] | A:{'a1': 'nvram', 'a2': 'var', 'sub_401445': 'do_unset', 'sub_40224D': 'nvram_unset'} | |
c0889e43b9fb99e0a15d5a45e58572120bf2a06ee20b165810a3d68c382cd705_c0889e43b9fb99e0a15d5a45e58572120bf2a06ee20b165810a3d68c382cd705.jsonl.gz | sub_445307 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_445307(unsigned __int64 *a1, int a2)
{
__int64 result; // rax
++qword_4F3D00;
result = sub_41429C(a1, a2, (unsigned __int64)(a1 + 31));
++qword_4F3D08;
return result;
}
Q:[a1,a2,sub_445307,sub_41429C,] | A:{'a1': 'self_p', 'a2': 'length', 'sub_445307': 'field_names_repeated_message_camel_case_my_enum_alloc', 'sub_41429C': 'pbtools_alloc_repeated_int32'} | |
3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33_3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33.jsonl.gz | sub_42FC8C | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42FC8C(__int64 a1)
{
__int64 result; // rax
long double v2; // fst6
unsigned __int64 v3; // rdx
__int64 v4; // [rsp+28h] [rbp-28h]
char *v5; // [rsp+30h] [rbp-20h]
int i; // [rsp+3Ch] [rbp-14h]
char *v7; // [rsp+40h] [rbp-10h]
__int64 v8; // [rsp+48h] [rbp-8h]
v8 = 8 * (*(_BYTE *)a1 & 0x7F) + (*(_DWORD *)a1 >> 11);
result = (*(_BYTE *)a1 & 0x7Fu) - 7;
switch ( *(_BYTE *)a1 & 0x7F )
{
case 7:
case 8:
case 9:
case 0xA:
case 0xB:
case 0xC:
case 0xD:
case 0xE:
case 0xF:
case 0x10:
case 0x11:
case 0x12:
case 0x13:
case 0x14:
case 0x17:
case 0x18:
case 0x19:
case 0x1A:
case 0x1B:
case 0x1C:
case 0x1D:
case 0x1E:
case 0x1F:
case 0x20:
case 0x21:
case 0x22:
case 0x23:
case 0x24:
case 0x25:
case 0x26:
case 0x27:
case 0x28:
case 0x29:
case 0x2A:
case 0x2B:
case 0x2C:
case 0x2D:
case 0x2E:
case 0x2F:
case 0x30:
case 0x31:
goto LABEL_3;
case 0x32:
case 0x33:
case 0x34:
case 0x40:
goto LABEL_4;
case 0x35:
case 0x36:
case 0x37:
case 0x3D:
case 0x3E:
case 0x3F:
result = *(_QWORD *)(a1 + 56);
if ( !result )
return result;
result = *(unsigned int *)(*(_QWORD *)(a1 + 56) + 80LL);
if ( (int)result < 0 )
return result;
v8 += *(int *)(*(_QWORD *)(a1 + 56) + 80LL) + *(_QWORD *)(a1 + 48);
goto LABEL_23;
case 0x42:
v8 += *(_QWORD *)(a1 + 64);
LABEL_3:
v8 += *(_QWORD *)(a1 + 56);
LABEL_4:
v8 += *(_QWORD *)(a1 + 48);
goto LABEL_23;
case 0x46:
v5 = *(char **)(a1 + 56);
v7 = v5;
if ( v5 )
{
do
{
for ( i = 0; i < *v7; ++i )
{
v4 = *(_QWORD *)&v7[8 * i + 24];
if ( (!v7[1] || v4) && (_UNKNOWN *)v4 != &unk_468860 && *(_QWORD *)(v4 + 24) )
v8 += *(_QWORD *)(*(_QWORD *)(v4 + 24) + 8LL) + *(_QWORD *)(*(_QWORD *)(v4 + 24) + 48LL);
}
v7 = (char *)*((_QWORD *)v7 + 2);
}
while ( v7 != v5 );
}
goto LABEL_23;
case 0x47:
v8 += *(_QWORD *)(a1 + 48);
goto LABEL_23;
case 0x48:
v2 = *(long double *)(a1 + 48);
if ( v2 >= 9.223372036854775808e18 )
v3 = (__int64)(v2 - 9.223372036854775808e18) ^ 0x8000000000000000LL;
else
v3 = (__int64)v2;
LODWORD(v8) = v3 + v8;
LABEL_23:
result = sub_42FBA4(&qword_492820[(unsigned __int8)(BYTE2(v8) + v8)], a1);
break;
default:
return result;
}
return result;
}
Q:[a1,v4,v5,i,v7,v8,sub_42FC8C,sub_42FBA4,] | A:{'a1': 'insn', 'v4': 'phi', 'v5': '__headphi', 'i': '__nrphi', 'v7': '__listphi', 'v8': 'hash', 'sub_42FC8C': 'cse_collect', 'sub_42FBA4': 'add_instruction_1'} | |
c01d3aec38f1f0fc6d283c3a670d938f7f9dc20a11765202b902e11a359342bd_c01d3aec38f1f0fc6d283c3a670d938f7f9dc20a11765202b902e11a359342bd.jsonl.gz | sub_435422 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_435422(__int64 a1)
{
__int64 v1; // [rsp+10h] [rbp-10h]
__int64 v2; // [rsp+18h] [rbp-8h]
v1 = *(_QWORD *)(a1 + 16872);
v2 = v1;
do
v2 = sub_4390A3(a1, v2);
while ( v2 != v1 );
sub_4276AA((FILE **)a1, "transform_to_arch_instructions", *(FILE **)(a1 + 32));
}
Q:[a1,v1,v2,sub_435422,sub_4390A3,sub_4276AA,] | A:{'a1': 'state', 'v1': 'first', 'v2': 'ins', 'sub_435422': 'transform_to_arch_instructions', 'sub_4390A3': 'transform_to_arch_instruction', 'sub_4276AA': 'print_blocks'} | |
370b4db309f59c8f514b381a85873bd083ea89f4439ad967e0d8d4c81708f0b3_370b4db309f59c8f514b381a85873bd083ea89f4439ad967e0d8d4c81708f0b3.jsonl.gz | sub_40DCC6 | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_40DCC6()
{
;
}
Q:[sub_40DCC6,] | A:{'sub_40DCC6': 'reset_0'} | |
614f31b237021943f00edd1722efa5c25b232a880ba0ce0b95bc8b4ce694ebc2_614f31b237021943f00edd1722efa5c25b232a880ba0ce0b95bc8b4ce694ebc2.jsonl.gz | sub_4121FE | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4121FE(__int64 a1)
{
__int64 result; // rax
*(_DWORD *)(a1 + 2312) = 1;
*(_WORD *)(a1 + 2328) = *(_WORD *)(a1 + 24);
*(_WORD *)(a1 + 2330) = *(_WORD *)(a1 + 18) + *(_WORD *)(a1 + 14);
*(_WORD *)(a1 + 2330) += *(_WORD *)(*(_QWORD *)(a1 + 2320) + 1LL);
*(_WORD *)(a1 + 2332) = 3;
result = a1;
*(_QWORD *)(a1 + 2336) += 11LL;
return result;
}
Q:[a1,sub_4121FE,] | A:{'a1': 'c', 'sub_4121FE': 'ea_get13'} | |
283ed54b1f66acccce94b9477f53c760e922840320b559e1a065b55929915f6d_283ed54b1f66acccce94b9477f53c760e922840320b559e1a065b55929915f6d.jsonl.gz | sub_40AB1A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40AB1A(_BYTE *a1, _BYTE *a2, int a3)
{
_BYTE *v3; // rbx
_BYTE *v4; // r12
__int64 result; // rax
size_t i; // r13
size_t j; // r14
unsigned int v8; // er14
v3 = a1;
v4 = a2;
if ( !a1 )
return 1LL;
if ( !a2 )
return 0xFFFFFFFFLL;
while ( 1 )
{
if ( !*v3 )
return 1LL;
if ( !*v4 )
return 0xFFFFFFFFLL;
while ( *v3 == 48 )
++v3;
for ( i = 0LL; (unsigned int)((char)v3[i] - 48) <= 9; ++i )
;
while ( *v4 == 48 )
++v4;
for ( j = 0LL; (unsigned int)((char)v4[j] - 48) <= 9; ++j )
;
if ( i != j )
break;
v8 = memcmp(v3, v4, i);
if ( v8 )
return v8;
if ( !--a3 )
return 0LL;
v3 += i;
v4 += i;
if ( *v3 == 46 )
++v3;
if ( *v4 == 46 )
++v4;
}
if ( i >= j )
result = 1LL;
else
result = 0xFFFFFFFFLL;
return result;
}
Q:[a3,a1,a2,sub_40AB1A,] | A:{'a3': 'length', 'a1': 'num1', 'a2': 'num2', 'sub_40AB1A': 'compartial'} | |
3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33_3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33.jsonl.gz | sub_405727 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 *__fastcall sub_405727(__int64 a1, int a2)
{
_BOOL4 i; // eax
__int64 *v4; // [rsp+8h] [rbp-8h]
v4 = (__int64 *)a1;
for ( i = sub_4056A8(a1, a2); !i && v4 != &qword_471180; i = sub_4056A8((__int64)v4, a2) )
v4 = (__int64 *)v4[1];
return v4;
}
Q:[a1,a2,sub_405727,sub_4056A8,] | A:{'a1': 'token', 'a2': 'op', 'sub_405727': 'skip_to', 'sub_4056A8': 'match_op'} | |
44ee792ef2256e9f771d78d41cbfab9051cda41f41311096bdebbd2072d0b092_44ee792ef2256e9f771d78d41cbfab9051cda41f41311096bdebbd2072d0b092.jsonl.gz | sub_442E00 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_442E00(__int64 a1, unsigned __int64 a2)
{
unsigned __int64 v2; // rax
unsigned __int64 v3; // rbx
void *v4; // rax
unsigned int v5; // er8
v2 = *(_QWORD *)(a1 + 16);
if ( v2 >= a2 )
return 1LL;
v3 = a2;
if ( 2 * v2 >= a2 )
v3 = (3 * a2) >> 1;
v4 = realloc(*(void **)a1, v3);
if ( !v4 )
return 0;
*(_QWORD *)(a1 + 16) = v3;
v5 = 1;
*(_QWORD *)a1 = v4;
return v5;
}
Q:[sub_442E00,] | A:{'sub_442E00': 'ucvector_reserve'} | |
09e593e1a10a4f6cadf5c016cb4c8cfb0a3586515f0619eba999737feb58c9d7_09e593e1a10a4f6cadf5c016cb4c8cfb0a3586515f0619eba999737feb58c9d7.jsonl.gz | sub_4352BB | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4352BB(__int64 a1)
{
return sub_4352DA(a1, 0xFFFFLL);
}
Q:[a1,sub_4352BB,sub_4352DA,] | A:{'a1': 'filename', 'sub_4352BB': 'file_slurp', 'sub_4352DA': 'file_load_data'} | |
3f1dbef0dcf52c12d23f5f5f78b2c3a922afbe6ead5cd010f21e0c1d6bff98ee_3f1dbef0dcf52c12d23f5f5f78b2c3a922afbe6ead5cd010f21e0c1d6bff98ee.jsonl.gz | sub_70010EBD | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_70010EBD(int a1)
{
return sub_70010C3B(a1, (__int64 (__fastcall *)(_QWORD))sub_70002F06, (void (*)(void))sub_70010E4B);
}
Q:[a1,sub_70010EBD,sub_70010C3B,sub_70002F06,sub_70010E4B,] | A:{'a1': 'eip_0', 'sub_70010EBD': 'cmovb_rm2r_w', 'sub_70010C3B': 'idex_36', 'sub_70002F06': 'decode_rm2r_w', 'sub_70010E4B': 'do_cmovb_rm2r_w'} | |
07e33571f3d22d6098974cc8e790b17fd95356f533959cd2b0c038d2c74715a0_07e33571f3d22d6098974cc8e790b17fd95356f533959cd2b0c038d2c74715a0.jsonl.gz | sub_405307 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_405307(FILE *a1, const void *a2, size_t a3)
{
__int64 result; // rax
if ( a1 )
{
if ( a2 )
{
if ( a3 == fwrite(a2, 1uLL, a3, a1) )
{
result = 1LL;
}
else
{
if ( *(_BYTE *)(((unsigned __int64)&stderr >> 3) + 0x7FFF8000) )
__asan_report_load8();
fwrite("saveblock: Can't save block to file.\n", 1uLL, 0x25uLL, stderr);
result = 0LL;
}
}
else
{
if ( *(_BYTE *)(((unsigned __int64)&stderr >> 3) + 0x7FFF8000) )
__asan_report_load8();
fwrite("saveblock: data is NULL pointer.\n", 1uLL, 0x21uLL, stderr);
result = 0LL;
}
}
else
{
if ( *(_BYTE *)(((unsigned __int64)&stderr >> 3) + 0x7FFF8000) )
__asan_report_load8();
fwrite("saveblock: file is NULL pointer.\n", 1uLL, 0x21uLL, stderr);
result = 0LL;
}
return result;
}
Q:[a3,a1,a2,sub_405307,] | A:{'a3': 'size', 'a1': 'file', 'a2': 'data', 'sub_405307': 'saveblock'} | |
8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197_8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197.jsonl.gz | sub_41D5A8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41D5A8(__int64 a1, __int64 a2)
{
char v3[8]; // [rsp+18h] [rbp-8h] BYREF
sub_41E7FE(v3, a1);
return sub_41E818(a1, a2, v3);
}
Q:[sub_41D5A8,sub_41E7FE,sub_41E818,] | A:{'sub_41D5A8': '_M_copy', 'sub_41E7FE': '_Alloc_node', 'sub_41E818': 'allocator'} | |
7c16ecc1f4177280f9c554334c74c60179f6cbd74ce0674df9f0cc7c89723807_7c16ecc1f4177280f9c554334c74c60179f6cbd74ce0674df9f0cc7c89723807.jsonl.gz | sub_4130D0 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int8 __fastcall sub_4130D0(__int64 a1)
{
unsigned __int8 result; // al
result = be_ismodule(a1, 0xFFFFFFFF);
if ( result )
{
if ( be_getmember(a1, 0xFFFFFFFF, (__int64)"init") )
{
be_pushvalue(a1, 0xFFFFFFFE);
be_call(a1, 1u);
be_pop(a1, 1);
result = (unsigned __int8)be_remove(a1, 0xFFFFFFFE);
}
else
{
result = be_pop(a1, 1);
}
}
return result;
}
Q:[a1,sub_4130D0,] | A:{'a1': 'vm', 'sub_4130D0': 'module_init'} | |
7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2_7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2.jsonl.gz | sub_407A43 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_407A43(__int64 a1, __int64 a2, unsigned int *a3, unsigned int a4, const void *a5, unsigned int a6)
{
int v11; // [rsp+34h] [rbp-1Ch] BYREF
char v12; // [rsp+3Bh] [rbp-15h] BYREF
unsigned int v13; // [rsp+3Ch] [rbp-14h] BYREF
void *dest; // [rsp+40h] [rbp-10h]
unsigned int v15; // [rsp+4Ch] [rbp-4h]
v13 = *a3;
if ( (int)sub_404AF7(a2, &v13, &v12, a4) < 0 )
return 4294967156LL;
if ( v12 != 48 )
{
if ( (int)sub_406272(a2, a3, (unsigned int *)(a1 + 884), 3, a4) < 0 )
return 4294967156LL;
v15 = sub_40609F(*(_DWORD *)(a1 + 884));
if ( (v15 & 0x80000000) != 0 )
return 4294967124LL;
v15 = sub_4056A5(a2, a3, &v11, a4, 1, 0LL);
if ( v15 )
return v15;
*a3 += v11;
}
dest = (void *)sub_43D332(a6);
if ( !dest )
return 4294967171LL;
memcpy(dest, a5, a6);
*(_QWORD *)a1 = dest;
*(_DWORD *)(a1 + 12) = 1;
*(_DWORD *)(a1 + 8) = a6;
return 0LL;
}
Q:[a3,a4,a1,a2,a5,a6,v11,v12,v13,dest,sub_407A43,sub_404AF7,sub_406272,sub_40609F,sub_4056A5,sub_43D332,] | A:{'a3': 'srcIdx', 'a4': 'maxIdx', 'a1': 'cert', 'a2': 'source', 'a5': 'pubKey', 'a6': 'pubKeyLen', 'v11': 'length', 'v12': 'tag', 'v13': 'localIdx', 'dest': 'publicKey', 'sub_407A43': 'StoreEccKey', 'sub_404AF7': 'GetASNTag', 'sub_406272': 'GetObjectId', 'sub_40609F': 'CheckCurve', 'sub_4056A5': 'CheckBitString', 'sub_43D332': 'wolfSSL_Malloc'} | |
b0a9cd2f3e4fb25c6201aa09bcf5782ae37b5367e290f1eed7e0432fa3739c0f_b0a9cd2f3e4fb25c6201aa09bcf5782ae37b5367e290f1eed7e0432fa3739c0f.jsonl.gz | sub_4330D6 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4330D6(unsigned int a1, char a2, __int16 a3, int *a4, unsigned int a5)
{
_BOOL4 v5; // eax
int v10; // [rsp+2Ch] [rbp-4h]
v5 = (a2 & 0x20) != 0 && (a4[4] & 0x2000) == 0;
v10 = v5;
sub_432C39(1, a3, a2, a1);
return sub_432F67(a2, a3, a4, a5, v10);
}
Q:[a3,a4,a1,a2,a5,v10,sub_4330D6,sub_432C39,sub_432F67,] | A:{'a3': 'r', 'a4': 'sym', 'a1': 'opcode', 'a2': 'op_reg', 'a5': 'c', 'v10': 'is_got', 'sub_4330D6': 'gen_modrm64', 'sub_432C39': 'orex', 'sub_432F67': 'gen_modrm_impl'} | |
bf7ae1a4450b359f92e96f59068a71bc49375889282b3e96663c3c09631e7838_bf7ae1a4450b359f92e96f59068a71bc49375889282b3e96663c3c09631e7838.jsonl.gz | sub_49603D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_49603D(char *a1, __int64 a2, _DWORD *a3)
{
__int64 result; // rax
__int64 v4; // rcx
__int64 v5; // r8
__int64 v6; // r9
size_t v7; // rax
char s[3]; // [rsp+20h] [rbp-820h] BYREF
char v10; // [rsp+23h] [rbp-81Dh] BYREF
char v11; // [rsp+24h] [rbp-81Ch]
char v12[1024]; // [rsp+420h] [rbp-420h] BYREF
int v13; // [rsp+820h] [rbp-20h]
int v14; // [rsp+824h] [rbp-1Ch]
char *src; // [rsp+828h] [rbp-18h]
__int64 v16; // [rsp+830h] [rbp-10h]
char *v17; // [rsp+838h] [rbp-8h]
v17 = a1;
v16 = -1LL;
src = sub_434CE5(a1, s, 59);
if ( !src || !*src )
src = "9600-8N1";
if ( a3 )
*a3 = 0;
if ( strlen(s) <= 5
&& (unsigned int)sub_4519F6(s[0]) == 115
&& (unsigned int)sub_4519F6(s[1]) == 101
&& (unsigned int)sub_4519F6(s[2]) == 114
&& sub_451A6A(v10)
&& (sub_451A6A(v11) || !v11) )
{
v13 = atoi(&v10);
v17 = sub_495876(v13, v12);
if ( !v17 )
{
if ( a3 )
*a3 = 70;
return -1LL;
}
}
else
{
v17 = sub_4958E8(s, v12);
if ( !v17 )
{
v17 = sub_495A31(s, v12);
if ( !v17 )
v17 = s;
}
}
if ( sub_49533F(v17) )
{
if ( a3 )
*a3 = 70;
result = -1LL;
}
else
{
v16 = sub_49684A(v17);
if ( v16 == -1 )
{
if ( a3 )
*a3 = 70;
result = v16;
}
else
{
v14 = sub_4963A6(v16, src);
if ( a2 && !v14 )
v14 = sub_464669(a2, src, (__int64)src, v4, v5, v6);
if ( v14 )
{
sub_49637F(v16);
if ( a3 )
*a3 = v14;
v16 = -1LL;
}
if ( v16 != -1 && *src && a2 )
{
v7 = strlen(src);
*(_QWORD *)(a2 + 304) = realloc(*(void **)(a2 + 304), v7 + 1);
strcpy(*(char **)(a2 + 304), src);
}
if ( v16 != -1 )
sub_4953CD(v16, a2, v17, src);
result = v16;
}
}
return result;
}
Q:[a3,a1,a2,s,v12,v13,v14,src,v16,v17,sub_49603D,sub_434CE5,sub_4519F6,sub_451A6A,sub_495876,sub_4958E8,sub_495A31,sub_49533F,sub_49684A,sub_4963A6,sub_464669,sub_49637F,sub_4953CD,] | A:{'a3': 'stat', 'a1': 'name', 'a2': 'lp', 's': 'devname', 'v12': 'temp1', 'v13': 'num', 'v14': 'status', 'src': 'config', 'v16': 'port', 'v17': 'savname', 'sub_49603D': 'sim_open_serial', 'sub_434CE5': 'get_glyph_nc', 'sub_4519F6': 'sim_tolower', 'sub_451A6A': 'sim_isdigit', 'sub_495876': 'sim_serial_getname', 'sub_4958E8': 'sim_serial_getname_bydesc', 'sub_495A31': 'sim_serial_getname_byname', 'sub_49533F': '_get_open_device_byname', 'sub_49684A': 'sim_open_os_serial', 'sub_4963A6': 'sim_config_serial', 'sub_464669': 'tmxr_set_config_line', 'sub_49637F': 'sim_close_serial', 'sub_4953CD': '_serial_add_to_open_list'} | |
dade8a50f9553a2c8d312f40f9e938d800aaeceed2d235843ec2760ee3f4ab45_dade8a50f9553a2c8d312f40f9e938d800aaeceed2d235843ec2760ee3f4ab45.jsonl.gz | sub_40DD4B | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall __noreturn sub_40DD4B(const char *a1)
{
fprintf(stderr, "%s\n", a1);
abort();
}
Q:[a1,sub_40DD4B,] | A:{'a1': 'msg', 'sub_40DD4B': 'gmp_die'} | |
ebce38d56473c420b2dd35734b38c295e926b8a2feaa22442c4129495df4ce92_ebce38d56473c420b2dd35734b38c295e926b8a2feaa22442c4129495df4ce92.jsonl.gz | sub_4043A7 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4043A7(int a1, __int64 a2)
{
int v3; // [rsp+10h] [rbp-50h] BYREF
__int64 v4; // [rsp+18h] [rbp-48h]
unsigned int v5; // [rsp+5Ch] [rbp-4h]
if ( byte_428460[0] != 1 || !a2 )
return (unsigned int)-22;
v3 = a1;
v5 = sub_406F3D(&v3, 7LL, 0LL);
if ( !v5 )
{
sub_411CCC(a2, 0LL, 48LL);
*(_BYTE *)a2 = 0;
*(_DWORD *)(a2 + 4) = a1;
*(_WORD *)(a2 + 8) = *(_WORD *)(v4 + 48);
*(_WORD *)(a2 + 10) = *(_WORD *)(v4 + 50);
*(_DWORD *)(a2 + 12) = *(_DWORD *)(v4 + 40);
*(_DWORD *)(a2 + 16) = *(_DWORD *)(v4 + 44);
*(_QWORD *)(a2 + 24) = *(_QWORD *)(v4 + 16);
*(_DWORD *)(a2 + 32) = *(_DWORD *)(v4 + 28);
*(_DWORD *)(a2 + 36) = *(_DWORD *)(v4 + 32);
*(_DWORD *)(a2 + 40) = *(_DWORD *)(v4 + 36);
*(_DWORD *)(a2 + 44) = *(_DWORD *)(v4 + 24);
sub_407863(&v3, 0LL);
}
return v5;
}
Q:[a1,a2,v3,sub_4043A7,sub_406F3D,sub_411CCC,sub_407863,] | A:{'a1': 'ulInode', 'a2': 'pStat', 'v3': 'ino', 'sub_4043A7': 'RedCoreStat', 'sub_406F3D': 'RedInodeMount', 'sub_411CCC': 'RedMemSet', 'sub_407863': 'RedInodePut'} | |
815149ae5fd39d75d7cc8d775865cd539022d76946b2a654ee9f9bd553ff4ecd_815149ae5fd39d75d7cc8d775865cd539022d76946b2a654ee9f9bd553ff4ecd.jsonl.gz | sub_42DCE0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42DCE0(__int64 a1, int a2)
{
char *v5; // [rsp+0h] [rbp-88h]
__int128 v6; // [rsp+10h] [rbp-78h] BYREF
void *v7[2]; // [rsp+20h] [rbp-68h] BYREF
_QWORD v8[2]; // [rsp+30h] [rbp-58h] BYREF
void *v9; // [rsp+40h] [rbp-48h] BYREF
__int64 v10; // [rsp+50h] [rbp-38h] BYREF
strcpy((char *)v8, "type_error");
v7[0] = v8;
v7[1] = (void *)10;
sub_42CBB0(&v9, (__int64)v7, a2);
_RAX = (char **)std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::_M_append();
v5 = (char *)&v6;
if ( *_RAX == (char *)(_RAX + 2) )
{
__asm
{
vmovdqu xmm0, xmmword ptr [rax+10h]
vmovdqa [rsp+88h+var_78], xmm0
}
}
else
{
v5 = *_RAX;
*(_QWORD *)&v6 = _RAX[2];
}
*((_BYTE *)_RAX + 16) = 0;
*_RAX = (char *)(_RAX + 2);
_RAX[1] = 0LL;
if ( v9 != &v10 )
operator delete(v9, v10 + 1);
if ( v7[0] != v8 )
operator delete(v7[0], v8[0] + 1LL);
*(_QWORD *)a1 = off_43E6C0;
*(_DWORD *)(a1 + 8) = a2;
std::runtime_error::runtime_error((std::runtime_error *)(a1 + 16), v5);
*(_QWORD *)a1 = off_43E710;
if ( v5 != (char *)&v6 )
operator delete(v5, v6 + 1);
return a1;
}
Q:[sub_42DCE0,sub_42CBB0,] | A:{'sub_42DCE0': 'create', 'sub_42CBB0': 'name'} | |
9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0_9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0.jsonl.gz | sub_456A02 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_456A02(__int64 a1)
{
return a1;
}
Q:[sub_456A02,] | A:{'sub_456A02': 'allocator'} | |
0c36dffccb2de7d67a0497c756b7cebe089a3d9eaaf497404f090d51226de782_0c36dffccb2de7d67a0497c756b7cebe089a3d9eaaf497404f090d51226de782.jsonl.gz | sub_402C7E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_402C7E(__int64 a1, int a2, int a3)
{
unsigned int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; (int)i < a2; ++i )
{
if ( a3 == *(_DWORD *)(4LL * (int)i + a1) )
return i;
}
return 0xFFFFFFFFLL;
}
Q:[a3,a1,a2,sub_402C7E,] | A:{'a3': 'rootVal', 'a1': 'inorder', 'a2': 'count', 'sub_402C7E': 'findBTRootIndex'} | |
decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08_decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08.jsonl.gz | sub_4EC05C | Help user generate meaningful names for variables and functions in the following code snippet. |
_QWORD *__fastcall sub_4EC05C(_QWORD *a1, __int64 a2, float a3)
{
__int64 v3; // rax
double v4; // xmm0_8
__int64 v5; // rdx
double v6; // xmm1_8
__int64 v7; // rax
double v8; // xmm0_8
__int64 v9; // rdx
float v10; // xmm0_4
while ( a1 )
{
v3 = a1[5];
if ( v3 < 0 )
{
v5 = a1[5] & 1LL | ((unsigned __int64)v3 >> 1);
v4 = (double)(int)v5 + (double)(int)v5;
}
else
{
v4 = (double)(int)v3;
}
v6 = 100.0 * v4;
v7 = *(_QWORD *)(a2 + 120);
if ( v7 < 0 )
{
v9 = *(_QWORD *)(a2 + 120) & 1LL | ((unsigned __int64)v7 >> 1);
v8 = (double)(int)v9 + (double)(int)v9;
}
else
{
v8 = (double)(int)v7;
}
v10 = v6 / v8;
if ( !*((_BYTE *)a1 + 201) && v10 >= a3 )
return a1;
a1 = (_QWORD *)rb_prev(a1);
}
return 0LL;
}
Q:[a1,a2,a3,sub_4EC05C,] | A:{'a1': 'nd', 'a2': 'hists', 'a3': 'min_pcnt', 'sub_4EC05C': 'hists__filter_prev_entries'} | |
decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08_decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08.jsonl.gz | sub_4FAE59 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4FAE59(__int64 a1, __int64 a2, __int64 a3, char **a4)
{
__int64 v4; // rdx
__int64 v5; // rcx
__int64 v6; // r8
__int64 v7; // r9
__int64 v9; // r8
__int64 v10; // r9
char *s1; // [rsp+20h] [rbp-20h] BYREF
_QWORD *v14; // [rsp+28h] [rbp-18h]
unsigned int v15; // [rsp+30h] [rbp-10h]
int i; // [rsp+34h] [rbp-Ch]
_QWORD *v17; // [rsp+38h] [rbp-8h]
*(_DWORD *)(a3 + 8) = 11;
*(_QWORD *)(a3 + 16) = a2;
*a4 = 0LL;
v17 = (_QWORD *)(a3 + 24);
for ( i = 0; ; ++i )
{
if ( i >= *(_DWORD *)(a2 + 40) )
{
v15 = sub_4F7719((void **)&s1);
*a4 = s1;
return v15;
}
v14 = alloc_arg();
if ( !v14 )
break;
v15 = sub_4F8800(a1, (__int64)v14, &s1);
if ( i >= *(_DWORD *)(a2 + 40) - 1 )
{
if ( v15 != 5 || strcmp(s1, &asc_52CEC0[18]) )
{
warning(
(__int64)"Error: function '%s()' only expects %d arguments but event %s has more",
*(_QWORD *)(a2 + 16),
*(unsigned int *)(a2 + 40),
*(_QWORD *)(a1 + 8),
v9,
v10,
a4,
a3);
goto LABEL_16;
}
}
else if ( v15 != 5 || strcmp(s1, ",") )
{
warning(
(__int64)"Error: function '%s()' expects %d arguments but event %s only uses %d",
*(_QWORD *)(a2 + 16),
*(unsigned int *)(a2 + 40),
*(_QWORD *)(a1 + 8),
(unsigned int)(i + 1),
v10,
a4,
a3);
LABEL_16:
sub_4F6DEA((__int64)v14);
sub_4F76F7(s1);
return 0LL;
}
*v17 = v14;
v17 = v14;
sub_4F76F7(s1);
}
if ( dword_5631C4 )
warning((__int64)"%s: not enough memory!", (__int64)"process_func_handler", v4, v5, v6, v7);
return 0LL;
}
Q:[a3,a4,a1,a2,v4,v5,s1,v14,v15,v17,sub_4FAE59,sub_4F7719,sub_4F8800,sub_4F6DEA,sub_4F76F7,] | A:{'a3': 'arg', 'a4': 'tok', 'a1': 'event', 'a2': 'func', 'v4': 'arg', 'v5': 'tok', 's1': 'token', 'v14': 'farg', 'v15': 'type', 'v17': 'next_arg', 'sub_4FAE59': 'process_func_handler', 'sub_4F7719': 'read_token', 'sub_4F8800': 'process_arg', 'sub_4F6DEA': 'free_arg', 'sub_4F76F7': 'free_token'} | |
d641d4455ba968ec8cdc678803903e8adc4e0f690e4b42f19186ba657d295323_d641d4455ba968ec8cdc678803903e8adc4e0f690e4b42f19186ba657d295323.jsonl.gz | sub_405BB4 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_405BB4(__int64 a1, unsigned __int64 a2, _QWORD *a3, void *a4)
{
unsigned __int8 *v7; // [rsp+20h] [rbp-10h]
_DWORD *v8; // [rsp+28h] [rbp-8h]
v8 = off_43E240;
v7 = (unsigned __int8 *)off_43E248;
*((_BYTE *)off_43E240 + 4) = a1;
*v8 = 117834016;
sub_4038FE(a1, a2);
if ( a3 )
*a3 = v7[6];
if ( a4 && a2 >= v7[6] )
memcpy(a4, v7 + 7, v7[6]);
return *((unsigned __int16 *)v7 + 2);
}
Q:[a3,a4,a1,a2,v7,v8,sub_405BB4,sub_4038FE,] | A:{'a3': 'channel_map_len', 'a4': 'channel_map', 'a1': 'connection', 'a2': 'max_channel_map_size', 'v7': 'rsp_0', 'v8': 'cmd', 'sub_405BB4': 'sl_bt_connection_read_channel_map', 'sub_4038FE': 'sl_bt_host_handle_command'} | |
69576dcc9c0b8188ddef8cfe961ea18d51e245ccdd99a4a73fef54835fd70e69_69576dcc9c0b8188ddef8cfe961ea18d51e245ccdd99a4a73fef54835fd70e69.jsonl.gz | sub_411B0B | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_411B0B(__int64 a1, __int64 a2)
{
__int64 result; // rax
__int64 v3; // [rsp+18h] [rbp-8h]
v3 = sub_411977(a1);
result = v3 == 0;
if ( v3 )
result = sub_4029D9(v3, a2);
return result;
}
Q:[a1,a2,v3,sub_411B0B,sub_411977,sub_4029D9,] | A:{'a1': 'v', 'a2': 'x', 'v3': 'data', 'sub_411B0B': 'vector_string_push_back', 'sub_411977': 'vector_string_push_raw', 'sub_4029D9': 'string_init_set'} | |
d7102207976f081658421d2875def9da4891802ce3ef5c15713de9cb4412d94b_d7102207976f081658421d2875def9da4891802ce3ef5c15713de9cb4412d94b.jsonl.gz | sub_42330A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42330A(__int64 a1, __int64 a2, int a3, int a4)
{
_BYTE *v4; // rax
__int64 v8; // [rsp+28h] [rbp-28h]
int v9; // [rsp+30h] [rbp-20h]
_BOOL4 v10; // [rsp+34h] [rbp-1Ch]
_BYTE *s; // [rsp+38h] [rbp-18h]
__int64 v12; // [rsp+40h] [rbp-10h]
__int64 v13; // [rsp+48h] [rbp-8h]
v13 = 0LL;
v12 = *(_QWORD *)(a1 + 16LL * a4);
v10 = 0;
v9 = 1;
v8 = 0LL;
while ( v12 )
{
v9 = (*(__int64 (__fastcall **)(_QWORD, __int64, __int64))(a1 + 16LL * a4 + 8))(*(_QWORD *)(v12 + 24), a2, 1LL);
v10 = v9 > 0;
if ( !v9 )
break;
v13 = v12;
v12 = *(_QWORD *)(v12 + 8LL * (v9 > 0) + 8);
}
if ( v9 )
{
if ( (*(_BYTE *)(a1 + 44) & 1) != 0 )
v4 = (_BYTE *)sub_4060B1("Tree.c", 246, 40);
else
v4 = malloc(0x28uLL);
s = v4;
memset(v4, 0, 0x28uLL);
if ( v13 )
*(_QWORD *)(v13 + 8LL * v10 + 8) = s;
else
*(_QWORD *)(16LL * a4 + a1) = s;
*(_QWORD *)s = v13;
s[36] |= 1u;
if ( !a4 )
{
++*(_DWORD *)(a1 + 36);
*(_DWORD *)(a1 + 40) += a3;
}
}
else
{
if ( (*(_BYTE *)(a1 + 44) & 2) != 0 )
exit(-99);
s = (_BYTE *)v12;
v8 = *(_QWORD *)(v12 + 24);
if ( !a4 )
*(_DWORD *)(a1 + 40) += a3 - *(_DWORD *)(v12 + 32);
}
*((_QWORD *)s + 3) = a2;
*((_DWORD *)s + 8) = a3;
sub_423250(a1, (_QWORD ***)s, a4);
return v8;
}
Q:[a3,a4,a1,a2,v8,v9,v10,s,v12,v13,sub_42330A,sub_4060B1,sub_423250,] | A:{'a3': 'size', 'a4': 'index', 'a1': 'aTree', 'a2': 'content', 'v8': 'rc', 'v9': 'result', 'v10': 'left', 's': 'newel', 'v12': 'curnode', 'v13': 'curparent', 'sub_42330A': 'TreeAddByIndex', 'sub_4060B1': 'mymalloc', 'sub_423250': 'TreeBalanceAfterAdd'} | |
9c4eb45616cf68f899f481bb462a5f7bc8353e57fe3d33fddecbe769a3efc9eb_9c4eb45616cf68f899f481bb462a5f7bc8353e57fe3d33fddecbe769a3efc9eb.jsonl.gz | sub_404A7A | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_404A7A(const char *a1, const char *a2, char a3)
{
int result; // eax
if ( *a1 && *a2 )
return sprintf(
byte_410540,
"%s/%s/mon_groups/%s/mon_data/mon_L3_%02d/llc_occupancy",
"/sys/fs/resctrl",
a1,
a2,
(unsigned int)a3);
if ( !*a1 && *a2 )
return sprintf(
byte_410540,
"%s/mon_groups/%s/mon_data/mon_L3_%02d/llc_occupancy",
"/sys/fs/resctrl",
a2,
(unsigned int)a3);
if ( *a1 && !*a2 )
return sprintf(byte_410540, "%s/%s/mon_data/mon_L3_%02d/llc_occupancy", "/sys/fs/resctrl", a1, (unsigned int)a3);
result = *(unsigned __int8 *)a1;
if ( !(_BYTE)result )
{
result = *(unsigned __int8 *)a2;
if ( !(_BYTE)result )
result = sprintf(byte_410540, "%s/mon_data/mon_L3_%02d/llc_occupancy", "/sys/fs/resctrl", (unsigned int)a3);
}
return result;
}
Q:[a3,a1,a2,sub_404A7A,] | A:{'a3': 'sock_num', 'a1': 'ctrlgrp', 'a2': 'mongrp', 'sub_404A7A': 'set_cmt_path'} | |
06b05d82dec9870e8b7ae0397f41b35df72003047fadef58765b37b6dc5de195_06b05d82dec9870e8b7ae0397f41b35df72003047fadef58765b37b6dc5de195.jsonl.gz | sub_43C99C | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43C99C(__int64 a1, char *a2, int *a3, _QWORD *a4)
{
__int64 v4; // r8
__int64 v5; // r9
__int64 result; // rax
__int64 v7; // r8
__int64 v8; // r9
__int64 v9; // r8
__int64 v10; // r9
__int64 v11; // r8
__int64 v12; // r9
int v15; // [rsp+2Ch] [rbp-14h]
int v16; // [rsp+30h] [rbp-10h]
unsigned int v17; // [rsp+34h] [rbp-Ch]
unsigned int v18; // [rsp+34h] [rbp-Ch]
void *v19; // [rsp+38h] [rbp-8h]
v16 = sub_43C60D(a2);
if ( v16 >= 0 )
{
v15 = open(a2, 2);
if ( v15 >= 0 )
{
if ( v16 )
{
v19 = sub_43C281;
v17 = sub_43C717(v15);
}
else
{
v19 = sub_43C410;
v17 = sub_43C7EA(v15);
}
if ( v17 )
{
log_error("%s(%d) Failed to initialize sg device %s\n", (__int64)"bs_sg_open", 459LL, (__int64)a2, v9, v10);
result = v17;
}
else
{
v18 = tgt_event_add(v15, 1u, (__int64)v19, 0LL);
if ( v18 )
{
log_error("%s(%d) Failed to add sg device event %s\n", (__int64)"bs_sg_open", 465LL, (__int64)a2, v11, v12);
result = v18;
}
else
{
*a3 = v15;
*a4 = 0LL;
result = 0LL;
}
}
}
else
{
log_error("%s(%d) Could not open %s, %m\n", (__int64)"bs_sg_open", 447LL, (__int64)a2, v7, v8);
result = (unsigned int)v15;
}
}
else
{
log_error("%s(%d) Not recognized %s as an SG device\n", (__int64)"bs_sg_open", 441LL, (__int64)a2, v4, v5);
result = 4294967274LL;
}
return result;
}
Q:[a3,a4,a2,a1,v15,v16,v17,v19,sub_43C99C,sub_43C60D,sub_43C281,sub_43C717,sub_43C410,sub_43C7EA,] | A:{'a3': 'fd', 'a4': 'size', 'a2': 'path', 'a1': 'lu', 'v15': 'sg_fd', 'v16': 'bsg', 'v17': 'erra', 'v19': 'cmd_complete', 'sub_43C99C': 'bs_sg_open', 'sub_43C60D': 'chk_sg_device', 'sub_43C281': 'bs_bsg_cmd_complete', 'sub_43C717': 'init_bsg_device', 'sub_43C410': 'bs_sg_cmd_complete', 'sub_43C7EA': 'init_sg_device'} | |
ae353ff1d6b132e8bc266655cc0acee2a7cfbd29790838b22e9e2a3256b7a8f8_ae353ff1d6b132e8bc266655cc0acee2a7cfbd29790838b22e9e2a3256b7a8f8.jsonl.gz | sub_47A145 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_47A145(__int64 *a1, __int64 a2)
{
__int64 result; // rax
struct __jmp_buf_tag s; // [rsp+10h] [rbp-7F0h] BYREF
__int64 v4; // [rsp+D8h] [rbp-728h]
int v5; // [rsp+E4h] [rbp-71Ch]
memset(&s, 0, 0x7F0uLL);
v4 = a2;
v5 = 0;
if ( _setjmp(&s) )
{
sub_47A6C2(&s);
result = 0xFFFFFFFFLL;
}
else
{
sub_47AA5B(&s, a1);
sub_47A044((__int64)&s, a1, 0);
sub_47A044((__int64)&s, a1, 1);
sub_47A43B(&s, a1);
sub_479F7A(a1);
sub_47A6C2(&s);
result = 0LL;
}
return result;
}
Q:[a1,a2,s,sub_47A145,sub_47A6C2,sub_47AA5B,sub_47A044,sub_47A43B,sub_479F7A,] | A:{'a1': 'ic', 'a2': 'errbuf', 's': 'opt_state', 'sub_47A145': 'bpf_optimize', 'sub_47A6C2': 'opt_cleanup', 'sub_47AA5B': 'opt_init', 'sub_47A044': 'opt_loop', 'sub_47A43B': 'intern_blocks', 'sub_479F7A': 'opt_root'} | |
50496bcee0d9ed460c36b6546463491f865f54f1da8824b4015293aa0dd94643_50496bcee0d9ed460c36b6546463491f865f54f1da8824b4015293aa0dd94643.jsonl.gz | sub_404530 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_404530(__int64 a1, int *a2)
{
int v3; // [rsp+1Ch] [rbp-4h]
v3 = 0;
sub_4042CF(a1, (__int64)&unk_40AAA0, a2[2], 4, 0);
while ( a2[v3 + 10] != -1 )
{
sub_4042CF(a1, (__int64)&unk_40AAA0, a2[v3 + 10], 24, 0);
sub_4042CF(a1, (__int64)&unk_40AAA0, a2[v3 + 10], 4, 1);
sub_4042CF(a1, (__int64)&unk_40AAA0, a2[v3++ + 10], 0, 1);
}
sub_4042CF(a1, (__int64)&unk_40AAA0, *a2, 24, 0);
sub_4042CF(a1, (__int64)&unk_40AAA0, *a2, 4, 1);
sub_4042CF(a1, (__int64)&unk_40AAA0, a2[1], 24, 0);
sub_4042CF(a1, (__int64)&unk_40AAA0, a2[1], 4, 1);
if ( a2[4] >= 0 )
{
sub_4042CF(a1, (__int64)&unk_40AAA0, a2[4], 24, 0);
sub_4042CF(a1, (__int64)&unk_40AAA0, a2[4], 4, 1);
sub_4042CF(a1, (__int64)&unk_40AAA0, a2[4], 0, 1);
}
sub_404399(a1, a2, 33);
sub_404399(a1, a2, 156);
sub_404399(a1, a2, 32);
return sub_404399(a1, a2, 8);
}
Q:[a1,a2,sub_404530,sub_4042CF,sub_404399,] | A:{'a1': 'dev', 'a2': 'hw_info', 'sub_404530': 'st7585_configure_panel', 'sub_4042CF': 'gpio_write_bit', 'sub_404399': 'st7585_spi_send_word'} | |
5e15d4b6a1e8206d634e8925fc9a339ec9cebc516c1ee0c90f704569d0283c08_5e15d4b6a1e8206d634e8925fc9a339ec9cebc516c1ee0c90f704569d0283c08.jsonl.gz | main | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
sub_401162(a1, a2, a3);
return 0LL;
}
Q:[a2,a3,a1,sub_401162,] | A:{'a2': 'argv', 'a3': 'envp', 'a1': 'argc', 'sub_401162': 'function_to_profile'} | |
1c5460c06114eba18295c931be056dec04bc7d84e64fe0f7be9f3a01688aae40_1c5460c06114eba18295c931be056dec04bc7d84e64fe0f7be9f3a01688aae40.jsonl.gz | sub_4911E5 | Help user generate meaningful names for variables and functions in the following code snippet. |
_DWORD *__fastcall sub_4911E5(__int64 a1, unsigned __int64 a2)
{
__int64 v3; // [rsp+18h] [rbp-18h] BYREF
_DWORD *v4; // [rsp+20h] [rbp-10h]
unsigned __int64 v5; // [rsp+28h] [rbp-8h]
v5 = sub_4910AA(a2);
v3 = 0LL;
v4 = (_DWORD *)sub_490F77(v5 << 16, (__int64)&v3);
if ( !v4 )
return 0LL;
sub_49116C(v4, v5, a2, v3);
if ( v5 > a2 )
{
if ( *(_QWORD *)(a1 + 2296) )
{
sub_490FD8(*(char **)(a1 + 2288), *(char **)(a1 + 2280), *(_QWORD *)(a1 + 2296));
sub_491CA9(a1, *(_QWORD *)(a1 + 2280));
}
sub_491128((_QWORD *)a1, (__int64)v4, (__int64)&v4[0x4000 * a2], v5 - a2);
}
return v4;
}
Q:[a1,a2,v3,v4,v5,sub_4911E5,sub_4910AA,sub_490F77,sub_49116C,sub_490FD8,sub_491CA9,sub_491128,] | A:{'a1': 'heap', 'a2': 'span_count', 'v3': 'align_offset', 'v4': 'span', 'v5': 'aligned_span_count', 'sub_4911E5': '_memory_map_aligned_span_count', 'sub_4910AA': '_memory_map_align_span_count', 'sub_490F77': '_memory_map', 'sub_49116C': '_memory_span_initialize', 'sub_490FD8': '_memory_span_mark_as_subspan_unless_master', 'sub_491CA9': '_memory_heap_cache_insert', 'sub_491128': '_memory_heap_set_reserved_spans'} | |
7dc7fd77c702ac66e020038977e4c5b256bb046b8e96253a37fa2f33ba09f7ff_7dc7fd77c702ac66e020038977e4c5b256bb046b8e96253a37fa2f33ba09f7ff.jsonl.gz | sub_411962 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_411962()
{
unsigned int v0; // ebx
sub_404A6C();
return v0;
}
Q:[sub_411962,sub_404A6C,] | A:{'sub_411962': 'ConstExpression', 'sub_404A6C': 'VarExpression'} | |
0bdd3e3355b55ed2816435efa21042f8306da2b2ea7b587febce5c0891e6891f_0bdd3e3355b55ed2816435efa21042f8306da2b2ea7b587febce5c0891e6891f.jsonl.gz | sub_4050E5 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4050E5(__int64 a1)
{
if ( *(_DWORD *)a1 != 1 )
__assert_fail("iv->iv_class == IR_VC_FUNCTION", "src/vmir_value.c", 0x12Bu, "value_function_addr");
return *(unsigned int *)(*(_QWORD *)(a1 + 48) + 44LL);
}
Q:[a1,sub_4050E5,] | A:{'a1': 'iv', 'sub_4050E5': 'value_function_addr'} | |
2639067df99b88f744e9cfab2902ccbfab4419c98de3b7b00cb98a17fe950843_2639067df99b88f744e9cfab2902ccbfab4419c98de3b7b00cb98a17fe950843.jsonl.gz | sub_40167E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_40167E()
{
char *v1; // [rsp+0h] [rbp-10h]
__int64 v2; // [rsp+8h] [rbp-8h]
v2 = 0LL;
v1 = sub_40166E();
if ( v1 )
v2 = sub_401633(v1);
return v2;
}
Q:[v1,v2,sub_40167E,sub_40166E,sub_401633,] | A:{'v1': 'encname', 'v2': 'enc', 'sub_40167E': 'nkf_locale_encoding', 'sub_40166E': 'nkf_locale_charmap', 'sub_401633': 'nkf_enc_find'} | |
71be51c2f85ea3ab34e654fb6cf4736d90e26a6c9bf9212e26d17216cc13a637_71be51c2f85ea3ab34e654fb6cf4736d90e26a6c9bf9212e26d17216cc13a637.jsonl.gz | sub_416A98 | Help user generate meaningful names for variables and functions in the following code snippet. |
char *__fastcall sub_416A98(char *a1, int a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6)
{
__int64 v7; // r9
unsigned int v8; // eax
__int64 v9; // rdx
char *v10; // [rsp+8h] [rbp-18h]
char *s; // [rsp+18h] [rbp-8h]
if ( !dword_4503B8 )
return sub_40F94E(a1, 63);
if ( a2 > 2047 )
{
s = sub_40EFFE(0LL, "?");
if ( dword_4503B8 > 1 && a2 <= 0xFFFF )
{
v8 = a2 >> 12;
LOBYTE(v8) = (a2 >> 12) | 0xE0;
s = sub_40F88D(s, "%c%c%c", v8, (a2 >> 6) & 0x3F | 0x80u, a2 & 0x3F | 0x80u, v7);
}
}
else
{
s = sub_40F88D(0LL, "%c%c", ((a2 >> 6) & 0x1Fu) + 192, (a2 & 0x3Fu) + 128, a5, a6);
}
if ( s )
v9 = strlen(s);
else
v9 = 0LL;
v10 = sub_40EF58(a1, s, v9);
sub_40EE25(s);
return v10;
}
Q:[a1,a2,v10,s,sub_416A98,sub_40F94E,sub_40EFFE,sub_40F88D,sub_40EF58,sub_40EE25,] | A:{'a1': 'RetStr', 'a2': 'Code', 'v10': 'RetStra', 's': 'Tempstr', 'sub_416A98': 'UnicodeStr', 'sub_40F94E': 'AddCharToStr', 'sub_40EFFE': 'CopyStr', 'sub_40F88D': 'FormatStr', 'sub_40EF58': 'CatStrLen', 'sub_40EE25': 'Destroy'} | |
ec13b450451a1a6f85448efbf548f41f93dcb45bdcb731e55b9e95be4a5b58ce_ec13b450451a1a6f85448efbf548f41f93dcb45bdcb731e55b9e95be4a5b58ce.jsonl.gz | sub_401B0A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_401B0A(__int64 a1, __int64 a2, __int64 a3)
{
__int64 result; // rax
*(_DWORD *)a3 = *(_DWORD *)(a2 + 52);
*(_DWORD *)(a3 + 16) = 0;
*(_QWORD *)(a3 + 24) = 0LL;
*(_QWORD *)(a3 + 8) = *(_QWORD *)a2;
result = *(unsigned __int16 *)(a2 + 58);
if ( (_WORD)result )
{
if ( *(_WORD *)(a2 + 58) == 1 )
__assert_fail("s->type != SOCKET_TYPE_RESERVE", "socket_server.c", 0x15Bu, "force_close");
sub_401AA6(a1, a2 + 8);
sub_401AA6(a1, a2 + 24);
if ( *(_WORD *)(a2 + 58) != 7 && *(_WORD *)(a2 + 58) != 2 )
sub_401414(*(_DWORD *)(a1 + 12), *(_DWORD *)(a2 + 48));
if ( *(_WORD *)(a2 + 58) != 8 )
close(*(_DWORD *)(a2 + 48));
result = a2;
*(_WORD *)(a2 + 58) = 0;
}
return result;
}
Q:[a3,a1,a2,sub_401B0A,sub_401AA6,sub_401414,] | A:{'a3': 'result', 'a1': 'ss_0', 'a2': 's', 'sub_401B0A': 'force_close', 'sub_401AA6': 'free_wb_list', 'sub_401414': 'sp_del'} | |
7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2_7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2.jsonl.gz | sub_4188F0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4188F0(__int64 a1)
{
return sub_41888B(a1);
}
Q:[a1,sub_4188F0,sub_41888B,] | A:{'a1': 'p', 'sub_4188F0': 'wc_ecc_del_point_h', 'sub_41888B': 'wc_ecc_del_point_ex'} | |
9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0_9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0.jsonl.gz | sub_45583E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_45583E(__int64 a1)
{
return a1;
}
Q:[sub_45583E,] | A:{'sub_45583E': 'CommandLine'} | |
3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33_3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33.jsonl.gz | sub_432341 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_432341(__int64 a1)
{
return *(_QWORD *)(a1 + 128);
}
Q:[a1,sub_432341,] | A:{'a1': 'type', 'sub_432341': 'unfoul'} | |
dbef1d827ccd2a42e8941d50152f102df28295732bfb69acb1ef6314d264873b_dbef1d827ccd2a42e8941d50152f102df28295732bfb69acb1ef6314d264873b.jsonl.gz | sub_40446B | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_40446B(__int64 a1, __int64 a2, __int64 a3, int a4, int a5, int a6)
{
int v6; // edx
int v7; // ecx
int v8; // er8
int v9; // er9
unsigned __int64 result; // rax
int v11; // edx
int v12; // ecx
int v13; // er8
int v14; // er9
int v15; // ecx
int v16; // er8
int v17; // er9
int v18; // edx
int v19; // ecx
int v20; // er8
int v21; // er9
int v22; // ecx
int v23; // er8
int v24; // er9
int v25; // ecx
int v26; // er8
int v27; // er9
const char *s; // [rsp+8h] [rbp-28h]
struct group *v29; // [rsp+10h] [rbp-20h]
struct passwd *v30; // [rsp+18h] [rbp-18h]
char *v31; // [rsp+20h] [rbp-10h]
const char *v32; // [rsp+20h] [rbp-10h]
const char **i; // [rsp+28h] [rbp-8h]
sub_40D598(1, (unsigned int)"handle_user_option(spec = %s)", a1, a4, a5, a6);
result = (unsigned int)dword_4355BC;
if ( !dword_4355BC )
{
if ( dword_4355B8 )
sub_417936(
(unsigned int)"Misplaced option: --user=%s in config file (Must be on the command line)",
a1,
v6,
v7,
v8,
v9);
if ( getuid() || geteuid() )
sub_417936(
(unsigned int)"Invalid option: --user (Only works for root)",
(unsigned int)"handle_user_option(spec = %s)",
v11,
v12,
v13,
v14);
s = sub_4038D2(a1);
sub_40D598(2, (unsigned int)"user = %s", (_DWORD)s, v15, v16, v17);
v31 = strchr(s, 58);
if ( v31 || (v31 = strchr(s, 46)) != 0LL )
{
if ( v31 > s )
{
s2 = byte_431470;
snprintf(byte_431470, 0x2000uLL, "%*.*s", (_DWORD)v31 - (_DWORD)s, (_DWORD)v31 - (_DWORD)s, s);
}
v32 = v31 + 1;
if ( *v32 )
{
qword_431468 = byte_433470;
snprintf(byte_433470, 0x2000uLL, "%s", v32);
}
}
else
{
s2 = byte_431470;
snprintf(byte_431470, 0x2000uLL, "%s", s);
}
dword_43548C = qword_431468 == 0LL;
if ( !s2 )
sub_417936((unsigned int)"Invalid --user argument: '%s' (No user name)", (_DWORD)s, v18, v19, v20, v21);
v30 = getpwnam(s2);
if ( !v30 )
sub_417936((unsigned int)"Invalid --user argument: '%s' (Unknown user %s)", (_DWORD)s, (_DWORD)s2, v22, v23, v24);
uid = v30->pw_uid;
gid = v30->pw_gid;
result = (unsigned __int64)qword_431468;
if ( qword_431468 )
{
v29 = getgrnam(qword_431468);
if ( !v29 )
sub_417936(
(unsigned int)"Invalid --user argument: '%s' (Unknown group %s)",
(_DWORD)s,
(_DWORD)qword_431468,
v25,
v26,
v27);
if ( v29->gr_gid != v30->pw_gid )
{
for ( i = (const char **)v29->gr_mem; *i && strcmp(*i, s2); ++i )
;
if ( !*i )
sub_417936(
(unsigned int)"Invalid --user argument: '%s' (User %s is not in group %s)",
(_DWORD)s,
(_DWORD)s2,
(_DWORD)qword_431468,
v26,
v27);
}
result = v29->gr_gid;
gid = v29->gr_gid;
}
}
return result;
}
Q:[a1,s,v29,v30,v32,i,sub_40446B,sub_40D598,sub_417936,sub_4038D2,] | A:{'a1': 'spec', 's': 'speca', 'v29': 'grp', 'v30': 'pwd', 'v32': 'posa', 'i': 'member', 'sub_40446B': 'handle_user_option', 'sub_40D598': 'debugf', 'sub_417936': 'prog_usage_msg', 'sub_4038D2': 'expand'} | |
251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651_251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651.jsonl.gz | sub_41FBB5 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41FBB5(__int64 a1, __int64 a2, unsigned int a3)
{
__int64 v3; // rbx
if ( a3 )
{
if ( a3 == 1 )
{
v3 = sub_4243CC(a2);
*(_QWORD *)sub_42441A(a1) = v3;
}
else
{
sub_424434(a1, a2, a3);
}
}
else
{
*(_QWORD *)sub_42C880(a1) = &off_42F250;
}
return 0LL;
}
Q:[a3,a1,a2,sub_41FBB5,sub_4243CC,sub_42441A,sub_424434,sub_42C880,] | A:{'a3': '__op', 'a1': '__dest', 'a2': '__source', 'sub_41FBB5': '_M_manager', 'sub_4243CC': '_M_get_pointer', 'sub_42441A': 'lambda', 'sub_424434': '_M_manager', 'sub_42C880': '_M_access'} | |
c518bc3ec7ac1de5c9ce166122c3a25fdcee604b732539449a3c567eb8a11f73_c518bc3ec7ac1de5c9ce166122c3a25fdcee604b732539449a3c567eb8a11f73.jsonl.gz | sub_404B24 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_404B24(__int64 a1, unsigned __int8 *a2, int a3)
{
int v4; // eax
unsigned int v5; // eax
void *v7[2]; // [rsp+20h] [rbp-70h] BYREF
void *v8; // [rsp+30h] [rbp-60h] BYREF
unsigned int v9; // [rsp+38h] [rbp-58h]
__int64 v10; // [rsp+48h] [rbp-48h]
unsigned int v11; // [rsp+54h] [rbp-3Ch]
char *s; // [rsp+58h] [rbp-38h]
unsigned int v13; // [rsp+64h] [rbp-2Ch]
__int64 v14; // [rsp+68h] [rbp-28h]
int v15; // [rsp+70h] [rbp-20h]
int v16; // [rsp+74h] [rbp-1Ch]
int v17; // [rsp+78h] [rbp-18h]
int v18; // [rsp+7Ch] [rbp-14h]
unsigned int v19; // [rsp+80h] [rbp-10h]
unsigned int v20; // [rsp+84h] [rbp-Ch]
unsigned int v21; // [rsp+88h] [rbp-8h]
char v22; // [rsp+8Fh] [rbp-1h]
if ( (unsigned int)dword_42F310 <= 1 )
return 0LL;
sub_402C50(&v8);
sub_402C50(v7);
v15 = *(_DWORD *)(a1 + 48);
v14 = *(_QWORD *)(a1 + 24);
v13 = *(_DWORD *)(a1 + 32);
v19 = 0;
v17 = 0;
LABEL_4:
while ( 1 )
{
*(_QWORD *)(a1 + 24) = sub_404A33(v7, v17, v8, v19);
sub_405A98(a1);
v17 = 1;
v16 = 0;
v20 = *(_DWORD *)(a1 + 48);
v21 = *(_DWORD *)(a1 + 32);
v18 = sub_4041B0(*(_DWORD *)a1, a2, a3, a1);
if ( v18 <= 0 )
break;
switch ( *a2 )
{
case 0x7Fu:
case 8u:
if ( v9 )
{
v4 = --v9;
if ( v19 <= v9 )
v4 = v19;
v19 = v4;
}
break;
case 0x12u:
if ( v20 )
{
--v20;
}
else if ( v21 + 1 < dword_42F310 )
{
++v21;
v20 = strlen((&::s)[dword_42F310 - v21 - 1]);
}
break;
case 7u:
sub_404899(a1, v13);
*(_DWORD *)(a1 + 48) = v15;
v18 = 0;
goto LABEL_33;
default:
if ( sub_401FF8((char)*a2) )
goto LABEL_33;
sub_402E42((__int64)&v8, a2, v18);
v16 = v18;
break;
}
v22 = 0;
while ( v21 < dword_42F310 )
{
s = (&::s)[dword_42F310 - v21 - 1];
v11 = strlen(s);
if ( v22 )
{
v22 = 0;
v20 = v11;
}
else
{
v5 = v9 + v20;
if ( v11 <= v9 + v20 )
v5 = v11;
v20 = v5;
}
v10 = sub_403ACD((__int64)s, v20, (__int64)v8, v9);
if ( v10 )
{
sub_404899(a1, v21);
*(_DWORD *)(a1 + 48) = v10 - (_DWORD)s;
v17 = 0;
if ( v16 )
{
v19 += v16;
v16 = 0;
}
goto LABEL_4;
}
v22 = 1;
++v21;
}
}
LABEL_33:
*(_QWORD *)(a1 + 24) = v14;
sub_405A98(a1);
sub_402F60(v7);
sub_402F60(&v8);
sub_405A98(a1);
return (unsigned int)v18;
}
Q:[a3,a1,a2,v7,v8,v10,s,v13,v14,v15,v16,v17,v18,v19,v22,sub_404B24,sub_402C50,sub_404A33,sub_405A98,sub_4041B0,sub_404899,sub_401FF8,sub_402E42,sub_403ACD,sub_402F60,] | A:{'a3': 'size', 'a1': 'l', 'a2': 'seq', 'v7': 'prompt', 'v8': 'ab', 'v10': 'q', 's': 'p', 'v13': 'oldindex', 'v14': 'oldprompt', 'v15': 'oldpos', 'v16': 'added', 'v17': 'fail', 'v18': 'rc', 'v19': 'matlen', 'v22': 'isstale', 'sub_404B24': 'bestlineSearch', 'sub_402C50': 'abInit', 'sub_404A33': 'bestlineMakeSearchPrompt', 'sub_405A98': 'bestlineRefreshLine', 'sub_4041B0': 'bestlineRead', 'sub_404899': 'bestlineEditHistoryGoto', 'sub_401FF8': 'IsControl', 'sub_402E42': 'abAppend', 'sub_403ACD': 'FindSubstringReverse', 'sub_402F60': 'abFree'} | |
7fc81bc5e05805462160f0f7e72ba32357f81d09a102ced059628d2f6c88ce53_7fc81bc5e05805462160f0f7e72ba32357f81d09a102ced059628d2f6c88ce53.jsonl.gz | sub_4165AE | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4165AE(__int64 a1)
{
return sub_4165CD(a1, 32LL);
}
Q:[a1,sub_4165AE,sub_4165CD,] | A:{'a1': 'mem', 'sub_4165AE': 'object_make_map', 'sub_4165CD': 'object_make_map_with_capacity'} | |
933450c0b65e20af18742d5f953f0d427d5999f56d83754137d1d819a8046bb8_933450c0b65e20af18742d5f953f0d427d5999f56d83754137d1d819a8046bb8.jsonl.gz | sub_404795 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_404795(unsigned int a1)
{
__int64 result; // rax
const char *v2; // rax
char s[9]; // [rsp+17h] [rbp-9h] BYREF
if ( unk_40FBC4 )
fprintf(stderr, "blink1_openById: %d \n", a1);
if ( a1 <= 0x20 )
{
v2 = (const char *)sub_404BBB(a1);
result = (__int64)sub_40448C(v2);
}
else
{
snprintf(s, 9uLL, "%x", a1);
result = sub_40458A(s);
}
return result;
}
Q:[s,sub_404795,sub_404BBB,sub_40448C,sub_40458A,] | A:{'s': 'serialstr', 'sub_404795': 'blink1_openById', 'sub_404BBB': 'blink1_getCachedPath', 'sub_40448C': 'blink1_openByPath', 'sub_40458A': 'blink1_openBySerial'} | |
bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b_bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b.jsonl.gz | sub_455686 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_455686(__int64 a1, unsigned __int64 a2)
{
if ( a2 > sub_4571E8(a1) )
std::__throw_bad_alloc();
return operator new(368 * a2);
}
Q:[sub_455686,sub_4571E8,] | A:{'sub_455686': 'allocate', 'sub_4571E8': '_M_max_size'} | |
e53d5295be6e634f84a15d2ee5468213cc33bcf6cde051baf5f95b2c12b222ac_e53d5295be6e634f84a15d2ee5468213cc33bcf6cde051baf5f95b2c12b222ac.jsonl.gz | sub_41EC80 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41EC80(__int64 a1)
{
return (**(__int64 (***)(void))(a1 + 8))();
}
Q:[sub_41EC80,] | A:{'sub_41EC80': 'archive_read_close'} | |
9238d686ece7ae9f0d81af00cc27fe44cd971455482c1d596e5cbe1c2530c5ba_9238d686ece7ae9f0d81af00cc27fe44cd971455482c1d596e5cbe1c2530c5ba.jsonl.gz | sub_404A57 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 __fastcall sub_404A57(__int64 a1)
{
return *(_DWORD *)(a1 + 20) && *(_DWORD *)(a1 + 16) >= *(_DWORD *)(*(_QWORD *)(a1 + 8) + 12LL);
}
Q:[a1,sub_404A57,] | A:{'a1': 'desc', 'sub_404A57': 'js_buf_eof'} | |
a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4_a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4.jsonl.gz | sub_452F4C | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_452F4C(__int64 a1)
{
return a1;
}
Q:[sub_452F4C,] | A:{'sub_452F4C': 'move'} | |
ae353ff1d6b132e8bc266655cc0acee2a7cfbd29790838b22e9e2a3256b7a8f8_ae353ff1d6b132e8bc266655cc0acee2a7cfbd29790838b22e9e2a3256b7a8f8.jsonl.gz | sub_448320 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_448320(void *src, int a2, _BYTE *a3)
{
size_t v4; // rdx
char v5; // r13
__int64 v6; // rax
__int64 v7; // rcx
size_t v8; // rdx
__int64 v9; // rcx
unsigned __int64 v10; // rsi
__int64 v11; // rdx
unsigned __int64 v12; // rdx
char v13; // di
char v14; // di
char v15; // di
char v16; // di
char v17; // di
char v18; // di
char v19; // al
unsigned __int64 result; // rax
int vars0[38]; // [rsp+0h] [rbp+0h] BYREF
unsigned __int64 vars98; // [rsp+98h] [rbp+98h]
v4 = a2;
vars98 = __readfsqword(0x28u);
vars0[2] = 1732584193;
vars0[3] = -271733879;
vars0[4] = -1732584194;
vars0[5] = 271733878;
vars0[0] = a2 & 0x1FFFFFFF;
v5 = a2;
vars0[1] = (unsigned __int64)a2 >> 29;
if ( (unsigned __int64)a2 > 0x3F )
{
src = sub_447070(vars0, src, a2 & 0xFFFFFFFFFFFFFFC0LL);
v5 = vars0[0];
v4 = a2 & 0x3F;
}
memcpy(&vars0[6], src, v4);
v6 = v5 & 0x3F;
v7 = v6 + 1;
*((_BYTE *)&vars0[6] + v6) = 0x80;
if ( (unsigned __int64)(63 - v6) <= 7 )
{
memset((char *)&vars0[6] + v6 + 1, 0, 63 - v6);
sub_447070(vars0, &vars0[6], 64LL);
v8 = 56LL;
v7 = 0LL;
}
else
{
v8 = 55 - v6;
}
memset((char *)&vars0[6] + v7, 0, v8);
vars0[0] *= 8;
vars0[20] = vars0[0];
vars0[21] = vars0[1];
sub_447070(vars0, &vars0[6], 64LL);
v9 = LOBYTE(vars0[2]);
BYTE1(v9) = BYTE1(vars0[2]);
v10 = ((unsigned __int64)HIBYTE(vars0[3]) << 56) | (((unsigned __int64)BYTE2(vars0[3]) << 48) | (((unsigned __int64)BYTE1(vars0[3]) << 40) | (((unsigned __int64)LOBYTE(vars0[3]) << 32) | (((unsigned __int64)HIBYTE(vars0[2]) << 24) | (((unsigned __int64)BYTE2(vars0[2]) << 16) | v9 & 0xFFFFFFFFFF00FFFFLL) & 0xFFFFFFFF00FFFFFFLL) & 0xFFFFFF00FFFFFFFFLL) & 0xFFFF00FFFFFFFFFFLL) & 0xFF00FFFFFFFFFFFFLL) & 0xFFFFFFFFFFFFFFLL;
v11 = LOBYTE(vars0[4]);
BYTE1(v11) = BYTE1(vars0[4]);
v12 = ((unsigned __int64)HIBYTE(vars0[5]) << 56) | (((unsigned __int64)BYTE2(vars0[5]) << 48) | (((unsigned __int64)BYTE1(vars0[5]) << 40) | (((unsigned __int64)LOBYTE(vars0[5]) << 32) | (((unsigned __int64)HIBYTE(vars0[4]) << 24) | (((unsigned __int64)BYTE2(vars0[4]) << 16) | v11 & 0xFFFFFFFFFF00FFFFLL) & 0xFFFFFFFF00FFFFFFLL) & 0xFFFFFF00FFFFFFFFLL) & 0xFFFF00FFFFFFFFFFLL) & 0xFF00FFFFFFFFFFFFLL) & 0xFFFFFFFFFFFFFFLL;
memset(vars0, 0, sizeof(vars0));
*a3 = a0123456789abcd_0[(unsigned __int8)v10 >> 4];
a3[1] = a0123456789abcd_0[v10 & 0xF];
v13 = a0123456789abcd_0[BYTE1(v10) >> 4];
a3[3] = a0123456789abcd_0[(v10 >> 8) & 0xF];
a3[2] = v13;
v14 = a0123456789abcd_0[BYTE2(v10) >> 4];
a3[5] = a0123456789abcd_0[(v10 >> 16) & 0xF];
a3[4] = v14;
v15 = a0123456789abcd_0[BYTE3(v10) >> 4];
a3[7] = a0123456789abcd_0[(v10 >> 24) & 0xF];
a3[6] = v15;
v16 = a0123456789abcd_0[BYTE4(v10) >> 4];
a3[9] = a0123456789abcd_0[BYTE4(v10) & 0xF];
a3[8] = v16;
v17 = a0123456789abcd_0[BYTE5(v10) >> 4];
a3[11] = a0123456789abcd_0[(v10 >> 40) & 0xF];
a3[10] = v17;
v18 = a0123456789abcd_0[BYTE6(v10) >> 4];
a3[13] = a0123456789abcd_0[HIWORD(v10) & 0xF];
LOBYTE(v9) = a0123456789abcd_0[v10 >> 60];
a3[12] = v18;
a3[14] = v9;
a3[15] = a0123456789abcd_0[HIBYTE(v10) & 0xF];
a3[16] = a0123456789abcd_0[(unsigned __int8)v12 >> 4];
a3[17] = a0123456789abcd_0[v12 & 0xF];
LOBYTE(v10) = a0123456789abcd_0[BYTE1(v12) >> 4];
a3[19] = a0123456789abcd_0[(v12 >> 8) & 0xF];
a3[18] = v10;
LOBYTE(v10) = a0123456789abcd_0[BYTE2(v12) >> 4];
a3[21] = a0123456789abcd_0[(v12 >> 16) & 0xF];
a3[20] = v10;
LOBYTE(v10) = a0123456789abcd_0[BYTE3(v12) >> 4];
a3[23] = a0123456789abcd_0[(v12 >> 24) & 0xF];
a3[22] = v10;
LOBYTE(v10) = a0123456789abcd_0[BYTE4(v12) >> 4];
a3[25] = a0123456789abcd_0[BYTE4(v12) & 0xF];
a3[24] = v10;
LOBYTE(v10) = a0123456789abcd_0[BYTE5(v12) >> 4];
a3[27] = a0123456789abcd_0[(v12 >> 40) & 0xF];
a3[26] = v10;
LOBYTE(v10) = a0123456789abcd_0[BYTE6(v12) >> 4];
a3[29] = a0123456789abcd_0[HIWORD(v12) & 0xF];
LOBYTE(v9) = a0123456789abcd_0[v12 >> 60];
v19 = a0123456789abcd_0[HIBYTE(v12) & 0xF];
a3[28] = v10;
a3[30] = v9;
a3[31] = v19;
result = __readfsqword(0x28u) ^ vars98;
a3[32] = 0;
return result;
}
Q:[vars0,vars98,sub_448320,sub_447070,] | A:{'vars0': 'anonymous12', 'vars98': 'anonymous11', 'sub_448320': 'strMD5_to_binary_3', 'sub_447070': 'body_3'} | |
ce91f793890cbebbef6dfac9d2cc87ce4fef3c0b414abf89c9f12a849db5dc8b_ce91f793890cbebbef6dfac9d2cc87ce4fef3c0b414abf89c9f12a849db5dc8b.jsonl.gz | sub_4035B8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4035B8(__int64 a1)
{
*(_DWORD *)(a1 + 32) = *(_DWORD *)(a1 + 32) + (__int16)sub_402121(a1) - 3;
return 0LL;
}
Q:[a1,sub_4035B8,sub_402121,] | A:{'a1': 'frame', 'sub_4035B8': 'OPCODE_GOTO', 'sub_402121': 'read2Bytes'} | |
258f9f7c6ece4aef809773d5d7825f681cb0968e55404bd9821bae7f8c43cfb1_258f9f7c6ece4aef809773d5d7825f681cb0968e55404bd9821bae7f8c43cfb1.jsonl.gz | sub_405676 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_405676(_QWORD *a1)
{
return 0xAAAAAAAAAAAAAAABLL * ((__int64)(a1[1] - *a1) >> 3);
}
Q:[sub_405676,] | A:{'sub_405676': 'size'} | |
decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08_decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08.jsonl.gz | sub_43FA91 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43FA91(__int64 a1, const char *a2)
{
const char *v3; // rax
const char *v4; // rax
FILE *stream; // [rsp+10h] [rbp-2020h]
char *s; // [rsp+18h] [rbp-2018h]
char *sa; // [rsp+18h] [rbp-2018h]
char *sb; // [rsp+18h] [rbp-2018h]
char v9[8200]; // [rsp+20h] [rbp-2010h] BYREF
unsigned __int64 v10; // [rsp+2028h] [rbp-8h]
v10 = __readfsqword(0x28u);
stream = fopen64(a2, "r");
if ( !stream )
return 0xFFFFFFFFLL;
while ( fgets(v9, 0x2000, stream) )
{
s = (char *)ltrim(v9);
if ( *s )
{
if ( *s == 35 )
{
sa = s + 1;
if ( !*sa || *sa != 33 )
{
sb = (char *)ltrim(sa);
if ( *sb && sb[strlen(sb) - 1] == 10 )
sb[strlen(sb) - 1] = 0;
if ( !strncmp(sb, "description:", 0xCuLL) )
{
v3 = (const char *)ltrim(sb + 12);
*(_QWORD *)(a1 + 24) = strdup(v3);
}
else if ( !strncmp(sb, "args:", 5uLL) )
{
v4 = (const char *)ltrim(sb + 5);
*(_QWORD *)(a1 + 32) = strdup(v4);
}
}
}
}
}
fclose(stream);
return 0LL;
}
Q:[a1,a2,stream,s,v9,sub_43FA91,] | A:{'a1': 'desc', 'a2': 'filename', 'stream': 'fp', 's': 'pb', 'v9': 'line', 'sub_43FA91': 'read_script_info'} | |
5c2a369c2a43bfe06e48866e92fbdc8c356c46190477983799d2e15f105ed3e0_5c2a369c2a43bfe06e48866e92fbdc8c356c46190477983799d2e15f105ed3e0.jsonl.gz | sub_44BD0C | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_44BD0C(unsigned int *a1, const char ***a2, __int64 a3, unsigned int *a4)
{
uint32_t v5; // eax
uint32_t v6; // eax
const char **v9; // [rsp+20h] [rbp-20h] BYREF
int v10; // [rsp+2Ch] [rbp-14h] BYREF
uint32_t *v11; // [rsp+30h] [rbp-10h]
int v12; // [rsp+38h] [rbp-8h]
unsigned int v13; // [rsp+3Ch] [rbp-4h]
v13 = -1;
v10 = *a1;
v9 = *a2;
if ( v10 <= 1 )
return 0xFFFFFFFFLL;
if ( *(_BYTE *)(a3 + 4120) != 1 )
return 0xFFFFFFFFLL;
a4[6] = 3;
if ( !strcmp(*v9, "src") )
{
++v9;
if ( --v10 <= 0 )
incomplete_command();
a4[2] = 8;
v13 = parse_cmd((unsigned int *)&v10, (__int64 *)&v9, 0x10u, 2, -1, a3, a4, 0);
}
else if ( !strcmp(*v9, "dst") )
{
++v9;
if ( --v10 <= 0 )
incomplete_command();
a4[2] = 24;
v13 = parse_cmd((unsigned int *)&v10, (__int64 *)&v9, 0x10u, 2, -1, a3, a4, 0);
}
else if ( !strcmp(*v9, "flow_lbl") )
{
++v9;
if ( --v10 <= 0 )
incomplete_command();
a4[2] = 0;
v13 = parse_cmd((unsigned int *)&v10, (__int64 *)&v9, 4u, 4, 0x7FFFF, a3, a4, 0);
}
else if ( !strcmp(*v9, "payload_len") )
{
++v9;
if ( --v10 <= 0 )
incomplete_command();
a4[2] = 4;
v13 = parse_cmd((unsigned int *)&v10, (__int64 *)&v9, 2u, 4, 0xFFFF, a3, a4, 0);
}
else if ( !strcmp(*v9, "nexthdr") )
{
++v9;
if ( --v10 <= 0 )
incomplete_command();
a4[2] = 6;
v13 = parse_cmd((unsigned int *)&v10, (__int64 *)&v9, 1u, 4, 255, a3, a4, 0);
}
else if ( !strcmp(*v9, "hoplimit") )
{
++v9;
if ( --v10 <= 0 )
incomplete_command();
a4[2] = 7;
v13 = parse_cmd((unsigned int *)&v10, (__int64 *)&v9, 1u, 4, 255, a3, a4, 1);
}
else
{
if ( strcmp(*v9, "traffic_class") )
return 0xFFFFFFFFLL;
++v9;
if ( --v10 <= 0 )
incomplete_command();
a4[2] = 1;
v13 = parse_cmd((unsigned int *)&v10, (__int64 *)&v9, 1u, 4, 255, a3, a4, 0);
if ( !v13 )
{
v12 = *(unsigned __int8 *)(a3 + 20);
v11 = (uint32_t *)(24LL * (v12 - 1) + 16 + a3 + 8);
v5 = ntohl(*v11);
*v11 = htonl((16 * v5) | 0xF);
v6 = ntohl(v11[1]);
v11[1] = htonl(16 * v6);
}
}
*a1 = v10;
*a2 = v9;
return v13;
}
Q:[a3,a4,a1,a2,v9,v10,v11,v12,v13,sub_44BD0C,] | A:{'a3': 'sel', 'a4': 'tkey', 'a1': 'argc_p', 'a2': 'argv_p', 'v9': 'argv', 'v10': 'argc', 'v11': 'key', 'v12': 'nkeys', 'v13': 'res', 'sub_44BD0C': 'parse_ip6_0'} | |
e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433_e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433.jsonl.gz | sub_44810D | Help user generate meaningful names for variables and functions in the following code snippet. |
bool __fastcall sub_44810D(__int64 a1, __int64 a2)
{
__int64 v2; // rbx
v2 = *(_QWORD *)sub_449B80(a1);
return v2 != *(_QWORD *)sub_449B80(a2);
}
Q:[sub_44810D,sub_449B80,] | A:{'sub_44810D': 'allocator', 'sub_449B80': 'base'} | |
8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2_8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2.jsonl.gz | sub_447C69 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_447C69(__int64 a1)
{
if ( !a1 )
return 1LL;
*(_DWORD *)(a1 + 20) = 0;
*(_DWORD *)(a1 + 24) = 0;
*(_WORD *)(a1 + 28) = 0;
*(_DWORD *)a1 = 1732584193;
*(_DWORD *)(a1 + 4) = -271733879;
*(_DWORD *)(a1 + 8) = -1732584194;
*(_DWORD *)(a1 + 12) = 271733878;
*(_DWORD *)(a1 + 16) = -1009589776;
*(_DWORD *)(a1 + 96) = 0;
*(_DWORD *)(a1 + 100) = 0;
return 0LL;
}
Q:[a1,sub_447C69,] | A:{'a1': 'context', 'sub_447C69': 'cf_SHA1Reset'} | |
6a65809a449cdcd8ef48c45d7836a8c2f0ae12fa4788c3927c09393d96325e5b_6a65809a449cdcd8ef48c45d7836a8c2f0ae12fa4788c3927c09393d96325e5b.jsonl.gz | psock_send | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall psock_send(__int64 a1, __int64 a2, int a3)
{
__int64 result; // rax
if ( *(_WORD *)(a1 + 2) )
{
if ( *(_WORD *)(a1 + 2) == 183 )
{
while ( 1 )
{
if ( !(unsigned __int8)sub_4053D8(a1) )
return 0LL;
LABEL_10:
if ( !*(_WORD *)(a1 + 32) )
break;
*(_WORD *)(a1 + 2) = 183;
}
*(_BYTE *)(a1 + 60) = 0;
}
*(_WORD *)(a1 + 2) = 0;
result = 3LL;
}
else
{
if ( a3 )
{
*(_QWORD *)(a1 + 8) = a2;
*(_WORD *)(a1 + 32) = a3;
*(_BYTE *)(a1 + 60) = 0;
goto LABEL_10;
}
*(_WORD *)(a1 + 2) = 0;
result = 2LL;
}
return result;
}
Q:[sub_4053D8,] | A:{'sub_4053D8': 'data_is_sent_and_acked'} | |
decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08_decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08.jsonl.gz | sub_4286BD | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4286BD(__int64 a1)
{
unsigned __int64 i; // [rsp+10h] [rbp-10h]
sub_4243E0(a1);
sub_4244A4(a1);
sub_425BC0(a1);
if ( (unsigned int)sub_427EAE((_QWORD *)a1, 0LL) )
return 0xFFFFFFFFLL;
printf("nr_run_events: %ld\n", *(_QWORD *)(a1 + 573688));
printf("nr_sleep_events: %ld\n", *(_QWORD *)(a1 + 573696));
printf("nr_wakeup_events: %ld\n", *(_QWORD *)(a1 + 573704));
if ( *(_QWORD *)(a1 + 573728) )
printf("target-less wakeups: %ld\n", *(_QWORD *)(a1 + 573728));
if ( *(_QWORD *)(a1 + 573736) )
printf("multi-target wakeups: %ld\n", *(_QWORD *)(a1 + 573736));
if ( *(_QWORD *)(a1 + 573720) )
printf("run atoms optimized: %ld\n", *(_QWORD *)(a1 + 573720));
sub_424AFD(a1);
sub_424BA6((_QWORD *)a1);
sub_425301(a1);
puts("------------------------------------------------------------");
for ( i = 0LL; i < *(unsigned int *)(a1 + 573684); ++i )
sub_4258D3((_QWORD *)a1);
return 0LL;
}
Q:[a1,sub_4286BD,sub_4243E0,sub_4244A4,sub_425BC0,sub_427EAE,sub_424AFD,sub_424BA6,sub_425301,sub_4258D3,] | A:{'a1': 'sched', 'sub_4286BD': 'perf_sched__replay', 'sub_4243E0': 'calibrate_run_measurement_overhead', 'sub_4244A4': 'calibrate_sleep_measurement_overhead', 'sub_425BC0': 'test_calibrations', 'sub_427EAE': 'perf_sched__read_events', 'sub_424AFD': 'print_task_traces', 'sub_424BA6': 'add_cross_task_wakeups', 'sub_425301': 'create_tasks', 'sub_4258D3': 'run_one_test'} | |
45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0_45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0.jsonl.gz | sub_414E1E | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_414E1E(_QWORD *a1)
{
sub_414DE6(a1);
operator delete(a1, 0x30uLL);
}
Q:[a1,sub_414E1E,sub_414DE6,] | A:{'a1': 'this', 'sub_414E1E': '~_Sp_counted_ptr_inplace', 'sub_414DE6': '~_Sp_counted_ptr_inplace'} | |
14c39801a976c945416b12662f5fa02721a11b799f493db0c913091da70eab07_14c39801a976c945416b12662f5fa02721a11b799f493db0c913091da70eab07.jsonl.gz | sub_40339F | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 __fastcall sub_40339F(int a1, __int64 a2, const char *a3)
{
_BOOL8 result; // rax
size_t n; // [rsp+28h] [rbp-8h]
n = strlen(a3);
if ( a2 )
result = gnutls_record_send() >= 0;
else
result = send(a1, a3, n, 0x4000) >= 0;
return result;
}
Q:[a3,a1,a2,n,sub_40339F,] | A:{'a3': 'Buffer', 'a1': 's', 'a2': 'session', 'n': 'l', 'sub_40339F': 'sendstring_auto'} | |
8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197_8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197.jsonl.gz | sub_4032E4 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_4032E4()
{
return sub_403238();
}
Q:[sub_4032E4,sub_403238,] | A:{'sub_4032E4': 'max_size', 'sub_403238': '_M_max_size'} | |
b7fe0a41777564954fab2fa97407222fe62c56ec7cc3104df89487be10c2d243_b7fe0a41777564954fab2fa97407222fe62c56ec7cc3104df89487be10c2d243.jsonl.gz | sub_40DB91 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40DB91(__int64 a1, unsigned int a2, char a3, unsigned __int16 a4)
{
if ( a4 <= 0xFu )
return 0LL;
if ( a4 > 0x800u )
return 0LL;
if ( a2 > 0xFFFFF )
return 0LL;
*(_DWORD *)(a1 + 188) = a2;
*(_BYTE *)(a1 + 192) = a3;
*(_WORD *)(a1 + 194) = a4;
*(_BYTE *)(a1 + 32) |= 8u;
return 1LL;
}
Q:[a3,a4,a1,a2,sub_40DB91,] | A:{'a3': 'more', 'a4': 'size', 'a1': 'packet', 'a2': 'num', 'sub_40DB91': 'coap_set_header_block1'} | |
876701f3a9046127c14232fb92e42c99080f16ec5c3cb376c624f10cf0c1511f_876701f3a9046127c14232fb92e42c99080f16ec5c3cb376c624f10cf0c1511f.jsonl.gz | sub_4093F4 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4093F4(__int64 a1, int a2, int a3, int a4, int a5, int a6, int a7)
{
__int64 result; // rax
__int64 v8; // [rsp+14h] [rbp-18h]
unsigned int i; // [rsp+24h] [rbp-8h]
int j; // [rsp+28h] [rbp-4h]
v8 = 4LL * (a2 * a4 + a3) + a1;
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a6 )
break;
for ( j = 0; j < a5; ++j )
*(_DWORD *)(v8 + 4LL * j) = a7;
v8 += 4LL * a2;
}
return result;
}
Q:[a3,a4,a1,a2,a5,a6,a7,v8,i,j,sub_4093F4,] | A:{'a3': 'x', 'a4': 'y', 'a1': 'screen', 'a2': 'pitchW', 'a5': 'width', 'a6': 'height', 'a7': 'color', 'v8': 'screena', 'i': 'yc', 'j': 'xc', 'sub_4093F4': 'PokeMini_VideoRect_32'} | |
d8bd0fa60e206d9711442506ad8361abe329eebf701c11022d691c8f25f86b04_d8bd0fa60e206d9711442506ad8361abe329eebf701c11022d691c8f25f86b04.jsonl.gz | sub_41B133 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 __fastcall sub_41B133(__int64 a1, int a2, __int64 a3)
{
if ( a2 >= 0 && a2 <= 1023 )
return (*(_QWORD *)(a3 + 8LL * (a2 / 64) + 8) & (1LL << (a2 % 64))) != 0;
sub_41926A(
a1,
(__int64)"nopoll_io_wait_select_is_set",
"nopoll_io.c",
0xBCu,
2u,
"received a non valid socket (%d), unable to test in the set",
(unsigned int)a2);
return 0LL;
}
Q:[sub_41B133,] | A:{'sub_41B133': 'nopoll_io_wait_select_is_set'} | |
7081e45cc9c4fbe9cf3486887760c2a5d1804b34cd8c38ec851c47429d0144e8_7081e45cc9c4fbe9cf3486887760c2a5d1804b34cd8c38ec851c47429d0144e8.jsonl.gz | sub_407AD8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_407AD8()
{
return sub_407AAB(1u);
}
Q:[sub_407AD8,sub_407AAB,] | A:{'sub_407AD8': 'genlognot', 'sub_407AAB': 'queue_bool'} | |
ed44ca9dcc1242045d57739612f7f576c6fb3ac81cc29b7aa045231f88565267_ed44ca9dcc1242045d57739612f7f576c6fb3ac81cc29b7aa045231f88565267.jsonl.gz | sub_421360 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_421360(__int64 a1)
{
int v1; // ebp
v1 = sub_4275F0(a1 + 384);
return v1 + (unsigned int)sub_4275F0(a1 + 624);
}
Q:[a1,sub_421360,sub_4275F0,] | A:{'a1': 'this', 'sub_421360': 'GetTcpConnectingCount', 'sub_4275F0': 'GetSize'} | |
dbef1d827ccd2a42e8941d50152f102df28295732bfb69acb1ef6314d264873b_dbef1d827ccd2a42e8941d50152f102df28295732bfb69acb1ef6314d264873b.jsonl.gz | sub_40DDEF | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_40DDEF(__int64 a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6, ...)
{
gcc_va_list va; // [rsp+18h] [rbp-C8h] BYREF
__int64 v8; // [rsp+38h] [rbp-A8h]
__int64 v9; // [rsp+40h] [rbp-A0h]
__int64 v10; // [rsp+48h] [rbp-98h]
__int64 v11; // [rsp+50h] [rbp-90h]
__int64 v12; // [rsp+58h] [rbp-88h]
va_start(va, a6);
v8 = a2;
v9 = a3;
v10 = a4;
v11 = a5;
v12 = a6;
va[0].gp_offset = 8;
sub_40DE95(a1, va);
return 0xFFFFFFFFLL;
}
Q:[a1,va,sub_40DDEF,sub_40DE95,] | A:{'a1': 'format', 'va': 'args', 'sub_40DDEF': 'errorsys', 'sub_40DE95': 'verrorsys'} | |
b29eb5653fcf2ce909f4d164785b08883df3ed1463b96e32f623211263040ba7_b29eb5653fcf2ce909f4d164785b08883df3ed1463b96e32f623211263040ba7.jsonl.gz | sub_4111D5 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_4111D5()
{
return xmlGetNoNsProp();
}
Q:[sub_4111D5,] | A:{'sub_4111D5': 'xml_node_get_attr_value'} | |
de43174f5631d1d268a85fb78a25cb04f070ecc3cd887343c29ce0593cee4735_de43174f5631d1d268a85fb78a25cb04f070ecc3cd887343c29ce0593cee4735.jsonl.gz | sub_406E81 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 *__fastcall sub_406E81(const char *a1)
{
__int64 v1; // rax
__int64 *v3; // [rsp+18h] [rbp-18h]
int *v4; // [rsp+20h] [rbp-10h]
if ( !a1 || !strcmp(a1, L"-r") )
v1 = gzdopen();
else
v1 = gzopen();
if ( !v1 )
return 0LL;
v4 = (int *)sub_405CBB(v1);
v3 = sub_406CDE(v4);
sub_405D14((void **)v4);
gzclose();
return v3;
}
Q:[a1,v3,v4,sub_406E81,sub_405CBB,sub_406CDE,sub_405D14,] | A:{'a1': 'fn', 'v3': 'gff', 'v4': 'ks', 'sub_406E81': 'gf_read', 'sub_405CBB': 'ks_init', 'sub_406CDE': 'gf_read_ks', 'sub_405D14': 'ks_destroy'} | |
81c9f5d79c117ec5dd98c5558d3d8ad93a41b288c3b0bd9acc9a7fa17c596bea_81c9f5d79c117ec5dd98c5558d3d8ad93a41b288c3b0bd9acc9a7fa17c596bea.jsonl.gz | sub_404A1D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_404A1D(unsigned int a1, __int64 a2, int a3)
{
int v3; // eax
pthread_mutex_t *v4; // rax
int v5; // eax
__int64 result; // rax
struct timeval v8; // [rsp+10h] [rbp-50h] BYREF
int v9; // [rsp+28h] [rbp-38h] BYREF
int oldstate; // [rsp+2Ch] [rbp-34h] BYREF
struct timeval tv; // [rsp+30h] [rbp-30h] BYREF
struct __pthread_internal_list *v12; // [rsp+40h] [rbp-20h]
__int64 v13; // [rsp+48h] [rbp-18h]
__int64 v14; // [rsp+50h] [rbp-10h]
__suseconds_t v15; // [rsp+58h] [rbp-8h]
if ( a3 )
{
gettimeofday(&tv, 0LL);
v15 = tv.tv_usec + 1000000 * tv.tv_sec;
}
sub_40313F(a1, (void (__fastcall *)(_QWORD, __int64))sub_407552, 0);
v3 = pthread_mutex_lock((pthread_mutex_t *)((char *)mutex + 82088));
v13 = v3;
if ( v3 )
{
puts("Error while trying to get lock in barrier.");
exit(-1);
}
v12 = mutex[2054].__list.__prev;
v4 = mutex;
++*(&mutex[2054].__align + 2);
if ( *(&v4[2054].__align + 2) == dword_413210 )
{
mutex[2054].__list.__prev = (struct __pthread_internal_list *)(mutex[2054].__list.__prev == 0LL);
*(&mutex[2054].__align + 2) = 0LL;
v13 = pthread_cond_broadcast((pthread_cond_t *)(&mutex[2053].__align + 1));
}
else
{
pthread_setcancelstate(1, &oldstate);
do
{
if ( v12 != mutex[2054].__list.__prev )
break;
v5 = pthread_cond_wait((pthread_cond_t *)(&mutex[2053].__align + 1), (pthread_mutex_t *)((char *)mutex + 82088));
v13 = v5;
}
while ( !v5 );
pthread_setcancelstate(oldstate, &v9);
}
pthread_mutex_unlock((pthread_mutex_t *)((char *)mutex + 82088));
result = sub_40313F(a1, (void (__fastcall *)(_QWORD, __int64))sub_4077C7, 1);
if ( a3 )
{
gettimeofday(&v8, 0LL);
result = v8.tv_usec + 1000000 * v8.tv_sec;
v14 = result;
}
if ( a3 )
{
result = v14 - v15;
*(_QWORD *)(a2 + 72LL * *((int *)&unk_4165E4 + 2458 * (int)a1) + 8) = v14 - v15;
}
return result;
}
Q:[a3,a1,a2,v8,v9,oldstate,tv,v12,v13,v14,v15,sub_404A1D,sub_40313F,sub_407552,sub_4077C7,] | A:{'a3': 'time_all', 'a1': 'my_id', 'a2': 'local_time', 'v8': 'FullTime_0', 'v9': 'Temp', 'oldstate': 'Cancel', 'tv': 'FullTime', 'v12': 'Cycle', 'v13': 'Error', 'v14': 'finish', 'v15': 'start', 'sub_404A1D': 'ConstructLists', 'sub_40313F': 'PartitionIterate', 'sub_407552': 'ConstructGridLists', 'sub_4077C7': 'ConstructInteractionLists'} | |
5b4700d9feea13f25b1c7be46723e23964b469211eb8b738ef7a04924d7cdb5f_5b4700d9feea13f25b1c7be46723e23964b469211eb8b738ef7a04924d7cdb5f.jsonl.gz | sub_40C400 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_40C400(_QWORD **a1)
{
_QWORD *v1; // rbx
_QWORD *v3; // rbp
_QWORD *v4; // rdi
v1 = *a1;
while ( v1 != a1 )
{
v3 = v1;
v1 = (_QWORD *)*v1;
v4 = (_QWORD *)v3[2];
if ( v4 != v3 + 4 )
operator delete(v4, v3[4] + 1LL);
operator delete(v3, 0x30uLL);
}
}
Q:[a1,sub_40C400,] | A:{'a1': 'this', 'sub_40C400': '_M_clear'} | |
9f07553910791793598325ae1b21920e204e1051315184d671adcea8fb4ddb8c_9f07553910791793598325ae1b21920e204e1051315184d671adcea8fb4ddb8c.jsonl.gz | sub_411B96 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_411B96(__int64 a1)
{
if ( (unsigned int)__isoc99_fscanf() != 1 )
__assert_fail("ret == 1", "/usr/src/repo/pkgs/apps/ferret/src/src/hash.c", 0x6Bu, "ohash_init_with_txt_stream");
*(_DWORD *)a1 = 0;
*(_QWORD *)(a1 + 8) = malloc(0LL);
return 0LL;
}
Q:[a1,sub_411B96,] | A:{'a1': 'ohash', 'sub_411B96': 'ohash_init_with_txt_stream'} | |
556e0263abbe1e4daef5ea125859adebb55575ea4fa8d33e6255954205d7ba5b_556e0263abbe1e4daef5ea125859adebb55575ea4fa8d33e6255954205d7ba5b.jsonl.gz | sub_424AE4 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_424AE4(__int64 a1)
{
int v1; // eax
__int64 v3; // rdx
char v4[12472]; // [rsp+10h] [rbp-3190h] BYREF
int v5; // [rsp+30C8h] [rbp-D8h]
_QWORD v6[17]; // [rsp+3100h] [rbp-A0h] BYREF
_WORD *v7; // [rsp+3188h] [rbp-18h]
_WORD *v8; // [rsp+3190h] [rbp-10h]
_WORD *v9; // [rsp+3198h] [rbp-8h]
v8 = 0LL;
v7 = 0LL;
v9 = (_WORD *)(a1 + 416);
v1 = *(_DWORD *)(a1 + 360);
if ( v1 != 1 )
{
if ( v1 != 28 )
return 0xFFFFFFFFLL;
if ( *v9 == 10 )
goto LABEL_12;
if ( !(unsigned int)sub_4247B6(v9, v6, 10) )
{
v9 = v6;
LABEL_12:
v7 = v9;
v3 = *((_QWORD *)v9 + 2);
*(_QWORD *)(a1 + 1128) = *((_QWORD *)v9 + 1);
*(_QWORD *)(a1 + 1136) = v3;
goto LABEL_13;
}
LABEL_6:
sub_41E211(0, a1);
return 0LL;
}
if ( *v9 != 2 )
{
if ( (unsigned int)sub_4247B6(v9, v6, 2) )
goto LABEL_6;
v9 = v6;
}
v8 = v9;
*(_DWORD *)(a1 + 1128) = *((_DWORD *)v9 + 1);
LABEL_13:
*(_WORD *)(a1 + 378) = 0;
*(_DWORD *)(a1 + 1124) = dword_583144;
*(_DWORD *)(a1 + 1116) = 1;
sub_419D0B((__int64)v4, a1);
v5 = 1;
sub_41DCFF((__int64)v4);
return 0LL;
}
Q:[a1,v4,v6,v7,v8,v9,sub_424AE4,sub_4247B6,sub_41E211,sub_419D0B,sub_41DCFF,] | A:{'a1': 'request', 'v4': 'context', 'v6': 'localaddr_buff', 'v7': 'addr_in6', 'v8': 'addr_in', 'v9': 'localaddr', 'sub_424AE4': '_dns_server_reply_request_eth_ip', 'sub_4247B6': '_dns_server_get_inet_by_addr', 'sub_41E211': '_dns_server_reply_SOA', 'sub_419D0B': '_dns_server_post_context_init', 'sub_41DCFF': '_dns_request_post'} | |
fb84531f464af633411a9cce5685cc845dea873feaaf9d319538d371cd4597c6_fb84531f464af633411a9cce5685cc845dea873feaaf9d319538d371cd4597c6.jsonl.gz | sub_404919 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_404919(unsigned __int8 *a1)
{
int v2; // [rsp+14h] [rbp-4h]
v2 = (unsigned __int16)sub_4048E0(a1);
return v2 | ((unsigned __int16)sub_4048E0(a1 + 2) << 16);
}
Q:[a1,v2,sub_404919,sub_4048E0,] | A:{'a1': 'offset', 'v2': 'l', 'sub_404919': 'r32_0', 'sub_4048E0': 'r16_0'} | |
9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0_9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0.jsonl.gz | sub_460DD6 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_460DD6(__int64 a1, unsigned __int64 a2)
{
if ( a2 > sub_46164A(a1) )
std::__throw_bad_alloc();
return operator new(312 * a2);
}
Q:[sub_460DD6,sub_46164A,] | A:{'sub_460DD6': 'allocate', 'sub_46164A': '_M_max_size'} | |
534b77e037503f35bba25c243fb010c2877ab7963605f61987a1c273554ab524_534b77e037503f35bba25c243fb010c2877ab7963605f61987a1c273554ab524.jsonl.gz | sub_40D70C | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_40D70C()
{
;
}
Q:[sub_40D70C,] | A:{'sub_40D70C': 'NullParams'} | |
45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0_45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0.jsonl.gz | sub_45386E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_45386E(__int64 a1)
{
return sub_4566E0(a1);
}
Q:[a1,sub_45386E,sub_4566E0,] | A:{'a1': 'this', 'sub_45386E': '~allocator', 'sub_4566E0': '~new_allocator'} | |
9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0_9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0.jsonl.gz | sub_440FC8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_440FC8(__int64 a1)
{
__int64 v2; // [rsp+18h] [rbp-8h] BYREF
sub_44B7BA(&v2, a1 + 8);
return v2;
}
Q:[sub_440FC8,sub_44B7BA,] | A:{'sub_440FC8': 'end', 'sub_44B7BA': '__normal_iterator'} | |
68eece29edec86fe51cb9da2a304caeab06c82737e887e77284167164d508312_68eece29edec86fe51cb9da2a304caeab06c82737e887e77284167164d508312.jsonl.gz | sub_42E3C0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42E3C0(__int64 a1, const char *a2, int a3)
{
__int64 result; // rax
*(_DWORD *)(a1 + 108) = 0;
strlen(a2);
result = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::_M_replace();
*(_DWORD *)(a1 + 112) = a3;
return result;
}
Q:[a3,a1,a2,sub_42E3C0,] | A:{'a3': 'size_locals', 'a1': 'this', 'a2': 'name', 'sub_42E3C0': 'prologue_encrypt_block'} | |
e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433_e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433.jsonl.gz | sub_43484C | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43484C(__int64 a1, __int64 a2, __int64 a3)
{
__int64 v3; // rbx
__int64 v4; // rax
v3 = sub_434897(a2);
v4 = sub_434897(a1);
return sub_4348B9(v4, v3, a3);
}
Q:[sub_43484C,sub_434897,sub_4348B9,] | A:{'sub_43484C': 'move_iterator', 'sub_434897': '__miter_base', 'sub_4348B9': '__copy_move_a'} | |
692d89ba41b3c244a2a1c90c266c7cba1727366e863f15abd0dbeaffc3a4918e_692d89ba41b3c244a2a1c90c266c7cba1727366e863f15abd0dbeaffc3a4918e.jsonl.gz | sub_401502 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_401502(unsigned __int8 *a1, __int64 a2, __int64 a3)
{
unsigned __int8 *v3; // rax
unsigned __int8 *i; // [rsp+48h] [rbp-10h]
unsigned __int64 v6; // [rsp+50h] [rbp-8h]
v6 = a3 ^ (0xC6A4A7935BD1E995LL * a2);
for ( i = a1; i != &a1[a2 & 0xFFFFFFFFFFFFFFF8LL]; i += 8 )
{
v3 = i;
v6 = 0xC6A4A7935BD1E995LL
* ((0xC6A4A7935BD1E995LL
* (((0xC6A4A7935BD1E995LL * *(_QWORD *)v3) >> 47) ^ (0xC6A4A7935BD1E995LL * *(_QWORD *)v3))) ^ v6);
}
switch ( a2 & 7 )
{
case 1LL:
goto LABEL_11;
case 2LL:
goto LABEL_10;
case 3LL:
goto LABEL_9;
case 4LL:
goto LABEL_8;
case 5LL:
goto LABEL_7;
case 6LL:
goto LABEL_6;
case 7LL:
v6 ^= (unsigned __int64)i[6] << 48;
LABEL_6:
v6 ^= (unsigned __int64)i[5] << 40;
LABEL_7:
v6 ^= (unsigned __int64)i[4] << 32;
LABEL_8:
v6 ^= (unsigned __int64)i[3] << 24;
LABEL_9:
v6 ^= (unsigned __int64)i[2] << 16;
LABEL_10:
v6 ^= (unsigned __int64)i[1] << 8;
LABEL_11:
v6 = 0xC6A4A7935BD1E995LL * (*i ^ v6);
break;
default:
return ((0xC6A4A7935BD1E995LL * ((v6 >> 47) ^ v6)) >> 47) ^ (0xC6A4A7935BD1E995LL * ((v6 >> 47) ^ v6));
}
return ((0xC6A4A7935BD1E995LL * ((v6 >> 47) ^ v6)) >> 47) ^ (0xC6A4A7935BD1E995LL * ((v6 >> 47) ^ v6));
}
Q:[a3,a1,a2,i,v6,sub_401502,] | A:{'a3': 'seed', 'a1': 'key', 'a2': 'len', 'i': 'data', 'v6': 'h', 'sub_401502': 'murmur3_hash64'} | |
aa83b7af2e14e99526d7a5c18af696a5412986d753d504cd6364dd65833cb6c8_aa83b7af2e14e99526d7a5c18af696a5412986d753d504cd6364dd65833cb6c8.jsonl.gz | sub_401656 | Help user generate meaningful names for variables and functions in the following code snippet. |
_DWORD *__fastcall sub_401656(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *v3; // rax
_DWORD *result; // rax
int i; // [rsp+24h] [rbp-4h]
for ( i = 0; --a2 >= 0; *v3 = i )
{
i += *a1;
v3 = a1++;
}
result = a3;
*a3 = i;
return result;
}
Q:[a3,a1,a2,i,sub_401656,] | A:{'a3': 'total', 'a1': 'table', 'a2': 'limit', 'i': 'accum', 'sub_401656': 'cumulativedist'} | |
7f545c8ae1786b370896c7ac49cb69fcc76f45d194b51355543a701e3d409007_7f545c8ae1786b370896c7ac49cb69fcc76f45d194b51355543a701e3d409007.jsonl.gz | sub_40DE81 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40DE81(FILE *a1, void *a2, int a3)
{
__int64 result; // rax
if ( fread(a2, a3, 1uLL, a1) == 1 )
result = 0LL;
else
result = 0xFFFFFFFFLL;
return result;
}
Q:[a3,a1,a2,sub_40DE81,] | A:{'a3': 'spacesize', 'a1': 'tracefile', 'a2': 'spaceptr', 'sub_40DE81': 'iotrace_read_space'} | |
60ac55a2a203ad4a0cba9f6ccbaa49a1f58686459d799f6c21baa5e3d1bb027c_60ac55a2a203ad4a0cba9f6ccbaa49a1f58686459d799f6c21baa5e3d1bb027c.jsonl.gz | sub_401E1E | Help user generate meaningful names for variables and functions in the following code snippet. |
bool __fastcall sub_401E1E(char a1)
{
return ((*__ctype_b_loc())[a1] & 0x400) != 0;
}
Q:[a1,sub_401E1E,] | A:{'a1': 'x', 'sub_401E1E': 'is_alpha'} | |
c4ae2bf24a4f31cef8364da9a3a6f2ff9152fef4aa62b4f5ce7850d840e2f0fc_c4ae2bf24a4f31cef8364da9a3a6f2ff9152fef4aa62b4f5ce7850d840e2f0fc.jsonl.gz | sub_403B1F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_403B1F(__int64 a1, int a2, const char *a3)
{
char dest[200]; // [rsp+20h] [rbp-F0h] BYREF
__int64 v6; // [rsp+E8h] [rbp-28h]
int v7; // [rsp+F0h] [rbp-20h]
int v8; // [rsp+F4h] [rbp-1Ch]
int v9; // [rsp+F8h] [rbp-18h]
int v10; // [rsp+FCh] [rbp-14h]
int v11; // [rsp+108h] [rbp-8h]
int i; // [rsp+10Ch] [rbp-4h]
if ( !a1 )
__assert_fail("cb != NULL", "hrd_conn.c", 0x21Eu, "hrd_publish_conn_qp");
if ( a2 < 0 || a2 >= *(_DWORD *)(a1 + 44) )
__assert_fail("n >= 0 && n < cb->num_conn_qps", "hrd_conn.c", 0x21Fu, "hrd_publish_conn_qp");
if ( !a3 || strlen(a3) > 0xC6 )
__assert_fail(
"qp_name != NULL && strlen(qp_name) < HRD_QP_NAME_SIZE - 1",
"hrd_conn.c",
0x221u,
"hrd_publish_conn_qp");
if ( strstr(a3, "__HRD_RESERVED_NAME_PREFIX") )
__assert_fail("strstr(qp_name, HRD_RESERVED_NAME_PREFIX) == NULL", "hrd_conn.c", 0x222u, "hrd_publish_conn_qp");
v11 = strlen(a3);
for ( i = 0; i < v11; ++i )
{
if ( a3[i] == 32 )
{
fwrite("HRD: Space not allowed in QP name\n", 1uLL, 0x22uLL, stderr);
exit(-1);
}
}
memcpy(dest, a3, v11);
dest[v11] = 0;
v6 = *(_QWORD *)(a1 + 64);
v7 = *(_DWORD *)(a1 + 72);
v8 = *(_DWORD *)(*(_QWORD *)(a1 + 80) + 40LL);
v9 = (unsigned __int16)sub_404CEC(**(_QWORD **)(*(_QWORD *)(a1 + 48) + 8LL * a2), *(unsigned int *)(a1 + 24));
v10 = *(_DWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 48) + 8LL * a2) + 52LL);
return sub_404F0C(dest, dest, 224LL);
}
Q:[a3,a1,a2,dest,v11,sub_403B1F,sub_404CEC,sub_404F0C,] | A:{'a3': 'qp_name', 'a1': 'cb', 'a2': 'n', 'dest': 'qp_attr', 'v11': 'len', 'sub_403B1F': 'hrd_publish_conn_qp', 'sub_404CEC': 'hrd_get_local_lid', 'sub_404F0C': 'hrd_publish'} |