LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ziang95[P]Tomasulo_simulator/instruction.cpp
// Function: instr_queue::ptr_branch(int)
bool instr_queue::ptr_branch(int offset)
{
    int dest = offset + head + 1;
    if (dest >= size || dest < 0)
    {
        err_log("Instr queue acccess out of range while branching");
        return false;
    }
    head = dest;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movl -0x14(%rbp), %eax
addl (%rcx), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x17932
cmpl $0x0, -0x18(%rbp)
jge 0x179a6
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4600
movq -0x60(%rbp), %rdx
leaq 0xac55(%rip), %rsi      # 0x2259f
leaq -0x38(%rbp), %rdi
callq 0x44c0
jmp 0x17955
leaq -0x38(%rbp), %rdi
callq 0x11880
jmp 0x17960
leaq -0x38(%rbp), %rdi
callq 0x4240
leaq -0x39(%rbp), %rdi
callq 0x43d0
movb $0x0, -0x1(%rbp)
jmp 0x179b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1799b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4240
leaq -0x39(%rbp), %rdi
callq 0x43d0
jmp 0x179be
movq -0x58(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x45f0
nopw (%rax,%rax)
// File: Ziang95[P]Tomasulo_simulator/issue.cpp
// Function: get_reg_or_rob(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&, memCell&)
void get_reg_or_rob(string regName, int &Q, memCell &V)
{
    auto found = RAT.find(regName);
    if (found != RAT.end())
    {
        int tmp = found->second;
        ROBEntry *R = CPU_ROB->get_entry(tmp);
        if (R->wrtnBack)
            V = R->value;
        else
            Q = tmp;
    }
    else
        reg->get(regName, V);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x70(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x182e0(%rip), %rdi     # 0x2fd58
callq 0xf1c0
movq %rax, -0x20(%rbp)
leaq 0x182d0(%rip), %rdi     # 0x2fd58
callq 0xf220
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xf1f0
testb $0x1, %al
jne 0x17aa4
jmp 0x17aed
leaq -0x20(%rbp), %rdi
callq 0xf250
movl 0x20(%rax), %eax
movl %eax, -0x2c(%rbp)
leaq 0x179a6(%rip), %rax     # 0x2f460
movq (%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0xe4d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x17ae2
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x48(%rcx), %ecx
movl %ecx, (%rax)
jmp 0x17aeb
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x17b41
movq -0x70(%rbp), %rsi
leaq 0x18298(%rip), %rax     # 0x2fd90
movq (%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4180
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x206c0
jmp 0x17b1f
leaq -0x58(%rbp), %rdi
callq 0x4240
jmp 0x17b41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4240
jmp 0x17b4a
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: Ziang95[P]Tomasulo_simulator/issue.cpp
// Function: check_squash()
bool check_squash()
{
    msg_log("Checking squash status", 4);
    if (brcUnit.squash_ROB_i() > -1)
    {
        pthread_mutex_lock(&squash_mutex);
        instr_Q->squash = true;
        pthread_cond_broadcast(&squash_cond);
        pthread_mutex_unlock(&squash_mutex);
        at_rising_edge(next_vdd);
        at_falling_edge(next_vdd);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4600
movq -0x48(%rbp), %rdx
leaq 0xaa7d(%rip), %rsi      # 0x225fd
leaq -0x28(%rbp), %rdi
callq 0x44c0
jmp 0x17b8b
leaq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0x12060
jmp 0x17b9b
leaq -0x28(%rbp), %rdi
callq 0x4240
leaq -0x29(%rbp), %rdi
callq 0x43d0
leaq 0x178d4(%rip), %rdi     # 0x2f488
callq 0x105f0
cmpl $-0x1, %eax
jle 0x17c3c
leaq 0x17853(%rip), %rdi     # 0x2f418
callq 0x4510
leaq 0x17887(%rip), %rax     # 0x2f458
movq (%rax), %rax
movb $0x1, 0x4(%rax)
leaq 0x17809(%rip), %rdi     # 0x2f3e8
callq 0x4130
leaq 0x1782d(%rip), %rdi     # 0x2f418
callq 0x42c0
leaq 0x17849(%rip), %rdi     # 0x2f440
callq 0x12130
leaq 0x1783d(%rip), %rdi     # 0x2f440
callq 0x121a0
movb $0x1, -0x1(%rbp)
jmp 0x17c40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x17c31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4240
leaq -0x29(%rbp), %rdi
callq 0x43d0
jmp 0x17c4b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: Ziang95[P]Tomasulo_simulator/memory.cpp
// Function: memory::memory(int)
memory::memory(int sz)
{
    buf = new memCell[sz];
    for (int i = 0; i < sz; i++)
        buf[i].f = 0.;
    size = sz;
    Lfront = Lrear = 0;
    Sfront = Srear = 0;
    LDQ_lock = SDQ_lock = PTHREAD_MUTEX_INITIALIZER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x1c, %rdi
callq 0x91d0
movslq -0xc(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1a4ac
movq -0x40(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a486
movq -0x40(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x14(%rax)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x41e0
movq -0x40(%rbp), %rdi
movl $0x0, -0x28(%rbp)
addq $0x58, %rdi
movq %rdi, -0x48(%rbp)
leaq -0x38(%rbp), %rsi
movl $0x28, %edx
callq 0x42f0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq $0x30, %rdi
movl $0x28, %edx
callq 0x42f0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: Ziang95[P]Tomasulo_simulator/memory.cpp
// Function: is_prev_index(int, int, int, int)
bool is_prev_index(int i, int j, int front, int rear)
{
    if (i == j) return false;
    if (rear < front)
    {
        rear += CPU_ROB->size;
        i += i<front?CPU_ROB->size:0;
        j += j<front?CPU_ROB->size:0;
    }
    return j - i > 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x1aee1
movb $0x0, -0x1(%rbp)
jmp 0x1af61
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1af50
leaq 0x14570(%rip), %rax     # 0x2f460
movq (%rax), %rax
movl 0x10(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1af16
leaq 0x14555(%rip), %rax     # 0x2f460
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0x1af1d
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x1af1d
movl -0x18(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x1af40
leaq 0x1452b(%rip), %rax     # 0x2f460
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1af47
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1af47
movl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl -0x8(%rbp), %eax
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: Ziang95[P]Tomasulo_simulator/memory.cpp
// Function: memory::LD_enQ(int, int)
LSQEntry* memory::LD_enQ(int rbi, int addr)
{
    pthread_mutex_lock(&LDQ_lock);
    if ((Lrear+1)%Q_LEN == Lfront)
    {
        pthread_mutex_unlock(&LDQ_lock);
        throw -2;
    }
    int index = Lrear;
    Lrear = (++Lrear)%Q_LEN;
    Load_Q[index].rob_i = rbi;
    Load_Q[index].addr = addr;
    Load_Q[index].code = LD;
    Load_Q[index].ready = false;
    pthread_mutex_unlock(&LDQ_lock);
    return Load_Q + index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x30, %rdi
callq 0x4510
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movq -0x20(%rbp), %rax
cmpl 0xc(%rax), %edx
jne 0x1afde
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x42c0
movl $0x4, %edi
callq 0x41c0
movq %rax, %rdi
movl $0xfffffffe, (%rdi)     # imm = 0xFFFFFFFE
movq 0x13fc3(%rip), %rsi     # 0x2ef98
xorl %eax, %eax
movl %eax, %edx
callq 0x45c0
movq -0x20(%rbp), %rdi
movl 0x10(%rdi), %eax
movl %eax, -0x14(%rbp)
movl 0x10(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x10(%rdi)
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, 0x10(%rdi)
movl -0xc(%rbp), %ecx
movq %rdi, %rax
addq $0x88, %rax
movslq -0x14(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq %rdi, %rax
addq $0x88, %rax
movslq -0x14(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movq %rdi, %rax
addq $0x88, %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x6, 0x8(%rax)
movq %rdi, %rax
addq $0x88, %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x14(%rax)
addq $0x30, %rdi
callq 0x42c0
movq -0x20(%rbp), %rax
addq $0x88, %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ziang95[P]Tomasulo_simulator/memory.cpp
// Function: memory::SD_enQ(int, int, int, memCell)
LSQEntry* memory::SD_enQ(int rbi, int Qj, int addr, memCell val)
{
    pthread_mutex_lock(&SDQ_lock);
    if ((Srear+1)%Q_LEN == Sfront)
    {
        pthread_mutex_unlock(&SDQ_lock);
        throw -1;
    }
    int index = Srear;
    Srear = (++Srear)%Q_LEN;
    Stor_Q[index].rob_i = rbi;
    Stor_Q[index].addr = addr;
    Stor_Q[index].SD_source = Qj;
    Stor_Q[index].code = LD;
    Stor_Q[index].val = val;
    Stor_Q[index].ready = false;
    pthread_mutex_unlock(&SDQ_lock);
    return Stor_Q + index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %r8d, -0x4(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x58, %rdi
callq 0x4510
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movq -0x28(%rbp), %rax
cmpl 0x14(%rax), %edx
jne 0x1b105
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
callq 0x42c0
movl $0x4, %edi
callq 0x41c0
movq %rax, %rdi
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movq 0x13e9c(%rip), %rsi     # 0x2ef98
xorl %eax, %eax
movl %eax, %edx
callq 0x45c0
movq -0x28(%rbp), %rdi
movl 0x18(%rdi), %eax
movl %eax, -0x20(%rbp)
movl 0x18(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x18(%rdi)
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, 0x18(%rdi)
movl -0x14(%rbp), %ecx
movq %rdi, %rax
addq $0x1888, %rax           # imm = 0x1888
movslq -0x20(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %ecx
movq %rdi, %rax
addq $0x1888, %rax           # imm = 0x1888
movslq -0x20(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movq %rdi, %rax
addq $0x1888, %rax           # imm = 0x1888
movslq -0x20(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq %rdi, %rax
addq $0x1888, %rax           # imm = 0x1888
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0x6, 0x8(%rax)
movq %rdi, %rax
addq $0x1888, %rax           # imm = 0x1888
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl -0x4(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq %rdi, %rax
addq $0x1888, %rax           # imm = 0x1888
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x14(%rax)
addq $0x58, %rdi
callq 0x42c0
movq -0x28(%rbp), %rax
addq $0x1888, %rax           # imm = 0x1888
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Ziang95[P]Tomasulo_simulator/memory.cpp
// Function: memory::setMem(valType, int, void*)
bool memory::setMem(valType type, int addr, void* val)
{
    if (addr>=size){
        err_log("Mem set out of range");
        return false;
    }
    if (type == INTGR)
        buf[addr].i = *(int*)val;
    else
        buf[addr].f = *(float*)val;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jl 0x1b28a
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4600
movq -0x68(%rbp), %rdx
leaq 0x75b2(%rip), %rsi      # 0x227e0
leaq -0x40(%rbp), %rdi
callq 0x44c0
jmp 0x1b239
leaq -0x40(%rbp), %rdi
callq 0x11880
jmp 0x1b244
leaq -0x40(%rbp), %rdi
callq 0x4240
leaq -0x41(%rbp), %rdi
callq 0x43d0
movb $0x0, -0x1(%rbp)
jmp 0x1b2c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x1b27f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4240
leaq -0x41(%rbp), %rdi
callq 0x43d0
jmp 0x1b2cd
cmpl $0x0, -0x14(%rbp)
jne 0x1b2a6
movq -0x60(%rbp), %rax
movq -0x20(%rbp), %rcx
movl (%rcx), %edx
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1b2be
movq -0x60(%rbp), %rax
movq -0x20(%rbp), %rcx
movss (%rcx), %xmm0
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: Ziang95[P]Tomasulo_simulator/memory.cpp
// Function: memory::mem_automat()
void memory::mem_automat()
{
    mem_next_vdd = 0;
    while (true)
    {
        at_rising_edge(mem_next_vdd);
        if (Sfront == Srear && Lfront == Lrear && sys_clk.is_instr_ended())
            sys_clk.end_mem();
        if (squash_p.flag)
        {
            squash_p.flag = false;
            at_falling_edge(mem_next_vdd);
        }
        else
        {
            if (Sfront != Srear && Stor_Q[Sfront].ready && CPU_ROB->get_front() == Stor_Q[Sfront].rob_i)
                store(Stor_Q[Sfront]);
            else if(Lfront != Lrear && Load_Q[Lfront].ready)
                load(Load_Q[Lfront]);
            else
                at_falling_edge(mem_next_vdd);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, 0x80(%rax)
movq -0x40(%rbp), %rdi
addq $0x80, %rdi
callq 0x12130
movq -0x40(%rbp), %rcx
movl 0x14(%rcx), %eax
cmpl 0x18(%rcx), %eax
jne 0x1bb54
movq -0x40(%rbp), %rcx
movl 0xc(%rcx), %eax
cmpl 0x10(%rcx), %eax
jne 0x1bb54
leaq 0x1425b(%rip), %rdi     # 0x2fd98
callq 0x116e0
testb $0x1, %al
jne 0x1bb48
jmp 0x1bb54
leaq 0x14249(%rip), %rdi     # 0x2fd98
callq 0x11740
movq -0x40(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0x1bb77
movq -0x40(%rbp), %rdi
movb $0x0, 0x28(%rdi)
addq $0x80, %rdi
callq 0x121a0
jmp 0x1bcbc
movq -0x40(%rbp), %rcx
movl 0x14(%rcx), %eax
cmpl 0x18(%rcx), %eax
je 0x1bc2b
movq -0x40(%rbp), %rcx
movq %rcx, %rax
addq $0x1888, %rax           # imm = 0x1888
movslq 0x14(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x14(%rax)
je 0x1bc2b
leaq 0x138b0(%rip), %rax     # 0x2f460
movq (%rax), %rdi
callq 0xe5d0
movq -0x40(%rbp), %rdx
movq %rdx, %rcx
addq $0x1888, %rcx           # imm = 0x1888
movslq 0x14(%rdx), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x1bc2b
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x1888, %rax           # imm = 0x1888
movslq 0x14(%rdi), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
leaq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1a550
jmp 0x1bcba
movq -0x40(%rbp), %rcx
movl 0xc(%rcx), %eax
cmpl 0x10(%rcx), %eax
je 0x1bca8
movq -0x40(%rbp), %rcx
movq %rcx, %rax
addq $0x88, %rax
movslq 0xc(%rcx), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x14(%rax)
je 0x1bca8
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x88, %rax
movslq 0xc(%rdi), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1a860
jmp 0x1bcb8
movq -0x40(%rbp), %rdi
addq $0x80, %rdi
callq 0x121a0
jmp 0x1bcba
jmp 0x1bcbc
jmp 0x1bb0e
nopw %cs:(%rax,%rax)
// File: Ziang95[P]Tomasulo_simulator/memory.cpp
// Function: init_main_mem()
void init_main_mem()
{
    while(pthread_create(&main_mem.mem_handle, NULL, [](void *arg)->void*{main_mem.mem_automat(); return NULL;}, NULL));
    while(pthread_create(&main_mem.SDQ_handle, NULL, [](void *arg)->void*{main_mem.SD_Q_automat(); return NULL;}, NULL));
    clk_wait_list.push_back(&main_mem.mem_next_vdd);
    clk_wait_list.push_back(&main_mem.SDQ_next_vdd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x1(%rbp), %rdi
callq 0x1bd80
movq %rax, %rdx
leaq 0x14135(%rip), %rdi     # 0x2fe20
addq $0x3088, %rdi           # imm = 0x3088
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
callq 0x4630
cmpl $0x0, %eax
je 0x1bd05
jmp 0x1bcd8
jmp 0x1bd07
leaq -0x2(%rbp), %rdi
callq 0x1bda0
movq %rax, %rdx
leaq 0x14106(%rip), %rdi     # 0x2fe20
addq $0x3090, %rdi           # imm = 0x3090
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
callq 0x4630
cmpl $0x0, %eax
je 0x1bd34
jmp 0x1bd07
leaq 0x140e5(%rip), %rax     # 0x2fe20
addq $0x80, %rax
movq %rax, -0x10(%rbp)
leaq 0x140bc(%rip), %rdi     # 0x2fe08
leaq -0x10(%rbp), %rsi
callq 0x8530
leaq 0x140c4(%rip), %rax     # 0x2fe20
addq $0x84, %rax
movq %rax, -0x18(%rbp)
leaq 0x1409b(%rip), %rdi     # 0x2fe08
leaq -0x18(%rbp), %rsi
callq 0x8530
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Ziang95[P]Tomasulo_simulator/output.cpp
// Function: init_output_unit()
void init_output_unit()
{
    next_vdd = 0;
    output_QEntry tmp;
    tmp.iss_cyc = 0;
    tmp.name = "\nInstructions:\t\tISS\tEXE\tMEM\tWB\tCOMMMIT";
    CPU_output_Q.push_back(tmp);
    while(pthread_create(&handle, NULL, &output_automat, NULL));
    clk_wait_list.push_back(&next_vdd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, 0x14d5a(%rip)     # 0x32edc
leaq -0x28(%rbp), %rdi
callq 0x1f500
movl $0x0, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq 0x4828(%rip), %rsi      # 0x229c5
callq 0x44b0
jmp 0x1e1a4
leaq 0x14d0d(%rip), %rdi     # 0x32eb8
leaq -0x28(%rbp), %rsi
callq 0x1f520
jmp 0x1e1b6
jmp 0x1e1b8
leaq 0x14d21(%rip), %rdi     # 0x32ee0
xorl %eax, %eax
movl %eax, %ecx
leaq -0xbba(%rip), %rdx      # 0x1d610
movq %rcx, %rsi
callq 0x4630
cmpl $0x0, %eax
je 0x1e1f0
jmp 0x1e1b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1cec0
jmp 0x1e21c
leaq 0x14ce5(%rip), %rax     # 0x32edc
movq %rax, -0x40(%rbp)
leaq 0x11c06(%rip), %rdi     # 0x2fe08
leaq -0x40(%rbp), %rsi
callq 0x8530
jmp 0x1e20d
leaq -0x28(%rbp), %rdi
callq 0x1cec0
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: Ziang95[P]Tomasulo_simulator/registor.cpp
// Function: registor::registor(int)
registor::registor(int _RegSize):RegSize(_RegSize)
{
    intReg = new int[_RegSize];
    for (int i = 0; i<_RegSize; i++)
        intReg[i] = 0;
    // intReg[0] = 0;
    flpReg = new float[_RegSize];
    for (int i = 0; i<RegSize; i++)
        flpReg[i] = 0.;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movslq -0xc(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x205e8
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x205c3
movslq -0xc(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x2064a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2061f
addq $0x20, %rsp
popq %rbp
retq
// File: Ziang95[P]Tomasulo_simulator/registor.cpp
// Function: registor::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, memCell&)
bool registor::get(string name, memCell &ret)
{
    int index = stoi(name.substr(1, name.size() - 1));
    if (index >= RegSize)
    {
        err_log(name + ": Reg access out of range");
        return false;
    }
    if (name[0] == 'R')
        ret.i = intReg[index];
    else if (name[0] == 'F')
        ret.f = flpReg[index];
    else
    {
        err_log("Reg name error");
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, %rax
movq -0xc0(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x4270
movq -0xb0(%rbp), %rsi
movq %rax, %rcx
decq %rcx
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movl $0x1, %edx
callq 0x4390
movq -0xa8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x15bd0
movl %eax, -0xa0(%rbp)
jmp 0x2073e
leaq -0x48(%rbp), %rdi
callq 0x4240
movl -0xa0(%rbp), %eax
movq -0xb8(%rbp), %rcx
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x10(%rcx), %eax
jl 0x207d1
movq -0xb0(%rbp), %rsi
leaq 0x227f(%rip), %rdx      # 0x229ec
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x20c40
movq -0xc8(%rbp), %rdi
callq 0x11880
jmp 0x2078b
leaq -0x78(%rbp), %rdi
callq 0x4240
movb $0x0, -0x1(%rbp)
jmp 0x208d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4240
jmp 0x208e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4240
jmp 0x208e1
movq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4690
movsbl (%rax), %eax
cmpl $0x52, %eax
jne 0x20805
movq -0xb8(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x208cf
movq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4690
movsbl (%rax), %eax
cmpl $0x46, %eax
jne 0x2083e
movq -0xb8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x208cd
leaq -0x99(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x4600
movq -0xd0(%rbp), %rdx
leaq 0x21a7(%rip), %rsi      # 0x22a06
leaq -0x98(%rbp), %rdi
callq 0x44c0
jmp 0x2086d
leaq -0x98(%rbp), %rdi
callq 0x11880
jmp 0x2087b
leaq -0x98(%rbp), %rdi
callq 0x4240
leaq -0x99(%rbp), %rdi
callq 0x43d0
movb $0x0, -0x1(%rbp)
jmp 0x208d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x208bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x4240
leaq -0x99(%rbp), %rdi
callq 0x43d0
jmp 0x208e1
jmp 0x208cf
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x45f0
nopw (%rax,%rax)
// File: Ziang95[P]Tomasulo_simulator/registor.cpp
// Function: registor::clear()
void registor::clear()
{
    for (int i = 0; i<RegSize; i++)
        intReg[i] = 0;
    for (int i = 0; i<RegSize; i++)
        flpReg[i] = 0;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x20c00
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x20bd7
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x20c32
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x20c07
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Ziang95[P]Tomasulo_simulator/reserv_station.cpp
// Function: resStation::resStation(FU_Q*, valType)
resStation::resStation(FU_Q *Q, valType t):type(t)
{
    prnt_Q = Q;
    busy = false;
    to_start = false;
    dest = -1;
    Rj = Rk = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x48(%rax)
movb $0x0, (%rax)
movb $0x0, 0x1(%rax)
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movb $0x1, 0x2d(%rax)
movb $0x1, 0x2c(%rax)
popq %rbp
retq
nopl (%rax)
// File: Ziang95[P]Tomasulo_simulator/reserv_station.cpp
// Function: resStation::squash(int)
void resStation::squash(int ROB_i)
{
    int R_f = CPU_ROB->get_front();
    int R_r = CPU_ROB->get_rear();
    if (is_prev_index(ROB_i, dest, R_f, R_r) || is_prev_index(ROB_i, Qj, R_f, R_r) || is_prev_index(ROB_i, Qk, R_f, R_r))
        busy = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xe3a2(%rip), %rax      # 0x2f460
movq (%rax), %rdi
callq 0xe5d0
movl %eax, -0x10(%rbp)
leaq 0xe390(%rip), %rax      # 0x2f460
movq (%rax), %rdi
callq 0xe5e0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %edi
movl 0x4(%rax), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x1aec0
testb $0x1, %al
jne 0x2112a
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edi
movl 0x8(%rax), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x1aec0
testb $0x1, %al
jne 0x2112a
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %edi
movl 0xc(%rax), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0x1aec0
testb $0x1, %al
jne 0x2112a
jmp 0x21131
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/manager.cpp
// Function: Manager::Manager()
Manager::Manager()
{
    m_pParser = std::make_unique<Parser>();
    m_pFileHandler = std::make_unique<FileHandler>();
    m_pCoder = std::make_unique<Coder>();
    m_pValidator = std::make_unique<Validator>();
    m_pTree = std::make_unique<Tree>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0xaff0
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x68(%rbp)
callq 0xb020
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x60(%rbp)
callq 0xb050
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x58(%rbp)
callq 0xb080
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x48(%rbp)
callq 0xb0b0
leaq -0x10(%rbp), %rdi
callq 0xb0e0
jmp 0x9b82
movq -0x70(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movq %rsi, -0x78(%rbp)
callq 0xb150
movq -0x78(%rbp), %rdi
callq 0xb180
leaq -0x28(%rbp), %rdi
callq 0xb1d0
jmp 0x9ba7
movq -0x70(%rbp), %rdi
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
movq %rsi, -0x80(%rbp)
callq 0xb240
movq -0x80(%rbp), %rdi
callq 0xb270
leaq -0x30(%rbp), %rdi
callq 0xb2c0
jmp 0x9bd0
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
leaq -0x30(%rbp), %rsi
movq %rsi, -0x88(%rbp)
callq 0xb330
movq -0x88(%rbp), %rdi
callq 0xb360
leaq -0x38(%rbp), %rdi
callq 0xb3b0
jmp 0x9bff
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
leaq -0x38(%rbp), %rsi
movq %rsi, -0x90(%rbp)
callq 0xb420
movq -0x90(%rbp), %rdi
callq 0xb450
leaq -0x40(%rbp), %rdi
callq 0xb4a0
jmp 0x9c2e
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
leaq -0x40(%rbp), %rsi
callq 0xb510
leaq -0x40(%rbp), %rdi
callq 0xb540
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xb540
movq -0x58(%rbp), %rdi
callq 0xb450
movq -0x60(%rbp), %rdi
callq 0xb360
movq -0x68(%rbp), %rdi
callq 0xb270
movq -0x50(%rbp), %rdi
callq 0xb180
movq -0x18(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/manager.cpp
// Function: Manager::validate(DataType&, DataType&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool Manager::validate(DataType & dataType, DataType & nodeType, std::vector<std::string> & nodeNameVector)
{
    if (dataType.m_baseType == BaseDataType::SEQUENCE_OF)
    {
        nodeNameVector = nodeType.m_nodeNameList; 
        if (nodeNameVector.size() == 1)
        {
            for (std::vector<std::string>::size_type i = m_pParser -> m_customDataTypeVector.size() - 1; i != (std::vector<std::string>::size_type) - 1; i--)
            {
                if (m_pParser -> m_customDataTypeNameVector[i] == nodeNameVector[0])
                {
                    DataType type = m_pParser -> m_customDataTypeVector[i];
                    nodeNameVector = type.m_nodeNameList;
                }
            }
        }
    }
    return m_pValidator -> validate(dataType, nodeType); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x9e32
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdi
callq 0xb590
movq -0x20(%rbp), %rdi
callq 0x8200
cmpq $0x1, %rax
jne 0x9e30
movq -0x90(%rbp), %rdi
callq 0xb7e0
movq %rax, %rdi
callq 0xb800
subq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x9e2e
movq -0x90(%rbp), %rdi
callq 0xb7e0
movq %rax, %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rsi
callq 0x82b0
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x82b0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x8220
testb $0x1, %al
jne 0x9dc3
jmp 0x9e1b
movq -0x90(%rbp), %rdi
callq 0xb7e0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0xb830
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0xb850
leaq -0x58(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xb590
jmp 0x9df6
leaq -0x78(%rbp), %rdi
callq 0x44a90
jmp 0x9e1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x44a90
jmp 0x9e5d
jmp 0x9e1d
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x9d73
jmp 0x9e30
jmp 0x9e32
movq -0x90(%rbp), %rdi
addq $0x18, %rdi
callq 0xb8d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf950
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/validator.cpp
// Function: Validator::validate(DataType&, DataType&, int&)
bool Validator::validate(DataType & dataType, DataType & nodeType, int & data)
{
    if (dataType.m_baseType == nodeType.m_baseType)
    {
        if (nodeType.m_rangeLimitLower != 0 || nodeType.m_rangeLimitUpper != 0)
        {
            if (data > nodeType.m_rangeLimitLower && data < nodeType.m_rangeLimitUpper)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return true;
        }
    }
    else
    {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xf9e6
movq -0x20(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0xf9b6
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0xf9e0
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jle 0xf9da
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0xf9da
movb $0x1, -0x1(%rbp)
jmp 0xf9ea
movb $0x0, -0x1(%rbp)
jmp 0xf9ea
movb $0x1, -0x1(%rbp)
jmp 0xf9ea
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/validator.cpp
// Function: Validator::validate(DataType&, DataType&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Validator::validate(DataType & dataType, DataType & nodeType, std::string & data)
{
    if (dataType.m_baseType == nodeType.m_baseType)
    {
        if (nodeType.m_lengthLimit != 0)
        {
            if (static_cast<int>(data.size()) < nodeType.m_lengthLimit)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return true;
        }
    }
    else
    {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xfa54
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xfa4e
movq -0x28(%rbp), %rdi
callq 0x6350
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0xfa48
movb $0x1, -0x1(%rbp)
jmp 0xfa58
movb $0x0, -0x1(%rbp)
jmp 0xfa58
movb $0x1, -0x1(%rbp)
jmp 0xfa58
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/filehandler.cpp
// Function: FileHandler::readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string FileHandler::readFile(std::string filePath)
{
    std::ifstream file(filePath);
    if (file.is_open())
    {
        auto ss = std::ostringstream{};
        ss << file.rdbuf();
        m_fileContent = ss.str();
        return m_fileContent; 
    }
    else
    {
        return "";
    } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdx, -0x3f8(%rbp)
movq %rsi, %rax
movq -0x3f8(%rbp), %rsi
movq %rdi, -0x3f0(%rbp)
movq %rdi, %rcx
movq %rcx, -0x3e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x3e0(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x3d8(%rbp)
movl $0x8, %edx
callq 0x66c0
movq -0x3d8(%rbp), %rdi
callq 0x66b0
movb %al, -0x3ce(%rbp)
jmp 0xfb20
movb -0x3ce(%rbp), %al
testb $0x1, %al
jne 0xfb2f
jmp 0xfc0c
leaq -0x3a8(%rbp), %rdi
callq 0x65e0
jmp 0xfb3d
leaq -0x220(%rbp), %rdi
callq 0x6680
movq %rax, -0x400(%rbp)
jmp 0xfb52
movq -0x400(%rbp), %rsi
leaq -0x3a8(%rbp), %rdi
callq 0x60e0
jmp 0xfb67
leaq -0x3c8(%rbp), %rdi
leaq -0x3a8(%rbp), %rsi
callq 0x6490
jmp 0xfb7c
movq -0x3e0(%rbp), %rdi
leaq -0x3c8(%rbp), %rsi
movq %rsi, -0x408(%rbp)
callq 0x6560
movq -0x408(%rbp), %rdi
callq 0x62e0
movq -0x3f0(%rbp), %rdi
movq -0x3e0(%rbp), %rsi
callq 0x61d0
jmp 0xfbb7
movl $0x1, -0x3cc(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x6100
jmp 0xfc73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0xfc8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x3a8(%rbp), %rdi
callq 0x6100
jmp 0xfc8f
leaq -0x3cd(%rbp), %rdi
movq %rdi, -0x410(%rbp)
callq 0x67a0
movq -0x3f0(%rbp), %rdi
movq -0x410(%rbp), %rdx
leaq 0x38c10(%rip), %rsi     # 0x48844
callq 0x8130
jmp 0xfc3b
leaq -0x3cd(%rbp), %rdi
callq 0x64d0
movl $0x1, -0x3cc(%rbp)
jmp 0xfc73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x3cd(%rbp), %rdi
callq 0x64d0
jmp 0xfc8f
leaq -0x220(%rbp), %rdi
callq 0x6110
movq -0x3e8(%rbp), %rax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x6110
movq -0x228(%rbp), %rdi
callq 0x6790
nopw (%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::encodeInteger(DataType&, int&)
std::vector<std::byte> Coder::encodeInteger(DataType & dataType, int & data)
{
    std::vector<std::byte> dataVector;
    dataVector.push_back(encodeID(dataType));
    int length = 0;
    std::vector<std::byte> dataInBytes = splitIntoBytes(data, length);
    std::vector<std::byte> lengthInBytes = encodeLength(length);
    dataVector.insert(dataVector.end(), lengthInBytes.begin(), lengthInBytes.end());
    dataVector.insert(dataVector.end(), dataInBytes.begin(), dataInBytes.end());
    return dataVector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x8110
movq -0xc8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xff20
movb %al, -0xb9(%rbp)
jmp 0xfd38
movq -0xd8(%rbp), %rdi
movb -0xb9(%rbp), %al
movb %al, -0x22(%rbp)
leaq -0x22(%rbp), %rsi
callq 0x11910
jmp 0xfd53
movq -0xc8(%rbp), %rsi
movl $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rcx
callq 0x10280
jmp 0xfd74
movq -0xc8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x10370
jmp 0xfd8a
movq -0xd8(%rbp), %rdi
callq 0x119f0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x11a20
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x11a60
movq -0xe8(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x119f0
movq -0xd8(%rbp), %rdi
movq %rax, -0x88(%rbp)
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rcx
callq 0x11940
movq %rax, -0xe0(%rbp)
jmp 0xfdf2
movq -0xd8(%rbp), %rdi
movq -0xe0(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x119f0
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x11a20
leaq -0x50(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x11a60
movq -0xf8(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0x119f0
movq -0xd8(%rbp), %rdi
movq %rax, -0xb0(%rbp)
movq -0x98(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xb0(%rbp), %rcx
callq 0x11940
movq %rax, -0xf0(%rbp)
jmp 0xfe7a
movq -0xf0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x1, -0x21(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x8320
leaq -0x50(%rbp), %rdi
callq 0x8320
testb $0x1, -0x21(%rbp)
jne 0xfeee
jmp 0xfee2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xfefe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xfed7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x8320
leaq -0x50(%rbp), %rdi
callq 0x8320
jmp 0xfefe
movq -0xd8(%rbp), %rdi
callq 0x8320
movq -0xd0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x8320
movq -0x30(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::splitIntoBytes(int&, int&)
std::vector<std::byte> Coder::splitIntoBytes(int & number, int & numberOfBytes)
{
    std::vector<std::byte> vectorOfBytes;
    if (number != 0)
    {
       numberOfBytes = getNumberOfBytes(number);
       for (int i = numberOfBytes - 1; i >= 0; i--) 
        {
           vectorOfBytes.push_back(static_cast<std::byte>(((number >> i * 8) & 0xFF))); 
        }
    }
    else
    {
        vectorOfBytes.push_back(static_cast<std::byte>(0));
    }
    
    return vectorOfBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x8110
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x10332
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x10ea0
movl %eax, -0x5c(%rbp)
jmp 0x102d1
movl -0x5c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jl 0x10330
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movb -0x38(%rbp), %cl
shlb $0x3, %cl
sarl %cl, %eax
movb %al, -0x39(%rbp)
leaq -0x39(%rbp), %rsi
callq 0x11910
jmp 0x1030c
jmp 0x1030e
movl -0x38(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x102e6
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x8320
jmp 0x10364
jmp 0x10347
movq -0x58(%rbp), %rdi
movb $0x0, -0x3a(%rbp)
leaq -0x3a(%rbp), %rsi
callq 0x11910
jmp 0x10345
jmp 0x10347
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x1035a
movq -0x58(%rbp), %rdi
callq 0x8320
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6790
nopl (%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::encodeLength(int&)
std::vector<std::byte> Coder::encodeLength(int & lengthInBytes)
{
    std::vector<std::byte> vectorOfBytes;
    
    int numberOfSeptets = 0;
    if (lengthInBytes != 0)
    {
        int len = lengthInBytes;
        while (len != 0)
        {
            len >>= 7;
            numberOfSeptets++;
        }  
        
        for (int i = 0; i < numberOfSeptets; i++)
        {
            if (i == numberOfSeptets - 1)
            {
                int8_t num = lengthInBytes >> (i * 7);
                num &= ~(1 << 7);
                vectorOfBytes.push_back(static_cast<std::byte>(num));
                
            }
            else
            {
                int8_t num = lengthInBytes >> (i * 7);
                num |= (1 << 7);
                vectorOfBytes.push_back(static_cast<std::byte>(num));
            }
        }
    }
    else
    {
        vectorOfBytes.push_back(static_cast<std::byte>(0));
    }
    
    return vectorOfBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x8110
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x10480
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x103cf
movl -0x24(%rbp), %eax
sarl $0x7, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x103b5
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x1047e
movl -0x28(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1043a
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl -0x28(%rbp), %edx
movl %edx, %ecx
shll $0x3, %ecx
subl %edx, %ecx
sarl %cl, %eax
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x7f, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
movb %al, -0x2a(%rbp)
leaq -0x2a(%rbp), %rsi
callq 0x11910
jmp 0x10421
jmp 0x1046e
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x8320
jmp 0x104b2
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl -0x28(%rbp), %edx
movl %edx, %ecx
shll $0x3, %ecx
subl %edx, %ecx
sarl %cl, %eax
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
orb $-0x80, %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
movb %al, -0x3e(%rbp)
leaq -0x3e(%rbp), %rsi
callq 0x11910
jmp 0x1046c
jmp 0x1046e
jmp 0x10470
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x103d6
jmp 0x10495
movq -0x50(%rbp), %rdi
movb $0x0, -0x3f(%rbp)
leaq -0x3f(%rbp), %rsi
callq 0x11910
jmp 0x10493
jmp 0x10495
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x104a8
movq -0x50(%rbp), %rdi
callq 0x8320
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6790
nopl (%rax,%rax)
// File: EmbeddedPaul166[P]SNMP-Agent/src/coder.cpp
// Function: Coder::encodeOctetString(DataType&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::vector<std::byte> Coder::encodeOctetString(DataType & dataType, std::string & data)
{
    std::vector<std::byte> dataVector;
    dataVector.push_back(encodeID(dataType));
    int length = data.size();
    std::vector<std::byte> lengthInBytes = encodeLength(length);
    std::vector<std::byte> dataInBytes = splitIntoBytes(data);
    dataVector.insert(dataVector.end(), lengthInBytes.begin(), lengthInBytes.end());
    dataVector.insert(dataVector.end(), dataInBytes.begin(), dataInBytes.end());
    return dataVector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x8110
movq -0xc8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xff20
movb %al, -0xb9(%rbp)
jmp 0x10518
movq -0xd8(%rbp), %rdi
movb -0xb9(%rbp), %al
movb %al, -0x22(%rbp)
leaq -0x22(%rbp), %rsi
callq 0x11910
jmp 0x10533
movq -0x20(%rbp), %rdi
callq 0x6350
movq -0xc8(%rbp), %rsi
movl %eax, -0x38(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x10370
jmp 0x10555
movq -0xc8(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x10700
jmp 0x1056b
movq -0xd8(%rbp), %rdi
callq 0x119f0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x11a20
leaq -0x50(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x11a60
movq -0xe8(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x119f0
movq -0xd8(%rbp), %rdi
movq %rax, -0x88(%rbp)
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rcx
callq 0x11940
movq %rax, -0xe0(%rbp)
jmp 0x105d3
movq -0xd8(%rbp), %rdi
movq -0xe0(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x119f0
movq %rax, -0xa0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x11a20
leaq -0x68(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x11a60
movq -0xf8(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0x119f0
movq -0xd8(%rbp), %rdi
movq %rax, -0xb0(%rbp)
movq -0x98(%rbp), %rsi
movq -0xa8(%rbp), %rdx
movq -0xb0(%rbp), %rcx
callq 0x11940
movq %rax, -0xf0(%rbp)
jmp 0x1065b
movq -0xf0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x1, -0x21(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x8320
leaq -0x50(%rbp), %rdi
callq 0x8320
testb $0x1, -0x21(%rbp)
jne 0x106cf
jmp 0x106c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x106df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x106b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x8320
leaq -0x50(%rbp), %rdi
callq 0x8320
jmp 0x106df
movq -0xd8(%rbp), %rdi
callq 0x8320
movq -0xd0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x8320
movq -0x30(%rbp), %rdi
callq 0x6790
nopw %cs:(%rax,%rax)