LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ivanzamanov[P]kmeans/src/extractor/extractor.cpp
// Function: processFile(int, stat*)
void processFile(int inputFD, struct stat* const fileStat) {
	char* fullData = 0;
	readFullData(inputFD, &fullData);

	matcher* startMarker;
	matcher* endMarker;
	build_matcher("<BODY>", startMarker);
	build_matcher("</BODY>", endMarker);
	article_match* lastArticleMatch = 0;
	int lastArticleEndPos = 0;

	// Read articles while found
	do {
		char* offsetData = fullData + lastArticleEndPos;
		// Try to find an article
		lastArticleMatch = get_match(offsetData, *startMarker, *endMarker);
		if(lastArticleMatch != 0) {
			// Found an article, save it
			save_article(lastArticleMatch, offsetData, articleCount + articleIndexOffset);
			articleCount++;
			// Move offset after the article's end.
			lastArticleEndPos = lastArticleEndPos + lastArticleMatch->end;
			delete lastArticleMatch;
		}
	} while(lastArticleMatch != 0);

	delete fullData;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %rbx, %rsi
callq 0x1870
leaq 0xd7b(%rip), %rdi       # 0x207e
leaq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x14d8
leaq 0xd6e(%rip), %rdi       # 0x2085
leaq 0x10(%rsp), %r15
movq %r15, %rsi
callq 0x14d8
movq (%rbx), %rbx
movq (%r14), %rsi
movq (%r15), %rdx
movq %rbx, %rdi
callq 0x13a5
testq %rax, %rax
je 0x1391
movq %rax, %r14
xorl %r15d, %r15d
movl 0x2d76(%rip), %edx      # 0x40bc
addl 0x2d6c(%rip), %edx      # 0x40b8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13fe
incl 0x2d5b(%rip)            # 0x40b8
movslq 0x4(%r14), %rax
movslq %r15d, %r15
addq %rax, %r15
movq %r14, %rdi
callq 0x10b0
movq %r15, %rbx
addq 0x8(%rsp), %rbx
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x13a5
movq %rax, %r14
testq %rax, %rax
jne 0x1340
movq 0x8(%rsp), %rdi
callq 0x10b0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ivanzamanov[P]kmeans/src/extractor/extractor.cpp
// Function: get_match(char const*, matcher const&, matcher const&)
article_match* get_match(const char* data, const matcher& startMarker, const matcher& endMarker) {
	// Search for the start marker
	int start = search(data, startMarker);
	int end = -1;
	if(start >= 0) {
			// Search for the end marker after the start
			end = search(data + start, endMarker);
			end = end + start;
			if(end > start) {
				// Found, return a reference
				article_match* result = new article_match(start + startMarker.n, end);
				return result;
			}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x169f
testl %eax, %eax
js 0x13f1
movl %eax, %ebp
movl %eax, %eax
addq %rax, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x169f
testl %eax, %eax
jle 0x13f1
movl %eax, %r14d
addl %ebp, %r14d
movl $0x8, %edi
callq 0x10c0
movl 0x8(%rbx), %ecx
addl %ebp, %ecx
movl %ecx, (%rax)
movl %r14d, 0x4(%rax)
jmp 0x13f3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ivanzamanov[P]kmeans/src/common/matcher.cpp
// Function: search(char const*, matcher const&)
int search(char const* string, const matcher& matcher) {
	unsigned int i = 0;
	unsigned int n = 0;
	while(*string != 0) {
		i++;
		int c = (int)*string;
		string++;
		if(c < matcher.min_char || c > matcher.max_char) {
			n = 0;
			continue;
		}
		n = matcher.table[n][c - matcher.min_char];
		if(n == matcher.n) {
			return i - n;
		}
	}
	return -1;
}

// Assembly:
movb (%rdi), %r10b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %r10b, %r10b
je 0x1706
pushq %rbx
movsbq 0xc(%rsi), %rcx
movb 0xd(%rsi), %dl
movq 0x10(%rsi), %r8
movl 0x8(%rsi), %r9d
movl $0x1, %esi
subl %r9d, %esi
incq %rdi
xorl %r11d, %r11d
movl $0x0, %ebx
cmpb %cl, %r10b
jl 0x16f1
cmpb %dl, %r10b
jg 0x16f1
movsbq %r10b, %r10
movl %r11d, %r11d
movq (%r8,%r11,8), %r11
subq %rcx, %r10
movl (%r11,%r10,4), %ebx
cmpl %r9d, %ebx
je 0x1703
movb (%rdi), %r10b
incl %esi
incq %rdi
movl %ebx, %r11d
testb %r10b, %r10b
jne 0x16cb
jmp 0x1705
movl %esi, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/j-faria[P]kima/examples/multi_instrument/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    // set the RV data files from multiple instruments
    datafiles = {"HD106252_ELODIE.txt",
                 "HD106252_HET.txt",
                 "HD106252_HJS.txt",
                 "HD106252_Lick.txt"
                };

    // note: all files should have the same structure, and be in the same units
    load_multi(datafiles, "ms", 2);

    // could also do (but not both!)
    //char* datafile = "HD106252_joined.txt";
    // load_multi(datafile, "ms", 1);

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(100);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x6c0, %rsp            # imm = 0x6C0
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2249a(%rip), %rsi     # 0x428ed
leaq 0x224a6(%rip), %rdx     # 0x42900
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x17fba
leaq 0x28(%rsp), %r15
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x22485(%rip), %rsi     # 0x42901
leaq 0x2248e(%rip), %rdx     # 0x42911
movq %r15, %rdi
callq 0x17fba
leaq 0x48(%rsp), %r15
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x22472(%rip), %rsi     # 0x42912
leaq 0x2247b(%rip), %rdx     # 0x42922
movq %r15, %rdi
callq 0x17fba
leaq 0x68(%rsp), %r15
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2245e(%rip), %rsi     # 0x42923
leaq 0x22468(%rip), %rdx     # 0x42934
movq %r15, %rdi
callq 0x17fba
leaq 0x88(%rsp), %r14
leaq 0x3007d(%rip), %rdi     # 0x50560
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x32d48
movq $-0x80, %r14
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x2050d
movq (%r12), %rsi
incq %rsi
callq 0x6460
addq $-0x20, %r12
addq $0x20, %r14
jne 0x204f7
leaq 0x8(%rsp), %rdx
movl $0x2, (%rdx)
leaq 0x30037(%rip), %rdi     # 0x50560
leaq 0x1cfe1(%rip), %rsi     # 0x3d511
callq 0x20779
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x20853
movq %r14, %rdi
movl $0x64, %esi
callq 0x20924
leaq 0x8(%rsp), %rdi
callq 0x20b02
xorl %eax, %eax
addq $0x6c0, %rsp            # imm = 0x6C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b02
jmp 0x205c5
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x68c0
jmp 0x205c5
jmp 0x20595
jmp 0x20595
movq %rax, %rbx
addq $-0x10, %r15
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0x205b0
movq (%r15), %rsi
incq %rsi
callq 0x6460
leaq -0x20(%r15), %rax
addq $-0x10, %r15
cmpq %r14, %r15
movq %rax, %r15
jne 0x2059c
jmp 0x205c5
movq %rax, %rbx
movq %rbx, %rdi
callq 0x6710
nop
// File: /workspace/github_cpp_makefile_star2_O3/akitsu-sanae[P]adtpp/src/adt.cpp
// Function: convert_to_dtor_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string convert_to_dtor_name(std::string str) {
    // remove template parameter
    // ex) std::vector<double> ==> std::vector
    while (true) {
        int temp_count = 0;
        auto temp_start = std::string::npos;
        auto temp_end = std::string::npos;
        for (auto it=std::begin(str); it!=std::end(str); it++) {
            if (*it == '<') {
                if (temp_count == 0)
                    temp_start = it - std::begin(str);
                temp_count++;
            }
            if (*it == '>') {
                temp_count--;
                if (temp_count == 0)
                    temp_end = it - std::begin(str);
            }
        }
        if (temp_start == std::string::npos)
            break;
        if (temp_end == std::string::npos)
                break;
        str.erase(temp_start, temp_end);
    }

    // remove namespace
    // ex) std::vector ==> vector
    auto found = str.find_last_of(':');
    if (found != std::string::npos)
        str.erase(0, found+1);
    return str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x257b
movq (%rbx), %rcx
addq %rcx, %rax
movq $-0x1, %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movq $-0x1, %rdx
movzbl (%rcx,%rdi), %r9d
cmpl $0x3e, %r9d
je 0x253d
cmpl $0x3c, %r9d
jne 0x2548
testl %r8d, %r8d
cmoveq %rdi, %rsi
incl %r8d
jmp 0x2548
decl %r8d
jne 0x2548
xorl %r8d, %r8d
movq %rdi, %rdx
leaq (%rcx,%rdi), %r9
incq %r9
incq %rdi
cmpq %rax, %r9
jne 0x2520
cmpq $-0x1, %rsi
je 0x257b
cmpq $-0x1, %rdx
je 0x257b
movq %rbx, %rdi
callq 0x2050
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
leaq (%rcx,%rdx), %rax
testq %rdx, %rdx
jne 0x250d
movq %rbx, %rdi
movl $0x3a, %esi
movq $-0x1, %rdx
callq 0x22e0
cmpq $-0x1, %rax
je 0x25a5
incq %rax
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x2050
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x25c4
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x25ca
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/akitsu-sanae[P]adtpp/src/main.cpp
// Function: trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trim(std::string& input) {
    auto start = std::begin(input);
    while (std::isspace(*start))
        start++;
    auto last = std::end(input);
    while (std::isspace(*(last-1)))
        last--;
    input = std::string{start, last};
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %r15
leaq -0x1(%r15), %r14
movsbl 0x1(%r14), %edi
incq %r14
callq 0x2040
testl %eax, %eax
jne 0x6d8f
movq 0x8(%rbx), %rax
addq %rax, %r15
incq %r15
movsbl -0x2(%r15), %edi
callq 0x2040
decq %r15
testl %eax, %eax
jne 0x6daa
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7b82
movq %rbx, %rdi
movq %r12, %rsi
callq 0x21f0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x6df6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: FU_CDB::enQ(memCell*, int)
bool FU_CDB::enQ(memCell *v, int s)
{
    pthread_mutex_lock(&Q_lock);
    if ((rear+1)%Q_LEN == front)
    {
        err_log("The reserv_CDB queue is full");
        pthread_mutex_unlock(&Q_lock);
        return false;
    }
    int index = rear;
    rear = (++rear)%Q_LEN;
    int pos = 0;
    for (; (front + pos)%Q_LEN != index && queue[(front + pos)%Q_LEN].source < s; pos++);
    for (int i = index; (Q_LEN + i)%Q_LEN != (front + pos)%Q_LEN; i--)
        queue[(Q_LEN+i)%Q_LEN] = queue[(Q_LEN+i-1)%Q_LEN];
    index = (front+pos)%Q_LEN;
    queue[index].value = *v;
    queue[index].source = s;
    pthread_mutex_unlock(&Q_lock);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
leaq 0x810(%rdi), %rbx
movq %rbx, %rdi
callq 0x3380
movl 0x808(%r15), %r13d
movl 0x80c(%r15), %eax
leal 0x1(%rax), %ecx
leal 0x100(%rax), %edx
testl %ecx, %ecx
cmovsl %edx, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
negl %ecx
leal (%rax,%rcx), %r12d
incl %r12d
cmpl %r13d, %r12d
je 0x3c99
movl %r12d, 0x80c(%r15)
leal 0xff(%r13), %ecx
testl %r13d, %r13d
cmovnsl %r13d, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl %r13d, %edi
subl %ecx, %edi
movl %eax, %ecx
cmpl %eax, %edi
je 0x3c35
leal 0x1(%r13), %esi
movl %edi, %ecx
movslq %ecx, %rdi
cmpl %r14d, 0x4(%r15,%rdi,8)
jge 0x3c35
leal 0xff(%rsi), %edi
testl %esi, %esi
cmovnsl %esi, %edi
andl $0xffffff00, %edi       # imm = 0xFFFFFF00
movl %esi, %ecx
subl %edi, %ecx
incl %esi
cmpl %eax, %ecx
jne 0x3c0e
movl %eax, %ecx
leal 0x1ff(%rax), %esi
testl %edx, %edx
cmovnsl %edx, %esi
andl $0xffffff00, %esi       # imm = 0xFFFFFF00
negl %esi
leal (%rax,%rsi), %edx
addl $0x100, %edx            # imm = 0x100
cmpl %ecx, %edx
je 0x3c85
addl $0xff, %eax
leal 0xff(%rax), %esi
testl %eax, %eax
cmovnsl %eax, %esi
andl $0xffffff00, %esi       # imm = 0xFFFFFF00
movslq %edx, %rdx
movl %eax, %edi
subl %esi, %edi
movslq %edi, %rsi
movq (%r15,%rsi,8), %r8
movq %r8, (%r15,%rdx,8)
decl %eax
movl %edi, %edx
cmpl %ecx, %esi
jne 0x3c5a
movslq %ecx, %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%r15,%rax,8)
movl %r14d, 0x4(%r15,%rax,8)
jmp 0x3cd1
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1135c(%rip), %rsi     # 0x15004
leaq 0x11371(%rip), %rdx     # 0x15020
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x721e
movq %r14, %rdi
callq 0x97ab
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3cd1
callq 0x3230
movq %rbx, %rdi
callq 0x31e0
cmpl %r13d, %r12d
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3cff
callq 0x3230
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: FU_CDB::squash(int)
void FU_CDB::squash(int ROB_i)
{
    int R_f = CPU_ROB->get_front();
    int R_r = CPU_ROB->get_rear();
    pthread_mutex_lock(&Q_lock);
    if (front == rear)
    {
        pthread_mutex_unlock(&Q_lock);
        return;
    }
    for (int i = rear; ;)
    {
        int j = (i-1)%Q_LEN;
        if (j == front || !is_prev_index(ROB_i, queue[j].source, R_f, R_r))
            break;
        rear = j;
        i = (--i)%Q_LEN;
    }
    if (is_prev_index(ROB_i, bus.source, R_f, R_r))
        bus.source = -2;
    pthread_mutex_unlock(&Q_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x17629(%rip), %r15     # 0x1b368
movq (%r15), %rdi
callq 0x8028
movl %eax, %r12d
movq (%r15), %rdi
callq 0x8030
movl %eax, %r13d
leaq 0x810(%rbx), %r15
movq %r15, %rdi
callq 0x3380
movl 0x808(%rbx), %eax
movl 0x80c(%rbx), %ecx
cmpl %ecx, %eax
je 0x3e0b
movq %r15, -0x30(%rbp)
leal -0x1(%rcx), %edx
leal 0xfe(%rcx), %esi
testl %edx, %edx
cmovnsl %edx, %esi
andl $0xffffff00, %esi       # imm = 0xFFFFFF00
negl %esi
leal (%rcx,%rsi), %r15d
decl %r15d
cmpl %eax, %r15d
je 0x3de5
movslq %r15d, %rax
movl 0x4(%rbx,%rax,8), %esi
movl %r14d, %edi
movl %r12d, %edx
movl %r13d, %ecx
callq 0xf79f
testb %al, %al
je 0x3de5
movl %r15d, 0x80c(%rbx)
leal -0x1(%r15), %eax
leal 0xfe(%r15), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
negl %ecx
addl %ecx, %r15d
decl %r15d
cmpl 0x808(%rbx), %r15d
jne 0x3d9e
movl 0x804(%rbx), %esi
movl %r14d, %edi
movl %r12d, %edx
movl %r13d, %ecx
callq 0xf79f
testb %al, %al
movq -0x30(%rbp), %r15
je 0x3e0b
movl $0xfffffffe, 0x804(%rbx) # imm = 0xFFFFFFFE
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: FU_CDB::CDB_automat()
void FU_CDB::CDB_automat()
{
    next_vdd = 0;
    while(true)
    {
        at_rising_edge(next_vdd);
        at_falling_edge(next_vdd);
        pthread_mutex_lock(&Q_lock);
        if (front != rear)
        {
            bus.source = queue[front].source;
            bus.value = queue[front].value;
            msg_log("About to broadcast, source ROB = " + to_string(bus.source), 3);
            front = (++front)%Q_LEN;
        }
        pthread_mutex_unlock(&Q_lock);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x838(%rdi), %r14
movl $0x0, 0x838(%rdi)
leaq 0x810(%rdi), %r15
movq %r14, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
movq %r14, %rdi
callq 0x9feb
movq %r14, %rdi
callq 0xa049
movq %r15, %rdi
callq 0x3380
movslq 0x808(%rbx), %rax
cmpl 0x80c(%rbx), %eax
je 0x3fe5
movl 0x4(%rbx,%rax,8), %r14d
movl %r14d, 0x804(%rbx)
movl (%rbx,%rax,8), %eax
movl %eax, 0x800(%rbx)
movl %r14d, %r13d
negl %r13d
cmovsl %r14d, %r13d
movl $0x1, %r12d
cmpl $0xa, %r13d
jb 0x3ef3
movl $0x4, %r12d
movl %r13d, %eax
movl $0xd1b71759, %edx       # imm = 0xD1B71759
cmpl $0x63, %eax
jbe 0x3eea
cmpl $0x3e7, %eax            # imm = 0x3E7
jbe 0x3ef0
cmpl $0x2710, %eax           # imm = 0x2710
jb 0x3ef3
movl %eax, %ecx
imulq %rdx, %rcx
shrq $0x2d, %rcx
addl $0x4, %r12d
cmpl $0x1869f, %eax          # imm = 0x1869F
movl %ecx, %eax
ja 0x3eba
addl $-0x3, %r12d
jmp 0x3ef3
addl $-0x2, %r12d
jmp 0x3ef3
decl %r12d
movq %r15, %rbx
shrl $0x1f, %r14d
movl %r14d, %esi
addl %r12d, %esi
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movl $0x2d, %edx
callq 0x32b0
movq -0x58(%rbp), %rdi
addq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x7056
movl $0x21, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
leaq 0x110e2(%rip), %rcx     # 0x15021
callq 0x3280
leaq -0x68(%rbp), %r14
movq %r14, -0x78(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3f68
movq %rdx, -0x78(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x68(%rbp)
jmp 0x3f6f
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %rbx, %r15
movq 0x8(%rax), %rdx
movq %rdx, -0x70(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x78(%rbp), %rdi
movl $0x3, %esi
callq 0x9f0f
movq -0x38(%rbp), %rbx
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x3fa9
callq 0x3230
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
movq -0x30(%rbp), %r14
je 0x3fbf
callq 0x3230
movl 0x808(%rbx), %eax
leal 0x1(%rax), %ecx
leal 0x100(%rax), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
andl $0xffffff00, %edx       # imm = 0xFFFFFF00
negl %edx
addl %edx, %eax
incl %eax
movl %eax, 0x808(%rbx)
movq %r15, %rdi
callq 0x31e0
jmp 0x3e56
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x4008
callq 0x3230
jmp 0x4008
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x401a
callq 0x3230
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: FU_Q::squash(int)
void FU_Q::squash(int ROB_i)
{
    int R_f = CPU_ROB->get_front();
    int R_r = CPU_ROB->get_rear();
    pthread_mutex_lock(&Q_lock);
    if (front == rear)
    {
        pthread_mutex_unlock(&Q_lock);
        return;
    }
    for (int i = rear; ;)
    {
        int j = (i-1)%Q_LEN;
        if (j == front || !is_prev_index(ROB_i, queue[j].dest, R_f, R_r))
            break;
        rear = j;
        i = (--i)%Q_LEN;
    }
    pthread_mutex_unlock(&Q_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x170c4(%rip), %r12     # 0x1b368
movq (%r12), %rdi
callq 0x8028
movl %eax, %r15d
movq (%r12), %rdi
callq 0x8030
movl %eax, %r13d
leaq 0x3808(%r14), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3380
movl 0x3800(%r14), %eax
movl 0x3804(%r14), %ecx
cmpl %ecx, %eax
je 0x434d
leal -0x1(%rcx), %edx
leal 0xfe(%rcx), %esi
testl %edx, %edx
cmovnsl %edx, %esi
andl $0xffffff00, %esi       # imm = 0xFFFFFF00
negl %esi
leal (%rcx,%rsi), %r12d
decl %r12d
cmpl %eax, %r12d
je 0x434d
movslq %r12d, %rax
imulq $0x38, %rax, %rax
movl 0x4(%r14,%rax), %esi
movl %ebx, %edi
movl %r15d, %edx
movl %r13d, %ecx
callq 0xf79f
testb %al, %al
je 0x434d
movl %r12d, 0x3804(%r14)
leal -0x1(%r12), %eax
leal 0xfe(%r12), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
negl %ecx
addl %ecx, %r12d
decl %r12d
cmpl 0x3800(%r14), %r12d
jne 0x4300
movq -0x30(%rbp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: FU_Q::deQ()
FU_QEntry *FU_Q::deQ()
{
    if (front == rear)
        return nullptr;
    FU_QEntry* ret = &queue[front];
    front = (++front)%Q_LEN;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x3800(%rdi), %rcx
cmpl 0x3804(%rdi), %ecx
jne 0x437b
xorl %eax, %eax
jmp 0x43a2
imulq $0x38, %rcx, %rax
addq %rdi, %rax
leal 0x1(%rcx), %edx
leal 0x100(%rcx), %esi
testl %edx, %edx
cmovnsl %edx, %esi
andl $0xffffff00, %esi       # imm = 0xFFFFFF00
negl %esi
addl %esi, %ecx
incl %ecx
movl %ecx, 0x3800(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: functionUnit::squash(int)
void functionUnit::squash(int ROB_i)
{
    for (auto _rs : rs)
        _rs->squash(ROB_i);
    queue.squash(ROB_i);
    squash_p.R_f = CPU_ROB->get_front();
    squash_p.R_r = CPU_ROB->get_rear();
    squash_p.ROB_i = brcUnit.squash_ROB_i();
    squash_p.flag = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x3870(%rdi), %r15
movq 0x3878(%rdi), %r12
cmpq %r12, %r15
je 0x43d9
movq (%r15), %rdi
movl %r14d, %esi
callq 0x13dea
addq $0x8, %r15
jmp 0x43c3
leaq 0x8(%rbx), %rdi
movl %r14d, %esi
callq 0x428a
leaq 0x16f7c(%rip), %r14     # 0x1b368
movq (%r14), %rdi
callq 0x8028
movl %eax, 0x3898(%rbx)
movq (%r14), %rdi
callq 0x8030
movl %eax, 0x389c(%rbx)
leaq 0x16f81(%rip), %rdi     # 0x1b390
callq 0x8fd4
movl %eax, 0x38a0(%rbx)
movb $0x1, 0x38a4(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: intAdder::intAdder()
intAdder::intAdder()
{
    for (int i = 0; i<CPU_cfg->int_add->rs_num; i++)
    {
        auto tmp = new resStation(&queue, INTGR);
        init_resStation(tmp);
        rs.push_back(tmp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x3870(%rdi)
movq $0x0, 0x3880(%rdi)
movb $0x0, 0x38a4(%rdi)
movups %xmm0, 0x3808(%rdi)
movups %xmm0, 0x3818(%rdi)
movups %xmm0, 0x3828(%rdi)
leaq 0x16835(%rip), %rax     # 0x1aca8
movq %rax, (%rdi)
leaq 0x16edb(%rip), %r12     # 0x1b358
movq (%r12), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
jle 0x4503
movq %rdi, %rbx
leaq 0x3870(%rdi), %rax
movq %rax, -0x38(%rbp)
leaq 0x8(%rdi), %r15
xorl %r14d, %r14d
movl $0x50, %edi
callq 0x3250
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x139c0
movq %r13, -0x30(%rbp)
movq %r13, %rdi
callq 0x14b41
movq 0x3878(%rbx), %rsi
cmpq 0x3880(%rbx), %rsi
je 0x44e6
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x3878(%rbx)
jmp 0x44f3
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x73f6
incl %r14d
movq (%r12), %rax
movq 0x8(%rax), %rax
cmpl (%rax), %r14d
jl 0x449f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, %rdi
callq 0x3230
jmp 0x4522
movq %rax, %r14
leaq 0x1684f(%rip), %rax     # 0x1ad78
movq %rax, (%rbx)
movq 0x3870(%rbx), %rdi
testq %rdi, %rdi
je 0x453d
callq 0x3230
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: flpAdder::flpAdder()
flpAdder::flpAdder()
{
    for (int i = 0; i<CPU_cfg->fp_add->rs_num; i++)
    {
        auto tmp = new resStation(&queue, FLTP);
        init_resStation(tmp);
        rs.push_back(tmp);
    }
    int latency = CPU_cfg->fp_add->exe_time - 1;
    pLatency_Q = nullptr;
    if (latency)
    {
        pLatency_Q = new FU_QEntry[latency];
        for (int i = 0; i<latency; i++)
            pLatency_Q[i].res = nullptr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x3870(%rdi)
movq $0x0, 0x3880(%rdi)
movb $0x0, 0x38a4(%rdi)
movups %xmm0, 0x3808(%rdi)
movups %xmm0, 0x3818(%rdi)
movups %xmm0, 0x3828(%rdi)
leaq 0x15b10(%rip), %rax     # 0x1acc0
movq %rax, (%rdi)
leaq 0x1619e(%rip), %r12     # 0x1b358
movq (%r12), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
jle 0x5240
leaq 0x3870(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0x8(%rbx), %r15
xorl %r14d, %r14d
movl $0x50, %edi
callq 0x3250
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x139c0
movq %r13, -0x30(%rbp)
movq %r13, %rdi
callq 0x14b41
movq 0x3878(%rbx), %rsi
cmpq 0x3880(%rbx), %rsi
je 0x5223
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x3878(%rbx)
jmp 0x5230
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x73f6
incl %r14d
movq (%r12), %rax
movq 0x10(%rax), %rax
cmpl (%rax), %r14d
jl 0x51d9
movslq 0x4(%rax), %r15
leaq -0x1(%r15), %r14
movq $0x0, 0x38a8(%rbx)
testl %r14d, %r14d
je 0x529b
movl $0x38, %ecx
movq %r14, %rax
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x3030
movq %rax, 0x38a8(%rbx)
cmpl $0x2, %r15d
jl 0x529b
movl %r14d, %ecx
imulq $0x38, %rcx, %rcx
xorl %edx, %edx
movq $0x0, 0x8(%rax,%rdx)
addq $0x38, %rdx
cmpq %rdx, %rcx
jne 0x5289
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x52b9
movq %rax, %r14
movq %r13, %rdi
callq 0x3230
jmp 0x52bc
movq %rax, %r14
leaq 0x15ab5(%rip), %rax     # 0x1ad78
movq %rax, (%rbx)
movq 0x3870(%rbx), %rdi
testq %rdi, %rdi
je 0x52d7
callq 0x3230
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: flpAdder::~flpAdder()
flpAdder::~flpAdder()
{
    for (auto &p : rs)
    {
        delete p;
        p = nullptr;
    }
    if (pLatency_Q)
        delete pLatency_Q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x159cc(%rip), %rax     # 0x1acc0
movq %rax, (%rdi)
movq 0x3870(%rdi), %r14
movq 0x3878(%rdi), %r15
cmpq %r15, %r14
je 0x531f
movq (%r14), %rdi
callq 0x3230
movq $0x0, (%r14)
addq $0x8, %r14
jmp 0x5305
movq 0x38a8(%rbx), %rdi
testq %rdi, %rdi
je 0x5330
callq 0x3230
leaq 0x15a41(%rip), %rax     # 0x1ad78
movq %rax, (%rbx)
movq 0x3870(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x5355
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3230
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: flpAdder::shift(FU_QEntry&, FU_QEntry&)
void flpAdder::shift(FU_QEntry &in, FU_QEntry &out)
{
    int size = CPU_cfg->fp_add->exe_time - 1;
    if (!size)
    {
        out = in;
        return;
    }
    out = pLatency_Q[size-1];
    for (int i = size-1; i>0; i--)
        pLatency_Q[i] = pLatency_Q[i-1];
    pLatency_Q[0] = in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x15ff1(%rip), %rax     # 0x1b358
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rax), %rax
cmpq $0x1, %rax
je 0x5402
movl %eax, %ecx
movq 0x38a8(%rdi), %r8
addq $-0x2, %rax
imulq $0x38, %rax, %r9
movq 0x30(%r8,%r9), %r10
movq %r10, 0x30(%rdx)
movups (%r8,%r9), %xmm0
movups 0x10(%r8,%r9), %xmm1
movups 0x20(%r8,%r9), %xmm2
movups %xmm2, 0x20(%rdx)
movups %xmm1, 0x10(%rdx)
movups %xmm0, (%rdx)
cmpl $0x3, %ecx
jl 0x53fb
movl %eax, %eax
imulq $0x38, %rax, %rcx
incq %rax
movq 0x38a8(%rdi), %rdx
movq -0x8(%rdx,%rcx), %r8
movq %r8, 0x30(%rdx,%rcx)
movups -0x38(%rdx,%rcx), %xmm0
movups -0x28(%rdx,%rcx), %xmm1
movups -0x18(%rdx,%rcx), %xmm2
movups %xmm2, 0x20(%rdx,%rcx)
movups %xmm1, 0x10(%rdx,%rcx)
movups %xmm0, (%rdx,%rcx)
decq %rax
addq $-0x38, %rcx
cmpq $0x1, %rax
ja 0x53c0
movq 0x38a8(%rdi), %rdx
movq 0x30(%rsi), %rax
movq %rax, 0x30(%rdx)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x20(%rdx)
movups %xmm1, 0x10(%rdx)
movups %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: flpMtplr::flpMtplr()
flpMtplr::flpMtplr()
{
    for (int i = 0; i<CPU_cfg->fp_mul->rs_num; i++)
    {
        auto tmp = new resStation(&queue, FLTP);
        init_resStation(tmp);
        rs.push_back(tmp);
    }
    int latency = CPU_cfg->fp_mul->exe_time - 1;
    pLatency_Q = nullptr;
    if (latency)
    {
        pLatency_Q = new FU_QEntry[latency];
        for (int i = 0; i<latency; i++)
            pLatency_Q[i].res = nullptr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x3870(%rdi)
movq $0x0, 0x3880(%rdi)
movb $0x0, 0x38a4(%rdi)
movups %xmm0, 0x3808(%rdi)
movups %xmm0, 0x3818(%rdi)
movups %xmm0, 0x3828(%rdi)
leaq 0x153de(%rip), %rax     # 0x1acd8
movq %rax, (%rdi)
leaq 0x15a54(%rip), %r12     # 0x1b358
movq (%r12), %rax
movq 0x18(%rax), %rax
cmpl $0x0, (%rax)
jle 0x598a
leaq 0x3870(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0x8(%rbx), %r15
xorl %r14d, %r14d
movl $0x50, %edi
callq 0x3250
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x139c0
movq %r13, -0x30(%rbp)
movq %r13, %rdi
callq 0x14b41
movq 0x3878(%rbx), %rsi
cmpq 0x3880(%rbx), %rsi
je 0x596d
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x3878(%rbx)
jmp 0x597a
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x73f6
incl %r14d
movq (%r12), %rax
movq 0x18(%rax), %rax
cmpl (%rax), %r14d
jl 0x5923
movslq 0x4(%rax), %r15
leaq -0x1(%r15), %r14
movq $0x0, 0x38a8(%rbx)
testl %r14d, %r14d
je 0x59e5
movl $0x38, %ecx
movq %r14, %rax
mulq %rcx
movq $-0x1, %rdi
cmovnoq %rax, %rdi
callq 0x3030
movq %rax, 0x38a8(%rbx)
cmpl $0x2, %r15d
jl 0x59e5
movl %r14d, %ecx
imulq $0x38, %rcx, %rcx
xorl %edx, %edx
movq $0x0, 0x8(%rax,%rdx)
addq $0x38, %rdx
cmpq %rdx, %rcx
jne 0x59d3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5a03
movq %rax, %r14
movq %r13, %rdi
callq 0x3230
jmp 0x5a06
movq %rax, %r14
leaq 0x1536b(%rip), %rax     # 0x1ad78
movq %rax, (%rbx)
movq 0x3870(%rbx), %rdi
testq %rdi, %rdi
je 0x5a21
callq 0x3230
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: flpMtplr::~flpMtplr()
flpMtplr::~flpMtplr()
{
    for (auto &p : rs)
    {
        delete p;
        p = nullptr;
    }
    if (pLatency_Q)
        delete pLatency_Q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1529a(%rip), %rax     # 0x1acd8
movq %rax, (%rdi)
movq 0x3870(%rdi), %r14
movq 0x3878(%rdi), %r15
cmpq %r15, %r14
je 0x5a69
movq (%r14), %rdi
callq 0x3230
movq $0x0, (%r14)
addq $0x8, %r14
jmp 0x5a4f
movq 0x38a8(%rbx), %rdi
testq %rdi, %rdi
je 0x5a7a
callq 0x3230
leaq 0x152f7(%rip), %rax     # 0x1ad78
movq %rax, (%rbx)
movq 0x3870(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x5a9f
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3230
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: flpMtplr::shift(FU_QEntry&, FU_QEntry&)
void flpMtplr::shift(FU_QEntry &in, FU_QEntry &out)
{
    int size = CPU_cfg->fp_mul->exe_time - 1;
    if (!size)
    {
        out = in;
        return;
    }
    out = pLatency_Q[size-1];
    for (int i = size-1; i>0; i--)
        pLatency_Q[i] = pLatency_Q[i-1];
    pLatency_Q[0] = in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x158a7(%rip), %rax     # 0x1b358
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rax
cmpq $0x1, %rax
je 0x5b4c
movl %eax, %ecx
movq 0x38a8(%rdi), %r8
addq $-0x2, %rax
imulq $0x38, %rax, %r9
movq 0x30(%r8,%r9), %r10
movq %r10, 0x30(%rdx)
movups (%r8,%r9), %xmm0
movups 0x10(%r8,%r9), %xmm1
movups 0x20(%r8,%r9), %xmm2
movups %xmm2, 0x20(%rdx)
movups %xmm1, 0x10(%rdx)
movups %xmm0, (%rdx)
cmpl $0x3, %ecx
jl 0x5b45
movl %eax, %eax
imulq $0x38, %rax, %rcx
incq %rax
movq 0x38a8(%rdi), %rdx
movq -0x8(%rdx,%rcx), %r8
movq %r8, 0x30(%rdx,%rcx)
movups -0x38(%rdx,%rcx), %xmm0
movups -0x28(%rdx,%rcx), %xmm1
movups -0x18(%rdx,%rcx), %xmm2
movups %xmm2, 0x20(%rdx,%rcx)
movups %xmm1, 0x10(%rdx,%rcx)
movups %xmm0, (%rdx,%rcx)
decq %rax
addq $-0x38, %rcx
cmpq $0x1, %rax
ja 0x5b0a
movq 0x38a8(%rdi), %rdx
movq 0x30(%rsi), %rax
movq %rax, 0x30(%rdx)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x20(%rdx)
movups %xmm1, 0x10(%rdx)
movups %xmm0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: ldsdUnit::ldsdUnit()
ldsdUnit::ldsdUnit()
{
    for (int i = 0; i<CPU_cfg->ld_str->rs_num; i++)
    {
        auto tmp = new resStation(&queue, INTGR);
        init_resStation(tmp);
        rs.push_back(tmp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movups %xmm0, 0x3870(%rdi)
movq $0x0, 0x3880(%rdi)
movb $0x0, 0x38a4(%rdi)
movups %xmm0, 0x3808(%rdi)
movups %xmm0, 0x3818(%rdi)
movups %xmm0, 0x3828(%rdi)
leaq 0x14caf(%rip), %rax     # 0x1acf0
movq %rax, (%rdi)
leaq 0x1530d(%rip), %r12     # 0x1b358
movq (%r12), %rax
movq 0x20(%rax), %rax
cmpl $0x0, (%rax)
jle 0x60d1
movq %rdi, %rbx
leaq 0x3870(%rdi), %rax
movq %rax, -0x38(%rbp)
leaq 0x8(%rdi), %r15
xorl %r14d, %r14d
movl $0x50, %edi
callq 0x3250
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x139c0
movq %r13, -0x30(%rbp)
movq %r13, %rdi
callq 0x14b41
movq 0x3878(%rbx), %rsi
cmpq 0x3880(%rbx), %rsi
je 0x60b4
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x3878(%rbx)
jmp 0x60c1
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x73f6
incl %r14d
movq (%r12), %rax
movq 0x20(%rax), %rax
cmpl (%rax), %r14d
jl 0x606d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, %rdi
callq 0x3230
jmp 0x60f0
movq %rax, %r14
leaq 0x14c81(%rip), %rax     # 0x1ad78
movq %rax, (%rbx)
movq 0x3870(%rbx), %rdi
testq %rdi, %rdi
je 0x610b
callq 0x3230
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O3/Ziang95[P]Tomasulo_simulator/FU.cpp
// Function: nopBublr::nopBublr()
nopBublr::nopBublr()
{
    bubble.ROB_i = -1;
    bubble.ROB_E = nullptr;
    for (int i = 0; i<3; i++)
    {
        shifter[i].ROB_i = -1;
        shifter[i].ROB_E = nullptr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, (%rdi)     # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rdi)
xorl %eax, %eax
movl $0xffffffff, 0x10(%rdi,%rax) # imm = 0xFFFFFFFF
movq $0x0, 0x18(%rdi,%rax)
addq $0x10, %rax
cmpq $0x30, %rax
jne 0x6990
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, 0x48(%rdi)
leaq 0x10(%rdi), %r12
leaq 0x20(%rdi), %r13
leaq 0x15235(%rip), %r15     # 0x1bca0
movq %r14, %rdi
callq 0x9feb
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%r13)
movups %xmm0, (%r13)
movups (%rbx), %xmm0
movups %xmm0, (%r12)
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rbx)
cmpq $0x0, 0x18(%rbx)
je 0x6ab4
movq %r15, %rdi
callq 0x96d0
movq 0x18(%rbx), %rcx
movl %eax, 0x54(%rcx)
cmpq $0x0, 0x28(%rbx)
je 0x6ace
movq %r15, %rdi
callq 0x96d0
movq 0x28(%rbx), %rcx
movl %eax, 0x5c(%rcx)
movb $0x1, 0x1(%rcx)
cmpq $0x0, 0x38(%rbx)
je 0x6ae7
movq %r15, %rdi
callq 0x96d0
movq 0x38(%rbx), %rcx
movl %eax, 0x60(%rcx)
movb $0x1, (%rcx)
movq %r14, %rdi
callq 0xa049
jmp 0x6a6b
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x20, %rsp
testl %esi, %esi
js 0x7fbc
cmpl %esi, 0x10(%rdi)
jle 0x7fbc
movl %esi, %eax
leaq (%rax,%rax,4), %rax
shlq $0x5, %rax
addq 0x8(%rdi), %rax
jmp 0x7ff6
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd25e(%rip), %rsi      # 0x15229
leaq 0xd26e(%rip), %rdx      # 0x15240
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x721e
movq %rbx, %rdi
callq 0x97ab
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x7ff4
callq 0x3230
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x8010
callq 0x3230
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/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 0x80b4
movl %edx, 0x4(%rdi)
movq 0x8(%rdi), %r15
leaq (%rbx,%rbx,4), %r12
shlq $0x5, %r12
leaq (%r15,%r12), %rdi
addq $0x8, %rdi
movl %ecx, 0x44(%rdi)
callq 0x3160
addq %r12, %r15
addq $0x28, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3160
movw $0x0, -0x28(%r15)
leaq 0x13c0a(%rip), %rdi     # 0x1bca0
callq 0x96d0
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
movl $0x4, %edi
callq 0x3140
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x12ec5(%rip), %rsi     # 0x1af90
movq %rax, %rdi
xorl %edx, %edx
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x127e7(%rip), %r14     # 0x1b368
movq (%r14), %rbx
testq %rbx, %rbx
je 0x8b99
movq %rbx, %rdi
callq 0x7f04
movq %rbx, %rdi
callq 0x3230
movl $0x28, %edi
callq 0x3250
movq %rax, %rbx
leaq 0x127ab(%rip), %rax     # 0x1b358
movq (%rax), %rax
movq (%rax), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x7e50
movq %rbx, (%r14)
leaq -0x61(%rip), %rbx       # 0x8b66
movq (%r14), %rcx
leaq 0x18(%rcx), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x3460
testl %eax, %eax
jne 0x8bc7
movq (%r14), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq 0x13122(%rip), %rcx     # 0x1bd10
movq 0x8(%rcx), %rsi
cmpq 0x10(%rcx), %rsi
je 0x8c02
movq %rax, (%rsi)
addq $0x8, 0x8(%rcx)
jmp 0x8c12
leaq 0x13107(%rip), %rdi     # 0x1bd10
leaq -0x18(%rbp), %rdx
callq 0x72bc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x125fc(%rip), %rcx     # 0x1bd10
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0x9743
movl $0x1, %edx
movq (%rax), %rsi
testq %rsi, %rsi
je 0x974a
imull (%rsi), %edx
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x9725
xorl %ebx, %ebx
cmpl $0x1, %edx
sete %bl
jmp 0x9787
movl $0x1, %ebx
jmp 0x9787
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xbb42(%rip), %rsi      # 0x1529b
leaq 0xbb60(%rip), %rdx      # 0x152c0
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x721e
movq %rbx, %rdi
callq 0x97ab
movq -0x30(%rbp), %rdi
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq %r14, %rdi
je 0x9787
callq 0x3230
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x97a3
callq 0x3230
movq %rbx, %rdi
callq 0x3440
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x12483(%rip), %rcx     # 0x1bd10
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
cmpq %rcx, %rax
je 0x98b7
xorl %edx, %edx
movq (%rax), %rsi
testq %rsi, %rsi
je 0x98be
addl (%rsi), %edx
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x989b
xorl %ebx, %ebx
testl %edx, %edx
sete %bl
jmp 0x98fb
movl $0x1, %ebx
jmp 0x98fb
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xb9ce(%rip), %rsi      # 0x1529b
leaq 0xb9ec(%rip), %rdx      # 0x152c0
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x721e
movq %rbx, %rdi
callq 0x97ab
movq -0x30(%rbp), %rdi
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq %r14, %rdi
je 0x98fb
callq 0x3230
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x9917
callq 0x3230
movq %rbx, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14ec2(%rip), %rax     # 0x1edd8
cmpl %esi, (%rax)
jge 0x9f1b
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x11360(%rip), %rbx     # 0x1b290
movq %rbx, %rdi
callq 0x3380
movq 0x11091(%rip), %r15     # 0x1afd0
leaq 0xb3e8(%rip), %rsi      # 0x1532e
movl $0x9, %edx
movq %r15, %rdi
callq 0x32a0
leaq 0x11d46(%rip), %r12     # 0x1bca0
movl 0x4(%r12), %esi
movq %r15, %rdi
callq 0x3430
movq %rax, %r15
leaq 0xb3c7(%rip), %rsi      # 0x15338
movl $0x6, %edx
movq %rax, %rdi
callq 0x32a0
movzbl (%r12), %esi
movq %r15, %rdi
callq 0x3400
movq %rax, %r15
leaq 0xb3aa(%rip), %rsi      # 0x1533f
movl $0x2, %edx
movq %rax, %rdi
callq 0x32a0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x32a0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31a0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
leaq 0x112b9(%rip), %rdi     # 0x1b2b8
callq 0x3380
movl $0x1, (%rbx)
leaq 0x11c8f(%rip), %r15     # 0x1bca0
cmpb $0x0, (%r15)
jne 0xa033
leaq 0x10(%r15), %rbx
leaq 0x11296(%rip), %r14     # 0x1b2b8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3390
cmpb $0x1, (%r15)
jne 0xa022
leaq 0x1127e(%rip), %rdi     # 0x1b2b8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
leaq 0x1125b(%rip), %rdi     # 0x1b2b8
callq 0x3380
movl $0x0, (%rbx)
leaq 0x11c31(%rip), %r15     # 0x1bca0
cmpb $0x1, (%r15)
jne 0xa091
leaq 0x40(%r15), %rbx
leaq 0x11238(%rip), %r14     # 0x1b2b8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3390
cmpb $0x0, (%r15)
jne 0xa080
leaq 0x11220(%rip), %rdi     # 0x1b2b8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8(%rdi), %r14
testq %r14, %r14
je 0xa12f
movq (%rbx), %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
callq 0x3480
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0xa119
leaq 0xb23e(%rip), %rsi      # 0x15374
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0xa221
leaq 0xb22b(%rip), %rsi      # 0x15378
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0xa225
leaq 0xb21a(%rip), %rsi      # 0x1537e
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0xa22c
leaq 0xb208(%rip), %rsi      # 0x15383
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0xa233
leaq 0xb1f5(%rip), %rsi      # 0x15387
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0xa23a
leaq 0xb1e4(%rip), %rsi      # 0x1538d
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0xa241
leaq 0xb1d4(%rip), %rsi      # 0x15394
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0xa248
leaq 0xb1c5(%rip), %rsi      # 0x15398
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0xa24f
leaq 0xb1b6(%rip), %rsi      # 0x1539c
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0xa256
leaq 0xb1a6(%rip), %rsi      # 0x1539f
movq %rbx, %rdi
callq 0x30c0
testl %eax, %eax
je 0xa25d
leaq 0xb196(%rip), %rsi      # 0x153a2
movq %rbx, %rdi
callq 0x30c0
cmpl $0x1, %eax
movl $0xb, %eax
sbbl $0x0, %eax
jmp 0xa262
xorl %eax, %eax
jmp 0xa262
movl $0x1, %eax
jmp 0xa262
movl $0x4, %eax
jmp 0xa262
movl $0x2, %eax
jmp 0xa262
movl $0x3, %eax
jmp 0xa262
movl $0x5, %eax
jmp 0xa262
movl $0x9, %eax
jmp 0xa262
movl $0x8, %eax
jmp 0xa262
movl $0x6, %eax
jmp 0xa262
movl $0x7, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq