LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<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 push(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->push(theMap))
			return true;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1a5d8
testb %al, %al
je 0x1bb6f
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bb62
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf876(%rip), %rsi      # 0x2b402
leaq 0xf888(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xf835(%rip), %rsi      # 0x2b3dc
leaq 0xf84f(%rip), %rdx      # 0x2b3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x21d, %ecx            # imm = 0x21D
callq 0x2ac94
leaq 0x1a109(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1a0e1(%rip), %rsi     # 0x35cb8
leaq 0x7ad4(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1bc00
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1bc0a
jmp 0x1bc17
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1bc17
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bc26
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<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 push(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->push(theMap))
			return true;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1a998
testb %al, %al
je 0x1bfaf
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bfa2
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf436(%rip), %rsi      # 0x2b402
leaq 0xf448(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xf3f5(%rip), %rsi      # 0x2b3dc
leaq 0xf40f(%rip), %rdx      # 0x2b3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x227, %ecx            # imm = 0x227
callq 0x2ac94
leaq 0x19cc9(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x19ca1(%rip), %rsi     # 0x35cb8
leaq 0x7694(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c040
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1c04a
jmp 0x1c057
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1c057
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c066
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<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&)
bool add(const std::string& path, const std::array<T, N>& arr, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setArray(arr);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1c1de
movq %rbx, %rsi
callq 0x19892
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c1d1
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf225(%rip), %rsi      # 0x2b420
leaq 0xf22f(%rip), %rdx      # 0x2b431
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xf1c6(%rip), %rsi      # 0x2b3dc
leaq 0xf1ff(%rip), %rdx      # 0x2b41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x246, %ecx            # imm = 0x246
callq 0x2ac94
leaq 0x19b02(%rip), %rax     # 0x35d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x19ada(%rip), %rsi     # 0x35d20
leaq 0x7465(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c26f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1c279
jmp 0x1c286
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1c286
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c295
callq 0x21762
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<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&)
bool add(const std::string& path, const std::deque<T, Alloc>& deq, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setArray(deq);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1c2f0
movq %rbx, %rsi
callq 0x198c2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c2e3
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf113(%rip), %rsi      # 0x2b420
leaq 0xf11d(%rip), %rdx      # 0x2b431
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xf0b4(%rip), %rsi      # 0x2b3dc
leaq 0xf0ed(%rip), %rdx      # 0x2b41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x253, %ecx            # imm = 0x253
callq 0x2ac94
leaq 0x199f0(%rip), %rax     # 0x35d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x199c8(%rip), %rsi     # 0x35d20
leaq 0x7353(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c381
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1c38b
jmp 0x1c398
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1c398
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c3a7
callq 0x21762
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<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&)
bool add(const std::string& path, const Container<T, Alloc>& container, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setArray(container);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1c402
movq %rbx, %rsi
callq 0x19920
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c3f5
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf001(%rip), %rsi      # 0x2b420
leaq 0xf00b(%rip), %rdx      # 0x2b431
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xefa2(%rip), %rsi      # 0x2b3dc
leaq 0xefdb(%rip), %rdx      # 0x2b41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x262, %ecx            # imm = 0x262
callq 0x2ac94
leaq 0x198de(%rip), %rax     # 0x35d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x198b6(%rip), %rsi     # 0x35d20
leaq 0x7241(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c493
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1c49d
jmp 0x1c4aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1c4aa
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c4b9
callq 0x21762
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1c95c
movq %rbx, %rsi
callq 0x19a46
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c94f
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xeaa7(%rip), %rsi      # 0x2b420
leaq 0xeab1(%rip), %rdx      # 0x2b431
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xea48(%rip), %rsi      # 0x2b3dc
leaq 0xea81(%rip), %rdx      # 0x2b41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x26f, %ecx            # imm = 0x26F
callq 0x2ac94
leaq 0x19384(%rip), %rax     # 0x35d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1935c(%rip), %rsi     # 0x35d20
leaq 0x6ce7(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c9ed
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1c9f7
jmp 0x1ca04
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1ca04
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ca13
callq 0x21762
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1ca6e
movq %rbx, %rsi
callq 0x19a86
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ca61
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe995(%rip), %rsi      # 0x2b420
leaq 0xe99f(%rip), %rdx      # 0x2b431
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xe936(%rip), %rsi      # 0x2b3dc
leaq 0xe96f(%rip), %rdx      # 0x2b41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x27c, %ecx            # imm = 0x27C
callq 0x2ac94
leaq 0x19272(%rip), %rax     # 0x35d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1924a(%rip), %rsi     # 0x35d20
leaq 0x6bd5(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1caff
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1cb09
jmp 0x1cb16
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1cb16
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cb25
callq 0x21762
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1cb80
movq %rbx, %rsi
callq 0x19ab8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cb73
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe883(%rip), %rsi      # 0x2b420
leaq 0xe88d(%rip), %rdx      # 0x2b431
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xe824(%rip), %rsi      # 0x2b3dc
leaq 0xe85d(%rip), %rdx      # 0x2b41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x289, %ecx            # imm = 0x289
callq 0x2ac94
leaq 0x19160(%rip), %rax     # 0x35d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x19138(%rip), %rsi     # 0x35d20
leaq 0x6ac3(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1cc11
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1cc1b
jmp 0x1cc28
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1cc28
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cc37
callq 0x21762
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1cfc8
movq %rbx, %rsi
callq 0x19c38
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cfbb
callq 0x21762
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe43b(%rip), %rsi      # 0x2b420
leaq 0xe445(%rip), %rdx      # 0x2b431
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xe3dc(%rip), %rsi      # 0x2b3dc
leaq 0xe415(%rip), %rdx      # 0x2b41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x296, %ecx            # imm = 0x296
callq 0x2ac94
leaq 0x18d18(%rip), %rax     # 0x35d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x18cf0(%rip), %rsi     # 0x35d20
leaq 0x667b(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d059
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1d063
jmp 0x1d070
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1d070
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d07f
callq 0x21762
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1ab02
testb %al, %al
je 0x1d34d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d342
callq 0x21762
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xe098(%rip), %rsi      # 0x2b402
leaq 0xe0aa(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xe057(%rip), %rsi      # 0x2b3dc
leaq 0xe0ad(%rip), %rdx      # 0x2b439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2af, %ecx            # imm = 0x2AF
callq 0x2ac94
leaq 0x1892b(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x18903(%rip), %rsi     # 0x35cb8
leaq 0x62f6(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d3de
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1d3e8
jmp 0x1d3f5
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1d3f5
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d404
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1ab46
testb %al, %al
je 0x1d45b
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d450
callq 0x21762
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xdf8a(%rip), %rsi      # 0x2b402
leaq 0xdf9c(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xdf49(%rip), %rsi      # 0x2b3dc
leaq 0xdf9f(%rip), %rdx      # 0x2b439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2b9, %ecx            # imm = 0x2B9
callq 0x2ac94
leaq 0x1881d(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x187f5(%rip), %rsi     # 0x35cb8
leaq 0x61e8(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d4ec
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1d4f6
jmp 0x1d503
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1d503
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d512
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1abc2
testb %al, %al
je 0x1d569
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d55e
callq 0x21762
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xde7c(%rip), %rsi      # 0x2b402
leaq 0xde8e(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xde3b(%rip), %rsi      # 0x2b3dc
leaq 0xde91(%rip), %rdx      # 0x2b439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2c5, %ecx            # imm = 0x2C5
callq 0x2ac94
leaq 0x1870f(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x186e7(%rip), %rsi     # 0x35cb8
leaq 0x60da(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d5fa
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1d604
jmp 0x1d611
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1d611
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d620
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1ad78
testb %al, %al
je 0x1daaf
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1daa4
callq 0x21762
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd936(%rip), %rsi      # 0x2b402
leaq 0xd948(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xd8f5(%rip), %rsi      # 0x2b3dc
leaq 0xd94b(%rip), %rdx      # 0x2b439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2cf, %ecx            # imm = 0x2CF
callq 0x2ac94
leaq 0x181c9(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x181a1(%rip), %rsi     # 0x35cb8
leaq 0x5b94(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1db40
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1db4a
jmp 0x1db57
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1db57
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1db66
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1add6
testb %al, %al
je 0x1dbbd
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1dbb2
callq 0x21762
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd828(%rip), %rsi      # 0x2b402
leaq 0xd83a(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xd7e7(%rip), %rsi      # 0x2b3dc
leaq 0xd83d(%rip), %rdx      # 0x2b439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2d9, %ecx            # imm = 0x2D9
callq 0x2ac94
leaq 0x180bb(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x18093(%rip), %rsi     # 0x35cb8
leaq 0x5a86(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1dc4e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1dc58
jmp 0x1dc65
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1dc65
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1dc74
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1ae1a
testb %al, %al
je 0x1dccb
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1dcc0
callq 0x21762
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd71a(%rip), %rsi      # 0x2b402
leaq 0xd72c(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xd6d9(%rip), %rsi      # 0x2b3dc
leaq 0xd72f(%rip), %rdx      # 0x2b439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2e3, %ecx            # imm = 0x2E3
callq 0x2ac94
leaq 0x17fad(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x17f85(%rip), %rsi     # 0x35cb8
leaq 0x5978(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1dd5c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1dd66
jmp 0x1dd73
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1dd73
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1dd82
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %r8d
callq 0x24076
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1b032
testb %al, %al
je 0x1e103
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1e0f8
callq 0x21762
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0x130d0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd2e2(%rip), %rsi      # 0x2b402
leaq 0xd2f4(%rip), %rdx      # 0x2b41b
leaq 0x18(%rsp), %rdi
callq 0x1f472
movb $0x1, %bpl
leaq 0xd2a1(%rip), %rsi      # 0x2b3dc
leaq 0xd2f7(%rip), %rdx      # 0x2b439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2ed, %ecx            # imm = 0x2ED
callq 0x2ac94
leaq 0x17b75(%rip), %rax     # 0x35cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x17b4d(%rip), %rsi     # 0x35cb8
leaq 0x5540(%rip), %rdx      # 0x236b2
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1e194
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
testb %bpl, %bpl
jne 0x1e19e
jmp 0x1e1ab
movq %rax, %r14
movq %rbx, %rdi
callq 0x131a0
jmp 0x1e1ab
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1e1ba
callq 0x21762
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x20(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %rax, %rsi
callq 0x21698
movq -0x8(%r15), %rdi
movl %ebp, %esi
callq 0x2478a
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x2335d
movq 0x12c81(%rip), %rcx     # 0x35fd0
cmpb $0x0, (%rcx)
je 0x23359
incl 0x8(%rax)
jmp 0x2335d
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24670
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2337e
callq 0x21762
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2338d
callq 0x21762
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x233b1
callq 0x21762
jmp 0x233b1
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x233c0
callq 0x21762
movq %rbx, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movb (%rdi), %r12b
testb %r12b, %r12b
je 0x1845
movq %rdx, %r14
movq %rdi, %r15
movq %r14, %rdi
callq 0x10d0
testl %eax, %eax
jle 0x1833
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpb (%r14,%rcx), %r12b
je 0x1839
incq %rcx
cmpq %rcx, %rax
jne 0x1825
movb %r12b, (%rbx)
incq %rbx
movb 0x1(%r15), %r12b
incq %r15
testb %r12b, %r12b
jne 0x1812
movb $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/download.cpp
// Function: main
int main(int argc, char *argv[])
{
	unsigned short port = 65535;
	unsigned int size = 0;

	if (argc < 4)
	{
		printf("Usage: download ip port max_size\r\n");
		return 0;
	}

	port = atoi(argv[2]);
	size = atoi(argv[3]);

	printf("Allocating %d bytes\r\n", size);
	char *response = (char *)malloc(size);
	if (response == NULL)
	{
		perror("malloc failed");
	}

	unsigned int download_size = 0;
	char file_name[128] = {0};

	printf("Attempting to download file from ip %s port %d\r\n", argv[1], (int)port);
	int ret = file_download(argv[1], port, response, size, &download_size, file_name);
	if (ret != 0)
	{
		printf("Download failed\r\n");
		return 0;
	}

	printf("Download complete\r\n");
	printf("Got %d bytes file name %s\r\n", download_size, file_name);

	char new_filename[256] = {0};
	char strip_filename[256] = {0};

	StripChars(file_name, strip_filename, (char *)".\\/;:*?\"<>|");

	sprintf(new_filename, "downloaded_%s", strip_filename);
	printf("Saving as file name %s\r\n", new_filename);
	write_file(new_filename, response, download_size);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
cmpl $0x3, %edi
jg 0x1876
leaq 0xa31(%rip), %rdi       # 0x22a2
jmp 0x1923
movq %rsi, %r14
movq 0x10(%rsi), %rdi
callq 0x11e0
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x11e0
movl %eax, %r12d
leaq 0x819(%rip), %rdi       # 0x20b1
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movl %r12d, %edi
callq 0x11b0
movq %rax, %r13
testq %rax, %rax
je 0x19d6
leaq -0x2c(%rbp), %rax
movl $0x0, (%rax)
xorps %xmm0, %xmm0
leaq -0xb0(%rbp), %rbx
movaps %xmm0, 0x70(%rbx)
movaps %xmm0, 0x60(%rbx)
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq 0x8(%r14), %rsi
movzwl %r15w, %edx
leaq 0x7de(%rip), %rdi       # 0x20d5
xorl %eax, %eax
callq 0x1060
movq 0x8(%r14), %rdi
movzwl %r15w, %esi
movq %r13, %rdx
movl %r12d, %ecx
leaq -0x2c(%rbp), %r8
movq %rbx, %r9
callq 0x144b
testl %eax, %eax
je 0x193c
leaq 0x96e(%rip), %rdi       # 0x2291
callq 0x11d0
xorl %eax, %eax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x93b(%rip), %rdi       # 0x227e
callq 0x11d0
movl -0x2c(%rbp), %r14d
leaq 0x7b3(%rip), %rdi       # 0x2106
movl %r14d, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
leaq -0x2b0(%rbp), %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x1100
leaq -0x1b0(%rbp), %r12
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
xorl %esi, %esi
callq 0x1100
leaq 0x78f(%rip), %rdx       # 0x2122
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17f6
leaq 0x789(%rip), %rsi       # 0x212e
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1080
leaq 0x783(%rip), %rdi       # 0x213c
movq %r15, %rsi
xorl %eax, %eax
callq 0x1060
movq %r15, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x13ce
jmp 0x1928
leaq 0x6ea(%rip), %rdi       # 0x20c7
callq 0x1130
jmp 0x18b5
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x31fa
addq $0x8, %rbx
leaq 0x40(%rax), %rcx
cmpq %rbx, %rax
cmoveq %r14, %rcx
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
cmpl $0x3, %edi
jne 0x2a59
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq -0x420(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x400(%rbp,%rax)
jne 0x2a8b
movq 0x10(%rbx), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x2270
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
jne 0x2abf
leaq -0x420(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x262c
leaq -0x218(%rbp), %rdi
callq 0x2070
leaq -0x420(%rbp), %rdi
callq 0x2070
xorl %eax, %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20e0
movq %rax, %r14
leaq 0x15d6(%rip), %rsi      # 0x4043
movq %rax, %rdi
callq 0x20b0
movq 0x3574(%rip), %rsi      # 0x5ff0
movq 0x3545(%rip), %rdx      # 0x5fc8
movq %r14, %rdi
callq 0x2240
movl $0x10, %edi
callq 0x20e0
movq %rax, %r14
leaq 0x15be(%rip), %rsi      # 0x405d
movq %rax, %rdi
callq 0x20b0
movq 0x3542(%rip), %rsi      # 0x5ff0
movq 0x3513(%rip), %rdx      # 0x5fc8
movq %r14, %rdi
callq 0x2240
jmp 0x2af1
movl $0x10, %edi
callq 0x20e0
movq %rax, %r14
leaq 0x15a1(%rip), %rsi      # 0x4074
movq %rax, %rdi
callq 0x20b0
movq 0x350e(%rip), %rsi      # 0x5ff0
movq 0x34df(%rip), %rdx      # 0x5fc8
movq %r14, %rdi
callq 0x2240
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
jmp 0x2b22
jmp 0x2b1a
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
jmp 0x2b2e
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
jmp 0x2b3a
movq %rax, %rbx
jmp 0x2b2e
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2070
leaq -0x420(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk-extras/exprtk_vectornorm.cpp
// Function: double norm<double>::norm_impl<11u>(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:
xorpd %xmm0, %xmm0
cmpq %rcx, %rdx
ja 0x11c02b
movq 0x8(%rsi), %rax
movapd 0x187055(%rip), %xmm1   # 0x2a3040
movsd 0x1870d5(%rip), %xmm2   # 0x2a30c8
movsd (%rax,%rdx,8), %xmm3
andpd %xmm1, %xmm3
movl $0xb, %esi
movapd %xmm2, %xmm4
testb $0x1, %sil
je 0x11c00f
mulsd %xmm3, %xmm4
movl %esi, %edi
andl $-0x2, %edi
mulsd %xmm3, %xmm3
shrl %esi
cmpl $0x1, %edi
ja 0x11c005
addsd %xmm4, %xmm0
incq %rdx
cmpq %rcx, %rdx
jbe 0x11bff3
movsd 0x1870ed(%rip), %xmm1   # 0x2a3120
jmp 0x114180
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x14, %edi
callq 0x1040
movq %rax, %rbx
movaps 0xdbe(%rip), %xmm0      # 0x2010
movups %xmm0, (%rax)
movl $0x1, 0x10(%rax)
xorl %eax, %eax
xorl %esi, %esi
xorl %ecx, %ecx
movl %esi, %edi
movl (%rbx,%rax,4), %edx
testl %edx, %edx
movl %ecx, %esi
cmovel %edx, %esi
addl %edi, %esi
cmpl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
ja 0x1289
cmpl $0x1, %edx
adcl $0x0, %ecx
incq %rax
cmpq $0x5, %rax
jne 0x1262
jmp 0x128e
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq 0x2d43(%rip), %rdi      # 0x3fd8
callq 0x1080
leaq -0x11(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1060
movl $0x14, %esi
movq %rbx, %rdi
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x14, %esi
movq %rbx, %rdi
callq 0x1050
movq %r14, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x18(%rdi), %eax
testl %eax, %eax
jle 0x5685
movq %rdi, %r14
xorl %r13d, %r13d
movq 0x49a8(%rip), %r15      # 0x9fc8
leaq 0x1cc5(%rip), %r12      # 0x72ec
movl 0x1c(%r14), %ecx
testl %ecx, %ecx
jle 0x5659
xorl %ebp, %ebp
imull %r13d, %ecx
movslq %ecx, %rax
addq %rbp, %rax
leaq (%rax,%rax,4), %rdi
addq (%r14), %rdi
movq %rbx, %rsi
callq 0x64da
movl 0x1c(%r14), %ecx
incq %rbp
cmpl %ecx, %ebp
jl 0x5631
movl 0x18(%r14), %eax
leal -0x1(%rax), %ecx
cmpl %ecx, %r13d
jne 0x567d
movl $0x6, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
movq %r15, %rdi
callq 0x2100
movl 0x18(%r14), %eax
incl %r13d
cmpl %eax, %r13d
jl 0x5627
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100