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 |
|---|---|---|---|---|---|
7936d99c58ad8e09fdacc59f86724a4d80e6db529b067b93ed38c8c35d68b2c0_7936d99c58ad8e09fdacc59f86724a4d80e6db529b067b93ed38c8c35d68b2c0.jsonl.gz | sub_401D5D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_401D5D()
{
return libusb_control_transfer();
}
Q:[sub_401D5D,] | A:{'sub_401D5D': 'usb_req_no_leak'} | |
88bd1a67d86d397d125d1dfba3db20c19e4e3d299a8a38fc732136c78cec6b01_88bd1a67d86d397d125d1dfba3db20c19e4e3d299a8a38fc732136c78cec6b01.jsonl.gz | sub_4054D3 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_4054D3()
{
return sub_404E69("/dev/i2c-1", &dword_40B1B8);
}
Q:[sub_4054D3,sub_404E69,] | A:{'sub_4054D3': 'hmc5883l_interface_iic_init', 'sub_404E69': 'iic_init'} | |
2f87019bcafb28a2aa1cb80b55ea9b24b542c7cbbe0806344c2ec21759477cbf_2f87019bcafb28a2aa1cb80b55ea9b24b542c7cbbe0806344c2ec21759477cbf.jsonl.gz | sub_4250DA | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4250DA(__int64 a1)
{
__int64 v2[4]; // [rsp+10h] [rbp-280h] BYREF
int v3; // [rsp+30h] [rbp-260h]
const char *v4; // [rsp+38h] [rbp-258h]
__int64 (__fastcall *v5)(unsigned int, __int64); // [rsp+40h] [rbp-250h]
const char *v6; // [rsp+48h] [rbp-248h]
const char *v7; // [rsp+50h] [rbp-240h]
int v8; // [rsp+58h] [rbp-238h]
const char *v9; // [rsp+60h] [rbp-230h]
__int64 (__fastcall *v10)(unsigned int, __int64); // [rsp+68h] [rbp-228h]
const char *v11; // [rsp+70h] [rbp-220h]
const char *v12; // [rsp+78h] [rbp-218h]
int v13; // [rsp+80h] [rbp-210h]
const char *v14; // [rsp+88h] [rbp-208h]
__int64 (__fastcall *v15)(unsigned int, __int64, __int64, __int64, __int64, __int64); // [rsp+90h] [rbp-200h]
const char *v16; // [rsp+98h] [rbp-1F8h]
const char *v17; // [rsp+A0h] [rbp-1F0h]
int v18; // [rsp+A8h] [rbp-1E8h]
const char *v19; // [rsp+B0h] [rbp-1E0h]
__int64 (__fastcall *v20)(unsigned int, __int64); // [rsp+B8h] [rbp-1D8h]
const char *v21; // [rsp+C0h] [rbp-1D0h]
const char *v22; // [rsp+C8h] [rbp-1C8h]
int v23; // [rsp+D0h] [rbp-1C0h]
const char *v24; // [rsp+D8h] [rbp-1B8h]
__int64 (__fastcall *v25)(unsigned int, __int64, __int64, __int64, __int64, __int64); // [rsp+E0h] [rbp-1B0h]
const char *v26; // [rsp+E8h] [rbp-1A8h]
const char *v27; // [rsp+F0h] [rbp-1A0h]
int v28; // [rsp+F8h] [rbp-198h]
const char *v29; // [rsp+100h] [rbp-190h]
__int64 (__fastcall *v30)(unsigned int, __int64 *); // [rsp+108h] [rbp-188h]
const char *v31; // [rsp+110h] [rbp-180h]
const char *v32; // [rsp+118h] [rbp-178h]
int v33; // [rsp+120h] [rbp-170h]
const char *v34; // [rsp+128h] [rbp-168h]
__int64 (__fastcall *v35)(unsigned int, __int64 *); // [rsp+130h] [rbp-160h]
const char *v36; // [rsp+138h] [rbp-158h]
const char *v37; // [rsp+140h] [rbp-150h]
int v38; // [rsp+148h] [rbp-148h]
const char *v39; // [rsp+150h] [rbp-140h]
__int64 (__fastcall *v40)(unsigned int, __int64 *, __int64, __int64, __int64, __int64); // [rsp+158h] [rbp-138h]
const char *v41; // [rsp+160h] [rbp-130h]
const char *v42; // [rsp+168h] [rbp-128h]
int v43; // [rsp+170h] [rbp-120h]
const char *v44; // [rsp+178h] [rbp-118h]
__int64 (__fastcall *v45)(unsigned int, __int64 *, __int64, __int64, __int64, __int64); // [rsp+180h] [rbp-110h]
const char *v46; // [rsp+188h] [rbp-108h]
const char *v47; // [rsp+190h] [rbp-100h]
int v48; // [rsp+198h] [rbp-F8h]
const char *v49; // [rsp+1A0h] [rbp-F0h]
__int64 (__fastcall *v50)(signed int, __int64, __int64, __int64, __int64, __int64); // [rsp+1A8h] [rbp-E8h]
const char *v51; // [rsp+1B0h] [rbp-E0h]
const char *v52; // [rsp+1B8h] [rbp-D8h]
int v53; // [rsp+1C0h] [rbp-D0h]
const char *v54; // [rsp+1C8h] [rbp-C8h]
__int64 (__fastcall *v55)(unsigned int, __int64); // [rsp+1D0h] [rbp-C0h]
const char *v56; // [rsp+1D8h] [rbp-B8h]
const char *v57; // [rsp+1E0h] [rbp-B0h]
int v58; // [rsp+1E8h] [rbp-A8h]
const char *v59; // [rsp+1F0h] [rbp-A0h]
__int64 (__fastcall *v60)(unsigned int, __int64); // [rsp+1F8h] [rbp-98h]
const char *v61; // [rsp+200h] [rbp-90h]
const char *v62; // [rsp+208h] [rbp-88h]
int v63; // [rsp+210h] [rbp-80h]
const char *v64; // [rsp+218h] [rbp-78h]
__int64 (__fastcall *v65)(unsigned int, _QWORD *); // [rsp+220h] [rbp-70h]
const char *v66; // [rsp+228h] [rbp-68h]
const char *v67; // [rsp+230h] [rbp-60h]
int v68; // [rsp+238h] [rbp-58h]
const char *v69; // [rsp+240h] [rbp-50h]
__int64 (__fastcall *v70)(unsigned int, __int64); // [rsp+248h] [rbp-48h]
const char *v71; // [rsp+250h] [rbp-40h]
const char *v72; // [rsp+258h] [rbp-38h]
int v73; // [rsp+260h] [rbp-30h]
__int64 v74; // [rsp+268h] [rbp-28h]
__int64 v75; // [rsp+270h] [rbp-20h]
__int64 v76; // [rsp+278h] [rbp-18h]
__int64 v77; // [rsp+280h] [rbp-10h]
int v78; // [rsp+288h] [rbp-8h]
v2[0] = (__int64)"ffi/native";
v2[1] = (__int64)sub_424CF2;
v2[2] = (__int64)"(ffi/native &opt path)\n"
"\n"
"Load a shared object or dll from the given path, and do not extract or run any code from it. This is "
"different than `native`, which will run initialization code to get a module table. If `path` is nil, "
"opens the current running binary. Returns a `core/native`.";
v2[3] = (__int64)"src/core/ffi.c";
v3 = 1448;
v4 = "ffi/lookup";
v5 = sub_424DBA;
v6 = "(ffi/lookup native symbol-name)\n"
"\n"
"Lookup a symbol from a native object. All symbol lookups will return a raw pointer if the symbol is found, else nil.";
v7 = "src/core/ffi.c";
v8 = 1466;
v9 = "ffi/close";
v10 = sub_424E74;
v11 = "(ffi/close native)\n"
"\n"
"Free a native object. Dereferencing pointers to symbols in the object will have undefined behavior after freeing.";
v12 = "src/core/ffi.c";
v13 = 1480;
v14 = "ffi/signature";
v15 = sub_423A5B;
v16 = "(ffi/signature calling-convention ret-type & arg-types)\n"
"\n"
"Create a function signature object that can be used to make calls with raw function pointers.";
v17 = "src/core/ffi.c";
v18 = 766;
v19 = "ffi/call";
v20 = sub_424937;
v21 = "(ffi/call pointer signature & args)\n"
"\n"
"Call a raw pointer as a function pointer. The function signature specifies how Janet values in `args` are conver"
"ted to native machine types.";
v22 = "src/core/ffi.c";
v23 = 1355;
v24 = "ffi/struct";
v25 = sub_422AE0;
v26 = "(ffi/struct & types)\n"
"\n"
"Create a struct type definition that can be used to pass structs into native functions. ";
v27 = "src/core/ffi.c";
v28 = 452;
v29 = "ffi/write";
v30 = sub_4249DE;
v31 = "(ffi/write ffi-type data &opt buffer index)\n"
"\n"
"Append a native type to a buffer such as it would appear in memory. This can be used to pass pointers to structs"
" in the ffi, or send C/C++/native structs over the network or to files. Returns a modifed buffer or a new buffer"
" if one is not supplied.";
v32 = "src/core/ffi.c";
v33 = 1379;
v34 = "ffi/read";
v35 = sub_424B44;
v36 = "(ffi/read ffi-type bytes &opt offset)\n"
"\n"
"Parse a native struct out of a buffer and convert it to normal Janet data structures. This function is the inver"
"se of `ffi/write`. `bytes` can also be a raw pointer, although this is unsafe.";
v37 = "src/core/ffi.c";
v38 = 1402;
v39 = "ffi/size";
v40 = sub_422B28;
v41 = "(ffi/size type)\n\nGet the size of an ffi type in bytes.";
v42 = "src/core/ffi.c";
v43 = 459;
v44 = "ffi/align";
v45 = sub_422BB2;
v46 = "(ffi/align type)\n\nGet the align of an ffi type in bytes.";
v47 = "src/core/ffi.c";
v48 = 467;
v49 = "ffi/trampoline";
v50 = sub_424C7C;
v51 = "(ffi/trampoline cc)\n"
"\n"
"Get a native function pointer that can be used as a callback and passed to C libraries. This callback trampoline"
" has the signature `void trampoline(void \\*ctx, void \\*userdata)` in the given calling convention. This is the"
" only function signature supported. It is up to the programmer to ensure that the `userdata` argument contains a"
" janet function the will be called with one argument, `ctx` which is an opaque pointer. This pointer can be furt"
"her inspected with `ffi/read`.";
v52 = "src/core/ffi.c";
v53 = 1422;
v54 = "ffi/jitfn";
v55 = sub_424806;
v56 = "(ffi/jitfn bytes)\n"
"\n"
"Create an abstract type that can be used as the pointer argument to `ffi/call`. The content of `bytes` is archit"
"ecture specific machine code that will be copied into executable memory.";
v57 = "src/core/ffi.c";
v58 = 1302;
v59 = "ffi/malloc";
v60 = sub_424F11;
v61 = "(ffi/malloc size)\n"
"\n"
"Allocates memory directly using the janet memory allocator. Memory allocated in this way must be freed manually!"
" Returns a raw pointer, or nil if size = 0.";
v62 = "src/core/ffi.c";
v63 = 1494;
v64 = "ffi/free";
v65 = sub_424F86;
v66 = "(ffi/free pointer)\n\nFree memory allocated with `ffi/malloc`. Returns nil.";
v67 = "src/core/ffi.c";
v68 = 1504;
v69 = "ffi/pointer-buffer";
v70 = sub_425014;
v71 = "(ffi/pointer-buffer pointer capacity &opt count offset)\n"
"\n"
"Create a buffer from a pointer. The underlying memory of the buffer will not be reallocated or freed by the garb"
"age collector, allowing unmanaged, mutable memory to be manipulated with buffer functions. Attempts to resize or"
" extend the buffer beyond its initial capacity will raise an error. As with many FFI functions, this is memory u"
"nsafe and can potentially allow out of bounds memory access. Returns a new buffer.";
v72 = "src/core/ffi.c";
v73 = 1515;
v74 = 0LL;
v75 = 0LL;
v76 = 0LL;
v77 = 0LL;
v78 = 0;
return sub_4573EE(a1, 0LL, v2);
}
Q:[a1,v2,sub_4250DA,sub_424CF2,sub_424DBA,sub_424E74,sub_423A5B,sub_424937,sub_422AE0,sub_4249DE,sub_424B44,sub_422B28,sub_422BB2,sub_424C7C,sub_424806,sub_424F11,sub_424F86,sub_425014,sub_4573EE,] | A:{'a1': 'env', 'v2': 'ffi_cfuns', 'sub_4250DA': 'janet_lib_ffi', 'sub_424CF2': 'janet_core_raw_native', 'sub_424DBA': 'janet_core_native_lookup', 'sub_424E74': 'janet_core_native_close', 'sub_423A5B': 'cfun_ffi_signature', 'sub_424937': 'cfun_ffi_call', 'sub_422AE0': 'cfun_ffi_struct', 'sub_4249DE': 'cfun_ffi_buffer_write', 'sub_424B44': 'cfun_ffi_buffer_read', 'sub_422B28': 'cfun_ffi_size', 'sub_422BB2': 'cfun_ffi_align', 'sub_424C7C': 'cfun_ffi_get_callback_trampoline', 'sub_424806': 'cfun_ffi_jitfn', 'sub_424F11': 'cfun_ffi_malloc', 'sub_424F86': 'cfun_ffi_free', 'sub_425014': 'cfun_ffi_pointer_buffer', 'sub_4573EE': 'janet_cfuns_ext'} | |
a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4_a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4.jsonl.gz | sub_48416C | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_48416C(__int64 a1, __int64 a2)
{
__int64 v2; // rax
v2 = sub_47DE63(a2);
return sub_488762(v2);
}
Q:[sub_48416C,sub_47DE63,sub_488762,] | A:{'sub_48416C': 'allocator', 'sub_47DE63': 'allocator', 'sub_488762': 'allocator'} | |
4d27d00763c053c6863afd9e1d4030266d5af6d886cf33c8ebc38a0747faf190_4d27d00763c053c6863afd9e1d4030266d5af6d886cf33c8ebc38a0747faf190.jsonl.gz | sub_409FB9 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BYTE *__fastcall sub_409FB9(_BYTE *a1, __int16 a2)
{
_BYTE *result; // rax
*a1 = HIBYTE(a2);
result = a1 + 1;
a1[1] = a2;
return result;
}
Q:[a1,a2,sub_409FB9,] | A:{'a1': 'p_desc_n', 'a2': 'i_cell_id', 'sub_409FB9': 'desc6dn_set_cell_id'} | |
9238d686ece7ae9f0d81af00cc27fe44cd971455482c1d596e5cbe1c2530c5ba_9238d686ece7ae9f0d81af00cc27fe44cd971455482c1d596e5cbe1c2530c5ba.jsonl.gz | sub_4039A9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4039A9(__int64 a1, _DWORD *a2)
{
__int64 result; // rax
unsigned int v3; // [rsp+14h] [rbp-Ch]
_DWORD *v4; // [rsp+18h] [rbp-8h]
if ( (unsigned int)sub_40290F(a2) == -1 )
return 0xFFFFFFFFLL;
v4 = (_DWORD *)sub_402696(1024, a2[2]);
if ( !v4 )
return 0xFFFFFFFFLL;
if ( (unsigned int)sub_404F7D(v4, a1) == -1 )
{
sub_4028AF((__int64)v4);
result = 0xFFFFFFFFLL;
}
else
{
v3 = sub_403557(v4, a2);
sub_4028AF((__int64)v4);
result = v3;
}
return result;
}
Q:[a1,a2,v3,v4,sub_4039A9,sub_40290F,sub_402696,sub_404F7D,sub_4028AF,sub_403557,] | A:{'a1': 'toappend', 'a2': 'target', 'v3': 'return_value', 'v4': 'temp', 'sub_4039A9': 'js_qappend', 'sub_40290F': 'js_has_sanity', 'sub_402696': 'js_create', 'sub_404F7D': 'js_qstr2js', 'sub_4028AF': 'js_destroy', 'sub_403557': 'js_append'} | |
7f545c8ae1786b370896c7ac49cb69fcc76f45d194b51355543a701e3d409007_7f545c8ae1786b370896c7ac49cb69fcc76f45d194b51355543a701e3d409007.jsonl.gz | sub_42E31F | Help user generate meaningful names for variables and functions in the following code snippet. |
void *__fastcall sub_42E31F(__int64 a1, _DWORD *a2)
{
_QWORD *v2; // rbx
int v3; // eax
void **v4; // rbx
void *s; // [rsp+10h] [rbp-20h]
int v7; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
if ( !*((_QWORD *)ptr + 192) )
{
v2 = ptr;
v2[192] = calloc(1uLL, 0x18uLL);
}
for ( i = 0; i < *(_DWORD *)(*((_QWORD *)ptr + 192) + 12LL) && *(_QWORD *)(**((_QWORD **)ptr + 192) + 8LL * i); ++i )
;
if ( i == *(_DWORD *)(*((_QWORD *)ptr + 192) + 8LL) )
{
if ( i )
v3 = 2 * i;
else
v3 = 2;
v7 = v3;
v4 = (void **)*((_QWORD *)ptr + 192);
*v4 = realloc(*v4, 8LL * v3);
if ( v7 <= 2 )
memset(**((void ***)ptr + 192), 0, 8LL * v7);
else
memset((void *)(**((_QWORD **)ptr + 192) + 8LL * i), 0, 8LL * (v7 / 2));
*(_DWORD *)(*((_QWORD *)ptr + 192) + 8LL) = v7;
}
s = malloc(0x1A8uLL);
if ( !s )
return 0LL;
++*(_DWORD *)(*((_QWORD *)ptr + 192) + 12LL);
*(_QWORD *)(8LL * i + **((_QWORD **)ptr + 192)) = s;
memset(s, 0, 0x1A8uLL);
if ( a2 )
*a2 = i;
*((_QWORD *)s + 52) = strdup(*(const char **)(a1 + 8));
sub_46A8D3(s, a1, off_4B3440);
*((_QWORD *)s + 2) = 0LL;
*((_DWORD *)s + 15) = -1;
return s;
}
Q:[a1,a2,s,v7,i,sub_42E31F,sub_46A8D3,] | A:{'a1': 'b', 'a2': 'num', 's': 'result', 'v7': 'newlen', 'i': 'c', 'sub_42E31F': 'disksim_bus_loadparams', 'sub_46A8D3': 'lp_loadparams'} | |
7d5cad6a21fdd89bd9078a7fa1fa7ddb4c55042e0fb93d88a15393c50b75c440_7d5cad6a21fdd89bd9078a7fa1fa7ddb4c55042e0fb93d88a15393c50b75c440.jsonl.gz | sub_401224 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_401224(unsigned int a1, int a2)
{
return sub_401207(a1, a2);
}
Q:[a1,a2,sub_401224,sub_401207,] | A:{'a1': 'a', 'a2': 'b', 'sub_401224': 'constant_time_eq_8', 'sub_401207': 'constant_time_eq'} | |
cd1db804d710f0be5cc8bd34a21a7aab3c043c465348f2d7ee3f4850690337f5_cd1db804d710f0be5cc8bd34a21a7aab3c043c465348f2d7ee3f4850690337f5.jsonl.gz | sub_40BE43 | Help user generate meaningful names for variables and functions in the following code snippet. |
_DWORD *__fastcall sub_40BE43(__int64 a1, unsigned int a2, __int64 a3)
{
char v3; // r12
char v4; // bl
__int64 v5; // rax
struct timeval v7; // [rsp+20h] [rbp-40h] BYREF
struct timeval tv; // [rsp+30h] [rbp-30h] BYREF
int v9; // [rsp+40h] [rbp-20h]
char v10; // [rsp+46h] [rbp-1Ah]
char v11; // [rsp+47h] [rbp-19h]
__int64 v12; // [rsp+48h] [rbp-18h]
v12 = a3;
v11 = 115;
v10 = 97;
sub_406AC8(a3, 3, a2);
gettimeofday(&tv, 0LL);
sub_409C3A(v12);
sub_40B150(v12, a1, a2);
sub_409CBB(v12);
gettimeofday(&v7, 0LL);
v9 = (int)sub_406966(&v7, &tv) / 1000;
v3 = v10;
v4 = v11;
v5 = sub_406901(&tv);
sub_407196(*(_QWORD *)(v12 + 1840), v5, v9, v4, v3);
return sub_406B14(v12);
}
Q:[a3,a1,a2,v7,tv,v9,v10,v11,v12,sub_40BE43,sub_406AC8,sub_409C3A,sub_40B150,sub_409CBB,sub_406966,sub_406901,sub_407196,sub_406B14,] | A:{'a3': 'data', 'a1': 'el', 'a2': 'fd', 'v7': '_et', 'tv': '_st', 'v9': '_duration', 'v10': '_s2', 'v11': '_s1', 'v12': 'rep', 'sub_40BE43': 'slave_accept_handler', 'sub_406AC8': 'applog_enter_session', 'sub_409C3A': 'acl_enter', 'sub_40B150': 'slave_accept', 'sub_409CBB': 'acl_leave', 'sub_406966': 'tvdiff_usec', 'sub_406901': 'msec_from_tv', 'sub_407196': 'slowlog_add', 'sub_406B14': 'applog_leave_session'} | |
dade8a50f9553a2c8d312f40f9e938d800aaeceed2d235843ec2760ee3f4ab45_dade8a50f9553a2c8d312f40f9e938d800aaeceed2d235843ec2760ee3f4ab45.jsonl.gz | sub_40C97F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40C97F(__int64 a1, _QWORD *a2, _QWORD *a3)
{
if ( !a1 || !a3 || !a2 )
return 0LL;
if ( a3 == a2 )
return 1LL;
*a3 = *a2;
a3[1] = a2[1];
if ( *a3 )
*(_QWORD *)(*a3 + 8LL) = a3;
if ( a2 == *(_QWORD **)(a1 + 16) )
{
if ( *(_QWORD *)(*(_QWORD *)(a1 + 16) + 8LL) == *(_QWORD *)(a1 + 16) )
a3[1] = a3;
*(_QWORD *)(a1 + 16) = a3;
}
else
{
if ( a3[1] )
*(_QWORD *)a3[1] = a3;
if ( !*a3 )
*(_QWORD *)(*(_QWORD *)(a1 + 16) + 8LL) = a3;
}
*a2 = 0LL;
a2[1] = 0LL;
sub_409322(a2);
return 1LL;
}
Q:[a3,a1,a2,sub_40C97F,sub_409322,] | A:{'a3': 'replacement', 'a1': 'parent', 'a2': 'item', 'sub_40C97F': 'cJSON_ReplaceItemViaPointer', 'sub_409322': 'cJSON_Delete'} | |
fabcd4074543f940b01553c817db2a3e881e2ff1f379817ba1cd84e20d54c14a_fabcd4074543f940b01553c817db2a3e881e2ff1f379817ba1cd84e20d54c14a.jsonl.gz | sub_40DB09 | Help user generate meaningful names for variables and functions in the following code snippet. |
_BYTE *__fastcall sub_40DB09(unsigned __int64 *a1, size_t a2, _BYTE *a3)
{
_QWORD v5[26]; // [rsp+20h] [rbp-D0h] BYREF
sub_40AFED(v5);
sub_40CA6B(v5, a1, a2);
return sub_40D836((__int64)v5, a3);
}
Q:[a3,a1,a2,v5,sub_40DB09,sub_40AFED,sub_40CA6B,sub_40D836,] | A:{'a3': 'buf', 'a1': 'data', 'a2': 'len', 'v5': 'ctx', 'sub_40DB09': 'SHA512Data', 'sub_40AFED': 'SHA512Init', 'sub_40CA6B': 'SHA512Update', 'sub_40D836': 'SHA512End'} | |
89a56c46f037f898ed5be52119007206f2226613e013c90a587db00e358dc334_89a56c46f037f898ed5be52119007206f2226613e013c90a587db00e358dc334.jsonl.gz | sub_413FAD | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_413FAD(__int64 a1, __int64 **a2)
{
_BYTE *v2; // rdx
__int64 v4; // [rsp+18h] [rbp-18h]
unsigned __int16 *v5; // [rsp+20h] [rbp-10h]
v5 = 0LL;
while ( a2 )
{
v4 = sub_413CAF(a1, a2[1]);
v5 = (unsigned __int16 *)sub_4107AE((__int64)v5, v4);
a2 = (__int64 **)*a2;
}
if ( v5 )
v2 = sub_410747(0x35u, v5);
else
v2 = 0LL;
sub_410A98(a1, 0xDu, (__int64)v2);
return 0LL;
}
Q:[a1,a2,v5,sub_413FAD,sub_413CAF,sub_4107AE,sub_410747,sub_410A98,] | A:{'a1': 'rec', 'a2': 'ap', 'v5': 'protos', 'sub_413FAD': 'sdp_set_add_access_protos', 'sub_413CAF': 'access_proto_to_dataseq', 'sub_4107AE': 'sdp_seq_append', 'sub_410747': 'sdp_data_alloc', 'sub_410A98': 'sdp_attr_add'} | |
56926e8e5152a5b06ab527d3f64330d53a117c9900022a6a8a2bb90c4fc01069_56926e8e5152a5b06ab527d3f64330d53a117c9900022a6a8a2bb90c4fc01069.jsonl.gz | sub_401353 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_401353(__int64 a1)
{
return *(_QWORD *)a1;
}
Q:[a1,sub_401353,] | A:{'a1': 'info', 'sub_401353': 'get_id'} | |
e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433_e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433.jsonl.gz | sub_4183B8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4183B8(__int64 a1, __int64 a2)
{
sub_4181B4((_QWORD *)a1);
*(_QWORD *)a1 = off_459A98;
*(_DWORD *)(a1 + 8) = 0;
return sub_419528(a1 + 16, a2);
}
Q:[sub_4183B8,sub_4181B4,sub_419528,] | A:{'sub_4183B8': 'HexDataProducer', 'sub_4181B4': 'DataProducer', 'sub_419528': 'vector'} | |
7421faa8c444aeca9266add08f45c75a4f43aebd993f880cd35dd964f63fdfb2_7421faa8c444aeca9266add08f45c75a4f43aebd993f880cd35dd964f63fdfb2.jsonl.gz | sub_462726 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_462726(_QWORD *a1, __int64 a2)
{
__int64 result; // rax
if ( a1 )
{
DH_free();
*a1 = 0LL;
result = 0LL;
}
else
{
*(_QWORD *)(__readfsqword(0) - 24) = "Error encountered in s2n_dhe.c:334";
*(_DWORD *)(__readfsqword(0) - 32) = 402653193;
sub_46D9B7(0LL, a2);
result = 0xFFFFFFFFLL;
}
return result;
}
Q:[a1,sub_462726,sub_46D9B7,] | A:{'a1': 'dh_params', 'sub_462726': 's2n_dh_params_free', 'sub_46D9B7': 's2n_calculate_stacktrace'} | |
dc18f2eab6fca0771187d56e937d87f9e9bff2864456e4b7f444dddf582e8e31_dc18f2eab6fca0771187d56e937d87f9e9bff2864456e4b7f444dddf582e8e31.jsonl.gz | sub_404CBF | Help user generate meaningful names for variables and functions in the following code snippet. |
unsigned __int64 __fastcall sub_404CBF(const char *a1, __int64 a2, __int64 a3)
{
__int64 v3; // rax
v3 = sub_402573(a1);
return sub_404C54(v3, a2, a3);
}
Q:[a3,a1,a2,sub_404CBF,sub_402573,sub_404C54,] | A:{'a3': 'arg1', 'a1': 'name', 'a2': 'arg0', 'sub_404CBF': 'new_binary_call', 'sub_402573': 'AST_new_symbol', 'sub_404C54': 'list3'} | |
ae353ff1d6b132e8bc266655cc0acee2a7cfbd29790838b22e9e2a3256b7a8f8_ae353ff1d6b132e8bc266655cc0acee2a7cfbd29790838b22e9e2a3256b7a8f8.jsonl.gz | sub_47A743 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __noreturn sub_47A743(__int64 a1, const char *a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6, ...)
{
gcc_va_list arg; // [rsp+18h] [rbp-C8h] BYREF
__int64 v7; // [rsp+40h] [rbp-A0h]
__int64 v8; // [rsp+48h] [rbp-98h]
__int64 v9; // [rsp+50h] [rbp-90h]
__int64 v10; // [rsp+58h] [rbp-88h]
v7 = a3;
v8 = a4;
v9 = a5;
v10 = a6;
if ( *(_QWORD *)(a1 + 200) )
{
arg[0].gp_offset = 16;
va_start(arg, a6);
vsnprintf(*(char **)(a1 + 200), 0x100uLL, a2, arg);
}
longjmp((struct __jmp_buf_tag *)a1, 1);
}
Q:[a1,a2,arg,sub_47A743,] | A:{'a1': 'opt_state', 'a2': 'fmt', 'arg': 'ap', 'sub_47A743': 'opt_error'} | |
0bdd3e3355b55ed2816435efa21042f8306da2b2ea7b587febce5c0891e6891f_0bdd3e3355b55ed2816435efa21042f8306da2b2ea7b587febce5c0891e6891f.jsonl.gz | sub_417085 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_417085()
{
__int64 v0; // rbp
_WORD *v1; // rax
*(_DWORD *)(*(_QWORD *)(v0 - 272) + **(__int16 **)(v0 - 264)) = *(_DWORD *)(*(__int16 *)(*(_QWORD *)(v0 - 264) + 2LL)
+ *(_QWORD *)(v0 - 272)) >= *(_DWORD *)(*(__int16 *)(*(_QWORD *)(v0 - 264) + 4LL) + *(_QWORD *)(v0 - 272));
*(_QWORD *)(v0 - 264) += 6LL;
v1 = *(_WORD **)(v0 - 264);
*(_QWORD *)(v0 - 264) = v1 + 1;
*(_WORD *)(v0 - 66) = *v1;
JUMPOUT(0x410F6ELL);
}
Q:[sub_417085,] | A:{'sub_417085': 'SGE32'} | |
3bd21ea222a0d610c070c5de5898e24a1d63c1bb05bac3ff8405291fd5ad51b6_3bd21ea222a0d610c070c5de5898e24a1d63c1bb05bac3ff8405291fd5ad51b6.jsonl.gz | sub_407B35 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_407B35(void *a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6)
{
sub_407AED((__int64)a1, a2, a3, a4, a5, a6);
free(a1);
}
Q:[a1,sub_407B35,sub_407AED,] | A:{'a1': 'entry', 'sub_407B35': 'free_extent', 'sub_407AED': 'check_extent'} | |
a26b940785adaaba7ee67968f766ef928db5f9be311013ff565dd9da1b43b838_a26b940785adaaba7ee67968f766ef928db5f9be311013ff565dd9da1b43b838.jsonl.gz | sub_40A84D | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40A84D(__int64 a1, __int64 a2)
{
return sub_40ABC5(a1, a2);
}
Q:[sub_40A84D,sub_40ABC5,] | A:{'sub_40A84D': '_Destroy', 'sub_40ABC5': '__destroy'} | |
9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0_9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0.jsonl.gz | sub_43FA7E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43FA7E(__int64 a1)
{
__int64 v2; // [rsp+10h] [rbp-10h] BYREF
__int64 v3; // [rsp+18h] [rbp-8h] BYREF
v2 = sub_440FC8(a1);
v3 = sub_440FA2(a1);
return sub_44A290(&v3, &v2);
}
Q:[sub_43FA7E,sub_440FC8,sub_440FA2,sub_44A290,] | A:{'sub_43FA7E': 'empty', 'sub_440FC8': 'end', 'sub_440FA2': 'begin', 'sub_44A290': 'Ptr'} | |
ca91fa92c27881dc5c0e1c75f3f2a37ed7dcfcf1edf640b0b267a80581c2f894_ca91fa92c27881dc5c0e1c75f3f2a37ed7dcfcf1edf640b0b267a80581c2f894.jsonl.gz | sub_409DF9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_409DF9(__int64 a1, __int64 a2)
{
__int64 v3; // [rsp+18h] [rbp-8h]
v3 = sub_40836B(a2, *(_QWORD *)(a1 + 200));
if ( !v3 )
return 0LL;
*(_DWORD *)(v3 + 100) = *(_DWORD *)(a1 + 100);
*(_DWORD *)(v3 + 92) = *(_DWORD *)(a1 + 92);
*(_DWORD *)(v3 + 96) = *(_DWORD *)(a1 + 96);
*(_QWORD *)(v3 + 136) = malloc(*(int *)(v3 + 96));
memcpy(*(void **)(v3 + 136), *(const void **)(a1 + 136), *(int *)(v3 + 96));
*(_QWORD *)(v3 + 104) = malloc(4LL * *(int *)(a1 + 100));
memcpy(*(void **)(v3 + 104), *(const void **)(a1 + 104), 4LL * *(int *)(a1 + 100));
*(_QWORD *)(v3 + 112) = malloc(4LL * *(int *)(a1 + 100));
memcpy(*(void **)(v3 + 112), *(const void **)(a1 + 112), 4LL * *(int *)(a1 + 100));
*(_QWORD *)(v3 + 120) = malloc(4LL * *(int *)(a1 + 100));
memcpy(*(void **)(v3 + 120), *(const void **)(a1 + 120), 4LL * *(int *)(a1 + 100));
*(_QWORD *)(v3 + 128) = malloc(*(int *)(a1 + 100));
memcpy(*(void **)(v3 + 128), *(const void **)(a1 + 128), *(int *)(a1 + 100));
*(_DWORD *)(v3 + 176) = 1;
*(_DWORD *)(v3 + 180) = 1;
sub_407356(v3);
sub_408223(v3);
return sub_407905(a2, (__int64)"rb+");
}
Q:[a1,a2,v3,sub_409DF9,sub_40836B,sub_407356,sub_408223,sub_407905,] | A:{'a1': 'psDBF', 'a2': 'pszFilename', 'v3': 'newDBF', 'sub_409DF9': 'DBFCloneEmpty', 'sub_40836B': 'DBFCreateEx', 'sub_407356': 'DBFWriteHeader', 'sub_408223': 'DBFClose', 'sub_407905': 'DBFOpen'} | |
188521825316f1dd4a5f7a68a55cfef8413d1ed8c86ec170a1b212557172a59c_188521825316f1dd4a5f7a68a55cfef8413d1ed8c86ec170a1b212557172a59c.jsonl.gz | sub_421D7F | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_421D7F()
{
;
}
Q:[sub_421D7F,] | A:{'sub_421D7F': 'NET_SV_FreeAddress'} | |
67ba13b20adae41569789b233dc9272b8255fe10209296e26b1b187b9e46ed6a_67ba13b20adae41569789b233dc9272b8255fe10209296e26b1b187b9e46ed6a.jsonl.gz | main | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall main(int a1, char **a2, char **a3)
{
__int64 result; // rax
FILE *stream; // [rsp+10h] [rbp-10h]
char *filename; // [rsp+18h] [rbp-8h]
filename = a2[1];
stream = fopen(filename, "r+b");
if ( stream )
{
sub_4028ED(stream);
fclose(stream);
result = 0LL;
}
else
{
printf("Can't open %s\n", filename);
result = 1LL;
}
return result;
}
Q:[a2,a3,a1,stream,filename,sub_4028ED,] | A:{'a2': 'argv', 'a3': 'envp', 'a1': 'argc', 'stream': 'binary', 'filename': 'binary_path', 'sub_4028ED': 'apply_themes'} | |
614f31b237021943f00edd1722efa5c25b232a880ba0ce0b95bc8b4ce694ebc2_614f31b237021943f00edd1722efa5c25b232a880ba0ce0b95bc8b4ce694ebc2.jsonl.gz | sub_41FA7E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41FA7E(__int64 a1)
{
__int16 v1; // ax
__int16 v2; // ax
__int64 v3; // rax
__int16 v5; // [rsp+10h] [rbp-10h]
unsigned __int16 v6; // [rsp+10h] [rbp-10h]
__int64 v7; // [rsp+10h] [rbp-10h]
sub_4125D6(a1, (_BYTE *)(a1 + 225));
LOBYTE(v1) = sub_412687(a1);
if ( (v1 & 0x80) != 0 )
v1 = (unsigned __int8)v1 | 0xFF00;
else
v1 = (unsigned __int8)v1;
v5 = v1;
if ( (*(_WORD *)(a1 + 4) & 0x80) != 0 )
{
LOBYTE(v2) = *(_WORD *)(a1 + 4);
HIBYTE(v2) = -1;
}
else
{
v2 = (unsigned __int8)*(_WORD *)(a1 + 4);
}
v6 = v5 * v2;
*(_WORD *)(a1 + 4) = v6;
v7 = v6 & 0xFF80;
if ( v7 == 65408 || !v7 )
*(_WORD *)(a1 + 30) &= 0xF7FEu;
else
*(_WORD *)(a1 + 30) |= 0x801u;
if ( *(_DWORD *)(a1 + 2312) )
v3 = 95LL;
else
v3 = 89LL;
*(_QWORD *)(a1 + 2336) += v3;
return (unsigned int)*(unsigned __int16 *)(a1 + 2332) + 1;
}
Q:[a1,v5,sub_41FA7E,sub_4125D6,sub_412687,] | A:{'a1': 'c', 'v5': 'db', 'sub_41FA7E': 'op_f6_05', 'sub_4125D6': 'e86_get_ea_ptr', 'sub_412687': 'e86_get_ea8'} | |
3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353_3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353.jsonl.gz | sub_423223 | Help user generate meaningful names for variables and functions in the following code snippet. |
bool __fastcall sub_423223(unsigned __int8 *a1, __int16 a2)
{
int v2; // eax
if ( (a2 & 0x80) != 0 )
v2 = 0;
else
v2 = sub_40E990(*(_QWORD *)(qword_4F2C40 + 7064), a1, 0LL);
if ( (a2 & 0x100) != 0 && v2 )
__assert_fail(
"0 && \"Cannot use IsPopupOpen() with a string id and ImGuiPopupFlags_AnyPopupLevel.\"",
"../../imgui.cpp",
0x20A6u,
"bool ImGui::IsPopupOpen(const char*, ImGuiPopupFlags)");
return sub_4230FA(v2, a2);
}
Q:[a1,a2,sub_423223,sub_40E990,sub_4230FA,] | A:{'a1': 'str_id', 'a2': 'popup_flags', 'sub_423223': 'IsPopupOpen', 'sub_40E990': 'GetID', 'sub_4230FA': 'IsPopupOpen'} | |
9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0_9e8dfbafd04e87edc44f4b276fb124aa9e4687121b190454ab7a505336ea1fd0.jsonl.gz | sub_45171A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_45171A(__int64 a1)
{
return a1;
}
Q:[sub_45171A,] | A:{'sub_45171A': 'base'} | |
8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197_8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197.jsonl.gz | sub_403DD4 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_403DD4(void *a1)
{
sub_403D9C((__int64)a1);
operator delete(a1);
}
Q:[a1,sub_403DD4,sub_403D9C,] | A:{'a1': 'this', 'sub_403DD4': '~exception', 'sub_403D9C': '~exception'} | |
7751b2e4e1f9cb5d4f497d32b2859cc9c1a92bc6dd427019f217234f9aa3f6ef_7751b2e4e1f9cb5d4f497d32b2859cc9c1a92bc6dd427019f217234f9aa3f6ef.jsonl.gz | sub_4A40C0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4A40C0(_QWORD *a1, __int64 a2, _DWORD *a3, int *a4, __int64 a5, __int64 a6, __int64 a7, __int16 a8)
{
__int64 result; // rax
__int64 v9; // rax
unsigned __int64 v10; // rcx
*a4 = HIBYTE(a8) >> 7;
*a3 = (a8 & 0x7FFF) - 0x3FFF;
*a1 = a7;
if ( (a8 & 0x7FFF) != 0 )
{
if ( a7 )
return 1LL;
if ( (a8 & 0x7FFF) != 0x7FFF )
{
LABEL_3:
*a3 = 0;
return 1LL;
}
result = 1LL;
}
else
{
if ( !a7 )
goto LABEL_3;
v9 = a7 & 0x7FFFFFFFFFFFFFFFLL;
if ( (a7 & 0x7FFFFFFFFFFFFFFFLL) != 0 )
{
_BitScanReverse64(&v10, v9);
LODWORD(v10) = v10 ^ 0x3F;
*a1 = v9 << v10;
*a3 = -16382 - v10;
result = 1LL;
}
else
{
*a1 = 0x8000000000000000LL;
result = 1LL;
*a3 = -16382;
}
}
return result;
}
Q:[v9,] | A:{'v9': 'result'} | |
fabcd4074543f940b01553c817db2a3e881e2ff1f379817ba1cd84e20d54c14a_fabcd4074543f940b01553c817db2a3e881e2ff1f379817ba1cd84e20d54c14a.jsonl.gz | sub_405C75 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_405C75(__int64 a1)
{
int i; // [rsp+14h] [rbp-4h]
for ( i = 0; i <= 31; ++i )
{
if ( *(_DWORD *)(a1 + 4LL * i) )
return 0LL;
}
return 1LL;
}
Q:[a1,sub_405C75,] | A:{'a1': 'x', 'sub_405C75': 'crypto_sign_ed25519_ref_sc25519_iszero_vartime'} | |
e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433_e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433.jsonl.gz | sub_421F2C | Help user generate meaningful names for variables and functions in the following code snippet. |
_QWORD *__fastcall sub_421F2C(_QWORD *a1, _QWORD *a2)
{
_QWORD *result; // rax
result = a1;
*a1 = *a2;
return result;
}
Q:[sub_421F2C,] | A:{'sub_421F2C': '__normal_iterator'} | |
766fcda9ae8f843f16029f36de9fe2b19ddfd2d7a292f41ecb27d8ce5fd424d3_766fcda9ae8f843f16029f36de9fe2b19ddfd2d7a292f41ecb27d8ce5fd424d3.jsonl.gz | sub_4366EE | Help user generate meaningful names for variables and functions in the following code snippet. |
double *__fastcall sub_4366EE(double *a1, double *a2, double *a3, double *a4, double a5, double a6)
{
double *result; // rax
double v10; // [rsp+30h] [rbp-10h]
double v11; // [rsp+38h] [rbp-8h]
if ( fabs(a6) > 1.0e-25 )
{
v10 = fabs(a5);
if ( fabs(a6) > v10 )
v10 = fabs(a6);
v11 = sqrt(a5 / v10 * (a5 / v10) + a6 / v10 * (a6 / v10)) * v10;
if ( a5 < 0.0 )
v11 = -v11;
*a3 = a5 / v11;
*a4 = a6 / v11;
*a1 = v11;
result = a2;
*a2 = 0.0;
}
else
{
*a3 = 1.0;
*a4 = 0.0;
*a1 = a5;
result = a2;
*a2 = a6;
}
return result;
}
Q:[a3,a4,a1,a2,a5,a6,v10,v11,sub_4366EE,] | A:{'a3': 'c', 'a4': 's', 'a1': 'xnew', 'a2': 'ynew', 'a5': 'xold', 'a6': 'yold', 'v10': 'mu', 'v11': 't', 'sub_4366EE': 'QProblemB_computeGivens_2'} | |
540ad4681cfaf79b7814f8886d276966eeaad4b9909dc230941677162e1d1c64_540ad4681cfaf79b7814f8886d276966eeaad4b9909dc230941677162e1d1c64.jsonl.gz | sub_4021CD | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4021CD(__int64 a1, int a2)
{
return a1 & qword_40C480[a2];
}
Q:[a1,a2,sub_4021CD,] | A:{'a1': 'x', 'a2': 'nbits', 'sub_4021CD': 'fse_mask_lsb64'} | |
b863f2cdae93922c3e2f3e4973bbadaab5158f9e781ef05c4ebd8ea998b16a19_b863f2cdae93922c3e2f3e4973bbadaab5158f9e781ef05c4ebd8ea998b16a19.jsonl.gz | sub_40608F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40608F(__int64 a1, __int64 a2, __int64 a3)
{
__int64 result; // rax
__int64 v5; // [rsp+20h] [rbp-18h]
unsigned int i; // [rsp+2Ch] [rbp-Ch]
v5 = *(_QWORD *)(a3 + 16);
for ( i = 0; ; ++i )
{
result = i;
if ( *(_DWORD *)(a3 + 76) <= i )
break;
sub_4044F7(a2, a3, ((__int64)(int)i << 6) + *(_QWORD *)(a3 + 16));
if ( *(_DWORD *)(((__int64)(int)i << 6) + v5 + 4) == 4 )
{
sub_405C6D(a2, a3, ((__int64)(int)i << 6) + *(_QWORD *)(a3 + 16));
}
else if ( *(_DWORD *)(((__int64)(int)i << 6) + v5 + 4) == 9 )
{
sub_405E35(a2, a3, ((__int64)(int)i << 6) + *(_QWORD *)(a3 + 16));
}
}
return result;
}
Q:[a3,a2,a1,v5,sub_40608F,sub_4044F7,sub_405C6D,sub_405E35,] | A:{'a3': 'elf', 'a2': 'modname', 'a1': 'mod', 'v5': 'sechdrs', 'sub_40608F': 'check_sec_ref', 'sub_4044F7': 'check_section', 'sub_405C6D': 'section_rela', 'sub_405E35': 'section_rel'} | |
c8491ae03f8dc9e8695f46c8251e57f69f5ff7c0ed65d1286b5d5158829a78e3_c8491ae03f8dc9e8695f46c8251e57f69f5ff7c0ed65d1286b5d5158829a78e3.jsonl.gz | sub_41F321 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41F321(__int64 a1, __int64 a2)
{
unsigned int v3; // [rsp+1Ch] [rbp-14h]
v3 = 0;
sub_438445(409LL, "AcpiExSystemWaitEvent", "exsystem", 128LL);
if ( a2 )
v3 = sub_41EFE2(*(_QWORD *)(a2 + 16), *(_QWORD *)(a1 + 16));
sub_4386D7(418LL, "AcpiExSystemWaitEvent", "exsystem", 128LL, v3);
return v3;
}
Q:[a1,a2,v3,sub_41F321,sub_438445,sub_41EFE2,sub_4386D7,] | A:{'a1': 'TimeDesc', 'a2': 'ObjDesc', 'v3': 'Status', 'sub_41F321': 'AcpiExSystemWaitEvent', 'sub_438445': 'AcpiUtTrace', 'sub_41EFE2': 'AcpiExSystemWaitSemaphore', 'sub_4386D7': 'AcpiUtStatusExit'} | |
aac1931ba2ac5661cdc0933ad49e81c786c7d736777e0cb10d5b7d8b839b7210_aac1931ba2ac5661cdc0933ad49e81c786c7d736777e0cb10d5b7d8b839b7210.jsonl.gz | sub_42571C | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_42571C()
{
__int64 v1[4]; // [rsp+8h] [rbp-80h] BYREF
__int64 v2[4]; // [rsp+28h] [rbp-60h] BYREF
__int64 v3[4]; // [rsp+48h] [rbp-40h] BYREF
__int64 v4[4]; // [rsp+68h] [rbp-20h] BYREF
++qword_451640;
v4[0] = 1LL;
v4[1] = 8LL;
v4[2] = 987LL;
v4[3] = -65132LL;
v3[0] = 1LL;
v3[1] = 8LL;
v3[2] = 987LL;
v3[3] = -65132LL;
v2[0] = 1LL;
v2[1] = 8LL;
v2[2] = 987LL;
v2[3] = -2LL;
v1[0] = 1LL;
v1[1] = 500LL;
v1[2] = 600LL;
v1[3] = 700LL;
sub_403037((__int64)v4, (__int64)v4, 1, 0LL, 3762LL, 24, 1);
++qword_451648;
sub_403037((__int64)v4, (__int64)v4, 4, 0LL, 3763LL, 24, 1);
++qword_451650;
sub_403037((__int64)v4, (__int64)v3, 4, 0LL, 3764LL, 24, 1);
++qword_451658;
sub_403037((__int64)v4, (__int64)v2, 3, 0LL, 3765LL, 24, 1);
++qword_451660;
sub_403037((__int64)v4, (__int64)v1, 1, 0LL, 3766LL, 24, 1);
return ++qword_451668;
}
Q:[v1,v2,v3,v4,sub_42571C,sub_403037,] | A:{'v1': 'p3', 'v2': 'p2', 'v3': 'p1', 'v4': 'p0', 'sub_42571C': 'testEqualInt64Arrays', 'sub_403037': 'UnityAssertEqualIntArray'} | |
693829a2e0907519004da0a5adce4ea70db360e9c310f3ad53f5269f42b96317_693829a2e0907519004da0a5adce4ea70db360e9c310f3ad53f5269f42b96317.jsonl.gz | sub_408A46 | Help user generate meaningful names for variables and functions in the following code snippet. |
void __fastcall sub_408A46(int a1)
{
__int16 v1; // [rsp+1Dh] [rbp-C3h] BYREF
char v2; // [rsp+1Fh] [rbp-C1h]
struct sigaction s; // [rsp+20h] [rbp-C0h] BYREF
unsigned __int8 v4[20]; // [rsp+C0h] [rbp-20h] BYREF
int v5; // [rsp+D4h] [rbp-Ch]
_DWORD *v6; // [rsp+D8h] [rbp-8h]
v1 = -915;
v2 = 0;
v6 = sub_404A31(byte_4106C0, (__int64)&v1, 3, 1);
if ( qword_4106E0 )
{
sub_4042FC((void *)qword_4106E0);
qword_4106E0 = 0LL;
}
qword_4106E0 = (__int64)v6;
write(a1, v6 + 2, (unsigned int)v6[1]);
dword_410740 = 1;
if ( byte_410300 )
fprintf(stderr, "%s :RTK send HCI_VENDOR_READ_RTK_ROM_VERISION_Command\n\n", "Realtek Bluetooth");
alarm(0);
memset(&s, 0, sizeof(s));
s.sa_flags = 1;
s.sa_handler = (__sighandler_t)sub_408939;
sigaction(14, &s, 0LL);
alarm(3u);
while ( dword_410740 != 2 )
{
v5 = sub_405C35(a1, v4, 16);
if ( v5 == -1 )
{
perror("rtk get eversion: read fail");
return;
}
sub_40580A((unsigned __int8 *)byte_4106C0, v4, v5);
}
alarm(0);
}
Q:[a1,v1,s,v4,v5,v6,sub_408A46,sub_404A31,sub_4042FC,sub_408939,sub_405C35,sub_40580A,] | A:{'a1': 'dd', 'v1': 'read_rom_patch_cmd', 's': 'sa', 'v4': 'bytes', 'v5': 'retlen', 'v6': 'nskb', 'sub_408A46': 'rtk_get_eversion', 'sub_404A31': 'h5_prepare_pkt', 'sub_4042FC': 'skb_free', 'sub_408939': 'rtk_get_eversion_timeout', 'sub_405C35': 'read_check_rtk', 'sub_40580A': 'h5_recv'} | |
1e46bbee86fadabb884ded3aaa32e40e5814fcc38b71ac0630b42b0505f8f0d2_1e46bbee86fadabb884ded3aaa32e40e5814fcc38b71ac0630b42b0505f8f0d2.jsonl.gz | sub_4115B0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4115B0(__int64 a1, __int64 a2)
{
__int64 v2; // rdx
sub_410B00(a1);
if ( **(_DWORD **)(a1 + 8) != 1 )
{
printf("Cleaning...");
v2 = *(_QWORD *)(a1 + 8);
if ( *(_DWORD *)v2 != 1 && (*(_DWORD *)v2 == 2 || *(_BYTE *)(v2 + 4)) )
putchar(10);
else
putchar(32);
}
sub_4114B0(a1, a2);
if ( **(_DWORD **)(a1 + 8) != 1 )
printf("%d files.\n", *(unsigned int *)(a1 + 112));
return *(unsigned int *)(a1 + 128);
}
Q:[a1,a2,sub_4115B0,sub_410B00,sub_4114B0,] | A:{'a1': 'this', 'a2': 'target', 'sub_4115B0': 'CleanTarget', 'sub_410B00': 'Reset', 'sub_4114B0': 'DoCleanTarget'} | |
c00ba4bccd75463928b9d2ca0657fdf7633263e8f3a85f5f4c8a0205576b1a25_c00ba4bccd75463928b9d2ca0657fdf7633263e8f3a85f5f4c8a0205576b1a25.jsonl.gz | sub_413AE0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_413AE0(pid_t *a1, void *a2, __int64 a3, unsigned __int64 a4, _QWORD *a5, int a6)
{
int v6; // er9
int v8; // eax
_BYTE *v11; // [rsp+18h] [rbp-1068h]
char v12[16]; // [rsp+30h] [rbp-1050h] BYREF
void *v13; // [rsp+40h] [rbp-1040h]
unsigned int v14; // [rsp+4Ch] [rbp-1034h]
_OWORD v15[256]; // [rsp+60h] [rbp-1020h] BYREF
__int64 v16; // [rsp+1060h] [rbp-20h] BYREF
int v17; // [rsp+1068h] [rbp-18h]
unsigned int v18; // [rsp+106Ch] [rbp-14h]
__int64 v19; // [rsp+1070h] [rbp-10h]
int i; // [rsp+107Ch] [rbp-4h]
v11 = (_BYTE *)a3;
v19 = a3;
v18 = sub_40BA27(*a1, (int)"array", a2, v12, 0x24uLL, a6);
if ( v18 )
return v18;
v8 = v14;
if ( v14 > 0x80 )
v8 = 128;
v17 = v8;
v18 = sub_40BA27(*a1, (int)"buckets", v13, v15, 32LL * v8, v6);
if ( v18 )
return v18;
for ( i = 0; i < v17; ++i )
{
v18 = sub_413CE4(a1, &v15[2 * i], v11, a4, &v16);
if ( v18 )
return v18;
a4 -= v16;
v11 += v16;
if ( a4 > 1 )
{
*v11 = 44;
--a4;
++v11;
}
}
*a5 = &v11[-v19];
return 0LL;
}
Q:[a3,a4,a1,a2,a5,v11,v12,v15,v16,v17,v18,v19,sub_413AE0,sub_40BA27,sub_413CE4,] | A:{'a3': 'buf', 'a4': 'buf_size', 'a1': 'context', 'a2': 'rzarray', 'a5': 'buf_len', 'v11': 'bufa', 'v12': 'lzarray', 'v15': 'buckets', 'v16': 'tmp_len', 'v17': 'array_len', 'v18': 'rv', 'v19': 'obuf', 'sub_413AE0': 'sprint_zarray_73', 'sub_40BA27': 'copy_proc_mem', 'sub_413CE4': 'sprint_zarray_bucket_73'} | |
c629e5294494f18a8a5bb3aefa8b3112d7aa4f1e9fde331308ca043898423382_c629e5294494f18a8a5bb3aefa8b3112d7aa4f1e9fde331308ca043898423382.jsonl.gz | sub_40F0B1 | Help user generate meaningful names for variables and functions in the following code snippet. |
_DWORD *__fastcall sub_40F0B1(int a1)
{
_DWORD *s; // [rsp+10h] [rbp-10h]
s = malloc(((a1 + 3) & 0xFFFFFFFC) + 8LL);
if ( !s )
return 0LL;
memset(s, 0, ((a1 + 3) & 0xFFFFFFFC) + 8LL);
*s = (a1 + 3) & 0xFFFFFFFC;
return s;
}
Q:[a1,s,sub_40F0B1,] | A:{'a1': 'size', 's': 'nlmsg', 'sub_40F0B1': 'nlmsg_alloc'} | |
b96d14afe5a309f3d2768451909eadc66db3a51f9332c796791f24616961688b_b96d14afe5a309f3d2768451909eadc66db3a51f9332c796791f24616961688b.jsonl.gz | sub_430DCB | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_430DCB(__int64 a1, __int64 a2, __int64 a3)
{
__int64 result; // rax
result = sub_45373E(a2, a3);
*(_QWORD *)(a1 + 40) = result;
return result;
}
Q:[a3,a1,a2,sub_430DCB,sub_45373E,] | A:{'a3': 'size', 'a1': 'thing', 'a2': 'text', 'sub_430DCB': '_setDoc_class_2', 'sub_45373E': 'krk_copyString'} | |
276536b89cc3e58f9e6dd34cde9d9d4ba21328c5a859320d5e06460e1ec2c7de_276536b89cc3e58f9e6dd34cde9d9d4ba21328c5a859320d5e06460e1ec2c7de.jsonl.gz | sub_440BDE | Help user generate meaningful names for variables and functions in the following code snippet. |
bool __fastcall sub_440BDE(__int64 a1)
{
return *(_BYTE *)(a1 + 1192) != 0;
}
Q:[a1,sub_440BDE,] | A:{'a1': 'gb', 'sub_440BDE': 'GB_workboy_is_enabled'} | |
8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197_8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197.jsonl.gz | sub_4114EE | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4114EE(_QWORD *a1, int a2, unsigned __int16 a3, __int64 a4)
{
char v7; // [rsp+2Bh] [rbp-5h] BYREF
unsigned __int16 i; // [rsp+2Ch] [rbp-4h]
unsigned __int8 v9; // [rsp+2Fh] [rbp-1h]
v9 = 1;
for ( i = 0; i < a3; ++i )
{
sub_408B52((__int64)a1);
if ( (unsigned __int8)sub_40B696(a1, a2) != 1 )
return 0;
v7 = a1[2];
sub_402772(a4, (__int64)&v7);
}
return v9;
}
Q:[sub_4114EE,sub_408B52,sub_40B696,sub_402772,] | A:{'sub_4114EE': 'get_binary', 'sub_408B52': 'get', 'sub_40B696': 'unexpect_eof', 'sub_402772': 'push_back'} | |
c0fe0b1d115c9a9d40b2c9859f7dfd1ea6098b73116e2548a49a45e30fbdd252_c0fe0b1d115c9a9d40b2c9859f7dfd1ea6098b73116e2548a49a45e30fbdd252.jsonl.gz | sub_41710F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41710F(__int64 a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6)
{
__int64 result; // rax
int v7; // ebx
int v8; // ebx
char v9; // al
char v10; // al
char v11[32]; // [rsp+10h] [rbp-70h] BYREF
__int64 v12; // [rsp+30h] [rbp-50h] BYREF
__int64 v13; // [rsp+38h] [rbp-48h]
__int64 v14; // [rsp+40h] [rbp-40h] BYREF
__int64 v15; // [rsp+48h] [rbp-38h]
char v16[20]; // [rsp+50h] [rbp-30h] BYREF
int v17; // [rsp+64h] [rbp-1Ch]
int i; // [rsp+68h] [rbp-18h]
int j; // [rsp+6Ch] [rbp-14h]
if ( dword_44C600 == 5 )
{
v14 = qword_44C630;
v15 = qword_44C638;
sub_416FAF(16, (__int64)&v14);
if ( (qword_44C630 & 0x80u) != 0LL )
HIBYTE(v15) ^= 0x87u;
v12 = v14;
v13 = v15;
sub_416FAF(16, (__int64)&v12);
if ( (v14 & 0x80u) != 0LL )
HIBYTE(v13) ^= 0x87u;
sub_4089CA((int)"k", (__int64)&qword_44C610);
sub_4089CA((int)"k1", (__int64)&v14);
sub_4089CA((int)"k2", (__int64)&v12);
if ( sub_4170DC(a1) )
{
for ( i = 0; i <= 15; ++i )
{
v9 = sub_417028(a1, *(_WORD *)(a1 + 40) + (unsigned __int16)i - 16);
v11[i + 16] = *((_BYTE *)&v14 + i) ^ v9;
}
}
else
{
v17 = *(_WORD *)(a1 + 40) & 0xF;
for ( i = 0; i <= 15; ++i )
{
if ( i >= v17 )
{
if ( i == v17 )
v11[i + 16] = *((_BYTE *)&v12 + i) ^ 0x80;
else
v11[i + 16] = *((_BYTE *)&v12 + i);
}
else
{
v10 = sub_417028(a1, (*(_WORD *)(a1 + 40) & 0xFFF0u) + i);
v11[i + 16] = *((_BYTE *)&v12 + i) ^ v10;
}
}
}
for ( i = 0; i <= 15; ++i )
v11[i] = v11[i + 16] ^ *((_BYTE *)&qword_44C620 + i);
++byte_44C640;
sub_4170C6();
result = sub_41706C((__int64)&qword_44C610, (__int64)v11);
}
else
{
if ( (unsigned int)dword_44C600 > 5 )
goto LABEL_32;
if ( dword_44C600 == 1 )
{
sub_4170C6();
return sub_41706C((__int64)&qword_44C610, (__int64)&unk_43AA80);
}
if ( dword_44C600 == 3 )
{
for ( j = 0; j <= 15; ++j )
{
v7 = *((unsigned __int8 *)&qword_44C620 + j);
v8 = sub_417028(a1, 16 * (unsigned __int8)byte_44C640 + j) ^ v7;
v16[j] = v8;
}
++byte_44C640;
sub_4170C6();
result = sub_41706C((__int64)&qword_44C610, (__int64)v16);
}
else
{
LABEL_32:
result = sub_4122DA(
1u,
(__int64)"%s.%u: btstack_crypto_cmac_handle_aes_engine_ready called in state %u",
(__int64)"btstack_crypto.c",
361LL,
(unsigned int)dword_44C600,
a6);
}
}
return result;
}
Q:[a1,v11,v12,v14,v16,v17,sub_41710F,sub_416FAF,sub_4089CA,sub_4170DC,sub_417028,sub_4170C6,sub_41706C,sub_4122DA,] | A:{'a1': 'btstack_crypto_cmac', 'v11': 'y_0', 'v12': 'k2_0', 'v14': 'k1_0', 'v16': 'y', 'v17': 'valid_octets_in_last_block', 'sub_41710F': 'btstack_crypto_cmac_handle_aes_engine_ready', 'sub_416FAF': 'btstack_crypto_cmac_shift_left_by_one_bit_inplace', 'sub_4089CA': 'log_info_key', 'sub_4170DC': 'btstack_crypto_cmac_last_block_complete', 'sub_417028': 'btstack_crypto_cmac_get_byte', 'sub_4170C6': 'btstack_crypto_cmac_next_state', 'sub_41706C': 'btstack_crypto_aes128_start', 'sub_4122DA': 'hci_dump_log'} | |
45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0_45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0.jsonl.gz | sub_42E7D0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 *__fastcall sub_42E7D0(__int64 *a1, __int64 a2)
{
__int64 *result; // rax
*a1 = sub_421B4A((__int64)a1, a2);
a1[1] = *a1;
result = a1;
a1[2] = a2 + *a1;
return result;
}
Q:[a1,a2,sub_42E7D0,sub_421B4A,] | A:{'a1': 'this', 'a2': '__n', 'sub_42E7D0': '_M_create_storage', 'sub_421B4A': '_M_allocate'} | |
9895acc23197a78b016e2ef6f09316b4db6f035f5b78cc4137e999b9fe3548fe_9895acc23197a78b016e2ef6f09316b4db6f035f5b78cc4137e999b9fe3548fe.jsonl.gz | sub_464041 | Help user generate meaningful names for variables and functions in the following code snippet. |
int *__fastcall sub_464041(__int64 a1, const void *a2, int a3, unsigned int a4)
{
unsigned int v5; // eax
unsigned int v6; // eax
void *v7; // rax
void **v8; // rbx
char v11[36]; // [rsp+20h] [rbp-A0h] BYREF
int v12; // [rsp+44h] [rbp-7Ch] BYREF
void **v13; // [rsp+48h] [rbp-78h]
int v14; // [rsp+54h] [rbp-6Ch]
int v15; // [rsp+58h] [rbp-68h]
int v16; // [rsp+5Ch] [rbp-64h]
int *v17; // [rsp+60h] [rbp-60h]
void *ptr; // [rsp+68h] [rbp-58h]
char *v19; // [rsp+70h] [rbp-50h]
void *dest; // [rsp+78h] [rbp-48h]
int i; // [rsp+84h] [rbp-3Ch]
__int64 v22; // [rsp+88h] [rbp-38h]
char v23; // [rsp+97h] [rbp-29h]
__int64 v24; // [rsp+98h] [rbp-28h]
char v25; // [rsp+A7h] [rbp-19h]
char *s; // [rsp+A8h] [rbp-18h]
dest = malloc(a3 + 1);
if ( !dest )
sub_43C17F("out of memory");
memcpy(dest, a2, a3);
*((_BYTE *)dest + a3) = 0;
for ( s = (char *)dest; *s > 0 && *s <= 32; ++s )
;
v25 = 0;
if ( *s == 91 )
{
v25 = 1;
}
else if ( *s != 40 )
{
sub_4656C6(a1, 2LL, "tcfdb.c", 718LL, "tcfdbrange4");
free(dest);
return sub_419610();
}
v19 = strchr(++s, 44);
if ( !v19 )
{
sub_4656C6(a1, 2LL, "tcfdb.c", 725LL, "tcfdbrange4");
free(dest);
return sub_419610();
}
*v19 = 0;
sub_429B79(s);
v5 = strlen(s);
v24 = sub_466469(s, v5);
s = v19 + 1;
v23 = 0;
v19 = strchr(v19 + 1, 93);
if ( v19 )
{
v23 = 1;
*v19 = 0;
}
else
{
v19 = strchr(s, 41);
if ( !v19 )
{
sub_4656C6(a1, 2LL, "tcfdb.c", 740LL, "tcfdbrange4");
free(dest);
return sub_419610();
}
*v19 = 0;
}
sub_429B79(s);
v6 = strlen(s);
v22 = sub_466469(s, v6);
switch ( v24 )
{
case -1LL:
v24 = *(_QWORD *)(a1 + 120);
break;
case -2LL:
v24 = *(_QWORD *)(a1 + 120) - 1LL;
break;
case -3LL:
v24 = *(_QWORD *)(a1 + 128);
break;
case -4LL:
v24 = *(_QWORD *)(a1 + 128) + 1LL;
break;
}
if ( v25 != 1 )
++v24;
switch ( v22 )
{
case -1LL:
v22 = *(_QWORD *)(a1 + 120);
break;
case -2LL:
v22 = *(_QWORD *)(a1 + 120) - 1LL;
break;
case -3LL:
v22 = *(_QWORD *)(a1 + 128);
break;
case -4LL:
v22 = *(_QWORD *)(a1 + 128) + 1LL;
break;
}
if ( v23 != 1 )
--v22;
free(dest);
ptr = sub_463C20(a1, v24, v22, a4, &v12);
v17 = sub_419697(v12);
for ( i = 0; i < v12; ++i )
{
v16 = sprintf(v11, "%llu", *((_QWORD *)ptr + i));
v15 = v16;
v14 = v17[3] + v17[4];
if ( v14 >= v17[2] )
{
v17[2] += v17[4] + 1;
v7 = realloc(*(void **)v17, 16LL * v17[2]);
*(_QWORD *)v17 = v7;
if ( !*(_QWORD *)v17 )
sub_43C17F("out of memory");
}
v13 = *(void ***)v17;
v8 = &v13[2 * v14];
*v8 = malloc(v15 + 1);
if ( !*v8 )
sub_43C17F("out of memory");
memcpy(v13[2 * v14], v11, v15);
*((_BYTE *)v13[2 * v14] + v15) = 0;
LODWORD(v13[2 * v14 + 1]) = v15;
++v17[4];
}
free(ptr);
return v17;
}
Q:[a3,a4,a1,a2,v11,v12,v13,v14,v15,v16,v17,ptr,v19,dest,v22,v23,v24,v25,s,sub_464041,sub_43C17F,sub_4656C6,sub_419610,sub_429B79,sub_466469,sub_463C20,sub_419697,] | A:{'a3': 'isiz', 'a4': 'max', 'a1': 'fdb', 'a2': 'ibuf', 'v11': 'kbuf', 'v12': 'num', 'v13': 'array', 'v14': 'TC_index', 'v15': 'TC_mysize', 'v16': 'ksiz', 'v17': 'keys', 'ptr': 'ids', 'v19': 'sep', 'dest': 'expr', 'v22': 'upper', 'v23': 'uinc', 'v24': 'lower', 'v25': 'linc', 's': 'pv', 'sub_464041': 'tcfdbrange4', 'sub_43C17F': 'tcmyfatal', 'sub_4656C6': 'tcfdbsetecode', 'sub_419610': 'tclistnew', 'sub_429B79': 'tcstrtrim', 'sub_466469': 'tcfdbkeytoid', 'sub_463C20': 'tcfdbrange', 'sub_419697': 'tclistnew2'} | |
50c086041f4bb1c7eeff955ae0d79cd8b9311dfaa383e543eb4728643780210d_50c086041f4bb1c7eeff955ae0d79cd8b9311dfaa383e543eb4728643780210d.jsonl.gz | sub_403200 | Help user generate meaningful names for variables and functions in the following code snippet. |
char **__fastcall sub_403200(char **a1, unsigned int a2)
{
unsigned int v3; // ebx
char *v4; // rcx
__int64 v5; // rdi
unsigned int v6; // edx
char *v7; // rax
char *v8; // rsi
char *v9; // rcx
char v10; // dl
char *v11; // rdi
char v12; // dl
__int64 v14; // rsi
char v15; // di
__int64 v16; // rsi
char v17; // dl
__int64 v18; // rdi
__int64 v19; // rdi
char v20; // r8
__int64 v21; // rdi
char v22; // dl
__int64 v23; // rsi
__int64 v24; // rsi
char v25; // r8
__int64 v26; // rsi
char v27; // dl
__int64 v28; // rdx
unsigned int v29; // eax
__int64 v30; // rdx
char v31; // al
__int64 v32; // rdx
__int64 v33; // rdi
__int64 v34; // rdx
__int64 v35; // rsi
__int64 v36; // rdx
__int64 v37; // rsi
__int64 v38; // rax
__int64 v39; // rdx
v3 = a2;
*a1 = (char *)(a1 + 2);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::_M_construct();
v4 = *a1;
v5 = (__int64)a1[1];
v6 = HIBYTE(a2);
v7 = &(*a1)[v5];
if ( *a1 == v7 )
{
LABEL_49:
v8 = &(*a1)[v5];
goto LABEL_4;
}
if ( !v6 )
{
*v4 = 48;
v8 = v4 + 1;
goto LABEL_4;
}
if ( v6 <= 9 )
{
if ( v5 > 0 )
{
v16 = 1LL;
goto LABEL_18;
}
goto LABEL_49;
}
if ( v6 > 0x63 )
{
if ( v5 > 2 )
{
v14 = 2 * (v6 % 0x64);
v6 /= 0x64u;
v15 = byte_40A3E0[(unsigned int)(v14 + 1)];
v4[1] = byte_40A3E0[v14];
v16 = 3LL;
v4[2] = v15;
LABEL_18:
v17 = v6 + 48;
LABEL_19:
*v4 = v17;
v8 = &v4[v16];
goto LABEL_4;
}
goto LABEL_49;
}
v8 = &(*a1)[v5];
if ( v5 > 1 )
{
v34 = 2 * v6;
v35 = (unsigned int)(v34 + 1);
v17 = byte_40A3E0[v34];
v4[1] = byte_40A3E0[v35];
v16 = 2LL;
goto LABEL_19;
}
LABEL_4:
v9 = v8 + 1;
*v8 = 46;
v10 = BYTE2(v3);
if ( v7 == v8 + 1 )
goto LABEL_7;
if ( !BYTE2(v3) )
{
v8[1] = 48;
v9 = v8 + 2;
goto LABEL_7;
}
v18 = v7 - v9;
if ( BYTE2(v3) <= 9u )
{
if ( v18 > 0 )
{
v21 = 1LL;
goto LABEL_24;
}
}
else if ( BYTE2(v3) <= 0x63u )
{
if ( v18 > 1 )
{
v32 = 2 * (unsigned int)BYTE2(v3);
v33 = (unsigned int)(v32 + 1);
v22 = byte_40A3E0[v32];
v8[2] = byte_40A3E0[v33];
v21 = 2LL;
goto LABEL_25;
}
}
else if ( v18 > 2 )
{
v19 = 2 * (BYTE2(v3) % 0x64u);
v10 = BYTE2(v3) / 0x64u;
v20 = byte_40A3E0[(unsigned int)(v19 + 1)];
v8[2] = byte_40A3E0[v19];
v21 = 3LL;
v8[3] = v20;
LABEL_24:
v22 = v10 + 48;
LABEL_25:
v8[1] = v22;
v9 += v21;
goto LABEL_7;
}
v9 = v7;
LABEL_7:
v11 = v9 + 1;
*v9 = 46;
v12 = BYTE1(v3);
if ( v7 == v9 + 1 )
goto LABEL_10;
if ( !BYTE1(v3) )
{
v9[1] = 48;
v11 = v9 + 2;
goto LABEL_10;
}
v23 = v7 - v11;
if ( BYTE1(v3) <= 9u )
{
if ( v23 > 0 )
{
v26 = 1LL;
goto LABEL_30;
}
}
else if ( BYTE1(v3) <= 0x63u )
{
if ( v23 > 1 )
{
v36 = 2 * (unsigned int)BYTE1(v3);
v37 = (unsigned int)(v36 + 1);
v27 = byte_40A3E0[v36];
v9[2] = byte_40A3E0[v37];
v26 = 2LL;
goto LABEL_31;
}
}
else if ( v23 > 2 )
{
v24 = 2 * (BYTE1(v3) % 0x64u);
v12 = BYTE1(v3) / 0x64u;
v25 = byte_40A3E0[(unsigned int)(v24 + 1)];
v9[2] = byte_40A3E0[v24];
v26 = 3LL;
v9[3] = v25;
LABEL_30:
v27 = v12 + 48;
LABEL_31:
v9[1] = v27;
v11 += v26;
goto LABEL_10;
}
v11 = v7;
LABEL_10:
*v11 = 46;
v3 = (unsigned __int8)v3;
if ( v7 != v11 + 1 )
{
if ( !v3 )
{
v11[1] = 48;
goto LABEL_13;
}
v28 = v7 - (v11 + 1);
if ( v3 <= 9 )
{
if ( v28 <= 0 )
goto LABEL_13;
}
else
{
if ( v3 <= 0x63 )
{
if ( v28 <= 1 )
goto LABEL_13;
v38 = 2 * v3;
v39 = (unsigned int)(v38 + 1);
v31 = byte_40A3E0[v38];
v11[2] = byte_40A3E0[v39];
goto LABEL_37;
}
if ( v28 <= 2 )
goto LABEL_13;
v29 = v3;
v3 /= 0x64u;
v30 = 2 * (v29 - 100 * v3);
v11[3] = byte_40A3E0[(unsigned int)(v30 + 1)];
v11[2] = byte_40A3E0[v30];
}
v31 = v3 + 48;
LABEL_37:
v11[1] = v31;
}
LABEL_13:
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::resize();
return a1;
}
Q:[sub_403200,] | A:{'sub_403200': 'ipv42'} | |
a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4_a929bcff2f328ae24d8d2f5cdc89b316cc93d0a4677dc4ebb21b9d7cd4df04a4.jsonl.gz | sub_43A382 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43A382(__int64 a1)
{
return sub_440708(a1);
}
Q:[sub_43A382,sub_440708,] | A:{'sub_43A382': '~_Vector_impl', 'sub_440708': '~allocator'} | |
190ad4b6ea66a95189ff60bb3776f9ebd1c638fd3069f9d2c9b59795fbac328a_190ad4b6ea66a95189ff60bb3776f9ebd1c638fd3069f9d2c9b59795fbac328a.jsonl.gz | sub_409CB4 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_409CB4(__int64 a1)
{
return sub_403C2D(a1, 0LL);
}
Q:[a1,sub_409CB4,sub_403C2D,] | A:{'a1': 'arg', 'sub_409CB4': 'Flist', 'sub_403C2D': 'copy'} | |
76c05f321c4703deb67fa538c2cf508c66723817fc1ebd22a9f48d40487c4c60_76c05f321c4703deb67fa538c2cf508c66723817fc1ebd22a9f48d40487c4c60.jsonl.gz | sub_4732A7 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_4732A7(__int64 a1, __int64 a2)
{
const char *v2; // rbx
__int64 v3; // r13
__int64 v4; // r12
unsigned int v5; // er15
unsigned int v6; // er14
unsigned int v7; // ebp
unsigned __int16 v8; // ax
unsigned int v10; // [rsp+18h] [rbp-90h]
unsigned int v11; // [rsp+1Ch] [rbp-8Ch]
unsigned int v12; // [rsp+30h] [rbp-78h]
unsigned int v13; // [rsp+34h] [rbp-74h]
unsigned __int64 v14; // [rsp+38h] [rbp-70h]
int v15; // [rsp+44h] [rbp-64h]
const char *v16; // [rsp+48h] [rbp-60h]
unsigned int v17; // [rsp+54h] [rbp-54h]
unsigned __int64 v18; // [rsp+58h] [rbp-50h]
unsigned __int64 v19; // [rsp+60h] [rbp-48h]
int v20; // [rsp+6Ch] [rbp-3Ch]
v14 = (*(unsigned int (__fastcall **)(__int64))(a2 + 24))(a1 + 4) + a1;
v20 = 0;
v19 = a1 + 8;
while ( v19 < v14 )
{
v13 = (*(__int64 (__fastcall **)(unsigned __int64))(a2 + 24))(v19);
v12 = (*(__int64 (__fastcall **)(unsigned __int64))(a2 + 24))(v19 + 4);
if ( v13 + v19 > v14 )
break;
printf(
"\n idx ID ? left right name data magic name\n%.79s\n",
"------------------------------------------------------------------------------------------------------------------"
"------------------------------------------------------------------------------------------------------------------"
"------------------------------------------------------------------------");
v18 = v19 + 8;
v17 = 0;
while ( v18 < 16 * (v12 + 1LL) + v19 + 8 )
{
v16 = (const char *)&unk_521580;
v15 = 0;
v11 = (*(__int64 (__fastcall **)(unsigned __int64))(a2 + 24))(v18 + 8);
if ( v11 )
{
v16 = (const char *)(v11 + v19);
v15 = (*(__int64 (__fastcall **)(const char *))(a2 + 24))(v16 - 4);
}
v10 = (*(__int64 (__fastcall **)(unsigned __int64))(a2 + 24))(v18 + 12);
if ( v10 )
v2 = (const char *)sub_40CC12((char *)(v10 + v19), 4LL, 0LL);
else
v2 = "-";
v3 = (*(unsigned int (__fastcall **)(unsigned __int64))(a2 + 24))(v18 + 12);
v4 = (*(unsigned int (__fastcall **)(unsigned __int64))(a2 + 24))(v18 + 8);
v5 = (*(unsigned __int16 (__fastcall **)(unsigned __int64))(a2 + 8))(v18 + 6);
v6 = (*(unsigned __int16 (__fastcall **)(unsigned __int64))(a2 + 8))(v18 + 4);
v7 = (*(unsigned __int16 (__fastcall **)(unsigned __int64))(a2 + 8))(v18 + 2);
v8 = (*(__int64 (__fastcall **)(unsigned __int64))(a2 + 8))(v18);
printf("%4x: %4x %4x %4x %4x %8x %8x %-4s %.*s\n", v17, v8, v7, v6, v5, v4, v3, v2, v15, v16);
v18 += 16LL;
++v17;
}
v19 += v13;
++v20;
}
return putchar(10);
}
Q:[a1,a2,v10,v11,v12,v13,v14,v15,v16,v17,v18,v19,v20,sub_4732A7,sub_40CC12,] | A:{'a1': 'root', 'a2': 'endian', 'v10': 'data_off', 'v11': 'name_off', 'v12': 'n_entries', 'v13': 'grp_size', 'v14': 'root_end', 'v15': 'name_len', 'v16': 'name', 'v17': 'entry_idx', 'v18': 'entry', 'v19': 'grp', 'v20': 'grp_idx', 'sub_4732A7': 'dump_brres_group', 'sub_40CC12': 'PrintID'} | |
fb04827bf9a551f5f69186e53039bed933d463cd8e2d00e60728cc981426dd66_fb04827bf9a551f5f69186e53039bed933d463cd8e2d00e60728cc981426dd66.jsonl.gz | sub_48627E | Help user generate meaningful names for variables and functions in the following code snippet. |
_QWORD *__fastcall sub_48627E(_QWORD *a1, __int64 a2)
{
_QWORD *result; // rax
result = a1;
*a1 = a2;
return result;
}
Q:[sub_48627E,] | A:{'sub_48627E': '_Iter_equals_val'} | |
8ae2ab0464f0ac96a7fdeccbe9109d753af18ecfd065336c7a6978a11512a7eb_8ae2ab0464f0ac96a7fdeccbe9109d753af18ecfd065336c7a6978a11512a7eb.jsonl.gz | sub_443FB5 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_443FB5()
{
__int64 result; // rax
__int64 *j; // [rsp+0h] [rbp-10h]
int i; // [rsp+Ch] [rbp-4h]
int k; // [rsp+Ch] [rbp-4h]
for ( i = 0; i <= 63; ++i )
*(&addr + i + 292) = 0LL;
byte_4B9EF0 &= 0xDFu;
qword_4B9F88 = qword_4B9C90;
qword_4B9ED8 = 0LL;
result = qword_4B9EE0;
for ( j = (__int64 *)qword_4B9EE0; j; j = (__int64 *)*j )
{
j[4] = 0LL;
for ( k = 0; k <= 63; ++k )
j[k + 5] = 0LL;
result = *j;
}
return result;
}
Q:[j,k,sub_443FB5,] | A:{'j': 'lp', 'k': 'n', 'sub_443FB5': 'clear_varlists'} | |
1b4297534707e63cf17a74e051815bd05f8bb58dee0920fe313d0c281140889c_1b4297534707e63cf17a74e051815bd05f8bb58dee0920fe313d0c281140889c.jsonl.gz | sub_4026DF | Help user generate meaningful names for variables and functions in the following code snippet. |
_BOOL8 __fastcall sub_4026DF(unsigned __int8 a1)
{
if ( a1 > 0x2Fu && a1 <= 0x39u )
return 1LL;
if ( a1 > 0x40u && a1 <= 0x46u )
return 1LL;
return a1 > 0x60u && a1 <= 0x66u;
}
Q:[a1,sub_4026DF,] | A:{'a1': 'c', 'sub_4026DF': 'is_valid_hex_char'} | |
fca9e3ca7ac0f7d833eae9680f76d609a4d08c36b8c5c76263a4932ef4032672_fca9e3ca7ac0f7d833eae9680f76d609a4d08c36b8c5c76263a4932ef4032672.jsonl.gz | sub_42314B | Help user generate meaningful names for variables and functions in the following code snippet. |
bool __fastcall sub_42314B(__int64 a1, __int64 a2)
{
__int64 v2; // rbx
v2 = *(_QWORD *)sub_4272E2(a1);
return v2 != *(_QWORD *)sub_4272E2(a2);
}
Q:[a1,a2,sub_42314B,sub_4272E2,] | A:{'a1': '__lhs', 'a2': '__rhs', 'sub_42314B': 'allocator', 'sub_4272E2': 'base'} | |
e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6_e75abb83d2b32eafb3b1ba5f14cbfd28cf6afef01d1bc62076b5ecd1d78019e6.jsonl.gz | sub_463814 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_463814(__int64 a1, __int64 a2, __int64 a3)
{
__int64 v3; // rbx
__int64 v4; // rbx
int v5; // edx
__int16 v6; // dx
*(_DWORD *)a1 = -1;
*(_WORD *)(a1 + 4) = -1;
*(_BYTE *)(a1 + 6) = 0;
*(_DWORD *)(a1 + 8) = -1;
*(_DWORD *)(a1 + 12) = 1103626240;
*(_BYTE *)(a1 + 16) = 1;
*(_DWORD *)(a1 + 20) = 0;
*(_DWORD *)(a1 + 24) = -1;
*(_DWORD *)(a1 + 28) = -1;
*(_BYTE *)(a1 + 32) = 0;
*(_BYTE *)(a1 + 33) = 0;
*(_BYTE *)(a1 + 34) = 0;
*(_BYTE *)(a1 + 35) = 0;
*(_BYTE *)(a1 + 36) = 0;
*(_BYTE *)(a1 + 37) = 0;
*(_BYTE *)(a1 + 38) = 0;
*(_WORD *)(a1 + 40) = -1;
*(_WORD *)(a1 + 42) = -1;
if ( a3 )
{
v3 = *(_QWORD *)(a3 + 8);
*(_QWORD *)a1 = *(_QWORD *)a3;
*(_QWORD *)(a1 + 8) = v3;
v4 = *(_QWORD *)(a3 + 24);
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a3 + 16);
*(_QWORD *)(a1 + 24) = v4;
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a3 + 32);
*(_DWORD *)(a1 + 40) = *(_DWORD *)(a3 + 40);
}
else
{
*(_DWORD *)a1 = 34;
*(_WORD *)(a1 + 4) = -1;
*(_DWORD *)(a1 + 28) = -1;
*(_DWORD *)(a1 + 24) = -1;
*(_BYTE *)(a1 + 32) = 0;
*(_BYTE *)(a1 + 33) = 0;
*(_BYTE *)(a1 + 34) = 0;
*(_BYTE *)(a1 + 36) = 0;
*(_BYTE *)(a1 + 35) = 0;
*(_BYTE *)(a1 + 38) = 0;
*(_WORD *)(a1 + 40) = -1;
*(_WORD *)(a1 + 42) = -1;
}
if ( sub_462F72(a2) )
{
if ( *(_DWORD *)(a1 + 24) == -1 )
v5 = -1;
else
v5 = 0;
*(_DWORD *)(a1 + 24) = v5;
}
else
{
*(_BYTE *)(a1 + 6) = *(char *)(a2 + 110124) < 0;
*(_DWORD *)(a1 + 8) = sub_463784(*(_BYTE *)(a2 + 110124) & 7);
*(_BYTE *)(a1 + 16) = (*(_BYTE *)(a2 + 110123) & 0x20) == 0;
*(float *)(a1 + 12) = (float)(unsigned __int8)sub_462ADE(a2, *(_BYTE *)(a1 + 16));
*(_DWORD *)(a1 + 20) = sub_4637D4((*(_BYTE *)(a2 + 110124) >> 3) & 3);
if ( (*(_BYTE *)(a2 + 110124) & 0x40) != 0 )
v6 = 0;
else
v6 = -1;
*(_WORD *)(a1 + 40) = v6;
*(_BYTE *)(a1 + 34) = sub_463022(a2);
*(_BYTE *)(a1 + 37) = (unsigned __int8)sub_4631E2(a2) != *(_BYTE *)(a1 + 37);
}
return a1;
}
Q:[a3,a1,a2,sub_463814,sub_462F72,sub_463784,sub_462ADE,sub_4637D4,sub_463022,sub_4631E2,] | A:{'a3': 'prev', 'a1': 'retstr', 'a2': 'this', 'sub_463814': 'toCommon', 'sub_462F72': 'isSwingVToggle', 'sub_463784': 'toCommonMode', 'sub_462ADE': 'getTemp', 'sub_4637D4': 'toCommonFanSpeed', 'sub_463022': 'getEconoToggle', 'sub_4631E2': 'getCleanToggle'} | |
f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83_f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83.jsonl.gz | sub_4A2867 | Help user generate meaningful names for variables and functions in the following code snippet. |
_QWORD *__fastcall sub_4A2867(_QWORD *a1, unsigned __int8 *a2)
{
_QWORD *result; // rax
__int64 v3; // rax
__int64 v4; // rdx
__int64 v5; // rcx
__int64 v6; // r8
__int64 v7; // r9
int v8; // [rsp+14h] [rbp-Ch] BYREF
unsigned __int64 v9; // [rsp+18h] [rbp-8h] BYREF
if ( (unsigned int)sub_4A1FD6(a2, byte_4C7170) )
{
*a1 = sub_4A2032(a2, &v8, &v9);
if ( !*a1 || v8 != 3 )
{
v3 = sub_40918C(a2);
sub_404EF5((__int64)"unable to read blob object %s", v3, v4, v5, v6, v7);
}
result = a1;
a1[1] = v9;
}
else
{
*a1 = sub_4053F2((const char *)&unk_4D52E2, (__int64)byte_4C7170);
result = a1;
a1[1] = 0LL;
}
return result;
}
Q:[a1,a2,v8,v9,sub_4A2867,sub_4A1FD6,sub_4A2032,sub_40918C,sub_404EF5,sub_4053F2,] | A:{'a1': 'ptr', 'a2': 'sha1', 'v8': 'type', 'v9': 'size', 'sub_4A2867': 'read_mmblob', 'sub_4A1FD6': 'hashcmp_18', 'sub_4A2032': 'read_sha1_file_15', 'sub_40918C': 'sha1_to_hex', 'sub_404EF5': 'die', 'sub_4053F2': 'xstrdup'} | |
8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197_8b110aab52a6d34ace0220c53cb5bf376dd342b17223a140a48976031a819197.jsonl.gz | sub_4059E4 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4059E4(_QWORD *a1, int a2, __int64 a3, char a4, unsigned int a5)
{
__int64 v5; // rbx
__int64 v6; // rbx
unsigned int v7; // ebx
char v10[48]; // [rsp+20h] [rbp-100h] BYREF
char v11[32]; // [rsp+50h] [rbp-D0h] BYREF
char v12[47]; // [rsp+70h] [rbp-B0h] BYREF
char v13[32]; // [rsp+A0h] [rbp-80h] BYREF
char v14[32]; // [rsp+C0h] [rbp-60h] BYREF
char v15[47]; // [rsp+E0h] [rbp-40h] BYREF
unsigned __int8 v16; // [rsp+10Fh] [rbp-11h]
a1[5] = a3;
v16 = 0;
if ( a2 == 4 )
{
v16 = sub_406D04(a1);
}
else
{
if ( a2 > 4 )
goto LABEL_11;
switch ( a2 )
{
case 3:
v16 = sub_408AE2(a1, 1LL);
break;
case 1:
v16 = sub_406E8E(a1, 1LL, a5);
break;
case 2:
v16 = sub_40801E(a1);
break;
default:
LABEL_11:
__assert_fail(
"false",
"../single_include/nlohmann/json.hpp",
0x1E50u,
"bool nlohmann::detail::binary_reader<BasicJsonType, InputAdapterType, SAX>::sax_parse(nlohmann::detail::input_"
"format_t, nlohmann::detail::binary_reader<BasicJsonType, InputAdapterType, SAX>::json_sax_t*, bool, nlohmann::"
"detail::cbor_tag_handler_t) [with BasicJsonType = nlohmann::basic_json<>; InputAdapterType = nlohmann::detail:"
":iterator_input_adapter<__gnu_cxx::__normal_iterator<const unsigned char*, std::vector<unsigned char> > >; SAX"
" = nlohmann::detail::json_sax_dom_parser<nlohmann::basic_json<> >; nlohmann::detail::binary_reader<BasicJsonTy"
"pe, InputAdapterType, SAX>::json_sax_t = nlohmann::detail::json_sax_dom_parser<nlohmann::basic_json<> >]");
}
}
if ( !v16 || !a4 )
return v16;
if ( a2 == 3 )
sub_408B20(a1);
else
sub_408B52(a1);
v5 = a1[2];
if ( v5 == sub_406CF7(a1) )
return v16;
v6 = a1[5];
std::allocator<char>::allocator();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string();
sub_408BA0(v14, a1);
sub_4048DF((__int64)v13);
sub_408C5E(v11, a1, (unsigned int)a2, v13, v12);
sub_403DFA((__int64)v10, 0x6Eu, a1[3], (__int64)v11);
sub_408BA0(v15, a1);
v7 = sub_406390(v6, a1[3], v15, v10);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
sub_4207B8(v10);
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string();
std::allocator<char>::~allocator();
return v7;
}
Q:[sub_4059E4,sub_406D04,sub_408AE2,sub_406E8E,sub_40801E,sub_408B20,sub_408B52,sub_406CF7,sub_408BA0,sub_4048DF,sub_408C5E,sub_403DFA,sub_406390,sub_4207B8,] | A:{'sub_4059E4': 'sax_parse', 'sub_406D04': 'parse_bson_internal', 'sub_408AE2': 'parse_ubjson_internal', 'sub_406E8E': 'parse_cbor_internal', 'sub_40801E': 'parse_msgpack_internal', 'sub_408B20': 'get_ignore_noop', 'sub_408B52': 'get', 'sub_406CF7': 'eof', 'sub_408BA0': 'get_token_string', 'sub_4048DF': 'allocator', 'sub_408C5E': 'exception_message', 'sub_403DFA': 'create', 'sub_406390': 'parse_error', 'sub_4207B8': '~parse_error'} | |
88b297ed3b6e932b99641b5620aeec3cd941b4e06cb37924289772eefa3de8b7_88b297ed3b6e932b99641b5620aeec3cd941b4e06cb37924289772eefa3de8b7.jsonl.gz | sub_402C12 | Help user generate meaningful names for variables and functions in the following code snippet. |
size_t sub_402C12()
{
return fwrite(
"Usage: turbostat [OPTIONS][(--interval seconds) | COMMAND ...]\n"
"\n"
"Turbostat forks the specified COMMAND and prints statistics\n"
"when COMMAND completes.\n"
"If no COMMAND is specified, turbostat wakes every 5-seconds\n"
"to print statistics, until interrupted.\n"
" -a, --add\tadd a counter\n"
"\t\t eg. --add msr0x10,u64,cpu,delta,MY_TSC\n"
" -c, --cpu\tcpu-set\tlimit output to summary plus cpu-set:\n"
"\t\t {core | package | j,k,l..m,n-p }\n"
" -d, --debug\tdisplays usec, Time_Of_Day_Seconds and more debugging\n"
" -D, --Dump\tdisplays the raw counter values\n"
" -e, --enable\t[all | column]\n"
"\t\tshows all or the specified disabled column\n"
" -H, --hide [column|column,column,...]\n"
"\t\thide the specified column(s)\n"
" -i, --interval sec.subsec\n"
"\t\tOverride default 5-second measurement interval\n"
" -J, --Joules\tdisplays energy in Joules instead of Watts\n"
" -l, --list\tlist column headers only\n"
" -n, --num_iterations num\n"
"\t\tnumber of the measurement iterations\n"
" -o, --out file\n"
"\t\tcreate or truncate \"file\" for all output\n"
" -q, --quiet\tskip decoding system configuration header\n"
" -s, --show [column|column,column,...]\n"
"\t\tshow only the specified column(s)\n"
" -S, --Summary\n"
"\t\tlimits output to 1-line system summary per interval\n"
" -T, --TCC temperature\n"
"\t\tsets the Thermal Control Circuit temperature in\n"
"\t\t degrees Celsius\n"
" -h, --help\tprint this help message\n"
" -v, --version\tprint version information\n"
"\n"
"For more help, run \"man turbostat\"\n",
1uLL,
0x565uLL,
stream);
}
Q:[sub_402C12,] | A:{'sub_402C12': 'help'} | |
12a59140d23aa8cb00fada75658caad7e3d2bfb7c301ee3aa728317a1146855b_12a59140d23aa8cb00fada75658caad7e3d2bfb7c301ee3aa728317a1146855b.jsonl.gz | sub_401C16 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_401C16(FILE *a1, _DWORD *a2)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < *a2; ++i )
{
fputs(*(const char **)&a2[2 * i + 2], a1);
fputc(10, a1);
}
return 0LL;
}
Q:[a1,a2,sub_401C16,] | A:{'a1': 'of_0', 'a2': 'th', 'sub_401C16': 'print_hdr'} | |
b37d124ce3c817c18aaa5f8864fe8997d880d0b8078956ceaeedc3669181706b_b37d124ce3c817c18aaa5f8864fe8997d880d0b8078956ceaeedc3669181706b.jsonl.gz | sub_403360 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_403360(_QWORD *a1)
{
__int64 result; // rax
while ( a1 )
{
result = *a1;
if ( !*a1 )
break;
sub_4038BF(a1);
sub_4038BF(*a1);
sub_4038BF(a1);
sub_4038BF(*a1);
result = *a1;
a1 = (_QWORD *)*a1;
}
return result;
}
Q:[a1,sub_403360,sub_4038BF,] | A:{'a1': 'ptr', 'sub_403360': 'traverse_list_haswell', 'sub_4038BF': 'maccess'} | |
f223df43e71fd244b2d3fc8309aa4a9e557a38d76ce9c8ff7a1df98b1c82c5e4_f223df43e71fd244b2d3fc8309aa4a9e557a38d76ce9c8ff7a1df98b1c82c5e4.jsonl.gz | sub_42643B | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42643B(char *a1)
{
char *v2; // [rsp+0h] [rbp-18h]
char v3; // [rsp+16h] [rbp-2h]
unsigned __int8 v4; // [rsp+17h] [rbp-1h]
v2 = a1;
v4 = 1;
if ( !a1 )
return 0LL;
while ( 1 )
{
v3 = *v2;
if ( !*v2 )
break;
++v2;
if ( v3 == 10 )
++v4;
}
return v4;
}
Q:[a1,v2,v3,v4,sub_42643B,] | A:{'a1': 'str', 'v2': 'stra', 'v3': 'e', 'v4': 'line_cnt', 'sub_42643B': 'u8x8_GetStringLineCnt'} | |
4c203109843f8da4148d01ce8f9e54fd81ce3fc82864f2211a1aaeb59256f803_4c203109843f8da4148d01ce8f9e54fd81ce3fc82864f2211a1aaeb59256f803.jsonl.gz | sub_44260E | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_44260E(char *a1)
{
return sub_441C58(
a1,
(__int64)addr
+ 3416 * (unsigned int)dword_4D2C20
+ 288 * (*((_QWORD *)addr + 427 * (unsigned int)dword_4D2C20 + 20441) == 0LL)
+ 164000,
*((_DWORD *)addr + 854 * (unsigned int)dword_4D2C20 + 40904),
(__int64)"10C");
}
Q:[a1,sub_44260E,sub_441C58,] | A:{'a1': 'item', 'sub_44260E': 'Pkg_Item_Turbo_10C', 'sub_441C58': 'Pkg_Fmt_Turbo'} | |
70d82b131ab1b0dd54c1283245a2455987da4a989a7a83237e20de671db67697_70d82b131ab1b0dd54c1283245a2455987da4a989a7a83237e20de671db67697.jsonl.gz | sub_405F64 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_405F64(__int64 a1, unsigned __int16 *a2, int a3, __int64 a4)
{
unsigned int v5; // [rsp+34h] [rbp-2Ch]
unsigned int v6; // [rsp+38h] [rbp-28h]
unsigned int v7; // [rsp+40h] [rbp-20h]
char v8; // [rsp+44h] [rbp-1Ch]
unsigned int v9; // [rsp+48h] [rbp-18h]
unsigned int v10; // [rsp+48h] [rbp-18h]
unsigned int v11; // [rsp+4Ch] [rbp-14h]
unsigned int v12; // [rsp+50h] [rbp-10h]
signed int v13; // [rsp+54h] [rbp-Ch]
unsigned int i; // [rsp+58h] [rbp-8h]
unsigned int v15; // [rsp+58h] [rbp-8h]
unsigned int v16; // [rsp+5Ch] [rbp-4h]
unsigned int v17; // [rsp+5Ch] [rbp-4h]
v12 = *(_DWORD *)(a1 + 48);
v11 = *(unsigned __int16 *)(a1 + 52);
if ( v11 <= HIWORD(v12) )
sub_406CFB("assertion failed: dif >> (OD_EC_WINDOW_SIZE - 16) < r", "../src/tests/../entdec.c", 280LL);
if ( a3 <= 0 )
sub_406CFB("assertion failed: nsyms > 0", "../src/tests/../entdec.c", 281LL);
v9 = a2[a3 - 1];
if ( v9 <= 0x3FFF )
sub_406CFB("assertion failed: 16384 <= ft", "../src/tests/../entdec.c", 283LL);
if ( v9 > 0x8000 )
sub_406CFB("assertion failed: ft <= 32768U", "../src/tests/../entdec.c", 284LL);
if ( v9 > v11 )
sub_406CFB("assertion failed: ft <= r", "../src/tests/../entdec.c", 285LL);
v8 = v9 <= v11 - v9;
v10 = v9 << v8;
v7 = v11 - v10;
if ( v11 - v10 >= v10 )
sub_406CFB("assertion failed: d < ft", "../src/tests/../entdec.c", 289LL);
v5 = 2 * v7 - ((v10 < 2 * v7 ? v10 ^ (2 * v7) : 0) ^ (2 * v7));
v6 = (((int)(2 * HIWORD(v12) - v5 + 1) / 3 > (int)((v12 >> 17) ^ ((int)(HIWORD(v12) - v7) > (int)(v12 >> 17) ? (HIWORD(v12) - v7) ^ (v12 >> 17) : 0)) ? (v12 >> 17) ^ ((int)(HIWORD(v12) - v7) > (int)(v12 >> 17) ? (HIWORD(v12) - v7) ^ (v12 >> 17) : 0) ^ ((int)(2 * HIWORD(v12) - v5 + 1) / 3) : 0) ^ (v12 >> 17) ^ ((int)(HIWORD(v12) - v7) > (int)(v12 >> 17) ? (HIWORD(v12) - v7) ^ (v12 >> 17) : 0)) >> v8;
if ( v6 >= v10 >> v8 )
sub_406CFB("assertion failed: q < ft >> s", "../src/tests/../entdec.c", 304LL);
v16 = 0;
v13 = 0;
for ( i = *a2; i <= v6; i = a2[v13] )
{
v16 = i;
++v13;
}
if ( i > v10 >> v8 )
sub_406CFB("assertion failed: fh <= ft >> s", "../src/tests/../entdec.c", 308LL);
v17 = v16 << v8;
v15 = i << v8;
return sub_405A75(
a1,
v12
- (((v17 ^ (v5 < v17 ? v17 ^ v5 : 0))
+ v17
+ (((v17 - (v17 ^ (v5 < v17 ? v17 ^ v5 : 0))) >> 1) ^ (v7 < (v17 - (v17 ^ (v5 < v17 ? v17 ^ v5 : 0))) >> 1 ? v7 ^ ((v17 - (v17 ^ (v5 < v17 ? v17 ^ v5 : 0))) >> 1) : 0))) << 16),
(v15 ^ (v5 < v15 ? v15 ^ v5 : 0))
+ v15
+ (((v15 - (v15 ^ (v5 < v15 ? v15 ^ v5 : 0))) >> 1) ^ (v7 < (v15 - (v15 ^ (v5 < v15 ? v15 ^ v5 : 0))) >> 1 ? v7 ^ ((v15 - (v15 ^ (v5 < v15 ? v15 ^ v5 : 0))) >> 1) : 0))
- ((v17 ^ (v5 < v17 ? v17 ^ v5 : 0))
+ v17
+ (((v17 - (v17 ^ (v5 < v17 ? v17 ^ v5 : 0))) >> 1) ^ (v7 < (v17 - (v17 ^ (v5 < v17 ? v17 ^ v5 : 0))) >> 1 ? v7 ^ ((v17 - (v17 ^ (v5 < v17 ? v17 ^ v5 : 0))) >> 1) : 0))),
v13,
a4);
}
Q:[a3,a4,a1,a2,v5,v6,v7,v8,v10,v11,v12,i,v16,sub_405F64,sub_406CFB,sub_405A75,] | A:{'a3': 'nsyms', 'a4': 'acc_str', 'a1': 'dec', 'a2': 'cdf', 'v5': 'e', 'v6': 'q', 'v7': 'd', 'v8': 's', 'v10': 'ft', 'v11': 'r', 'v12': 'dif', 'i': 'fh', 'v16': 'fl', 'sub_405F64': 'od_ec_decode_cdf_', 'sub_406CFB': 'od_fatal_impl', 'sub_405A75': 'od_ec_dec_normalize_'} | |
83bc2e05fa5444e354f267389b497358bfc179c1babf5ee1daf389919d571037_83bc2e05fa5444e354f267389b497358bfc179c1babf5ee1daf389919d571037.jsonl.gz | sub_407F70 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_407F70(__int64 a1, __int64 a2)
{
__int64 v3; // rax
int v4; // eax
__int64 v5; // rax
__int64 v6; // rax
__int64 v7; // rax
int v10; // [rsp+18h] [rbp-48h] BYREF
int v11; // [rsp+1Ch] [rbp-44h] BYREF
__int64 v12; // [rsp+20h] [rbp-40h]
__int64 v13; // [rsp+28h] [rbp-38h]
__int64 v14[3]; // [rsp+30h] [rbp-30h] BYREF
__int64 v15; // [rsp+48h] [rbp-18h]
int v16; // [rsp+54h] [rbp-Ch]
char **v17; // [rsp+58h] [rbp-8h]
v14[0] = 0LL;
v14[1] = 0LL;
v12 = 0LL;
v13 = 0LL;
v15 = 0LL;
while ( a1 )
{
if ( (*(_DWORD *)(a2 + 80) & 8) == 0 && (v17 = sub_404EB7(a1)) != 0LL )
{
if ( v12 )
{
*(_QWORD *)(v13 + 16) = 0LL;
v15 = sub_407E75(v14, 0LL, 14);
v3 = sub_408388(v12, 1LL, a2);
*(_QWORD *)(v15 + 8) = v3;
v13 = 0LL;
v12 = 0LL;
}
if ( (*(_DWORD *)(a2 + 80) & 0x400000) != 0 )
{
v16 = 4;
}
else
{
if ( !strcmp(*v17, "STYLE") )
v4 = 5;
else
v4 = 4;
v16 = v4;
}
v15 = sub_407E75(v14, a1, v16);
a1 = sub_405656(v15, (__int64)v17, &v10);
if ( v10 )
{
*(_DWORD *)(v15 + 40) = 14;
v5 = sub_408388(*(_QWORD *)(v15 + 16), 1LL, a2);
*(_QWORD *)(v15 + 8) = v5;
*(_QWORD *)(v15 + 16) = 0LL;
}
}
else if ( sub_405902(a1) )
{
v6 = sub_4074D3(a1, a2);
a1 = sub_407F06(v6, &v11);
}
else
{
if ( v12 )
{
*(_QWORD *)(v13 + 16) = a1;
v13 = a1;
}
else
{
v13 = a1;
v12 = a1;
}
a1 = *(_QWORD *)(a1 + 16);
}
}
if ( v12 )
{
*(_QWORD *)(v13 + 16) = 0LL;
v15 = sub_407E75(v14, 0LL, 14);
v7 = sub_408388(v12, 1LL, a2);
*(_QWORD *)(v15 + 8) = v7;
}
return v14[0];
}
Q:[a1,a2,v10,v11,v12,v14,v15,v16,v17,sub_407F70,sub_404EB7,sub_407E75,sub_408388,sub_405656,sub_405902,sub_4074D3,sub_407F06,] | A:{'a1': 'ptr', 'a2': 'f', 'v10': 'unclosed', 'v11': 'eaten', 'v12': 'source', 'v14': 'd', 'v15': 'p', 'v16': 'blocktype', 'v17': 'tag', 'sub_407F70': 'compile_document', 'sub_404EB7': 'isopentag', 'sub_407E75': 'Pp', 'sub_408388': 'compile', 'sub_405656': 'htmlblock', 'sub_405902': 'isfootnote', 'sub_4074D3': 'addfootnote', 'sub_407F06': 'consume'} | |
3a7b792028bedb7be20f69d30dd7794216a4b0f0ef69f4c9a39c83c0989f3a0f_3a7b792028bedb7be20f69d30dd7794216a4b0f0ef69f4c9a39c83c0989f3a0f.jsonl.gz | sub_4029F9 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4029F9(__int64 a1, __int64 a2)
{
__int64 result; // rax
FILE *v3; // rbx
const char *v4; // rax
unsigned int v5; // [rsp+1Ch] [rbp-14h]
v5 = sub_402AA4(a1, a2);
result = (unsigned int)dword_4080FC;
if ( dword_4080FC == 1 )
{
if ( v5 )
{
fwrite("Subprocess error ", 1uLL, 0x11uLL, stderr);
v3 = stderr;
v4 = (const char *)sub_404715(v5, 10LL, 1LL);
fputs(v4, v3);
fwrite("\nABORTING HARD\n", 1uLL, 0xFuLL, stderr);
exit(1);
}
}
return result;
}
Q:[a1,a2,v5,sub_4029F9,sub_402AA4,sub_404715,] | A:{'a1': 'script', 'a2': 'argv', 'v5': 'status', 'sub_4029F9': 'execute', 'sub_402AA4': '_execute', 'sub_404715': 'int2str'} | |
7421faa8c444aeca9266add08f45c75a4f43aebd993f880cd35dd964f63fdfb2_7421faa8c444aeca9266add08f45c75a4f43aebd993f880cd35dd964f63fdfb2.jsonl.gz | sub_477467 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_477467(__int64 a1, _QWORD *a2)
{
__int64 v2; // rbx
__int64 v3; // rbx
__int64 v4; // rbx
__int64 v5; // rbx
__int64 result; // rax
__int64 v7[3]; // [rsp+10h] [rbp-60h] BYREF
__int64 v8[3]; // [rsp+28h] [rbp-48h] BYREF
__int64 v9[5]; // [rsp+40h] [rbp-30h] BYREF
v9[3] = __readfsqword(0x28u);
v2 = a2[7];
v7[0] = a2[6];
v7[1] = v2;
v3 = a2[9];
v7[2] = a2[8];
v8[0] = v3;
v4 = a2[11];
v8[1] = a2[10];
v8[2] = v4;
v5 = a2[13];
v9[0] = a2[12];
v9[1] = v5;
v9[2] = a2[14];
if ( (int)sub_46186F((__int64 *)(a1 + 592), (__int64)v7, (__int64)v8, (__int64)v9) >= 0 )
result = 0LL;
else
result = 0xFFFFFFFFLL;
return result;
}
Q:[a1,a2,v7,sub_477467,sub_46186F,] | A:{'a1': 'conn', 'a2': 'raw_server_data', 'v7': 'dhe_data', 'sub_477467': 's2n_dhe_server_key_recv_parse_data', 'sub_46186F': 's2n_dh_p_g_Ys_to_dh_params'} | |
6fd1fd6b811014087ab068b5dde4a7c86fc54e8e790d85b5135cc35bc9885aab_6fd1fd6b811014087ab068b5dde4a7c86fc54e8e790d85b5135cc35bc9885aab.jsonl.gz | send_ctx_info | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall send_ctx_info(int a1)
{
FILE *v1; // rax
int v3; // [rsp+1Ch] [rbp-4h] BYREF
v3 = a1;
v1 = sub_42DC26();
return ppack(v1, 0LL, &v3);
}
Q:[a1,v3,sub_42DC26,] | A:{'a1': 'ctx', 'v3': 'cmsg', 'sub_42DC26': 'get_pipe'} | |
b7fe0a41777564954fab2fa97407222fe62c56ec7cc3104df89487be10c2d243_b7fe0a41777564954fab2fa97407222fe62c56ec7cc3104df89487be10c2d243.jsonl.gz | sub_40C965 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40C965(__int64 a1, int a2, char a3, __int16 a4)
{
__int64 result; // rax
memset((void *)a1, 0, 0xF0uLL);
*(_DWORD *)(a1 + 12) = a2;
*(_BYTE *)(a1 + 16) = a3;
result = a1;
*(_WORD *)(a1 + 18) = a4;
return result;
}
Q:[a3,a4,a1,a2,sub_40C965,] | A:{'a3': 'code', 'a4': 'mid', 'a1': 'packet', 'a2': 'type', 'sub_40C965': 'coap_init_message'} | |
8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2_8e89f9502949c1a463a3dd08a58c3c7a60591689c0f4de603abd6f5993935ae2.jsonl.gz | sub_43E493 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43E493(__int64 a1, __int64 a2)
{
unsigned __int8 v3; // [rsp+1Fh] [rbp-1h] BYREF
return sub_43E38A(a1, a2, 0LL, &v3);
}
Q:[a1,a2,v3,sub_43E493,sub_43E38A,] | A:{'a1': 'pk1', 'a2': 'pk2', 'v3': 'type', 'sub_43E493': 'as_unpack_compare', 'sub_43E38A': 'msgpack_compare_internal'} | |
50f91fbb687e4aca8337eb5bce28a71df6ee79200978534756911134280b1f04_50f91fbb687e4aca8337eb5bce28a71df6ee79200978534756911134280b1f04.jsonl.gz | sub_4018E8 | Help user generate meaningful names for variables and functions in the following code snippet. |
__off_t __fastcall sub_4018E8(char *a1)
{
int *v1; // rax
char *v2; // rax
int *v4; // rax
char *v5; // rax
struct stat stat_buf; // [rsp+10h] [rbp-A0h] BYREF
__int64 v7; // [rsp+A0h] [rbp-10h]
FILE *stream; // [rsp+A8h] [rbp-8h]
if ( (int)sub_404070(a1, &stat_buf) < 0 )
goto LABEL_2;
if ( stat_buf.st_size )
return stat_buf.st_size;
stream = fopen(a1, "r");
if ( !stream )
{
LABEL_2:
v1 = __errno_location();
v2 = strerror(*v1);
fprintf(stderr, "Failed to get boot image size (%s)!", v2);
return -1LL;
}
fseek(stream, 0LL, 2);
v7 = ftell(stream);
fclose(stream);
if ( v7 > 0 )
return v7;
v4 = __errno_location();
v5 = strerror(*v4);
fprintf(stderr, "Failed to get boot image size (fseek -> ftell failed, %s)!", v5);
return -1LL;
}
Q:[a1,stat_buf,v7,stream,sub_4018E8,sub_404070,] | A:{'a1': 'path', 'stat_buf': 'info', 'v7': 'size', 'stream': 'f', 'sub_4018E8': 'get_bootimg_size', 'sub_404070': 'stat_0'} | |
a8a78f7d12b4be4664d2b69853927f379cd38f83b505a131adc36bb98e3a8736_a8a78f7d12b4be4664d2b69853927f379cd38f83b505a131adc36bb98e3a8736.jsonl.gz | sub_4030F4 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_4030F4()
{
dword_4231EC = 4;
LOBYTE(dword_4231E0) = sub_40159D(++dword_4231E4 + 256) & 0xEF;
dword_4231E0 = (unsigned __int8)dword_4231E0;
return (unsigned int)++dword_4231E8;
}
Q:[sub_4030F4,sub_40159D,] | A:{'sub_4030F4': 'OPC_6502_28', 'sub_40159D': 'MemReadByte'} | |
7fc81bc5e05805462160f0f7e72ba32357f81d09a102ced059628d2f6c88ce53_7fc81bc5e05805462160f0f7e72ba32357f81d09a102ced059628d2f6c88ce53.jsonl.gz | sub_417C3E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_417C3E(__int64 a1)
{
return sub_417CA5(a1) + 8;
}
Q:[a1,sub_417C3E,sub_417CA5,] | A:{'a1': 'object', 'sub_417C3E': 'object_get_external_data', 'sub_417CA5': 'object_get_allocated_data'} | |
258f9f7c6ece4aef809773d5d7825f681cb0968e55404bd9821bae7f8c43cfb1_258f9f7c6ece4aef809773d5d7825f681cb0968e55404bd9821bae7f8c43cfb1.jsonl.gz | sub_406F0A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_406F0A(__int64 a1, __int64 a2)
{
__int64 result; // rax
if ( a2 )
result = sub_407AF6(a1, a2);
else
result = 0LL;
return result;
}
Q:[sub_406F0A,sub_407AF6,] | A:{'sub_406F0A': '_M_allocate', 'sub_407AF6': 'allocate'} | |
fc9efd69c78bfd2879262c7c7b7f2edcc043a9e3211c855fda31906cc6864565_fc9efd69c78bfd2879262c7c7b7f2edcc043a9e3211c855fda31906cc6864565.jsonl.gz | sub_417A8A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_417A8A(int a1, __off64_t a2)
{
__int64 result; // rax
if ( lseek64(a1, a2, 0) == -1 )
result = 0xFFFFFFFFLL;
else
result = 0LL;
return result;
}
Q:[a1,a2,sub_417A8A,] | A:{'a1': 'handle', 'a2': 'abs_pos', 'sub_417A8A': 'osal_seek'} | |
352fdfcb7ad00bcfe1eb90e77706ee9f5d528da6873a13d133796fdd79f5b633_352fdfcb7ad00bcfe1eb90e77706ee9f5d528da6873a13d133796fdd79f5b633.jsonl.gz | sub_43558F | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_43558F(__int64 a1)
{
int v2; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
v3 = *(_DWORD *)(a1 + 16);
v2 = *(_DWORD *)(a1 + 60);
if ( (unsigned int)sub_404FE0(a1, "---")
|| (*(_DWORD *)(a1 + 16) = v3, *(_DWORD *)(a1 + 60) = v2, (unsigned int)sub_404FE0(a1, "...")) )
{
if ( (unsigned int)sub_43583A(a1) )
return 1LL;
}
*(_DWORD *)(a1 + 16) = v3;
*(_DWORD *)(a1 + 60) = v2;
return 0LL;
}
Q:[a1,v2,v3,sub_43558F,sub_404FE0,sub_43583A,] | A:{'a1': 'G', 'v2': 'yythunkpos0', 'v3': 'yypos0', 'sub_43558F': 'yy_YAMLStop', 'sub_404FE0': 'yymatchString', 'sub_43583A': 'yy_BlankLine'} | |
8cdff8415a6722605eba3681c736361b2f4e448e341437d289c12f16da04f4e2_8cdff8415a6722605eba3681c736361b2f4e448e341437d289c12f16da04f4e2.jsonl.gz | sub_40DBF0 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_40DBF0(__int64 a1)
{
__int64 v1; // rbx
__int64 v2; // rdx
v1 = 1LL;
fwrite("pc =", 1uLL, 4uLL, stream);
fprintf(stream, "%016lx", *(_QWORD *)(a1 + 8));
fputc(32, stream);
do
{
while ( 1 )
{
fprintf(stream, "%-3s=", off_42E7C0[v1]);
fprintf(stream, "%016lx", *(_QWORD *)(a1 + 8 * v1 + 16));
if ( (v1 & 3) == 3 )
break;
++v1;
fputc(32, stream);
if ( v1 == 32 )
goto LABEL_5;
}
++v1;
fputc(10, stream);
}
while ( v1 != 32 );
LABEL_5:
fprintf(stream, "priv=%c", (unsigned int)byte_42C143[*(unsigned __int8 *)(a1 + 801)]);
fwrite(" mstatus=", 1uLL, 9uLL, stream);
v2 = *(_QWORD *)(a1 + 864) | (*(unsigned __int8 *)(a1 + 802) << 13);
if ( ((*(_WORD *)(a1 + 864) | (unsigned __int16)(*(unsigned __int8 *)(a1 + 802) << 13)) & 0x6000) == 24576LL
|| (v2 & 0x18000) == 98304 )
{
v2 |= 0x8000000000000000LL;
}
fprintf(stream, "%016lx", v2);
fprintf(stream, " insn_counter=%ld", *(_QWORD *)(a1 + 808));
fprintf(stream, " minstret=%ld", *(_QWORD *)(a1 + 816));
fprintf(stream, " mcycle=%ld", *(_QWORD *)(a1 + 824));
fputc(10, stream);
fwrite(" mideleg=", 1uLL, 9uLL, stream);
fprintf(stream, "%016lx", *(unsigned int *)(a1 + 960));
fwrite(" mie=", 1uLL, 5uLL, stream);
fprintf(stream, "%016lx", *(unsigned int *)(a1 + 948));
fwrite(" mip=", 1uLL, 5uLL, stream);
fprintf(stream, "%016lx", *(unsigned int *)(a1 + 952));
return fputc(10, stream);
}
Q:[a1,sub_40DBF0,] | A:{'a1': 's', 'sub_40DBF0': 'riscv_dump_regs'} | |
d641d4455ba968ec8cdc678803903e8adc4e0f690e4b42f19186ba657d295323_d641d4455ba968ec8cdc678803903e8adc4e0f690e4b42f19186ba657d295323.jsonl.gz | sub_41ABCF | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_41ABCF()
{
sub_41BCBF(&qword_442848);
return sub_41BCBF(&qword_442850);
}
Q:[sub_41ABCF,sub_41BCBF,] | A:{'sub_41ABCF': 'btmesh_db_init', 'sub_41BCBF': 'sl_slist_init'} | |
f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83_f831702f41994ee170774af7a79dac102dd372be4a801864a0cdf0753939ec83.jsonl.gz | sub_40F9A4 | Help user generate meaningful names for variables and functions in the following code snippet. |
_QWORD *__fastcall sub_40F9A4(_QWORD *a1)
{
_QWORD *result; // rax
while ( a1 )
{
sub_40F92D((__int64)a1);
result = (_QWORD *)*a1;
a1 = (_QWORD *)*a1;
}
return result;
}
Q:[a1,sub_40F9A4,sub_40F92D,] | A:{'a1': 'r', 'sub_40F9A4': 'prune_refs', 'sub_40F92D': 'prune_ref'} | |
decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08_decb9d72b93d941cc30c251e69b1ae930ef147e67c065af3feea2db57aca5f08.jsonl.gz | sub_4C8BA7 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4C8BA7(__int64 **a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5, __int64 a6)
{
__int64 result; // rax
__int64 **i; // [rsp+10h] [rbp-20h]
if ( *((int *)a1 + 516) > 1 )
{
if ( *((_DWORD *)a1 + 517) )
{
eprintf(1, "FAILED %s:%d %s\n", (__int64)"tests/parse-events.c", 31LL, (__int64)"wrong number of groups", a6);
result = 0xFFFFFFFFLL;
}
else
{
for ( i = (__int64 **)*a1; i != a1; i = (__int64 **)*i )
{
if ( *((_DWORD *)i + 4) != 2 )
{
eprintf(1, "FAILED %s:%d %s\n", (__int64)"tests/parse-events.c", 34LL, (__int64)"wrong type", a6);
return 0xFFFFFFFFLL;
}
if ( i[5] != (__int64 *)1412 )
{
eprintf(1, "FAILED %s:%d %s\n", (__int64)"tests/parse-events.c", 36LL, (__int64)"wrong sample_type", a6);
return 0xFFFFFFFFLL;
}
if ( i[4] != (__int64 *)1 )
{
eprintf(1, "FAILED %s:%d %s\n", (__int64)"tests/parse-events.c", 38LL, (__int64)"wrong sample_period", a6);
return 0xFFFFFFFFLL;
}
}
result = 0LL;
}
}
else
{
eprintf(1, "FAILED %s:%d %s\n", (__int64)"tests/parse-events.c", 30LL, (__int64)"wrong number of entries", a6);
result = 0xFFFFFFFFLL;
}
return result;
}
Q:[a1,i,sub_4C8BA7,] | A:{'a1': 'evlist', 'i': 'evsel', 'sub_4C8BA7': 'test__checkevent_tracepoint_multi'} | |
6fd1fd6b811014087ab068b5dde4a7c86fc54e8e790d85b5135cc35bc9885aab_6fd1fd6b811014087ab068b5dde4a7c86fc54e8e790d85b5135cc35bc9885aab.jsonl.gz | sub_40B8FF | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_40B8FF()
{
__int64 v0; // rax
tcase_fn_start("test_ck_assert_float_nonnan_with_mod", "check_check_sub.c", 923LL);
v0 = tcase_name();
record_test_name(v0);
return mark_point("check_check_sub.c", 928LL);
}
Q:[sub_40B8FF,] | A:{'sub_40B8FF': 'test_ck_assert_float_nonnan_with_mod'} | |
3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353_3c26826d30953c6610a5cbaa1a21fa70e07051d67c07c54975320fb7cc8ea353.jsonl.gz | sub_42F352 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42F352(__int64 a1)
{
__int64 v1; // rax
int v2; // ebx
__int64 v3; // rax
__int64 v4; // rax
__int64 v5; // rax
bool v6; // al
bool v7; // al
char v9[47]; // [rsp+10h] [rbp-C0h] BYREF
bool v10; // [rsp+3Fh] [rbp-91h]
__int64 v11; // [rsp+40h] [rbp-90h]
int *v12; // [rsp+48h] [rbp-88h]
unsigned int *v13; // [rsp+50h] [rbp-80h]
__int64 v14; // [rsp+58h] [rbp-78h]
_DWORD *v15; // [rsp+60h] [rbp-70h]
unsigned int v16; // [rsp+6Ch] [rbp-64h]
__int64 v17; // [rsp+70h] [rbp-60h]
_DWORD *v18; // [rsp+78h] [rbp-58h]
__int64 v19; // [rsp+80h] [rbp-50h]
__int64 v20; // [rsp+88h] [rbp-48h]
unsigned int *v21; // [rsp+90h] [rbp-40h]
__int64 v22; // [rsp+98h] [rbp-38h]
__int64 v23; // [rsp+A0h] [rbp-30h]
unsigned int l; // [rsp+ACh] [rbp-24h]
__int64 k; // [rsp+B0h] [rbp-20h]
unsigned int j; // [rsp+B8h] [rbp-18h]
unsigned int i; // [rsp+BCh] [rbp-14h]
v23 = a1;
v22 = a1 + 12160;
if ( *(_DWORD *)(a1 + 6976) )
__assert_fail(
"g.Windows.Size == 0",
"../../imgui.cpp",
0x2EF0u,
"void ImGui::DockContextPruneUnusedSettingsNodes(ImGuiContext*)");
sub_447866(v9);
sub_4478D4(v9, *(unsigned int *)(v22 + 32));
for ( i = 0; (signed int)i < *(_DWORD *)(v22 + 32); ++i )
{
v21 = (unsigned int *)sub_44790C(v22 + 32, i);
if ( v21[1] )
v1 = sub_447960(v9, v21[1]);
else
v1 = 0LL;
v20 = v1;
if ( v1 )
v2 = *(_DWORD *)(v20 + 12);
else
v2 = *v21;
*(_DWORD *)(sub_4479AC(v9, *v21) + 12) = v2;
if ( v21[1] )
{
v3 = sub_4479AC(v9, v21[1]);
++*(_DWORD *)(v3 + 8);
}
}
for ( j = 0; (signed int)j < *(_DWORD *)(v22 + 32); ++j )
{
v19 = sub_44790C(v22 + 32, j);
if ( *(_DWORD *)(v19 + 8) )
{
v18 = sub_42B18A(*(_DWORD *)(v19 + 8));
if ( v18 )
{
if ( v18[5] )
{
v17 = sub_447960(v9, (unsigned int)v18[5]);
if ( v17 )
++*(_DWORD *)(v17 + 8);
}
}
}
}
for ( k = sub_4473A8(v23 + 12256); k; k = sub_4473DE(v23 + 12256, k) )
{
v16 = *(_DWORD *)(k + 20);
if ( v16 )
{
v15 = (_DWORD *)sub_447960(v9, v16);
if ( v15 )
{
++*v15;
v4 = (__int64)(v16 == v15[3] ? v15 : sub_447960(v9, (unsigned int)v15[3]));
v14 = v4;
if ( v4 )
++*(_DWORD *)(v14 + 4);
}
}
}
for ( l = 0; (signed int)l < *(_DWORD *)(v22 + 32); ++l )
{
v13 = (unsigned int *)sub_44790C(v22 + 32, l);
v12 = (int *)sub_447960(v9, *v13);
if ( *v12 <= 1 )
{
v5 = (__int64)(v12[3] == *v13 ? v12 : sub_447960(v9, (unsigned int)v12[3]));
v11 = v5;
v10 = 0;
v6 = *v12 == 1 && !v13[1] && !v12[2] && (v13[5] & 0x800) == 0;
v10 = v10 || v6;
v7 = !*v12 && !v13[1] && !v12[2];
v10 = v10 || v7;
v10 = v10 || *(_DWORD *)(v11 + 4) == 0;
if ( v10 )
{
sub_43AC4A(v13, 1LL);
*v13 = 0;
}
}
}
return sub_44789C(v9);
}
Q:[a1,v9,v10,v11,v12,v13,v14,v15,v16,v17,v18,v19,v20,v21,v22,v23,l,k,j,i,sub_42F352,sub_447866,sub_4478D4,sub_44790C,sub_447960,sub_4479AC,sub_42B18A,sub_4473A8,sub_4473DE,sub_43AC4A,sub_44789C,] | A:{'a1': 'ctx', 'v9': 'pool', 'v10': 'remove', 'v11': 'data_root_0', 'v12': 'data_1', 'v13': 'settings_2', 'v14': 'data_root', 'v15': 'data_0', 'v16': 'dock_id', 'v17': 'data', 'v18': 'window_settings', 'v19': 'settings_0', 'v20': 'parent_data', 'v21': 'settings', 'v22': 'dc', 'v23': 'g', 'l': 'settings_n_1', 'k': 'settings_1', 'j': 'settings_n_0', 'i': 'settings_n', 'sub_42F352': 'DockContextPruneUnusedSettingsNodes', 'sub_447866': 'ImPool', 'sub_4478D4': 'Reserve', 'sub_44790C': 'operator[]', 'sub_447960': 'GetByKey', 'sub_4479AC': 'GetOrAddByKey', 'sub_42B18A': 'FindWindowSettings', 'sub_4473A8': 'begin', 'sub_4473DE': 'next_chunk', 'sub_43AC4A': 'DockSettingsRemoveNodeReferences', 'sub_44789C': '~ImPool'} | |
25704a965dec99975424e2827e1fd510210b9d6cd5f079ef91488ae33df75d23_25704a965dec99975424e2827e1fd510210b9d6cd5f079ef91488ae33df75d23.jsonl.gz | sub_401B5E | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_401B5E()
{
__int64 v0; // rax
__int64 v2; // [rsp+18h] [rbp-8h]
v2 = sub_40465F();
v0 = sub_40465F();
return sub_4040AD(v0, v2);
}
Q:[v2,sub_401B5E,sub_40465F,sub_4040AD,] | A:{'v2': 'e', 'sub_401B5E': 'yy_2_definition', 'sub_40465F': 'pop', 'sub_4040AD': 'Rule_setExpression'} | |
4c37d94e6e7036c83e2bbac033138232245f9e10dde9739277eb47fcaa18953e_4c37d94e6e7036c83e2bbac033138232245f9e10dde9739277eb47fcaa18953e.jsonl.gz | sub_42B600 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_42B600(__int64 a1, __m128 _XMM0, __m128 _XMM1, __m128 a4, __m128 a5, __m128 a6, __m128 a7, __m128 a8, __m128 a9)
{
__int64 result; // rax
_QWORD *v11; // r10
__m256i *v14; // r8
int v16; // esi
__int64 v17; // r9
__int64 v18; // rcx
unsigned int v19; // edx
__int64 *v20; // rax
unsigned __int64 v21; // rdi
unsigned __int64 v22; // rdx
unsigned __int64 v23; // r11
unsigned __int64 v24; // rdx
__int64 *v25; // r12
__int64 v26; // r14
__int64 v27; // rdx
__int64 v28; // r15
unsigned int v29; // eax
__int64 v30; // rdx
__int64 v31; // rcx
__int64 v32; // r8
__int64 v33; // r9
__m128 v34; // xmm4
__m128 v35; // xmm5
__int64 v36; // rcx
__int64 v37; // r8
__int64 v38; // r9
__m128 v39; // xmm4
__m128 v40; // xmm5
__int64 v41; // rcx
__int64 v42; // r8
__int64 v43; // r9
__m128 v44; // xmm4
__m128 v45; // xmm5
__int64 v46; // rdx
__int64 v47; // rdx
char v48; // [rsp-10h] [rbp-D0h]
char v49; // [rsp-10h] [rbp-D0h]
char v50; // [rsp-10h] [rbp-D0h]
char v51; // [rsp-10h] [rbp-D0h]
__int128 v52; // [rsp+0h] [rbp-C0h] BYREF
__m256i v53; // [rsp+10h] [rbp-B0h] BYREF
__m256i v54; // [rsp+30h] [rbp-90h]
__int128 v55; // [rsp+50h] [rbp-70h]
__int128 v56; // [rsp+60h] [rbp-60h]
__int128 v57; // [rsp+70h] [rbp-50h]
__int128 v58; // [rsp+80h] [rbp-40h]
result = (unsigned int)qword_4BD1D0;
if ( (_DWORD)qword_4BD1D0 != HIDWORD(qword_4BD1D0) )
{
v11 = (_QWORD *)qword_4BD1D8;
if ( qword_4BD1D8 )
{
__asm
{
vpxor xmm0, xmm0, xmm0
vmovdqa xmmword ptr [rsp+0D0h+var_B0], xmm0
vmovdqa xmmword ptr [rsp+0D0h+var_B0+10h], xmm0
vmovdqa xmmword ptr [rsp+0D0h+var_90], xmm0
vmovdqa xmmword ptr [rsp+0D0h+var_90+10h], xmm0
vmovdqa [rsp+0D0h+var_70], xmm0
vmovdqa [rsp+0D0h+var_60], xmm0
vmovdqa [rsp+0D0h+var_50], xmm0
vmovdqa [rsp+0D0h+var_40], xmm0
}
if ( (unsigned int)qword_4BD1D0 >= HIDWORD(qword_4BD1D0) )
{
if ( (_DWORD)qword_4BD1D0 == 0x40000 )
goto LABEL_36;
LODWORD(v52) = qword_4BD1D0;
*(_QWORD *)((char *)&v52 + 4) = 0x40000LL;
HIDWORD(v52) = HIDWORD(qword_4BD1D0);
}
else
{
*((_QWORD *)&v52 + 1) = 0LL;
__asm
{
vmovd xmm1, eax
vpinsrd xmm0, xmm1, edx, 1
vmovq [rsp+0D0h+var_C0], xmm0
}
}
v14 = (__m256i *)&v52;
__asm { vpxor xmm0, xmm0, xmm0 }
v16 = 0;
v17 = 0xFFFFFFFFFFFFLL;
while ( 1 )
{
v18 = v14->m256i_u32[0];
v19 = v14->m256i_u32[1];
if ( (unsigned int)v18 < v19 )
break;
LABEL_15:
v14 = (__m256i *)((char *)v14 + 8);
if ( &v53 == v14 )
{
v25 = (__int64 *)&qword_51C180;
v26 = 0LL;
result = 0LL;
__asm { vzeroupper }
while ( 1 )
{
v27 = *v25;
if ( *v25 )
{
v28 = v53.m256i_i64[v26];
if ( v28 || *(_QWORD *)((char *)&v55 + v26 * 8) )
{
if ( !(_BYTE)result )
{
v29 = *(_DWORD *)(a1 + 5128);
if ( v29 > 0x7F )
goto LABEL_36;
v30 = v29 + 1;
*(_DWORD *)(a1 + 5128) = v30;
*(_QWORD *)(a1 + 8LL * v29) = 4468161LL;
if ( v29 == 127 )
goto LABEL_36;
*(_DWORD *)(a1 + 5128) = v29 + 2;
*(_QWORD *)(a1 + 8 * v30) = 4468161LL;
v27 = *v25;
}
sub_42B330(a1, "%s excl", v27, v18, (__int64)v14, v17, _XMM0, _XMM1, a4, a5, a6, a7, a8, a9, v48);
sub_42B330(a1, "%5lld", v28, v31, v32, v33, _XMM0, _XMM1, a4, a5, v34, v35, a8, a9, v49);
sub_42B330(a1, "%s incl", *v25, v36, v37, v38, _XMM0, _XMM1, a4, a5, v39, v40, a8, a9, v50);
sub_42B330(
a1,
"%5lld",
v28 + *(_QWORD *)((char *)&v55 + v26 * 8),
v41,
v42,
v43,
_XMM0,
_XMM1,
a4,
a5,
v44,
v45,
a8,
a9,
v51);
result = 1LL;
}
}
v25 += 5126;
++v26;
if ( &unk_56C300 == (_UNKNOWN *)v25 )
return result;
}
}
}
v20 = (__int64 *)(*v11 + 8LL * (unsigned int)v18);
v21 = *v11 + 8 * ((unsigned int)v18 + (unsigned __int64)(v19 - 1 - (unsigned int)v18)) + 8;
while ( 1 )
{
while ( 1 )
{
v18 = *v20;
v22 = (unsigned __int64)*v20 >> 61;
if ( v22 != 1 )
break;
++v16;
LABEL_9:
if ( (__int64 *)v21 == ++v20 )
goto LABEL_15;
}
if ( v22 != 2 )
{
if ( !v22 )
{
if ( v16 )
{
--v16;
}
else
{
*(_QWORD *)&v55 = v53.m256i_i64[0] + v55;
*((_QWORD *)&v55 + 1) += v53.m256i_i64[1];
*(_QWORD *)&v56 = v53.m256i_i64[2] + v56;
v46 = v53.m256i_i64[3];
__asm { vmovdqa [rsp+0D0h+var_B0], ymm0 }
*((_QWORD *)&v56 + 1) += v46;
*(_QWORD *)&v57 = v54.m256i_i64[0] + v57;
*((_QWORD *)&v57 + 1) += v54.m256i_i64[1];
*(_QWORD *)&v58 = v54.m256i_i64[2] + v58;
v47 = v54.m256i_i64[3];
__asm { vmovdqa [rsp+0D0h+var_90], ymm0 }
*((_QWORD *)&v58 + 1) += v47;
}
}
goto LABEL_9;
}
v18 &= 0xFFFFFFFFFFFFuLL;
v23 = HIWORD(*v20);
v24 = v23 & 0x1FFF;
if ( (v23 & 0x1FF8) != 0 )
{
__asm { vzeroupper }
LABEL_36:
BUG();
}
if ( v16 <= 1 )
{
v53.m256i_i64[v24] += v18;
goto LABEL_9;
}
++v20;
*((_QWORD *)&v55 + v24) += v18;
if ( (__int64 *)v21 == v20 )
goto LABEL_15;
}
}
}
return result;
}
Q:[sub_42B600,sub_42B330,] | A:{'sub_42B600': 'MicroProfileToolTipMeta', 'sub_42B330': 'MicroProfileStringArrayFormat'} | |
3928f6f5dfff8e9c26fb15c7ada4f08fa799a0e6d2f3c508b15d3bd272eac115_3928f6f5dfff8e9c26fb15c7ada4f08fa799a0e6d2f3c508b15d3bd272eac115.jsonl.gz | sub_4034F0 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4034F0(__int64 a1, int a2, double *a3, __int64 a4, __int64 a5, __int64 a6, double a7, double a8)
{
__int64 v8; // rcx
__int64 v9; // r8
__int64 v10; // r9
__int64 v11; // rcx
__int64 v12; // r8
__int64 v13; // r9
__int64 v14; // rcx
__int64 v15; // r8
__int64 v16; // r9
__int64 v17; // rcx
__int64 v18; // r8
__int64 v19; // r9
__int64 v20; // rcx
__int64 v21; // r8
__int64 v22; // r9
__int64 result; // rax
unsigned int v26[12]; // [rsp+30h] [rbp-B0h] BYREF
unsigned int v27[12]; // [rsp+60h] [rbp-80h] BYREF
unsigned int v28[12]; // [rsp+90h] [rbp-50h] BYREF
double *v29; // [rsp+C0h] [rbp-20h]
double *v30; // [rsp+C8h] [rbp-18h]
unsigned int i; // [rsp+D4h] [rbp-Ch]
int v32; // [rsp+D8h] [rbp-8h]
unsigned int v33; // [rsp+DCh] [rbp-4h]
sub_402EFE(
6u,
(__int64)"SXX tune %f MHz (fref=%f MHz) begin",
(__int64)a3,
a4,
a5,
a6,
a8 / 1000000.0,
a7 / 1000000.0);
sub_402C43(a1, a2);
*(_DWORD *)(*(_QWORD *)(a1 + 4528) + 1632LL) = 0;
sub_40AF59(a1, 284LL);
*(_DWORD *)(*(_QWORD *)(a1 + 4528) + 1632LL) = 1;
sub_40AF59(a1, 284LL);
sub_40301B(v26, a7, a8, 3800000000.0, 5222000000.0, 284LL, (__int64)v26, v8, v9, v10);
sub_40301B(v27, a7, a8, 4961000000.0, 6754000000.0, 284LL, *(__int64 *)&a7, v11, v12, v13);
sub_40301B(v28, a7, a8, 6306000000.0, 7714000000.0, 284LL, *(__int64 *)&a7, v14, v15, v16);
v33 = -1;
v32 = -1;
for ( i = 0; (int)i <= 2; ++i )
{
v29 = (double *)&v26[12 * i];
if ( *((_BYTE *)v29 + 40) == 1 )
{
sub_4032AE(a1, v29);
sub_402EFE(7u, (__int64)"Testing for SEL_VCO = %d", i, v20, v21, v22);
*(_DWORD *)(*(_QWORD *)(a1 + 4528) + 1752LL) = i;
sub_40AF59(a1, 289LL);
if ( !(unsigned int)sub_4123B3(
a1,
*(_QWORD *)(a1 + 4528) + 1748LL,
289LL,
*(_QWORD *)(a1 + 4528) + 1780LL,
*(_QWORD *)(a1 + 4528) + 1784LL,
291LL) )
{
if ( v32 == -1
|| (v17 = (unsigned int)((v32 - 128) >> 31),
(int)abs32(*(_DWORD *)(*(_QWORD *)(a1 + 4528) + 1748LL) - 128) < (int)abs32(v32 - 128)) )
{
v33 = i;
v32 = *(_DWORD *)(*(_QWORD *)(a1 + 4528) + 1748LL);
}
}
}
}
if ( v33 == -1 )
{
sub_403B94(3LL, "VCO select FAIL");
result = 4294967293LL;
}
else
{
sub_402EFE(7u, (__int64)"Choosing SEL_VCO = %d", v33, v17, v18, v19);
*(_DWORD *)(*(_QWORD *)(a1 + 4528) + 1748LL) = v32;
*(_DWORD *)(*(_QWORD *)(a1 + 4528) + 1752LL) = v33;
sub_40AF59(a1, 289LL);
*(_DWORD *)(*(_QWORD *)(a1 + 4528) + 1636LL) = 0;
sub_40AF59(a1, 284LL);
v30 = (double *)&v26[12 * v33];
sub_4032AE(a1, v30);
if ( a2 == 2 )
*(double *)(a1 + 4544) = a8;
if ( a2 == 1 )
*(double *)(a1 + 4552) = a8;
if ( a2 == 2 )
*(double *)(a1 + 4568) = a7;
if ( a2 == 1 )
*(double *)(a1 + 4576) = a7;
if ( a3 )
*a3 = ((double)*((int *)v30 + 5) / 1048576.0 + (double)(*((_DWORD *)v30 + 4) + 4))
* ((double)(1 << *((_DWORD *)v30 + 9))
* a7)
/ (double)*((int *)v30 + 8);
result = 0LL;
}
return result;
}
Q:[a3,a1,a2,a7,a8,v26,v29,v30,i,v32,v33,sub_4034F0,sub_402EFE,sub_402C43,sub_40AF59,sub_40301B,sub_4032AE,sub_4123B3,sub_403B94,] | A:{'a3': 'factual', 'a1': 'self', 'a2': 'direction', 'a7': 'fref', 'a8': 'fout', 'v26': 'states', 'v29': 's_0', 'v30': 's', 'i': 'SEL_VCO_i', 'v32': 'CSW_VCO_best', 'v33': 'SEL_VCO_best', 'sub_4034F0': 'LMS7002M_set_lo_freq', 'sub_402EFE': 'LMS7_logf', 'sub_402C43': 'LMS7002M_set_mac_dir', 'sub_40AF59': 'LMS7002M_regs_spi_write', 'sub_40301B': 'LMS7002M_sxx_calc_tune_state', 'sub_4032AE': 'LMS7002M_sxx_apply_tune_state', 'sub_4123B3': 'LMS7002M_tune_vco', 'sub_403B94': 'LMS7_log'} | |
e3620101844e8d6e64abf9b73043ebe1218fb6a8cf20bdc149ecf9dbfed98545_e3620101844e8d6e64abf9b73043ebe1218fb6a8cf20bdc149ecf9dbfed98545.jsonl.gz | sub_40EB1A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_40EB1A(__int64 a1, unsigned int a2, unsigned int a3)
{
return sub_40ECF7(a1 + 33630424, a2, a3);
}
Q:[a3,a1,a2,sub_40EB1A,sub_40ECF7,] | A:{'a3': 'mode', 'a1': 'core', 'a2': 'address', 'sub_40EB1A': 'F1C100sSPI0Read', 'sub_40ECF7': 'F1C100sSPIRead'} | |
16265d36e785b01ab7c4f58b3656e0c6d08390a77bbd0bef82e61eaee743327b_16265d36e785b01ab7c4f58b3656e0c6d08390a77bbd0bef82e61eaee743327b.jsonl.gz | sub_403970 | Help user generate meaningful names for variables and functions in the following code snippet. |
void *__fastcall sub_403970(void *a1, size_t a2)
{
size_t v2; // rax
void *result; // rax
if ( a2 )
v2 = a2;
else
v2 = 1LL;
if ( a1 )
result = realloc(a1, v2);
else
result = malloc(v2);
if ( !result )
{
fwrite("realloc failed!\n", 1uLL, 0x10uLL, _bss_start);
exit(1);
}
return result;
}
Q:[a1,a2,sub_403970,] | A:{'a1': 'ptr', 'a2': 'bytes', 'sub_403970': 'reallocate'} | |
34e1f47d7c3f4a6a8540956845e947b127c61352252002721d774608d8656d0e_34e1f47d7c3f4a6a8540956845e947b127c61352252002721d774608d8656d0e.jsonl.gz | sub_402572 | Help user generate meaningful names for variables and functions in the following code snippet. |
int __fastcall sub_402572(const char *a1)
{
return printf("%s", a1);
}
Q:[a1,sub_402572,] | A:{'a1': 'buf', 'sub_402572': 'X_display_line'} | |
c305b540beeb91de0683f14151efc79b8231667323725757dad9e744300ff63d_c305b540beeb91de0683f14151efc79b8231667323725757dad9e744300ff63d.jsonl.gz | sub_411E80 | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_411E80()
{
int v0; // edx
int v1; // ecx
int v2; // er8
int v3; // er9
Window *v4; // rbx
unsigned int v5; // eax
XSetWindowAttributes v6; // [rsp+0h] [rbp-140h] BYREF
XWindowChanges v7; // [rsp+70h] [rbp-D0h] BYREF
XSetWindowAttributes v8; // [rsp+A0h] [rbp-A0h] BYREF
int v9; // [rsp+114h] [rbp-2Ch]
char *v10; // [rsp+118h] [rbp-28h]
unsigned int v11; // [rsp+124h] [rbp-1Ch]
__int64 i; // [rsp+128h] [rbp-18h]
v10 = sub_4101C9(0LL);
v9 = *((_DWORD *)v10 + 11) + *((_DWORD *)v10 + 13);
v11 = 1;
if ( !ptr )
{
ptr = calloc(1uLL, 0x10uLL);
if ( !ptr )
sub_41367C((unsigned int)"fatal: could not malloc() %u bytes\n", 16, v0, v1, v2, v3);
memset(&v6, 0, sizeof(v6));
v6.background_pixel = *(_QWORD *)(*(_QWORD *)qword_419D78 + 16LL);
v6.event_mask = 32772LL;
v6.override_redirect = 1;
v6.colormap = qword_419DD8;
v4 = (Window *)ptr;
*v4 = XCreateWindow(
display,
qword_419DA0,
v9,
*((_DWORD *)v10 + 10),
v11,
dword_419C4C,
0,
dword_419DD0,
1u,
qword_419DC8,
0x2A0AuLL,
&v6);
XSelectInput(display, *(_QWORD *)ptr, 0x80000LL);
XChangeProperty(display, *(_QWORD *)ptr, qword_419CD8, 6uLL, 32, 0, &byte_419DB8, 1);
XChangeProperty(
display,
*(_QWORD *)ptr,
qword_419CE0,
0x20uLL,
32,
0,
(const unsigned __int8 *)&qword_419DC8->visualid,
1);
XChangeProperty(display, *(_QWORD *)ptr, qword_419D08, 4uLL, 32, 0, &qword_419D10, 1);
XMapRaised(display, *(_QWORD *)ptr);
XSetSelectionOwner(display, qword_419CC8, *(_QWORD *)ptr, 0LL);
if ( XGetSelectionOwner(display, qword_419CC8) != *(_QWORD *)ptr )
{
fwrite("dwm: unable to obtain system tray.\n", 1uLL, 0x23uLL, _bss_start);
free(ptr);
ptr = 0LL;
return;
}
sub_40EBE6(qword_419DA0, qword_419D40, 0x20000, 0LL, qword_419CC8, *(_QWORD *)ptr, 0);
XSync(display, 0);
}
v11 = 0;
for ( i = *((_QWORD *)ptr + 1); i; i = *(_QWORD *)(i + 392) )
{
v8.background_pixel = *(_QWORD *)(*(_QWORD *)qword_419D78 + 16LL);
XChangeWindowAttributes(display, *(_QWORD *)(i + 416), 2uLL, &v8);
XMapRaised(display, *(_QWORD *)(i + 416));
*(_DWORD *)(i + 268) = v11;
XMoveResizeWindow(
display,
*(_QWORD *)(i + 416),
*(_DWORD *)(i + 268),
0,
*(_DWORD *)(i + 276),
*(_DWORD *)(i + 280));
v11 += *(_DWORD *)(i + 276);
if ( v10 != *(char **)(i + 408) )
*(_QWORD *)(i + 408) = v10;
}
if ( v11 )
v5 = v11;
else
v5 = 1;
v11 = v5;
v9 -= v5;
XMoveResizeWindow(display, *(_QWORD *)ptr, v9, *((_DWORD *)v10 + 10), v5, dword_419C4C);
v7.x = v9;
v7.y = *((_DWORD *)v10 + 10);
v7.width = v11;
v7.height = dword_419C4C;
v7.stack_mode = 0;
v7.sibling = *((_QWORD *)v10 + 19);
XConfigureWindow(display, *(_QWORD *)ptr, 0x6Fu, &v7);
XMapWindow(display, *(_QWORD *)ptr);
XMapSubwindows(display, *(_QWORD *)ptr);
XSetForeground(display, *(GC *)(qword_419D88 + 64), *(_QWORD *)(*(_QWORD *)qword_419D78 + 16LL));
XFillRectangle(display, *(_QWORD *)ptr, *(GC *)(qword_419D88 + 64), 0, 0, v11, dword_419C4C);
XSync(display, 0);
}
Q:[v6,v7,v8,v9,v10,v11,sub_411E80,sub_4101C9,sub_41367C,sub_40EBE6,] | A:{'v6': 'wa_0', 'v7': 'wc', 'v8': 'wa', 'v9': 'x', 'v10': 'm', 'v11': 'w', 'sub_411E80': 'updatesystray', 'sub_4101C9': 'systraytomon', 'sub_41367C': 'die', 'sub_40EBE6': 'sendeventsystray'} | |
507b6d6826ab1404fd3df13a4b27da226b5beb2f60ed3e979a82f4c0a6725d69_507b6d6826ab1404fd3df13a4b27da226b5beb2f60ed3e979a82f4c0a6725d69.jsonl.gz | sub_423C96 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_423C96(_QWORD *a1)
{
return sub_442DC3(*a1);
}
Q:[a1,sub_423C96,sub_442DC3,] | A:{'a1': 'map', 'sub_423C96': 'gt_map_get_seq_name', 'sub_442DC3': 'gt_string_get_string'} | |
fe853fdf0ea214c31ee1548d41053864861f40f40a42d4cf89561829e3543a3b_fe853fdf0ea214c31ee1548d41053864861f40f40a42d4cf89561829e3543a3b.jsonl.gz | sub_414230 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_414230(int c)
{
unsigned int v1; // ebp
v1 = 0;
if ( c && (((*__ctype_b_loc())[c] & 8) != 0 || strchr(".-_", c)) )
v1 = 1;
return v1;
}
Q:[sub_414230,] | A:{'sub_414230': 'isIdentifier'} | |
eec34215ebfdb5a3218eeb77b1546d6d001312b1ea4361ffbda4ac1d3e99e353_eec34215ebfdb5a3218eeb77b1546d6d001312b1ea4361ffbda4ac1d3e99e353.jsonl.gz | sub_412024 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_412024(unsigned int a1)
{
return a1;
}
Q:[a1,sub_412024,] | A:{'a1': 'id', 'sub_412024': 'NFP_CPP_ID_ISLAND_of_0'} | |
e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433_e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433.jsonl.gz | sub_409099 | Help user generate meaningful names for variables and functions in the following code snippet. |
void sub_409099()
{
;
}
Q:[sub_409099,] | A:{'sub_409099': 'delete'} | |
4c37d94e6e7036c83e2bbac033138232245f9e10dde9739277eb47fcaa18953e_4c37d94e6e7036c83e2bbac033138232245f9e10dde9739277eb47fcaa18953e.jsonl.gz | j_._ZdlPv_25 | Help user generate meaningful names for variables and functions in the following code snippet. |
// attributes: thunk
void __fastcall operator delete(void *a1)
{
._ZdlPv(a1);
}
Q:[a1,] | A:{'a1': 'this'} | |
fca9e3ca7ac0f7d833eae9680f76d609a4d08c36b8c5c76263a4932ef4032672_fca9e3ca7ac0f7d833eae9680f76d609a4d08c36b8c5c76263a4932ef4032672.jsonl.gz | sub_421A4A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 sub_421A4A()
{
return std::operator<<<std::char_traits<char>>();
}
Q:[sub_421A4A,] | A:{'sub_421A4A': 'GTestStreamToHelper'} | |
8cae1a4a33735ef95c4c8b1612d43b76781ee98149adfbb3f86481ae23018b4c_8cae1a4a33735ef95c4c8b1612d43b76781ee98149adfbb3f86481ae23018b4c.jsonl.gz | sub_45AA57 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_45AA57(_DWORD *a1)
{
return (unsigned int)(506832829 * *a1) >> 15;
}
Q:[a1,sub_45AA57,] | A:{'a1': 'data', 'sub_45AA57': 'HashBytesH10_0'} | |
45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0_45450e7da787ad8522c4254a1fb55d2f2a0245c269fcd1544f5f008e388e64c0.jsonl.gz | sub_41733A | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_41733A(__int64 a1, __int64 a2)
{
return sub_41785E(a1, a2);
}
Q:[a1,a2,sub_41733A,sub_41785E,] | A:{'a1': '__first', 'a2': '__last', 'sub_41733A': '_Destroy', 'sub_41785E': '_Destroy'} | |
a7ee28fac247a90985baa623246f120e383625b5e201cc1a0fad679dd75b91d6_a7ee28fac247a90985baa623246f120e383625b5e201cc1a0fad679dd75b91d6.jsonl.gz | sub_405E48 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_405E48(char a1, int a2)
{
__int64 i; // [rsp+10h] [rbp-8h]
for ( i = qword_42C738; i; i = *(_QWORD *)(i + 40) )
sub_405DDF(i, a1, a2);
return 0LL;
}
Q:[a1,a2,i,sub_405E48,sub_405DDF,] | A:{'a1': 'option', 'a2': 'value', 'i': 'lobj', 'sub_405E48': 'aim_log_option_set_all', 'sub_405DDF': 'aim_log_option_set'} | |
352fdfcb7ad00bcfe1eb90e77706ee9f5d528da6873a13d133796fdd79f5b633_352fdfcb7ad00bcfe1eb90e77706ee9f5d528da6873a13d133796fdd79f5b633.jsonl.gz | sub_431A90 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_431A90(_DWORD *a1)
{
__int64 result; // rax
int v2; // [rsp+18h] [rbp-8h]
int v3; // [rsp+1Ch] [rbp-4h]
v3 = a1[4];
v2 = a1[15];
if ( (unsigned int)sub_404FE0((__int64)a1, "{{TOC}}") && (unsigned int)sub_43628E(a1) && (unsigned int)sub_4361B4(a1) )
{
sub_405120((__int64)a1, (__int64)sub_40A34E, a1[9], a1[10], (__int64)"yy_1_TOC");
result = 1LL;
}
else
{
a1[4] = v3;
a1[15] = v2;
result = 0LL;
}
return result;
}
Q:[a1,v2,v3,sub_431A90,sub_404FE0,sub_43628E,sub_4361B4,sub_405120,sub_40A34E,] | A:{'a1': 'G', 'v2': 'yythunkpos0', 'v3': 'yypos0', 'sub_431A90': 'yy_TOC', 'sub_404FE0': 'yymatchString', 'sub_43628E': 'yy_Sp', 'sub_4361B4': 'yy_Newline', 'sub_405120': 'yyDo', 'sub_40A34E': 'yy_1_TOC'} | |
26443bb961d6d223ad03db23f3a2c970d54aeb6a3a2bd37212d51400b9fc5aea_26443bb961d6d223ad03db23f3a2c970d54aeb6a3a2bd37212d51400b9fc5aea.jsonl.gz | sub_4023E7 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_4023E7(int *a1, unsigned int a2, int *a3)
{
__int64 result; // rax
if ( a2 != -1 )
{
*a3 = -1;
if ( (unsigned int)sub_40220C(*a1, a2) )
return 0LL;
}
*a3 = accept(*a1, 0LL, 0LL);
if ( *a3 >= 0 )
result = 1LL;
else
result = 0xFFFFFFFFLL;
return result;
}
Q:[a3,a1,a2,sub_4023E7,sub_40220C,] | A:{'a3': 'outSock', 'a1': 'listenSock', 'a2': 'timeout', 'sub_4023E7': 'so_accept', 'sub_40220C': 'readtmo'} | |
e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433_e191f669788b22c0b8bd75b10116cb2ec96663b4afd68f9ebf351c4b8ecb8433.jsonl.gz | sub_44DC03 | Help user generate meaningful names for variables and functions in the following code snippet. |
__int64 __fastcall sub_44DC03(__int64 a1, __int64 a2, __int64 a3)
{
return sub_44E779(a1, a2, a3);
}
Q:[sub_44DC03,sub_44E779,] | A:{'sub_44DC03': 'move_iterator', 'sub_44E779': 'move_iterator'} |