LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_erase_value()
void
test_map_modifiers_erase_value()
{
	ft::map<int, int> map;

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		map.insert(ft::make_pair(i, rand() % 100 - 50));

	print_map_info(map);

	std::cout << map.erase(4) << std::endl;
	std::cout << map.erase(4) << std::endl;
	std::cout << map.erase(2) << std::endl;

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq 0x51f7d(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0x64, -0x34(%rbp)
jge 0x2933e
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fd20
movq %rax, -0x78(%rbp)
jmp 0x292e4
movq -0x78(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x14f10
movb %dl, -0x81(%rbp)
movq %rax, -0x80(%rbp)
jmp 0x29305
movb -0x81(%rbp), %al
movq -0x80(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x29299
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x29450
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x29349
movl $0x4, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x2b310
movq %rax, -0x90(%rbp)
jmp 0x29366
movq -0x90(%rbp), %rsi
movq 0x51c44(%rip), %rdi     # 0x7afb8
callq 0x3080
movq %rax, -0x98(%rbp)
jmp 0x29382
movq -0x98(%rbp), %rdi
movq 0x51c08(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x29397
movl $0x4, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2b310
movq %rax, -0xa0(%rbp)
jmp 0x293b4
movq -0xa0(%rbp), %rsi
movq 0x51bf6(%rip), %rdi     # 0x7afb8
callq 0x3080
movq %rax, -0xa8(%rbp)
jmp 0x293d0
movq -0xa8(%rbp), %rdi
movq 0x51bba(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x293e5
movl $0x2, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
callq 0x2b310
movq %rax, -0xb0(%rbp)
jmp 0x29402
movq -0xb0(%rbp), %rsi
movq 0x51ba8(%rip), %rdi     # 0x7afb8
callq 0x3080
movq %rax, -0xb8(%rbp)
jmp 0x2941e
movq -0xb8(%rbp), %rdi
movq 0x51b6c(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x29433
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x2943e
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_erase_range()
void
test_map_modifiers_erase_range()
{
	ft::map<int, int> map;
	ft::map<int, int>::iterator it;

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		map.insert(ft::make_pair(i, rand() % 100 - 50));

	print_map_info(map);

	map.erase(map.find(42), map.end());

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq -0x38(%rbp), %rdi
callq 0x2b030
leaq 0x51d84(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x3c(%rbp)
cmpl $0x64, -0x3c(%rbp)
jge 0x29543
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
leaq -0x3c(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1fd20
movq %rax, -0xa0(%rbp)
jmp 0x294e0
movq -0xa0(%rbp), %rax
movq %rax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x14f10
movb %dl, -0xa9(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x29507
movb -0xa9(%rbp), %al
movq -0xa8(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x29492
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x295f8
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x2954e
movl $0x2a, -0x7c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x7c(%rbp), %rsi
callq 0x2b050
movq %rax, -0xb8(%rbp)
jmp 0x2956b
movq -0xb8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x189d0
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x18830
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x189d0
movq -0xc8(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x2b340
movq %rax, -0xc0(%rbp)
jmp 0x295cd
movq -0xc0(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x295e6
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_erase_iterators_validity()
void
test_map_modifiers_erase_iterators_validity()
{
	ft::map<int, int> map;
	ft::map<int, int>::iterator it;

	for (int i = 0; i < 10; i++)
		map.insert(ft::make_pair(i, rand() % 100 - 50));

	print_map_info(map);

	it = map.find(9);

	for (int i = 0; i < 9; i++)
		map.erase(i);

	if (it == map.find(9))
		std::cout << "correct" << std::endl;

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq -0x38(%rbp), %rdi
callq 0x2b030
movl $0x0, -0x3c(%rbp)
cmpl $0xa, -0x3c(%rbp)
jge 0x296e5
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
leaq -0x3c(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1fd20
movq %rax, -0x90(%rbp)
jmp 0x29682
movq -0x90(%rbp), %rax
movq %rax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x14f10
movb %dl, -0x99(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x296a9
movb -0x99(%rbp), %al
movq -0x98(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x29634
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x297da
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x296f0
movl $0x9, -0x74(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x74(%rbp), %rsi
callq 0x2b050
movq %rax, -0xa8(%rbp)
jmp 0x2970d
movq -0xa8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x78(%rbp)
cmpl $0x9, -0x78(%rbp)
jge 0x29749
leaq -0x30(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2b310
jmp 0x2973c
jmp 0x2973e
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x29727
movl $0x9, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x84(%rbp), %rsi
callq 0x2b050
movq %rax, -0xb0(%rbp)
jmp 0x2976c
movq -0xb0(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x186b0
testb $0x1, %al
jne 0x2978a
jmp 0x297bd
movq 0x51827(%rip), %rdi     # 0x7afb8
leaq 0x2d955(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0xb8(%rbp)
jmp 0x297a6
movq -0xb8(%rbp), %rdi
movq 0x517e4(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x297bb
jmp 0x297bd
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x297c8
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_clear_int()
void
test_map_modifiers_clear_int()
{
	ft::map<int, int> mymap;

	mymap[42] = 42;
	mymap[0] = 3;
	mymap[-42] = 100;

	print_map_info(mymap);

	mymap.clear();

	print_map_info(mymap);

	mymap[-42] = 42;
	mymap[-1] = 3;

	print_map_info(mymap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x14da0
movq -0x68(%rbp), %rdi
movl $0x2a, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x2b3c0
movq %rax, -0x60(%rbp)
jmp 0x2a0d2
movq -0x60(%rbp), %rax
movl $0x2a, (%rax)
movl $0x0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2b3c0
movq %rax, -0x70(%rbp)
jmp 0x2a0f6
movq -0x70(%rbp), %rax
movl $0x3, (%rax)
movl $0xffffffd6, -0x4c(%rbp) # imm = 0xFFFFFFD6
leaq -0x30(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x2b3c0
movq %rax, -0x78(%rbp)
jmp 0x2a11a
movq -0x78(%rbp), %rax
movl $0x64, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x2a12f
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2b4a0
movq -0x80(%rbp), %rdi
callq 0x2abf0
jmp 0x2a147
movl $0xffffffd6, -0x50(%rbp) # imm = 0xFFFFFFD6
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2b3c0
movq %rax, -0x88(%rbp)
jmp 0x2a164
movq -0x88(%rbp), %rax
movl $0x2a, (%rax)
movl $0xffffffff, -0x54(%rbp) # imm = 0xFFFFFFFF
leaq -0x30(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0x2b3c0
movq %rax, -0x90(%rbp)
jmp 0x2a18e
movq -0x90(%rbp), %rax
movl $0x3, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x2abf0
jmp 0x2a1a6
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
movq -0x40(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_modifiers.cpp
// Function: test_map_modifiers_clear_string()
void
test_map_modifiers_clear_string()
{
	ft::map<int, std::string> mymap;

	mymap[42] = "test";
	mymap[0] = "hello";
	mymap[-42] = "world";

	print_map_info(mymap);

	mymap.clear();

	print_map_info(mymap);

	mymap[-42] = "hi";
	mymap[-1] = "there";

	print_map_info(mymap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2ad60
movq -0x68(%rbp), %rdi
movl $0x2a, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x2b4c0
movq %rax, -0x60(%rbp)
jmp 0x2a212
movq -0x60(%rbp), %rdi
leaq 0x2cef2(%rip), %rsi     # 0x5710f
callq 0x3280
jmp 0x2a224
movl $0x0, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2b4c0
movq %rax, -0x70(%rbp)
jmp 0x2a23e
movq -0x70(%rbp), %rdi
leaq 0x2ce14(%rip), %rsi     # 0x5705d
callq 0x3280
jmp 0x2a250
movl $0xffffffd6, -0x4c(%rbp) # imm = 0xFFFFFFD6
leaq -0x30(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x2b4c0
movq %rax, -0x78(%rbp)
jmp 0x2a26a
movq -0x78(%rbp), %rdi
leaq 0x2d559(%rip), %rsi     # 0x577ce
callq 0x3280
jmp 0x2a27c
leaq -0x30(%rbp), %rdi
callq 0x2adb0
jmp 0x2a287
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2b5a0
movq -0x80(%rbp), %rdi
callq 0x2adb0
jmp 0x2a29f
movl $0xffffffd6, -0x50(%rbp) # imm = 0xFFFFFFD6
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2b4c0
movq %rax, -0x88(%rbp)
jmp 0x2a2bc
movq -0x88(%rbp), %rdi
leaq 0x2d53d(%rip), %rsi     # 0x57807
callq 0x3280
jmp 0x2a2d1
movl $0xffffffff, -0x54(%rbp) # imm = 0xFFFFFFFF
leaq -0x30(%rbp), %rdi
leaq -0x54(%rbp), %rsi
callq 0x2b4c0
movq %rax, -0x90(%rbp)
jmp 0x2a2ee
movq -0x90(%rbp), %rdi
leaq 0x2d50e(%rip), %rsi     # 0x5780a
callq 0x3280
jmp 0x2a303
leaq -0x30(%rbp), %rdi
callq 0x2adb0
jmp 0x2a30e
leaq -0x30(%rbp), %rdi
callq 0x2b010
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2b010
movq -0x40(%rbp), %rdi
callq 0x3360
nop
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_observers.cpp
// Function: test_map_observers_key_comp()
void
test_map_observers_key_comp()
{
	ft::map<char, int> mymap;

	ft::map<char, int>::key_compare mycomp = mymap.key_comp();

	mymap['a'] = 100;
	mymap['b'] = 200;
	mymap['c'] = 300;

	std::cout << "mymap contains:";

	char highest = mymap.rbegin()->first;

	ft::map<char, int>::iterator it = mymap.begin();
	do
	{
		std::cout << " [" << it->first << "] = " << it->second;
	} while (mycomp((*it++).first, highest));
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1bf70
movq -0x70(%rbp), %rdi
callq 0x1d920
jmp 0x2e433
movb $0x61, -0x46(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x46(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x78(%rbp)
jmp 0x2e44a
movq -0x78(%rbp), %rax
movl $0x64, (%rax)
movb $0x62, -0x47(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x47(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x80(%rbp)
jmp 0x2e46b
movq -0x80(%rbp), %rax
movl $0xc8, (%rax)
movb $0x63, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x88(%rbp)
jmp 0x2e48f
movq -0x88(%rbp), %rax
movl $0x12c, (%rax)          # imm = 0x12C
movq 0x4cb15(%rip), %rdi     # 0x7afb8
leaq 0x29367(%rip), %rsi     # 0x57811
callq 0x31e0
jmp 0x2e4b1
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x2e900
movq -0x98(%rbp), %rdi
callq 0x2e930
movq %rax, -0x90(%rbp)
jmp 0x2e4da
movq -0x90(%rbp), %rax
movb (%rax), %al
movb %al, -0x49(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2b200
movq %rax, -0x60(%rbp)
movq 0x4cabe(%rip), %rdi     # 0x7afb8
leaq 0x29116(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xa0(%rbp)
jmp 0x2e50f
leaq -0x60(%rbp), %rdi
callq 0x1c330
movq -0xa0(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3250
movq %rax, -0xa8(%rbp)
jmp 0x2e530
movq -0xa8(%rbp), %rdi
leaq 0x290dc(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xb0(%rbp)
jmp 0x2e54c
leaq -0x60(%rbp), %rdi
callq 0x1c330
movq -0xb0(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x3350
jmp 0x2e566
jmp 0x2e568
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x2e970
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1d940
movq %rax, %rsi
leaq -0x31(%rbp), %rdi
leaq -0x49(%rbp), %rdx
callq 0x1d050
movb %al, -0xb1(%rbp)
jmp 0x2e598
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x2e4f3
jmp 0x2e5a8
movq 0x4ca09(%rip), %rdi     # 0x7afb8
movq 0x4c9e2(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x2e5bd
leaq -0x30(%rbp), %rdi
callq 0x1c230
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c230
movq -0x40(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_observers.cpp
// Function: test_map_observers_value_comp()
void
test_map_observers_value_comp()
{
	ft::map<char, int> mymap;

	mymap['x'] = 1001;
	mymap['y'] = 2002;
	mymap['z'] = 3003;

	std::cout << "mymap contains:\n";

	ft::pair<char, int> highest = *mymap.rbegin();          // last element

	ft::map<char, int>::iterator it = mymap.begin();
	do {
		std::cout << " [" << it->first << "] = " << it->second;
	} while ( mymap.value_comp()(*it++, highest) );
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1bf70
movq -0x88(%rbp), %rdi
movb $0x78, -0x31(%rbp)
leaq -0x31(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x80(%rbp)
jmp 0x2e625
movq -0x80(%rbp), %rax
movl $0x3e9, (%rax)          # imm = 0x3E9
movb $0x79, -0x45(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x45(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x90(%rbp)
jmp 0x2e649
movq -0x90(%rbp), %rax
movl $0x7d2, (%rax)          # imm = 0x7D2
movb $0x7a, -0x46(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x46(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x98(%rbp)
jmp 0x2e670
movq -0x98(%rbp), %rax
movl $0xbbb, (%rax)          # imm = 0xBBB
movq 0x4c934(%rip), %rdi     # 0x7afb8
leaq 0x29196(%rip), %rsi     # 0x57821
callq 0x31e0
jmp 0x2e692
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x2e900
movq -0xa8(%rbp), %rdi
callq 0x2e9b0
movq %rax, -0xa0(%rbp)
jmp 0x2e6bb
movq -0xa0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2e9e0
jmp 0x2e6cd
leaq -0x30(%rbp), %rdi
callq 0x2b200
movq %rax, -0x60(%rbp)
movq 0x4c8d7(%rip), %rdi     # 0x7afb8
leaq 0x28f2f(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xb0(%rbp)
jmp 0x2e6f6
leaq -0x60(%rbp), %rdi
callq 0x1c330
movq -0xb0(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3250
movq %rax, -0xb8(%rbp)
jmp 0x2e717
movq -0xb8(%rbp), %rdi
leaq 0x28ef5(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xc0(%rbp)
jmp 0x2e733
leaq -0x60(%rbp), %rdi
callq 0x1c330
movq -0xc0(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x3350
jmp 0x2e74d
jmp 0x2e74f
leaq -0x30(%rbp), %rdi
callq 0x2ea10
jmp 0x2e75a
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x2e970
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1d940
movq %rax, -0xc8(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2ea70
jmp 0x2e788
movq -0xc8(%rbp), %rsi
leaq -0x61(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2ea40
movb %al, -0xc9(%rbp)
jmp 0x2e7a4
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x2e6da
jmp 0x2e7b4
movq 0x4c7fd(%rip), %rdi     # 0x7afb8
movq 0x4c7d6(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x2e7c9
leaq -0x30(%rbp), %rdi
callq 0x1c230
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1c230
movq -0x40(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_range()
void
test_map_constructors_range()
{
	ft::map<char, int> map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, rand() % 10000 - 10000 / 2));

	ft::map<char, int> range(map.begin(), map.end());

	print_map_info(map);
	print_map_info(range);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x1bf70
leaq 0x4c2bd(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movb $0x61, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x7a, %eax
jg 0x2f006
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x68db8bad, %rax, %rax # imm = 0x68DB8BAD
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rax
addl %edx, %eax
imull $0x2710, %eax, %edx     # imm = 0x2710
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x1388(%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
leaq -0x31(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2fc90
movq %rax, -0xa8(%rbp)
jmp 0x2efad
movq -0xa8(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x2b130
movb %dl, -0xb1(%rbp)
movq %rax, -0xb0(%rbp)
jmp 0x2efd4
movb -0xb1(%rbp), %al
movq -0xb0(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x2ef56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2f09b
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x2b200
movq -0xc0(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x1c1c0
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x2fcc0
jmp 0x2f04c
leaq -0x30(%rbp), %rdi
callq 0x1c020
jmp 0x2f057
leaq -0x90(%rbp), %rdi
callq 0x1c020
jmp 0x2f065
leaq -0x90(%rbp), %rdi
callq 0x1c230
leaq -0x30(%rbp), %rdi
callq 0x1c230
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1c230
leaq -0x30(%rbp), %rdi
callq 0x1c230
movq -0x48(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_copy_int()
void
test_map_constructors_copy_int()
{
	ft::map<char, int> map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, rand() % 10000 - 10000 / 2));

	{
		ft::map<char, int> cpy1(map);
		ft::map<char, int> cpy2 = map;

		print_map_info(map);
		print_map_info(cpy1);
		print_map_info(cpy2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x1bf70
leaq 0x4c13d(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movb $0x61, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x7a, %eax
jg 0x2f186
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x68db8bad, %rax, %rax # imm = 0x68DB8BAD
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rax
addl %edx, %eax
imull $0x2710, %eax, %edx     # imm = 0x2710
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x1388(%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
leaq -0x31(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2fc90
movq %rax, -0xc8(%rbp)
jmp 0x2f12d
movq -0xc8(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x2b130
movb %dl, -0xd1(%rbp)
movq %rax, -0xd0(%rbp)
jmp 0x2f154
movb -0xd1(%rbp), %al
movq -0xd0(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x2f0d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2f22d
leaq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fd40
jmp 0x2f198
leaq -0xc0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fd40
jmp 0x2f1aa
leaq -0x30(%rbp), %rdi
callq 0x1c020
jmp 0x2f1b5
leaq -0x90(%rbp), %rdi
callq 0x1c020
jmp 0x2f1c3
leaq -0xc0(%rbp), %rdi
callq 0x1c020
jmp 0x2f1d1
leaq -0xc0(%rbp), %rdi
callq 0x1c230
leaq -0x90(%rbp), %rdi
callq 0x1c230
leaq -0x30(%rbp), %rdi
callq 0x1c230
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2f221
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x1c230
leaq -0x90(%rbp), %rdi
callq 0x1c230
leaq -0x30(%rbp), %rdi
callq 0x1c230
movq -0x48(%rbp), %rdi
callq 0x3360
nop
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_copy_string()
void
test_map_constructors_copy_string()
{
	ft::map<char, std::string> map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, ft_itoa(rand() % 10000 - 10000 / 2)));

	{
		ft::map<char, std::string> cpy1(map);
		ft::map<char, std::string> cpy2 = map;

		print_map_info(map);
		print_map_info(cpy1);
		print_map_info(cpy2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
leaq -0x30(%rbp), %rdi
callq 0x24c90
leaq 0x4bfad(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movb $0x61, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x7a, %eax
jg 0x2f36b
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x68db8bad, %rax, %rax # imm = 0x68DB8BAD
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rax
addl %edx, %eax
imull $0x2710, %eax, %edx     # imm = 0x2710
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x1388(%rax,%rcx), %esi
leaq -0x80(%rbp), %rdi
callq 0x7860
jmp 0x2f2af
leaq -0x60(%rbp), %rdi
leaq -0x31(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x2fdb0
jmp 0x2f2c2
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2fd70
movb %dl, -0x109(%rbp)
movq %rax, -0x108(%rbp)
jmp 0x2f2de
movb -0x109(%rbp), %al
movq -0x108(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movb %al, -0x98(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2fdf0
leaq -0x80(%rbp), %rdi
callq 0x3160
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x2f266
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x2f41e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x2f35d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2fdf0
leaq -0x80(%rbp), %rdi
callq 0x3160
jmp 0x2f41e
leaq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fe10
jmp 0x2f37d
leaq -0x100(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fe10
jmp 0x2f38f
leaq -0x30(%rbp), %rdi
callq 0x2fe40
jmp 0x2f39a
leaq -0xd0(%rbp), %rdi
callq 0x2fe40
jmp 0x2f3a8
leaq -0x100(%rbp), %rdi
callq 0x2fe40
jmp 0x2f3b6
leaq -0x100(%rbp), %rdi
callq 0x24db0
leaq -0xd0(%rbp), %rdi
callq 0x24db0
leaq -0x30(%rbp), %rdi
callq 0x24db0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x2f412
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x24db0
leaq -0xd0(%rbp), %rdi
callq 0x24db0
leaq -0x30(%rbp), %rdi
callq 0x24db0
movq -0x88(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_custom_compare_char()
void
test_map_constructors_custom_compare_char()
{
	ft::map<char, int, greater<char> > map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(i, rand() % 10000 - 10000 / 2));

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x30(%rbp), %rdi
callq 0x2ff90
leaq 0x4bdad(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movb $0x61, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x7a, %eax
jg 0x2f50a
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x68db8bad, %rax, %rax # imm = 0x68DB8BAD
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rax
addl %edx, %eax
imull $0x2710, %eax, %edx     # imm = 0x2710
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x1388(%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
leaq -0x31(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2fc90
movq %rax, -0x68(%rbp)
jmp 0x2f4ba
movq -0x68(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x2ffb0
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x2f4d8
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x2f466
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30130
jmp 0x2f527
leaq -0x30(%rbp), %rdi
callq 0x2fff0
jmp 0x2f515
leaq -0x30(%rbp), %rdi
callq 0x30130
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_custom_compare_string()
void
test_map_constructors_custom_compare_string()
{
	ft::map<std::string, char, greater<std::string> > map;

	srand(g_seed);

	for (char i = 'a'; i <= 'z'; i++)
		map.insert(ft::make_pair(ft_itoa(rand() % 10000 - 10000 / 2), i));

	print_map_info(map);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x30150
leaq 0x4bcbd(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movb $0x61, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x7a, %eax
jg 0x2f655
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x68db8bad, %rax, %rax # imm = 0x68DB8BAD
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rax
addl %edx, %eax
imull $0x2710, %eax, %edx     # imm = 0x2710
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x1388(%rax,%rcx), %esi
leaq -0x80(%rbp), %rdi
callq 0x7860
jmp 0x2f59f
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x31(%rbp), %rdx
callq 0x301b0
jmp 0x2f5b2
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x30170
movb %dl, -0xa9(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x2f5ce
movb -0xa9(%rbp), %al
movq -0xa8(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movb %al, -0x98(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x301f0
leaq -0x80(%rbp), %rdi
callq 0x3160
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x2f556
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x2f672
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x2f64a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x301f0
leaq -0x80(%rbp), %rdi
callq 0x3160
jmp 0x2f672
leaq -0x30(%rbp), %rdi
callq 0x30210
jmp 0x2f660
leaq -0x30(%rbp), %rdi
callq 0x30350
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x30350
movq -0x88(%rbp), %rdi
callq 0x3360
nopw (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_constructors.cpp
// Function: test_map_constructors_cplusplus()
void
test_map_constructors_cplusplus()
{
	ft::map<char, int> first;

	first['a'] = 10;
	first['b'] = 30;
	first['c'] = 50;
	first['d'] = 70;

	ft::map<char, int> second(first.begin(), first.end());

	ft::map<char, int> third(second);

	ft::map<char, int, classcomp> fourth;

	bool(*fn_pt)(char, char) = fncomp;
	ft::map<char, int, bool(*)(char, char)> fifth(fn_pt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
leaq -0x30(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x1bf70
movq -0x138(%rbp), %rdi
movb $0x61, -0x31(%rbp)
leaq -0x31(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x130(%rbp)
jmp 0x2f6c8
movq -0x130(%rbp), %rax
movl $0xa, (%rax)
movb $0x62, -0x45(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x45(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x140(%rbp)
jmp 0x2f6ef
movq -0x140(%rbp), %rax
movl $0x1e, (%rax)
movb $0x63, -0x46(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x46(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x148(%rbp)
jmp 0x2f716
movq -0x148(%rbp), %rax
movl $0x32, (%rax)
movb $0x64, -0x47(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x47(%rbp), %rsi
callq 0x1c3f0
movq %rax, -0x150(%rbp)
jmp 0x2f73d
movq -0x150(%rbp), %rax
movl $0x46, (%rax)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x158(%rbp)
callq 0x2b200
movq -0x158(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x1c1c0
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x2fcc0
jmp 0x2f787
leaq -0xb8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2fd40
jmp 0x2f799
leaq -0xe8(%rbp), %rdi
callq 0x30370
leaq -0x8cc(%rip), %rax      # 0x2eee0
movq %rax, -0xf0(%rbp)
leaq -0x121(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0x30390
movq -0x160(%rbp), %rdx
leaq -0x120(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x303b0
jmp 0x2f7e2
leaq -0x121(%rbp), %rdi
callq 0x225a0
leaq -0x120(%rbp), %rdi
callq 0x30430
leaq -0xe8(%rbp), %rdi
callq 0x30450
leaq -0xb8(%rbp), %rdi
callq 0x1c230
leaq -0x78(%rbp), %rdi
callq 0x1c230
leaq -0x30(%rbp), %rdi
callq 0x1c230
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2f882
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2f879
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x121(%rbp), %rdi
callq 0x225a0
leaq -0xe8(%rbp), %rdi
callq 0x30450
leaq -0xb8(%rbp), %rdi
callq 0x1c230
leaq -0x78(%rbp), %rdi
callq 0x1c230
leaq -0x30(%rbp), %rdi
callq 0x1c230
movq -0x40(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_constructors_base()
void
test_map_iterators_constructors_base()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;

	iter_type from(map.begin());
	iter_type cpy(from);

	if (from == cpy)
		std::cout << "valid" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x30(%rbp), %rdi
callq 0x1f960
movl $0x30, -0x34(%rbp)
cmpl $0x3a, -0x34(%rbp)
jge 0x333b7
leaq -0x34(%rbp), %rsi
movq %rsi, %rdi
callq 0x1c250
movq %rax, -0x78(%rbp)
jmp 0x33363
movq -0x78(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x1f980
movb %dl, -0x81(%rbp)
movq %rax, -0x80(%rbp)
jmp 0x33384
movb -0x81(%rbp), %al
movq -0x80(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3334b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1fa90
jmp 0x33424
leaq -0x30(%rbp), %rdi
callq 0x1f9c0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1fa60
testb $0x1, %al
jne 0x333df
jmp 0x33412
movq 0x47bd2(%rip), %rdi     # 0x7afb8
leaq 0x250f0(%rip), %rsi     # 0x584dd
callq 0x31e0
movq %rax, -0x90(%rbp)
jmp 0x333fb
movq -0x90(%rbp), %rdi
movq 0x47b8f(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x33410
jmp 0x33412
leaq -0x30(%rbp), %rdi
callq 0x1fa90
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_operator_star()
void
test_map_iterators_operator_star()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;

	iter_type from(map.begin());

	std::cout << "[" << from->first << "] = " << from->second << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x1f960
movl $0x30, -0x34(%rbp)
cmpl $0x3a, -0x34(%rbp)
jge 0x334b4
leaq -0x34(%rbp), %rsi
movq %rsi, %rdi
callq 0x1c250
movq %rax, -0x70(%rbp)
jmp 0x33463
movq -0x70(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x1f980
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0x33481
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3344b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1fa90
jmp 0x33562
leaq -0x30(%rbp), %rdi
callq 0x1f9c0
movq %rax, -0x68(%rbp)
movq 0x47af0(%rip), %rdi     # 0x7afb8
leaq 0x24149(%rip), %rsi     # 0x57618
callq 0x31e0
movq %rax, -0x88(%rbp)
jmp 0x334dd
leaq -0x68(%rbp), %rdi
callq 0x20ae0
movq -0x88(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0x90(%rbp)
jmp 0x334fd
movq -0x90(%rbp), %rdi
leaq 0x2410f(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0x98(%rbp)
jmp 0x33519
leaq -0x68(%rbp), %rdi
callq 0x20ae0
movq -0x98(%rbp), %rdi
movsbl 0x4(%rax), %esi
callq 0x3250
movq %rax, -0xa0(%rbp)
jmp 0x3353b
movq -0xa0(%rbp), %rdi
movq 0x47a4f(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x33550
leaq -0x30(%rbp), %rdi
callq 0x1fa90
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_operator_increment()
void
test_map_iterators_operator_increment()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;

	iter_type from(map.begin());
	iter_type until(map.end());

	std::cout << "map:";
	while (from != until)
	{
		std::cout << " [" << from->first << "] = " << from->second;
		from++;
	}
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x1f960
movl $0x30, -0x34(%rbp)
cmpl $0x3a, -0x34(%rbp)
jge 0x33600
leaq -0x34(%rbp), %rsi
movq %rsi, %rdi
callq 0x1c250
movq %rax, -0x80(%rbp)
jmp 0x335a3
movq -0x80(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x1f980
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x335c7
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3358b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1fa90
jmp 0x336ff
leaq -0x30(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1f9c0
movq -0x98(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x1f9f0
movq %rax, -0x70(%rbp)
movq 0x4798d(%rip), %rdi     # 0x7afb8
leaq 0x23ff0(%rip), %rsi     # 0x57622
callq 0x31e0
jmp 0x33639
jmp 0x3363b
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x34490
testb $0x1, %al
jne 0x33651
jmp 0x336d8
movq 0x47960(%rip), %rdi     # 0x7afb8
leaq 0x23fb8(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xa0(%rbp)
jmp 0x3366d
leaq -0x68(%rbp), %rdi
callq 0x20ae0
movq -0xa0(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0xa8(%rbp)
jmp 0x3368d
movq -0xa8(%rbp), %rdi
leaq 0x23f7f(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xb0(%rbp)
jmp 0x336a9
leaq -0x68(%rbp), %rdi
callq 0x20ae0
movq -0xb0(%rbp), %rdi
movsbl 0x4(%rax), %esi
callq 0x3250
jmp 0x336c4
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0x344c0
movq %rax, -0x78(%rbp)
jmp 0x3363b
movq 0x478d9(%rip), %rdi     # 0x7afb8
movq 0x478b2(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x336ed
leaq -0x30(%rbp), %rdi
callq 0x1fa90
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopl (%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_operator_decrement()
void
test_map_iterators_operator_decrement()
{
	ft::map<int, char> map;

	for (int i = 48; i < 58; i++)
		map.insert(ft::make_pair(i, i));

	typedef ft::map<int, char>::iterator iter_type;

	iter_type begin(map.begin());
	iter_type end(map.end());

	iter_type it(begin);
	while (it != end)
		std::cout << " [" << it->first << "] = " << (it++)->second;
	std::cout << std::endl;

	while (it != begin)
		std::cout << " [" << (--it)->first << "] = " << it->second;
	std::cout << std::endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x1f960
movl $0x30, -0x34(%rbp)
cmpl $0x3a, -0x34(%rbp)
jge 0x337a6
leaq -0x34(%rbp), %rsi
movq %rsi, %rdi
callq 0x1c250
movq %rax, -0x88(%rbp)
jmp 0x33746
movq -0x88(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x1f980
movb %dl, -0x91(%rbp)
movq %rax, -0x90(%rbp)
jmp 0x3376d
movb -0x91(%rbp), %al
movq -0x90(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3372b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1fa90
jmp 0x33939
leaq -0x30(%rbp), %rdi
callq 0x1f9c0
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1f9f0
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x34490
testb $0x1, %al
jne 0x337de
jmp 0x33865
movq 0x477d3(%rip), %rdi     # 0x7afb8
leaq 0x23e2b(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xa0(%rbp)
jmp 0x337fa
leaq -0x78(%rbp), %rdi
callq 0x20ae0
movq -0xa0(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0xa8(%rbp)
jmp 0x3381a
movq -0xa8(%rbp), %rdi
leaq 0x23df2(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xb0(%rbp)
jmp 0x33836
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
callq 0x344c0
movq %rax, -0x80(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x20ae0
movq -0xb0(%rbp), %rdi
movsbl 0x4(%rax), %esi
callq 0x3250
jmp 0x33860
jmp 0x337c8
movq 0x4774c(%rip), %rdi     # 0x7afb8
movq 0x47725(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x3387a
jmp 0x3387c
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x34490
testb $0x1, %al
jne 0x33892
jmp 0x33912
movq 0x4771f(%rip), %rdi     # 0x7afb8
leaq 0x23d77(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xb8(%rbp)
jmp 0x338ae
leaq -0x78(%rbp), %rdi
callq 0x209d0
movq %rax, %rdi
callq 0x20ae0
movq -0xb8(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0xc0(%rbp)
jmp 0x338d6
movq -0xc0(%rbp), %rdi
leaq 0x23d36(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xc8(%rbp)
jmp 0x338f2
leaq -0x78(%rbp), %rdi
callq 0x20ae0
movq -0xc8(%rbp), %rdi
movsbl 0x4(%rax), %esi
callq 0x3250
jmp 0x3390d
jmp 0x3387c
movq 0x4769f(%rip), %rdi     # 0x7afb8
movq 0x47678(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x33927
leaq -0x30(%rbp), %rdi
callq 0x1fa90
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopw %cs:(%rax,%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_empty_maps()
void
test_map_iterators_empty_maps()
{
	ft::map<int, int> map;
	ft::map<int, int> const const_map;

	if (map.begin() == map.end())
		std::cout << "correct" << std::endl;

	if (const_map.begin() == const_map.end())
		std::cout << "correct" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq -0x60(%rbp), %rdi
callq 0x14da0
leaq -0x30(%rbp), %rdi
callq 0x2b0c0
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x18830
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x186b0
testb $0x1, %al
jne 0x3399a
jmp 0x339f0
movq 0x47617(%rip), %rdi     # 0x7afb8
leaq 0x23745(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0x98(%rbp)
jmp 0x339b6
movq -0x98(%rbp), %rdi
movq 0x475d4(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x339cb
jmp 0x339f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x15090
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x33a77
leaq -0x60(%rbp), %rdi
callq 0x2ba30
movq %rax, -0x88(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2ba60
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1d5b0
testb $0x1, %al
jne 0x33a29
jmp 0x33a5c
movq 0x47588(%rip), %rdi     # 0x7afb8
leaq 0x236b6(%rip), %rsi     # 0x570ed
callq 0x31e0
movq %rax, -0xa0(%rbp)
jmp 0x33a45
movq -0xa0(%rbp), %rdi
movq 0x47545(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x33a5a
jmp 0x33a5c
leaq -0x60(%rbp), %rdi
callq 0x15090
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3360
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_100_size_map()
void
test_map_iterators_100_size_map()
{
	typedef ft::map<int, int>::iterator iterator;

	ft::map<int, int> map;

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		map.insert(ft::make_pair(i, rand() % 100 - 50));

	for (iterator it = map.begin(); it != map.end(); it++)
		std::cout << " [" << it->first << "] = " << it->second;
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq 0x4776d(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0x64, -0x34(%rbp)
jge 0x33b54
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fd20
movq %rax, -0x80(%rbp)
jmp 0x33af4
movq -0x80(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x14f10
movb %dl, -0x89(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x33b18
movb -0x89(%rbp), %al
movq -0x88(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x33aa9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x33c33
leaq -0x30(%rbp), %rdi
callq 0x2b0c0
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x18830
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2c720
testb $0x1, %al
jne 0x33b84
jmp 0x33c0c
movq 0x4742d(%rip), %rdi     # 0x7afb8
leaq 0x23a85(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0x98(%rbp)
jmp 0x33ba0
leaq -0x68(%rbp), %rdi
callq 0x20da0
movq -0x98(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0xa0(%rbp)
jmp 0x33bc0
movq -0xa0(%rbp), %rdi
leaq 0x23a4c(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xa8(%rbp)
jmp 0x33bdc
leaq -0x68(%rbp), %rdi
callq 0x20da0
movq -0xa8(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x3350
jmp 0x33bf6
jmp 0x33bf8
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0x34500
movq %rax, -0x78(%rbp)
jmp 0x33b61
movq 0x473a5(%rip), %rdi     # 0x7afb8
movq 0x4737e(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x33c21
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nopl (%rax)
// File: DimitriDaSilva[P]42_ft_containers/tester/containers/map/test_map_iterators.cpp
// Function: test_map_iterators_100_size_const_map()
void
test_map_iterators_100_size_const_map()
{
	typedef ft::map<int, int>::const_iterator const_iterator;

	ft::map<int, int> const_map;

	srand(g_seed);

	for (int i = 0; i < 100; i++)
		const_map.insert(ft::make_pair(i, rand() % 100 - 50));

	for (const_iterator it = const_map.begin(); it != const_map.end(); it++)
		std::cout << " [" << it->first << "] = " << it->second;
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq -0x30(%rbp), %rdi
callq 0x14da0
leaq 0x475ad(%rip), %rax     # 0x7b208
movl (%rax), %edi
callq 0x31d0
movl $0x0, -0x34(%rbp)
cmpl $0x64, -0x34(%rbp)
jge 0x33d1a
callq 0x30a0
movl %eax, %ecx
movslq %ecx, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
imull $0x64, %eax, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal -0x32(%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1fd20
movq %rax, -0x90(%rbp)
jmp 0x33cb7
movq -0x90(%rbp), %rax
movq %rax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x14f10
movb %dl, -0x99(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x33cde
movb -0x99(%rbp), %al
movq -0x98(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x33c69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15090
jmp 0x33e16
leaq -0x30(%rbp), %rdi
callq 0x2b0c0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x189d0
leaq -0x30(%rbp), %rdi
callq 0x18830
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x189d0
leaq -0x68(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x20dc0
testb $0x1, %al
jne 0x33d64
jmp 0x33def
movq 0x4724d(%rip), %rdi     # 0x7afb8
leaq 0x238a5(%rip), %rsi     # 0x57617
callq 0x31e0
movq %rax, -0xa8(%rbp)
jmp 0x33d80
leaq -0x68(%rbp), %rdi
callq 0x20e40
movq -0xa8(%rbp), %rdi
movl (%rax), %esi
callq 0x3350
movq %rax, -0xb0(%rbp)
jmp 0x33da0
movq -0xb0(%rbp), %rdi
leaq 0x2386c(%rip), %rsi     # 0x5761a
callq 0x31e0
movq %rax, -0xb8(%rbp)
jmp 0x33dbc
leaq -0x68(%rbp), %rdi
callq 0x20e40
movq -0xb8(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x3350
jmp 0x33dd6
jmp 0x33dd8
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
callq 0x2ba90
movq %rax, -0x88(%rbp)
jmp 0x33d34
movq 0x471c2(%rip), %rdi     # 0x7afb8
movq 0x4719b(%rip), %rsi     # 0x7af98
callq 0x3220
jmp 0x33e04
leaq -0x30(%rbp), %rdi
callq 0x15090
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3360
nop