LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/BohangZhang[P]Sorcery-C-Project/player.cc
// Function: Player::draw()
void Player::draw() {
    if (this->isDeckEmpty()) {
        throw 4; // Number, You deck is empty!
    } else if (this->isHandFull()) {
        throw 13; // Number, You hand is full!
    } else {
        shared_ptr<Card> c = deck->getDeck()[0];
        this->deck->popfirst();
        this->hand->push(c);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %rdi
callq 0xf708
testb %al, %al
jne 0x1d667
movq 0x38(%r14), %rdi
callq 0x16072
testb %al, %al
jne 0x1d679
movq 0x28(%r14), %rdi
callq 0xf702
movq (%rax), %rax
movq (%rax), %r15
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x1d609
movq 0x169c5(%rip), %rax     # 0x33fc0
cmpb $0x0, (%rax)
je 0x1d605
incl 0x8(%rbx)
jmp 0x1d609
lock
incl 0x8(%rbx)
movq 0x28(%r14), %rdi
callq 0xf71e
movq 0x38(%r14), %rdi
movq %r15, (%rsp)
movq %rbx, 0x8(%rsp)
testq %rbx, %rbx
je 0x1d639
movq 0x16995(%rip), %rax     # 0x33fc0
cmpb $0x0, (%rax)
je 0x1d635
incl 0x8(%rbx)
jmp 0x1d639
lock
incl 0x8(%rbx)
movq %rsp, %rsi
callq 0x16082
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1d650
callq 0xb634
testq %rbx, %rbx
je 0x1d65d
movq %rbx, %rdi
callq 0xb634
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x4, %edi
callq 0x5100
movl $0x4, (%rax)
jmp 0x1d689
movl $0x4, %edi
callq 0x5100
movl $0xd, (%rax)
movq 0x16900(%rip), %rsi     # 0x33f90
movq %rax, %rdi
xorl %edx, %edx
callq 0x5300
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1d6b1
callq 0xb634
jmp 0x1d6b1
movq %rax, %r14
testq %rbx, %rbx
je 0x1d6be
movq %rbx, %rdi
callq 0xb634
movq %r14, %rdi
callq 0x5320
// File: /workspace/github_cpp_makefile_star2_O1/BohangZhang[P]Sorcery-C-Project/ritual.cc
// Function: Ritual::action(std::shared_ptr<Minion>)
void Ritual::action(shared_ptr<Minion> m) {
    if (name == "Aura of Power") {
        m->addAttack(1);
        m->addDefense(1);
    }
    if (name == "Standstill") {
        m->getMaster()->getSlot()->pop(m);
        m->getMaster()->getGraveyard()->pushfirst(m);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %r14
leaq 0x49c9(%rip), %rsi      # 0x28d23
movq %r14, %rdi
callq 0x50a0
testl %eax, %eax
jne 0x24388
movq (%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xa0(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xa8(%rax)
leaq 0x49a2(%rip), %rsi      # 0x28d31
movq %r14, %rdi
callq 0x50a0
testl %eax, %eax
jne 0x244a7
movq (%rbx), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xe8aa
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x17bd0
movq 0x8(%rsp), %rdi
movq (%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x243ec
movq 0xfbe2(%rip), %rcx      # 0x33fc0
cmpb $0x0, (%rcx)
je 0x243e8
incl 0x8(%rax)
jmp 0x243ec
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %rsi
callq 0x2474a
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x24405
callq 0xb634
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x24414
callq 0xb634
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x24423
callq 0xb634
movq (%rbx), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xe8aa
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x17bfc
movq 0x8(%rsp), %rdi
movq (%rbx), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x24470
movq 0xfb5e(%rip), %rcx      # 0x33fc0
cmpb $0x0, (%rcx)
je 0x2446c
incl 0x8(%rax)
jmp 0x24470
lock
incl 0x8(%rax)
leaq 0x28(%rsp), %rsi
callq 0x15c44
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x24489
callq 0xb634
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x24498
callq 0xb634
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x244a7
callq 0xb634
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x244c3
jmp 0x244de
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x244cd
callq 0xb634
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x244e1
callq 0xb634
jmp 0x244e1
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x244f0
callq 0xb634
movq %rbx, %rdi
callq 0x5320
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rsi, %rax
movq (%rdi), %rsi
movq 0x8(%rdi), %rcx
cmpq %rcx, %rsi
sete %bl
je 0x2478f
movq (%rax), %rax
cmpq %rax, (%rsi)
je 0x24784
addq $0x10, %rsi
cmpq %rcx, %rsi
sete %bl
je 0x2478f
leaq 0x10(%rsi), %rdx
cmpq %rax, (%rsi)
movq %rdx, %rsi
jne 0x24769
addq $-0x10, %rdx
movq %rdx, %rsi
callq 0x15fb6
testb %bl, %bl
jne 0x2478f
popq %rbx
retq
movl $0x4, %edi
callq 0x5100
movl $0xe, (%rax)
movq 0xf7ea(%rip), %rsi      # 0x33f90
movq %rax, %rdi
xorl %edx, %edx
callq 0x5300
// File: /workspace/github_cpp_makefile_star2_O1/BohangZhang[P]Sorcery-C-Project/tri_minion.cc
// Function: Tri_Minion::action(std::shared_ptr<Minion>)
void Tri_Minion::action(shared_ptr<Minion> m) {
    if (name == "Fire Elemental") {
        m->subDefense(1);
    }
    if (name == "Potion Seller") {
        for (auto it = this->master->getSlot()->getSlot().begin(); it != this->master->getSlot()->getSlot().end(); ++it) {
            (*it)->addDefense(1);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x316b(%rip), %rsi      # 0x28d83
movq %r14, %rdi
callq 0x50a0
testl %eax, %eax
jne 0x25c35
movq (%r15), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xb8(%rax)
leaq 0x3156(%rip), %rsi      # 0x28d92
movq %r14, %rdi
callq 0x50a0
testl %eax, %eax
je 0x25c54
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x70(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x17bd0
movq (%r14), %rdi
callq 0x24706
movq (%rax), %r15
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x25c7f
callq 0xb634
leaq 0x8(%rsp), %r14
movq 0x70(%rbx), %rsi
movq %r14, %rdi
callq 0x17bd0
movq 0x8(%rsp), %rdi
callq 0x24706
movq 0x8(%rax), %r12
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x25cad
callq 0xb634
cmpq %r12, %r15
je 0x25c48
movq (%r15), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0xa8(%rax)
addq $0x10, %r15
jmp 0x25c84
jmp 0x25ccb
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x25cdd
callq 0xb634
movq %rbx, %rdi
callq 0x5320
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: ezSTL::test::test_stack()
void test::test_stack() {
		srand((unsigned int)time(NULL));
		start_info("stack");
		stack<int> s;
		print_stack(s);
		test_info("stack   push");
		for (int i = 0; i < 5; ++i) {
			s.push(rand());
			print_stack(s);
		}
		test_info("stack   pop");
		for (int i = 0; i < 5; ++i) {
			s.pop();
			print_stack(s);
		}
		finish_info("stack");
		continue_next_test();
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
xorl %edi, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21d0
leaq 0x80(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc6fe(%rip), %rsi      # 0x10344
leaq 0xc6fc(%rip), %rdx      # 0x10349
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xa568
movq %rbx, %rdi
callq 0x246c
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x3c71
callq 0x21c0
xorl %ebp, %ebp
movq %rsp, %rbx
movl %ebp, 0x8(%rbx)
movl $0x18, %edi
callq 0x21f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %ebp, 0x10(%rax)
movq %rax, (%rbx)
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movq %rbx, %rdi
callq 0x8ac2
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc69c(%rip), %rsi      # 0x1034a
leaq 0xc6a1(%rip), %rdx      # 0x10356
leaq 0x50(%rsp), %rdi
callq 0xa568
leaq 0x50(%rsp), %rdi
callq 0x270c
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x3cd8
callq 0x21c0
movl $0x5, %r14d
movq %rsp, %rbx
callq 0x2060
movl %eax, %ebp
movl $0x18, %edi
callq 0x21f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %ebp, 0x10(%rax)
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq (%rcx), %rdx
movq %rax, 0x8(%rdx)
movq %rax, (%rcx)
incl 0x8(%rsp)
movq %rbx, %rdi
callq 0x8ac2
decl %r14d
jne 0x3ce1
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc623(%rip), %rsi      # 0x10357
leaq 0xc627(%rip), %rdx      # 0x10362
leaq 0x30(%rsp), %rdi
callq 0xa568
leaq 0x30(%rsp), %rdi
callq 0x270c
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x3d5e
callq 0x21c0
movl $0x5, %ebp
movq %rsp, %rbx
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rcx
movq %rcx, (%rax)
movq (%rdi), %rcx
movq %rax, 0x8(%rcx)
callq 0x21c0
decl 0x8(%rsp)
movq %rbx, %rdi
callq 0x8ac2
decl %ebp
jne 0x3d66
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc5a5(%rip), %rsi      # 0x10344
leaq 0xc5a3(%rip), %rdx      # 0x10349
leaq 0x10(%rsp), %rdi
callq 0xa568
leaq 0x10(%rsp), %rdi
callq 0x2656
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x3dc9
callq 0x21c0
callq 0x2782
movq %rsp, %rdi
callq 0x8aa0
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x3e02
jmp 0x3e2a
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x3e02
jmp 0x3e2a
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e2d
callq 0x21c0
jmp 0x3e2d
jmp 0x3e2a
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e35
callq 0x21c0
jmp 0x3e35
jmp 0x3e2a
jmp 0x3e2a
jmp 0x3e2a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8aa0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: ezSTL::test::test_queue()
void test::test_queue() {
		srand((unsigned int)time(NULL));
		start_info("queue");
		queue<int> q;
		print_queue(q);
		test_info("queue   push");
		for (int i = 0; i < 5; ++i) {
			q.push(rand());
			print_queue(q);
		}
		test_info("queue   pop");
		for (int i = 0; i < 5; ++i) {
			q.pop();
			print_queue(q);
		}
		finish_info("queue");
		continue_next_test();
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
xorl %edi, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21d0
leaq 0x80(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc502(%rip), %rsi      # 0x1036c
leaq 0xc500(%rip), %rdx      # 0x10371
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xa568
movq %rbx, %rdi
callq 0x246c
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x3e95
callq 0x21c0
xorl %ebp, %ebp
movq %rsp, %rbx
movl %ebp, 0x8(%rbx)
movl $0x18, %edi
callq 0x21f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %ebp, 0x10(%rax)
movq %rax, (%rbx)
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movq %rbx, %rdi
callq 0x8b78
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc4a9(%rip), %rsi      # 0x1037b
leaq 0xc4ae(%rip), %rdx      # 0x10387
leaq 0x50(%rsp), %rdi
callq 0xa568
leaq 0x50(%rsp), %rdi
callq 0x270c
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x3efc
callq 0x21c0
movl $0x5, %r14d
movq %rsp, %rbx
callq 0x2060
movl %eax, %ebp
movl $0x18, %edi
callq 0x21f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %ebp, 0x10(%rax)
movq (%rsp), %rcx
movq %rcx, 0x8(%rax)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq (%rcx), %rdx
movq %rax, 0x8(%rdx)
movq %rax, (%rcx)
incl 0x8(%rsp)
movq %rbx, %rdi
callq 0x8b78
decl %r14d
jne 0x3f05
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc439(%rip), %rsi      # 0x10391
leaq 0xc43d(%rip), %rdx      # 0x1039c
leaq 0x30(%rsp), %rdi
callq 0xa568
leaq 0x30(%rsp), %rdi
callq 0x270c
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x3f82
callq 0x21c0
movl $0x5, %ebp
movq %rsp, %rbx
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
callq 0x21c0
decl 0x8(%rsp)
movq %rbx, %rdi
callq 0x8b78
decl %ebp
jne 0x3f8a
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc3a6(%rip), %rsi      # 0x1036c
leaq 0xc3a4(%rip), %rdx      # 0x10371
leaq 0x10(%rsp), %rdi
callq 0xa568
leaq 0x10(%rsp), %rdi
callq 0x2656
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ff0
callq 0x21c0
callq 0x2782
movq %rsp, %rdi
callq 0x8aa0
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x4029
jmp 0x4051
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x4029
jmp 0x4051
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x4054
callq 0x21c0
jmp 0x4054
jmp 0x4051
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x405c
callq 0x21c0
jmp 0x405c
jmp 0x4051
jmp 0x4051
jmp 0x4051
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8aa0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: ezSTL::test::test_priority_queue()
void test::test_priority_queue() {
		const int max_iteration = 10;
		srand((unsigned int)time(NULL));
		start_info("priority_queue");
		priority_queue<int> pq;
		print_priority_queue(pq);
		test_info("priority_queue   push");
		for (int i = 0; i < max_iteration; ++i) {
			pq.push(rand());
			print_priority_queue(pq);
		}
		test_info("priority_queue   pop");
		print_priority_queue(pq);
		for (int i = 0; i < max_iteration; ++i) {
			pq.pop();
			print_priority_queue(pq);
		}
		finish_info("priority_queue");
		continue_next_test();
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
xorl %edi, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21d0
leaq 0xa0(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc2d3(%rip), %rsi      # 0x10363
leaq 0xc2da(%rip), %rdx      # 0x10371
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
callq 0xa568
movq %rbx, %rdi
callq 0x246c
movq 0x90(%rsp), %rdi
cmpq %r14, %rdi
je 0x40c1
callq 0x21c0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x8c62
leaq 0x80(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc286(%rip), %rsi      # 0x10372
leaq 0xc294(%rip), %rdx      # 0x10387
leaq 0x70(%rsp), %rdi
callq 0xa568
leaq 0x70(%rsp), %rdi
callq 0x270c
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x4116
callq 0x21c0
movl $0xa, %ebp
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %r14
callq 0x2060
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8d20
movq %rbx, %rdi
callq 0x8c62
decl %ebp
jne 0x4125
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc233(%rip), %rsi      # 0x10388
leaq 0xc240(%rip), %rdx      # 0x1039c
leaq 0x50(%rsp), %rdi
callq 0xa568
leaq 0x50(%rsp), %rdi
callq 0x270c
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0x417f
callq 0x21c0
leaq 0x10(%rsp), %rdi
callq 0x8c62
movl $0xa, %ebp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x8d60
movq %rbx, %rdi
callq 0x8c62
decl %ebp
jne 0x4193
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xc1ac(%rip), %rsi      # 0x10363
leaq 0xc1b3(%rip), %rdx      # 0x10371
leaq 0x30(%rsp), %rdi
callq 0xa568
leaq 0x30(%rsp), %rdi
callq 0x2656
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x41e1
callq 0x21c0
callq 0x2782
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x41f5
callq 0x21c0
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
jmp 0x4221
jmp 0x4247
movq %rax, %rbx
movq 0x50(%rsp), %rdi
jmp 0x4221
jmp 0x4247
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r14, %rdi
je 0x424a
callq 0x21c0
jmp 0x424a
jmp 0x4247
movq %rax, %rbx
movq 0x90(%rsp), %rdi
cmpq %r14, %rdi
jne 0x4254
jmp 0x4259
jmp 0x4247
jmp 0x4247
jmp 0x4247
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4259
callq 0x21c0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a50
callq 0x3248
callq 0x3c1a
callq 0x3e3e
callq 0x4064
callq 0x4262
callq 0x46d2
callq 0x4b42
callq 0x5026
callq 0x5838
callq 0x5ee4
callq 0x6d36
callq 0x7128
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_vector<unsigned int>(ezSTL::vector<unsigned int, ezSTL::allocator<unsigned int>>&)
void test::print_vector(vector<T>& v) {
		std::cout << "size: " << v.size();
		std::cout << " ; capacity: " << v.capacity();
		std::cout << " ; empty: " << v.empty();
		if(!v.empty()) std::cout << " ; front: " << v.front();
		if (!v.empty()) std::cout << " ; back: " << v.back();
		std::cout << std::endl << "vector: ";
		for (auto ite = v.begin(); ite != v.end(); ++ite)
			std::cout << *ite << " ";
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0xc05b(%rip), %rbx      # 0x15fd8
leaq 0x69a3(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
movl %eax, %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x68ec(%rip), %rsi      # 0x10899
movl $0xd, %edx
movq %rbx, %rdi
callq 0x2220
movq 0x10(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
movl %eax, %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x68d1(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
movq (%r14), %rax
xorl %esi, %esi
cmpq 0x8(%r14), %rax
sete %sil
movq %rbx, %rdi
callq 0x22c0
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0xa029
movq 0xbfd0(%rip), %r15      # 0x15fd8
leaq 0x68a3(%rip), %rsi      # 0x108b2
movl $0xa, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0x2110
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0xa05c
movq 0xbf9f(%rip), %r15      # 0x15fd8
leaq 0x687d(%rip), %rsi      # 0x108bd
movl $0x9, %edx
movq %r15, %rdi
callq 0x2220
movq 0x8(%r14), %rax
movl -0x4(%rax), %esi
movq %r15, %rdi
callq 0x2110
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x683d(%rip), %rsi      # 0x108c7
movl $0x8, %edx
movq %rax, %rdi
callq 0x2220
movq (%r14), %r13
cmpq 0x8(%r14), %r13
je 0xa0d4
movq 0xbf31(%rip), %r15      # 0x15fd8
leaq 0x6412(%rip), %r12      # 0x104c0
movl (%r13), %esi
movq %r15, %rdi
callq 0x2110
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
addq $0x4, %r13
cmpq 0x8(%r14), %r13
jne 0xa0ae
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8572
leaq 0x4(%rax), %rcx
movq %rcx, 0x8(%rbx)
movl (%r14), %ecx
movl %ecx, (%rax)
jmp 0x85eb
subq (%rbx), %rax
movq %rax, %rbp
shrq $0x2, %rbp
shrq %rax
testl %ebp, %ebp
movl %eax, %eax
movl $0x1, %r12d
cmovneq %rax, %r12
leaq (,%r12,4), %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, %r13
testl %ebp, %ebp
je 0x85c4
movq (%rbx), %rax
movl %ebp, %ecx
shlq $0x2, %rcx
xorl %r13d, %r13d
movl (%rax,%r13), %edx
movl %edx, (%r15,%r13)
addq $0x4, %r13
cmpq %r13, %rcx
jne 0x85b0
addq %r15, %r13
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x85d1
callq 0x21c0
movl (%r14), %eax
movl %eax, (%r13)
addq $0x4, %r13
movq %r15, (%rbx)
movq %r13, 0x8(%rbx)
leaq (%r15,%r12,4), %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8644
cmpq %r14, %rax
je 0x8631
movq %rax, %rcx
movl -0x4(%rcx), %edx
movl %edx, (%rcx)
leaq -0x4(%rcx), %rdx
movq %rdx, %rcx
cmpq %r14, %rdx
jne 0x8620
movl (%r15), %ecx
movl %ecx, (%r14)
addq $0x4, %rax
movq %rax, 0x8(%rbx)
jmp 0x86d4
subq (%rbx), %rax
movq %rax, %rcx
shrq $0x2, %rcx
shrq %rax
testl %ecx, %ecx
movl %eax, %eax
movl $0x1, %r13d
cmovneq %rax, %r13
leaq (,%r13,4), %rdi
callq 0x21f0
movq %rax, %r12
movq (%rbx), %rdi
movq %rax, %rbp
cmpq %r14, %rdi
je 0x8692
movq %rdi, %rax
movq %r12, %rbp
movl (%rax), %ecx
movl %ecx, (%rbp)
addq $0x4, %rbp
addq $0x4, %rax
cmpq %r14, %rax
jne 0x8680
movl (%r15), %eax
movl %eax, (%rbp)
movq 0x8(%rbx), %rax
leaq 0x4(%rbp), %r15
cmpq %r14, %rax
je 0x86b8
movl (%r14), %ecx
movl %ecx, (%r15)
addq $0x4, %r14
addq $0x4, %r15
cmpq %rax, %r14
jne 0x86a5
testq %rdi, %rdi
je 0x86c2
callq 0x21c0
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
leaq (%r12,%r13,4), %rax
movq %rax, 0x10(%rbx)
movq %rbp, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/vector.h
// Function: ezSTL::vector<int, ezSTL::allocator<int>>::vector(ezSTL::vector<int, ezSTL::allocator<int>> const&)
vector<T, Alloc>::vector(const vector<T, Alloc>& v) {
		// copy from v to *this
		start = allocate(v.size());
		for (size_type i = 0; i < v.size(); ++i)
			construct(start + i, v[i]);
		finish = start + v.size();
		end_of_storage = finish;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
subq (%rsi), %rdi
movabsq $0x3fffffffc, %r15      # imm = 0x3FFFFFFFC
andq %r15, %rdi
callq 0x21f0
movq %rax, (%rbx)
movq (%r14), %rcx
movq 0x8(%r14), %rsi
subq %rcx, %rsi
movq %rsi, %rdx
shrq $0x2, %rdx
testq %r15, %rsi
je 0x8737
movl %edx, %esi
xorl %edi, %edi
movl (%rcx,%rdi,4), %r8d
movl %r8d, (%rax,%rdi,4)
incq %rdi
cmpq %rdi, %rsi
jne 0x8727
movl %edx, %ecx
leaq (%rax,%rcx,4), %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/vector.h
// Function: ezSTL::vector<int, ezSTL::allocator<int>>::operator=(ezSTL::vector<int, ezSTL::allocator<int>> const&)
vector<T, Alloc>& vector<T, Alloc>::operator= (const vector<T, Alloc>& v) {
		if (this == &v) return *this;
		else {
			// destroy and deallocate old vector
			destroy(begin(), end());
			deallocate();
			// allocate and construct new vector
			start = allocate(v.size());
			for (size_type i = 0; i < v.size(); ++i)
				construct(start + i, v[i]);
			finish = start + v.size();
			end_of_storage = finish;
			return *this;
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x87bd
movq %rsi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8769
callq 0x21c0
movq 0x8(%r14), %rdi
subq (%r14), %rdi
movabsq $0x3fffffffc, %r15      # imm = 0x3FFFFFFFC
andq %r15, %rdi
callq 0x21f0
movq %rax, (%rbx)
movq (%r14), %rcx
movq 0x8(%r14), %rsi
subq %rcx, %rsi
movq %rsi, %rdx
shrq $0x2, %rdx
testq %r15, %rsi
je 0x87af
movl %edx, %esi
xorl %edi, %edi
movl (%rcx,%rdi,4), %r8d
movl %r8d, (%rax,%rdi,4)
incq %rdi
cmpq %rdi, %rsi
jne 0x879f
movl %edx, %ecx
leaq (%rax,%rcx,4), %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_list<int>(ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>&)
void test::print_list(list<T>& l) {
		std::cout << "size: " << l.size();
		std::cout << " ; empty: " << l.empty();
		if (!l.empty()) std::cout << " ; front: " << l.front();
		if (!l.empty()) std::cout << " ; back: " << l.back();
		std::cout << std::endl << "list: ";
		for (auto ite = l.begin(); ite != l.end(); ++ite)
			std::cout << *ite << " ";
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0xd7ff(%rip), %rbx      # 0x15fd8
leaq 0x8147(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x80a7(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
xorl %esi, %esi
cmpl $0x0, 0x8(%r14)
sete %sil
movq %rbx, %rdi
callq 0x22c0
cmpl $0x0, 0x8(%r14)
je 0x8854
movq 0xd7aa(%rip), %r15      # 0x15fd8
leaq 0x807d(%rip), %rsi      # 0x108b2
movl $0xa, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x22d0
cmpl $0x0, 0x8(%r14)
je 0x8887
movq 0xd776(%rip), %r15      # 0x15fd8
leaq 0x8054(%rip), %rsi      # 0x108bd
movl $0x9, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x22d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x801b(%rip), %rsi      # 0x108d0
movl $0x6, %edx
movq %rax, %rdi
callq 0x2220
movq (%r14), %rax
movq 0x8(%rax), %r13
cmpq %rax, %r13
je 0x8901
movq 0xd703(%rip), %r15      # 0x15fd8
leaq 0x7be4(%rip), %r12      # 0x104c0
movl 0x10(%r13), %esi
movq %r15, %rdi
callq 0x22d0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
movq 0x8(%r13), %r13
cmpq (%r14), %r13
jne 0x88dc
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<ezSTL::pair<int, int>, ezSTL::allocator<ezSTL::__list_node<ezSTL::pair<int, int>>>>::list(ezSTL::list<ezSTL::pair<int, int>, ezSTL::allocator<ezSTL::__list_node<ezSTL::pair<int, int>>>> const&)
list<T, Alloc>::list(const list<T, Alloc>& other) {
		Alloc alloc = Alloc();
		link_type prev_node = alloc.allocate();
		alloc.construct(prev_node, __list_node<T>());
		list_iterator.node = prev_node;
		__size = 0;
		// copy each node of other
		for (iterator ite = other.begin(); ite != other.end(); ++ite) {
			link_type new_node = alloc.allocate();
			alloc.construct(new_node, __list_node<T>(*ite));
			if (ite == other.begin())
				list_iterator.node->next = new_node;
			prev_node->next = new_node;
			new_node->prev = prev_node;
			prev_node = new_node;
			++__size;
		}
		prev_node->next = list_iterator.node;
		list_iterator.node->prev = prev_node;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
callq 0x21f0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movq (%r14), %rax
movq 0x8(%rax), %r12
cmpq %rax, %r12
je 0xb319
movl $0x18, %edi
callq 0x21f0
movq 0x10(%r12), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
movq (%r14), %rcx
cmpq 0x8(%rcx), %r12
jne 0xb300
movq (%rbx), %rcx
movq %rax, 0x8(%rcx)
movq %rax, 0x8(%r15)
movq %r15, (%rax)
incl 0x8(%rbx)
movq 0x8(%r12), %r12
movq %rax, %r15
cmpq (%r14), %r12
jne 0xb2d7
jmp 0xb31c
movq %r15, %rax
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::operator=(ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>> const&)
list<T, Alloc>& list<T, Alloc>::operator=(const list<T, Alloc>& other) {
		if (this != &other) {
			Alloc alloc = Alloc();
			link_type prev_node = alloc.allocate();
			alloc.construct(prev_node, __list_node<T>());
			list_iterator.node = prev_node;
			__size = 0;
			// copy each node of other
			for (iterator ite = other.begin(); ite != other.end(); ++ite) {
				link_type new_node = alloc.allocate();
				alloc.construct(new_node, __list_node<T>(*ite));
				if (ite == other.begin())
					list_iterator.node->next = new_node;
				prev_node->next = new_node;
				new_node->prev = prev_node;
				prev_node = new_node;
				++__size;
			}
			prev_node->next = list_iterator.node;
			list_iterator.node->prev = prev_node;
		}
		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x8a52
movq %rsi, %r14
movl $0x18, %edi
callq 0x21f0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %eax, %eax
movl %eax, 0x10(%r15)
movq %r15, (%rbx)
movl %eax, 0x8(%rbx)
movq (%r14), %rax
movq 0x8(%rax), %r12
cmpq %rax, %r12
je 0x8a45
movl $0x18, %edi
callq 0x21f0
movl 0x10(%r12), %ecx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %ecx, 0x10(%rax)
movq (%r14), %rcx
cmpq 0x8(%rcx), %r12
jne 0x8a2c
movq (%rbx), %rcx
movq %rax, 0x8(%rcx)
movq %rax, 0x8(%r15)
movq %r15, (%rax)
incl 0x8(%rbx)
movq 0x8(%r12), %r12
movq %rax, %r15
cmpq (%r14), %r12
jne 0x8a04
jmp 0x8a48
movq %r15, %rax
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/list.h
// Function: ezSTL::list<int, ezSTL::allocator<ezSTL::__list_node<int>>>::clear()
void list<T, Alloc>::clear() {
		Alloc alloc = Alloc();
		// clear all node
		for (iterator ite = begin(), next_iterator = begin(); ite != end(); ite = next_iterator) {
			next_iterator = ite + 1;
			alloc.destroy(ite.node);
			alloc.deallocate(ite.node);
		}
		list_iterator.node->prev = list_iterator.node;
		list_iterator.node->next = list_iterator.node;
		__size = 0;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rdi
cmpq %rax, %rdi
je 0x8a89
movq 0x8(%rdi), %r14
callq 0x21c0
movq (%rbx), %rax
movq %r14, %rdi
cmpq %rax, %r14
jne 0x8a75
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movl $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_stack<int>(ezSTL::stack<int>&)
void test::print_stack(stack<T>& s) {
		std::cout << "size: " << s.size();
		std::cout << " ; empty: " << s.empty();
		if (!s.empty()) std::cout << " ; top: " << s.top();
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xd507(%rip), %rbx      # 0x15fd8
leaq 0x7e4f(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x7daf(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
xorl %esi, %esi
cmpl $0x0, 0x8(%r14)
sete %sil
movq %rbx, %rdi
callq 0x22c0
cmpl $0x0, 0x8(%r14)
je 0x8b4b
movq 0xd4b2(%rip), %r15      # 0x15fd8
leaq 0x7daa(%rip), %rsi      # 0x108d7
movl $0x8, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x22d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_queue<int>(ezSTL::queue<int>&)
void test::print_queue(queue<T>& q) {
		std::cout << "size: " << q.size();
		std::cout << " ; empty: " << q.empty();
		if (!q.empty()) std::cout << " ; front: " << q.front();
		if (!q.empty()) std::cout << " ; back: " << q.back();
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xd451(%rip), %rbx      # 0x15fd8
leaq 0x7d99(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x7cf9(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
xorl %esi, %esi
cmpl $0x0, 0x8(%r14)
sete %sil
movq %rbx, %rdi
callq 0x22c0
cmpl $0x0, 0x8(%r14)
je 0x8c02
movq 0xd3fc(%rip), %r15      # 0x15fd8
leaq 0x7ccf(%rip), %rsi      # 0x108b2
movl $0xa, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x22d0
cmpl $0x0, 0x8(%r14)
je 0x8c35
movq 0xd3c8(%rip), %r15      # 0x15fd8
leaq 0x7ca6(%rip), %rsi      # 0x108bd
movl $0x9, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movq (%rax), %rax
movl 0x10(%rax), %esi
movq %r15, %rdi
callq 0x22d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_priority_queue<int, ezSTL::less<int>>(ezSTL::priority_queue<int, ezSTL::less<int>>&)
void test::print_priority_queue(priority_queue<T, Compare>& pq) {
		std::cout << "size: " << pq.size();
		std::cout << " ; empty: " << pq.empty();
		if (!pq.empty()) std::cout << " ; top: " << pq.top();
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xd367(%rip), %rbx      # 0x15fd8
leaq 0x7caf(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
movl %eax, %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x7c06(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
movq (%r14), %rax
xorl %esi, %esi
cmpq 0x8(%r14), %rax
sete %sil
movq %rbx, %rdi
callq 0x22c0
movq (%r14), %rax
cmpq 0x8(%r14), %rax
je 0x8cf4
movq 0xd305(%rip), %r15      # 0x15fd8
leaq 0x7bfd(%rip), %rsi      # 0x108d7
movl $0x8, %edx
movq %r15, %rdi
callq 0x2220
movq (%r14), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0x22d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/queue.h
// Function: ezSTL::priority_queue<int, ezSTL::less<int>>::push(int const&)
void push(const_reference x) {
			base_vector.push_back(x);
			// percolateUp
			for (size_type i = size() - 1; i > 0;) {
				// swap new inserted value and its parent
				if (cmp(base_vector[i], base_vector[(i - 1) / 2])) {
					ezSTL::swap(base_vector[i], base_vector[(i - 1) / 2]);
					i = (i - 1) / 2;
				}
				else break;
			}
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8548
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
decl %ecx
je 0x8d5d
movl %ecx, %edx
movl %ecx, %esi
decl %esi
movl %esi, %ecx
shrl %ecx
movl (%rax,%rdx,4), %edi
movl (%rax,%rcx,4), %r8d
cmpl %r8d, %edi
jge 0x8d5d
movl %r8d, (%rax,%rdx,4)
movl %edi, (%rax,%rcx,4)
cmpl $0x1, %esi
ja 0x8d3b
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_rbtree<int, ezSTL::less<int>>(ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>&)
void test::print_rbtree(rbtree<T, Compare>& rbt) {
		std::cout << "size: " << rbt.size();
		std::cout << " ; empty: " << rbt.empty();
		std::cout << std::endl << "rbtree: ";
		for (auto ite = rbt.begin(); ite != rbt.end(); ++ite)
			std::cout << *ite << " ";
		/*for(auto ite = rbt.end(); ite != rbt.begin(); --ite)
			if(ite != rbt.end()) std::cout << *ite << " ";
		if(!empty()) std::cout << *rbt.begin() << " ";*/
		std::cout << std::endl;
		if(rbt.isRBTree())
			std::cout << "It is exactly an rbtree!" << std::endl;
		else
			std::cout << "It is not an rbtree." << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0xd1ad(%rip), %rbx      # 0x15fd8
leaq 0x7af5(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x7a56(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
xorl %esi, %esi
cmpl $0x0, (%r14)
sete %sil
movq %rbx, %rdi
callq 0x22c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x7a42(%rip), %rsi      # 0x108e0
movl $0x8, %edx
movq %rax, %rdi
callq 0x2220
movq 0x8(%r14), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x8(%rsp)
cmpq %rcx, %rax
je 0x8efe
movq 0xd114(%rip), %r15      # 0x15fd8
leaq 0x75f5(%rip), %r12      # 0x104c0
leaq 0x8(%rsp), %r13
movl 0x20(%rax), %esi
movq %r15, %rdi
callq 0x22d0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
movq %r13, %rdi
callq 0xa5f8
movq 0x8(%rsp), %rax
cmpq 0x8(%r14), %rax
jne 0x8ed0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq %r14, %rdi
callq 0xa63c
movq 0xd0a4(%rip), %rdi      # 0x15fd8
testb %al, %al
je 0x8f46
leaq 0x79aa(%rip), %rsi      # 0x108e9
movl $0x18, %edx
jmp 0x8f52
leaq 0x79b5(%rip), %rsi      # 0x10902
movl $0x14, %edx
callq 0x2220
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<ezSTL::pair<int, int>, ezSTL::less<ezSTL::pair<int, int>>, ezSTL::allocator<ezSTL::__rbtree_node<ezSTL::pair<int, int>>>>::insert(ezSTL::pair<int, int> const&)
void rbtree<T, Compare, Alloc>::insert(const value_type& v) {
		// z : node to be inserted
		link_type z = Alloc().allocate();
		Alloc().construct(z, v);
		// y : parent node of z
		link_type y = nullptr;
		// x : node used to find proper position
		link_type x = root();
		// find the proper position to insert
		while (x != nullptr) {
			y = x;
			if (cmp(v, x->data))
				x = x->left;
			else if(cmp(x->data, v))
				x = x->right;
			// if v == x->data , renew it
			else {
				x->data = v;
				return;
			}
		}
		z->parent = y;
		// if it is an empty tree
		if (y == nullptr) {
			header.node->parent = z;
			header.node->left = z;
			header.node->right = z;
			z->parent = header.node;
		}
		else if (cmp(v, y->data))
			y->left = z;
		else y->right = z;
		// fix up
		insert_fixup(z);
		// adjust header: left and right
		if (empty() || cmp(v, leftmost()->data))
			header.node->left = z;
		if (empty() || cmp(rightmost()->data, v))
			header.node->right = z;
		++__size;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x28, %edi
callq 0x21f0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movl (%r14), %eax
movl 0x4(%r14), %edx
movb $0x0, (%r15)
movups 0x1(%rsp), %xmm0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rsi
movups %xmm0, 0x1(%r15)
movq %rcx, 0x10(%r15)
movq %rsi, 0x18(%r15)
movl %eax, 0x20(%r15)
movl %edx, 0x24(%r15)
movq 0x8(%rbx), %rsi
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xabd6
movq %rdi, %rcx
movl 0x20(%rdi), %r8d
movl $0x10, %edi
cmpl %r8d, %eax
jl 0xabcb
movl $0x18, %edi
jle 0xac55
movq (%rcx,%rdi), %rdi
testq %rdi, %rdi
jne 0xabaf
jmp 0xabd8
xorl %ecx, %ecx
movq %rcx, 0x8(%r15)
testq %rcx, %rcx
je 0xabec
cmpl 0x20(%rcx), %eax
jge 0xabfe
movq %r15, 0x10(%rcx)
jmp 0xac02
movq %r15, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movq %r15, 0x18(%rsi)
movq %rsi, 0x8(%r15)
jmp 0xac02
movq %r15, 0x18(%rcx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xac66
movl (%rbx), %eax
testl %eax, %eax
je 0xac23
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movl (%r14), %edx
cmpl 0x20(%rcx), %edx
jge 0xac2b
movq 0x8(%rbx), %rcx
movq %r15, 0x10(%rcx)
testl %eax, %eax
je 0xac3f
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rcx
movl 0x20(%rcx), %ecx
cmpl (%r14), %ecx
jge 0xac47
movq 0x8(%rbx), %rcx
movq %r15, 0x18(%rcx)
incl %eax
movl %eax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x20(%rcx), %rsi
cmpq %r14, %rsi
je 0xac4b
movl %eax, 0x20(%rcx)
movl %edx, 0x24(%rcx)
jmp 0xac4b
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>::erase(ezSTL::__rbtree_iterator<int>)
void rbtree<T, Compare, Alloc>::erase(iterator pos) {
		// adjust leftmost and rightmost
		if (pos == begin())
			header.node->left = (pos + 1).node;
		if(pos == (end() - 1))
			header.node->right = (pos - 1).node;
		link_type todelete = nullptr;
		if (pos.node->left == nullptr || pos.node->right == nullptr)
			todelete = pos.node;
		else
			todelete = (pos + 1).node;
		
		// son: son of node todelete, father: parent of son
		link_type son = nullptr, father = nullptr;
		if (todelete->left != nullptr)
			son = todelete->left;
		else
			son = todelete->right;
		if (son)
			son->parent = todelete->parent;
		father = todelete->parent;
		if (todelete == father->left)
			father->left = son;
		else if(todelete == father->right)
			father->right = son;
		if (todelete == root())
			header.node->parent = son;
		// copy data from node to be deleted to pos
		if (todelete != pos.node)
			pos.node->data = todelete->data;
		// if the deleted node is black, then fix up
		if (todelete->color == __rbtree_black)
			delete_fixup(father, son);
		// deallocate node
		Alloc().destroy(todelete);
		Alloc().deallocate(todelete);
		--__size;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
movq (%rsi), %rax
cmpq 0x10(%rcx), %rax
jne 0x90ca
movq %rsp, %r15
movq %rax, (%r15)
movq %r15, %rdi
callq 0xa5f8
movq (%r15), %rax
movq 0x8(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq 0x8(%rbx), %rax
movq %rsp, %r15
movq %rax, (%r15)
movq %r15, %rdi
callq 0xaa72
movq (%r14), %rax
cmpq (%r15), %rax
jne 0x90fd
movq %rsp, %r15
movq %rax, (%r15)
movq %r15, %rdi
callq 0xaa72
movq (%r15), %rax
movq 0x8(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq (%r14), %r15
cmpq $0x0, 0x10(%r15)
je 0x9121
cmpq $0x0, 0x18(%r15)
je 0x9121
movq %rsp, %r12
movq %r15, (%r12)
movq %r12, %rdi
callq 0xa5f8
movq (%r12), %r15
movq 0x10(%r15), %rdx
testq %rdx, %rdx
jne 0x912e
movq 0x18(%r15), %rdx
testq %rdx, %rdx
je 0x913b
movq 0x8(%r15), %rax
movq %rax, 0x8(%rdx)
movq 0x8(%r15), %rsi
cmpq 0x10(%rsi), %r15
je 0x9151
cmpq 0x18(%rsi), %r15
jne 0x9158
leaq 0x18(%rsi), %rax
jmp 0x9155
leaq 0x10(%rsi), %rax
movq %rdx, (%rax)
movq 0x8(%rbx), %rax
cmpq 0x8(%rax), %r15
jne 0x9166
movq %rdx, 0x8(%rax)
movq (%r14), %rax
cmpq %rax, %r15
je 0x9175
movl 0x20(%r15), %ecx
movl %ecx, 0x20(%rax)
cmpb $0x1, (%r15)
jne 0x9183
movq %rbx, %rdi
callq 0xa900
movq %r15, %rdi
callq 0x21c0
decl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/rbtree.h
// Function: ezSTL::rbtree<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>::clear()
void rbtree<T, Compare, Alloc>::clear() {
		// dfs clear
		if (root())
			dfs_clear(root());
		header.node->left = header.node;
		header.node->right = header.node->right;
		header.node->parent = nullptr;
		header.node->color = __rbtree_red;
		__size = 0;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x91b3
movq %rbx, %rdi
callq 0xaac6
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rax)
movq $0x0, 0x8(%rax)
movb $0x0, (%rax)
movl $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/cjc12[P]ezSTL/src/../include/test.h
// Function: void ezSTL::test::print_set<int, ezSTL::less<int>>(ezSTL::set<int, ezSTL::less<int>, ezSTL::allocator<ezSTL::__rbtree_node<int>>>&)
void test::print_set(set<T, Compare>& s) {
		std::cout << "size: " << s.size();
		std::cout << " ; empty: " << s.empty();
		std::cout << std::endl << "set: ";
		for (auto ite = s.begin(); ite != s.end(); ++ite)
			std::cout << *ite << " ";
		std::cout << std::endl;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0xcdf3(%rip), %rbx      # 0x15fd8
leaq 0x773b(%rip), %rsi      # 0x10927
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2220
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2110
leaq 0x769c(%rip), %rsi      # 0x108a7
movl $0xa, %edx
movq %rbx, %rdi
callq 0x2220
xorl %esi, %esi
cmpl $0x0, (%r14)
sete %sil
movq %rbx, %rdi
callq 0x22c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x76bf(%rip), %rsi      # 0x10917
movl $0x5, %edx
movq %rax, %rdi
callq 0x2220
movq 0x8(%r14), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x8(%rsp)
cmpq %rcx, %rax
je 0x92b8
movq 0xcd5a(%rip), %r15      # 0x15fd8
leaq 0x723b(%rip), %r12      # 0x104c0
leaq 0x8(%rsp), %r13
movl 0x20(%rax), %esi
movq %r15, %rdi
callq 0x22d0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2220
movq %r13, %rdi
callq 0xa5f8
movq 0x8(%rsp), %rax
cmpq 0x8(%r14), %rax
jne 0x928a
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop