LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: std::unordered_set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> swxJson::Json::wantUnorderedSet<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>()
std::unordered_set<Key, Hash, Pred, Alloc> wantUnorderedSet()
	{
		if (_type != JSON_Array)
			throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");

		std::list<JsonPtr>* data = (std::list<JsonPtr>*)_data;
		std::unordered_set<Key, Hash, Pred, Alloc> res;

		for (auto& node: *data)
			res.insert((Key)(*node));

		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, (%rsi)
jne 0x1f2a9
movq %rdi, %rbx
movq 0x8(%rsi), %r12
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
movq (%r12), %rbp
cmpq %r12, %rbp
je 0x1f297
leaq 0x10(%rsp), %r13
movq %rsp, %r14
leaq 0x20(%rsp), %r15
movq 0x10(%rbp), %rsi
movq %r14, %rdi
callq 0x24906
movq %rbx, 0x20(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1f378
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1f28e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x132a0
movq (%rbp), %rbp
cmpq %r12, %rbp
jne 0x1f259
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe34f(%rip), %rsi      # 0x2d615
leaq 0xe35d(%rip), %rdx      # 0x2d62a
movq %rsp, %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0xe2f0(%rip), %rsi      # 0x2d5cf
leaq 0xe3e3(%rip), %rdx      # 0x2d6c9
movq %rsp, %r8
movq %rbx, %rdi
movl $0x39b, %ecx            # imm = 0x39B
callq 0x2bf1c
leaq 0x1992b(%rip), %rax     # 0x38c28
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x198eb(%rip), %rsi     # 0x38bf8
leaq -0x5176(%rip), %rdx     # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1f335
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x1f33f
jmp 0x1f36f
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
jmp 0x1f36f
movq %rax, %r14
jmp 0x1f367
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1f367
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x132a0
movq %rbx, %rdi
callq 0x1f7a2
movq %r14, %rdi
callq 0x13430
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> swxJson::Json::wantDict<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::map<std::string, T, Compare, Alloc> wantDict(const std::string& path, const std::string& delim = "./")
	{
		JsonPtr node = getNode(path, delim);
		if (node)
			return node->wantDict<T, Compare, Alloc>();
		
		throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x21f1c
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1fda1
movq %rbx, %rdi
callq 0x1fe60
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1fd93
callq 0x19f10
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd83c(%rip), %rsi      # 0x2d5fa
leaq 0xd84f(%rip), %rdx      # 0x2d614
leaq 0x18(%rsp), %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0xd7f6(%rip), %rsi      # 0x2d5cf
leaq 0xd8fa(%rip), %rdx      # 0x2d6da
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x41c, %ecx            # imm = 0x41C
callq 0x2bf1c
leaq 0x18e7f(%rip), %rax     # 0x38c78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x18e07(%rip), %rsi     # 0x38c10
leaq -0x5c72(%rip), %rdx     # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1fe32
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x1fe3c
jmp 0x1fe49
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
jmp 0x1fe49
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1fe58
callq 0x19f10
movq %r14, %rdi
callq 0x13430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> swxJson::Json::wantDict<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>()
std::map<std::string, T, Compare, Alloc> wantDict()
	{
		if (_type != JSON_Object)
			throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");

		std::map<std::string, JsonPtr>* data = (std::map<std::string, JsonPtr>*)_data;
		std::map<std::string, T, Compare, Alloc> res;

		for (auto& npair: *data)
			res[npair.first] = (T)(*(npair.second));

		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, (%rsi)
jne 0x1ff0f
movq %rdi, %rbx
movq 0x8(%rsi), %r12
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x18(%r12), %r14
addq $0x8, %r12
cmpq %r12, %r14
je 0x1fefd
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x24906
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x1ffe4
movq %rax, %rdi
movq %r15, %rsi
callq 0x13310
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1feed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
movq %r14, %rdi
callq 0x131a0
movq %rax, %r14
cmpq %r12, %rax
jne 0x1feb3
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd6e9(%rip), %rsi      # 0x2d615
leaq 0xd6f7(%rip), %rdx      # 0x2d62a
leaq 0x8(%rsp), %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0xd688(%rip), %rsi      # 0x2d5cf
leaq 0xd78c(%rip), %rdx      # 0x2d6da
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x3aa, %ecx            # imm = 0x3AA
callq 0x2bf1c
leaq 0x18cc1(%rip), %rax     # 0x38c28
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x18c81(%rip), %rsi     # 0x38bf8
leaq -0x5de0(%rip), %rdx     # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ffa0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x1ffaa
jmp 0x1ffdb
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
jmp 0x1ffdb
movq %rax, %r14
jmp 0x1ffd3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1ffd3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
movq %rbx, %rdi
callq 0x20414
movq %r14, %rdi
callq 0x13430
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> swxJson::Json::wantUnorderedDict<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::unordered_map<std::string, T, Hash, Pred, Alloc> wantUnorderedDict(const std::string& path, const std::string& delim = "./")
	{
		JsonPtr node = getNode(path, delim);
		if (node)
			return node->wantUnorderedDict<T, Hash, Pred, Alloc>();
		
		throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x21f1c
movq (%r14), %rsi
testq %rsi, %rsi
je 0x20b39
movq %rbx, %rdi
callq 0x20bf8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x20b2b
callq 0x19f10
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcaa4(%rip), %rsi      # 0x2d5fa
leaq 0xcab7(%rip), %rdx      # 0x2d614
leaq 0x18(%rsp), %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0xca5e(%rip), %rsi      # 0x2d5cf
leaq 0xcb6b(%rip), %rdx      # 0x2d6e3
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x426, %ecx            # imm = 0x426
callq 0x2bf1c
leaq 0x180e7(%rip), %rax     # 0x38c78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1806f(%rip), %rsi     # 0x38c10
leaq -0x6a0a(%rip), %rdx     # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x20bca
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x20bd4
jmp 0x20be1
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
jmp 0x20be1
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x20bf0
callq 0x19f10
movq %r14, %rdi
callq 0x13430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::insertNode(std::shared_ptr<swxJson::Json>)
JsonPtr insertNode(JsonPtr node)
	{
		if (_nodeStack.empty())
			return node;
	
		if (_wantValue)
			fillValue(node);
		else
		{
			_nodeStack.top()->pushNode(node);
			_wantComma = true;
		}
		
		return nullptr;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x12a8(%rsi), %rax
cmpq 0x1288(%rsi), %rax
je 0x29aaf
movq %rsi, %r14
cmpb $0x1, 0x12e9(%rsi)
jne 0x29ac3
movq (%rdx), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x29b0b
movq 0xf52b(%rip), %rcx      # 0x38fd0
cmpb $0x0, (%rcx)
je 0x29b07
incl 0x8(%rax)
jmp 0x29b0b
movups (%rdx), %xmm0
xorl %eax, %eax
movq %rax, 0x8(%rdx)
movups %xmm0, (%rbx)
movq %rax, (%rdx)
jmp 0x29b54
cmpq 0x12b0(%r14), %rax
jne 0x29adc
movq 0x12c0(%r14), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x10(%rax), %rdi
movq (%rdx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x29b2d
movq 0xf4d3(%rip), %rcx      # 0x38fd0
cmpb $0x0, (%rcx)
je 0x29b29
incl 0x8(%rax)
jmp 0x29b2d
lock
incl 0x8(%rax)
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x2a446
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x29b4e
callq 0x19f10
jmp 0x29b4e
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
callq 0x22c32
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x29b46
callq 0x19f10
movb $0x1, 0x12ea(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
jmp 0x29b71
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x29b7b
callq 0x19f10
movq %rbx, %rdi
callq 0x13430
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::JsonParser()
JsonParser(): _numberChars("0123456789+-.eE"), _pos(0)
	{
		_wantKey = false;
		_wantValue = false;
		_wantComma = false;
		_wantSemicolon = false;

		for (int i = 0; i < 256; i++)
			_callMap[i] = &JsonParser::generalProcess;

		_callMap[(uint8_t)'{'] = &JsonParser::enterObject;
		_callMap[(uint8_t)'}'] = &JsonParser::exitObject;
		_callMap[(uint8_t)'['] = &JsonParser::enterArray;
		_callMap[(uint8_t)']'] = &JsonParser::exitArray;
		_callMap[(uint8_t)','] = &JsonParser::processComma;
		_callMap[(uint8_t)':'] = &JsonParser::processSemicolon;
		_callMap[(uint8_t)'"'] = &JsonParser::processString;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x3a68(%rip), %rsi      # 0x2dc80
leaq 0x3a70(%rip), %rdx      # 0x2dc8f
movq %rsp, %r12
movq %r12, %rdi
callq 0x19f80
leaq 0x1000(%rbx), %r15
movq (%r12), %r14
movq 0x8(%r12), %r12
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x13150
testl %r12d, %r12d
jle 0x2a269
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %eax, %eax
movzbl (%r14,%rax), %ecx
movb $0x1, (%r15,%rcx)
incq %rax
cmpq %rax, %r12
jne 0x2a257
cmpq %r13, %r14
je 0x2a27e
movq 0x10(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x132a0
leaq 0x1100(%rbx), %r14
movq %r14, %rdi
callq 0x13350
leaq 0x1278(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x12b8(%rbx)
movups %xmm0, 0x12a8(%rbx)
movups %xmm0, 0x1298(%rbx)
movups %xmm0, 0x1288(%rbx)
movups %xmm0, 0x1278(%rbx)
xorl %esi, %esi
callq 0x2afe2
leaq 0x12d8(%rbx), %rax
movq %rax, 0x12c8(%rbx)
xorl %eax, %eax
movq %rax, 0x12d0(%rbx)
movb $0x0, 0x12d8(%rbx)
movq %rax, 0x12f0(%rbx)
movl $0x0, 0x12e8(%rbx)
leaq -0xfbf(%rip), %rcx      # 0x29338
movq %rcx, (%rbx,%rax)
movq $0x0, 0x8(%rbx,%rax)
addq $0x10, %rax
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2a2f7
leaq 0x2bf(%rip), %rax       # 0x2a5d6
movq %rax, 0x7b0(%rbx)
xorl %eax, %eax
movq %rax, 0x7b8(%rbx)
leaq 0x48c(%rip), %rcx       # 0x2a7ba
movq %rcx, 0x7d0(%rbx)
movq %rax, 0x7d8(%rbx)
leaq 0x591(%rip), %rcx       # 0x2a8d4
movq %rcx, 0x5b0(%rbx)
movq %rax, 0x5b8(%rbx)
leaq 0x760(%rip), %rcx       # 0x2aab8
movq %rcx, 0x5d0(%rbx)
movq %rax, 0x5d8(%rbx)
leaq 0x865(%rip), %rcx       # 0x2abd2
movq %rcx, 0x2c0(%rbx)
movq %rax, 0x2c8(%rbx)
leaq 0x960(%rip), %rcx       # 0x2ace2
movq %rcx, 0x3a0(%rbx)
movq %rax, 0x3a8(%rbx)
leaq 0xa33(%rip), %rcx       # 0x2adca
movq %rcx, 0x220(%rbx)
movq %rax, 0x228(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0xec0b(%rip), %rsi      # 0x38fc8
movq %r14, %rdi
callq 0x13130
addq $0x1170, %rbx           # imm = 0x1170
movq %rbx, %rdi
callq 0x130b0
movq %r15, %rdi
callq 0x13430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::fillValue(std::shared_ptr<swxJson::Json>)
void fillValue(JsonPtr node)
	{
		if (_nodeStack.top()->addNode(_key, node) == false)
			throw JSON_ERROR_FMT(JosnInvalidContentError, "Json parser: content error, reduplicated key: %s.", _key.c_str());
		
		_wantKey = false;
		_wantValue = false;
		_wantComma = true;
		_wantSemicolon = false;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x12a8(%rdi), %rax
cmpq 0x12b0(%rdi), %rax
jne 0x2a471
movq 0x12c0(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x10(%rax), %rdi
leaq 0x12c8(%rbx), %r14
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2a4a6
movq 0xeb38(%rip), %rcx      # 0x38fd0
cmpb $0x0, (%rcx)
je 0x2a4a2
incl 0x8(%rax)
jmp 0x2a4a6
lock
incl 0x8(%rax)
movq %rsp, %rdx
movq %r14, %rsi
callq 0x22890
movl %eax, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2a4c2
callq 0x19f10
testb %bpl, %bpl
je 0x2a4da
movl $0x10000, 0x12e8(%rbx)  # imm = 0x10000
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x36d7(%rip), %rsi      # 0x2dbc8
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x2c17e
movb $0x1, %bpl
leaq 0x35f1(%rip), %rsi      # 0x2daf8
leaq 0x36b0(%rip), %rdx      # 0x2dbbe
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movl $0x42, %ecx
callq 0x2bf1c
leaq 0xe849(%rip), %rax      # 0x38d70
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe821(%rip), %rsi      # 0x38d58
leaq -0x103a0(%rip), %rdx    # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a564
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x2a56e
jmp 0x2a58a
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
jmp 0x2a58a
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2a58a
callq 0x19f10
movq %r14, %rdi
callq 0x13430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::enterObject()
JsonPtr enterObject()
	{
		if (_wantKey || _wantSemicolon || _wantComma)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, '{' at improper place.");

		JsonPtr node(new Json());
		node->setDict();
		insertNode(node);
		_nodeStack.push(node);

		_wantKey = true;
		_wantValue = false;
		_wantComma = false;
		_wantSemicolon = false;

		_pos++;
		return nullptr;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpb $0x0, 0x12e8(%rsi)
jne 0x2a6e7
movq %rsi, %r14
cmpb $0x0, 0x12eb(%rsi)
jne 0x2a6e7
cmpb $0x1, 0x12ea(%r14)
je 0x2a6e7
movq %rdi, %rbx
movl $0x10, %edi
callq 0x13290
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x10(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x27a1a
movq -0x8(%r15), %rdi
callq 0x22724
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x2a671
movq 0xe96d(%rip), %rcx      # 0x38fd0
cmpb $0x0, (%rcx)
je 0x2a66d
incl 0x8(%rax)
jmp 0x2a671
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq 0x29a62
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2a692
callq 0x19f10
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2a6a1
callq 0x19f10
leaq 0x1278(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2b15a
movl $0x1, 0x12e8(%r14)
incq 0x12f0(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2a6d9
callq 0x19f10
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3598(%rip), %rsi      # 0x2dc9c
leaq 0x35c3(%rip), %rdx      # 0x2dcce
leaq 0x8(%rsp), %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0x33d9(%rip), %rsi      # 0x2daf8
leaq 0x356a(%rip), %rdx      # 0x2dc90
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x24, %ecx
callq 0x2bf1c
leaq 0xe631(%rip), %rax      # 0x38d70
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe609(%rip), %rsi      # 0x38d58
leaq -0x105b8(%rip), %rdx    # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2a7a3
callq 0x19f10
jmp 0x2a7a3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2a78c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x2a796
jmp 0x2a7b2
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
jmp 0x2a7b2
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2a7b2
callq 0x19f10
movq %r14, %rdi
callq 0x13430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::exitObject()
JsonPtr exitObject()
	{
		if (_wantSemicolon || _wantValue || _nodeStack.empty() || _nodeStack.top()->type() != Json::JSON_Object)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, '}' at improper place.");

		_pos++;
		return finishNode();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x12eb(%rsi)
jne 0x2a828
cmpb $0x0, 0x12e9(%rsi)
jne 0x2a828
movq 0x12a8(%rsi), %rax
cmpq 0x1288(%rsi), %rax
je 0x2a828
movq %rdi, %rbx
cmpq 0x12b0(%rsi), %rax
jne 0x2a802
movq 0x12c0(%rsi), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x10(%rax), %rax
cmpl $0x0, (%rax)
jne 0x2a828
incq 0x12f0(%rsi)
movq %rbx, %rdi
callq 0x2b3de
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3495(%rip), %rsi      # 0x2dcda
leaq 0x34c0(%rip), %rdx      # 0x2dd0c
leaq 0x8(%rsp), %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0x3298(%rip), %rsi      # 0x2daf8
leaq 0x3468(%rip), %rdx      # 0x2dccf
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x4d, %ecx
callq 0x2bf1c
leaq 0xe4f0(%rip), %rax      # 0x38d70
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe4c8(%rip), %rsi      # 0x38d58
leaq -0x106f9(%rip), %rdx    # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2a8b9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x2a8c3
jmp 0x2a8cb
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
movq %r14, %rdi
callq 0x13430
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::enterArray()
JsonPtr enterArray()
	{
		if (_wantKey || _wantSemicolon || _wantComma)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, '[' at improper place.");

		JsonPtr node(new Json());
		node->setArray();
		insertNode(node);
		_nodeStack.push(node);

		_wantKey = false;
		_wantValue = false;
		_wantComma = false;
		_wantSemicolon = false;

		_pos++;
		return nullptr;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpb $0x0, 0x12e8(%rsi)
jne 0x2a9e5
movq %rsi, %r14
cmpb $0x0, 0x12eb(%rsi)
jne 0x2a9e5
cmpb $0x1, 0x12ea(%r14)
je 0x2a9e5
movq %rdi, %rbx
movl $0x10, %edi
callq 0x13290
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x10(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x27a1a
movq -0x8(%r15), %rdi
callq 0x22bde
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x2a96f
movq 0xe66f(%rip), %rcx      # 0x38fd0
cmpb $0x0, (%rcx)
je 0x2a96b
incl 0x8(%rax)
jmp 0x2a96f
lock
incl 0x8(%rax)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
callq 0x29a62
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2a990
callq 0x19f10
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2a99f
callq 0x19f10
leaq 0x1278(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2b15a
movl $0x0, 0x12e8(%r14)
incq 0x12f0(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2a9d7
callq 0x19f10
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3316(%rip), %rsi      # 0x2dd18
leaq 0x3341(%rip), %rdx      # 0x2dd4a
leaq 0x8(%rsp), %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0x30db(%rip), %rsi      # 0x2daf8
leaq 0x32e9(%rip), %rdx      # 0x2dd0d
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x56, %ecx
callq 0x2bf1c
leaq 0xe333(%rip), %rax      # 0x38d70
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe30b(%rip), %rsi      # 0x38d58
leaq -0x108b6(%rip), %rdx    # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2aaa1
callq 0x19f10
jmp 0x2aaa1
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2aa8a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x2aa94
jmp 0x2aab0
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
jmp 0x2aab0
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2aab0
callq 0x19f10
movq %r14, %rdi
callq 0x13430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::exitArray()
JsonPtr exitArray()
	{
		if (_wantSemicolon || _wantValue || _nodeStack.empty() || _nodeStack.top()->type() != Json::JSON_Array)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, ']' at improper place.");

		_pos++;
		return finishNode();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x12eb(%rsi)
jne 0x2ab26
cmpb $0x0, 0x12e9(%rsi)
jne 0x2ab26
movq 0x12a8(%rsi), %rax
cmpq 0x1288(%rsi), %rax
je 0x2ab26
movq %rdi, %rbx
cmpq 0x12b0(%rsi), %rax
jne 0x2ab00
movq 0x12c0(%rsi), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x10(%rax), %rax
cmpl $0x1, (%rax)
jne 0x2ab26
incq 0x12f0(%rsi)
movq %rbx, %rdi
callq 0x2b3de
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3212(%rip), %rsi      # 0x2dd55
leaq 0x323d(%rip), %rdx      # 0x2dd87
leaq 0x8(%rsp), %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0x2f9a(%rip), %rsi      # 0x2daf8
leaq 0x31e6(%rip), %rdx      # 0x2dd4b
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x69, %ecx
callq 0x2bf1c
leaq 0xe1f2(%rip), %rax      # 0x38d70
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe1ca(%rip), %rsi      # 0x38d58
leaq -0x109f7(%rip), %rdx    # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2abb7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x2abc1
jmp 0x2abc9
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
movq %r14, %rdi
callq 0x13430
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::processComma()
JsonPtr processComma()
	{
		if (_wantComma == false)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, ',' at error position.");

		_wantComma = false;
		if (_nodeStack.top()->type() == Json::JSON_Object)
			_wantKey = true;

		_pos++;
		return nullptr;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x12ea(%rsi)
je 0x2ac37
movb $0x0, 0x12ea(%rsi)
movq 0x12a8(%rsi), %rax
cmpq 0x12b0(%rsi), %rax
jne 0x2ac0c
movq 0x12c0(%rsi), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x10(%rax), %rax
cmpl $0x0, (%rax)
jne 0x2ac1c
movb $0x1, 0x12e8(%rsi)
incq 0x12f0(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3141(%rip), %rsi      # 0x2dd95
leaq 0x316c(%rip), %rdx      # 0x2ddc7
leaq 0x8(%rsp), %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0x2e89(%rip), %rsi      # 0x2daf8
leaq 0x3112(%rip), %rdx      # 0x2dd88
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x16d, %ecx            # imm = 0x16D
callq 0x2bf1c
leaq 0xe0e1(%rip), %rax      # 0x38d70
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe0b9(%rip), %rsi      # 0x38d58
leaq -0x10b08(%rip), %rdx    # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2acc8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x2acd2
jmp 0x2acda
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
movq %r14, %rdi
callq 0x13430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::processSemicolon()
JsonPtr processSemicolon()
	{
		if (_wantSemicolon == false)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, ':' at error position.");

		_wantSemicolon = false;
		_wantValue = true;
		_pos++;
		return nullptr;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, 0x12eb(%rsi)
je 0x2ad1e
movb $0x0, 0x12eb(%rsi)
movb $0x1, 0x12e9(%rsi)
incq 0x12f0(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x309e(%rip), %rsi      # 0x2ddd9
leaq 0x30c9(%rip), %rdx      # 0x2de0b
leaq 0x8(%rsp), %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0x2da2(%rip), %rsi      # 0x2daf8
leaq 0x306b(%rip), %rdx      # 0x2ddc8
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x17a, %ecx            # imm = 0x17A
callq 0x2bf1c
leaq 0xdffa(%rip), %rax      # 0x38d70
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xdfd2(%rip), %rsi      # 0x38d58
leaq -0x10bef(%rip), %rdx    # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2adaf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x2adb9
jmp 0x2adc1
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
movq %r14, %rdi
callq 0x13430
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::processString()
JsonPtr processString()
	{
		if(_wantComma || _wantSemicolon)
				throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error.");

		std::string str = fetchString();
		
		if (_wantKey)
		{
			fillKey(str);
			return nullptr;
		}
		else
		{
			JsonPtr node(new Json(str));
			return insertNode(node);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpb $0x0, 0x12ea(%rsi)
jne 0x2aee2
movq %rsi, %r14
cmpb $0x1, 0x12eb(%rsi)
je 0x2aee2
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2b51a
cmpb $0x1, 0x12e8(%r14)
jne 0x2ae32
leaq 0x12c8(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x131d0
movl $0x1000000, 0x12e8(%r14) # imm = 0x1000000
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x2aeb9
movl $0x10, %edi
callq 0x13290
movq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x27840
leaq 0x40(%rsp), %rdi
movq %r15, -0x8(%rdi)
movq %r15, %rsi
callq 0x27a1a
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x2ae8b
movq 0xe153(%rip), %rcx      # 0x38fd0
cmpb $0x0, (%rcx)
je 0x2ae87
incl 0x8(%rax)
jmp 0x2ae8b
lock
incl 0x8(%rax)
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29a62
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2aeaa
callq 0x19f10
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2aeb9
callq 0x19f10
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2aed4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2c1a(%rip), %rsi      # 0x2db19
leaq 0x2c2e(%rip), %rdx      # 0x2db34
leaq 0x8(%rsp), %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0x2bde(%rip), %rsi      # 0x2daf8
leaq 0x2eeb(%rip), %rdx      # 0x2de0c
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movl $0x15a, %ecx            # imm = 0x15A
callq 0x2bf1c
leaq 0xde36(%rip), %rax      # 0x38d70
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xde0e(%rip), %rsi      # 0x38d58
leaq -0x10db3(%rip), %rdx    # 0x1a19e
movq %r14, %rdi
callq 0x13410
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2af6b
callq 0x19f10
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2af91
callq 0x19f10
jmp 0x2af91
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x132a0
jmp 0x2af91
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2afda
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
jmp 0x2afda
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2afc8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x2afd2
jmp 0x2afda
movq %rax, %rbx
movq %r14, %rdi
callq 0x131e0
movq %rbx, %rdi
callq 0x13430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::finishNode()
JsonPtr finishNode()
	{
		if (_nodeStack.size() == 1)
		{
			JsonPtr root = _nodeStack.top();
			_nodeStack.pop();
			return root;
		}
		else
		{
			_nodeStack.pop();
			
			_wantKey = false;
			_wantValue = false;
			_wantComma = true;
			_wantSemicolon = false;
		}
		
		return nullptr;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1278(%rsi), %rdi
movq 0x12c0(%rsi), %rax
movq %rax, %rsi
subq 0x12a0(%r14), %rsi
shrq $0x3, %rsi
cmpq $0x1, %rax
adcq $-0x1, %rsi
shlq $0x5, %rsi
movq 0x1298(%r14), %r8
movq 0x12a8(%r14), %rcx
movq 0x12b0(%r14), %rdx
movq %rcx, %r9
subq %rdx, %r9
sarq $0x4, %r9
subq 0x1288(%r14), %r8
sarq $0x4, %r8
addq %r9, %r8
addq %rsi, %r8
cmpq $0x1, %r8
jne 0x2b479
cmpq %rdx, %rcx
jne 0x2b454
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rax), %rcx
movq -0x10(%rcx), %rax
movq %rax, (%rbx)
movq -0x8(%rcx), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2b495
movq 0xdb61(%rip), %rcx      # 0x38fd0
cmpb $0x0, (%rcx)
je 0x2b491
incl 0x8(%rax)
jmp 0x2b495
callq 0x2b4a6
movl $0x10000, 0x12e8(%r14) # imm = 0x10000
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x2b49a
lock
incl 0x8(%rax)
callq 0x2b4a6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::fetchString[abi:cxx11]()
std::string fetchString()
	{
		_pos++;
		char *_start = _pos;

		while (true)
		{
			if (*_pos == 0)
				throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, uncompleted string.");

			else if (*_pos == '\\')
			{
				_outStringStream.write(_start, _pos - _start);
				processSlash();
				_start = _pos;
			}
			else if (*_pos == '"')
			{
				if (_outStringStream.tellp() == 0)
				{
					std::string str(_start, _pos - _start);
					_pos++;
					return str;
				}
				else
				{
					_outStringStream.write(_start, _pos - _start);
					std::string str = _outStringStream.str();
					_outStringStream.str("");
					_pos++;
					return str;
				}
			}
			else
				_pos++;
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x12f0(%rsi), %r15
incq %r15
movq %r15, 0x12f0(%rsi)
leaq 0x1100(%rsi), %r12
xorl %edx, %edx
movzbl (%r15,%rdx), %eax
cmpl $0x22, %eax
je 0x2b58c
cmpl $0x5c, %eax
je 0x2b570
testl %eax, %eax
je 0x2b62b
leaq (%r15,%rdx), %rax
incq %rax
movq %rax, 0x12f0(%r14)
incq %rdx
jmp 0x2b546
movq %r12, %rdi
movq %r15, %rsi
callq 0x13330
movq %r14, %rdi
callq 0x2b708
movq 0x12f0(%r14), %r15
jmp 0x2b544
movq %r12, %rdi
callq 0x13230
movq 0x12f0(%r14), %rdx
subq %r15, %rdx
testq %rax, %rax
je 0x2b5ff
movq %r12, %rdi
movq %r15, %rsi
callq 0x13330
leaq 0x1108(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x133b0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1aa1(%rip), %rdx      # 0x2d072
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x19f80
movq %rsp, %rsi
movq %r15, %rdi
callq 0x13370
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2b614
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x132a0
jmp 0x2b614
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %r15, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19f80
incq 0x12f0(%r14)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x27de(%rip), %rsi      # 0x2de26
leaq 0x2806(%rip), %rdx      # 0x2de55
movq %rsp, %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0x2497(%rip), %rsi      # 0x2daf8
leaq 0x27b2(%rip), %rdx      # 0x2de1a
movq %rsp, %r8
movq %rbx, %rdi
movl $0x11f, %ecx            # imm = 0x11F
callq 0x2bf1c
leaq 0xd6f1(%rip), %rax      # 0x38d70
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd6c9(%rip), %rsi      # 0x38d58
leaq -0x114f8(%rip), %rdx    # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2b6bc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x132a0
jmp 0x2b6bc
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x2b700
movq (%rbx), %rsi
incq %rsi
callq 0x132a0
jmp 0x2b700
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2b6ee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x2b6f8
jmp 0x2b700
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
movq %r14, %rdi
callq 0x13430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::parseUTF16Char()
uint16_t parseUTF16Char()
	{
		uint16_t utf16Char = 0;
		for (int i = 0; i < 4; i++)
		{
			char c = *(_pos + i);

			if (c <= '9' && c >= '0')
				c -= '0';
			else if (c <= 'f' && c>= 'a')
			{
				c -= 'a';
				c += 10;
			}
			else if (c <= 'F' && c>= 'A')
			{
				c -= 'A';
				c += 10;
			}
			else
				throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, uncompleted string.");

			utf16Char <<= 4;
			utf16Char += (uint16_t)c;
		}

		return utf16Char;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x12f0(%rdi), %rcx
xorl %edx, %edx
xorl %eax, %eax
movb (%rcx,%rdx), %sil
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
jb 0x2bb90
leal -0x61(%rsi), %edi
cmpb $0x5, %dil
ja 0x2bb81
addb $-0x57, %sil
jmp 0x2bb8e
leal -0x41(%rsi), %edi
cmpb $0x5, %dil
ja 0x2bbaf
addb $-0x37, %sil
movl %esi, %edi
shll $0x4, %eax
movzbl %dil, %esi
addl %eax, %esi
movl %esi, %eax
incq %rdx
cmpq $0x4, %rdx
jne 0x2bb65
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x13110
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x225a(%rip), %rsi      # 0x2de26
leaq 0x2282(%rip), %rdx      # 0x2de55
leaq 0x8(%rsp), %rdi
callq 0x19f80
movb $0x1, %bpl
leaq 0x1f11(%rip), %rsi      # 0x2daf8
leaq 0x236b(%rip), %rdx      # 0x2df59
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0xd1, %ecx
callq 0x2bf1c
leaq 0xd169(%rip), %rax      # 0x38d70
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd141(%rip), %rsi      # 0x38d58
leaq -0x11a80(%rip), %rdx    # 0x1a19e
movq %rbx, %rdi
callq 0x13410
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2bc40
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x132a0
testb %bpl, %bpl
jne 0x2bc4a
jmp 0x2bc52
movq %rax, %r14
movq %rbx, %rdi
callq 0x131e0
movq %r14, %rdi
callq 0x13430
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::UTF16ToUTF8(unsigned short)
void UTF16ToUTF8(uint16_t utf16Char)
	{
		const uint8_t utf82 = 0xc0;	//-- 1100 0000
		const uint8_t utf83 = 0xe0;	//-- 1110 0000
		const uint8_t low6BitsMask = 0x3F;	//-- 0011 1111

		if (utf16Char <= 0x7F)
		{
			_outStringStream<<(char)utf16Char;
		}
		else if (utf16Char <= 0x7FF)
		{
			char a = utf82 | (utf16Char >> 6);
			char b = 0x80 | (utf16Char & low6BitsMask);

			_outStringStream << a << b;
		}
		else
		{
			char a = utf83 | (utf16Char >> 12);
			char b = 0x80 | ((utf16Char >> 6) & low6BitsMask);
			char c = 0x80 | (utf16Char & low6BitsMask);

			_outStringStream << a << b << c;
		}
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpw $0x7f, %bx
ja 0x2bc7d
addq $0x1100, %rdi           # imm = 0x1100
leaq 0x2(%rsp), %rsi
movb %bl, (%rsi)
movl $0x1, %edx
jmp 0x2bd08
movzwl %bx, %ebp
cmpl $0x7ff, %ebp            # imm = 0x7FF
ja 0x2bcb4
movl %ebx, %eax
shrl $0x6, %eax
orb $-0x40, %al
andb $0x3f, %bl
orb $-0x80, %bl
addq $0x1100, %rdi           # imm = 0x1100
leaq 0x3(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
callq 0x132f0
leaq 0x4(%rsp), %rsi
jmp 0x2bcfe
movl %ebp, %eax
shrl $0xc, %eax
orb $-0x20, %al
shrl $0x6, %ebp
andb $0x3f, %bpl
orb $-0x80, %bpl
andb $0x3f, %bl
orb $-0x80, %bl
addq $0x1100, %rdi           # imm = 0x1100
leaq 0x5(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
callq 0x132f0
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x132f0
leaq 0x7(%rsp), %rsi
movb %bl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x132f0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day03/ex03/NinjaTrap.cpp
// Function: NinjaTrap::NinjaTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
NinjaTrap::NinjaTrap(std::string name) : ClapTrap(name)
{
	this->hitPoints = 60;
	this->maxHit = 60;
	this->energyPoints = 120;
	this->maxEnergyPoints = 120;
	this->meleeAttackDamage = 60;
	this->rangedAttackDamage = 5;
	this->armorDamageReduction = 0;
	this->level = 1.0;
	std::cout << this->name << ": IIAAAA ! I'm a ninja !" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2910
movq %rbx, %rdi
movq %r14, %rsi
callq 0x236c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f91
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2100
leaq 0x4da0(%rip), %rax      # 0x7d38
movq %rax, (%rbx)
movaps 0x228e(%rip), %xmm0     # 0x5230
movups %xmm0, 0x8(%rbx)
movabsq $0x50000003c, %rax      # imm = 0x50000003C
movq %rax, 0x40(%rbx)
movl $0x0, 0x48(%rbx)
movl $0x3f800000, 0x18(%rbx) # imm = 0x3F800000
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq 0x5007(%rip), %rdi      # 0x7fd8
callq 0x2110
movq %rax, %r14
leaq 0x2260(%rip), %rsi      # 0x5240
movl $0x18, %edx
movq %rax, %rdi
callq 0x2110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2090
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3044
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2100
jmp 0x3044
movq %rax, %r14
movq %rbx, %rdi
callq 0x2588
movq %r14, %rdi
callq 0x2150
// File: /workspace/github_cpp_makefile_star2_O3/ian-howell[P]configparser/src/config_parser.cpp
// Function: Config::get_section(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::map<std::string, std::string> Config::get_section(const std::string& section_name)
{
    if (sections.count(section_name) == 0)
    {
        std::string error = "No such key: `" + section_name + "`";
        throw std::out_of_range(error);
    }
    return sections.at(section_name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x3af6
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x2f5f
movq %r15, %rdi
movq %r14, %rsi
callq 0x34f6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3764
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x20d2(%rip), %rsi      # 0x5038
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x346d
leaq 0x2123(%rip), %rsi      # 0x50a0
movq %rbx, %rdi
callq 0x22d0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x2fa6
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x2fb2
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fe5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2170
movl $0x10, %edi
callq 0x20f0
movq %rax, %r14
movq %rsp, %rsi
movq %rax, %rdi
callq 0x2220
movq 0x4fcc(%rip), %rsi      # 0x7fd0
movq 0x4fbd(%rip), %rdx      # 0x7fc8
movq %r14, %rdi
callq 0x2290
movq %rax, %rbx
jmp 0x3023
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3051
movq 0x10(%rsp), %rsi
jmp 0x3049
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3051
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ian-howell[P]configparser/src/config_parser.cpp
// Function: Config::dump(_IO_FILE*)
void Config::dump(FILE* log_file)
{
    // Set up iterators
    std::map<std::string, std::string>::iterator itr1;
    std::map<std::string, std::map<std::string, std::string> >::iterator itr2;
    for(itr2 = sections.begin(); itr2 != sections.end(); itr2++)
    {
        fprintf(log_file, "[%s]\n", itr2->first.c_str());
        for(itr1 = itr2->second.begin(); itr1 != itr2->second.end(); itr1++)
        {
            fprintf(log_file, "%s=%s\n", itr1->first.c_str(), itr1->second.c_str());
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x30e4
movq %rsi, %rbx
leaq 0x1fc0(%rip), %r13      # 0x504d
movq 0x20(%r15), %rdx
movq %rbx, %rdi
leaq 0x1fac(%rip), %rsi      # 0x5047
xorl %eax, %eax
callq 0x21f0
movq 0x58(%r15), %rbp
leaq 0x48(%r15), %r12
cmpq %r12, %rbp
je 0x30d4
movq 0x20(%rbp), %rdx
movq 0x40(%rbp), %rcx
movq %rbx, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x21f0
movq %rbp, %rdi
callq 0x2100
movq %rax, %rbp
cmpq %r12, %rax
jne 0x30af
movq %r15, %rdi
callq 0x2100
movq %rax, %r15
cmpq %r14, %rax
jne 0x308d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ian-howell[P]configparser/src/main.cpp
// Function: main
int main()
{
    Config config("example1.ini");

    for (const auto& it : config["Example"])
    {
        std::cout << "`" << it.first << "` -> `" << it.second << "`\n";
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xe75(%rip), %rsi       # 0x50f6
leaq 0xe7a(%rip), %rdx       # 0x5102
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x3a60
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
callq 0x242c
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x42b9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xe3a(%rip), %rsi       # 0x5103
leaq 0xe3a(%rip), %rdx       # 0x510a
leaq 0x8(%rsp), %rdi
callq 0x3a60
leaq 0x48(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x305a
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4305
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
leaq 0x50(%rsp), %r15
movq 0x10(%r15), %rbx
cmpq %r15, %rbx
je 0x438f
movq 0x3ca6(%rip), %r14      # 0x7fc0
leaq 0xdea(%rip), %r12       # 0x510b
leaq 0xdea(%rip), %r13       # 0x5112
movl $0x1, %edx
movq %r14, %rdi
leaq 0xd69(%rip), %rsi       # 0x50a0
callq 0x21a0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x21a0
movq %rax, %rbp
movl $0x6, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21a0
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
movq %rbp, %rdi
callq 0x21a0
movl $0x2, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2100
movq %rax, %rbx
cmpq %r15, %rax
jne 0x4328
leaq 0x48(%rsp), %rdi
callq 0x36d2
leaq 0x78(%rsp), %rdi
callq 0x364e
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4401
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x4401
movq %rax, %rbx
jmp 0x4401
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x440b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x440b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x36d2
leaq 0x78(%rsp), %rdi
callq 0x364e
movq %rbx, %rdi
callq 0x22a0