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 |
|---|---|---|---|---|---|
f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83_f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83.jsonl.gz | sub_456CFA | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_456CFA(_DWORD *a1, __int64 a2)
{
unsigned int v3; // [rsp+1Ch] [rbp-4h]
v3 = a1[2] != *(_QWORD *)(a2 + 88);
if ( dword_4F75FC && dword_4F7600 && *a1 != (unsigned int)*(_QWORD *)(a2 + 104) )
v3 |= 2u;
if ( dword_4F7600 )
{
if ( a1[6] != *(_DWORD *)(a2 + 28) || a1[7] != *(_DWORD *)(a2 + 32) )
v3 |= 4u;
if ( a1[5] != (unsigned int)*(_QWORD *)(a2 + 8) )
v3 |= 0x10u;
}
if ( a1[8] != (unsigned int)*(_QWORD *)(a2 + 48) )
v3 |= 0x20u;
return v3;
}
Q:[a1,a2,v3,sub_456CFA,] | A:{'a1': 'sd', 'a2': 'st', 'v3': 'changed', 'sub_456CFA': 'match_stat_data'} | |
8ae2ab0464f0ac96a7fdeccbe9109d753af18ecfd065336c7a6978a11512a7eb_8ae2ab0464f0ac96a7fdeccbe9109d753af18ecfd065336c7a6978a11512a7eb.jsonl.gz | sub_43DB08 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43DB08(__int64 a1, int a2, int a3, int a4, int a5, int a6)
{
int v6; // edx
int v7; // ecx
int v8; // er8
int v9; // er9
int v10; // eax
int v11; // edx
int v12; // ecx
int v13; // er8
int v14; // er9
__int64 result; // rax
int v16; // [rsp+4h] [rbp-Ch]
char *v17; // [rsp+8h] [rbp-8h]
if ( *(_BYTE *)++qword_4B9CE8 != 40 )
{
a1 = 5LL;
error(5, a2, a3, a4, a5, a6);
}
++qword_4B9CE8;
v17 = sub_43D952(a1, a2, a3, a4, a5, a6);
v10 = *(unsigned __int8 *)qword_4B9CE8;
if ( v10 == 41 )
{
sub_44F152(**((unsigned int **)v17 + 5));
result = ++qword_4B9CE8;
}
else if ( v10 == 44 )
{
++qword_4B9CE8;
v16 = sub_403AD2();
if ( *(_BYTE *)qword_4B9CE8 != 41 )
error(38, a2, v11, v12, v13, v14);
++qword_4B9CE8;
if ( v16 <= 0 || v16 > **((_DWORD **)v17 + 5) )
error(27, a2, v11, v12, v13, v14);
result = sub_44F152((unsigned int)(*(_DWORD *)(*((_QWORD *)v17 + 5) + 4 * (v16 - 1 + 4LL)) - 1));
}
else
{
result = error(5, a2, v6, v7, v8, v9);
}
return result;
}
Q:[v16,v17,sub_43DB08,sub_43D952,sub_44F152,sub_403AD2,] | A:{'v16': 'dimension', 'v17': 'vp', 'sub_43DB08': 'fn_dim', 'sub_43D952': 'get_arrayname', 'sub_44F152': 'push_int', 'sub_403AD2': 'eval_integer'} | |
2c0593b564bef489c77724f81cb4f7c32fbd2800e3c3c6955cfdbc0730dc9542_2c0593b564bef489c77724f81cb4f7c32fbd2800e3c3c6955cfdbc0730dc9542.jsonl.gz | sub_4019AB | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_4019AB()
{
__int64 result; // rax
char v1; // [rsp+Bh] [rbp-5h] BYREF
unsigned int v2; // [rsp+Ch] [rbp-4h]
v2 = sub_401847(0, 0x102u, (__int64)&v1, 1);
if ( (v2 & 0x80000000) != 0 )
result = v2;
else
result = v1 & 1;
return result;
}
Q:[v1,v2,sub_4019AB,sub_401847,] | A:{'v1': 'val', 'v2': 'r', 'sub_4019AB': 'get_sd_boot_disabled', 'sub_401847': 'eeprom'} | |
7301b6e819ff084818bf7bd8fce59c1aa17e3d4892c34b25c84a11ff0b5959c5_7301b6e819ff084818bf7bd8fce59c1aa17e3d4892c34b25c84a11ff0b5959c5.jsonl.gz | sub_41BF49 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41BF49(unsigned __int8 a1, __int64 a2)
{
if ( (a1 & 0x80u) != 0 )
*(_QWORD *)(a2 + 24) = qword_5B7700[a1 - 128];
else
*(_QWORD *)(a2 + 24) = a1;
return 0LL;
}
Q:[a1,a2,sub_41BF49,] | A:{'a1': 'data', 'a2': 'res', 'sub_41BF49': 'myencoding_decode_windows_1257'} | |
e6951f37e53aa26b8cc1158f7a801b19b5050181eb2932e812d0435a1aa23f66_e6951f37e53aa26b8cc1158f7a801b19b5050181eb2932e812d0435a1aa23f66.jsonl.gz | sub_420AF4 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_420AF4(unsigned int a1, char *a2)
{
if ( *(_QWORD *)(qword_4335F0 + 8LL * a1) )
{
(*(void (__fastcall **)(_QWORD, __int64))(qword_4335F0 + 8LL * a1))(a1, qword_4335D8);
}
else
{
switch ( a1 )
{
case 1u:
if ( *(_QWORD *)(qword_4335D8 + 16) )
fprintf(
stderr,
"the mandatory parameter(s) %s are missing in the context introduced by %s.\n",
a2,
*(const char **)(qword_4335D8 + 16));
else
fprintf(stderr, "The mandatory parameter(s) %s are missing in the main context.\n", a2);
free(a2);
break;
case 2u:
fprintf(stderr, a2, *(_QWORD *)(qword_4335D8 + 64), *(_QWORD *)(qword_4335D8 + 72));
break;
case 3u:
if ( *(_QWORD *)(qword_4335D8 + 40) )
fprintf(stderr, "%s requires argument(s).\n", *(const char **)(qword_4335D8 + 40));
else
fprintf(stderr, "%s requires argument(s).\n", *(const char **)(qword_4335D8 + 48));
break;
case 4u:
if ( *(_QWORD *)(qword_4335D8 + 40) )
fprintf(
stderr,
"The parameter %s can only appear once in the context introduced by %s.\n",
*(const char **)(qword_4335D8 + 56),
*(const char **)(qword_4335D8 + 16));
else
fprintf(
stderr,
"The parameter %s can only appear once in the main context.\n",
*(const char **)(qword_4335D8 + 56));
break;
case 5u:
fprintf(stderr, "Unknown parameter %s.\n%s", *(const char **)(qword_4335D8 + 48), a2);
break;
case 6u:
fprintf(stderr, "The parameter %s is incompatible with %s.\n", *(const char **)(qword_4335D8 + 48), a2);
break;
case 7u:
if ( *(_QWORD *)(qword_4335D8 + 16) )
fprintf(
stderr,
"The parameter %s must appear exactly %d times in the context introduced by %s.\n",
*(const char **)(qword_4335D8 + 56),
*(unsigned int *)(qword_4335D8 + 32),
*(const char **)(qword_4335D8 + 16));
else
fprintf(
stderr,
"The parameter %s must appear exactly %d times in the main context.\n",
*(const char **)(qword_4335D8 + 56),
*(unsigned int *)(qword_4335D8 + 32));
break;
case 8u:
if ( *(_QWORD *)(qword_4335D8 + 16) )
fprintf(
stderr,
"The parameter %s must appear less than %d times in the context introduced by %s.\n",
*(const char **)(qword_4335D8 + 56),
*(unsigned int *)(qword_4335D8 + 32),
*(const char **)(qword_4335D8 + 16));
else
fprintf(
stderr,
"The parameter %s must appear less than %d times in the main context.\n",
*(const char **)(qword_4335D8 + 56),
*(unsigned int *)(qword_4335D8 + 32));
break;
case 9u:
if ( *(_QWORD *)(qword_4335D8 + 16) )
fprintf(
stderr,
"The parameter %s must appear more than %d times in the context introduced by %s.\n",
*(const char **)(qword_4335D8 + 56),
*(unsigned int *)(qword_4335D8 + 32),
*(const char **)(qword_4335D8 + 16));
else
fprintf(
stderr,
"The parameter %s must appear more than %d times in the main context.\n",
*(const char **)(qword_4335D8 + 56),
*(unsigned int *)(qword_4335D8 + 32));
break;
case 0xAu:
fprintf(
stderr,
"The parameter %s must have exactly %d arguments.\n",
*(const char **)(qword_4335D8 + 48),
*(unsigned int *)(qword_4335D8 + 36));
break;
case 0xBu:
fprintf(
stderr,
"The parameter %s must have less than %d arguments.\n",
*(const char **)(qword_4335D8 + 48),
*(unsigned int *)(qword_4335D8 + 36));
break;
case 0xCu:
fprintf(
stderr,
"The parameter %s must have more than %d arguments.\n",
*(const char **)(qword_4335D8 + 48),
*(unsigned int *)(qword_4335D8 + 36));
break;
case 0xDu:
if ( *(_QWORD *)(qword_4335D8 + 48) )
fprintf(
stderr,
"The parameter %s takes no arguments or has too many arguments.\n",
*(const char **)(qword_4335D8 + 48));
break;
default:
break;
}
}
if ( a1 == 5 && *a2 )
sub_426AC2(0LL);
else
sub_42698B(*(_QWORD *)(qword_4335D8 + 8), 0LL);
exit(a1);
}
Q:[a1,a2,sub_420AF4,sub_426AC2,sub_42698B,] | A:{'a1': 'e', 'a2': 'errmsg', 'sub_420AF4': 'fatal', 'sub_426AC2': 'ctxopt_disp_usage', 'sub_42698B': 'ctxopt_ctx_disp_usage'} | |
3f1dbef0dcf52c12d23f5f5f78b2c3a922afbe6ead5cd010f21e0c1d6bff98ee_3f1dbef0dcf52c12d23f5f5f78b2c3a922afbe6ead5cd010f21e0c1d6bff98ee.jsonl.gz | sub_7000DEAB | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_7000DEAB()
{
;
}
Q:[sub_7000DEAB,] | A:{'sub_7000DEAB': 'do_jno_i_w'} | |
6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58_6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58.jsonl.gz | sub_422CB8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_422CB8(__int64 a1)
{
__int64 result; // rax
result = sub_407247(a1, 1, 6, *(_BYTE *)(a1 + 5));
*(_BYTE *)(a1 + 5) = result;
return result;
}
Q:[a1,sub_422CB8,sub_407247,] | A:{'a1': 'ctx', 'sub_422CB8': 'SET_6_D', 'sub_407247': 'doSetRes'} | |
bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b_bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b.jsonl.gz | sub_435F8E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_435F8E(__int64 a1, __int64 a2)
{
return sub_43F06E(a1, a2);
}
Q:[sub_435F8E,sub_43F06E,] | A:{'sub_435F8E': 'lower_bound', 'sub_43F06E': 'lower_bound'} | |
2be14a6f399dc7f092d4927f4d1d5af584fa371659d9020c953c39e9f1fbedfe_2be14a6f399dc7f092d4927f4d1d5af584fa371659d9020c953c39e9f1fbedfe.jsonl.gz | sub_403B1E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_403B1E()
{
return glClear();
}
Q:[sub_403B1E,] | A:{'sub_403B1E': 'clear_screen'} | |
ed44ca9dcc1242045d57739612f7f576c6fb3ac81cc29b7aa045231f88565267_ed44ca9dcc1242045d57739612f7f576c6fb3ac81cc29b7aa045231f88565267.jsonl.gz | sub_409BE0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_409BE0(__int64 a1, __int64 a2)
{
unsigned int v2; // er12
const char *v3; // r15
__int64 v5; // rsi
const char *v6; // [rsp+8h] [rbp-110h]
unsigned __int8 v7; // [rsp+8h] [rbp-110h]
unsigned int v8; // [rsp+1Ch] [rbp-FCh] BYREF
char *s2[2]; // [rsp+20h] [rbp-F8h] BYREF
__int64 v10[2]; // [rsp+30h] [rbp-E8h] BYREF
void *v11[2]; // [rsp+40h] [rbp-D8h] BYREF
__int64 v12[2]; // [rsp+50h] [rbp-C8h] BYREF
void *v13[2]; // [rsp+60h] [rbp-B8h] BYREF
__int64 v14[2]; // [rsp+70h] [rbp-A8h] BYREF
char *s1[2]; // [rsp+80h] [rbp-98h] BYREF
__int64 v16; // [rsp+90h] [rbp-88h] BYREF
unsigned int v17; // [rsp+A0h] [rbp-78h]
void *v18; // [rsp+C0h] [rbp-58h]
__int64 v19; // [rsp+D0h] [rbp-48h] BYREF
LOBYTE(v10[0]) = 0;
s2[0] = (char *)v10;
s2[1] = 0LL;
sub_40F410(s1);
v2 = sub_431A60(a2, s2, &v8);
if ( !(_BYTE)v2 )
{
sub_440C80(1LL, "EventIncomingRequestAuth - GetTopViaIpPort error");
v5 = sub_432D50(a2, 400LL);
if ( v5 )
sub_421CD0(&unk_45F628, v5);
LABEL_18:
v2 = 0;
goto LABEL_9;
}
if ( (unsigned __int8)sub_410F70(&unk_4600C0, s2[0], *(_QWORD *)(a2 + 552)) )
{
sub_440C80(256LL, "EventIncomingRequestAuth ip(%s) user(%s) IP-PBX => allowed", s2[0], *(const char **)(a2 + 552));
goto LABEL_9;
}
if ( (unsigned __int8)sub_40F6B0(&unk_460060, *(_QWORD *)(a2 + 344), s1) )
goto LABEL_4;
v11[1] = 0LL;
v11[0] = v12;
LOBYTE(v12[0]) = 0;
if ( !(unsigned __int8)sub_4315D0(a2, &off_447693) )
{
v7 = sub_410CC0(&unk_4600C0, s2[0], *(_QWORD *)(a2 + 552), v11);
if ( !v7 )
goto LABEL_25;
sub_440C80(
256LL,
"EventIncomingRequestAuth ip(%s) user(%s) IP-PBX dest_user(%s)",
s2[0],
*(const char **)(a2 + 552),
(const char *)v11[0]);
LABEL_31:
v2 = v7;
goto LABEL_32;
}
v13[1] = 0LL;
v13[0] = v14;
LOBYTE(v14[0]) = 0;
sub_431750(a2, v13);
v7 = sub_40D320(&unk_45FFA0, v13[0]);
if ( v7 )
{
sub_440C80(256LL, "EventIncomingRequestAuth BYE CallId(%s) is found", (const char *)v13[0]);
if ( v13[0] != v14 )
operator delete(v13[0], v14[0] + 1);
goto LABEL_31;
}
if ( v13[0] != v14 )
operator delete(v13[0], v14[0] + 1);
LABEL_25:
if ( !(unsigned __int8)sub_409AB0(a1, a2) )
{
sub_440C80(256LL, "EventIncomingRequestAuth no UserInfo and CheckAuthrization() return false");
goto LABEL_35;
}
if ( !(unsigned __int8)sub_40F6B0(&unk_460060, *(_QWORD *)(a2 + 344), s1) )
{
sub_440C80(256LL, "EventIncomingRequestAuth no UserInfo and CheckAuthrization() return true and no UserInfo");
LABEL_35:
v2 = 0;
LABEL_32:
if ( v11[0] != v12 )
operator delete(v11[0], v12[0] + 1);
goto LABEL_9;
}
if ( v11[0] != v12 )
operator delete(v11[0], v12[0] + 1);
LABEL_4:
v3 = s1[0];
v6 = s2[0];
if ( strcmp(s1[0], s2[0]) || v8 != v17 )
{
sub_440C80(256LL, "EventIncomingRequestAuth current(%s:%d) != recv(%s:%d)", v3, v17, v6, v8);
if ( (unsigned __int8)sub_409AB0(a1, a2) )
{
sub_40FAE0(&unk_460060, *(_QWORD *)(a2 + 344), s2[0], v8);
goto LABEL_9;
}
sub_440C80(256LL, "EventIncomingRequestAuth CheckAuthrization() return false");
goto LABEL_18;
}
LABEL_9:
if ( v18 != &v19 )
operator delete(v18, v19 + 1);
if ( (__int64 *)s1[0] != &v16 )
operator delete(s1[0], v16 + 1);
if ( (__int64 *)s2[0] != v10 )
operator delete(s2[0], v10[0] + 1);
return v2;
}
Q:[a1,v8,v11,v13,s1,sub_409BE0,sub_40F410,sub_431A60,sub_440C80,sub_432D50,sub_410F70,sub_40F6B0,sub_4315D0,sub_410CC0,sub_431750,sub_40D320,sub_409AB0,sub_40FAE0,] | A:{'a1': 'this', 'v8': 'iPort', 'v11': 'strTo', 'v13': 'strCallId', 's1': 'clsInfo', 'sub_409BE0': 'EventIncomingRequestAuth', 'sub_40F410': 'CUserInfo', 'sub_431A60': 'GetTopViaIpPort', 'sub_440C80': 'Print', 'sub_432D50': 'CreateResponseWithToTag', 'sub_410F70': 'Select', 'sub_40F6B0': 'Select', 'sub_4315D0': 'IsMethod', 'sub_410CC0': 'SelectIncomingRoute', 'sub_431750': 'GetCallId', 'sub_40D320': 'Select', 'sub_409AB0': 'CheckAuthrization', 'sub_40FAE0': 'SetIpPort'} | |
1c5460c06114eba18295c931be056dec04bc7d84e64fe0f7be9f3a01688aae40_1c5460c06114eba18295c931be056dec04bc7d84e64fe0f7be9f3a01688aae40.jsonl.gz | sub_49DF40 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_49DF40(unsigned int **a1, __int64 a2, unsigned __int64 *a3, int *a4)
{
__int64 result; // rax
unsigned __int64 v6; // [rsp+28h] [rbp-18h]
unsigned int *v7; // [rsp+30h] [rbp-10h]
int v8; // [rsp+3Ch] [rbp-4h]
v8 = *a4;
if ( (unsigned int)*a4 > 0xE )
return 1LL;
v7 = *a1;
if ( a2 - (__int64)*a1 > 3 )
{
v6 = ((unsigned __int64)*v7 << v8) | *a3;
_RAX = v7 + 1;
__asm { prefetchnta byte ptr [rax] }
*a1 = v7 + 1;
*a3 = v6;
*a4 = v8 + 32;
result = 1LL;
}
else
{
sub_49DF39();
result = 0LL;
}
return result;
}
Q:[a3,a4,a1,a2,result,v6,v7,v8,sub_49DF40,sub_49DF39,] | A:{'a3': 'pval', 'a4': 'pbits', 'a1': 'ppin', 'a2': 'pinend', 'result': '_RAX', 'v6': 'val', 'v7': 'pin', 'v8': 'bits', 'sub_49DF40': 'elf_zlib_fetch', 'sub_49DF39': 'elf_uncompress_failed'} | |
bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b_bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b.jsonl.gz | sub_427D48 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_427D48(__int64 a1)
{
return sub_42C198(a1);
}
Q:[sub_427D48,sub_42C198,] | A:{'sub_427D48': '_Rb_tree', 'sub_42C198': '_Rb_tree_impl'} | |
e2598a7edd2402f26a8bbd3f8912fd56a4f4cf3f81418f2e012c0e2bb1d6b154_e2598a7edd2402f26a8bbd3f8912fd56a4f4cf3f81418f2e012c0e2bb1d6b154.jsonl.gz | sub_40C383 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40C383(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-4h]
v2 = a1;
if ( a1 > 2 )
__assert_fail(
"btn < (int)(sizeof btn_state / sizeof btn_state[0])",
"src/platform/linux/wayland/wayland.c",
0x81u,
"way_mouse_up");
byte_432CD0[a1 - 1] = 0;
if ( a1 == 1 )
{
v2 = 272;
}
else if ( a1 == 2 )
{
v2 = 274;
}
return sub_40BE53(qword_42EC20, 0LL, v2, 0LL);
}
Q:[a1,sub_40C383,sub_40BE53,] | A:{'a1': 'btn', 'sub_40C383': 'way_mouse_up', 'sub_40BE53': 'zwlr_virtual_pointer_v1_button'} | |
5ea9f9c54079c7f4b8eaa0e7140af6562134c5adc9cce337d10805b6c5752ec2_5ea9f9c54079c7f4b8eaa0e7140af6562134c5adc9cce337d10805b6c5752ec2.jsonl.gz | sub_423172 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_423172(unsigned __int64 a1, _QWORD *a2)
{
__int64 v2; // rdx
unsigned __int64 v3; // rax
__int64 v4; // rdx
__int64 v5; // rdx
__int64 v6; // rdx
unsigned __int64 v7; // rax
unsigned __int64 v8; // rax
__int64 v9; // [rsp+10h] [rbp-80h]
__int64 v10; // [rsp+10h] [rbp-80h]
__int64 v11; // [rsp+10h] [rbp-80h]
__int64 v12; // [rsp+10h] [rbp-80h]
__int64 v13; // [rsp+18h] [rbp-78h]
__int64 v14; // [rsp+18h] [rbp-78h]
__int64 v15; // [rsp+18h] [rbp-78h]
__int64 v16; // [rsp+18h] [rbp-78h]
__int64 v17; // [rsp+20h] [rbp-70h]
__int64 v18; // [rsp+20h] [rbp-70h]
__int64 v19; // [rsp+20h] [rbp-70h]
__int64 v20; // [rsp+20h] [rbp-70h]
__int64 v21; // [rsp+38h] [rbp-58h]
unsigned __int64 *ptr; // [rsp+50h] [rbp-40h]
unsigned __int64 v23; // [rsp+58h] [rbp-38h]
_QWORD *v24; // [rsp+60h] [rbp-30h]
unsigned __int64 v25; // [rsp+68h] [rbp-28h]
_QWORD *v26; // [rsp+70h] [rbp-20h]
unsigned __int64 v27; // [rsp+78h] [rbp-18h]
unsigned __int64 *v28; // [rsp+80h] [rbp-10h]
int i; // [rsp+8Ch] [rbp-4h]
int j; // [rsp+8Ch] [rbp-4h]
if ( a1 )
{
if ( a1 == 2 )
{
if ( *((_DWORD *)a2 + 8) < *((_DWORD *)a2 + 2) )
{
v9 = *a2;
v13 = a2[1];
v17 = a2[2];
v2 = a2[4];
*a2 = a2[3];
a2[1] = v2;
a2[2] = a2[5];
a2[3] = v9;
a2[4] = v13;
a2[5] = v17;
}
}
else
{
for ( i = 2; a1 > 1LL << i; ++i )
;
ptr = (unsigned __int64 *)sub_457E68(192LL * i + 48, "bwtsw2_chain.c", 18LL, "ks_introsort_hsaip");
v28 = ptr;
v27 = (unsigned __int64)a2;
v26 = &a2[3 * a1 - 3];
for ( j = 2 * i; ; j = *((_DWORD *)v28 + 4) )
{
while ( v27 < (unsigned __int64)v26 )
{
if ( --j )
{
v25 = v27;
v24 = v26;
v23 = 24 * (((__int64)(0xAAAAAAAAAAAAAAABLL * ((__int64)((__int64)v26 - v27) >> 3)) >> 1) + 1) + v27;
if ( *(_DWORD *)(v23 + 8) >= *(_DWORD *)(v27 + 8) )
{
if ( *((_DWORD *)v26 + 2) >= *(_DWORD *)(v27 + 8) )
v3 = (unsigned __int64)v26;
else
v3 = v27;
v23 = v3;
}
else if ( *(_DWORD *)(v23 + 8) < *((_DWORD *)v26 + 2) )
{
v23 = (unsigned __int64)v26;
}
v21 = *(_QWORD *)(v23 + 8);
if ( (_QWORD *)v23 != v26 )
{
v10 = *(_QWORD *)v23;
v14 = *(_QWORD *)(v23 + 8);
v18 = *(_QWORD *)(v23 + 16);
v4 = v26[1];
*(_QWORD *)v23 = *v26;
*(_QWORD *)(v23 + 8) = v4;
*(_QWORD *)(v23 + 16) = v26[2];
*v26 = v10;
v26[1] = v14;
v26[2] = v18;
}
while ( 1 )
{
do
v25 += 24LL;
while ( *(_DWORD *)(v25 + 8) < (int)v21 );
do
v24 -= 3;
while ( v25 <= (unsigned __int64)v24 && (int)v21 < *((_DWORD *)v24 + 2) );
if ( (unsigned __int64)v24 <= v25 )
break;
v11 = *(_QWORD *)v25;
v15 = *(_QWORD *)(v25 + 8);
v19 = *(_QWORD *)(v25 + 16);
v5 = v24[1];
*(_QWORD *)v25 = *v24;
*(_QWORD *)(v25 + 8) = v5;
*(_QWORD *)(v25 + 16) = v24[2];
*v24 = v11;
v24[1] = v15;
v24[2] = v19;
}
v12 = *(_QWORD *)v25;
v16 = *(_QWORD *)(v25 + 8);
v20 = *(_QWORD *)(v25 + 16);
v6 = v26[1];
*(_QWORD *)v25 = *v26;
*(_QWORD *)(v25 + 8) = v6;
*(_QWORD *)(v25 + 16) = v26[2];
*v26 = v12;
v26[1] = v16;
v26[2] = v20;
if ( (__int64)(v25 - v27) <= (__int64)((__int64)v26 - v25) )
{
if ( (__int64)((__int64)v26 - v25) > 384 )
{
*v28 = v25 + 24;
v28[1] = (unsigned __int64)v26;
*((_DWORD *)v28 + 4) = j;
v28 += 3;
}
if ( (__int64)(v25 - v27) <= 384 )
v8 = v27;
else
v8 = v25 - 24;
v26 = (_QWORD *)v8;
}
else
{
if ( (__int64)(v25 - v27) > 384 )
{
*v28 = v27;
v28[1] = v25 - 24;
*((_DWORD *)v28 + 4) = j;
v28 += 3;
}
if ( (__int64)((__int64)v26 - v25) <= 384 )
v7 = (unsigned __int64)v26;
else
v7 = v25 + 24;
v27 = v7;
}
}
else
{
sub_422FA0(0xAAAAAAAAAAAAAAABLL * ((__int64)((__int64)v26 - v27) >> 3) + 1, v27);
v26 = (_QWORD *)v27;
}
}
if ( v28 == ptr )
break;
v28 -= 3;
v27 = *v28;
v26 = (_QWORD *)v28[1];
}
free(ptr);
sub_422EE4((unsigned __int64)a2, (unsigned __int64)&a2[3 * a1]);
}
}
}
Q:[a1,a2,v9,v16,v20,v21,ptr,v26,v27,v28,j,sub_423172,sub_457E68,sub_422FA0,] | A:{'a1': 'n', 'a2': 'a', 'v9': 'swap_tmp', 'v16': 'swap_tmp_8b', 'v20': 'swap_tmp_16b', 'v21': 'rp_8', 'ptr': 'stack', 'v26': 't', 'v27': 's', 'v28': 'top', 'j': 'da', 'sub_423172': 'ks_introsort_hsaip', 'sub_457E68': 'wrap_malloc', 'sub_422FA0': 'ks_combsort_hsaip'} | |
6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58_6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58.jsonl.gz | sub_40C6F8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40C6F8(__int64 a1)
{
unsigned __int16 v1; // ax
unsigned __int8 v2; // al
v1 = *(_WORD *)(a1 + 28);
*(_WORD *)(a1 + 28) = v1 + 1;
v2 = sub_406777(a1, v1);
return sub_4066D5(a1, *(_WORD *)(a1 + 6), v2);
}
Q:[a1,sub_40C6F8,sub_406777,sub_4066D5,] | A:{'a1': 'ctx', 'sub_40C6F8': 'LD_off_HL_n', 'sub_406777': 'read8', 'sub_4066D5': 'write8'} | |
a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4_a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4.jsonl.gz | sub_45F433 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_45F433(__int64 a1)
{
return a1;
}
Q:[sub_45F433,] | A:{'sub_45F433': '__shared_ptr'} | |
207a8dc2843fcc5d63bda75e764659825c09b358686a6fbac9f52640114a8cef_207a8dc2843fcc5d63bda75e764659825c09b358686a6fbac9f52640114a8cef.jsonl.gz | sub_4082E9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4082E9(__int64 a1)
{
unsigned int v2; // [rsp+1Ch] [rbp-4h]
v2 = *(_DWORD *)(*(_QWORD *)(a1 + 32) + 16LL);
if ( (*(_DWORD *)(*(_QWORD *)(a1 + 32) + 64LL) & 2) != 0 )
return sub_4080A7(a1, v2, &unk_40CC40, 0x10u);
if ( (*(_DWORD *)(*(_QWORD *)(a1 + 32) + 64LL) & 4) != 0 )
return sub_4080A7(a1, v2, &unk_40CC60, 0x38u);
return sub_4080A7(a1, v2, &unk_40CC20, 0x10u);
}
Q:[a1,v2,sub_4082E9,sub_4080A7,] | A:{'a1': 'stm', 'v2': 'target_address', 'sub_4082E9': 'stm32_reset_device', 'sub_4080A7': 'stm32_run_raw_code'} | |
4b40a5d5620be83110f98e6b5dce774f527910c5086f4274160db44c4ef1327c_4b40a5d5620be83110f98e6b5dce774f527910c5086f4274160db44c4ef1327c.jsonl.gz | sub_40606D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40606D(_QWORD *a1, unsigned int *a2, unsigned int a3)
{
char v5; // [rsp+23h] [rbp-1Dh] BYREF
int v6; // [rsp+24h] [rbp-1Ch] BYREF
unsigned int v7; // [rsp+28h] [rbp-18h]
unsigned int v8; // [rsp+2Ch] [rbp-14h]
unsigned int v9; // [rsp+30h] [rbp-10h]
unsigned int v10; // [rsp+34h] [rbp-Ch]
int v11; // [rsp+38h] [rbp-8h]
unsigned int v12; // [rsp+3Ch] [rbp-4h]
if ( (a2[7] & 3) == 1 )
return 4294967287LL;
v12 = sub_40625D(a1, a2);
if ( a3 >= v12 )
{
if ( a3 > v12 )
{
v11 = a2[8];
if ( v12 != a2[8] )
{
v10 = sub_405FA6((__int64)a1, a2, 0, 2);
if ( (v10 & 0x80000000) != 0 )
return v10;
}
while ( a3 > a2[8] )
{
v5 = 0;
v8 = sub_405C00((__int64)a1, a2, &v5, 1u);
if ( (v8 & 0x80000000) != 0 )
return v8;
}
v9 = sub_405FA6((__int64)a1, a2, v11, 0);
if ( (v9 & 0x80000000) != 0 )
return v9;
}
}
else
{
v7 = sub_40565F((__int64)a1, a2);
if ( v7 )
return v7;
v6 = 0;
v7 = sub_404B72(a1, a2 + 12, 0LL, a2[5], a2[6], a3, a2 + 5, &v6);
if ( v7 )
return v7;
a2[6] = a3;
a2[7] |= 0x10000u;
}
return 0LL;
}
Q:[a3,a1,a2,v5,v6,v7,v8,v9,v10,v11,v12,sub_40606D,sub_40625D,sub_405FA6,sub_405C00,sub_40565F,sub_404B72,] | A:{'a3': 'size', 'a1': 'lfs', 'a2': 'file', 'v5': 'buffer', 'v6': 'off', 'v7': 'err', 'v8': 'res', 'v9': 'err_0', 'v10': 'err_1', 'v11': 'pos', 'v12': 'oldsize', 'sub_40606D': 'lfs_file_truncate', 'sub_40625D': 'lfs_file_size', 'sub_405FA6': 'lfs_file_seek', 'sub_405C00': 'lfs_file_write', 'sub_40565F': 'lfs_file_flush', 'sub_404B72': 'lfs_ctz_find'} | |
7421faa8c444aeca9266add08f45c75a4f43aebd993f880cd35dd964f63fdfb2_7421faa8c444aeca9266add08f45c75a4f43aebd993f880cd35dd964f63fdfb2.jsonl.gz | sub_49C266 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_49C266(__int64 a1, __int64 a2, __int64 *a3)
{
unsigned __int64 v4; // [rsp+28h] [rbp-8h]
v4 = __readfsqword(0x28u);
sub_49C15E(a1, a2, a3, 0xA8u);
return v4 - __readfsqword(0x28u);
}
Q:[a3,a1,a2,sub_49C266,sub_49C15E,] | A:{'a3': 'state', 'a1': 'output', 'a2': 'nblocks', 'sub_49C266': 's2n_kyber_512_r3_shake128_squeezeblocks', 'sub_49C15E': 'keccak_squeezeblocks'} | |
4a2436d19e8ef0321db858769cd0f4bb117e0463889ac368782c1575f4f6d0f6_4a2436d19e8ef0321db858769cd0f4bb117e0463889ac368782c1575f4f6d0f6.jsonl.gz | sub_41AAF7 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_41AAF7()
{
char s[256]; // [rsp+0h] [rbp-100h] BYREF
sprintf(
s,
"iptables -A INPUT -p tcp -m multiport --sport 53,80 --tcp-flags SYN,ACK SYN,ACK -j NFQUEUE --queue-num %d",
1LL);
system(s);
return 0LL;
}
Q:[s,sub_41AAF7,] | A:{'s': 'cmd', 'sub_41AAF7': 'x38_setup'} | |
7c16ecc1f4177280f9c554334c74c60179f6cbd74ce0674df9f0cc7c89723807_7c16ecc1f4177280f9c554334c74c60179f6cbd74ce0674df9f0cc7c89723807.jsonl.gz | sub_415F7B | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_415F7B(__int64 a1, char *a2, unsigned __int64 a3)
{
char *v3; // rax
char v4; // al
char v7; // [rsp+2Fh] [rbp-1h]
while ( a3 > 1 )
{
v7 = 16 * sub_415F08(*a2);
v3 = a2 + 1;
a2 += 2;
v4 = sub_415F08(*v3);
sub_415670(a1, v4 | v7);
a3 -= 2LL;
}
}
Q:[a3,a1,a2,v7,sub_415F7B,sub_415F08,sub_415670,] | A:{'a3': 'len', 'a1': 'attr', 'a2': 'hex', 'v7': 'vala', 'sub_415F7B': 'buf_add_hex', 'sub_415F08': 'asc2byte', 'sub_415670': 'buf_add1'} | |
dde82f30bb011940478bd4895b01e213dc10ad4cb289f4d397d2e1f971e3baf0_dde82f30bb011940478bd4895b01e213dc10ad4cb289f4d397d2e1f971e3baf0.jsonl.gz | sub_4095B6 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_4095B6()
{
__int64 v0; // rax
void *v1; // rsp
__int64 result; // rax
__int64 v3; // [rsp+0h] [rbp-60h] BYREF
unsigned int v4; // [rsp+8h] [rbp-58h] BYREF
unsigned int v5; // [rsp+Ch] [rbp-54h]
_BYTE *v6; // [rsp+10h] [rbp-50h]
__int64 v7; // [rsp+18h] [rbp-48h]
__int64 *v8; // [rsp+20h] [rbp-40h]
__int64 v9; // [rsp+28h] [rbp-38h]
if ( sysconf(30) > 0x1FFF )
v0 = 0x2000LL;
else
v0 = sysconf(30);
v9 = v0 - 1;
v1 = alloca(16 * ((v0 + 15) / 0x10uLL));
v8 = &v3;
v7 = mnl_nlmsg_put_header();
*(_WORD *)(v7 + 4) = 16;
*(_WORD *)(v7 + 6) = 5;
v6 = (_BYTE *)mnl_nlmsg_put_extra_header();
*v6 = 3;
v6[1] = 1;
mnl_attr_put_u32();
mnl_attr_put_strz();
v5 = sub_409554(v7, (__int64)sub_4092C1, (__int64)&v4);
if ( v5 )
result = v5;
else
result = v4;
return result;
}
Q:[v4,v5,v6,v7,v8,sub_4095B6,sub_409554,sub_4092C1,] | A:{'v4': 'nl_family', 'v5': 'err', 'v6': 'genl', 'v7': 'nlh', 'v8': 'p_buf', 'sub_4095B6': 'get_family', 'sub_409554': 'msg_query', 'sub_4092C1': 'family_id_cb'} | |
fb04827bf9a551f5f69186e53039bed933d463cd8e2d00e60728cc981426dd66_fb04827bf9a551f5f69186e53039bed933d463cd8e2d00e60728cc981426dd66.jsonl.gz | sub_464AD0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_464AD0(__int64 a1, __int64 a2)
{
__int64 v2; // rax
__int64 result; // rax
__int64 v4; // rbx
__int64 v5; // rax
if ( *(_QWORD *)(a1 + 8) == *(_QWORD *)(a1 + 16) )
{
v4 = sub_4568D3(a2);
v5 = sub_456B86(a1);
result = sub_468784(a1, v5, v4);
}
else
{
v2 = sub_4568D3(a2);
sub_46874B(a1, *(_QWORD *)(a1 + 8), v2);
result = a1;
*(_QWORD *)(a1 + 8) += 16LL;
}
return result;
}
Q:[sub_464AD0,sub_4568D3,sub_456B86,sub_468784,sub_46874B,] | A:{'sub_464AD0': 'allocator', 'sub_4568D3': 'allocator', 'sub_456B86': 'end', 'sub_468784': 'allocator', 'sub_46874B': 'allocator'} | |
98f33d596ee72dd128aaca33f1dfd87c1dabdef4149e767cb3cce1896d9876c3_98f33d596ee72dd128aaca33f1dfd87c1dabdef4149e767cb3cce1896d9876c3.jsonl.gz | sub_40D642 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __noreturn sub_40D642()
{
exit(1);
}
Q:[sub_40D642,] | A:{'sub_40D642': 'cpuidle_exit'} | |
f55c67812e1597d6a331e582d38a28e20c9d249593ac7fa2b9090b33e4c6e88c_f55c67812e1597d6a331e582d38a28e20c9d249593ac7fa2b9090b33e4c6e88c.jsonl.gz | sub_402098 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_402098(__int64 a1, unsigned __int64 a2, unsigned __int64 a3)
{
unsigned __int64 v5; // [rsp+10h] [rbp-10h] BYREF
__int64 v6; // [rsp+18h] [rbp-8h]
v6 = a1;
v5 = a2;
while ( a3 > v5 )
{
if ( (unsigned __int8)sub_401C84(v6, &v5, a3) != 1 )
return 0LL;
}
return 1LL;
}
Q:[a3,a1,a2,v5,v6,sub_402098,sub_401C84,] | A:{'a3': 'data_size', 'a1': 'data', 'a2': 'length', 'v5': 'lengtha', 'v6': 'dataa', 'sub_402098': 'test_for_type_second', 'sub_401C84': 'test_for_type_second_entry'} | |
7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2_7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2.jsonl.gz | sub_44BFE5 | Help user generate meaningful names for variables and functions in the following code snippet. |
_DWORD *__fastcall sub_44BFE5(__int64 a1, __int64 a2, __int64 a3, int a4)
{
_DWORD *result; // rax
int i; // [rsp+28h] [rbp-4h]
for ( i = 0; i <= 71; i += 8 )
{
*(_DWORD *)(4LL * i + a1) = *(_DWORD *)(4LL * i + a2) + (a4 & *(_DWORD *)(4LL * i + a3));
*(_DWORD *)(4 * (i + 1LL) + a1) = *(_DWORD *)(4 * (i + 1LL) + a2) + (a4 & *(_DWORD *)(4 * (i + 1LL) + a3));
*(_DWORD *)(4 * (i + 2LL) + a1) = *(_DWORD *)(4 * (i + 2LL) + a2) + (a4 & *(_DWORD *)(4 * (i + 2LL) + a3));
*(_DWORD *)(4 * (i + 3LL) + a1) = *(_DWORD *)(4 * (i + 3LL) + a2) + (a4 & *(_DWORD *)(4 * (i + 3LL) + a3));
*(_DWORD *)(4 * (i + 4LL) + a1) = *(_DWORD *)(4 * (i + 4LL) + a2) + (a4 & *(_DWORD *)(4 * (i + 4LL) + a3));
*(_DWORD *)(4 * (i + 5LL) + a1) = *(_DWORD *)(4 * (i + 5LL) + a2) + (a4 & *(_DWORD *)(4 * (i + 5LL) + a3));
*(_DWORD *)(4 * (i + 6LL) + a1) = *(_DWORD *)(4 * (i + 6LL) + a2) + (a4 & *(_DWORD *)(4 * (i + 6LL) + a3));
result = (_DWORD *)(4 * (i + 7LL) + a1);
*result = *(_DWORD *)(4 * (i + 7LL) + a2) + (a4 & *(_DWORD *)(4 * (i + 7LL) + a3));
}
return result;
}
Q:[a3,a4,a1,a2,sub_44BFE5,] | A:{'a3': 'b', 'a4': 'm', 'a1': 'r', 'a2': 'a', 'sub_44BFE5': 'sp_2048_cond_add_72'} | |
f85c5f2f5a3fff1b852aaf59a31dfe68834f0c6e5b944484c00a51c97bdd9441_f85c5f2f5a3fff1b852aaf59a31dfe68834f0c6e5b944484c00a51c97bdd9441.jsonl.gz | sub_4041C3 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4041C3(__int64 a1, _QWORD *a2)
{
*a2 = *(_QWORD *)(*(_QWORD *)a1 + 24LL * (unsigned int)--*(_DWORD *)(a1 + 12));
return 0LL;
}
Q:[a1,a2,sub_4041C3,] | A:{'a1': 'ctx', 'a2': 'val', 'sub_4041C3': 'dom_pop'} | |
2604678e7dff384eee802ca605db3687e7b0f99dd5e013598941564083275560_2604678e7dff384eee802ca605db3687e7b0f99dd5e013598941564083275560.jsonl.gz | sub_40F4FA | Help user generate meaningful names for variables and functions in the following code snippet. |
double __fastcall sub_40F4FA(double *a1, double *a2, __int64 a3)
{
double *v4; // rax
double v5; // xmm1_8
double v6; // xmm0_8
double v7; // xmm0_8
double v9; // [rsp+8h] [rbp-58h]
double v10; // [rsp+10h] [rbp-50h]
double v12; // [rsp+38h] [rbp-28h]
double v13; // [rsp+38h] [rbp-28h]
double v14; // [rsp+48h] [rbp-18h]
__int64 v15; // [rsp+50h] [rbp-10h]
double x; // [rsp+58h] [rbp-8h]
double xa; // [rsp+58h] [rbp-8h]
if ( !a1 || !a2 )
return -1.0;
v15 = 0LL;
v12 = 0.0;
x = 0.0;
while ( v15 < a3 )
{
v4 = &a1[2 * v15];
v5 = v4[1];
x = sub_40FA00(*v4, v5, *v4, -v4[1]) + x;
v12 = v5 + v12;
++v15;
}
xa = sqrt(x);
if ( xa == 0.0 )
{
*a2 = 0.0;
*a1 = 1.0;
a1[1] = 0.0;
}
else
{
if ( *a1 != 0.0 || a1[1] != 0.0 )
{
v10 = *a1;
v9 = a1[1];
v6 = *a1;
cabs();
v14 = v9 / v6;
xa = sub_40FA00(v10 / v6, v9 / v6, xa, 0.0);
v13 = v14;
}
else
{
v13 = 0.0;
}
v7 = a1[1] + v13;
*a1 = *a1 + xa;
a1[1] = v7;
*a2 = 1.0 / sub_40FA00(xa, -v13, *a1, a1[1]);
}
return -xa;
}
Q:[a3,a1,a2,xa,sub_40F4FA,] | A:{'a3': 'n', 'a1': 'x', 'a2': 'beta', 'xa': 'ba', 'sub_40F4FA': 'cs_cl_house'} | |
7be234ff1bf913b18e7f3dc63277693fbaa1a69ce49eeb885aa12327d52c2d59_7be234ff1bf913b18e7f3dc63277693fbaa1a69ce49eeb885aa12327d52c2d59.jsonl.gz | sub_40F996 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 __fastcall sub_40F996(unsigned __int64 a1)
{
return a1 <= 0xFFFF;
}
Q:[a1,sub_40F996,] | A:{'a1': 'port', 'sub_40F996': 'is_valid_port'} | |
c4ffc14f1587debb81833d9d33cb0dcaf224d46f78e46f542c0ad4003ca993ea_c4ffc14f1587debb81833d9d33cb0dcaf224d46f78e46f542c0ad4003ca993ea.jsonl.gz | sub_40EFE0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40EFE0(__int64 *a1, __int64 a2, unsigned __int64 a3)
{
__int64 v4; // r15
__int64 v5; // r14
__int64 v6; // r13
__int64 v7; // r12
__int64 v8; // rbp
__int64 v9; // rbx
__int64 v10; // r11
__int64 v11; // r10
__int64 v12; // r9
__int64 v13; // r8
__int64 v14; // rdi
__int64 v15; // rcx
unsigned __int64 v16; // rdx
unsigned __int64 v17; // rax
__int64 v19; // [rsp+0h] [rbp-1A8h]
__int64 v20; // [rsp+8h] [rbp-1A0h]
__int64 v21; // [rsp+10h] [rbp-198h]
__int64 v22; // [rsp+18h] [rbp-190h]
__int64 v23; // [rsp+20h] [rbp-188h]
__int64 v24; // [rsp+28h] [rbp-180h]
__int64 v25; // [rsp+30h] [rbp-178h]
__int64 v26; // [rsp+38h] [rbp-170h]
__int64 v27; // [rsp+40h] [rbp-168h]
__int64 v28; // [rsp+48h] [rbp-160h]
__int64 v29; // [rsp+50h] [rbp-158h]
__int64 v30; // [rsp+58h] [rbp-150h]
__int64 v31; // [rsp+60h] [rbp-148h]
__int64 v32; // [rsp+68h] [rbp-140h]
__int64 v33; // [rsp+70h] [rbp-138h]
__int64 v34; // [rsp+78h] [rbp-130h]
__int64 v35; // [rsp+80h] [rbp-128h]
__int64 v36; // [rsp+88h] [rbp-120h]
__int64 v37; // [rsp+90h] [rbp-118h]
__int64 v38; // [rsp+98h] [rbp-110h]
__int64 v39; // [rsp+A0h] [rbp-108h]
__int64 v40; // [rsp+A8h] [rbp-100h]
__int64 v41; // [rsp+B0h] [rbp-F8h]
__int64 v42; // [rsp+B8h] [rbp-F0h]
__int64 v43; // [rsp+C0h] [rbp-E8h]
__int64 v44; // [rsp+C8h] [rbp-E0h]
__int64 v45; // [rsp+D0h] [rbp-D8h]
__int64 v46; // [rsp+D8h] [rbp-D0h]
__int64 v47; // [rsp+E0h] [rbp-C8h]
__int64 v48; // [rsp+E8h] [rbp-C0h]
__int64 v49; // [rsp+F0h] [rbp-B8h]
__int64 v50; // [rsp+F8h] [rbp-B0h]
__int64 v51; // [rsp+100h] [rbp-A8h]
__int64 v52; // [rsp+108h] [rbp-A0h]
__int64 v53; // [rsp+110h] [rbp-98h]
__int64 v54; // [rsp+118h] [rbp-90h]
__int64 v55; // [rsp+120h] [rbp-88h]
__int64 v56; // [rsp+128h] [rbp-80h]
__int64 v57; // [rsp+130h] [rbp-78h]
__int64 v58; // [rsp+138h] [rbp-70h]
__int64 v59; // [rsp+140h] [rbp-68h]
__int64 v60; // [rsp+148h] [rbp-60h]
__int64 v61; // [rsp+150h] [rbp-58h]
__int64 v62; // [rsp+158h] [rbp-50h]
__int64 v63; // [rsp+160h] [rbp-48h]
__int64 v64; // [rsp+168h] [rbp-40h]
v19 = *a1;
v20 = a1[1];
v21 = a1[2];
v22 = a1[3];
v23 = a1[4];
v24 = a1[5];
v25 = a1[6];
v26 = a1[7];
v27 = a1[8];
v28 = a1[9];
v29 = a1[10];
v30 = a1[11];
v31 = a1[12];
v32 = a1[13];
v33 = a1[14];
v34 = a1[15];
v35 = a1[16];
v36 = a1[17];
v37 = a1[18];
v38 = a1[19];
v39 = a1[20];
v40 = a1[21];
v41 = a1[22];
v42 = a1[23];
v43 = a1[24];
v44 = a1[25];
v46 = a1[27];
v47 = a1[28];
v45 = a1[26];
v48 = a1[29];
v49 = a1[30];
v50 = a1[31];
v51 = a1[32];
v52 = a1[33];
v53 = a1[34];
v54 = a1[35];
v55 = a1[36];
v56 = a1[37];
v57 = a1[38];
v58 = a1[39];
v59 = a1[40];
v60 = a1[41];
v61 = a1[42];
v62 = a1[43];
v63 = a1[44];
v4 = a1[45];
v5 = a1[47];
v6 = a1[48];
v7 = a1[49];
v64 = a1[46];
v8 = a1[50];
v9 = a1[51];
v10 = a1[52];
v11 = a1[53];
v12 = a1[54];
v13 = a1[55];
v14 = a1[56];
v15 = a1[57];
v16 = a3 / 0x3A;
if ( a3 > 0x39 )
{
v17 = 0LL;
do
{
++v17;
v19 = *(_QWORD *)(a2 + 8 * v19);
v20 = *(_QWORD *)(a2 + 8 * v20);
v21 = *(_QWORD *)(a2 + 8 * v21);
v22 = *(_QWORD *)(a2 + 8 * v22);
v23 = *(_QWORD *)(a2 + 8 * v23);
v24 = *(_QWORD *)(a2 + 8 * v24);
v25 = *(_QWORD *)(a2 + 8 * v25);
v26 = *(_QWORD *)(a2 + 8 * v26);
v27 = *(_QWORD *)(a2 + 8 * v27);
v28 = *(_QWORD *)(a2 + 8 * v28);
v29 = *(_QWORD *)(a2 + 8 * v29);
v30 = *(_QWORD *)(a2 + 8 * v30);
v31 = *(_QWORD *)(a2 + 8 * v31);
v32 = *(_QWORD *)(a2 + 8 * v32);
v33 = *(_QWORD *)(a2 + 8 * v33);
v34 = *(_QWORD *)(a2 + 8 * v34);
v35 = *(_QWORD *)(a2 + 8 * v35);
v36 = *(_QWORD *)(a2 + 8 * v36);
v37 = *(_QWORD *)(a2 + 8 * v37);
v38 = *(_QWORD *)(a2 + 8 * v38);
v39 = *(_QWORD *)(a2 + 8 * v39);
v40 = *(_QWORD *)(a2 + 8 * v40);
v41 = *(_QWORD *)(a2 + 8 * v41);
v42 = *(_QWORD *)(a2 + 8 * v42);
v43 = *(_QWORD *)(a2 + 8 * v43);
v44 = *(_QWORD *)(a2 + 8 * v44);
v45 = *(_QWORD *)(a2 + 8 * v45);
v46 = *(_QWORD *)(a2 + 8 * v46);
v47 = *(_QWORD *)(a2 + 8 * v47);
v48 = *(_QWORD *)(a2 + 8 * v48);
v49 = *(_QWORD *)(a2 + 8 * v49);
v50 = *(_QWORD *)(a2 + 8 * v50);
v51 = *(_QWORD *)(a2 + 8 * v51);
v52 = *(_QWORD *)(a2 + 8 * v52);
v53 = *(_QWORD *)(a2 + 8 * v53);
v54 = *(_QWORD *)(a2 + 8 * v54);
v55 = *(_QWORD *)(a2 + 8 * v55);
v56 = *(_QWORD *)(a2 + 8 * v56);
v57 = *(_QWORD *)(a2 + 8 * v57);
v58 = *(_QWORD *)(a2 + 8 * v58);
v59 = *(_QWORD *)(a2 + 8 * v59);
v60 = *(_QWORD *)(a2 + 8 * v60);
v61 = *(_QWORD *)(a2 + 8 * v61);
v62 = *(_QWORD *)(a2 + 8 * v62);
v4 = *(_QWORD *)(a2 + 8 * v4);
v5 = *(_QWORD *)(a2 + 8 * v5);
v6 = *(_QWORD *)(a2 + 8 * v6);
v7 = *(_QWORD *)(a2 + 8 * v7);
v8 = *(_QWORD *)(a2 + 8 * v8);
v9 = *(_QWORD *)(a2 + 8 * v9);
v10 = *(_QWORD *)(a2 + 8 * v10);
v63 = *(_QWORD *)(a2 + 8 * v63);
v11 = *(_QWORD *)(a2 + 8 * v11);
v12 = *(_QWORD *)(a2 + 8 * v12);
v13 = *(_QWORD *)(a2 + 8 * v13);
v14 = *(_QWORD *)(a2 + 8 * v14);
v15 = *(_QWORD *)(a2 + 8 * v15);
v64 = *(_QWORD *)(a2 + 8 * v64);
}
while ( v16 > v17 );
}
return v15
+ v14
+ v13
+ v12
+ v11
+ v10
+ v9
+ v8
+ v7
+ v6
+ v5
+ v64
+ v4
+ v63
+ v62
+ v61
+ v60
+ v59
+ v58
+ v57
+ v56
+ v55
+ v54
+ v53
+ v52
+ v51
+ v50
+ v49
+ v48
+ v47
+ v46
+ v45
+ v44
+ v43
+ v42
+ v41
+ v40
+ v39
+ v38
+ v37
+ v36
+ v35
+ v34
+ v33
+ v32
+ v31
+ v30
+ v29
+ v28
+ v27
+ v26
+ v25
+ v24
+ v23
+ v22
+ v21
+ v20
+ v19;
}
Q:[sub_40EFE0,] | A:{'sub_40EFE0': 'naked_access_58'} | |
fb04827bf9a551f5f69186e53039bed933d463cd8e2d00e60728cc981426dd66_fb04827bf9a551f5f69186e53039bed933d463cd8e2d00e60728cc981426dd66.jsonl.gz | sub_423250 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_423250(__int64 a1)
{
return sub_44731E(a1);
}
Q:[sub_423250,sub_44731E,] | A:{'sub_423250': '~binary_reader', 'sub_44731E': '~shared_ptr'} | |
45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0_45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0.jsonl.gz | sub_46008E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_46008E(__int64 a1)
{
return a1;
}
Q:[a1,sub_46008E,] | A:{'a1': '__t', 'sub_46008E': 'forward'} | |
8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2_8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2.jsonl.gz | sub_405BB6 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall __noreturn sub_405BB6(__int64 a1, __int64 a2, int a3)
{
sub_40592B(a1, a2, a3 | 0x6000000, (__int64)"invalid args");
}
Q:[a3,a1,a2,sub_405BB6,sub_40592B,] | A:{'a3': 'linenumber', 'a1': 'thr', 'a2': 'filename', 'sub_405BB6': 'duk_err_type_invalid_args', 'sub_40592B': 'duk_err_handle_error'} | |
d641d4455ba968ec8cdc678803903e8adc4e0f690e4b42f19186ba657d295323_d641d4455ba968ec8cdc678803903e8adc4e0f690e4b42f19186ba657d295323.jsonl.gz | sub_410A60 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_410A60(__int64 a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6)
{
unsigned __int16 *v7; // [rsp+10h] [rbp-10h]
_DWORD *v8; // [rsp+18h] [rbp-8h]
v8 = off_43E280;
v7 = (unsigned __int16 *)off_43E288;
*((_WORD *)off_43E280 + 2) = a1;
*v8 = 52625960;
sub_40A2AC(a1, a2, (unsigned __int16)a1, a4, a5, a6);
return v7[2];
}
Q:[a1,v7,v8,sub_410A60,sub_40A2AC,] | A:{'a1': 'netkey_index', 'v7': 'rsp_0', 'v8': 'cmd', 'sub_410A60': 'sl_btmesh_lpn_establish_friendship', 'sub_40A2AC': 'sl_btmesh_host_handle_command'} | |
bb9310054c3f344729bb7df0dbde2a43dacee9abc1ae5ac38ae0c568be371b2f_bb9310054c3f344729bb7df0dbde2a43dacee9abc1ae5ac38ae0c568be371b2f.jsonl.gz | sub_408603 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_408603(char a1)
{
char v2; // [rsp+Ch] [rbp-4h]
v2 = tolower(a1);
if ( v2 > 47 && v2 <= 57 )
return (unsigned int)(v2 - 48);
if ( v2 <= 96 || v2 > 102 )
return 0xFFFFFFFFLL;
return (unsigned int)(v2 - 87);
}
Q:[a1,v2,sub_408603,] | A:{'a1': 'x', 'v2': 'xa', 'sub_408603': 'unhex'} | |
e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6_e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6.jsonl.gz | sub_485D9F | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_485D9F(int a1, int a2)
{
int result; // eax
if ( a1 == 1 && a2 == 0xFFFF )
{
std::ios_base::Init::Init((std::ios_base::Init *)&unk_4C14AE);
result = __cxa_atexit(std::ios_base::Init::~Init, &unk_4C14AE, &unk_4C11F0);
}
return result;
}
Q:[a1,a2,sub_485D9F,] | A:{'a1': '__initialize_p', 'a2': '__priority', 'sub_485D9F': '_Z41__static_initialization_and_destruction_0ii_79'} | |
2954c746386b679ec91901f40cababd226af864899b77eb9b01cf71ccddfb68d_2954c746386b679ec91901f40cababd226af864899b77eb9b01cf71ccddfb68d.jsonl.gz | sub_41F262 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41F262(__int64 a1)
{
__int64 v3; // rax
__int64 v4; // rdx
__int64 v5; // rax
double v6; // xmm0_8
__int64 v7; // rax
double v8; // [rsp+0h] [rbp-50h]
void *v9; // [rsp+10h] [rbp-40h] BYREF
__int64 v10; // [rsp+18h] [rbp-38h]
__int64 v11; // [rsp+20h] [rbp-30h]
char v12; // [rsp+2Fh] [rbp-21h]
double v13; // [rsp+30h] [rbp-20h]
__int64 v14; // [rsp+38h] [rbp-18h]
if ( (int)sub_42113C(a1) < 0 )
return 0LL;
if ( *(_DWORD *)(a1 + 272) == 2 )
{
if ( *(int *)(a1 + 204) > 0 )
{
v14 = *(_QWORD *)(*(_QWORD *)(a1 + 192) + 8LL * *(int *)(a1 + 204) - 8);
if ( !v14 || (unsigned __int8)sub_41DEEE(v14) != 1 )
return 0LL;
}
if ( *(_BYTE *)(a1 + 176) && *(_QWORD *)(a1 + 152) )
{
sub_422936(*(_QWORD *)(a1 + 152));
++*(_DWORD *)(a1 + 136);
}
v3 = *(_QWORD *)(a1 + 248);
if ( v3 < 0 )
{
v4 = *(_QWORD *)(a1 + 248) & 1LL | ((unsigned __int64)v3 >> 1);
v8 = (double)(int)v4 + (double)(int)v4;
}
else
{
v8 = (double)(int)v3;
}
v5 = sub_4218E0(a1 + 80);
if ( v5 < 0 )
v6 = (double)(int)(v5 & 1 | ((unsigned __int64)v5 >> 1)) + (double)(int)(v5 & 1 | ((unsigned __int64)v5 >> 1));
else
v6 = (double)(int)v5;
v13 = v8 / v6;
sub_4218C2(a1 + 80, v8 / v6);
if ( (unsigned __int8)sub_41E93A(a1 + 80, *(_QWORD *)(a1 + 312)) != 1 )
return 0LL;
if ( *(_BYTE *)(a1 + 277) )
{
v7 = sub_420EC6(a1);
if ( (unsigned __int8)sub_41E6B4(a1 + 24, 475249515, v7) != 1 )
return 0LL;
}
if ( *(_BYTE *)(a1 + 176) )
{
if ( !*(_QWORD *)(a1 + 160) )
return 0LL;
v9 = 0LL;
if ( (unsigned __int8)sub_420DBC(a1, "cues", &v9) != 1 )
return 0LL;
v12 = sub_4228D0(*(_QWORD *)(a1 + 160), v9);
if ( v9 )
operator delete[](v9);
if ( v12 != 1 )
return 0LL;
}
if ( *(_BYTE *)(a1 + 277) && !sub_41BD6C(a1, *(_QWORD *)(a1 + 304)) )
return 0LL;
if ( (unsigned __int8)sub_41E31E(a1 + 24, *(_QWORD *)(a1 + 312)) != 1 )
return 0LL;
if ( (*(unsigned __int8 (__fastcall **)(_QWORD))(**(_QWORD **)(a1 + 312) + 24LL))(*(_QWORD *)(a1 + 312)) )
{
if ( *(_QWORD *)(a1 + 288) == -1LL )
return 0LL;
v11 = (*(__int64 (__fastcall **)(_QWORD))(**(_QWORD **)(a1 + 312) + 8LL))(*(_QWORD *)(a1 + 312));
v10 = sub_420EC6(a1);
if ( v10 <= 0 )
return 0LL;
if ( (*(unsigned int (__fastcall **)(_QWORD, _QWORD))(**(_QWORD **)(a1 + 312) + 16LL))(
*(_QWORD *)(a1 + 312),
*(_QWORD *)(a1 + 288)) )
{
return 0LL;
}
if ( (unsigned int)sub_421CEF(*(_QWORD *)(a1 + 312), v10, 8LL) )
return 0LL;
if ( (*(unsigned int (__fastcall **)(_QWORD, __int64))(**(_QWORD **)(a1 + 312) + 16LL))(
*(_QWORD *)(a1 + 312),
v11) )
{
return 0LL;
}
}
if ( *(_BYTE *)(a1 + 176) )
{
if ( !*(_QWORD *)(a1 + 160) || !*(_QWORD *)(a1 + 168) )
return 0LL;
sub_422936(*(_QWORD *)(a1 + 160));
sub_422936(*(_QWORD *)(a1 + 168));
}
}
return 1LL;
}
Q:[a1,v9,v10,v11,v12,v13,v14,sub_41F262,sub_42113C,sub_41DEEE,sub_422936,sub_4218E0,sub_4218C2,sub_41E93A,sub_420EC6,sub_41E6B4,sub_420DBC,sub_4228D0,sub_41BD6C,sub_41E31E,sub_421CEF,] | A:{'a1': 'this', 'v9': 'name', 'v10': 'segment_size', 'v11': 'pos', 'v12': 'cues_open', 'v13': 'duration', 'v14': 'old_cluster', 'sub_41F262': 'Finalize', 'sub_42113C': 'WriteFramesAll', 'sub_41DEEE': 'Finalize', 'sub_422936': 'Close', 'sub_4218E0': 'timecode_scale', 'sub_4218C2': 'set_duration', 'sub_41E93A': 'Finalize', 'sub_420EC6': 'MaxOffset', 'sub_41E6B4': 'AddSeekEntry', 'sub_420DBC': 'UpdateChunkName', 'sub_4228D0': 'Open', 'sub_41BD6C': 'Write', 'sub_41E31E': 'Finalize', 'sub_421CEF': 'WriteUIntSize'} | |
3f1dbef0dcf52c12d23f5f5f78b2c3a922afbe6ead5cd010f21e0c1d6bff98ee_3f1dbef0dcf52c12d23f5f5f78b2c3a922afbe6ead5cd010f21e0c1d6bff98ee.jsonl.gz | sub_7000FCB9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_7000FCB9(unsigned int a1, char a2)
{
return *(_DWORD *)a1 & ((unsigned int)(1LL << (8 * a2)) - 1);
}
Q:[a1,a2,sub_7000FCB9,] | A:{'a1': 'addr', 'a2': 'len', 'sub_7000FCB9': 'swaddr_read_18'} | |
1cf3c06358268939f24acae1bce75aada87849a1ce41e7eec2af6c54bdcbbdcf_1cf3c06358268939f24acae1bce75aada87849a1ce41e7eec2af6c54bdcbbdcf.jsonl.gz | sub_4023C4 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_4023C4(__int64 a1)
{
int v1; // eax
if ( (a1 & 1) != 0 )
v1 = 0;
else
v1 = *(_DWORD *)a1;
if ( v1 )
{
if ( v1 == 1 )
printf("#<function>");
}
else
{
printf("%ld", a1 >> 1);
}
return putchar(10);
}
Q:[a1,sub_4023C4,] | A:{'a1': 't', 'sub_4023C4': 'print_val'} | |
9861972866b8ccea0a5b33e64b5d5e1a71dd13da10d037c25b6e25d222407eb3_9861972866b8ccea0a5b33e64b5d5e1a71dd13da10d037c25b6e25d222407eb3.jsonl.gz | sub_404DB8 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall __noreturn sub_404DB8(void *a1)
{
fd_set readfds; // [rsp+10h] [rbp-90h] BYREF
int v2[3]; // [rsp+90h] [rbp-10h] BYREF
int v3; // [rsp+9Ch] [rbp-4h]
while ( 1 )
{
v3 = 0;
memset(&readfds, 0, sizeof(readfds));
v2[2] = 0;
v2[1] = (unsigned int)v2;
readfds.fds_bits[0] |= 1uLL;
v3 = select(1, &readfds, 0LL, 0LL, 0LL);
if ( v3 == -1 )
printf("ERROR:file[%s],function[%s],line[%d] select fail\n", "main.c", "stdin_process_thread", 1794LL);
if ( v3 > 0 && (readfds.fds_bits[0] & 1) != 0 )
{
memset(&unk_45FE20, 0, 0x80uLL);
v2[0] = read(0, &unk_45FE20, 0x80uLL);
byte_45FEA0 = v2[0];
}
}
}
Q:[a1,readfds,v2,v3,sub_404DB8,] | A:{'a1': 'data', 'readfds': 'read_fd', 'v2': 'read_result', 'v3': 'result', 'sub_404DB8': 'stdin_process_thread'} | |
d20d5d136ed82a5a36fdeedd4c3a30a62ee46f8e0365a7e4e8f0c462411d4a2f_d20d5d136ed82a5a36fdeedd4c3a30a62ee46f8e0365a7e4e8f0c462411d4a2f.jsonl.gz | sub_4ADE37 | Help user generate meaningful names for variables and functions in the following code snippet. |
char *sub_4ADE37()
{
if ( setenv("LANG", "C", 1) < 0 )
fprintf(stderr, "Failed to setenv LANG to '%s'\n", "C");
return setlocale();
}
Q:[sub_4ADE37,] | A:{'sub_4ADE37': 'take_your_locale_and_shove_it'} | |
bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b_bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b.jsonl.gz | sub_40F507 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40F507(unsigned int a1)
{
unsigned int v2; // [rsp+0h] [rbp-4h]
v2 = ((((((a1 & 0x55555555) + ((a1 >> 1) & 0x55555555)) & 0x33333333)
+ ((((a1 & 0x55555555) + ((a1 >> 1) & 0x55555555)) >> 2) & 0x33333333)) >> 4)
+ (((a1 & 0x55555555) + ((a1 >> 1) & 0x55555555)) & 0x33333333)
+ ((((a1 & 0x55555555) + ((a1 >> 1) & 0x55555555)) >> 2) & 0x33333333)) & 0xF0F0F0F;
return (unsigned __int8)((((v2 >> 8) + v2) >> 16) + BYTE1(v2) + v2);
}
Q:[sub_40F507,] | A:{'sub_40F507': 'stbi__bitcount'} | |
401210897d42300e36aa265b418c9223b386d5a95735505dce371e33095d2cb6_401210897d42300e36aa265b418c9223b386d5a95735505dce371e33095d2cb6.jsonl.gz | sub_401975 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_401975(__int64 a1, __int64 a2)
{
__int64 result; // rax
unsigned int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; ; ++i )
{
result = *(unsigned int *)(a2 + 4);
if ( i >= (unsigned int)result )
break;
sub_401821(a1, *(_QWORD *)(*(_QWORD *)(a2 + 8) + 8LL * i));
}
return result;
}
Q:[a1,a2,sub_401975,sub_401821,] | A:{'a1': 'list', 'a2': 'source', 'sub_401975': 'list_cat', 'sub_401821': 'list_add'} | |
8f546fdfb581421fdfbfeb375ad304f6d5289eb31a93e4934d4f651ec840ff14_8f546fdfb581421fdfbfeb375ad304f6d5289eb31a93e4934d4f651ec840ff14.jsonl.gz | sub_40387A | Help user generate meaningful names for variables and functions in the following code snippet. |
int sub_40387A()
{
sub_401DAA("SMSC", (__int64)&unk_56C900);
return puts("SMSC LPC47N227 runtime register block\n");
}
Q:[sub_40387A,sub_401DAA,] | A:{'sub_40387A': 'print_smsc_chips', 'sub_401DAA': 'print_vendor_chips'} | |
7dc7fd77c702ac66e020038977e4c5b256bb046b8e96253a37fa2f33ba09f7ff_7dc7fd77c702ac66e020038977e4c5b256bb046b8e96253a37fa2f33ba09f7ff.jsonl.gz | sub_4077EE | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4077EE(__int64 a1, __int64 a2)
{
char v3[72]; // [rsp+20h] [rbp-50h] BYREF
sub_4077C8((__int64)v3, a2);
sub_409E28(a1, v3);
sub_405544((__int64)v3);
return a1;
}
Q:[a1,a2,sub_4077EE,sub_4077C8,sub_409E28,sub_405544,] | A:{'a1': 'retstr', 'a2': 'p_data', 'sub_4077EE': 'allocator', 'sub_4077C8': 'tuple', 'sub_409E28': 'argmap', 'sub_405544': '~tuple'} | |
b075dfd15a5f87f7bd9b7e1d96fde5cc5aceb552b90c5c42e9565c1e439733f4_b075dfd15a5f87f7bd9b7e1d96fde5cc5aceb552b90c5c42e9565c1e439733f4.jsonl.gz | sub_419777 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_419777(__int64 a1, const char *a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6, ...)
{
__int64 result; // rax
char s[8192]; // [rsp+10h] [rbp-20D0h] BYREF
gcc_va_list arg; // [rsp+2010h] [rbp-D0h] BYREF
__int64 v10; // [rsp+2040h] [rbp-A0h]
__int64 v11; // [rsp+2048h] [rbp-98h]
__int64 v12; // [rsp+2050h] [rbp-90h]
__int64 v13; // [rsp+2058h] [rbp-88h]
va_start(arg, a6);
v10 = a3;
v11 = a4;
v12 = a5;
v13 = a6;
++*(_DWORD *)(a1 + 152);
arg[0].gp_offset = 16;
vsnprintf(s, 0x2000uLL, a2, arg);
if ( *(_QWORD *)a1 )
result = (*(__int64 (__fastcall **)(_QWORD, _QWORD, _QWORD, char *))(a1 + 128))(
*(_QWORD *)(a1 + 144),
*(_QWORD *)(*(_QWORD *)a1 + 16LL),
*(unsigned int *)(*(_QWORD *)a1 + 24LL),
s);
else
result = (*(__int64 (__fastcall **)(_QWORD, void *, _QWORD, char *))(a1 + 128))(
*(_QWORD *)(a1 + 144),
&unk_443D3A,
0LL,
s);
return result;
}
Q:[a1,a2,s,arg,sub_419777,] | A:{'a1': 'pp', 'a2': 'msg', 's': 'tmpmsg', 'arg': 'args', 'sub_419777': 'dowarning'} | |
3f1dbef0dcf52c12d23f5f5f78b2c3a922afbe6ead5cd010f21e0c1d6bff98ee_3f1dbef0dcf52c12d23f5f5f78b2c3a922afbe6ead5cd010f21e0c1d6bff98ee.jsonl.gz | sub_7000D411 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_7000D411(int a1)
{
int v2; // [rsp+1Ch] [rbp-4h]
v2 = sub_70003311(a1 + 1);
qword_7002E218 = qword_7002E1D0;
qword_7002E220 = qword_7002E1D8;
qword_7002E228 = qword_7002E1E0;
qword_7002E230 = qword_7002E1E8;
qword_7002E238 = qword_7002E1F0;
qword_7002E240 = qword_7002E1F8;
qword_7002E248 = qword_7002E200;
qword_7002E250 = qword_7002E208;
qword_7002E258 = qword_7002E210;
sub_7000D3DE();
return (unsigned int)(v2 + 1);
}
Q:[a1,v2,sub_7000D411,sub_70003311,sub_7000D3DE,] | A:{'a1': 'eip_0', 'v2': 'len', 'sub_7000D411': 'imul_rm2r_l', 'sub_70003311': 'decode_rm2r_l', 'sub_7000D3DE': 'do_imul_l'} | |
1f4870939c6a06e209cc6778e1d9d9213935f5ce1a00659358f41e29118ddf0a_1f4870939c6a06e209cc6778e1d9d9213935f5ce1a00659358f41e29118ddf0a.jsonl.gz | sub_43511F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43511F(__int64 a1, __int64 a2, unsigned __int16 *a3, unsigned __int64 a4, unsigned int *a5)
{
__int64 result; // rax
int v6; // ebx
int v7; // ebx
int v8; // ebx
int v9; // ebx
int v10; // ebx
int v11; // ebx
bool v12; // dl
int v13; // eax
bool v14; // dl
int v15; // eax
bool v16; // dl
int v17; // eax
bool v18; // dl
int v19; // eax
_BOOL4 v20; // ebx
_BOOL4 v21; // ebx
_BOOL4 v22; // ebx
__int64 v23[6]; // [rsp+30h] [rbp-970h] BYREF
__int64 v24[6]; // [rsp+60h] [rbp-940h] BYREF
__int64 v25[6]; // [rsp+90h] [rbp-910h] BYREF
__int64 v26[5]; // [rsp+C0h] [rbp-8E0h] BYREF
int v27; // [rsp+E8h] [rbp-8B8h]
__int64 v29; // [rsp+F0h] [rbp-8B0h]
int v30; // [rsp+FCh] [rbp-8A4h]
unsigned int *v31; // [rsp+100h] [rbp-8A0h]
__int64 *v32; // [rsp+108h] [rbp-898h]
_BYTE *v33; // [rsp+110h] [rbp-890h]
__int64 v34; // [rsp+118h] [rbp-888h]
int v35; // [rsp+124h] [rbp-87Ch]
unsigned int *v36; // [rsp+128h] [rbp-878h]
__int64 *v37; // [rsp+130h] [rbp-870h]
_WORD *v38; // [rsp+138h] [rbp-868h]
__int64 v39; // [rsp+140h] [rbp-860h]
int v40; // [rsp+14Ch] [rbp-854h]
unsigned int *v41; // [rsp+150h] [rbp-850h]
__int64 *v42; // [rsp+158h] [rbp-848h]
_WORD *v43; // [rsp+160h] [rbp-840h]
__int64 v44; // [rsp+168h] [rbp-838h]
int v45; // [rsp+174h] [rbp-82Ch]
unsigned int *v46; // [rsp+178h] [rbp-828h]
__int64 *v47; // [rsp+180h] [rbp-820h]
_WORD *v48; // [rsp+188h] [rbp-818h]
__int64 v49; // [rsp+190h] [rbp-810h]
int v50; // [rsp+19Ch] [rbp-804h]
unsigned int *v51; // [rsp+1A0h] [rbp-800h]
__int64 *v52; // [rsp+1A8h] [rbp-7F8h]
_WORD *v53; // [rsp+1B0h] [rbp-7F0h]
__int64 v54; // [rsp+1B8h] [rbp-7E8h]
int v55; // [rsp+1C4h] [rbp-7DCh]
unsigned int *v56; // [rsp+1C8h] [rbp-7D8h]
__int64 *v57; // [rsp+1D0h] [rbp-7D0h]
_WORD *v58; // [rsp+1D8h] [rbp-7C8h]
__int64 v59; // [rsp+1E0h] [rbp-7C0h]
int v60; // [rsp+1ECh] [rbp-7B4h]
unsigned int *v61; // [rsp+1F0h] [rbp-7B0h]
__int64 *v62; // [rsp+1F8h] [rbp-7A8h]
_WORD *v63; // [rsp+200h] [rbp-7A0h]
_WORD *v64; // [rsp+208h] [rbp-798h]
int v65; // [rsp+214h] [rbp-78Ch]
unsigned int *v66; // [rsp+218h] [rbp-788h]
unsigned __int64 v67; // [rsp+220h] [rbp-780h]
__int64 *v68; // [rsp+228h] [rbp-778h]
_WORD *v69; // [rsp+230h] [rbp-770h]
__int64 v70; // [rsp+238h] [rbp-768h]
int v71; // [rsp+244h] [rbp-75Ch]
unsigned int *v72; // [rsp+248h] [rbp-758h]
__int64 *v73; // [rsp+250h] [rbp-750h]
_BYTE *v74; // [rsp+258h] [rbp-748h]
__int64 v75; // [rsp+260h] [rbp-740h]
int v76; // [rsp+26Ch] [rbp-734h]
unsigned int *v77; // [rsp+270h] [rbp-730h]
__int64 *v78; // [rsp+278h] [rbp-728h]
_WORD *v79; // [rsp+280h] [rbp-720h]
__int64 v80; // [rsp+288h] [rbp-718h]
int v81; // [rsp+294h] [rbp-70Ch]
unsigned int *v82; // [rsp+298h] [rbp-708h]
__int64 *v83; // [rsp+2A0h] [rbp-700h]
_WORD *v84; // [rsp+2A8h] [rbp-6F8h]
__int64 v85; // [rsp+2B0h] [rbp-6F0h]
int v86; // [rsp+2BCh] [rbp-6E4h]
unsigned int *v87; // [rsp+2C0h] [rbp-6E0h]
__int64 *v88; // [rsp+2C8h] [rbp-6D8h]
_WORD *v89; // [rsp+2D0h] [rbp-6D0h]
__int64 v90; // [rsp+2D8h] [rbp-6C8h]
int v91; // [rsp+2E4h] [rbp-6BCh]
unsigned int *v92; // [rsp+2E8h] [rbp-6B8h]
__int64 *v93; // [rsp+2F0h] [rbp-6B0h]
_WORD *v94; // [rsp+2F8h] [rbp-6A8h]
__int64 v95; // [rsp+300h] [rbp-6A0h]
int v96; // [rsp+30Ch] [rbp-694h]
unsigned int *v97; // [rsp+310h] [rbp-690h]
__int64 *v98; // [rsp+318h] [rbp-688h]
_WORD *v99; // [rsp+320h] [rbp-680h]
__int64 v100; // [rsp+328h] [rbp-678h]
int v101; // [rsp+334h] [rbp-66Ch]
unsigned int *v102; // [rsp+338h] [rbp-668h]
__int64 *v103; // [rsp+340h] [rbp-660h]
_WORD *v104; // [rsp+348h] [rbp-658h]
_WORD *v105; // [rsp+350h] [rbp-650h]
int v106; // [rsp+35Ch] [rbp-644h]
unsigned int *v107; // [rsp+360h] [rbp-640h]
unsigned __int64 v108; // [rsp+368h] [rbp-638h]
__int64 *v109; // [rsp+370h] [rbp-630h]
_WORD *v110; // [rsp+378h] [rbp-628h]
__int64 v111; // [rsp+380h] [rbp-620h]
int v112; // [rsp+38Ch] [rbp-614h]
unsigned int *v113; // [rsp+390h] [rbp-610h]
__int64 *v114; // [rsp+398h] [rbp-608h]
_BYTE *v115; // [rsp+3A0h] [rbp-600h]
__int64 v116; // [rsp+3A8h] [rbp-5F8h]
int v117; // [rsp+3B4h] [rbp-5ECh]
unsigned int *v118; // [rsp+3B8h] [rbp-5E8h]
__int64 *v119; // [rsp+3C0h] [rbp-5E0h]
_WORD *v120; // [rsp+3C8h] [rbp-5D8h]
__int64 v121; // [rsp+3D0h] [rbp-5D0h]
int v122; // [rsp+3DCh] [rbp-5C4h]
unsigned int *v123; // [rsp+3E0h] [rbp-5C0h]
__int64 *v124; // [rsp+3E8h] [rbp-5B8h]
_WORD *v125; // [rsp+3F0h] [rbp-5B0h]
__int64 v126; // [rsp+3F8h] [rbp-5A8h]
int v127; // [rsp+404h] [rbp-59Ch]
unsigned int *v128; // [rsp+408h] [rbp-598h]
__int64 *v129; // [rsp+410h] [rbp-590h]
_WORD *v130; // [rsp+418h] [rbp-588h]
__int64 v131; // [rsp+420h] [rbp-580h]
int v132; // [rsp+42Ch] [rbp-574h]
unsigned int *v133; // [rsp+430h] [rbp-570h]
__int64 *v134; // [rsp+438h] [rbp-568h]
_WORD *v135; // [rsp+440h] [rbp-560h]
__int64 v136; // [rsp+448h] [rbp-558h]
int v137; // [rsp+454h] [rbp-54Ch]
unsigned int *v138; // [rsp+458h] [rbp-548h]
__int64 *v139; // [rsp+460h] [rbp-540h]
_WORD *v140; // [rsp+468h] [rbp-538h]
__int64 v141; // [rsp+470h] [rbp-530h]
int v142; // [rsp+47Ch] [rbp-524h]
unsigned int *v143; // [rsp+480h] [rbp-520h]
__int64 *v144; // [rsp+488h] [rbp-518h]
_WORD *v145; // [rsp+490h] [rbp-510h]
_WORD *v146; // [rsp+498h] [rbp-508h]
int v147; // [rsp+4A4h] [rbp-4FCh]
unsigned int *v148; // [rsp+4A8h] [rbp-4F8h]
_WORD *v149; // [rsp+4B0h] [rbp-4F0h]
__int64 *v150; // [rsp+4B8h] [rbp-4E8h]
_WORD *v151; // [rsp+4C0h] [rbp-4E0h]
__int64 v152; // [rsp+4C8h] [rbp-4D8h]
int v153; // [rsp+4D4h] [rbp-4CCh]
unsigned int *v154; // [rsp+4D8h] [rbp-4C8h]
__int64 *v155; // [rsp+4E0h] [rbp-4C0h]
_BYTE *v156; // [rsp+4E8h] [rbp-4B8h]
__int64 v157; // [rsp+4F0h] [rbp-4B0h]
int v158; // [rsp+4FCh] [rbp-4A4h]
unsigned int *v159; // [rsp+500h] [rbp-4A0h]
__int64 *v160; // [rsp+508h] [rbp-498h]
_WORD *v161; // [rsp+510h] [rbp-490h]
__int64 v162; // [rsp+518h] [rbp-488h]
int v163; // [rsp+524h] [rbp-47Ch]
unsigned int *v164; // [rsp+528h] [rbp-478h]
__int64 *v165; // [rsp+530h] [rbp-470h]
_WORD *v166; // [rsp+538h] [rbp-468h]
__int64 v167; // [rsp+540h] [rbp-460h]
int v168; // [rsp+54Ch] [rbp-454h]
unsigned int *v169; // [rsp+550h] [rbp-450h]
__int64 *v170; // [rsp+558h] [rbp-448h]
_WORD *v171; // [rsp+560h] [rbp-440h]
__int64 v172; // [rsp+568h] [rbp-438h]
int v173; // [rsp+574h] [rbp-42Ch]
unsigned int *v174; // [rsp+578h] [rbp-428h]
__int64 *v175; // [rsp+580h] [rbp-420h]
_WORD *v176; // [rsp+588h] [rbp-418h]
__int64 v177; // [rsp+590h] [rbp-410h]
int v178; // [rsp+59Ch] [rbp-404h]
unsigned int *v179; // [rsp+5A0h] [rbp-400h]
__int64 *v180; // [rsp+5A8h] [rbp-3F8h]
_WORD *v181; // [rsp+5B0h] [rbp-3F0h]
__int64 v182; // [rsp+5B8h] [rbp-3E8h]
int v183; // [rsp+5C4h] [rbp-3DCh]
unsigned int *v184; // [rsp+5C8h] [rbp-3D8h]
__int64 *v185; // [rsp+5D0h] [rbp-3D0h]
_WORD *v186; // [rsp+5D8h] [rbp-3C8h]
_WORD *v187; // [rsp+5E0h] [rbp-3C0h]
int v188; // [rsp+5ECh] [rbp-3B4h]
unsigned int *v189; // [rsp+5F0h] [rbp-3B0h]
unsigned __int64 v190; // [rsp+5F8h] [rbp-3A8h]
__int64 *v191; // [rsp+600h] [rbp-3A0h]
_WORD *v192; // [rsp+608h] [rbp-398h]
__int64 v193; // [rsp+610h] [rbp-390h]
int v194; // [rsp+61Ch] [rbp-384h]
unsigned int *v195; // [rsp+620h] [rbp-380h]
__int64 *v196; // [rsp+628h] [rbp-378h]
_WORD *v197; // [rsp+630h] [rbp-370h]
__int64 v198; // [rsp+638h] [rbp-368h]
int v199; // [rsp+644h] [rbp-35Ch]
unsigned int *v200; // [rsp+648h] [rbp-358h]
__int64 *v201; // [rsp+650h] [rbp-350h]
_WORD *v202; // [rsp+658h] [rbp-348h]
__int64 v203; // [rsp+660h] [rbp-340h]
int v204; // [rsp+66Ch] [rbp-334h]
unsigned int *v205; // [rsp+670h] [rbp-330h]
__int64 *v206; // [rsp+678h] [rbp-328h]
_WORD *v207; // [rsp+680h] [rbp-320h]
__int64 v208; // [rsp+688h] [rbp-318h]
int v209; // [rsp+694h] [rbp-30Ch]
unsigned int *v210; // [rsp+698h] [rbp-308h]
__int64 *v211; // [rsp+6A0h] [rbp-300h]
_WORD *v212; // [rsp+6A8h] [rbp-2F8h]
__int64 v213; // [rsp+6B0h] [rbp-2F0h]
int v214; // [rsp+6BCh] [rbp-2E4h]
unsigned int *v215; // [rsp+6C0h] [rbp-2E0h]
__int64 *v216; // [rsp+6C8h] [rbp-2D8h]
_WORD *v217; // [rsp+6D0h] [rbp-2D0h]
__int64 v218; // [rsp+6D8h] [rbp-2C8h]
int v219; // [rsp+6E4h] [rbp-2BCh]
unsigned int *v220; // [rsp+6E8h] [rbp-2B8h]
__int64 *v221; // [rsp+6F0h] [rbp-2B0h]
_WORD *v222; // [rsp+6F8h] [rbp-2A8h]
__int64 v223; // [rsp+700h] [rbp-2A0h]
int v224; // [rsp+70Ch] [rbp-294h]
unsigned int *v225; // [rsp+710h] [rbp-290h]
__int64 *v226; // [rsp+718h] [rbp-288h]
_WORD *v227; // [rsp+720h] [rbp-280h]
__int64 v228; // [rsp+728h] [rbp-278h]
int v229; // [rsp+734h] [rbp-26Ch]
unsigned int *v230; // [rsp+738h] [rbp-268h]
__int64 *v231; // [rsp+740h] [rbp-260h]
_WORD *v232; // [rsp+748h] [rbp-258h]
__int64 v233; // [rsp+750h] [rbp-250h]
int v234; // [rsp+75Ch] [rbp-244h]
unsigned int *v235; // [rsp+760h] [rbp-240h]
__int64 *v236; // [rsp+768h] [rbp-238h]
_WORD *v237; // [rsp+770h] [rbp-230h]
__int64 v238; // [rsp+778h] [rbp-228h]
int v239; // [rsp+784h] [rbp-21Ch]
unsigned int *v240; // [rsp+788h] [rbp-218h]
__int64 *v241; // [rsp+790h] [rbp-210h]
_WORD *v242; // [rsp+798h] [rbp-208h]
__int64 v243; // [rsp+7A0h] [rbp-200h]
int v244; // [rsp+7ACh] [rbp-1F4h]
unsigned int *v245; // [rsp+7B0h] [rbp-1F0h]
__int64 *v246; // [rsp+7B8h] [rbp-1E8h]
_WORD *v247; // [rsp+7C0h] [rbp-1E0h]
__int64 v248; // [rsp+7C8h] [rbp-1D8h]
int v249; // [rsp+7D4h] [rbp-1CCh]
unsigned int *v250; // [rsp+7D8h] [rbp-1C8h]
__int64 *v251; // [rsp+7E0h] [rbp-1C0h]
_WORD *v252; // [rsp+7E8h] [rbp-1B8h]
__int64 v253; // [rsp+7F0h] [rbp-1B0h]
int v254; // [rsp+7FCh] [rbp-1A4h]
unsigned int *v255; // [rsp+800h] [rbp-1A0h]
__int64 *v256; // [rsp+808h] [rbp-198h]
_WORD *v257; // [rsp+810h] [rbp-190h]
__int64 v258; // [rsp+818h] [rbp-188h]
int v259; // [rsp+824h] [rbp-17Ch]
unsigned int *v260; // [rsp+828h] [rbp-178h]
__int64 *v261; // [rsp+830h] [rbp-170h]
_WORD *v262; // [rsp+838h] [rbp-168h]
__int64 v263; // [rsp+840h] [rbp-160h]
int v264; // [rsp+84Ch] [rbp-154h]
unsigned int *v265; // [rsp+850h] [rbp-150h]
__int64 *v266; // [rsp+858h] [rbp-148h]
_WORD *v267; // [rsp+860h] [rbp-140h]
__int64 v268; // [rsp+868h] [rbp-138h]
int v269; // [rsp+874h] [rbp-12Ch]
unsigned int *v270; // [rsp+878h] [rbp-128h]
__int64 *v271; // [rsp+880h] [rbp-120h]
_WORD *v272; // [rsp+888h] [rbp-118h]
int i; // [rsp+894h] [rbp-10Ch]
__int64 v274; // [rsp+898h] [rbp-108h]
__int64 v275; // [rsp+8A0h] [rbp-100h]
__int64 v276; // [rsp+8A8h] [rbp-F8h]
__int64 v277; // [rsp+8B0h] [rbp-F0h]
int v278; // [rsp+8BCh] [rbp-E4h]
_WORD *v279; // [rsp+8C0h] [rbp-E0h]
_WORD *v280; // [rsp+8C8h] [rbp-D8h]
_WORD *v281; // [rsp+8D0h] [rbp-D0h]
_WORD *v282; // [rsp+8D8h] [rbp-C8h]
unsigned __int64 v283; // [rsp+8E0h] [rbp-C0h]
_WORD *v284; // [rsp+8E8h] [rbp-B8h]
unsigned __int64 v285; // [rsp+8F0h] [rbp-B0h]
unsigned __int64 v286; // [rsp+8F8h] [rbp-A8h]
unsigned __int8 *v287; // [rsp+900h] [rbp-A0h]
unsigned __int8 *v288; // [rsp+908h] [rbp-98h]
unsigned __int8 *v289; // [rsp+910h] [rbp-90h]
unsigned __int8 *v290; // [rsp+918h] [rbp-88h]
unsigned __int64 v291; // [rsp+920h] [rbp-80h]
unsigned __int64 v292; // [rsp+928h] [rbp-78h]
unsigned __int64 v293; // [rsp+930h] [rbp-70h]
unsigned __int64 v294; // [rsp+938h] [rbp-68h]
unsigned int *v295; // [rsp+940h] [rbp-60h]
unsigned int *v296; // [rsp+948h] [rbp-58h]
unsigned __int64 v297; // [rsp+950h] [rbp-50h]
_WORD *v298; // [rsp+958h] [rbp-48h]
unsigned __int16 *v299; // [rsp+960h] [rbp-40h]
unsigned int *v300; // [rsp+968h] [rbp-38h]
unsigned __int64 v301; // [rsp+970h] [rbp-30h]
unsigned __int16 *v302; // [rsp+978h] [rbp-28h]
__int64 v303; // [rsp+980h] [rbp-20h]
_WORD *v304; // [rsp+988h] [rbp-18h]
v304 = (_WORD *)a1;
v303 = a2;
v302 = a3;
v301 = a4;
v300 = a5;
if ( a4 <= 9 )
return -20LL;
v299 = v302;
v298 = v304;
v297 = (unsigned __int64)v304 + v303;
v296 = v300 + 1;
v295 = v300 + 1;
v294 = (unsigned __int16)sub_42A969(v302);
v293 = (unsigned __int16)sub_42A969(v302 + 1);
v292 = (unsigned __int16)sub_42A969(v302 + 2);
v291 = v301 - (v292 + v293 + v294) - 6;
v290 = (unsigned __int8 *)(v302 + 3);
v289 = (unsigned __int8 *)v302 + v294 + 6;
v288 = &v289[v293];
v287 = &v289[v293 + v292];
v286 = (unsigned __int64)(v303 + 3) >> 2;
v285 = (unsigned __int64)v304 + v286;
v284 = (_WORD *)((char *)v304 + v286 + v286);
v283 = (unsigned __int64)v284 + v286;
v282 = v304;
v281 = (_WORD *)((char *)v304 + v286);
v280 = v284;
v279 = (_WORD *)((char *)v284 + v286);
v27 = sub_42AF8F(v300);
v278 = BYTE2(v27);
if ( v301 < v291 )
return -20LL;
v277 = sub_42AB2C(v23, v290, v294);
if ( sub_42AAB2(v277) )
return v277;
v276 = sub_42AB2C(v24, v289, v293);
if ( sub_42AAB2(v276) )
return v276;
v275 = sub_42AB2C(v25, v288, v292);
if ( sub_42AAB2(v275) )
return v275;
v274 = sub_42AB2C(v26, v287, v291);
if ( sub_42AAB2(v274) )
return v274;
v6 = sub_42ADF3((__int64)v23);
v7 = sub_42ADF3((__int64)v24) | v6;
v8 = sub_42ADF3((__int64)v25) | v7;
for ( i = v8 | sub_42ADF3((__int64)v26); i == 0 && (unsigned __int64)v279 < v297 - 7; i = v11 | sub_42ADF3((__int64)v26) )
{
if ( (unsigned int)sub_42A8DD() )
{
v272 = v282;
v271 = v23;
v270 = v295;
v269 = v278;
v268 = sub_42AD94((__int64)v23, v278);
*v272 = v270[v268];
sub_42ADD2((__int64)v271, BYTE2(v270[v268]));
v282 = (_WORD *)((char *)v282 + HIBYTE(v270[v268]));
}
if ( (unsigned int)sub_42A8DD() )
{
v267 = v281;
v266 = v24;
v265 = v295;
v264 = v278;
v263 = sub_42AD94((__int64)v24, v278);
*v267 = v265[v263];
sub_42ADD2((__int64)v266, BYTE2(v265[v263]));
v281 = (_WORD *)((char *)v281 + HIBYTE(v265[v263]));
}
if ( (unsigned int)sub_42A8DD() )
{
v262 = v280;
v261 = v25;
v260 = v295;
v259 = v278;
v258 = sub_42AD94((__int64)v25, v278);
*v262 = v260[v258];
sub_42ADD2((__int64)v261, BYTE2(v260[v258]));
v280 = (_WORD *)((char *)v280 + HIBYTE(v260[v258]));
}
if ( (unsigned int)sub_42A8DD() )
{
v257 = v279;
v256 = v26;
v255 = v295;
v254 = v278;
v253 = sub_42AD94((__int64)v26, v278);
*v257 = v255[v253];
sub_42ADD2((__int64)v256, BYTE2(v255[v253]));
v279 = (_WORD *)((char *)v279 + HIBYTE(v255[v253]));
}
sub_42A8DD();
v252 = v282;
v251 = v23;
v250 = v295;
v249 = v278;
v248 = sub_42AD94((__int64)v23, v278);
*v252 = v250[v248];
sub_42ADD2((__int64)v251, BYTE2(v250[v248]));
v282 = (_WORD *)((char *)v282 + HIBYTE(v250[v248]));
sub_42A8DD();
v247 = v281;
v246 = v24;
v245 = v295;
v244 = v278;
v243 = sub_42AD94((__int64)v24, v278);
*v247 = v245[v243];
sub_42ADD2((__int64)v246, BYTE2(v245[v243]));
v281 = (_WORD *)((char *)v281 + HIBYTE(v245[v243]));
sub_42A8DD();
v242 = v280;
v241 = v25;
v240 = v295;
v239 = v278;
v238 = sub_42AD94((__int64)v25, v278);
*v242 = v240[v238];
sub_42ADD2((__int64)v241, BYTE2(v240[v238]));
v280 = (_WORD *)((char *)v280 + HIBYTE(v240[v238]));
sub_42A8DD();
v237 = v279;
v236 = v26;
v235 = v295;
v234 = v278;
v233 = sub_42AD94((__int64)v26, v278);
*v237 = v235[v233];
sub_42ADD2((__int64)v236, BYTE2(v235[v233]));
v279 = (_WORD *)((char *)v279 + HIBYTE(v235[v233]));
if ( (unsigned int)sub_42A8DD() )
{
v232 = v282;
v231 = v23;
v230 = v295;
v229 = v278;
v228 = sub_42AD94((__int64)v23, v278);
*v232 = v230[v228];
sub_42ADD2((__int64)v231, BYTE2(v230[v228]));
v282 = (_WORD *)((char *)v282 + HIBYTE(v230[v228]));
}
if ( (unsigned int)sub_42A8DD() )
{
v227 = v281;
v226 = v24;
v225 = v295;
v224 = v278;
v223 = sub_42AD94((__int64)v24, v278);
*v227 = v225[v223];
sub_42ADD2((__int64)v226, BYTE2(v225[v223]));
v281 = (_WORD *)((char *)v281 + HIBYTE(v225[v223]));
}
if ( (unsigned int)sub_42A8DD() )
{
v222 = v280;
v221 = v25;
v220 = v295;
v219 = v278;
v218 = sub_42AD94((__int64)v25, v278);
*v222 = v220[v218];
sub_42ADD2((__int64)v221, BYTE2(v220[v218]));
v280 = (_WORD *)((char *)v280 + HIBYTE(v220[v218]));
}
if ( (unsigned int)sub_42A8DD() )
{
v217 = v279;
v216 = v26;
v215 = v295;
v214 = v278;
v213 = sub_42AD94((__int64)v26, v278);
*v217 = v215[v213];
sub_42ADD2((__int64)v216, BYTE2(v215[v213]));
v279 = (_WORD *)((char *)v279 + HIBYTE(v215[v213]));
}
v212 = v282;
v211 = v23;
v210 = v295;
v209 = v278;
v208 = sub_42AD94((__int64)v23, v278);
*v212 = v210[v208];
sub_42ADD2((__int64)v211, BYTE2(v210[v208]));
v282 = (_WORD *)((char *)v282 + HIBYTE(v210[v208]));
v207 = v281;
v206 = v24;
v205 = v295;
v204 = v278;
v203 = sub_42AD94((__int64)v24, v278);
*v207 = v205[v203];
sub_42ADD2((__int64)v206, BYTE2(v205[v203]));
v281 = (_WORD *)((char *)v281 + HIBYTE(v205[v203]));
v202 = v280;
v201 = v25;
v200 = v295;
v199 = v278;
v198 = sub_42AD94((__int64)v25, v278);
*v202 = v200[v198];
sub_42ADD2((__int64)v201, BYTE2(v200[v198]));
v280 = (_WORD *)((char *)v280 + HIBYTE(v200[v198]));
v197 = v279;
v196 = v26;
v195 = v295;
v194 = v278;
v193 = sub_42AD94((__int64)v26, v278);
*v197 = v195[v193];
sub_42ADD2((__int64)v196, BYTE2(v195[v193]));
v279 = (_WORD *)((char *)v279 + HIBYTE(v195[v193]));
v9 = sub_42ADF3((__int64)v23);
v10 = sub_42ADF3((__int64)v24) | v9;
v11 = sub_42ADF3((__int64)v25) | v10;
}
if ( v285 < (unsigned __int64)v282 )
return -20LL;
if ( v284 < v281 )
return -20LL;
if ( v283 < (unsigned __int64)v280 )
return -20LL;
v192 = v282;
v191 = v23;
v190 = v285;
v189 = v295;
v188 = v278;
v187 = v282;
while ( 1 )
{
v12 = (unsigned int)sub_42ADF3((__int64)v191) == 0;
if ( !v12 || (unsigned __int64)v192 >= v190 - 7 )
break;
if ( (unsigned int)sub_42A8DD() )
{
v186 = v192;
v185 = v191;
v184 = v189;
v183 = v188;
v182 = sub_42AD94((__int64)v191, v188);
*v186 = v184[v182];
sub_42ADD2((__int64)v185, BYTE2(v184[v182]));
v192 = (_WORD *)((char *)v192 + HIBYTE(v184[v182]));
}
sub_42A8DD();
v181 = v192;
v180 = v191;
v179 = v189;
v178 = v188;
v177 = sub_42AD94((__int64)v191, v188);
*v181 = v179[v177];
sub_42ADD2((__int64)v180, BYTE2(v179[v177]));
v192 = (_WORD *)((char *)v192 + HIBYTE(v179[v177]));
if ( (unsigned int)sub_42A8DD() )
{
v176 = v192;
v175 = v191;
v174 = v189;
v173 = v188;
v172 = sub_42AD94((__int64)v191, v188);
*v176 = v174[v172];
sub_42ADD2((__int64)v175, BYTE2(v174[v172]));
v192 = (_WORD *)((char *)v192 + HIBYTE(v174[v172]));
}
v171 = v192;
v170 = v191;
v169 = v189;
v168 = v188;
v167 = sub_42AD94((__int64)v191, v188);
*v171 = v169[v167];
sub_42ADD2((__int64)v170, BYTE2(v169[v167]));
v192 = (_WORD *)((char *)v192 + HIBYTE(v169[v167]));
}
while ( 1 )
{
v13 = sub_42ADF3((__int64)v191);
if ( v13 != 0 || (unsigned __int64)v192 > v190 - 2 )
break;
v166 = v192;
v165 = v191;
v164 = v189;
v163 = v188;
v162 = sub_42AD94((__int64)v191, v188);
*v166 = v164[v162];
sub_42ADD2((__int64)v165, BYTE2(v164[v162]));
v192 = (_WORD *)((char *)v192 + HIBYTE(v164[v162]));
}
while ( (unsigned __int64)v192 <= v190 - 2 )
{
v161 = v192;
v160 = v191;
v159 = v189;
v158 = v188;
v157 = sub_42AD94((__int64)v191, v188);
*v161 = v159[v157];
sub_42ADD2((__int64)v160, BYTE2(v159[v157]));
v192 = (_WORD *)((char *)v192 + HIBYTE(v159[v157]));
}
if ( v190 > (unsigned __int64)v192 )
{
v156 = v192;
v155 = v191;
v154 = v189;
v153 = v188;
v152 = sub_42AD94((__int64)v191, v188);
*v156 = v154[v152];
if ( HIBYTE(v154[v152]) == 1 )
{
sub_42ADD2((__int64)v155, BYTE2(v154[v152]));
}
else if ( *((_DWORD *)v155 + 2) <= 0x3Fu )
{
sub_42ADD2((__int64)v155, BYTE2(v154[v152]));
if ( *((_DWORD *)v155 + 2) > 0x40u )
*((_DWORD *)v155 + 2) = 64;
}
v192 = (_WORD *)((char *)v192 + 1);
}
v151 = v281;
v150 = v24;
v149 = v284;
v148 = v295;
v147 = v278;
v146 = v281;
while ( 1 )
{
v14 = (unsigned int)sub_42ADF3((__int64)v150) == 0;
if ( !v14 || v151 >= (_WORD *)((char *)v149 - 7) )
break;
if ( (unsigned int)sub_42A8DD() )
{
v145 = v151;
v144 = v150;
v143 = v148;
v142 = v147;
v141 = sub_42AD94((__int64)v150, v147);
*v145 = v143[v141];
sub_42ADD2((__int64)v144, BYTE2(v143[v141]));
v151 = (_WORD *)((char *)v151 + HIBYTE(v143[v141]));
}
sub_42A8DD();
v140 = v151;
v139 = v150;
v138 = v148;
v137 = v147;
v136 = sub_42AD94((__int64)v150, v147);
*v140 = v138[v136];
sub_42ADD2((__int64)v139, BYTE2(v138[v136]));
v151 = (_WORD *)((char *)v151 + HIBYTE(v138[v136]));
if ( (unsigned int)sub_42A8DD() )
{
v135 = v151;
v134 = v150;
v133 = v148;
v132 = v147;
v131 = sub_42AD94((__int64)v150, v147);
*v135 = v133[v131];
sub_42ADD2((__int64)v134, BYTE2(v133[v131]));
v151 = (_WORD *)((char *)v151 + HIBYTE(v133[v131]));
}
v130 = v151;
v129 = v150;
v128 = v148;
v127 = v147;
v126 = sub_42AD94((__int64)v150, v147);
*v130 = v128[v126];
sub_42ADD2((__int64)v129, BYTE2(v128[v126]));
v151 = (_WORD *)((char *)v151 + HIBYTE(v128[v126]));
}
while ( 1 )
{
v15 = sub_42ADF3((__int64)v150);
if ( v15 != 0 || v151 > v149 - 1 )
break;
v125 = v151;
v124 = v150;
v123 = v148;
v122 = v147;
v121 = sub_42AD94((__int64)v150, v147);
*v125 = v123[v121];
sub_42ADD2((__int64)v124, BYTE2(v123[v121]));
v151 = (_WORD *)((char *)v151 + HIBYTE(v123[v121]));
}
while ( v151 <= v149 - 1 )
{
v120 = v151;
v119 = v150;
v118 = v148;
v117 = v147;
v116 = sub_42AD94((__int64)v150, v147);
*v120 = v118[v116];
sub_42ADD2((__int64)v119, BYTE2(v118[v116]));
v151 = (_WORD *)((char *)v151 + HIBYTE(v118[v116]));
}
if ( v149 > v151 )
{
v115 = v151;
v114 = v150;
v113 = v148;
v112 = v147;
v111 = sub_42AD94((__int64)v150, v147);
*v115 = v113[v111];
if ( HIBYTE(v113[v111]) == 1 )
{
sub_42ADD2((__int64)v114, BYTE2(v113[v111]));
}
else if ( *((_DWORD *)v114 + 2) <= 0x3Fu )
{
sub_42ADD2((__int64)v114, BYTE2(v113[v111]));
if ( *((_DWORD *)v114 + 2) > 0x40u )
*((_DWORD *)v114 + 2) = 64;
}
v151 = (_WORD *)((char *)v151 + 1);
}
v110 = v280;
v109 = v25;
v108 = v283;
v107 = v295;
v106 = v278;
v105 = v280;
while ( 1 )
{
v16 = (unsigned int)sub_42ADF3((__int64)v109) == 0;
if ( !v16 || (unsigned __int64)v110 >= v108 - 7 )
break;
if ( (unsigned int)sub_42A8DD() )
{
v104 = v110;
v103 = v109;
v102 = v107;
v101 = v106;
v100 = sub_42AD94((__int64)v109, v106);
*v104 = v102[v100];
sub_42ADD2((__int64)v103, BYTE2(v102[v100]));
v110 = (_WORD *)((char *)v110 + HIBYTE(v102[v100]));
}
sub_42A8DD();
v99 = v110;
v98 = v109;
v97 = v107;
v96 = v106;
v95 = sub_42AD94((__int64)v109, v106);
*v99 = v97[v95];
sub_42ADD2((__int64)v98, BYTE2(v97[v95]));
v110 = (_WORD *)((char *)v110 + HIBYTE(v97[v95]));
if ( (unsigned int)sub_42A8DD() )
{
v94 = v110;
v93 = v109;
v92 = v107;
v91 = v106;
v90 = sub_42AD94((__int64)v109, v106);
*v94 = v92[v90];
sub_42ADD2((__int64)v93, BYTE2(v92[v90]));
v110 = (_WORD *)((char *)v110 + HIBYTE(v92[v90]));
}
v89 = v110;
v88 = v109;
v87 = v107;
v86 = v106;
v85 = sub_42AD94((__int64)v109, v106);
*v89 = v87[v85];
sub_42ADD2((__int64)v88, BYTE2(v87[v85]));
v110 = (_WORD *)((char *)v110 + HIBYTE(v87[v85]));
}
while ( 1 )
{
v17 = sub_42ADF3((__int64)v109);
if ( v17 != 0 || (unsigned __int64)v110 > v108 - 2 )
break;
v84 = v110;
v83 = v109;
v82 = v107;
v81 = v106;
v80 = sub_42AD94((__int64)v109, v106);
*v84 = v82[v80];
sub_42ADD2((__int64)v83, BYTE2(v82[v80]));
v110 = (_WORD *)((char *)v110 + HIBYTE(v82[v80]));
}
while ( (unsigned __int64)v110 <= v108 - 2 )
{
v79 = v110;
v78 = v109;
v77 = v107;
v76 = v106;
v75 = sub_42AD94((__int64)v109, v106);
*v79 = v77[v75];
sub_42ADD2((__int64)v78, BYTE2(v77[v75]));
v110 = (_WORD *)((char *)v110 + HIBYTE(v77[v75]));
}
if ( v108 > (unsigned __int64)v110 )
{
v74 = v110;
v73 = v109;
v72 = v107;
v71 = v106;
v70 = sub_42AD94((__int64)v109, v106);
*v74 = v72[v70];
if ( HIBYTE(v72[v70]) == 1 )
{
sub_42ADD2((__int64)v73, BYTE2(v72[v70]));
}
else if ( *((_DWORD *)v73 + 2) <= 0x3Fu )
{
sub_42ADD2((__int64)v73, BYTE2(v72[v70]));
if ( *((_DWORD *)v73 + 2) > 0x40u )
*((_DWORD *)v73 + 2) = 64;
}
v110 = (_WORD *)((char *)v110 + 1);
}
v69 = v279;
v68 = v26;
v67 = v297;
v66 = v295;
v65 = v278;
v64 = v279;
while ( 1 )
{
v18 = (unsigned int)sub_42ADF3((__int64)v68) == 0;
if ( !v18 || (unsigned __int64)v69 >= v67 - 7 )
break;
if ( (unsigned int)sub_42A8DD() )
{
v63 = v69;
v62 = v68;
v61 = v66;
v60 = v65;
v59 = sub_42AD94((__int64)v68, v65);
*v63 = v61[v59];
sub_42ADD2((__int64)v62, BYTE2(v61[v59]));
v69 = (_WORD *)((char *)v69 + HIBYTE(v61[v59]));
}
sub_42A8DD();
v58 = v69;
v57 = v68;
v56 = v66;
v55 = v65;
v54 = sub_42AD94((__int64)v68, v65);
*v58 = v56[v54];
sub_42ADD2((__int64)v57, BYTE2(v56[v54]));
v69 = (_WORD *)((char *)v69 + HIBYTE(v56[v54]));
if ( (unsigned int)sub_42A8DD() )
{
v53 = v69;
v52 = v68;
v51 = v66;
v50 = v65;
v49 = sub_42AD94((__int64)v68, v65);
*v53 = v51[v49];
sub_42ADD2((__int64)v52, BYTE2(v51[v49]));
v69 = (_WORD *)((char *)v69 + HIBYTE(v51[v49]));
}
v48 = v69;
v47 = v68;
v46 = v66;
v45 = v65;
v44 = sub_42AD94((__int64)v68, v65);
*v48 = v46[v44];
sub_42ADD2((__int64)v47, BYTE2(v46[v44]));
v69 = (_WORD *)((char *)v69 + HIBYTE(v46[v44]));
}
while ( 1 )
{
v19 = sub_42ADF3((__int64)v68);
if ( v19 != 0 || (unsigned __int64)v69 > v67 - 2 )
break;
v43 = v69;
v42 = v68;
v41 = v66;
v40 = v65;
v39 = sub_42AD94((__int64)v68, v65);
*v43 = v41[v39];
sub_42ADD2((__int64)v42, BYTE2(v41[v39]));
v69 = (_WORD *)((char *)v69 + HIBYTE(v41[v39]));
}
while ( (unsigned __int64)v69 <= v67 - 2 )
{
v38 = v69;
v37 = v68;
v36 = v66;
v35 = v65;
v34 = sub_42AD94((__int64)v68, v65);
*v38 = v36[v34];
sub_42ADD2((__int64)v37, BYTE2(v36[v34]));
v69 = (_WORD *)((char *)v69 + HIBYTE(v36[v34]));
}
if ( v67 > (unsigned __int64)v69 )
{
v33 = v69;
v32 = v68;
v31 = v66;
v30 = v65;
v29 = sub_42AD94((__int64)v68, v65);
*v33 = v31[v29];
if ( HIBYTE(v31[v29]) == 1 )
{
sub_42ADD2((__int64)v32, BYTE2(v31[v29]));
}
else if ( *((_DWORD *)v32 + 2) <= 0x3Fu )
{
sub_42ADD2((__int64)v32, BYTE2(v31[v29]));
if ( *((_DWORD *)v32 + 2) > 0x40u )
*((_DWORD *)v32 + 2) = 64;
}
v69 = (_WORD *)((char *)v69 + 1);
}
v20 = sub_42AF58((__int64)v23);
v21 = sub_42AF58((__int64)v24) && v20;
v22 = sub_42AF58((__int64)v25) && v21;
if ( v22 & sub_42AF58((__int64)v26) )
result = v303;
else
result = -20LL;
return result;
}
Q:[a3,a4,a1,a2,a5,v18,v23,v24,v269,v277,v290,v294,v299,v300,sub_43511F,sub_42A969,sub_42AF8F,sub_42AB2C,sub_42AAB2,sub_42ADF3,sub_42A8DD,sub_42AD94,sub_42ADD2,sub_42AF58,] | A:{'a3': 'cSrc', 'a4': 'cSrcSize', 'a1': 'dst', 'a2': 'dstSize', 'a5': 'DTable', 'v18': 'cSrc', 'v23': 'bitD', 'v24': 'DStream', 'v269': 'nbBits', 'v277': 'code', 'v290': 'srcBuffer', 'v294': 'srcSize', 'v299': 'memPtr', 'v300': 'table', 'sub_43511F': 'HUF_decompress4X2_usingDTable_internal_bmi2', 'sub_42A969': 'MEM_readLE16_4', 'sub_42AF8F': 'HUF_getDTableDesc', 'sub_42AB2C': 'BIT_initDStream_1', 'sub_42AAB2': 'ERR_isError_8', 'sub_42ADF3': 'BIT_reloadDStream_1', 'sub_42A8DD': 'MEM_64bits_3', 'sub_42AD94': 'BIT_lookBitsFast_1', 'sub_42ADD2': 'BIT_skipBits_1', 'sub_42AF58': 'BIT_endOfDStream'} | |
bba09cc2e1eb5efb993454bdf472ff4af0e3b34a78277ac18ade6cbde3628a45_bba09cc2e1eb5efb993454bdf472ff4af0e3b34a78277ac18ade6cbde3628a45.jsonl.gz | sub_40484B | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_40484B()
{
sub_4045E8();
return sub_408BA1();
}
Q:[sub_40484B,sub_4045E8,sub_408BA1,] | A:{'sub_40484B': 'display_getch', 'sub_4045E8': 'display_refresh', 'sub_408BA1': 'device_getch'} | |
45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0_45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0.jsonl.gz | sub_460846 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_460846(__int64 a1)
{
return sub_46156C(a1);
}
Q:[a1,sub_460846,sub_46156C,] | A:{'a1': 'this', 'sub_460846': '~allocator', 'sub_46156C': '~new_allocator'} | |
33a261668156a7cfbfce8006108a44559b1a92c9e8a63df1d529f57f954e3e99_33a261668156a7cfbfce8006108a44559b1a92c9e8a63df1d529f57f954e3e99.jsonl.gz | sub_40FEB9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40FEB9(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
int v7; // [rsp+20h] [rbp-40h]
int v8; // [rsp+24h] [rbp-3Ch]
int v9; // [rsp+2Ch] [rbp-34h]
const void *v10; // [rsp+30h] [rbp-30h]
__off64_t v11; // [rsp+38h] [rbp-28h]
__int64 n; // [rsp+40h] [rbp-20h]
int v13; // [rsp+4Ch] [rbp-14h]
__int64 v14; // [rsp+50h] [rbp-10h]
__int64 v15; // [rsp+58h] [rbp-8h]
if ( !*(_QWORD *)(a1 + 4704) )
{
*(_QWORD *)(a1 + 4704) = malloc(*(int *)(a1 + 4712));
if ( !*(_QWORD *)(a1 + 4704) )
return 0LL;
memset(*(void **)(a1 + 4704), 0, *(int *)(a1 + 4712));
}
v11 = -1LL;
if ( a3 < *(_QWORD *)(a2 + 32) )
{
if ( a4 + a3 <= *(_QWORD *)(a2 + 32) )
v15 = a4;
else
v15 = *(_QWORD *)(a2 + 32) - a3;
}
else
{
v15 = 0LL;
}
sub_4083B8(*(_QWORD *)(a1 + 4664), 0, *(_DWORD *)(a1 + 4672), v15 + 12);
v13 = 12;
v9 = sub_40382C(*(__int64 **)(a1 + 4728), a2);
if ( v9 == -1 )
return -1LL;
*(_DWORD *)(a1 + 5392) = 1;
v14 = 0LL;
do
{
if ( v15 <= *(int *)(a1 + 4672) - (__int64)v13 + v14 )
n = v15 - v14;
else
n = *(int *)(a1 + 4672) - (__int64)v13;
if ( v11 != ((v14 + a3) & -*(_DWORD *)(a1 + 4712)) )
{
if ( (int)sub_4038DB(
*(_QWORD *)(a1 + 4728),
v9,
*(void **)(a1 + 4704),
-*(_DWORD *)(a1 + 4712) & (unsigned __int64)(v14 + a3),
*(int *)(a1 + 4712)) < 0 )
goto LABEL_17;
v11 = (v14 + a3) & -*(_DWORD *)(a1 + 4712);
}
v8 = (a3 + v14) & (*(_DWORD *)(a1 + 4712) - 1);
if ( n + v8 >= *(int *)(a1 + 4712) )
{
v7 = *(_DWORD *)(a1 + 4712) - v8;
memcpy((void *)(v13 + *(_QWORD *)(a1 + 4664)), (const void *)(*(_QWORD *)(a1 + 4704) + v8), v7);
v11 += *(int *)(a1 + 4712);
if ( (int)sub_4038DB(*(_QWORD *)(a1 + 4728), v9, *(void **)(a1 + 4704), v11, *(int *)(a1 + 4712)) < 0 )
{
LABEL_17:
sub_403936(v9);
return -1LL;
}
memcpy((void *)(v13 + v7 + *(_QWORD *)(a1 + 4664)), *(const void **)(a1 + 4704), n - v7);
v10 = *(const void **)(a1 + 4664);
}
else if ( v13 )
{
memcpy((void *)(v13 + *(_QWORD *)(a1 + 4664)), (const void *)(*(_QWORD *)(a1 + 4704) + v8), n);
v10 = *(const void **)(a1 + 4664);
}
else
{
v10 = (const void *)(*(_QWORD *)(a1 + 4704) + v8);
}
v14 += n;
sub_404348(*(_QWORD *)(a1 + 4656), 0, v10, n + v13);
v13 = 0;
}
while ( v14 < v15 && !*(_DWORD *)(a1 + 5388) );
*(_DWORD *)(a1 + 5392) = 0;
sub_403936(v9);
if ( *(_DWORD *)(a1 + 5388) )
{
sub_40BCCC(a1, *(_DWORD *)(a1 + 4768));
v15 = -2LL;
*(_DWORD *)(a1 + 5388) = 0;
}
else
{
sub_40BCCC(a1, v15 + 12);
}
return v15;
}
Q:[a3,a4,a1,a2,v7,v8,v9,v10,v11,n,v13,v15,sub_40FEB9,sub_4083B8,sub_40382C,sub_4038DB,sub_403936,sub_404348,sub_40BCCC,] | A:{'a3': 'offset', 'a4': 'maxsize', 'a1': 'ctx', 'a2': 'entry', 'v7': 'first_part_size', 'v8': 'io_buffer_index', 'v9': 'file', 'v10': 'usb_buffer_ptr', 'v11': 'buf_index', 'n': 'blocksize', 'v13': 'ofs', 'v15': 'actualsize', 'sub_40FEB9': 'send_file_data', 'sub_4083B8': 'poke32', 'sub_40382C': 'entry_open', 'sub_4038DB': 'entry_read', 'sub_403936': 'entry_close', 'sub_404348': 'write_usb', 'sub_40BCCC': 'check_and_send_USB_ZLP'} | |
8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2_8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2.jsonl.gz | sub_4102C2 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4102C2(__int64 a1, int a2)
{
return sub_41024B(a1, a2);
}
Q:[a1,a2,sub_4102C2,sub_41024B,] | A:{'a1': 'thr', 'a2': 'idx', 'sub_4102C2': 'duk_known_hobject', 'sub_41024B': 'duk__known_heaphdr'} | |
507b6d6826ab1404fd3df13a4b27da226b5beb2f60ed3e979a82f4c0a6725d69_507b6d6826ab1404fd3df13a4b27da226b5beb2f60ed3e979a82f4c0a6725d69.jsonl.gz | sub_43B712 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43B712(__int64 a1, __int64 a2, __int64 *a3, __int64 *a4, __int64 a5, __int64 a6, __int64 *a7, __int64 a8)
{
__int64 *v8; // rax
int v9; // er8
int v10; // er9
int v11; // edx
int v12; // ecx
int v13; // er8
int v14; // er9
__int64 v16; // [rsp+38h] [rbp-58h]
unsigned __int64 i; // [rsp+40h] [rbp-50h]
__int64 v18; // [rsp+48h] [rbp-48h]
_QWORD *v19; // [rsp+50h] [rbp-40h]
__int64 v20; // [rsp+58h] [rbp-38h]
_QWORD *v21; // [rsp+60h] [rbp-30h]
unsigned int v26; // [rsp+8Ch] [rbp-4h]
v26 = 0;
v21 = 0LL;
v20 = 0LL;
v19 = 0LL;
v18 = 0LL;
v16 = *a7;
for ( i = 0LL; i < a7[1]; ++i )
{
if ( *(_DWORD *)v16 != 2 )
{
if ( *(_QWORD *)(v16 + 24) )
{
if ( *(_QWORD *)(v16 + 8) && (unsigned int)sub_423D5D(*(_QWORD *)(v16 + 8)) )
{
if ( !v19 )
{
v19 = sub_40DBDB(a4);
v18 = sub_443540(a6);
}
v26 |= sub_43A20E(a1, a2, (__int64)v19, v18, v16, a8);
}
else
{
v26 |= sub_43A20E(a1, a2, (__int64)a4, a6, v16, a8);
}
}
else if ( *(_QWORD *)(v16 + 8) && (unsigned int)sub_423D5D(*(_QWORD *)(v16 + 8)) )
{
if ( !v21 )
{
v21 = sub_40DBDB(a3);
v20 = sub_443540(a5);
}
v26 |= sub_43A20E(a1, a2, (__int64)v21, v20, v16, a8);
}
else
{
v26 |= sub_43A20E(a1, a2, (__int64)a3, a5, v16, a8);
}
sub_43D6F4(*(_QWORD *)(a8 + 40), v16);
v8 = (__int64 *)sub_43A382(v16);
sub_43ACA6(a1, v8, a8, (int)v8, v9, v10);
sub_44B6DA(a1, (unsigned int)"\n", v11, v12, v13, v14);
if ( *(_BYTE *)(a8 + 4) != 1 && i )
{
a3 = 0LL;
a5 = 0LL;
a4 = 0LL;
a6 = 0LL;
if ( v21 )
{
sub_442B47(v21);
sub_442B47(v20);
v21 = 0LL;
v20 = 0LL;
}
if ( v19 )
{
sub_442B47(v19);
sub_442B47(v18);
v19 = 0LL;
v18 = 0LL;
}
}
}
v16 += 64LL;
}
if ( v21 )
{
sub_442B47(v21);
sub_442B47(v20);
}
if ( v19 )
{
sub_442B47(v19);
sub_442B47(v18);
}
return v26;
}
Q:[a3,a4,a1,a2,a5,a6,a7,a8,v9,v10,v11,v16,i,v18,v19,v20,v21,v26,sub_43B712,sub_423D5D,sub_40DBDB,sub_443540,sub_43A20E,sub_43D6F4,sub_43A382,sub_43ACA6,sub_44B6DA,sub_442B47,] | A:{'a3': 'read_end1', 'a4': 'read_end2', 'a1': 'gprinter', 'a2': 'tag', 'a5': 'qualities_end1', 'a6': 'qualities_end2', 'a7': 'map_placeholder_vector', 'a8': 'attributes', 'v9': 'qualities_end1', 'v10': 'qualities_end2', 'v11': 'read_end1', 'v16': 'map_ph', 'i': 'map_ph_it', 'v18': 'qualities_r_end2', 'v19': 'read_rc_end2', 'v20': 'qualities_r_end1', 'v21': 'read_rc_end1', 'v26': 'error_code', 'sub_43B712': 'gt_output_sam_gprint_map_placeholder_vector_pe', 'sub_423D5D': 'gt_map_get_strand', 'sub_40DBDB': 'gt_dna_string_reverse_complement_dup', 'sub_443540': 'gt_string_reverse_dup', 'sub_43A20E': 'gt_output_sam_gprint_map_placeholder', 'sub_43D6F4': 'gt_sam_attribute_func_params_set_alignment_info', 'sub_43A382': 'gt_output_sam_select_sam_attributes', 'sub_43ACA6': 'gt_output_sam_gprint_optional_fields', 'sub_44B6DA': 'gt_gprintf', 'sub_442B47': 'gt_string_delete'} | |
113e75c189faad4e2f0b88afe04011a4861b8d4a3a7fdfecdcc57b845ed83590_113e75c189faad4e2f0b88afe04011a4861b8d4a3a7fdfecdcc57b845ed83590.jsonl.gz | sub_41DA0D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41DA0D(__int64 a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6, __int64 a7, __int64 a8, __int64 a9, unsigned __int8 *a10, char a11)
{
__int64 result; // rax
int v12; // [rsp+34h] [rbp-1Ch]
int v13; // [rsp+38h] [rbp-18h]
int v14; // [rsp+40h] [rbp-10h]
int v15; // [rsp+44h] [rbp-Ch]
int j; // [rsp+48h] [rbp-8h]
int l; // [rsp+48h] [rbp-8h]
int i; // [rsp+4Ch] [rbp-4h]
int k; // [rsp+4Ch] [rbp-4h]
v15 = a10[5];
v14 = a10[6];
v13 = a10[4];
v12 = v13 >> a11;
for ( i = 0; i < v14; ++i )
{
for ( j = 0; j < v15; ++j )
*(_BYTE *)(v13 * i + j + a1) = (*(unsigned __int8 *)(v13 * i + j + a4) + *(unsigned __int8 *)(v13 * i + j + a7)) >> 1;
}
for ( k = 0; ; ++k )
{
result = (unsigned int)(v14 >> a11);
if ( k >= (int)result )
break;
for ( l = 0; l < v15 >> a11; ++l )
{
*(_BYTE *)(v12 * k + l + a2) = (*(unsigned __int8 *)(v12 * k + l + a5) + *(unsigned __int8 *)(v12 * k + l + a8)) >> 1;
*(_BYTE *)(v12 * k + l + a3) = (*(unsigned __int8 *)(v12 * k + l + a6) + *(unsigned __int8 *)(v12 * k + l + a9)) >> 1;
}
}
return result;
}
Q:[a3,a4,a1,a2,a5,a6,a7,a8,a9,a10,a11,v12,v13,v14,v15,k,sub_41DA0D,] | A:{'a3': 'rec_v', 'a4': 'pblock0_y', 'a1': 'rec_y', 'a2': 'rec_u', 'a5': 'pblock0_u', 'a6': 'pblock0_v', 'a7': 'pblock1_y', 'a8': 'pblock1_u', 'a9': 'pblock1_v', 'a10': 'block_pos', 'a11': 'sub', 'v12': 'sizeC', 'v13': 'sizeY', 'v14': 'bheight', 'v15': 'bwidth', 'k': 'ia', 'sub_41DA0D': 'average_blocks_all_lbd'} | |
e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433_e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433.jsonl.gz | sub_42B9B2 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42B9B2(__int64 a1)
{
__int64 v2; // [rsp+18h] [rbp-8h] BYREF
sub_42C4B4(&v2, a1 + 8);
return v2;
}
Q:[sub_42B9B2,sub_42C4B4,] | A:{'sub_42B9B2': 'end', 'sub_42C4B4': '__normal_iterator'} | |
c00ba4bccd75463928b9d2ca0657fdf7633263e8f3a85f5f4c8a0205576b1a25_c00ba4bccd75463928b9d2ca0657fdf7633263e8f3a85f5f4c8a0205576b1a25.jsonl.gz | sub_4028CF | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_4028CF()
{
__int64 result; // rax
if ( dword_431224 )
result = (unsigned int)dword_43101C;
else
result = 4294967288LL;
return result;
}
Q:[sub_4028CF,] | A:{'sub_4028CF': 'tb_height'} | |
2ceee776f3ad6c2f35b8f97c7cfeff38c006848a306dfa92217fdebcf0ec093f_2ceee776f3ad6c2f35b8f97c7cfeff38c006848a306dfa92217fdebcf0ec093f.jsonl.gz | sub_41077E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41077E(unsigned int a1, unsigned int *a2)
{
__int64 v2; // rsi
unsigned int v3; // eax
if ( *a2 + 1 >= a2[1] )
{
a2[1] = *a2 + 2;
--a2[1];
a2[1] |= a2[1] >> 1;
a2[1] |= a2[1] >> 2;
a2[1] |= a2[1] >> 4;
a2[1] |= a2[1] >> 8;
a2[1] |= HIWORD(a2[1]);
*((_QWORD *)a2 + 1) = realloc(*((void **)a2 + 1), ++a2[1]);
}
v2 = *((_QWORD *)a2 + 1);
v3 = (*a2)++;
*(_BYTE *)(v2 + v3) = a1;
*(_BYTE *)(*((_QWORD *)a2 + 1) + *a2) = 0;
return a1;
}
Q:[a1,a2,sub_41077E,] | A:{'a1': 'c', 'a2': 's', 'sub_41077E': 'kputc_0'} | |
74b93be29b886f02996dd82341e273fc6ded8145e7a7bad3f6303c5716197756_74b93be29b886f02996dd82341e273fc6ded8145e7a7bad3f6303c5716197756.jsonl.gz | sub_4122F3 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4122F3(__int64 a1, __int64 a2)
{
return sub_413DC8(a1, a2);
}
Q:[a1,a2,sub_4122F3,sub_413DC8,] | A:{'a1': '__first', 'a2': '__last', 'sub_4122F3': '_Destroy', 'sub_413DC8': '__destroy'} | |
5c2a369c2a43bfe06e48866e92fbdc8c356c46190477983799d2e15f105ed3e0_5c2a369c2a43bfe06e48866e92fbdc8c356c46190477983799d2e15f105ed3e0.jsonl.gz | sub_447991 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int16 *__fastcall sub_447991(unsigned __int16 *a1)
{
unsigned __int16 *result; // rax
char v2[8]; // [rsp+10h] [rbp-20h] BYREF
unsigned __int16 *v3; // [rsp+18h] [rbp-18h]
unsigned __int16 *v4; // [rsp+20h] [rbp-10h]
unsigned __int16 *v5; // [rsp+28h] [rbp-8h]
if ( a1 )
{
parse_rtattr_flags(v2, 3LL, a1 + 2, (unsigned int)*a1 - 4, 0x8000LL);
if ( v3 )
{
result = (unsigned __int16 *)sub_4473F6(v3);
}
else if ( v4 )
{
result = (unsigned __int16 *)sub_447773(v4);
}
else
{
result = v5;
if ( v5 )
result = (unsigned __int16 *)sub_447839(v5);
}
}
return result;
}
Q:[a1,v2,sub_447991,sub_4473F6,sub_447773,sub_447839,] | A:{'a1': 'attr', 'v2': 'tb', 'sub_447991': 'tunnel_key_print_key_opt', 'sub_4473F6': 'tunnel_key_print_geneve_options', 'sub_447773': 'tunnel_key_print_vxlan_options', 'sub_447839': 'tunnel_key_print_erspan_options'} | |
44e8aed08fe933b793e356a871e8f31cdd3a534e9dca1fb63610d519aee2b0ea_44e8aed08fe933b793e356a871e8f31cdd3a534e9dca1fb63610d519aee2b0ea.jsonl.gz | sub_45499A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_45499A(__int64 a1)
{
return a1;
}
Q:[sub_45499A,] | A:{'sub_45499A': 'allocator'} | |
84e358d88b6a2d9d1b86c2cfe73a828ec824b8ad271a8799d0804866326c3fb6_84e358d88b6a2d9d1b86c2cfe73a828ec824b8ad271a8799d0804866326c3fb6.jsonl.gz | sub_401FF3 | Help user generate meaningful names for variables and functions in the following code snippet. |
int sub_401FF3(const char *a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6, ...)
{
gcc_va_list arg; // [rsp+18h] [rbp-C8h] BYREF
__int64 v8; // [rsp+38h] [rbp-A8h]
__int64 v9; // [rsp+40h] [rbp-A0h]
__int64 v10; // [rsp+48h] [rbp-98h]
__int64 v11; // [rsp+50h] [rbp-90h]
__int64 v12; // [rsp+58h] [rbp-88h]
va_start(arg, a6);
v8 = a2;
v9 = a3;
v10 = a4;
v11 = a5;
v12 = a6;
arg[0].gp_offset = 8;
printf("# ");
return vprintf(a1, arg);
}
Q:[a1,arg,sub_401FF3,] | A:{'a1': 'msg', 'arg': 'args', 'sub_401FF3': 'ksft_print_msg_1'} | |
ec13b450451a1a6f85448efbf548f41f93dcb45bdcb731e55b9e95be4a5b58ce_ec13b450451a1a6f85448efbf548f41f93dcb45bdcb731e55b9e95be4a5b58ce.jsonl.gz | sub_4049EE | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4049EE(__int64 a1, __int64 a2, int a3)
{
char v4[8]; // [rsp+20h] [rbp-210h] BYREF
int v5; // [rsp+28h] [rbp-208h]
__int64 v6; // [rsp+30h] [rbp-200h]
v5 = a3;
v6 = a2;
return sub_404201(a1, (__int64)v4, 83, 16);
}
Q:[a3,a1,a2,v4,sub_4049EE,sub_404201,] | A:{'a3': 'id', 'a1': 'ss_0', 'a2': 'opaque', 'v4': 'request', 'sub_4049EE': 'socket_server_start', 'sub_404201': 'send_request'} | |
3d7cab3a1bf8adde17b4d0ec97573fdef2461eddb73b47a8a887d7be9398c3be_3d7cab3a1bf8adde17b4d0ec97573fdef2461eddb73b47a8a887d7be9398c3be.jsonl.gz | sub_408EE7 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 __fastcall sub_408EE7(__int64 a1)
{
unsigned int v2; // eax
if ( sub_408E9F(a1) )
return 1LL;
v2 = *(_DWORD *)qword_415B60;
if ( *(_DWORD *)qword_415B60 <= 0x135u )
{
if ( v2 >= 0x132 )
return 1LL;
if ( v2 == 257 )
return sub_408E5E(*(_QWORD *)(a1 + 8));
if ( v2 >= 0x101 && v2 - 279 <= 1 )
return 1LL;
}
return 0LL;
}
Q:[a1,sub_408EE7,sub_408E9F,sub_408E5E,] | A:{'a1': 't', 'sub_408EE7': 'isdeclstart', 'sub_408E9F': 'istypestart', 'sub_408E5E': 'istypename'} | |
11d51f39d967e6c925cbbbf561559e32fec33ac3b7a84b8e1e75a62d16d81f0a_11d51f39d967e6c925cbbbf561559e32fec33ac3b7a84b8e1e75a62d16d81f0a.jsonl.gz | sub_42EB1E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42EB1E(unsigned __int64 a1, __int64 a2)
{
_QWORD *v3; // [rsp+0h] [rbp-D0h]
__int64 v4; // [rsp+18h] [rbp-B8h]
__int64 v5; // [rsp+20h] [rbp-B0h]
__int64 v6; // [rsp+28h] [rbp-A8h]
int v7; // [rsp+30h] [rbp-A0h] BYREF
int v8; // [rsp+34h] [rbp-9Ch] BYREF
int v9; // [rsp+38h] [rbp-98h] BYREF
int v10; // [rsp+3Ch] [rbp-94h]
__int64 v11; // [rsp+40h] [rbp-90h]
unsigned int v12; // [rsp+48h] [rbp-88h]
int v13; // [rsp+4Ch] [rbp-84h]
__int64 v14; // [rsp+50h] [rbp-80h]
int v16; // [rsp+64h] [rbp-6Ch]
__int64 v17; // [rsp+68h] [rbp-68h]
__int64 v18; // [rsp+70h] [rbp-60h]
int v19; // [rsp+7Ch] [rbp-54h]
int v20; // [rsp+80h] [rbp-50h]
int v21; // [rsp+84h] [rbp-4Ch]
unsigned int v22; // [rsp+88h] [rbp-48h]
int v23; // [rsp+8Ch] [rbp-44h]
int v24; // [rsp+90h] [rbp-40h]
int v25; // [rsp+94h] [rbp-3Ch]
__int64 v26; // [rsp+98h] [rbp-38h]
_BYTE *v27; // [rsp+A0h] [rbp-30h]
const char *v28; // [rsp+A8h] [rbp-28h]
const char *v29; // [rsp+B0h] [rbp-20h]
__int64 v30; // [rsp+B8h] [rbp-18h]
__int64 v31; // [rsp+C0h] [rbp-10h]
__int64 v32; // [rsp+C8h] [rbp-8h]
v32 = 0LL;
v31 = 0LL;
v30 = 0LL;
v29 = 0LL;
v28 = 0LL;
v27 = 0LL;
v26 = 0LL;
v25 = 0;
v24 = 0;
v23 = 0;
v22 = 1;
v9 = 0;
v21 = 0;
v8 = 32773;
v7 = 32773;
v20 = 0;
v19 = 0;
a1 = (unsigned int)a1;
v17 = sub_43A033((unsigned int)a1, a2, &off_493E40);
while ( 2 )
{
v16 = sub_43AF0E(a1);
if ( v16 )
{
switch ( v16 )
{
case -1:
case 0:
goto LABEL_87;
case 1:
sub_43B665(&off_493E40);
v22 = 0;
break;
case 2:
a1 = sub_43B565(a1);
if ( (unsigned int)sub_43A194(a1, 2LL, &v8) )
continue;
goto LABEL_87;
case 3:
a1 = sub_43B565(a1);
if ( (unsigned int)sub_43A194(a1, 2LL, &v7) )
continue;
goto LABEL_87;
case 4:
v29 = (const char *)sub_43B565(a1);
continue;
case 5:
v28 = (const char *)sub_43B565(a1);
continue;
case 6:
a1 = sub_43B565(a1);
v26 = sub_41FC82((const char *)a1, 0);
continue;
case 7:
v20 = 1;
continue;
case 8:
v24 = 1;
continue;
case 9:
v19 = 1;
continue;
case 10:
v27 = (_BYTE *)sub_43B565(a1);
continue;
case 11:
v25 = 1;
continue;
case 12:
v23 = 1;
continue;
case 13:
v21 = 2;
continue;
case 14:
v21 = 5;
continue;
default:
continue;
}
}
else
{
sub_43B5A8(a1);
v3 = (_QWORD *)sub_43B58C(a1);
if ( !*v3 || (unsigned int)sub_43A68C(*v3, &v9) && v9 > 0 )
{
if ( v21 && !v9 )
v9 = 2048;
if ( v25 && v21 )
goto LABEL_87;
if ( v9 && !v21 )
v21 = 2;
if ( v9 )
{
if ( !BN_GENCB_new() )
goto LABEL_59;
BN_GENCB_set();
if ( !(unsigned int)sub_41CDA2(0LL, 1) && !v27 )
BIO_printf();
if ( v27 )
{
sub_41CECD(v27);
BIO_printf();
}
if ( v25 )
{
v14 = DSA_new();
BIO_printf();
if ( !v14 || !(unsigned int)DSA_generate_parameters_ex() )
{
DSA_free();
BN_GENCB_free();
ERR_print_errors();
break;
}
v30 = DSA_dup_DH();
DSA_free();
if ( !v30 )
{
LABEL_46:
BN_GENCB_free();
ERR_print_errors();
break;
}
}
else
{
v30 = DH_new();
BIO_printf();
BIO_printf();
if ( !v30 || !(unsigned int)DH_generate_parameters_ex() )
goto LABEL_46;
}
BN_GENCB_free();
sub_41CF82(0LL);
}
else
{
v32 = sub_422073(v29, 114, v8);
if ( !v32 )
break;
if ( v25 )
{
if ( v8 == 4 )
v18 = ASN1_d2i_bio();
else
v18 = PEM_read_bio_DSAparams();
if ( !v18 )
goto LABEL_99;
v30 = DSA_dup_DH();
DSA_free();
if ( !v30 )
{
LABEL_59:
ERR_print_errors();
break;
}
}
else
{
if ( v8 == 4 )
v30 = ASN1_d2i_bio();
else
v30 = PEM_read_bio_DHparams();
if ( !v30 )
goto LABEL_99;
}
}
v31 = sub_422073(v28, 119, v7);
if ( !v31 )
break;
if ( v24 )
DHparams_print();
if ( v20 )
{
if ( !(unsigned int)DH_check() )
goto LABEL_59;
if ( (v10 & 1) != 0 )
BIO_printf();
if ( (v10 & 2) != 0 )
BIO_printf();
if ( (v10 & 0x10) != 0 )
BIO_printf();
if ( (v10 & 0x20) != 0 )
BIO_printf();
if ( (v10 & 0x40) != 0 )
BIO_printf();
if ( (v10 & 4) != 0 )
BIO_printf();
if ( (v10 & 8) != 0 )
BIO_printf();
if ( !v10 )
BIO_printf();
if ( v9 && v10 )
{
LABEL_87:
BIO_printf();
break;
}
}
if ( v23 )
{
v13 = DH_size();
v12 = DH_bits();
DH_get0_pqg();
v11 = sub_41F235(v13);
BIO_printf();
BIO_printf();
sub_41F81B(v31, v6, "dhp", v12);
sub_41F81B(v31, v5, "dhg", v12);
BIO_printf();
BIO_printf();
BIO_printf();
BIO_printf();
if ( DH_get_length() > 0 )
{
DH_get_length();
BIO_printf();
}
BIO_printf();
CRYPTO_free();
}
if ( v19
|| ((DH_get0_pqg(), v7 != 4) ? (!v4 ? (v10 = PEM_write_bio_DHparams()) : (v10 = PEM_write_bio_DHxparams())) : (v10 = ASN1_i2d_bio()),
v10) )
{
v22 = 0;
break;
}
LABEL_99:
BIO_printf();
ERR_print_errors();
break;
}
}
break;
}
BIO_free();
BIO_free_all();
DH_free();
sub_41FE1B(v26);
return v22;
}
Q:[a1,a2,v3,v4,v5,v6,v7,v8,v9,v11,v12,v13,v14,v16,v17,v18,v19,v20,v21,v23,v24,v25,v26,v27,v28,v29,v30,v31,v32,sub_42EB1E,sub_43A033,sub_43AF0E,sub_43B665,sub_43B565,sub_43A194,sub_41FC82,sub_43B5A8,sub_43B58C,sub_43A68C,sub_41CDA2,sub_41CECD,sub_41CF82,sub_422073,sub_41F235,sub_41F81B,sub_41FE1B,] | A:{'a1': 'argc', 'a2': 'argv', 'v3': 'argva', 'v4': 'q', 'v5': 'gbn', 'v6': 'pbn', 'v7': 'outformat', 'v8': 'informat', 'v9': 'num', 'v11': 'data', 'v12': 'bits', 'v13': 'len', 'v14': 'dsa', 'v16': 'o', 'v17': 'prog', 'v18': 'dsa_0', 'v19': 'noout', 'v20': 'check', 'v21': 'g', 'v23': 'C', 'v24': 'text', 'v25': 'dsaparam', 'v26': 'e', 'v27': 'inrand', 'v28': 'outfile', 'v29': 'infile', 'v30': 'dh_0', 'v31': 'out', 'v32': 'in', 'sub_42EB1E': 'dhparam_main', 'sub_43A033': 'opt_init', 'sub_43AF0E': 'opt_next', 'sub_43B665': 'opt_help', 'sub_43B565': 'opt_arg', 'sub_43A194': 'opt_format', 'sub_41FC82': 'setup_engine', 'sub_43B5A8': 'opt_num_rest', 'sub_43B58C': 'opt_rest', 'sub_43A68C': 'opt_int', 'sub_41CDA2': 'app_RAND_load_file', 'sub_41CECD': 'app_RAND_load_files', 'sub_41CF82': 'app_RAND_write_file', 'sub_422073': 'bio_open_default', 'sub_41F235': 'app_malloc', 'sub_41F81B': 'print_bignum_var', 'sub_41FE1B': 'release_engine'} | |
e53d5295be6e634f84a15d2ee5468213cc33bcf6cde051baf5f95b2c12b222ac_e53d5295be6e634f84a15d2ee5468213cc33bcf6cde051baf5f95b2c12b222ac.jsonl.gz | sub_435970 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_435970(__int64 a1, unsigned __int8 *a2, unsigned int a3)
{
unsigned __int16 v3; // eax^2
unsigned __int64 v4; // r8
unsigned __int8 *v5; // rbp
unsigned __int64 v6; // rax
__int64 v7; // r12
__int64 v8; // rbx
__int64 v9; // r11
__int64 v10; // r10
unsigned __int64 v11; // r15
__int64 v12; // r9
unsigned __int64 v13; // r14
__int64 v14; // r8
__int64 v15; // rdi
__int64 v16; // rsi
__int64 v17; // rcx
unsigned __int64 v18; // r13
__int64 v19; // rdx
__int64 v20; // r12
__int64 v21; // rbx
__int64 v22; // r11
__int64 v23; // r10
__int64 v24; // r9
__int64 v25; // r8
__int64 v26; // rdi
__int64 v27; // rsi
__int64 v28; // rcx
unsigned __int64 v29; // rdx
bool v30; // zf
int v32; // edx
unsigned __int64 v33; // r8
unsigned __int64 v34; // rax
unsigned __int64 v35; // r14
unsigned __int64 v36; // r15
__int64 v37; // r11
__int64 v38; // rbx
unsigned __int64 v39; // rbp
__int64 v40; // r8
unsigned __int64 v41; // r12
__int64 v42; // r9
__int64 v43; // rdi
__int64 v44; // rcx
unsigned __int64 v45; // r13
unsigned __int64 v46; // r10
__int64 v47; // rsi
__int64 v48; // rdx
__int64 v49; // r11
__int64 v50; // rbx
__int64 v51; // r8
__int64 v52; // r9
__int64 v53; // rdi
__int64 v54; // rcx
__int64 v55; // rsi
int i; // edx
unsigned __int64 v57; // rax
__int64 v58; // r8
unsigned int v59; // [rsp+Ch] [rbp-6Ch]
unsigned __int8 *v60; // [rsp+10h] [rbp-68h]
int v61; // [rsp+1Ch] [rbp-5Ch]
unsigned __int64 v62; // [rsp+20h] [rbp-58h]
unsigned __int64 v63; // [rsp+28h] [rbp-50h]
unsigned __int64 v64; // [rsp+30h] [rbp-48h]
unsigned __int64 v65; // [rsp+38h] [rbp-40h]
unsigned __int64 v66; // [rsp+40h] [rbp-38h]
v3 = WORD1(a1);
a1 = (unsigned __int16)a1;
v59 = a3;
v60 = a2;
v62 = v3;
v66 = (unsigned __int16)a1;
if ( a3 == 1 )
{
v57 = a1 + *a2;
if ( v57 >= 0xFFF1 )
v57 -= 65521LL;
v58 = v57 + v62;
if ( v57 + v62 >= 0xFFF1 )
v58 = v57 + v62 - 65521;
v4 = v57 | (v58 << 16);
}
else
{
v4 = 1LL;
if ( a2 )
{
if ( a3 <= 0xF )
{
v32 = 0;
if ( v59 )
{
do
{
++v32;
v66 += *v60++;
v62 += v66;
}
while ( v32 != v59 );
}
v33 = v66;
if ( v66 >= 0xFFF1 )
v33 = v66 - 65521;
v4 = ((v62 % 0xFFF1) << 16) | v33;
}
else
{
if ( a3 > 0x15AF )
{
do
{
v59 -= 5552;
v5 = v60;
v61 = 347;
do
{
v6 = v66 + *v5;
v63 = v6 + v5[1];
v64 = v63 + v5[2];
v7 = v5[6];
v8 = v5[7];
v9 = v5[8];
v10 = v5[9];
v11 = v64 + v5[3];
v12 = v5[10];
v13 = v11 + v5[4];
v14 = v5[11];
v15 = v5[12];
v16 = v5[13];
v17 = v5[14];
v18 = v13 + v5[5];
v19 = v5[15];
v5 += 16;
v20 = v18 + v7;
v21 = v20 + v8;
v22 = v21 + v9;
v23 = v22 + v10;
v24 = v23 + v12;
v25 = v24 + v14;
v26 = v25 + v15;
v27 = v26 + v16;
v28 = v27 + v17;
v29 = v28 + v19;
v30 = v61-- == 1;
v66 = v29;
v62 += v29 + v28 + v27 + v26 + v25 + v24 + v23 + v22 + v21 + v20 + v18 + v13 + v11 + v64 + v63 + v6;
}
while ( !v30 );
v60 += 5552;
v66 = v29 % 0xFFF1;
v62 %= 0xFFF1uLL;
}
while ( v59 > 0x15AF );
}
if ( v59 )
{
while ( v59 > 0xF )
{
v59 -= 16;
v34 = v66 + *v60;
v35 = v34 + v60[1];
v36 = v35 + v60[2];
v65 = v36 + v60[3];
v37 = v60[8];
v38 = v60[9];
v39 = v60[4] + v65;
v40 = v60[10];
v41 = v39 + v60[5];
v42 = v60[11];
v43 = v60[12];
v44 = v60[13];
v45 = v41 + v60[6];
v46 = v45 + v60[7];
v47 = v60[14];
v48 = v60[15];
v60 += 16;
v49 = v46 + v37;
v50 = v49 + v38;
v51 = v50 + v40;
v52 = v51 + v42;
v53 = v52 + v43;
v54 = v53 + v44;
v55 = v54 + v47;
v66 = v55 + v48;
v62 += v55 + v48 + v55 + v54 + v53 + v52 + v51 + v50 + v49 + v46 + v45 + v41 + v39 + v65 + v36 + v35 + v34;
}
if ( v59 )
{
for ( i = 0; i != v59; ++i )
{
v66 += *v60++;
v62 += v66;
}
}
v66 %= 0xFFF1uLL;
v62 %= 0xFFF1uLL;
}
v4 = v66 | (v62 << 16);
}
}
}
return v4;
}
Q:[sub_435970,] | A:{'sub_435970': 'adler32'} | |
381d292075dc673d592537d3c6560c868a4f6a2b66ddf83329a8ac77b4ceb3ad_381d292075dc673d592537d3c6560c868a4f6a2b66ddf83329a8ac77b4ceb3ad.jsonl.gz | sub_401A3F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_401A3F(__int64 a1, __int64 a2, _DWORD *a3)
{
char v5[296]; // [rsp+20h] [rbp-130h] BYREF
unsigned int v6; // [rsp+148h] [rbp-8h]
int i; // [rsp+14Ch] [rbp-4h]
sub_401884(a2, v5);
v6 = sub_4014C7(a1, v5);
if ( a3 )
{
*a3 = -1;
if ( v6 != -1 )
{
for ( i = 0; !sub_401836(a2, i); ++i )
{
if ( *(_DWORD *)(16LL * i + a2 + 8) == *(_DWORD *)(a1 + 16) )
*a3 = i;
}
}
}
return v6;
}
Q:[a3,a1,a2,v5,v6,sub_401A3F,sub_401884,sub_4014C7,sub_401836,] | A:{'a3': 'longindex', 'a1': 'options', 'a2': 'longopts', 'v5': 'optstring', 'v6': 'result', 'sub_401A3F': 'optparse_long_fallback', 'sub_401884': 'optparse_from_long', 'sub_4014C7': 'optparse_0', 'sub_401836': 'optparse_longopts_end'} | |
9d78dbff2b693e04074ea84c73a96628b1f1aed0c972b2f8d7ee58d07ee0ab92_9d78dbff2b693e04074ea84c73a96628b1f1aed0c972b2f8d7ee58d07ee0ab92.jsonl.gz | sub_429677 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_429677(char *a1, unsigned __int64 a2, char *a3, unsigned __int64 a4, unsigned int a5)
{
unsigned __int64 result; // rax
char *v6; // rax
char v7; // si
char *v8; // rax
char v9; // cl
char *v10; // rax
char v11; // si
char *v12; // rax
char v13; // cl
unsigned __int8 v14; // [rsp+Ch] [rbp-64h]
int j; // [rsp+34h] [rbp-3Ch]
char *v19; // [rsp+38h] [rbp-38h]
char *v20; // [rsp+40h] [rbp-30h]
unsigned __int64 v21; // [rsp+48h] [rbp-28h]
int i; // [rsp+54h] [rbp-1Ch]
char *v23; // [rsp+58h] [rbp-18h]
char *v24; // [rsp+60h] [rbp-10h]
unsigned __int64 v25; // [rsp+68h] [rbp-8h]
result = a5;
v14 = a5;
while ( a4 > 0xF )
{
sub_454AAE(a1, v14);
v25 = a2;
v24 = a1;
result = (unsigned __int64)a3;
v23 = a3;
for ( i = 16; i; --i )
{
v6 = v24++;
v7 = *v6;
v8 = v23++;
v9 = *v8;
result = v25++;
*(_BYTE *)result = v9 ^ v7;
}
a2 += 16LL;
a3 += 16;
a4 -= 16LL;
}
if ( a4 )
{
sub_454AAE(a1, v14);
v21 = a2;
v20 = a1;
v19 = a3;
result = a4;
for ( j = a4; j; --j )
{
v10 = v20++;
v11 = *v10;
v12 = v19++;
v13 = *v12;
result = v21++;
*(_BYTE *)result = v13 ^ v11;
}
}
return result;
}
Q:[a3,a4,a1,a2,a5,j,v19,v20,v21,i,v23,v24,v25,sub_429677,sub_454AAE,] | A:{'a3': 'src', 'a4': 'len', 'a1': 'state', 'a2': 'dest', 'a5': 'first_round', 'j': '_len_0', 'v19': '_src2_0', 'v20': '_src1_0', 'v21': '_dest_0', 'i': '_len', 'v23': '_src2', 'v24': '_src1', 'v25': '_dest', 'sub_429677': 'ascon_siv_encrypt_16', 'sub_454AAE': 'ascon_permute'} | |
decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08_decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08.jsonl.gz | sub_4B3D0C | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4B3D0C(__int64 a1, char *a2, size_t a3, unsigned int a4, __int64 a5, __int64 a6)
{
__int64 v7; // [rsp+20h] [rbp-10h]
v7 = 0LL;
if ( *(_QWORD *)(a1 + 280) )
v7 = *(_QWORD *)(*(_QWORD *)(a1 + 280) + 32LL);
return sub_4B2C7F(v7, a2, a3, a4, a5, a6);
}
Q:[a3,a4,a1,a2,v7,sub_4B3D0C,sub_4B2C7F,] | A:{'a3': 'size', 'a4': 'width', 'a1': 'he', 'a2': 'bf', 'v7': 'map', 'sub_4B3D0C': 'hist_entry__dso_daddr_snprintf', 'sub_4B2C7F': '_hist_entry__dso_snprintf'} | |
8cae1a4a33735ef95c4c8b1612d43b76781ee98149adfbb3f86481ae23018b4c_8cae1a4a33735ef95c4c8b1612d43b76781ee98149adfbb3f86481ae23018b4c.jsonl.gz | sub_48E45A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_48E45A(__int64 a1, unsigned __int64 a2, __int64 a3, unsigned __int64 a4)
{
__int16 v4; // ax
unsigned __int64 i; // [rsp+20h] [rbp-10h]
unsigned __int64 j; // [rsp+20h] [rbp-10h]
unsigned __int64 k; // [rsp+20h] [rbp-10h]
unsigned __int16 v9; // [rsp+2Eh] [rbp-2h]
v9 = 0;
for ( i = 0LL; i < a4; ++i )
*(_WORD *)(a3 + 2 * i) = 256;
for ( j = 0LL; j < a2; ++j )
{
if ( a4 <= *(unsigned __int8 *)(a1 + j) )
__assert_fail("block_ids[i] < num_histograms", "c/enc/./block_splitter_inc.h", 0xA4u, "RemapBlockIdsDistance");
if ( *(_WORD *)(2LL * *(unsigned __int8 *)(a1 + j) + a3) == 256 )
{
v4 = v9++;
*(_WORD *)(2LL * *(unsigned __int8 *)(a1 + j) + a3) = v4;
}
}
for ( k = 0LL; k < a2; ++k )
{
*(_BYTE *)(a1 + k) = *(_WORD *)(2LL * *(unsigned __int8 *)(a1 + k) + a3);
if ( a4 <= *(unsigned __int8 *)(a1 + k) )
__assert_fail("block_ids[i] < num_histograms", "c/enc/./block_splitter_inc.h", 0xABu, "RemapBlockIdsDistance");
}
if ( a4 < v9 )
__assert_fail("next_id <= num_histograms", "c/enc/./block_splitter_inc.h", 0xADu, "RemapBlockIdsDistance");
return v9;
}
Q:[a3,a4,a1,a2,j,v9,sub_48E45A,] | A:{'a3': 'new_id', 'a4': 'num_histograms', 'a1': 'block_ids', 'a2': 'length', 'j': 'ib', 'v9': 'next_id', 'sub_48E45A': 'RemapBlockIdsDistance'} | |
43d196ad5ba82394e288a8b3f0cf9f679ec45e2ccdee873903ccd9e7d2d70a50_43d196ad5ba82394e288a8b3f0cf9f679ec45e2ccdee873903ccd9e7d2d70a50.jsonl.gz | sub_401C4D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_401C4D(__int64 a1, const char *a2)
{
const char **v3; // [rsp+18h] [rbp-8h]
v3 = sub_401AF7(a1, a2);
if ( v3 )
return (unsigned int)sub_4014B6(qword_406230, *(_WORD *)(a1 + 12), *((_DWORD *)v3 + 4));
fprintf(stderr, "invalid value '%s'\n", a2);
return 2LL;
}
Q:[a1,a2,v3,sub_401C4D,sub_401AF7,sub_4014B6,] | A:{'a1': 'env', 'a2': 'data', 'v3': 'v', 'sub_401C4D': 'rbcfg_env_set_u32', 'sub_401AF7': 'rbcfg_env_find', 'sub_4014B6': 'rbcfg_set_u32'} | |
477af4d40069544556e623d88d3014d4e0d738c019c3c162fcda139de2d22397_477af4d40069544556e623d88d3014d4e0d738c019c3c162fcda139de2d22397.jsonl.gz | sub_40D686 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40D686(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
__int64 v6; // [rsp+8h] [rbp-28h] BYREF
__int64 v7; // [rsp+10h] [rbp-20h]
__int64 v8; // [rsp+18h] [rbp-18h]
v8 = a1;
v7 = a2;
v6 = a3;
sub_40F7F1(&v6);
return sub_40F7FC(v8, v7, v6, a4);
}
Q:[a3,a4,a1,a2,v6,v7,v8,sub_40D686,sub_40F7F1,sub_40F7FC,] | A:{'a3': '__first', 'a4': '__last', 'a1': 'this', 'a2': '__pos', 'v6': '__firsta', 'v7': '__posa', 'v8': 'thisa', 'sub_40D686': 'allocator', 'sub_40F7F1': 'allocator', 'sub_40F7FC': 'allocator'} | |
fb04827bf9a551f5f69186e53039bed933d463cd8e2d00e60728cc981426dd66_fb04827bf9a551f5f69186e53039bed933d463cd8e2d00e60728cc981426dd66.jsonl.gz | sub_488764 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_488764(__int64 *a1, __int64 a2)
{
__int64 v2; // rbx
__int64 v3; // rax
v2 = *a1;
v3 = sub_4860F6(a2);
return sub_489E4A(v2, v3);
}
Q:[sub_488764,sub_4860F6,sub_489E4A,] | A:{'sub_488764': 'operator', 'sub_4860F6': 'forward', 'sub_489E4A': '_M_create_node'} | |
a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4_a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4.jsonl.gz | sub_47C47A | Help user generate meaningful names for variables and functions in the following code snippet. |
char __fastcall sub_47C47A(__int64 a1, __int64 a2, __int64 a3)
{
_QWORD *v3; // rbx
_QWORD *v4; // rax
__int64 v6; // [rsp+8h] [rbp-28h] BYREF
__int64 v7[3]; // [rsp+10h] [rbp-20h] BYREF
v7[1] = a1;
v7[0] = a2;
v6 = a3;
v3 = (_QWORD *)sub_47C6F2(&v6);
v4 = (_QWORD *)sub_47C6F2(v7);
return sub_43CE60(v4, v3);
}
Q:[sub_47C47A,sub_47C6F2,sub_43CE60,] | A:{'sub_47C47A': 'allocator', 'sub_47C6F2': 'operator*', 'sub_43CE60': 'operator<'} | |
477af4d40069544556e623d88d3014d4e0d738c019c3c162fcda139de2d22397_477af4d40069544556e623d88d3014d4e0d738c019c3c162fcda139de2d22397.jsonl.gz | sub_40A37E | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_40A37E()
{
;
}
Q:[sub_40A37E,] | A:{'sub_40A37E': 'delete'} | |
cc63c597b85a866af50daa8815d6c7b811056a995e56ca676a7f4154e667a7eb_cc63c597b85a866af50daa8815d6c7b811056a995e56ca676a7f4154e667a7eb.jsonl.gz | sub_404E75 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_404E75(unsigned int a1, unsigned int a2)
{
unsigned __int64 v3; // [rsp+10h] [rbp-28h]
unsigned int v4; // [rsp+2Ch] [rbp-Ch]
unsigned int v5; // [rsp+30h] [rbp-8h]
int v6; // [rsp+34h] [rbp-4h]
v4 = (a2 ^ a1) & 0x80000000;
v3 = (a1 & 0x7FFFFF | 0x800000) * (unsigned __int64)(a2 & 0x7FFFFF | 0x800000);
v6 = (unsigned __int8)(a1 >> 23) + (unsigned __int8)(a2 >> 23) - 127;
if ( (v3 & 0x800000000000LL) != 0 )
{
++v6;
v5 = ((v3 >> 23) + 1) & 0xFFFFFF;
}
else
{
v5 = ((v3 >> 22) + 1) & 0xFFFFFF;
}
if ( !(unsigned __int8)(a1 >> 23) || !(unsigned __int8)(a2 >> 23) )
return 0LL;
if ( (v6 & 0x100) == 0 )
return v4 | (v6 << 23) & 0x7F800000 | (v5 >> 1);
if ( (v6 & 0x80) != 0 )
return 0LL;
return v4 | (v5 >> 1) | 0x7F800000;
}
Q:[a1,a2,v3,v4,v5,v6,sub_404E75,] | A:{'a1': 'x', 'a2': 'y', 'v3': 'm', 'v4': 'sign', 'v5': 'z0', 'v6': 'e1', 'sub_404E75': 'fp_mul'} | |
8d851b5a13ca80e91047f14e94ae78b57d21e192448affca455dae8a3036ee6d_8d851b5a13ca80e91047f14e94ae78b57d21e192448affca455dae8a3036ee6d.jsonl.gz | sub_40BC9D | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_40BC9D(unsigned __int8 *a1, unsigned int a2)
{
__int64 v2; // r15
__int64 v3; // r14
__int64 v4; // r13
__int64 v5; // r12
unsigned int v6; // ebx
unsigned __int8 v7; // al
unsigned int v8; // er13
const char *v9; // r12
unsigned int v10; // ebx
float v11; // xmm0_4
const char *v12; // rsi
unsigned int v13; // ebx
const char *v14; // rax
int result; // eax
unsigned int v16; // [rsp+8h] [rbp-58h]
unsigned int v17; // [rsp+Ch] [rbp-54h]
unsigned int v18; // [rsp+Ch] [rbp-54h]
unsigned int v19; // [rsp+10h] [rbp-50h]
int i; // [rsp+2Ch] [rbp-34h]
v19 = a1[11] & 0xF;
v2 = (a1[12] >> 3) & 7;
v3 = (unsigned __int8)sub_40BBF1(a1[6]);
v4 = (unsigned __int8)sub_40BBF1(a1[5]);
v5 = (unsigned __int8)sub_40BBF1(a1[4]);
v17 = (unsigned __int8)sub_40BBF1(a1[3]);
v16 = (unsigned __int8)sub_40BBF1(a1[2]);
v6 = (unsigned __int8)sub_40BBF1(a1[1]);
v7 = sub_40BBF1(*a1);
printf("Voice %d, %c%c%c%c%c%c%c algorithm: %d op_mask=%x\n", a2, v7, v6, v16, v17, v5, v4, v3, v2, v19);
v8 = (a1[13] >> 3) & 3;
v9 = (const char *)sub_40B0A4((a1[13] >> 3) & 3);
v10 = a1[10] & 1;
v11 = sub_40BC19(a1[8], 4000000);
if ( (a1[9] & 1) != 0 )
v12 = "ENABLED";
else
v12 = "DISABLED";
printf(" LFO: %s speed: %d (%.02fHz) sync: %d waveform: %s (%d)\n", v12, a1[8], v11, v10, v9, v8);
printf(
" am_depth: %d am_sens: %d pm_depth: %d pm_sens: %d\n",
a1[9] >> 1,
(a1[13] >> 1) & 3,
a1[10] >> 1,
(*((_WORD *)a1 + 6) >> 6) & 7);
printf(" l_enable: %d r_enable: %d fb_level: %d\n", (a1[11] & 0x10) != 0, (a1[11] & 0x20) != 0, a1[12] & 7);
v13 = a1[49] & 7;
v14 = sub_40B05A(v13);
printf(" mono: %d transpose: %d pmd_controller: %s (%d)\n", a1[48] & 1, (unsigned int)(char)a1[14], v14, v13);
printf(" pitch_bend_range: %d portamento_speed: %d\n", (a1[49] >> 3) & 0xF, a1[48] >> 1);
puts(" Attack -Decay- --TL--- Key sns ");
result = puts(" OP AR VS D1R D2R RR SL TL S A T LD RD DT F C IF");
for ( i = 0; i <= 3; ++i )
{
v18 = (*(_DWORD *)&a1[8 * i + 20] >> 15) & 0x1F;
result = printf(
" %d% 3d% 4d% 4d% 4d% 4d% 3d% 4d% 2d% 3d% 2d% 3d% 3d% 3d% 3d% 2d% 3d\n",
(unsigned int)i,
a1[8 * i + 20] & 0x1F,
a1[8 * i + 20] >> 6,
a1[8 * i + 21] & 0x1F,
v18,
a1[8 * i + 23] & 0xF,
a1[8 * i + 22] >> 4,
a1[8 * i + 16],
(a1[8 * i + 17] >> 2) & 7,
(a1[8 * i + 18] >> 1) & 0xF,
a1[8 * i + 17] & 3,
(*(_DWORD *)&a1[8 * i + 16] >> 13) & 0xF,
(a1[8 * i + 19] >> 4) & 3,
a1[8 * i + 18] >> 5,
a1[8 * i + 19] & 0xF,
(a1[8 * i + 20] & 0x20) != 0,
(a1[8 * i + 21] >> 5) & 3);
}
return result;
}
Q:[a1,a2,sub_40BC9D,sub_40BBF1,sub_40B0A4,sub_40BC19,sub_40B05A,] | A:{'a1': 'voice', 'a2': 'voicenum', 'sub_40BC9D': 'fb01_bulk_voice_dump', 'sub_40BBF1': 'safechar_0', 'sub_40B0A4': 'fb01_lfo_waveform_name', 'sub_40BC19': 'lfo_speed_to_hz_0', 'sub_40B05A': 'fb01_input_controller_name'} | |
352fdfcb7ad00bcfe1eb90e77706ee9f5d528da6873a13d133796fdd79f5b633_352fdfcb7ad00bcfe1eb90e77706ee9f5d528da6873a13d133796fdd79f5b633.jsonl.gz | sub_40800C | Help user generate meaningful names for variables and functions in the following code snippet. |
_WORD *__fastcall sub_40800C(__int64 a1, const char *a2)
{
_WORD *result; // rax
*(_QWORD *)(a1 + 64) = sub_4035B9(a2);
result = *(_WORD **)(a1 + 64);
*result = 33;
return result;
}
Q:[a1,a2,sub_40800C,sub_4035B9,] | A:{'a1': 'G', 'a2': 'yytext', 'sub_40800C': 'yy_1_Ellipsis', 'sub_4035B9': 'mk_pos_str'} | |
819877a5309a852874e6ff60e55ac0b31c9d82ad9eca5ccd226cbb9e62c77eb8_819877a5309a852874e6ff60e55ac0b31c9d82ad9eca5ccd226cbb9e62c77eb8.jsonl.gz | sub_40D052 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40D052(__int64 a1, int a2, __int64 a3)
{
__int64 result; // rax
size_t v4; // rbx
char dest[8]; // [rsp+20h] [rbp-1030h] BYREF
__int64 v7; // [rsp+28h] [rbp-1028h]
char v8[4080]; // [rsp+30h] [rbp-1020h] BYREF
int v9; // [rsp+1028h] [rbp-28h]
__int64 v11; // [rsp+1030h] [rbp-20h]
int i; // [rsp+103Ch] [rbp-14h]
*(_QWORD *)dest = 0LL;
v7 = 0LL;
memset(v8, 0, sizeof(v8));
if ( a2 <= 1 )
return sub_4035C3(a1, "wrong # args: should be \"%s\"", "lappend varName ?value value ...?");
v11 = sub_4036B7(a1, *(char **)(a3 + 8), 0);
if ( v11 )
strncpy(dest, *(const char **)(v11 + 16), 0x1000uLL);
for ( i = 2; i < a2; ++i )
{
v9 = sub_411738(*(_QWORD *)(8LL * i + a3));
if ( dest[0] )
{
if ( strlen(dest) + 1 > 0xFFF )
return sub_403164(a1, "string too long");
*(_WORD *)&dest[strlen(dest)] = 32;
}
if ( v9 )
{
if ( strlen(dest) + 1 > 0xFFF )
return sub_403164(a1, "string too long");
*(_WORD *)&dest[strlen(dest)] = 123;
}
v4 = strlen(dest);
if ( v4 + strlen(*(const char **)(8LL * i + a3)) > 0xFFF )
return sub_403164(a1, "string too long");
strcat(dest, *(const char **)(8LL * i + a3));
if ( v9 )
{
if ( strlen(dest) + 1 > 0xFFF )
return sub_403164(a1, "string too long");
*(_WORD *)&dest[strlen(dest)] = 125;
}
}
if ( (unsigned int)sub_403A3F(a1, *(char **)(a3 + 8), dest, 0) )
result = 0LL;
else
result = sub_4030E1(a1, dest);
return result;
}
Q:[a3,a1,a2,dest,v9,v11,i,sub_40D052,sub_4035C3,sub_4036B7,sub_411738,sub_403164,sub_403A3F,sub_4030E1,] | A:{'a3': 'argv', 'a1': 'interp', 'a2': 'argc', 'dest': 'buf', 'v9': 'needbraces', 'v11': 'v', 'i': 'a', 'sub_40D052': 'picol_lappend', 'sub_4035C3': 'picolErrFmt', 'sub_4036B7': 'picolGetVar2', 'sub_411738': 'picolNeedsBraces', 'sub_403164': 'picolErr', 'sub_403A3F': 'picolSetVar2', 'sub_4030E1': 'picolSetResult'} | |
9d09d641ebec77cedf86af6a95ac9983d95d10ddc175a08670a9fd4eeedd6d07_9d09d641ebec77cedf86af6a95ac9983d95d10ddc175a08670a9fd4eeedd6d07.jsonl.gz | sub_406B35 | Help user generate meaningful names for variables and functions in the following code snippet. |
int sub_406B35()
{
int result; // eax
pthread_t newthread; // [rsp+8h] [rbp-8h] BYREF
result = (unsigned __int8)byte_40B1A8;
if ( !byte_40B1A8 )
{
pthread_create(&newthread, 0LL, (void *(*)(void *))start_routine, 0LL);
result = pthread_detach(newthread);
byte_40B1A8 = 1;
}
return result;
}
Q:[newthread,sub_406B35,] | A:{'newthread': 'tid', 'sub_406B35': 'rt_tick_init'} | |
5fe4ddfde34348a56b5727f0a076887b8eb98346be656bf1acfacd7653a0a8ee_5fe4ddfde34348a56b5727f0a076887b8eb98346be656bf1acfacd7653a0a8ee.jsonl.gz | sub_4615E0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4615E0(__int64 a1)
{
_QWORD **v1; // rsi
__int64 (__fastcall *v2)(__int64, __int64); // rax
__int64 v3; // rax
void *v5; // [rsp+8h] [rbp-1F0h] BYREF
__m128i v6; // [rsp+10h] [rbp-1E8h] BYREF
char v7; // [rsp+20h] [rbp-1D8h] BYREF
char v8[8]; // [rsp+30h] [rbp-1C8h] BYREF
const char *v9; // [rsp+38h] [rbp-1C0h]
int v10; // [rsp+40h] [rbp-1B8h]
__int64 v11[2]; // [rsp+48h] [rbp-1B0h]
void *v12; // [rsp+58h] [rbp-1A0h] BYREF
void *v13; // [rsp+60h] [rbp-198h]
__int64 v14; // [rsp+68h] [rbp-190h]
__int64 v15; // [rsp+70h] [rbp-188h]
__int64 v16; // [rsp+78h] [rbp-180h]
__int64 v17; // [rsp+80h] [rbp-178h]
__int64 v18; // [rsp+88h] [rbp-170h]
__int64 v19; // [rsp+90h] [rbp-168h]
char v20[8]; // [rsp+98h] [rbp-160h] BYREF
int v21; // [rsp+A0h] [rbp-158h]
char *v22; // [rsp+A8h] [rbp-150h]
__int64 v23; // [rsp+B0h] [rbp-148h]
char v24; // [rsp+B8h] [rbp-140h] BYREF
__int64 v25[28]; // [rsp+C8h] [rbp-130h] BYREF
__int16 v26; // [rsp+1A8h] [rbp-50h]
__int64 v27; // [rsp+1B0h] [rbp-48h]
__int64 v28; // [rsp+1B8h] [rbp-40h]
__int64 v29; // [rsp+1C0h] [rbp-38h]
__int64 v30; // [rsp+1C8h] [rbp-30h]
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v1 = (_QWORD **)sub_45F340();
v2 = (__int64 (__fastcall *)(__int64, __int64))(*v1)[17];
if ( v2 == sub_42DD80
&& (v1 = (_QWORD **)v1[1], v2 = (__int64 (__fastcall *)(__int64, __int64))(*v1)[17], v2 == sub_42DD80)
&& (v1 = (_QWORD **)v1[1], v2 = (__int64 (__fastcall *)(__int64, __int64))(*v1)[17], v2 == sub_42DD80)
&& (v1 = (_QWORD **)v1[1], v2 = (__int64 (__fastcall *)(__int64, __int64))(*v1)[17], v2 == sub_42DD80) )
{
(*(void (__fastcall **)(void **, _QWORD *, __int64))(*v1[1] + 136LL))(&v5, v1[1], a1);
}
else
{
((void (__fastcall *)(void **, _QWORD **, __int64))v2)(&v5, v1, a1);
}
v8[0] = 1;
v9 = "util/testharness.cc";
v10 = 63;
std::ios_base::ios_base((std::ios_base *)v25);
v26 = 0;
v3 = *(_QWORD *)(qword_47CB50 - 24);
v25[0] = (__int64)&unk_47CB30;
v25[27] = 0LL;
v27 = 0LL;
v28 = 0LL;
v29 = 0LL;
v30 = 0LL;
v11[0] = qword_47CB50;
*(__int64 *)((char *)v11 + v3) = qword_47CB58;
v11[1] = 0LL;
std::ios::init();
v12 = (void *)qword_47CB60;
*(void **)((char *)&v12 + *(_QWORD *)(qword_47CB60 - 24)) = (void *)qword_47CB68;
std::ios::init();
*(__int64 *)((char *)v11 + *(_QWORD *)(qword_47CB48 - 24)) = qword_47CB70;
v11[0] = (__int64)&unk_47CC88;
v25[0] = (__int64)&unk_47CCD8;
v12 = &unk_47CCB0;
v13 = &unk_47CBA0;
v14 = 0LL;
v15 = 0LL;
v16 = 0LL;
v17 = 0LL;
v18 = 0LL;
v19 = 0LL;
std::locale::locale((std::locale *)v20);
v13 = &unk_47CD50;
v21 = 24;
v22 = &v24;
v23 = 0LL;
v24 = 0;
std::ios::init();
if ( v5 )
{
std::__ostream_insert<char,std::char_traits<char>>();
std::__ostream_insert<char,std::char_traits<char>>();
v8[0] = 0;
}
sub_460E20(&v6, (unsigned int **)&v5);
if ( !v8[0] )
{
std::__ostream_insert<char,std::char_traits<char>>();
std::__ostream_insert<char,std::char_traits<char>>();
}
if ( (char *)v6.m128i_i64[0] != &v7 )
operator delete((void *)v6.m128i_i64[0]);
sub_42EB00((__int64)v8);
if ( v5 )
operator delete[](v5);
return a1;
}
Q:[sub_4615E0,sub_45F340,sub_42DD80,sub_460E20,sub_42EB00,] | A:{'sub_4615E0': 'TmpDir', 'sub_45F340': 'Default', 'sub_42DD80': 'GetTestDirectory', 'sub_460E20': 'ToString', 'sub_42EB00': '~Tester'} | |
a068192c5ba45754496e7c81fb0909b44bb45d4184f690fb3ecab6434f2e309b_a068192c5ba45754496e7c81fb0909b44bb45d4184f690fb3ecab6434f2e309b.jsonl.gz | sub_4084BD | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4084BD(int a1, const void *a2, int a3, __int64 a4, __int64 a5, __int64 a6)
{
int v6; // eax
char v7; // al
char *endptr; // [rsp+10h] [rbp-20h] BYREF
int base; // [rsp+1Ch] [rbp-14h]
void *dest; // [rsp+20h] [rbp-10h]
char *nptr; // [rsp+28h] [rbp-8h]
if ( dword_413038 == 128 )
sub_4038E5("fmt_add", 0x22u, "Too many formatters & strings (KC_FMT_MAX_SIZE=%i)", 128LL, a5, a6);
*((_DWORD *)&unk_412438 + 6 * dword_413038) = a1;
if ( a3 )
{
dest = malloc(a3 + 1);
*(&qword_412440 + 3 * dword_413038) = dest;
memcpy(dest, a2, a3);
*((_BYTE *)dest + a3) = 0;
nptr = (char *)dest;
while ( 1 )
{
if ( !*nptr )
{
*(_BYTE *)dest = 0;
dword_412448[6 * dword_413038] = strlen((const char *)*(&qword_412440 + 3 * dword_413038));
return (unsigned int)++dword_413038;
}
if ( *nptr == 92 && nptr[1] )
{
base = 0;
v6 = *++nptr;
if ( v6 == 120 )
{
++nptr;
base = 16;
}
else if ( v6 <= 120 )
{
if ( v6 == 116 )
{
*(_BYTE *)dest = 9;
goto LABEL_25;
}
if ( v6 <= 116 )
{
if ( v6 == 110 )
{
*(_BYTE *)dest = 10;
goto LABEL_25;
}
if ( v6 == 114 )
{
*(_BYTE *)dest = 13;
goto LABEL_25;
}
}
}
if ( *nptr <= 47 || *nptr > 57 )
{
*(_BYTE *)dest = *nptr;
}
else
{
v7 = strtoul(nptr, &endptr, base);
*(_BYTE *)dest = v7;
if ( nptr < endptr )
nptr = endptr - 1;
}
}
else
{
*(_BYTE *)dest = *nptr;
}
LABEL_25:
++nptr;
dest = (char *)dest + 1;
}
}
return (unsigned int)++dword_413038;
}
Q:[a3,a1,a2,endptr,dest,nptr,sub_4084BD,sub_4038E5,] | A:{'a3': 'len', 'a1': 'type', 'a2': 'str', 'endptr': 'next', 'dest': 'd', 'nptr': 's', 'sub_4084BD': 'fmt_add', 'sub_4038E5': 'fatal0'} | |
a0889d5ca286b9efd7fc39704eced11d6b133d376f698994f2223f6402722316_a0889d5ca286b9efd7fc39704eced11d6b133d376f698994f2223f6402722316.jsonl.gz | sub_40206B | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40206B(unsigned int a1)
{
return 1566083941 * (a1 ^ (a1 >> 27));
}
Q:[a1,sub_40206B,] | A:{'a1': 'x', 'sub_40206B': 'ini_func2'} | |
d96bae3770c907e4bb624cafcf4e92654843bbb3ba74942be7a2a6f7999a0046_d96bae3770c907e4bb624cafcf4e92654843bbb3ba74942be7a2a6f7999a0046.jsonl.gz | sub_401C85 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_401C85(__int64 a1)
{
__int64 result; // rax
if ( qword_4040D0 && qword_4040D8 )
{
*(_QWORD *)(qword_4040D8 + 32) = a1;
*(_QWORD *)(a1 + 24) = qword_4040D8;
*(_QWORD *)(a1 + 32) = 0LL;
result = a1;
qword_4040D8 = a1;
}
else
{
qword_4040D8 = a1;
qword_4040D0 = a1;
*(_QWORD *)(a1 + 24) = 0LL;
result = a1;
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a1 + 24);
}
return result;
}
Q:[a1,sub_401C85,] | A:{'a1': 'h', 'sub_401C85': 'add_hid'} | |
867b3f12dd6bc0f5d65f833e0aac6c437c6682ccfe80bbc748ae054ccf229091_867b3f12dd6bc0f5d65f833e0aac6c437c6682ccfe80bbc748ae054ccf229091.jsonl.gz | sub_415C90 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_415C90(__int64 a1)
{
__int64 result; // rax
memset((void *)(a1 + 20), 255, 0x21AC2uLL);
*(_QWORD *)a1 = 0LL;
result = 0xF00000000LL;
*(_QWORD *)(a1 + 137942) = 0LL;
*(_QWORD *)(a1 + 8) = 0xF00000000LL;
*(_DWORD *)(a1 + 16) = 15;
return result;
}
Q:[a1,sub_415C90,] | A:{'a1': 'this', 'sub_415C90': 'Microdrive'} | |
283ed54b1f66acccce94b9477f53c760e922840320b559e1a065b55929915f6d_283ed54b1f66acccce94b9477f53c760e922840320b559e1a065b55929915f6d.jsonl.gz | sub_40D379 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40D379(_QWORD *a1, __int64 a2)
{
__int64 result; // rax
sub_40D3B6(*a1, a1[1] - *a1, a2);
result = a1[1];
*a1 = result;
return result;
}
Q:[sub_40D379,sub_40D3B6,] | A:{'sub_40D379': 'fastcopy', 'sub_40D3B6': 'awrite'} | |
7e9197c1975ab9f6a09f18f03b3ec95749d31c9b830ebd6a4cd0b7c1e6d58838_7e9197c1975ab9f6a09f18f03b3ec95749d31c9b830ebd6a4cd0b7c1e6d58838.jsonl.gz | sub_407B10 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_407B10(int fildes, struct stat64 *stat_buf)
{
return __fxstat64(1, fildes, stat_buf);
}
Q:[sub_407B10,] | A:{'sub_407B10': 'fstat64'} | |
a4fa3fc9103c24be86b146316cf7ed9fb93db067af0251e503388696c8da6e2f_a4fa3fc9103c24be86b146316cf7ed9fb93db067af0251e503388696c8da6e2f.jsonl.gz | sub_40E9C0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40E9C0(__int64 a1, __int64 a2, int a3, __int64 a4, int a5, int a6)
{
__int64 result; // rax
__int64 i; // [rsp+20h] [rbp-18h]
char v10; // [rsp+2Fh] [rbp-9h]
v10 = 0;
result = *(_QWORD *)(a2 + 112);
for ( i = result; i; i = *(_QWORD *)i )
{
if ( a3 == *(_DWORD *)(i + 8) )
{
if ( v10 != 1 )
{
sub_415F0F(a1, a4);
v10 = 1;
}
else
{
sub_415FB1(a1, (unsigned int)" && ", a3, a4, a5, a6);
}
sub_40A254(*(unsigned int **)(i + 40), a1);
}
result = *(_QWORD *)i;
}
if ( v10 )
result = sub_415F0F(a1, "\n");
return result;
}
Q:[a3,a4,a1,a2,i,v10,sub_40E9C0,sub_415F0F,sub_415FB1,sub_40A254,] | A:{'a3': 'tok', 'a4': 'prefix', 'a1': 'r', 'a2': 'sym', 'i': 'prop', 'v10': 'hit', 'sub_40E9C0': 'get_symbol_props_str', 'sub_415F0F': 'str_append', 'sub_415FB1': 'str_printf', 'sub_40A254': 'expr_gstr_print'} | |
45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0_45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0.jsonl.gz | sub_416E36 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_416E36(_QWORD *a1)
{
return (__int64)(a1[1] - *a1) >> 1;
}
Q:[a1,sub_416E36,] | A:{'a1': 'this', 'sub_416E36': 'size'} | |
a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4_a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4.jsonl.gz | sub_46A2B2 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_46A2B2(__int64 a1, __int64 a2)
{
__int64 v2; // rbx
v2 = *(_QWORD *)sub_45BA20(a1);
return 0xCCCCCCCCCCCCCCCDLL * ((v2 - *(_QWORD *)sub_45BA20(a2)) >> 3);
}
Q:[sub_46A2B2,sub_45BA20,] | A:{'sub_46A2B2': 'allocator', 'sub_45BA20': 'base'} | |
c3985d12d25d477cd67d5428d926a1f57621bcb89b3d9651025cf803ff03987c_c3985d12d25d477cd67d5428d926a1f57621bcb89b3d9651025cf803ff03987c.jsonl.gz | sub_401316 | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_401316()
{
;
}
Q:[sub_401316,] | A:{'sub_401316': 'int_vector_lifecycle_destroy'} | |
adf8f3f32558035a43de6a2794e05c617fd356387dc6999991cbc942fd311076_adf8f3f32558035a43de6a2794e05c617fd356387dc6999991cbc942fd311076.jsonl.gz | sub_417AE6 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_417AE6(_WORD *a1, unsigned int a2, unsigned int a3, char a4)
{
__int64 result; // rax
unsigned __int16 v7; // [rsp+2Eh] [rbp-2h]
v7 = sub_41783C(a2);
sub_405762(a1, a3);
if ( a4 )
result = sub_408581(a1, v7);
else
result = sub_40861E(a1, v7);
return result;
}
Q:[a3,a4,a1,a2,v7,sub_417AE6,sub_41783C,sub_405762,sub_408581,sub_40861E,] | A:{'a3': 'new_opcode', 'a4': 'is_range', 'a1': 'insns', 'a2': 'dex_pc', 'v7': 'index', 'sub_417AE6': 'DecompileInvokeVirtual', 'sub_41783C': 'GetIndexAt', 'sub_405762': 'dexInstr_SetOpcode', 'sub_408581': 'dexInstr_SetVRegB_3rc', 'sub_40861E': 'dexInstr_SetVRegB_35c'} | |
89f8c4b131cafb0b3fbe7014dad033943f8a241645b7b4dd035958321181f060_89f8c4b131cafb0b3fbe7014dad033943f8a241645b7b4dd035958321181f060.jsonl.gz | sub_401272 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_401272(const char *a1)
{
puts("sunxi-nand-part 6a2f6b5\n");
printf("usage: %s [-f a10|a20] nand-device\n", a1);
printf(" %s nand-device 'name2 len2 [usertype2]' ['name3 len3 [usertype3]'] ...\n", a1);
return printf(
" %s [-f a10|a20] nand-device start1 'name1 len1 [usertype1]' ['name2 len2 [usertype2]'] ...\n",
a1);
}
Q:[a1,sub_401272,] | A:{'a1': 'cmd', 'sub_401272': 'usage'} | |
251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651_251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651.jsonl.gz | sub_429AB8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_429AB8(__int64 a1)
{
__int64 v1; // rax
v1 = sub_429AAA(a1);
return sub_4132CE(v1);
}
Q:[sub_429AB8,sub_429AAA,sub_4132CE,] | A:{'sub_429AB8': 'lambda', 'sub_429AAA': 'lambda', 'sub_4132CE': 'operator'} | |
fa27d0bacf06ce93b14fd9cba32c0c5a7d20e024d2a5f59104dc1d7405bb9602_fa27d0bacf06ce93b14fd9cba32c0c5a7d20e024d2a5f59104dc1d7405bb9602.jsonl.gz | sub_43176D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43176D(const char *a1, __int64 a2, int a3)
{
unsigned int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; (int)i < a3; ++i )
{
if ( !strcmp(a1, *(const char **)(8LL * (int)i + a2)) )
return i;
}
return 0xFFFFFFFFLL;
}
Q:[a3,a1,a2,sub_43176D,] | A:{'a3': 'arr_size', 'a1': 'pattern', 'a2': 'arr', 'sub_43176D': 'strInArray'} | |
6e038a76c89f52341669b20c809c950c0a24bdf0e467b056f29332c2d4d25be5_6e038a76c89f52341669b20c809c950c0a24bdf0e467b056f29332c2d4d25be5.jsonl.gz | sub_401ABC | Help user generate meaningful names for variables and functions in the following code snippet. |
void *__fastcall sub_401ABC(int a1, __int64 a2)
{
char *s; // [rsp+18h] [rbp-28h]
__int64 size; // [rsp+20h] [rbp-20h]
const char *v5; // [rsp+28h] [rbp-18h]
const char *v6; // [rsp+30h] [rbp-10h]
v6 = *(const char **)(a2 + 8);
v5 = *(const char **)(a2 + 24);
if ( a1 <= 3 )
return 0LL;
size = snprintf(0LL, 0LL, "{\"context\":{\"child_ids\":[\"%s\"]},\"emeter\":{\"get_realtime\":{}}}", v5) + 1LL;
s = (char *)calloc(1uLL, size);
snprintf(s, size, "{\"context\":{\"child_ids\":[\"%s\"]},\"emeter\":{\"get_realtime\":{}}}", v5);
return sub_401531(v6, s);
}
Q:[a1,a2,s,size,v5,v6,sub_401ABC,sub_401531,] | A:{'a1': 'argc', 'a2': 'argv', 's': 'msg', 'size': 'len', 'v5': 'plug', 'v6': 'plug_addr', 'sub_401ABC': 'handler_get_realtime', 'sub_401531': 'hs100_send'} | |
34e1f47d7c3f4a6a8540956845e947b127c61352252002721d774608d8656d0e_34e1f47d7c3f4a6a8540956845e947b127c61352252002721d774608d8656d0e.jsonl.gz | sub_448AEF | Help user generate meaningful names for variables and functions in the following code snippet. |
const char *__fastcall sub_448AEF(const char *a1)
{
int *i; // [rsp+18h] [rbp-8h]
for ( i = (int *)&unk_4584C0; *i; i += 6 )
{
if ( !strncmp(*((const char **)i + 1), a1, *i) )
return (const char *)*((_QWORD *)i + 2);
}
return a1;
}
Q:[a1,i,sub_448AEF,] | A:{'a1': 'model', 'i': 'cnp', 'sub_448AEF': 'xilinx_class'} | |
3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353_3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353.jsonl.gz | sub_483EF7 | Help user generate meaningful names for variables and functions in the following code snippet. |
double __fastcall sub_483EF7(double a1)
{
return fabs(a1);
}
Q:[a1,sub_483EF7,] | A:{'a1': 'x', 'sub_483EF7': 'ImAbs'} | |
bfa1835a8cfa41c6110f4663d2d821bce11bf6fbfb1ac54ccfda804c176264e2_bfa1835a8cfa41c6110f4663d2d821bce11bf6fbfb1ac54ccfda804c176264e2.jsonl.gz | sub_4119FD | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4119FD(_QWORD *a1)
{
__int64 v1; // rax
__int64 result; // rax
__int64 v3; // [rsp+18h] [rbp-18h]
__int64 v4; // [rsp+20h] [rbp-10h]
__int64 i; // [rsp+28h] [rbp-8h]
__int64 j; // [rsp+28h] [rbp-8h]
if ( a1[28] )
v1 = *(_QWORD *)(a1[28] + 32LL);
else
v1 = 0LL;
v4 = v1;
v3 = *(_QWORD *)(a1[29] + 32LL);
if ( a1[28] )
sub_410817(a1[36], a1[35], (_QWORD *)a1[28]);
if ( v3 > 0 )
sub_410817(a1[37], a1[35], (_QWORD *)a1[29]);
for ( i = 0LL; i < v4; ++i )
*(double *)(a1[31] + 8 * i) = *(double *)(a1[36] + 8 * i) * *(double *)(a1[31] + 8 * i);
for ( j = 0LL; ; ++j )
{
result = j;
if ( j >= v3 )
break;
*(double *)(a1[32] + 8 * j) = *(double *)(a1[37] + 8 * j) * *(double *)(a1[32] + 8 * j);
}
return result;
}
Q:[a1,v3,v4,j,sub_4119FD,sub_410817,] | A:{'a1': 'w', 'v3': 'num_G_rows', 'v4': 'num_A_rows', 'j': 'ia', 'sub_4119FD': 'unset_equilibration', 'sub_410817': 'restore'} | |
f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83_f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83.jsonl.gz | sub_4A294E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4A294E(_BYTE *a1, __int64 a2, void *a3, __int64 a4, __int64 a5)
{
size_t v8; // [rsp+20h] [rbp-40h]
unsigned __int8 *src; // [rsp+28h] [rbp-38h]
int v10[2]; // [rsp+30h] [rbp-30h] BYREF
int v11; // [rsp+38h] [rbp-28h]
__int64 v12; // [rsp+40h] [rbp-20h]
void *ptr; // [rsp+48h] [rbp-18h]
__int64 v14; // [rsp+50h] [rbp-10h]
int v15; // [rsp+58h] [rbp-8h]
int i; // [rsp+5Ch] [rbp-4h]
v8 = a2;
v14 = a5;
v15 = -1;
if ( a2 > 0 && a1[a2 - 1] == 10 )
{
if ( a2 > 1 && a1[a2 - 2] == 13 )
v8 = a2 - 2;
else
v8 = a2 - 1;
}
ptr = sub_40558A(a1, v8);
for ( i = 0; i < *(_DWORD *)v14; ++i )
{
v12 = *(_QWORD *)(v14 + 8) + 72LL * i;
if ( !(unsigned int)regexec(v12, (const char *)ptr, 2LL, v10, 0) )
{
if ( *(_DWORD *)(v12 + 64) )
goto LABEL_20;
break;
}
}
if ( i < *(_DWORD *)v14 )
{
i = v11 >= 0;
src = &a1[v10[2 * (v11 >= 0)]];
v15 = v10[2 * (v11 >= 0) + 1] - v10[2 * (v11 >= 0)];
if ( a4 < v15 )
v15 = a4;
while ( v15 > 0 && (byte_4C5800[src[v15 - 1]] & 1) != 0 )
--v15;
memcpy(a3, src, v15);
}
LABEL_20:
free(ptr);
return v15;
}
Q:[a3,a4,a1,a2,a5,v8,src,v10,v12,ptr,v14,v15,sub_4A294E,sub_40558A,] | A:{'a3': 'buffer', 'a4': 'buffer_size', 'a1': 'line', 'a2': 'len', 'a5': 'priv', 'v8': 'lena', 'src': 'linea', 'v10': 'pmatch', 'v12': 'reg', 'ptr': 'line_buffer', 'v14': 'regs', 'v15': 'result', 'sub_4A294E': 'ff_regexp', 'sub_40558A': 'xstrndup'} | |
09e593e1a10a4f6cadf5c016cb4c8cfb0a3586515f0619eba999737feb58c9d7_09e593e1a10a4f6cadf5c016cb4c8cfb0a3586515f0619eba999737feb58c9d7.jsonl.gz | sub_40F0BC | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40F0BC(__int64 a1, __int64 *a2, _QWORD *a3, __int64 a4)
{
__int64 result; // rax
__int64 v5; // rdx
__int64 v6; // rcx
__int64 v7; // r8
__int64 v8; // r9
__int64 v9; // rcx
__int64 v10; // rdx
__int64 v11; // rax
_QWORD *v13; // [rsp+8h] [rbp-38h]
int v14; // [rsp+20h] [rbp-20h]
int v15; // [rsp+24h] [rbp-1Ch]
_QWORD *v16; // [rsp+28h] [rbp-18h]
_QWORD *v17; // [rsp+30h] [rbp-10h]
__int64 *v18; // [rsp+38h] [rbp-8h]
v13 = a3;
v18 = a2;
v17 = a3;
v16 = 0LL;
if ( !a3 )
return 0LL;
v14 = 1;
while ( v17 && *(_BYTE *)(v17[11] + 127LL) == 4 && *(_BYTE *)(v17[11] + 126LL) == 22 )
{
v16 = v17;
v17 = (_QWORD *)v17[4];
++v14;
}
v15 = a2 != 0LL;
while ( v18 && *((_BYTE *)v18 + 127) == 4 && *((_BYTE *)v18 + 126) == 22 )
{
v18 = (__int64 *)v18[3];
++v15;
}
if ( v15 >= v14 )
{
v9 = *(unsigned __int16 *)(*(_QWORD *)(qword_49FAC0 + 24) + 4LL);
if ( v17 )
v10 = (__int64)(v17 + 20);
else
v10 = 0LL;
if ( v18 )
v11 = v18[3];
else
v11 = 0LL;
while ( 1 )
{
off_49BBD8(a1, v11, v10, v9);
if ( v17 == v13 )
break;
v17 = v16;
v16 = (_QWORD *)v16[1];
v18 = (__int64 *)*v18;
v9 = *(unsigned __int16 *)(*(_QWORD *)(qword_49FAC0 + 24) + 4LL);
if ( v17[5] )
v10 = v17[5] + 160LL;
else
v10 = 0LL;
if ( v18[4] )
v11 = *(_QWORD *)(v18[4] + 24);
else
v11 = 0LL;
}
result = 0LL;
}
else
{
sub_40ECBC();
sub_413CB2(a4);
sub_40A7D7(35, "Mismatched parameters.", v5, v6, v7, v8);
result = 0xFFFFFFFFLL;
}
return result;
}
Q:[a3,a4,a1,a2,v13,v14,v15,v16,v17,v18,sub_40F0BC,sub_40ECBC,sub_413CB2,sub_40A7D7,] | A:{'a3': 'params', 'a4': 'thread', 'a1': 'symb_item', 'a2': 'args', 'v13': 'paramsa', 'v14': 'paramn', 'v15': 'argn', 'v16': 'param_parent', 'v17': 'param', 'v18': 'arg', 'sub_40F0BC': 'substitute_params_into_symb', 'sub_40ECBC': 'pop_the_script', 'sub_413CB2': 'pop_the_result_node', 'sub_40A7D7': 'report_error'} |