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 |
|---|---|---|---|---|---|
b57dc741ab89a18d2d7bde13dc91979a52dfdc00913ec7c57afdd64909a03a5c_b57dc741ab89a18d2d7bde13dc91979a52dfdc00913ec7c57afdd64909a03a5c.jsonl.gz | sub_43277D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43277D(__int64 a1)
{
__int64 result; // rax
int i; // [rsp+14h] [rbp-4h]
*(_QWORD *)(a1 + 8) = sub_431D2B(*(_QWORD *)(a1 + 8));
*(_QWORD *)(a1 + 16) = sub_431D2B(*(_QWORD *)(a1 + 16));
*(_DWORD *)(a1 + 24) = sub_431D1D(*(_DWORD *)(a1 + 24));
*(_DWORD *)(a1 + 28) = sub_431D1D(*(_DWORD *)(a1 + 28));
*(_DWORD *)(a1 + 32) = sub_431D1D(*(_DWORD *)(a1 + 32));
*(_DWORD *)(a1 + 36) = sub_431D1D(*(_DWORD *)(a1 + 36));
*(_DWORD *)(a1 + 56) = sub_431D1D(*(_DWORD *)(a1 + 56));
for ( i = 0; ; ++i )
{
result = (unsigned int)i;
if ( i >= 8 )
break;
*(_DWORD *)(a1 + 24LL * i + 576) = sub_431D1D(*(_DWORD *)(a1 + 24LL * i + 576));
*(_DWORD *)(a1 + 24LL * i + 580) = sub_431D1D(*(_DWORD *)(a1 + 24LL * i + 580));
*(_DWORD *)(a1 + 24LL * i + 584) = sub_431D1D(*(_DWORD *)(a1 + 24LL * i + 584));
*(_QWORD *)(a1 + 24LL * i + 592) = sub_431D2B(*(_QWORD *)(a1 + 24LL * i + 592));
}
return result;
}
Q:[a1,sub_43277D,] | A:{'a1': 'header', 'sub_43277D': 'vhd_header_out'} | |
6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58_6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58.jsonl.gz | sub_408849 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BYTE *__fastcall sub_408849(__int64 a1)
{
__int16 v1; // bx
unsigned __int16 v2; // ax
char v3; // al
char v4; // al
*(_DWORD *)(a1 + 88) += 5;
v1 = *(_WORD *)(a1 + 10);
v2 = *(_WORD *)(a1 + 28);
*(_WORD *)(a1 + 28) = v2 + 1;
v3 = sub_406777(a1, v2);
v4 = sub_406777(a1, v1 + v3);
return sub_40700A((_BYTE *)a1, v4);
}
Q:[a1,sub_408849,sub_406777,sub_40700A,] | A:{'a1': 'ctx', 'sub_408849': 'AND_off_IY_d', 'sub_406777': 'read8', 'sub_40700A': 'doAND'} | |
8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2_8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2.jsonl.gz | sub_47F0CF | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_47F0CF(unsigned int a1, unsigned int a2)
{
__int64 result; // rax
int i; // [rsp+14h] [rbp-Ch]
void (__fastcall *v4)(_QWORD); // [rsp+18h] [rbp-8h]
__int64 (__fastcall *v5)(_QWORD); // [rsp+18h] [rbp-8h]
if ( !qword_511A30 )
return 4294964983LL;
if ( a1 == -1 )
{
for ( i = 0; i <= 2; ++i )
{
v4 = 0LL;
sub_48CC13(qword_511A30);
if ( qword_511A40[i] )
v4 = *(void (__fastcall **)(_QWORD))(qword_511A40[i] + 72);
sub_48CC5B(qword_511A30);
if ( v4 )
v4(a2);
}
result = 0LL;
}
else if ( (int)sub_47F41A(a1) >= 0 )
{
sub_48CC13(qword_511A30);
v5 = *(__int64 (__fastcall **)(_QWORD))(qword_511A40[a1] + 72);
sub_48CC5B(qword_511A30);
result = v5(a2);
}
else
{
result = 4294964978LL;
}
return result;
}
Q:[a1,a2,v4,sub_47F0CF,sub_48CC13,sub_48CC5B,sub_47F41A,] | A:{'a1': 'fd', 'a2': 'timeout', 'v4': 'yield_func', 'sub_47F0CF': '_iotx_cm_yield', 'sub_48CC13': 'amp_mutex_lock', 'sub_48CC5B': 'amp_mutex_unlock', 'sub_47F41A': '_fd_is_valid'} | |
9d78dbff2b693e04074ea84c73a96628b1f1aed0c972b2f8d7ee58d07ee0ab92_9d78dbff2b693e04074ea84c73a96628b1f1aed0c972b2f8d7ee58d07ee0ab92.jsonl.gz | sub_409BF4 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 sub_409BF4()
{
__int16 v0; // ax
__int16 v1; // ax
__int16 v2; // ax
__int16 v4; // [rsp+6h] [rbp-1Ah]
__int16 v5; // [rsp+8h] [rbp-18h]
unsigned __int16 v6; // [rsp+Ah] [rbp-16h]
__int16 v7; // [rsp+Ch] [rbp-14h]
__int16 v8; // [rsp+Eh] [rbp-12h]
unsigned __int16 v9; // [rsp+10h] [rbp-10h]
__int16 v10; // [rsp+12h] [rbp-Eh]
__int16 v11; // [rsp+12h] [rbp-Eh]
__int16 v12; // [rsp+14h] [rbp-Ch]
__int16 v13; // [rsp+14h] [rbp-Ch]
__int16 v14; // [rsp+16h] [rbp-Ah]
__int16 v15; // [rsp+16h] [rbp-Ah]
__int16 v16; // [rsp+1Ah] [rbp-6h]
unsigned __int16 v17; // [rsp+1Ch] [rbp-4h]
__int16 v18; // [rsp+1Eh] [rbp-2h]
v17 = sub_424E93();
v16 = sub_424E93();
v18 = sub_424E93();
v12 = sub_424E93();
v14 = sub_424E93();
v8 = sub_424E93();
v9 = sub_424E93();
v7 = v16 ^ v8 ^ v9;
v5 = sub_424E93();
v6 = sub_424E93();
v4 = v18 ^ v5 ^ v6;
v0 = sub_424E93();
v10 = v0 ^ v7 & v4 ^ v17 ^ v12 ^ v14;
v13 = v8 & v4 ^ v5 & v7 ^ v0 ^ v12;
v1 = sub_424E93();
v11 = v1 ^ v10;
v15 = v9 & v4 ^ v6 & v7 ^ v1 ^ v14;
v2 = sub_424E93();
return ((unsigned __int16)(v9 & v6 ^ v9 & v5 ^ v6 & v8 ^ v2 ^ v15) ^ (unsigned __int16)(v2 ^ v8 & v5 ^ v13 ^ v11)) == (v17 ^ (unsigned __int16)(v18 & v16))
&& v16 == ((unsigned __int16)(v8 ^ v7) ^ v9)
&& v18 == ((unsigned __int16)(v5 ^ v4) ^ v6);
}
Q:[v4,v5,v6,v7,v8,v9,v11,v12,v15,v16,v17,v18,sub_409BF4,sub_424E93,] | A:{'v4': 'w3', 'v5': 'w3_2', 'v6': 'w3_4', 'v7': 'w2', 'v8': 'w2_2', 'v9': 'w2_4', 'v11': 'w1a', 'v12': 'w1_2a', 'v15': 'w1_4', 'v16': 'y', 'v17': 'x', 'v18': 'z', 'sub_409BF4': 'test_uint16_x3_and', 'sub_424E93': 'aead_random_generate_32'} | |
bec0a07631308fe77b571886db09a49a5e4be678153bf53f83ebdf8e9d2865bb_bec0a07631308fe77b571886db09a49a5e4be678153bf53f83ebdf8e9d2865bb.jsonl.gz | sub_449F4B | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_449F4B(__int64 a1, _QWORD *a2, unsigned __int64 a3, unsigned __int64 a4, unsigned int a5)
{
unsigned __int64 v6; // rax
unsigned __int64 v7; // rdx
unsigned __int64 v8; // rsi
unsigned __int64 v9; // rdi
unsigned __int64 v10; // rdx
__int64 v11; // rax
__int64 v12; // rcx
__int64 v13; // rdx
__int64 v14; // rdx
unsigned int v15; // eax
_QWORD *v16; // rcx
__int64 v17; // rdx
__m128i v18[3]; // [rsp+10h] [rbp-120h] BYREF
unsigned int v19; // [rsp+4Ch] [rbp-E4h]
__int128 v20; // [rsp+50h] [rbp-E0h]
_QWORD *v21; // [rsp+60h] [rbp-D0h]
__int64 v22; // [rsp+68h] [rbp-C8h]
__int64 v23[2]; // [rsp+70h] [rbp-C0h] BYREF
unsigned __int64 v24; // [rsp+80h] [rbp-B0h] BYREF
unsigned __int64 v25; // [rsp+88h] [rbp-A8h]
__int64 v26; // [rsp+90h] [rbp-A0h] BYREF
unsigned __int64 v27; // [rsp+98h] [rbp-98h] BYREF
int v28; // [rsp+A4h] [rbp-8Ch] BYREF
unsigned int v29; // [rsp+A8h] [rbp-88h] BYREF
unsigned __int8 v30; // [rsp+AEh] [rbp-82h] BYREF
unsigned __int8 v31; // [rsp+AFh] [rbp-81h] BYREF
__int128 v32; // [rsp+B0h] [rbp-80h] BYREF
unsigned int v33; // [rsp+CCh] [rbp-64h]
_QWORD *v34; // [rsp+D0h] [rbp-60h]
int v35; // [rsp+DCh] [rbp-54h]
__int128 v36; // [rsp+E0h] [rbp-50h]
__int64 v37; // [rsp+F0h] [rbp-40h]
int v38; // [rsp+F8h] [rbp-38h]
int v39; // [rsp+FCh] [rbp-34h]
unsigned __int128 v40; // [rsp+100h] [rbp-30h]
v22 = a1;
v21 = a2;
v20 = __PAIR128__(a4, a3);
v19 = a5;
v39 = 1 << a5;
v38 = ((1 << a5) - 1) & a3;
if ( v38 )
{
if ( v19 == 4 )
{
v20 -= v38;
v33 = sub_448FD6(v22, &v24, v20, *((unsigned __int64 *)&v20 + 1));
if ( v33 )
return v33;
v33 = sub_448FD6(v22, v23, v20 + 16, (v20 + (unsigned __int128)0x10uLL) >> 64);
if ( v33 )
return v33;
v6 = (v24 >> (8 * (unsigned __int8)v38)) | (v25 << (64 - 8 * (unsigned __int8)v38));
v7 = v25 >> (8 * (unsigned __int8)v38);
if ( ((8 * (_BYTE)v38) & 0x40) != 0 )
{
v6 = v25 >> (8 * (unsigned __int8)v38);
v7 = 0LL;
}
v8 = v6;
v9 = v7;
v10 = (v23[1] << (8 * (16 - (unsigned __int8)v38))) | ((unsigned __int64)v23[0] >> (64
- 8
* (16 - (unsigned __int8)v38)));
v11 = v23[0] << (8 * (16 - (unsigned __int8)v38));
if ( ((8 * (16 - (_BYTE)v38)) & 0x40) != 0 )
{
v10 = v23[0] << (8 * (16 - (unsigned __int8)v38));
v11 = 0LL;
}
*(_QWORD *)&v40 = v11 | v8;
*((_QWORD *)&v40 + 1) = v10 | v9;
}
else
{
if ( (int)v19 > 4 )
goto LABEL_32;
switch ( v19 )
{
case 3u:
v18[1] = (__m128i)v38;
v20 -= v38;
v33 = sub_448DD1(v22, &v27, v20, *((unsigned __int64 *)&v20 + 1));
if ( v33 )
return v33;
v33 = sub_448DD1(v22, &v26, v20 + 8, (v20 + (unsigned __int128)8uLL) >> 64);
if ( v33 )
return v33;
v40 = (v27 >> (8 * (unsigned __int8)v38)) | (unsigned __int128)(unsigned __int64)(v26 << (8
* (8 - (unsigned __int8)v38)));
break;
case 1u:
v33 = sub_4487C4(v22, &v31, v20, *((unsigned __int64 *)&v20 + 1));
if ( v33 )
return v33;
v33 = sub_4487C4(v22, &v30, v20 + 1, (v20 + (unsigned __int128)1uLL) >> 64);
if ( v33 )
return v33;
v40 = v31 | (v30 << 8);
break;
case 2u:
v18[2] = (__m128i)v38;
v20 -= v38;
v33 = sub_448BD2(v22, &v29, v20, *((unsigned __int64 *)&v20 + 1));
if ( v33 )
return v33;
v33 = sub_448BD2(v22, &v28, v20 + 4, (v20 + (unsigned __int128)4uLL) >> 64);
if ( v33 )
return v33;
v40 = (v29 >> (8 * v38)) | (v28 << (8 * (4 - v38)));
break;
default:
LABEL_32:
abort();
}
}
}
else
{
if ( (unsigned int)sub_44976B(v22, &v32, v20, *((unsigned __int64 *)&v20 + 1), 0) )
{
v12 = v22;
v13 = *((_QWORD *)&v20 + 1);
*(_QWORD *)(v22 + 1088) = v20;
*(_QWORD *)(v12 + 1096) = v13;
*(_DWORD *)(v22 + 1084) = 13;
return 0xFFFFFFFFLL;
}
v37 = sub_40B5DE(*(_DWORD **)(v22 + 1360), v32);
if ( !v37 )
return 0LL;
if ( *(_DWORD *)(v37 + 32) )
{
v35 = (unsigned __int8)(v20 >> 12);
v34 = (_QWORD *)(*(_QWORD *)(v37 + 40) + v32 - *(_QWORD *)(v37 + 8));
v18[0].m128i_i64[0] = v20 & 0xFFFFFFFFFFFFF000LL;
v18[0].m128i_i64[1] = *((_QWORD *)&v20 + 1);
*(__m128i *)(v22 + 32 * ((unsigned __int8)(v20 >> 12) + 43LL)) = _mm_load_si128(v18);
*(_QWORD *)(v22 + 32LL * v35 + 1392) = (char *)v34 - v20;
switch ( v19 )
{
case 0u:
v40 = *(unsigned __int8 *)v34;
break;
case 1u:
v40 = *(unsigned __int16 *)v34;
break;
case 2u:
v40 = *(unsigned int *)v34;
break;
case 3u:
v40 = (unsigned __int64)*v34;
break;
case 4u:
v14 = v34[1];
*(_QWORD *)&v40 = *v34;
*((_QWORD *)&v40 + 1) = v14;
break;
default:
abort();
}
}
else
{
v36 = v32 - *(unsigned __int64 *)(v37 + 8);
if ( ((*(int *)(v37 + 112) >> v19) & 1) != 0 )
{
v40 = (*(unsigned int (__fastcall **)(_QWORD, _QWORD, _QWORD))(v37 + 96))(
*(_QWORD *)(v37 + 88),
(unsigned int)v36,
v19);
}
else if ( (*(_DWORD *)(v37 + 112) & 4) != 0 && v19 == 3 )
{
v40 = (*(unsigned int (__fastcall **)(_QWORD, _QWORD, __int64))(v37 + 96))(
*(_QWORD *)(v37 + 88),
(unsigned int)v36,
2LL);
v15 = (*(__int64 (__fastcall **)(_QWORD, _QWORD, __int64))(v37 + 96))(
*(_QWORD *)(v37 + 88),
(unsigned int)(v36 + 4),
2LL);
*(_QWORD *)&v40 = v40 | ((unsigned __int64)v15 << 32);
}
else
{
v40 = 0uLL;
}
}
}
v16 = v21;
v17 = *((_QWORD *)&v40 + 1);
*v21 = v40;
v16[1] = v17;
return 0LL;
}
Q:[a3,a1,a2,a5,v19,v20,v21,v22,v32,v33,v34,v35,v36,v37,v38,v39,sub_449F4B,sub_448FD6,sub_448DD1,sub_4487C4,sub_448BD2,sub_44976B,sub_40B5DE,] | A:{'a3': 'addr', 'a1': 's', 'a2': 'pval', 'a5': 'size_log2', 'v19': 'size_log2a', 'v20': 'addra', 'v21': 'pvala', 'v22': 'sa', 'v32': 'paddr', 'v33': 'err', 'v34': 'ptr', 'v35': 'tlb_idx', 'v36': 'offset', 'v37': 'pr', 'v38': 'al_0', 'v39': 'size', 'sub_449F4B': 'riscv128_read_slow', 'sub_448FD6': 'target_read_u128', 'sub_448DD1': 'target_read_u64_1', 'sub_4487C4': 'target_read_u8_1', 'sub_448BD2': 'target_read_u32_1', 'sub_44976B': 'get_phys_addr_1', 'sub_40B5DE': 'get_phys_mem_range'} | |
42faebc29e6877a2606d36c9ee4a9acccbfddd98af102782d4cb07481a63ee48_42faebc29e6877a2606d36c9ee4a9acccbfddd98af102782d4cb07481a63ee48.jsonl.gz | sub_41C3F6 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41C3F6(int a1, int a2, int a3)
{
__int64 result; // rax
_QWORD *v4; // rbx
int v5; // er12
int v6; // er13
_QWORD *i; // r14
_QWORD *v8; // rax
int v9; // eax
__int64 v11; // [rsp+18h] [rbp-38h]
v11 = sub_41C01F(a1);
if ( v11 )
{
if ( a2 )
{
v4 = (_QWORD *)v11;
v5 = a1;
while ( 1 )
{
v9 = v5--;
if ( v9 <= 0 )
break;
v6 = 0x200uLL / a2;
for ( i = v4; --v6 > 0; i += a2 )
*i = &i[a2];
if ( v5 )
{
v4 += 512;
v8 = v4;
}
else
{
v8 = 0LL;
}
*i = v8;
}
}
result = v11;
}
else
{
if ( a3 )
{
fwrite("Out of memory.\n", 1uLL, 0xFuLL, stderr);
exit(1);
}
result = 0LL;
}
return result;
}
Q:[a3,a1,a2,v8,v11,sub_41C3F6,sub_41C01F,] | A:{'a3': 'no_mem_exit', 'a1': 'nPages', 'a2': 'size', 'v8': 'result', 'v11': 'pg', 'sub_41C3F6': 'GetPage', 'sub_41C01F': 'GetMoreCore'} | |
9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0_9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0.jsonl.gz | sub_458589 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_458589(__int64 a1, __int64 a2, __int64 a3)
{
return sub_45BAE8(a1, a2, a3);
}
Q:[sub_458589,sub_45BAE8,] | A:{'sub_458589': 'Ptr', 'sub_45BAE8': 'Ptr'} | |
20c07804a3f28a6a5c3f8253e79de0ec1aedc41632a0737ad8dad981cd237640_20c07804a3f28a6a5c3f8253e79de0ec1aedc41632a0737ad8dad981cd237640.jsonl.gz | sub_493E58 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_493E58(__int64 a1, __int64 *a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6)
{
__int64 v6; // rdx
__int64 v7; // rcx
__int64 v8; // r8
__int64 v9; // r9
__int64 v10; // r8
__int64 v11; // r9
__int64 v12; // rcx
__int64 v13; // r8
__int64 v14; // r9
__int64 v16; // rdx
__int64 v17; // rcx
__int64 v18; // r8
__int64 v19; // r9
__int64 v20; // rdx
__int64 v21; // rcx
__int64 v22; // r8
__int64 v23; // r9
__int64 v24; // rdx
__int64 v25; // rcx
__int64 v26; // r8
__int64 v27; // r9
__int64 v28; // rdx
__int64 v29; // rcx
__int64 v30; // r8
__int64 v31; // r9
__int64 v32; // rcx
__int64 v33; // r8
__int64 v34; // r9
__int16 v35; // ax
char v37[16]; // [rsp+10h] [rbp-70h] BYREF
char src[72]; // [rsp+20h] [rbp-60h] BYREF
__int64 v39; // [rsp+68h] [rbp-18h] BYREF
__int64 *v40; // [rsp+70h] [rbp-10h]
__int64 v41; // [rsp+78h] [rbp-8h]
v41 = *(_QWORD *)(*(_QWORD *)a1 + 8LL);
if ( !*(_DWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 8LL) + 120LL) )
{
sub_46FC12(2, "WPS: * Credential", a3, a4, a5, a6);
if ( *(_QWORD *)(a1 + 848) )
{
memcpy((void *)(a1 + 440), *(const void **)(a1 + 848), 0x90uLL);
}
else
{
memset((void *)(a1 + 440), 0, 0x90uLL);
if ( *(_BYTE *)(a1 + 796) == 0x80 && *(_QWORD *)(v41 + 304) )
{
sub_46FC12(2, "WPS: Use backhaul STA credentials", v6, v7, v8, v9);
memcpy((void *)(a1 + 440), (const void *)(v41 + 272), *(_QWORD *)(v41 + 304));
*(_QWORD *)(a1 + 472) = *(_QWORD *)(v41 + 304);
*(_WORD *)(a1 + 480) = 32;
*(_WORD *)(a1 + 482) = 8;
memcpy((void *)(a1 + 560), (const void *)(a1 + 52), 6uLL);
if ( *(_QWORD *)(v41 + 312) )
{
memcpy((void *)(a1 + 485), *(const void **)(v41 + 312), *(_QWORD *)(v41 + 320));
*(_QWORD *)(a1 + 552) = *(_QWORD *)(v41 + 320);
}
}
else
{
memcpy((void *)(a1 + 440), (const void *)(*(_QWORD *)a1 + 40LL), *(_QWORD *)(*(_QWORD *)a1 + 72LL));
*(_QWORD *)(a1 + 472) = *(_QWORD *)(*(_QWORD *)a1 + 72LL);
sub_46FC12(
2,
"WPS: Own auth types 0x%x - masked Enrollee auth types 0x%x",
*(unsigned __int16 *)(*(_QWORD *)a1 + 328LL),
*(unsigned __int16 *)(a1 + 408),
v10,
v11);
if ( (*(_WORD *)(a1 + 408) & 0x20) != 0 )
{
*(_WORD *)(a1 + 408) = 32;
}
else if ( (*(_WORD *)(a1 + 408) & 2) != 0 )
{
*(_WORD *)(a1 + 408) = 2;
}
else
{
if ( (*(_WORD *)(a1 + 408) & 1) == 0 )
{
sub_46FC12(2, "WPS: Unsupported auth_type 0x%x", *(unsigned __int16 *)(a1 + 408), v12, v13, v14);
return 0xFFFFFFFFLL;
}
*(_WORD *)(a1 + 408) = 1;
}
*(_WORD *)(a1 + 480) = *(_WORD *)(a1 + 408);
sub_46FC12(
2,
"WPS: Own encr types 0x%x (rsn: 0x%x, wpa: 0x%x) - masked Enrollee encr types 0x%x",
*(unsigned __int16 *)(*(_QWORD *)a1 + 322LL),
*(unsigned __int16 *)(*(_QWORD *)a1 + 324LL),
*(unsigned __int16 *)(*(_QWORD *)a1 + 326LL),
*(unsigned __int16 *)(a1 + 406),
a2);
if ( **(_DWORD **)a1 && *(_WORD *)(a1 + 408) == 32 )
{
v16 = (unsigned __int16)(*(_WORD *)(*(_QWORD *)a1 + 324LL) & *(_WORD *)(a1 + 406));
*(_WORD *)(a1 + 406) &= *(_WORD *)(*(_QWORD *)a1 + 324LL);
}
else if ( **(_DWORD **)a1 && *(_WORD *)(a1 + 408) == 2 )
{
v16 = (unsigned __int16)(*(_WORD *)(*(_QWORD *)a1 + 326LL) & *(_WORD *)(a1 + 406));
*(_WORD *)(a1 + 406) &= *(_WORD *)(*(_QWORD *)a1 + 326LL);
}
if ( *(_WORD *)(a1 + 408) == 32 || *(_WORD *)(a1 + 408) == 2 )
{
if ( (*(_WORD *)(a1 + 406) & 8) != 0 )
{
*(_WORD *)(a1 + 406) = 8;
}
else
{
if ( (*(_WORD *)(a1 + 406) & 4) == 0 )
{
sub_46FC12(2, "WPS: No suitable encryption type for WPA/WPA2", v16, v17, v18, v19);
return 0xFFFFFFFFLL;
}
*(_WORD *)(a1 + 406) = 4;
}
}
else
{
if ( (*(_WORD *)(a1 + 406) & 1) == 0 )
{
sub_46FC12(2, "WPS: No suitable encryption type for non-WPA/WPA2 mode", v16, v17, v18, v19);
return 0xFFFFFFFFLL;
}
*(_WORD *)(a1 + 406) = 1;
}
*(_WORD *)(a1 + 482) = *(_WORD *)(a1 + 406);
memcpy((void *)(a1 + 560), (const void *)(a1 + 52), 6uLL);
if ( *(_DWORD *)(*(_QWORD *)a1 + 16LL) == 1
&& **(_DWORD **)a1
&& !*(_DWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 8LL) + 136LL) )
{
if ( (int)sub_47214B((__int64)v37, 0x10uLL) < 0 )
{
sub_46FC12(3, "WPS: Could not generate random PSK", v20, v21, v22, v23);
return 0xFFFFFFFFLL;
}
free(*(void **)(a1 + 416));
*(_QWORD *)(a1 + 416) = sub_4A2BC5(v37, 16LL, a1 + 424);
if ( !*(_QWORD *)(a1 + 416) )
return 0xFFFFFFFFLL;
--*(_QWORD *)(a1 + 424);
while ( *(_QWORD *)(a1 + 424) && *(_BYTE *)(*(_QWORD *)(a1 + 416) + *(_QWORD *)(a1 + 424) - 1LL) == 61 )
--*(_QWORD *)(a1 + 424);
sub_470404(2, "WPS: Generated passphrase", *(_QWORD *)(a1 + 416), *(_QWORD *)(a1 + 424));
memcpy((void *)(a1 + 485), *(const void **)(a1 + 416), *(_QWORD *)(a1 + 424));
*(_QWORD *)(a1 + 552) = *(_QWORD *)(a1 + 424);
}
else if ( (unsigned int)sub_492EC0(v41, a1 + 52, (__int64)&v39) )
{
sub_46FF4C(2, "WPS: Use PSK from wpa_psk_file", v39, 0x20uLL);
sub_46DD60(src, 65LL, v39, 0x20uLL);
memcpy((void *)(a1 + 485), src, 0x40uLL);
*(_QWORD *)(a1 + 552) = 64LL;
}
else if ( !*(_DWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 8LL) + 156LL)
&& *(_DWORD *)(a1 + 856)
&& *(_DWORD *)(*(_QWORD *)a1 + 384LL) )
{
sub_46FC12(2, "WPS: Use PSK format for Network Key", v24, v25, v26, v27);
sub_46DD60(src, 65LL, *(_QWORD *)a1 + 352LL, 0x20uLL);
memcpy((void *)(a1 + 485), src, 0x40uLL);
*(_QWORD *)(a1 + 552) = 64LL;
}
else if ( *(_DWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 8LL) + 156LL) || !*(_QWORD *)(*(_QWORD *)a1 + 336LL) )
{
if ( (*(_WORD *)(a1 + 408) & 0x22) != 0 )
{
free(*(void **)(a1 + 416));
*(_QWORD *)(a1 + 424) = 32LL;
*(_QWORD *)(a1 + 416) = malloc(*(_QWORD *)(a1 + 424));
if ( !*(_QWORD *)(a1 + 416) )
return 0xFFFFFFFFLL;
if ( (int)sub_47214B(*(_QWORD *)(a1 + 416), *(_QWORD *)(a1 + 424)) < 0 )
{
sub_46FC12(3, "WPS: Could not generate random PSK", v28, v29, v30, v31);
free(*(void **)(a1 + 416));
*(_QWORD *)(a1 + 416) = 0LL;
return 0xFFFFFFFFLL;
}
sub_46FF4C(2, "WPS: Generated per-device PSK", *(_QWORD *)(a1 + 416), *(_QWORD *)(a1 + 424));
sub_46DD60(src, 65LL, *(_QWORD *)(a1 + 416), *(_QWORD *)(a1 + 424));
memcpy((void *)(a1 + 485), src, 2LL * *(_QWORD *)(a1 + 424));
*(_QWORD *)(a1 + 552) = 2LL * *(_QWORD *)(a1 + 424);
}
}
else
{
memcpy((void *)(a1 + 485), *(const void **)(*(_QWORD *)a1 + 336LL), *(_QWORD *)(*(_QWORD *)a1 + 344LL));
*(_QWORD *)(a1 + 552) = *(_QWORD *)(*(_QWORD *)a1 + 344LL);
}
}
}
v40 = sub_4717A9(200LL);
if ( !v40 )
return 0xFFFFFFFFLL;
if ( (unsigned int)sub_493D02(v40, (unsigned __int64 *)(a1 + 440), a1 + 440, v32, v33, v34) )
{
sub_47194C((__int64)v40);
return 0xFFFFFFFFLL;
}
sub_4903A8(a2, 4110);
v35 = sub_490351((__int64)v40);
sub_4903A8(a2, v35);
sub_49042B(a2, (__int64)v40);
sub_47194C((__int64)v40);
}
if ( *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 8LL) + 128LL) )
{
sub_46FC12(2, "WPS: * Credential (pre-configured)", a3, a4, a5, a6);
sub_49042B(a2, *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 8LL) + 128LL));
}
return 0LL;
}
Q:[a1,a2,v37,src,v39,v40,v41,sub_493E58,sub_46FC12,sub_47214B,sub_4A2BC5,sub_470404,sub_492EC0,sub_46FF4C,sub_46DD60,sub_4717A9,sub_493D02,sub_47194C,sub_4903A8,sub_490351,sub_49042B,] | A:{'a1': 'wps', 'a2': 'msg', 'v37': 'r', 'src': 'hex', 'v39': 'pskfile_psk', 'v40': 'cred', 'v41': 'reg', 'sub_493E58': 'wps_build_cred', 'sub_46FC12': 'wpa_printf', 'sub_47214B': 'os_get_random', 'sub_4A2BC5': 'base64_encode', 'sub_470404': 'wpa_hexdump_ascii_key', 'sub_492EC0': 'wps_cp_lookup_pskfile', 'sub_46FF4C': 'wpa_hexdump_key', 'sub_46DD60': 'wpa_snprintf_hex', 'sub_4717A9': 'wpabuf_alloc', 'sub_493D02': 'wps_build_credential', 'sub_47194C': 'wpabuf_clear_free', 'sub_4903A8': 'wpabuf_put_be16_2', 'sub_490351': 'wpabuf_len_24', 'sub_49042B': 'wpabuf_put_buf_6'} | |
556e0263abbe1e4daef5ea125859adebb55575ea4fa8d33e6255954205d7ba5b_556e0263abbe1e4daef5ea125859adebb55575ea4fa8d33e6255954205d7ba5b.jsonl.gz | sub_419E37 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_419E37(__int64 a1, void *a2, unsigned int a3)
{
__int64 v4; // rax
__int64 v5; // rax
unsigned int v6; // [rsp+Ch] [rbp-54h] BYREF
void *s2; // [rsp+10h] [rbp-50h]
__int64 v8; // [rsp+18h] [rbp-48h]
__int64 v9; // [rsp+28h] [rbp-38h]
__int64 v10; // [rsp+30h] [rbp-30h]
__int64 v11; // [rsp+38h] [rbp-28h]
__int64 v12; // [rsp+40h] [rbp-20h]
int v13; // [rsp+48h] [rbp-18h]
signed int v14; // [rsp+4Ch] [rbp-14h]
__int64 i; // [rsp+50h] [rbp-10h]
__int64 v16; // [rsp+58h] [rbp-8h]
v8 = a1;
s2 = a2;
v6 = a3;
v13 = 0;
v16 = 0LL;
i = 0LL;
v14 = 0;
if ( a3 == 1 )
{
v14 = 4;
}
else
{
if ( v6 != 28 )
return 0LL;
v14 = 16;
}
v13 = sub_419042((unsigned int *)s2, v14, 0);
v13 = sub_419042(&v6, 4u, v13);
pthread_mutex_lock((pthread_mutex_t *)(v8 + 1752));
v12 = *(_QWORD *)(v8 + 8 * ((unsigned int)sub_419333(v13, 4) + 228LL));
if ( v12 )
{
v11 = v12;
v4 = v12;
}
else
{
v4 = 0LL;
}
for ( i = v4; i; i = v5 )
{
if ( *(_DWORD *)(i + 36) == v6 && !memcmp((const void *)(i + 296), s2, v14) )
{
v16 = i;
break;
}
v10 = *(_QWORD *)i;
if ( v10 )
{
v9 = v10;
v5 = v10;
}
else
{
v5 = 0LL;
}
}
pthread_mutex_unlock((pthread_mutex_t *)(v8 + 1752));
return v16;
}
Q:[a3,a1,a2,v6,s2,v8,v9,v10,v11,v12,v13,v14,i,v16,sub_419E37,sub_419042,sub_419333,] | A:{'a3': 'addr_type', 'a1': 'request', 'a2': 'addr', 'v6': 'addr_typea', 's2': 'addra', 'v8': 'requesta', 'v9': '__mptr_0', 'v10': '____ptr_0', 'v11': '__mptr', 'v12': '____ptr', 'v13': 'key', 'v14': 'addr_len', 'i': 'addr_tmp', 'v16': 'addr_map', 'sub_419E37': '_dns_ip_address_get', 'sub_419042': 'jhash_1', 'sub_419333': 'hash_32_generic_1'} | |
2e7195e6bc11902cb1147d429b22ff6f7655de6050b37429b5d7074aaa0727e8_2e7195e6bc11902cb1147d429b22ff6f7655de6050b37429b5d7074aaa0727e8.jsonl.gz | sub_41BD04 | Help user generate meaningful names for variables and functions in the following code snippet. |
_QWORD *__fastcall sub_41BD04(__int64 a1)
{
return sub_40E056(a1);
}
Q:[a1,sub_41BD04,sub_40E056,] | A:{'a1': 'self', 'sub_41BD04': 'lxw_worksheet_write_page_setup', 'sub_40E056': '_worksheet_write_page_setup'} | |
8dfe029ed4a37518aca4298134b481d562addd5f363b314a82d78c3ce0359d9b_8dfe029ed4a37518aca4298134b481d562addd5f363b314a82d78c3ce0359d9b.jsonl.gz | sub_408EF3 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_408EF3(__int64 a1, __int64 a2)
{
_QWORD *v3; // [rsp+10h] [rbp-20h]
_QWORD *i; // [rsp+20h] [rbp-10h]
char v5; // [rsp+2Ch] [rbp-4h]
v5 = 0;
if ( *(_QWORD *)(a1 + 11496) )
{
for ( i = *(_QWORD **)(*(_QWORD *)(a1 + 11496) + 8LL); i && *i; i = (_QWORD *)i[1] )
{
if ( (v5 & 1) == 0 && *i == a2 )
{
v3 = (_QWORD *)i[1];
sub_403E37(*(_QWORD *)(a1 + 11496), i);
sub_403E37(*(_QWORD *)(a1 + 11496), v3);
return 1LL;
}
++v5;
}
}
return 0LL;
}
Q:[a1,a2,v3,i,sub_408EF3,sub_403E37,] | A:{'a1': 's', 'a2': 'h', 'v3': 'iter2', 'i': 'iter', 'sub_408EF3': 'sdb_unhook', 'sub_403E37': 'ls_delete'} | |
c01d3aec38f1f0fc6d283c3a670d938f7f9dc20a11765202b902e11a359342bd_c01d3aec38f1f0fc6d283c3a670d938f7f9dc20a11765202b902e11a359342bd.jsonl.gz | sub_417E37 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_417E37(FILE **a1, __int64 a2)
{
unsigned __int64 v2; // rbx
__int64 v3; // rcx
__int64 v4; // r8
__int64 v5; // r9
__int64 v6; // r8
__int64 v7; // r9
__int64 result; // rax
char v9; // [rsp+14h] [rbp-1Ch]
int v10; // [rsp+18h] [rbp-18h]
if ( sub_413B62(*(_QWORD *)(a2 + 8 * (((*(_DWORD *)(a2 + 32) >> 15) & 0x3F) + 1 + 6LL) + 8)) )
{
v2 = (unsigned int)sub_413F3B(a1, a2, *(_QWORD *)(a2 + 8 * (((*(_DWORD *)(a2 + 32) >> 15) & 0x3F) + 1 + 6LL) + 8));
if ( v2 >= sub_40D46C(a1, *(_QWORD *)(a2 + 24), *(_QWORD *)(a2 + 24), v3, v4, v5) )
sub_40290A(a1, (unsigned __int8 *)a2, "right shift count >= width of type", a2, v6, v7);
}
result = sub_413B62(*(_QWORD *)(a2 + 8 * (((*(_DWORD *)(a2 + 32) >> 15) & 0x3F) + 6LL) + 8));
if ( (_DWORD)result )
{
result = sub_413B62(*(_QWORD *)(a2 + 8 * (((*(_DWORD *)(a2 + 32) >> 15) & 0x3F) + 1 + 6LL) + 8));
if ( (_DWORD)result )
{
v10 = sub_4140A5((__int64)a1, a2, *(_QWORD *)(a2 + 8 * (((*(_DWORD *)(a2 + 32) >> 15) & 0x3F) + 6LL) + 8));
v9 = sub_4140A5((__int64)a1, a2, *(_QWORD *)(a2 + 8 * (((*(_DWORD *)(a2 + 32) >> 15) & 0x3F) + 1 + 6LL) + 8));
result = sub_4149C1(a1, a2, v10 >> v9);
}
}
return result;
}
Q:[a1,a2,v10,sub_417E37,sub_413B62,sub_413F3B,sub_40D46C,sub_40290A,sub_4140A5,sub_4149C1,] | A:{'a1': 'state', 'a2': 'ins', 'v10': 'left', 'sub_417E37': 'simplify_ssr', 'sub_413B62': 'is_simple_const', 'sub_413F3B': 'read_const', 'sub_40D46C': 'size_of', 'sub_40290A': 'warning', 'sub_4140A5': 'read_sconst', 'sub_4149C1': 'mkconst'} | |
0bdd3e3355b55ed2816435efa21042f8306da2b2ea7b587febce5c0891e6891f_0bdd3e3355b55ed2816435efa21042f8306da2b2ea7b587febce5c0891e6891f.jsonl.gz | sub_430919 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_430919(const char *a1)
{
return sub_4308AF(a1, (__int64)&off_442360, 64);
}
Q:[a1,sub_430919,sub_4308AF,] | A:{'a1': 'function', 'sub_430919': 'vmir_default_external_function_resolver', 'sub_4308AF': 'vmir_function_tab_lookup'} | |
507b6d6826ab1404fd3df13a4b27da226b5beb2f60ed3e979a82f4c0a6725d69_507b6d6826ab1404fd3df13a4b27da226b5beb2f60ed3e979a82f4c0a6725d69.jsonl.gz | sub_4232A9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4232A9(__int64 a1, __int64 a2)
{
_QWORD v3[12]; // [rsp+10h] [rbp-80h] BYREF
__int64 v4; // [rsp+70h] [rbp-20h] BYREF
__int64 v5; // [rsp+78h] [rbp-18h]
unsigned int v6; // [rsp+84h] [rbp-Ch]
char **v7; // [rsp+88h] [rbp-8h]
v7 = (char **)(a1 + 24);
v6 = sub_4205EB((__int64 *)(a1 + 24), (_QWORD *)(a1 + 24), *(_QWORD *)(a2 + 8));
if ( v6 )
return v6;
sub_41F15B(*(_QWORD *)(a2 + 8));
v5 = sub_44A1CE(5LL, 88LL);
do
{
memset(v3, 0, 0x58uLL);
v6 = sub_421868(v7, a2, 0LL, &v4, v3, 0);
if ( v6 )
{
sub_44A51A(v5);
while ( (unsigned __int8)sub_422CD9(a1, *(_QWORD *)(a2 + 8), 0) )
;
return v6;
}
if ( (unsigned __int8)sub_443269(&v3[5]) != 1 )
sub_422FEF(v5, v3, a2);
}
while ( (unsigned __int8)sub_422CD9(a1, *(_QWORD *)(a2 + 8), 1) );
v6 = sub_423171(v5, a2);
sub_44A51A(v5);
if ( v6 )
{
while ( (unsigned __int8)sub_422CD9(a1, *(_QWORD *)(a2 + 8), 0) )
;
}
sub_44617B(a2, 1LL);
return v6;
}
Q:[a1,v3,v4,v5,v6,v7,sub_4232A9,sub_4205EB,sub_41F15B,sub_44A1CE,sub_421868,sub_44A51A,sub_422CD9,sub_443269,sub_422FEF,sub_423171,sub_44617B,] | A:{'a1': 'buffered_sam_input', 'v3': 'pending', 'v4': 'alignment_flag', 'v5': 'pending_v', 'v6': 'error_code', 'v7': 'text_line', 'sub_4232A9': 'gt_input_sam_parser_parse_template', 'sub_4205EB': 'gt_isp_read_tag', 'sub_41F15B': 'gt_input_parse_tag_chomp_pairend_info', 'sub_44A1CE': 'gt_vector_new', 'sub_421868': 'gt_isp_parse_sam_alignment', 'sub_44A51A': 'gt_vector_delete', 'sub_422CD9': 'gt_isp_fetch_next_line', 'sub_443269': 'gt_string_is_null', 'sub_422FEF': 'gt_isp_solve_pending_maps', 'sub_423171': 'gt_isp_solve_remaining_maps', 'sub_44617B': 'gt_template_setup_pair_attributes_to_alignments'} | |
88bd1a67d86d397d125d1dfba3db20c19e4e3d299a8a38fc732136c78cec6b01_88bd1a67d86d397d125d1dfba3db20c19e4e3d299a8a38fc732136c78cec6b01.jsonl.gz | sub_4054E8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_4054E8()
{
return sub_404EB7(dword_40B1B8);
}
Q:[sub_4054E8,sub_404EB7,] | A:{'sub_4054E8': 'hmc5883l_interface_iic_deinit', 'sub_404EB7': 'iic_deinit'} | |
4bd79747e1dc57f4771eefd9a3a47d051b453172d6afd251df0ca1c3a230b34e_4bd79747e1dc57f4771eefd9a3a47d051b453172d6afd251df0ca1c3a230b34e.jsonl.gz | sub_413162 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_413162(__int64 a1, __int64 a2, __int64 a3, __int64 a4, int a5)
{
__int64 v6; // rdx
__int64 v7; // rdx
__int64 v8; // rbx
__int64 v9; // rbx
if ( *(__int16 *)(a2 + 74) < 0 )
return 0LL;
if ( a5 > 1 || (*(_WORD *)(a2 + 74) & 2) == 0 )
goto LABEL_9;
if ( !sub_412E75((_DWORD *)a3, (_DWORD *)(a2 + 4), 100) )
{
*(_WORD *)(a2 + 74) |= 0x8000u;
sub_4162E9(a1, "inconsistent chromaticities");
return 0LL;
}
if ( !a5 )
return 1LL;
LABEL_9:
v6 = *(_QWORD *)(a3 + 8);
*(_QWORD *)(a2 + 4) = *(_QWORD *)a3;
*(_QWORD *)(a2 + 12) = v6;
v7 = *(_QWORD *)(a3 + 24);
*(_QWORD *)(a2 + 20) = *(_QWORD *)(a3 + 16);
*(_QWORD *)(a2 + 28) = v7;
v8 = *(_QWORD *)(a4 + 8);
*(_QWORD *)(a2 + 36) = *(_QWORD *)a4;
*(_QWORD *)(a2 + 44) = v8;
v9 = *(_QWORD *)(a4 + 24);
*(_QWORD *)(a2 + 52) = *(_QWORD *)(a4 + 16);
*(_QWORD *)(a2 + 60) = v9;
*(_DWORD *)(a2 + 68) = *(_DWORD *)(a4 + 32);
*(_WORD *)(a2 + 74) |= 2u;
if ( sub_412E75((_DWORD *)a3, dword_449400, 1000) )
*(_WORD *)(a2 + 74) |= 0x40u;
else
*(_WORD *)(a2 + 74) &= 0xFFBFu;
return 2LL;
}
Q:[a3,a4,a1,a2,a5,sub_413162,sub_412E75,sub_4162E9,] | A:{'a3': 'xy', 'a4': 'XYZ', 'a1': 'png_ptr', 'a2': 'colorspace', 'a5': 'preferred', 'sub_413162': 'png_colorspace_set_xy_and_XYZ', 'sub_412E75': 'png_colorspace_endpoints_match', 'sub_4162E9': 'png_benign_error'} | |
7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2_7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2.jsonl.gz | sub_4306EF | Help user generate meaningful names for variables and functions in the following code snippet. |
_DWORD *__fastcall sub_4306EF(_DWORD *a1, int *a2)
{
_DWORD *result; // rax
__int64 v3; // [rsp+20h] [rbp-130h]
__int64 v4; // [rsp+20h] [rbp-130h]
__int64 v5; // [rsp+30h] [rbp-120h]
__int64 v6; // [rsp+30h] [rbp-120h]
__int64 v7; // [rsp+38h] [rbp-118h]
__int64 v8; // [rsp+48h] [rbp-108h]
__int64 v9; // [rsp+58h] [rbp-F8h]
__int64 v10; // [rsp+70h] [rbp-E0h]
__int64 v11; // [rsp+88h] [rbp-C8h]
__int64 v12; // [rsp+A8h] [rbp-A8h]
__int64 v13; // [rsp+B0h] [rbp-A0h]
__int64 v14; // [rsp+C8h] [rbp-88h]
__int64 v15; // [rsp+E8h] [rbp-68h]
__int64 v16; // [rsp+100h] [rbp-50h]
__int64 v17; // [rsp+118h] [rbp-38h]
__int64 v18; // [rsp+128h] [rbp-28h]
__int64 v19; // [rsp+138h] [rbp-18h]
__int64 v20; // [rsp+140h] [rbp-10h]
__int64 v21; // [rsp+148h] [rbp-8h]
v21 = *a2 * (__int64)*a2;
v13 = 2 * a2[3] * (__int64)a2[4];
v5 = a2[7] * (__int64)a2[7];
v3 = v5 >> 28;
v20 = (v21 >> 28) + 2 * *a2 * (__int64)a2[1];
v19 = (v20 >> 28) + a2[1] * (__int64)a2[1] + 2 * *a2 * (__int64)a2[2];
v18 = (v19 >> 28) + 2 * a2[1] * (__int64)a2[2] + 2 * *a2 * (__int64)a2[3];
v17 = (v18 >> 28) + a2[2] * (__int64)a2[2] + 2 * a2[1] * (__int64)a2[3] + 2 * *a2 * (__int64)a2[4];
v16 = (v17 >> 28) + 2 * a2[2] * (__int64)a2[3] + 2 * a2[1] * (__int64)a2[4] + 2 * *a2 * (__int64)a2[5];
v15 = (v16 >> 28)
+ a2[3] * (__int64)a2[3]
+ 2 * a2[2] * (__int64)a2[4]
+ 2 * a2[1] * (__int64)a2[5]
+ 2 * *a2 * (__int64)a2[6];
v14 = v13
- (v13 >> 28 << 28)
+ (v15 >> 28)
+ 2 * a2[2] * (__int64)a2[5]
+ 2 * a2[1] * (__int64)a2[6]
+ 2 * *a2 * (__int64)a2[7];
v12 = (v14 >> 28)
+ (v13 >> 28)
+ a2[4] * (__int64)a2[4]
+ 2 * a2[3] * (__int64)a2[5]
+ 2 * a2[2] * (__int64)a2[6]
+ 2 * a2[1] * (__int64)a2[7];
v11 = (v12 >> 28) + 2 * a2[4] * (__int64)a2[5] + 2 * a2[3] * (__int64)a2[6] + 2 * a2[2] * (__int64)a2[7];
v10 = (v11 >> 28) + a2[5] * (__int64)a2[5] + 2 * a2[4] * (__int64)a2[6] + 2 * a2[3] * (__int64)a2[7];
v9 = (v10 >> 28) + 2 * a2[5] * (__int64)a2[6] + 2 * a2[4] * (__int64)a2[7];
v8 = (v9 >> 28) + a2[6] * (__int64)a2[6] + 2 * a2[5] * (__int64)a2[7];
v7 = (v8 >> 28) + 2 * a2[6] * (__int64)a2[7];
v6 = (v7 >> 28) + v5 - (v5 >> 28 << 28);
v4 = (v6 >> 28) + v3;
*a1 = (v4 >> 28) + v21 - ((unsigned int)(v21 >> 28) << 28);
a1[1] = v20 - ((unsigned int)(v20 >> 28) << 28);
a1[2] = v19 - ((unsigned int)(v19 >> 28) << 28);
a1[3] = v18 - ((unsigned int)(v18 >> 28) << 28);
a1[4] = v17 - ((unsigned int)(v17 >> 28) << 28);
a1[5] = v16 - ((unsigned int)(v16 >> 28) << 28);
a1[6] = v15 - ((unsigned int)(v15 >> 28) << 28);
a1[7] = v14 - ((unsigned int)(v14 >> 28) << 28);
a1[8] = (v4 >> 28) + v12 - ((unsigned int)(v12 >> 28) << 28);
a1[9] = v11 - ((unsigned int)(v11 >> 28) << 28);
a1[10] = v10 - ((unsigned int)(v10 >> 28) << 28);
a1[11] = v9 - ((unsigned int)(v9 >> 28) << 28);
a1[12] = v8 - ((unsigned int)(v8 >> 28) << 28);
a1[13] = v7 - ((unsigned int)(v7 >> 28) << 28);
a1[14] = v6 - ((unsigned int)(v6 >> 28) << 28);
result = a1 + 15;
a1[15] = v4 - ((unsigned int)(v4 >> 28) << 28);
return result;
}
Q:[a1,a2,v3,v6,v7,v8,v9,v10,v11,v12,v13,v14,v15,v16,v17,v18,v19,v20,v21,sub_4306EF,] | A:{'a1': 'r', 'a2': 'a', 'v3': 't15', 'v6': 't14', 'v7': 't13', 'v8': 't12', 'v9': 't11', 'v10': 't10', 'v11': 't9', 'v12': 't8', 'v13': 't307', 'v14': 't7', 'v15': 't6', 'v16': 't5', 'v17': 't4', 'v18': 't3', 'v19': 't2', 'v20': 't1', 'v21': 't0', 'sub_4306EF': 'fe448_sqr_8'} | |
819877a5309a852874e6ff60e55ac0b31c9d82ad9eca5ccd226cbb9e62c77eb8_819877a5309a852874e6ff60e55ac0b31c9d82ad9eca5ccd226cbb9e62c77eb8.jsonl.gz | sub_407A9D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_407A9D(__int64 a1, int a2, __int64 a3)
{
__int64 result; // rax
_BOOL4 v4; // edx
char *v5; // rax
char s[4096]; // [rsp+20h] [rbp-2040h] BYREF
__int64 v8[2]; // [rsp+1020h] [rbp-1040h] BYREF
char v9[4080]; // [rsp+1030h] [rbp-1030h] BYREF
int v10; // [rsp+202Ch] [rbp-34h]
_DWORD *v11; // [rsp+2030h] [rbp-30h]
__int64 v12; // [rsp+2038h] [rbp-28h]
char *v13; // [rsp+2040h] [rbp-20h]
int v14; // [rsp+2048h] [rbp-18h]
int v15; // [rsp+204Ch] [rbp-14h]
_BYTE *i; // [rsp+2050h] [rbp-10h]
_DWORD *v17; // [rsp+2058h] [rbp-8h]
v17 = 0LL;
v8[0] = 0LL;
v8[1] = 0LL;
memset(v9, 0, sizeof(v9));
v15 = 0;
v14 = 1;
if ( a2 <= 2 )
return sub_4035C3(
a1,
"wrong # args: should be \"%s\"",
"array exists|get|names|set|size|statistics arrayName ?arg ...?");
v12 = sub_4036B7(a1, *(char **)(a3 + 16), 0);
if ( v12 )
{
v11 = (_DWORD *)sub_4058BD();
if ( !v11 )
return sub_4035C3(a1, "expected pointer but got \"%s\"", *(const char **)(v12 + 16));
v17 = v11;
v14 = sub_405A62(a1, 2, (__int64)v11);
}
if ( **(_BYTE **)(a3 + 8) == 101 && !strcmp(*(const char **)(a3 + 8), "exists") )
{
v4 = v12 && v14;
sub_40311F(a1, "%d", v4);
return 0LL;
}
if ( (**(_BYTE **)(a3 + 8) != 103 || strcmp(*(const char **)(a3 + 8), "get"))
&& (**(_BYTE **)(a3 + 8) != 110 || strcmp(*(const char **)(a3 + 8), "names"))
&& (**(_BYTE **)(a3 + 8) != 115 || strcmp(*(const char **)(a3 + 8), "size")) )
{
if ( **(_BYTE **)(a3 + 8) == 115 && !strcmp(*(const char **)(a3 + 8), "set") )
{
if ( a2 != 4 )
return sub_4035C3(a1, "wrong # args: should be \"%s\"", "array set arrayName list");
if ( !v12 )
v17 = sub_406EE0(a1, *(char **)(a3 + 16));
for ( i = sub_4042B2(*(_BYTE **)(a3 + 24), (__int64)v8, 0x1000uLL); i; i = sub_4042B2(i, (__int64)v8, 0x1000uLL) )
{
i = sub_4042B2(i, (__int64)s, 0x1000uLL);
if ( !i )
return sub_403164(a1, "list must have an even number of elements");
if ( !v14 )
{
v10 = snprintf(s, 0x1000uLL, "%s(%s)", *(const char **)(a3 + 16), (const char *)v8);
if ( v10 >= 0 )
result = sub_4035C3(a1, "can't set \"%s\": variable isn't array", s);
else
result = sub_4035C3(a1, "can't set \"%s...\": variable isn't array", s);
return result;
}
sub_407715((__int64)v17, (char *)v8, s);
}
}
else
{
if ( **(_BYTE **)(a3 + 8) != 115 || strcmp(*(const char **)(a3 + 8), "statistics") )
return sub_4035C3(
a1,
"bad subcommand \"%s\": must be exists, get, set, size, or names",
*(const char **)(a3 + 8));
if ( a2 != 3 )
return sub_4035C3(a1, "wrong # args: should be \"%s\"", "array statistics arrname");
if ( !v12 || !v14 )
return sub_4035C3(a1, "\"%s\" isn't an array", *(const char **)(a3 + 16));
v5 = sub_4078C8((__int64)v17, (char *)v8, 0x1000uLL);
sub_4030E1(a1, v5);
}
return 0LL;
}
v13 = "*";
if ( v12 && v14 )
{
if ( **(_BYTE **)(a3 + 8) == 115 && !strcmp(*(const char **)(a3 + 8), "size") )
return sub_40311F(a1, "%d", v17[64]);
if ( a2 == 4 )
v13 = *(char **)(a3 + 24);
if ( **(_BYTE **)(a3 + 8) == 110 && !strcmp(*(const char **)(a3 + 8), "names") )
{
v15 = 1;
}
else if ( **(_BYTE **)(a3 + 8) == 103 && !strcmp(*(const char **)(a3 + 8), "get") )
{
v15 = 2;
}
else if ( a2 != 3 )
{
return sub_403164(a1, "usage: array get|names|size a");
}
if ( (unsigned int)sub_40729E((__int64)v17, v13, (char *)v8, 0x1000uLL, v15) )
return sub_403164(a1, "string too long");
sub_4030E1(a1, (const char *)v8);
return 0LL;
}
if ( **(_BYTE **)(a3 + 8) == 103 && !strcmp(*(const char **)(a3 + 8), "get")
|| **(_BYTE **)(a3 + 8) == 110 && !strcmp(*(const char **)(a3 + 8), "names") )
{
result = sub_4030E1(a1, &::s);
}
else
{
result = sub_40311F(a1, "%d", 0);
}
return result;
}
Q:[a3,a1,a2,s,v8,v11,v12,v13,v14,v15,i,v17,sub_407A9D,sub_4035C3,sub_4036B7,sub_4058BD,sub_405A62,sub_40311F,sub_406EE0,sub_4042B2,sub_403164,sub_407715,sub_4078C8,sub_4030E1,sub_40729E,] | A:{'a3': 'argv', 'a1': 'interp', 'a2': 'argc', 's': 'buf2', 'v8': 'buf', 'v11': '_p', 'v12': 'v', 'v13': 'pat', 'v14': 'valid', 'v15': 'mode', 'i': 'cp', 'v17': 'ap', 'sub_407A9D': 'picol_array', 'sub_4035C3': 'picolErrFmt', 'sub_4036B7': 'picolGetVar2', 'sub_4058BD': 'picolScanPtr', 'sub_405A62': 'picolValidPtr', 'sub_40311F': 'picolSetFmtResult', 'sub_406EE0': 'picolArrCreate', 'sub_4042B2': 'picolListHead', 'sub_403164': 'picolErr', 'sub_407715': 'picolArrSet', 'sub_4078C8': 'picolArrStat', 'sub_4030E1': 'picolSetResult', 'sub_40729E': 'picolArrGetAll'} | |
f85e671f468706ba8156699f38f281f602a807c8d4f0d4ee8d81959ff4573f3d_f85e671f468706ba8156699f38f281f602a807c8d4f0d4ee8d81959ff4573f3d.jsonl.gz | sub_405279 | Help user generate meaningful names for variables and functions in the following code snippet. |
char *__fastcall sub_405279(const char *a1, int a2)
{
char *dest; // [rsp+18h] [rbp-8h]
dest = (char *)calloc(1uLL, 0x158uLL);
if ( !dest )
return 0LL;
*((_DWORD *)dest + 84) = a2;
*((_QWORD *)dest + 36) = sub_40511C;
*((_QWORD *)dest + 34) = sub_405162;
*((_QWORD *)dest + 35) = sub_405221;
strncpy(dest, a1, 0x100uLL);
dest[255] = 0;
return dest;
}
Q:[a1,a2,dest,sub_405279,sub_40511C,sub_405162,sub_405221,] | A:{'a1': 'name', 'a2': 'delay', 'dest': 'res', 'sub_405279': 'resource_halt_open', 'sub_40511C': 'resource_halt_close', 'sub_405162': 'resource_halt_enable', 'sub_405221': 'resource_halt_disable'} | |
0d2339a86c5360b2903e326cf96aff1bba53a83010193cb8a761753fe9d96bbe_0d2339a86c5360b2903e326cf96aff1bba53a83010193cb8a761753fe9d96bbe.jsonl.gz | sub_4033B5 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4033B5(__int16 a1)
{
int v1; // eax
char v3[2]; // [rsp+1Eh] [rbp-2h] BYREF
v3[0] = HIBYTE(a1);
v3[1] = a1;
v1 = sub_401C4B((__int64)v3, 2);
return sub_401DD7(2 * v1 + 1);
}
Q:[a1,v3,sub_4033B5,sub_401C4B,sub_401DD7,] | A:{'a1': 'c', 'v3': 'res', 'sub_4033B5': 'sysItobin2', 'sub_401C4B': 'vmemAllocString', 'sub_401DD7': 'vmemPush'} | |
68eece29edec86fe51cb9da2a304caeab06c82737e887e77284167164d508312_68eece29edec86fe51cb9da2a304caeab06c82737e887e77284167164d508312.jsonl.gz | sub_4341C0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4341C0(__int64 a1, _DWORD *a2, _DWORD *a3)
{
std::invalid_argument *v3; // rbp
int v6; // ebp
unsigned __int8 v7; // al
unsigned __int8 v8; // r15
int v9; // er12
__int64 v10; // rax
unsigned __int64 v11; // rbp
unsigned __int8 v12; // cl
_DWORD *v13; // rax
_DWORD *v14; // rsi
__int16 v15; // dx
_DWORD *v16; // rax
int v17; // edx
_DWORD *v18; // rax
__int64 v19; // rax
__int64 v20; // rdx
unsigned __int8 v21; // r8
__int64 v22; // rsi
__int16 v23; // ax
int v24; // eax
__int64 v25; // rsi
int v26; // esi
__int64 result; // rax
unsigned __int64 v28; // rbp
unsigned __int64 v29; // rdx
char v30; // dl
__int64 v31; // [rsp+0h] [rbp-58h]
unsigned __int8 v32; // [rsp+Fh] [rbp-49h]
unsigned __int8 v33; // [rsp+Fh] [rbp-49h]
int v34; // [rsp+18h] [rbp-40h] BYREF
__int16 v35; // [rsp+1Ch] [rbp-3Ch]
v6 = a3[2] - *a3;
if ( a2[2] - *a2 < v6 )
v6 = a2[2] - *a2;
v7 = sub_42F380(a1);
if ( v6 > 0 )
{
v8 = v7;
v9 = 1 << v7;
v10 = v6;
v11 = 0LL;
v31 = v10;
while ( *((_QWORD *)a3 + 1) - *(_QWORD *)a3 > v11 )
{
v12 = *(_BYTE *)(*(_QWORD *)a3 + v11);
if ( v8 > 0x1Fu || v12 > 0x1Fu )
{
LABEL_26:
v3 = (std::invalid_argument *)__cxa_allocate_exception(0x10uLL);
std::invalid_argument::invalid_argument(v3, "invalid register number");
__cxa_throw(
v3,
(struct type_info *)&`typeinfo for'std::invalid_argument,
std::invalid_argument::~invalid_argument);
}
v13 = *(_DWORD **)(a1 + 8);
v14 = *(_DWORD **)(a1 + 16);
v34 = 34;
LOBYTE(v15) = v8;
HIBYTE(v15) = v12;
v35 = v8;
if ( v13 == v14 )
{
v32 = v12;
sub_43A300(a1, v14, &v34);
v16 = *(_DWORD **)(a1 + 8);
v14 = *(_DWORD **)(a1 + 16);
v12 = v32;
}
else
{
*v13 = 34;
v16 = v13 + 2;
*((_WORD *)v16 - 2) = v15;
*(_QWORD *)(a1 + 8) = v16;
}
v17 = *(_DWORD *)(a1 + 76);
v34 = 13;
v35 = v8;
*(_DWORD *)(a1 + 76) = v9 | v17 | (1 << v12);
if ( v14 == v16 )
{
sub_43A300(a1, v14, &v34);
}
else
{
*v16 = 13;
v18 = v16 + 2;
*((_BYTE *)v18 - 4) = v8;
*((_BYTE *)v18 - 3) = 0;
*(_QWORD *)(a1 + 8) = v18;
}
v19 = *(_QWORD *)a2;
v20 = *((_QWORD *)a2 + 1);
*(_DWORD *)(a1 + 76) |= v9;
if ( v20 - v19 <= v11 )
break;
v21 = *(_BYTE *)(v19 + v11);
if ( v21 > 0x1Fu )
goto LABEL_26;
v34 = 19;
v22 = *(_QWORD *)(a1 + 8);
LOBYTE(v23) = v21;
HIBYTE(v23) = v8;
v35 = v21;
if ( v22 == *(_QWORD *)(a1 + 16) )
{
v33 = v21;
sub_43A300(a1, v22, &v34);
v26 = ++v11;
*(_DWORD *)(a1 + 76) |= v9 | (1 << v33);
if ( v31 == v11 )
goto LABEL_16;
}
else
{
*(_WORD *)(v22 + 4) = v23;
v24 = *(_DWORD *)(a1 + 76);
v25 = v22 + 8;
*(_DWORD *)(v25 - 8) = 19;
*(_QWORD *)(a1 + 8) = v25;
v26 = ++v11;
*(_DWORD *)(a1 + 76) = v9 | v24 | (1 << v21);
if ( v11 == v31 )
goto LABEL_16;
}
}
LABEL_25:
std::__throw_out_of_range_fmt("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)");
}
v26 = 0;
LABEL_16:
result = *(_QWORD *)a2;
v28 = v26;
v29 = *((_QWORD *)a2 + 1) - *(_QWORD *)a2;
if ( v26 < (int)v29 )
{
while ( v29 > v28 )
{
v30 = *(_BYTE *)(result + v28++);
sub_434120(a1, 13, v30);
result = *(_QWORD *)a2;
v29 = *((_QWORD *)a2 + 1) - *(_QWORD *)a2;
if ( (int)v28 >= (int)v29 )
return result;
}
goto LABEL_25;
}
return result;
}
Q:[a1,sub_4341C0,sub_42F380,sub_43A300,sub_434120,] | A:{'a1': 'this', 'sub_4341C0': 'logxor_not', 'sub_42F380': 'tempreg', 'sub_43A300': '_M_realloc_insert', 'sub_434120': 'onereg'} | |
f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83_f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83.jsonl.gz | sub_42BF18 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42BF18(__int64 a1, __int64 a2)
{
unsigned int v3; // [rsp+10h] [rbp-10h]
if ( *(_BYTE *)(a2 + 48) == 4 && *(_QWORD *)(a1 + 208) )
{
*(_DWORD *)(a2 + 40) = *(_DWORD *)(*(_QWORD *)(a1 + 208) + 4LL * *(int *)(a2 + 40));
*(_QWORD *)(a1 + 144) |= 1 << *(_DWORD *)(a2 + 40);
}
else if ( *(_BYTE *)(a2 + 48) == 17 && *(_QWORD *)(a2 + 8) && *(_BYTE *)(*(_QWORD *)(a2 + 8) + 48LL) == 17 )
{
v3 = *(_DWORD *)(*(_QWORD *)(a2 + 8) + 40LL);
*(_QWORD *)(a2 + 8) = *(_QWORD *)(*(_QWORD *)(a2 + 8) + 8LL);
if ( *(_QWORD *)(a2 + 8) )
**(_QWORD **)(a2 + 8) = a2;
*(_DWORD *)(4LL * (int)v3 + *(_QWORD *)(a1 + 208)) = *(_DWORD *)(*(_QWORD *)(a1 + 208) + 4LL * *(int *)(a2 + 40));
if ( v3 <= 0x3F )
*(_QWORD *)(a1 + 144) &= ~(1LL << v3);
}
return 0LL;
}
Q:[a1,a2,v3,sub_42BF18,] | A:{'a1': 'extra', 'a2': 'node', 'v3': 'other_idx', 'sub_42BF18': 'optimize_subexps'} | |
e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433_e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433.jsonl.gz | sub_41C8DA | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41C8DA(__int64 a1, __int64 a2, unsigned int a3)
{
sub_41D4F2(a1);
sub_41D3C0(a1 + 16, a1);
*(_QWORD *)a1 = off_45A4B8;
*(_QWORD *)(a1 + 16) = off_45A508;
sub_41D6CC(a1 + 32);
*(_DWORD *)(a1 + 48) = 0;
return sub_41C99E(a1, a2, a3);
}
Q:[a1,sub_41C8DA,sub_41D4F2,sub_41D3C0,sub_41D6CC,sub_41C99E,] | A:{'a1': 'this', 'sub_41C8DA': 'UnmappedDataSource', 'sub_41D4F2': 'DataSource', 'sub_41D3C0': 'Segment', 'sub_41D6CC': 'smart_array_ptr', 'sub_41C99E': 'setData'} | |
d38b641159c9df1b4688a4c8c8443c8c7907254ac799e9fb8b49a100c919ec59_d38b641159c9df1b4688a4c8c8443c8c7907254ac799e9fb8b49a100c919ec59.jsonl.gz | sub_40D444 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40D444(__int64 a1, __int64 a2)
{
__int64 v2; // rcx
__int64 v3; // r8
__int64 v4; // r9
__int64 result; // rax
__int64 v6; // rdx
__int64 v7; // rcx
__int64 v8; // r8
__int64 v9; // r9
__int64 v10; // rdx
__int64 v11; // rcx
__int64 v12; // r8
__int64 v13; // r9
__int64 v14; // rcx
__int64 v15; // r8
__int64 v16; // r9
_QWORD *v17; // rbx
_QWORD *v18; // rbx
__int64 v19; // [rsp+18h] [rbp-38h]
int v20; // [rsp+24h] [rbp-2Ch]
unsigned __int8 *v21; // [rsp+28h] [rbp-28h]
unsigned __int8 v22; // [rsp+33h] [rbp-1Dh]
int v23; // [rsp+34h] [rbp-1Ch]
__int64 v24; // [rsp+38h] [rbp-18h]
if ( *(_BYTE *)qword_47F240 == 34 )
v24 = qword_47F240 + 1;
else
v24 = qword_47F240;
v22 = sub_407391();
v21 = (unsigned __int8 *)qword_47F240;
*(_BYTE *)qword_47F240 = v22;
if ( *(_BYTE *)qword_47F240 == 32 )
++qword_47F240;
if ( *(_BYTE *)qword_47F240 == 44 )
{
++qword_47F240;
v20 = sub_40FFBE();
if ( v20 >= 0 )
{
v23 = 0;
if ( *(_BYTE *)qword_47F240 == 44 )
{
++qword_47F240;
v23 = sub_40FFBE();
if ( v23 <= 15 )
{
if ( v23 < 0 )
{
sub_40B288("Alignment negative. 0 assumed.", a2, v10, v11, v12, v13);
v23 = 0;
}
}
else
{
a2 = 15LL;
sub_40B288("Alignment too large: %d. assumed.", 15LL, v10, v11, v12, v13);
v23 = 15;
}
}
*v21 = 0;
v19 = sub_413686(v24);
*v21 = v22;
if ( (*(_BYTE *)(v19 + 4) & 0xE) != 0 || *(_DWORD *)(v19 + 8) )
{
sub_40B577("Ignoring attempt to re-define symbol.", a2, v22, v14, v15, v16);
}
else
{
if ( !qword_47F3E0 )
{
qword_47F3E0 = sub_41206F("__DATA", "__bss", 1LL, 0LL, 0LL);
v17 = (_QWORD *)qword_47F3E0;
*v17 = sub_4163F6(80LL);
memset(*(void **)qword_47F3E0, 0, 0x50uLL);
*(_QWORD *)(qword_47F3E0 + 8) = *(_QWORD *)qword_47F3E0;
}
v18 = *(_QWORD **)qword_47F3E0;
*v18 = sub_44C0C6(**(_QWORD **)qword_47F3E0, 1 << v23);
*(_DWORD *)(v19 + 8) = **(_QWORD **)qword_47F3E0;
*(_BYTE *)(v19 + 4) = 14;
*(_BYTE *)(v19 + 5) = *(_DWORD *)(qword_47F3E0 + 92);
*(_QWORD *)(v19 + 64) = *(_QWORD *)qword_47F3E0;
**(_QWORD **)qword_47F3E0 += v20;
if ( *(_DWORD *)(qword_47F3E0 + 68) < (unsigned int)v23 )
*(_DWORD *)(qword_47F3E0 + 68) = v23;
}
result = sub_40ED36();
}
else
{
sub_40B577("BSS length (%u.) <0! Ignored.", (unsigned int)v20, v6, v7, v8, v9);
result = sub_40EDA2();
}
}
else
{
sub_40B577("Expected comma after name", a2, v22, v2, v3, v4);
result = sub_40EDA2();
}
return result;
}
Q:[a1,v19,v20,v21,v22,v23,v24,sub_40D444,sub_407391,sub_40FFBE,sub_40B288,sub_413686,sub_40B577,sub_41206F,sub_4163F6,sub_44C0C6,sub_40ED36,sub_40EDA2,] | A:{'a1': 'value', 'v19': 'symbolP', 'v20': 'size', 'v21': 'p', 'v22': 'c', 'v23': 'align', 'v24': 'name', 'sub_40D444': 's_lcomm', 'sub_407391': 'get_symbol_end', 'sub_40FFBE': 'get_absolute_expression', 'sub_40B288': 'as_warn', 'sub_413686': 'symbol_find_or_make', 'sub_40B577': 'as_bad', 'sub_41206F': 'section_new', 'sub_4163F6': 'xmalloc', 'sub_44C0C6': 'rnd', 'sub_40ED36': 'demand_empty_rest_of_line', 'sub_40EDA2': 'ignore_rest_of_line'} | |
f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83_f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83.jsonl.gz | sub_494B5A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_494B5A(_DWORD *a1)
{
__int64 v1; // rdx
__int64 v2; // rcx
__int64 v3; // r8
__int64 v4; // r9
memset(a1, 0, 0x158uLL);
sub_47ADCC(a1);
a1[10] |= 1u;
v1 = a1[11] | 1u;
a1[11] = v1;
sub_47AF14((__int64)a1, 0LL, v1, v2, v3, v4);
return 0LL;
}
Q:[a1,sub_494B5A,sub_47ADCC,sub_47AF14,] | A:{'a1': 'ids', 'sub_494B5A': 'init_patch_ids', 'sub_47ADCC': 'diff_setup', 'sub_47AF14': 'diff_setup_done'} | |
7081e45cc9c4fbe9cf3486887760c2a5d1804b34cd8c38ec851c47429d0144e8_7081e45cc9c4fbe9cf3486887760c2a5d1804b34cd8c38ec851c47429d0144e8.jsonl.gz | sub_40E1B7 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40E1B7(int a1, int a2, __int64 a3)
{
int v4; // [rsp+1Ch] [rbp-4h] BYREF
v4 = a2;
return sub_40E07C(a1, 1, &v4, a3, 0LL);
}
Q:[a3,a1,a2,v4,sub_40E1B7,sub_40E07C,] | A:{'a3': 'left', 'a1': 'op', 'a2': 'n', 'v4': 'a', 'sub_40E1B7': 'mkunop1', 'sub_40E07C': 'mknode'} | |
d6f1c4fccbb8fc2066c0c7749389636df7b33c67e152dc8852a86b3a79bd4c3d_d6f1c4fccbb8fc2066c0c7749389636df7b33c67e152dc8852a86b3a79bd4c3d.jsonl.gz | sub_521104 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_521104(__int64 a1, __int64 a2, unsigned int a3)
{
__int64 v3; // rax
__int64 v4; // rcx
__int64 v5; // r8
__int64 v6; // r9
v3 = (*(__int64 (__fastcall **)(__int64, _QWORD))(a1 + 40))(a1, a3);
return sub_404774(a2, v3, v3, v4, v5, v6);
}
Q:[a3,a1,a2,sub_521104,sub_404774,] | A:{'a3': 'reg', 'a1': 'handle', 'a2': 'OS', 'sub_521104': 'printRegName_4', 'sub_404774': 'SStream_concat'} | |
16265d36e785b01ab7c4f58b3656e0c6d08390a77bbd0bef82e61eaee743327b_16265d36e785b01ab7c4f58b3656e0c6d08390a77bbd0bef82e61eaee743327b.jsonl.gz | sub_4101E1 | Help user generate meaningful names for variables and functions in the following code snippet. |
__pid_t __fastcall sub_4101E1(Window *a1)
{
__int64 v1; // rax
*(_BYTE *)(a1[47] + 2) = *(_BYTE *)(a1[47] + 2) == 0;
if ( *(_BYTE *)(a1[47] + 2) )
v1 = qword_424068;
else
v1 = qword_424070;
return sub_40E847(a1, v1, dword_423FA8, 0);
}
Q:[a1,sub_4101E1,sub_40E847,] | A:{'a1': 'c', 'sub_4101E1': 'client_toggle_hlock', 'sub_40E847': 'client_flash'} | |
3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33_3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33.jsonl.gz | sub_43EA1F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43EA1F(__int64 a1)
{
__int64 v2; // [rsp+8h] [rbp-20h]
char *v3; // [rsp+10h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-Ch]
char *v5; // [rsp+20h] [rbp-8h]
v3 = *(char **)(a1 + 8);
v5 = v3;
if ( v3 )
{
do
{
for ( i = 0; i < *v5; ++i )
{
v2 = *(_QWORD *)&v5[8 * i + 24];
if ( (!v5[1] || v2) && v2 )
return *(_QWORD *)&v5[8 * i + 24];
}
v5 = (char *)*((_QWORD *)v5 + 2);
}
while ( v5 != v3 );
}
return 0LL;
}
Q:[a1,v2,v3,i,v5,sub_43EA1F,] | A:{'a1': 'p', 'v2': 'pu', 'v3': '__headpu', 'i': '__nrpu', 'v5': '__listpu', 'sub_43EA1F': 'first_user'} | |
448d64472cd235d309b0787287aae4b43df6af9375d1a6596bb8fa1c593df428_448d64472cd235d309b0787287aae4b43df6af9375d1a6596bb8fa1c593df428.jsonl.gz | sub_432890 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 __fastcall sub_432890(__int64 a1, char **a2)
{
return (int)sub_4323D0(a1, a2) >= 0;
}
Q:[a1,sub_432890,sub_4323D0,] | A:{'a1': 'this', 'sub_432890': 'containsWholeWordIgnoreCase', 'sub_4323D0': 'indexOfWholeWordIgnoreCase'} | |
614f31b237021943f00edd1722efa5c25b232a880ba0ce0b95bc8b4ce694ebc2_614f31b237021943f00edd1722efa5c25b232a880ba0ce0b95bc8b4ce694ebc2.jsonl.gz | sub_418AA9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_418AA9(__int64 a1)
{
__int64 v1; // rax
__int16 v3; // [rsp+18h] [rbp-18h]
sub_4125D6(a1, (_BYTE *)(a1 + 225));
v3 = (*(unsigned __int8 *)(a1 + *(unsigned __int16 *)(a1 + 2332) + 2 + 224) << 8) | *(unsigned __int8 *)(a1 + *(unsigned __int16 *)(a1 + 2332) + 1 + 224) | sub_412728(a1);
sub_4128F4(a1, v3);
sub_412AC8(a1, v3);
if ( *(_DWORD *)(a1 + 2312) )
v1 = 17LL;
else
v1 = 4LL;
*(_QWORD *)(a1 + 2336) += v1;
return (unsigned int)*(unsigned __int16 *)(a1 + 2332) + 3;
}
Q:[a1,v3,sub_418AA9,sub_4125D6,sub_412728,sub_4128F4,sub_412AC8,] | A:{'a1': 'c', 'v3': 'd', 'sub_418AA9': 'op_81_01', 'sub_4125D6': 'e86_get_ea_ptr', 'sub_412728': 'e86_get_ea16', 'sub_4128F4': 'e86_set_ea16', 'sub_412AC8': 'e86_set_flg_log_16'} | |
f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83_f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83.jsonl.gz | sub_472D63 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_472D63(char *a1, char *a2)
{
__int64 v2; // rcx
__int64 v3; // r8
__int64 v4; // r9
__int64 v5; // rdx
__int64 v6; // rcx
__int64 v7; // r8
__int64 v8; // r9
__int64 v10[3]; // [rsp+10h] [rbp-20h] BYREF
int v11; // [rsp+28h] [rbp-8h]
unsigned int v12; // [rsp+2Ch] [rbp-4h]
v12 = sub_455FE1(a1, 0LL, 0LL, 1);
v11 = sub_455FE1(a2, 0LL, 0LL, 1);
v10[0] = 0LL;
v10[1] = 0LL;
v10[2] = (__int64)&unk_4FCB21;
if ( v12 + v11 )
{
sub_471E91((__int64)v10, 34, v12, v2, v3, v4);
sub_455FE1(a1, v10, 0LL, 1);
sub_455FE1(a2, v10, 0LL, 1);
sub_471E91((__int64)v10, 34, v5, v6, v7, v8);
}
else
{
sub_471EEE(v10, a1);
sub_471EEE(v10, a2);
}
return sub_406F0C(v10, 0LL);
}
Q:[a1,a2,v10,v11,v12,sub_472D63,sub_455FE1,sub_471E91,sub_471EEE,sub_406F0C,] | A:{'a1': 'one', 'a2': 'two', 'v10': 'res', 'v11': 'need_two', 'v12': 'need_one', 'sub_472D63': 'quote_two', 'sub_455FE1': 'quote_c_style', 'sub_471E91': 'strbuf_addch_22', 'sub_471EEE': 'strbuf_addstr_23', 'sub_406F0C': 'strbuf_detach'} | |
e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433_e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433.jsonl.gz | sub_44F844 | Help user generate meaningful names for variables and functions in the following code snippet. |
_QWORD *__fastcall sub_44F844(__int64 a1)
{
*(_QWORD *)a1 = off_45FB18;
if ( *(_QWORD *)(a1 + 40) )
operator delete[](*(void **)(a1 + 40));
return sub_44F570((_QWORD *)a1);
}
Q:[a1,sub_44F844,sub_44F570,] | A:{'a1': 'this', 'sub_44F844': '~OptStrTokIter', 'sub_44F570': '~OptIterRwd'} | |
59e38d28aabe42db81b9a29bf97cdbff97200e90593c16b1ecf0d6253ce280e0_59e38d28aabe42db81b9a29bf97cdbff97200e90593c16b1ecf0d6253ce280e0.jsonl.gz | sub_4044F7 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4044F7(__int64 a1)
{
while ( a1 && !sub_404462(a1) )
a1 = *(_QWORD *)(a1 + 344);
return a1;
}
Q:[a1,sub_4044F7,sub_404462,] | A:{'a1': 'c', 'sub_4044F7': 'nextvisible', 'sub_404462': 'isvisible'} | |
a1bc81a374b357fb421be338241550f3799adf0054742df0bfa64e77b75402ce_a1bc81a374b357fb421be338241550f3799adf0054742df0bfa64e77b75402ce.jsonl.gz | sub_40AE90 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int16 __fastcall sub_40AE90(int a1, int a2)
{
__int64 v2; // rax
__int64 v3; // rbx
int v4; // er13
int v6; // ebp
bool v7; // dl
int v8; // er14
_WORD *v9; // r15
_WORD *v10; // rax
__int16 *v11; // rsi
_WORD *v12; // rdx
_WORD *v13; // rdi
LOWORD(v2) = qword_4174F8;
v3 = *(__int16 *)(qword_4174F8 + 2LL * a1);
v4 = *(__int16 *)(qword_4174F8 + 2LL * a1 + 2);
if ( (__int16)v3 < *(__int16 *)(qword_4174F8 + 2LL * a1 + 2) )
{
v2 = *(__int16 *)(qword_4174F8 + 2LL * a1);
v6 = 0;
do
{
v7 = *((__int16 *)qword_4174E8 + v2++) != a2;
v6 += v7;
}
while ( v4 > (int)v2 );
if ( v6 )
{
v8 = a1 - dword_4177BC + dword_4175A4;
v9 = sub_4070B0((unsigned int)(2 * v6));
*((_QWORD *)qword_417868 + v8) = v9;
v10 = sub_4070B0((unsigned int)(2 * v6));
*((_QWORD *)qword_417860 + v8) = v10;
v11 = (__int16 *)qword_4174E8;
v12 = v9;
v13 = qword_4174F0;
do
{
if ( v11[v3] != a2 )
{
++v10;
*v12++ = v13[v3];
*(v10 - 1) = v11[v3];
}
++v3;
}
while ( v4 > (int)v3 );
*(_WORD *)(qword_417858 + 2LL * v8) = v6;
LOWORD(v2) = *(v12 - 1) + 1 - *v9;
*(_WORD *)(qword_417850 + 2LL * v8) = v2;
}
}
return v2;
}
Q:[a1,a2,sub_40AE90,sub_4070B0,] | A:{'a1': 'symbol', 'a2': 'default_state', 'sub_40AE90': 'save_column', 'sub_4070B0': 'xmalloc'} | |
29a8c6141bed2cb4f15a2da179d03cd547aa10a3dff0d928d84a39d36622e119_29a8c6141bed2cb4f15a2da179d03cd547aa10a3dff0d928d84a39d36622e119.jsonl.gz | sub_40773B | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40773B(__int64 a1, unsigned int a2, __int64 a3)
{
unsigned int *v3; // rax
__int64 result; // rax
__int64 v6; // [rsp+26h] [rbp-12h] BYREF
__int16 v7; // [rsp+2Eh] [rbp-Ah]
v6 = 0LL;
v7 = 0;
if ( (unsigned int)sub_404BC8(a1, a2, (__int64)&v6) == -1 )
{
if ( !sub_40705A((__int64)&v6, a3) )
{
fprintf(stderr, "%s:%d: Tag %u - value mismatch: timestamps\n", "test/test_utils.c", 202LL, a2);
fflush(stderr);
result = 0LL;
}
else
{
result = 1LL;
}
}
else
{
v3 = (unsigned int *)sub_40266B(a1);
sub_407240(v3, "test/test_utils.c", 0xC9u);
result = 0LL;
}
return result;
}
Q:[v3,] | A:{'v3': 'result'} | |
477af4d40069544556e623d88d3014d4e0d738c019c3c162fcda139de2d22397_477af4d40069544556e623d88d3014d4e0d738c019c3c162fcda139de2d22397.jsonl.gz | sub_415671 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_415671(__int64 a1, __int64 a2, __int64 a3)
{
return sub_415B08(a1, a2, a3);
}
Q:[a3,a1,a2,sub_415671,sub_415B08,] | A:{'a3': '__result', 'a1': '__first', 'a2': '__last', 'sub_415671': '__copy_move_a1', 'sub_415B08': '__copy_move_a2'} | |
10b6f490e402a48bbb0b312acbdf9a1c623841c47b052e026d9cf82e12b1a981_10b6f490e402a48bbb0b312acbdf9a1c623841c47b052e026d9cf82e12b1a981.jsonl.gz | sub_408130 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_408130(unsigned int a1, __int64 a2, __int64 a3, char *a4)
{
unsigned int v4; // edi
unsigned int v5; // esi
int v8; // [rsp+24h] [rbp-Ch]
const char *v9; // [rsp+28h] [rbp-8h]
v9 = "MUL";
v8 = (HIWORD(a1) & 0x70) + ((unsigned __int8)a1 >> 4);
if ( v8 == 96 )
goto LABEL_11;
if ( v8 > 96 )
return 0xFFFFFFFFLL;
if ( v8 == 64 )
{
LABEL_11:
v9 = (const char *)&off_40C924;
goto LABEL_12;
}
if ( v8 > 64 )
return 0xFFFFFFFFLL;
if ( v8 != 63 )
{
if ( v8 == 32 )
goto LABEL_12;
if ( v8 <= 32 )
{
if ( v8 )
{
if ( v8 != 31 )
return 0xFFFFFFFFLL;
goto LABEL_16;
}
LABEL_12:
if ( (((BYTE2(a1) & 0x70) + ((unsigned __int8)a1 >> 4)) & 0x20) != 0 )
v4 = 85;
else
v4 = 83;
sprintf(
a4,
"%c%sL\tr%d, r%d, r%d, r%d",
v4,
v9,
(unsigned __int16)a1 >> 12,
(a1 >> 8) & 0xF,
HIWORD(a1) & 0xF,
a1 & 0xF);
return 0LL;
}
return 0xFFFFFFFFLL;
}
LABEL_16:
if ( (((BYTE2(a1) & 0x70) + ((unsigned __int8)a1 >> 4)) & 0x20) != 0 )
v5 = 85;
else
v5 = 83;
sprintf(a4, "%cDIV\tr%d, r%d, r%d", v5, (a1 >> 8) & 0xF, HIWORD(a1) & 0xF, a1 & 0xF);
return 0LL;
}
Q:[a4,a1,a2,a3,v8,v9,sub_408130,] | A:{'a4': 'cp', 'a1': 'opcode', 'a2': 'address', 'a3': 'instruction', 'v8': 'op', 'v9': 'infix', 'sub_408130': 't2ev_mul64_div'} | |
d6f1c4fccbb8fc2066c0c7749389636df7b33c67e152dc8852a86b3a79bd4c3d_d6f1c4fccbb8fc2066c0c7749389636df7b33c67e152dc8852a86b3a79bd4c3d.jsonl.gz | sub_434C7B | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_434C7B(__int64 a1, int a2, int a3)
{
if ( a2 == 1 )
*(_DWORD *)(a1 + 104) = a3;
if ( a2 == 3 )
*(_DWORD *)(a1 + 4) = a3;
return 0LL;
}
Q:[a3,a1,a2,sub_434C7B,] | A:{'a3': 'value', 'a1': 'handle', 'a2': 'type', 'sub_434C7B': 'PPC_option'} | |
c0889e43b9fb99e0a15d5a45e58572120bf2a06ee20b165810a3d68c382cd705_c0889e43b9fb99e0a15d5a45e58572120bf2a06ee20b165810a3d68c382cd705.jsonl.gz | sub_42BFEF | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42BFEF(__int64 a1, unsigned __int64 a2, unsigned __int64 a3)
{
++qword_4EA340;
sub_4164F1(
a1,
a2,
a3,
40LL,
(void (__fastcall *)(__int64, unsigned __int64))sub_42B91E,
(void (__fastcall *)(unsigned __int64, _QWORD))sub_42BA66);
return ++qword_4EA348;
}
Q:[a3,a1,a2,sub_42BFEF,sub_4164F1,sub_42B91E,sub_42BA66,] | A:{'a3': 'repeated_p', 'a1': 'decoder_p', 'a2': 'repeated_info_p', 'sub_42BFEF': 'repeated_bar_decode_repeated_inner', 'sub_4164F1': 'pbtools_decode_repeated_inner', 'sub_42B91E': 'repeated_bar_init', 'sub_42BA66': 'repeated_bar_decode_inner'} | |
e383fe03736d1eaf3ceba98645dff20ac6cac08e2f118d53c65088bedac57c93_e383fe03736d1eaf3ceba98645dff20ac6cac08e2f118d53c65088bedac57c93.jsonl.gz | sub_404B4A | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_404B4A()
{
;
}
Q:[sub_404B4A,] | A:{'sub_404B4A': 'msg_init'} | |
532441bb48224b1f851737c102ee0a246e6bf5bdf16bf8374a8a4cca1d0f7c02_532441bb48224b1f851737c102ee0a246e6bf5bdf16bf8374a8a4cca1d0f7c02.jsonl.gz | sub_402EED | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_402EED(__int64 a1, __int64 a2)
{
char *v2; // rax
struct in_addr in; // [rsp+14h] [rbp-2Ch]
unsigned __int16 v5; // [rsp+2Ch] [rbp-14h]
unsigned __int16 v6; // [rsp+2Eh] [rbp-12h]
_BYTE *v7; // [rsp+30h] [rbp-10h]
unsigned __int16 v8; // [rsp+3Eh] [rbp-2h]
v7 = (_BYTE *)(*(_QWORD *)(a1 + 8) + dword_4091D0 + a2);
v6 = *v7++ & 0xF;
v5 = (unsigned __int8)*v7++;
ntohs(*(_WORD *)v7);
in.s_addr = *(_DWORD *)(v7 + 2);
sprintf(byte_41DAA0, " IGMP HEADER:\n");
strcat(&dest, byte_41DAA0);
if ( v6 == 1 || v6 == 2 )
v8 = 1;
else
v8 = 2;
sprintf(byte_41DAA0, " IGMP Version = %d\n IGMP Type = %s\n", v8, (const char *)*(&off_4099E0 + v6));
strcat(&dest, byte_41DAA0);
if ( v8 == 2 )
{
sprintf(byte_41DAA0, " Max Resp Time = %d\n", v5);
strcat(&dest, byte_41DAA0);
}
v2 = inet_ntoa(in);
sprintf(byte_41DAA0, " IGMP Grp Addr = %s\n", v2);
strcat(&dest, byte_41DAA0);
return 8LL;
}
Q:[a1,a2,in,v5,v6,v7,v8,sub_402EED,] | A:{'a1': 'wsabuf', 'a2': 'iphdrlen', 'in': 'addr_4', 'v5': 'maxresptime', 'v6': 'type', 'v7': 'hdr', 'v8': 'version', 'sub_402EED': 'DecodeIGMPHeader'} | |
2ceb4cf63507b31e6145cd5d625836ecdebe294165368349fcf0c702c8796756_2ceb4cf63507b31e6145cd5d625836ecdebe294165368349fcf0c702c8796756.jsonl.gz | sub_4022CB | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4022CB(__int64 a1, unsigned __int8 a2)
{
sub_402112(a1, a2 >> 4, 1);
return sub_402112(a1, a2, 0);
}
Q:[a1,a2,sub_4022CB,sub_402112,] | A:{'a1': 'g', 'a2': 'data', 'sub_4022CB': 'do_fast_write_async', 'sub_402112': 'do_write_async'} | |
b86008a082e6b7238fc7a1d92205a52c2ebbc3c563127a4856bacedddc645305_b86008a082e6b7238fc7a1d92205a52c2ebbc3c563127a4856bacedddc645305.jsonl.gz | sub_407345 | Help user generate meaningful names for variables and functions in the following code snippet. |
_WORD *__fastcall sub_407345(_QWORD *a1, _WORD *a2)
{
__int64 v2; // rsi
__int64 v3; // rax
_WORD *s; // [rsp+18h] [rbp-8h]
if ( a1[5] >= *a1 )
__assert_fail("FlowIndex->FlowCntSnapshot < FlowIndex->FlowMax", "flow.c", 0x183u, "FlowAlloc");
v2 = a1[1];
v3 = a1[5];
a1[5] = v3 + 1;
s = (_WORD *)(v2 + 255 * v3);
memset(s, 0, 0xFFuLL);
memcpy(s, a2, 0x31uLL);
*(_WORD *)((char *)s + 101) = *(_WORD *)((char *)a2 + 101);
*(_WORD *)((char *)s + 103) = *(_WORD *)((char *)a2 + 103);
s[48] = a2[48];
return s;
}
Q:[a1,a2,s,sub_407345,] | A:{'a1': 'FlowIndex', 'a2': 'F', 's': 'Flow', 'sub_407345': 'FlowAlloc'} | |
decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08_decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08.jsonl.gz | ins__is_jump | Help user generate meaningful names for variables and functions in the following code snippet. |
bool __fastcall ins__is_jump(__int64 a1)
{
return *(_QWORD *)(a1 + 8) == (_QWORD)&unk_55C200;
}
Q:[a1,] | A:{'a1': 'ins'} | |
542b936b32dd37a8461a39e879d7b9f417b62c30ed5f1ea47c21ec23ed56033a_542b936b32dd37a8461a39e879d7b9f417b62c30ed5f1ea47c21ec23ed56033a.jsonl.gz | sub_406A48 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_406A48(__int64 a1, __int64 a2)
{
__int64 result; // rax
char s[6240]; // [rsp+10h] [rbp-1860h] BYREF
memset(s, 0, 0x1858uLL);
if ( !_setjmp((struct __jmp_buf_tag *)(a1 + 64)) )
{
sub_403D88();
result = *(unsigned int *)(a1 + 36);
if ( !(_DWORD)result )
return result;
*(_BYTE *)(a1 + 56) = 1;
sub_406B4C(a1, s, *(_QWORD *)(a2 + 8));
}
if ( *(_BYTE *)(a1 + 56) )
sub_403D9B(a1, (__int64)s);
return sub_402BAC((unsigned __int8 *)a1);
}
Q:[a1,a2,s,sub_406A48,sub_403D88,sub_406B4C,sub_403D9B,] | A:{'a1': '_metadata', 'a2': 'variant', 's': 'self', 'sub_406A48': 'wrapper_enclave_tcs_entry', 'sub_403D88': 'enclave_setup', 'sub_406B4C': 'enclave_tcs_entry', 'sub_403D9B': 'enclave_teardown'} | |
251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651_251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651.jsonl.gz | sub_40E529 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40E529(__int64 a1, __int64 a2)
{
__int64 v3; // [rsp+8h] [rbp-8h] BYREF
v3 = a1;
sub_40EC21(&v3);
return sub_40EC2B(v3, a2);
}
Q:[a1,a2,v3,sub_40E529,sub_40EC21,sub_40EC2B,] | A:{'a1': '__first', 'a2': '__last', 'v3': '__firsta', 'sub_40E529': 'distance', 'sub_40EC21': '__iterator_category', 'sub_40EC2B': '__distance'} | |
c518bc3ec7ac1de5c9ce166122c3a25fdcee604b732539449a3c567eb8a11f73_c518bc3ec7ac1de5c9ce166122c3a25fdcee604b732539449a3c567eb8a11f73.jsonl.gz | sub_402EED | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_402EED(__int64 a1, const char *a2)
{
int v2; // eax
v2 = strlen(a2);
return sub_402E42(a1, a2, v2);
}
Q:[a1,a2,sub_402EED,sub_402E42,] | A:{'a1': 'a', 'a2': 's', 'sub_402EED': 'abAppends', 'sub_402E42': 'abAppend'} | |
09e593e1a10a4f6cadf5c016cb4c8cfb0a3586515f0619eba999737feb58c9d7_09e593e1a10a4f6cadf5c016cb4c8cfb0a3586515f0619eba999737feb58c9d7.jsonl.gz | sub_438845 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_438845(char ***a1, const char *a2, const char *a3)
{
int v3; // edx
int v4; // edx
char **v7; // [rsp+28h] [rbp-18h]
int v8; // [rsp+34h] [rbp-Ch]
unsigned int v9; // [rsp+34h] [rbp-Ch]
char *dest; // [rsp+38h] [rbp-8h]
if ( a2 )
v3 = strlen(a2) + 1;
else
v3 = 0;
v8 = v3 + 16;
if ( a3 )
v4 = strlen(a3) + 1;
else
v4 = 0;
v9 = v4 + v8;
v7 = (char **)sub_46243D(0LL, (int)v9, 0LL, 0LL);
*a1 = v7;
if ( !v7 )
return 0LL;
dest = (char *)(v7 + 2);
if ( a2 )
{
*v7 = dest;
strcpy(dest, a2);
dest += strlen(a2) + 1;
}
else
{
*v7 = 0LL;
}
if ( a3 )
{
v7[1] = dest;
strcpy(dest, a3);
strlen(a3);
}
else
{
v7[1] = 0LL;
}
return v9;
}
Q:[a3,a1,a2,v7,v9,dest,sub_438845,sub_46243D,] | A:{'a3': 'thread_name', 'a1': '_buffer', 'a2': 'agent_name', 'v7': '_struct_ptr', 'v9': '_total_size', 'dest': '_ptr', 'sub_438845': 'put_smtoper_set_log', 'sub_46243D': 'mem_alloc_'} | |
550caec23a6658db1a4e2198ae85a92ec078c1e143c918cc7d856d584399e706_550caec23a6658db1a4e2198ae85a92ec078c1e143c918cc7d856d584399e706.jsonl.gz | sub_4027AA | Help user generate meaningful names for variables and functions in the following code snippet. |
int sub_4027AA()
{
unsigned int v1; // [rsp+14h] [rbp-DCh]
void *v2; // [rsp+20h] [rbp-D0h]
char *v3; // [rsp+28h] [rbp-C8h]
char *v4; // [rsp+30h] [rbp-C0h]
char *v5; // [rsp+38h] [rbp-B8h]
unsigned int v6; // [rsp+44h] [rbp-ACh]
char *v7; // [rsp+48h] [rbp-A8h]
char *v8; // [rsp+D0h] [rbp-20h]
char *v9; // [rsp+D8h] [rbp-18h]
char *v10; // [rsp+E0h] [rbp-10h]
char *ptr; // [rsp+E8h] [rbp-8h]
g_variant_iter_init();
g_variant_iter_next();
g_variant_iter_next();
g_variant_iter_next();
g_variant_iter_next();
g_variant_iter_next();
g_variant_iter_next();
g_variant_iter_next();
g_variant_iter_next();
ptr = sub_4026EA(v7);
v10 = sub_4026EA(v5);
v9 = sub_4026EA(v4);
v8 = sub_4026EA(v3);
if ( byte_406194 )
sub_403186((_DWORD)ptr, (_DWORD)v10, v6, v1);
else
sub_402E91((_DWORD)ptr, (_DWORD)v10, v6, v1);
free(ptr);
free(v10);
free(v7);
free(v5);
free(v2);
free(v4);
free(v3);
free(v9);
free(v8);
return fflush(stdout);
}
Q:[v1,v2,v3,v4,v5,v6,v7,v8,v9,v10,ptr,sub_4027AA,sub_4026EA,sub_403186,sub_402E91,] | A:{'v1': 'timeout', 'v2': 'actions', 'v3': 'body', 'v4': 'summary', 'v5': 'app_icon', 'v6': 'replaces_id', 'v7': 'app_name', 'v8': 'body_sanitized', 'v9': 'summary_sanitized', 'v10': 'app_icon_sanitized', 'ptr': 'app_name_sanitized', 'sub_4027AA': 'output_notification', 'sub_4026EA': 'sanitize', 'sub_403186': 'json_output', 'sub_402E91': 'default_output'} | |
89a56c46f037f898ed5be52119007206f2226613e013c90a587db00e358dc334_89a56c46f037f898ed5be52119007206f2226613e013c90a587db00e358dc334.jsonl.gz | sub_416A3B | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_416A3B(__int64 a1)
{
if ( a1 && *(_QWORD *)(a1 + 24) )
return *(unsigned int *)(*(_QWORD *)(a1 + 24) + 44LL);
syslog(3, "%s: Invalid session\n", "sdp_get_error");
return 0xFFFFFFFFLL;
}
Q:[a1,sub_416A3B,] | A:{'a1': 'session', 'sub_416A3B': 'sdp_get_error'} | |
f2b2915e9e2d6729375d876f6c15174498b7f2f04b5b9bcc85cb7c605be4924f_f2b2915e9e2d6729375d876f6c15174498b7f2f04b5b9bcc85cb7c605be4924f.jsonl.gz | sub_41DCB0 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_41DCB0(const char *a1, _QWORD *a2)
{
__int64 v2; // rdx
char *v4; // rax
_QWORD v5[3]; // [rsp+18h] [rbp-438h] BYREF
char s[1032]; // [rsp+30h] [rbp-420h] BYREF
char *v7; // [rsp+438h] [rbp-18h]
unsigned int v8; // [rsp+444h] [rbp-Ch]
size_t v9; // [rsp+448h] [rbp-8h]
++qword_4396E0;
v9 = 0LL;
v2 = a2[1];
v5[0] = *a2;
v5[1] = v2;
v5[2] = a2[2];
v8 = vsnprintf(s, 0x400uLL, a1, a2);
if ( (v8 & 0x80000000) != 0 )
return ++qword_4396E8;
if ( ::s )
{
v9 = strlen(::s);
v7 = (char *)sub_41DC79(::s, (int)v8 + v9 + 1);
++qword_439708;
if ( !v7 )
return ++qword_439710;
::s = v7;
}
else
{
++qword_4396F0;
v4 = (char *)sub_41DC20((int)(v8 + 1));
++qword_4396F8;
::s = v4;
if ( !v4 )
return ++qword_439700;
}
if ( v8 > 0x3FF )
return vsnprintf(&::s[v9], (int)v8, a1, v5);
++qword_439718;
return (unsigned int)memcpy(&::s[v9], s, (int)(v8 + 1));
}
Q:[a1,a2,v5,s,v7,v8,v9,sub_41DCB0,sub_41DC79,sub_41DC20,] | A:{'a1': 'format', 'a2': 'args', 'v5': 'ap', 's': 'buffer', 'v7': 'tmp', 'v8': 'len', 'v9': 'msg_len', 'sub_41DCB0': 'vcm_print_error', 'sub_41DC79': 'libc_realloc', 'sub_41DC20': 'libc_malloc'} | |
6b9a29c14e348a499dce372e585ac9ae074eb84f02dae35beb4324b410e27e66_6b9a29c14e348a499dce372e585ac9ae074eb84f02dae35beb4324b410e27e66.jsonl.gz | sub_41C4A0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41C4A0(unsigned __int64 a1, int a2)
{
__time_t *v3; // rcx
__suseconds_t v4; // rdx
struct timeval tv; // [rsp+10h] [rbp-20h] BYREF
int i; // [rsp+2Ch] [rbp-4h]
if ( a1 > 7 )
return 1LL;
if ( a2 > 0 )
{
gettimeofday(&tv, 0LL);
qword_434EC8[2 * a1] = malloc(24LL * a2);
if ( !qword_434EC8[2 * a1] )
return 1LL;
*((_DWORD *)&unk_434EC0 + 4 * a1) = a2;
for ( i = 0; i < a2; ++i )
{
*(_WORD *)(qword_434EC8[2 * a1] + 24LL * i + 16) = 0;
*(_WORD *)(qword_434EC8[2 * a1] + 24LL * i + 18) = 0;
v3 = (__time_t *)(24LL * i + qword_434EC8[2 * a1]);
v4 = tv.tv_usec;
*v3 = tv.tv_sec;
v3[1] = v4;
}
}
return 0LL;
}
Q:[a1,a2,tv,sub_41C4A0,] | A:{'a1': 'bus', 'a2': 'number', 'tv': 'akt_time', 'sub_41C4A0': 'init_FB'} | |
7301b6e819ff084818bf7bd8fce59c1aa17e3d4892c34b25c84a11ff0b5959c5_7301b6e819ff084818bf7bd8fce59c1aa17e3d4892c34b25c84a11ff0b5959c5.jsonl.gz | sub_418F37 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_418F37(__int64 a1)
{
__int64 result; // rax
unsigned __int64 v2; // rax
__int64 v3; // [rsp+10h] [rbp-28h]
__int64 v4; // [rsp+18h] [rbp-20h]
__int64 v5; // [rsp+20h] [rbp-18h]
char v6; // [rsp+2Fh] [rbp-9h]
__int64 v7; // [rsp+30h] [rbp-8h]
result = *(_QWORD *)(*(_QWORD *)(a1 + 256) + 8LL);
if ( result )
{
v7 = *(_QWORD *)(*(_QWORD *)(a1 + 256) + 8LL);
v6 = 0;
v3 = **(_QWORD **)(a1 + 256);
while ( 1 )
{
while ( 1 )
{
if ( !v7 )
{
result = a1;
*(_DWORD *)(a1 + 328) = 0;
return result;
}
--v7;
v5 = *(_QWORD *)(8 * v7 + v3);
if ( !v7 )
{
v6 = 1;
if ( *(_QWORD *)(a1 + 176) )
v5 = *(_QWORD *)(a1 + 176);
}
if ( *(_DWORD *)(v5 + 16) == 1 )
break;
if ( v6 )
{
result = a1;
*(_DWORD *)(a1 + 328) = 6;
return result;
}
}
if ( *(_QWORD *)(v5 + 8) == 114LL )
break;
v2 = *(_QWORD *)(v5 + 8);
if ( v2 > 0x3D )
{
if ( v2 <= 0x87 && v2 >= 0x41 )
{
switch ( v2 )
{
case 0x41uLL:
result = a1;
if ( *(_QWORD *)(a1 + 184) )
*(_DWORD *)(a1 + 328) = 5;
else
*(_DWORD *)(a1 + 328) = 2;
break;
case 0x7DuLL:
result = a1;
*(_DWORD *)(a1 + 328) = 8;
break;
case 0x7EuLL:
case 0x82uLL:
case 0x84uLL:
result = a1;
*(_DWORD *)(a1 + 328) = 12;
break;
case 0x7FuLL:
case 0x83uLL:
if ( v6 == 1 )
goto LABEL_42;
result = a1;
*(_DWORD *)(a1 + 328) = 14;
break;
case 0x80uLL:
result = a1;
*(_DWORD *)(a1 + 328) = *(_DWORD *)(**(_QWORD **)(a1 + 280)
+ 4LL * *(_QWORD *)(*(_QWORD *)(a1 + 280) + 8LL)
- 4);
break;
case 0x87uLL:
result = a1;
*(_DWORD *)(a1 + 328) = 13;
break;
default:
goto LABEL_42;
}
return result;
}
}
else if ( v2 >= 0x17 )
{
switch ( v2 )
{
case 0x17uLL:
result = a1;
*(_DWORD *)(a1 + 328) = 6;
break;
case 0x1BuLL:
result = a1;
*(_DWORD *)(a1 + 328) = 10;
break;
case 0x20uLL:
result = a1;
*(_DWORD *)(a1 + 328) = 11;
break;
case 0x36uLL:
result = a1;
*(_DWORD *)(a1 + 328) = 19;
break;
case 0x3DuLL:
if ( v6 == 1 )
goto LABEL_42;
result = a1;
*(_DWORD *)(a1 + 328) = 3;
break;
default:
goto LABEL_42;
}
return result;
}
LABEL_42:
if ( v6 )
{
result = a1;
*(_DWORD *)(a1 + 328) = 6;
return result;
}
}
if ( v6 )
{
result = a1;
*(_DWORD *)(a1 + 328) = 15;
}
else
{
v4 = v7;
do
{
if ( !v4 )
{
result = a1;
*(_DWORD *)(a1 + 328) = 15;
return result;
}
--v4;
if ( *(_QWORD *)(*(_QWORD *)(8 * v4 + v3) + 8LL) == 128LL )
{
result = a1;
*(_DWORD *)(a1 + 328) = 15;
return result;
}
}
while ( *(_QWORD *)(*(_QWORD *)(8 * v4 + v3) + 8LL) != 125LL );
result = a1;
*(_DWORD *)(a1 + 328) = 16;
}
}
return result;
}
Q:[a1,v3,v4,v5,v6,sub_418F37,] | A:{'a1': 'tree', 'v3': 'list', 'v4': 'ancestor', 'v5': 'node', 'v6': 'last', 'sub_418F37': 'myhtml_tree_reset_insertion_mode_appropriately'} | |
36e2a2b3c90d2417126c548d6e41cc7407e894b30d56150ef0c7c66984693b6d_36e2a2b3c90d2417126c548d6e41cc7407e894b30d56150ef0c7c66984693b6d.jsonl.gz | sub_42D1F5 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42D1F5(int a1)
{
__int64 result; // rax
unsigned int i; // [rsp+10h] [rbp-4h]
for ( i = 0; *((_DWORD *)&unk_462CC0 + 10 * (int)i) != -1 && a1 != *((_DWORD *)&unk_462CC0 + 10 * (int)i); ++i )
;
if ( *((_DWORD *)&unk_462CC0 + 10 * (int)i) == -1 )
result = 0xFFFFFFFFLL;
else
result = i;
return result;
}
Q:[a1,sub_42D1F5,] | A:{'a1': 'val', 'sub_42D1F5': 'find_asm_entry'} | |
47f002f4668fd48706512e77658f4968bbeeae5a22bc204933c7c794e08e0cd8_47f002f4668fd48706512e77658f4968bbeeae5a22bc204933c7c794e08e0cd8.jsonl.gz | sub_41162A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41162A(__int64 a1)
{
return 32 * (1 - *(unsigned __int8 *)(a1 + 88)) + 33;
}
Q:[a1,sub_41162A,] | A:{'a1': 'this', 'sub_41162A': 'length'} | |
bd3828dfb34ba781bec33c1de282f318297bb654233245dae251c4e307355d55_bd3828dfb34ba781bec33c1de282f318297bb654233245dae251c4e307355d55.jsonl.gz | sub_41B737 | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_41B737(unsigned __int64 *a1, char *a2)
{
unsigned __int64 v2; // rbx
__int64 v3; // rax
unsigned __int64 v4; // r12
char v5; // cl
unsigned int v6; // er14
const char *v7; // r12
FILE *v8; // rbx
FILE *v9; // rbx
unsigned __int64 result; // rax
__int64 v12; // [rsp+18h] [rbp-68h]
char v13[96]; // [rsp+20h] [rbp-60h] BYREF
v2 = (unsigned __int64)v13;
if ( _asan_option_detect_stack_use_after_return )
{
v3 = __asan_stack_malloc_0();
if ( v3 )
v2 = v3;
}
*(_QWORD *)v2 = 1102416563LL;
*(_QWORD *)(v2 + 8) = "1 32 2 14 formatted:2852";
*(_QWORD *)(v2 + 16) = sub_41B737;
v4 = v2 >> 3;
*(_DWORD *)(v4 + 2147450880) = -235802127;
*(_DWORD *)(v4 + 2147450884) = -202116350;
sub_41B67F(a1);
while ( 1 )
{
if ( !a2 )
__ubsan_handle_type_mismatch_v1();
if ( *(_BYTE *)(((unsigned __int64)a2 >> 3) + 0x7FFF8000) != 0
&& ((unsigned __int8)a2 & 7) >= *(_BYTE *)(((unsigned __int64)a2 >> 3) + 0x7FFF8000) )
{
__asan_report_load1();
}
result = (unsigned __int8)*a2;
if ( !(_BYTE)result )
break;
v12 = sub_41B702(a1);
if ( !a2 )
__ubsan_handle_type_mismatch_v1();
if ( *(_BYTE *)(((unsigned __int64)a2 >> 3) + 0x7FFF8000) != 0
&& ((unsigned __int8)a2 & 7) >= *(_BYTE *)(((unsigned __int64)a2 >> 3) + 0x7FFF8000) )
{
__asan_report_load1();
}
if ( v12 != *a2 )
{
v5 = v12;
if ( *(char *)(((v2 + 32) >> 3) + 0x7FFF8000) < 0 )
__asan_report_store1();
*(_BYTE *)(v2 + 32) = v5;
if ( *(_BYTE *)(((v2 + 33) >> 3) + 0x7FFF8000) != 0
&& (char)((v2 + 33) & 7) >= *(_BYTE *)(((v2 + 33) >> 3) + 0x7FFF8000) )
{
__asan_report_store1();
}
*(_BYTE *)(v2 + 33) = 0;
sub_41B278(a1);
if ( !a2 )
__ubsan_handle_type_mismatch_v1();
if ( *(_BYTE *)(((unsigned __int64)a2 >> 3) + 0x7FFF8000) != 0
&& ((unsigned __int8)a2 & 7) >= *(_BYTE *)(((unsigned __int64)a2 >> 3) + 0x7FFF8000) )
{
__asan_report_load1();
}
v6 = *a2;
if ( v12 == -1 )
v7 = (const char *)&off_4455A0;
else
v7 = (const char *)(v2 + 32);
if ( *(_BYTE *)(((unsigned __int64)&stderr >> 3) + 0x7FFF8000) )
__asan_report_load8();
v8 = stderr;
if ( !stderr )
__ubsan_handle_nonnull_arg();
fprintf(v8, "matched character `%s` but expected character `%c`", v7, v6);
if ( *(_BYTE *)(((unsigned __int64)&stderr >> 3) + 0x7FFF8000) )
__asan_report_load8();
v9 = stderr;
if ( !stderr )
__ubsan_handle_nonnull_arg();
fputc(10, v9);
__asan_handle_no_return();
exit(255);
}
if ( a2 == (char *)-1LL )
__ubsan_handle_pointer_overflow();
++a2;
}
if ( v13 == (char *)v2 )
{
*(_QWORD *)((v2 >> 3) + 0x7FFF8000) = 0LL;
}
else
{
*(_QWORD *)v2 = 1172321806LL;
*(_QWORD *)((v2 >> 3) + 0x7FFF8000) = 0xF5F5F5F5F5F5F5F5LL;
result = *(_QWORD *)(v2 + 56);
*(_BYTE *)result = 0;
}
return result;
}
Q:[a1,a2,v12,sub_41B737,sub_41B67F,sub_41B702,sub_41B278,] | A:{'a1': 'self', 'a2': 'expect', 'v12': 'peak', 'sub_41B737': 'CC_Match', 'sub_41B67F': 'CC_Spin', 'sub_41B702': 'CC_Read', 'sub_41B278': 'CC_PrintLine'} | |
6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58_6b0036b42f434346a5bca38f2ac47e5270e30e107783eb83d1e9014b8f1d2a58.jsonl.gz | sub_423965 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_423965(_BYTE *a1)
{
__int64 result; // rax
result = sub_407695(a1, a1[2], 1);
a1[2] = result;
return result;
}
Q:[a1,sub_423965,sub_407695,] | A:{'a1': 'ctx', 'sub_423965': 'SRA_C', 'sub_407695': 'doSR'} | |
45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0_45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0.jsonl.gz | sub_42CF55 | Help user generate meaningful names for variables and functions in the following code snippet. |
char *__fastcall sub_42CF55(const void *a1, __int64 a2, char *a3)
{
__int64 v5; // [rsp+28h] [rbp-8h]
v5 = (a2 - (__int64)a1) >> 4;
if ( v5 )
memmove(a3, a1, 16 * v5);
return &a3[16 * v5];
}
Q:[a3,a1,a2,v5,sub_42CF55,] | A:{'a3': '__result', 'a1': '__first', 'a2': '__last', 'v5': '_Num', 'sub_42CF55': '__copy_m'} | |
fb04827bf9a551f5f69186e53039bed933d463cd8e2d00e60728cc981426dd66_fb04827bf9a551f5f69186e53039bed933d463cd8e2d00e60728cc981426dd66.jsonl.gz | sub_451104 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_451104(__int64 a1, __int64 a2)
{
__int64 v2; // rsi
__int64 result; // rax
v2 = sub_44B6E7(a2);
sub_448F28(a1, v2);
*(_DWORD *)(a1 + 16) = sub_4457D5();
*(_BYTE *)(a1 + 20) = 0;
*(_QWORD *)(a1 + 24) = 0LL;
*(_QWORD *)(a1 + 32) = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
sub_451082((_QWORD *)(a1 + 24));
*(_QWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 56) = 0LL;
*(_QWORD *)(a1 + 64) = 0LL;
sub_4510E8(a1 + 48);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
*(_QWORD *)(a1 + 104) = &unk_48E06F;
*(_QWORD *)(a1 + 112) = 0LL;
*(_QWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 128) = 0LL;
result = sub_456FEF(a1 + 72);
*(_BYTE *)(a1 + 136) = result;
return result;
}
Q:[sub_451104,sub_44B6E7,sub_448F28,sub_4457D5,sub_451082,sub_4510E8,sub_456FEF,] | A:{'sub_451104': 'lexer', 'sub_44B6E7': 'shared_ptr', 'sub_448F28': 'shared_ptr', 'sub_4457D5': 'eof', 'sub_451082': 'position_t', 'sub_4510E8': 'vector', 'sub_456FEF': 'get_decimal_point'} | |
bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b_bb617c8fa1226b81c1d526808551544f95aadeb79a5e62c7307853d0fbf2577b.jsonl.gz | sub_428100 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_428100(__int64 a1)
{
return sub_42C65C(a1);
}
Q:[sub_428100,sub_42C65C,] | A:{'sub_428100': '~map', 'sub_42C65C': '~_Rb_tree'} | |
60a194101bbb0c7f9cf2cd1194de564c18122929447228af1d8480f510c78886_60a194101bbb0c7f9cf2cd1194de564c18122929447228af1d8480f510c78886.jsonl.gz | sub_418E64 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_418E64(_QWORD *a1)
{
_QWORD v2[8]; // [rsp+20h] [rbp-80h] BYREF
_QWORD v3[8]; // [rsp+60h] [rbp-40h] BYREF
sub_416B3B(" x", (__int64)a1);
sub_416B3B(" y", (__int64)(a1 + 8));
sub_416B3B(" z", (__int64)(a1 + 16));
sub_4164FC(v3, a1 + 16);
sub_405584(v2, v3, a1);
sub_416B3B(" X", (__int64)v2);
sub_405584(v2, v3, a1 + 8);
sub_416B3B(" Y", (__int64)v2);
return putchar(10);
}
Q:[a1,v2,v3,sub_418E64,sub_416B3B,sub_4164FC,sub_405584,] | A:{'a1': 'a', 'v2': 'cs_0', 'v3': 'as', 'sub_418E64': 'failprint_ext', 'sub_416B3B': 'field_print', 'sub_4164FC': 'p448_inverse', 'sub_405584': 'p448_mul'} | |
7421faa8c444aeca9266add08f45c75a4f43aebd993f880cd35dd964f63fdfb2_7421faa8c444aeca9266add08f45c75a4f43aebd993f880cd35dd964f63fdfb2.jsonl.gz | sub_42299F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42299F(_BYTE *a1, __int64 a2)
{
if ( !a1 )
{
*(_QWORD *)(__readfsqword(0) - 24) = "Error encountered in s2n_config.c:812";
*(_DWORD *)(__readfsqword(0) - 32) = 402653193;
sub_46D9B7(0LL, a2);
return 0xFFFFFFFFLL;
}
if ( (*a1 & 1) == (unsigned __int8)a2 )
return 0LL;
*a1 = a2 & 1 | *a1 & 0xFE;
if ( !a1[281] )
a1[281] = 1;
if ( (_BYTE)a2 )
{
if ( (int)sub_42072F((__int64)a1) < 0 )
return 0xFFFFFFFFLL;
}
else if ( (*a1 & 8) == 0 && (int)sub_420855((__int64)a1) < 0 )
{
return 0xFFFFFFFFLL;
}
return 0LL;
}
Q:[a1,a2,sub_42299F,sub_46D9B7,sub_42072F,sub_420855,] | A:{'a1': 'config', 'a2': 'enabled', 'sub_42299F': 's2n_config_set_session_tickets_onoff', 'sub_46D9B7': 's2n_calculate_stacktrace', 'sub_42072F': 's2n_config_init_session_ticket_keys', 'sub_420855': 's2n_config_free_session_ticket_keys'} | |
8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2_8637b53fba300d2bbda36edc905b4ce0ac17bbe93b75784d9e0ff8ef770869f2.jsonl.gz | sub_4A74CA | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4A74CA(__int64 a1, unsigned __int64 a2, unsigned __int8 a3)
{
char v5; // [rsp+28h] [rbp-18h]
unsigned __int64 v6; // [rsp+30h] [rbp-10h]
unsigned int v7; // [rsp+3Ch] [rbp-4h]
v7 = 0;
v6 = a2 >> 6;
v5 = a2 & 0x3F;
if ( a3 && a3 != 1 )
return 4294967292LL;
if ( a2 < *(_QWORD *)(a1 + 8) << 6 )
goto LABEL_8;
if ( !a3 )
return 0LL;
v7 = sub_4A6D37(a1, v6 + 1);
if ( !v7 )
{
LABEL_8:
*(_QWORD *)(*(_QWORD *)(a1 + 16) + 8 * v6) &= ~(1LL << v5);
*(_QWORD *)(*(_QWORD *)(a1 + 16) + 8 * v6) |= (unsigned __int64)a3 << v5;
}
return v7;
}
Q:[a3,a1,a2,v5,v6,sub_4A74CA,sub_4A6D37,] | A:{'a3': 'val', 'a1': 'X', 'a2': 'pos', 'v5': 'idx', 'v6': 'off', 'sub_4A74CA': 'mbedtls_mpi_set_bit', 'sub_4A6D37': 'mbedtls_mpi_grow'} | |
2e7195e6bc11902cb1147d429b22ff6f7655de6050b37429b5d7074aaa0727e8_2e7195e6bc11902cb1147d429b22ff6f7655de6050b37429b5d7074aaa0727e8.jsonl.gz | sub_429EB2 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_429EB2(__int64 a1)
{
return sub_429F15(a1, 0LL);
}
Q:[a1,sub_429EB2,sub_429F15,] | A:{'a1': 'filename', 'sub_429EB2': 'workbook_new', 'sub_429F15': 'workbook_new_opt'} | |
8acf4c9edbc8cd33ded2ad41f05284dbb7541bfe5b191fef23a7ba0da427906e_8acf4c9edbc8cd33ded2ad41f05284dbb7541bfe5b191fef23a7ba0da427906e.jsonl.gz | sub_40161A | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_40161A(__int64 a1, int a2)
{
__int64 v2; // rax
double v3; // xmm0_8
__int64 v4; // rdx
double v5; // [rsp+14h] [rbp-8h]
if ( a2 > 0 )
{
v2 = *(_QWORD *)(a1 + 104);
if ( v2 < 0 )
{
v4 = *(_QWORD *)(a1 + 104) & 1LL | ((unsigned __int64)v2 >> 1);
v3 = (double)(int)v4 + (double)(int)v4;
}
else
{
v3 = (double)(int)v2;
}
v5 = (double)a2 / v3;
*(double *)(a1 + 32) = *(double *)(a1 + 32) * v5;
*(double *)(a1 + 40) = *(double *)(a1 + 40) / v5;
*(_QWORD *)(a1 + 104) = a2;
}
}
Q:[a1,a2,v5,sub_40161A,] | A:{'a1': 'this', 'a2': 'NewSampleTime', 'v5': 'ratio', 'sub_40161A': 'SetSampleTime'} | |
251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651_251c609d040d03d5f9c14cb2c70e65542d5cb3f75e64f702172bcafe52351651.jsonl.gz | sub_424C1C | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_424C1C(__int64 a1, __int64 a2)
{
__int64 v2; // rax
sub_4201B2(a2);
v2 = sub_42C2D8(a1);
return sub_40A7E8(1LL, v2);
}
Q:[a1,a2,sub_424C1C,sub_4201B2,sub_42C2D8,sub_40A7E8,] | A:{'a1': '__functor', 'a2': '__f', 'sub_424C1C': 'lambda', 'sub_4201B2': 'lambda', 'sub_42C2D8': '_M_access', 'sub_40A7E8': 'new'} | |
9b7fe0b287cb708dbbe00367c5722c27721676356197b3daa910c3336153c700_9b7fe0b287cb708dbbe00367c5722c27721676356197b3daa910c3336153c700.jsonl.gz | sub_40191B | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_40191B(void **a1, unsigned __int64 a2, int a3)
{
unsigned __int64 result; // rax
unsigned __int64 i; // [rsp+28h] [rbp-8h]
if ( !a2 )
__assert_fail("size > 0", "vector.c", 0x2Fu, "vector_i_init_set");
if ( !a1 )
__assert_fail("v != NULL", "vector.c", 0x30u, "vector_i_init_set");
a1[1] = (void *)a2;
*a1 = malloc(8 * a2);
for ( i = 0LL; ; ++i )
{
result = i;
if ( i >= a2 )
break;
*((_DWORD *)*a1 + i) = a3;
}
return result;
}
Q:[a3,a1,a2,sub_40191B,] | A:{'a3': 'init', 'a1': 'v', 'a2': 'size', 'sub_40191B': 'vector_i_init_set'} | |
45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0_45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0.jsonl.gz | sub_457FDD | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_457FDD(__int64 a1)
{
return a1;
}
Q:[a1,sub_457FDD,] | A:{'a1': '__t', 'sub_457FDD': 'forward'} | |
74b93be29b886f02996dd82341e273fc6ded8145e7a7bad3f6303c5716197756_74b93be29b886f02996dd82341e273fc6ded8145e7a7bad3f6303c5716197756.jsonl.gz | sub_413BCC | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 *__fastcall sub_413BCC(__int64 *a1)
{
*a1 = std::_Rb_tree_decrement();
return a1;
}
Q:[a1,sub_413BCC,] | A:{'a1': 'this', 'sub_413BCC': 'operator--'} | |
7c16ecc1f4177280f9c554334c74c60179f6cbd74ce0674df9f0cc7c89723807_7c16ecc1f4177280f9c554334c74c60179f6cbd74ce0674df9f0cc7c89723807.jsonl.gz | be_module_setname | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall be_module_setname(__int64 a1, __int64 a2)
{
if ( (*(_BYTE *)(a1 + 9) & 8) != 0 )
return 0LL;
*(_QWORD *)(a1 + 24) = a2;
*(_BYTE *)(a1 + 9) |= 0x10u;
return 1LL;
}
Q:[a1,a2,] | A:{'a1': 'module', 'a2': 'name'} | |
0013eff4f651197c69fb1942eb3da4fc642ba9295409416173887304907dcd82_0013eff4f651197c69fb1942eb3da4fc642ba9295409416173887304907dcd82.jsonl.gz | sub_40D4A6 | Help user generate meaningful names for variables and functions in the following code snippet. |
_QWORD *__fastcall sub_40D4A6(_QWORD *a1, unsigned __int64 a2, _QWORD *a3, unsigned __int64 a4, unsigned __int64 a5)
{
if ( a5 + a4 > a3[1] )
__assert_fail("srcindx + length <= src->num_of_bits", "bit_array.c", 0x63Au, "bit_array_copy");
if ( a2 > a1[1] )
__assert_fail("dstindx <= dst->num_of_bits", "bit_array.c", 0x63Bu, "bit_array_copy");
return sub_40D1D6(a1, a2, a3, a4, a5);
}
Q:[a3,a4,a1,a2,a5,sub_40D4A6,sub_40D1D6,] | A:{'a3': 'src', 'a4': 'srcindx', 'a1': 'dst', 'a2': 'dstindx', 'a5': 'length', 'sub_40D4A6': 'bit_array_copy', 'sub_40D1D6': '_array_copy'} | |
44e8aed08fe933b793e356a871e8f31cdd3a534e9dca1fb63610d519aee2b0ea_44e8aed08fe933b793e356a871e8f31cdd3a534e9dca1fb63610d519aee2b0ea.jsonl.gz | sub_44E60A | Help user generate meaningful names for variables and functions in the following code snippet. |
_QWORD *__fastcall sub_44E60A(_QWORD *a1, __int64 a2, __int64 a3)
{
__int64 v3; // rdx
_QWORD *result; // rax
*a1 = *(_QWORD *)sub_4536F4(a2);
v3 = *(_QWORD *)sub_4536F4(a3);
result = a1;
a1[1] = v3;
return result;
}
Q:[sub_44E60A,sub_4536F4,] | A:{'sub_44E60A': 'pair', 'sub_4536F4': 'forward'} | |
8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2_8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2.jsonl.gz | sub_42A0A9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42A0A9(volatile signed __int32 *a1, unsigned int a2)
{
return a2 + _InterlockedExchangeAdd(a1, a2);
}
Q:[a1,a2,sub_42A0A9,] | A:{'a1': 'target', 'a2': 'value', 'sub_42A0A9': 'as_aaf_uint32_rls_9'} | |
b96d14afe5a309f3d2768451909eadc66db3a51f9332c796791f24616961688b_b96d14afe5a309f3d2768451909eadc66db3a51f9332c796791f24616961688b.jsonl.gz | sub_435439 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_435439(int a1, _QWORD *a2, int a3, int a4, int a5, int a6)
{
__int64 result; // rax
__int64 v7; // rsi
int v8; // er8
int v9; // er9
int v10; // eax
int v11; // er9
__int64 v12; // rdi
__int64 v14; // [rsp+18h] [rbp-8h]
if ( a1 <= 0 )
return sub_45F24C(*(_QWORD *)(qword_488420 + 16), (unsigned int)"Expected more args.", a3, a4, a5, a6);
v7 = *(_QWORD *)(qword_488418 + 160);
if ( (unsigned int)sub_45FE0C(*a2, v7) )
{
v14 = *a2 & 0xFFFFFFFFFFFFLL;
if ( a1 == 1 )
{
while ( 1 )
{
if ( *(_QWORD *)(v14 + 64) >= *(_QWORD *)((*(_QWORD *)(v14 + 56) & 0xFFFFFFFFFFFFLL) + 0x40) )
return *a2;
if ( (*(_QWORD *)(*(_QWORD *)((*(_QWORD *)(v14 + 56) & 0xFFFFFFFFFFFFLL) + 0x48) + 16LL * *(_QWORD *)(v14 + 64)) & 0xFFFF000000000000LL) != 0x7FFC000000000000LL )
break;
++*(_QWORD *)(v14 + 64);
}
v12 = *(_QWORD *)(*(_QWORD *)((*(_QWORD *)(v14 + 56) & 0xFFFFFFFFFFFFLL) + 0x48) + 16LL * *(_QWORD *)(v14 + 64));
sub_45F560(v12);
++*(_QWORD *)(v14 + 64);
result = sub_45F5A9(v12, v7);
}
else
{
result = sub_45F24C(
*(_QWORD *)(qword_488420 + 16),
(unsigned int)"%s() takes no arguments (%d given)",
off_4872C0[0],
a1 - 1,
v8,
v9);
}
}
else
{
v10 = sub_463D61(*a2);
result = sub_45F24C(
*(_QWORD *)(qword_488420 + 8),
(unsigned int)"%s() expects %s, not '%s'",
off_4872C0[0],
(unsigned int)"dictkeys",
v10,
v11);
}
return result;
}
Q:[a3,a1,a2,v7,v12,v14,sub_435439,sub_45F24C,sub_45FE0C,sub_45F560,sub_45F5A9,sub_463D61,] | A:{'a3': 'hasKw', 'a1': 'argc', 'a2': 'argv', 'v7': 'argv', 'v12': 'argc', 'v14': 'self', 'sub_435439': '_dictkeys___call__', 'sub_45F24C': 'krk_runtimeError', 'sub_45FE0C': 'krk_isInstanceOf', 'sub_45F560': 'krk_push', 'sub_45F5A9': 'krk_pop', 'sub_463D61': 'krk_typeName'} | |
decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08_decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08.jsonl.gz | cu_find_realpath | Help user generate meaningful names for variables and functions in the following code snippet. |
const char *__fastcall cu_find_realpath(__int64 a1, const char *a2)
{
const char *result; // rax
unsigned __int64 v3; // [rsp+20h] [rbp-20h]
unsigned __int64 i; // [rsp+28h] [rbp-18h]
const char *v5; // [rsp+30h] [rbp-10h]
v5 = 0LL;
if ( !a2 )
return 0LL;
if ( (unsigned int)dwarf_getsrcfiles() )
return 0LL;
for ( i = 0LL; i < v3; ++i )
{
v5 = (const char *)dwarf_filesrc();
if ( !(unsigned int)strtailcmp(v5, a2) )
break;
}
if ( i == v3 )
result = 0LL;
else
result = v5;
return result;
}
Q:[a2,a1,v3,v5,] | A:{'a2': 'fname', 'a1': 'cu_die', 'v3': 'nfiles', 'v5': 'src'} | |
fa27d0bacf06ce93b14fd9cba32c0c5a7d20e024d2a5f59104dc1d7405bb9602_fa27d0bacf06ce93b14fd9cba32c0c5a7d20e024d2a5f59104dc1d7405bb9602.jsonl.gz | sub_441910 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_441910(__int64 a1, __int64 a2, char a3)
{
int v3; // edx
int v4; // ecx
int v5; // er8
int v6; // er9
FILE *v8; // rax
int v9; // ecx
int v10; // er8
int v11; // er9
int v12; // edx
int v13; // ecx
int v14; // er8
int v15; // er9
int v16; // eax
__int64 v17; // rax
int v18; // ecx
int v19; // er8
int v20; // er9
int v21; // edx
__int64 v22; // rax
char v24; // [rsp+2Eh] [rbp-22h] BYREF
__mode_t mask; // [rsp+3Ch] [rbp-14h]
__int64 v26; // [rsp+40h] [rbp-10h]
__int64 v27; // [rsp+48h] [rbp-8h]
v26 = *(_QWORD *)(a1 + 568);
if ( a3 != 114 )
{
v27 = sub_44CC1F(72LL);
mask = umask(0x3Fu);
v8 = tmpfile();
v12 = v27;
*(_QWORD *)(v27 + 24) = v8;
if ( !*(_QWORD *)(v27 + 24) )
{
if ( (unsigned int)dword_47A188 <= 4 )
sub_44D896(4, (unsigned int)"could not generate temporary file name: %m", v12, v9, v10, v11);
sub_44528A(1LL);
}
umask(mask);
if ( *(_DWORD *)(a1 + 552) )
{
sub_44FB45((unsigned int)&v24, (unsigned int)"wb%d", *(_DWORD *)(a1 + 552), v13, v14, v15);
v16 = fileno(*(FILE **)(v27 + 24));
dup(v16);
v17 = gzdopen();
v21 = v27;
*(_QWORD *)v27 = v17;
if ( !*(_QWORD *)v27 )
{
if ( (unsigned int)dword_47A188 <= 4 )
sub_44D896(4, (unsigned int)"could not open temporary file", v21, v18, v19, v20);
sub_44528A(1LL);
}
}
else
{
*(_QWORD *)(v27 + 8) = *(_QWORD *)(v27 + 24);
}
*(_QWORD *)(v27 + 64) = a1;
v22 = sub_44CCCD(a2);
*(_QWORD *)(v27 + 32) = v22;
goto LABEL_24;
}
v27 = sub_44330B(a1, a2);
if ( v27 )
{
if ( *(_DWORD *)(a1 + 552) )
{
if ( (unsigned int)dword_47A188 <= 4 )
sub_44D896(4, (unsigned int)"compression is not supported by tar archive format", v3, v4, v5, v6);
sub_44528A(1LL);
}
*(_QWORD *)(v27 + 8) = *(_QWORD *)(v26 + 24);
LABEL_24:
*(_BYTE *)(v27 + 40) = a3;
*(_QWORD *)(v27 + 16) = *(_QWORD *)(v26 + 24);
return v27;
}
if ( a2 )
{
if ( (unsigned int)dword_47A188 <= 4 )
sub_44D896(4, (unsigned int)"could not find file \"%s\" in archive", a2, v4, v5, v6);
sub_44528A(1LL);
}
return 0LL;
}
Q:[a3,a1,a2,v3,v24,mask,v26,v27,sub_441910,sub_44CC1F,sub_44D896,sub_44528A,sub_44FB45,sub_44CCCD,sub_44330B,] | A:{'a3': 'mode', 'a1': 'AH_0', 'a2': 'filename', 'v3': 'mode', 'v24': 'fmode', 'mask': 'old_umask', 'v26': 'ctx', 'v27': 'tm', 'sub_441910': 'tarOpen', 'sub_44CC1F': 'pg_malloc0', 'sub_44D896': 'pg_log_generic', 'sub_44528A': 'exit_nicely', 'sub_44FB45': 'pg_sprintf', 'sub_44CCCD': 'pg_strdup', 'sub_44330B': '_tarPositionTo'} | |
2628714fc89bbd06927f17c35c7cc10c3c4f3a82276ea56c58894e172e8f25b3_2628714fc89bbd06927f17c35c7cc10c3c4f3a82276ea56c58894e172e8f25b3.jsonl.gz | sub_418690 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_418690(_QWORD *a1)
{
return sub_4356B9(*a1);
}
Q:[a1,sub_418690,sub_4356B9,] | A:{'a1': 'buffered_input', 'sub_418690': 'buffered_input_file_get_file_name', 'sub_4356B9': 'input_file_sliced_get_file_name'} | |
52d6428286326c975eaf1801693e24ec80f3dcc477ca21987a78c689c68cce17_52d6428286326c975eaf1801693e24ec80f3dcc477ca21987a78c689c68cce17.jsonl.gz | sub_411309 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_411309(__int64 a1)
{
__int64 v1; // rax
__int64 v2; // rax
__int64 result; // rax
__int64 v4; // [rsp+10h] [rbp-8h]
if ( **(int **)(a1 + 8) <= 14 )
v1 = *(_QWORD *)(a1 + 8);
else
v1 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
v4 = v1;
if ( (*(_DWORD *)a1 & 0x3F0) != 16 )
goto LABEL_18;
if ( *(_DWORD *)v1 == 5 && !*(_QWORD *)(a1 + 40) || *(_DWORD *)v1 == 6 && !*(_QWORD *)(a1 + 40) )
goto LABEL_17;
if ( *(int *)v1 > 14 )
v1 = *(_QWORD *)(v1 + 8);
if ( *(_DWORD *)v1 == 7
&& (**(int **)(v4 + 8) <= 14 ? (v2 = *(_QWORD *)(v4 + 8)) : (v2 = *(_QWORD *)(*(_QWORD *)(v4 + 8) + 8LL)),
v2 == qword_451528 && !*(_QWORD *)(a1 + 40)) )
{
LABEL_17:
result = 1LL;
}
else
{
LABEL_18:
result = 0LL;
}
return result;
}
Q:[a1,v4,sub_411309,] | A:{'a1': 'e', 'v4': 'ty', 'sub_411309': 'isnullptr'} | |
a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4_a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4.jsonl.gz | sub_44BAE8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_44BAE8(__int64 a1)
{
return sub_45C643(a1);
}
Q:[sub_44BAE8,sub_45C643,] | A:{'sub_44BAE8': '_M_ptr', 'sub_45C643': 'default_delete'} | |
3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33_3ab645463ad13ea30c238ceac9bf56691ea8cada0b7c92413fecc09c2d081d33.jsonl.gz | sub_403EB9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_403EB9(__int64 a1)
{
return sub_404C28(*(_QWORD *)(a1 + 32));
}
Q:[a1,sub_403EB9,sub_404C28,] | A:{'a1': 'expr', 'sub_403EB9': 'expand_addressof', 'sub_404C28': 'expand_expression'} | |
473b941682ea09b07b603dfb71d2a7d8480485ec92dc551c93613ac8ed3c5b1d_473b941682ea09b07b603dfb71d2a7d8480485ec92dc551c93613ac8ed3c5b1d.jsonl.gz | sub_424620 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_424620(__int64 a1, __int64 a2, __int64 a3)
{
__int64 v3; // rdx
mcount(a1, a2, a3);
return sub_4244A7(a1, (unsigned int)a2, v3);
}
Q:[a3,a2,sub_424620,sub_4244A7,] | A:{'a3': 'argv', 'a2': 'argc', 'sub_424620': 'rtlb_log10', 'sub_4244A7': 'rtlb_aux_unmath'} | |
7dff80169eaa7297ab210ad7b764ebe3e7f09f3243b9cb18b4659e21ae521c17_7dff80169eaa7297ab210ad7b764ebe3e7f09f3243b9cb18b4659e21ae521c17.jsonl.gz | sub_401D20 | Help user generate meaningful names for variables and functions in the following code snippet. |
int (*__fastcall sub_401D20(Display *a1, int a2, int a3, int a4, int a5))(struct _XDisplay *)
{
return sub_401BCA(a1, 0, a2, a3, a4, a5);
}
Q:[a3,a4,a1,a2,a5,sub_401D20,sub_401BCA,] | A:{'a3': 'display_mask', 'a4': 'attribute', 'a1': 'dpy', 'a2': 'screen', 'a5': 'value', 'sub_401D20': 'XNVCTRLSetAttribute', 'sub_401BCA': 'XNVCTRLSetTargetAttribute'} | |
7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2_7219b0ef569734ba548000b39f891b63e71d053f533c94257503597f308a3fd2.jsonl.gz | sub_404B7F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_404B7F(__int64 a1, char a2, unsigned int *a3, unsigned int *a4, unsigned int a5, int a6)
{
unsigned int v11; // [rsp+28h] [rbp-10h] BYREF
char v12; // [rsp+2Fh] [rbp-9h] BYREF
unsigned int v13; // [rsp+30h] [rbp-8h] BYREF
unsigned int v14; // [rsp+34h] [rbp-4h]
v14 = 0;
v13 = *a3;
v11 = 0;
if ( (unsigned int)sub_404AF7(a1, &v13, &v12, a5) )
v14 = -140;
if ( !v14 && a2 != v12 )
v14 = -140;
if ( !v14 && (int)sub_404997(a1, &v13, (int *)&v11, a5, a6) < 0 )
v14 = -140;
if ( !v14 )
{
*a4 = v11;
*a3 = v13;
v14 = v11;
}
return v14;
}
Q:[a3,a4,a1,a2,a5,a6,v11,v12,v13,sub_404B7F,sub_404AF7,sub_404997,] | A:{'a3': 'inOutIdx', 'a4': 'len', 'a1': 'input', 'a2': 'tag', 'a5': 'maxIdx', 'a6': 'check', 'v11': 'length', 'v12': 'tagFound', 'v13': 'idx', 'sub_404B7F': 'GetASNHeader_ex', 'sub_404AF7': 'GetASNTag', 'sub_404997': 'GetLength_ex'} | |
e43b09e2b916f0940aa2c15b3b2661a179a2f51d0903ae1f909e255282fb99bf_e43b09e2b916f0940aa2c15b3b2661a179a2f51d0903ae1f909e255282fb99bf.jsonl.gz | sub_401DBA | Help user generate meaningful names for variables and functions in the following code snippet. |
size_t sub_401DBA()
{
size_t result; // rax
__int64 v2; // [rsp+8h] [rbp-18h]
_BYTE *i; // [rsp+10h] [rbp-10h]
__int64 v4; // [rsp+18h] [rbp-8h]
v2 = qword_407E88;
if ( qword_407E88 )
{
v4 = qword_407D38;
for ( i = (char *)to - qword_407D38; v4--; ++i )
*i = *(_BYTE *)((unsigned __int8)*i + v2);
}
qword_407DA8 = to;
qword_407DB0 = n;
result = nbytes;
if ( n >= nbytes )
{
sub_402F83(0LL);
to = qword_407DA8;
result = qword_407DB0;
n = qword_407DB0;
}
return result;
}
Q:[v2,i,v4,sub_401DBA,sub_402F83,] | A:{'v2': 't', 'i': 'inp', 'v4': 'cnt', 'sub_401DBA': 'def', 'sub_402F83': 'dd_out'} | |
bdcc38c8cca1a301c72f437fbc2ef4fe15e99ee7737ab0b790ed572e400e6b73_bdcc38c8cca1a301c72f437fbc2ef4fe15e99ee7737ab0b790ed572e400e6b73.jsonl.gz | sub_410CE9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__off_t __fastcall sub_410CE9(char *a1)
{
__off_t result; // rax
struct stat stat_buf; // [rsp+10h] [rbp-90h] BYREF
if ( (unsigned int)sub_414640(a1, &stat_buf) )
result = 0xFFFFFFFFLL;
else
result = stat_buf.st_size;
return result;
}
Q:[sub_410CE9,sub_414640,] | A:{'sub_410CE9': 'getFileSize_15', 'sub_414640': 'stat'} | |
8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197_8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197.jsonl.gz | sub_410AE1 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_410AE1(__int64 a1)
{
return a1;
}
Q:[sub_410AE1,] | A:{'sub_410AE1': 'allocator'} | |
75ab5db9ebed82aba3f8edddf07b150870b57b1b9220ed50b1962f215b38d514_75ab5db9ebed82aba3f8edddf07b150870b57b1b9220ed50b1962f215b38d514.jsonl.gz | sub_403AA3 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_403AA3(const char *a1, _QWORD *a2)
{
__int64 v2; // r8
__int64 v3; // r9
unsigned int v5; // [rsp+14h] [rbp-Ch]
FILE *stream; // [rsp+18h] [rbp-8h]
stream = fopen(a1, "rb");
if ( !stream )
return 0xFFFFFFFFLL;
v5 = sub_403A41((__int64)stream, a2, 0LL, 0LL, v2, v3);
if ( v5 )
fclose(stream);
return v5;
}
Q:[a1,a2,stream,sub_403AA3,sub_403A41,] | A:{'a1': 'path', 'a2': 'vf', 'stream': 'f', 'sub_403AA3': 'ov_fopen', 'sub_403A41': 'ov_open'} | |
2e7195e6bc11902cb1147d429b22ff6f7655de6050b37429b5d7074aaa0727e8_2e7195e6bc11902cb1147d429b22ff6f7655de6050b37429b5d7074aaa0727e8.jsonl.gz | sub_443E53 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_443E53(FILE **a1, __int64 a2)
{
return sub_4228BC(*a1, "vt:i4", a2, 0LL);
}
Q:[a1,a2,sub_443E53,sub_4228BC,] | A:{'a1': 'self', 'a2': 'value', 'sub_443E53': '_write_vt_i4', 'sub_4228BC': 'lxw_xml_data_element'} | |
6e348e984bd63ac982d83dafa4e61fb9925c759b418264e141a667eb3a0dba17_6e348e984bd63ac982d83dafa4e61fb9925c759b418264e141a667eb3a0dba17.jsonl.gz | sub_441BDC | Help user generate meaningful names for variables and functions in the following code snippet. |
_WORD *__fastcall sub_441BDC(int a1, _WORD *a2)
{
double v2; // xmm0_8
float v3; // xmm0_4
double v4; // xmm0_8
float v5; // xmm0_4
_WORD *result; // rax
float v7; // [rsp+18h] [rbp-8h]
float v8; // [rsp+1Ch] [rbp-4h]
float v9; // [rsp+1Ch] [rbp-4h]
v8 = *(float *)(qword_4E6B90 + 112) * (float)((__int16)a1 - *(__int16 *)(qword_4E6B90 + 116));
v7 = (float)*(__int16 *)(qword_4E6B90 + 106)
- (float)(*(float *)(qword_4E6B90 + 112) * (float)(SHIWORD(a1) - *(__int16 *)(qword_4E6B90 + 118)));
if ( v8 <= 0.0 )
v2 = -0.5;
else
v2 = 0.5;
v3 = v2 + v8;
v9 = v3;
if ( v7 <= 0.0 )
v4 = -0.5;
else
v4 = 0.5;
v5 = v4 + v7;
*a2 = (int)v9;
result = a2;
a2[1] = (int)v5;
return result;
}
Q:[a2,v7,v9,sub_441BDC,] | A:{'a2': 'wpt', 'v7': 'tmpy', 'v9': 'tmpx', 'sub_441BDC': 'user_to_window'} | |
766fcda9ae8f843f16029f36de9fe2b19ddfd2d7a292f41ecb27d8ce5fd424d3_766fcda9ae8f843f16029f36de9fe2b19ddfd2d7a292f41ecb27d8ce5fd424d3.jsonl.gz | sub_4356BB | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4356BB(double a1, double a2)
{
if ( a1 <= a2 )
a1 = a2;
return *(_QWORD *)&a1;
}
Q:[a1,a2,sub_4356BB,] | A:{'a1': 'x', 'a2': 'y', 'sub_4356BB': 'qpOASES_getMax_10'} | |
6fd1fd6b811014087ab068b5dde4a7c86fc54e8e790d85b5135cc35bc9885aab_6fd1fd6b811014087ab068b5dde4a7c86fc54e8e790d85b5135cc35bc9885aab.jsonl.gz | sub_420B79 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_420B79()
{
int v0; // er9
int v1; // er9
const char *v2; // rax
int v4; // er9
int v6; // er9
const char *v7; // rax
int v9; // er9
int v11; // er9
char *v13; // [rsp+18h] [rbp-18h] BYREF
__int64 v14; // [rsp+20h] [rbp-10h]
__int64 v15; // [rsp+28h] [rbp-8h]
tcase_fn_start("test_set_log_env", "check_check_log.c", 69LL);
v15 = suite_create("Suite");
v14 = srunner_create(v15);
if ( sub_4209E2("CK_LOG_FILE_NAME", "test_log", &v13) )
ck_assert_failed(
(unsigned int)"check_check_log.c",
76,
(unsigned int)"Assertion 'save_set_env(\"CK_LOG_FILE_NAME\", \"test_log\", &old_val) == 0' failed",
(unsigned int)"Failed to set environment variable",
0,
v0);
mark_point("check_check_log.c", 76LL);
if ( !(unsigned int)srunner_has_log(v14) )
ck_assert_failed(
(unsigned int)"check_check_log.c",
79,
(unsigned int)"Assertion 'srunner_has_log (sr)' failed",
(unsigned int)"SRunner not logging",
0,
v1);
mark_point("check_check_log.c", 79LL);
v2 = (const char *)srunner_log_fname(v14);
if ( strcmp(v2, "test_log") )
ck_assert_failed(
(unsigned int)"check_check_log.c",
80,
(unsigned int)"Assertion 'strcmp(srunner_log_fname(sr), \"test_log\") == 0' failed",
(unsigned int)"Bad file name returned",
0,
v4);
mark_point("check_check_log.c", 80LL);
srunner_set_log(v14, "test2_log");
if ( !(unsigned int)srunner_has_log(v14) )
ck_assert_failed(
(unsigned int)"check_check_log.c",
87,
(unsigned int)"Assertion 'srunner_has_log (sr)' failed",
(unsigned int)"SRunner not logging",
0,
v6);
mark_point("check_check_log.c", 87LL);
v7 = (const char *)srunner_log_fname(v14);
if ( strcmp(v7, "test2_log") )
ck_assert_failed(
(unsigned int)"check_check_log.c",
88,
(unsigned int)"Assertion 'strcmp(srunner_log_fname(sr), \"test2_log\") == 0' failed",
(unsigned int)"Bad file name returned",
0,
v9);
mark_point("check_check_log.c", 88LL);
if ( (unsigned int)sub_420A23("CK_LOG_FILE_NAME", v13) )
ck_assert_failed(
(unsigned int)"check_check_log.c",
92,
(unsigned int)"Assertion 'restore_env(\"CK_LOG_FILE_NAME\", old_val) == 0' failed",
(unsigned int)"Failed to restore environment variable",
0,
v11);
mark_point("check_check_log.c", 92LL);
return srunner_free(v14);
}
Q:[v13,v14,v15,sub_420B79,sub_4209E2,sub_420A23,] | A:{'v13': 'old_val', 'v14': 'sr', 'v15': 's', 'sub_420B79': 'test_set_log_env', 'sub_4209E2': 'save_set_env', 'sub_420A23': 'restore_env'} | |
1c5460c06114eba18295c931be056dec04bc7d84e64fe0f7be9f3a01688aae40_1c5460c06114eba18295c931be056dec04bc7d84e64fe0f7be9f3a01688aae40.jsonl.gz | sub_496900 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_496900(__int64 a1, __int64 a2, __int64 a3, unsigned __int64 a4, void (__fastcall *a5)(__int64, const char *, _QWORD), __int64 a6, _QWORD *a7)
{
__int64 result; // rax
__int64 v10; // [rsp+38h] [rbp-18h]
_QWORD *v11; // [rsp+38h] [rbp-18h]
if ( a7[3]
&& ((v10 = *a7 + 24LL * a7[3] - 24, a3 == *(_QWORD *)(v10 + 8)) || a3 == *(_QWORD *)(v10 + 8) + 1LL)
&& a2 == *(_QWORD *)(v10 + 16) )
{
if ( a4 > *(_QWORD *)(v10 + 8) )
*(_QWORD *)(v10 + 8) = a4;
result = 1LL;
}
else
{
v11 = (_QWORD *)tracy::backtrace_vector_grow(a1, 0x18uLL, a5, a6, (__int64)a7);
if ( v11 )
{
*v11 = a3;
v11[1] = a4;
v11[2] = a2;
++a7[3];
result = 1LL;
}
else
{
result = 0LL;
}
}
return result;
}
Q:[a3,a4,a1,a2,a5,a6,a7,v10,sub_496900,] | A:{'a3': 'lowpc', 'a4': 'highpc', 'a1': 'state', 'a2': 'rdata', 'a5': 'error_callback', 'a6': 'data', 'a7': 'pvec', 'v10': 'p', 'sub_496900': 'add_unit_addr'} | |
4c37d94e6e7036c83e2bbac033138232245f9e10dde9739277eb47fcaa18953e_4c37d94e6e7036c83e2bbac033138232245f9e10dde9739277eb47fcaa18953e.jsonl.gz | sub_41FCC0 | Help user generate meaningful names for variables and functions in the following code snippet. |
const char *__fastcall sub_41FCC0(int a1, bool *a2)
{
const char *result; // rax
__int64 v3; // rcx
result = 0LL;
if ( a1 <= 5 )
{
result = "Infinite";
v3 = (unsigned int)dword_4440F0[a1];
*a2 = (_DWORD)qword_4D9D70 == (_DWORD)v3;
if ( (_DWORD)v3 )
{
snprintf(s, 0x7FuLL, "%7d", v3);
result = s;
}
}
return result;
}
Q:[a1,a2,sub_41FCC0,] | A:{'a1': 'nIndex', 'a2': 'bSelected', 'sub_41FCC0': 'MicroProfileUIMenuAggregate'} | |
3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353_3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353.jsonl.gz | sub_469A4D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_469A4D(__int64 a1, __int64 a2, int a3, int a4, int a5, unsigned int a6, float a7, float a8, float a9, float a10)
{
int v15; // [rsp+30h] [rbp-30h] BYREF
int v16; // [rsp+34h] [rbp-2Ch]
int v17; // [rsp+38h] [rbp-28h]
__int64 v18; // [rsp+40h] [rbp-20h]
__int64 v19; // [rsp+48h] [rbp-18h] BYREF
int v20; // [rsp+54h] [rbp-Ch] BYREF
int v21; // [rsp+58h] [rbp-8h] BYREF
int v22; // [rsp+5Ch] [rbp-4h]
v22 = sub_4654C4(a1, a6, &v19);
sub_4664CD(a1, a6, &v21, &v20, 0LL, 0LL, a7, a8, a9, a10);
v18 = a2;
v15 = a3;
v16 = a4;
v17 = a5;
if ( a3 && v16 )
sub_4696DB(&v15, v19, v22, v21, v20, 1, 0.34999999, a7, a8, a9, a10);
return sub_40F90B(v19);
}
Q:[a3,a4,a1,a2,a5,a6,a7,a8,a9,a10,v15,v19,v20,v21,v22,sub_469A4D,sub_4654C4,sub_4664CD,sub_4696DB,sub_40F90B,] | A:{'a3': 'out_w', 'a4': 'out_h', 'a1': 'info', 'a2': 'output', 'a5': 'out_stride', 'a6': 'glyph', 'a7': 'scale_x', 'a8': 'scale_y', 'a9': 'shift_x', 'a10': 'shift_y', 'v15': 'gbm', 'v19': 'vertices', 'v20': 'iy0', 'v21': 'ix0', 'v22': 'num_verts', 'sub_469A4D': 'stbtt_MakeGlyphBitmapSubpixel', 'sub_4654C4': 'stbtt_GetGlyphShape', 'sub_4664CD': 'stbtt_GetGlyphBitmapBoxSubpixel', 'sub_4696DB': 'stbtt_Rasterize', 'sub_40F90B': 'MemFree'} | |
e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433_e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433.jsonl.gz | sub_409B6F | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_409B6F(unsigned __int64 a1, __int64 a2)
{
bool v2; // bl
char v4[9]; // [rsp+1Fh] [rbp-11h] BYREF
sub_409D5E(v4, a2);
v2 = a1 > sub_409EC7(v4);
sub_409850((__int64)v4);
if ( v2 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
return a1;
}
Q:[sub_409B6F,sub_409D5E,sub_409EC7,sub_409850,] | A:{'sub_409B6F': '_S_check_init_len', 'sub_409D5E': 'allocator', 'sub_409EC7': '_S_max_size', 'sub_409850': '~allocator'} | |
4b6879214768d5629dffdb5907a53a98ff471e93ed4708d9e41908572afb8641_4b6879214768d5629dffdb5907a53a98ff471e93ed4708d9e41908572afb8641.jsonl.gz | sub_40B627 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40B627(unsigned int *a1, int a2)
{
int v2; // eax
__int64 v4; // [rsp+18h] [rbp-18h] BYREF
int v5[2]; // [rsp+20h] [rbp-10h] BYREF
__int64 *v6; // [rsp+28h] [rbp-8h]
v4 = (int)abs32(a2);
if ( a2 >= 0 )
v2 = 1;
else
v2 = -1;
v5[0] = v2;
v5[1] = 1;
v6 = &v4;
return sub_40B49C(a1, (__int64)v5);
}
Q:[a1,a2,v4,v5,sub_40B627,sub_40B49C,] | A:{'a1': 'X', 'a2': 'z', 'v4': 'p', 'v5': 'Y', 'sub_40B627': 'mpi_cmp_int', 'sub_40B49C': 'mpi_cmp_mpi'} | |
98b37e3e65106c5188b46163dfb0f0c998cbb4097476f58901e20617a1ff914e_98b37e3e65106c5188b46163dfb0f0c998cbb4097476f58901e20617a1ff914e.jsonl.gz | sub_401696 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 __fastcall sub_401696(char a1)
{
if ( ((*__ctype_b_loc())[a1] & 0x400) != 0 )
return 1LL;
if ( ((*__ctype_b_loc())[a1] & 0x800) != 0 )
return 1LL;
switch ( a1 )
{
case '.':
return 1LL;
case '&':
return 1LL;
case '?':
return 1LL;
case '#':
return 1LL;
case '/':
return 1LL;
case '%':
return 1LL;
case '$':
return 1LL;
case '[':
return 1LL;
case '@':
return 1LL;
case '!':
return 1LL;
}
return a1 == 94;
}
Q:[a1,sub_401696,] | A:{'a1': 'ch_0', 'sub_401696': 'is_valid_label_char'} | |
20c07804a3f28a6a5c3f8253e79de0ec1aedc41632a0737ad8dad981cd237640_20c07804a3f28a6a5c3f8253e79de0ec1aedc41632a0737ad8dad981cd237640.jsonl.gz | sub_464BED | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_464BED(__int64 a1)
{
if ( a1 )
{
sub_47335E(sub_4625B2, 0LL, a1);
sub_47335E(sub_464FD9, a1, 0LL);
if ( *(_QWORD *)(a1 + 312) )
sub_4A09F9(*(_QWORD *)(a1 + 312));
sub_47190A(*(_QWORD *)(a1 + 304));
free(*(void **)(a1 + 264));
free((void *)a1);
}
}
Q:[a1,sub_464BED,sub_47335E,sub_4A09F9,sub_47190A,] | A:{'a1': 'sm', 'sub_464BED': 'eapol_auth_free', 'sub_47335E': 'eloop_cancel_timeout', 'sub_4A09F9': 'eap_server_sm_deinit', 'sub_47190A': 'wpabuf_free'} | |
5b4a6854c7a9b97be9d7bf435821c48ce23e4de1c96dc92250380b12856aa5f8_5b4a6854c7a9b97be9d7bf435821c48ce23e4de1c96dc92250380b12856aa5f8.jsonl.gz | sub_406537 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_406537(__int64 *a1, _DWORD *a2)
{
__int64 v2; // rax
int v3; // ebx
int v4; // eax
int v6; // [rsp+14h] [rbp-3Ch]
int v7; // [rsp+18h] [rbp-38h]
_QWORD *v8; // [rsp+38h] [rbp-18h]
sub_405F54(a1);
v8 = (_QWORD *)g_type_instance_get_private();
gtk_widget_get_style();
gtk_widget_get_pango_context();
gtk_widget_get_type();
v2 = g_type_check_class_cast();
(*(void (__fastcall **)(__int64 *, _DWORD *))(v2 + 240))(a1, a2);
pango_context_get_language();
pango_context_get_metrics();
v3 = pango_font_metrics_get_ascent();
a2[1] += (int)(v3 + pango_font_metrics_get_descent() + 512) >> 10;
if ( *v8 )
{
v7 = pango_font_metrics_get_approximate_char_width();
v6 = pango_font_metrics_get_approximate_digit_width();
v4 = v7;
if ( v6 >= v7 )
v4 = v6;
*a2 += 3 * ((v4 + 512) >> 10);
}
return pango_font_metrics_unref();
}
Q:[a1,a2,v6,v7,v8,sub_406537,sub_405F54,] | A:{'a1': 'widget', 'a2': 'requisition', 'v6': 'digit_width', 'v7': 'char_width', 'v8': 'privatea', 'sub_406537': 'gimp_spin_scale_size_request', 'sub_405F54': 'gimp_spin_scale_get_type'} |