LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nandakishoremmn2[P]multigrid/multigridsolver.cpp
// Function: MultiGridSolver::save_data(char*)
void MultiGridSolver::save_data(char *filename)
{
	std::ofstream outfile(filename);

	for (std::vector<GridData>::iterator i = data.begin(); i != data.end(); ++i)
	{
		outfile<<i->iterations<<" ";
		outfile<<i->residue<<" ";
		outfile<<i->wu<<" ";
		outfile<<i->level<<" ";
		outfile<<"\n";
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x10f0
movq -0x238(%rbp), %rdi
addq $0x20, %rdi
callq 0x3650
movq %rax, -0x218(%rbp)
movq -0x238(%rbp), %rdi
addq $0x20, %rdi
callq 0x36c0
movq %rax, -0x220(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x3680
testb $0x1, %al
jne 0x339d
jmp 0x34cc
leaq -0x218(%rbp), %rdi
callq 0x36f0
movl 0x10(%rax), %esi
leaq -0x210(%rbp), %rdi
callq 0x1170
movq %rax, -0x240(%rbp)
jmp 0x33c1
movq -0x240(%rbp), %rdi
leaq 0x1cdf(%rip), %rsi      # 0x50ae
callq 0x10c0
jmp 0x33d6
leaq -0x218(%rbp), %rdi
callq 0x36f0
movsd (%rax), %xmm0
leaq -0x210(%rbp), %rdi
callq 0x11a0
movq %rax, -0x248(%rbp)
jmp 0x33fb
movq -0x248(%rbp), %rdi
leaq 0x1ca5(%rip), %rsi      # 0x50ae
callq 0x10c0
jmp 0x3410
leaq -0x218(%rbp), %rdi
callq 0x36f0
movsd 0x8(%rax), %xmm0
leaq -0x210(%rbp), %rdi
callq 0x11a0
movq %rax, -0x250(%rbp)
jmp 0x3436
movq -0x250(%rbp), %rdi
leaq 0x1c6a(%rip), %rsi      # 0x50ae
callq 0x10c0
jmp 0x344b
leaq -0x218(%rbp), %rdi
callq 0x36f0
movl 0x14(%rax), %esi
leaq -0x210(%rbp), %rdi
callq 0x1170
movq %rax, -0x258(%rbp)
jmp 0x346f
movq -0x258(%rbp), %rdi
leaq 0x1c31(%rip), %rsi      # 0x50ae
callq 0x10c0
jmp 0x3484
leaq 0x1c91(%rip), %rsi      # 0x511c
leaq -0x210(%rbp), %rdi
callq 0x10c0
jmp 0x3499
jmp 0x349b
leaq -0x218(%rbp), %rdi
callq 0x3710
jmp 0x336a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x1130
jmp 0x34e1
leaq -0x210(%rbp), %rdi
callq 0x1130
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x1190
nopl (%rax)
// File: dlbeer[P]summary_map/test_compile.cpp
// Function: main
int main()
{
    test_map m;
    summary_map<std::string, int, int,
		std::less<std::string>, int_aggregator> custom_map;

    test_mutable(m);
    test_const(m);
    test_cpp11(m);

    return 0;
}

// Assembly:
subq $0xc8, %rsp
movl $0x0, 0xc4(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2420
leaq 0x10(%rsp), %rdi
callq 0x2490
jmp 0x1278
leaq 0x68(%rsp), %rdi
callq 0x1310
jmp 0x1284
leaq 0x68(%rsp), %rdi
callq 0x1d40
jmp 0x1290
leaq 0x68(%rsp), %rdi
callq 0x21f0
jmp 0x129c
movl $0x0, 0xc4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2500
leaq 0x68(%rsp), %rdi
callq 0x2550
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x8(%rsp)
movl %eax, 0x4(%rsp)
jmp 0x12f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x8(%rsp)
movl %eax, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2500
leaq 0x68(%rsp), %rdi
callq 0x2550
movq 0x8(%rsp), %rdi
callq 0x1130
nopw %cs:(%rax,%rax)
// File: 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>>>::equal_range(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::pair<iterator, iterator> equal_range(const key_type& target)
    {
	iterator b = find(target);
	iterator e = b;

	if (e != end())
	    ++e;

	return std::make_pair(b, e);
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0x2a00
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x2620
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x32c0
testb $0x1, %al
jne 0x26a5
jmp 0x26af
leaq 0x18(%rsp), %rdi
callq 0x32e0
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3310
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0xb8(%rsp), %rsi
callq 0x2a00
movq 0x18(%rsp), %rdi
movq %rax, 0xb0(%rsp)
callq 0x2620
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x39a0
testb $0x1, %al
jne 0x27c9
jmp 0x289c
movq 0xb8(%rsp), %rsi
movl $0x0, 0x44(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x44(%rsp), %rdx
callq 0x39c0
movq 0x10(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x3a00
jmp 0x27fe
movq 0x18(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x2a40
movb %dl, 0x7(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x2818
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movb %al, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x98(%rsp)
movb 0x28(%rsp), %al
movb %al, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0xb0(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x2bc0
leaq 0x48(%rsp), %rdi
callq 0x3a40
jmp 0x289c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x2890
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x2bc0
leaq 0x48(%rsp), %rdi
callq 0x3a40
jmp 0x28b5
leaq 0xb0(%rsp), %rdi
callq 0x3a50
addq $0x20, %rax
addq $0xc8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x1130
nop
// File: 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>>>::swap(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>>>&)
void swap(summary_map& r)
    {
	using std::swap;

	swap(comparer, r.comparer);
	swap(aggregator, r.aggregator);
	swap(allocator, r.allocator);

	std::swap(item_count, r.item_count);
	std::swap(header.left, r.header.left);

	if (header.left)
	    header.left->parent = &header;
	if (r.header.left)
	    r.header.left->parent = &r.header;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x4b80
movq (%rsp), %rdi
addq $0x1, %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
callq 0x4b90
movq (%rsp), %rdi
addq $0x2, %rdi
movq 0x8(%rsp), %rsi
addq $0x2, %rsi
callq 0x4ba0
movq (%rsp), %rdi
addq $0x50, %rdi
movq 0x8(%rsp), %rsi
addq $0x50, %rsi
callq 0x4bd0
movq (%rsp), %rdi
addq $0x8, %rdi
addq $0x30, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
addq $0x30, %rsi
callq 0x40d0
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2f4f
movq (%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq 0x38(%rax), %rax
movq %rcx, 0x40(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2f71
movq 0x8(%rsp), %rcx
addq $0x8, %rcx
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x40(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4b41
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x43e0
testb $0x1, %al
jne 0x4aed
jmp 0x4afd
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x4b3f
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x43e0
testb $0x1, %al
jne 0x4b17
jmp 0x4b31
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x4b3d
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x4b4b
jmp 0x4b3f
jmp 0x4acb
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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>>>::summary_map(std::initializer_list<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>)
summary_map(std::initializer_list<value_type> init) :
	item_count(0)
    {
	try {
	    insert(init.begin(), init.end());
	}
	catch (...) {
	    delete_tree(allocator, header.left);
	    throw;
	}
    }

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x2, %rdi
movq %rdi, 0x18(%rsp)
callq 0x5b00
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq %rdi, 0x28(%rsp)
callq 0x3570
jmp 0x5960
movq 0x20(%rsp), %rax
movq $0x0, 0x50(%rax)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5b80
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x5b90
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x5b10
jmp 0x599f
jmp 0x5a08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x5a0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1060
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x2, %rdi
movq 0x38(%rax), %rsi
callq 0x31e0
jmp 0x59e0
callq 0x1110
jmp 0x5a29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x1120
jmp 0x59fc
movq 0x28(%rsp), %rdi
callq 0x3280
jmp 0x5a0d
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x3730
movq 0x38(%rsp), %rdi
callq 0x1130
movq %rax, %rdi
callq 0x3160
nopl (%rax)
// File: 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
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x3f8ccccd, -0x14(%rbp) # imm = 0x3F8CCCCD
movl $0x3f99999a, -0x18(%rbp) # imm = 0x3F99999A
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1420
movl %eax, %esi
movq 0x3d5b(%rip), %rdi      # 0x4fd8
callq 0x10e0
movq %rax, %rdi
movq 0x3d3c(%rip), %rsi      # 0x4fc8
callq 0x10b0
movl $0x1, -0x4c(%rbp)
movl $0x2, -0x48(%rbp)
movl $0x3, -0x44(%rbp)
leaq -0x4c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x3, -0x38(%rbp)
leaq -0x4d(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1480
movq -0xa0(%rbp), %rcx
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x14a0
jmp 0x12e0
leaq -0x4d(%rbp), %rdi
callq 0x1520
movl $0x4, -0x94(%rbp)
movl $0x5, -0x90(%rbp)
movl $0x6, -0x8c(%rbp)
leaq -0x94(%rbp), %rax
movq %rax, -0x88(%rbp)
movq $0x3, -0x80(%rbp)
leaq -0x95(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1480
movq -0xa8(%rbp), %rcx
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x14a0
jmp 0x134d
leaq -0x95(%rbp), %rdi
callq 0x1520
leaq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1540
movl %eax, -0xac(%rbp)
jmp 0x136e
movl -0xac(%rbp), %esi
movq 0x3c5d(%rip), %rdi      # 0x4fd8
callq 0x10e0
movq %rax, -0xb8(%rbp)
jmp 0x1389
movq -0xb8(%rbp), %rdi
movq 0x3c31(%rip), %rsi      # 0x4fc8
callq 0x10b0
jmp 0x139e
movl $0x0, -0x4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x15a0
leaq -0x30(%rbp), %rdi
callq 0x15a0
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x4d(%rbp), %rdi
callq 0x1520
jmp 0x1412
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x95(%rbp), %rdi
callq 0x1520
jmp 0x1409
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x15a0
leaq -0x30(%rbp), %rdi
callq 0x15a0
movq -0x58(%rbp), %rdi
callq 0x10f0
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x4ed0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x2a03
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x4ef0
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x24(%rsp), %rsi
callq 0x4ef0
movsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x298f
movsd 0x28(%rsp), %xmm0
callq 0x2180
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x2, 0x10(%rsp)
jge 0x4cd6
movl $0x0, 0x14(%rsp)
jmp 0x4d18
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x285ba(%rip), %rdi     # 0x2d2a0
callq 0x2270
cmpl $0x3, 0x10(%rsp)
jne 0x4d07
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x28536(%rip), %rdi     # 0x2d238
callq 0x2270
callq 0x2b80
leaq 0x594dd(%rip), %rdi     # 0x5e1f0
callq 0x5c30
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %r8, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movq %r8, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpl $-0x1, 0x44(%rsp)
je 0x55c9
movq 0x20(%rsp), %rdi
addq $0x78, %rdi
leaq 0x4c(%rsp), %rsi
callq 0x5420
movq 0x20(%rsp), %rdi
addq $0xa8, %rdi
leaq 0x44(%rsp), %rsi
callq 0x5420
movq 0x20(%rsp), %rdi
addq $0x90, %rdi
leaq 0x48(%rsp), %rsi
callq 0x5420
movq 0x20(%rsp), %rax
addq $0xf0, %rax
movq %rax, 0x10(%rsp)
leaq 0x4c(%rsp), %rdi
leaq 0x44(%rsp), %rsi
callq 0xc100
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0xc010
movq %rax, %rdi
leaq 0x48(%rsp), %rsi
callq 0x5870
movl $0x1, (%rax)
movq 0x18(%rsp), %rdi
callq 0xc130
cmpq $0x0, %rax
jbe 0x5619
movq 0x20(%rsp), %rax
addq $0xc0, %rax
movq %rax, 0x8(%rsp)
leaq 0x4c(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xc100
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0xc150
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0xc240
addq $0x58, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x1a040(%rip), %eax     # 0x2d20c
jge 0x132ea
movq 0x18(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0xfd80
movq %rax, %rdi
movslq 0x34(%rsp), %rsi
callq 0x4ef0
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xb8d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x1326b
movq 0x10(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xff70
movq 0x18(%rsp), %rdi
movslq (%rax), %rsi
callq 0xfd80
movq %rax, %rdi
movslq 0x34(%rsp), %rsi
callq 0x4ef0
movsd (%rax), %xmm1
movsd 0x28(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x13200
testb $0x1, 0x19f96(%rip)     # 0x2d208
je 0x132aa
movsd 0x28(%rsp), %xmm0
movaps 0xcdcf(%rip), %xmm1     # 0x20050
pand %xmm1, %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
jmp 0x132d8
movsd 0x28(%rsp), %xmm0
callq 0x2af0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
jmp 0x132da
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x131c2
movsd 0xcd2e(%rip), %xmm0     # 0x20020
addsd 0x38(%rsp), %xmm0
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x70, %rdi
callq 0x12980
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2a670
movq -0x70(%rbp), %rdi
callq 0x12a20
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x22910
jmp 0x1fefa
leaq -0x48(%rbp), %rdi
callq 0x12980
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x2a6b0
jmp 0x1ff11
leaq -0x38(%rbp), %rdi
callq 0x12af0
movq %rax, %rdi
callq 0x3d220
movq %rax, -0x80(%rbp)
jmp 0x1ff28
movq -0x80(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x216d0
jmp 0x1ff37
leaq -0x38(%rbp), %rdi
callq 0x12b30
leaq -0x48(%rbp), %rdi
callq 0x12a00
leaq -0x58(%rbp), %rdi
callq 0x12a70
leaq -0x28(%rbp), %rdi
callq 0x12b10
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x20056
movslq -0xc(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x12c80
movq %rax, %rdi
callq 0x12d30
movq -0x78(%rbp), %rdi
movq %rax, -0x90(%rbp)
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movl %eax, -0x84(%rbp)
jmp 0x1ff99
movl -0x84(%rbp), %esi
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq 0xb8(%rax), %rax
callq *%rax
jmp 0x1ffb4
movslq -0xc(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x12c80
movq %rax, %rdi
callq 0x12d30
movq %rax, %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movl %eax, -0x94(%rbp)
jmp 0x1ffdd
movl -0x94(%rbp), %esi
movq -0x78(%rbp), %rdi
movq (%rdi), %rax
movq 0xb8(%rax), %rax
callq *%rax
jmp 0x1fff5
jmp 0x2007b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x20034
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2002b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x12b30
leaq -0x48(%rbp), %rdi
callq 0x12a00
leaq -0x58(%rbp), %rdi
callq 0x12a70
jmp 0x2008d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12eb0
jmp 0x2008d
movl $0x4, %edi
callq 0x6160
movq %rax, %rdi
movl $0x3, (%rdi)
movq 0x33f28(%rip), %rsi     # 0x53f98
xorl %eax, %eax
movl %eax, %edx
callq 0x6430
jmp 0x20096
leaq -0x28(%rbp), %rdi
callq 0x12eb0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6460
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
callq 0x129a0
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x129a0
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x15ee0
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x15ee0
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x19df0
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x19df0
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movb $0x0, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: BohangZhang[P]Sorcery-C-Project/game.cc
// Function: Game::addCard(int)
void Game::addCard(int i) {
    if (i == 1) {
        this->player1->draw();
    } else {
        this->player2->draw();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x229d4
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x12980
movq %rax, %rdi
callq 0x31d80
jmp 0x229e9
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x12980
movq %rax, %rdi
callq 0x31d80
addq $0x20, %rsp
popq %rbp
retq
nop
// File: BohangZhang[P]Sorcery-C-Project/game.cc
// Function: Game::addMagic(int, int)
void Game::addMagic(int i, int m) {
    if (i == 1) {
        this->player1->addMagic(m);
    } else {
        this->player2->addMagic(m);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x22a2a
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x12980
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x2a7a0
jmp 0x22a42
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x12980
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x2a7a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6470
movq -0xa0(%rbp), %rdx
leaq 0x1eee4(%rip), %rsi     # 0x4196c
leaq -0x28(%rbp), %rdi
callq 0x12870
jmp 0x22a93
xorl %eax, %eax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x21650
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rdx
leaq -0x28(%rbp), %rsi
callq 0x22cc0
jmp 0x22ac0
leaq -0x50(%rbp), %rdi
callq 0x12d50
leaq -0x28(%rbp), %rdi
callq 0x64c8
leaq -0x29(%rbp), %rdi
callq 0x62f0
movq -0xa8(%rbp), %rsi
addq $0x28, %rsi
leaq -0x60(%rbp), %rdi
callq 0x129a0
movq -0xa8(%rbp), %rdi
movq %rdi, %rsi
addq $0x38, %rsi
addq $0x28, %rdi
callq 0x19df0
movq -0xa8(%rbp), %rdi
addq $0x38, %rdi
leaq -0x60(%rbp), %rsi
callq 0x19df0
movq -0xa8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl (%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x22baf
movq -0xa8(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x229f0
jmp 0x22b4f
movq -0xa8(%rbp), %rdi
movl $0x2, %esi
callq 0x229a0
jmp 0x22b62
jmp 0x22bd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x22b90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12d50
leaq -0x28(%rbp), %rdi
callq 0x64c8
leaq -0x29(%rbp), %rdi
callq 0x62f0
jmp 0x22cac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x22ca3
movq -0xa8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x229f0
jmp 0x22bc4
movq -0xa8(%rbp), %rdi
movl $0x1, %esi
callq 0x229a0
jmp 0x22bd7
jmp 0x22bd9
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x6470
movq -0xb8(%rbp), %rdx
leaq 0x1ed76(%rip), %rsi     # 0x41970
leaq -0x80(%rbp), %rdi
callq 0x12870
jmp 0x22c05
xorl %eax, %eax
movl %eax, %esi
leaq -0x98(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x21650
movq -0xa8(%rbp), %rdi
movq -0xc0(%rbp), %rdx
leaq -0x80(%rbp), %rsi
callq 0x22cc0
jmp 0x22c35
leaq -0x98(%rbp), %rdi
callq 0x12d50
leaq -0x80(%rbp), %rdi
callq 0x64c8
leaq -0x81(%rbp), %rdi
callq 0x62f0
leaq -0x60(%rbp), %rdi
callq 0x12a00
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x22c97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x12d50
leaq -0x80(%rbp), %rdi
callq 0x64c8
leaq -0x81(%rbp), %rdi
callq 0x62f0
leaq -0x60(%rbp), %rdi
callq 0x12a00
movq -0x38(%rbp), %rdi
callq 0x6460
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
callq 0x12980
movq %rax, %rdi
movl $0x1, %esi
callq 0x33000
leaq 0x2e6a7(%rip), %rdi     # 0x54378
callq 0x19250
movq %rax, -0x10(%rbp)
leaq 0x2e697(%rip), %rdi     # 0x54378
callq 0x19280
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x195d0
testb $0x1, %al
jne 0x25cfd
jmp 0x25d31
leaq -0x10(%rbp), %rdi
callq 0x19640
movq %rax, %rsi
movq 0x2e2b8(%rip), %rdi     # 0x53fc8
callq 0x6250
movq 0x2e2ac(%rip), %rdi     # 0x53fc8
movl $0xa, %esi
callq 0x6350
leaq -0x10(%rbp), %rdi
callq 0x19660
jmp 0x25cda
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x12980
movq %rax, %rdi
movl $0x2, %esi
callq 0x33000
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2a6b0
movq -0x60(%rbp), %rdi
callq 0x12af0
movq %rax, %rdi
callq 0x3d230
movl %eax, -0x54(%rbp)
jmp 0x2e59d
movl -0xc(%rbp), %eax
movl %eax, -0x6c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x12b30
movl -0x6c(%rbp), %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x2e5f3
movl $0x4, %edi
callq 0x6160
movq %rax, %rdi
movl $0xb, (%rdi)
movq 0x259c8(%rip), %rsi     # 0x53f98
xorl %eax, %eax
movl %eax, %edx
callq 0x6430
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x12b30
jmp 0x2e6a3
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2a6b0
movq -0x80(%rbp), %rdi
callq 0x12af0
movq %rax, %rdi
callq 0x3d220
movq %rax, -0x78(%rbp)
jmp 0x2e61b
movq -0x78(%rbp), %rdi
movl -0xc(%rbp), %eax
decl %eax
movslq %eax, %rsi
callq 0x12c80
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x12c10
leaq -0x50(%rbp), %rdi
callq 0x12b30
movq -0x88(%rbp), %rdi
callq 0x12d30
movq %rax, %rdi
movq (%rdi), %rax
movq 0xc8(%rax), %rax
callq *%rax
jmp 0x2e665
leaq -0x40(%rbp), %rdi
callq 0x12d50
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12b30
jmp 0x2e6a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x12d50
movq -0x28(%rbp), %rdi
callq 0x6460
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x2a8f0
testb $0x1, %al
jne 0x31d9f
jmp 0x31dc2
movl $0x4, %edi
callq 0x6160
movq %rax, %rdi
movl $0x4, (%rdi)
movq 0x221df(%rip), %rsi     # 0x53f98
xorl %eax, %eax
movl %eax, %edx
callq 0x6430
movq -0x40(%rbp), %rdi
callq 0x2a890
testb $0x1, %al
jne 0x31dd1
jmp 0x31df4
movl $0x4, %edi
callq 0x6160
movq %rax, %rdi
movl $0xd, (%rdi)
movq 0x221ad(%rip), %rsi     # 0x53f98
xorl %eax, %eax
movl %eax, %edx
callq 0x6430
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x48(%rbp)
callq 0x25d80
movq %rax, %rdi
callq 0x1d330
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x287a0
movq %rax, %rsi
leaq -0x18(%rbp), %rdi
callq 0x1a1f0
movq -0x48(%rbp), %rdi
callq 0x25d80
movq %rax, %rdi
callq 0x1d3b0
jmp 0x31e38
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
callq 0x12e10
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x1a1f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x27970
jmp 0x31e69
leaq -0x38(%rbp), %rdi
callq 0x15c40
leaq -0x18(%rbp), %rdi
callq 0x15c40
jmp 0x31eab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x31ea0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x15c40
leaq -0x18(%rbp), %rdi
callq 0x15c40
jmp 0x31eb3
jmp 0x31ead
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6460
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x8, %rdi
leaq 0x4eeb(%rip), %rsi      # 0x41c6b
callq 0x12920
testb $0x1, %al
jne 0x3cd8b
jmp 0x3cdc5
movq -0x90(%rbp), %rdi
callq 0x12d30
movq %rax, %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xa0(%rax)
movq -0x90(%rbp), %rdi
callq 0x12d30
movq %rax, %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xa8(%rax)
movq -0x88(%rbp), %rdi
addq $0x8, %rdi
leaq 0x4ea2(%rip), %rsi      # 0x41c79
callq 0x12920
testb $0x1, %al
jne 0x3cde5
jmp 0x3cf75
movq -0x90(%rbp), %rdi
callq 0x12d30
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x19d90
movq -0x98(%rbp), %rdi
callq 0x12980
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x2a6b0
jmp 0x3ce1e
leaq -0x20(%rbp), %rdi
callq 0x12af0
movq -0x90(%rbp), %rsi
movq %rax, -0xa8(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x12c10
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x3d2d0
jmp 0x3ce5a
leaq -0x50(%rbp), %rdi
callq 0x12d50
leaq -0x20(%rbp), %rdi
callq 0x12b30
leaq -0x30(%rbp), %rdi
callq 0x12a00
movq -0x90(%rbp), %rdi
callq 0x12d30
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x19d90
movq -0xb0(%rbp), %rdi
callq 0x12980
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x2a6e0
jmp 0x3ceae
leaq -0x60(%rbp), %rdi
callq 0x3ab30
movq -0x90(%rbp), %rsi
movq %rax, -0xc0(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x12c10
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x26f20
jmp 0x3ceea
leaq -0x80(%rbp), %rdi
callq 0x12d50
leaq -0x60(%rbp), %rdi
callq 0x3a9d0
leaq -0x70(%rbp), %rdi
callq 0x12a00
jmp 0x3cf75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3cf33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12d50
leaq -0x20(%rbp), %rdi
callq 0x12b30
leaq -0x30(%rbp), %rdi
callq 0x12a00
jmp 0x3cf7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3cf6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x12d50
leaq -0x60(%rbp), %rdi
callq 0x3a9d0
leaq -0x70(%rbp), %rdi
callq 0x12a00
jmp 0x3cf7e
addq $0xc0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6460
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x12b50
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
callq 0x12b80
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12bb0
testb $0x1, %al
jne 0x3d315
jmp 0x3d361
leaq -0x18(%rbp), %rdi
callq 0x12bf0
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x12c40
testb $0x1, %al
jne 0x3d330
jmp 0x3d354
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x274b0
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x27440
movq %rax, -0x30(%rbp)
addq $0x40, %rsp
popq %rbp
retq
jmp 0x3d356
leaq -0x18(%rbp), %rdi
callq 0x12d70
jmp 0x3d2f5
movl $0x4, %edi
callq 0x6160
movq %rax, %rdi
movl $0xe, (%rdi)
movq 0x16c1d(%rip), %rsi     # 0x53f98
xorl %eax, %eax
movl %eax, %edx
callq 0x6430
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
leaq 0x2c71(%rip), %rsi      # 0x41ccb
callq 0x12920
testb $0x1, %al
jne 0x3f065
jmp 0x3f07f
movq -0x60(%rbp), %rdi
callq 0x12d30
movq %rax, %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xb8(%rax)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
leaq 0x2c4c(%rip), %rsi      # 0x41cda
callq 0x12920
testb $0x1, %al
jne 0x3f09c
jmp 0x3f1af
movq -0x58(%rbp), %rdi
addq $0x70, %rdi
callq 0x12980
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2a6b0
movq -0x70(%rbp), %rdi
callq 0x12af0
movq %rax, %rdi
callq 0x3d220
movq %rax, -0x68(%rbp)
jmp 0x3f0d0
movq -0x68(%rbp), %rdi
callq 0x12b50
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12b30
movq -0x58(%rbp), %rdi
addq $0x70, %rdi
callq 0x12980
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2a6b0
movq -0x80(%rbp), %rdi
callq 0x12af0
movq %rax, %rdi
callq 0x3d220
movq %rax, -0x78(%rbp)
jmp 0x3f11a
movq -0x78(%rbp), %rdi
callq 0x12b80
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x12bb0
movb %al, -0x81(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12b30
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x3f14f
jmp 0x3f1ad
leaq -0x18(%rbp), %rdi
callq 0x12bf0
movq %rax, %rdi
callq 0x12d30
movq %rax, %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xa8(%rax)
leaq -0x18(%rbp), %rdi
callq 0x12d70
jmp 0x3f0e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x12b30
jmp 0x3f1b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12b30
jmp 0x3f1b8
jmp 0x3f1af
addq $0x90, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6460
nopw %cs:(%rax,%rax)
// File: flordan[P]ipc_benchmark/pipe/producer.cpp
// Function: main
int main() {
    std::cerr << "Producer running" << std::endl;
    
    struct timeval st;
    std::cerr << "Latency test" << std::endl;
    for (int i=0;i<LATENCY_PROBES;i++){
        gettimeofday(&st,NULL);
        std::cout << st.tv_sec << "." << 1000000 + st.tv_usec << std::endl;
        usleep(250000);
    }

}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movq 0x2dfd(%rip), %rdi      # 0x3ff0
leaq 0xe0a(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movq 0x2db7(%rip), %rsi      # 0x3fc0
callq 0x1050
movq 0x2ddb(%rip), %rdi      # 0x3ff0
leaq 0xdf9(%rip), %rsi       # 0x2015
callq 0x1040
movq %rax, %rdi
movq 0x2d95(%rip), %rsi      # 0x3fc0
callq 0x1050
movl $0x0, 0xc(%rsp)
cmpl $0x3e8, 0xc(%rsp)       # imm = 0x3E8
jge 0x12aa
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1080
movq 0x10(%rsp), %rsi
movq 0x2d74(%rip), %rdi      # 0x3fd0
callq 0x1090
movq %rax, %rdi
leaq 0xdb7(%rip), %rsi       # 0x2022
callq 0x1040
movq %rax, %rdi
movq 0x18(%rsp), %rsi
addq $0xf4240, %rsi          # imm = 0xF4240
callq 0x1090
movq %rax, %rdi
movq 0x2d32(%rip), %rsi      # 0x3fc0
callq 0x1050
movl $0x3d090, %edi          # imm = 0x3D090
callq 0x1060
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1238
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: 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
movl $0x0, 0x4(%rsp)
callq 0x2940
callq 0x35d0
callq 0x4480
callq 0x47f0
callq 0x4b60
callq 0x4ee0
callq 0x55b0
callq 0x5c80
callq 0x63f0
callq 0x6e70
callq 0x7a10
callq 0x8e30
callq 0x9530
xorl %eax, %eax
popq %rcx
retq
nop
// File: cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_vector<int>(ezSTL::vector<int, ezSTL::allocator<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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x25d78(%rip), %rdi     # 0x30fd8
leaq 0x1b67e(%rip), %rsi     # 0x268e5
callq 0x2220
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11940
movq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq 0x25d4a(%rip), %rdi     # 0x30fd8
leaq 0x1b5c2(%rip), %rsi     # 0x26857
callq 0x2220
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11980
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x2280
movq 0x25d1c(%rip), %rdi     # 0x30fd8
leaq 0x1b5a2(%rip), %rsi     # 0x26865
callq 0x2220
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x119b0
movq 0x30(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x2340
movq 0x40(%rsp), %rdi
callq 0x119b0
testb $0x1, %al
jne 0xb323
movq 0x25cdc(%rip), %rdi     # 0x30fd8
leaq 0x1b56d(%rip), %rsi     # 0x26870
callq 0x2220
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x119f0
movq 0x18(%rsp), %rdi
movl (%rax), %esi
callq 0x2310
movq 0x40(%rsp), %rdi
callq 0x119b0
testb $0x1, %al
jne 0xb35f
movq 0x25ca0(%rip), %rdi     # 0x30fd8
leaq 0x1b53c(%rip), %rsi     # 0x2687b
callq 0x2220
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11a00
movq 0x10(%rsp), %rdi
movl (%rax), %esi
callq 0x2310
movq 0x25c72(%rip), %rdi     # 0x30fd8
movq 0x25c5b(%rip), %rsi     # 0x30fc8
callq 0x2250
movq %rax, %rdi
leaq 0x1b509(%rip), %rsi     # 0x26885
callq 0x2220
movq 0x40(%rsp), %rdi
callq 0xb7b0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11a20
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0xb3e3
movq 0x38(%rsp), %rax
movl (%rax), %esi
movq 0x25c19(%rip), %rdi     # 0x30fd8
callq 0x2310
movq %rax, %rdi
leaq 0x1b0da(%rip), %rsi     # 0x264a8
callq 0x2220
movq 0x38(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x38(%rsp)
jmp 0xb390
movq 0x25bee(%rip), %rdi     # 0x30fd8
movq 0x25bd7(%rip), %rsi     # 0x30fc8
callq 0x2250
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
je 0xb445
movq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq %rsi, %rax
addq $0x4, %rax
movq %rax, 0x8(%rdi)
movq 0x38(%rsp), %rdx
callq 0x11a30
jmp 0xb549
movq 0x10(%rsp), %rdi
callq 0x11940
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0xb466
movl 0x34(%rsp), %eax
shll %eax
movl %eax, 0xc(%rsp)
jmp 0xb471
movl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xb471
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %esi
callq 0x11a60
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0xb4e6
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
addq $0x4, %rax
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %esi
callq 0x11a80
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq %rax, %rdx
callq 0x11a30
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xb49e
movq 0x10(%rsp), %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
callq 0x11850
movq 0x10(%rsp), %rdi
callq 0x118b0
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rsi, %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdx
callq 0x11a30
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
movl 0x30(%rsp), %edx
shlq $0x2, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x11a20
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0xb861
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11b00
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
callq 0x11a20
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0xb84f
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x4, %rdx
callq 0x11a30
jmp 0xb851
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
jmp 0xb7e2
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
addq $-0x4, %rcx
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)