LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_02_03.cc
// Function: main
int main(int argc, char const *argv[])
{
	cout << compare(1.1f, 1.2f) << endl;

	std::vector<int> vect1{1, 2, 3};
	std::vector<int> vect2{4, 5, 6};
	cout << compare(vect1, vect2) << endl;

	// Sales_data data1, data2;
	// cout << compare(data1, data2) << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq 0x2d8a(%rip), %rdi      # 0x3fd8
pushq $-0x1
popq %rsi
callq 0x10e0
movq %rax, %rdi
callq 0x1060
movabsq $0x200000001, %rax      # imm = 0x200000001
leaq -0x30(%rbp), %rsi
movq %rax, (%rsi)
movl $0x3, 0x8(%rsi)
leaq -0x48(%rbp), %rdi
pushq $0x3
popq %rbx
leaq -0x54(%rbp), %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1318
movabsq $0x500000004, %rax      # imm = 0x500000004
movq %rax, (%r14)
movl $0x6, 0x8(%r14)
leaq -0x30(%rbp), %rdi
leaq -0x54(%rbp), %rsi
leaq -0x11(%rbp), %rcx
movq %rbx, %rdx
callq 0x1318
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x134e
movq 0x2d0f(%rip), %rdi      # 0x3fd8
movl %eax, %esi
callq 0x10e0
movq %rax, %rdi
callq 0x1060
leaq -0x30(%rbp), %rdi
callq 0x13d8
leaq -0x48(%rbp), %rdi
callq 0x13d8
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
jmp 0x1306
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x13d8
leaq -0x48(%rbp), %rdi
callq 0x13d8
movq %rbx, %rdi
callq 0x10f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/IdelCoder[P]PTransE-ag/Test_TransE_path.cpp
// Function: vec_len(std::vector<double, std::allocator<double>>)
double vec_len(vector<double> a)
{
	double res=0;
	for (int i=0; i<a.size(); i++)
		res+=a[i]*a[i];
	return sqrt(res);
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x287b
movsd (%rax,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x2864
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2150
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x39b9
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %rsi
leaq 0xc8c8(%rip), %rdi      # 0x10250
callq 0x2340
cmpl $0x3, %ebp
jne 0x39a2
movq 0x10(%rbx), %rsi
leaq 0xc84b(%rip), %rdi      # 0x101e8
callq 0x2340
callq 0x294b
leaq 0x3d7f2(%rip), %rdi     # 0x411a0
callq 0x3f60
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movq %rdi, %r14
movl %esi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl %ecx, 0x14(%rsp)
cmpl $-0x1, %ecx
je 0x3cc6
leaq 0x78(%r14), %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rsi
callq 0x3c18
leaq 0xa8(%r14), %rdi
leaq 0x14(%rsp), %r12
movq %r12, %rsi
callq 0x3c18
leaq 0x90(%r14), %rdi
leaq 0xc(%rsp), %r13
movq %r13, %rsi
callq 0x3c18
leaq 0xf0(%r14), %rdi
movl (%r15), %eax
movl (%r12), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x18(%rsp), %rsi
movq %rcx, (%rsi)
callq 0x5fb6
movq %rax, %rdi
movq %r13, %rsi
callq 0x3dd2
movl $0x1, (%rax)
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x3d00
addq $0xc0, %r14
movl 0x10(%rsp), %eax
movl 0xc(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x18(%rsp), %rsi
movq %rcx, (%rsi)
movq %r14, %rdi
callq 0x601c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6082
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movl 0x89fd(%rip), %eax      # 0x101c4
movslq %esi, %rsi
movq (%rdi), %rcx
imulq $0x18, %rsi, %rsi
addq %rcx, %rsi
movb 0x89e5(%rip), %dil      # 0x101c0
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
xorpd %xmm0, %xmm0
movapd 0x2860(%rip), %xmm1     # 0xa050
cmpq %rax, %r8
je 0x7844
movq (%rsi), %r9
movsd (%r9,%r8,8), %xmm2
movq (%rdx), %r9
movq 0x8(%rdx), %r10
subq %r9, %r10
sarq $0x2, %r10
xorl %r11d, %r11d
cmpq %r11, %r10
je 0x782b
movslq (%r9,%r11,4), %rbx
imulq $0x18, %rbx, %rbx
movq (%rcx,%rbx), %rbx
subsd (%rbx,%r8,8), %xmm2
incq %r11
jmp 0x780f
testb $0x1, %dil
jne 0x7837
mulsd %xmm2, %xmm2
jmp 0x783b
andpd %xmm1, %xmm2
subsd %xmm2, %xmm0
incq %r8
jmp 0x77f0
addsd 0x283c(%rip), %xmm0     # 0xa088
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x90(%rsp), %rdi
callq 0x5280
leaq 0x20910(%rip), %rsi     # 0x2b228
movq %rbx, %rdi
callq 0xb0c4
movq %rbx, %rdi
callq 0xa7ab
leaq 0x70(%rsp), %rdi
movq %r15, %rsi
callq 0x5290
pushq $0x4e
popq %rsi
leaq 0x70(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xa7dd
movq %r15, %rdi
callq 0x5378
leaq 0x90(%rsp), %rdi
movl %ebp, %esi
callq 0x5320
leaq 0x98(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x52d0
pushq $0x43
popq %rsi
leaq 0x50(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xa863
movq %r15, %rdi
callq 0x5378
leaq 0x12eb7(%rip), %rsi     # 0x1d84a
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x8d88
pushq $0x54
popq %rsi
leaq 0x30(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0xa863
movq %r15, %rdi
callq 0x5378
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x5290
pushq $0x45
popq %rsi
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xa7dd
movq %r14, %rdi
callq 0x5378
leaq 0x90(%rsp), %rdi
callq 0x5070
movq %rbx, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaa0a
movq %rax, %r14
jmp 0xaa15
movq %rax, %r14
movq %rbx, %rdi
callq 0x9dd8
leaq 0x90(%rsp), %rdi
callq 0x5070
movq %r14, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/BohangZhang[P]Sorcery-C-Project/ascii_graphics.cc
// Function: display_enchantment_general(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, 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>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static card_template_t display_enchantment_general(card_template_t out,std::string name,int cost,
                                                   std::string desc,std::string attack,
                                                   std::string defence) {
  std::ostringstream oss;
  prepare_for_replace(out);
  replace_text_left(out,'N',name);
  oss << cost;
  replace_text_right(out,'C',oss.str());
  replace_text_right(out,'T',"Enchantment");
  replace_text_left(out,'E',desc);
  replace_text_left(out,'A',attack);
  replace_text_right(out,'D',defence);
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %r9, %r15
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x5280
movq %r14, %rdi
callq 0xa7ab
leaq 0xb0(%rsp), %rdi
movq %r13, %rsi
callq 0x5290
pushq $0x4e
popq %rsi
leaq 0xb0(%rsp), %r13
movq %r14, %rdi
movq %r13, %rdx
callq 0xa7dd
movq %r13, %rdi
callq 0x5378
leaq 0xd0(%rsp), %rdi
movl %ebp, %esi
callq 0x5320
leaq 0xd8(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x52d0
pushq $0x43
popq %rsi
leaq 0x90(%rsp), %r13
movq %r14, %rdi
movq %r13, %rdx
callq 0xa863
movq %r13, %rdi
callq 0x5378
leaq 0x13bcb(%rip), %rsi     # 0x1e7d4
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x8d88
pushq $0x54
popq %rsi
leaq 0x70(%rsp), %r13
movq %r14, %rdi
movq %r13, %rdx
callq 0xa863
movq %r13, %rdi
callq 0x5378
leaq 0x50(%rsp), %rdi
movq %r12, %rsi
callq 0x5290
pushq $0x45
popq %rsi
leaq 0x50(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0xa7dd
movq %r12, %rdi
callq 0x5378
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x5290
movq 0x280(%rsp), %r15
pushq $0x41
popq %rsi
leaq 0x30(%rsp), %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0xa7dd
movq %r12, %rdi
callq 0x5378
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x5290
pushq $0x44
popq %rsi
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0xa863
movq %r15, %rdi
callq 0x5378
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0xd0(%rsp), %rdi
callq 0x5070
movq %rbx, %rax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xacf2
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x5070
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1215c
movq (%r14), %rsi
movq %rsp, %rdi
callq 0xe57c
movq (%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x12172
movq 0x10(%rsp), %rdi
callq 0x1b2e2
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xe0ae
leaq 0x18(%rsp), %rdi
callq 0x8ea0
leaq 0x8(%rsp), %rdi
callq 0x8ea0
leaq 0x40(%rsp), %rdi
callq 0x8ea0
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movslq %ebp, %r15
cmpq %r15, %rcx
jbe 0xd45e
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 0x8e3e
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rdi
callq 0x5120
movl $0x3, (%rax)
movq 0x1db2d(%rip), %rsi     # 0x2afa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5310
movq %rax, %rbx
jmp 0xd494
movq %rax, %rbx
jmp 0xd49e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8ea0
leaq 0x8(%rsp), %rdi
callq 0x8ea0
leaq 0x40(%rsp), %rdi
callq 0x8ea0
jmp 0xd4b7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8e3e
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %rdi
callq 0x8e60
leaq 0x18(%r15), %rdi
movq %rbx, %rsi
callq 0x8e60
leaq 0x28(%r15), %rdi
leaq 0x38(%r15), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r15)
movups %xmm0, 0x28(%r15)
movq %r14, %rsi
callq 0xb472
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb472
movl $0x1, (%r15)
movb $0x0, 0x4(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x88, %rsp
movq %rdi, %rbx
leaq 0x10374(%rip), %rsi     # 0x1e96c
leaq 0x68(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x8d88
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0xe740
leaq 0x38(%rsp), %rdi
callq 0x8ea0
leaq 0x68(%rsp), %rdi
callq 0x5378
leaq 0x28(%rbx), %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8e60
leaq 0x38(%rbx), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xb472
movq %r12, %rdi
movq %r15, %rsi
callq 0xb472
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
testb $0x1, %al
jne 0xe67e
movq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x121cc
leaq 0x8(%rbx), %rax
jmp 0xe68e
movq 0x18(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x121cc
leaq 0x18(%rbx), %rax
movq (%rax), %rdi
callq 0x15df4
leaq 0x102d3(%rip), %rsi     # 0x1e970
leaq 0x48(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x8d88
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xe740
leaq 0x28(%rsp), %rdi
callq 0x8ea0
leaq 0x48(%rsp), %rdi
callq 0x5378
leaq 0x18(%rsp), %rdi
callq 0x8ea0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8ea0
leaq 0x48(%rsp), %rdi
callq 0x5378
jmp 0xe72d
jmp 0xe72a
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x8ea0
leaq 0x68(%rsp), %rdi
callq 0x5378
jmp 0xe737
movq %rax, %rbx
jmp 0xe737
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8ea0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xa0, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1024a(%rip), %rsi     # 0x1e9aa
movq %rbx, %rdi
callq 0x8dc3
testb %al, %al
je 0xe80c
movq 0x28(%r14), %r12
leaq 0x1022e(%rip), %rsi     # 0x1e9a9
leaq 0x60(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x8d88
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x8f30
leaq 0x60(%rsp), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x148d6
leaq 0x38(%rsp), %rdi
callq 0x8ea0
leaq 0x60(%rsp), %rdi
callq 0x5378
movq 0x38(%r14), %r12
leaq 0x101e7(%rip), %rsi     # 0x1e9b0
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x8d88
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x8f30
leaq 0x40(%rsp), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x148d6
leaq 0x28(%rsp), %rdi
callq 0x8ea0
leaq 0x40(%rsp), %rdi
callq 0x5378
leaq 0x1015d(%rip), %rsi     # 0x1e970
movq %rbx, %rdi
callq 0x8dc3
testb %al, %al
jne 0xe832
leaq 0x10146(%rip), %rsi     # 0x1e96c
movq %rbx, %rdi
callq 0x8dc3
testb %al, %al
je 0xe876
movq 0x28(%r14), %r14
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5290
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x148d6
leaq 0x18(%rsp), %rdi
callq 0x8ea0
leaq 0x80(%rsp), %rdi
callq 0x5378
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8ea0
leaq 0x40(%rsp), %rdi
jmp 0xe8cb
jmp 0xe8b1
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x8ea0
leaq 0x60(%rsp), %rdi
jmp 0xe8cb
movq %rax, %rbx
jmp 0xe8d0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8ea0
leaq 0x80(%rsp), %rdi
callq 0x5378
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
pushq $0x1
popq %rsi
callq 0x1674e
leaq 0x1abd2(%rip), %r12     # 0x2b2d0
movq (%r12), %r14
movq 0x1a8bf(%rip), %r15     # 0x2afc8
pushq $0xa
popq %rbp
cmpq 0x8(%r12), %r14
je 0x1072e
movq %r15, %rdi
movq %r14, %rsi
callq 0x51b0
movq %r15, %rdi
movl %ebp, %esi
callq 0x5240
addq $0x20, %r14
jmp 0x1070c
movq 0x18(%rbx), %rdi
pushq $0x2
popq %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1674e
// File: /workspace/github_cpp_makefile_star2_O2/BohangZhang[P]Sorcery-C-Project/player.cc
// Function: Player::Player(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Player::Player(string name) : name{name} {
    hp = 20;
    magic = 3;
    ritual = shared_ptr<Ritual>(nullptr);
    deck = shared_ptr<Deck>(new Deck());
    hand = shared_ptr<Hand>(new Hand());
    slot = shared_ptr<Slot>(new Slot());
    graveyard = shared_ptr<Graveyard>(new Graveyard());
    game = shared_ptr<Game>(nullptr);
    database = shared_ptr<Database>(nullptr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x5290
leaq 0x68(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
movabsq $0x300000014, %rax      # imm = 0x300000014
movq %rax, 0x20(%rbx)
movq %rsp, %rsi
movaps %xmm0, (%rsi)
callq 0x1a8a6
leaq 0x8(%rsp), %rdi
callq 0x8ea0
pushq $0x20
popq %rdi
callq 0x51f0
leaq 0x18173(%rip), %rcx     # 0x2a0d0
addq $0x10, %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
andq $0x0, 0x18(%rax)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1a8d4
leaq 0x28(%rbx), %rdi
movq %rsp, %rsi
callq 0x1a974
leaq 0x8(%rsp), %rdi
callq 0x8ea0
pushq $0x18
popq %rdi
callq 0x51f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1a9a2
leaq 0x38(%rbx), %rdi
movq %rsp, %rsi
callq 0x1aa5a
leaq 0x8(%rsp), %rdi
callq 0x8ea0
pushq $0x18
popq %rdi
callq 0x51f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1aa88
leaq 0x48(%rbx), %rdi
movq %rsp, %rsi
callq 0x1ab40
leaq 0x8(%rsp), %rdi
callq 0x8ea0
pushq $0x18
popq %rdi
callq 0x51f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1ab6e
leaq 0x88(%rbx), %r14
leaq 0x78(%rbx), %r15
addq $0x58, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1ac26
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x8ea0
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rbx)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1ac54
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x8ea0
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rbx)
movq %rsp, %rsi
movq %r15, %rdi
callq 0x1ac82
leaq 0x8(%rsp), %rdi
callq 0x8ea0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x12089
jmp 0x12089
jmp 0x12089
movq %rax, %r14
leaq 0x90(%rbx), %rdi
callq 0x8ea0
leaq 0x80(%rbx), %rdi
callq 0x8ea0
leaq 0x70(%rbx), %rdi
callq 0x8ea0
leaq 0x60(%rbx), %rdi
callq 0x8ea0
leaq 0x50(%rbx), %rdi
callq 0x8ea0
leaq 0x40(%rbx), %rdi
callq 0x8ea0
leaq 0x30(%rbx), %rdi
callq 0x8ea0
movq %rbx, %rdi
callq 0x5378
movq %r14, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/BohangZhang[P]Sorcery-C-Project/player.cc
// Function: Player::use(int)
void Player::use(int i) {
    if (getSlot()->getSize() < i) throw 11; // Number; The Minion doesn't exist
    shared_ptr<Minion> m = getSlot()->getSlot()[i - 1];
    string minion_type = m->getType();
    if (minion_type == "Enchantment") {
        minion_type = m->getOriginType();
    }
    if (minion_type != "Act_Minion") throw 12; // Number; Wrong command, the minion doesn't have an ability to use
    if (getMagic() < m->getAbilityCost()) throw 6; // Number; You don't have enough Magic
    if (m->getSilent() == 1) throw 1; // The Ac Minion has been silented
    m->use();
    subMagic(m->getAbilityCost());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a802
movq (%r15), %rdi
callq 0x1b2e6
movl %eax, %r15d
leaq 0x20(%rsp), %rdi
callq 0x8ea0
cmpl %ebp, %r15d
jl 0x13c57
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a802
movq (%r15), %rdi
callq 0x1b2e2
movq (%rax), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rsi
addq $-0x10, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8f30
leaq 0x20(%rsp), %rdi
callq 0x8ea0
movq (%r14), %rsi
leaq 0x18(%rsp), %rdi
callq 0xb3f4
leaq 0xac34(%rip), %rsi      # 0x1e7d4
leaq 0x18(%rsp), %rdi
callq 0x8dc3
testb %al, %al
je 0x13bdb
movq 0x8(%rsp), %rsi
movq (%rsi), %rax
leaq 0x38(%rsp), %rdi
callq *0x88(%rax)
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %r14
movq %r14, %rsi
callq 0x5250
movq %r14, %rdi
callq 0x5378
leaq 0xac3c(%rip), %rsi      # 0x1e81e
leaq 0x18(%rsp), %rdi
callq 0xe0a3
testb %al, %al
jne 0x13c76
movl 0x24(%rbx), %ebp
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpl %eax, %ebp
jl 0x13c7a
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
testb %al, %al
jne 0x13c7e
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0xd8(%rax)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
movl %eax, %esi
callq 0x121d0
leaq 0x18(%rsp), %rdi
callq 0x5378
leaq 0x10(%rsp), %rdi
callq 0x8ea0
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rdi
callq 0x5120
movl $0xb, (%rax)
movq 0x17334(%rip), %rsi     # 0x2afa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5310
pushq $0xc
jmp 0x13c80
pushq $0x6
jmp 0x13c80
pushq $0x1
popq %rbx
pushq $0x4
popq %rdi
callq 0x5120
movl %ebx, (%rax)
movq 0x1730e(%rip), %rsi     # 0x2afa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5310
jmp 0x13caf
movq %rax, %rbx
jmp 0x13cbc
jmp 0x13ca5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x13cc1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5378
leaq 0x10(%rsp), %rdi
callq 0x8ea0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0x48, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a802
movq (%r15), %rdi
callq 0x1b2e6
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x8ea0
cmpl %ebx, %ebp
jl 0x14321
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a802
movq (%r15), %rdi
callq 0x1b2e2
movq (%rax), %rax
movslq %ebx, %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rsi
addq $-0x10, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x8f30
leaq 0x20(%rsp), %rdi
callq 0x8ea0
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0xc8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x8ea0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rdi
callq 0x5120
movl $0xb, (%rax)
movq 0x16c6a(%rip), %rsi     # 0x2afa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5310
jmp 0x1434c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x14354
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8ea0
movq %rbx, %rdi
callq 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x12226
testb %al, %al
jne 0x15e6f
movq %rbx, %rdi
callq 0x12212
testb %al, %al
jne 0x15e7f
movq 0x28(%rbx), %rdi
callq 0xc2c6
movq (%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0xb86e
movq 0x28(%rbx), %rdi
callq 0xc2e2
movq 0x38(%rbx), %rbx
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xb86e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10e7e
leaq 0x20(%rsp), %rdi
callq 0x8ea0
leaq 0x10(%rsp), %rdi
callq 0x8ea0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x4
popq %rdi
callq 0x5120
movl $0x4, (%rax)
jmp 0x15e8d
pushq $0x4
popq %rdi
callq 0x5120
movl $0xd, (%rax)
movq 0x1510c(%rip), %rsi     # 0x2afa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5310
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8ea0
jmp 0x15eb0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8ea0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
leaq 0x3c61(%rip), %rsi      # 0x1ec80
movq %r14, %rdi
callq 0x8dc3
testb %al, %al
je 0x1b04a
movq (%rbx), %rdi
movq (%rdi), %rax
pushq $0x1
popq %rbp
movl %ebp, %esi
callq *0xa0(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0xa8(%rax)
leaq 0x3c3d(%rip), %rsi      # 0x1ec8e
movq %r14, %rdi
callq 0x8dc3
testb %al, %al
je 0x1b117
movq (%rbx), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xb45c
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x12172
movq 0x8(%rsp), %r14
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8f30
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b326
leaq 0x40(%rsp), %rdi
callq 0x8ea0
leaq 0x10(%rsp), %rdi
callq 0x8ea0
leaq 0x20(%rsp), %rdi
callq 0x8ea0
movq (%rbx), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xb45c
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x12184
movq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8f30
movq %r14, %rdi
movq %r15, %rsi
callq 0x10b26
leaq 0x30(%rsp), %rdi
callq 0x8ea0
leaq 0x10(%rsp), %rdi
callq 0x8ea0
leaq 0x20(%rsp), %rdi
callq 0x8ea0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x1b136
jmp 0x1b147
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x8ea0
leaq 0x10(%rsp), %rdi
callq 0x8ea0
jmp 0x1b14a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8ea0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b34a
movq (%rsi), %rdx
cmpq (%rax), %rdx
je 0x1b344
addq $0x10, %rsi
jmp 0x1b331
popq %rax
jmp 0x10dc0
pushq $0x4
popq %rdi
callq 0x5120
movl $0xe, (%rax)
movq 0xfc41(%rip), %rsi      # 0x2afa0
movq %rax, %rdi
xorl %edx, %edx
callq 0x5310
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x2a1d(%rip), %rsi      # 0x1ece0
movq %r14, %rdi
callq 0x8dc3
testb %al, %al
je 0x1c2de
movq (%r15), %rdi
movq (%rdi), %rax
pushq $0x1
popq %rsi
callq *0xb8(%rax)
leaq 0x2a0a(%rip), %rsi      # 0x1ecef
movq %r14, %rdi
callq 0x8dc3
testb %al, %al
je 0x1c360
movq 0x70(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12172
movq (%r14), %rdi
callq 0x1b2e2
movq (%rax), %r12
leaq 0x10(%rsp), %rdi
callq 0x8ea0
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rbp
movq 0x70(%rbx), %rsi
movq %r15, %rdi
callq 0x12172
movq 0x8(%rsp), %rdi
callq 0x1b2e2
movq 0x8(%rax), %r13
movq %r14, %rdi
callq 0x8ea0
cmpq %r13, %r12
je 0x1c360
movq (%r12), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0xa8(%rax)
addq $0x10, %r12
jmp 0x1c324
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x1c37f
movq %rax, %rbx
movq %r14, %rdi
callq 0x8ea0
movq %rbx, %rdi
callq 0x5330
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH08_TheIOLibrary/examples/fileIO.cc
// Function: main
int main(int argc, char* argv[])
{
	// for each file passed to the program
	for (auto p = argv + 1; p != argv + argc; ++p) {
	    ifstream input(*p);   // create input and open the file
	    if (input) {          // if the file is ok, ``process'' this file
	        process(input);
		} else
	        cerr << "couldn't open: " + string(*p);
	} // input goes out of scope and is destroyed on each iteration
	
	auto p = argv + 1, end = argv + argc;
	
	ifstream input;           
	while (p != end) {        // for each file passed to the program
		input.open(*p);       // open the file, automatically clears the stream 
	    if (input) {          // if the file is ok, read and ``process'' the input
	        	process(input);
		} else
			cerr << "couldn't open: " + string(*p);
	    input.close();        // close file when we're done with it
	    ++p;                  // increment pointer to get next file
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rbx
movslq %edi, %rax
shlq $0x3, %rax
movq %rax, -0x38(%rbp)
pushq $0x8
popq %r12
leaq -0x58(%rbp), %r14
leaq -0x78(%rbp), %r15
cmpq %r12, -0x38(%rbp)
je 0x13a6
movq (%rbx,%r12), %rsi
leaq -0x280(%rbp), %r13
movq %r13, %rdi
pushq $0x8
popq %rdx
callq 0x1110
movq -0x280(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x260(%rbp,%rax)
je 0x138d
movq (%rbx,%r12), %rsi
movq %r14, %r13
movq %r14, %rdi
leaq -0x29(%rbp), %rdx
callq 0x1060
movq %r15, %rdi
leaq 0xca7(%rip), %rsi       # 0x2004
movq %r13, %rdx
callq 0x14b2
movq 0x2c84(%rip), %rdi      # 0x3ff0
movq %r15, %rsi
callq 0x10b0
movq %r15, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1070
leaq -0x280(%rbp), %r13
jmp 0x1395
movq %r13, %rdi
callq 0x125c
movq %r13, %rdi
callq 0x1050
addq $0x8, %r12
jmp 0x130b
leaq -0x280(%rbp), %rdi
callq 0x10c0
pushq $0x8
popq %r12
leaq -0x78(%rbp), %r13
cmpq %r12, -0x38(%rbp)
je 0x1455
movq (%rbx,%r12), %rsi
leaq -0x280(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x1090
movq -0x280(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x260(%rbp,%rax)
je 0x1434
movq (%rbx,%r12), %rsi
leaq -0x58(%rbp), %r14
movq %r14, %rdi
leaq -0x29(%rbp), %rdx
callq 0x1060
movq %r13, %rdi
leaq 0xbfa(%rip), %rsi       # 0x2004
movq %r14, %rdx
callq 0x14b2
movq 0x2bd7(%rip), %rdi      # 0x3ff0
movq %r13, %rsi
callq 0x10b0
movq %r13, %rdi
callq 0x1070
leaq -0x58(%rbp), %rdi
callq 0x1070
jmp 0x1440
leaq -0x280(%rbp), %rdi
callq 0x125c
leaq -0x280(%rbp), %rdi
callq 0x1030
addq $0x8, %r12
jmp 0x13ba
leaq -0x280(%rbp), %rdi
callq 0x1050
xorl %eax, %eax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x149b
jmp 0x1484
jmp 0x149b
jmp 0x147f
jmp 0x149b
movq %rax, %rbx
jmp 0x1490
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x1070
leaq -0x58(%rbp), %rdi
callq 0x1070
jmp 0x149e
movq %rax, %rbx
leaq -0x280(%rbp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xa0, %rsp
xorl %edi, %edi
callq 0x21a0
movl %eax, %edi
callq 0x21c0
leaq 0xaec8(%rip), %rsi      # 0xe344
leaq 0x80(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x2090
leaq 0x80(%rsp), %rdi
callq 0x243c
leaq 0x80(%rsp), %rdi
callq 0x20c0
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x6b78
movq %rbx, %rdi
callq 0x7088
leaq 0xae86(%rip), %rsi      # 0xe34a
leaq 0x60(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x2090
leaq 0x60(%rsp), %rdi
callq 0x257e
leaq 0x60(%rsp), %rdi
callq 0x20c0
pushq $0x5
popq %rbp
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %r14
subl $0x1, %ebp
jb 0x3517
callq 0x2060
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6cbc
movq %rbx, %rdi
callq 0x7088
jmp 0x34f4
leaq 0xae39(%rip), %rsi      # 0xe357
leaq 0x40(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x2090
leaq 0x40(%rsp), %rdi
callq 0x257e
leaq 0x40(%rsp), %rdi
callq 0x20c0
pushq $0x5
popq %rbp
leaq 0x10(%rsp), %rbx
subl $0x1, %ebp
jb 0x3560
movq %rbx, %rdi
callq 0x6d2c
movq %rbx, %rdi
callq 0x7088
jmp 0x3549
leaq 0xaddd(%rip), %rsi      # 0xe344
leaq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x2090
leaq 0x20(%rsp), %rdi
callq 0x2542
leaq 0x20(%rsp), %rdi
callq 0x20c0
callq 0x25a2
leaq 0x10(%rsp), %rdi
callq 0x7066
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x35c5
jmp 0x35eb
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x35c5
jmp 0x35eb
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x20c0
jmp 0x35ee
jmp 0x35eb
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x20c0
jmp 0x35f8
movq %rax, %rbx
jmp 0x35f8
jmp 0x35eb
jmp 0x35eb
jmp 0x35eb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7066
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xa0, %rsp
xorl %edi, %edi
callq 0x21a0
movl %eax, %edi
callq 0x21c0
leaq 0xad4c(%rip), %rsi      # 0xe36c
leaq 0x80(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x2090
leaq 0x80(%rsp), %rdi
callq 0x243c
leaq 0x80(%rsp), %rdi
callq 0x20c0
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x6b78
movq %rbx, %rdi
callq 0x7112
leaq 0xad13(%rip), %rsi      # 0xe37b
leaq 0x60(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x2090
leaq 0x60(%rsp), %rdi
callq 0x257e
leaq 0x60(%rsp), %rdi
callq 0x20c0
pushq $0x5
popq %rbp
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %r14
subl $0x1, %ebp
jb 0x36bb
callq 0x2060
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6cbc
movq %rbx, %rdi
callq 0x7112
jmp 0x3698
leaq 0xaccf(%rip), %rsi      # 0xe391
leaq 0x40(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x2090
leaq 0x40(%rsp), %rdi
callq 0x257e
leaq 0x40(%rsp), %rdi
callq 0x20c0
pushq $0x5
popq %rbp
leaq 0x10(%rsp), %rbx
subl $0x1, %ebp
jb 0x3704
movq %rbx, %rdi
callq 0x6d68
movq %rbx, %rdi
callq 0x7112
jmp 0x36ed
leaq 0xac61(%rip), %rsi      # 0xe36c
leaq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x2090
leaq 0x20(%rsp), %rdi
callq 0x2542
leaq 0x20(%rsp), %rdi
callq 0x20c0
callq 0x25a2
leaq 0x10(%rsp), %rdi
callq 0x7066
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x3769
jmp 0x378f
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x3769
jmp 0x378f
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x20c0
jmp 0x3792
jmp 0x378f
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x20c0
jmp 0x379c
movq %rax, %rbx
jmp 0x379c
jmp 0x378f
jmp 0x378f
jmp 0x378f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7066
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21a0
movl %eax, %edi
callq 0x21c0
leaq 0xab9f(%rip), %rsi      # 0xe363
leaq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x2090
leaq 0x90(%rsp), %rdi
callq 0x243c
leaq 0x90(%rsp), %rdi
callq 0x20c0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x71ca
leaq 0xab66(%rip), %rsi      # 0xe372
leaq 0x70(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x2090
leaq 0x70(%rsp), %rdi
callq 0x257e
leaq 0x70(%rsp), %rdi
callq 0x20c0
pushq $0xa
popq %rbp
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %r14
subl $0x1, %ebp
jb 0x385f
callq 0x2060
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x725c
movq %rbx, %rdi
callq 0x71ca
jmp 0x383c
leaq 0xab22(%rip), %rsi      # 0xe388
leaq 0x50(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x2090
leaq 0x50(%rsp), %rdi
callq 0x257e
leaq 0x50(%rsp), %rdi
callq 0x20c0
leaq 0x10(%rsp), %rdi
callq 0x71ca
pushq $0xa
popq %rbp
leaq 0x10(%rsp), %rbx
subl $0x1, %ebp
jb 0x38b2
movq %rbx, %rdi
callq 0x7294
movq %rbx, %rdi
callq 0x71ca
jmp 0x389b
leaq 0xaaaa(%rip), %rsi      # 0xe363
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x2090
leaq 0x30(%rsp), %rdi
callq 0x2542
leaq 0x30(%rsp), %rdi
callq 0x20c0
callq 0x25a2
leaq 0x10(%rsp), %rdi
callq 0x6b68
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x3917
jmp 0x393d
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x3917
jmp 0x393d
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x20c0
jmp 0x3940
jmp 0x393d
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x20c0
jmp 0x394a
movq %rax, %rbx
jmp 0x394a
jmp 0x393d
jmp 0x393d
jmp 0x393d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6b68
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26d2
callq 0x2d16
callq 0x345c
callq 0x3600
callq 0x37a4
callq 0x3952
callq 0x3c68
callq 0x3f7e
callq 0x42dc
callq 0x488c
callq 0x4e0c
callq 0x5774
callq 0x5a68
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xcd12(%rip), %r14      # 0x14fd8
leaq 0x6630(%rip), %rsi      # 0xe8fd
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x2, %rcx
movl %ecx, %esi
movq %rax, %rdi
callq 0x2120
leaq 0x657e(%rip), %rsi      # 0xe86f
movq %r14, %rdi
callq 0x21d0
movq 0x10(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x2, %rcx
movl %ecx, %esi
movq %rax, %rdi
callq 0x2120
leaq 0x6568(%rip), %rsi      # 0xe87d
movq %r14, %rdi
callq 0x21d0
movq (%rbx), %rcx
xorl %esi, %esi
cmpq 0x8(%rbx), %rcx
sete %sil
movq %rax, %rdi
callq 0x22b0
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x8386
movq 0xcc96(%rip), %rdi      # 0x14fd8
leaq 0x653f(%rip), %rsi      # 0xe888
callq 0x21d0
movq (%rbx), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x2120
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x8386
movq 0xcc6d(%rip), %rdi      # 0x14fd8
leaq 0x6521(%rip), %rsi      # 0xe893
callq 0x21d0
movq 0x8(%rbx), %rcx
movl -0x4(%rcx), %esi
movq %rax, %rdi
callq 0x2120
movq 0xcc4b(%rip), %r14      # 0x14fd8
movq %r14, %rdi
callq 0x20d0
leaq 0x6501(%rip), %rsi      # 0xe89d
movq %rax, %rdi
callq 0x21d0
movq (%rbx), %r12
leaq 0x6112(%rip), %r15      # 0xe4c0
cmpq 0x8(%rbx), %r12
je 0x83d1
movl (%r12), %esi
movq %r14, %rdi
callq 0x2120
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
addq $0x4, %r12
jmp 0x83ae
movq 0xcc00(%rip), %rdi      # 0x14fd8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
cmpq 0x10(%rdi), %rax
je 0x6914
leaq 0x4(%rax), %rcx
movq %rcx, 0x8(%rbx)
movl (%r14), %ecx
movl %ecx, (%rax)
jmp 0x6984
subq (%rbx), %rax
movq %rax, %r13
shrq $0x2, %r13
shrq %rax
testl %r13d, %r13d
movl %eax, %eax
pushq $0x1
popq %r12
cmovneq %rax, %r12
leaq (,%r12,4), %rdi
callq 0x21e0
movq %rax, %r15
movq (%rbx), %rax
movl %r13d, %ecx
pushq $-0x4
popq %rbp
xorl %r13d, %r13d
cmpq %r13, %rcx
je 0x6960
movl (%rax,%r13,4), %edx
movl %edx, (%r15,%r13,4)
incq %r13
addq $-0x4, %rbp
jmp 0x694a
movq %rbx, %rdi
callq 0x8934
leaq (%r15,%r12,4), %rax
movq %r15, %rcx
subq %rbp, %rcx
movl (%r14), %edx
movl %edx, (%r15,%r13,4)
movq %r15, (%rbx)
movq %rcx, 0x8(%rbx)
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_O2/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 0x69d8
movq %rax, %rcx
cmpq %r14, %rcx
je 0x69c5
movl -0x4(%rcx), %edx
movl %edx, (%rcx)
addq $-0x4, %rcx
jmp 0x69b5
movl (%r15), %ecx
movl %ecx, (%r14)
addq $0x4, %rax
movq %rax, 0x8(%rbx)
jmp 0x6a58
subq (%rbx), %rax
movq %rax, %rcx
shrq $0x2, %rcx
shrq %rax
testl %ecx, %ecx
movl %eax, %eax
pushq $0x1
popq %r13
cmovneq %rax, %r13
leaq (,%r13,4), %rdi
callq 0x21e0
movq %rax, %r12
movq (%rbx), %rax
movq %r12, %rbp
cmpq %r14, %rax
je 0x6a1b
movl (%rax), %ecx
movl %ecx, (%rbp)
addq $0x4, %rbp
addq $0x4, %rax
jmp 0x6a07
movl (%r15), %eax
movl %eax, (%rbp)
movq 0x8(%rbx), %rax
leaq 0x4(%rbp), %r15
cmpq %rax, %r14
je 0x6a3e
movl (%r14), %ecx
movl %ecx, (%r15)
addq $0x4, %r14
addq $0x4, %r15
jmp 0x6a29
movq %rbx, %rdi
callq 0x8934
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_O2/cjc12[P]ezSTL/src/../include/vector.h
// Function: ezSTL::vector<int, ezSTL::allocator<int>>::erase(int*)
typename vector<T, Alloc>::iterator
		vector<T, Alloc>::erase(iterator pos) {
		for (auto ite = pos; ite != end(); ++ite) {
			destroy(ite);
			if(ite + 1 != end())
				construct(ite, *(ite + 1));
		}
		--finish;
		return pos;
	}

// Assembly:
movq %rsi, %rax
movq 0x8(%rdi), %rcx
leaq 0x4(%rsi), %rdx
leaq -0x4(%rdx), %rsi
cmpq %rcx, %rsi
je 0x6a8e
cmpq %rcx, %rdx
je 0x6a88
movl (%rdx), %esi
movl %esi, -0x4(%rdx)
addq $0x4, %rdx
jmp 0x6a75
addq $-0x4, %rcx
movq %rcx, 0x8(%rdi)
retq
nop