LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<int, std::less<int>, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<int, std::less<int>, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool add(const std::string& path, const std::set<T, Compare, Alloc>& collections, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setArray(collections);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x58(%rsp), %rcx
leaq 0x48(%rsp), %rdi
movl $0x1, %r8d
callq 0x64fd0
leaq 0x48(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
callq 0x63de0
cmpl $0x8, %eax
jne 0x4de7d
leaq 0x48(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0x49910
jmp 0x4de57
leaq 0x48(%rsp), %rdi
callq 0x5eb60
movb $0x1, %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4df3e
movb $0x1, 0x16(%rsp)
movl $0x60, %edi
callq 0x40120
movq %rax, (%rsp)
leaq 0x17(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x40480
movq 0x8(%rsp), %rdx
leaq 0x2853a(%rip), %rsi     # 0x763e5
leaq 0x18(%rsp), %rdi
callq 0x47fc0
jmp 0x4deb7
movq (%rsp), %rdi
leaq 0x284df(%rip), %rsi     # 0x763a1
leaq 0x28518(%rip), %rdx     # 0x763e1
movl $0x26f, %ecx            # imm = 0x26F
leaq 0x18(%rsp), %r8
callq 0x63df0
jmp 0x4deda
movq (%rsp), %rdi
movb $0x0, 0x16(%rsp)
leaq 0x3be36(%rip), %rsi     # 0x89d20
leaq 0x15f5f(%rip), %rdx     # 0x63e50
callq 0x40450
jmp 0x4df52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4df20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x40170
leaq 0x17(%rsp), %rdi
callq 0x40310
testb $0x1, 0x16(%rsp)
jne 0x4df33
jmp 0x4df3c
movq (%rsp), %rdi
callq 0x401f0
jmp 0x4df3e
leaq 0x48(%rsp), %rdi
callq 0x5eb60
movq 0x40(%rsp), %rdi
callq 0x40470
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool add(const std::string& path, const std::unordered_set<Key, Hash, Pred, Alloc>& collections, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setArray(collections);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x58(%rsp), %rcx
leaq 0x48(%rsp), %rdi
movl $0x1, %r8d
callq 0x64fd0
leaq 0x48(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
callq 0x63de0
cmpl $0x8, %eax
jne 0x4dfed
leaq 0x48(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0x499a0
jmp 0x4dfc7
leaq 0x48(%rsp), %rdi
callq 0x5eb60
movb $0x1, %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4e0ae
movb $0x1, 0x16(%rsp)
movl $0x60, %edi
callq 0x40120
movq %rax, (%rsp)
leaq 0x17(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x40480
movq 0x8(%rsp), %rdx
leaq 0x283ca(%rip), %rsi     # 0x763e5
leaq 0x18(%rsp), %rdi
callq 0x47fc0
jmp 0x4e027
movq (%rsp), %rdi
leaq 0x2836f(%rip), %rsi     # 0x763a1
leaq 0x283a8(%rip), %rdx     # 0x763e1
movl $0x27c, %ecx            # imm = 0x27C
leaq 0x18(%rsp), %r8
callq 0x63df0
jmp 0x4e04a
movq (%rsp), %rdi
movb $0x0, 0x16(%rsp)
leaq 0x3bcc6(%rip), %rsi     # 0x89d20
leaq 0x15def(%rip), %rdx     # 0x63e50
callq 0x40450
jmp 0x4e0c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4e090
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x40170
leaq 0x17(%rsp), %rdi
callq 0x40310
testb $0x1, 0x16(%rsp)
jne 0x4e0a3
jmp 0x4e0ac
movq (%rsp), %rdi
callq 0x401f0
jmp 0x4e0ae
leaq 0x48(%rsp), %rdi
callq 0x5eb60
movq 0x40(%rsp), %rdi
callq 0x40470
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<bool, 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, bool>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, 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, bool>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool add(const std::string& path, const std::map<std::string, T, Compare, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setDict(theMap);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x58(%rsp), %rcx
leaq 0x48(%rsp), %rdi
movl $0x1, %r8d
callq 0x64fd0
leaq 0x48(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
callq 0x63de0
cmpl $0x8, %eax
jne 0x4e15d
leaq 0x48(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0x49a30
jmp 0x4e137
leaq 0x48(%rsp), %rdi
callq 0x5eb60
movb $0x1, %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4e21e
movb $0x1, 0x16(%rsp)
movl $0x60, %edi
callq 0x40120
movq %rax, (%rsp)
leaq 0x17(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x40480
movq 0x8(%rsp), %rdx
leaq 0x2825a(%rip), %rsi     # 0x763e5
leaq 0x18(%rsp), %rdi
callq 0x47fc0
jmp 0x4e197
movq (%rsp), %rdi
leaq 0x281ff(%rip), %rsi     # 0x763a1
leaq 0x28238(%rip), %rdx     # 0x763e1
movl $0x289, %ecx            # imm = 0x289
leaq 0x18(%rsp), %r8
callq 0x63df0
jmp 0x4e1ba
movq (%rsp), %rdi
movb $0x0, 0x16(%rsp)
leaq 0x3bb56(%rip), %rsi     # 0x89d20
leaq 0x15c7f(%rip), %rdx     # 0x63e50
callq 0x40450
jmp 0x4e232
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4e200
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x40170
leaq 0x17(%rsp), %rdi
callq 0x40310
testb $0x1, 0x16(%rsp)
jne 0x4e213
jmp 0x4e21c
movq (%rsp), %rdi
callq 0x401f0
jmp 0x4e21e
leaq 0x48(%rsp), %rdi
callq 0x5eb60
movq 0x40(%rsp), %rdi
callq 0x40470
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<int, 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, int>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, 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, int>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool add(const std::string& path, const std::unordered_map<std::string, T, Hash, Pred, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setDict(theMap);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x58(%rsp), %rcx
leaq 0x48(%rsp), %rdi
movl $0x1, %r8d
callq 0x64fd0
leaq 0x48(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
callq 0x63de0
cmpl $0x8, %eax
jne 0x4e71d
leaq 0x48(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
movq 0x60(%rsp), %rsi
callq 0x49ce0
jmp 0x4e6f7
leaq 0x48(%rsp), %rdi
callq 0x5eb60
movb $0x1, %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4e7de
movb $0x1, 0x16(%rsp)
movl $0x60, %edi
callq 0x40120
movq %rax, (%rsp)
leaq 0x17(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x40480
movq 0x8(%rsp), %rdx
leaq 0x27c9a(%rip), %rsi     # 0x763e5
leaq 0x18(%rsp), %rdi
callq 0x47fc0
jmp 0x4e757
movq (%rsp), %rdi
leaq 0x27c3f(%rip), %rsi     # 0x763a1
leaq 0x27c78(%rip), %rdx     # 0x763e1
movl $0x296, %ecx            # imm = 0x296
leaq 0x18(%rsp), %r8
callq 0x63df0
jmp 0x4e77a
movq (%rsp), %rdi
movb $0x0, 0x16(%rsp)
leaq 0x3b596(%rip), %rsi     # 0x89d20
leaq 0x156bf(%rip), %rdx     # 0x63e50
callq 0x40450
jmp 0x4e7f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4e7c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x40170
leaq 0x17(%rsp), %rdi
callq 0x40310
testb $0x1, 0x16(%rsp)
jne 0x4e7d3
jmp 0x4e7dc
movq (%rsp), %rdi
callq 0x401f0
jmp 0x4e7de
leaq 0x48(%rsp), %rdi
callq 0x5eb60
movq 0x40(%rsp), %rdi
callq 0x40470
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<int, 4ul>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::array<int, 4ul> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::array<T, N>& arr, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(arr))
			return;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %r8d
callq 0x64fd0
movq 0x18(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0x4b1c0
movb %al, 0x25(%rsp)
jmp 0x4ebe2
movb 0x25(%rsp), %al
testb $0x1, %al
jne 0x4ebec
jmp 0x4ec11
leaq 0x58(%rsp), %rdi
callq 0x5eb60
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4ecd6
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x40120
movq %rax, 0x8(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x40480
movq 0x10(%rsp), %rdx
leaq 0x27787(%rip), %rsi     # 0x763c7
leaq 0x28(%rsp), %rdi
callq 0x47fc0
jmp 0x4ec4c
movq 0x8(%rsp), %rdi
leaq 0x27749(%rip), %rsi     # 0x763a1
leaq 0x2779f(%rip), %rdx     # 0x763fe
movl $0x2af, %ecx            # imm = 0x2AF
leaq 0x28(%rsp), %r8
callq 0x63ca0
jmp 0x4ec70
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x3b037(%rip), %rsi     # 0x89cb8
leaq 0x15078(%rip), %rdx     # 0x63d00
callq 0x40450
jmp 0x4ecea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4ecb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x40170
leaq 0x27(%rsp), %rdi
callq 0x40310
testb $0x1, 0x26(%rsp)
jne 0x4ecca
jmp 0x4ecd4
movq 0x8(%rsp), %rdi
callq 0x401f0
jmp 0x4ecd6
leaq 0x58(%rsp), %rdi
callq 0x5eb60
movq 0x50(%rsp), %rdi
callq 0x40470
nopw (%rax,%rax)
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<int, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::deque<int, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::deque<T, Alloc>& deq, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(deq))
			return;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %r8d
callq 0x64fd0
movq 0x18(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0x4b260
movb %al, 0x25(%rsp)
jmp 0x4ed52
movb 0x25(%rsp), %al
testb $0x1, %al
jne 0x4ed5c
jmp 0x4ed81
leaq 0x58(%rsp), %rdi
callq 0x5eb60
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4ee46
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x40120
movq %rax, 0x8(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x40480
movq 0x10(%rsp), %rdx
leaq 0x27617(%rip), %rsi     # 0x763c7
leaq 0x28(%rsp), %rdi
callq 0x47fc0
jmp 0x4edbc
movq 0x8(%rsp), %rdi
leaq 0x275d9(%rip), %rsi     # 0x763a1
leaq 0x2762f(%rip), %rdx     # 0x763fe
movl $0x2b9, %ecx            # imm = 0x2B9
leaq 0x28(%rsp), %r8
callq 0x63ca0
jmp 0x4ede0
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x3aec7(%rip), %rsi     # 0x89cb8
leaq 0x14f08(%rip), %rdx     # 0x63d00
callq 0x40450
jmp 0x4ee5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4ee27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x40170
leaq 0x27(%rsp), %rdi
callq 0x40310
testb $0x1, 0x26(%rsp)
jne 0x4ee3a
jmp 0x4ee44
movq 0x8(%rsp), %rdi
callq 0x401f0
jmp 0x4ee46
leaq 0x58(%rsp), %rdi
callq 0x5eb60
movq 0x50(%rsp), %rdi
callq 0x40470
nopw (%rax,%rax)
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<std::vector, bool, std::allocator<bool>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<bool, std::allocator<bool>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const Container<T, Alloc>& container, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(container))
			return;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %r8d
callq 0x64fd0
movq 0x18(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0x4b300
movb %al, 0x25(%rsp)
jmp 0x4eec2
movb 0x25(%rsp), %al
testb $0x1, %al
jne 0x4eecc
jmp 0x4eef1
leaq 0x58(%rsp), %rdi
callq 0x5eb60
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4efb6
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x40120
movq %rax, 0x8(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x40480
movq 0x10(%rsp), %rdx
leaq 0x274a7(%rip), %rsi     # 0x763c7
leaq 0x28(%rsp), %rdi
callq 0x47fc0
jmp 0x4ef2c
movq 0x8(%rsp), %rdi
leaq 0x27469(%rip), %rsi     # 0x763a1
leaq 0x274bf(%rip), %rdx     # 0x763fe
movl $0x2c5, %ecx            # imm = 0x2C5
leaq 0x28(%rsp), %r8
callq 0x63ca0
jmp 0x4ef50
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x3ad57(%rip), %rsi     # 0x89cb8
leaq 0x14d98(%rip), %rdx     # 0x63d00
callq 0x40450
jmp 0x4efca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4ef97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x40170
leaq 0x27(%rsp), %rdi
callq 0x40310
testb $0x1, 0x26(%rsp)
jne 0x4efaa
jmp 0x4efb4
movq 0x8(%rsp), %rdi
callq 0x401f0
jmp 0x4efb6
leaq 0x58(%rsp), %rdi
callq 0x5eb60
movq 0x50(%rsp), %rdi
callq 0x40470
nopw (%rax,%rax)
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<int, std::less<int>, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<int, std::less<int>, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::set<T, Compare, Alloc>& collections, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(collections))
			return;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %r8d
callq 0x64fd0
movq 0x18(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0x4b620
movb %al, 0x25(%rsp)
jmp 0x4f5f2
movb 0x25(%rsp), %al
testb $0x1, %al
jne 0x4f5fc
jmp 0x4f621
leaq 0x58(%rsp), %rdi
callq 0x5eb60
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4f6e6
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x40120
movq %rax, 0x8(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x40480
movq 0x10(%rsp), %rdx
leaq 0x26d77(%rip), %rsi     # 0x763c7
leaq 0x28(%rsp), %rdi
callq 0x47fc0
jmp 0x4f65c
movq 0x8(%rsp), %rdi
leaq 0x26d39(%rip), %rsi     # 0x763a1
leaq 0x26d8f(%rip), %rdx     # 0x763fe
movl $0x2cf, %ecx            # imm = 0x2CF
leaq 0x28(%rsp), %r8
callq 0x63ca0
jmp 0x4f680
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x3a627(%rip), %rsi     # 0x89cb8
leaq 0x14668(%rip), %rdx     # 0x63d00
callq 0x40450
jmp 0x4f6fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4f6c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x40170
leaq 0x27(%rsp), %rdi
callq 0x40310
testb $0x1, 0x26(%rsp)
jne 0x4f6da
jmp 0x4f6e4
movq 0x8(%rsp), %rdi
callq 0x401f0
jmp 0x4f6e6
leaq 0x58(%rsp), %rdi
callq 0x5eb60
movq 0x50(%rsp), %rdi
callq 0x40470
nopw (%rax,%rax)
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::unordered_set<Key, Hash, Pred, Alloc>& collections, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(collections))
			return;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %r8d
callq 0x64fd0
movq 0x18(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0x4b6c0
movb %al, 0x25(%rsp)
jmp 0x4f762
movb 0x25(%rsp), %al
testb $0x1, %al
jne 0x4f76c
jmp 0x4f791
leaq 0x58(%rsp), %rdi
callq 0x5eb60
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4f856
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x40120
movq %rax, 0x8(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x40480
movq 0x10(%rsp), %rdx
leaq 0x26c07(%rip), %rsi     # 0x763c7
leaq 0x28(%rsp), %rdi
callq 0x47fc0
jmp 0x4f7cc
movq 0x8(%rsp), %rdi
leaq 0x26bc9(%rip), %rsi     # 0x763a1
leaq 0x26c1f(%rip), %rdx     # 0x763fe
movl $0x2d9, %ecx            # imm = 0x2D9
leaq 0x28(%rsp), %r8
callq 0x63ca0
jmp 0x4f7f0
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x3a4b7(%rip), %rsi     # 0x89cb8
leaq 0x144f8(%rip), %rdx     # 0x63d00
callq 0x40450
jmp 0x4f86a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4f837
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x40170
leaq 0x27(%rsp), %rdi
callq 0x40310
testb $0x1, 0x26(%rsp)
jne 0x4f84a
jmp 0x4f854
movq 0x8(%rsp), %rdi
callq 0x401f0
jmp 0x4f856
leaq 0x58(%rsp), %rdi
callq 0x5eb60
movq 0x50(%rsp), %rdi
callq 0x40470
nopw (%rax,%rax)
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<bool, 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, bool>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, 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, bool>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::map<std::string, T, Compare, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(theMap))
			return;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %r8d
callq 0x64fd0
movq 0x18(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0x4b7a0
movb %al, 0x25(%rsp)
jmp 0x4f8d2
movb 0x25(%rsp), %al
testb $0x1, %al
jne 0x4f8dc
jmp 0x4f901
leaq 0x58(%rsp), %rdi
callq 0x5eb60
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4f9c6
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x40120
movq %rax, 0x8(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x40480
movq 0x10(%rsp), %rdx
leaq 0x26a97(%rip), %rsi     # 0x763c7
leaq 0x28(%rsp), %rdi
callq 0x47fc0
jmp 0x4f93c
movq 0x8(%rsp), %rdi
leaq 0x26a59(%rip), %rsi     # 0x763a1
leaq 0x26aaf(%rip), %rdx     # 0x763fe
movl $0x2e3, %ecx            # imm = 0x2E3
leaq 0x28(%rsp), %r8
callq 0x63ca0
jmp 0x4f960
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x3a347(%rip), %rsi     # 0x89cb8
leaq 0x14388(%rip), %rdx     # 0x63d00
callq 0x40450
jmp 0x4f9da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4f9a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x40170
leaq 0x27(%rsp), %rdi
callq 0x40310
testb $0x1, 0x26(%rsp)
jne 0x4f9ba
jmp 0x4f9c4
movq 0x8(%rsp), %rdi
callq 0x401f0
jmp 0x4f9c6
leaq 0x58(%rsp), %rdi
callq 0x5eb60
movq 0x50(%rsp), %rdi
callq 0x40470
nopw (%rax,%rax)
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<int, 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, int>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, 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, int>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::unordered_map<std::string, T, Hash, Pred, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(theMap))
			return;

		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Target node is not array.");
	}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x1, %r8d
callq 0x64fd0
movq 0x18(%rsp), %rdi
callq 0x63bd0
movq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0x4bb60
movb %al, 0x25(%rsp)
jmp 0x4fe92
movb 0x25(%rsp), %al
testb $0x1, %al
jne 0x4fe9c
jmp 0x4fec1
leaq 0x58(%rsp), %rdi
callq 0x5eb60
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4ff86
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x40120
movq %rax, 0x8(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x40480
movq 0x10(%rsp), %rdx
leaq 0x264d7(%rip), %rsi     # 0x763c7
leaq 0x28(%rsp), %rdi
callq 0x47fc0
jmp 0x4fefc
movq 0x8(%rsp), %rdi
leaq 0x26499(%rip), %rsi     # 0x763a1
leaq 0x264ef(%rip), %rdx     # 0x763fe
movl $0x2ed, %ecx            # imm = 0x2ED
leaq 0x28(%rsp), %r8
callq 0x63ca0
jmp 0x4ff20
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x39d87(%rip), %rsi     # 0x89cb8
leaq 0x13dc8(%rip), %rdx     # 0x63d00
callq 0x40450
jmp 0x4ff9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x4ff67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x40170
leaq 0x27(%rsp), %rdi
callq 0x40310
testb $0x1, 0x26(%rsp)
jne 0x4ff7a
jmp 0x4ff84
movq 0x8(%rsp), %rdi
callq 0x401f0
jmp 0x4ff86
leaq 0x58(%rsp), %rdi
callq 0x5eb60
movq 0x50(%rsp), %rdi
callq 0x40470
nopw (%rax,%rax)
// File: swxlion[P]swxJson/tests/../src/swxJson.h
// Function: bool swxJson::Json::addBasicValue<bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
inline bool addBasicValue(const std::string& key, TYPE value)
	{
		//JsonPtr node(new Json(value));
		JsonPtr node(new Json());
		(*node) = value;
		return addNode(key, node);
	}

// Assembly:
subq $0x88, %rsp
movb %dl, %al
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
andb $0x1, %al
movb %al, 0x77(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x10, %edi
callq 0x402a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x38(%rsp)
callq 0x48d30
jmp 0x62f95
movq 0x38(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x5eb00
movq 0x20(%rsp), %rdi
movzbl 0x77(%rsp), %eax
movl %eax, 0x2c(%rsp)
callq 0x63140
movl 0x2c(%rsp), %esi
movq %rax, %rdi
andl $0x1, %esi
callq 0x63170
jmp 0x62fcd
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x5eb30
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x659f0
movb %al, 0x1f(%rsp)
jmp 0x63005
leaq 0x40(%rsp), %rdi
callq 0x5eb60
leaq 0x60(%rsp), %rdi
callq 0x5eb60
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x10, %esi
callq 0x402b0
jmp 0x63078
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x6306e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5eb60
leaq 0x60(%rsp), %rdi
callq 0x5eb60
movq 0x58(%rsp), %rdi
callq 0x40470
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: akw0088[P]openssl/download.cpp
// Function: get_file(char*, unsigned int*)
char *get_file(char *filename, unsigned int *size)
{
	FILE	*file;
	char	*buffer;
	int	file_size, bytes_read;
	
	file = fopen(filename, "rb");
	if (file == NULL)
		return 0;
	fseek(file, 0, SEEK_END);
	file_size = ftell(file);
	fseek(file, 0, SEEK_SET);
	buffer = new char [file_size + 1];
	bytes_read = (int)fread(buffer, sizeof(char), file_size, file);
	if (bytes_read != file_size)
	{
		delete [] buffer;
		fclose(file);
		return 0;
	}
	fclose(file);
	buffer[file_size] = '\0';

	if (size != NULL)
	{
		*size = file_size;
	}

	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xced(%rip), %rsi       # 0x2038
callq 0x11b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1368
movq $0x0, -0x8(%rbp)
jmp 0x141f
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1190
movq -0x20(%rbp), %rdi
callq 0x1030
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1190
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1040
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x11e0
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0x13f2
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x13df
movq -0x38(%rbp), %rdi
callq 0x11c0
movq -0x20(%rbp), %rdi
callq 0x1170
movq $0x0, -0x8(%rbp)
jmp 0x141f
movq -0x20(%rbp), %rdi
callq 0x1170
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x18(%rbp)
je 0x1417
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: akw0088[P]openssl/download.cpp
// Function: StripChars(char const*, char*, char*)
void StripChars(const char *in, char *out, char *stripc)
{
    while (*in)
    {
    	bool flag = false;

	int length = strlen(stripc);
    	for(int i = 0; i < length; i++)
	{
		if (*in == stripc[i])
		{
			flag = true;
			break;
		}
	}

	if (flag)
	{
		in++;
		continue;
	}
        *out++ = *in++;
    }
    *out = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x19f5
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10e0
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x19ba
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x19ad
movb $0x1, -0x19(%rbp)
jmp 0x19ba
jmp 0x19af
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1988
testb $0x1, -0x19(%rbp)
je 0x19ce
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1964
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x1964
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/word_transform.cc
// Function: transform(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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>>>>> const&)
const string& transform(const string& s, const map<string, string>& m)
{
	// the actual map work; this part is the heart of the program
	auto map_it = m.find(s);
	// if this word is in the transformation map
	if (map_it != m.cend())
		return map_it->second; // use the replacement word
	else
		return s;              // otherwise return the original unchanged
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2f00
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2f60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2f30
testb $0x1, %al
jne 0x2711
jmp 0x2724
leaq -0x20(%rbp), %rdi
callq 0x2f90
addq $0x20, %rax
movq %rax, -0x8(%rbp)
jmp 0x272c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/word_transform.cc
// Function: main
int main(int argc, char **argv)
{
	// open and check both files
	if (argc != 3)
		throw runtime_error("wrong number of arguments");

	ifstream map_file(argv[1]); // open transformation file
	if (!map_file)              // check that open succeeded
		throw runtime_error("no transformation file");

	ifstream input(argv[2]);    // open file of text to transform
	if (!input)                 // check that open succeeded
		throw runtime_error("no input file");

	word_transform(map_file, input);

	return 0;  // exiting main will automatically close the files
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x2afb
movl $0x10, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x438(%rbp)
leaq 0x2586(%rip), %rsi      # 0x5043
callq 0x20b0
jmp 0x2ac4
movq -0x438(%rbp), %rdi
movq 0x551e(%rip), %rsi      # 0x7ff0
movq 0x54ef(%rip), %rdx      # 0x7fc8
callq 0x22b0
movq -0x438(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2160
jmp 0x2cbd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x228(%rbp), %rdi
movl $0x8, %edx
callq 0x22e0
movq -0x228(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x228(%rbp,%rax), %rdi
callq 0x20f0
movb %al, -0x439(%rbp)
jmp 0x2b34
movb -0x439(%rbp), %al
testb $0x1, %al
jne 0x2b40
jmp 0x2bb2
movl $0x10, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x448(%rbp)
leaq 0x24ff(%rip), %rsi      # 0x505d
callq 0x20b0
jmp 0x2b65
movq -0x448(%rbp), %rdi
movq 0x547d(%rip), %rsi      # 0x7ff0
movq 0x544e(%rip), %rdx      # 0x7fc8
callq 0x22b0
jmp 0x2cc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2cb1
movq -0x448(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2160
jmp 0x2cb1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x430(%rbp), %rdi
movl $0x8, %edx
callq 0x22e0
jmp 0x2bcd
movq -0x430(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x430(%rbp,%rax), %rdi
callq 0x20f0
movb %al, -0x449(%rbp)
jmp 0x2bed
movb -0x449(%rbp), %al
testb $0x1, %al
jne 0x2bf9
jmp 0x2c65
movl $0x10, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x458(%rbp)
leaq 0x245d(%rip), %rsi      # 0x5074
callq 0x20b0
jmp 0x2c1e
movq -0x458(%rbp), %rdi
movq 0x53c4(%rip), %rsi      # 0x7ff0
movq 0x5395(%rip), %rdx      # 0x7fc8
callq 0x22b0
jmp 0x2cc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2ca5
movq -0x458(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2160
jmp 0x2ca5
leaq -0x228(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x2740
jmp 0x2c7a
movl $0x0, -0x4(%rbp)
leaq -0x430(%rbp), %rdi
callq 0x2070
leaq -0x228(%rbp), %rdi
callq 0x2070
movl -0x4(%rbp), %eax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
leaq -0x430(%rbp), %rdi
callq 0x2070
leaq -0x228(%rbp), %rdi
callq 0x2070
movq -0x18(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_vectornorm.cpp
// Function: double norm<double>::norm_impl<1u>(exprtk::type_store<double>::type_view<double> const&, unsigned long, unsigned long)
inline T norm_impl(const vector_t& vector, const std::size_t r0, const std::size_t r1)
   {
      T sum = T(0);

      for (std::size_t i = r0; i <= r1; ++i)
      {
         sum += exprtk::details::numeric::fast_exp<T,Pow>::result(std::abs(vector[i]));
      }

      switch (Pow)
      {
         case 1  : return sum;
         case 2  : return exprtk::details::numeric::sqrt(sum);
         default : return exprtk::details::numeric::pow(sum, T(1) / Pow);
      }
   }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x123810
movq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x124b30
movsd (%rax), %xmm0
callq 0x124b10
callq 0x124b00
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1237cb
movsd 0x10(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/exprtk_vectornorm.cpp
// Function: norm<double>::norm_impl(exprtk::type_store<double>::type_view<double> const&, unsigned int, unsigned long, unsigned long)
inline T norm_impl(const vector_t& vector, unsigned int pow, const std::size_t r0, const std::size_t r1)
   {
      T sum = T(0);

      for (std::size_t i = r0; i <= r1; ++i)
      {
         sum += exprtk::details::numeric::pow(std::abs(vector[i]),T(pow));
      }

      return exprtk::details::numeric::pow(sum,T(1) / pow);
   }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x1249f7
movq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x124b30
movsd (%rax), %xmm0
callq 0x124b10
movl 0x24(%rsp), %eax
cvtsi2sd %rax, %xmm1
callq 0x124bf0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x1249ae
movsd 0x8(%rsp), %xmm0
movl 0x24(%rsp), %eax
cvtsi2sd %rax, %xmm2
movsd 0x32377a(%rip), %xmm1   # 0x448188
divsd %xmm2, %xmm1
callq 0x124bf0
addq $0x38, %rsp
retq
nopl (%rax)
// File: zengfenfei[P]codility/src/PassingCars.cpp
// Function: solution(std::vector<int, std::allocator<int>>&)
int solution(vector<int> &A) {
	int carsToEast = 0;
	int pairs = 0;
	for (int i = 0; i < A.size(); i++) {
		if (A[i] == 0) {
			carsToEast++;
		} else {
			pairs += carsToEast;
		}
		if (pairs > 1000000000) {
			return -1;
		}
	}
	return pairs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x12b3
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1400
cmpl $0x0, (%rax)
jne 0x128b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1294
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x3b9aca00, -0x18(%rbp) # imm = 0x3B9ACA00
jle 0x12a6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12b9
jmp 0x12a8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1251
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zengfenfei[P]codility/src/PassingCars.cpp
// Function: main
int main() {
	vector<int> A(5);
	A[0] = 0;
	A[1] = 1;
	A[2] = 0;
	A[3] = 1;
	A[4] = 1;

	cout << solution(A) << '\n';	// 5
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1420
movq -0x38(%rbp), %rdx
leaq -0x18(%rbp), %rdi
movl $0x5, %esi
callq 0x1440
jmp 0x12f9
leaq -0x19(%rbp), %rdi
callq 0x14b0
xorl %eax, %eax
movl %eax, %esi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1400
movq -0x48(%rbp), %rdi
movl $0x0, (%rax)
movl $0x1, %esi
callq 0x1400
movq -0x48(%rbp), %rdi
movl $0x1, (%rax)
movl $0x2, %esi
callq 0x1400
movq -0x48(%rbp), %rdi
movl $0x0, (%rax)
movl $0x3, %esi
callq 0x1400
movq -0x48(%rbp), %rdi
movl $0x1, (%rax)
movl $0x4, %esi
callq 0x1400
movq -0x48(%rbp), %rdi
movl $0x1, (%rax)
callq 0x1230
movl %eax, %esi
movq 0x2c5d(%rip), %rdi      # 0x3fd8
callq 0x10d0
movq %rax, -0x40(%rbp)
jmp 0x1386
movq -0x40(%rbp), %rdi
movl $0xa, %esi
callq 0x10b0
jmp 0x1396
leaq -0x18(%rbp), %rdi
callq 0x14d0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x14b0
jmp 0x13d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x14d0
movq -0x28(%rbp), %rdi
callq 0x10e0
nopl (%rax)
// File: sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<MulticolorValue, true>::print_simple(std::ostream&)
void print_simple(std::ostream &os) {
		for(int i = 0; i < height; ++i) {
			if(i == 0) {
				field[0].begin_screen(os);
			}

			for(int j = 0; j < width; ++j) {
				if(j == 0) {
					field[i * width].begin_line(os);
				}

				field[i * width + j].print(os);

				if(j == width - 1) {
					field[i * width + j].end_line(os);
				}
			}

			if(i == height - 1) {
				field[i].end_screen(os);
			}
		}
		os << std::flush;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x7f59
cmpl $0x0, -0x14(%rbp)
jne 0x7e7e
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9180
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xccb0
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x7f1f
cmpl $0x0, -0x18(%rbp)
jne 0x7eba
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
imull 0x1c(%rdi), %eax
movslq %eax, %rsi
callq 0x9180
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xccc0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
imull 0x1c(%rdi), %eax
addl -0x18(%rbp), %eax
movslq %eax, %rsi
callq 0x9180
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xccd0
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
movl 0x1c(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x7f0f
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
imull 0x1c(%rdi), %eax
addl -0x18(%rbp), %eax
movslq %eax, %rsi
callq 0x9180
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xce50
jmp 0x7f11
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7e85
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x7f49
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x9180
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xce60
jmp 0x7f4b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7e4f
movq -0x10(%rbp), %rdi
movq 0xc064(%rip), %rsi      # 0x13fc8
callq 0x21b0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: sgielen[P]clife/multicolor.cpp
// Function: MulticolorValue::MulticolorValue(bool)
MulticolorValue(bool value) : value(value), red(0), green(0), blue(0), age(0) {
		if(value) {
			char color = (rand() % 6) + 1;
			red   = (color & 1) ? 255 : 0;
			green = (color & 2) ? 255 : 0;
			blue  = (color & 4) ? 255 : 0;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movb $0x0, 0x1(%rax)
movb $0x0, 0x2(%rax)
movb $0x0, 0x3(%rax)
movb $0x0, 0x4(%rax)
testb $0x1, -0x9(%rbp)
je 0x9178
callq 0x2030
movl $0x6, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rax
addl $0x1, %edx
movb %dl, %cl
movb %cl, -0xa(%rbp)
movsbl -0xa(%rbp), %esi
andl $0x1, %esi
xorl %ecx, %ecx
movl $0xff, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
movb %cl, 0x1(%rax)
movsbl -0xa(%rbp), %esi
andl $0x2, %esi
xorl %ecx, %ecx
movl $0xff, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
movb %cl, 0x2(%rax)
movsbl -0xa(%rbp), %esi
andl $0x4, %esi
xorl %ecx, %ecx
movl $0xff, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
movb %cl, 0x3(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: sgielen[P]clife/multicolor.cpp
// Function: MulticolorValue::print(std::ostream&) const
void print(std::ostream &os) const {
		if(value && to_ledscreen) {
			os << red << green << blue;
		} else if(value) {
			double brightness = std::max(0.3, 1 - age / 20.);

			uint8_t redval = (red * brightness) / 43;
			uint8_t greenval = (green * brightness) / 43;
			uint8_t blueval = (blue * brightness) / 43;
			uint8_t code = 16 + 36 * redval + 6 * greenval + blueval;
			os << "\x1b[38;5;" << int(code) << "mo\x1b[m";
		} else if(to_ledscreen) {
			os << '\x00' << '\x00' << '\x00';
		} else {
			os << ' ';
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, (%rax)
je 0xcd2b
xorl %eax, %eax
testb $0x1, %al
jne 0xccf5
jmp 0xcd2b
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movzbl 0x1(%rax), %esi
callq 0x2250
movq %rax, %rdi
movq -0x38(%rbp), %rax
movzbl 0x2(%rax), %esi
callq 0x2250
movq %rax, %rdi
movq -0x38(%rbp), %rax
movzbl 0x3(%rax), %esi
callq 0x2250
jmp 0xce41
movq -0x38(%rbp), %rax
testb $0x1, (%rax)
je 0xce31
movq -0x38(%rbp), %rax
movabsq $0x3fd3333333333333, %rcx # imm = 0x3FD3333333333333
movq %rcx, -0x20(%rbp)
movzbl 0x4(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd 0x147e(%rip), %xmm1     # 0xe1d8
divsd %xmm1, %xmm0
movsd 0x147a(%rip), %xmm1     # 0xe1e0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xceb0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x18(%rbp)
movzbl 0x1(%rax), %ecx
cvtsi2sd %ecx, %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1443(%rip), %xmm1     # 0xe1e8
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movb %cl, -0x29(%rbp)
movzbl 0x2(%rax), %ecx
cvtsi2sd %ecx, %xmm0
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movb %cl, -0x2a(%rbp)
movzbl 0x3(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, -0x2b(%rbp)
movzbl -0x29(%rbp), %eax
imull $0x24, %eax, %eax
addl $0x10, %eax
movzbl -0x2a(%rbp), %ecx
imull $0x6, %ecx, %ecx
addl %ecx, %eax
movzbl -0x2b(%rbp), %ecx
addl %ecx, %eax
movb %al, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x14df(%rip), %rsi      # 0xe2ee
callq 0x2180
movq %rax, %rdi
movzbl -0x2c(%rbp), %esi
callq 0x22c0
movq %rax, %rdi
leaq 0x14cc(%rip), %rsi      # 0xe2f6
callq 0x2180
jmp 0xce3f
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x21c0
jmp 0xce41
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)