LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<std::vector, int, std::allocator<int>>(std::vector<int, std::allocator<int>> const&)
bool merge(const Container<T, Alloc>& container)
	{
		bool res = canBeArray();
		if (res)
		{
			for (auto& data: container)
				push(data);
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1adbc
cmpl $0x8, %eax
jne 0x1adba
movq %rbx, %rdi
callq 0x24ca4
jmp 0x1adbc
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x1adde
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x1adde
movslq (%r15), %rsi
movq %rbx, %rdi
callq 0x2186c
addq $0x4, %r15
jmp 0x1adc8
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<int, std::less<int>, std::allocator<int>>(std::set<int, std::less<int>, std::allocator<int>> const&)
bool merge(const std::set<T, Compare, Alloc>& collections)
	{
		bool res = canBeArray();
		if (res)
		{
			for (auto& data: collections)
				push(data);
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1af20
cmpl $0x8, %eax
jne 0x1af1e
movq %r14, %rdi
callq 0x24ca4
jmp 0x1af20
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x1af4e
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
je 0x1af4e
movslq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x2186c
movq %r15, %rdi
callq 0x13270
movq %rax, %r15
cmpq %rbx, %rax
jne 0x1af32
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>(std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>> const&)
bool merge(const std::unordered_set<Key, Hash, Pred, Alloc>& collections)
	{
		bool res = canBeArray();
		if (res)
		{
			for (auto& data: collections)
				push(data);
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1af81
cmpl $0x8, %eax
jne 0x1af7f
movq %rbx, %rdi
callq 0x24ca4
jmp 0x1af81
xorl %ebp, %ebp
movq 0x10(%r14), %r14
testq %r14, %r14
setne %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x1afa6
movslq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x2186c
movq (%r14), %r14
testq %r14, %r14
jne 0x1af92
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::map<std::__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&)
bool merge(const std::map<std::string, T, Compare, Alloc>& theMap)
	{
		bool res = canBeObject();
		if (!res) return false;
		
		for (auto& dataPair: theMap)
		{
			if (addBasicValue(dataPair.first, dataPair.second) == false)
				return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, (%rsp)
movl (%rdi), %eax
testl %eax, %eax
je 0x1b133
cmpl $0x8, %eax
jne 0x1b1b3
movq (%rsp), %rdi
callq 0x247d6
movq 0x18(%rbx), %r15
addq $0x8, %rbx
cmpq %rbx, %r15
sete %bpl
je 0x1b1b5
leaq 0x18(%rsp), %r12
leaq 0x20(%r15), %r13
movq %r12, 0x8(%rsp)
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1f1a4
movq (%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2385c
movl %eax, %r13d
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1b193
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x13220
testb %r13b, %r13b
je 0x1b1b5
movq %r15, %rdi
callq 0x13270
movq %rax, %r15
leaq 0x18(%rsp), %r12
cmpq %rbx, %rax
sete %bpl
jne 0x1b149
jmp 0x1b1b5
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1b1e4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x13220
movq %rbx, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool 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::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&)
bool merge(const std::unordered_map<std::string, T, Hash, Pred, Alloc>& theMap)
	{
		bool res = canBeObject();
		if (!res) return false;
		for (auto& dataPair: theMap)
		{
			if (addBasicValue(dataPair.first, dataPair.second) == false)
				return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
testl %eax, %eax
je 0x1b209
cmpl $0x8, %eax
jne 0x1b22e
movq %r14, %rdi
callq 0x247d6
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
sete %bpl
je 0x1b230
leaq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
movq %r14, %rdi
callq 0x23690
testb %al, %al
jne 0x1b20d
jmp 0x1b230
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<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 push(const std::string& path, const std::array<T, N>& arr, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->push(arr))
			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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x19d9a
testb %al, %al
je 0x1b39d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b390
callq 0x21a22
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 0x11048(%rip), %rsi     # 0x2c402
leaq 0x1105a(%rip), %rdx     # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0x11007(%rip), %rsi     # 0x2c3dc
leaq 0x11021(%rip), %rdx     # 0x2c3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x1e9, %ecx            # imm = 0x1E9
callq 0x2b040
leaq 0x1c8db(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1c8b3(%rip), %rsi     # 0x37cb8
leaq 0x856e(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b436
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1b436
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1b448
movq %rbx, %rdi
callq 0x131a0
jmp 0x1b448
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b457
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<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 push(const std::string& path, const std::deque<T, Alloc>& deq, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->push(deq))
			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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x19e9c
testb %al, %al
je 0x1b4b1
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b4a4
callq 0x21a22
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 0x10f34(%rip), %rsi     # 0x2c402
leaq 0x10f46(%rip), %rdx     # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0x10ef3(%rip), %rsi     # 0x2c3dc
leaq 0x10f0d(%rip), %rdx     # 0x2c3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x1f3, %ecx            # imm = 0x1F3
callq 0x2b040
leaq 0x1c7c7(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1c79f(%rip), %rsi     # 0x37cb8
leaq 0x845a(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b54a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1b54a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1b55c
movq %rbx, %rdi
callq 0x131a0
jmp 0x1b55c
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b56b
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<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 push(const std::string& path, const Container<T, Alloc>& container, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->push(container))
			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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x19f9e
testb %al, %al
je 0x1b5c5
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b5b8
callq 0x21a22
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 0x10e20(%rip), %rsi     # 0x2c402
leaq 0x10e32(%rip), %rdx     # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0x10ddf(%rip), %rsi     # 0x2c3dc
leaq 0x10df9(%rip), %rdx     # 0x2c3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x1ff, %ecx            # imm = 0x1FF
callq 0x2b040
leaq 0x1c6b3(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1c68b(%rip), %rsi     # 0x37cb8
leaq 0x8346(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b65e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1b65e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1b670
movq %rbx, %rdi
callq 0x131a0
jmp 0x1b670
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b67f
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<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 push(const std::string& path, const std::set<T, Compare, Alloc>& collections, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->push(collections))
			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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1a4a8
testb %al, %al
je 0x1bb29
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bb1c
callq 0x21a22
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 0x108bc(%rip), %rsi     # 0x2c402
leaq 0x108ce(%rip), %rdx     # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0x1087b(%rip), %rsi     # 0x2c3dc
leaq 0x10895(%rip), %rdx     # 0x2c3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x209, %ecx            # imm = 0x209
callq 0x2b040
leaq 0x1c14f(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1c127(%rip), %rsi     # 0x37cb8
leaq 0x7de2(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1bbc2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1bbc2
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1bbd4
movq %rbx, %rdi
callq 0x131a0
jmp 0x1bbd4
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bbe3
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<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 push(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->push(collections))
			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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1a5aa
testb %al, %al
je 0x1bc3d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bc30
callq 0x21a22
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 0x107a8(%rip), %rsi     # 0x2c402
leaq 0x107ba(%rip), %rdx     # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0x10767(%rip), %rsi     # 0x2c3dc
leaq 0x10781(%rip), %rdx     # 0x2c3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x213, %ecx            # imm = 0x213
callq 0x2b040
leaq 0x1c03b(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1c013(%rip), %rsi     # 0x37cb8
leaq 0x7cce(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1bcd6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1bcd6
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1bce8
movq %rbx, %rdi
callq 0x131a0
jmp 0x1bce8
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bcf7
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1a6ac
testb %al, %al
je 0x1bd51
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bd44
callq 0x21a22
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 0x10694(%rip), %rsi     # 0x2c402
leaq 0x106a6(%rip), %rdx     # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0x10653(%rip), %rsi     # 0x2c3dc
leaq 0x1066d(%rip), %rdx     # 0x2c3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x21d, %ecx            # imm = 0x21D
callq 0x2b040
leaq 0x1bf27(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1beff(%rip), %rsi     # 0x37cb8
leaq 0x7bba(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1bdea
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1bdea
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1bdfc
movq %rbx, %rdi
callq 0x131a0
jmp 0x1bdfc
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1be0b
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1aab4
testb %al, %al
je 0x1c1a1
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c194
callq 0x21a22
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 0x10244(%rip), %rsi     # 0x2c402
leaq 0x10256(%rip), %rdx     # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0x10203(%rip), %rsi     # 0x2c3dc
leaq 0x1021d(%rip), %rdx     # 0x2c3fd
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x227, %ecx            # imm = 0x227
callq 0x2b040
leaq 0x1bad7(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1baaf(%rip), %rsi     # 0x37cb8
leaq 0x776a(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c23a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1c23a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1c24c
movq %rbx, %rdi
callq 0x131a0
jmp 0x1c24c
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c25b
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1c3d6
movq %rbx, %rsi
callq 0x198b0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c3c9
callq 0x21a22
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 0x1002d(%rip), %rsi     # 0x2c420
leaq 0x10037(%rip), %rdx     # 0x2c431
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xffce(%rip), %rsi      # 0x2c3dc
leaq 0x10007(%rip), %rdx     # 0x2c41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x246, %ecx            # imm = 0x246
callq 0x2b040
leaq 0x1b90a(%rip), %rax     # 0x37d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1b8e2(%rip), %rsi     # 0x37d20
leaq 0x7535(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c46f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1c46f
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1c481
movq %rbx, %rdi
callq 0x131a0
jmp 0x1c481
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c490
callq 0x21a22
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1c4ea
movq %rbx, %rsi
callq 0x198e0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c4dd
callq 0x21a22
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 0xff19(%rip), %rsi      # 0x2c420
leaq 0xff23(%rip), %rdx      # 0x2c431
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xfeba(%rip), %rsi      # 0x2c3dc
leaq 0xfef3(%rip), %rdx      # 0x2c41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x253, %ecx            # imm = 0x253
callq 0x2b040
leaq 0x1b7f6(%rip), %rax     # 0x37d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1b7ce(%rip), %rsi     # 0x37d20
leaq 0x7421(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c583
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1c583
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1c595
movq %rbx, %rdi
callq 0x131a0
jmp 0x1c595
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c5a4
callq 0x21a22
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1c5fe
movq %rbx, %rsi
callq 0x1993e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c5f1
callq 0x21a22
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 0xfe05(%rip), %rsi      # 0x2c420
leaq 0xfe0f(%rip), %rdx      # 0x2c431
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xfda6(%rip), %rsi      # 0x2c3dc
leaq 0xfddf(%rip), %rdx      # 0x2c41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x262, %ecx            # imm = 0x262
callq 0x2b040
leaq 0x1b6e2(%rip), %rax     # 0x37d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1b6ba(%rip), %rsi     # 0x37d20
leaq 0x730d(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c697
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1c697
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1c6a9
movq %rbx, %rdi
callq 0x131a0
jmp 0x1c6a9
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c6b8
callq 0x21a22
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1cb62
movq %rbx, %rsi
callq 0x19a64
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cb55
callq 0x21a22
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 0xf8a1(%rip), %rsi      # 0x2c420
leaq 0xf8ab(%rip), %rdx      # 0x2c431
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xf842(%rip), %rsi      # 0x2c3dc
leaq 0xf87b(%rip), %rdx      # 0x2c41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x26f, %ecx            # imm = 0x26F
callq 0x2b040
leaq 0x1b17e(%rip), %rax     # 0x37d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1b156(%rip), %rsi     # 0x37d20
leaq 0x6da9(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1cbfb
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1cbfb
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1cc0d
movq %rbx, %rdi
callq 0x131a0
jmp 0x1cc0d
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cc1c
callq 0x21a22
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1cc76
movq %rbx, %rsi
callq 0x19aa4
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cc69
callq 0x21a22
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 0xf78d(%rip), %rsi      # 0x2c420
leaq 0xf797(%rip), %rdx      # 0x2c431
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xf72e(%rip), %rsi      # 0x2c3dc
leaq 0xf767(%rip), %rdx      # 0x2c41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x27c, %ecx            # imm = 0x27C
callq 0x2b040
leaq 0x1b06a(%rip), %rax     # 0x37d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1b042(%rip), %rsi     # 0x37d20
leaq 0x6c95(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1cd0f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1cd0f
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1cd21
movq %rbx, %rdi
callq 0x131a0
jmp 0x1cd21
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cd30
callq 0x21a22
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1cd8a
movq %rbx, %rsi
callq 0x19ad6
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1cd7d
callq 0x21a22
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 0xf679(%rip), %rsi      # 0x2c420
leaq 0xf683(%rip), %rdx      # 0x2c431
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xf61a(%rip), %rsi      # 0x2c3dc
leaq 0xf653(%rip), %rdx      # 0x2c41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x289, %ecx            # imm = 0x289
callq 0x2b040
leaq 0x1af56(%rip), %rax     # 0x37d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1af2e(%rip), %rsi     # 0x37d20
leaq 0x6b81(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ce23
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1ce23
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1ce35
movq %rbx, %rdi
callq 0x131a0
jmp 0x1ce35
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ce44
callq 0x21a22
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x1d1da
movq %rbx, %rsi
callq 0x19c56
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d1cd
callq 0x21a22
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 0xf229(%rip), %rsi      # 0x2c420
leaq 0xf233(%rip), %rdx      # 0x2c431
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xf1ca(%rip), %rsi      # 0x2c3dc
leaq 0xf203(%rip), %rdx      # 0x2c41c
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x296, %ecx            # imm = 0x296
callq 0x2b040
leaq 0x1ab06(%rip), %rax     # 0x37d38
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1aade(%rip), %rsi     # 0x37d20
leaq 0x6731(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d273
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1d273
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1d285
movq %rbx, %rdi
callq 0x131a0
jmp 0x1d285
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d294
callq 0x21a22
movq %r14, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1ac42
testb %al, %al
je 0x1d567
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d55c
callq 0x21a22
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 0xee7e(%rip), %rsi      # 0x2c402
leaq 0xee90(%rip), %rdx      # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xee3d(%rip), %rsi      # 0x2c3dc
leaq 0xee93(%rip), %rdx      # 0x2c439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2af, %ecx            # imm = 0x2AF
callq 0x2b040
leaq 0x1a711(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1a6e9(%rip), %rsi     # 0x37cb8
leaq 0x63a4(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d600
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1d600
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1d612
movq %rbx, %rdi
callq 0x131a0
jmp 0x1d612
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d621
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1ac96
testb %al, %al
je 0x1d679
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d66e
callq 0x21a22
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 0xed6c(%rip), %rsi      # 0x2c402
leaq 0xed7e(%rip), %rdx      # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xed2b(%rip), %rsi      # 0x2c3dc
leaq 0xed81(%rip), %rdx      # 0x2c439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2b9, %ecx            # imm = 0x2B9
callq 0x2b040
leaq 0x1a5ff(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1a5d7(%rip), %rsi     # 0x37cb8
leaq 0x6292(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d712
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1d712
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1d724
movq %rbx, %rdi
callq 0x131a0
jmp 0x1d724
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d733
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1ad18
testb %al, %al
je 0x1d78b
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d780
callq 0x21a22
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 0xec5a(%rip), %rsi      # 0x2c402
leaq 0xec6c(%rip), %rdx      # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xec19(%rip), %rsi      # 0x2c3dc
leaq 0xec6f(%rip), %rdx      # 0x2c439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2c5, %ecx            # imm = 0x2C5
callq 0x2b040
leaq 0x1a4ed(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x1a4c5(%rip), %rsi     # 0x37cb8
leaq 0x6180(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1d824
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1d824
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1d836
movq %rbx, %rdi
callq 0x131a0
jmp 0x1d836
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1d845
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1aef8
testb %al, %al
je 0x1dce5
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1dcda
callq 0x21a22
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 0xe700(%rip), %rsi      # 0x2c402
leaq 0xe712(%rip), %rdx      # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xe6bf(%rip), %rsi      # 0x2c3dc
leaq 0xe715(%rip), %rdx      # 0x2c439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2cf, %ecx            # imm = 0x2CF
callq 0x2b040
leaq 0x19f93(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x19f6b(%rip), %rsi     # 0x37cb8
leaq 0x5c26(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1dd7e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1dd7e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1dd90
movq %rbx, %rdi
callq 0x131a0
jmp 0x1dd90
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1dd9f
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2434a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1af5c
testb %al, %al
je 0x1ddf7
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ddec
callq 0x21a22
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 0xe5ee(%rip), %rsi      # 0x2c402
leaq 0xe600(%rip), %rdx      # 0x2c41b
leaq 0x18(%rsp), %rdi
callq 0x1f6e4
movb $0x1, %bpl
leaq 0xe5ad(%rip), %rsi      # 0x2c3dc
leaq 0xe603(%rip), %rdx      # 0x2c439
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x2d9, %ecx            # imm = 0x2D9
callq 0x2b040
leaq 0x19e81(%rip), %rax     # 0x37cd0
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0x19e59(%rip), %rsi     # 0x37cb8
leaq 0x5b14(%rip), %rdx      # 0x2397a
movq %rbx, %rdi
callq 0x13360
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1de90
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x13220
jmp 0x1de90
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1dea2
movq %rbx, %rdi
callq 0x131a0
jmp 0x1dea2
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1deb1
callq 0x21a22
movq %r14, %rdi
callq 0x13380
nop