LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: helchr[P]reMap/main.cpp
// Function: cleanAddresses(std::map<unsigned long, std::vector<unsigned long, std::allocator<unsigned long>>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::vector<unsigned long, std::allocator<unsigned long>>>>>&, unsigned long, unsigned long)
void cleanAddresses(std::map<size_t,std::vector<size_t>>& addresses,
                    uint64_t removeFront, uint64_t removeBack)
{
    auto usableBits = getUsableBits(removeFront,removeBack);
    uint64_t mask = 1;
    mask = mask << usableBits;
    mask = mask - 1ULL;

    for(auto& list : addresses)
    {
        for(auto& a : list.second)
        {
            a >>= removeFront;
            a &= mask;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9c30
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xc730
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xc760
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xc790
testb $0x1, %al
jne 0x9ce0
jmp 0x9d70
leaq -0x38(%rbp), %rdi
callq 0xc7c0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0xcad0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0xcb00
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xcb30
testb $0x1, %al
jne 0x9d26
jmp 0x9d60
leaq -0x58(%rbp), %rdi
callq 0xcb70
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rcx
movq -0x68(%rbp), %rax
movq (%rax), %rdx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x68(%rbp), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
leaq -0x58(%rbp), %rdi
callq 0xcb90
jmp 0x9d13
jmp 0x9d62
leaq -0x38(%rbp), %rdi
callq 0xc8f0
jmp 0x9cca
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: helchr[P]reMap/main.cpp
// Function: compactSets(std::map<unsigned long, std::vector<unsigned long, std::allocator<unsigned long>>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::vector<unsigned long, std::allocator<unsigned long>>>>> const&)
std::map<size_t,std::vector<uint64_t>> compactSets(const std::map<size_t,std::vector<uint64_t>>& addresses)
{
    std::map<size_t,std::vector<uint64_t>> newAddresses;
    size_t newIdx = 0;
    for(const auto& adr : addresses)
    {
        if(!adr.second.empty())
        {
            newAddresses.insert(make_pair(newIdx,adr.second));
            newIdx++;
        }
    }
    return newAddresses;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xcf30
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xcbf0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xcc20
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xcc50
testb $0x1, %al
jne 0xa36d
jmp 0xa425
leaq -0x30(%rbp), %rdi
callq 0xcc80
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0xc820
testb $0x1, %al
jne 0xa415
movq -0x40(%rbp), %rdx
addq $0x8, %rdx
leaq -0x60(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xcf90
jmp 0xa3a6
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xcf50
movb %dl, -0x99(%rbp)
movq %rax, -0x98(%rbp)
jmp 0xa3c5
movb -0x99(%rbp), %al
movq -0x98(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movb %al, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xcfd0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa415
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xa44b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xcfd0
jmp 0xa44b
jmp 0xa417
leaq -0x30(%rbp), %rdi
callq 0xccb0
jmp 0xa357
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa43b
movq -0x90(%rbp), %rdi
callq 0xcff0
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0xcff0
movq -0x68(%rbp), %rdi
callq 0x6950
// File: helchr[P]reMap/main.cpp
// Function: prepareSolvePrint(std::map<unsigned long, std::vector<unsigned long, std::allocator<unsigned long>>, std::less<unsigned long>, std::allocator<std::pair<unsigned long const, std::vector<unsigned long, std::allocator<unsigned long>>>>>, unsigned long, unsigned long)
void prepareSolvePrint(AddressSet adrs,size_t removeFront, size_t removeBack)
{
    cleanAddresses(adrs,removeFront,removeBack);
    adrs = compactSets(adrs);
    auto expectedBits = static_cast<size_t>(ceil(log2(adrs.size())));
    auto cSol = calculateAddressingFunction(adrs,expectedBits,getUsableBits(removeFront,removeBack));
    printSolutions(cSol,removeFront);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9c60
movq -0xa8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa300
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
callq 0xd010
movq -0xb0(%rbp), %rdi
callq 0xcff0
movq -0xa8(%rbp), %rdi
callq 0xd080
movq %rax, %rdi
callq 0xd040
callq 0x60c0
movsd 0x28b26(%rip), %xmm2    # 0x33008
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9c30
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq %rax, %rcx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x9d80
movq -0x98(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0xd0a0
jmp 0xa54f
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0xa250
jmp 0xa55e
leaq -0x80(%rbp), %rdi
callq 0xcd90
leaq -0x68(%rbp), %rdi
callq 0xcd90
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xa5a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xcd90
leaq -0x68(%rbp), %rdi
callq 0xcd90
movq -0x88(%rbp), %rdi
callq 0x6950
nopl (%rax)
// File: helchr[P]reMap/solver.cpp
// Function: Solver::xorRows(std::vector<unsigned long, std::allocator<unsigned long>>&, unsigned long, unsigned long)
void Solver::xorRows(Matrix& matrix, size_t row, size_t col)
{
    auto tmp = matrix[row];
    uint64_t mask = 1ULL << col;
    for(size_t r = 0; r < matrix.size(); r++)
    {
        if(r != row)
        {
            if((matrix[r] & mask) == mask)
            {
                matrix[r] ^= tmp;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x180e0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd540
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x175a6
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x17596
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x180e0
movq (%rax), %rax
andq -0x30(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x17594
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x180e0
movq -0x48(%rbp), %rcx
xorq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x17596
jmp 0x17598
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x17534
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: helchr[P]reMap/solver.cpp
// Function: Solver::findRowToSwap(std::vector<unsigned long, std::allocator<unsigned long>> const&, unsigned long, unsigned long)
size_t Solver::findRowToSwap(const Matrix& matrix, size_t row, size_t col)
{
    uint64_t mask = 1ULL << col;
    for(size_t r = row+1; r < matrix.size(); r++)
    {
        if((matrix[r] & mask) == mask)
        {
            return r;
        }
    }
    return row;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd540
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x17635
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x18100
movq (%rax), %rax
andq -0x30(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x17625
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1763d
jmp 0x17627
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x175e4
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: helchr[P]reMap/solver.cpp
// Function: Solver::getSetBit(std::bitset<64ul>)
size_t Solver::getSetBit(std::bitset<bitSize> bits)
{
    for(size_t i = 0; i < bitSize; i++ )
    {
        if(bits[i] == 1)
        {
            return i;
        }
    }
    return std::numeric_limits<size_t>::max();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x40, -0x20(%rbp)
jae 0x1776c
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xd570
leaq -0x30(%rbp), %rdi
callq 0xd5b0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd5f0
movl -0x34(%rbp), %eax
cmpl $0x1, %eax
jne 0x1775c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17775
jmp 0x1775e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x17718
callq 0xd560
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: helchr[P]reMap/solver.cpp
// Function: Solver::getSetBits(std::bitset<64ul>)
std::set<size_t> Solver::getSetBits(std::bitset<bitSize> bits)
{
    std::set<size_t> out;
    assert(bits.count() > 1);
    for(size_t i = 0; i < bitSize; i++ )
    {
        if(bits[i] == 1)
        {
            out.insert(i);
        }
    }
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xd190
leaq -0x10(%rbp), %rdi
callq 0xcab0
cmpq $0x1, %rax
jbe 0x177bc
jmp 0x177db
leaq 0x1bdc1(%rip), %rdi     # 0x33584
leaq 0x1bdcb(%rip), %rsi     # 0x33595
movl $0x3e, %edx
leaq 0x1bdca(%rip), %rcx     # 0x335a0
callq 0x63e0
movq $0x0, -0x28(%rbp)
cmpq $0x40, -0x28(%rbp)
jae 0x17873
movq -0x28(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xd570
jmp 0x17801
leaq -0x38(%rbp), %rdi
callq 0xd5b0
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd5f0
movl -0x6c(%rbp), %eax
cmpl $0x1, %eax
jne 0x17860
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd330
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0x17839
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movb %al, -0x50(%rbp)
jmp 0x17860
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xe070
jmp 0x17893
jmp 0x17862
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x177e3
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x17886
movq -0x68(%rbp), %rdi
callq 0xe070
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6950
nopl (%rax)
// File: helchr[P]reMap/solver.cpp
// Function: Solver::solve(std::vector<unsigned long, std::allocator<unsigned long>>&, unsigned long)
void Solver::solve(Matrix& matrix, size_t colMax)
{
    for(size_t c = colMax, r = 0; c-- > 1 && r < matrix.size();)
    {
        uint64_t mask = 1ULL << c;
        if((matrix[r] & mask) == 1)
        {
            xorRows(matrix,r,c);
            r++;
        }
        else
        {
            auto rowToSwap = findRowToSwap(matrix,r,c);
            if(rowToSwap == r)
            {
                //move to next column, stay in same row
                continue;
            }
            else
            {
                swapRows(matrix,r,rowToSwap);
                xorRows(matrix,r,c);
                r++;
            }
        }
        if(debug)
        {
            printMatrix(matrix);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x1, %rcx
movb %al, -0x41(%rbp)
jbe 0x17907
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd540
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x17913
jmp 0x179db
movq -0x20(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x180e0
movq (%rax), %rax
andq -0x30(%rbp), %rax
cmpq $0x1, %rax
jne 0x17960
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x174f0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x179c0
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x175b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x17988
jmp 0x178cc
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x174a0
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x174f0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x179c0
movq -0x40(%rbp), %rax
testb $0x1, (%rax)
je 0x179d6
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17650
jmp 0x178cc
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: helchr[P]reMap/sysinfo.cpp
// Function: SysInfo::getNumberOfChannels(unsigned int, unsigned int)
unsigned int SysInfo::getNumberOfChannels(unsigned int socket, unsigned int controller)
{
    unsigned int count = 0;
    for(unsigned int i = 0; i < 4; i++)
    {
        std::string path = pciDevPath + socketIds.at(socket) +"/" + controllerIds.at(controller) + "." + channelIds.at(i);
        if(fs::exists(path))
        {
            count++;
        }
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jae 0x19625
movl -0x4(%rbp), %eax
movl %eax, %esi
leaq 0x2d16b(%rip), %rdi     # 0x46590
callq 0x1a950
movq %rax, %rdx
leaq 0x2d1c4(%rip), %rsi     # 0x465f8
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x1a8d0
movq -0x108(%rbp), %rsi
leaq 0x1a1a4(%rip), %rdx     # 0x335f9
leaq -0x90(%rbp), %rdi
callq 0x1a750
jmp 0x19463
movl -0x8(%rbp), %eax
movl %eax, %esi
leaq 0x2d139(%rip), %rdi     # 0x465a8
callq 0x1a950
movq %rax, -0x110(%rbp)
jmp 0x1947d
movq -0x110(%rbp), %rdx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1a700
jmp 0x19496
leaq 0x19eed(%rip), %rdx     # 0x3338a
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1a750
jmp 0x194ac
movl -0x10(%rbp), %eax
movl %eax, %esi
leaq 0x2d128(%rip), %rdi     # 0x465e0
callq 0x1a950
movq %rax, -0x118(%rbp)
jmp 0x194c6
movq -0x118(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1a700
jmp 0x194dc
leaq -0x50(%rbp), %rdi
callq 0x6a88
leaq -0x70(%rbp), %rdi
callq 0x6a88
leaq -0x90(%rbp), %rdi
callq 0x6a88
leaq -0xb0(%rbp), %rdi
callq 0x6a88
leaq -0x100(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1a9c0
jmp 0x19518
leaq -0x100(%rbp), %rdi
callq 0x1a990
movb %al, -0x119(%rbp)
jmp 0x1952c
leaq -0x100(%rbp), %rdi
callq 0x1aa50
movb -0x119(%rbp), %al
testb $0x1, %al
jne 0x19547
jmp 0x19603
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x19603
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x195c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x195b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x195ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6a88
leaq -0x70(%rbp), %rdi
callq 0x6a88
leaq -0x90(%rbp), %rdi
callq 0x6a88
leaq -0xb0(%rbp), %rdi
callq 0x6a88
jmp 0x19631
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x1961a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x1aa50
jmp 0x1961a
leaq -0x30(%rbp), %rdi
callq 0x6a88
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1940f
leaq -0x30(%rbp), %rdi
callq 0x6a88
jmp 0x19631
movl -0xc(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x6950
nopl (%rax)
// File: helchr[P]reMap/sysinfo.cpp
// Function: SysInfo::getRankInterleaveingRegionLimit(unsigned int)
unsigned int SysInfo::getRankInterleaveingRegionLimit(unsigned int reg)
{
    unsigned int mask = 1 << 10;
    mask = mask -1;
    reg = (reg >> 1) & mask;
    return reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x400, -0x8(%rbp)      # imm = 0x400
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
andl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: helchr[P]reMap/sysinfo.cpp
// Function: SysInfo::getTadRegions(unsigned int)
std::map<size_t,std::vector<SysInfo::TadRegion>> SysInfo::getTadRegions(unsigned int socket)
{
    std::map<size_t,std::vector<TadRegion>> regions; //must be ordered map
    for(unsigned int contr = 0; contr < 2; contr++)
    {
        size_t lastLimit = 0;
        unsigned int i = 0;
        auto reg = readTadRegion(socket,contr,i);
        auto regionLimit = getRegionLimitAddress(reg);
        while(lastLimit != regionLimit)
        {
            TadRegion r;
            r.limitAddress = regionLimit;
            r.socketInterleaving = getSocketInterleaving(reg);
            r.channelInterleaving = getChannelInterleaving(reg);
            regions[regionLimit].push_back(r);
            i++;
            lastLimit = regionLimit;
            reg = readTadRegion(socket,contr,i);
            regionLimit =  getRegionLimitAddress(reg);
        }
    }
    return regions;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x1af20
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jae 0x1a33a
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x19640
movl %eax, -0x64(%rbp)
jmp 0x1a279
movl -0x64(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x19e00
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x1a32a
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x28(%rbp), %edi
callq 0x1a1e0
movb %al, -0x48(%rbp)
movl -0x28(%rbp), %edi
callq 0x1a200
movq -0x60(%rbp), %rdi
movb %al, -0x47(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x1af40
movq %rax, -0x70(%rbp)
jmp 0x1a2ca
movq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1b020
jmp 0x1a2d9
movl -0x24(%rbp), %eax
incl %eax
movl %eax, -0x24(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x19640
movl %eax, -0x74(%rbp)
jmp 0x1a2fc
movl -0x74(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x19e00
movq %rax, -0x40(%rbp)
jmp 0x1a28b
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xe050
jmp 0x1a35a
jmp 0x1a32c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a24d
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x1a34d
movq -0x60(%rbp), %rdi
callq 0xe050
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6950
nopw %cs:(%rax,%rax)
// File: helchr[P]reMap/sysinfo.cpp
// Function: SysInfo::getTypeOfImc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
unsigned int SysInfo::getTypeOfImc(const std::string& path)
{
    std::ifstream ifs(path+"/type");
    unsigned int type;
    ifs >> type;
    return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x1929e(%rip), %rdx     # 0x33658
leaq -0x230(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x1ab00
movq -0x248(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x68c0
jmp 0x1a3e7
leaq -0x230(%rbp), %rdi
callq 0x6a88
leaq -0x210(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x6090
jmp 0x1a408
movl -0x240(%rbp), %eax
movl %eax, -0x24c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x6170
movl -0x24c(%rbp), %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x6a88
jmp 0x1a46d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x6170
movq -0x238(%rbp), %rdi
callq 0x6950
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/convs.cc
// Function: main
int main()
{
	int i = 42;
	std::cout << i << std::endl; // prints 42
	if (i) // condition will evaluate as true
		i = 0;
	std::cout << i << std::endl; // prints 0

	bool b = 42;            // b is true
	std::cout << b << std::endl; // prints 1

	int j = b;              // j has value 1
	std::cout << j << std::endl; // prints 1

	double pi = 3.14;       // pi has value 3.14
	std::cout << pi << std::endl; // prints 3.14

	j = pi;                 // j has value 3
	std::cout << j << std::endl; // prints 3

	unsigned char c = -1;   // assuming 8-bit chars, c has value 255
	i = c;  // the character with value 255 is an unprintable character
	        // assigns value of c (i.e., 255) to an int
	std::cout << i << std::endl; // prints 255
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x2a, -0x8(%rbp)
movl -0x8(%rbp), %esi
movq 0x2de8(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2dc9(%rip), %rsi      # 0x3fc8
callq 0x1040
cmpl $0x0, -0x8(%rbp)
je 0x1211
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %esi
movq 0x2dbd(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2d9e(%rip), %rsi      # 0x3fc8
callq 0x1040
movb $0x1, -0x9(%rbp)
movb -0x9(%rbp), %al
movq 0x2d9b(%rip), %rdi      # 0x3fd8
andb $0x1, %al
movzbl %al, %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d77(%rip), %rsi      # 0x3fc8
callq 0x1040
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
movq 0x2d6d(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2d4e(%rip), %rsi      # 0x3fc8
callq 0x1040
movsd 0xd81(%rip), %xmm0      # 0x2008
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movq 0x2d40(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rdi
movq 0x2d21(%rip), %rsi      # 0x3fc8
callq 0x1040
cvttsd2si -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
movq 0x2d1a(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2cfb(%rip), %rsi      # 0x3fc8
callq 0x1040
movb $-0x1, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
movq 0x2cf1(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2cd2(%rip), %rsi      # 0x3fc8
callq 0x1040
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: SeTriones[P]Anubis/double_linked_list.c
// Function: init_list
double_linked_list* init_list() {
	double_linked_list* ret = (double_linked_list*)malloc(sizeof(double_linked_list));
	if (!ret) {
		return NULL;
	}
	ret->header = NULL;
	ret->tail = ret->header;
	ret->node_cnt = 0;
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x22d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2557
movq $0x0, -0x8(%rbp)
jmp 0x2584
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: SeTriones[P]Anubis/double_linked_list.c
// Function: destroy_list
void destroy_list(double_linked_list* lst) {
	if (lst == NULL) {
		return;
	}
	node* n = lst->header;
	if (n == NULL) {
		return;
	}
	node* cur;
	while (n) {
		cur = n;
		n = n->next;
		free(cur);
	}
	free(lst);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x25a5
jmp 0x25ea
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x25b9
jmp 0x25ea
jmp 0x25bb
cmpq $0x0, -0x10(%rbp)
je 0x25e1
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2270
jmp 0x25bb
movq -0x8(%rbp), %rdi
callq 0x2270
addq $0x20, %rsp
popq %rbp
retq
// File: SeTriones[P]Anubis/double_linked_list.c
// Function: mv_node_to_header
void mv_node_to_header(double_linked_list* lst, node* n, int is_new_node) {
	node* next = NULL;
	node* prev = NULL;
	if (is_new_node == 0) {
		if (n == lst->header) {
			return;
		}
		prev = n->prev;
		next = n->next;
		n->prev->next = next;
		if (n->next) {
			n->next->prev= prev;
		}
		if (n == lst->tail) {
			lst->tail = prev;
		}
	}
	else {
		if (1 == ++lst->node_cnt) {
			lst->tail = n;
		}
	}
	n->prev = NULL;
	n->next = lst->header;
	if (lst->header) {
		lst->header->prev = n;
	}
	lst->header = n;
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x26d6
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x2677
jmp 0x2739
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x26ba
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x26d4
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x26fa
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x26f8
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x26fa
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x272e
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: SeTriones[P]Anubis/double_linked_list.c
// Function: rm_node_from_tail
int rm_node_from_tail(double_linked_list* lst, int cnt, uint64_t* keys) {
	node* n = lst->tail;
	node* cur;
	int ret = 0;
	keys = (uint64_t*)malloc(sizeof(uint64_t) * cnt);
	while (n && cnt > 0) {
		cur = n;
		n = n->prev;

		keys[ret] = cur->key;
		free(cur);

		cnt--;
		lst->node_cnt--;
		ret++;
	}
	lst->tail = n;
	if (!n) {
		lst->header = NULL;
	}
	return ret; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x3, %rdi
callq 0x22d0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x2d(%rbp)
je 0x278d
cmpl $0x0, -0xc(%rbp)
setg %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x2796
jmp 0x27e7
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rdi
callq 0x2270
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2777
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x2805
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: SeTriones[P]Anubis/double_linked_list.c
// Function: push_from_header
int push_from_header(double_linked_list* lst, node* n) {
	n->next = lst->header;
	n->prev = NULL;
	if (lst->header) {
		lst->header->prev = n;
	}
	lst->header = n;
	return ++lst->node_cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2850
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x10(%rcx)
popq %rbp
retq
nopw (%rax,%rax)
// File: SeTriones[P]Anubis/double_linked_list.c
// Function: push_from_tail
int push_from_tail(double_linked_list* lst, node* n) {
	if (lst->tail) {
		lst->tail->next = n;
		n->prev = lst->tail;
		lst->tail = n;
		return ++lst->node_cnt;
	}
	else {
		return push_from_header(lst, n);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x28c9
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x10(%rcx)
movl %eax, -0x4(%rbp)
jmp 0x28d9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2810
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: SeTriones[P]Anubis/double_linked_list.c
// Function: pop_from_header
node* pop_from_header(double_linked_list* lst) {
	if (!lst->header) {
		return NULL;
	}
	node* n = lst->header;
	lst->header = n->next;
	if (lst->header) {
		lst->header->prev = NULL;
	} else {
		lst->tail = NULL;
	}
	--lst->node_cnt;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x290c
movq $0x0, -0x8(%rbp)
jmp 0x2962
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2941
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
jmp 0x294d
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: SeTriones[P]Anubis/double_linked_list.c
// Function: pop_from_tail
node* pop_from_tail(double_linked_list* lst) {
	if (!lst->tail) {
		return NULL;
	}
	node* n = lst->tail;
	lst->tail = n->prev;
	if (lst->tail) {
		lst->tail->next = NULL;
	} else {
		lst->header = NULL;
	}
	--lst->node_cnt;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x298d
movq $0x0, -0x8(%rbp)
jmp 0x29e6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x29c6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
jmp 0x29d1
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: SeTriones[P]Anubis/acceptor.cpp
// Function: acceptor::~acceptor()
acceptor::~acceptor() {
	delete[] epoll_fds;
	delete[] epoll_ready_event_num;
	delete[] pipe_read_fds;
	delete[] pipe_write_fds;
	for (int i = 0; i < epoll_cnt; i++) {
		pthread_mutex_destroy(&epoll_mutexes[i]);
	}
	delete[] epoll_mutexes;
	for (int i = 0; i < epoll_cnt; i++) {
		delete[] epoll_ready_events[i];
	}
	delete[] epoll_ready_events;
	pthread_mutex_destroy(&epoll_idx_mutex);
	pthread_mutex_destroy(&conn_mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2d7b
movq -0x18(%rbp), %rdi
callq 0x22a0
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2d99
movq -0x28(%rbp), %rdi
callq 0x22a0
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2db7
movq -0x30(%rbp), %rdi
callq 0x22a0
movq -0x20(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2dd5
movq -0x38(%rbp), %rdi
callq 0x22a0
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x2e0b
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x2250
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ddc
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x2e26
movq -0x40(%rbp), %rdi
callq 0x22a0
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x2e6c
movq -0x20(%rbp), %rax
movq 0x80(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x2e5f
movq -0x48(%rbp), %rdi
callq 0x22a0
jmp 0x2e61
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2e2d
movq -0x20(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x2e8a
movq -0x50(%rbp), %rdi
callq 0x22a0
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
callq 0x2250
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x2250
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: SeTriones[P]Anubis/acceptor.cpp
// Function: acceptor::recycle_fd(int, int)
int acceptor::recycle_fd(int fd, int epoll_idx) {
	if (epoll_idx < 0 || epoll_idx >= epoll_cnt) {
		_ERROR("err epollidx=%d", epoll_idx);
		return -1;
	}
	return add_input_fd(fd, epoll_fds[epoll_idx]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x2ee3
movq -0x80(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4(%rcx), %eax
jl 0x2f69
leaq -0x20(%rbp), %rdi
callq 0x21e0
leaq -0x20(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2120
leaq -0x70(%rbp), %rdi
movl $0x12, %esi
leaq 0x60fb(%rip), %rdx      # 0x9004
leaq -0x58(%rbp), %rcx
callq 0x2190
movq 0xa0bf(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
callq 0x21c0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rdx
movq %rax, %rcx
movl -0x18(%rbp), %r9d
leaq 0x60f6(%rip), %rsi      # 0x9045
leaq 0x6225(%rip), %r8       # 0x917b
movb $0x0, %al
callq 0x2310
movl %eax, -0x74(%rbp)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f83
movq -0x80(%rbp), %rdi
movl -0x14(%rbp), %esi
movq 0x10(%rdi), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
callq 0x2f90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop
// File: SeTriones[P]Anubis/acceptor.cpp
// Function: acceptor::add_input_fd(int, int)
int acceptor::add_input_fd(int fd, int efd) {
	epoll_event event;
	event.events = EPOLLIN | EPOLLET;
	event.data.fd = fd;
	int ret = epoll_ctl(efd, EPOLL_CTL_ADD, fd, &event);
	if (ret < 0) {
		_ERROR("add_input_fd err,fd=%d,errno=%d", fd, errno);
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x80000001, -0x1c(%rbp) # imm = 0x80000001
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %edx
movl $0x1, %esi
leaq -0x1c(%rbp), %rcx
callq 0x2300
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x3074
leaq -0x28(%rbp), %rdi
callq 0x21e0
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2120
leaq -0x80(%rbp), %rdi
movl $0x12, %esi
leaq 0x600b(%rip), %rdx      # 0x9004
leaq -0x60(%rbp), %rcx
callq 0x2190
movq 0x9fcf(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x21c0
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x88(%rbp)
callq 0x2040
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rdx
movq -0x90(%rbp), %rcx
movl -0x88(%rbp), %r9d
movl (%rax), %eax
leaq 0x6041(%rip), %rsi      # 0x909e
leaq 0x6117(%rip), %r8       # 0x917b
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2310
movl %eax, -0x84(%rbp)
movl -0x20(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: SeTriones[P]Anubis/acceptor.cpp
// Function: acceptor::close_fd(int)
int acceptor::close_fd(int fd) {
	int tmp;
	pthread_mutex_lock(&conn_mutex);
	conn_num--;
	tmp = conn_num;
	pthread_mutex_unlock(&conn_mutex);
	_INFO("close fd=%d, conn_num=%d", fd, tmp);
	return close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x30, %rdi
callq 0x2340
movq -0x90(%rbp), %rdi
movl 0x1c(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x1c(%rdi)
movl 0x1c(%rdi), %eax
movl %eax, -0x10(%rbp)
addq $0x30, %rdi
callq 0x2170
leaq -0x18(%rbp), %rdi
callq 0x21e0
leaq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2120
leaq -0x70(%rbp), %rdi
movl $0x12, %esi
leaq 0x5f19(%rip), %rdx      # 0x9004
leaq -0x50(%rbp), %rcx
callq 0x2190
movq 0x9edd(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0x88(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x21c0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rdx
movq %rax, %rcx
movl -0xc(%rbp), %r9d
movl -0x10(%rbp), %eax
leaq 0x5f3f(%rip), %rsi      # 0x906d
leaq 0x6046(%rip), %r8       # 0x917b
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2310
movl %eax, -0x74(%rbp)
movl -0xc(%rbp), %edi
callq 0x2420
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: SeTriones[P]Anubis/acceptor.cpp
// Function: acceptor::create_listen(int&, unsigned short)
int acceptor::create_listen(int &socket_fd, unsigned short port) {
	sockaddr_in addr;
	memset(&addr, 0, sizeof addr);
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = INADDR_ANY;
	addr.sin_port = htons(port);

	if ((socket_fd = socket(PF_INET, SOCK_STREAM, 0)) == -1)
		return -1;
	if (set_socket(socket_fd, O_NONBLOCK))
		return -1;
	if (::bind(socket_fd, (const sockaddr*)&addr, sizeof addr))
		return -1;
	if (listen(socket_fd, max_conn))
		return -1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2130
movw $0x2, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
movzwl -0x1a(%rbp), %edi
callq 0x2050
movw %ax, -0x2a(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x20a0
movq -0x18(%rbp), %rcx
movl %eax, (%rcx)
cmpl $-0x1, %eax
jne 0x31ce
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3238
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl $0x800, %edx            # imm = 0x800
callq 0x3250
cmpl $0x0, %eax
je 0x31f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3238
movq -0x18(%rbp), %rax
movl (%rax), %edi
leaq -0x2c(%rbp), %rsi
movl $0x10, %edx
callq 0x2080
cmpl $0x0, %eax
je 0x3212
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3238
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edi
movl (%rax), %esi
callq 0x2230
cmpl $0x0, %eax
je 0x3231
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3238
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: SeTriones[P]Anubis/acceptor.cpp
// Function: acceptor::set_socket(int, int)
int acceptor::set_socket(int fd, int flag) {
	int options;
	options = SOCKET_SND_BUF_SIZE;
	setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &options, sizeof(int));
	options = SOCKET_RCV_BUF_SIZE;
	setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &options, sizeof(int));
	options = 1;
	setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &options, sizeof(int));
	options = fcntl(fd, F_GETFL);
	fcntl(fd, F_SETFL, options | flag);
	int on = 1;
	int ret = -1;
	ret = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&on, sizeof(on));
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x100000, -0x14(%rbp)  # imm = 0x100000
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0x7, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x23e0
movl $0x100000, -0x14(%rbp)  # imm = 0x100000
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0x8, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x23e0
movl $0x1, -0x14(%rbp)
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x23e0
movl -0xc(%rbp), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x2140
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %edx
orl -0x10(%rbp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x2140
movl $0x1, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x23e0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SeTriones[P]Anubis/acceptor.cpp
// Function: acceptor::del_input_fd(int, int)
int acceptor::del_input_fd(int fd, int efd) {
	epoll_event event;
	event.events = EPOLLIN | EPOLLET;
	event.data.fd = fd;
	int ret = epoll_ctl(efd, EPOLL_CTL_DEL, fd, &event);
	if (ret < 0) {
		_ERROR("del_input_fd err,fd=%d,errno=%d", fd, errno);
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x80000001, -0x1c(%rbp) # imm = 0x80000001
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %edx
movl $0x2, %esi
leaq -0x1c(%rbp), %rcx
callq 0x2300
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x3414
leaq -0x28(%rbp), %rdi
callq 0x21e0
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2120
leaq -0x80(%rbp), %rdi
movl $0x12, %esi
leaq 0x5c6b(%rip), %rdx      # 0x9004
leaq -0x60(%rbp), %rcx
callq 0x2190
movq 0x9c2f(%rip), %rax      # 0xcfd8
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x21c0
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x88(%rbp)
callq 0x2040
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rdx
movq -0x90(%rbp), %rcx
movl -0x88(%rbp), %r9d
movl (%rax), %eax
leaq 0x5cd9(%rip), %rsi      # 0x90d6
leaq 0x5d77(%rip), %r8       # 0x917b
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2310
movl %eax, -0x84(%rbp)
movl -0x20(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: SeTriones[P]Anubis/acceptor.cpp
// Function: acceptor::create_pipe(int)
int acceptor::create_pipe(int idx) {
	int options;
	int pipe_fd[2];
	
	if (pipe(pipe_fd)) {
		return -1;
	}

	pipe_read_fds[idx] = pipe_fd[0];
	pipe_write_fds[idx] = pipe_fd[1];

	for (int i = 0;i < 2;i++) {
		if ((options = fcntl(pipe_fd[i], F_GETFL)) == -1) {
			return -1;
		}
		if (fcntl(pipe_fd[i], F_SETFL, options | O_NONBLOCK) == -1) {
			return -1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x22e0
cmpl $0x0, %eax
je 0x3471
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3508
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %esi
movq 0x90(%rax), %rcx
movslq -0x14(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movl -0x1c(%rbp), %edx
movq 0x98(%rax), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jge 0x3501
movslq -0x24(%rbp), %rax
movl -0x20(%rbp,%rax,4), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x2140
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x34c9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3508
movslq -0x24(%rbp), %rax
movl -0x20(%rbp,%rax,4), %edi
movl -0x18(%rbp), %edx
orl $0x800, %edx            # imm = 0x800
movl $0x4, %esi
movb $0x0, %al
callq 0x2140
cmpl $-0x1, %eax
jne 0x34f4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3508
jmp 0x34f6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x349e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: SeTriones[P]Anubis/base_nio_handler.cpp
// Function: base_nio_handler::readn_timeout(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
int base_nio_handler::readn_timeout(int fd, std::string &content, int buf_len) {
    char buf[READ_BUF_SIZE+1];
    timeval timeout = {
        0,
        recv_timeout * 1000
    };
    int n,len;
    int left = buf_len;

    while (left > 0)
    {
        len = left>READ_BUF_SIZE?READ_BUF_SIZE:left;
        if ((n = read_data(fd, buf, len,&timeout)) <= 0)
            return buf_len - left;

        buf[n] = '\0';
        content += buf;
        left -= n;
    }

    return buf_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x458(%rbp)
movq $0x0, -0x440(%rbp)
imull $0x3e8, (%rax), %eax    # imm = 0x3E8
cltq
movq %rax, -0x438(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x44c(%rbp)
cmpl $0x0, -0x44c(%rbp)
jle 0x3619
cmpl $0x400, -0x44c(%rbp)    # imm = 0x400
jle 0x358d
movl $0x400, %eax            # imm = 0x400
movl %eax, -0x45c(%rbp)
jmp 0x3599
movl -0x44c(%rbp), %eax
movl %eax, -0x45c(%rbp)
movq -0x458(%rbp), %rdi
movl -0x45c(%rbp), %eax
movl %eax, -0x448(%rbp)
movl -0x14(%rbp), %esi
leaq -0x430(%rbp), %rdx
movl -0x448(%rbp), %ecx
leaq -0x440(%rbp), %r8
callq 0x3630
movl %eax, -0x444(%rbp)
cmpl $0x0, %eax
jg 0x35e1
movl -0x24(%rbp), %eax
subl -0x44c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x361f
movslq -0x444(%rbp), %rax
movb $0x0, -0x430(%rbp,%rax)
leaq -0x430(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x21f0
movl -0x444(%rbp), %ecx
movl -0x44c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x44c(%rbp)
jmp 0x3567
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nopl (%rax,%rax)