LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: KokiKishimoto[P]cp_decomposition/testcp.cpp
// Function: TestCP::generate_key(std::vector<Triple, std::allocator<Triple>>&)
void generate_key(std::vector<Triple>& triples){
		for (Triple& t : triples) {
			Key k1(t.relation, t.obj);
			subjSet[k1].insert(t.subj);

			Key k2(t.relation, t.subj);
			objSet[k2].insert(t.obj);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x75b0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x75e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7610
testb $0x1, %al
jne 0x53c0
jmp 0x545b
leaq -0x20(%rbp), %rdi
callq 0x7650
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdx
addq $0x4, %rdx
leaq -0x38(%rbp), %rdi
callq 0xf740
movq -0x68(%rbp), %rdi
addq $0x318, %rdi            # imm = 0x318
leaq -0x38(%rbp), %rsi
callq 0xf770
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0xf850
movq %rax, -0x48(%rbp)
movb %dl, -0x40(%rbp)
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0xf740
movq -0x68(%rbp), %rdi
addq $0x348, %rdi            # imm = 0x348
leaq -0x50(%rbp), %rsi
callq 0xf770
movq %rax, %rdi
movq -0x30(%rbp), %rsi
addq $0x4, %rsi
callq 0xf850
movq %rax, -0x60(%rbp)
movb %dl, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7700
jmp 0x53aa
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: KokiKishimoto[P]cp_decomposition/./testdata.hpp
// Function: TestData::addEntity(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Data&)
int addEntity(std::string entity, Data& data) {
		if (data.entity_dict.find(entity) == data.entity_dict.end()) {
			return -1;
		} else {
			return data.entity_dict[entity];
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x7750
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x7780
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7720
testb $0x1, %al
jne 0xa9ed
jmp 0xa9f6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xaa0c
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x77b0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: KokiKishimoto[P]cp_decomposition/./testdata.hpp
// Function: TestData::addRelation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Data&)
int addRelation(std::string relation, Data& data) {
		if (data.relation_dict.find(relation) == data.relation_dict.end()) {
			return -1;
		} else {
			return data.relation_dict[relation];
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x7750
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x7780
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7720
testb $0x1, %al
jne 0xaa6d
jmp 0xaa76
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xaa8c
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x77b0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: KokiKishimoto[P]cp_decomposition/testcp.cpp
// Function: TestCP::pre_score_inv(int, int, int, int)
void pre_score_inv(int subj, int relation, int relation_inv, int obj) {
		const std::vector<double>& obj_v = objVec[obj];
		const std::vector<double>& obj_v_inv = subjVec[obj];
		const std::vector<double>& relation_v = relationVec[relation];
		const std::vector<double>& relation_v_inv = relationVec[relation_inv];
		const std::vector<double>& subj_v = subjVec[subj];
		const std::vector<double>& subj_v_inv = objVec[subj];

		op.product(subj_v, obj_v, relation_v, outVec1, outVec2, outVec3);
		op.product(obj_v_inv, subj_v_inv, relation_v_inv, outVec1_inv, outVec2_inv, outVec3_inv);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x250, %rdi            # imm = 0x250
movslq -0x18(%rbp), %rsi
callq 0xc860
movq -0x80(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x238, %rdi            # imm = 0x238
movslq -0x18(%rbp), %rsi
callq 0xc860
movq -0x80(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x268, %rdi            # imm = 0x268
movslq -0x10(%rbp), %rsi
callq 0xc860
movq -0x80(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x268, %rdi            # imm = 0x268
movslq -0x14(%rbp), %rsi
callq 0xc860
movq -0x80(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x238, %rdi            # imm = 0x238
movslq -0xc(%rbp), %rsi
callq 0xc860
movq -0x80(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x250, %rdi            # imm = 0x250
movslq -0xc(%rbp), %rsi
callq 0xc860
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq %rax, %rsi
addq $0x310, %rsi            # imm = 0x310
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
movq %rax, %r9
addq $0x280, %r9             # imm = 0x280
movq %rax, %r10
addq $0x298, %r10            # imm = 0x298
addq $0x2b0, %rax            # imm = 0x2B0
leaq -0x60(%rbp), %rdi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x11d20
leaq -0x60(%rbp), %rdi
callq 0x57c0
movq -0x80(%rbp), %rax
movq %rax, %rsi
addq $0x310, %rsi            # imm = 0x310
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %r8
movq %rax, %r9
addq $0x2c8, %r9             # imm = 0x2C8
movq %rax, %r10
addq $0x2e0, %r10            # imm = 0x2E0
addq $0x2f8, %rax            # imm = 0x2F8
leaq -0x78(%rbp), %rdi
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x11d20
leaq -0x78(%rbp), %rdi
callq 0x57c0
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: KokiKishimoto[P]cp_decomposition/testcp.cpp
// Function: TestCP::generate_rank(std::vector<RankScore, std::allocator<RankScore>>&, int, int, int, std::map<std::pair<int, int>, std::set<int, std::less<int>, std::allocator<int>>, std::less<std::pair<int, int>>, std::allocator<std::pair<std::pair<int, int> const, std::set<int, std::less<int>, std::allocator<int>>>>>&, std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
void generate_rank(std::vector<RankScore>& scores_ent, int relation, int ent1, int ent2, std::map<Key, std::set<int> >& entSet, std::vector<double>& rank, std::vector<double>& rank_filter){
		std::sort(scores_ent.begin(), scores_ent.end());
		Key k_e(relation, ent2);
		const std::set<int>& hypo_e = entSet[k_e];
		int k = 0;
		for (int i=0; i<scores_ent.size(); ++i) {
			RankScore& re = scores_ent[i];
			if (re.id == ent1) {
				rank.push_back(i);
				rank_filter.push_back(k);
				std::cout << i << ' ' << k << std::endl;
				break;
			}
			if (hypo_e.find(re.id) == hypo_e.end()) {
				++k;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbad0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb750
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11f40
leaq -0x40(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0xf740
movq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xf770
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
movslq -0x50(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb120
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x11b72
movq -0x10(%rbp), %rdi
movslq -0x50(%rbp), %rsi
callq 0x11910
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x11b24
movq 0x10(%rbp), %rdi
cvtsi2sdl -0x50(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x11f80
movq 0x18(%rbp), %rdi
cvtsi2sdl -0x4c(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x11f80
movl -0x50(%rbp), %esi
movq 0xd4e2(%rip), %rdi      # 0x1efd8
callq 0x2390
movq %rax, %rdi
movl $0x20, %esi
callq 0x22b0
movq %rax, %rdi
movl -0x4c(%rbp), %esi
callq 0x2390
movq %rax, %rdi
movq 0xd4ab(%rip), %rsi      # 0x1efc8
callq 0x2250
jmp 0x11b72
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $0x8, %rsi
callq 0x11fe0
movq %rax, -0x70(%rbp)
movq -0x48(%rbp), %rdi
callq 0x12010
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x11fb0
testb $0x1, %al
jne 0x11b59
jmp 0x11b62
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x11b64
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x11a80
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: KokiKishimoto[P]cp_decomposition/testcp.cpp
// Function: TestCP::calculate_ranking(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&, int)
double calculate_ranking(std::vector<double>& a, std::vector<double>& b, int rank){
		double rank_num = 0.0;
		for(int i=0; i<a.size(); i++){
			if(a[i]<rank){
				rank_num++;       
			}
			if(b[i]<rank){
				rank_num++;       
			}
		}
		return rank_num;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd9e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x11c2f
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xc880
movsd (%rax), %xmm1
cvtsi2sdl -0x1c(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x11bf1
movsd 0x2429(%rip), %xmm0     # 0x14010
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xc880
movsd (%rax), %xmm1
cvtsi2sdl -0x1c(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x11c1f
movsd 0x23fb(%rip), %xmm0     # 0x14010
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x11c21
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11ba6
movsd -0x28(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: KokiKishimoto[P]cp_decomposition/testcp.cpp
// Function: TestCP::calate_mrr(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double calate_mrr(const std::vector<double>& a, const std::vector<double>& b){
		double sum = 0.0;
		double mrr_value = 0.0;
		for(int i=0; i<a.size(); i++){
			sum = sum + 1/(a[i]+1) + 1/(b[i]+1);
		}
		mrr_value = sum;
		return mrr_value;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd9e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x11d06
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x11e80
movsd -0x48(%rbp), %xmm0
movsd 0x2364(%rip), %xmm2     # 0x14010
addsd (%rax), %xmm2
movsd 0x2358(%rip), %xmm1     # 0x14010
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x11e80
movsd -0x40(%rbp), %xmm0
movsd 0x2331(%rip), %xmm2     # 0x14010
addsd (%rax), %xmm2
movsd 0x2325(%rip), %xmm1     # 0x14010
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11c6b
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jaycelq[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree::innerNode::getLower(int)
int BPlusTree::innerNode::getLower(int k)
{
    if(keyNum == 0) return 0;
    int lo = 0, hi = keyNum;

    while(lo < hi) {
        int mid = (lo + hi) / 2;
        if(key[mid] > k) hi = mid;
        else lo = mid + 1;
    }

    return hi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0xc(%rax)
jne 0x2452
movl $0x0, -0x4(%rbp)
jmp 0x24a8
movq -0x28(%rbp), %rax
movl $0x0, -0x18(%rbp)
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x24a2
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x20(%rbp)
movslq -0x20(%rbp), %rcx
movl 0x30(%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jle 0x2497
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x24a0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2463
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: jaycelq[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree::innerNode::insert(int, BPlusTree::Node*)
void BPlusTree::innerNode::insert(int k, Node *p)
{
    int i = 0;
    for(i = keyNum-1; i >= 0 && key[i] > k; i--) {
        key[i+1] = key[i];
        child[i+2] = child[i+1];
    }
    key[i+1] = k;
    child[i+2] = p;
    keyNum++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x29(%rbp)
jl 0x24f7
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl 0x30(%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
setg %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2500
jmp 0x2540
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl 0x30(%rax,%rcx,4), %edx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, 0x30(%rax,%rcx,4)
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq 0x10(%rax,%rcx,8), %rdx
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x24d7
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, 0x30(%rax,%rcx,4)
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jaycelq[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree::leafNode::insert(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void BPlusTree::leafNode::insert(int k, string v)
{
    int i = 0;
    for(i = keyNum-1; i >= 0 && key[i] > k; i--) {
        key[i+1] = key[i];
        value[i+1] = value[i];
    }
    key[i+1] = k;
    value[i+1] = v;
    keyNum++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x31(%rbp)
jl 0x283f
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl 0x70(%rax,%rcx,4), %eax
cmpl -0xc(%rbp), %eax
setg %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2848
jmp 0x2895
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movl 0x70(%rdi,%rax,4), %ecx
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cltq
movl %ecx, 0x70(%rdi,%rax,4)
movq %rdi, %rsi
addq $0x10, %rsi
movslq -0x1c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
addq $0x10, %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x5, %rax
addq %rax, %rdi
callq 0x2030
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x281f
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0xc(%rbp), %ecx
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cltq
movl %ecx, 0x70(%rdi,%rax,4)
addq $0x10, %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x5, %rax
addq %rax, %rdi
callq 0x2030
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jaycelq[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree::leafNode::split(BPlusTree::leafNode*)
int BPlusTree::leafNode::split(leafNode* newNode)
{
    for(int i = 0; i < minKeyNum; i++) {
        newNode->key[i] = key[i+minKeyNum+1];
        newNode->value[i] = value[i + minKeyNum+1];
    }
    keyNum = minKeyNum + 1;
    newNode->keyNum = minKeyNum;

    newNode->right = right;
    newNode->left = this;
    if(right != NULL) {
        right->left = newNode;
    }
    right = newNode;

    return newNode->key[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x295d
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
addl $0x1, %eax
cltq
movl 0x70(%rsi,%rax,4), %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, 0x70(%rax,%rcx,4)
addq $0x10, %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
addl $0x1, %eax
cltq
shlq $0x5, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x2030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x28ff
movq -0x20(%rbp), %rax
movl $0x2, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl $0x1, 0xc(%rcx)
movq 0x88(%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x88(%rcx)
movq -0x10(%rbp), %rcx
movq %rax, 0x80(%rcx)
cmpq $0x0, 0x88(%rax)
je 0x29b0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x88(%rax), %rax
movq %rcx, 0x80(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rax
movl 0x70(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jaycelq[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree::get(BPlusTree::Node*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool BPlusTree::get(Node* node, int key, string & v)
{
    if(node == NULL) return false;

    if(node->isLeaf) {
        int slot = node->getLower(key) - 1;
        if(((leafNode*)node)->key[slot] == key) {
            v = ((leafNode*)node)->value[slot];
            return true;
        }
    }
    else {
        int slot = node->getLower(key);
        return get(((innerNode*)node)->child[slot], key, v);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x29ff
movb $0x0, -0x1(%rbp)
jmp 0x2a85
movq -0x18(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x2a50
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *(%rax)
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl 0x70(%rax,%rcx,4), %eax
cmpl -0x1c(%rbp), %eax
jne 0x2a4e
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
movslq -0x2c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq -0x28(%rbp), %rdi
callq 0x2030
movb $0x1, -0x1(%rbp)
jmp 0x2a85
jmp 0x2a83
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq (%rdi), %rax
callq *(%rax)
movq -0x38(%rbp), %rdi
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x29d0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2a85
ud2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: CDISC2020[P]Projet_satellite_agile/src/ARINC/kernel_arinc.c
// Function: update_pids
void update_pids(int sig)
{
	FILE* file=NULL;
	file=fopen("listpid", "r");
	if(!file)
		printf("Failed to read listpid");
	else
	{
		int tab[N] = {0};
		fscanf(file,"%d\n%d\n%d\n", pid, pid+1, pid+2); // En fonction de N
		printf("New pids:\n%d\n%d\n%d\n", pid[0], pid[1], pid[2]); // fct N
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0xdfb(%rip), %rdi       # 0x2015
leaq 0xde3(%rip), %rsi       # 0x2004
callq 0x10b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1241
leaq 0xdce(%rip), %rdi       # 0x2006
movb $0x0, %al
callq 0x1060
jmp 0x1298
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0x1070
movq -0x10(%rbp), %rdi
leaq 0xdcb(%rip), %rsi       # 0x2027
leaq 0x2e31(%rip), %rdx      # 0x4094
movq %rdx, %rcx
addq $0x4, %rcx
movq %rdx, %r8
addq $0x8, %r8
movb $0x0, %al
callq 0x1030
movl 0x2e16(%rip), %esi      # 0x4094
movl 0x2e14(%rip), %edx      # 0x4098
movl 0x2e12(%rip), %ecx      # 0x409c
leaq 0xd8c(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nop
// File: CMU-SAFARI[P]ramulator/src/Config.h
// Function: ramulator::Config::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string operator [] (const std::string& name) const {
      if (options.find(name) != options.end()) {
        return (options.find(name))->second;
      } else {
        return "";
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1c1d0
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x1c200
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c1a0
testb $0x1, %al
jne 0x17b44
jmp 0x17b70
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c1d0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c230
movq -0x60(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0xc1c0
jmp 0x17bb5
leaq -0x31(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xc5e0
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x2394c6(%rip), %rsi    # 0x251052
callq 0x17a40
jmp 0x17b93
leaq -0x31(%rbp), %rdi
callq 0xc3c0
jmp 0x17bb5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0xc3c0
jmp 0x17bbf
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xc5d0
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Config.h
// Function: ramulator::Config::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void add (const std::string& name, const std::string& value) {
      if (!contains(name)) {
        options.insert(make_pair(name, value));
      } else {
        printf("ramulator::Config::add options[%s] already set.\n", name.c_str());
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c5d0
testb $0x1, %al
jne 0x17c99
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1c670
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x1c630
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x17c63
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movb %al, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c6b0
jmp 0x17cb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c6b0
jmp 0x17cbc
movq -0x10(%rbp), %rdi
callq 0xc1b0
movq %rax, %rsi
leaq 0x237f69(%rip), %rdi    # 0x24fc15
movb $0x0, %al
callq 0xc070
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xc5d0
nopw %cs:(%rax,%rax)
nop
// File: CMU-SAFARI[P]ramulator/src/Config.h
// Function: ramulator::Config::contains(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool contains(const std::string& name) const {
      if (options.find(name) != options.end()) {
        return true;
      } else {
        return false;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1c1d0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x1c200
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1c1a0
testb $0x1, %al
jne 0x1c615
jmp 0x1c61b
movb $0x1, -0x1(%rbp)
jmp 0x1c61f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/StatType.h
// Function: Stats::ScalarBase<Stats::Scalar>::print(std::basic_ofstream<char, std::char_traits<char>>&)
virtual void print(std::ofstream& file) {
    Stat<ScalarType>::printname(file);
    // TODO deal with flag
    file.precision(Stat<ScalarType>::_precision);
    file.width(20);
    Result res = Stat<ScalarType>::self().result();
    file << std::fixed << res;
    Stat<ScalarType>::printdesc(file);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x265c0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq (%rdi), %rcx
addq -0x18(%rcx), %rdi
movslq 0x48(%rax), %rsi
callq 0x27490
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x14, %esi
callq 0x274c0
movq -0x20(%rbp), %rdi
callq 0x274f0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x10f0(%rip), %rsi      # 0x27500
callq 0xc160
movq %rax, %rdi
movsd -0x18(%rbp), %xmm0
callq 0xc630
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x26610
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: CMU-SAFARI[P]ramulator/src/Config.h
// Function: ramulator::Config::record_cmd_trace() const
bool record_cmd_trace() const {
      // the default value is false
      if (options.find("record_cmd_trace") != options.end()) {
        if ((options.find("record_cmd_trace"))->second == "on") {
          return true;
        }
        return false;
      }
      return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xc5e0
movq -0x90(%rbp), %rdx
leaq 0x223288(%rip), %rsi    # 0x250957
leaq -0x38(%rbp), %rdi
callq 0x17a40
jmp 0x2d6da
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1c1d0
movq %rax, -0xa8(%rbp)
jmp 0x2d6f3
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1c200
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1c1a0
movb %al, -0xa9(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc6b8
leaq -0x39(%rbp), %rdi
callq 0xc3c0
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x2d742
jmp 0x2d84e
movq -0x98(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xc5e0
movq -0xb8(%rbp), %rdx
leaq 0x2231e6(%rip), %rsi    # 0x250957
leaq -0x80(%rbp), %rdi
callq 0x17a40
jmp 0x2d77c
movq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c1d0
movq %rax, -0xc8(%rbp)
jmp 0x2d795
movq -0xc8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1c230
movq %rax, %rdi
addq $0x20, %rdi
leaq 0x223317(%rip), %rsi    # 0x250ace
callq 0x17f10
movb %al, -0xc9(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xc6b8
leaq -0x81(%rbp), %rdi
callq 0xc3c0
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x2d7e3
jmp 0x2d848
movb $0x1, -0x1(%rbp)
jmp 0x2d852
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2d80c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc6b8
leaq -0x39(%rbp), %rdi
callq 0xc3c0
jmp 0x2d860
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2d83a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xc6b8
leaq -0x81(%rbp), %rdi
callq 0xc3c0
jmp 0x2d860
movb $0x0, -0x1(%rbp)
jmp 0x2d852
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xc5d0
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/Config.h
// Function: ramulator::Config::print_cmd_trace() const
bool print_cmd_trace() const {
      // the default value is false
      if (options.find("print_cmd_trace") != options.end()) {
        if ((options.find("print_cmd_trace"))->second == "on") {
          return true;
        }
        return false;
      }
      return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xc5e0
movq -0x90(%rbp), %rdx
leaq 0x2230b9(%rip), %rsi    # 0x250968
leaq -0x38(%rbp), %rdi
callq 0x17a40
jmp 0x2d8ba
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1c1d0
movq %rax, -0xa8(%rbp)
jmp 0x2d8d3
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1c200
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1c1a0
movb %al, -0xa9(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc6b8
leaq -0x39(%rbp), %rdi
callq 0xc3c0
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x2d922
jmp 0x2da2e
movq -0x98(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xc5e0
movq -0xb8(%rbp), %rdx
leaq 0x223017(%rip), %rsi    # 0x250968
leaq -0x80(%rbp), %rdi
callq 0x17a40
jmp 0x2d95c
movq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1c1d0
movq %rax, -0xc8(%rbp)
jmp 0x2d975
movq -0xc8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1c230
movq %rax, %rdi
addq $0x20, %rdi
leaq 0x223137(%rip), %rsi    # 0x250ace
callq 0x17f10
movb %al, -0xc9(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xc6b8
leaq -0x81(%rbp), %rdi
callq 0xc3c0
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x2d9c3
jmp 0x2da28
movb $0x1, -0x1(%rbp)
jmp 0x2da32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2d9ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc6b8
leaq -0x39(%rbp), %rdi
callq 0xc3c0
jmp 0x2da40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2da1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xc6b8
leaq -0x81(%rbp), %rdi
callq 0xc3c0
jmp 0x2da40
movb $0x0, -0x1(%rbp)
jmp 0x2da32
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xc5d0
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/StatType.h
// Function: Stats::VectorBase<Stats::Vector, Stats::Scalar>::print(std::basic_ofstream<char, std::char_traits<char>>&)
void print(std::ofstream& file) {
    Stat<Derived>::printname(file);
    file.precision(Stat<Derived>::_precision);
    file.width(20);
    file << std::fixed << total();
    Stat<Derived>::printdesc(file);
    for (off_type i = 0 ; i < size() ; ++i) {
      data[i].print(file);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2e300
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq (%rdi), %rcx
addq -0x18(%rcx), %rdi
movslq 0x48(%rax), %rsi
callq 0x27490
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x14, %esi
callq 0x274c0
movq -0x10(%rbp), %rdi
leaq -0x6a99(%rip), %rsi     # 0x27500
callq 0xc160
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x28(%rbp), %rdi
callq 0xc630
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e350
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jae 0x2e00b
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e5a0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2dfc9
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/StatType.h
// Function: Stats::VectorBase<Stats::Vector, Stats::Scalar>::vresult() const
VResult vresult() const {
    VResult vres;
    for (off_type i = 0 ; i < size() ; ++i) {
      vres[i] = data[i].result();
    }
    return vres;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x273e0
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x48(%rbp)
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x2e18b
movl -0x48(%rbp), %eax
movl -0x44(%rbp), %ecx
cmpl %ecx, %eax
jae 0x2e1f3
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2e5c0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
movsd %xmm0, -0x50(%rbp)
jmp 0x2e1ba
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2e5e0
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2e173
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2e600
jmp 0x2e210
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2e206
movq -0x40(%rbp), %rdi
callq 0x2e600
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xc5d0
nopl (%rax)
// File: CMU-SAFARI[P]ramulator/src/StatType.h
// Function: Stats::VectorBase<Stats::Vector, Stats::Scalar>::total() const
Result total() const {
    Result sum = 0.0;
    for (off_type i = 0 ; i < size() ; ++i) {
      sum += data[i].result();
    }
    return sum;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jae 0x2e28c
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2e5c0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x60(%rax)
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2e243
movsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/DRAM.h
// Function: ramulator::DRAM<ramulator::DDR3>::check(ramulator::DDR3::Command, int const*, long)
bool DRAM<T>::check(typename T::Command cmd, const int* addr, long clk)
{
    if (next[int(cmd)] != -1 && clk < next[int(cmd)])
        return false; // stop recursion: the check failed at this level

    int child_id = addr[int(level)+1];
    if (child_id < 0 || level == spec->scope[int(cmd)] || !children.size())
        return true; // stop recursion: the check passed at all levels

    // recursively check my child
    return children[child_id]->check(cmd, addr, clk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0x14(%rbp), %rcx
cmpq $-0x1, 0x450(%rax,%rcx,8)
je 0x2f1dd
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rdx
cmpq 0x450(%rcx,%rdx,8), %rax
jge 0x2f1dd
movb $0x0, -0x1(%rbp)
jmp 0x2f263
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x398(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x2f231
movq -0x38(%rbp), %rcx
movl 0x398(%rcx), %eax
movq 0x390(%rcx), %rcx
movslq -0x14(%rbp), %rdx
cmpl 0x180(%rcx,%rdx,4), %eax
je 0x2f231
movq -0x38(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
callq 0x2bfd0
cmpq $0x0, %rax
jne 0x2f237
movb $0x1, -0x1(%rbp)
jmp 0x2f263
movq -0x38(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
movslq -0x2c(%rbp), %rsi
callq 0x2f3f0
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x2f190
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: CMU-SAFARI[P]ramulator/src/DRAM.h
// Function: ramulator::DRAM<ramulator::DDR3>::decode(ramulator::DDR3::Command, int const*)
typename T::Command DRAM<T>::decode(typename T::Command cmd, const int* addr)
{
    int child_id = addr[int(level)+1];
    if (prereq[int(cmd)]) {
        typename T::Command prereq_cmd = prereq[int(cmd)](this, cmd, child_id);
        if (prereq_cmd != T::Command::MAX)
            return prereq_cmd; // stop recursion: there is a prerequisite at this level
    }

    if (child_id < 0 || !children.size())
        return cmd; // stop recursion: there were no prequisites at any level

    // recursively decode at my child
    return children[child_id]->decode(cmd, addr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movl 0x398(%rax), %edx
addl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x24(%rbp)
movq 0x870(%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x2f370
testb $0x1, %al
jne 0x2f2de
jmp 0x2f312
movq -0x30(%rbp), %rsi
movq 0x870(%rsi), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movl -0x14(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0x2f3a0
movl %eax, -0x28(%rbp)
cmpl $0xc, -0x28(%rbp)
je 0x2f310
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f35c
jmp 0x2f312
cmpl $0x0, -0x24(%rbp)
jl 0x2f32e
movq -0x30(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
callq 0x2bfd0
cmpq $0x0, %rax
jne 0x2f336
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f35c
movq -0x30(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
movslq -0x24(%rbp), %rsi
callq 0x2f3f0
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x2f290
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: CMU-SAFARI[P]ramulator/src/Scheduler.h
// Function: ramulator::RowTable<ramulator::DDR3>::get_hits(std::vector<int, std::allocator<int>> const&, bool)
int get_hits(const vector<int>& addr_vec, const bool to_opened_row = false)
    {
        auto begin = addr_vec.begin();
        auto end = begin + int(T::Level::Row);

        vector<int> rowgroup(begin, end);
        int row = *end;

        auto itr = table.find(rowgroup);
        if (itr == table.end())
            return 0;

        if(!to_opened_row && (itr->second.row != row))
            return 0;

        return itr->second.hits;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2fac0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x3, %esi
callq 0x2faf0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2fb30
movq -0x90(%rbp), %rcx
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x2fb50
jmp 0x2f9ae
leaq -0x59(%rbp), %rdi
callq 0x2fbd0
leaq -0x30(%rbp), %rdi
callq 0x2fbf0
movq -0x98(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x70(%rbp)
addq $0x8, %rdi
leaq -0x48(%rbp), %rsi
callq 0x2fc10
movq %rax, -0xa0(%rbp)
jmp 0x2f9e2
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x8, %rdi
callq 0x2fc70
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2fc40
testb $0x1, %al
jne 0x2fa14
jmp 0x2fa55
movl $0x0, -0x4(%rbp)
movl $0x1, -0x84(%rbp)
jmp 0x2fa98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x2fbd0
jmp 0x2faad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2fcd0
jmp 0x2faad
testb $0x1, -0x19(%rbp)
jne 0x2fa7f
leaq -0x78(%rbp), %rdi
callq 0x2fca0
movl 0x18(%rax), %eax
cmpl -0x70(%rbp), %eax
je 0x2fa7f
movl $0x0, -0x4(%rbp)
movl $0x1, -0x84(%rbp)
jmp 0x2fa98
leaq -0x78(%rbp), %rdi
callq 0x2fca0
movl 0x1c(%rax), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x84(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2fcd0
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xc5d0
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/DRAM.h
// Function: ramulator::DRAM<ramulator::DDR3>::check_row_hit(ramulator::DDR3::Command, int const*)
bool DRAM<T>::check_row_hit(typename T::Command cmd, const int* addr)
{
    int child_id = addr[int(level)+1];
    if (rowhit[int(cmd)]) {
        return rowhit[int(cmd)](this, cmd, child_id);  // stop recursion: there is a row hit at this level
    }

    if (child_id < 0 || !children.size())
        return false; // stop recursion: there were no row hits at any level

    // recursively check for row hits at my child
    return children[child_id]->check_row_hit(cmd, addr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movl 0x398(%rax), %edx
addl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x24(%rbp)
movq 0x878(%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x31340
testb $0x1, %al
jne 0x312be
jmp 0x312e6
movq -0x30(%rbp), %rsi
movq 0x878(%rsi), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movl -0x14(%rbp), %edx
movl -0x24(%rbp), %ecx
callq 0x31360
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x31330
cmpl $0x0, -0x24(%rbp)
jl 0x31302
movq -0x30(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
callq 0x2bfd0
cmpq $0x0, %rax
jne 0x31308
movb $0x0, -0x1(%rbp)
jmp 0x31330
movq -0x30(%rbp), %rdi
addq $0x3b0, %rdi            # imm = 0x3B0
movslq -0x24(%rbp), %rsi
callq 0x2f3f0
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x31270
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/StatType.h
// Function: Stats::VectorBase<Stats::Vector, Stats::Scalar>::init(unsigned int)
void init(size_type __size) {
    _size = __size;
    data.resize(size());
    for (off_type i = 0 ; i < size() ; ++i) {
      data[i].flags(0)
             .name("[" + std::string(1, char(i + '0')) + "]");
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl -0xc(%rbp), %eax
movl %eax, 0x70(%rdi)
movq %rdi, %rax
addq $0x78, %rax
movq %rax, -0x98(%rbp)
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x98(%rbp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0x356e0
movl $0x0, -0x10(%rbp)
movq -0xa0(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, %ecx
movl -0xa4(%rbp), %eax
cmpl %ecx, %eax
jae 0x356b2
movq -0xa0(%rbp), %rdi
addq $0x78, %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x2e5a0
movq %rax, -0xc8(%rbp)
leaq -0x12(%rbp), %rdi
xorl %esi, %esi
callq 0x267e0
movq -0xc8(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x2d1a0
movq %rax, -0xc0(%rbp)
movl -0x10(%rbp), %eax
addl $0x30, %eax
movl %eax, -0xb4(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xc5e0
movl -0xb4(%rbp), %eax
movq -0xb0(%rbp), %rcx
movsbl %al, %edx
leaq -0x78(%rbp), %rdi
movl $0x1, %esi
callq 0x2cfe0
jmp 0x355ce
leaq 0x21bb02(%rip), %rsi    # 0x2510d7
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2dba0
jmp 0x355e4
leaq 0x21bb1a(%rip), %rdx    # 0x251105
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2caf0
jmp 0x355fa
movq -0xc0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2ce90
jmp 0x3560c
leaq -0x38(%rbp), %rdi
callq 0xc6b8
leaq -0x58(%rbp), %rdi
callq 0xc6b8
leaq -0x78(%rbp), %rdi
callq 0xc6b8
leaq -0x79(%rbp), %rdi
callq 0xc3c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3552e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x356a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x3569e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x35695
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc6b8
leaq -0x58(%rbp), %rdi
callq 0xc6b8
leaq -0x78(%rbp), %rdi
callq 0xc6b8
leaq -0x79(%rbp), %rdi
callq 0xc3c0
jmp 0x356bb
addq $0xd0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0xc5d0
nopw (%rax,%rax)
// File: CMU-SAFARI[P]ramulator/src/Memory.h
// Function: ramulator::Memory<ramulator::DDR3, ramulator::Controller>::calc_log2(int)
int calc_log2(int val){
        int n = 0;
        while ((val >>= 1))
            n ++;
        return n;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
sarl %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x37c4a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x37c32
movl -0x10(%rbp), %eax
popq %rbp
retq
nop
// File: CMU-SAFARI[P]ramulator/src/Memory.h
// Function: ramulator::Memory<ramulator::DDR3, ramulator::Controller>::pending_requests()
int pending_requests()
    {
        int reqs = 0;
        for (auto ctrl: ctrls)
            reqs += ctrl->readq.size() + ctrl->writeq.size() + ctrl->otherq.size() + ctrl->actq.size() + ctrl->pending.size();
        return reqs;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, -0xc(%rbp)
addq $0xc08, %rax            # imm = 0xC08
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36f70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36e00
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3fd70
testb $0x1, %al
jne 0x38d51
jmp 0x38df4
leaq -0x20(%rbp), %rdi
callq 0x3fdb0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x10c0, %rdi           # imm = 0x10C0
callq 0x3fdd0
movl %eax, -0x44(%rbp)
movq -0x30(%rbp), %rdi
addq $0x10e0, %rdi           # imm = 0x10E0
callq 0x3fdd0
movl %eax, %ecx
movl -0x44(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1120, %rdi           # imm = 0x1120
callq 0x3fdd0
movl %eax, %ecx
movl -0x40(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1100, %rdi           # imm = 0x1100
callq 0x3fdd0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
addl %ecx, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
addq $0x1140, %rdi           # imm = 0x1140
callq 0x3fdf0
movq -0x38(%rbp), %rcx
addq %rax, %rcx
movslq -0xc(%rbp), %rax
addq %rcx, %rax
movl %eax, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3fe20
jmp 0x38d3b
movl -0xc(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)