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 |
|---|---|---|---|---|---|
5184c2b77d38653561b9feb1ac4655a09710ae7a47128c1e2e0af437220e8cde_5184c2b77d38653561b9feb1ac4655a09710ae7a47128c1e2e0af437220e8cde.jsonl.gz | sub_404431 | Help user generate meaningful names for variables and functions in the following code snippet. |
__time_t __fastcall sub_404431(void (__fastcall *a1)(__int64, __int64), __int64 a2, __int64 a3, unsigned int a4, _QWORD *a5)
{
struct timespec tp; // [rsp+30h] [rbp-20h] BYREF
unsigned __int64 v10; // [rsp+48h] [rbp-8h]
clock_gettime(1, &tp);
if ( a5 )
{
if ( a2 != a3 )
{
v10 = 1000 * (tp.tv_sec - *a5) + (tp.tv_nsec - a5[1]) / 0xF4240uLL;
if ( v10 < a4 )
return *a5;
}
}
a1(a2, a3);
return tp.tv_sec;
}
Q:[a3,a4,a1,a2,a5,tp,v10,sub_404431,] | A:{'a3': 'total', 'a4': 'interval_ms', 'a1': 'cb', 'a2': 'current', 'a5': 'last', 'tp': 'now', 'v10': 'delta', 'sub_404431': 'progress_limit_rate'} | |
9e888b50654147b938cd52111c7230620df1b163750bfeb9f4788f6abc8a1594_9e888b50654147b938cd52111c7230620df1b163750bfeb9f4788f6abc8a1594.jsonl.gz | sub_4013B5 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4013B5(__int64 a1)
{
__int64 result; // rax
if ( !a1 )
return 2LL;
if ( *(_BYTE *)(a1 + 74) != 1 )
return 3LL;
if ( (*(unsigned __int8 (**)(void))(a1 + 16))() )
{
(*(void (__fastcall **)(const char *))(a1 + 64))("at24cxx: iic deinit failed.\n");
result = 1LL;
}
else
{
*(_BYTE *)(a1 + 74) = 0;
result = 0LL;
}
return result;
}
Q:[a1,sub_4013B5,] | A:{'a1': 'handle', 'sub_4013B5': 'at24cxx_deinit'} | |
3c0aaf322c6ccdc6b2e4303341c6135e39952377a0ef7fbf56294667f9cd2c29_3c0aaf322c6ccdc6b2e4303341c6135e39952377a0ef7fbf56294667f9cd2c29.jsonl.gz | sub_420FEA | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_420FEA(__int64 a1, __int64 a2, int a3)
{
__int64 result; // rax
__int64 i; // [rsp+28h] [rbp-8h]
char *v6; // [rsp+28h] [rbp-8h]
result = (unsigned int)dword_44F3F0;
if ( !dword_44F3F0 )
{
result = *(_QWORD *)(qword_487080 + 48);
for ( i = result; i; i = result )
{
if ( a1 == *(_QWORD *)i && a2 == *(_QWORD *)(i + 8) )
{
result = i;
*(_DWORD *)(i + 16) |= a3;
break;
}
result = *(_QWORD *)(i + 24);
}
if ( !i )
{
v6 = sub_420692(a1);
*((_QWORD *)v6 + 1) = a2;
*((_DWORD *)v6 + 4) = a3;
*((_QWORD *)v6 + 3) = *(_QWORD *)(qword_487080 + 48);
result = qword_487080;
*(_QWORD *)(qword_487080 + 48) = v6;
}
}
return result;
}
Q:[a3,a1,a2,v6,sub_420FEA,sub_420692,] | A:{'a3': 'tags', 'a1': 't', 'a2': 'n', 'v6': 'v', 'sub_420FEA': 'make_suspect', 'sub_420692': 'uno_getext'} | |
f7bc07a61a42c165e8cc618ccb7952982216221f481dabb283517b51f0a6d546_f7bc07a61a42c165e8cc618ccb7952982216221f481dabb283517b51f0a6d546.jsonl.gz | sub_412C42 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_412C42(_QWORD *a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6, __m128 a7, __m128 a8, __m128 a9, __m128 a10, __m128 a11, __m128 a12, __m128 a13, __m128 a14, int a15)
{
__int64 v15; // rcx
int v16; // eax
__int64 result; // rax
char v18; // [rsp+0h] [rbp-50h]
int v19; // [rsp+4h] [rbp-4Ch]
__int64 v21; // [rsp+10h] [rbp-40h]
signed int v23; // [rsp+34h] [rbp-1Ch]
unsigned int v24; // [rsp+38h] [rbp-18h]
int v25; // [rsp+3Ch] [rbp-14h]
int j; // [rsp+40h] [rbp-10h]
int v27; // [rsp+40h] [rbp-10h]
int v28; // [rsp+40h] [rbp-10h]
int v29; // [rsp+44h] [rbp-Ch]
int v30; // [rsp+48h] [rbp-8h]
int i; // [rsp+4Ch] [rbp-4h]
v21 = a4;
v19 = a6;
if ( a15 )
sub_412277(a1, "\tcs:Z:", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v18);
v29 = 0;
v30 = 0;
for ( i = 0; i < *(_DWORD *)(*(_QWORD *)(v21 + 72) + 20LL); ++i )
{
v24 = *(_DWORD *)(*(_QWORD *)(v21 + 72) + 4LL * i + 24) & 0xF;
v23 = *(_DWORD *)(*(_QWORD *)(v21 + 72) + 4LL * i + 24) >> 4;
if ( v24 > 3 && v24 != 7 && v24 != 8 )
__assert_fail(
"(op >= MM_CIGAR_MATCH && op <= MM_CIGAR_N_SKIP) || op == MM_CIGAR_EQ_MATCH || op == MM_CIGAR_X_MISMATCH",
"format.c",
0x93u,
"write_cs_core");
switch ( v24 )
{
case 0u:
case 7u:
case 8u:
v25 = 0;
for ( j = 0; j < v23; ++j )
{
v15 = v29 + j;
if ( *(_BYTE *)(v30 + j + a3) == *(_BYTE *)(v15 + a2) )
{
a4 = *(unsigned __int8 *)(v30 + j + a3);
v16 = v25++;
*(_BYTE *)(a5 + v16) = byte_4693C7[a4];
}
else
{
if ( v25 > 0 )
{
if ( v19 )
{
sub_412277(a1, ":%d", (unsigned int)v25, v15, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v18);
}
else
{
*(_BYTE *)(v25 + a5) = 0;
sub_412277(a1, "=%s", a5, v15, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v18);
}
v25 = 0;
}
sub_412277(
a1,
"*%c%c",
(unsigned int)byte_4693C1[*(unsigned __int8 *)(v29 + j + a2)],
(unsigned int)byte_4693C1[*(unsigned __int8 *)(v30 + j + a3)],
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v18);
}
}
if ( v25 > 0 )
{
if ( v19 )
{
sub_412277(a1, ":%d", (unsigned int)v25, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v18);
}
else
{
*(_BYTE *)(v25 + a5) = 0;
sub_412277(a1, "=%s", a5, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v18);
}
}
v30 += v23;
v29 += v23;
break;
case 1u:
v27 = 0;
*(_BYTE *)(v23 + a5) = 0;
while ( v27 < v23 )
{
a4 = v27;
*(_BYTE *)(v27 + a5) = byte_4693C1[*(unsigned __int8 *)(v30 + v27 + a3)];
++v27;
}
sub_412277(a1, "+%s", a5, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v18);
v30 += v23;
break;
case 2u:
v28 = 0;
*(_BYTE *)(v23 + a5) = 0;
while ( v28 < v23 )
{
a4 = v28;
*(_BYTE *)(v28 + a5) = byte_4693C1[*(unsigned __int8 *)(v29 + v28 + a2)];
++v28;
}
sub_412277(a1, "-%s", a5, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v18);
v29 += v23;
break;
default:
if ( *(_DWORD *)(*(_QWORD *)(v21 + 72) + 4LL * i + 24) >> 4 <= 1u )
__assert_fail("len >= 2", "format.c", 0xB4u, "write_cs_core");
sub_412277(
a1,
"~%c%c%d%c%c",
(unsigned int)byte_4693C1[*(unsigned __int8 *)(v29 + a2)],
(unsigned int)byte_4693C1[*(unsigned __int8 *)(v29 + 1LL + a2)],
(unsigned int)v23,
(unsigned int)byte_4693C1[*(unsigned __int8 *)(v29 + v23 - 2LL + a2)],
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
byte_4693C1[*(unsigned __int8 *)(v29 + v23 - 1LL + a2)]);
v29 += v23;
break;
}
}
if ( v29 != *(_DWORD *)(v21 + 28) - *(_DWORD *)(v21 + 24)
|| (result = (unsigned int)(*(_DWORD *)(v21 + 20) - *(_DWORD *)(v21 + 16)), v30 != (_DWORD)result) )
{
__assert_fail("t_off == r->re - r->rs && q_off == r->qe - r->qs", "format.c", 0xBAu, "write_cs_core");
}
return result;
}
Q:[a3,a4,a1,a2,a5,a6,a15,v15,v23,v24,v25,v27,v29,v30,sub_412C42,sub_412277,] | A:{'a3': 'qseq', 'a4': 'r', 'a1': 's', 'a2': 'tseq', 'a5': 'tmp', 'a6': 'no_iden', 'a15': 'write_tag', 'v15': 'r', 'v23': 'len', 'v24': 'op', 'v25': 'l_tmp', 'v27': 'jb', 'v29': 't_off', 'v30': 'q_off', 'sub_412C42': 'write_cs_core', 'sub_412277': 'mm_sprintf_lite'} | |
4f8c8d6eef1a0ea5e70639aa44b92fa135cebb474351f1852f2fe65e054afcc8_4f8c8d6eef1a0ea5e70639aa44b92fa135cebb474351f1852f2fe65e054afcc8.jsonl.gz | sub_403E70 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_403E70()
{
__int64 result; // rax
int v1; // [rsp+1Ch] [rbp-4h]
v1 = hci_send_cmd();
if ( v1 >= 0 )
result = hci_read_bd_addr();
else
result = (unsigned int)v1;
return result;
}
Q:[v1,sub_403E70,] | A:{'v1': 'err', 'sub_403E70': 'generic_reset_device_0'} | |
866119e843c576da0d5be4aee49bcdefb830f4174c180740ed9987c1f137b153_866119e843c576da0d5be4aee49bcdefb830f4174c180740ed9987c1f137b153.jsonl.gz | sub_40C354 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40C354(__int64 a1)
{
return a1 + 4;
}
Q:[a1,sub_40C354,] | A:{'a1': 'rta', 'sub_40C354': 'rta_getattr_str'} | |
cc514aea46329b2bbe7d1ede9a05315966bd71bcf8cc0ff6e5ffa267e88c9796_cc514aea46329b2bbe7d1ede9a05315966bd71bcf8cc0ff6e5ffa267e88c9796.jsonl.gz | sub_402C63 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_402C63(__int64 a1)
{
return sub_402B95((unsigned int *)(a1 + 16));
}
Q:[a1,sub_402C63,sub_402B95,] | A:{'a1': 'S', 'sub_402C63': 'CS_GetEntryCount_0', 'sub_402B95': 'CollCount_0'} | |
b863f2cdae93922c3e2f3e4973bbadaab5158f9e781ef05c4ebd8ea998b16a19_b863f2cdae93922c3e2f3e4973bbadaab5158f9e781ef05c4ebd8ea998b16a19.jsonl.gz | sub_404D05 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_404D05(const char **a1)
{
while ( *a1 )
{
fputs(*a1++, stderr);
if ( *a1 )
fwrite(", ", 1uLL, 2uLL, stderr);
}
return fputc(10, stderr);
}
Q:[a1,sub_404D05,] | A:{'a1': 'list', 'sub_404D05': 'print_section_list'} | |
ca91fa92c27881dc5c0e1c75f3f2a37ed7dcfcf1edf640b0b267a80581c2f894_ca91fa92c27881dc5c0e1c75f3f2a37ed7dcfcf1edf640b0b267a80581c2f894.jsonl.gz | sub_40900F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40900F(__int64 a1, int a2, int a3)
{
return sub_408CF4(a1, a2, a3, 67);
}
Q:[a3,a1,a2,sub_40900F,sub_408CF4,] | A:{'a3': 'iField', 'a1': 'psDBF', 'a2': 'iRecord', 'sub_40900F': 'DBFReadStringAttribute', 'sub_408CF4': 'DBFReadAttribute'} | |
76aa827f32bff6cc733db94b888eadbc456526a784c5cdeeea2d4d2ed06b95b1_76aa827f32bff6cc733db94b888eadbc456526a784c5cdeeea2d4d2ed06b95b1.jsonl.gz | sub_415A32 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 __fastcall sub_415A32(__int64 a1)
{
_BOOL8 result; // rax
int v2; // [rsp+1Ch] [rbp-4h]
v2 = sub_41F7F3(*(_QWORD *)(a1 + 56)) - 1;
if ( v2 <= 2499 && v2 >= 0 && qword_505000[v2] )
result = *(_DWORD *)(qword_505000[v2] + 4) >= *(_DWORD *)(qword_505000[v2] + 8);
else
result = 0LL;
return result;
}
Q:[a1,v2,sub_415A32,sub_41F7F3,] | A:{'a1': 'n', 'v2': 'whichq', 'sub_415A32': 'qfull', 'sub_41F7F3': 'eval'} | |
7a877c440eef374fefd8be6bb667526fd0352c0cdbbca724c8216f482d765f31_7a877c440eef374fefd8be6bb667526fd0352c0cdbbca724c8216f482d765f31.jsonl.gz | sub_403EFE | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_403EFE(void **a1)
{
sub_40126F(a1[1]);
sub_40126F(a1);
}
Q:[a1,sub_403EFE,sub_40126F,] | A:{'a1': 'list', 'sub_403EFE': 'ts_list_free', 'sub_40126F': 'ts_free'} | |
2e7195e6bc11902cb1147d429b22ff6f7655de6050b37429b5d7074aaa0727e8_2e7195e6bc11902cb1147d429b22ff6f7655de6050b37429b5d7074aaa0727e8.jsonl.gz | sub_418BA1 | Help user generate meaningful names for variables and functions in the following code snippet. |
_QWORD *__fastcall sub_418BA1(_QWORD *a1, __int64 a2)
{
_QWORD *result; // rax
_QWORD *v3; // [rsp+10h] [rbp-20h] BYREF
void **v4; // [rsp+18h] [rbp-18h]
void *ptr; // [rsp+20h] [rbp-10h]
char v6; // [rsp+2Fh] [rbp-1h]
v6 = *(_BYTE *)(a2 + 1);
v3 = 0LL;
v4 = (void **)&v3;
ptr = (void *)sub_422FD7("type", *(_QWORD *)(a2 + 120));
*((_QWORD *)ptr + 520) = 0LL;
*v4 = ptr;
v4 = (void **)((char *)ptr + 4160);
if ( *(_DWORD *)(a2 + 136) != -1 )
{
ptr = (void *)sub_423048("dxfId", *(unsigned int *)(a2 + 136));
*((_QWORD *)ptr + 520) = 0LL;
*v4 = ptr;
v4 = (void **)((char *)ptr + 4160);
}
ptr = (void *)sub_423048("priority", *(unsigned int *)(a2 + 140));
*((_QWORD *)ptr + 520) = 0LL;
*v4 = ptr;
v4 = (void **)((char *)ptr + 4160);
if ( *(_BYTE *)(a2 + 115) )
{
ptr = (void *)sub_423048("stopIfTrue", 1LL);
*((_QWORD *)ptr + 520) = 0LL;
*v4 = ptr;
v4 = (void **)((char *)ptr + 4160);
}
if ( v6 == 24 || v6 == 26 || v6 == 28 || v6 == 30 || v6 == 32 )
{
ptr = (void *)sub_423048("aboveAverage", 0LL);
*((_QWORD *)ptr + 520) = 0LL;
*v4 = ptr;
v4 = (void **)((char *)ptr + 4160);
}
if ( v6 == 25 || v6 == 26 )
{
ptr = (void *)sub_423048("equalAverage", 1LL);
*((_QWORD *)ptr + 520) = 0LL;
*v4 = ptr;
v4 = (void **)((char *)ptr + 4160);
}
if ( v6 == 27 || v6 == 28 )
{
ptr = (void *)sub_423048("stdDev", 1LL);
*((_QWORD *)ptr + 520) = 0LL;
*v4 = ptr;
v4 = (void **)((char *)ptr + 4160);
}
if ( v6 == 29 || v6 == 30 )
{
ptr = (void *)sub_423048("stdDev", 2LL);
*((_QWORD *)ptr + 520) = 0LL;
*v4 = ptr;
v4 = (void **)((char *)ptr + 4160);
}
if ( v6 == 31 || v6 == 32 )
{
ptr = (void *)sub_423048("stdDev", 3LL);
*((_QWORD *)ptr + 520) = 0LL;
*v4 = ptr;
v4 = (void **)((char *)ptr + 4160);
}
sub_4227C2(*a1, "cfRule", &v3);
while ( 1 )
{
result = v3;
if ( !v3 )
break;
ptr = v3;
v3 = (_QWORD *)v3[520];
if ( !v3 )
v4 = (void **)&v3;
free(ptr);
}
return result;
}
Q:[a1,a2,v3,ptr,v6,sub_418BA1,sub_422FD7,sub_423048,sub_4227C2,] | A:{'a1': 'self', 'a2': 'cond_format', 'v3': 'attributes', 'ptr': 'attribute', 'v6': 'criteria', 'sub_418BA1': '_worksheet_write_cf_rule_average', 'sub_422FD7': 'lxw_new_attribute_str', 'sub_423048': 'lxw_new_attribute_int', 'sub_4227C2': 'lxw_xml_empty_tag'} | |
e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6_e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6.jsonl.gz | sub_4713CA | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4713CA(int a1)
{
__int64 result; // rax
switch ( a1 )
{
case 1:
result = 7LL;
break;
case 2:
result = 2LL;
break;
case 3:
result = 3LL;
break;
case 4:
result = 4LL;
break;
case 5:
result = 6LL;
break;
default:
result = 0LL;
break;
}
return result;
}
Q:[a1,sub_4713CA,] | A:{'a1': 'speed', 'sub_4713CA': 'convertFan'} | |
d8bd0fa60e206d9711442506ad8361abe329eebf701c11022d691c8f25f86b04_d8bd0fa60e206d9711442506ad8361abe329eebf701c11022d691c8f25f86b04.jsonl.gz | sub_40C3AB | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40C3AB(__int64 a1, __int64 a2, __int64 a3)
{
char v5[112]; // [rsp+20h] [rbp-70h] BYREF
sub_40B49C((__int64)v5);
sub_40C401(v5, a2, a3);
return sub_40C484(v5, a1);
}
Q:[a3,a1,a2,v5,sub_40C3AB,sub_40B49C,sub_40C401,sub_40C484,] | A:{'a3': 'size', 'a1': 'buf', 'a2': 'data', 'v5': 'hash', 'sub_40C3AB': 'sha256_hash', 'sub_40B49C': 'sha256_init', 'sub_40C401': 'sha256_update', 'sub_40C484': 'sha256_final'} | |
4d27d00763c053c6863afd9e1d4030266d5af6d886cf33c8ebc38a0747faf190_4d27d00763c053c6863afd9e1d4030266d5af6d886cf33c8ebc38a0747faf190.jsonl.gz | sub_4093EB | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4093EB(_BYTE *a1)
{
sub_4013C7(a1, 101);
return sub_4013E1((__int64)a1, 1u);
}
Q:[a1,sub_4093EB,sub_4013C7,sub_4013E1,] | A:{'a1': 'p_desc', 'sub_4093EB': 'desc65_init', 'sub_4013C7': 'desc_set_tag', 'sub_4013E1': 'desc_set_length'} | |
403e45776a19c0209e3689b016225e7306b8335a7a28b6f650372addb3f128a1_403e45776a19c0209e3689b016225e7306b8335a7a28b6f650372addb3f128a1.jsonl.gz | sub_4017B7 | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_4017B7()
{
;
}
Q:[sub_4017B7,] | A:{'sub_4017B7': 'ble_evt_system_no_license_key'} | |
8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2_8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2.jsonl.gz | sub_46FB30 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_46FB30(__int64 *a1)
{
char v2; // [rsp+1Fh] [rbp-1h] BYREF
sub_46FAE0(a1, (__int64)&v2, 1LL);
return (unsigned int)v2;
}
Q:[a1,v2,sub_46FB30,sub_46FAE0,] | A:{'a1': 'S', 'v2': 'x', 'sub_46FB30': 'LoadChar', 'sub_46FAE0': 'LoadBlock'} | |
e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6_e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6.jsonl.gz | sub_42E272 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42E272(__int64 a1, _BYTE *a2)
{
unsigned __int8 v2; // al
char v4[32]; // [rsp+20h] [rbp-2A0h] BYREF
char v5[47]; // [rsp+40h] [rbp-280h] BYREF
char v6[32]; // [rsp+70h] [rbp-250h] BYREF
char v7[32]; // [rsp+90h] [rbp-230h] BYREF
char v8[32]; // [rsp+B0h] [rbp-210h] BYREF
char v9[32]; // [rsp+D0h] [rbp-1F0h] BYREF
char v10[47]; // [rsp+F0h] [rbp-1D0h] BYREF
char v11[32]; // [rsp+120h] [rbp-1A0h] BYREF
char v12[47]; // [rsp+140h] [rbp-180h] BYREF
char v13[32]; // [rsp+170h] [rbp-150h] BYREF
char v14[47]; // [rsp+190h] [rbp-130h] BYREF
char v15[32]; // [rsp+1C0h] [rbp-100h] BYREF
char v16[47]; // [rsp+1E0h] [rbp-E0h] BYREF
char v17[32]; // [rsp+210h] [rbp-B0h] BYREF
char v18[47]; // [rsp+230h] [rbp-90h] BYREF
char v19[32]; // [rsp+260h] [rbp-60h] BYREF
char v20[47]; // [rsp+280h] [rbp-40h] BYREF
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
std::allocator<char>::~allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::reserve();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v4, (a2[110125] & 1) != 0, (__int64)v5, 0);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
sub_4055CE((__int64)v6, (a2[110125] >> 4) & 7);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
sub_405349((__int64)v7, a2[110126] >> 1, 1LL, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
v2 = sub_42DD7C((__int64)a2);
sub_405B4E((__int64)v8, v2);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v9, (a2[110128] & 0xF) != 0, (__int64)v10, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v11, (a2[110133] & 1) != 0, (__int64)v12, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v13, (a2[110133] & 0x20) != 0, (__int64)v14, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v15, (a2[110136] & 4) != 0, (__int64)v16, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v17, (a2[110136] & 8) != 0, (__int64)v18, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v19, (a2[110136] & 2) != 0, (__int64)v20, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
return a1;
}
Q:[a1,a2,sub_42E272,sub_403E56,sub_4055CE,sub_405349,sub_42DD7C,sub_405B4E,] | A:{'a1': 'retstr', 'a2': 'this', 'sub_42E272': 'toString', 'sub_403E56': 'addBoolToString', 'sub_4055CE': 'addModeToString', 'sub_405349': 'addTempToString', 'sub_42DD7C': 'getFan', 'sub_405B4E': 'addFanToString'} | |
fa8b432a1eb1b00555c0e7b055c457c432b632eaf8c86f41f0c39ee10a3fbd03_fa8b432a1eb1b00555c0e7b055c457c432b632eaf8c86f41f0c39ee10a3fbd03.jsonl.gz | sub_40A24E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40A24E(__int64 a1)
{
__int64 result; // rax
if ( (unsigned __int8)sub_409F3D(a1) == 13 )
result = 3LL;
else
result = 0LL;
return result;
}
Q:[a1,sub_40A24E,sub_409F3D,] | A:{'a1': 'p_desc', 'sub_40A24E': 'desc4a_get_event_length', 'sub_409F3D': 'desc4a_get_linkage'} | |
afbc915f426c094251076b359394b2f319370d1b13f49ecddb3e0e7ac8910e84_afbc915f426c094251076b359394b2f319370d1b13f49ecddb3e0e7ac8910e84.jsonl.gz | sub_4143FE | Help user generate meaningful names for variables and functions in the following code snippet. |
_BYTE *__fastcall sub_4143FE(__int64 a1, __int64 a2, __int16 a3)
{
*(_QWORD *)(a1 + 16) = a2;
*(_WORD *)(a1 + 10) = a3;
return sub_4143B1(a1);
}
Q:[a3,a1,a2,sub_4143FE,sub_4143B1,] | A:{'a3': 'width', 'a1': 'b', 'a2': 'buf', 'sub_4143FE': 'u8g_pb32h1_Init', 'sub_4143B1': 'u8g_pb32h1_Clear'} | |
251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651_251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651.jsonl.gz | sub_40D7DE | Help user generate meaningful names for variables and functions in the following code snippet. |
_QWORD *__fastcall sub_40D7DE(_QWORD *a1)
{
++*a1;
return a1;
}
Q:[a1,sub_40D7DE,] | A:{'a1': 'this', 'sub_40D7DE': 'operator++'} | |
e5ee0203e1b19b8999a5a0fc3546f2fbd5543cbefd2ec1cd7236ad2356113f8c_e5ee0203e1b19b8999a5a0fc3546f2fbd5543cbefd2ec1cd7236ad2356113f8c.jsonl.gz | sub_4072EC | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4072EC(__int64 a1, int a2, unsigned int a3, __int64 a4, _DWORD *a5)
{
const char *v5; // rdx
__int64 result; // rax
int v10; // [rsp+2Ch] [rbp-54h] BYREF
void *v11; // [rsp+30h] [rbp-50h]
__int64 v12; // [rsp+38h] [rbp-48h]
__int64 v13; // [rsp+40h] [rbp-40h]
int j; // [rsp+4Ch] [rbp-34h]
int i; // [rsp+50h] [rbp-30h]
int k; // [rsp+54h] [rbp-2Ch]
int v17; // [rsp+58h] [rbp-28h]
int v18; // [rsp+5Ch] [rbp-24h]
void *v19; // [rsp+60h] [rbp-20h]
__int64 v20; // [rsp+68h] [rbp-18h]
void *ptr; // [rsp+70h] [rbp-10h]
__int64 v22; // [rsp+78h] [rbp-8h]
v22 = a4;
ptr = 0LL;
v20 = 0LL;
v19 = 0LL;
v18 = 0;
v17 = 0;
while ( v22 && !strcmp(*(const char **)(v22 + 8), *(const char **)(a4 + 8)) )
{
v13 = *(_QWORD *)(v22 + 16);
v12 = *(_QWORD *)(v13 + 32);
if ( (unsigned int)sub_40761D(a1 + 8, (unsigned int)(a2 - 1), v12 + 12, *(unsigned int *)(v12 + 48)) )
{
v11 = 0LL;
v10 = 0;
v11 = (void *)sub_407D69(a1 + 8, (unsigned int)(a2 - 1), a3, v13, v12, &v10);
if ( v10 )
{
++v18;
if ( ptr )
ptr = realloc(ptr, 8LL * v18);
else
ptr = malloc(8uLL);
if ( v19 )
v19 = realloc(v19, 4LL * v18);
else
v19 = malloc(4uLL);
*((_QWORD *)ptr + v18 - 1) = v11;
*((_DWORD *)v19 + v18 - 1) = v10;
}
else
{
free(v11);
}
}
v22 = *(_QWORD *)(v22 + 24);
}
if ( ptr && v18 )
{
v20 = *(_QWORD *)ptr;
v17 = *(_DWORD *)v19;
for ( i = 0; i < v18; ++i )
{
if ( v17 > *((_DWORD *)v19 + i) )
{
v20 = *((_QWORD *)ptr + i);
v17 = *((_DWORD *)v19 + i);
}
}
for ( j = 0; j < v18; ++j )
{
if ( v20 != *((_QWORD *)ptr + j) )
free(*((void **)ptr + j));
}
free(ptr);
free(v19);
*a5 = v17;
result = v20;
}
else
{
printf("Error encoding ");
for ( k = 0; k < a2; ++k )
{
if ( a2 == k + 1 )
v5 = "\n";
else
v5 = " ";
printf("%s%s", *(const char **)(8LL * k + a1), v5);
}
result = 0LL;
}
return result;
}
Q:[a3,a4,a1,a2,a5,v10,v11,v12,v13,j,i,v17,v18,v19,v20,ptr,v22,sub_4072EC,sub_40761D,sub_407D69,] | A:{'a3': 'mode', 'a4': 'instr_head', 'a1': 'tokens', 'a2': 'num_tokens', 'a5': 'len', 'v10': 'narr_0', 'v11': 'barr_0', 'v12': 'e', 'v13': 'node', 'j': 'i_1', 'i': 'i_0', 'v17': 'narr', 'v18': 'nenc', 'v19': 'nsize', 'v20': 'barr', 'ptr': 'enc', 'v22': 'cur', 'sub_4072EC': 'x86_assemble', 'sub_40761D': 'x86_classify_operand', 'sub_407D69': 'x86_encode'} | |
5184c2b77d38653561b9feb1ac4655a09710ae7a47128c1e2e0af437220e8cde_5184c2b77d38653561b9feb1ac4655a09710ae7a47128c1e2e0af437220e8cde.jsonl.gz | sub_403D23 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_403D23(__int64 a1, __int64 a2)
{
return sub_403CBE(a1, a2, "\r%zu/%zu frames loaded");
}
Q:[a1,a2,sub_403D23,sub_403CBE,] | A:{'a1': 'current', 'a2': 'total', 'sub_403D23': 'load_progress_cb', 'sub_403CBE': 'generic_progress_cb'} | |
ae353ff1d6b132e8bc266655cc0acee2a7cfbd29790838b22e9e2a3256b7a8f8_ae353ff1d6b132e8bc266655cc0acee2a7cfbd29790838b22e9e2a3256b7a8f8.jsonl.gz | sub_46595F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_46595F(unsigned __int8 *a1)
{
int i; // [rsp+14h] [rbp-4h]
for ( i = 0; off_4E90C0[3 * i]; ++i )
{
if ( !(unsigned int)sub_4658D6((unsigned __int8 *)off_4E90C0[3 * i], a1) )
return dword_4E90D0[6 * i];
}
return 0xFFFFFFFFLL;
}
Q:[a1,sub_46595F,sub_4658D6,] | A:{'a1': 'name', 'sub_46595F': 'pcap_datalink_name_to_val', 'sub_4658D6': 'pcap_strcasecmp'} | |
7c16ecc1f4177280f9c554334c74c60179f6cbd74ce0674df9f0cc7c89723807_7c16ecc1f4177280f9c554334c74c60179f6cbd74ce0674df9f0cc7c89723807.jsonl.gz | sub_427C94 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_427C94(__int64 a1, __m128i a2)
{
__m128i v2; // xmm0
if ( (int)be_top(a1) > 0 && be_isnumber(a1, 1u) )
{
a2.m128i_u64[0] = (unsigned __int64)be_toreal(a1, 1u);
v2 = _mm_cvtsi32_si128(_mm_cvtsi128_si32(a2));
*(float *)v2.m128i_i32 = tanhf(*(float *)v2.m128i_i32);
be_pushreal(a1, COERCE_FLOAT(_mm_cvtsi128_si32(v2)));
}
else
{
be_pushreal(a1, 0.0);
}
return be_returnvalue(a1);
}
Q:[a1,sub_427C94,] | A:{'a1': 'vm', 'sub_427C94': 'm_tanh'} | |
616268ddd6c2eb493b2c54efa19d29a7054ba3644d87315019eb9d0213d39602_616268ddd6c2eb493b2c54efa19d29a7054ba3644d87315019eb9d0213d39602.jsonl.gz | sub_406E03 | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_406E03()
{
qword_441AE8 = 0LL;
dword_441D74 = 1;
}
Q:[sub_406E03,] | A:{'sub_406E03': 'opNIL'} | |
1f521185abebe790038be8fb8b4eb165b2fd6d5af5b82a99f02d98f6827de627_1f521185abebe790038be8fb8b4eb165b2fd6d5af5b82a99f02d98f6827de627.jsonl.gz | sub_42DDD3 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42DDD3(__int64 *a1, unsigned int a2, __int64 *a3, __int64 a4, char a5)
{
__int64 v9; // [rsp+20h] [rbp-10h] BYREF
unsigned int v10; // [rsp+2Ch] [rbp-4h]
if ( a2 <= (unsigned int)sub_42DDA4((__int64)a1) )
{
v10 = sub_425A98(*a1, a2, &v9, a5);
if ( !v10 )
{
*a3 = sub_42DC7D(v9, a2, (__int64)a1);
if ( *(_BYTE *)*a3 || (v10 = sub_42D6C5(*a3)) == 0 )
{
if ( !a4 || *(_WORD *)(*a3 + 18) && *(_BYTE *)(*a3 + 2) == *(_BYTE *)(a4 + 97) )
return 0LL;
v10 = sub_4A66CA(56500LL);
sub_42DF1D(*a3);
}
else
{
sub_42DF1D(*a3);
}
}
}
else
{
v10 = sub_4A66CA(56479LL);
}
if ( a4 )
--*(_BYTE *)(a4 + 96);
return v10;
}
Q:[a3,a4,a1,a2,a5,v9,v10,sub_42DDD3,sub_42DDA4,sub_425A98,sub_42DC7D,sub_42D6C5,sub_4A66CA,sub_42DF1D,] | A:{'a3': 'ppPage', 'a4': 'pCur', 'a1': 'pBt', 'a2': 'pgno', 'a5': 'bReadOnly', 'v9': 'pDbPage', 'v10': 'rc', 'sub_42DDD3': 'getAndInitPage', 'sub_42DDA4': 'btreePagecount', 'sub_425A98': 'sqlite3PagerAcquire', 'sub_42DC7D': 'btreePageFromDbPage', 'sub_42D6C5': 'btreeInitPage', 'sub_4A66CA': 'sqlite3CorruptError', 'sub_42DF1D': 'releasePage'} | |
53faff7486da2db257c0486a573e49eb3e70656a42b3e2ad40ce428af0925783_53faff7486da2db257c0486a573e49eb3e70656a42b3e2ad40ce428af0925783.jsonl.gz | sub_4041F7 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_4041F7()
{
__int64 v0; // rax
v0 = sub_467A09();
return sub_413962(v0);
}
Q:[sub_4041F7,sub_467A09,sub_413962,] | A:{'sub_4041F7': 'lv_scr_act_27', 'sub_467A09': 'lv_disp_get_default', 'sub_413962': 'lv_disp_get_scr_act'} | |
fca9e3ca7ac0f7d833eae9680f76d609a4d08c36b8c5c76263a4932ef4032672_fca9e3ca7ac0f7d833eae9680f76d609a4d08c36b8c5c76263a4932ef4032672.jsonl.gz | sub_427F38 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_427F38(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
return sub_42A428(a1, a2, a3, a4);
}
Q:[a3,a4,a1,a2,sub_427F38,sub_42A428,] | A:{'a3': '__result', 'a4': '__alloc', 'a1': '__first', 'a2': '__last', 'sub_427F38': 'allocator', 'sub_42A428': '__uninitialized_copy_a'} | |
251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651_251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651.jsonl.gz | sub_426ACC | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_426ACC(__int64 a1)
{
__int64 v2; // [rsp+18h] [rbp-8h]
v2 = sub_42AAA2(a1);
return sub_42AABC(v2);
}
Q:[a1,v2,sub_426ACC,sub_42AAA2,sub_42AABC,] | A:{'a1': '__source', 'v2': '__f', 'sub_426ACC': '_M_get_pointer', 'sub_42AAA2': 'lambda', 'sub_42AABC': 'lambda'} | |
e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6_e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6.jsonl.gz | sub_41D29C | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41D29C(__int64 a1, __int64 a2)
{
unsigned __int16 v2; // ax
unsigned __int8 v3; // al
char v4; // bl
char v5; // bl
unsigned __int16 v6; // ax
char v7; // bl
unsigned __int16 v8; // ax
char v10[32]; // [rsp+20h] [rbp-3A0h] BYREF
char v11[32]; // [rsp+40h] [rbp-380h] BYREF
char v12[47]; // [rsp+60h] [rbp-360h] BYREF
char v13[32]; // [rsp+90h] [rbp-330h] BYREF
char v14[47]; // [rsp+B0h] [rbp-310h] BYREF
char v15[32]; // [rsp+E0h] [rbp-2E0h] BYREF
char v16[32]; // [rsp+100h] [rbp-2C0h] BYREF
char v17[32]; // [rsp+120h] [rbp-2A0h] BYREF
char v18[32]; // [rsp+140h] [rbp-280h] BYREF
char v19[47]; // [rsp+160h] [rbp-260h] BYREF
char v20[32]; // [rsp+190h] [rbp-230h] BYREF
char v21[47]; // [rsp+1B0h] [rbp-210h] BYREF
char v22[32]; // [rsp+1E0h] [rbp-1E0h] BYREF
char v23[47]; // [rsp+200h] [rbp-1C0h] BYREF
char v24[32]; // [rsp+230h] [rbp-190h] BYREF
char v25[47]; // [rsp+250h] [rbp-170h] BYREF
char v26[47]; // [rsp+280h] [rbp-140h] BYREF
char v27[32]; // [rsp+2B0h] [rbp-110h] BYREF
char v28[47]; // [rsp+2D0h] [rbp-F0h] BYREF
char v29[47]; // [rsp+300h] [rbp-C0h] BYREF
char v30[32]; // [rsp+330h] [rbp-90h] BYREF
char v31[47]; // [rsp+350h] [rbp-70h] BYREF
char v32[47]; // [rsp+380h] [rbp-40h] BYREF
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
std::allocator<char>::~allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::reserve();
v2 = sub_41C850(a2);
sub_40513C((__int64)v10, 41LL, v2, 0);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v11, (*(_BYTE *)(a2 + 110131) & 0x20) != 0, (__int64)v12, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v13, (*(_BYTE *)(a2 + 110131) & 0x10) != 0, (__int64)v14, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
sub_4055CE((__int64)v15, *(_BYTE *)(a2 + 110125) >> 4);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
v3 = sub_41CAB6(a2);
sub_405349((__int64)v16, v3, 1LL, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
sub_405B4E((__int64)v17, *(_BYTE *)(a2 + 110125) & 0xF);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v18, (*(_BYTE *)(a2 + 110131) & 1) != 0, (__int64)v19, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v20, (*(_BYTE *)(a2 + 110131) & 0x40) != 0, (__int64)v21, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_403E56((__int64)v22, *(char *)(a2 + 110131) < 0, (__int64)v23, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
v4 = 0;
if ( (*(_BYTE *)(a2 + 110131) & 0xE) != 0 )
{
sub_402545((__int64)v26, (*(_BYTE *)(a2 + 110131) >> 1) & 7, 0xAu);
}
else
{
std::allocator<char>::allocator();
v4 = 1;
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
}
sub_403D35((__int64)v24, (__int64)v26, (__int64)v25, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
if ( v4 )
std::allocator<char>::~allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
v5 = 0;
if ( (unsigned __int16)sub_41CE92(a2) )
{
v6 = sub_41CE92(a2);
sub_4071A8((__int64)v29, v6);
}
else
{
std::allocator<char>::allocator();
v5 = 1;
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
}
sub_403D35((__int64)v27, (__int64)v29, (__int64)v28, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
if ( v5 )
std::allocator<char>::~allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
v7 = 0;
if ( (unsigned __int16)sub_41CF20(a2) )
{
v8 = sub_41CF20(a2);
sub_4071A8((__int64)v32, v8);
}
else
{
std::allocator<char>::allocator();
v7 = 1;
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
}
sub_403D35((__int64)v30, (__int64)v32, (__int64)v31, 1);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
if ( v7 )
std::allocator<char>::~allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
return a1;
}
Q:[a1,a2,sub_41D29C,sub_41C850,sub_40513C,sub_403E56,sub_4055CE,sub_41CAB6,sub_405349,sub_405B4E,sub_402545,sub_403D35,sub_41CE92,sub_4071A8,sub_41CF20,] | A:{'a1': 'retstr', 'a2': 'this', 'sub_41D29C': 'toString', 'sub_41C850': 'getModel', 'sub_40513C': 'addModelToString', 'sub_403E56': 'addBoolToString', 'sub_4055CE': 'addModeToString', 'sub_41CAB6': 'getTemp', 'sub_405349': 'addTempToString', 'sub_405B4E': 'addFanToString', 'sub_402545': 'uint64ToString', 'sub_403D35': 'addLabeledString', 'sub_41CE92': 'getOnTimer', 'sub_4071A8': 'minsToString', 'sub_41CF20': 'getOffTimer'} | |
ea0508ee09ef8e2db8df2c25d1ba40a3b48502a5e26703b6381588af1721319c_ea0508ee09ef8e2db8df2c25d1ba40a3b48502a5e26703b6381588af1721319c.jsonl.gz | sub_4072E0 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 __fastcall sub_4072E0(__int64 a1, __int64 a2)
{
return sub_4069D0(a1, a2, 5u);
}
Q:[sub_4072E0,sub_4069D0,] | A:{'sub_4072E0': 'log_suite_end', 'sub_4069D0': 'srunner_send_evt'} | |
6fd1fd6b811014087ab068b5dde4a7c86fc54e8e790d85b5135cc35bc9885aab_6fd1fd6b811014087ab068b5dde4a7c86fc54e8e790d85b5135cc35bc9885aab.jsonl.gz | sub_422B8A | Help user generate meaningful names for variables and functions in the following code snippet. |
int sub_422B8A()
{
mark_point("check_check_fixture.c", 166LL);
return raise(8);
}
Q:[sub_422B8A,] | A:{'sub_422B8A': 'teardown_sub_signal'} | |
b714b50430dc155167fb13379f4e00d79d775ccac764ece9ad5d0d56db016e15_b714b50430dc155167fb13379f4e00d79d775ccac764ece9ad5d0d56db016e15.jsonl.gz | sub_46C134 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_46C134(__int64 a1, __int64 a2, _QWORD *a3, __int64 a4, __int64 a5, __int64 a6)
{
char *endptr; // [rsp+28h] [rbp-18h] BYREF
__int64 v9; // [rsp+30h] [rbp-10h]
int v10; // [rsp+3Ch] [rbp-4h]
v10 = 0;
v9 = a1;
if ( *(_BYTE *)a2 == 102 && *(_BYTE *)(a2 + 1) == 105 && *(_BYTE *)(a2 + 2) == 108 && *(_BYTE *)(a2 + 3) == 101 )
{
v10 = strtoul((const char *)(a2 + 4), &endptr, 10);
if ( (char *)(a2 + 4) == endptr || *endptr )
goto LABEL_16;
}
else
{
if ( *(_BYTE *)a2 != 115 || *(_BYTE *)(a2 + 1) != 116 || *(_BYTE *)(a2 + 2) != 100 )
goto LABEL_16;
if ( !strcmp((const char *)(a2 + 3), "in") )
{
v10 = 0;
}
else if ( !strcmp((const char *)(a2 + 3), "out") )
{
v10 = 1;
}
else
{
if ( strcmp((const char *)(a2 + 3), "err") )
{
LABEL_16:
sub_462AC3(a1, (__int64)"bad file identifier \"", a2, (__int64)"\"", 0LL, a6);
return 1LL;
}
v10 = 2;
}
}
if ( v10 >= *(_DWORD *)(v9 + 296) )
{
if ( *(_DWORD *)(v9 + 296) || v10 > 2 )
goto LABEL_21;
sub_46BE61(v9, v10);
}
if ( !*(_QWORD *)(*(_QWORD *)(v9 + 304) + 8LL * v10) )
{
LABEL_21:
sub_462AC3(a1, (__int64)"file \"", a2, (__int64)"\" isn't open", 0LL, a6);
return 1LL;
}
*a3 = *(_QWORD *)(*(_QWORD *)(v9 + 304) + 8LL * v10);
return 0LL;
}
Q:[a3,a1,a2,endptr,v9,v10,sub_46C134,sub_462AC3,sub_46BE61,] | A:{'a3': 'filePtrPtr', 'a1': 'interp', 'a2': 'string', 'endptr': 'end', 'v9': 'iPtr', 'v10': 'fd', 'sub_46C134': 'TclGetOpenFile', 'sub_462AC3': 'Tcl_AppendResult', 'sub_46BE61': 'TclMakeFileTable'} | |
3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353_3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353.jsonl.gz | sub_4AEE40 | Help user generate meaningful names for variables and functions in the following code snippet. |
float __fastcall sub_4AEE40(int a1, signed int a2, signed int a3, signed int a4, char a5, float a6, float a7)
{
float result; // xmm0_4
int v8; // eax
__m128i v9; // xmm3
float v10; // xmm0_4
__m128i v11; // xmm4
float v12; // xmm0_4
__m128 v13; // xmm0
__m128i v14; // xmm0
__m128i v15; // xmm0
float v16; // ebx
__m128i v17; // xmm0
__m128i v18; // xmm0
float v19; // ebx
__m128i v20; // xmm0
__m128i v21; // xmm0
__m128i v22; // xmm0
float v23; // ebx
__m128i v24; // xmm0
__m128i v25; // xmm0
__m128i v26; // xmm0
float v27; // ebx
__m128i v28; // xmm0
signed int v31; // [rsp+10h] [rbp-40h] BYREF
signed int v32; // [rsp+14h] [rbp-3Ch] BYREF
signed int v33; // [rsp+18h] [rbp-38h]
int v34; // [rsp+1Ch] [rbp-34h]
float v35; // [rsp+20h] [rbp-30h]
float v36; // [rsp+24h] [rbp-2Ch]
float v37; // [rsp+28h] [rbp-28h]
bool v38; // [rsp+2Fh] [rbp-21h]
int v39; // [rsp+30h] [rbp-20h]
float v40; // [rsp+34h] [rbp-1Ch]
float v41; // [rsp+38h] [rbp-18h]
float v42; // [rsp+3Ch] [rbp-14h]
v34 = a1;
v33 = a2;
v32 = a3;
v31 = a4;
if ( a3 == a4 )
return 0.0;
if ( v32 >= v31 )
v8 = sub_4A6DF1(v33, v31, v32);
else
v8 = sub_4A6DF1(v33, v32, v31);
v39 = v8;
if ( !a5 )
return (float)(v39 - v32) / (float)(v31 - v32);
v38 = v31 < v32;
if ( v31 < v32 )
sub_4B29EB(&v32, &v31);
v9 = 0LL;
*(float *)v9.m128i_i32 = (float)v32;
if ( a6 <= sub_483EDC(COERCE_FLOAT(_mm_cvtsi128_si32(v9))).m128_f32[0] )
{
v10 = (float)v32;
}
else if ( (float)v32 >= 0.0 )
{
v10 = a6;
}
else
{
v10 = -a6;
}
v42 = v10;
v11 = 0LL;
*(float *)v11.m128i_i32 = (float)v31;
if ( a6 <= sub_483EDC(COERCE_FLOAT(_mm_cvtsi128_si32(v11))).m128_f32[0] )
{
v12 = (float)v31;
}
else if ( (float)v31 >= 0.0 )
{
v12 = a6;
}
else
{
v12 = -a6;
}
v41 = v12;
if ( (float)v32 == 0.0 && (float)v31 < 0.0 )
{
v42 = -a6;
}
else if ( (float)v31 == 0.0 && (float)v32 < 0.0 )
{
v41 = -a6;
}
if ( v42 < (float)v39 )
{
if ( (float)v39 < v41 )
{
if ( (float)(v32 * v31) >= 0.0 )
{
if ( (float)v32 >= 0.0 && (float)v31 >= 0.0 )
{
v25 = 0LL;
*(float *)v25.m128i_i32 = (float)v39 / v42;
v26 = _mm_cvtsi32_si128(_mm_cvtsi128_si32(v25));
*(float *)v26.m128i_i32 = sub_483E9A(*(float *)v26.m128i_i32);
v27 = COERCE_FLOAT(_mm_cvtsi128_si32(v26));
v28 = (__m128i)LODWORD(v41);
*(float *)v28.m128i_i32 = v41 / v42;
v40 = v27 / sub_483E9A(COERCE_FLOAT(_mm_cvtsi128_si32(v28)));
}
else
{
v21 = 0LL;
*(float *)v21.m128i_i32 = (float)v39 / v41;
v22 = _mm_cvtsi32_si128(_mm_cvtsi128_si32(v21));
*(float *)v22.m128i_i32 = sub_483E9A(*(float *)v22.m128i_i32);
v23 = COERCE_FLOAT(_mm_cvtsi128_si32(v22));
v24 = (__m128i)LODWORD(v42);
*(float *)v24.m128i_i32 = v42 / v41;
v40 = 1.0 - (float)(v23 / sub_483E9A(COERCE_FLOAT(_mm_cvtsi128_si32(v24))));
}
}
else
{
v37 = (float)-(float)v32 / (float)((float)v31 - (float)v32);
v36 = v37 - a7;
v35 = v37 + a7;
if ( (float)v33 == 0.0 )
{
v40 = v37;
}
else
{
v13 = 0LL;
if ( (float)v33 >= 0.0 )
{
v13.m128_f32[0] = (float)v39 / a6;
v18 = _mm_cvtsi32_si128(_mm_cvtsi128_si32((__m128i)v13));
*(float *)v18.m128i_i32 = sub_483E9A(*(float *)v18.m128i_i32);
v19 = COERCE_FLOAT(_mm_cvtsi128_si32(v18));
v20 = (__m128i)LODWORD(v41);
*(float *)v20.m128i_i32 = v41 / a6;
*(float *)v20.m128i_i32 = sub_483E9A(COERCE_FLOAT(_mm_cvtsi128_si32(v20)));
v40 = (float)((float)(1.0 - v35) * (float)(v19 / *(float *)v20.m128i_i32)) + v35;
}
else
{
v13.m128_f32[0] = (float)v39;
v14 = (__m128i)_mm_xor_ps(v13, (__m128)0x80000000);
*(float *)v14.m128i_i32 = *(float *)v14.m128i_i32 / a6;
v15 = _mm_cvtsi32_si128(_mm_cvtsi128_si32(v14));
*(float *)v15.m128i_i32 = sub_483E9A(*(float *)v15.m128i_i32);
v16 = COERCE_FLOAT(_mm_cvtsi128_si32(v15));
v17 = (__m128i)_mm_xor_ps((__m128)LODWORD(v42), (__m128)0x80000000);
*(float *)v17.m128i_i32 = *(float *)v17.m128i_i32 / a6;
*(float *)v17.m128i_i32 = sub_483E9A(COERCE_FLOAT(_mm_cvtsi128_si32(v17)));
v40 = (float)(1.0 - (float)(v16 / *(float *)v17.m128i_i32)) * v36;
}
}
}
}
else
{
v40 = 1.0;
}
}
else
{
v40 = 0.0;
}
if ( v38 )
result = 1.0 - v40;
else
result = v40;
return result;
}
Q:[a3,a4,a1,a2,a5,a6,a7,v31,v32,v33,v34,v35,v36,v37,v38,v39,v40,v41,v42,sub_4AEE40,sub_4A6DF1,sub_4B29EB,sub_483EDC,sub_483E9A,] | A:{'a3': 'v_min', 'a4': 'v_max', 'a1': 'data_type', 'a2': 'v', 'a5': 'is_logarithmic', 'a6': 'logarithmic_zero_epsilon', 'a7': 'zero_deadzone_halfsize', 'v31': 'v_maxa', 'v32': 'v_mina', 'v33': 'va', 'v34': 'data_typea', 'v35': 'zero_point_snap_R', 'v36': 'zero_point_snap_L', 'v37': 'zero_point_center', 'v38': 'flipped', 'v39': 'v_clamped', 'v40': 'result', 'v41': 'v_max_fudged', 'v42': 'v_min_fudged', 'sub_4AEE40': 'ScaleRatioFromValueT', 'sub_4A6DF1': 'ImClamp', 'sub_4B29EB': 'ImSwap', 'sub_483EDC': 'ImAbs', 'sub_483E9A': 'ImLog'} | |
f2b2915e9e2d6729375d876f6c15174498b7f2f04b5b9bcc85cb7c605be4924f_f2b2915e9e2d6729375d876f6c15174498b7f2f04b5b9bcc85cb7c605be4924f.jsonl.gz | sub_41CB21 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41CB21(const char *a1, const char *a2)
{
__int64 result; // rax
++qword_439AB0;
result = sub_41C11D(a1, a2);
++qword_439AB8;
return result;
}
Q:[a1,a2,sub_41CB21,sub_41C11D,] | A:{'a1': 'value', 'a2': 'check_value_data', 'sub_41CB21': 'check_string', 'sub_41C11D': 'string_equal_display_error'} | |
3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353_3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353.jsonl.gz | sub_483334 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_483334(int *a1, int a2)
{
unsigned __int64 result; // rax
void *dest; // [rsp+18h] [rbp-8h]
result = (unsigned int)a1[1];
if ( a2 > (int)result )
{
dest = (void *)sub_40F8BA(16LL * a2);
if ( *((_QWORD *)a1 + 1) )
{
memcpy(dest, *((const void **)a1 + 1), 16LL * *a1);
sub_40F90B(*((_QWORD *)a1 + 1));
}
*((_QWORD *)a1 + 1) = dest;
result = (unsigned __int64)a1;
a1[1] = a2;
}
return result;
}
Q:[a1,a2,dest,sub_483334,sub_40F8BA,sub_40F90B,] | A:{'a1': 'this', 'a2': 'new_capacity', 'dest': 'new_data', 'sub_483334': 'reserve', 'sub_40F8BA': 'MemAlloc', 'sub_40F90B': 'MemFree'} | |
3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33_3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33.jsonl.gz | sub_413180 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 *__fastcall sub_413180(__int64 *a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6)
{
if ( !*(_BYTE *)(a2 + 58) || *(_BYTE *)(a2 + 58) == 5 || *(_BYTE *)(a2 + 58) == 4 )
*(_BYTE *)(a2 + 59) = 1;
else
sub_405C49(*a1, "__thread can only be used alone, or with extern or static", a3, a4, a5, a6);
return a1;
}
Q:[a1,a2,sub_413180,sub_405C49,] | A:{'a1': 'next', 'a2': 'ctx', 'sub_413180': 'thread_specifier', 'sub_405C49': 'sparse_error'} | |
09e593e1a10a4f6cadf5c016cb4c8cfb0a3586515f0619eba999737feb58c9d7_09e593e1a10a4f6cadf5c016cb4c8cfb0a3586515f0619eba999737feb58c9d7.jsonl.gz | sub_4330CE | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4330CE(int a1, __int64 *a2, __int64 a3, __int64 a4, __int64 a5)
{
__int64 v5; // rax
__int16 v6; // bx
const char *v7; // rsi
__int64 v11; // [rsp+30h] [rbp-30h] BYREF
__int64 v12; // [rsp+38h] [rbp-28h] BYREF
unsigned int v13; // [rsp+44h] [rbp-1Ch]
__int64 v14; // [rsp+48h] [rbp-18h]
if ( a1 <= 0 )
v5 = 0LL;
else
v5 = *a2;
v14 = v5;
v6 = *(_WORD *)(*(_QWORD *)(*(_QWORD *)(a5 + 48) + 24LL) + 4LL);
if ( v5 )
v7 = (const char *)sub_405ADA(v14 + 160);
else
v7 = 0LL;
v13 = sub_432351(a3, v7, v6, &v12, &v11);
if ( !v13 && a3 )
sub_4053FD(a4 + 160, v12, v11);
return v13;
}
Q:[a3,a4,a1,a2,a5,v11,v12,v13,v14,sub_4330CE,sub_405ADA,sub_432351,sub_4053FD,] | A:{'a3': 'item', 'a4': 'result', 'a1': 'argc', 'a2': 'argv', 'a5': 'gsl_thread', 'v11': 'returnitem', 'v12': 'returnclass', 'v13': 'rc', 'v14': 'name', 'sub_4330CE': 'XML_value_next', 'sub_405ADA': 'string_value', 'sub_432351': 'XML_value_next_sibling', 'sub_4053FD': 'assign_pointer'} | |
4365b5d0920047e31277b8a2796d99fcda79fd077dfd596f28b6a99bb1606856_4365b5d0920047e31277b8a2796d99fcda79fd077dfd596f28b6a99bb1606856.jsonl.gz | sub_44A6A2 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_44A6A2(__int64 a1)
{
int *v2; // [rsp+18h] [rbp-8h]
v2 = *(int **)(a1 + 8 * ((int)--*(_DWORD *)(a1 + 144) + 16LL) + 8);
sub_43586C(a1, *v2);
return (unsigned int)*v2;
}
Q:[sub_44A6A2,sub_43586C,] | A:{'sub_44A6A2': 'create_thread', 'sub_43586C': 'unblock_thread'} | |
eec34215ebfdb5a3218eeb77b1546d6d001312b1ea4361ffbda4ac1d3e99e353_eec34215ebfdb5a3218eeb77b1546d6d001312b1ea4361ffbda4ac1d3e99e353.jsonl.gz | sub_410E56 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_410E56(__int64 a1)
{
return *(_QWORD *)(a1 + 24);
}
Q:[a1,sub_410E56,] | A:{'a1': 'cpp', 'sub_410E56': 'nfp_cpp_priv'} | |
fca9e3ca7ac0f7d833eae9680f76d609a4d08c36b8c5c76263a4932ef4032672_fca9e3ca7ac0f7d833eae9680f76d609a4d08c36b8c5c76263a4932ef4032672.jsonl.gz | sub_42305D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_42305D()
{
return std::operator<<<std::char_traits<char>>();
}
Q:[sub_42305D,] | A:{'sub_42305D': 'GTestStreamToHelper'} | |
4d266dd65189678552f44e9be4e85fd1eac2e3921eff15e2ce86fc1cfb8460d3_4d266dd65189678552f44e9be4e85fd1eac2e3921eff15e2ce86fc1cfb8460d3.jsonl.gz | sub_40621B | Help user generate meaningful names for variables and functions in the following code snippet. |
__int16 __fastcall sub_40621B(__int64 a1, __int64 a2)
{
int v2; // eax
if ( *(_BYTE *)(a2 + 9) )
{
LOWORD(v2) = sub_40609A((uint16_t *)(*(unsigned __int16 *)(a2 + 5) + a1 + 435), a2);
}
else
{
v2 = *(unsigned __int8 *)(a2 + 7);
if ( v2 == 4 )
{
LOWORD(v2) = (unsigned __int16)sub_405F2A((uint32_t *)(*(unsigned __int16 *)(a2 + 5) + a1 + 435), a2);
}
else if ( *(unsigned __int8 *)(a2 + 7) <= 4u )
{
if ( v2 == 1 )
{
LOWORD(v2) = (unsigned __int16)sub_405E60((_BYTE *)(*(unsigned __int16 *)(a2 + 5) + a1 + 435), a2);
}
else if ( v2 == 2 )
{
LOWORD(v2) = (unsigned __int16)sub_405EAF((uint16_t *)(*(unsigned __int16 *)(a2 + 5) + a1 + 435), a2);
}
}
}
return v2;
}
Q:[a1,a2,sub_40621B,sub_40609A,sub_405F2A,sub_405E60,sub_405EAF,] | A:{'a1': 'pt_stream', 'a2': 'pt_rule', 'sub_40621B': 'update_rule_field', 'sub_40609A': 'update_bits', 'sub_405F2A': 'update_u32_n', 'sub_405E60': 'update_u8_n', 'sub_405EAF': 'update_u16_n'} | |
507b6d6826ab1404fd3df13a4b27da226b5beb2f60ed3e979a82f4c0a6725d69_507b6d6826ab1404fd3df13a4b27da226b5beb2f60ed3e979a82f4c0a6725d69.jsonl.gz | sub_442B7E | Help user generate meaningful names for variables and functions in the following code snippet. |
bool __fastcall sub_442B7E(__int64 a1)
{
return *(_QWORD *)(a1 + 8) == 0LL;
}
Q:[a1,sub_442B7E,] | A:{'a1': 'string', 'sub_442B7E': 'gt_string_is_static'} | |
6096ba2824eff13515e7a98799ef225f1733fe11d0aede2dde862a8735c916ff_6096ba2824eff13515e7a98799ef225f1733fe11d0aede2dde862a8735c916ff.jsonl.gz | sub_40CEF7 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_40CEF7()
{
__int64 v0; // rbx
__int64 result; // rax
__int64 v2; // [rsp+8h] [rbp-18h]
v2 = sub_4136AA("soap");
qword_4CD5D8 = sub_413937(qword_4CD568, v2);
v0 = qword_4CD5D8;
*(_QWORD *)(v0 + 16) = sub_413F78(21LL, 0LL, 0LL);
*(_DWORD *)(*(_QWORD *)(qword_4CD5D8 + 16) + 76LL) = -2;
*(_QWORD *)(*(_QWORD *)(qword_4CD5D8 + 16) + 16LL) = v2;
*(_QWORD *)(qword_4CD5D8 + 88) = "(built-in)";
result = qword_4CD5D8;
*(_DWORD *)(qword_4CD5D8 + 96) = 0;
return result;
}
Q:[v2,sub_40CEF7,sub_4136AA,sub_413937,sub_413F78,] | A:{'v2': 's', 'sub_40CEF7': 'add_soap', 'sub_4136AA': 'lookup', 'sub_413937': 'enter', 'sub_413F78': 'mktype'} | |
91a2943c83933b5d1b349e8fe93779c526101eacc519346c3c3104719cbb2284_91a2943c83933b5d1b349e8fe93779c526101eacc519346c3c3104719cbb2284.jsonl.gz | sub_406283 | Help user generate meaningful names for variables and functions in the following code snippet. |
int sub_406283()
{
int v0; // eax
int result; // eax
v0 = --dword_40C498;
if ( dword_40C498 < 0 )
v0 = 0;
dword_40C498 = v0;
result = dword_40C300;
if ( dword_40C4EC - 1 <= dword_40C300 )
{
result = dword_40C498;
if ( dword_40C49C + dword_40C4EC / 2 >= dword_40C498 )
{
if ( dword_40C49C )
--dword_40C49C;
result = wclear(qword_40C4C0);
}
}
return result;
}
Q:[sub_406283,] | A:{'sub_406283': 'scrollUp'} | |
ce91f793890cbebbef6dfac9d2cc87ce4fef3c0b414abf89c9f12a849db5dc8b_ce91f793890cbebbef6dfac9d2cc87ce4fef3c0b414abf89c9f12a849db5dc8b.jsonl.gz | sub_40354A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40354A(_QWORD *a1)
{
unsigned __int8 v2; // [rsp+17h] [rbp-1h]
v2 = sub_4020EB((__int64)a1);
*(_QWORD *)(8LL * v2 + *a1) = (int)(*(_QWORD *)(*a1 + 8LL * v2) + (char)sub_4020EB((__int64)a1));
return 0LL;
}
Q:[a1,v2,sub_40354A,sub_4020EB,] | A:{'a1': 'frame', 'v2': 'index', 'sub_40354A': 'OPCODE_IINC', 'sub_4020EB': 'read1Byte'} | |
172a2b2342ca5d634b41adc44c9b662352f1c3d83f55ee5a5030612ff100beeb_172a2b2342ca5d634b41adc44c9b662352f1c3d83f55ee5a5030612ff100beeb.jsonl.gz | sub_411D5E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_411D5E()
{
const char *v0; // rax
__int64 result; // rax
__int64 v2; // [rsp+0h] [rbp-10h]
size_t i; // [rsp+8h] [rbp-8h]
byte_41F1F8 = 1;
s = "readline / skipline";
++qword_41F200;
qword_41F220 = 0LL;
qword_41F218 = 0LL;
sub_411431("tmp.strbuf.001.txt");
printf("Testing %s ", s);
v2 = qword_41F218 + qword_41F220;
for ( i = strlen(s); i <= 0x41; ++i )
putchar(46);
if ( byte_41F1F8 )
v0 = " pass";
else
v0 = " fail";
printf("%s", v0);
if ( v2 )
{
if ( qword_41F218 && qword_41F220 )
printf(" [%zu/%zu]\n", qword_41F218, v2);
else
printf(" (%zu)\n", v2);
}
else
{
puts(" (empty)");
++qword_41F210;
}
if ( !byte_41F1F8 )
++qword_41F208;
qword_41F230 += qword_41F220;
result = qword_41F228 + qword_41F218;
qword_41F228 += qword_41F218;
return result;
}
Q:[v2,i,sub_411D5E,sub_411431,] | A:{'v2': 'tests_in_suite', 'i': 'suite_i', 'sub_411D5E': 'test_read_file', 'sub_411431': 'test_file'} | |
11e5c558f462624706c4911fcfcfb3fa470faf591537d30299dafed6fcd0af41_11e5c558f462624706c4911fcfcfb3fa470faf591537d30299dafed6fcd0af41.jsonl.gz | sub_4017BC | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4017BC(__int64 a1, char a2, unsigned int a3, _BYTE *a4)
{
char v6; // [rsp+27h] [rbp-9h] BYREF
__int64 v7; // [rsp+28h] [rbp-8h]
v7 = sub_4016AE(a1, a2, a3, &v6);
if ( a4 )
*a4 = v6;
return v7;
}
Q:[a3,a4,a1,a2,v6,v7,sub_4017BC,sub_4016AE,] | A:{'a3': 'key', 'a4': 'created', 'a1': 'context', 'a2': 'log_2_size', 'v6': 'empty_or_tombstone', 'v7': 'entry', 'sub_4017BC': 'employees_table_emplace_key', 'sub_4016AE': 'employees_table_probe'} | |
d8978fde855390e54d48e6d97a2ed03d28b238e23e5357c0a821fefa3a1ca8fb_d8978fde855390e54d48e6d97a2ed03d28b238e23e5357c0a821fefa3a1ca8fb.jsonl.gz | sub_401472 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_401472(void (__fastcall **a1)(const char *), char a2, int *a3)
{
__int64 result; // rax
unsigned __int8 v5; // [rsp+2Eh] [rbp-2h] BYREF
if ( !a1 )
return 2LL;
if ( *((_BYTE *)a1 + 56) != 1 )
return 3LL;
if ( ((unsigned __int8 (__fastcall *)(_QWORD, unsigned __int8 *, __int64))a1[3])(*(unsigned __int8 *)a1, &v5, 1LL) )
{
a1[6]("pcf8574: iic read failed.\n");
result = 1LL;
}
else
{
*a3 = ((int)v5 >> a2) & 1;
result = 0LL;
}
return result;
}
Q:[a3,a1,a2,v5,sub_401472,] | A:{'a3': 'level', 'a1': 'handle', 'a2': 'pin', 'v5': 'data', 'sub_401472': 'pcf8574_read'} | |
8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2_8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2.jsonl.gz | sub_446F87 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_446F87(__int64 a1, __int64 a2, const char *a3, int a4)
{
_BOOL4 v4; // eax
__int64 v8; // [rsp+38h] [rbp-28h] BYREF
char *s2; // [rsp+40h] [rbp-20h]
_BOOL4 v10; // [rsp+4Ch] [rbp-14h]
__int64 v11; // [rsp+50h] [rbp-10h]
int i; // [rsp+58h] [rbp-8h]
unsigned int v13; // [rsp+5Ch] [rbp-4h]
v13 = 0;
v8 = 0LL;
if ( sub_446E92(a1, a2, &v8) )
{
v11 = *(_QWORD *)(v8 + 24);
for ( i = 0; i < *(_DWORD *)(v8 + 12); ++i )
{
if ( *(_QWORD *)(8LL * i + v11) )
{
v4 = **(_BYTE **)(8LL * i + v11) == 42 && *(_BYTE *)(*(_QWORD *)(8LL * i + v11) + 1LL) == 46;
v10 = v4;
if ( a4 == 1
&& v10
&& (s2 = strchr(a3, 46)) != 0LL
&& !strcasecmp((const char *)(*(_QWORD *)(8LL * i + v11) + 1LL), s2)
|| !strcasecmp(*(const char **)(8LL * i + v11), a3) )
{
v13 = 1;
}
if ( !v13 && qword_4C8800[1] && LODWORD(qword_4C8800[0]) > 1 )
qword_4C8800[1](
2LL,
"modssl_X509_match_name",
"src/main/aerospike/ssl_util.c",
342LL,
"as_tls_match_name: expecting name '%s', %smatched by ID '%s'",
a3,
"NOT ",
*(const char **)(8LL * i + v11));
if ( v13 == 1 )
break;
}
}
}
if ( !v13 && qword_4C8800[1] && LODWORD(qword_4C8800[0]) )
qword_4C8800[1](
1LL,
"modssl_X509_match_name",
"src/main/aerospike/ssl_util.c",
359LL,
"Cert %s for name '%s'",
"does not match",
a3);
sub_44692C(v8);
return v13;
}
Q:[a3,a4,a1,a2,v8,s2,v10,v11,v13,sub_446F87,sub_446E92,sub_44692C,] | A:{'a3': 'name', 'a4': 'allow_wildcard', 'a1': 'p', 'a2': 'x509', 'v8': 'ids', 's2': 'cp', 'v10': 'is_wildcard', 'v11': 'id', 'v13': 'matched', 'sub_446F87': 'modssl_X509_match_name', 'sub_446E92': 'getIDs', 'sub_44692C': 'as_array_destroy'} | |
a9c3af2bbfaf6f2b91ec77b94c94de2d53a1a5ea1853e29d66a8aff6314cd940_a9c3af2bbfaf6f2b91ec77b94c94de2d53a1a5ea1853e29d66a8aff6314cd940.jsonl.gz | sub_402E10 | Help user generate meaningful names for variables and functions in the following code snippet. |
int sub_402E10()
{
qword_40C3A0 = 0LL;
qword_40C3A8 = 0LL;
qword_40C3B0 = 0LL;
__cxa_atexit(func, &qword_40C3A0, &unk_40C1A8);
qword_40C380 = 0LL;
qword_40C388 = 0LL;
qword_40C390 = 0LL;
return __cxa_atexit(func, &qword_40C380, &unk_40C1A8);
}
Q:[sub_402E10,] | A:{'sub_402E10': '_GLOBAL__sub_I_g_midiFormat'} | |
70544b8971401eb9f7cd513c291abdc9953c4cec8836446583dd009e53f43ad2_70544b8971401eb9f7cd513c291abdc9953c4cec8836446583dd009e53f43ad2.jsonl.gz | sub_4038EE | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4038EE(__int64 a1, __int64 a2, __int64 a3)
{
int v5; // [rsp+2Ch] [rbp-4h]
((void (__fastcall *)(__int64))off_40A390[9])(a1 + 64);
v5 = sub_4037A2(a1, a2, a3, *(unsigned int *)(a1 + 44));
if ( v5 > 0 )
*(_DWORD *)(a1 + 44) += v5;
((void (__fastcall *)(__int64))off_40A390[11])(a1 + 64);
return v5;
}
Q:[a3,a1,a2,v5,sub_4038EE,sub_4037A2,] | A:{'a3': 'count', 'a1': 'fid', 'a2': 'buf', 'v5': 'n', 'sub_4038EE': 'ixp_read', 'sub_4037A2': '_pread'} | |
ebce38d56473c420b2dd35734b38c295e926b8a2feaa22442c4129495df4ce92_ebce38d56473c420b2dd35734b38c295e926b8a2feaa22442c4129495df4ce92.jsonl.gz | sub_407FB8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_407FB8(unsigned __int8 a1, unsigned int a2, unsigned __int8 a3, __int64 a4)
{
unsigned int v4; // eax
if ( a2 <= 1 || a2 >= dword_4284A0[3] + 2 || a3 > 1u )
sub_40BADE("../../../core/driver/inode.c", 1181LL);
v4 = sub_4080A9(a2, a3);
return (unsigned int)sub_406803(a1, v4, a4);
}
Q:[a3,a4,a1,a2,sub_407FB8,sub_40BADE,sub_4080A9,sub_406803,] | A:{'a3': 'bWhich', 'a4': 'pfAllocated', 'a1': 'bMR', 'a2': 'ulInode', 'sub_407FB8': 'RedInodeBitGet', 'sub_40BADE': 'RedOsAssertFail', 'sub_4080A9': 'InodeBlock', 'sub_406803': 'RedImapBlockGet'} | |
7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2_7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2.jsonl.gz | sub_42C840 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42C840(__int64 a1, int *a2)
{
char v2; // dl
__int64 result; // rax
_DWORD v4[12]; // [rsp+10h] [rbp-90h] BYREF
_DWORD v5[12]; // [rsp+40h] [rbp-60h] BYREF
int v6[12]; // [rsp+70h] [rbp-30h] BYREF
sub_423CD1((__int64)v6, a2 + 20);
sub_424290(v5, a2, v6);
sub_424290(v4, a2 + 10, v6);
sub_4232B9(a1, v4);
v2 = ((unsigned __int8)sub_426D3C(v5) << 7) ^ *(_BYTE *)(a1 + 31);
result = a1 + 31;
*(_BYTE *)(a1 + 31) = v2;
return result;
}
Q:[a1,a2,v4,v5,v6,sub_42C840,sub_423CD1,sub_424290,sub_4232B9,sub_426D3C,] | A:{'a1': 's', 'a2': 'h', 'v4': 'y', 'v5': 'x', 'v6': 'recip', 'sub_42C840': 'ge_p3_tobytes', 'sub_423CD1': 'fe_invert', 'sub_424290': 'fe_mul', 'sub_4232B9': 'fe_tobytes', 'sub_426D3C': 'fe_isnegative'} | |
45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0_45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0.jsonl.gz | sub_4296CE | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4296CE(__int64 a1, __int64 a2, __int64 a3)
{
return sub_42A9C4(a1, a2, a3);
}
Q:[a3,a1,a2,sub_4296CE,sub_42A9C4,] | A:{'a3': '__result', 'a1': '__first', 'a2': '__last', 'sub_4296CE': 'allocator', 'sub_42A9C4': 'allocator'} | |
e3acda395257961e26e6ab80a6a53057b0e6a1d88575fd9f343683f29d221741_e3acda395257961e26e6ab80a6a53057b0e6a1d88575fd9f343683f29d221741.jsonl.gz | sub_4347CA | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 *__fastcall sub_4347CA(__int64 a1, __int64 a2)
{
__int64 *v3; // [rsp+18h] [rbp-38h]
__int64 *v4; // [rsp+20h] [rbp-30h]
_QWORD *v5; // [rsp+28h] [rbp-28h]
__int64 *v6; // [rsp+38h] [rbp-18h]
__int64 v7; // [rsp+40h] [rbp-10h]
__int64 i; // [rsp+48h] [rbp-8h]
v7 = *(_QWORD *)(a1 + 16);
v6 = sub_42D2E5(5LL, v7);
if ( !v6 )
return 0LL;
for ( i = 0LL; i < v7; ++i )
{
v5 = sub_42D17A(*(_QWORD **)(a2 + 8 * (i + 2) + 8));
v4 = sub_42D2E5(0LL, 3LL);
v3 = sub_42E1B2(*(_QWORD *)(a1 + 24 + 8 * i));
if ( !sub_42CCA5(0LL, (__int64)v6, (__int64)v3, (__int64)v4, (__int64)v5, -1LL) )
return 0LL;
v4[3] = (__int64)v3;
v4[4] = (__int64)v5;
v4[5] = sub_41A548();
v6[i + 3] = (__int64)v4;
}
return v6;
}
Q:[a1,a2,v4,v5,v6,v7,sub_4347CA,sub_42D2E5,sub_42D17A,sub_42E1B2,sub_42CCA5,sub_41A548,] | A:{'a1': 'a', 'a2': 'b', 'v4': 't', 'v5': 'v', 'v6': 'z', 'v7': 'n', 'sub_4347CA': 'excl_mkdict', 'sub_42D2E5': 'newK', 'sub_42D17A': 'ci', 'sub_42E1B2': 'Ks', 'sub_42CCA5': 'OOM_CD', 'sub_41A548': '_n'} | |
5315d423f79afb83f749d4d734d1dde80b0f439f410fcfb4b4bf9fe5a60ff93d_5315d423f79afb83f749d4d734d1dde80b0f439f410fcfb4b4bf9fe5a60ff93d.jsonl.gz | sub_40EF1B | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40EF1B(_QWORD *a1, uint16_t *a2, unsigned int a3, char a4, __int64 a5, int a6)
{
__int64 result; // rax
uint16_t v7; // ax
uint16_t v8; // ax
uint16_t v9; // ax
unsigned int v13; // [rsp+3Ch] [rbp-24h] BYREF
_DWORD *v14; // [rsp+40h] [rbp-20h]
unsigned int v15; // [rsp+48h] [rbp-18h]
unsigned int m; // [rsp+4Ch] [rbp-14h]
unsigned int l; // [rsp+50h] [rbp-10h]
unsigned int k; // [rsp+54h] [rbp-Ch]
unsigned int j; // [rsp+58h] [rbp-8h]
unsigned int i; // [rsp+5Ch] [rbp-4h]
v13 = 0;
v15 = a3 - 12;
if ( a3 <= 0xB )
return 0LL;
v14 = calloc(1uLL, 0x40uLL);
if ( !v14 )
return 0LL;
v14[1] = ntohs(a2[2]);
if ( v14[1] > 0x32u )
{
v14[1] = 0;
sub_40ED00((__int64)v14);
return 0LL;
}
syslog(7, "%s: Section %s, %d records", "dns_wire_parse_", "question", (unsigned int)v14[1]);
if ( v14[1] )
{
*((_QWORD *)v14 + 3) = calloc((unsigned int)v14[1], 0x40uLL);
if ( !*((_QWORD *)v14 + 3) )
{
sub_40ED00((__int64)v14);
return 0LL;
}
}
for ( i = 0; i < v14[1]; ++i )
{
if ( (unsigned __int8)sub_40E93D(
(int *)(*((_QWORD *)v14 + 3) + ((unsigned __int64)i << 6)),
(__int64)(a2 + 6),
v15,
&v13,
0,
a4,
a5,
a6) != 1 )
{
sub_40ED00((__int64)v14);
syslog(3, "%s: question %d RR parse failed.\n", "dns_wire_parse_", i);
return 0LL;
}
}
v7 = ntohs(a2[3]);
v14[2] = v7;
if ( v14[2] > 0x32u )
{
v14[2] = 0;
sub_40ED00((__int64)v14);
return 0LL;
}
syslog(7, "%s: Section %s, %d records", "dns_wire_parse_", "answers", (unsigned int)v14[2]);
if ( v14[2] )
{
*((_QWORD *)v14 + 4) = calloc((unsigned int)v14[2], 0x40uLL);
if ( !*((_QWORD *)v14 + 4) )
goto LABEL_46;
}
for ( j = 0; j < v14[2]; ++j )
{
if ( (unsigned __int8)sub_40E93D(
(int *)(*((_QWORD *)v14 + 4) + ((unsigned __int64)j << 6)),
(__int64)(a2 + 6),
v15,
&v13,
1,
a4,
a5,
a6) != 1 )
{
sub_40ED00((__int64)v14);
syslog(3, "%s: answers %d RR parse failed.\n", "dns_wire_parse_", j);
return 0LL;
}
}
v8 = ntohs(a2[4]);
v14[3] = v8;
if ( v14[3] > 0x32u )
{
v14[3] = 0;
sub_40ED00((__int64)v14);
return 0LL;
}
syslog(7, "%s: Section %s, %d records", "dns_wire_parse_", "authority", (unsigned int)v14[3]);
if ( v14[3] )
{
*((_QWORD *)v14 + 5) = calloc((unsigned int)v14[3], 0x40uLL);
if ( !*((_QWORD *)v14 + 5) )
goto LABEL_46;
}
for ( k = 0; k < v14[3]; ++k )
{
if ( (unsigned __int8)sub_40E93D(
(int *)(*((_QWORD *)v14 + 5) + ((unsigned __int64)k << 6)),
(__int64)(a2 + 6),
v15,
&v13,
1,
a4,
a5,
a6) != 1 )
{
sub_40ED00((__int64)v14);
syslog(3, "%s: authority %d RR parse failed.\n", "dns_wire_parse_", k);
return 0LL;
}
}
v9 = ntohs(a2[5]);
v14[4] = v9;
if ( v14[4] > 0x32u )
{
v14[4] = 0;
sub_40ED00((__int64)v14);
return 0LL;
}
syslog(7, "%s: Section %s, %d records", "dns_wire_parse_", "additional", (unsigned int)v14[4]);
if ( v14[4] && (*((_QWORD *)v14 + 6) = calloc((unsigned int)v14[4], 0x40uLL)) == 0LL )
{
LABEL_46:
sub_40ED00((__int64)v14);
result = 0LL;
}
else
{
for ( l = 0; l < v14[4]; ++l )
{
if ( (unsigned __int8)sub_40E93D(
(int *)(*((_QWORD *)v14 + 6) + ((unsigned __int64)l << 6)),
(__int64)(a2 + 6),
v15,
&v13,
1,
a4,
a5,
a6) != 1 )
{
sub_40ED00((__int64)v14);
syslog(3, "%s: additional %d RR parse failed.\n", "dns_wire_parse_", l);
return 0LL;
}
}
for ( m = 0; m < v14[4]; ++m )
{
if ( *(_WORD *)(*((_QWORD *)v14 + 6) + ((unsigned __int64)m << 6) + 8) == 41
&& (unsigned __int8)sub_40CDDF((_QWORD *)v14 + 7, ((unsigned __int64)m << 6) + *((_QWORD *)v14 + 6)) != 1 )
{
goto LABEL_46;
}
}
*a1 = v14;
result = 1LL;
}
return result;
}
Q:[a3,a4,a2,a5,a6,v7,v13,v14,v15,m,l,k,j,sub_40EF1B,sub_40ED00,sub_40E93D,sub_40CDDF,] | A:{'a3': 'len', 'a4': 'dump_to_stderr', 'a2': 'message', 'a5': 'file', 'a6': 'line', 'v7': 'result', 'v13': 'offset', 'v14': 'rv', 'v15': 'data_len', 'm': 'i_3', 'l': 'i_2', 'k': 'i_1', 'j': 'i_0', 'sub_40EF1B': 'dns_wire_parse_', 'sub_40ED00': 'dns_message_free', 'sub_40E93D': 'dns_rr_parse_', 'sub_40CDDF': 'dns_opt_parse'} | |
6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58_6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58.jsonl.gz | sub_40D1D8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40D1D8(__int64 a1)
{
__int64 result; // rax
result = sub_406777(a1, *(_WORD *)(a1 + 4));
*(_BYTE *)(a1 + 1) = result;
return result;
}
Q:[a1,sub_40D1D8,sub_406777,] | A:{'a1': 'ctx', 'sub_40D1D8': 'LD_A_off_DE', 'sub_406777': 'read8'} | |
6304f984c14a4d98b773d0291a6dd3e43febc7f48dbb715cb3878d88f0894996_6304f984c14a4d98b773d0291a6dd3e43febc7f48dbb715cb3878d88f0894996.jsonl.gz | sub_4030BD | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_4030BD(__int64 a1, __int64 a2, __int64 a3)
{
unsigned __int64 result; // rax
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+20h] [rbp-8h]
int v6; // [rsp+24h] [rbp-4h]
unsigned int v7; // [rsp+24h] [rbp-4h]
unsigned int v8; // [rsp+24h] [rbp-4h]
int v9; // [rsp+24h] [rbp-4h]
unsigned int v10; // [rsp+24h] [rbp-4h]
v6 = 218;
for ( i = 0; i <= 30; ++i )
{
v7 = *(unsigned __int8 *)(i + a2) - *(unsigned __int8 *)(i + a3) + v6 + 65280;
*(_BYTE *)(i + a1) = v7;
v6 = v7 >> 8;
}
v8 = *(unsigned __int8 *)(a2 + 31) - *(unsigned __int8 *)(a3 + 31) + v6;
*(_BYTE *)(a1 + 31) = v8 & 0x7F;
result = 19 * (v8 >> 7);
v9 = 19 * (v8 >> 7);
for ( j = 0; j <= 31; ++j )
{
v10 = *(unsigned __int8 *)(j + a1) + v9;
result = j + a1;
*(_BYTE *)result = v10;
v9 = v10 >> 8;
}
return result;
}
Q:[a3,a1,a2,i,v10,sub_4030BD,] | A:{'a3': 'b', 'a1': 'r', 'a2': 'a', 'i': 'ia', 'v10': 'ca', 'sub_4030BD': 'f25519_sub'} | |
e66f1ef06cb5cd9868a64c3563f84f528cc36471b411b386d9921fccf9bf273e_e66f1ef06cb5cd9868a64c3563f84f528cc36471b411b386d9921fccf9bf273e.jsonl.gz | sub_405A3F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_405A3F(const char *a1, int a2)
{
__int64 result; // rax
char *v3; // [rsp+18h] [rbp-8h]
v3 = strchr(a1, a2);
if ( v3 )
result = v3 - a1;
else
result = 0xFFFFFFFFLL;
return result;
}
Q:[a1,a2,v3,sub_405A3F,] | A:{'a1': 's', 'a2': 'c', 'v3': 'p', 'sub_405A3F': 'chrpos'} | |
028cb0434a6d0ef20507319d5e16b908c7ac9721213577d7712511e77169ac37_028cb0434a6d0ef20507319d5e16b908c7ac9721213577d7712511e77169ac37.jsonl.gz | sub_405628 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_405628(_QWORD *a1, const char *a2, unsigned int a3)
{
char *v5; // [rsp+28h] [rbp-18h]
__int64 v6; // [rsp+30h] [rbp-10h]
__int64 v7; // [rsp+38h] [rbp-8h]
v5 = strchr(a2, 46);
if ( !v5 )
return sub_4054A7(a1, a2, a3);
v7 = sub_4053F5((__int64)a1, a2, v5 - a2);
if ( (unsigned int)sub_4082ED(v7) != 4 )
return 0xFFFFFFFFLL;
v6 = sub_40830C(v7);
return sub_405628(v6, v5 + 1, a3);
}
Q:[a3,a1,a2,v5,v6,v7,sub_405628,sub_4054A7,sub_4053F5,sub_4082ED,sub_40830C,] | A:{'a3': 'free_value', 'a1': 'object', 'a2': 'name', 'v5': 'dot_pos', 'v6': 'temp_object', 'v7': 'temp_value', 'sub_405628': 'json_object_dotremove_internal', 'sub_4054A7': 'json_object_remove_internal', 'sub_4053F5': 'json_object_getn_value', 'sub_4082ED': 'json_value_get_type', 'sub_40830C': 'json_value_get_object'} | |
448d64472cd235d309b0787287aae4b43df6af9375d1a6596bb8fa1c593df428_448d64472cd235d309b0787287aae4b43df6af9375d1a6596bb8fa1c593df428.jsonl.gz | sub_430AC0 | Help user generate meaningful names for variables and functions in the following code snippet. |
const char **__fastcall sub_430AC0(const char **a1, int a2)
{
char *v3; // rax
char *v4; // r14
const char *v6; // r13
char *v7; // rbx
size_t v8; // rax
int v9; // er15
unsigned __int64 v10; // rbp
bool v11; // cc
unsigned __int64 v12; // rax
__int64 v13; // rax
const char *v14; // rsi
const char *v15; // rbp
char *v16; // rcx
char *v17; // rdx
__int64 v18; // rdi
char v19; // al
char v20[56]; // [rsp+10h] [rbp-38h] BYREF
v3 = sub_423A00((__int64)v20, a2);
v4 = (char *)(v20 - v3);
if ( (int)(v20 - v3) > 0 )
{
v6 = *a1;
v7 = v3;
v8 = strlen(*a1);
v9 = v8;
v10 = v8 + (int)v4 + 1;
v11 = _InterlockedExchangeAdd((volatile signed __int32 *)v6 - 4, 0) <= 0;
v12 = *((_QWORD *)v6 - 1);
if ( v11 && v10 <= v12 )
{
v15 = *a1;
}
else
{
if ( v12 >= v10 )
v10 = *((_QWORD *)v6 - 1);
v13 = operator new[](v10 + 23);
v14 = *a1;
*(_QWORD *)(v13 + 8) = v10;
v15 = (const char *)(v13 + 16);
*(_DWORD *)v13 = 0;
memcpy((void *)(v13 + 16), v14, *((_QWORD *)v6 - 1));
sub_4645F0(v6 - 16);
}
*a1 = v15;
v16 = (char *)&v15[v9];
if ( (_DWORD)v4 != 1 )
{
v17 = v7;
v18 = (__int64)&v7[(_DWORD)v4 - 2 + 1];
while ( 1 )
{
v19 = *v17;
if ( !*v17 )
break;
if ( v19 < 0 )
{
++v17;
v16 += 2;
*(v16 - 1) = v19 & 0x3F | 0x80;
*(v16 - 2) = ((unsigned __int8)v19 >> 6) | 0xC0;
if ( (char *)v18 == v17 )
break;
}
else
{
++v17;
*v16++ = v19;
if ( (char *)v18 == v17 )
break;
}
}
}
*v16 = 0;
}
return a1;
}
Q:[sub_430AC0,sub_423A00,sub_4645F0,] | A:{'sub_430AC0': 'operator+=', 'sub_423A00': 'numberToString', 'sub_4645F0': 'release'} | |
31146286f7c34c986f4a16187c92a35fbaba59c79649cdf48ea40c29070ea8ff_31146286f7c34c986f4a16187c92a35fbaba59c79649cdf48ea40c29070ea8ff.jsonl.gz | sub_40CE36 | Help user generate meaningful names for variables and functions in the following code snippet. |
char *__fastcall sub_40CE36(const char *a1)
{
size_t v1; // rax
char *dest; // [rsp+18h] [rbp-8h]
v1 = strlen(a1);
dest = (char *)malloc(v1 + 1);
if ( !dest )
{
sprintf(byte_43FEA0, "out of space in strdupl(%s)", a1);
sub_401DF6();
exit(1);
}
strcpy(dest, a1);
return dest;
}
Q:[a1,dest,sub_40CE36,sub_401DF6,] | A:{'a1': 's', 'dest': 't', 'sub_40CE36': 'strdupl', 'sub_401DF6': 'errprint'} | |
c0889e43b9fb99e0a15d5a45e58572120bf2a06ee20b165810a3d68c382cd705_c0889e43b9fb99e0a15d5a45e58572120bf2a06ee20b165810a3d68c382cd705.jsonl.gz | sub_40C46D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40C46D(__int64 a1, __int64 a2, __int64 a3)
{
return a2 * *(_QWORD *)(a1 + 8) + a3;
}
Q:[a3,a1,a2,sub_40C46D,] | A:{'a3': 'column', 'a1': 'diff_matrix', 'a2': 'row', 'sub_40C46D': 'nala_diff_matrix_index'} | |
8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2_8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2.jsonl.gz | sub_46559D | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int8 *__fastcall sub_46559D(unsigned __int16 *a1, unsigned __int8 *a2, __int64 a3)
{
unsigned __int8 *v3; // rax
unsigned __int8 *result; // rax
unsigned __int64 v5; // [rsp+18h] [rbp-10h]
unsigned __int8 *v6; // [rsp+20h] [rbp-8h]
v6 = a2;
v5 = (unsigned __int64)&a2[a3];
while ( 1 )
{
result = v6;
if ( (unsigned __int64)v6 >= v5 )
break;
v3 = v6++;
*a1 = sub_46552D(*a1, *v3);
}
return result;
}
Q:[a3,a1,a2,v5,v6,sub_46559D,sub_46552D,] | A:{'a3': 'inLen', 'a1': 'inContext', 'a2': 'inSrc', 'v5': 'srcEnd', 'v6': 'src', 'sub_46559D': 'CRC16_Update', 'sub_46552D': 'UpdateCRC16'} | |
31146286f7c34c986f4a16187c92a35fbaba59c79649cdf48ea40c29070ea8ff_31146286f7c34c986f4a16187c92a35fbaba59c79649cdf48ea40c29070ea8ff.jsonl.gz | sub_41141D | Help user generate meaningful names for variables and functions in the following code snippet. |
_DWORD *__fastcall sub_41141D(_DWORD *a1)
{
while ( 1 )
{
a1 -= 2;
if ( (unsigned __int64)a1 < *((_QWORD *)off_43EAC8 + 28) )
break;
if ( (unsigned int)sub_4113F1(*a1 & 0x1FFFF) )
return a1;
}
return 0LL;
}
Q:[a1,sub_41141D,sub_4113F1,] | A:{'a1': 'w', 'sub_41141D': 'chkvow', 'sub_4113F1': 'vowel'} | |
cdeac11397b3ddafedfc7fcababa15dcd5c3d76b9d23735fb7b4af1a33b3d615_cdeac11397b3ddafedfc7fcababa15dcd5c3d76b9d23735fb7b4af1a33b3d615.jsonl.gz | sub_40E6C4 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40E6C4(unsigned __int64 a1)
{
unsigned __int64 v1; // rax
v1 = sub_40E65E();
return sub_40E69D(v1, a1);
}
Q:[a1,sub_40E6C4,sub_40E65E,sub_40E69D,] | A:{'a1': 'start_ticks', 'sub_40E6C4': 'stm_since', 'sub_40E65E': 'stm_now', 'sub_40E69D': 'stm_diff'} | |
6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58_6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58.jsonl.gz | sub_410EC6 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_410EC6(__int64 a1)
{
unsigned __int16 v1; // ax
char v2; // al
char v5; // [rsp+1Fh] [rbp-1h]
*(_DWORD *)(a1 + 88) += 2;
v1 = *(_WORD *)(a1 + 28);
*(_WORD *)(a1 + 28) = v1 + 1;
v5 = sub_406777(a1, v1);
v2 = sub_406777(a1, *(_WORD *)(a1 + 8) + v5);
*(_BYTE *)(a1 + 3) = sub_407247(a1, 1, 3, v2);
return sub_4066D5(a1, *(_WORD *)(a1 + 8) + v5, *(_BYTE *)(a1 + 3));
}
Q:[a1,v5,sub_410EC6,sub_406777,sub_407247,sub_4066D5,] | A:{'a1': 'ctx', 'v5': 'off', 'sub_410EC6': 'LD_B_SET_3_off_IX_d', 'sub_406777': 'read8', 'sub_407247': 'doSetRes', 'sub_4066D5': 'write8'} | |
7421faa8c444aeca9266add08f45c75a4f43aebd993f880cd35dd964f63fdfb2_7421faa8c444aeca9266add08f45c75a4f43aebd993f880cd35dd964f63fdfb2.jsonl.gz | sub_42931A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42931A(__int64 a1, __int64 a2, __int64 a3)
{
__int64 result; // rax
if ( a1 )
{
*(_QWORD *)(a1 + 352) = a2;
*(_QWORD *)(a1 + 360) = a3;
result = 0LL;
}
else
{
*(_QWORD *)(__readfsqword(0) - 24) = "Error encountered in s2n_resume.c:1015";
*(_DWORD *)(__readfsqword(0) - 32) = 402653193;
sub_46D9B7(0LL, a2);
result = 0xFFFFFFFFLL;
}
return result;
}
Q:[a3,a1,a2,sub_42931A,sub_46D9B7,] | A:{'a3': 'ctx', 'a1': 'config', 'a2': 'callback', 'sub_42931A': 's2n_config_set_session_ticket_cb', 'sub_46D9B7': 's2n_calculate_stacktrace'} | |
65b0a6a66ac7f742f3b62174dd1ff457acc880965e6d65927b21910da8931604_65b0a6a66ac7f742f3b62174dd1ff457acc880965e6d65927b21910da8931604.jsonl.gz | sub_4403F0 | Help user generate meaningful names for variables and functions in the following code snippet. |
int sub_4403F0()
{
int v0; // edx
int v1; // ecx
int v2; // er8
int v3; // er9
__int64 v4; // rsi
__int64 v5; // rdx
__int64 v6; // rcx
__int64 v7; // r8
__int64 v8; // r9
__m128i v9; // xmm1
__int64 v10; // rcx
__int64 v11; // r8
__int64 v12; // r9
unsigned int v14; // [rsp+Ch] [rbp-1Ch]
_QWORD *v15; // [rsp+10h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-Ch]
v15 = sub_431518("net_ip", "localhost", 32);
v4 = sub_44691C((unsigned int)"%i", 27960, v0, v1, v2, v3);
v14 = *((_DWORD *)sub_431518("net_port", (const char *)v4, 32) + 12);
for ( i = 0; ; ++i )
{
if ( i > 9 )
return sub_42C36A("WARNING: Couldn't allocate IP port\n", v4, v5, v6, v7, v8);
v4 = i + v14;
fd = sub_43FA5E((const char *)v15[1], v4, v4, v6, v7, v8);
if ( fd )
break;
}
v9 = 0LL;
*(float *)v9.m128i_i32 = (float)(int)(v14 + i);
sub_431C70("net_port", COERCE_FLOAT(_mm_cvtsi128_si32(v9)), v4, v14, v6, v7, v8);
if ( *(_DWORD *)(qword_796190 + 48) )
sub_43FC56(v14 + i, v4, v14, v10, v11, v12);
return sub_4401D6();
}
Q:[v14,v15,sub_4403F0,sub_431518,sub_44691C,sub_42C36A,sub_43FA5E,sub_431C70,sub_43FC56,sub_4401D6,] | A:{'v14': 'port', 'v15': 'ip_0', 'sub_4403F0': 'NET_OpenIP', 'sub_431518': 'Cvar_Get', 'sub_44691C': 'va', 'sub_42C36A': 'Com_Printf', 'sub_43FA5E': 'NET_IPSocket', 'sub_431C70': 'Cvar_SetValue', 'sub_43FC56': 'NET_OpenSocks', 'sub_4401D6': 'NET_GetLocalAddress'} | |
9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0_9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0.jsonl.gz | sub_43DE36 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43DE36(__int64 a1)
{
return sub_448430(a1);
}
Q:[sub_43DE36,sub_448430,] | A:{'sub_43DE36': 'end', 'sub_448430': 'end'} | |
1f521185abebe790038be8fb8b4eb165b2fd6d5af5b82a99f02d98f6827de627_1f521185abebe790038be8fb8b4eb165b2fd6d5af5b82a99f02d98f6827de627.jsonl.gz | sub_43B5A8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43B5A8(__int64 a1)
{
__int16 v2; // ax
if ( (unsigned int)sub_43B1B7(a1, *(_DWORD *)(a1 + 12) + 2, 1) )
return 7LL;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + *(int *)(a1 + 12)) = 0;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + *(int *)(a1 + 12) + 1LL) = 0;
v2 = *(_WORD *)(a1 + 8);
HIBYTE(v2) |= 2u;
*(_WORD *)(a1 + 8) = v2;
return 0LL;
}
Q:[a1,sub_43B5A8,sub_43B1B7,] | A:{'a1': 'pMem', 'sub_43B5A8': 'vdbeMemAddTerminator', 'sub_43B1B7': 'sqlite3VdbeMemGrow'} | |
bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b_bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b.jsonl.gz | sub_434304 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_434304(__int64 a1, __int64 a2)
{
__int64 v2; // rbx
__int64 v3; // rax
__int64 v4; // rax
__int64 result; // rax
__int64 v6; // [rsp+10h] [rbp-20h] BYREF
__int64 v7; // [rsp+18h] [rbp-18h] BYREF
v2 = sub_43BA8E(a1);
v3 = sub_43BA7C(a1);
v6 = sub_43BAA0(a1, v3, v2, a2);
v7 = sub_433934(a1);
if ( sub_42E129(&v6, &v7) || (v4 = sub_43A60F(v6), (unsigned __int8)sub_433A00(a1, a2, v4)) )
result = sub_433934(a1);
else
result = v6;
return result;
}
Q:[sub_434304,sub_43BA8E,sub_43BA7C,sub_43BAA0,sub_433934,sub_42E129,sub_43A60F,sub_433A00,] | A:{'sub_434304': 'find', 'sub_43BA8E': '_M_end', 'sub_43BA7C': '_M_begin', 'sub_43BAA0': '_M_lower_bound', 'sub_433934': 'end', 'sub_42E129': 'operator==', 'sub_43A60F': '_S_key', 'sub_433A00': 'operator'} | |
8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2_8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2.jsonl.gz | sub_48F015 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_48F015(__int64 a1, unsigned int a2, __int64 a3, unsigned int a4, const char *a5, __int64 a6)
{
__int64 result; // rax
char v11[16]; // [rsp+30h] [rbp-60h] BYREF
unsigned int s[18]; // [rsp+40h] [rbp-50h] BYREF
unsigned __int64 i; // [rsp+88h] [rbp-8h]
memset(s, 0, sizeof(s));
result = sub_493311(a6, s);
if ( (_DWORD)result )
return sub_48E694(a1, a2, a3, a4, (__int64)"invalid PK context\n");
for ( i = 0LL; i <= 2; ++i )
{
result = s[6 * i];
if ( !(_DWORD)result )
break;
snprintf(v11, 0x10uLL, "%s%s", a5, *(const char **)&s[6 * i + 2]);
v11[15] = 0;
if ( s[6 * i] == 1 )
result = sub_48EC66(a1, a2, a3, a4, v11, *(_QWORD *)&s[6 * i + 4]);
else
result = sub_48E694(a1, a2, a3, a4, (__int64)"should not happen\n");
}
return result;
}
Q:[a3,a4,a1,a2,a5,a6,v11,s,sub_48F015,sub_493311,sub_48E694,sub_48EC66,] | A:{'a3': 'file', 'a4': 'line', 'a1': 'ssl', 'a2': 'level', 'a5': 'text', 'a6': 'pk', 'v11': 'name', 's': 'items', 'sub_48F015': 'debug_print_pk', 'sub_493311': 'mbedtls_pk_debug', 'sub_48E694': 'debug_send_line', 'sub_48EC66': 'mbedtls_debug_print_mpi'} | |
8ae2ab0464f0ac96a7fdeccbe9109d753af18ecfd065336c7a6978a11512a7eb_8ae2ab0464f0ac96a7fdeccbe9109d753af18ecfd065336c7a6978a11512a7eb.jsonl.gz | sub_414229 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_414229(char a1, char a2)
{
int i; // [rsp+14h] [rbp-4h]
for ( i = 32; i <= 126; ++i )
{
sub_413AAF(i, i, 0);
sub_413AAF(i, i + 128, 0);
}
sub_413B43(a1, 0);
return sub_413B43(a2, 1);
}
Q:[a1,a2,i,sub_414229,sub_413AAF,sub_413B43,] | A:{'a1': 'pri', 'a2': 'alt', 'i': 'loop', 'sub_414229': 'saa505xregion', 'sub_413AAF': 'ttxtcopychar', 'sub_413B43': 'saa505xregset'} | |
d4d7ec48682e1e40a04c527f91a614d9afcb7f19dd69a450898dd4339b23abb9_d4d7ec48682e1e40a04c527f91a614d9afcb7f19dd69a450898dd4339b23abb9.jsonl.gz | sub_402973 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_402973(__int64 a1)
{
bool v1; // al
unsigned __int8 v3; // [rsp+17h] [rbp-19h]
unsigned __int64 v4; // [rsp+18h] [rbp-18h]
unsigned __int64 i; // [rsp+20h] [rbp-10h]
unsigned __int8 v6; // [rsp+2Fh] [rbp-1h]
v4 = sub_403044(a1);
v1 = v4 && (unsigned __int8)sub_40305E(a1, 0LL);
v6 = v1;
for ( i = 1LL; i < v4; ++i )
{
v3 = sub_40305E(a1, i);
if ( v3 < v6 )
v6 = v3;
}
return v6;
}
Q:[a1,v3,v4,i,v6,sub_402973,sub_403044,sub_40305E,] | A:{'a1': '__a', 'v3': '__t', 'v4': '__s', 'i': '__i', 'v6': '__r', 'sub_402973': '_BinClos', 'sub_403044': 'size', 'sub_40305E': 'operator[]'} | |
bf7ae1a4450b359f92e96f59068a71bc49375889282b3e96663c3c09631e7838_bf7ae1a4450b359f92e96f59068a71bc49375889282b3e96663c3c09631e7838.jsonl.gz | sub_466B98 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 __fastcall sub_466B98(__int64 a1)
{
return *(_DWORD *)(a1 + 284) != *(_DWORD *)(a1 + 288);
}
Q:[a1,sub_466B98,] | A:{'a1': 'lp', 'sub_466B98': 'tmxr_tpbusyln'} | |
36e2a2b3c90d2417126c548d6e41cc7407e894b30d56150ef0c7c66984693b6d_36e2a2b3c90d2417126c548d6e41cc7407e894b30d56150ef0c7c66984693b6d.jsonl.gz | sub_430724 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_430724(int *a1, unsigned int a2)
{
unsigned int v2; // edx
__int64 result; // rax
__int64 v4; // rbx
__int64 v5; // rax
unsigned int v6; // eax
__int64 v7; // rax
int *v8; // [rsp+8h] [rbp-58h]
__int64 v9; // [rsp+10h] [rbp-50h]
unsigned int v10; // [rsp+1Ch] [rbp-44h]
__int64 v11; // [rsp+28h] [rbp-38h]
int *v12; // [rsp+30h] [rbp-30h]
int v13; // [rsp+38h] [rbp-28h]
int v14; // [rsp+3Ch] [rbp-24h]
__int64 v15; // [rsp+40h] [rbp-20h]
__int64 v16; // [rsp+48h] [rbp-18h]
v14 = 0;
v13 = 0;
v8 = sub_429298(a1);
if ( (unsigned int)sub_42B7B8((unsigned int)v8) == 0x80000000
|| (unsigned int)sub_42B7B8((unsigned int)v8) == -1879048192 )
{
v12 = (int *)sub_441DD3(v8);
sub_42F8E8();
if ( (unsigned int)sub_42B7B8((unsigned int)v12) == -536870912 )
{
v16 = sub_42F8F9(v8, 0, 1u);
}
else
{
v11 = sub_435C7C(v12);
if ( *v8 == 5 )
{
sub_42B929(v11 + 8, (_DWORD)v8 + 8);
v4 = sub_42F8F9(v12, 0, 1u);
v5 = sub_42F8F9(v8 + 1, 0, 1u);
}
else
{
sub_42B929(v11, *(_DWORD *)(v11 + 4));
v4 = sub_42F8F9(v12, 0, 1u);
v5 = sub_42F8F9(v8, 0, 1u);
}
v16 = sub_40968D(5, v5, v4);
v6 = qword_870B10;
qword_870B10 += 4LL;
sub_42B929(v6, (unsigned int)v12);
qword_870B10 += 4LL;
}
sub_442093();
if ( *(_BYTE *)v16 == 8 && *(_DWORD *)(v16 + 8) == 5 )
v7 = *(_QWORD *)(v16 + 40);
else
v7 = v16;
v10 = *(_DWORD *)(v7 + 8);
if ( (unsigned int)sub_4048B8(v10) )
{
sub_403085(
"assert failed: %s/%d is protected",
*((_QWORD *)&unk_6585E8 + 3 * (int)v10),
*((_DWORD *)&unk_6585E0 + 6 * (int)v10));
result = 0LL;
}
else if ( (unsigned int)sub_404880(v10) )
{
dword_462CB8 = dword_870B48;
sub_403464();
if ( a2 )
{
v15 = sub_403E38();
*(_QWORD *)(v15 + 8) = v16;
*(_QWORD *)v15 = *(_QWORD *)(v15 + 8);
if ( (unsigned int)sub_404848(v10) )
{
v9 = sub_404707(v10);
*(_QWORD *)(v15 + 16) = v9;
*(_DWORD *)(v15 + 24) = *(_DWORD *)(v9 + 24) - 1;
if ( !*(_DWORD *)(v15 + 24) )
*(_DWORD *)(v15 + 24) = -1;
}
else
{
*(_QWORD *)(v15 + 16) = 0LL;
*(_DWORD *)(v15 + 24) = 1;
sub_4049FF(v10, v15);
v14 = 1;
v13 = 1;
}
}
else
{
v15 = sub_403B02(v16, v16, 0);
if ( !(unsigned int)sub_404848(v10) )
{
sub_4049CE(v10, v15);
v13 = 1;
}
v14 = 1;
}
*(_DWORD *)(v15 + 28) = dword_462CB8;
qword_855D80 = v15;
if ( dword_462220 - dword_462CB8 <= 256 )
sub_4031C3("no more code space");
sub_40AF7F(*(_QWORD *)(v15 + 8), 0xFFFFFFFF);
if ( dword_462220 - dword_462CB8 <= 256 )
sub_4031C3("no more code space");
*(_DWORD *)(v15 + 32) = dword_462CB8 - 1;
if ( a2 )
sub_4049CE(v10, v15);
else
sub_4049FF(v10, v15);
if ( v13 )
{
sub_404A8F(v10, dword_462CB8);
sub_415902(v10);
sub_404ABD(v10, dword_462CB8 - 1);
sub_404AEB(v10, 1);
}
if ( v14 )
sub_404A30(v10, v15);
dword_870B48 = dword_462CB8;
sub_405249(1);
result = 1LL;
}
else
{
sub_403085(
"assert failed: %s/%d is not dynamic",
*((_QWORD *)&unk_6585E8 + 3 * (int)v10),
*((_DWORD *)&unk_6585E0 + 6 * (int)v10));
result = 0LL;
}
}
else
{
sub_403085("bad argument to assert/1 or assertz/1", a2, v2);
result = 0LL;
}
return result;
}
Q:[a1,a2,v8,v9,v11,v12,v13,v14,v15,v16,sub_430724,sub_429298,sub_42B7B8,sub_441DD3,sub_42F8E8,sub_42F8F9,sub_435C7C,sub_42B929,sub_40968D,sub_442093,sub_4048B8,sub_403085,sub_404880,sub_403464,sub_403E38,sub_404848,sub_404707,sub_4049FF,sub_403B02,sub_4049CE,sub_4031C3,sub_40AF7F,sub_404A8F,sub_415902,sub_404ABD,sub_404AEB,sub_404A30,sub_405249,] | A:{'a1': 't', 'a2': 'start', 'v8': 'ta', 'v9': 'first_rule', 'v11': 'lastc', 'v12': 'dump_constraints', 'v13': 'first_flag', 'v14': 'last_flag', 'v15': 'r', 'v16': 'nt', 'sub_430724': 'do_assert_rule', 'sub_429298': 'findbind', 'sub_42B7B8': 'tag_func', 'sub_441DD3': 'get_rule_constraints', 'sub_42F8E8': 'init_ht_to_pterm', 'sub_42F8F9': 'ht_to_pterm', 'sub_435C7C': 'end_of_constraints', 'sub_42B929': 'make_bound_var_addr_func', 'sub_40968D': 'new_p_func2', 'sub_442093': 'cleanup_dump', 'sub_4048B8': 'p_protected', 'sub_403085': 'warn_err', 'sub_404880': 'p_dynamic', 'sub_403464': 'init_lable', 'sub_403E38': 'new_rule', 'sub_404848': 'p_compiled', 'sub_404707': 'p_first_rule', 'sub_4049FF': 'assign_p_last_rule', 'sub_403B02': 'store_rule', 'sub_4049CE': 'assign_p_first_rule', 'sub_4031C3': 'fatal', 'sub_40AF7F': 'compile_rule', 'sub_404A8F': 'assign_p_start_hdrcode', 'sub_415902': 'emit_dynamic_try', 'sub_404ABD': 'assign_p_end_hdrcode', 'sub_404AEB': 'assign_p_compiled', 'sub_404A30': 'assign_p_last_compiled_rule', 'sub_405249': 'resolve'} | |
614f31b237021943f00edd1722efa5c25b232a880ba0ce0b95bc8b4ce694ebc2_614f31b237021943f00edd1722efa5c25b232a880ba0ce0b95bc8b4ce694ebc2.jsonl.gz | sub_405D85 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_405D85(unsigned __int16 *a1, unsigned __int8 a2, char a3)
{
__int64 v3; // rax
unsigned __int8 v6; // [rsp+0h] [rbp-20h]
int v7; // [rsp+14h] [rbp-Ch]
char v8; // [rsp+1Bh] [rbp-5h]
char v9; // [rsp+1Ch] [rbp-4h]
char v10; // [rsp+1Dh] [rbp-3h]
unsigned __int16 v11; // [rsp+1Eh] [rbp-2h]
unsigned __int16 v12; // [rsp+1Eh] [rbp-2h]
v10 = a3 ^ *((_BYTE *)a1 + a2);
v9 = v10 & a3;
v8 = ~a3 & v10;
LODWORD(v3) = a2;
if ( a2 == 3 )
{
if ( a3 < 0 )
*((_BYTE *)a1 + a2) = a3;
v7 = 1 << (((unsigned __int8)a3 >> 1) & 7);
if ( (a3 & 1) != 0 )
v6 = v7 | *((_BYTE *)a1 + 2);
else
v6 = ~(_BYTE)v7 & a1[1];
LODWORD(v3) = sub_405D85(a1, 2LL, v6);
}
else if ( a2 <= 3u )
{
if ( a2 <= 1u )
{
*((_BYTE *)a1 + a2) = a3;
LODWORD(v3) = *((_DWORD *)a1 + 4);
if ( (_DWORD)v3 )
LODWORD(v3) = fprintf(stderr, "Data now %04X\n", *a1);
}
else if ( a2 == 2 )
{
*((_BYTE *)a1 + a2) = a3;
v3 = *((_QWORD *)a1 + 1);
if ( v3 )
{
if ( a3 >= 0 )
{
if ( *((_DWORD *)a1 + 4) && v8 < 0 )
fwrite("ide exits reset.\n", 1uLL, 0x11uLL, stderr);
v11 = a3 & 7;
if ( (a3 & 0x10) != 0 )
v11 += 2;
if ( (v8 & 0x20) != 0 )
{
if ( *((_DWORD *)a1 + 4) )
fprintf(stderr, "write edge: %02X = %04X\n", v11, *a1);
LODWORD(v3) = sub_405348(*((_QWORD *)a1 + 1), v11, *a1);
}
else
{
LODWORD(v3) = v9 & 0x40;
if ( (v9 & 0x40) != 0 )
{
if ( *((_DWORD *)a1 + 4) )
fprintf(stderr, "read edge: %02X = ", v11);
v12 = sub_4052E9(*((_QWORD *)a1 + 1), v11);
if ( *((_DWORD *)a1 + 4) )
fprintf(stderr, "%04X\n", v12);
*a1 = v12;
LODWORD(v3) = (_DWORD)a1;
}
}
}
else
{
if ( *((_DWORD *)a1 + 4) )
fprintf(stderr, "ide reset state (%02X).\n", (unsigned __int8)a3);
LODWORD(v3) = sub_403FAE(*((_BYTE **)a1 + 1));
}
}
}
}
return v3;
}
Q:[a3,a1,a2,v7,v8,v9,v10,v11,sub_405D85,sub_405348,sub_4052E9,sub_403FAE,] | A:{'a3': 'val', 'a1': 'ppide', 'a2': 'addr', 'v7': 'bit', 'v8': 'dlow', 'v9': 'dhigh', 'v10': 'changed', 'v11': 'da', 'sub_405D85': 'ppide_write', 'sub_405348': 'ide_write16', 'sub_4052E9': 'ide_read16', 'sub_403FAE': 'ide_reset_begin'} | |
28cc4eccbc28769028abf8d86f562e7dc5021b224249e70480e36679f8e6b49a_28cc4eccbc28769028abf8d86f562e7dc5021b224249e70480e36679f8e6b49a.jsonl.gz | sub_40FAD0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 *__fastcall sub_40FAD0(_QWORD *a1)
{
void *v2; // rbp
void *v3; // rdi
void *v4; // rdi
void *v5; // rdi
void *v6; // rdi
void *v7; // rdi
v2 = (void *)a1[9];
*a1 = &`vtable for'SVR_Q + 2;
if ( v2 )
{
sub_4061F0((__int64)v2);
operator delete(v2);
}
v3 = (void *)a1[10];
if ( v3 )
operator delete[](v3);
v4 = (void *)a1[11];
if ( v4 )
operator delete[](v4);
v5 = (void *)a1[13];
if ( v5 )
operator delete[](v5);
v6 = (void *)a1[14];
if ( v6 )
operator delete[](v6);
v7 = (void *)a1[15];
if ( v7 )
operator delete[](v7);
return sub_405BD0(a1);
}
Q:[a1,sub_40FAD0,sub_4061F0,sub_405BD0,] | A:{'a1': 'this', 'sub_40FAD0': '~SVR_Q', 'sub_4061F0': '~Cache', 'sub_405BD0': '~Kernel'} | |
e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6_e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6.jsonl.gz | sub_439624 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_439624(unsigned __int8 a1)
{
if ( a1 == 3 )
return 4LL;
if ( a1 <= 3u )
{
if ( a1 == 1 )
return 2LL;
if ( a1 == 2 )
return 3LL;
}
return 0LL;
}
Q:[a1,sub_439624,] | A:{'a1': 'speed', 'sub_439624': 'toCommonFanSpeed'} | |
bec0a07631308fe77b571886db09a49a5e4be678153bf53f83ebdf8e9d2865bb_bec0a07631308fe77b571886db09a49a5e4be678153bf53f83ebdf8e9d2865bb.jsonl.gz | sub_43ECDF | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43ECDF(unsigned int a1, int a2)
{
if ( !a2 )
return a1;
if ( a1 == 0x80000000 && a2 == -1 )
return 0LL;
return (unsigned int)((int)a1 % a2);
}
Q:[a1,a2,sub_43ECDF,] | A:{'a1': 'a', 'a2': 'b', 'sub_43ECDF': 'rem32_0'} | |
d0acddaf1222c6ab785a4dd1b8f0c6a143a41f26ba52ecfbbf69cd16a46bbd6d_d0acddaf1222c6ab785a4dd1b8f0c6a143a41f26ba52ecfbbf69cd16a46bbd6d.jsonl.gz | sub_4128C6 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4128C6(_DWORD *a1)
{
int v1; // eax
int v2; // ebx
__int64 result; // rax
int k; // [rsp+44h] [rbp-1Ch]
int j; // [rsp+48h] [rbp-18h]
int i; // [rsp+4Ch] [rbp-14h]
v1 = *(unsigned __int16 *)a1;
if ( v1 == 2 )
{
for ( i = 0; i <= 3; ++i )
{
if ( *((_BYTE *)a1 + i + 4) )
return 0LL;
}
result = 1LL;
}
else if ( v1 == 10 )
{
if ( !a1[2] && !a1[3] && (v2 = a1[4], v2 == htonl(0xFFFFu)) )
{
for ( j = 0; j <= 3; ++j )
{
if ( *((_BYTE *)a1 + j + 20) )
return 0LL;
}
}
else
{
for ( k = 0; k <= 15; ++k )
{
if ( *((_BYTE *)a1 + k + 8) )
return 0LL;
}
}
result = 1LL;
}
else
{
result = 0LL;
}
return result;
}
Q:[a1,k,j,sub_4128C6,] | A:{'a1': 'sa', 'k': 'i_1', 'j': 'i_0', 'sub_4128C6': 'addr_is_any'} | |
8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2_8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2.jsonl.gz | sub_41C166 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41C166(__int64 a1, __int64 a2)
{
__int64 result; // rax
sub_41A0EB();
result = (unsigned int)sub_41A17D(a2, *(_QWORD *)(a1 + 40)) ^ 1;
if ( (_BYTE)result )
result = sub_41A1BB(*(_QWORD *)(a1 + 40), a2);
return result;
}
Q:[a1,a2,sub_41C166,sub_41A0EB,sub_41A17D,sub_41A1BB,] | A:{'a1': 'cmd', 'a2': 'pool', 'sub_41C166': 'as_event_put_connection', 'sub_41A0EB': 'as_event_set_conn_last_used', 'sub_41A17D': 'as_async_conn_pool_push_head', 'sub_41A1BB': 'as_event_release_connection'} | |
477af4d40069544556e623d88d3014d4e0d738c019c3c162fcda139de2d22397_477af4d40069544556e623d88d3014d4e0d738c019c3c162fcda139de2d22397.jsonl.gz | sub_40ECCF | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40ECCF(__int64 a1)
{
return a1;
}
Q:[a1,sub_40ECCF,] | A:{'a1': '__t', 'sub_40ECCF': 'forward'} | |
251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651_251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651.jsonl.gz | sub_422AE6 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_422AE6(__int64 a1)
{
__int64 v1; // rax
v1 = sub_42832C(a1);
return sub_428356(v1);
}
Q:[a1,sub_422AE6,sub_42832C,sub_428356,] | A:{'a1': '__functor', 'sub_422AE6': '_M_invoke', 'sub_42832C': '_M_get_pointer', 'sub_428356': 'std::__invoke_r_void_invalid_response_tests()::_lambda()_&__3'} | |
3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353_3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353.jsonl.gz | sub_483096 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned int *__fastcall sub_483096(unsigned int *a1, unsigned int a2)
{
unsigned int v2; // eax
unsigned int *result; // rax
if ( (int)a2 > (int)a1[1] )
{
v2 = sub_483BD6(a1, a2);
sub_483B2E(a1, v2);
}
result = a1;
*a1 = a2;
return result;
}
Q:[a1,a2,sub_483096,sub_483BD6,sub_483B2E,] | A:{'a1': 'this', 'a2': 'new_size', 'sub_483096': 'resize', 'sub_483BD6': '_grow_capacity', 'sub_483B2E': 'reserve'} | |
20c07804a3f28a6a5c3f8253e79de0ec1aedc41632a0737ad8dad981cd237640_20c07804a3f28a6a5c3f8253e79de0ec1aedc41632a0737ad8dad981cd237640.jsonl.gz | sub_409667 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_409667(__int64 *a1, const void *a2, const char *a3)
{
__int64 v5; // [rsp+18h] [rbp-28h]
__int64 v6; // [rsp+20h] [rbp-20h]
__int64 v7; // [rsp+28h] [rbp-18h]
unsigned __int64 j; // [rsp+30h] [rbp-10h]
unsigned __int64 i; // [rsp+38h] [rbp-8h]
v6 = *a1;
for ( i = 0LL; i < *(_QWORD *)(v6 + 48); ++i )
{
v7 = 0LL;
v5 = *(_QWORD *)(*(_QWORD *)(v6 + 104) + 8 * i);
for ( j = 0LL; j < *(_QWORD *)(v5 + 56); ++j )
{
v7 = *(_QWORD *)(*(_QWORD *)(v5 + 64) + 8 * j);
if ( !strcmp(a3, *(const char **)(v7 + 16)) )
break;
v7 = 0LL;
}
if ( v7 && sub_40942D(v5, a2) )
return v7;
}
return 0LL;
}
Q:[a3,a1,a2,v5,v6,v7,sub_409667,sub_40942D,] | A:{'a3': 'ifname', 'a1': 'iface', 'a2': 'addr', 'v5': 'ifacea', 'v6': 'interfaces', 'v7': 'hapd', 'sub_409667': 'sta_track_seen_on', 'sub_40942D': 'sta_track_get'} | |
60ca250f4cce765620e45312d0d0a7d8c03e6784ce018e7dbb376a4a97ce5956_60ca250f4cce765620e45312d0d0a7d8c03e6784ce018e7dbb376a4a97ce5956.jsonl.gz | sub_405710 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_405710(__int64 a1, __int64 a2, int a3)
{
int v3; // er9
int v4; // er10
int v5; // ecx
unsigned __int16 *v6; // r11
int v7; // er13
__int64 v8; // r12
int v9; // edx
int v10; // eax
int v11; // ebx
__int64 v12; // r10
__int64 v13; // rcx
__int64 v14; // r14
__int64 v15; // rdx
__int64 v16; // rcx
int v17; // esi
int v18; // ecx
int v19; // er13
__int16 v20; // dx
int v21; // ecx
int v22; // esi
__int64 v23; // rax
int v24; // er10
int v25; // eax
__int64 v26; // rcx
__int64 v27; // r13
__int64 v28; // rcx
__int64 v29; // rsi
int v30; // er10
int v31; // edx
int v32; // esi
__int64 v33; // rcx
__int64 v34; // r13
__int64 v35; // rcx
__int64 v36; // rsi
int v37; // ecx
int v38; // eax
int v39; // edx
__int64 v40; // rcx
__int16 v41; // si
__int64 v42; // rdx
__int64 v43; // rdx
__int64 v44; // rcx
int v45; // er13
int v46; // er10
int v47; // esi
__int64 v48; // rcx
__int64 v49; // r14
__int64 v50; // rcx
__int64 v51; // rsi
int v52; // ecx
int v53; // edx
int v54; // eax
__int64 v55; // rcx
__int16 v56; // si
__int64 v57; // rax
__int64 v58; // rax
__int64 v59; // rcx
int v60; // er13
int v61; // er10
int v62; // esi
int v63; // ecx
int v64; // edx
int v65; // eax
__int64 v66; // rcx
__int16 v67; // si
__int64 v68; // rax
__int64 v69; // rax
__int64 v70; // rcx
__int64 v71; // rcx
__int64 v72; // r14
__int64 v73; // rcx
__int64 v74; // rsi
v3 = *(unsigned __int16 *)(a2 + 2);
v4 = 4 - (v3 == 0);
v5 = v3 == 0 ? 138 : 7;
if ( a3 >= 0 )
{
v6 = (unsigned __int16 *)(a2 + 6);
v7 = -1;
v8 = a2 + 4LL * a3 + 10;
v9 = 0;
do
{
v10 = v9 + 1;
v11 = *v6;
if ( v9 + 1 >= v5 )
goto LABEL_16;
if ( v11 == v3 )
{
++v9;
goto LABEL_14;
}
if ( v10 >= v4 )
{
LABEL_16:
v21 = *(_DWORD *)(a1 + 5940);
v22 = *(unsigned __int16 *)(a1 + 5936);
if ( v3 )
{
if ( v3 != v7 )
{
v23 = a1 + 4LL * v3;
v24 = *(unsigned __int16 *)(v23 + 2750);
v25 = *(unsigned __int16 *)(v23 + 2748);
v22 |= v25 << v21;
*(_WORD *)(a1 + 5936) = v22;
if ( 16 - v24 >= v21 )
{
v21 += v24;
}
else
{
v26 = *(_QWORD *)(a1 + 40);
v27 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v26 + 1;
*(_BYTE *)(v27 + v26) = v22;
v28 = *(_QWORD *)(a1 + 40);
LOBYTE(v27) = *(_BYTE *)(a1 + 5937);
v29 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v28 + 1;
*(_BYTE *)(v29 + v28) = v27;
LODWORD(v27) = *(_DWORD *)(a1 + 5940);
v21 = v27 + v24 - 16;
v22 = v25 >> (16 - v27);
*(_WORD *)(a1 + 5936) = v22;
}
LOWORD(v10) = v9;
*(_DWORD *)(a1 + 5940) = v21;
}
v30 = *(unsigned __int16 *)(a1 + 2812);
v31 = *(unsigned __int16 *)(a1 + 2814);
v32 = (v30 << v21) | v22;
*(_WORD *)(a1 + 5936) = v32;
if ( 16 - v31 >= v21 )
{
v37 = v31 + v21;
}
else
{
v33 = *(_QWORD *)(a1 + 40);
v34 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v33 + 1;
*(_BYTE *)(v34 + v33) = v32;
v35 = *(_QWORD *)(a1 + 40);
LOBYTE(v34) = *(_BYTE *)(a1 + 5937);
v36 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v35 + 1;
*(_BYTE *)(v36 + v35) = v34;
LODWORD(v34) = *(_DWORD *)(a1 + 5940);
v37 = v34 + v31 - 16;
v32 = v30 >> (16 - v34);
*(_WORD *)(a1 + 5936) = v32;
}
*(_DWORD *)(a1 + 5940) = v37;
v38 = (unsigned __int16)(v10 - 3);
if ( v37 > 14 )
{
v39 = v38 << v37;
v40 = *(_QWORD *)(a1 + 16);
v41 = v39 | v32;
v42 = *(_QWORD *)(a1 + 40);
*(_WORD *)(a1 + 5936) = v41;
*(_QWORD *)(a1 + 40) = v42 + 1;
*(_BYTE *)(v40 + v42) = v41;
v43 = *(_QWORD *)(a1 + 40);
LOBYTE(v41) = *(_BYTE *)(a1 + 5937);
v44 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v43 + 1;
*(_BYTE *)(v44 + v43) = v41;
LODWORD(v43) = *(_DWORD *)(a1 + 5940);
*(_DWORD *)(a1 + 5940) = v43 - 14;
*(_WORD *)(a1 + 5936) = v38 >> (16 - v43);
if ( v11 )
{
LABEL_11:
if ( v11 == v3 )
{
v7 = v11;
v4 = 3;
v5 = 6;
}
else
{
v7 = v3;
v4 = 4;
v5 = 7;
}
v9 = 0;
goto LABEL_14;
}
goto LABEL_25;
}
*(_DWORD *)(a1 + 5940) = v37 + 2;
*(_WORD *)(a1 + 5936) = (v38 << v37) | v32;
}
else if ( v10 > 10 )
{
v60 = *(unsigned __int16 *)(a1 + 2820);
v61 = *(unsigned __int16 *)(a1 + 2822);
v62 = (v60 << v21) | v22;
*(_WORD *)(a1 + 5936) = v62;
if ( 16 - v61 < v21 )
{
v71 = *(_QWORD *)(a1 + 40);
v72 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v71 + 1;
*(_BYTE *)(v72 + v71) = v62;
v73 = *(_QWORD *)(a1 + 40);
LOBYTE(v72) = *(_BYTE *)(a1 + 5937);
v74 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v73 + 1;
*(_BYTE *)(v74 + v73) = v72;
LODWORD(v72) = *(_DWORD *)(a1 + 5940);
v63 = v72 + v61 - 16;
v62 = v60 >> (16 - v72);
*(_WORD *)(a1 + 5936) = v62;
*(_DWORD *)(a1 + 5940) = v63;
if ( v63 > 9 )
{
LABEL_33:
v64 = (unsigned __int16)(v9 - 10);
v65 = v64 << v63;
v66 = *(_QWORD *)(a1 + 16);
v67 = v65 | v62;
v68 = *(_QWORD *)(a1 + 40);
*(_WORD *)(a1 + 5936) = v67;
*(_QWORD *)(a1 + 40) = v68 + 1;
*(_BYTE *)(v66 + v68) = v67;
v69 = *(_QWORD *)(a1 + 40);
LOBYTE(v67) = *(_BYTE *)(a1 + 5937);
v70 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v69 + 1;
*(_BYTE *)(v70 + v69) = v67;
LODWORD(v69) = *(_DWORD *)(a1 + 5940);
*(_DWORD *)(a1 + 5940) = v69 - 9;
*(_WORD *)(a1 + 5936) = v64 >> (16 - v69);
goto LABEL_10;
}
}
else
{
v63 = v61 + v21;
*(_DWORD *)(a1 + 5940) = v63;
if ( v63 > 9 )
goto LABEL_33;
}
*(_DWORD *)(a1 + 5940) = v63 + 7;
*(_WORD *)(a1 + 5936) = ((unsigned __int16)(v9 - 10) << v63) | v62;
}
else
{
v45 = *(unsigned __int16 *)(a1 + 2816);
v46 = *(unsigned __int16 *)(a1 + 2818);
v47 = (v45 << v21) | v22;
*(_WORD *)(a1 + 5936) = v47;
if ( 16 - v46 >= v21 )
{
v52 = v46 + v21;
*(_DWORD *)(a1 + 5940) = v52;
if ( v52 > 13 )
{
LABEL_29:
v53 = (unsigned __int16)(v9 - 2);
v54 = v53 << v52;
v55 = *(_QWORD *)(a1 + 16);
v56 = v54 | v47;
v57 = *(_QWORD *)(a1 + 40);
*(_WORD *)(a1 + 5936) = v56;
*(_QWORD *)(a1 + 40) = v57 + 1;
*(_BYTE *)(v55 + v57) = v56;
v58 = *(_QWORD *)(a1 + 40);
LOBYTE(v56) = *(_BYTE *)(a1 + 5937);
v59 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v58 + 1;
*(_BYTE *)(v59 + v58) = v56;
LODWORD(v58) = *(_DWORD *)(a1 + 5940);
*(_DWORD *)(a1 + 5940) = v58 - 13;
*(_WORD *)(a1 + 5936) = v53 >> (16 - v58);
goto LABEL_10;
}
}
else
{
v48 = *(_QWORD *)(a1 + 40);
v49 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v48 + 1;
*(_BYTE *)(v49 + v48) = v47;
v50 = *(_QWORD *)(a1 + 40);
LOBYTE(v49) = *(_BYTE *)(a1 + 5937);
v51 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v50 + 1;
*(_BYTE *)(v51 + v50) = v49;
LODWORD(v49) = *(_DWORD *)(a1 + 5940);
v52 = v49 + v46 - 16;
v47 = v45 >> (16 - v49);
*(_WORD *)(a1 + 5936) = v47;
*(_DWORD *)(a1 + 5940) = v52;
if ( v52 > 13 )
goto LABEL_29;
}
*(_DWORD *)(a1 + 5940) = v52 + 3;
*(_WORD *)(a1 + 5936) = ((unsigned __int16)(v9 - 2) << v52) | v47;
}
}
else
{
v12 = a1 + 4LL * v3;
do
{
while ( 1 )
{
v17 = *(unsigned __int16 *)(v12 + 2748);
v18 = *(_DWORD *)(a1 + 5940);
v19 = *(unsigned __int16 *)(v12 + 2750);
v20 = *(_WORD *)(a1 + 5936) | (v17 << v18);
*(_WORD *)(a1 + 5936) = v20;
if ( v18 <= 16 - v19 )
break;
v13 = *(_QWORD *)(a1 + 40);
v14 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v13 + 1;
*(_BYTE *)(v14 + v13) = v20;
v15 = *(_QWORD *)(a1 + 40);
LOBYTE(v14) = *(_BYTE *)(a1 + 5937);
v16 = *(_QWORD *)(a1 + 16);
*(_QWORD *)(a1 + 40) = v15 + 1;
*(_BYTE *)(v16 + v15) = v14;
LODWORD(v15) = *(_DWORD *)(a1 + 5940);
--v10;
*(_WORD *)(a1 + 5936) = v17 >> (16 - v15);
*(_DWORD *)(a1 + 5940) = v15 + v19 - 16;
if ( !v10 )
goto LABEL_10;
}
--v10;
*(_DWORD *)(a1 + 5940) = v19 + v18;
}
while ( v10 );
}
LABEL_10:
if ( v11 )
goto LABEL_11;
LABEL_25:
v9 = 0;
v7 = v3;
v4 = 3;
v5 = 138;
LABEL_14:
v6 += 2;
v3 = v11;
}
while ( (unsigned __int16 *)v8 != v6 );
}
}
Q:[sub_405710,] | A:{'sub_405710': 'send_tree'} | |
863ee06768ce415c250f1907f601671ff2f629debe2a52e8a1d80b78953405a9_863ee06768ce415c250f1907f601671ff2f629debe2a52e8a1d80b78953405a9.jsonl.gz | sub_401DA9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_401DA9(__int64 a1)
{
return sub_403C0D(a1);
}
Q:[a1,sub_401DA9,sub_403C0D,] | A:{'a1': 'com', 'sub_401DA9': 'average_delete', 'sub_403C0D': 'component_delete'} | |
7301b6e819ff084818bf7bd8fce59c1aa17e3d4892c34b25c84a11ff0b5959c5_7301b6e819ff084818bf7bd8fce59c1aa17e3d4892c34b25c84a11ff0b5959c5.jsonl.gz | sub_42BDBE | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42BDBE(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
switch ( *(_BYTE *)(a3 + a4) )
{
case '-':
return a4 + 1;
case '<':
*(_DWORD *)(a1 + 320) = 31;
break;
case '>':
*(_DWORD *)(a1 + 320) = 5;
break;
default:
*(_DWORD *)(a1 + 320) = 28;
break;
}
return a4 + 1;
}
Q:[a3,a4,a1,a2,sub_42BDBE,] | A:{'a3': 'html', 'a4': 'html_offset', 'a1': 'tree', 'a2': 'token_node', 'sub_42BDBE': 'myhtml_tokenizer_state_script_data_double_escaped_dash_dash'} | |
a26b940785adaaba7ee67968f766ef928db5f9be311013ff565dd9da1b43b838_a26b940785adaaba7ee67968f766ef928db5f9be311013ff565dd9da1b43b838.jsonl.gz | sub_4092AF | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4092AF(__int64 a1)
{
return sub_409347(a1);
}
Q:[sub_4092AF,sub_409347,] | A:{'sub_4092AF': '_M_head', 'sub_409347': '_M_head'} | |
14c39801a976c945416b12662f5fa02721a11b799f493db0c913091da70eab07_14c39801a976c945416b12662f5fa02721a11b799f493db0c913091da70eab07.jsonl.gz | sub_405D26 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_405D26(__int64 a1, char *a2)
{
struct stat64 stat_buf; // [rsp+10h] [rbp-90h] BYREF
if ( !*(_DWORD *)(a1 + 88) )
return sub_40331E(a1, "530 Please login with USER and PASS.\r\n");
if ( *(int *)(a1 + 88) <= 1 )
return sub_40331E(a1, "550 Permission denied.\r\n");
if ( !a2 )
return sub_40331E(a1, "501 Syntax error in parameters or arguments.\r\n");
if ( !*(_DWORD *)(a1 + 56) || *(_DWORD *)(a1 + 80) != -1 )
return sub_40331E(a1, "550 Another action is in progress, use ABOR command first.\r\n");
sub_402E50((const char *)(a1 + 8312), (const char *)(a1 + 120), a2, 0x2000uLL, (void *)(a1 + 16504));
if ( (unsigned int)sub_407E10((char *)(a1 + 16504), &stat_buf) )
goto LABEL_15;
if ( *(_DWORD *)(a1 + 88) != 3 )
return sub_40331E(a1, "550 Permission denied.\r\n");
if ( (stat_buf.st_mode & 0xF000) != 0x8000 )
return sub_40331E(a1, "550 File or directory unavailable.\r\n");
LABEL_15:
sub_40331E(a1, "150 File status okay; about to open data connection.\r\n");
sub_403509(a1, " STOR: ", a2);
sub_40372F(a1, (void *(*)(void *))sub_40587B);
return 1LL;
}
Q:[a1,a2,stat_buf,sub_405D26,sub_40331E,sub_402E50,sub_407E10,sub_403509,sub_40372F,sub_40587B,] | A:{'a1': 'context', 'a2': 'params', 'stat_buf': 'filestats', 'sub_405D26': 'ftpSTOR', 'sub_40331E': 'sendstring', 'sub_402E50': 'ftp_effective_path', 'sub_407E10': 'stat64', 'sub_403509': 'writelogentry', 'sub_40372F': 'worker_thread_start', 'sub_40587B': 'stor_thread'} | |
81615611eb13cf9a4fb3d460dcb3d94fef45de4faf895a7ec0e40c42cadbba6d_81615611eb13cf9a4fb3d460dcb3d94fef45de4faf895a7ec0e40c42cadbba6d.jsonl.gz | sub_40EE85 | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_40EE85()
{
;
}
Q:[sub_40EE85,] | A:{'sub_40EE85': 'get_restricted_token'} | |
45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0_45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0.jsonl.gz | sub_416DC6 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_416DC6(__int64 a1)
{
return sub_416F6A(a1);
}
Q:[a1,sub_416DC6,sub_416F6A,] | A:{'a1': 'this', 'sub_416DC6': '~_Rb_tree_impl', 'sub_416F6A': '~allocator'} | |
e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433_e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433.jsonl.gz | sub_44EF82 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_44EF82()
{
return sub_44EB3E();
}
Q:[sub_44EF82,sub_44EB3E,] | A:{'sub_44EF82': 'max_size', 'sub_44EB3E': '_M_max_size'} | |
e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6_e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6.jsonl.gz | sub_4730B6 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4730B6(__int64 a1, char a2)
{
__int64 result; // rax
result = a1;
*(_BYTE *)(a1 + 110135) = (4 * (a2 & 1)) | *(_BYTE *)(a1 + 110135) & 0xFB;
return result;
}
Q:[a1,a2,sub_4730B6,] | A:{'a1': 'this', 'a2': 'state', 'sub_4730B6': 'setAbsenseDetect'} | |
b050fc82c68487717668b1441a9b5fcc63c622a19856061d7f6135c9fff3cecf_b050fc82c68487717668b1441a9b5fcc63c622a19856061d7f6135c9fff3cecf.jsonl.gz | sub_4029FF | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4029FF(__int64 *a1, float a2)
{
_DWORD *v2; // rax
int v4[16]; // [rsp+10h] [rbp-80h] BYREF
int v5[3]; // [rsp+50h] [rbp-40h] BYREF
int v6[4]; // [rsp+5Ch] [rbp-34h] BYREF
int v7[3]; // [rsp+6Ch] [rbp-24h] BYREF
__int64 *v8; // [rsp+78h] [rbp-18h]
__int64 i; // [rsp+80h] [rbp-10h]
__int64 *v10; // [rsp+88h] [rbp-8h]
v7[0] = 0;
v7[1] = 0;
v7[2] = 0;
v10 = 0LL;
v8 = 0LL;
i = 0LL;
for ( i = *a1; i != a1[1]; i = *(_QWORD *)(i + 8) )
{
v8 = v10;
v10 = *(__int64 **)i;
if ( v8 )
{
sub_4024D1(*v8, (float *)v5, (float *)v6);
*(float *)v7 = (float)((float)(*(float *)v6 - *(float *)v5) / 2.0) + *(float *)v7;
sub_4024D1(*v10, (float *)v5, (float *)v6);
*(float *)v7 = (float)((float)(*(float *)v6 - *(float *)v5) / 2.0) + *(float *)v7;
*(float *)v7 = *(float *)v7 + a2;
v2 = sub_40226E(v4, v7);
sub_401429((__int64)v10, (__int64)v2);
}
}
return a1[3];
}
Q:[a1,a2,v4,v5,v7,v8,i,v10,sub_4029FF,sub_4024D1,sub_40226E,sub_401429,] | A:{'a1': 'objects', 'a2': 'buffer', 'v4': 'transform', 'v5': 'bounds', 'v7': 'offset', 'v8': 'last', 'i': 'tl_iter', 'v10': 'current', 'sub_4029FF': 'chain_pack', 'sub_4024D1': 'object_bounds', 'sub_40226E': 'init_transform_translate_f', 'sub_401429': 'transform_chain'} | |
dde82f30bb011940478bd4895b01e213dc10ad4cb289f4d397d2e1f971e3baf0_dde82f30bb011940478bd4895b01e213dc10ad4cb289f4d397d2e1f971e3baf0.jsonl.gz | sub_4074E9 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_4074E9(__int64 a1, char a2)
{
return (a1 & (unsigned __int64)(1 << a2)) >> a2;
}
Q:[a1,sub_4074E9,] | A:{'a1': 'up_map', 'sub_4074E9': 'map_get'} |