LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Thilotilo[P]DoaERando/NPCManipulator.cpp
// Function: DoaERando::NPCManipulator::ReplacePangTong(unsigned char)
void NPCManipulator::ReplacePangTong(BYTE generalId)
{
    // Set the flags for the new general after the "Pang Tong went out
    // with his soldiers" Text
    myRom.WriteByte(0x36EAF, generalId);
    // Read the new general's recruitment flags, which are used to determine
    // whether to launch the battle.
    myRom.WriteByte(0x3B3C5, generalId);
    // Actual replacement for who joined our army after the battle
    myRom.WriteByte(0x36ECC, generalId);
    // Text replace for Pang Tong went out with his soldiers
    myRom.WriteByte(0x2EA09, generalId);
    // Text replace for Pang Tong joined our army
    myRom.WriteByte(0x2EA62, generalId);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
movl $0x36eaf, %esi          # imm = 0x36EAF
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x3b3c5, %esi          # imm = 0x3B3C5
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x36ecc, %esi          # imm = 0x36ECC
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2ea09, %esi          # imm = 0x2EA09
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2ea62, %esi          # imm = 0x2EA62
movzbl -0x9(%rbp), %edx
callq 0x404c20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Thilotilo[P]DoaERando/NPCManipulator.cpp
// Function: DoaERando::NPCManipulator::ReplaceZhugeLiang(unsigned char)
void NPCManipulator::ReplaceZhugeLiang(BYTE generalId)
{
    // Replace 2 versions of Zhuge Liang in his house.
    // This is the lying down version
    myRom.WriteByte(0x312C5, generalId);
    // This is the standing up version
    myRom.WriteByte(0x312D3, generalId);
    // Replace Zhuge Liang in Gui Yang
    myRom.WriteByte(0x31343, generalId);
    // Text replace for "X is sleeping"
    myRom.WriteByte(0x2B9B2, generalId);
    // Text replace for "My brother X is not home"
    myRom.WriteByte(0x2B8F7, generalId);
    // Text replace for "X has joined them!"
    myRom.WriteByte(0x2BAE5, generalId);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
movl $0x312c5, %esi          # imm = 0x312C5
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x312d3, %esi          # imm = 0x312D3
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x31343, %esi          # imm = 0x31343
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2b9b2, %esi          # imm = 0x2B9B2
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2b8f7, %esi          # imm = 0x2B8F7
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2bae5, %esi          # imm = 0x2BAE5
movzbl -0x9(%rbp), %edx
callq 0x404c20
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Thilotilo[P]DoaERando/NPCManipulator.cpp
// Function: DoaERando::NPCManipulator::ReplaceXuZheBridgeTrigger(unsigned char)
void NPCManipulator::ReplaceXuZheBridgeTrigger(BYTE generalId)
{
    // Replace the general that the bridge lady looks for
    myRom.WriteByte(0x3684F, generalId);

    // Xu Zhe, my love, where are you?
    myRom.WriteByte(0x2AF53, generalId); // Replace Id
    myRom.WriteByte(0x2AF55, 0xE0); // newline in case of long name

    // Xu Zhe!  Oh, I'm blocking the bridge...
    myRom.WriteByte(0x2AF65, generalId); // Replace ID
    // Adjust text to protect against long names.
    myRom.WriteByte(0x2AF67, 0xFB);
    myRom.WriteByte(0x2AF68, 0x18);
    myRom.WriteByte(0x2AF69, 0x0A);
    myRom.WriteByte(0x2AF6A, 0x30);
    myRom.WriteByte(0x2AF6B, 0x3C);
    myRom.WriteByte(0x2AF6C, 0x8E);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
movl $0x3684f, %esi          # imm = 0x3684F
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2af53, %esi          # imm = 0x2AF53
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2af55, %esi          # imm = 0x2AF55
movl $0xe0, %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2af65, %esi          # imm = 0x2AF65
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2af67, %esi          # imm = 0x2AF67
movl $0xfb, %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2af68, %esi          # imm = 0x2AF68
movl $0x18, %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2af69, %esi          # imm = 0x2AF69
movl $0xa, %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2af6a, %esi          # imm = 0x2AF6A
movl $0x30, %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2af6b, %esi          # imm = 0x2AF6B
movl $0x3c, %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x2af6c, %esi          # imm = 0x2AF6C
movl $0x8e, %edx
callq 0x404c20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Thilotilo[P]DoaERando/NPCManipulator.cpp
// Function: DoaERando::NPCManipulator::ReplaceMaYuanyi(unsigned char)
void NPCManipulator::ReplaceMaYuanyi(BYTE generalId)
{
    // Replace the actual NPC
    myRom.WriteByte(0x31A73, generalId);
    // This requires a bit of explanation.  There are 2 bits that can tell the NPC to
    // use text 2 instead of text 1.  One of those bits is set when the yellow scarves
    // are defeated, the other is set when Ma Yuanyi is defeated.  It doesn't matter
    // if one or both are set - as long as both aren't clear, we will move to text 2.
    // EXCEPT we can actually move one id past text 2 if both bits are set AND bit 6 of
    // the YZone is set.  Thus, we swizzle this a bit so that both of Ma Yuanyi's texts
    // are the battle text (the textId + 1 is the text we get on future interactions), and
    // then set both bits when the battle is complete.  This way, we can't lock the battle
    // out when we clear the yellow scarves.  (Note that this will go ahead and change the
    // other NPCs in Qing Zhou texts, but those aren't really relevant any more anyway)
    myRom.WriteByte(0x31A6E, 0xCB); // Set bit 6 of YZone
    myRom.WriteByte(0x31A72, 0xAB); // Set text 2 to the battle text
    myRom.WriteByte(0x3B076, 0x83); // Set bit 7 & bit 0 of the location flags
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
movl $0x31a73, %esi          # imm = 0x31A73
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x31a6e, %esi          # imm = 0x31A6E
movl $0xcb, %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x31a72, %esi          # imm = 0x31A72
movl $0xab, %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x3b076, %esi          # imm = 0x3B076
movl $0x83, %edx
callq 0x404c20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Thilotilo[P]DoaERando/NPCManipulator.cpp
// Function: DoaERando::NPCManipulator::ReplaceYuanShang(unsigned char)
void NPCManipulator::ReplaceYuanShang(BYTE generalId)
{
    // Replace the actual NPC
    myRom.WriteByte(0x317C3, generalId);
    myRom.WriteByte(0x3695A, generalId);
    // Set the correct general's flags to 0x90 (recruitable & encounterable)
    // rather than setting Yuan Shang's flags to 00 after defeating the
    // Yuan Shang battle.
    myRom.WriteByte(0x3693A, 0x90);
    myRom.WriteByte(0x3693C, generalId);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
movl $0x317c3, %esi          # imm = 0x317C3
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x3695a, %esi          # imm = 0x3695A
movzbl -0x9(%rbp), %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x3693a, %esi          # imm = 0x3693A
movl $0x90, %edx
callq 0x404c20
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x3693c, %esi          # imm = 0x3693C
movzbl -0x9(%rbp), %edx
callq 0x404c20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Assembler.cpp
// Function: Assembler::get_endianess()
enum Assembler::endianess Assembler::get_endianess()
{
    unsigned int a = 1;

    char *ptr = (char *) &a;

    if(*ptr==1)
        return lil_endian;
    
    else
        return big_endian;
}

// Assembly:
movl $0x1, -0x8(%rsp)
leaq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x1, %eax
jne 0x6049
movl $0x0, -0x4(%rsp)
jmp 0x6051
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Assembler.cpp
// Function: Assembler::str_to_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
int Assembler::str_to_int(string &num) const
{
    istringstream iss(num);

    int a = 0;

    string::iterator it=num.begin();
    
    if(*it=='+' || *it=='-')
        ++it;
    

    if(*it=='0')    // oct or hex
    {
        ++it;

        if(it==num.end())
            return 0;

        if(*it=='x' || *it=='X')
            iss>>hex>>a;
            

        else
            iss>>oct>>a;
        
    }

    else        // normal decimal
        iss>>a;


    iss>>dec;
    return a;
}

// Assembly:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x1c8(%rsp)
movq %rsi, 0x1c0(%rsp)
movq 0x1c0(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl $0x8, %edx
callq 0x3480
movl $0x0, 0x3c(%rsp)
movq 0x1c0(%rsp), %rdi
callq 0x3220
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xc1d0
movsbl (%rax), %eax
cmpl $0x2b, %eax
je 0x631c
leaq 0x30(%rsp), %rdi
callq 0xc1d0
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x6326
leaq 0x30(%rsp), %rdi
callq 0xc1e0
leaq 0x30(%rsp), %rdi
callq 0xc1d0
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x6419
leaq 0x30(%rsp), %rdi
callq 0xc1e0
movq 0x1c0(%rsp), %rdi
callq 0x3150
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc200
testb $0x1, %al
jne 0x636d
jmp 0x6385
movl $0x0, 0x1d4(%rsp)
movl $0x1, 0x24(%rsp)
jmp 0x6452
leaq 0x30(%rsp), %rdi
callq 0xc1d0
movsbl (%rax), %eax
cmpl $0x78, %eax
je 0x63a9
leaq 0x30(%rsp), %rdi
callq 0xc1d0
movsbl (%rax), %eax
cmpl $0x58, %eax
jne 0x63ee
leaq 0x5e90(%rip), %rsi      # 0xc240
leaq 0x40(%rsp), %rdi
callq 0x3470
movq %rax, 0x8(%rsp)
jmp 0x63c1
movq 0x8(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x3170
jmp 0x63d2
jmp 0x6417
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3140
jmp 0x646b
leaq 0x5e6b(%rip), %rsi      # 0xc260
leaq 0x40(%rsp), %rdi
callq 0x3470
movq %rax, (%rsp)
jmp 0x6405
movq (%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x3170
jmp 0x6415
jmp 0x6417
jmp 0x642c
leaq 0x40(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x3170
jmp 0x642a
jmp 0x642c
leaq 0x5e4d(%rip), %rsi      # 0xc280
leaq 0x40(%rsp), %rdi
callq 0x3470
jmp 0x643f
movl 0x3c(%rsp), %eax
movl %eax, 0x1d4(%rsp)
movl $0x1, 0x24(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3140
movl 0x1d4(%rsp), %eax
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x18(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Assembler.cpp
// Function: Assembler::assemble()
void Assembler::assemble()
{   
    if(assembled==true)
        return;

    lines.clear();
    aux_lines.clear();
    errors.clear();
    warnings.clear();
    reset_pc();
    reset_data_addr();
    reset_line_cnt();

    first_pass();

    second_pass();

    generate_warnings();
    
    if(errors.empty())
    {
        generate_object_file();
        assembled = true;
    }

    if(!warnings.empty())
        warn = true;

    return ;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x128(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x64a8
jmp 0x6572
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0xc2a0
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
callq 0xc2a0
movq 0x8(%rsp), %rdi
addq $0xc8, %rdi
callq 0xc2d0
movq 0x8(%rsp), %rdi
addq $0xf8, %rdi
callq 0xc2e0
movq 0x8(%rsp), %rdi
callq 0xc2f0
movq 0x8(%rsp), %rdi
callq 0xc310
movq 0x8(%rsp), %rdi
callq 0xc330
movq 0x8(%rsp), %rdi
callq 0x6580
movq 0x8(%rsp), %rdi
callq 0x67e0
movq 0x8(%rsp), %rdi
callq 0x6bb0
movq 0x8(%rsp), %rdi
addq $0xc8, %rdi
callq 0xc350
testb $0x1, %al
jne 0x6539
jmp 0x654f
movq 0x8(%rsp), %rdi
callq 0x6d30
movq 0x8(%rsp), %rax
movb $0x1, 0x128(%rax)
movq 0x8(%rsp), %rdi
addq $0xf8, %rdi
callq 0xc370
testb $0x1, %al
jne 0x6570
movq 0x8(%rsp), %rax
movb $0x1, 0x129(%rax)
jmp 0x6572
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Assembler.cpp
// Function: Assembler::first_pass()
void Assembler::first_pass()
{
    string s;

    while(getline(src, s))
    {
        ++line_cnt;

        string::iterator it = s.begin();

        while(it!=s.end() && *it <= 32)     // remove leading whitespace
            ++it;
        
        string::iterator jt=it;

        while(jt!=s.end() && *jt!=';')      // remove comment part
            ++jt;

                                // removing trailing spaces -> NO NEED
        string tmp(it, jt);

        if(tmp.size()>0)    // put the non-empty line in the list
        {
            analyze(tmp);
        }

    }

    return ;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x33e0
movq 0x20(%rsp), %rax
movq 0xa0(%rax), %rdi
leaq 0x90(%rsp), %rsi
callq 0x3080
movq %rax, 0x18(%rsp)
jmp 0x65c9
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3390
movb %al, 0x17(%rsp)
jmp 0x65e3
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x65f0
jmp 0x67ad
movq 0x20(%rsp), %rax
movl 0x98(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x98(%rax)
leaq 0x90(%rsp), %rdi
callq 0x3220
movq %rax, 0x78(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x3150
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xc390
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x16(%rsp)
jne 0x6646
jmp 0x665d
leaq 0x78(%rsp), %rdi
callq 0xc1d0
movsbl (%rax), %eax
cmpl $0x20, %eax
setle %al
movb %al, 0x16(%rsp)
movb 0x16(%rsp), %al
testb $0x1, %al
jne 0x6667
jmp 0x668c
leaq 0x78(%rsp), %rdi
callq 0xc1e0
jmp 0x6616
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x67c2
movq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x3150
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xc390
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x15(%rsp)
jne 0x66c6
jmp 0x66dd
leaq 0x68(%rsp), %rdi
callq 0xc1d0
movsbl (%rax), %eax
cmpl $0x3b, %eax
setne %al
movb %al, 0x15(%rsp)
movb 0x15(%rsp), %al
testb $0x1, %al
jne 0x66e7
jmp 0x66f3
leaq 0x68(%rsp), %rdi
callq 0xc1e0
jmp 0x6696
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x34a0
movq 0x8(%rsp), %rcx
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0xc3d0
jmp 0x6731
leaq 0x2f(%rsp), %rdi
callq 0x32f0
leaq 0x40(%rsp), %rdi
callq 0x31d0
cmpq $0x0, %rax
jbe 0x679e
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7120
jmp 0x675c
jmp 0x679e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x32f0
jmp 0x67c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3180
jmp 0x67c2
leaq 0x40(%rsp), %rdi
callq 0x3180
jmp 0x65a9
leaq 0x90(%rsp), %rdi
callq 0x3180
addq $0xb8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0x3180
movq 0x88(%rsp), %rdi
callq 0x3490
nopl (%rax)
// File: saumya-prakash[P]AssemblerEmulator/Assembler.cpp
// Function: Assembler::insert_into_symtab(label&)
void Assembler::insert_into_symtab(struct label& l)
{
    if(symtab.find(l.name)!=symtab.end())
    {
        errors.insert({line_cnt, Error(7)});
    }

    else
    {
        symtab[l.name] = l;
    }
    
    return;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0xa8(%rsp), %rsi
callq 0xcb70
movq 0x30(%rsp), %rdi
movq %rax, 0xa0(%rsp)
callq 0xca60
movq %rax, 0x98(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xcc20
testb $0x1, %al
jne 0x92f9
jmp 0x93ac
movq 0x30(%rsp), %rax
movq %rax, %rcx
addq $0xc8, %rcx
movq %rcx, 0x18(%rsp)
addq $0x98, %rax
movq %rax, 0x20(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x7, %esi
callq 0xc550
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0xc590
jmp 0x9342
movq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xc520
movq %rax, 0x10(%rsp)
jmp 0x9358
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x5cb0
leaq 0x50(%rsp), %rdi
callq 0x5cd0
jmp 0x93d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x93a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x5cb0
leaq 0x50(%rsp), %rdi
callq 0x5cd0
jmp 0x93e0
movq 0x30(%rsp), %rdi
movq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xa8(%rsp), %rsi
callq 0xcc40
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xcd30
addq $0xb8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x3490
nopw (%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Assembler.cpp
// Function: Assembler::encode_zeroth(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int const&, unsigned int const&)
unsigned Assembler::encode_zeroth(const string& s, const unsigned& opcode, const unsigned& line_no)
{
    istringstream iss(s);
    string t;

    iss>>t;     // 'dump' mnemonic

    string more;
    iss>>more;

    if(!more.empty())   // more operands than required
    {
        errors.insert({line_no, Error(6)});
        return 0xffffffff;
    }

    return opcode;
}

// Assembly:
subq $0x288, %rsp            # imm = 0x288
movq %rdi, 0x278(%rsp)
movq %rsi, 0x270(%rsp)
movq %rdx, 0x268(%rsp)
movq %rcx, 0x260(%rsp)
movq 0x278(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x270(%rsp), %rsi
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x8, %edx
callq 0x3480
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x33e0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x33a0
jmp 0x9466
leaq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x33e0
movq 0x18(%rsp), %rsi
leaq 0xe0(%rsp), %rdi
callq 0x33a0
jmp 0x948c
leaq 0x90(%rsp), %rdi
callq 0x3460
testb $0x1, %al
jne 0x95a1
movq 0x20(%rsp), %rax
addq $0xc8, %rax
movq %rax, 0x8(%rsp)
movq 0x260(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x6, %esi
callq 0xc550
jmp 0x94cf
movq 0x10(%rsp), %rsi
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0xcb30
jmp 0x94e5
movq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xc520
movq %rax, (%rsp)
jmp 0x94fa
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x5cb0
leaq 0x48(%rsp), %rdi
callq 0x5cd0
movl $0xffffffff, 0x284(%rsp) # imm = 0xFFFFFFFF
movl $0x1, 0x3c(%rsp)
jmp 0x95ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x95fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x95f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x9595
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x5cb0
leaq 0x48(%rsp), %rdi
callq 0x5cd0
jmp 0x95f0
movq 0x268(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x284(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x3180
leaq 0xc0(%rsp), %rdi
callq 0x3180
leaq 0xe0(%rsp), %rdi
callq 0x3140
movl 0x284(%rsp), %eax
addq $0x288, %rsp            # imm = 0x288
retq
leaq 0x90(%rsp), %rdi
callq 0x3180
leaq 0xc0(%rsp), %rdi
callq 0x3180
leaq 0xe0(%rsp), %rdi
callq 0x3140
movq 0xb8(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Assembler.cpp
// Function: only_label(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool only_label(const string& s)
{
    string::const_iterator it = s.begin();

    while(it!=s.end() && *it!=':')
        ++it;
    
    if(it==s.end())
        return false;
    
    it++;           // ':' found -> move one ahead
    while(it!=s.end())  
    {
        if(*it>32)
            return false;
        
        it++;
    }

    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3260
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x34c0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xc190
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x9ef5
jmp 0x9f0c
leaq 0x30(%rsp), %rdi
callq 0xc0e0
movsbl (%rax), %eax
cmpl $0x3a, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x9f16
jmp 0x9f22
leaq 0x30(%rsp), %rdi
callq 0xc0f0
jmp 0x9ec8
movq 0x38(%rsp), %rdi
callq 0x34c0
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc110
testb $0x1, %al
jne 0x9f46
jmp 0x9f4d
movb $0x0, 0x47(%rsp)
jmp 0x9fb3
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0xc150
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x34c0
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc190
testb $0x1, %al
jne 0x9f82
jmp 0x9fae
leaq 0x30(%rsp), %rdi
callq 0xc0e0
movsbl (%rax), %eax
cmpl $0x20, %eax
jle 0x9f9b
movb $0x0, 0x47(%rsp)
jmp 0x9fb3
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0xc150
movq %rax, 0x8(%rsp)
jmp 0x9f5e
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: saumya-prakash[P]AssemblerEmulator/Assembler.cpp
// Function: Assembler::print_bytes(std::ostream&, unsigned int) const
void Assembler::print_bytes(ostream& os, unsigned a) const
{
    char *ptr = (char *) &a;

    if(machine_type==lil_endian)     // reverse bytes
    {
        ptr += 3;

        os.write(ptr, 1);

        ptr--;
        os.write(ptr, 1);

        ptr--;
        os.write(ptr, 1);

        ptr--;
        os.write(ptr, 1);    
    }

    else        // no need to reverse bytes
    {
        os.write(ptr, 1);

        ptr++;
        os.write(ptr, 1);

        ptr++;
        os.write(ptr, 1);

        ptr++;
        os.write(ptr, 1);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
leaq 0x14(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x11175(%rip)     # 0x1c338
jne 0xb253
movq 0x8(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x33c0
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x33c0
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x33c0
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x33c0
jmp 0xb2cd
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x33c0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x33c0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x33c0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x33c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Assembler.cpp
// Function: Assembler::print_errors(std::ostream&) const
void Assembler::print_errors(ostream &os) const
{
    for(map<unsigned, class Error>::const_iterator it=errors.begin(); it!=errors.end(); ++it)
    {
        unsigned line_no = it->first;

        class Error tmp = it->second;

        os<<"Line "<<line_no<<": "<<tmp.message<<endl;
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0xc8, %rdi
callq 0xcfa0
movq %rax, 0x70(%rsp)
movq 0x28(%rsp), %rdi
addq $0xc8, %rdi
callq 0xcff0
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xcfd0
testb $0x1, %al
jne 0xb520
jmp 0xb5ef
leaq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd020
movq 0x18(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x64(%rsp)
callq 0xd020
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x40(%rsp), %rdi
callq 0xd210
movq 0x78(%rsp), %rdi
leaq 0x8cb9(%rip), %rsi      # 0x14215
callq 0x3270
movq %rax, 0x20(%rsp)
jmp 0xb568
movq 0x20(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x33d0
movq %rax, 0x10(%rsp)
jmp 0xb57d
movq 0x10(%rsp), %rdi
leaq 0x8adf(%rip), %rsi      # 0x14068
callq 0x3270
movq %rax, 0x8(%rsp)
jmp 0xb595
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3240
movq %rax, (%rsp)
jmp 0xb5aa
movq (%rsp), %rdi
movq 0x10a13(%rip), %rsi     # 0x1bfc8
callq 0x32d0
jmp 0xb5bc
leaq 0x40(%rsp), %rdi
callq 0x5cd0
leaq 0x70(%rsp), %rdi
callq 0xd040
jmp 0xb4f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5cd0
jmp 0xb5f7
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/Assembler.cpp
// Function: Assembler::print_symtab(std::ostream&) const
void Assembler::print_symtab(ostream& os) const
{
    for(map<string, struct label>::const_iterator it=symtab.begin(); it!=symtab.end(); ++it)
    {
        string name = it->first;
        struct label l = it->second;

        os<<name<<'\t'<<l.addr<<endl;
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xd240
movq %rax, 0x90(%rsp)
movq 0x20(%rsp), %rdi
callq 0xd270
movq %rax, 0x88(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xca40
testb $0x1, %al
jne 0xb671
jmp 0xb75c
leaq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xca90
movq %rax, %rsi
leaq 0x68(%rsp), %rdi
callq 0x3110
movq 0x18(%rsp), %rdi
callq 0xca90
movq %rax, %rsi
addq $0x20, %rsi
leaq 0x38(%rsp), %rdi
callq 0xd2a0
jmp 0xb6ad
movq 0x98(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x3240
movq %rax, 0x10(%rsp)
jmp 0xb6c6
movq 0x10(%rsp), %rdi
movl $0x9, %esi
callq 0x3360
movq %rax, 0x8(%rsp)
jmp 0xb6dc
movq 0x8(%rsp), %rdi
movl 0x58(%rsp), %esi
callq 0x33d0
movq %rax, (%rsp)
jmp 0xb6f0
movq (%rsp), %rdi
movq 0x108cd(%rip), %rsi     # 0x1bfc8
callq 0x32d0
jmp 0xb702
leaq 0x38(%rsp), %rdi
callq 0x5670
leaq 0x68(%rsp), %rdi
callq 0x3180
leaq 0x90(%rsp), %rdi
callq 0xcb00
jmp 0xb641
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xb750
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5670
leaq 0x68(%rsp), %rdi
callq 0x3180
jmp 0xb764
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x3490
nop
// File: saumya-prakash[P]AssemblerEmulator/Assembler.cpp
// Function: Assembler::print_warnings(std::ostream&) const
void Assembler::print_warnings(ostream& os) const
{
    for(map<unsigned, class Warning>::const_iterator it=warnings.begin(); it!=warnings.end(); ++it)
    {
        unsigned a = it->first;
        class Warning b = it->second;

        os<<"Line "<<a<<": "<<b.message<<endl;
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0xf8, %rdi
callq 0xd070
movq %rax, 0x70(%rsp)
movq 0x28(%rsp), %rdi
addq $0xf8, %rdi
callq 0xd0c0
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd0a0
testb $0x1, %al
jne 0xb7d0
jmp 0xb89f
leaq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd0f0
movq 0x18(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x64(%rsp)
callq 0xd0f0
movq %rax, %rsi
addq $0x8, %rsi
leaq 0x40(%rsp), %rdi
callq 0xd2e0
movq 0x78(%rsp), %rdi
leaq 0x8a09(%rip), %rsi      # 0x14215
callq 0x3270
movq %rax, 0x20(%rsp)
jmp 0xb818
movq 0x20(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x33d0
movq %rax, 0x10(%rsp)
jmp 0xb82d
movq 0x10(%rsp), %rdi
leaq 0x882f(%rip), %rsi      # 0x14068
callq 0x3270
movq %rax, 0x8(%rsp)
jmp 0xb845
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3240
movq %rax, (%rsp)
jmp 0xb85a
movq (%rsp), %rdi
movq 0x10763(%rip), %rsi     # 0x1bfc8
callq 0x32d0
jmp 0xb86c
leaq 0x40(%rsp), %rdi
callq 0x59b0
leaq 0x70(%rsp), %rdi
callq 0xd110
jmp 0xb7a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x59b0
jmp 0xb8a7
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: saumya-prakash[P]AssemblerEmulator/./Assembler.h
// Function: label::validate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string validate(const string &s)    // checks for valid label name
        {
            if(isalpha(s[0])==0)    // first character should be an alphabet
                return string();
                
            for(string::const_iterator it=s.begin(); it!=s.end(); ++it)     // should consist of only alpha-numerics
                if(*it<=32 || isalnum(*it)==0)
                    return string();

            return s;
        }

// Assembly:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3310
movsbl (%rax), %edi
callq 0x3440
cmpl $0x0, %eax
jne 0xda38
movq (%rsp), %rdi
callq 0x33e0
jmp 0xdabb
movq 0x20(%rsp), %rdi
callq 0x3260
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x34c0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc190
testb $0x1, %al
jne 0xda6b
jmp 0xdaad
leaq 0x18(%rsp), %rdi
callq 0xc0e0
movsbl (%rax), %eax
cmpl $0x20, %eax
jle 0xda94
leaq 0x18(%rsp), %rdi
callq 0xc0e0
movsbl (%rax), %edi
callq 0x32b0
cmpl $0x0, %eax
jne 0xda9f
movq (%rsp), %rdi
callq 0x33e0
jmp 0xdabb
jmp 0xdaa1
leaq 0x18(%rsp), %rdi
callq 0xc0f0
jmp 0xda47
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x3110
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::write_(char const*)
int dp830::write_(const char *command) {
    assert(fhandle_);
    int len = strlen(command);
    fhandle_.write(command,len);
    //printf("write: -->%s<--\n",command);
    fhandle_.flush();
    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2210
testb $0x1, %al
jne 0x269a
jmp 0x269c
jmp 0x26bb
leaq 0x296d(%rip), %rdi      # 0x5010
leaq 0x296f(%rip), %rsi      # 0x5019
movl $0x10, %edx
leaq 0x296d(%rip), %rcx      # 0x5023
callq 0x2120
movq -0x10(%rbp), %rdi
callq 0x20f0
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2220
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x2130
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::read_(char*, int)
int dp830::read_(char *buf, int len){
    assert(fhandle_);
    if (!buf) return 0;
    memset(buf,0,len);
    fhandle_.getline(buf,len);
    return fhandle_.gcount();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2210
testb $0x1, %al
jne 0x272d
jmp 0x272f
jmp 0x274e
leaq 0x28da(%rip), %rdi      # 0x5010
leaq 0x28dc(%rip), %rsi      # 0x5019
movl $0x19, %edx
leaq 0x28fa(%rip), %rcx      # 0x5043
callq 0x2120
cmpq $0x0, -0x18(%rbp)
jne 0x275e
movl $0x0, -0x4(%rbp)
jmp 0x278a
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
xorl %esi, %esi
callq 0x2100
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x20b0
movq -0x28(%rbp), %rdi
callq 0x2300
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::GetState(int)
int dp830::GetState(int channel){
    char buf[40];
    char buf2[40];
    snprintf(buf,sizeof(buf),":OUTP:STAT? CH%d",channel);
    write_(buf);
    read_(buf2,sizeof(buf2));
    return strcmp(buf2,"OFF")?1:0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x28, %esi
leaq 0x2894(%rip), %rdx      # 0x5061
movb $0x0, %al
callq 0x22a0
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2670
movq -0x78(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0x28, %edx
callq 0x2700
leaq -0x70(%rbp), %rdi
leaq 0x28aa(%rip), %rsi      # 0x50a8
callq 0x2230
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::On(int)
int dp830::On(int channel) {
    char buf[40];
    snprintf(buf,sizeof(buf),":SOUR%d:CURR:PROT:CLEAR",channel);
    write_(buf);
    snprintf(buf,sizeof(buf),":OUTP:STAT CH%d,ON",channel);
    return write_(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x28, %esi
leaq 0x2828(%rip), %rdx      # 0x5072
movb $0x0, %al
callq 0x22a0
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2670
leaq -0x40(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x28, %esi
leaq 0x2819(%rip), %rdx      # 0x508a
movb $0x0, %al
callq 0x22a0
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2670
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::AllOn()
int dp830::AllOn() {
    On(1);
    On(2);
    On(3);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x1, %esi
callq 0x2820
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x2820
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x2820
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::AllOff()
int dp830::AllOff() {
    Off(1);
    Off(2);
    Off(3);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x1, %esi
callq 0x28e0
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x28e0
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x28e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::SetOCP(int, double)
int dp830::SetOCP(int channel, double limit) {
    char buf[60];
    snprintf(buf,sizeof(buf),":SOUR%d:CURR:PROT:STAT ON",channel);
    write_(buf);
    snprintf(buf,sizeof(buf),":SOUR%d:CURR:PROT %6.3f",channel,limit);
    return write_(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x3c, %esi
leaq 0x263c(%rip), %rdx      # 0x50cb
movb $0x0, %al
callq 0x22a0
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2670
leaq -0x60(%rbp), %rdi
movl -0xc(%rbp), %ecx
movsd -0x18(%rbp), %xmm0
movl $0x3c, %esi
leaq 0x262a(%rip), %rdx      # 0x50e5
movb $0x1, %al
callq 0x22a0
movq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2670
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::GetOCP(int)
double dp830::GetOCP(int channel) {
    char buf[40];
    snprintf(buf,sizeof(buf),":SOUR%d:CURR:PROT?",channel);
    write_(buf);
    read_(buf,sizeof(buf));
    return std::stod(buf,NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %ecx
leaq 0x25f6(%rip), %rdx      # 0x50fd
xorl %eax, %eax
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl $0x28, %esi
callq 0x22a0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x2670
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movl $0x28, %edx
callq 0x2700
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x22d0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x30b0
jmp 0x2b6c
xorl %eax, %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
callq 0x3070
movsd %xmm0, -0x98(%rbp)
jmp 0x2b83
leaq -0x60(%rbp), %rdi
callq 0x2318
leaq -0x61(%rbp), %rdi
callq 0x21b0
movsd -0x98(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x2bc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2318
leaq -0x61(%rbp), %rdi
callq 0x21b0
movq -0x70(%rbp), %rdi
callq 0x22c0
nopl (%rax,%rax)
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::GetOCPTripped(int)
int dp830::GetOCPTripped(int channel) {
    char buf[40];
    snprintf(buf,sizeof(buf),":SOUR%d:CURR:PROT:TRIP?",channel);
    write_(buf);
    read_(buf,sizeof(buf));
    return (strcmp(buf,"YES")==0)?1:0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x28, %esi
leaq 0x2506(%rip), %rdx      # 0x5110
movb $0x0, %al
callq 0x22a0
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2670
movq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x28, %edx
callq 0x2700
leaq -0x40(%rbp), %rdi
leaq 0x24ed(%rip), %rsi      # 0x5128
callq 0x2230
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::GetSetPoint_(int, char const*)
double dp830::GetSetPoint_(int channel, const char *tag) {
    char buf[40];
    char buf2[40];
    snprintf(buf,sizeof(buf),":SOUR%d:%s?",channel,tag);
    write_(buf);
    read_(buf2,sizeof(buf2));
    return std::stod(buf2,NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %r8
leaq 0x249d(%rip), %rdx      # 0x512c
xorl %eax, %eax
leaq -0x40(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x28, %esi
callq 0x22a0
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x2670
movq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
movl $0x28, %edx
callq 0x2700
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x22d0
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x30b0
jmp 0x2d04
xorl %eax, %eax
movl %eax, %esi
leaq -0x90(%rbp), %rdi
callq 0x3070
movsd %xmm0, -0xd0(%rbp)
jmp 0x2d1e
leaq -0x90(%rbp), %rdi
callq 0x2318
leaq -0x91(%rbp), %rdi
callq 0x21b0
movsd -0xd0(%rbp), %xmm0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x2d79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2318
leaq -0x91(%rbp), %rdi
callq 0x21b0
movq -0xa0(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::Measure_(int, char const*)
double dp830::Measure_(int channel, const char *tag) {
    char buf[40];
    char buf2[40];
    snprintf(buf,sizeof(buf),":MEAS:%s? CH%d",tag,channel);
    write_(buf);
    read_(buf2,sizeof(buf2));
    return std::stod(buf2,NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %r8d
leaq 0x2308(%rip), %rdx      # 0x5138
xorl %eax, %eax
leaq -0x40(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
movl $0x28, %esi
callq 0x22a0
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x2670
movq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
movl $0x28, %edx
callq 0x2700
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x22d0
movq -0xb8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x30b0
jmp 0x2ea5
xorl %eax, %eax
movl %eax, %esi
leaq -0x90(%rbp), %rdi
callq 0x3070
movsd %xmm0, -0xd0(%rbp)
jmp 0x2ebf
leaq -0x90(%rbp), %rdi
callq 0x2318
leaq -0x91(%rbp), %rdi
callq 0x21b0
movsd -0xd0(%rbp), %xmm0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
jmp 0x2f1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2318
leaq -0x91(%rbp), %rdi
callq 0x21b0
movq -0xa0(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: hollanderic[P]dp832/dp832.cpp
// Function: dp830::Bounce(int, double)
int dp830::Bounce(int channel, double delay) {
    double volt = GetVoltageSetPoint(channel);
    SetVoltage(channel, 0.0);
    usleep(delay*1e6);
    SetVoltage(channel, volt);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %esi
callq 0x2da0
movq -0x28(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %esi
xorps %xmm0, %xmm0
callq 0x29e0
movsd -0x18(%rbp), %xmm0
movsd 0x1ff3(%rip), %xmm1     # 0x5008
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %edi
callq 0x2240
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movsd -0x20(%rbp), %xmm0
callq 0x29e0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: hollanderic[P]dp832/main.cpp
// Function: getDevicePathArg[abi:cxx11](int, char**)
const std::string getDevicePathArg(int argc, char** argv) {
    char opt;
    std::string result = kDefaultUSBDevicePath;
    while ((opt = getopt(argc, argv, kValidArgs.c_str())) >= 0) {
        if (opt == 'd') {
            result = string(optarg);
            break;
        }
    }

    // Reset option parser.
    optind = 1; 

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x1a(%rbp)
leaq 0x4c24(%rip), %rsi      # 0x81d0
callq 0x20e0
movl -0xc(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x4bea(%rip), %rdi      # 0x81b0
callq 0x20d0
movl -0x74(%rbp), %edi
movq -0x70(%rbp), %rsi
movq %rax, %rdx
callq 0x2090
movb %al, -0x19(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
jl 0x366c
movsbl -0x19(%rbp), %eax
cmpl $0x64, %eax
jne 0x3667
movq 0x49b7(%rip), %rax      # 0x7fb0
movq (%rax), %rax
movq %rax, -0x88(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x22d0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x30b0
jmp 0x3626
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x21f0
leaq -0x40(%rbp), %rdi
callq 0x2318
leaq -0x41(%rbp), %rdi
callq 0x21b0
jmp 0x366c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x21b0
movq -0x68(%rbp), %rdi
callq 0x2318
jmp 0x3699
jmp 0x35b1
movq 0x4965(%rip), %rax      # 0x7fd8
movl $0x1, (%rax)
movb $0x1, -0x1a(%rbp)
testb $0x1, -0x1a(%rbp)
jne 0x368c
movq -0x68(%rbp), %rdi
callq 0x2318
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: hollanderic[P]dp832/main.cpp
// Function: isExtraMode(int, char**)
bool isExtraMode(int argc, char** argv) {
    char opt;
    bool result = false;
    while ((opt = getopt(argc, argv, kValidArgs.c_str())) >= 0) {
        if (opt == 'x') {
            result = true;
            break;
        }
    }

    // Reset option parser.
    optind = 1; 

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x12(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x4ad8(%rip), %rdi      # 0x81b0
callq 0x20d0
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x2090
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
jl 0x3708
movsbl -0x11(%rbp), %eax
cmpl $0x78, %eax
jne 0x3706
movb $0x1, -0x12(%rbp)
jmp 0x3708
jmp 0x36c3
movq 0x48c9(%rip), %rax      # 0x7fd8
movl $0x1, (%rax)
movb -0x12(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: my_strcpy(char*, char const*, int)
int my_strcpy(char* to, const char* from, int max)/*{{{*/
/******************************************************************************
 * my modification of strcpy
 * copy max characters from "from" to "to", add NULL terminator automatically
 * updated 2008-04-23, memcpy win in speed when the copying string is long
 * updated 2011-10-27:
 *   since calling strlen will be time consuming for very large from string,
 *   e.g. when "from" is the buffer of a whole trunk of file. Therefore, strlen
 *   part is removed.
 *****************************************************************************/
{
    if(max < 200) {
        strncpy(to,from,max);
    } else {
        memcpy(to,from,max);
    }
    to[max] = '\0';
    return max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0xc8, -0x14(%rbp)
jge 0x285f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2120
jmp 0x2870
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x21c0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nanjiangshu[P]calSOV/calSOV.cpp
// Function: rootname(char const*, char*, int)
char *rootname(const char* filename, char* rtname, int max_rtname /*= MAX_PATH*/)/*{{{*/
/*****************************************************************************
 * rootname
 * given the file name, 
 * return the rootname of the filename
 ****************************************************************************/
{
    const char *pch;
    char *pstr;
    if((pch = strrchr(filename,'/')) != NULL)
        pstr = (char*) pch+1;
    else
        pstr = (char*) filename;

    if((pch = strrchr(pstr,'.')) != NULL)
        my_strcpy(rtname,pstr, min((int)(pch - pstr), max_rtname));
    else
        rtname = pstr;
    return rtname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x22a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x28c9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x28d1
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x2e, %esi
callq 0x22a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2925
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x7da0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl (%rax), %edx
callq 0x2830
jmp 0x292d
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)