LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/illmat[P]MemCrawl/myPtrace.cpp
// Function: detach(int)
int detach(pid_t pid)
{
    if(ptrace(PTRACE_DETACH, pid, NULL, NULL))
    {
        perror("PTRACE_DETACH");
        return 1;
    }
    std::cout << "detached from " << pid << std::endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
xorl %ebx, %ebx
movl $0x11, %edi
movl %r14d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x2150
testq %rax, %rax
jne 0x3da6
movq 0x3280(%rip), %r15      # 0x6fd0
leaq 0x14e5(%rip), %rsi      # 0x523c
movl $0xe, %edx
movq %r15, %rdi
callq 0x21e0
movq %r15, %rdi
movl %r14d, %esi
callq 0x22e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1481(%rip), %rdi      # 0x522e
callq 0x2140
movl $0x1, %ebx
jmp 0x3d99
// File: /workspace/github_cpp_makefile_star2_O1/illmat[P]MemCrawl/myPtrace.cpp
// Function: peek(int, unsigned long, long&)
int peek(pid_t pid, unsigned long addr, long &buffer)
{
    errno = 0;
    if(((buffer = ptrace(PTRACE_PEEKDATA, pid, (void *)addr, NULL)) == -1) && errno)
    {
        perror("PTRACE_PEEKDATA");
        if(ptrace(PTRACE_DETACH, pid, NULL, NULL))
            perror("PTRACE_DETACH");
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r13
movl %edi, %ebx
callq 0x2040
movq %rax, %r15
movl $0x0, (%rax)
xorl %r14d, %r14d
movl $0x2, %edi
movl %ebx, %esi
movq %r13, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x2150
movq %rax, (%r12)
cmpq $-0x1, %rax
jne 0x3e03
cmpl $0x0, (%r15)
jne 0x3e15
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x142f(%rip), %rdi      # 0x524b
callq 0x2140
movl $0x11, %edi
movl %ebx, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x2150
movl $0x1, %r14d
testq %rax, %rax
je 0x3e03
leaq 0x13e9(%rip), %rdi      # 0x522e
callq 0x2140
jmp 0x3e03
// File: /workspace/github_cpp_makefile_star2_O1/illmat[P]MemCrawl/myPtrace.cpp
// Function: poke(int, unsigned long, long)
int poke(pid_t pid, unsigned long addr, long buffer)
{
    errno = 0;
    if (ptrace(PTRACE_POKEDATA, pid, (void *)addr, buffer) == -1 && errno)
    {
        perror("PTRACE_POKE");
        return 1;
    }
    std::cout << "successfully wrote " << buffer << " to " << std::hex << "0x" << addr << std::dec << std::endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %r13d
callq 0x2040
movq %rax, %r12
movl $0x0, (%rax)
xorl %ebx, %ebx
movl $0x5, %edi
movl %r13d, %esi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2150
cmpq $-0x1, %rax
jne 0x3e99
cmpl $0x0, (%r12)
jne 0x3f5b
movq 0x3130(%rip), %r12      # 0x6fd0
leaq 0x13c0(%rip), %rsi      # 0x5267
movl $0x13, %edx
movq %r12, %rdi
callq 0x21e0
movq %r12, %rdi
movq %r15, %rsi
callq 0x2170
movq %rax, %r15
leaq 0x1348(%rip), %rsi      # 0x5211
movl $0x4, %edx
movq %rax, %rdi
callq 0x21e0
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
leaq 0x1387(%rip), %rsi      # 0x527b
movl $0x2, %edx
movq %r15, %rdi
callq 0x21e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x20d0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r14,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12f9(%rip), %rdi      # 0x525b
callq 0x2140
movl $0x1, %ebx
jmp 0x3f4a
nop
// File: /workspace/github_cpp_makefile_star2_O1/illmat[P]MemCrawl/print.cpp
// Function: printHelp()
void printHelp() {
    std::cout << "MemCrawl options: " << std::endl;
    std::cout << "help:\t\tprints this help screen" << std::endl;
    std::cout << "list:\t\tprints a list of all entries" << std::endl;
    std::cout << "update:\t\tupdates all entries" << std::endl;
    std::cout << "ulist:\t\tupdates and lists all entries" << std::endl;
    std::cout << "info:\t\tprints info about scan regions" << std::endl;
    std::cout << "set <number>:\tsets all entries to <number>" << std::endl;
    std::cout << "reset:\t\tresets all entries" << std::endl;
    std::cout << "pid:\t\tchange to pid" << std::endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x2ea6(%rip), %rbx      # 0x6fd0
leaq 0x1168(%rip), %rsi      # 0x5299
movl $0x12, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x1140(%rip), %rsi      # 0x52ac
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x1124(%rip), %rsi      # 0x52cb
movl $0x23, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x110d(%rip), %rsi      # 0x52ef
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x10ef(%rip), %rsi      # 0x530c
movl $0x25, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x10da(%rip), %rsi      # 0x5332
movl $0x25, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x10c5(%rip), %rsi      # 0x5358
movl $0x2a, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x10b5(%rip), %rsi      # 0x5383
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
leaq 0x1095(%rip), %rsi      # 0x539e
movl $0x13, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/illmat[P]MemCrawl/scan.cpp
// Function: scanIntInit(std::vector<scanRegion, std::allocator<scanRegion>>, std::vector<scanResult, std::allocator<scanResult>>&, int, int)
int scanIntInit(std::vector<scanRegion> regions, std::vector<scanResult> &results, pid_t pid, int scanValue)
{
    unsigned long startAddr = 0, endAddr = 0;
    long buffer = 0;

    if (attach(pid) != 0)
    {
        return 1;
    }
    for (unsigned int x=0; x<regions.size(); x++)
    {
        scanResult result;
        startAddr = regions[x].startRegion;
        endAddr = regions[x].endRegion;

        while (startAddr < endAddr)
        {

            if (peek(pid, startAddr, buffer) != 0)
            {
                return 1;
            }
            if (buffer == scanValue)
            {
                result.addr = startAddr;
                result.value = buffer;
                results.push_back(result);
            }
            startAddr += sizeof(unsigned long);

         }

    }


    detach(pid);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r13
movq $0x0, -0x30(%rbp)
movl %edx, %edi
callq 0x3bf4
movl $0x1, %ecx
testl %eax, %eax
jne 0x442c
movq (%r13), %rax
cmpq %rax, 0x8(%r13)
je 0x441c
movslq %r14d, %r12
xorl %ecx, %ecx
xorl %esi, %esi
movq %r13, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
shlq $0x4, %rcx
movq (%rax,%rcx), %r14
movq 0x8(%rax,%rcx), %r13
cmpq %r13, %r14
jae 0x43f7
movl %ebx, %edi
movq %r14, %rsi
leaq -0x30(%rbp), %rdx
callq 0x3db9
testl %eax, %eax
jne 0x4427
movq -0x30(%rbp), %rax
cmpq %r12, %rax
jne 0x43f1
movq %r14, -0x50(%rbp)
movl %eax, -0x48(%rbp)
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0x43e5
movups -0x50(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%r15)
jmp 0x43f1
movq %r15, %rdi
leaq -0x50(%rbp), %rdx
callq 0x4788
addq $0x8, %r14
jmp 0x43a6
movq -0x40(%rbp), %rsi
incl %esi
movq -0x38(%rbp), %r13
movq (%r13), %rax
movq 0x8(%r13), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
movq %rsi, %rcx
cmpq %rsi, %rdx
ja 0x4395
movl %ebx, %edi
callq 0x3d22
xorl %ecx, %ecx
jmp 0x442c
movl $0x1, %ecx
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/illmat[P]MemCrawl/scan.cpp
// Function: scanIntResults(std::vector<scanResult, std::allocator<scanResult>>&, int, int)
int scanIntResults(std::vector<scanResult> &results, pid_t pid, int scanValue)
{
    long buffer = 0;
    scanResult result;
    std::vector<scanResult> newResults;

    if (attach(pid) != 0)
    {
        return 1;
    }
    for (unsigned int x=0; x<results.size(); x++)
    {
        if (peek(pid, results[x].addr, buffer) != 0)
        {
            return 1;
        }
        if (buffer == scanValue)
        {
            result.addr = results[x].addr;
            result.value = buffer;
            newResults.push_back(result);
        }

    }

    results = newResults;
    detach(pid);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r12d
movl %esi, %ebx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, -0x48(%rbp)
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movl %esi, %edi
callq 0x3bf4
movl $0x1, %r15d
testl %eax, %eax
jne 0x451b
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x44fd
movslq %r12d, %r12
movl $0x1, %r13d
xorl %r15d, %r15d
shlq $0x4, %r15
movq (%rax,%r15), %rsi
movl %ebx, %edi
leaq -0x48(%rbp), %rdx
callq 0x3db9
testl %eax, %eax
jne 0x4515
movq -0x48(%rbp), %rax
cmpq %r12, %rax
jne 0x44e4
movq (%r14), %rcx
movq (%rcx,%r15), %rcx
movq %rcx, -0x58(%rbp)
movl %eax, -0x50(%rbp)
movq -0x38(%rbp), %rsi
cmpq -0x30(%rbp), %rsi
je 0x44d7
movups -0x58(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, -0x38(%rbp)
jmp 0x44e4
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x4788
movl %r13d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
incl %r13d
cmpq %r15, %rcx
ja 0x4491
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x46a8
xorl %r15d, %r15d
movl %ebx, %edi
callq 0x3d22
jmp 0x451b
movl $0x1, %r15d
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x4530
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x21c0
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4544
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x455c
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/illmat[P]MemCrawl/scan.cpp
// Function: updateIntResults(std::vector<scanResult, std::allocator<scanResult>>&, int)
int updateIntResults(std::vector<scanResult> &results, pid_t pid)
{
    long buffer = 0;

    if (attach(pid) != 0)
    {
        return 1;
    }
    for (unsigned int x=0; x<results.size(); x++)
    {
        if (peek(pid, results[x].addr, buffer) != 0)
        {
            return 1;
        }
        else {
            results[x].value = buffer;
        }
    }

    detach(pid);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq $0x0, -0x30(%rbp)
movl %esi, %edi
callq 0x3bf4
movl $0x1, %ecx
testl %eax, %eax
jne 0x45ec
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x45dc
xorl %r13d, %r13d
leaq -0x30(%rbp), %r12
movl $0x1, %r15d
shlq $0x4, %r13
movq (%rax,%r13), %rsi
movl %ebx, %edi
movq %r12, %rdx
callq 0x3db9
testl %eax, %eax
jne 0x45e7
movl -0x30(%rbp), %ecx
movq (%r14), %rax
movl %ecx, 0x8(%rax,%r13)
movl %r15d, %r13d
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
incl %r15d
cmpq %r13, %rcx
ja 0x45a5
movl %ebx, %edi
callq 0x3d22
xorl %ecx, %ecx
jmp 0x45ec
movl $0x1, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/illmat[P]MemCrawl/scan.cpp
// Function: setInt(std::vector<scanResult, std::allocator<scanResult>>&, int, int)
int setInt(std::vector<scanResult> &results, pid_t pid, int value)
{
    if (attach(pid) != 0)
    {
        return 1;
    }
    for (unsigned int x=0; x<results.size(); x++)
    {
        if (poke(pid, results[x].addr, value) != 0)
        {
            return 1;
        }
    }

    detach(pid);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movl %esi, %ebx
movq %rdi, %r15
movl %esi, %edi
callq 0x3bf4
movl $0x1, -0x2c(%rbp)
testl %eax, %eax
jne 0x4695
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
setne %r13b
je 0x4687
movslq %r12d, %r12
movq (%rax), %rsi
movl %ebx, %edi
movq %r12, %rdx
callq 0x3e4c
testl %eax, %eax
jne 0x4682
movl $0x1, %ecx
movl %ecx, %r14d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r14, %rcx
seta %r13b
jbe 0x4687
movq %r14, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rsi
movl %ebx, %edi
movq %r12, %rdx
callq 0x3e4c
leal 0x1(%r14), %ecx
testl %eax, %eax
je 0x464b
testb %r13b, %r13b
jne 0x4695
movl %ebx, %edi
callq 0x3d22
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/danfai[P]dboc/stringtokenizer.cpp
// Function: StringTokenizer::getString[abi:cxx11]()
std::string StringTokenizer::getString()
{
    if (this->end)
        throw InvalidLineException();
    if (line[pos] == ' ') { ++pos;
        return ""; }
    int oldpos = pos;
    for(; line[pos] != '\0'; ++pos) {
        if (line[pos] == ' ') {
            ++pos;
            std::string b = line.substr(oldpos, pos-oldpos-1);
            return b;
        }
    }
    this->end = true;
    return line.substr(oldpos);
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x24(%rsi)
jne 0x2af7
movq %rdi, %rbx
movl 0x20(%rsi), %ecx
movq (%rsi), %rax
cmpb $0x20, (%rax,%rcx)
jne 0x2ab3
leal 0x1(%rcx), %eax
movl %eax, 0x20(%rsi)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2635(%rip), %rdx      # 0x50db
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x29c4
jmp 0x2af2
movslq %ecx, %rdx
movl 0x20(%rsi), %ecx
movl %ecx, %edi
movzbl (%rax,%rdi), %edi
testl %edi, %edi
je 0x2adc
cmpl $0x20, %edi
je 0x2acf
incl %ecx
movl %ecx, 0x20(%rsi)
jmp 0x2ab9
leal 0x1(%rcx), %eax
movl %eax, 0x20(%rsi)
subl %edx, %ecx
movq %rbx, %rdi
jmp 0x2aed
movl $0x1, 0x24(%rsi)
movq %rbx, %rdi
movq $-0x1, %rcx
callq 0x21f0
movq %rbx, %rax
popq %rbx
retq
movl $0x8, %edi
callq 0x2110
leaq 0x5248(%rip), %rcx      # 0x7d50
movq %rcx, (%rax)
leaq 0x5216(%rip), %rsi      # 0x7d28
movq 0x54bf(%rip), %rdx      # 0x7fd8
movq %rax, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/danfai[P]dboc/parser.cpp
// Function: Parser::Parser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Parser::Parser(std::string inFile)
{
    std::ifstream in(inFile);

    std::string line;
    while(std::getline(in, line)) {
        if(line.size() > 0)
            parseLine(line);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x22c0
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x30(%rsp), %rbp
movq %rsp, %r15
leaq 0x20(%rsp), %r12
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2320
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2c9f
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
je 0x2c2b
movq %rbp, 0x20(%rsp)
movq (%rsp), %rsi
addq %rsi, %rdx
movq %r12, %rdi
callq 0x2b42
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2d26
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2c2b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21e0
jmp 0x2c2b
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2cb5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
leaq 0x40(%rsp), %rdi
callq 0x2080
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2d15
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2cf5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21e0
jmp 0x2cf5
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2d0b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21e0
leaq 0x40(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x288a
movq %r14, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/danfai[P]dboc/./entry.h
// Function: Field::getFieldName(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&)
void getFieldName(std::ostringstream &oss) {
            oss << "    ";
            //TODO: Check for relation
            switch(type) {
                case Field::b:
                    oss << "bool";
                    break;
                case Field::e:
                case Field::c:
                    oss << additionalType;
                    break;
                case Field::d:
                    oss << "double";
                    break;
                case Field::f:
                    oss << "float";
                    break;
                case Field::i:
                    oss << "int";
                    break;
                case Field::l:
                    oss << "long";
                    break;
                case Field::p:
                    oss << "Wt::Dbo::ptr<" << additionalType << ">";
                    break;
                case Field::ss:
                    oss << "std::string";
                    break;
                case Field::Wdt:
                    oss << "Wt::WDateTime";
                    break;
                case Field::Ws:
                    oss << "Wt::WString";
                    break;
                default:
                    // I dont know
                    break;
            }
            oss  << " " << fieldName << ";" << std::endl;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x14a2(%rip), %rsi      # 0x5379
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2210
movl (%r14), %eax
cmpq $0xa, %rax
ja 0x3fb2
leaq 0x12cc(%rip), %rcx      # 0x51c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
jmp 0x3faa
leaq 0x1475(%rip), %rsi      # 0x538a
movl $0x5, %edx
jmp 0x3faa
leaq 0x148d(%rip), %rsi      # 0x53b3
movl $0xd, %edx
jmp 0x3faa
leaq 0x144a(%rip), %rsi      # 0x537e
jmp 0x3f8e
leaq 0x1446(%rip), %rsi      # 0x5383
movl $0x6, %edx
jmp 0x3faa
leaq 0x144e(%rip), %rsi      # 0x5399
movl $0xd, %edx
movq %rbx, %rdi
callq 0x2210
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %rbx, %rdi
callq 0x2210
leaq 0x10b5(%rip), %rsi      # 0x5024
movl $0x1, %edx
movq %rax, %rdi
jmp 0x3fad
leaq 0x1410(%rip), %rsi      # 0x5390
movl $0x3, %edx
jmp 0x3faa
leaq 0x1406(%rip), %rsi      # 0x5394
movl $0x4, %edx
jmp 0x3faa
leaq 0x1425(%rip), %rsi      # 0x53c1
jmp 0x3fa5
leaq 0x1402(%rip), %rsi      # 0x53a7
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2210
leaq 0x13c3(%rip), %rsi      # 0x537c
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2210
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %rbx
leaq 0x12df(%rip), %rsi      # 0x52bf
movl $0x1, %edx
movq %rax, %rdi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get()
char_int_type get()
    {
        ++position.chars_read_total;
        ++position.chars_read_current_line;

        if (next_unget)
        {
            // just reset the next_unget variable and work with current
            next_unget = false;
        }
        else
        {
            current = ia.get_character();
        }

        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
        {
            token_string.push_back(char_traits<char_type>::to_char_type(current));
        }

        if (current == '\n')
        {
            ++position.lines_read;
            position.chars_read_current_line = 0;
        }

        return current;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
incq 0x20(%rdi)
incq 0x28(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x35cd
movb $0x0, 0x18(%rbx)
jmp 0x35d8
movq %rbx, %rdi
callq 0x725c
movl %eax, 0x14(%rbx)
movl 0x14(%rbx), %eax
cmpl $-0x1, %eax
je 0x3602
movb %al, -0x9(%rbp)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x35f5
movb %al, (%rsi)
incq 0x40(%rbx)
jmp 0x3602
leaq 0x38(%rbx), %rdi
leaq -0x9(%rbp), %rdx
callq 0x72a2
movl 0x14(%rbx), %eax
cmpl $0xa, %eax
jne 0x3613
incq 0x30(%rbx)
andq $0x0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/main.cpp
// Function: checkdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool checkdir(string str) {
	DIR* dir = opendir(str.c_str());
	if (dir) {
		closedir(dir);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
callq 0x3430
movq %rax, %rbx
testq %rax, %rax
je 0x3bea
movq %rbx, %rdi
callq 0x3490
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/main.cpp
// Function: refreshValues()
void refreshValues()
{		
	auto batInit = getBatteryInfo();
	currentEnergy = batInit.energy;
	currentPower = batInit.power;

	ifstream st(Path + "status");
	timeNow = time(NULL);
	//timeElapsed = timeElapsed + timeNow - lastTime;
	timeElapsed += refreshRate;
	lastTime = timeNow;
	st >> status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
callq 0x3bf7
movss %xmm0, 0x15cae(%rip)    # 0x1a364
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movss %xmm0, 0x15ca6(%rip)    # 0x1a368
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0x15cb7(%rip), %rsi     # 0x1a388
movq 0x15cb8(%rip), %rdx     # 0x1a390
addq %rsi, %rdx
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x518a
leaq 0xcfc9(%rip), %rsi      # 0x116b7
movq %rbx, %rdi
callq 0x3560
leaq -0x238(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x34a0
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4719
callq 0x32f0
xorl %edi, %edi
callq 0x32e0
movl %eax, 0x15c52(%rip)     # 0x1a378
movl 0x15bb4(%rip), %ecx     # 0x1a2e0
addl %ecx, 0x15c4a(%rip)     # 0x1a37c
movl %eax, 0x15c48(%rip)     # 0x1a380
leaq 0x15c69(%rip), %rsi     # 0x1a3a8
leaq -0x238(%rbp), %rdi
callq 0x33e0
leaq -0x238(%rbp), %rdi
callq 0x30c0
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x30c0
jmp 0x4787
jmp 0x4776
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x4787
callq 0x32f0
movq %rbx, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/main.cpp
// Function: keyListenerFunction()
void keyListenerFunction()
{
	int ch = 0;
	while((ch = wgetch(mainwin)) != 'q')
	{
		if(ch == 27)
			break;

		switch ( ch ) {

		case KEY_UP:
			if (logIndex > 0)
				--logIndex;
			newPrint();
			break;

		case KEY_DOWN:
			if (logIndex + 1 < logCache.size())
				++logIndex;
			newPrint();
			break;
		}
	}
	quit = 1;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1577f(%rip), %rdi     # 0x1a470
callq 0x3120
cmpl $0x102, %eax            # imm = 0x102
jg 0x4d22
jne 0x4d42
movslq 0x1567e(%rip), %rax     # 0x1a384
incq %rax
movq 0x15770(%rip), %rcx     # 0x1a480
subq 0x15761(%rip), %rcx     # 0x1a478
sarq $0x5, %rcx
cmpq %rax, %rcx
ja 0x4d35
jmp 0x4d3b
cmpl $0x103, %eax            # imm = 0x103
jne 0x4cea
movl 0x15655(%rip), %eax     # 0x1a384
testl %eax, %eax
jle 0x4d3b
decl %eax
movl %eax, 0x15649(%rip)     # 0x1a384
callq 0x478f
jmp 0x4cea
cmpl $0x1b, %eax
je 0x4d4c
cmpl $0x71, %eax
jne 0x4cea
movb $0x1, 0x15716(%rip)     # 0x1a469
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/main.cpp
// Function: coreFunction()
void coreFunction() {
	lastTime = time(NULL);
	// sleep(1);
	while(!quit) {
		refreshValues();
		newPrint();
		if(timeElapsed % (LOG_P * refreshRate) == 0)
			addLog();
		sleep(refreshRate);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x32e0
movl %eax, 0x1561a(%rip)     # 0x1a380
cmpb $0x0, 0x156fc(%rip)     # 0x1a469
jne 0x4dac
callq 0x469b
callq 0x478f
movl 0x155fd(%rip), %eax     # 0x1a37c
movl 0x1555b(%rip), %ecx     # 0x1a2e0
imull 0x15558(%rip), %ecx     # 0x1a2e4
cltd
idivl %ecx
testl %edx, %edx
jne 0x4d98
callq 0x4bd8
movl 0x15542(%rip), %edi     # 0x1a2e0
callq 0x3260
cmpb $0x1, 0x156bf(%rip)     # 0x1a469
jne 0x4d6f
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/main.cpp
// Function: main
int main() {

	init();
	thread keyListener(keyListenerFunction);
	thread core(coreFunction);
	thread *p;
	keyListener.join();
	//core.join();
	//terminate();
	//delete p;
	core.detach();
	erase();
	delwin(mainwin);
	endwin();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x41db
leaq -0xdc(%rip), %rsi       # 0x4ce6
leaq -0x10(%rbp), %rdi
callq 0x50f8
leaq -0x7d(%rip), %rsi       # 0x4d55
leaq -0x8(%rbp), %rdi
callq 0x50f8
leaq -0x10(%rbp), %rdi
callq 0x3500
leaq -0x8(%rbp), %rdi
callq 0x3520
callq 0x3360
movq 0x15677(%rip), %rdi     # 0x1a470
callq 0x3060
callq 0x33a0
cmpq $0x0, -0x8(%rbp)
jne 0x4e31
cmpq $0x0, -0x10(%rbp)
jne 0x4e31
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
jmp 0x4e22
cmpq $0x0, -0x8(%rbp)
jne 0x4e31
cmpq $0x0, -0x10(%rbp)
jne 0x4e31
movq %rax, %rdi
callq 0x3530
callq 0x30d0
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::detail::input_stream_adapter::get_character()
std::char_traits<char>::int_type get_character()
    {
        auto res = sb->sbumpc();
        // set eof manually, as we don't use the istream interface.
        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
        {
            is->clear(is->rdstate() | std::ios::eofbit);
        }
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x728d
movzbl (%rax), %r14d
incq %rax
movq %rax, 0x10(%rdi)
cmpl $-0x1, %r14d
je 0x7298
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rdi), %rax
callq *0x50(%rax)
movl %eax, %r14d
jmp 0x727f
movq %rbx, %rdi
callq 0x366a
jmp 0x7285
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>)
basic_json& operator=(basic_json other) noexcept (
        std::is_nothrow_move_constructible<value_t>::value&&
        std::is_nothrow_move_assignable<value_t>::value&&
        std::is_nothrow_move_constructible<json_value>::value&&
        std::is_nothrow_move_assignable<json_value>::value&&
        std::is_nothrow_move_assignable<json_base_class_t>::value
    )
    {
        // check that passed value is valid
        other.assert_invariant();

        using std::swap;
        swap(m_data.m_type, other.m_data.m_type);
        swap(m_data.m_value, other.m_data.m_value);
        json_base_class_t::operator=(std::move(other));

        set_parents();
        assert_invariant();
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1, %esi
callq 0x52be
movb (%r14), %al
movb (%rbx), %cl
movb %cl, (%r14)
movb %al, (%rbx)
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x52be
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)3>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::string_t const&)
static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
        j.m_data.m_value = s;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movzbl (%r14), %esi
callq 0x53b0
movb $0x3, (%r14)
movq %rbx, %rdi
callq 0xb8ac
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x52be
nop
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::number_float_t)
static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_float;
        j.m_data.m_value = val;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, -0x10(%rbp)
movq %rdi, %rbx
addq $0x8, %rdi
movzbl (%rbx), %esi
callq 0x53b0
movb $0x7, (%rbx)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x52be
movq %rax, %rdi
callq 0x517b
nop
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::boolean_t)
static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::boolean;
        j.m_data.m_value = b;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
addq $0x8, %rdi
movzbl (%rbx), %esi
callq 0x53b0
movb $0x4, (%rbx)
movzbl %r14b, %eax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x52be
movq %rax, %rdi
callq 0x517b
nop
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::number_integer_t)
static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_integer;
        j.m_data.m_value = val;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
movzbl (%rbx), %esi
callq 0x53b0
movb $0x5, (%rbx)
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x52be
movq %rax, %rdi
callq 0x517b
nop
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::number_unsigned_t)
static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_unsigned;
        j.m_data.m_value = val;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
movzbl (%rbx), %esi
callq 0x53b0
movb $0x6, (%rbx)
movq %r14, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x52be
movq %rax, %rdi
callq 0x517b
nop
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool key(string_t& val)
    {
        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(ref_stack.back()->is_object());

        // add null at given key and store the reference for later
        object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0xe044
movq -0x8(%rax), %rax
cmpb $0x1, (%rax)
jne 0xe063
movq %rdi, %rbx
movq 0x8(%rax), %rdi
callq 0xc13e
movq %rax, 0x20(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5174(%rip), %rdi      # 0x131bf
leaq 0x3803(%rip), %rsi      # 0x11855
leaq 0x5edd(%rip), %rcx      # 0x13f36
movl $0x1ae0, %edx           # imm = 0x1AE0
callq 0x3210
leaq 0x5103(%rip), %rdi      # 0x1316d
leaq 0x37e4(%rip), %rsi      # 0x11855
leaq 0x5ebe(%rip), %rcx      # 0x13f36
movl $0x1ae1, %edx           # imm = 0x1AE1
callq 0x3210
// File: /workspace/github_cpp_makefile_star2_O1/Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
reference operator[](typename object_t::key_type key)
    {
        // implicitly convert null value to an empty object
        if (is_null())
        {
            m_data.m_type = value_t::object;
            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

        // operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
            return set_parent(result.first->second);
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rdi)
jne 0xf46d
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x3320
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x52be
cmpb $0x1, (%r14)
jne 0xf499
movq 0x8(%r14), %rdi
leaq -0x40(%rbp), %rdx
movq $0x0, (%rdx)
movq %rbx, %rsi
callq 0xf5b2
addq $0x40, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x31d0
movq %rax, %rbx
movq %r14, %rdi
callq 0xbf8c
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x4f67(%rip), %rsi      # 0x14423
leaq -0x40(%rbp), %rdi
callq 0xf527
movb $0x1, %r15b
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
movq %r14, %rcx
callq 0xbd68
xorl %r15d, %r15d
leaq 0xa7da(%rip), %rsi      # 0x19cc0
leaq -0x6b0b(%rip), %rdx     # 0x89e2
movq %rbx, %rdi
callq 0x3510
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf512
callq 0x32f0
jmp 0xf512
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xf51f
movq %rbx, %rdi
callq 0x3250
movq %r14, %rdi
callq 0x3530
// File: /workspace/github_cpp_makefile_star2_O1/cesarblum[P]propertypp/example.cpp
// Function: Example::printProperties()
void Example::printProperties()
{
    std::cout << "i: " << i
              << "; f: " << f
              << "; p: " << p << " (" << (p ? *p : 0) << ")"
              << std::endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2d8c(%rip), %r14      # 0x3fd8
leaq 0xdc1(%rip), %rsi       # 0x2014
movl $0x3, %edx
movq %r14, %rdi
callq 0x10a0
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
xorl %ebp, %ebp
xorl %esi, %esi
callq *(%rax)
movq %r14, %rdi
movl %eax, %esi
callq 0x10d0
movq %rax, %r14
leaq 0xd97(%rip), %rsi       # 0x2018
movl $0x5, %edx
movq %rax, %rdi
callq 0x10a0
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
cvtss2sd %xmm0, %xmm0
movq %r14, %rdi
callq 0x10c0
movq %rax, %r14
leaq 0xd6f(%rip), %rsi       # 0x201e
movl $0x5, %edx
movq %rax, %rdi
callq 0x10a0
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x1050
movq %rax, %r14
leaq 0xd48(%rip), %rsi       # 0x2024
movl $0x2, %edx
movq %rax, %rdi
callq 0x10a0
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
testq %rax, %rax
je 0x1306
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movl (%rax), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x10d0
movq %rax, %rbx
leaq 0xd0d(%rip), %rsi       # 0x2027
movl $0x1, %edx
movq %rax, %rdi
callq 0x10a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_cpp_makefile_star2_O1/cesarblum[P]propertypp/example.cpp
// Function: main
int main()
{
    Example e;
    e.printProperties(); // should print all 0

    e.i = 14;
    e.f = 2.3;
    e.p = new int;
    *e.p = 5;
    e.printProperties(); // should print assigned values

    e.f = -1.0;
    e.printProperties(); // e.f should be unchanged (see setter above)

    e.i = e.f;           // implicit type conversion
    e.printProperties(); // e.i should equal the integer part of e.f

    e.f = 5.5;
    e.printProperties(); // only e.f should be changed

    e.i = e.f = 9.3;     // chained assignment
    e.printProperties(); // e.i should be 9, e.f should be 9.3

    e.i = *e.p;
    e.printProperties(); // e.i should equal the value pointed to by e.p

    delete e.p;
    e.p = 0;
    e.printProperties(); // e.p should be null

    return 0;
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x120c
movq %rbx, %rdi
callq 0x123e
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
movl $0xe, %esi
callq *(%rax)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movss 0xc54(%rip), %xmm0      # 0x2004
callq *(%rax)
movl $0x4, %edi
callq 0x1080
movq 0x40(%rbx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *(%rcx)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movl $0x5, (%rax)
movq %rbx, %rdi
callq 0x123e
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movss 0xc18(%rip), %xmm0      # 0x2008
callq *(%rax)
movq %rbx, %rdi
callq 0x123e
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
cvttss2si %xmm0, %esi
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
callq 0x123e
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movss 0xbe3(%rip), %xmm0      # 0x200c
callq *(%rax)
movq %rbx, %rdi
callq 0x123e
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movss 0xbce(%rip), %xmm0      # 0x2010
callq *(%rax)
cvttss2si %xmm0, %esi
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
callq 0x123e
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movl (%rax), %esi
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rbx, %rdi
callq 0x123e
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
testq %rax, %rax
je 0x1494
movl $0x4, %esi
movq %rax, %rdi
callq 0x1090
leaq 0x8(%rsp), %rbx
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq %rbx, %rdi
callq 0x123e
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
retq