LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
mapped_type& operator[](const key_type& key)
    {
	iterator i = find(key);

	if (i == end())
	    i = insert(std::make_pair(key, mapped_type())).first;

	return i->second;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %rdx
callq 0x230a
movq %rax, %r14
cmpq %r15, %rax
jne 0x1a7b
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x1ef4
movl $0x0, 0x20(%r14)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rax
cmpq %r13, %rax
je 0x1a12
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x1a1c
movups (%r13), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rsp), %rax
leaq 0x28(%rsp), %rcx
movq %rax, 0x8(%rcx)
movq %r13, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movl $0x0, 0x20(%rcx)
leaq 0x2(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x236a
movq %rax, %r14
testb $0x1, %dl
je 0x1a5e
incq 0x50(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a6d
callq 0x1090
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1a7b
callq 0x1090
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x1a97
movq %r14, %rcx
andb $-0x3, 0x2c(%rcx)
movq %rax, %rcx
movq 0x40(%rax), %rax
testq %rax, %rax
jne 0x1a87
addq $0x20, %r14
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1abe
callq 0x1090
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1acc
callq 0x1090
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O3/dlbeer[P]summary_map/./summary_map.hpp
// Function: summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::find_ge(std::less<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&, summary_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, summary, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, aggregator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>, summary>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>::node*)
static node *find_ge(const key_compare& cmp, const key_type& target,
			 node *header)
    {
	node *n = header->left;
	node *best = header;

	while (n) {
	    if (cmp(n->value.first, target)) {
		n = n->right;
	    } else if (cmp(target, n->value.first)) {
		best = n;
		n = n->left;
	    } else {
		return n;
	    }
	}

	return best;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq 0x30(%rdx), %rbx
testq %rbx, %rbx
je 0x25b5
movq %rsi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1030
testl %eax, %eax
js 0x25a2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1030
movl $0x30, %ecx
movq %rbx, %r15
testl %eax, %eax
js 0x25a7
jmp 0x25b2
movl $0x38, %ecx
movq (%rbx,%rcx), %rbx
testq %rbx, %rbx
jne 0x257a
jmp 0x25b5
movq %rbx, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x25c0
movq %rax, %rdi
callq 0x1c80
// File: /workspace/github_cpp_makefile_star2_O3/Baobaobear[P]sort/./sortlib.hpp
// Function: void baobao::internal::max_heapify_p<int*, std::less<int>>(int*, int*, int*, std::less<int>)
void max_heapify_p(RandomAccessIterator first, RandomAccessIterator target, RandomAccessIterator last, Comp compare)
{
    typename std::iterator_traits<RandomAccessIterator>::value_type temp = *target;
    --first;
    RandomAccessIterator son;
    for (; (son = target + (target - first)) <= last; target = son)
    {
        if (son < last && compare(*son, *(son + 1)))
            ++son;
        if (compare(temp, *son))
            *target = *son;
        else
            break;
    }
    *target = temp;
}

// Assembly:
movl (%rsi), %eax
addq $-0x4, %rdi
movq %rsi, %rcx
subq %rdi, %rcx
addq %rsi, %rcx
cmpq %rdx, %rcx
jbe 0x5649
movq %rsi, %r8
jmp 0x5685
cmpq %rdx, %rcx
jae 0x5666
leaq 0x4(%rcx), %r8
movl (%rcx), %r10d
movl 0x4(%rcx), %r9d
cmpl %r9d, %r10d
cmovgl %r10d, %r9d
cmovgeq %rcx, %r8
jmp 0x566c
movl (%rcx), %r9d
movq %rcx, %r8
cmpl %r9d, %eax
jge 0x5644
movl %r9d, (%rsi)
movq %r8, %rcx
subq %rdi, %rcx
addq %r8, %rcx
movq %r8, %rsi
cmpq %rdx, %rcx
jbe 0x5649
movl %eax, (%r8)
retq
// File: /workspace/github_cpp_makefile_star2_O3/IdelCoder[P]PTransE-ag/Test_TransE_path.cpp
// Function: main
int main(int argc,char**argv)
{
    if (argc<2)
        return 0;
    else
    {
        version = argv[1];
        if (argc==3)
            used = argv[2];
        prepare();
        test.run();
    }
}

// Assembly:
cmpl $0x2, %edi
jl 0x41c1
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %r14
movq 0xb114(%rip), %r15      # 0xf268
leaq 0xb105(%rip), %r12      # 0xf260
movq %r14, %rdi
callq 0x20f0
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x2280
cmpl $0x3, %ebp
jne 0x41a8
movq 0x10(%rbx), %rbx
movq 0xb07a(%rip), %r14      # 0xf200
leaq 0xb06b(%rip), %r15      # 0xf1f8
movq %rbx, %rdi
callq 0x20f0
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x2280
callq 0x2a6e
leaq 0x3bffc(%rip), %rdi     # 0x401b0
callq 0x4868
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/IdelCoder[P]PTransE-ag/Test_TransE_path.cpp
// Function: Test::add(int, int, int, std::vector<std::pair<std::vector<int, std::allocator<int>>, double>, std::allocator<std::pair<std::vector<int, std::allocator<int>>, double>>>)
void add(int x,int y,int z, vector<pair<vector<int>,double> > path_list)
    {
		if (z!=-1)
		{
        	fb_h.push_back(x);
        	fb_r.push_back(z);
        	fb_l.push_back(y);
			// 保存测试数据的三元组
        	ok[make_pair(x,z)][y]=1;
		}
		if (path_list.size()>0)
		// 保存所有路径信息
		fb_path[make_pair(x,y)] = path_list;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rdi, %r14
movl %esi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl %ecx, 0xc(%rsp)
cmpl $-0x1, %ecx
je 0x44fd
movl %ecx, %r15d
movl %edx, %ebp
movq 0x80(%r14), %rax
cmpq 0x88(%r14), %rax
je 0x4455
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0x80(%r14)
jmp 0x4466
leaq 0x78(%r14), %rdi
leaq 0x8(%rsp), %rdx
movq %rax, %rsi
callq 0x9a1c
movq 0xb0(%r14), %rsi
cmpq 0xb8(%r14), %rsi
je 0x4486
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xb0(%r14)
jmp 0x4497
leaq 0xa8(%r14), %rdi
leaq 0xc(%rsp), %rdx
callq 0x9a1c
movq 0x98(%r14), %rsi
cmpq 0xa0(%r14), %rsi
je 0x44b6
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x98(%r14)
jmp 0x44c7
leaq 0x90(%r14), %rdi
leaq 0x4(%rsp), %rdx
callq 0x9a1c
leaq 0xf0(%r14), %rdi
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
callq 0x6f48
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x4672
movl $0x1, (%rax)
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x4537
addq $0xc0, %r14
movl 0x8(%rsp), %eax
movl 0x4(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
movq %r14, %rdi
callq 0x6fd2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x705c
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/IdelCoder[P]PTransE-ag/Test_TransE_path.cpp
// Function: Test::calc_path(int, std::vector<int, std::allocator<int>>)
double calc_path(int r1,vector<int> rel_path)
    {
        double sum=0;
        for (int ii=0; ii<n; ii++)
		{
			double tmp = relation_vec[r1][ii];
			for (int j=0; j<rel_path.size(); j++)
				tmp-=relation_vec[rel_path[j]][ii];
	        if (L1_flag)
				sum+=-fabs(tmp);
			else
				sum+=-sqr(tmp);
		}
        return 10+sum;
    }

// Assembly:
movslq 0x6911(%rip), %rax      # 0xf1cc
testq %rax, %rax
jle 0x894f
pushq %rbx
movslq %esi, %rsi
movq (%rdi), %rcx
leaq (%rsi,%rsi,2), %rsi
movq (%rcx,%rsi,8), %rsi
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
movq %rdx, %r8
subq %rdi, %r8
sarq $0x2, %r8
cmpq $0x1, %r8
adcq $0x0, %r8
movb 0x68d5(%rip), %r9b      # 0xf1c8
xorpd %xmm0, %xmm0
xorl %r10d, %r10d
movapd 0x274e(%rip), %xmm1     # 0xb050
movsd (%rsi,%r10,8), %xmm2
cmpq %rdi, %rdx
je 0x892a
xorl %r11d, %r11d
movslq (%rdi,%r11,4), %rbx
leaq (%rbx,%rbx,2), %rbx
movq (%rcx,%rbx,8), %rbx
subsd (%rbx,%r10,8), %xmm2
incq %r11
cmpq %r11, %r8
jne 0x8910
testb %r9b, %r9b
jne 0x8935
mulsd %xmm2, %xmm2
jmp 0x8939
andpd %xmm1, %xmm2
subsd %xmm2, %xmm0
incq %r10
cmpq %rax, %r10
jne 0x8902
addsd 0x273b(%rip), %xmm0     # 0xb088
popq %rbx
retq
movsd 0x2731(%rip), %xmm0     # 0xb088
retq
// File: /workspace/github_cpp_makefile_star2_O3/BohangZhang[P]Sorcery-C-Project/ascii_graphics.cc
// Function: display_spell(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
card_template_t display_spell(std::string name,int cost,std::string desc) {
  std::ostringstream oss;
  card_template_t out(CARD_TEMPLATE_SPELL);
  prepare_for_replace(out);
  replace_text_left(out,'N',name);
  oss << cost;
  replace_text_right(out,'C',oss.str());
  replace_text_right(out,'T',"Spell");
  replace_text_left(out,'E',desc);
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x88(%rsp), %rdi
callq 0x5270
leaq 0x25c18(%rip), %rsi     # 0x33220
movq %rbx, %rdi
callq 0xe1d8
movq %rbx, %rdi
callq 0xd464
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
callq 0xb4e8
leaq 0x68(%rsp), %r15
movq %rbx, %rdi
movl $0x4e, %esi
movq %r15, %rdx
callq 0xd4a5
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xd660
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x51f0
leaq 0x88(%rsp), %rdi
movl %ebp, %esi
callq 0x5310
leaq 0x90(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x52c0
leaq 0x48(%rsp), %r15
movq %rbx, %rdi
movl $0x43, %esi
movq %r15, %rdx
callq 0xd545
movq (%r15), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xd6b0
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x51f0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x19227(%rip), %rsi     # 0x268e8
leaq 0x19225(%rip), %rdx     # 0x268ed
leaq 0x28(%rsp), %rdi
callq 0xb57e
leaq 0x28(%rsp), %r15
movq %rbx, %rdi
movl $0x54, %esi
movq %r15, %rdx
callq 0xd545
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xd6fc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x51f0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xb4e8
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movl $0x45, %esi
movq %r14, %rdx
callq 0xd4a5
movq (%r14), %rdi
cmpq %r15, %rdi
je 0xd743
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x51f0
movq 0x2586e(%rip), %rsi     # 0x32fb8
leaq 0x88(%rsp), %rdi
callq 0x5120
leaq 0xf8(%rsp), %rdi
callq 0x50b0
movq %rbx, %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd77e
movq %rax, %r14
jmp 0xd789
movq %rax, %r14
movq %rbx, %rdi
callq 0xc796
movq 0x25828(%rip), %rsi     # 0x32fb8
leaq 0x88(%rsp), %rdi
callq 0x5120
leaq 0xf8(%rsp), %rdi
callq 0x50b0
movq %r14, %rdi
callq 0x5320
// File: /workspace/github_cpp_makefile_star2_O3/BohangZhang[P]Sorcery-C-Project/enchantment.cc
// Function: Enchantment::attackMinion(int)
void Enchantment::attackMinion(int j)  {
    vector<shared_ptr<Minion>> s = this->master->getGame()->getNoncurrent()->getSlot()->getSlot();
    if (s.size() > j) {
        s[j]->subDefense(this->getAttack());
        this->subDefense(s[j]->getAttack());
    }
    else throw 3; // Number; The opponent player doesn't have the ith minion
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x70(%rdi), %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x17a62
movq (%r14), %rsi
movq %rsp, %rdi
callq 0x11e3e
movq (%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x17a94
movq 0x10(%rsp), %rdi
callq 0x243d6
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x118f4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x107dd
callq 0xb478
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x107ec
callq 0xb478
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x107fb
callq 0xb478
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movslq %ebp, %r15
cmpq %r15, %rcx
jbe 0x10865
shlq $0x4, %r15
movq (%rax,%r15), %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq (%r14), %rcx
movq %r14, %rdi
movl %eax, %esi
callq *0xb8(%rcx)
movq 0x20(%rsp), %rax
movq (%rax,%r15), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq *0xb8(%rcx)
leaq 0x20(%rsp), %rdi
callq 0xb420
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %edi
callq 0x5100
movl $0x3, (%rax)
movq 0x22714(%rip), %rsi     # 0x32f90
movq %rax, %rdi
xorl %edx, %edx
callq 0x5300
movq %rax, %rbx
jmp 0x108a2
movq %rax, %rbx
jmp 0x108b1
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x108a2
callq 0xb478
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x108b1
callq 0xb478
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x108cf
callq 0xb478
jmp 0x108cf
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb420
movq %rbx, %rdi
callq 0x5320
nop
// File: /workspace/github_cpp_makefile_star2_O3/BohangZhang[P]Sorcery-C-Project/game.cc
// Function: Game::Game(std::shared_ptr<Player>, std::shared_ptr<Player>)
Game::Game(shared_ptr<Player> player1, shared_ptr<Player> player2) : player1{player1}, player2{player2} {
    curplayer = player1;
    noncurplayer = player2;
    Round = 1;
    eog = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x11d5c
movq 0x21272(%rip), %rcx     # 0x32fc0
cmpb $0x0, (%rcx)
je 0x11d58
incl 0x8(%rax)
jmp 0x11d5c
lock
incl 0x8(%rax)
leaq 0x8(%rsi), %rax
movq (%r14), %rcx
movq %rcx, 0x18(%rbx)
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rcx
movq %rcx, 0x20(%rbx)
testq %rcx, %rcx
je 0x11d8d
movq 0x21241(%rip), %rdx     # 0x32fc0
cmpb $0x0, (%rdx)
je 0x11d89
incl 0x8(%rcx)
jmp 0x11d8d
lock
incl 0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
movq (%rsi), %rcx
movq %rcx, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq %rax, %rsi
callq 0xe6ba
movq (%r14), %rax
movq %rax, 0x38(%rbx)
leaq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0xe6ba
movl $0x1, (%rbx)
movb $0x0, 0x4(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/BohangZhang[P]Sorcery-C-Project/game.cc
// Function: Game::nextTurn()
void Game::nextTurn() {
    notify("End");
    shared_ptr<Player> p = curplayer;
    curplayer = noncurplayer;
    noncurplayer = p;
    ++Round;
    if (Round % 2 == 0) {
        addMagic(2, 1);
        addCard(2);
    } else {
        addMagic(1, 1);
        addCard(1);
    }
    notify("Start");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x15b16(%rip), %rsi     # 0x27a24
leaq 0x15b12(%rip), %rdx     # 0x27a27
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0xb57e
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rdx
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x120a0
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x11f4f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x51f0
movq 0x28(%rbx), %r12
leaq 0x8(%rsp), %r14
movq %r12, -0x8(%r14)
leaq 0x30(%rbx), %rdi
movq 0x30(%rbx), %rax
movq %rax, (%r14)
testq %rax, %rax
je 0x11f85
movq 0x2104d(%rip), %rcx     # 0x32fc0
cmpb $0x0, (%rcx)
je 0x11f7d
incl 0x8(%rax)
jmp 0x11f85
lock
incl 0x8(%rax)
movq (%rsp), %r12
movq 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
leaq 0x40(%rbx), %r15
movq %r15, %rsi
callq 0xe6ba
movq %r12, 0x38(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0xe6ba
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
testb $0x1, %al
jne 0x11fc7
movq 0x8(%rbx), %rdi
movl $0x1, %esi
callq 0x17b74
leaq 0x8(%rbx), %rax
jmp 0x11fd9
movq 0x18(%rbx), %rdi
movl $0x1, %esi
callq 0x17b74
leaq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x1d264
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x15a37(%rip), %rsi     # 0x27a28
leaq 0x15a35(%rip), %rdx     # 0x27a2d
leaq 0x10(%rsp), %rdi
callq 0xb57e
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x120a0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x12031
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12040
callq 0xb478
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x12089
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x51f0
jmp 0x12089
jmp 0x12086
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x12098
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x51f0
jmp 0x12098
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x12098
callq 0xb478
movq %rbx, %rdi
callq 0x5320
// File: /workspace/github_cpp_makefile_star2_O3/BohangZhang[P]Sorcery-C-Project/game.cc
// Function: Game::notify(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<Minion>)
void Game::notify(string t, shared_ptr<Minion> m) {
    if (t == "Enter") {
        this->curplayer->notify("MEnter", m);
        this->noncurplayer->notify("OEnter", m);
    }
    if (t == "Start" || t == "End") {
        this->curplayer->notify(t);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x159a2(%rip), %rsi     # 0x27a62
movq %rbx, %rdi
callq 0x50a0
testl %eax, %eax
jne 0x121dd
movq 0x28(%r14), %r12
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1597d(%rip), %rsi     # 0x27a61
leaq 0x1597c(%rip), %rdx     # 0x27a67
leaq 0x50(%rsp), %rdi
callq 0xb57e
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x12120
movq 0x20eae(%rip), %rcx     # 0x32fc0
cmpb $0x0, (%rcx)
je 0x1211c
incl 0x8(%rax)
jmp 0x12120
lock
incl 0x8(%rax)
leaq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x1b2d6
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x12141
callq 0xb478
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x12158
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x51f0
movq 0x38(%r14), %r12
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x158fc(%rip), %rsi     # 0x27a68
leaq 0x158fb(%rip), %rdx     # 0x27a6e
leaq 0x30(%rsp), %rdi
callq 0xb57e
movq (%r15), %rax
movq %rax, (%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x121a7
movq 0x20e27(%rip), %rcx     # 0x32fc0
cmpb $0x0, (%rcx)
je 0x121a3
incl 0x8(%rax)
jmp 0x121a7
lock
incl 0x8(%rax)
leaq 0x30(%rsp), %rsi
movq %rsp, %rdx
movq %r12, %rdi
callq 0x1b2d6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x121c6
callq 0xb478
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x121dd
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x51f0
leaq 0x15844(%rip), %rsi     # 0x27a28
movq %rbx, %rdi
callq 0x50a0
testl %eax, %eax
je 0x12203
leaq 0x1582d(%rip), %rsi     # 0x27a24
movq %rbx, %rdi
callq 0x50a0
testl %eax, %eax
jne 0x12269
movq 0x28(%r14), %r14
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xb4e8
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b2d6
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1224f
callq 0xb478
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0x12269
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x51f0
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1228c
callq 0xb478
movq 0x30(%rsp), %rdi
jmp 0x122c3
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x122a5
callq 0xb478
movq 0x50(%rsp), %rdi
jmp 0x122c3
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x122be
callq 0xb478
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0x122d4
movq (%r13), %rsi
incq %rsi
callq 0x51f0
movq %rbx, %rdi
callq 0x5320
// File: /workspace/github_cpp_makefile_star2_O3/BohangZhang[P]Sorcery-C-Project/game.cc
// Function: Game::boardDisplay()
void Game::boardDisplay() {
    // print player 1
    player1->boardDisplay(1);
    // print center graphic
    for (auto it = CENTRE_GRAPHIC.begin() ; it != CENTRE_GRAPHIC.end(); ++it) {
        cout << *it;
        std::cout << '\n';
    }  
    // print player 2
    player2->boardDisplay(2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl $0x1, %esi
callq 0x1de6a
leaq 0x1db39(%rip), %r12     # 0x332c8
movq (%r12), %r13
cmpq 0x8(%r12), %r13
je 0x157d6
movq 0x1d827(%rip), %r14     # 0x32fc8
leaq 0xf(%rsp), %r15
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x5240
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5240
addq $0x20, %r13
cmpq 0x8(%r12), %r13
jne 0x157a6
movq 0x18(%rbx), %rdi
movl $0x2, %esi
callq 0x1de6a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/BohangZhang[P]Sorcery-C-Project/player.cc
// Function: Player::attack(int)
void Player::attack(int i) {
    if (getSlot()->getSize() < i) throw 11; // Number; The Minion doesn't exist
    shared_ptr<Minion> m = getSlot()->getSlot()[i - 1];
    m->attackPlayer();
/*  string type = m->getType();
    if (m->ifDead()) {
        if (type == "Enchantment") {
            shared_ptr<Minion> dead_m = getDatabase()->getMinion(m->getOriginName());
            getGraveyard()->pushfirst(dead_m);
        }
        else {
            shared_ptr<Minion> dead_m = getDatabase()->getMinion(m->getName());
            getGraveyard()->pushfirst(dead_m);
        }
        getSlot()->pop(m);
    } */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movq 0x50(%r14), %rbx
testq %rbx, %rbx
je 0x1aa58
movq 0x18576(%rip), %rax     # 0x32fc0
cmpb $0x0, (%rax)
je 0x1aa54
incl 0x8(%rbx)
jmp 0x1aa58
lock
incl 0x8(%rbx)
callq 0x243da
movl %eax, %r15d
testq %rbx, %rbx
je 0x1aa6d
movq %rbx, %rdi
callq 0xb478
cmpl %ebp, %r15d
jl 0x1ab08
movq 0x48(%r14), %rdi
movq 0x50(%r14), %rbx
testq %rbx, %rbx
je 0x1aa98
movq 0x18536(%rip), %rax     # 0x32fc0
cmpb $0x0, (%rax)
je 0x1aa94
incl 0x8(%rbx)
jmp 0x1aa98
lock
incl 0x8(%rbx)
callq 0x243d6
movq (%rax), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
movq -0x10(%rax,%rcx), %r15
movq -0x8(%rax,%rcx), %r14
testq %r14, %r14
je 0x1aacd
movq 0x18503(%rip), %rax     # 0x32fc0
cmpb $0x0, (%rax)
je 0x1aac8
incl 0x8(%r14)
jmp 0x1aacd
lock
incl 0x8(%r14)
testq %rbx, %rbx
je 0x1aada
movq %rbx, %rdi
callq 0xb478
movq (%r15), %rax
movq %r15, %rdi
callq *0xc8(%rax)
testq %r14, %r14
je 0x1aafd
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb478
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %edi
callq 0x5100
movl $0xb, (%rax)
movq 0x18471(%rip), %rsi     # 0x32f90
movq %rax, %rdi
xorl %edx, %edx
callq 0x5300
movq %rax, %r15
movq %r14, %rbx
testq %r14, %r14
jne 0x1ab40
jmp 0x1ab48
jmp 0x1ab38
movq %rax, %r15
testq %rbx, %rbx
je 0x1ab48
movq %rbx, %rdi
callq 0xb478
movq %r15, %rdi
callq 0x5320
// File: /workspace/github_cpp_makefile_star2_O3/BohangZhang[P]Sorcery-C-Project/player.cc
// Function: Player::draw()
void Player::draw() {
    if (this->isDeckEmpty()) {
        throw 4; // Number, You deck is empty!
    } else if (this->isHandFull()) {
        throw 13; // Number, You hand is full!
    } else {
        shared_ptr<Card> c = deck->getDeck()[0];
        this->deck->popfirst();
        this->hand->push(c);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0xf4ec
testb %al, %al
jne 0x1d31d
movq 0x38(%r14), %rdi
callq 0x15fa2
testb %al, %al
jne 0x1d32f
movq 0x28(%r14), %rdi
callq 0xf4e6
movq (%rax), %rax
movq (%rax), %r15
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x1d2bf
movq 0x15d0f(%rip), %rax     # 0x32fc0
cmpb $0x0, (%rax)
je 0x1d2bb
incl 0x8(%rbx)
jmp 0x1d2bf
lock
incl 0x8(%rbx)
movq 0x28(%r14), %rdi
callq 0xf502
movq 0x38(%r14), %rdi
movq %r15, (%rsp)
movq %rbx, 0x8(%rsp)
testq %rbx, %rbx
je 0x1d2ef
movq 0x15cdf(%rip), %rax     # 0x32fc0
cmpb $0x0, (%rax)
je 0x1d2eb
incl 0x8(%rbx)
jmp 0x1d2ef
lock
incl 0x8(%rbx)
movq %rsp, %rsi
callq 0x15fb2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1d306
callq 0xb478
testq %rbx, %rbx
je 0x1d313
movq %rbx, %rdi
callq 0xb478
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x4, %edi
callq 0x5100
movl $0x4, (%rax)
jmp 0x1d33f
movl $0x4, %edi
callq 0x5100
movl $0xd, (%rax)
movq 0x15c4a(%rip), %rsi     # 0x32f90
movq %rax, %rdi
xorl %edx, %edx
callq 0x5300
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1d367
callq 0xb478
jmp 0x1d367
movq %rax, %r14
testq %rbx, %rbx
je 0x1d374
movq %rbx, %rdi
callq 0xb478
movq %r14, %rdi
callq 0x5320
// File: /workspace/github_cpp_makefile_star2_O3/BohangZhang[P]Sorcery-C-Project/ritual.cc
// Function: Ritual::action(std::shared_ptr<Minion>)
void Ritual::action(shared_ptr<Minion> m) {
    if (name == "Aura of Power") {
        m->addAttack(1);
        m->addDefense(1);
    }
    if (name == "Standstill") {
        m->getMaster()->getSlot()->pop(m);
        m->getMaster()->getGraveyard()->pushfirst(m);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
leaq 0x3cf9(%rip), %rsi      # 0x27d23
movq %r14, %rdi
callq 0x50a0
testl %eax, %eax
jne 0x24058
movq (%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xa0(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xa8(%rax)
leaq 0x3cd2(%rip), %rsi      # 0x27d31
movq %r14, %rdi
callq 0x50a0
testl %eax, %eax
jne 0x24177
movq (%rbx), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xe68a
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x17a94
movq 0x8(%rsp), %rdi
movq (%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x240bc
movq 0xef12(%rip), %rcx      # 0x32fc0
cmpb $0x0, (%rcx)
je 0x240b8
incl 0x8(%rax)
jmp 0x240bc
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %rsi
callq 0x2441a
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x240d5
callq 0xb478
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x240e4
callq 0xb478
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x240f3
callq 0xb478
movq (%rbx), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xe68a
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x17ac0
movq 0x8(%rsp), %rdi
movq (%rbx), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x24140
movq 0xee8e(%rip), %rcx      # 0x32fc0
cmpb $0x0, (%rcx)
je 0x2413c
incl 0x8(%rax)
jmp 0x24140
lock
incl 0x8(%rax)
leaq 0x28(%rsp), %rsi
callq 0x15b74
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x24159
callq 0xb478
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x24168
callq 0xb478
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x24177
callq 0xb478
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x24193
jmp 0x241ae
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2419d
callq 0xb478
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x241b1
callq 0xb478
jmp 0x241b1
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x241c0
callq 0xb478
movq %rbx, %rdi
callq 0x5320
// File: /workspace/github_cpp_makefile_star2_O3/BohangZhang[P]Sorcery-C-Project/slot.cc
// Function: Slot::pop(std::shared_ptr<Minion>)
void Slot::pop(shared_ptr<Minion> m) {
    for (auto it = this->theSlot.begin(); it != this->theSlot.end(); ++it) {
        if (*it == m) {
            this->theSlot.erase(it);
            return;
        }
    }
    throw 14; // Number, Error when pop out Minion from Slot
}

// Assembly:
pushq %rax
movq %rsi, %rax
movq (%rdi), %rsi
movq 0x8(%rdi), %rcx
cmpq %rcx, %rsi
je 0x2443b
movq (%rax), %rax
cmpq %rax, (%rsi)
je 0x2445c
addq $0x10, %rsi
cmpq %rcx, %rsi
jne 0x2442d
movl $0x4, %edi
callq 0x5100
movl $0xe, (%rax)
movq 0xeb3e(%rip), %rsi      # 0x32f90
movq %rax, %rdi
xorl %edx, %edx
callq 0x5300
popq %rax
jmp 0x15ee6
nop
// File: /workspace/github_cpp_makefile_star2_O3/BohangZhang[P]Sorcery-C-Project/tri_minion.cc
// Function: Tri_Minion::action(std::shared_ptr<Minion>)
void Tri_Minion::action(shared_ptr<Minion> m) {
    if (name == "Fire Elemental") {
        m->subDefense(1);
    }
    if (name == "Potion Seller") {
        for (auto it = this->master->getSlot()->getSlot().begin(); it != this->master->getSlot()->getSlot().end(); ++it) {
            (*it)->addDefense(1);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x24cf(%rip), %rsi      # 0x27d83
movq %r14, %rdi
callq 0x50a0
testl %eax, %eax
jne 0x258d1
movq (%r15), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xb8(%rax)
leaq 0x24ba(%rip), %rsi      # 0x27d92
movq %r14, %rdi
callq 0x50a0
testl %eax, %eax
je 0x258f0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x70(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x17a94
movq (%r14), %rdi
callq 0x243d6
movq (%rax), %r15
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2591b
callq 0xb478
leaq 0x8(%rsp), %r14
movq 0x70(%rbx), %rsi
movq %r14, %rdi
callq 0x17a94
movq 0x8(%rsp), %rdi
callq 0x243d6
movq 0x8(%rax), %r12
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x25949
callq 0xb478
cmpq %r12, %r15
je 0x258e4
movq (%r15), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xa8(%rax)
addq $0x10, %r15
jmp 0x25920
jmp 0x25967
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x25979
callq 0xb478
movq %rbx, %rdi
callq 0x5320
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/test.h
// Function: ezSTL::test::test_stack()
void test::test_stack() {
		srand((unsigned int)time(NULL));
		start_info("stack");
		stack<int> s;
		print_stack(s);
		test_info("stack   push");
		for (int i = 0; i < 5; ++i) {
			s.push(rand());
			print_stack(s);
		}
		test_info("stack   pop");
		for (int i = 0; i < 5; ++i) {
			s.pop();
			print_stack(s);
		}
		finish_info("stack");
		continue_next_test();
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
xorl %edi, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21d0
leaq 0x80(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc740(%rip), %rsi      # 0x10344
leaq 0xc73e(%rip), %rdx      # 0x10349
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xa4e2
movq %rbx, %rdi
callq 0x246c
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x3c2f
callq 0x21c0
xorl %ebp, %ebp
movq %rsp, %rbx
movl %ebp, 0x8(%rbx)
movl $0x18, %edi
callq 0x21f0
movl %ebp, 0x10(%rax)
movq %rax, (%rbx)
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movq %rbx, %rdi
callq 0x89fe
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc6e4(%rip), %rsi      # 0x1034a
leaq 0xc6e9(%rip), %rdx      # 0x10356
leaq 0x50(%rsp), %rdi
callq 0xa4e2
leaq 0x50(%rsp), %rdi
callq 0x2706
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x3c90
callq 0x21c0
movl $0x5, %r14d
movq %rsp, %rbx
callq 0x2060
movl %eax, %ebp
movl $0x18, %edi
callq 0x21f0
movl %ebp, 0x10(%rax)
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
movq %rax, (%rcx)
incl 0x8(%rsp)
movq %rbx, %rdi
callq 0x89fe
decl %r14d
jne 0x3c99
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc674(%rip), %rsi      # 0x10357
leaq 0xc678(%rip), %rdx      # 0x10362
leaq 0x30(%rsp), %rdi
callq 0xa4e2
leaq 0x30(%rsp), %rdi
callq 0x2706
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x3d0d
callq 0x21c0
movl $0x5, %ebp
movq %rsp, %rbx
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
callq 0x21c0
decl 0x8(%rsp)
movq %rbx, %rdi
callq 0x89fe
decl %ebp
jne 0x3d15
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc5f9(%rip), %rsi      # 0x10344
leaq 0xc5f7(%rip), %rdx      # 0x10349
leaq 0x10(%rsp), %rdi
callq 0xa4e2
leaq 0x10(%rsp), %rdi
callq 0x2650
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x3d75
callq 0x21c0
callq 0x277c
movq %rsp, %rdi
callq 0x89dc
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x3dae
jmp 0x3dd6
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x3dae
jmp 0x3dd6
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x3dd9
callq 0x21c0
jmp 0x3dd9
jmp 0x3dd6
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x3de1
callq 0x21c0
jmp 0x3de1
jmp 0x3dd6
jmp 0x3dd6
jmp 0x3dd6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x89dc
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/test.h
// Function: ezSTL::test::test_queue()
void test::test_queue() {
		srand((unsigned int)time(NULL));
		start_info("queue");
		queue<int> q;
		print_queue(q);
		test_info("queue   push");
		for (int i = 0; i < 5; ++i) {
			q.push(rand());
			print_queue(q);
		}
		test_info("queue   pop");
		for (int i = 0; i < 5; ++i) {
			q.pop();
			print_queue(q);
		}
		finish_info("queue");
		continue_next_test();
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
xorl %edi, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21d0
leaq 0x80(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc556(%rip), %rsi      # 0x1036c
leaq 0xc554(%rip), %rdx      # 0x10371
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xa4e2
movq %rbx, %rdi
callq 0x246c
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e41
callq 0x21c0
xorl %ebp, %ebp
movq %rsp, %rbx
movl %ebp, 0x8(%rbx)
movl $0x18, %edi
callq 0x21f0
movl %ebp, 0x10(%rax)
movq %rax, (%rbx)
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movq %rbx, %rdi
callq 0x8ab4
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc503(%rip), %rsi      # 0x1037b
leaq 0xc508(%rip), %rdx      # 0x10387
leaq 0x50(%rsp), %rdi
callq 0xa4e2
leaq 0x50(%rsp), %rdi
callq 0x2706
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ea2
callq 0x21c0
movl $0x5, %r14d
movq %rsp, %rbx
callq 0x2060
movl %eax, %ebp
movl $0x18, %edi
callq 0x21f0
movl %ebp, 0x10(%rax)
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
movq %rax, (%rcx)
incl 0x8(%rsp)
movq %rbx, %rdi
callq 0x8ab4
decl %r14d
jne 0x3eab
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc49c(%rip), %rsi      # 0x10391
leaq 0xc4a0(%rip), %rdx      # 0x1039c
leaq 0x30(%rsp), %rdi
callq 0xa4e2
leaq 0x30(%rsp), %rdi
callq 0x2706
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x3f1f
callq 0x21c0
movl $0x5, %ebp
movq %rsp, %rbx
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
callq 0x21c0
decl 0x8(%rsp)
movq %rbx, %rdi
callq 0x8ab4
decl %ebp
jne 0x3f27
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc40d(%rip), %rsi      # 0x1036c
leaq 0xc40b(%rip), %rdx      # 0x10371
leaq 0x10(%rsp), %rdi
callq 0xa4e2
leaq 0x10(%rsp), %rdi
callq 0x2650
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x3f89
callq 0x21c0
callq 0x277c
movq %rsp, %rdi
callq 0x89dc
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x3fc2
jmp 0x3fea
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x3fc2
jmp 0x3fea
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x3fed
callq 0x21c0
jmp 0x3fed
jmp 0x3fea
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ff5
callq 0x21c0
jmp 0x3ff5
jmp 0x3fea
jmp 0x3fea
jmp 0x3fea
movq %rax, %rbx
movq %rsp, %rdi
callq 0x89dc
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/test.h
// Function: ezSTL::test::test_priority_queue()
void test::test_priority_queue() {
		const int max_iteration = 10;
		srand((unsigned int)time(NULL));
		start_info("priority_queue");
		priority_queue<int> pq;
		print_priority_queue(pq);
		test_info("priority_queue   push");
		for (int i = 0; i < max_iteration; ++i) {
			pq.push(rand());
			print_priority_queue(pq);
		}
		test_info("priority_queue   pop");
		print_priority_queue(pq);
		for (int i = 0; i < max_iteration; ++i) {
			pq.pop();
			print_priority_queue(pq);
		}
		finish_info("priority_queue");
		continue_next_test();
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
xorl %edi, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21d0
leaq 0xa0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc339(%rip), %rsi      # 0x10363
leaq 0xc340(%rip), %rdx      # 0x10371
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0xa4e2
movq %rbx, %rdi
callq 0x246c
movq 0x90(%rsp), %rdi
cmpq %r14, %rdi
je 0x405b
callq 0x21c0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x8b9e
leaq 0x80(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc2ec(%rip), %rsi      # 0x10372
leaq 0xc2fa(%rip), %rdx      # 0x10387
leaq 0x70(%rsp), %rdi
callq 0xa4e2
leaq 0x70(%rsp), %rdi
callq 0x2706
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x40b0
callq 0x21c0
movl $0xa, %ebp
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %r14
callq 0x2060
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8c5c
movq %rbx, %rdi
callq 0x8b9e
decl %ebp
jne 0x40bf
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc299(%rip), %rsi      # 0x10388
leaq 0xc2a6(%rip), %rdx      # 0x1039c
leaq 0x50(%rsp), %rdi
callq 0xa4e2
leaq 0x50(%rsp), %rdi
callq 0x2706
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x4119
callq 0x21c0
leaq 0x10(%rsp), %rdi
callq 0x8b9e
movl $0xa, %ebp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x8c9e
movq %rbx, %rdi
callq 0x8b9e
decl %ebp
jne 0x412d
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc212(%rip), %rsi      # 0x10363
leaq 0xc219(%rip), %rdx      # 0x10371
leaq 0x30(%rsp), %rdi
callq 0xa4e2
leaq 0x30(%rsp), %rdi
callq 0x2650
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x417b
callq 0x21c0
callq 0x277c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x418f
callq 0x21c0
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x41bb
jmp 0x41e1
movq %rax, %rbx
movq 0x50(%rsp), %rdi
jmp 0x41bb
jmp 0x41e1
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x41e4
callq 0x21c0
jmp 0x41e4
jmp 0x41e1
movq %rax, %rbx
movq 0x90(%rsp), %rdi
cmpq %r14, %rdi
jne 0x41ee
jmp 0x41f3
jmp 0x41e1
jmp 0x41e1
jmp 0x41e1
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x41f3
callq 0x21c0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/main.cpp
// Function: main
int main()
{
	// add annotations to prevent running the testing codes of corresponding modules
	test::test_vector();
	test::test_list();
	test::test_stack();
	test::test_queue();
	test::test_priority_queue();
	test::test_rbtree();
	test::test_set();
	test::test_map();
	test::test_unordered_map();
	test::test_smart_pointers();
	test::test_set_map_efficiency();
	test::test_algorithm();
	test::test_algorithm_efficiency();
	return 0;
}

// Assembly:
pushq %rax
callq 0x2a44
callq 0x3240
callq 0x3bd8
callq 0x3dea
callq 0x3ffe
callq 0x41fc
callq 0x4662
callq 0x4ac8
callq 0x4fac
callq 0x5776
callq 0x5e22
callq 0x6c62
callq 0x7058
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_vector<unsigned int>(ezSTL::vector<unsigned int, ezSTL::allocator<unsigned int>>&)
void test::print_vector(vector<T>& v) {
		std::cout << "size: " << v.size();
		std::cout << " ; capacity: " << v.capacity();
		std::cout << " ; empty: " << v.empty();
		if(!v.empty()) std::cout << " ; front: " << v.front();
		if (!v.empty()) std::cout << " ; back: " << v.back();
		std::cout << std::endl << "vector: ";
		for (auto ite = v.begin(); ite != v.end(); ++ite)
			std::cout << *ite << " ";
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0xc0ed(%rip), %rbx      # 0x15fd8
leaq 0x6a35(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
movl %eax, %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x697e(%rip), %rsi      # 0x10899
movl $0xd, %edx
movq %rbx, %rdi
callq 0x2220
movq 0x10(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
movl %eax, %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x6963(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
movq (%r14), %rax
xorl %esi, %esi
cmpq 0x8(%r14), %rax
sete %sil
movq %rbx, %rdi
callq 0x22c0
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x9fca
movq 0xc062(%rip), %r15      # 0x15fd8
leaq 0x6935(%rip), %rsi      # 0x108b2
movl $0xa, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0x2110
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x9fca
movq 0xc031(%rip), %r15      # 0x15fd8
leaq 0x690f(%rip), %rsi      # 0x108bd
movl $0x9, %edx
movq %r15, %rdi
callq 0x2220
movq 0x8(%r14), %rax
movl -0x4(%rax), %esi
movq %r15, %rdi
callq 0x2110
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x68cf(%rip), %rsi      # 0x108c7
movl $0x8, %edx
movq %rax, %rdi
callq 0x2220
movq (%r14), %r13
cmpq 0x8(%r14), %r13
je 0xa042
movq 0xbfc3(%rip), %r15      # 0x15fd8
leaq 0x64a4(%rip), %r12      # 0x104c0
movl (%r13), %esi
movq %r15, %rdi
callq 0x2110
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
addq $0x4, %r13
cmpq 0x8(%r14), %r13
jne 0xa01c
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/vector.h
// Function: ezSTL::vector<int, ezSTL::allocator<int>>::push_back(int const&)
void vector<T, Alloc>::push_back(const_reference x) {
		// if there is still extra space
		if (finish != end_of_storage) {
			construct(finish++, x);
		}
		else
		{
			size_type old_size = size();
			// calculate new size
			size_type new_size = old_size ? 2 * old_size : 1;
			iterator new_start = allocate(new_size);
			iterator temp = new_start;
			for (size_type i = 0; i < old_size; ++i)
				construct(temp++, (*this)[i]);
			destroy(start, finish);
			deallocate();
			construct(temp++, x);
			start = new_start;
			finish = temp;
			end_of_storage = start + new_size;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r13
cmpq 0x10(%rdi), %r13
je 0x84ac
leaq 0x4(%r13), %rax
movq %rax, 0x8(%rbx)
movl (%r14), %eax
movl %eax, (%r13)
jmp 0x8526
subq (%rbx), %r13
movq %r13, %rax
shrq %rax
movabsq $0x3fffffffc, %rbp      # imm = 0x3FFFFFFFC
movq %r13, %rcx
andq %rbp, %rcx
movl %eax, %eax
movl $0x1, %r12d
cmovneq %rax, %r12
leaq (,%r12,4), %rdi
callq 0x21f0
movq %rax, %r15
movq (%rbx), %rdi
andq %rbp, %r13
je 0x8500
xorl %ebp, %ebp
movl (%rdi,%rbp), %eax
movl %eax, (%r15,%rbp)
addq $0x4, %rbp
cmpq %rbp, %r13
jne 0x84eb
addq %r15, %rbp
jmp 0x8508
movq %r15, %rbp
testq %rdi, %rdi
je 0x850d
callq 0x21c0
movl (%r14), %eax
movl %eax, (%rbp)
addq $0x4, %rbp
movq %r15, (%rbx)
movq %rbp, 0x8(%rbx)
leaq (%r15,%r12,4), %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/vector.h
// Function: ezSTL::vector<int, ezSTL::allocator<int>>::insert(int*, int const&)
typename vector<T, Alloc>::iterator
		vector<T, Alloc>::insert(const_iterator pos, const_reference x) {
		if (finish != end_of_storage) {
			for (auto ite = end(); ite != pos; --ite) {
				if (ite != end()) destroy(ite);
				*ite = *(ite - 1);
			}
			construct(pos, x);
			++finish;
			return pos;
		}
		else {
			size_type old_size = size();
			size_type new_size = old_size ? 2 * old_size : 1;
			// allocate new space
			iterator new_start = allocate(new_size);
			iterator temp = new_start;
			// copy values before pos
			for (auto ite = begin(); ite != pos; ++ite)
				construct(temp++, *ite);
			// insert new value x
			auto res = temp;
			construct(temp++, x);
			for (auto ite = pos; ite != end(); ++ite)
				construct(temp++, *ite);
			destroy(start, finish);
			deallocate();
			start = new_start;
			finish = temp;
			end_of_storage = start + new_size;
			return res;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x8580
cmpq %r14, %rax
je 0x856d
movq %rax, %rcx
movl -0x4(%rcx), %edx
movl %edx, (%rcx)
leaq -0x4(%rcx), %rdx
movq %rdx, %rcx
cmpq %r14, %rdx
jne 0x855c
movl (%r15), %ecx
movl %ecx, (%r14)
addq $0x4, %rax
movq %rax, 0x8(%rbx)
jmp 0x8610
subq (%rbx), %rax
movq %rax, %rcx
shrq $0x2, %rcx
shrq %rax
testl %ecx, %ecx
movl %eax, %eax
movl $0x1, %r13d
cmovneq %rax, %r13
leaq (,%r13,4), %rdi
callq 0x21f0
movq %rax, %r12
movq (%rbx), %rdi
movq %rax, %rbp
cmpq %r14, %rdi
je 0x85ce
movq %rdi, %rax
movq %r12, %rbp
movl (%rax), %ecx
movl %ecx, (%rbp)
addq $0x4, %rbp
addq $0x4, %rax
cmpq %r14, %rax
jne 0x85bc
movl (%r15), %eax
movl %eax, (%rbp)
movq 0x8(%rbx), %rax
leaq 0x4(%rbp), %r15
cmpq %r14, %rax
je 0x85f4
movl (%r14), %ecx
movl %ecx, (%r15)
addq $0x4, %r14
addq $0x4, %r15
cmpq %rax, %r14
jne 0x85e1
testq %rdi, %rdi
je 0x85fe
callq 0x21c0
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
leaq (%r12,%r13,4), %rax
movq %rax, 0x10(%rbx)
movq %rbp, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/cjc12[P]ezSTL/src/../include/vector.h
// Function: ezSTL::vector<int, ezSTL::allocator<int>>::operator=(ezSTL::vector<int, ezSTL::allocator<int>> const&)
vector<T, Alloc>& vector<T, Alloc>::operator= (const vector<T, Alloc>& v) {
		if (this == &v) return *this;
		else {
			// destroy and deallocate old vector
			destroy(begin(), end());
			deallocate();
			// allocate and construct new vector
			start = allocate(v.size());
			for (size_type i = 0; i < v.size(); ++i)
				construct(start + i, v[i]);
			finish = start + v.size();
			end_of_storage = finish;
			return *this;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x86f9
movq %rsi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x86a5
callq 0x21c0
movq 0x8(%r14), %rdi
subq (%r14), %rdi
movabsq $0x3fffffffc, %r15      # imm = 0x3FFFFFFFC
andq %r15, %rdi
callq 0x21f0
movq %rax, (%rbx)
movq (%r14), %rcx
movq 0x8(%r14), %rsi
subq %rcx, %rsi
movq %rsi, %rdx
shrq $0x2, %rdx
testq %r15, %rsi
je 0x86eb
movl %edx, %esi
xorl %edi, %edi
movl (%rcx,%rdi,4), %r8d
movl %r8d, (%rax,%rdi,4)
incq %rdi
cmpq %rdi, %rsi
jne 0x86db
movl %edx, %ecx
leaq (%rax,%rcx,4), %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq