name string | code string | asm string | file string |
|---|---|---|---|
GetInfoRequestRPLIDAR(RPLIDAR*, int*, int*, int*, int*, char*) | inline int GetInfoRequestRPLIDAR(RPLIDAR* pRPLIDAR, int* pModelID, int* pHardwareVersion, int* pFirmwareMajor, int* pFirmwareMinor, char* SerialNumber)
{
int i = 0;
#ifdef ENABLE_RPLIDAR_SDK_SUPPORT
sl_lidar_response_device_info_t devinfo;
if (SL_IS_FAIL(pRPLIDAR->drv->getDeviceInfo(devinfo)))
{
pri... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movq %rsi, %r13
movq %rdi, %r14
movw $0x50a5, 0x2(%rsp) # imm = 0x50A5
xorl %r12d, %r12d
movl %r12d, 0x8(%rsp)
movl %r12d, 0xc(%rsp)
movl %r12d, 0x4(%rsp)
movl 0x328(%rdi), %eax
leaq 0xe440(%rip), %rbp # 0x30917
... | /ENSTABretagneRobotics[P]Hardware-MATLAB/RPLIDAR.h |
StartScanRequestRPLIDAR(RPLIDAR*) | inline int StartScanRequestRPLIDAR(RPLIDAR* pRPLIDAR)
{
#ifdef ENABLE_RPLIDAR_SDK_SUPPORT
if (SL_IS_FAIL(pRPLIDAR->drv->startScan(false, false)))
{
printf("A RPLIDAR is not responding correctly : startScan() failed. \n");
return EXIT_FAILURE;
}
pRPLIDAR->nodes_cache->clear();
#else
unsigned char reqb... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movw $0x20a5, 0xa(%rsp) # imm = 0x20A5
xorl %r15d, %r15d
movl %r15d, 0x14(%rsp)
movl %r15d, 0x10(%rsp)
movl %r15d, 0xc(%rsp)
movl 0x328(%rdi), %eax
leaq 0xde65(%rip), %rbx # 0x30917
leal -0x1(%rax), %ecx
cmpl $0x4, %ecx
jae 0x22af0
m... | /ENSTABretagneRobotics[P]Hardware-MATLAB/RPLIDAR.h |
GetAddrPortTypeFromDevPath(char*, char*, unsigned long, char*, unsigned long, int*) | inline int GetAddrPortTypeFromDevPath(char* szDevPath, char* address, size_t addresslen, char* port, size_t portlen, int* pDevType)
{
char* ptr = NULL;
char* ptr2 = NULL;
size_t tmplen = 0;
if ((szDevPath == NULL)||(address == NULL)||(port == NULL)||(pDevType == NULL)||(addresslen < 16)||(portlen < 6)) retur... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x6, %r8
jb 0x26034
movq %rdx, %rbx
cmpq $0x10, %rdx
jb 0x26034
movq %rdi, %r12
testq %rdi, %rdi
je 0x26034
testq %rsi, %rsi
je 0x26034
testq %rcx, %rcx
je 0x26034
movq %r9, %r15
testq %r9, %r9
je 0x26034
movq %r8, %r13
xorl %ebp, ... | /ENSTABretagneRobotics[P]Hardware-MATLAB/OSNet.h |
inittcpsrv(int*, char*, char*, int, int) | inline int inittcpsrv(SOCKET* pSock, char* address, char* port, int maxnbcli, int timeout)
{
struct sockaddr_in sa;
#ifdef _WIN32
WSADATA wsaData;
#endif // _WIN32
#ifdef _WIN32
// Initiate use of the Winsock 2 DLL (WS2_32.dll) by a process.
if (WSAStartup(MAKEWORD(2,2), &wsaData) != EXIT_SUCCESS)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %ecx, 0xc(%rsp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %r14d
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x9100
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0x265cb
movl %eax, %r13d
movslq %ebp... | /ENSTABretagneRobotics[P]Hardware-MATLAB/OSNet.h |
waitforclifortcpsrv(int, int*, int) | inline int waitforclifortcpsrv(SOCKET socksrv, SOCKET* pSockCli, int timeout)
{
fd_set sock_set;
int iResult = SOCKET_ERROR;
struct timeval tv;
struct sockaddr_storage addr;
socklen_t addrlen = sizeof(struct sockaddr_storage);
char hostname[NI_MAXHOST];
char service[NI_MAXSERV];
tv.tv_sec = (long)(ti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x550, %rsp # imm = 0x550
movq %rsi, %rbx
movl %edi, %r14d
movl $0x80, 0xc(%rsp)
movslq %edx, %rax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
movslq %ecx, %rcx
movq %rcx, 0x10(... | /ENSTABretagneRobotics[P]Hardware-MATLAB/OSNet.h |
initudpcli(int*, char*, char*) | inline int initudpcli(SOCKET* pSock, char* address, char* port)
{
struct sockaddr_in sa;
#ifdef _WIN32
WSADATA wsaData;
#endif // _WIN32
#ifdef _WIN32
// Initiate use of the Winsock 2 DLL (WS2_32.dll) by a process.
if (WSAStartup(MAKEWORD(2,2), &wsaData) != EXIT_SUCCESS)
{
PRINT_DEBUG_ERROR_OSNET((... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x2, %edi
movl $0x2, %esi
movl $0x11, %edx
callq 0x9100
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0x26863
movl %eax, %r13d
movq %rsp, %r12
movq $0xa, (%r12)
movq $0x0, 0x8(%r12)
movl $0x1... | /ENSTABretagneRobotics[P]Hardware-MATLAB/OSNet.h |
waitforcliforudpsrv(int, int*, int) | inline int waitforcliforudpsrv(SOCKET socksrv, SOCKET* pSockCli, int timeout)
{
fd_set sock_set;
int iResult = SOCKET_ERROR;
struct timeval tv;
struct sockaddr_storage addr;
socklen_t addrlen = sizeof(struct sockaddr_storage);
char hostname[NI_MAXHOST];
char service[NI_MAXSERV];
char buf[65535];
tv... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10550, %rsp # imm = 0x10550
movq %rsi, %rbx
movl %edi, %r14d
movl $0x80, 0xc(%rsp)
movslq %edx, %rax
imulq $0x10624dd3, %rax, %rcx # imm = 0x10624DD3
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x26, %rcx
addl %edx, %ecx
movslq %ecx, %rcx
movq %rcx, 0x1... | /ENSTABretagneRobotics[P]Hardware-MATLAB/OSNet.h |
SetOptionsComputerRS232Port(void*, unsigned int, unsigned char, int, unsigned char, unsigned char, unsigned int) | inline int SetOptionsComputerRS232Port(HANDLE hDev, UINT BaudRate, BYTE ParityMode, BOOL bCheckParity, BYTE nbDataBits,
BYTE StopBitsMode, UINT timeout)
{
// Should we do something like PurgeComm(g_hCom,PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|PURGE_RXCLEAR) / tcflush
// in the beginning of this f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r9d, %ebp
movl %r8d, %r13d
movl %ecx, %r14d
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movups %xmm0, 0x2c(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
... | /ENSTABretagneRobotics[P]Hardware-MATLAB/OSComputerRS232Port.h |
ConvertToDoubleMT(int, unsigned char*, int, double*) | inline int ConvertToDoubleMT(int OutputSettings, unsigned char* buf, int offset, double* pValue)
{
usInt_MT usl;
usShort_MT uss;
uInt_MT ul;
LARGE_INTEGER li;
uDouble_MT ud;
uFloat_MT uf;
switch (OutputSettings & OUTPUT_FORMAT_MASK)
{
case OUTPUT_FORMAT_DOUBLE:
ud.c[0] = buf[7+offset];
ud.c[1... | shrl $0x8, %edi
andl $0x3, %edi
movslq %edx, %rax
leaq 0x5f87(%rip), %r8 # 0x2e38c
movslq (%r8,%rdi,4), %rdi
addq %r8, %rdi
jmpq *%rdi
movl (%rsi,%rax), %eax
bswapl %eax
movd %eax, %xmm0
cvtss2sd %xmm0, %xmm0
jmp 0x28479
movzbl 0x5(%rsi,%rax), %edi
movzbl 0x4(%rsi,%rax), %r8d
shll $0x8, %r8d
movswl %r8w, %r8d
orl... | /ENSTABretagneRobotics[P]Hardware-MATLAB/MT.h |
PurgeRS232Port(RS232PORT*) | inline int PurgeRS232Port(RS232PORT* pRS232Port)
{
switch (pRS232Port->DevType)
{
case TCP_CLIENT_TYPE_RS232PORT:
case TCP_SERVER_TYPE_RS232PORT:
case UDP_CLIENT_TYPE_RS232PORT:
case UDP_SERVER_TYPE_RS232PORT:
return flushsocket(pRS232Port->s);
case LOCAL_TYPE_RS232PORT:
return PurgeComputerRS232Po... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
movl 0x310(%rdi), %eax
movl $0x1, %edx
leal -0x1(%rax), %ecx
cmpl $0x4, %ecx
jae 0x28769
movl 0x8(%rdi), %r14d
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r8
movaps %xmm0, (%r8)
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rs... | /ENSTABretagneRobotics[P]Hardware-MATLAB/RS232Port.h |
ReadChannelP33x(P33X*, unsigned char, float*) | inline int ReadChannelP33x(P33X* pP33x, uint8 Channel, float* pValue)
{
uint8 readbuf[9];
uint8 writebuf[5];
uint8 crc_h = 0;
uint8 crc_l = 0;
uFloat_P33X value;
//int stat = 0;
writebuf[0] = (uint8)0xfa; // device address = 250
writebuf[1] = (uint8)0x49; // function 73
writebuf[2] = (uint8)Channel... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movw $0x49fa, 0xa(%rsp) # imm = 0x49FA
movb %sil, 0xc(%rsp)
movl $0xffff, %eax # imm = 0xFFFF
movb $0x3, %cl
xorl %edx, %edx
movzbl 0xa(%rsp,%rdx), %esi
xorl %esi, %eax
movb $0x8, %sil
movl %eax, %edi
shrl %edi
m... | /ENSTABretagneRobotics[P]Hardware-MATLAB/P33x.h |
InitP33x(P33X*) | inline int InitP33x(P33X* pP33x)
{
uint8 readbuf[10];
uint8 writebuf[4];
uint8 crc_h = 0;
uint8 crc_l = 0;
//int devclass = 0;
//int group = 0;
//int year = 0;
//int week = 0;
//int buf = 0;
//int stat = 0;
writebuf[0] = (uint8)0xfa; // device address = 250
writebuf[1] = (uint8)0x30; // funct... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movw $0x30fa, 0xa(%rsp) # imm = 0x30FA
movl $0xffff, %eax # imm = 0xFFFF
movb $0x2, %cl
xorl %edx, %edx
movzbl 0xa(%rsp,%rdx), %esi
xorl %esi, %eax
movb $0x8, %sil
movl %eax, %edi
shrl %edi
movl %edi, %r8d
xorl $0xa001, %r8d ... | /ENSTABretagneRobotics[P]Hardware-MATLAB/P33x.h |
handlecliThreadProc | THREAD_PROC_RETURN_VALUE handlecliThreadProc(void* pHandlecliThreadParam)
{
int (*handlecli)(SOCKET, void*) = ((HANDLECLITHREADPARAM*)pHandlecliThreadParam)->handlecli;
SOCKET sockcli = ((HANDLECLITHREADPARAM*)pHandlecliThreadParam)->sockcli;
void* pParam = ((HANDLECLITHREADPARAM*)pHandlecliThreadParam)->pParam;... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movq 0x10(%rdi), %rsi
movl %ebp, %edi
callq *(%rbx)
movq %rbx, %rdi
callq 0x9700
movl %ebp, %edi
movl $0x2, %esi
callq 0x97d0
movl %ebp, %edi
callq 0x9ba0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
| /ENSTABretagneRobotics[P]Hardware-MATLAB/OSNet.c |
PromptForUserInputTimeout | char PromptForUserInputTimeout(UINT timeout)
{
#ifdef _WIN32
HANDLE hStdin = INVALID_HANDLE_VALUE;
DWORD fdwMode = 0, fdwSaveOldMode = 0;
INPUT_RECORD irInBuf[1];
DWORD cNumRead = 0;
//char buf[32];
//DWORD dwReadBytes = 0;
CHRONO chrono;
double duration = 0;
fprintf(stdout, "Press any key to con... | pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movl %edi, %ebx
movq 0x93eb(%rip), %r15 # 0x36cc0
movq (%r15), %rcx
leaq 0x3265(%rip), %rdi # 0x30b44
movl $0x20, %esi
movl $0x1, %edx
callq 0x9b80
movq (%r15), %rdi
callq 0x96d0
leaq 0x64(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x9680
movups (%r14),... | /ENSTABretagneRobotics[P]Hardware-MATLAB/OSMisc.c |
calloc_array2 | void* calloc_array2(int height, int width, size_t SizeOfElements)
{
int i = 0, ki = 0;
void** p = NULL;
p = (void**)calloc(height, sizeof(void*));
if (p == NULL)
{
return p;
}
for (i = 0; i < height; i++)
{
p[i] = (void*)calloc(width, SizeOfElements);
if (p[i] == NULL)
{
for (ki... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movl %edi, %ebp
movslq %edi, %rdi
movl $0x8, %esi
callq 0x93b0
testq %rax, %rax
je 0x2dd34
movq %rax, %rbx
testl %ebp, %ebp
jle 0x2dd36
movslq %r15d, %r15
movl %ebp, %r12d
xorl %r13d, %r13d
movq %r15, %rdi
movq... | /ENSTABretagneRobotics[P]Hardware-MATLAB/OSMisc.c |
free_array2 | void free_array2(void** p, int height)
{
int i = 0;
if (p == NULL)
{
return;
}
for (i = 0; i < height; i++)
{
free(p[i]); p[i] = NULL;
}
free(p); p = NULL;
} | testq %rdi, %rdi
je 0x2dec4
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x2deb7
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x9700
movq $0x0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x2de9e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9700
retq
| /ENSTABretagneRobotics[P]Hardware-MATLAB/OSMisc.c |
setup_cute_reporter_tests | static void setup_cute_reporter_tests(void) {
reporter = create_cute_reporter();
// We can not use setup_reporting() since we are running
// inside a test suite which needs the real reporting
// So we'll have to set up the messaging explicitly
reporter->ipc = start_cgreen_messaging(666);
clear... | pushq %rax
callq 0x2140
movq %rax, 0x2fc5(%rip) # 0x5220
movl $0x29a, %edi # imm = 0x29A
callq 0x2160
movq 0x2fb4(%rip), %rcx # 0x5220
movl %eax, 0x80(%rcx)
callq 0x28cc
movq 0x2fa2(%rip), %rdi # 0x5220
leaq 0x66f(%rip), %rsi # 0x28f4
callq 0x20d0
movq 0x2f8f(%rip), %rdi # 0x5220
le... | /cgreen-devs[P]cgreen/tests/cute_reporter_tests.c |
cute_reporter_tests | TestSuite *cute_reporter_tests(void) {
TestSuite *suite = create_test_suite();
set_setup(suite, setup_cute_reporter_tests);
add_test_with_context(suite, CuteReporter, will_report_beginning_of_suite);
add_test_with_context(suite, CuteReporter, will_report_beginning_and_successful_finishing_of_test);
... | pushq %rbx
leaq 0x942(%rip), %rdi # 0x313e
leaq 0x81c(%rip), %rsi # 0x301f
movl $0xc3, %edx
callq 0x2170
movq %rax, %rbx
leaq -0x5c9(%rip), %rsi # 0x224e
movq %rax, %rdi
callq 0x2050
leaq 0x7da(%rip), %rsi # 0x3000
movq 0x279b(%rip), %rdx # 0x4fc8
movq %rbx, %rdi
callq 0x20f0
leaq 0x846(%rip... | /cgreen-devs[P]cgreen/tests/cute_reporter_tests.c |
teardown_cute_reporter_tests | static void teardown_cute_reporter_tests(void) {
//bad mojo when running tests in same process, as destroy_reporter also sets
//context.reporter = NULL, thus breaking the next test to run
destroy_reporter(reporter);
if (NULL != output) {
free(output);
//need to set output to NULL to avoi... | pushq %rax
movq 0x2977(%rip), %rdi # 0x5220
callq 0x2120
movq 0x2973(%rip), %rdi # 0x5228
testq %rdi, %rdi
je 0x28ca
callq 0x20e0
movq $0x0, 0x295e(%rip) # 0x5228
popq %rax
retq
| /cgreen-devs[P]cgreen/tests/cute_reporter_tests.c |
mocked_printf | static int mocked_printf(const char *format, ...) {
int result = 0;
va_list ap;
va_start(ap, format);
result = mocked_vprintf(format, ap);
va_end(ap);
return result;
} | subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x294f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)... | /cgreen-devs[P]cgreen/tests/cute_reporter_tests.c |
mocked_vprintf | static int mocked_vprintf(const char *format, va_list arguments) {
char buffer[10000];
vsnprintf(buffer, sizeof(buffer), format, arguments);
output = concat(output, buffer);
return strlen(output);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x2710, %rsp # imm = 0x2710
movq %rsi, %r9
movq %rdi, %r8
movq %rsp, %rbx
movl $0x2710, %esi # imm = 0x2710
movl $0x2710, %ecx # imm = 0x2710
movq %rbx, %rdi
movl $0x1, %edx
callq 0x20b0
movq 0x2879(%rip), %r14 # 0x5228
movq %r14, %rdi
callq 0x20... | /cgreen-devs[P]cgreen/tests/cute_reporter_tests.c |
main | int main()
{
typedef booster::shared_ptr<cppcms::sessions::session_storage_factory> sfact_type;
try {
std::cout << "Testing thread cache... "<< std::flush;
test_cache(cppcms::impl::thread_cache_factory(20));
std::cout << "Ok" << std::endl;
#if !defined(CPPCMS_WIN32) && !defined(CPPCMS_NO_PREFOK_CACHE)
std::... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq 0x4995(%rip), %rdi # 0xafb8
leaq 0x1d84(%rip), %rsi # 0x83ae
movl $0x18, %edx
callq 0x3290
movq 0x497d(%rip), %rdi # 0xafb8
callq 0x3150
leaq 0xd8(%rsp), %rdi
movl $0x14, %esi
callq 0x3080
leaq 0xd8(%rs... | /artyom-beilis[P]cppcms/tests/cache_backend_test.cpp |
nhr_request_create | nhr_request nhr_request_create(void) {
struct nhr_request_struct * r = (struct nhr_request_struct *)nhr_malloc_zero(sizeof(struct nhr_request_struct));
#if !defined(NHR_OS_WINDOWS)
signal(SIGPIPE, nhr_request_handle_sigpipe);
#endif
r->socket = NHR_INVALID_SOCKET;
r->command = NHR_COMMAND_NONE;
r->work_mutex = n... | pushq %rbx
movl $0xa8, %edi
callq 0x47dd
movq %rax, %rbx
leaq -0x25(%rip), %rsi # 0x34ac
pushq $0xd
popq %rdi
callq 0x31a0
orl $-0x1, 0x4(%rbx)
andl $0x0, 0x30(%rbx)
callq 0x3b4c
movq %rax, 0x78(%rbx)
callq 0x3b4c
movq %rax, 0x80(%rbx)
movq $0x1e, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
| /OlehKulykov[P]libnhr/src/nhr_request_public.c |
nhr_request_set_url | void nhr_request_set_url(nhr_request request,
const char * scheme,
const char * host,
const char * path,
const unsigned short port) {
if (request) {
nhr_string_delete(request->scheme);
request->scheme = nhr_string_copy(scheme);
nhr_string_delete(request->host);
request->host = nh... | testq %rdi, %rdi
je 0x356c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x39ae
movq %r13, %rdi
callq 0x3924
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rdi
callq 0x39ae
movq %r12, %rdi
callq 0x3924
movq %rax,... | /OlehKulykov[P]libnhr/src/nhr_request_public.c |
nhr_request_send | nhr_bool nhr_request_send(nhr_request request) {
if (!request) {
return nhr_false;
}
if (!request->scheme || !request->host || !request->path || !request->method || !request->on_recvd_response || !request->on_error) {
request->error_code = nhr_error_code_missed_parameter;
return nhr_false;
}
request->error... | testq %rdi, %rdi
je 0x35b4
cmpq $0x0, 0x8(%rdi)
je 0x35ad
cmpq $0x0, 0x10(%rdi)
je 0x35ad
cmpq $0x0, 0x18(%rdi)
je 0x35ad
cmpl $0x0, 0x20(%rdi)
je 0x35ad
cmpq $0x0, 0x68(%rdi)
je 0x35ad
cmpq $0x0, 0x70(%rdi)
je 0x35ad
andl $0x0, 0x48(%rdi)
jmp 0x4cd5
movl $0x1, 0x48(%rdi)
xorl %eax, %eax
retq
| /OlehKulykov[P]libnhr/src/nhr_request_public.c |
nhr_request_add_header_field | void nhr_request_add_header_field(nhr_request request, const char * name, const char * value) {
size_t name_len = 0, value_len = 0;
_nhr_map_node * last = NULL;
if (!request) {
return;
}
name_len = name ? strlen(name) : 0;
value_len = value ? strlen(value) : 0;
if (name_len == 0 || value_len == 0) {
return;... | testq %rdi, %rdi
je 0x36a6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
je 0x35fa
movq %r15, %rdi
callq 0x30b0
movq %rax, %r12
jmp 0x35fd
xorl %r12d, %r12d
testq %r14, %r14
je 0x3698
movq %r14, %rdi
callq 0x30b0
movq %rax, ... | /OlehKulykov[P]libnhr/src/nhr_request_public.c |
nhr_request_add_parameter | void nhr_request_add_parameter(nhr_request request, const char * name, const char * value) {
size_t name_len = 0, value_len = 0;
_nhr_map_node * last = NULL;
if (!request) {
return;
}
name_len = name ? strlen(name) : 0;
value_len = value ? strlen(value) : 0;
if (name_len == 0 || value_len == 0) {
return;
}... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3741
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x36d4
movq %r14, %rdi
callq 0x30b0
movq %rax, %r12
jmp 0x36d7
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x3741
movq %rbx, %rdi
callq 0x30b0
movq %rax, %r13
testq %r12, %r12
... | /OlehKulykov[P]libnhr/src/nhr_request_public.c |
nhr_request_cancel | void nhr_request_cancel(nhr_request request) {
if (request) {
if (request->work_thread) {
nhr_request_set_command(request, NHR_COMMAND_END);
return; // automaticaly deleted before exit work thread function.
}
nhr_request_close(request);
nhr_request_delete(request);
}
} | pushq %rbx
testq %rdi, %rdi
je 0x3911
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x3913
movq %rbx, %rdi
movl $0x270f, %esi # imm = 0x270F
popq %rbx
jmp 0x494a
popq %rbx
retq
movq %rbx, %rdi
callq 0x48dd
movq %rbx, %rdi
popq %rbx
jmp 0x4e01
| /OlehKulykov[P]libnhr/src/nhr_request_public.c |
nhr_thread_create | nhr_thread nhr_thread_create(nhr_thread_funct thread_function, void * user_object) {
nhr_thread t = NULL;
int res = -1;
#if !defined(NHR_OS_WINDOWS)
pthread_attr_t attr;
#endif
if (!thread_function) {
return NULL;
}
nhr_threads_joiner_create_ifneed();
t = (nhr_thread)nhr_malloc_zero(sizeof(struct nhr_thread_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0x3a74
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x582b(%rip) # 0x9218
jne 0x3a0e
pushq $0x10
popq %rdi
callq 0x47dd
movq %rax, 0x581a(%rip) # 0x9218
callq 0x3b4c
movq 0x580e(%rip), %rcx # 0x9218
movq %rax, 0x8(%rcx)
pushq ... | /OlehKulykov[P]libnhr/src/nhr_thread.c |
nhr_thread_func_priv | static void * nhr_thread_func_priv(void * some_pointer) {
#endif
nhr_thread t = (nhr_thread)some_pointer;
t->thread_function(t->user_object);
nhr_threads_joiner_add(t);
#if defined(NHR_OS_WINDOWS)
return 0;
#else
return NULL;
#endif
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq *(%rbx)
movq 0x5754(%rip), %rax # 0x9218
movq 0x8(%rax), %rdi
callq 0x3bd1
movq 0x5744(%rip), %rax # 0x9218
movq (%rax), %r14
andq $0x0, 0x8(%rsp)
testq %r14, %r14
je 0x3b0c
andq $0x0, (%rax)
movq 0x10(%r14), %rdi
lea... | /OlehKulykov[P]libnhr/src/nhr_thread.c |
nhr_mutex_create_recursive | nhr_mutex nhr_mutex_create_recursive(void) {
#if defined(NHR_OS_WINDOWS)
CRITICAL_SECTION * mutex = (CRITICAL_SECTION *)nhr_malloc_zero(sizeof(CRITICAL_SECTION));
InitializeCriticalSection((LPCRITICAL_SECTION)mutex);
return mutex;
#else
pthread_mutex_t * mutex = (pthread_mutex_t *)nhr_malloc_zero(sizeof(pthread_mut... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x28
popq %rdi
callq 0x47dd
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x32b0
testl %eax, %eax
jne 0x3bb2
leaq 0xc(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x3100
testl %eax, %eax
jne 0x3ba8
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32e0
movl %ea... | /OlehKulykov[P]libnhr/src/nhr_thread.c |
nhr_mutex_lock | void nhr_mutex_lock(nhr_mutex mutex) {
if (mutex) {
#if defined(NHR_OS_WINDOWS)
EnterCriticalSection((LPCRITICAL_SECTION)mutex);
#else
pthread_mutex_lock((pthread_mutex_t *)mutex);
#endif
}
} | testq %rdi, %rdi
jne 0x3310
retq
| /OlehKulykov[P]libnhr/src/nhr_thread.c |
nhr_mutex_unlock | void nhr_mutex_unlock(nhr_mutex mutex) {
if (mutex) {
#if defined(NHR_OS_WINDOWS)
LeaveCriticalSection((LPCRITICAL_SECTION)mutex);
#else
pthread_mutex_unlock((pthread_mutex_t *)mutex);
#endif
}
} | testq %rdi, %rdi
jne 0x3200
retq
| /OlehKulykov[P]libnhr/src/nhr_thread.c |
nhr_mutex_delete | void nhr_mutex_delete(nhr_mutex mutex) {
if (mutex) {
#if defined(NHR_OS_WINDOWS)
DeleteCriticalSection((LPCRITICAL_SECTION)mutex);
#else
pthread_mutex_destroy((pthread_mutex_t *)mutex);
#endif
nhr_free(mutex);
}
} | testq %rdi, %rdi
je 0x3bfc
pushq %rbx
movq %rdi, %rbx
callq 0x30f0
movq %rbx, %rdi
popq %rbx
jmp 0x47fb
retq
nopl (%rax)
| /OlehKulykov[P]libnhr/src/nhr_thread.c |
nhr_request_create_url_encoded_parameters_POST | char * nhr_request_create_url_encoded_parameters_POST(nhr_request r, size_t * parameters_len) {
size_t params_len = 0;
char content_length[24];
#if defined(NHR_GZIP)
size_t zgip_parameters_size = 0;
void * zgip_parameters = NULL;
#endif
char * params = r->parameters ? nhr_request_url_encoded_pa... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
andq $0x0, (%rsp)
andq $0x0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x3c88
movq %rsp, %rsi
callq 0x425e
testq %rax, %rax
je 0x3c88
movq %rax, %r15
movb 0x90(%r14), %al
testb %al, %al
jne 0x3c4a
cmpb $0x0, 0x91(%r14... | /OlehKulykov[P]libnhr/src/nhr_request_method_post.c |
nhr_request_generate_new_boundary | void nhr_request_generate_new_boundary(nhr_request r) {
static const char charset[62] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
char boundary[NHR_POST_BOUNDARY_LEN];
size_t i;
srand((unsigned)time(NULL));
for (i = 0; i < NHR_POST_BOUNDARY_LEN; i++) {
boundary[i] = c... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x31d0
movl %eax, %edi
callq 0x3160
pushq $0x3e
popq %rbp
leaq 0x26d0(%rip), %r15 # 0x63f0
cmpq $0xc, %r14
je 0x3d3f
callq 0x3320
cltd
idivl %ebp
movslq %edx, %rax
movb (%rax,%r15), %al
movb %al, 0x... | /OlehKulykov[P]libnhr/src/nhr_request_method_post.c |
nhr_request_create_header_POST | char * nhr_request_create_header_POST(nhr_request r, size_t * header_size) {
size_t buff_size = 0, writed = 0, headers_len = 0, parameters_len = 0;
char * buff = NULL, *headers = NULL;
void * parameters = NULL;
buff_size = strlen(r->path);
buff_size += strlen(r->host);
#if defined(NHR_NO_P... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rbp
andq $0x0, 0x20(%rsp)
andq $0x0, (%rsp)
movq 0x18(%rdi), %rdi
callq 0x30b0
movq %rax, %r13
movq 0x10(%rbp), %rdi
callq 0x30b0
movq %rax, %rbx
cmpb $0x0, 0xa0(%rbp)
je 0x3ff6
movq %rsp, %rsi
movq %rbp... | /OlehKulykov[P]libnhr/src/nhr_request_method_post.c |
nhr_request_map_strings_length | size_t nhr_request_map_strings_length(_nhr_map_node * map, const size_t iteration_increment) {
size_t len = 0;
_nhr_map_node *cur = map;
while (cur) {
len += strlen(cur->key) + strlen(cur->value.string) + iteration_increment;
cur = cur->next;
}
return len;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
testq %r15, %r15
je 0x419d
movq (%r15), %rdi
callq 0x30b0
movq %rax, %r12
movq 0x10(%r15), %rdi
callq 0x30b0
addq %rbx, %r14
addq %r12, %r14
addq %rax, %r14
movq 0x8(%r15), %r15
jmp 0x4175
movq %r14, %rax
addq $0x8,... | /OlehKulykov[P]libnhr/src/nhr_request_method_common.c |
nhr_request_http_headers | char * nhr_request_http_headers(_nhr_map_node * map, size_t * length) {
const size_t buff_size = nhr_request_map_strings_length(map, 4); // "\r\n" + ": "
size_t writed = 0;
_nhr_map_node * cur = map;
char * buff = NULL;
if (buff_size == 0) {
return NULL;
}
buff = (char *)nhr_malloc(buff_size); // null termina... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x4
popq %rsi
callq 0x4164
testq %rax, %rax
je 0x422c
movq %rax, %r12
movq %rbx, (%rsp)
movq %rax, %rdi
callq 0x47ac
movq %rax, %r15
leaq 0x224d(%rip), %rbp # 0x6430
leaq 0x2244(%rip), %rbx # 0x... | /OlehKulykov[P]libnhr/src/nhr_request_method_common.c |
nhr_request_url_encoded_parameters | char * nhr_request_url_encoded_parameters(_nhr_map_node * map, size_t * length) {
size_t buff_size = nhr_request_map_strings_length(map, 2); // `&` + `=`
size_t writed = 0;
_nhr_map_node * cur = map;
char * buff = NULL;
if (buff_size == 0) {
return NULL;
}
buff = (char *)nhr_malloc(buff_size); // null termina... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x2
popq %rsi
callq 0x4164
testq %rax, %rax
je 0x42cc
movq %rax, %rdi
callq 0x47ac
movq %rax, %r15
leaq 0x225e(%rip), %r13 # 0x64ec
leaq 0x2256(%rip), %rbp # 0x64eb
xorl %r12d, %r12d
leaq (%r15,... | /OlehKulykov[P]libnhr/src/nhr_request_method_common.c |
nhr_gz_decompress | void * nhr_gz_decompress(const void * buff,
const size_t buff_size,
size_t * decompressed_size,
const unsigned char method) {
z_stream zip;
Bytef * out_buff = NULL;
size_t writed = 0, out_size = NHR_GZ_CHUNK_SIZE;
int available_size = 0, result = Z_ERRNO;
if (!buff || buff_size == 0) {
retu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %dl
orb %al, %dl
jne 0x46df
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
m... | /OlehKulykov[P]libnhr/src/nhr_gz.c |
nhr_map_delete | void nhr_map_delete(_nhr_map_node * map) {
_nhr_map_node *cur = map, *last;
while (cur) {
last = cur;
cur = cur->next;
nhr_string_delete(last->key);
if (last->value_type <= NHR_MAP_VALUE_STRING) {
nhr_free(last->value.data);
}
if (last->reserved_type <= NHR_MAP_VALUE_STRING) {
nhr_fre... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x478b
movq (%rbx), %rdi
movq 0x8(%rbx), %r14
callq 0x39ae
cmpb $0x2, 0x31(%rbx)
ja 0x476f
movq 0x10(%rbx), %rdi
callq 0x47fb
cmpb $0x2, 0x30(%rbx)
ja 0x477e
movq 0x18(%rbx), %rdi
callq 0x47fb
movq %rbx, %rdi
callq 0x47fb
movq %r14, %rbx
jmp 0x474f
ad... | /OlehKulykov[P]libnhr/src/nhr_map.c |
nhr_request_recv | nhr_bool nhr_request_recv(nhr_request r) {
int error_number = -1, len = -1;
char buff[NHR_RECV_BUFF_SIZE];
do {
len = (int)recv(r->socket, buff, NHR_RECV_BUFF_SIZE, 0);
#if defined(NHR_OS_WINDOWS)
error_number = WSAGetLastError();
#else
error_number = errno;
#endif
if (len > 0) {
r->last_time = time(NULL... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10000, %rsp # imm = 0x10000
movq %rdi, %rbx
movq %rsp, %r14
movl 0x4(%rbx), %edi
movl $0x10000, %edx # imm = 0x10000
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3040
movq %rax, %r15
testl %r15d, %r15d
jle 0x48b3
xorl %edi, %edi
callq 0x31d0
movq %rax, 0x40(%rbx)
mo... | /OlehKulykov[P]libnhr/src/nhr_request_private.c |
nhr_request_close | void nhr_request_close(nhr_request r) {
if (r->socket != NHR_INVALID_SOCKET) {
NHR_SOCK_CLOSE(r->socket);
r->socket = NHR_INVALID_SOCKET;
#if defined(NHR_OS_WINDOWS)
WSACleanup();
#endif
}
} | pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %edi
cmpl $-0x1, %edi
je 0x48f2
callq 0x3140
orl $-0x1, 0x4(%rbx)
popq %rbx
retq
| /OlehKulykov[P]libnhr/src/nhr_request_private.c |
nhr_request_wait_raw_response | void nhr_request_wait_raw_response(nhr_request r) {
nhr_bool is_finished = nhr_false;
if (nhr_request_recv(r)) {
is_finished = r->response ? r->response->is_finished : nhr_false;
if (is_finished) {
nhr_request_set_command(r, NHR_COMMAND_INFORM_RESPONSE);
}
if (!nhr_request_check_timeout(r)) {
return; //... | pushq %rbx
movq %rdi, %rbx
callq 0x4848
testb %al, %al
je 0x4927
movq 0x88(%rbx), %rax
testq %rax, %rax
je 0x491e
cmpb $0x0, 0x25(%rax)
je 0x491e
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x494a
movq %rbx, %rdi
popq %rbx
jmp 0x4976
testq %rbx, %rbx
je 0x4934
pushq $0x5
popq %rsi
movq %rbx, %rdi
jmp 0x4944
movl $0x2, 0... | /OlehKulykov[P]libnhr/src/nhr_request_private.c |
nhr_request_send_raw_request | void nhr_request_send_raw_request(nhr_request r) {
char * header = NULL;
size_t header_size = 0;
switch (r->method) {
#if !defined(NHR_NO_GET)
case nhr_method_GET: header = nhr_request_create_header_GET(r, &header_size); break;
#endif
#if !defined(NHR_NO_POST)
case nhr_method_POST: header = nhr_request_create_h... | pushq %r14
pushq %rbx
pushq %rax
andq $0x0, (%rsp)
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl $0x2, %eax
je 0x49e7
cmpl $0x1, %eax
jne 0x4a42
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x539c
jmp 0x49f2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3fa7
movq %rax, %r14
movq (%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4a6... | /OlehKulykov[P]libnhr/src/nhr_request_private.c |
nhr_request_send_buffer | nhr_bool nhr_request_send_buffer(nhr_request r, const void * data, const size_t data_size) {
int send_result = -1, error_number = -1;
r->error_code = nhr_error_code_none;
#if defined(NHR_OS_WINDOWS)
send_result = send(r->socket, (const char *)data, data_size, 0);
error_number = WSAGetLastError();
#else
send_resul... | pushq %rax
andl $0x0, 0x48(%rdi)
movl 0x4(%rdi), %edi
movslq %edx, %rdx
xorl %ecx, %ecx
callq 0x30c0
movq %rax, %rcx
movb $0x1, %al
testl %ecx, %ecx
jg 0x4a87
callq 0x3050
cmpl $0x0, (%rax)
setle %al
popq %rcx
retq
| /OlehKulykov[P]libnhr/src/nhr_request_private.c |
nhr_request_connect_getaddr_info | struct addrinfo * nhr_request_connect_getaddr_info(nhr_request r) {
struct addrinfo hints;
char portstr[12];
struct addrinfo * result = NULL;
int ret = 0, retry_number = 0, last_ret = 0;
#if defined(NHR_OS_WINDOWS)
WSADATA wsa;
memset(&wsa, 0, sizeof(WSADATA));
if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) {
r->e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movzwl (%rdi), %edx
leaq 0x15f3(%rip), %rsi # 0x609e
leaq 0x44(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x3290
pushq $0x4
popq %rbp
leaq 0x10(%rsp), %r12
subl $0x1, %ebp
jb 0x4b23... | /OlehKulykov[P]libnhr/src/nhr_request_private.c |
nhr_request_connect_to_host | void nhr_request_connect_to_host(nhr_request r) {
struct addrinfo * result = NULL;
struct addrinfo * p = NULL;
nhr_socket_t sock = NHR_INVALID_SOCKET;
int retry_number = 0;
#if defined(NHR_OS_WINDOWS)
unsigned long iMode = 0;
#endif
r->last_time = time(NULL);
result = nhr_request_connect_getaddr_info(r);
if (!... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x31d0
movq %rax, 0x40(%rbx)
movq %rbx, %rdi
callq 0x4a89
movq %rax, %r14
movq %rbx, %rdi
callq 0x4976
testb %al, %al
sete %al
movq %r14, 0x10(%rsp)
testq %r14, %r14
sete %cl
orb %al, %cl
je 0x4b99
a... | /OlehKulykov[P]libnhr/src/nhr_request_private.c |
nhr_request_work_th_func | static void nhr_request_work_th_func(void * user_object) {
nhr_request r = (nhr_request)user_object;
while (nhr_request_get_command(r) < NHR_COMMAND_END) {
nhr_mutex_lock(r->work_mutex);
switch (nhr_request_get_command(r)) {
case NHR_COMMAND_CONNECT_TO_HOST: nhr_request_connect_to_host(r); break;
case NHR_... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x5
popq %rbp
leaq 0x18d7(%rip), %r14 # 0x65fc
movq %rbx, %rdi
callq 0x4e6d
cmpl $0x270e, %eax # imm = 0x270E
jg 0x4de8
movq 0x78(%rbx), %rdi
callq 0x3bd1
movq %rbx, %rdi
callq 0x4e6d
decl %eax
cmpl $0x3, %eax
ja 0x4d7f
movslq (%r14,%rax,4), %rax
ad... | /OlehKulykov[P]libnhr/src/nhr_request_private.c |
nhr_request_delete | void nhr_request_delete(nhr_request r) {
nhr_request_close(r);
nhr_string_delete_clean(&r->scheme);
nhr_string_delete_clean(&r->host);
nhr_string_delete_clean(&r->path);
nhr_map_delete_clean(&r->http_headers);
nhr_map_delete_clean(&r->parameters);
nhr_mutex_delete(r->work_mutex);
nhr_mutex_delete(r->command_... | pushq %rbx
movq %rdi, %rbx
callq 0x48dd
leaq 0x8(%rbx), %rdi
callq 0x39b3
leaq 0x10(%rbx), %rdi
callq 0x39b3
leaq 0x18(%rbx), %rdi
callq 0x39b3
leaq 0x58(%rbx), %rdi
callq 0x4793
leaq 0x60(%rbx), %rdi
callq 0x4793
movq 0x78(%rbx), %rdi
callq 0x3be5
movq 0x80(%rbx), %rdi
callq 0x3be5
movq 0x88(%rbx), %rdi
callq 0x535c
l... | /OlehKulykov[P]libnhr/src/nhr_request_private.c |
nhr_response_ungzip | void nhr_response_ungzip(nhr_response r) {
void * decompressed = NULL;
size_t decompressed_size = 0;
if (!r->body || r->body_len <= 0) {
return;
}
if (r->content_encoding & NHR_CONTENT_ENCODING_GZIP) {
decompressed = nhr_gz_decompress(r->body, r->body_len, &decompressed_size, NHR_GZ_METHOD_GZIP);
} else if... | pushq %r14
pushq %rbx
pushq %rax
andq $0x0, (%rsp)
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4eff
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x4eff
movzbl 0x23(%rbx), %eax
movb $0x1, %r14b
testb $0x1, %al
jne 0x4ec7
xorl %r14d, %r14d
testb $0x2, %al
je 0x4ed6
movzbl %r14b, %ecx
movq %rsp, %rdx
callq 0x4586
... | /OlehKulykov[P]libnhr/src/nhr_response.c |
nhr_response_find_http_field_value | char * nhr_response_find_http_field_value(char * received, const char * field) {
char * sub = strstr(received, field);
if (!sub) {
return NULL;
}
sub += strlen(field);
while (!isalnum(*sub)) {
sub++;
}
return sub;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x3300
testq %rax, %rax
je 0x4f59
movq %rax, %rbx
movq %r14, %rdi
callq 0x30b0
movq %rax, %r14
callq 0x3330
movq (%rax), %rcx
leaq (%r14,%rbx), %rax
decq %rax
movsbq 0x1(%rax), %rdx
incq %rax
testb $0x8, (%rcx,%rdx,2)
je 0x4f49
jmp 0x4f5b
xorl %eax, %eax
addq $0x8,... | /OlehKulykov[P]libnhr/src/nhr_response.c |
nhr_response_parse_body | void nhr_response_parse_body(nhr_response r, char * received, const size_t received_len) {
#if defined(NHR_DEBUG_LOG)
size_t log_index = 0;
printf("\n----[ RESPONSE HEADER ]----\n");
for (log_index = 0; log_index < received_len; log_index++) {
printf("%c", received[log_index]);
}
printf("\n----------------------... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x4147(%rip), %rax # 0x91f0
movq (%rax), %rsi
movq %r12, %rdi
callq 0x3300
testq %rax, %rax
je 0x5124
movq %rax, %r14
subq %r12, %rax
cmpq $0x5, %rax
jb 0x5124
addq $0x4, %r14
testb $0x1, 0x22(%rbx)
jne 0x51... | /OlehKulykov[P]libnhr/src/nhr_response.c |
nhr_response_parse_status_code | void nhr_response_parse_status_code(nhr_response r, char * received) {
int code = 0;
char * value = strstr(received, " ");
if (!value) {
return;
}
if (nhr_sscanf(value, " %i", &code) == 1 && code > 0) {
r->status_code = code;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
andl $0x0, 0x4(%rsp)
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x30d0
testq %rax, %rax
je 0x5181
leaq 0xf47(%rip), %rsi # 0x609d
leaq 0x4(%rsp), %r14
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3220
cmpl $0x1, %eax
sete %cl
movl (%r14)... | /OlehKulykov[P]libnhr/src/nhr_response.c |
nhr_response_parse_content_length | void nhr_response_parse_content_length(nhr_response r, char * received) {
unsigned long length = 0;
char * value = nhr_response_find_http_field_value(received, k_nhr_content_length);
if (!value) {
return;
}
if (nhr_sscanf(value, "%lu", &length) == 1 && length > 0) {
r->content_length = (size_t)length;
}
} | pushq %r14
pushq %rbx
pushq %rax
andq $0x0, (%rsp)
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x4059(%rip), %rcx # 0x91f8
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x4f1b
testq %rax, %rax
je 0x51e0
leaq 0x110a(%rip), %rsi # 0x62c0
movq %rsp, %r14
movq %rax, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3220
cmpl $0x1,... | /OlehKulykov[P]libnhr/src/nhr_response.c |
nhr_response_parse_transfer_encoding | void nhr_response_parse_transfer_encoding(nhr_response r, char * received) {
char * encoding = nhr_response_find_http_field_value(received, k_nhr_transfer_encoding);
if (!encoding) {
return;
}
if (strstr(encoding, k_nhr_chunked)) {
#if defined(NHR_NO_RECV_CHUNKS)
nhr_response_log_unprocessed(k_nhr_transfer_enc... | pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x3fd6(%rip), %rcx # 0x91e0
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x4f1b
testq %rax, %rax
je 0x5235
leaq 0x3fdf(%rip), %rcx # 0x9200
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x3300
testq %rax, %rax
je 0x5235
orb $0x1, 0x22(%rbx)
popq %rbx
retq
| /OlehKulykov[P]libnhr/src/nhr_response.c |
nhr_response_parse_content_encoding | void nhr_response_parse_content_encoding(nhr_response r, char * received) {
char * encoding = nhr_response_find_http_field_value(received, k_nhr_content_encoding);
if (!encoding) {
return;
}
if (strstr(encoding, k_nhr_gzip)) {
#if defined(NHR_GZIP)
r->content_encoding |= NHR_CONTENT_ENCODING_GZIP;
#else
nhr_... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x1484(%rip), %rsi # 0x66cc
movq %rax, %rdi
callq 0x4f1b
testq %rax, %rax
je 0x5288
movq %rax, %r14
leaq 0xe42(%rip), %rsi # 0x60a1
movq %rax, %rdi
callq 0x3300
testq %rax, %rax
je 0x5270
orb $0x1, 0x23(%rbx)
leaq 0xe2f(%rip), %rsi #... | /OlehKulykov[P]libnhr/src/nhr_response.c |
nhr_response_check_is_finished | void nhr_response_check_is_finished(nhr_response r) {
if (!nhr_response_is_finished_receiving(r)) {
return;
}
if (r->content_encoding & NHR_CONTENT_ENCODING_GZIP ||
r->content_encoding & NHR_CONTENT_ENCODING_DEFLATE) {
#if defined(NHR_GZIP)
nhr_response_ungzip(r);
#endif
}
r->is_finished = nhr_true;
} | pushq %rbx
movq %rdi, %rbx
callq 0x5290
testb %al, %al
je 0x52cd
testb $0x3, 0x23(%rbx)
je 0x52c9
movq %rbx, %rdi
callq 0x4e98
movb $0x1, 0x25(%rbx)
popq %rbx
retq
| /OlehKulykov[P]libnhr/src/nhr_response.c |
nhr_response_create | nhr_response nhr_response_create(void * received, const size_t received_len) {
struct nhr_response_struct * r = (struct nhr_response_struct *)nhr_malloc_zero(sizeof(struct nhr_response_struct));
nhr_response_parse_status_code(r, received);
if (r->status_code != 0) {
nhr_response_parse_content_length(r, received)... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x28
popq %rdi
callq 0x47dd
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x5130
cmpw $0x0, 0x20(%rbx)
je 0x5326
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5189
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51fc
movq %rbx, %rdi
movq %r15, %rsi
callq... | /OlehKulykov[P]libnhr/src/nhr_response.c |
nhr_response_append | void nhr_response_append(nhr_response r, void * received, const size_t received_len) {
if (r->transfer_encoding & NHR_TRANSFER_ENCODING_CHUNKED) {
#if !defined(NHR_NO_RECV_CHUNKS)
nhr_response_read_chunks(r, (char *)received);
#endif
} else {
nhr_response_add_body_data(r, received, received_len);
}
nhr_response... | pushq %rbx
movq %rdi, %rbx
testb $0x1, 0x22(%rdi)
jne 0x534b
movq %rbx, %rdi
callq 0x5022
jmp 0x5353
movq %rbx, %rdi
callq 0x4f63
movq %rbx, %rdi
popq %rbx
jmp 0x52ae
| /OlehKulykov[P]libnhr/src/nhr_response.c |
nhr_request_create_header_GET | char * nhr_request_create_header_GET(nhr_request r, size_t * header_size) {
size_t buff_size = 0, writed = 0, headers_len = 0, parameters_len = 0;
char * buff = NULL, *headers = NULL, *parameters = NULL;
buff_size = strlen(r->path);
buff_size += strlen(r->host);
headers = r->http_headers ?... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
andq $0x0, 0x20(%rsp)
andq $0x0, 0x18(%rsp)
movq 0x18(%rdi), %rdi
callq 0x30b0
movq %rax, %r13
movq 0x10(%r12), %rdi
callq 0x30b0
movq %rax, %rbx
movq 0x58(%r12), %rdi
testq %rdi, %rdi
je 0x53f3
leaq... | /OlehKulykov[P]libnhr/src/nhr_request_method_get.c |
test::fileno(_IO_FILE*) | int (test::fileno)(FILE *stream) {
EMULATE_EINTR(fileno, -1);
#ifdef fileno
return FMT_POSIX(fileno(stream));
#else
return ::FMT_POSIX(fileno(stream));
#endif
} | movl 0x7a9f6(%rip), %eax # 0x8764c
testl %eax, %eax
je 0xb590
leal 0x1(%rax), %ecx
movl %ecx, 0x7a9e5(%rip) # 0x8764c
cmpl $0x3, %eax
je 0xb590
pushq %rax
callq 0xb070
movl $0x4, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rcx
retq
nop
| /scientific-systems[P]fmt/test/posix-mock-test.cc |
fmt::v5::file::file(fmt::v5::basic_cstring_view<char>, int) | file::file(cstring_view path, int oflag) {
int mode = S_IRUSR | S_IWUSR;
#if defined(_WIN32) && !defined(__MINGW32__)
fd_ = -1;
FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode));
#else
FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode)));
#endif
if (fd_ == -1)
FMT_THROW(syste... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rbx, %rdi
movl %ebp, %esi
movl $0x180, %edx # imm = 0x180
callq 0xcd15
movl %eax, (%r14)
cmpl $-0x1, %eax
jne 0xccf7
callq 0xb070
cmpl $0x4, (%rax)
je 0xcc93
movq %rax, %r15
movl $0x18, %edi
callq 0xb... | /scientific-systems[P]fmt/test/../src/posix.cc |
fmt::v5::file::close() | void file::close() {
if (fd_ == -1)
return;
// Don't retry close in case of EINTR!
// See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
int result = FMT_POSIX_CALL(close(fd_));
fd_ = -1;
if (result != 0)
FMT_THROW(system_error(errno, "cannot close file"));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
cmpl $-0x1, %edi
je 0xcdc9
callq 0xcd7c
movl $0xffffffff, (%rbx) # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xcdd1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x18, %edi
callq 0xb250
movq %rax, %rbx
callq 0xb070
movl (%rax), %esi
leaq 0x54318(%rip),... | /scientific-systems[P]fmt/test/../src/posix.cc |
testing::internal::TypedExpectation<double (char const*, char**, __locale_struct*)>::WillOnce(testing::Action<double (char const*, char**, __locale_struct*)> const&) | TypedExpectation& WillOnce(const Action<F>& action) {
ExpectSpecProperty(last_clause_ <= kWillOnce,
".WillOnce() cannot appear after "
".WillRepeatedly() or .RetiresOnSaturation().");
last_clause_ = kWillOnce;
untyped_actions_.push_back(new Action<F>(action));
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0xa4(%rdi), %ebp
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4f1ab(%rip), %rsi # 0x62a9e
leaq 0x4f1f0(%rip), %rdx # 0x62aea
movq %rsp, %rdi
callq 0x14d2c
cmpl $0x6, %ebp
jl 0x13927
movl 0x10(%rbx... | /scientific-systems[P]fmt/test/gmock/gmock.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int... | void write_padded(const align_spec &spec, F &&f) {
unsigned width = spec.width(); // User-perceived width (in code points).
size_t size = f.size(); // The number of code units.
size_t num_code_points = width != 0 ? f.width() : size;
if (width <= num_code_points)
return f(reserve(size));
auto &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rsi), %r13d
movq (%rdx), %r15
movq %r13, %r14
subq %r15, %r14
jbe 0x170ab
movq %rsi, %r12
movq (%rdi), %rbp
movq 0x10(%rbp), %r15
addq %r15, %r13
cmpq %r13, 0x18(%rbp)
jae 0x17061
movq (%rbp), %rax
movq %rbp, %rdi
movq %... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>::num_writer>::operator()<char*>(char*&&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x1749b
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xb9c0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x174b7
leaq (%r15,%rdx... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>::num_writer::operator()<char*&>(char*&) const | void operator()(It &&it) const {
basic_string_view<char_type> s(&sep, SEP_SIZE);
it = internal::format_decimal<char_type>(
it, abs_value, size, internal::add_thousands_sep<char_type>(s));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq (%rsi), %r14
movl (%rdi), %eax
movslq 0x4(%rdi), %r15
leaq (%rsp,%r15), %rcx
addq $0x3, %rcx
cmpq $0x64, %rax
jb 0x1764f
xorl %esi, %esi
leaq 0x4d1e4(%rip), %rdx # 0x64750
movl $0xaaaaaaab, %r8d # imm = 0xAAAAAAAB
movl %eax, %r9d
movl %eax... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_decimal<int>(int) | void write_decimal(Int value) {
typedef typename internal::int_traits<Int>::main_type main_type;
main_type abs_value = static_cast<main_type>(value);
bool is_negative = internal::is_negative(value);
if (is_negative)
abs_value = 0 - abs_value;
int num_digits = internal::count_digits(abs_value);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movl %esi, %r13d
negl %r13d
cmovsl %esi, %r13d
movl %r13d, %eax
orl $0x1, %eax
bsrl %eax, %eax
xorl $-0x20, %eax
imull $0x4d1, %eax, %ebx # imm = 0x4D1
addl $0x9ef1, %ebx # imm = 0x9EF1
shrl $0xc, %ebx
leaq... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_int<unsigned int, fmt::v5::basic_format_specs<char>>(unsigned int, fmt::v5::basic_format_specs<char> const&) | void write_int(T value, const Spec &spec) {
internal::handle_int_type_spec(spec.type,
int_writer<T, Spec>(*this, value, spec));
} | subq $0x28, %rsp
movzbl 0x11(%rdx), %eax
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movl %esi, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
movzbl 0x10(%rdx), %ecx
testb $0x1, %cl
je 0x1782d
testb $0x2, %cl
movl $0x20, %ecx
movl $0x2b, %edx
cmovel %ecx, %edx
movb %dl, 0x1c(%rsp)
movl $0x1, 0x20(%rsp)
cmpl $0x63, %eax
jg 0x17842
cm... | /scientific-systems[P]fmt/include/fmt/format.h |
fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::on_hex() | void on_hex() {
if (spec.has(HASH_FLAG)) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = static_cast<char>(spec.type);
}
int num_digits = count_digits<4>();
writer.write_int(num_digits, get_prefix(), spec,
hex_writer{*this, num_digits});
} | movq 0x8(%rdi), %r8
testb $0x8, 0x10(%r8)
je 0x17928
movl 0x18(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x18(%rdi)
movb $0x30, 0x14(%rdi,%rax)
movb 0x11(%r8), %al
movl 0x18(%rdi), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%rdi)
movb %al, 0x14(%rdi,%rcx)
movl 0x10(%rdi), %eax
xorl %esi, %esi
movl %eax, %ecx
incl %esi... | /scientific-systems[P]fmt/include/fmt/format.h |
fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::on_bin() | void on_bin() {
if (spec.has(HASH_FLAG)) {
prefix[prefix_size++] = '0';
prefix[prefix_size++] = static_cast<char>(spec.type);
}
int num_digits = count_digits<1>();
writer.write_int(num_digits, get_prefix(), spec,
bin_writer<1>{abs_value, num_digits});
} | movq %rdi, %rdx
movq 0x8(%rdi), %r8
testb $0x8, 0x10(%r8)
je 0x17995
movl 0x18(%rdx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x18(%rdx)
movb $0x30, 0x14(%rdx,%rax)
movb 0x11(%r8), %al
movl 0x18(%rdx), %ecx
leal 0x1(%rcx), %esi
movl %esi, 0x18(%rdx)
movb %al, 0x14(%rdx,%rcx)
movl 0x10(%rdx), %r9d
xorl %esi, %esi
movabsq $... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<uns... | void write_padded(const align_spec &spec, F &&f) {
unsigned width = spec.width(); // User-perceived width (in code points).
size_t size = f.size(); // The number of code units.
size_t num_code_points = width != 0 ? f.width() : size;
if (width <= num_code_points)
return f(reserve(size));
auto &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rsi), %r13d
movq (%rdx), %r15
movq %r13, %r14
subq %r15, %r14
jbe 0x17fa9
movq %rsi, %r12
movq (%rdi), %rbp
movq 0x10(%rbp), %r15
addq %r15, %r13
cmpq %r13, 0x18(%rbp)
jae 0x17f5f
movq (%rbp), %rax
movq %rbp, %rdi
movq %... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::hex_writer>::operator()<char*>(char*&&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %r15
movq (%rsi), %r14
movq %r14, %rdi
testq %r15, %r15
je 0x1807d
movq 0x8(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xb9c0
leaq (%r14,%r15), %rdi
movq %rdi, (%rbx)
movq 0x20(%r12), %r1... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::hex_writer>::operator()<char*&>(char*&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %r15
movq (%rsi), %r14
movq %r14, %rdi
testq %r15, %r15
je 0x1813b
movq 0x8(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xb9c0
leaq (%r14,%r15), %rdi
movq %rdi, (%rbx)
movq 0x20(%r12), %r1... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<1>>(int, fmt::v5::... | void write_int(int num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + internal::to_unsigned(num_digits);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %r11d
addq %rcx, %r11
movb 0x4(%r8), %r10b
movl 0x8(%r8), %eax
cmpl $0x4, %eax
jne 0x18207
movl (%r8), %eax
cmpq %rax, %r11
movq %rax, %rsi
cmovaq %r11, %rsi
xorl %ebx, %ebx
subq %r11, %rax
cmovaeq %rax, %rbx
movl 0x8(%r8), %eax
movl %eax, 0x8(%rsp)
movq (%r8... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<uns... | void write_padded(const align_spec &spec, F &&f) {
unsigned width = spec.width(); // User-perceived width (in code points).
size_t size = f.size(); // The number of code units.
size_t num_code_points = width != 0 ? f.width() : size;
if (width <= num_code_points)
return f(reserve(size));
auto &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rsi), %r13d
movq (%rdx), %r15
movq %r13, %r14
subq %r15, %r14
jbe 0x182fb
movq %rsi, %r12
movq (%rdi), %rbp
movq 0x10(%rbp), %r15
addq %r15, %r13
cmpq %r13, 0x18(%rbp)
jae 0x182b1
movq (%rbp), %rax
movq %rbp, %rdi
movq %... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<1>>::operator()<char*>(char*&&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %r15
movq (%rsi), %r14
movq %r14, %rdi
testq %r15, %r15
je 0x183cf
movq 0x8(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xb9c0
leaq (%r14,%r15), %rdi
movq %rdi, (%rbx)
movq 0x20(%r12), %r1... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<1>>::operator()<char*&>(char*&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %r15
movq (%rsi), %r14
movq %r14, %rdi
testq %r15, %r15
je 0x1846b
movq 0x8(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xb9c0
leaq (%r14,%r15), %rdi
movq %rdi, (%rbx)
movq 0x20(%r12), %r1... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<3>>(int, fmt::v5::... | void write_int(int num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + internal::to_unsigned(num_digits);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %r11d
addq %rcx, %r11
movb 0x4(%r8), %r10b
movl 0x8(%r8), %eax
cmpl $0x4, %eax
jne 0x18515
movl (%r8), %eax
cmpq %rax, %r11
movq %rax, %rsi
cmovaq %r11, %rsi
xorl %ebx, %ebx
subq %r11, %rax
cmovaeq %rax, %rbx
movl 0x8(%r8), %eax
movl %eax, 0x8(%rsp)
movq (%r8... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<uns... | void write_padded(const align_spec &spec, F &&f) {
unsigned width = spec.width(); // User-perceived width (in code points).
size_t size = f.size(); // The number of code units.
size_t num_code_points = width != 0 ? f.width() : size;
if (width <= num_code_points)
return f(reserve(size));
auto &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rsi), %r13d
movq (%rdx), %r15
movq %r13, %r14
subq %r15, %r14
jbe 0x18609
movq %rsi, %r12
movq (%rdi), %rbp
movq 0x10(%rbp), %r15
addq %r15, %r13
cmpq %r13, 0x18(%rbp)
jae 0x185bf
movq (%rbp), %rax
movq %rbp, %rdi
movq %... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<3>>::operator()<char*>(char*&&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %r15
movq (%rsi), %r14
movq %r14, %rdi
testq %r15, %r15
je 0x186dd
movq 0x8(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xb9c0
leaq (%r14,%r15), %rdi
movq %rdi, (%rbx)
movq 0x20(%r12), %r1... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::bin_writer<3>>::operator()<char*&>(char*&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %r15
movq (%rsi), %r14
movq %r14, %rdi
testq %r15, %r15
je 0x1877b
movq 0x8(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xb9c0
leaq (%r14,%r15), %rdi
movq %rdi, (%rbx)
movq 0x20(%r12), %r1... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer>(int, fmt::v5::bas... | void write_int(int num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + internal::to_unsigned(num_digits);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq 0x70(%rsp), %r9
movl %esi, %r11d
addq %rcx, %r11
movb 0x4(%r8), %r10b
movl 0x8(%r8), %eax
cmpl $0x4, %eax
jne 0x1882d
movl (%r8), %eax
cmpq %rax, %r11
movq %rax, %rsi
cmovaq %r11, %rsi
xorl %ebx, %ebx
subq %r11, %rax
cmovaeq %rax, %rbx
movl 0x8(%r8), %eax
movl %eax... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer>::operator()<char*&>(char*&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x18a61
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xb9c0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x18a7d
leaq (%r15,%rdx... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::num_writer::operator()<char*&>(char*&) const | void operator()(It &&it) const {
basic_string_view<char_type> s(&sep, SEP_SIZE);
it = internal::format_decimal<char_type>(
it, abs_value, size, internal::add_thousands_sep<char_type>(s));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq (%rsi), %r14
movl (%rdi), %eax
movslq 0x4(%rdi), %r15
leaq (%rsp,%r15), %rcx
addq $0x3, %rcx
cmpq $0x64, %rax
jb 0x18bad
xorl %esi, %esi
leaq 0x4bc86(%rip), %rdx # 0x64750
movl $0xaaaaaaab, %r8d # imm = 0xAAAAAAAB
movl %eax, %r9d
movl %eax... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_decimal<unsigned int>(unsigned int) | void write_decimal(Int value) {
typedef typename internal::int_traits<Int>::main_type main_type;
main_type abs_value = static_cast<main_type>(value);
bool is_negative = internal::is_negative(value);
if (is_negative)
abs_value = 0 - abs_value;
int num_digits = internal::count_digits(abs_value);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movl %esi, %eax
orl $0x1, %eax
bsrl %eax, %eax
xorl $-0x20, %eax
imull $0x4d1, %eax, %ebx # imm = 0x4D1
addl $0x9ef1, %ebx # imm = 0x9EF1
shrl $0xc, %ebx
leaq 0x4b6e3(%rip), %rax # 0x64310
cmpl (%rax,%rbx,4), %esi... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::dec_writer>::operator()<char*>(char*&&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x19279
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xb9c0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x19295
leaq (%r15,%rdx... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::dec_writer>::operator()<char*&>(char*&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
movq (%rsi), %r15
testq %r12, %r12
je 0x192e1
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xb9c0
addq %r12, %r15
movq %r15, (%rbx)
movq 0x20(%r14), %rdx
testq %rdx, %rdx
je 0x192fd
leaq (%r15,%rdx... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_int<unsigned long long, fmt::v5::basic_format_specs<char>>(unsigned long long, fmt::v5::basic_format_specs<char> const&) | void write_int(T value, const Spec &spec) {
internal::handle_int_type_spec(spec.type,
int_writer<T, Spec>(*this, value, spec));
} | subq $0x28, %rsp
movzbl 0x11(%rdx), %eax
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movzbl 0x10(%rdx), %ecx
testb $0x1, %cl
je 0x1a32a
testb $0x2, %cl
movl $0x20, %ecx
movl $0x2b, %edx
cmovel %ecx, %edx
movb %dl, 0x20(%rsp)
movl $0x1, 0x24(%rsp)
cmpl $0x63, %eax
jg 0x1a33f
cm... | /scientific-systems[P]fmt/include/fmt/format.h |
fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::on_dec() | void on_dec() {
int num_digits = internal::count_digits(abs_value);
writer.write_int(num_digits, get_prefix(), spec,
dec_writer{abs_value, num_digits});
} | subq $0x28, %rsp
movq 0x10(%rdi), %r9
movq %r9, %rax
orq $0x1, %rax
bsrq %rax, %rax
xorl $-0x40, %eax
imull $0x4d1, %eax, %esi # imm = 0x4D1
addl $0x13911, %esi # imm = 0x13911
shrl $0xc, %esi
leaq 0x49f66(%rip), %rax # 0x64340
cmpq (%rax,%rsi,8), %r9
sbbl $-0x1, %esi
leaq 0x18(%rdi), %rdx
movl 0x1c(%... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::hex_writer>::operator()<char*&>(char*&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %r15
movq (%rsi), %r14
movq %r14, %rdi
testq %r15, %r15
je 0x1ac9d
movq 0x8(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xb9c0
leaq (%r14,%r15), %rdi
movq %rdi, (%rbx)
movq 0x20(%r12), %r1... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned long long, fmt::v5::basic_format_specs<char>>::bin_writer<1>>(int, fmt... | void write_int(int num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + internal::to_unsigned(num_digits);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq 0x70(%rsp), %r9
movl %esi, %r11d
addq %rcx, %r11
movb 0x4(%r8), %r10b
movl 0x8(%r8), %eax
cmpl $0x4, %eax
jne 0x1ad75
movl (%r8), %eax
cmpq %rax, %r11
movq %rax, %rsi
cmovaq %r11, %rsi
xorl %ebx, %ebx
subq %r11, %rax
cmovaeq %rax, %rbx
movl 0x8(%r8), %eax
movl %eax... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<uns... | void write_padded(const align_spec &spec, F &&f) {
unsigned width = spec.width(); // User-perceived width (in code points).
size_t size = f.size(); // The number of code units.
size_t num_code_points = width != 0 ? f.width() : size;
if (width <= num_code_points)
return f(reserve(size));
auto &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rsi), %r13d
movq (%rdx), %r15
movq %r13, %r14
subq %r15, %r14
jbe 0x1ae6f
movq %rsi, %r12
movq (%rdi), %rbp
movq 0x10(%rbp), %r15
addq %r15, %r13
cmpq %r13, 0x18(%rbp)
jae 0x1ae25
movq (%rbp), %rax
movq %rbp, %rdi
movq %... | /scientific-systems[P]fmt/include/fmt/format.h |
fmt::v5::internal::arg_formatter_base<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write(bool) | void write(bool value) {
string_view sv(value ? "true" : "false");
specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
leaq 0x4691a(%rip), %rax # 0x621ce
leaq 0x46918(%rip), %rbx # 0x621d3
testl %esi, %esi
cmovneq %rax, %rbx
movl %esi, %r14d
xorq $0x5, %r14
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x1b903
movslq 0xc(%rsi), %rax
cmpq %r14, %rax
movq %r14, %... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::str_writer<char>>(fmt::v5::align_spec const&, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_bu... | void write_padded(const align_spec &spec, F &&f) {
unsigned width = spec.width(); // User-perceived width (in code points).
size_t size = f.size(); // The number of code units.
size_t num_code_points = width != 0 ? f.width() : size;
if (width <= num_code_points)
return f(reserve(size));
auto &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl (%rsi), %ebp
movq 0x8(%rdx), %rdx
movq %rbp, %r15
movq (%rdi), %r12
movq 0x10(%r12), %rbx
movq 0x18(%r12), %rax
subq %rdx, %r15
jbe 0x1b9bf
movq %rsi, %r13
addq %rbx, %rbp
cmpq %rbp, %rax
jae 0x1b982
movq (%r12), %rax
movq... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<char, fmt::v5::basic_format_specs<char>>::dec_writer>(int, fmt::v5::basic_strin... | void write_int(int num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + internal::to_unsigned(num_digits);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %r11d
addq %rcx, %r11
movb 0x4(%r8), %r10b
movl 0x8(%r8), %eax
cmpl $0x4, %eax
jne 0x1bfad
movl (%r8), %eax
cmpq %rax, %r11
movq %rax, %rsi
cmovaq %r11, %rsi
xorl %ebx, %ebx
subq %r11, %rax
cmovaeq %rax, %rbx
movl 0x8(%r8), %eax
movl %eax, 0x8(%rsp)
movq (%r8... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<cha... | void write_padded(const align_spec &spec, F &&f) {
unsigned width = spec.width(); // User-perceived width (in code points).
size_t size = f.size(); // The number of code units.
size_t num_code_points = width != 0 ? f.width() : size;
if (width <= num_code_points)
return f(reserve(size));
auto &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rsi), %r13d
movq (%rdx), %r15
movq %r13, %r14
subq %r15, %r14
jbe 0x1c40d
movq %rsi, %r12
movq (%rdi), %rbp
movq 0x10(%rbp), %r15
addq %r15, %r13
cmpq %r13, 0x18(%rbp)
jae 0x1c3c3
movq (%rbp), %rax
movq %rbp, %rdi
movq %... | /scientific-systems[P]fmt/include/fmt/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<char, fmt::v5::basic_format_specs<char>>::hex_writer>::operator()<char*>(char*&&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rdi), %r15
movq (%rsi), %r14
movq %r14, %rdi
testq %r15, %r15
je 0x1c4e1
movq 0x8(%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0xb9c0
leaq (%r14,%r15), %rdi
movq %rdi, (%rbx)
movq 0x20(%r12), %r1... | /scientific-systems[P]fmt/include/fmt/format.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.