LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: nopBublr::FU_automat()
void nopBublr::FU_automat()
{
    next_vdd = 0;
    while (true)
    {
        at_rising_edge(next_vdd);
        for (int i = 2; i>0; i--)
            shifter[i] = shifter[i-1];
        shifter[0] = bubble;
        bubble.ROB_i = -1;
        bubble.ROB_E = nullptr;
        if (shifter[0].ROB_E)
            shifter[0].ROB_E->output.exe = sys_clk.get_prog_cyc();
        if (shifter[1].ROB_E)
        {
            shifter[1].ROB_E->output.wBack = sys_clk.get_prog_cyc();
            shifter[1].ROB_E->wrtnBack = true;
        }
        if (shifter[2].ROB_E)
        {
            shifter[2].ROB_E->output.commit = sys_clk.get_prog_cyc();
            shifter[2].ROB_E->finished = true;
        }
        at_falling_edge(next_vdd);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
andl $0x0, 0x48(%rdi)
leaq 0x10(%rdi), %r12
leaq 0x20(%rdi), %r13
leaq 0x30(%rdi), %r15
movq %r14, %rdi
callq 0x83e0
movups (%r13), %xmm0
movups %xmm0, (%r15)
movups (%r12), %xmm0
movups %xmm0, (%r13)
movups (%rbx), %xmm0
movups %xmm0, (%r12)
orl $-0x1, (%rbx)
andq $0x0, 0x8(%rbx)
cmpq $0x0, 0x18(%rbx)
je 0x562c
leaq 0x11688(%rip), %rdi     # 0x16ca8
callq 0x7e24
movq 0x18(%rbx), %rcx
movl %eax, 0x54(%rcx)
cmpq $0x0, 0x28(%rbx)
je 0x564a
leaq 0x1166e(%rip), %rdi     # 0x16ca8
callq 0x7e24
movq 0x28(%rbx), %rcx
movl %eax, 0x5c(%rcx)
movb $0x1, 0x1(%rcx)
cmpq $0x0, 0x38(%rbx)
je 0x5667
leaq 0x11650(%rip), %rdi     # 0x16ca8
callq 0x7e24
movq 0x38(%rbx), %rcx
movl %eax, 0x60(%rcx)
movb $0x1, (%rcx)
movq %r14, %rdi
callq 0x8437
jmp 0x55e7
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/ROB.cpp
// Function: ROB::get_entry(int)
ROBEntry *ROB::get_entry(int index)
{
    if (index >= size || index < 0)
    {
        err_log("ROB access out of range");
        return nullptr;
    }
    return &buf[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
testl %esi, %esi
js 0x6c9f
cmpl %esi, 0x10(%rdi)
jle 0x6c9f
movl %esi, %eax
imulq $0xa0, %rax, %rax
addq 0x8(%rdi), %rax
jmp 0x6cc9
leaq 0x8583(%rip), %rsi      # 0xf229
leaq -0x30(%rbp), %rbx
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x7ee9
leaq -0x30(%rbp), %rdi
callq 0x3140
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/ROB.cpp
// Function: ROB::add_entry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, opCode)
int ROB::add_entry(string n, string d, opCode c)
{
    if ((rear+1)%size == front)
        throw -1;
    int index = rear;
    rear = (rear + 1)%size;
    ROBEntry *tmp = buf + index;
    (*tmp).code = c;
    (*tmp).name = n;
    (*tmp).regName = d;
    (*tmp).finished = false;
    (*tmp).wrtnBack = false;
    (*tmp).output.issue = sys_clk.get_prog_cyc();
    (*tmp).output.exe = -1;
    (*tmp).output.mem = -1;
    (*tmp).output.wBack = -1;
    (*tmp).output.commit = -1;
    return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movslq 0x4(%rdi), %rbx
leal 0x1(%rbx), %eax
cltd
idivl 0x10(%rdi)
cmpl (%rdi), %edx
je 0x6d7e
movl %edx, 0x4(%rdi)
movq 0x8(%rdi), %r15
imulq $0xa0, %rbx, %r12
leaq (%r15,%r12), %rdi
addq $0x8, %rdi
movl %ecx, 0x44(%rdi)
callq 0x3190
addq %r12, %r15
addq $0x28, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3190
andw $0x0, -0x28(%r15)
leaq 0xff48(%rip), %rdi      # 0x16ca8
callq 0x7e24
movl %eax, 0x28(%r15)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x2c(%r15)
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rdi
callq 0x3170
orl $-0x1, (%rax)
movq 0xf200(%rip), %rsi      # 0x15f90
movq %rax, %rdi
xorl %edx, %edx
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/ROB.cpp
// Function: init_CPU_ROB()
void init_CPU_ROB()
{
    if (CPU_ROB)
        delete CPU_ROB;
    CPU_ROB = new ROB(*(CPU_cfg->ROB_num));
    while(pthread_create(&CPU_ROB->handle, NULL, &ROB_thread_container, CPU_ROB));
    clk_wait_list.push_back(&CPU_ROB->next_vdd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xf150(%rip), %r14      # 0x16370
movq (%r14), %rbx
testq %rbx, %rbx
je 0x7238
movq %rbx, %rdi
callq 0x6c24
movq %rbx, %rdi
callq 0x3270
pushq $0x28
popq %rdi
callq 0x3290
movq %rax, %rbx
leaq 0xf116(%rip), %rax      # 0x16360
movq (%rax), %rax
movq (%rax), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x6bac
movq %rbx, (%r14)
leaq -0x5f(%rip), %rbx       # 0x7205
movq (%r14), %rcx
leaq 0x18(%rcx), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3460
testl %eax, %eax
jne 0x7264
movq (%r14), %rax
addq $0x20, %rax
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
leaq 0xfa8a(%rip), %rdi      # 0x16d18
callq 0x5ec2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3270
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/clock.cpp
// Function: all_unit_ready_for_one()
int all_unit_ready_for_one()
{
    int r = 1;
    for (const int* v : clk_wait_list)
    {
        if (!v)
        {
            err_log("null Ptr encountered in clk_wait_list");
            return -1;
        }
        r *= *v;
    }
    return r == 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
leaq 0xeeac(%rip), %rax      # 0x16d18
movq (%rax), %r14
movq 0x8(%rax), %r15
pushq $0x1
popq %r12
cmpq %r15, %r14
je 0x7eb6
movq (%r14), %rax
testq %rax, %rax
je 0x7e8e
imull (%rax), %r12d
addq $0x8, %r14
jmp 0x7e77
leaq 0x7406(%rip), %rsi      # 0xf29b
leaq -0x48(%rbp), %rbx
leaq -0x21(%rbp), %rdx
movq %rbx, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x7ee9
leaq -0x48(%rbp), %rdi
callq 0x3140
xorl %ecx, %ecx
cmpl $0x1, %r12d
sete %cl
cmpq %r15, %r14
pushq $-0x1
popq %rax
cmovel %ecx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/clock.cpp
// Function: all_unit_ready_for_zero()
int all_unit_ready_for_zero()
{
    int r = 0;
    for (const int* v : clk_wait_list)
    {
        if (!v)
        {
            err_log("null Ptr encountered in clk_wait_list");
            return -1;
        }
        r += *v;
    }
    return r == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
leaq 0xed88(%rip), %rax      # 0x16d18
movq (%rax), %r14
movq 0x8(%rax), %r15
xorl %r12d, %r12d
cmpq %r15, %r14
je 0x7fd8
movq (%r14), %rax
testq %rax, %rax
je 0x7fb0
addl (%rax), %r12d
addq $0x8, %r14
jmp 0x7f9a
leaq 0x72e4(%rip), %rsi      # 0xf29b
leaq -0x48(%rbp), %rbx
leaq -0x21(%rbp), %rdx
movq %rbx, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x7ee9
leaq -0x48(%rbp), %rdi
callq 0x3140
xorl %ecx, %ecx
testl %r12d, %r12d
sete %cl
cmpq %r15, %r14
pushq $-0x1
popq %rax
cmovel %ecx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/clock.cpp
// Function: msg_log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void msg_log(string msg, int lvl)
{
    if (debug_level < lvl) return;
    pthread_mutex_lock(&cout_lock);
    cout<<"[Pro_cyc="<<sys_clk.get_prog_cyc()<<", vdd="<<sys_clk.get_vdd()<<"] "<<msg<<endl;
    pthread_mutex_unlock(&cout_lock);
}

// Assembly:
leaq 0x11a96(%rip), %rax     # 0x19de0
cmpl %esi, (%rax)
jge 0x834f
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xdf35(%rip), %rbx      # 0x16298
movq %rbx, %rdi
callq 0x3390
movq 0xdc4e(%rip), %rdi      # 0x15fc0
leaq 0x6fb5(%rip), %rsi      # 0xf32e
callq 0x3280
leaq 0xe923(%rip), %r15      # 0x16ca8
movl 0x4(%r15), %esi
movq %rax, %rdi
callq 0x3430
leaq 0x6fa0(%rip), %rsi      # 0xf338
movq %rax, %rdi
callq 0x3280
movzbl (%r15), %esi
movq %rax, %rdi
callq 0x3400
leaq 0x6f8c(%rip), %rsi      # 0xf33f
movq %rax, %rdi
callq 0x3280
movq %rax, %rdi
movq %r14, %rsi
callq 0x3260
movq %rax, %rdi
callq 0x3160
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3210
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/clock.cpp
// Function: at_rising_edge(int&)
void at_rising_edge(int &next_vdd)
{
    pthread_mutex_lock(&boradcast_lock);
    next_vdd = 1;
    while(sys_clk.get_vdd() == 0)
        pthread_cond_wait(&(sys_clk.vdd_1), &boradcast_lock);
    pthread_mutex_unlock(&boradcast_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xdecc(%rip), %rbx      # 0x162c0
movq %rbx, %rdi
callq 0x3390
movl $0x1, (%r14)
leaq 0xe89e(%rip), %r15      # 0x16ca8
leaq 0x10(%r15), %r14
cmpb $0x0, (%r15)
jne 0x8421
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33a0
jmp 0x840e
leaq 0xde98(%rip), %rdi      # 0x162c0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3210
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/clock.cpp
// Function: at_falling_edge(int&)
void at_falling_edge(int &next_vdd)
{
    pthread_mutex_lock(&boradcast_lock);
    next_vdd = 0;
    while(sys_clk.get_vdd() == 1)
        pthread_cond_wait(&(sys_clk.vdd_0), &boradcast_lock);
    pthread_mutex_unlock(&boradcast_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xde75(%rip), %rbx      # 0x162c0
movq %rbx, %rdi
callq 0x3390
andl $0x0, (%r14)
leaq 0xe84a(%rip), %r15      # 0x16ca8
leaq 0x40(%r15), %r14
cmpb $0x1, (%r15)
jne 0x8475
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33a0
jmp 0x8462
leaq 0xde44(%rip), %rdi      # 0x162c0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3210
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/import.cpp
// Function: get_opcode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
opCode get_opcode(string opName)
{
    for (char &c : opName)
        c = toupper(c);
    if (opName == "ADD")
        return ADD;
    else if (opName == "ADD.D")
        return ADD_D;
    else if (opName == "ADDI")
        return ADDI;
    else if (opName == "SUB")
        return SUB;
    else if (opName == "SUB.D")
        return SUB_D;
    else if (opName == "MULT.D")
        return MUL_D;
    else if (opName == "BEQ")
        return BEQ;
    else if (opName == "BNE")
        return BNE;
    else if (opName == "LD")
        return LD;
    else if (opName == "SD")
        return SD;
    else if (opName == "NOP")
        return NOP;
    else
        return ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x850c
movsbl (%r14,%r12), %edi
callq 0x3480
movb %al, (%r14,%r12)
incq %r12
jmp 0x84f4
leaq 0x6e61(%rip), %rsi      # 0xf374
movq %rbx, %rdi
callq 0x7486
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0x85fe
leaq 0x6e4a(%rip), %rsi      # 0xf378
movq %rbx, %rdi
callq 0x7486
testb %al, %al
je 0x8541
pushq $0x1
jmp 0x85fd
leaq 0x6e36(%rip), %rsi      # 0xf37e
movq %rbx, %rdi
callq 0x7486
testb %al, %al
je 0x855b
pushq $0x4
jmp 0x85fd
leaq 0x6e21(%rip), %rsi      # 0xf383
movq %rbx, %rdi
callq 0x7486
testb %al, %al
je 0x8575
pushq $0x2
jmp 0x85fd
leaq 0x6e0b(%rip), %rsi      # 0xf387
movq %rbx, %rdi
callq 0x7486
testb %al, %al
je 0x858c
pushq $0x3
jmp 0x85fd
leaq 0x6dfa(%rip), %rsi      # 0xf38d
movq %rbx, %rdi
callq 0x7486
testb %al, %al
je 0x85a3
pushq $0x5
jmp 0x85fd
leaq 0x6dea(%rip), %rsi      # 0xf394
movq %rbx, %rdi
callq 0x7486
testb %al, %al
je 0x85ba
pushq $0x9
jmp 0x85fd
leaq 0x6dd7(%rip), %rsi      # 0xf398
movq %rbx, %rdi
callq 0x7486
testb %al, %al
je 0x85d1
pushq $0x8
jmp 0x85fd
leaq 0x6dc4(%rip), %rsi      # 0xf39c
movq %rbx, %rdi
callq 0x7486
testb %al, %al
je 0x85e8
pushq $0x6
jmp 0x85fd
leaq 0x6db0(%rip), %rsi      # 0xf39f
movq %rbx, %rdi
callq 0x7486
testb %al, %al
je 0x8607
pushq $0x7
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6d94(%rip), %rsi      # 0xf3a2
movq %rbx, %rdi
callq 0x7486
movzbl %al, %eax
xorl $0xb, %eax
jmp 0x85fe
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/././headers/import.h
// Function: config::~config()
~config()
        {
            if (ROB_num) delete ROB_num;
            if (int_add) delete int_add;
            if (fp_add) delete fp_add;
            if (fp_mul) delete fp_mul;
            if (ld_str) delete ld_str;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x9f36
callq 0x3270
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x9f44
callq 0x3270
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9f52
callq 0x3270
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9f60
callq 0x3270
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x9f74
popq %rbx
popq %rbp
jmp 0x3270
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/instruction.cpp
// Function: instr_queue::ptr_advance()
bool instr_queue::ptr_advance()
{
    if (head >= size)
    {
        err_log("Instr queue acccess out of range while advancing");
        return false;
    }
    head ++;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movslq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r14, %r15
jbe 0xa7c3
leal 0x1(%r14), %eax
movl %eax, (%rdi)
jmp 0xa7eb
leaq 0x4d8c(%rip), %rsi      # 0xf556
leaq -0x40(%rbp), %rbx
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x7ee9
leaq -0x40(%rbp), %rdi
callq 0x3140
cmpq %r14, %r15
seta %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movslq (%rdi), %rcx
movslq %esi, %rdx
leaq (%rcx,%rdx), %rax
incq %rax
cmpq %rax, 0x8(%rdi)
seta %sil
addq %rdx, %rcx
cmpl $-0x1, %ecx
setge %bl
andb %sil, %bl
je 0xa842
movl %eax, (%rdi)
jmp 0xa86a
leaq 0x4d3e(%rip), %rsi      # 0xf587
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x3100
movq %r14, %rdi
callq 0x7ee9
leaq -0x38(%rbp), %rdi
callq 0x3140
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc399(%rip), %rdi      # 0x16c68
movq %r15, %rsi
callq 0x7496
testq %rax, %rax
je 0xa8ff
movl 0x28(%rax), %r15d
leaq 0xba89(%rip), %rax      # 0x16370
movq (%rax), %rdi
movl %r15d, %esi
callq 0x6c7e
cmpb $0x1, 0x1(%rax)
jne 0xa931
movl 0x48(%rax), %eax
movl %eax, (%rbx)
jmp 0xa934
leaq 0xc39a(%rip), %rax      # 0x16ca0
movq (%rax), %r14
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3350
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xe45c
leaq -0x40(%rbp), %rdi
callq 0x3140
jmp 0xa934
movl %r15d, (%r14)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x4c7e(%rip), %rsi      # 0xf5e5
leaq -0x38(%rbp), %rbx
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
callq 0x3100
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x8343
leaq -0x38(%rbp), %rdi
callq 0x3140
leaq 0xba06(%rip), %rdi      # 0x16398
callq 0x7748
movl %eax, %ebx
testl %eax, %eax
js 0xa9e5
leaq 0xb984(%rip), %r14      # 0x16328
movq %r14, %rdi
callq 0x3390
leaq 0xb9b5(%rip), %rax      # 0x16368
movq (%rax), %rax
movb $0x1, 0x4(%rax)
leaq 0xb937(%rip), %rdi      # 0x162f8
callq 0x30e0
movq %r14, %rdi
callq 0x3210
leaq 0xb97b(%rip), %r14      # 0x16350
movq %r14, %rdi
callq 0x83e0
movq %r14, %rdi
callq 0x8437
testl %ebx, %ebx
setns %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movb $0x0, 0x28(%rdi)
movl %esi, %eax
shlq $0x2, %rax
xorl %r15d, %r15d
testl %esi, %esi
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
movl $0x0, %r12d
cmovgl %esi, %r12d
callq 0x3030
movq %rax, (%rbx)
cmpq %r15, %r12
je 0xbdab
movq (%rbx), %rax
andl $0x0, (%rax,%r15,4)
incq %r15
jmp 0xbd99
movl %r14d, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpl %esi, %edi
jne 0xc3e5
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
cmpl %edx, %ecx
jge 0xc41a
xorl %eax, %eax
movl $0x0, %ecx
cmpl %edx, %edi
jge 0xc405
leaq 0x9f71(%rip), %rcx      # 0x16370
movq (%rcx), %rcx
movl 0x10(%rcx), %ecx
cmpl %edx, %esi
jge 0xc416
leaq 0x9f60(%rip), %rax      # 0x16370
movq (%rax), %rax
movl 0x10(%rax), %eax
addl %ecx, %edi
addl %eax, %esi
cmpl %edi, %esi
setg %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
callq 0x3390
movslq 0x10(%r12), %rcx
leal 0x1(%rcx), %eax
movl $0x100, %esi            # imm = 0x100
cltd
idivl %esi
cmpl 0xc(%r12), %edx
je 0xc498
movl %edx, 0x10(%r12)
imulq $0x18, %rcx, %rax
addq %rax, %r12
addq $0x88, %r12
movl %r15d, (%r12)
movl %r14d, 0x10(%r12)
movl $0x6, 0x8(%r12)
movb $0x0, 0x14(%r12)
movq %rbx, %rdi
callq 0x3210
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x3210
pushq $0x4
popq %rdi
callq 0x3170
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
movq 0x9adb(%rip), %rsi      # 0x15f90
movq %rax, %rdi
xorl %edx, %edx
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x2c(%rbp)
movl %ecx, %r12d
movl %edx, %r15d
movl %esi, %r13d
movq %rdi, %r14
leaq 0x58(%rdi), %rbx
movq %rbx, %rdi
callq 0x3390
movslq 0x18(%r14), %rcx
leal 0x1(%rcx), %eax
movl $0x100, %esi            # imm = 0x100
cltd
idivl %esi
cmpl 0x14(%r14), %edx
je 0xc54a
movl %edx, 0x18(%r14)
imulq $0x18, %rcx, %rax
addq %rax, %r14
addq $0x1888, %r14           # imm = 0x1888
movl %r13d, (%r14)
movl %r12d, 0x10(%r14)
movl %r15d, 0x4(%r14)
movl $0x6, 0x8(%r14)
movl -0x2c(%rbp), %eax
movl %eax, 0xc(%r14)
movb $0x0, 0x14(%r14)
movq %rbx, %rdi
callq 0x3210
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x3210
pushq $0x4
popq %rdi
callq 0x3170
orl $-0x1, (%rax)
movq 0x9a2c(%rip), %rsi      # 0x15f90
movq %rax, %rdi
xorl %edx, %edx
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movl 0x8(%rdi), %r15d
cmpl %edx, %r15d
jle 0xc59b
movq (%rdi), %rax
movslq %ebx, %rdx
testl %esi, %esi
je 0xc5c5
movss (%rcx), %xmm0
movss %xmm0, (%rax,%rdx,4)
jmp 0xc5ca
leaq 0x3226(%rip), %rsi      # 0xf7c8
leaq -0x40(%rbp), %r14
leaq -0x19(%rbp), %rdx
movq %r14, %rdi
callq 0x3100
movq %r14, %rdi
callq 0x7ee9
leaq -0x40(%rbp), %rdi
callq 0x3140
jmp 0xc5ca
movl (%rcx), %ecx
movl %ecx, (%rax,%rdx,4)
cmpl %ebx, %r15d
setg %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x80(%rdi), %r14
andl $0x0, 0x80(%rdi)
leaq 0x1888(%rdi), %r12
leaq 0x88(%rdi), %r13
leaq 0xa155(%rip), %r15      # 0x16ca8
movq %r14, %rdi
callq 0x83e0
movl 0x14(%rbx), %eax
cmpl 0x18(%rbx), %eax
jne 0xcb7f
movl 0xc(%rbx), %eax
cmpl 0x10(%rbx), %eax
jne 0xcb7f
movq %r15, %rdi
callq 0x7e2e
testb %al, %al
je 0xcb7f
movq %r15, %rdi
callq 0x7e4c
cmpb $0x1, 0x28(%rbx)
jne 0xcb8e
movb $0x0, 0x28(%rbx)
jmp 0xcc15
movslq 0x14(%rbx), %rax
cmpl 0x18(%rbx), %eax
je 0xcbe0
imulq $0x18, %rax, %rax
cmpb $0x1, 0x14(%r12,%rax)
jne 0xcbe0
leaq 0x97c6(%rip), %rax      # 0x16370
movq (%rax), %rdi
callq 0x6cf4
movslq 0x14(%rbx), %rcx
imulq $0x18, %rcx, %rcx
cmpl (%r12,%rcx), %eax
jne 0xcbe0
addq %r12, %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movups (%rcx), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xbde8
jmp 0xcb53
movslq 0xc(%rbx), %rax
cmpl 0x10(%rbx), %eax
je 0xcc15
imulq $0x18, %rax, %rax
cmpb $0x1, 0x14(%r13,%rax)
jne 0xcc15
addq %r13, %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xbffe
jmp 0xcb53
movq %r14, %rdi
callq 0x8437
jmp 0xcb53
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x3088, %ebx           # imm = 0x3088
addq 0x9380(%rip), %rbx      # 0x15fb8
leaq 0x81(%rip), %r14        # 0xccc0
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x3460
testl %eax, %eax
jne 0xcc3f
movl $0x3090, %ebx           # imm = 0x3090
addq 0x935a(%rip), %rbx      # 0x15fb8
leaq 0x6b(%rip), %r14        # 0xccd0
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x3460
testl %eax, %eax
jne 0xcc65
leaq 0xa0b1(%rip), %r15      # 0x16d30
leaq 0x80(%r15), %rax
leaq -0x20(%rbp), %rbx
movq %rax, (%rbx)
leaq 0xa084(%rip), %r14      # 0x16d18
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5ec2
addq $0x84, %r15
movq %r15, (%rbx)
leaq -0x20(%rbp), %rsi
movq %r14, %rdi
callq 0x5ec2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/mips.cpp
// Function: main
int main(int argc, char** argv)
{
    if (argc < 2 || argc > 3)
    {
        cout<<"Require 1 or 2 arguments"<<endl;
        return -1;
    }
    if (argc == 3)
        debug_level = stoi(argv[2]);
    if (!read_config_instrs(string(argv[1])))
        return -1;
    init_CPU_ROB();
    init_FUs();
    init_FU_CDB();
    init_main_mem();
    init_issue_unit();
    init_brcUnit();
    init_output_unit();
    msg_log("Threads count is: "+to_string(clk_wait_list.size()), 0);
    msg_log("instr buffer size is: " + to_string(instr_Q->size), 3);
    start_sys_clk();
    cin.get();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
leal -0x4(%rdi), %eax
cmpl $-0x3, %eax
ja 0xcd14
movq 0x92c5(%rip), %rdi      # 0x15fc0
leaq 0x2b6e(%rip), %rsi      # 0xf870
callq 0x3280
movq %rax, %rdi
callq 0x3160
jmp 0xce4a
movq %rsi, %rbx
cmpl $0x3, %edi
jne 0xcd4a
movq 0x10(%rbx), %rsi
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x30(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x9fdb
movl %eax, 0xd09f(%rip)      # 0x19de0
leaq -0x30(%rbp), %rdi
callq 0x3140
movq 0x8(%rbx), %rsi
leaq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x3100
leaq -0x90(%rbp), %rdi
callq 0x861e
movl %eax, %ebx
leaq -0x90(%rbp), %rdi
callq 0x3140
testb %bl, %bl
je 0xce4a
callq 0x720e
callq 0x56b1
callq 0x3ced
callq 0xcc22
callq 0xb9fd
callq 0x7943
callq 0xda2e
movq 0x9f76(%rip), %rsi      # 0x16d20
subq 0x9f67(%rip), %rsi      # 0x16d18
sarq $0x3, %rsi
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xcf01
leaq 0x2ac1(%rip), %rsi      # 0xf889
leaq -0x70(%rbp), %rdi
movq %rbx, %rdx
callq 0x5a8a
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x8343
leaq -0x70(%rbp), %rdi
callq 0x3140
leaq -0x30(%rbp), %rdi
callq 0x3140
movq 0x9570(%rip), %rax      # 0x16368
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0xcf01
leaq 0x2a91(%rip), %rsi      # 0xf89c
leaq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x5a8a
leaq -0x50(%rbp), %rdi
pushq $0x3
popq %rsi
callq 0x8343
leaq -0x50(%rbp), %rdi
callq 0x3140
leaq -0x30(%rbp), %rdi
callq 0x3140
callq 0x848b
movq 0x919f(%rip), %rdi      # 0x15fe0
callq 0x32e0
xorl %eax, %eax
jmp 0xce4d
pushq $-0x1
popq %rax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0xce69
jmp 0xce72
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x3140
jmp 0xce75
jmp 0xce72
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0xce87
jmp 0xce8e
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x3140
jmp 0xce91
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
andl $0x0, 0xc3aa(%rip)      # 0x19dec
leaq -0x40(%rbp), %rbx
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andl $0x0, -0x18(%rax)
leaq 0x1f5c(%rip), %rsi      # 0xf9bd
movq %rbx, %rdi
callq 0x34a0
leaq 0xc358(%rip), %rdi      # 0x19dc8
leaq -0x48(%rbp), %rsi
callq 0xe08e
leaq 0xc370(%rip), %r14      # 0x19df0
leaq -0x6ce(%rip), %r15      # 0xd3b9
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x3460
testl %eax, %eax
jne 0xda87
leaq 0xc34b(%rip), %rax      # 0x19dec
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x9269(%rip), %rdi      # 0x16d18
callq 0x5ec2
movq %rbx, %rdi
callq 0x3140
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdac9
movq %rax, %r14
movq %rbx, %rdi
callq 0x3140
movq %r14, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x10(%rdi)
movl %esi, %eax
shlq $0x2, %rax
xorl %r12d, %r12d
testl %esi, %esi
pushq $-0x1
popq %r15
cmovnsq %rax, %r15
cmovlel %r12d, %ebx
movq %r15, %rdi
callq 0x3030
movq %rax, (%r14)
cmpq %r12, %rbx
je 0xe408
andl $0x0, (%rax,%r12,4)
incq %r12
jmp 0xe3f9
movq %r15, %rdi
callq 0x3030
movq %rax, 0x8(%r14)
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0xe424
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0xe416
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rcx
decq %rcx
leaq -0x60(%rbp), %r12
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x32a0
pushq $0xa
popq %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x9fdb
movl %eax, %r12d
leaq -0x60(%rbp), %rdi
callq 0x3140
cmpl 0x10(%r14), %r12d
jge 0xe4c5
movq (%r15), %rax
movzbl (%rax), %eax
cmpl $0x46, %eax
je 0xe4e9
cmpl $0x52, %eax
jne 0xe500
movslq %r12d, %rax
shlq $0x2, %rax
addq (%r14), %rax
jmp 0xe4f4
leaq 0x1518(%rip), %rdx      # 0xf9e4
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe6cc
movq %rbx, %rdi
callq 0x7ee9
leaq -0x80(%rbp), %rdi
jmp 0xe521
movslq %r12d, %rax
shlq $0x2, %rax
addq 0x8(%r14), %rax
movss (%rax), %xmm0
movss %xmm0, (%rbx)
movb $0x1, %al
jmp 0xe528
leaq 0x14f7(%rip), %rsi      # 0xf9fe
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x3100
leaq -0x40(%rbp), %rdi
callq 0x7ee9
leaq -0x40(%rbp), %rdi
callq 0x3140
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0xe553
movq %rax, %rbx
jmp 0xe558
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
jmp 0xe553
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O2/Ziang95[P]Tomasulo_simulator/registor.cpp
// Function: registor::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, memCell)
bool registor::set(string name, memCell val)
{
    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')
    {
        if (index == 0)
        {
            err_log("R0 can't be modified");
            return false;
        }
        intReg[index] = val.i;
    }
    else if (name[0] == 'F')
        flpReg[index] = val.f;
    else
    {
        err_log("Reg name error");
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rcx
decq %rcx
leaq -0x40(%rbp), %r12
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x32a0
pushq $0xa
popq %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x9fdb
movl %eax, %r12d
leaq -0x40(%rbp), %rdi
callq 0x3140
cmpl 0x10(%r14), %r12d
jge 0xe5c9
movq (%r15), %rax
movzbl (%rax), %eax
cmpl $0x46, %eax
je 0xe5f3
cmpl $0x52, %eax
jne 0xe601
testl %r12d, %r12d
je 0xe624
movq (%r14), %rax
jmp 0xe5f7
leaq 0x1414(%rip), %rdx      # 0xf9e4
leaq -0xa0(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe6cc
movq %rbx, %rdi
callq 0x7ee9
leaq -0xa0(%rbp), %rdi
jmp 0xe645
movq 0x8(%r14), %rax
movslq %r12d, %rcx
movl %ebx, (%rax,%rcx,4)
movb $0x1, %al
jmp 0xe64c
leaq 0x13f6(%rip), %rsi      # 0xf9fe
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x3100
leaq -0x60(%rbp), %rdi
callq 0x7ee9
leaq -0x60(%rbp), %rdi
jmp 0xe645
leaq 0x13e2(%rip), %rsi      # 0xfa0d
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x3100
leaq -0x80(%rbp), %rdi
callq 0x7ee9
leaq -0x80(%rbp), %rdi
callq 0x3140
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
jmp 0xe688
jmp 0xe670
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
jmp 0xe688
movq %rax, %rbx
jmp 0xe68d
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
jmp 0xe688
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3140
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rcx
xorl %edx, %edx
movslq 0x10(%rdi), %rax
cmpq %rax, %rdx
jge 0xe6b1
andl $0x0, (%rcx,%rdx,4)
incq %rdx
jmp 0xe69f
movq 0x8(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0xe6ca
andl $0x0, (%rcx,%rdx,4)
incq %rdx
jmp 0xe6bc
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, 0x34(%rdi)
movq %rsi, 0x48(%rdi)
andw $0x0, (%rdi)
orl $-0x1, 0x4(%rdi)
movw $0x101, 0x2c(%rdi)      # imm = 0x101
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x7a42(%rip), %r12      # 0x16370
movq (%r12), %rdi
callq 0x6cf4
movl %eax, %r15d
movq (%r12), %rdi
callq 0x6cfc
movl %eax, %r12d
movl 0x4(%rbx), %esi
movl %r14d, %edi
movl %r15d, %edx
movl %eax, %ecx
callq 0xc3de
testb %al, %al
jne 0xe984
movl 0x8(%rbx), %esi
movl %r14d, %edi
movl %r15d, %edx
movl %r12d, %ecx
callq 0xc3de
testb %al, %al
jne 0xe984
movl 0xc(%rbx), %esi
movl %r14d, %edi
movl %r15d, %edx
movl %r12d, %ecx
callq 0xc3de
testb %al, %al
je 0xe987
movb $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/EmbeddedPaul166[P]SNMP-Agent/src/main.cpp
// Function: main
int main() 
{
    char * pPath =  getenv("PROJECT_PATH");
    if (pPath == nullptr)
    {
        std::cout << "Error: Source set-env file first" << std::endl;
        return 0;
    }
    std::string filePath(pPath);
    filePath += "/mibs/RFC1213-MIB.txt";
    Manager manager;
    manager.parse(filePath);
    encodeASequence(manager);
    encodeASequenceInsideASequence(manager);
    
    while (1)
    {
        std::string input;
        std::cout << std::endl;
        std::cout << "Input OID string:" << std::endl;
        std::cin >> input;
        std::cout << std::endl;
        if (std::cin.fail())
        {
            std::cout << "Bad input!" << std::endl;
            continue;
        }
        else
        {
            manager.getNodeByOID(input);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x13ed0(%rip), %rdi     # 0x190eb
callq 0x43a0
testq %rax, %rax
jne 0x5254
movq 0x22d84(%rip), %rdi     # 0x27fb0
leaq 0x13ec5(%rip), %rsi     # 0x190f8
callq 0x4300
movq %rax, %rdi
callq 0x4190
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x68(%rsp), %rbx
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5398
leaq 0x13ea9(%rip), %rsi     # 0x19119
movq %rbx, %rdi
callq 0x4590
leaq 0x20(%rsp), %rdi
callq 0x5840
leaq 0x48(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x4410
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5ab4
leaq 0x48(%rsp), %rdi
callq 0x4170
leaq 0x20(%rsp), %rdi
callq 0x479c
leaq 0x20(%rsp), %rdi
callq 0x4ee7
leaq 0x10(%rsp), %r13
movq 0x22ce6(%rip), %rbx     # 0x27fb0
leaq 0x13e5e(%rip), %r14     # 0x1912f
movq 0x22d08(%rip), %r15     # 0x27fe0
movq %rsp, %r12
leaq 0x13e5f(%rip), %rbp     # 0x19141
movq %r13, (%rsp)
andq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x4190
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4300
movq %rax, %rdi
callq 0x4190
movq %r15, %rdi
movq %r12, %rsi
callq 0x43d0
movq %rbx, %rdi
callq 0x4190
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
je 0x5343
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x4300
movq %rax, %rdi
callq 0x4190
jmp 0x5350
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x5dc8
movq %r12, %rdi
callq 0x4170
jmp 0x52e2
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x536a
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4170
jmp 0x5374
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x596a
jmp 0x5385
jmp 0x5382
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x10(%rdi), %r15
leaq 0x18(%rdi), %r13
leaq 0x20(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
andq $0x0, 0x20(%rdi)
movq %rsp, %rdi
callq 0x6372
movq %rsp, %rbp
movq (%rbp), %rsi
andq $0x0, (%rbp)
movq %rbx, %rdi
callq 0x670a
movq %rbp, %rdi
callq 0x63b0
movq %rsp, %rdi
callq 0x63ca
movq %rsp, %rbp
movq (%rbp), %rsi
andq $0x0, (%rbp)
movq %r14, %rdi
callq 0x673c
movq %rbp, %rdi
callq 0x6408
movq %rsp, %rdi
callq 0x6422
movq %rsp, %rbp
movq (%rbp), %rsi
andq $0x0, (%rbp)
movq %r15, %rdi
callq 0x676e
movq %rbp, %rdi
callq 0x6460
movq %rsp, %rdi
callq 0x647a
movq %rsp, %rbp
movq (%rbp), %rsi
andq $0x0, (%rbp)
movq %r13, %rdi
callq 0x67a0
movq %rbp, %rdi
callq 0x64b8
movq %rsp, %rdi
callq 0x64d2
movq %rsp, %rbx
movq (%rbx), %rsi
andq $0x0, (%rbx)
movq %r12, %rdi
callq 0x67d2
movq %rbx, %rdi
callq 0x6510
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5936
jmp 0x5936
jmp 0x5936
jmp 0x5936
movq %rax, %rbp
movq %r12, %rdi
callq 0x6510
movq %r13, %rdi
callq 0x64b8
movq %r15, %rdi
callq 0x6460
movq %r14, %rdi
callq 0x6408
movq %rbx, %rdi
callq 0x63b0
movq %rbp, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, %r12
movq %rsi, 0x10(%rsp)
cmpl $0x6, (%rsi)
jne 0x5a5d
movq %rcx, %r15
movq 0x8(%rsp), %rax
leaq 0x20(%rax), %rsi
movq %rcx, %rdi
callq 0x652a
movq 0x8(%r15), %rax
subq (%r15), %rax
cmpq $0x20, %rax
jne 0x5a5d
movq (%r12), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
pushq $0x50
popq %rcx
cqto
idivq %rcx
movq %rax, %r13
imulq $0x50, %rax, %rbp
addq $-0x50, %rbp
movq %rax, %r14
shlq $0x5, %r14
addq $-0x20, %r14
leaq 0x18(%rsp), %rbx
subq $0x1, %r13
jb 0x5a5d
movq (%r12), %rax
movq 0x18(%rax), %rdi
addq %r14, %rdi
movq (%r15), %rsi
callq 0x53d3
testb %al, %al
je 0x5a53
movq (%r12), %rax
movq (%rax), %rsi
addq %rbp, %rsi
movq %rbx, %rdi
callq 0x65f4
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
callq 0x652a
movq %rbx, %rdi
callq 0x18002
addq $-0x50, %rbp
addq $-0x20, %r14
jmp 0x5a0f
movq 0x18(%r12), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x6d90
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x18002
movq %rbx, %rdi
callq 0x4540
nop
// File: /workspace/github_cpp_makefile_star2_O2/EmbeddedPaul166[P]SNMP-Agent/src/manager.cpp
// Function: Manager::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Manager::parse(std::string filePath)
{
    std::string fileContent = m_pFileHandler -> readFile(filePath);
    std::string importPath = m_pParser -> isImportPresent(fileContent);
    if (importPath != "")
    {
        std::string importContent = m_pFileHandler -> readFile(importPath);
        m_pParser -> parseMIBImportFile(importContent);
    }
    m_pParser -> parseMIBFile(fileContent);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %r14
movq 0x8(%rdi), %r15
leaq 0xe0(%rsp), %rbx
movq %rbx, %rdi
callq 0x4410
leaq 0xc0(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6df0
leaq 0xe0(%rsp), %rdi
callq 0x4170
movq (%r14), %r15
leaq 0xa0(%rsp), %rdi
leaq 0xc0(%rsp), %rbx
movq %rbx, %rsi
callq 0x4410
movq %rsp, %rdi
leaq 0xa0(%rsp), %rdx
movq %r15, %rsi
callq 0x8038
leaq 0xa0(%rsp), %rdi
callq 0x4170
leaq 0x13c9b(%rip), %rsi     # 0x197d4
movq %rsp, %rdi
callq 0x6649
testb %al, %al
je 0x5bae
movq 0x8(%r14), %r15
leaq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x4410
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rdx
movq %r15, %rsi
callq 0x6df0
leaq 0x60(%rsp), %rdi
callq 0x4170
movq (%r14), %r15
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x4410
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x86ac
leaq 0x40(%rsp), %rdi
callq 0x4170
leaq 0x80(%rsp), %rdi
callq 0x4170
movq (%r14), %r14
leaq 0x20(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x4410
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0xb41e
leaq 0x20(%rsp), %rdi
callq 0x4170
movq %rsp, %rdi
callq 0x4170
leaq 0xc0(%rsp), %rdi
callq 0x4170
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x4170
jmp 0x5c0e
movq %rax, %r14
leaq 0x80(%rsp), %rdi
jmp 0x5c2c
movq %rax, %r14
leaq 0x60(%rsp), %rdi
jmp 0x5c2c
jmp 0x5c47
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x4170
jmp 0x5c4a
movq %rax, %r14
leaq 0xa0(%rsp), %rdi
jmp 0x5c4d
jmp 0x5c42
movq %rax, %r14
jmp 0x5c52
movq %rax, %r14
movq %rsp, %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4170
movq %r14, %rdi
callq 0x4540