LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::addInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Json::addInt(const std::string& path, intmax_t value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->type() == JSON_Uninit)
		node->setInt(value);
	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 0x17c52
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x19596
movq %rbx, %rsi
callq 0x183a2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1958b
callq 0x16eec
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x81a9(%rip), %rsi      # 0x2175c
leaq 0x81b3(%rip), %rdx      # 0x2176d
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x80dc(%rip), %rsi      # 0x216aa
leaq 0x81a1(%rip), %rdx      # 0x21776
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x330, %ecx            # imm = 0x330
callq 0x1ee7c
leaq 0xf762(%rip), %rax      # 0x28d50
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xf6d2(%rip), %rsi      # 0x28cd0
leaq 0x32d3(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1962f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1962f
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x19641
movq %rbx, %rdi
callq 0xb1c0
jmp 0x19641
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19650
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::addUInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Json::addUInt(const std::string& path, uintmax_t value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->type() == JSON_Uninit)
		node->setUInt(value);
	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 0x17c52
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x196a8
movq %rbx, %rsi
callq 0x183e2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1969d
callq 0x16eec
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8097(%rip), %rsi      # 0x2175c
leaq 0x80a1(%rip), %rdx      # 0x2176d
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x7fca(%rip), %rsi      # 0x216aa
leaq 0x8096(%rip), %rdx      # 0x2177d
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x339, %ecx            # imm = 0x339
callq 0x1ee7c
leaq 0xf650(%rip), %rax      # 0x28d50
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xf5c0(%rip), %rsi      # 0x28cd0
leaq 0x31c1(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x19741
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x19741
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x19753
movq %rbx, %rdi
callq 0xb1c0
jmp 0x19753
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19762
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::addString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Json::addString(const std::string& path, const char* value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->type() == JSON_Uninit)
		node->setString(value);
	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 0x17c52
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x197ba
movq %rbx, %rsi
callq 0x1846c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x197af
callq 0x16eec
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7f85(%rip), %rsi      # 0x2175c
leaq 0x7f8f(%rip), %rdx      # 0x2176d
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x7eb8(%rip), %rsi      # 0x216aa
leaq 0x7f8c(%rip), %rdx      # 0x21785
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x342, %ecx            # imm = 0x342
callq 0x1ee7c
leaq 0xf53e(%rip), %rax      # 0x28d50
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xf4ae(%rip), %rsi      # 0x28cd0
leaq 0x30af(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x19853
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x19853
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x19865
movq %rbx, %rdi
callq 0xb1c0
jmp 0x19865
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19874
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::addString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Json::addString(const std::string& path, const std::string& value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->type() == JSON_Uninit)
		node->setString(value);
	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 0x17c52
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x198cc
movq %rbx, %rsi
callq 0x18534
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x198c1
callq 0x16eec
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7e73(%rip), %rsi      # 0x2175c
leaq 0x7e7d(%rip), %rdx      # 0x2176d
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x7da6(%rip), %rsi      # 0x216aa
leaq 0x7e7a(%rip), %rdx      # 0x21785
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x34b, %ecx            # imm = 0x34B
callq 0x1ee7c
leaq 0xf42c(%rip), %rax      # 0x28d50
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xf39c(%rip), %rsi      # 0x28cd0
leaq 0x2f9d(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x19965
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x19965
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x19977
movq %rbx, %rdi
callq 0xb1c0
jmp 0x19977
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19986
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::addNull(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&)
void Json::addNull(const std::string& path, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->type() == JSON_Uninit)
		node->setNull();
	else
		throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %r8d
callq 0x17c52
movq (%rbx), %rbx
cmpl $0x8, (%rbx)
jne 0x199e4
movq %rbx, %rdi
callq 0x182c0
movl $0x7, (%rbx)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x199d9
callq 0x16eec
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7d5b(%rip), %rsi      # 0x2175c
leaq 0x7d65(%rip), %rdx      # 0x2176d
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x7c8e(%rip), %rsi      # 0x216aa
leaq 0x7d6c(%rip), %rdx      # 0x2178f
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x354, %ecx            # imm = 0x354
callq 0x1ee7c
leaq 0xf314(%rip), %rax      # 0x28d50
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xf284(%rip), %rsi      # 0x28cd0
leaq 0x2e85(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x19a7d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x19a7d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x19a8a
movq %rbx, %rdi
callq 0xb1c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19a99
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::addArray(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&)
JsonPtr Json::addArray(const std::string& path, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->type() == JSON_Uninit)
	{
		node->setArray();
		return node;
	}
	else
		throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, %r8d
callq 0x17c52
movq (%rbx), %rdi
cmpl $0x8, (%rdi)
jne 0x19ad9
callq 0x185ac
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x7c65(%rip), %rsi      # 0x2175c
leaq 0x7c6f(%rip), %rdx      # 0x2176d
movq %rsp, %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x7b9a(%rip), %rsi      # 0x216aa
leaq 0x7c80(%rip), %rdx      # 0x21797
movq %rsp, %r8
movq %r14, %rdi
movl $0x360, %ecx            # imm = 0x360
callq 0x1ee7c
leaq 0xf222(%rip), %rax      # 0x28d50
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xf192(%rip), %rsi      # 0x28cd0
leaq 0x2d93(%rip), %rdx      # 0x1c8d8
movq %r14, %rdi
callq 0xb390
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x19b6e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x19b6e
movq %rax, %r15
movb $0x1, %bpl
testb %bpl, %bpl
je 0x19b80
movq %r14, %rdi
callq 0xb1c0
jmp 0x19b80
movq %rax, %r15
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x19b8e
callq 0x16eec
movq %r15, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::addDict(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&)
JsonPtr Json::addDict(const std::string& path, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->type() == JSON_Uninit)
	{
		node->setDict();
		return node;
	}
	else
		throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x1, %r8d
callq 0x17c52
movq (%rbx), %rdi
cmpl $0x8, (%rdi)
jne 0x19bcd
callq 0x180de
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x7b71(%rip), %rsi      # 0x2175c
leaq 0x7b7b(%rip), %rdx      # 0x2176d
movq %rsp, %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x7aa6(%rip), %rsi      # 0x216aa
leaq 0x7b95(%rip), %rdx      # 0x217a0
movq %rsp, %r8
movq %r14, %rdi
movl $0x36c, %ecx            # imm = 0x36C
callq 0x1ee7c
leaq 0xf12e(%rip), %rax      # 0x28d50
addq $0x10, %rax
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xf09e(%rip), %rsi      # 0x28cd0
leaq 0x2c9f(%rip), %rdx      # 0x1c8d8
movq %r14, %rdi
callq 0xb390
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x19c62
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x19c62
movq %rax, %r15
movb $0x1, %bpl
testb %bpl, %bpl
je 0x19c74
movq %r14, %rdi
callq 0xb1c0
jmp 0x19c74
movq %rax, %r15
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x19c82
callq 0x16eec
movq %r15, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::remove(int)
bool Json::remove(int index)
{
	if (_type != JSON_Array)
		return false;

	std::list<JsonPtr>* data = (std::list<JsonPtr>*)_data;
	auto it = data->begin();
	int i = 0;
	for (; it != data->end(); it++, i++)
	{
		if (i == index)
		{
			data->erase(it);
			return true;	
		}
	}

	return true;
}

// Assembly:
pushq %rbx
movl (%rdi), %ebx
cmpl $0x1, %ebx
jne 0x19cb6
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
cmpq %rdi, %rax
je 0x19cb6
incl %esi
decl %esi
je 0x19cae
movq (%rax), %rax
cmpq %rdi, %rax
jne 0x19ca0
jmp 0x19cb6
movq %rax, %rsi
callq 0x1d8a4
cmpl $0x1, %ebx
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::remove(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 Json::remove(const std::string& path, const std::string& delim)
{
	std::string lastSection;
	bool nodeTypeError, nodeNotFound;
	JsonPtr node = getParentNode(path, delim, lastSection, nodeTypeError, nodeNotFound);

	if (node)
	{
		std::map<std::string, JsonPtr>* data = (std::map<std::string, JsonPtr>*)(node->_data);
		data->erase(lastSection);
		return true;
	}

	if (nodeNotFound)
		return true;

	if (nodeTypeError == false && nodeNotFound == false)
	{
		std::map<std::string, JsonPtr>* data = (std::map<std::string, JsonPtr>*)_data;
		data->erase(lastSection);
		return true;
	}
	
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0xe(%rsp), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %r8
leaq 0xf(%rsp), %r9
movq %r14, %rsi
callq 0x17a54
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x19d2f
movq 0x8(%rax), %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x1d8d0
movb $0x1, %bl
movq %r14, %rdi
movq %rax, %rsi
callq 0x1d978
jmp 0x19d5f
movb $0x1, %bl
cmpb $0x0, 0xe(%rsp)
jne 0x19d5f
cmpb $0x0, 0xf(%rsp)
je 0x19d43
xorl %ebx, %ebx
jmp 0x19d5f
movq 0x8(%r14), %r14
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x1d8d0
movq %r14, %rdi
movq %rax, %rsi
callq 0x1d978
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x19d6e
callq 0x16eec
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x19d85
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb260
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x19d98
movq %rax, %rbx
jmp 0x19daa
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x19daa
callq 0x16eec
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x19dc1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb260
movq %rbx, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::type(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&)
enum Json::ElementType Json::type(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->type();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Node is not exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x178d6
movq (%rbx), %rax
testq %rax, %rax
je 0x19e58
movl (%rax), %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19e4b
callq 0x16eec
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7938(%rip), %rsi      # 0x217ad
leaq 0x7943(%rip), %rdx      # 0x217bf
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x781a(%rip), %rsi      # 0x216aa
leaq 0x7911(%rip), %rdx      # 0x217a8
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x3af, %ecx            # imm = 0x3AF
callq 0x1ee7c
leaq 0xeec8(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xee28(%rip), %rsi      # 0x28ce8
leaq 0x2a11(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x19ef1
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x19ef1
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x19efe
movq %rbx, %rdi
callq 0xb1c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19f0d
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getInt(long) const
intmax_t Json::getInt(intmax_t dft) const
{
	if (_type == JSON_Integer)
		return *((intmax_t*)_data);

	if (_type == JSON_UInteger)
	{
		intmax_t v = (intmax_t)(*((uintmax_t*)_data));
		if (v >= 0)
			return v;
	}

	return dft;
}

// Assembly:
movl (%rdi), %eax
cmpl $0x4, %eax
je 0x19f3c
cmpl $0x3, %eax
jne 0x19f49
movq 0x8(%rdi), %rax
movq (%rax), %rax
retq
movq 0x8(%rdi), %rax
movq (%rax), %rax
testq %rax, %rax
js 0x19f49
retq
movq %rsi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getUInt(unsigned long) const
uintmax_t Json::getUInt(uintmax_t dft) const
{
	if (_type == JSON_UInteger)
		return *((uintmax_t*)_data);

	if (_type == JSON_Integer)
	{
		intmax_t v = *((intmax_t*)_data);
		if (v >= 0)
			return (uintmax_t)v;
	}

	return dft;
}

// Assembly:
movl (%rdi), %eax
cmpl $0x3, %eax
je 0x19f62
cmpl $0x4, %eax
jne 0x19f6f
movq 0x8(%rdi), %rax
movq (%rax), %rax
retq
movq 0x8(%rdi), %rax
movq (%rax), %rax
testq %rax, %rax
js 0x19f6f
retq
movq %rsi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantInt() const
intmax_t Json::wantInt() const
{
	if (_type == JSON_Integer)
		return *((intmax_t*)_data);

	if (_type == JSON_UInteger)
	{
		intmax_t v = (intmax_t)(*((uintmax_t*)_data));
		if (v >= 0)
			return v;
	}

	throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl (%rdi), %eax
cmpl $0x4, %eax
je 0x1a0b9
cmpl $0x3, %eax
jne 0x1a0d0
movq 0x8(%rdi), %rax
movq (%rax), %rax
jmp 0x1a0c5
movq 0x8(%rdi), %rax
movq (%rax), %rax
testq %rax, %rax
js 0x1a0d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x76dc(%rip), %rsi      # 0x217c9
leaq 0x76ea(%rip), %rdx      # 0x217de
leaq 0x8(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x75a2(%rip), %rsi      # 0x216aa
leaq 0x76d0(%rip), %rdx      # 0x217df
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x412, %ecx            # imm = 0x412
callq 0x1ee7c
leaq 0xebd8(%rip), %rax      # 0x28d00
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xeb80(%rip), %rsi      # 0x28cb8
leaq 0x2799(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a169
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1a169
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1a176
movq %rbx, %rdi
callq 0xb1c0
movq %r14, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantUInt() const
uintmax_t Json::wantUInt() const
{
	if (_type == JSON_UInteger)
		return *((uintmax_t*)_data);

	if (_type == JSON_Integer)
	{
		intmax_t v = *((intmax_t*)_data);
		if (v >= 0)
			return (uintmax_t)v;
	}

	throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl (%rdi), %eax
cmpl $0x3, %eax
je 0x1a19d
cmpl $0x4, %eax
jne 0x1a1b4
movq 0x8(%rdi), %rax
movq (%rax), %rax
jmp 0x1a1a9
movq 0x8(%rdi), %rax
movq (%rax), %rax
testq %rax, %rax
js 0x1a1b4
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x75f8(%rip), %rsi      # 0x217c9
leaq 0x7606(%rip), %rdx      # 0x217de
leaq 0x8(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x74be(%rip), %rsi      # 0x216aa
leaq 0x75f4(%rip), %rdx      # 0x217e7
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x421, %ecx            # imm = 0x421
callq 0x1ee7c
leaq 0xeaf4(%rip), %rax      # 0x28d00
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xea9c(%rip), %rsi      # 0x28cb8
leaq 0x26b5(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a24d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1a24d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1a25a
movq %rbx, %rdi
callq 0xb1c0
movq %r14, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantBoolVector() const
std::vector<bool> Json::wantBoolVector() const
{
	if (_type != JSON_Array)
		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");

	std::list<JsonPtr>* data = (std::list<JsonPtr>*)_data;
	std::vector<bool> res;
	res.reserve(data->size());

	for (auto& node: *data)
		res.push_back(node->wantBool());

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, (%rsi)
jne 0x1a47b
movq %rdi, %rbx
movq 0x8(%rsi), %r14
xorl %eax, %eax
movq %rax, (%rdi)
movl %eax, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movl %eax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq 0x10(%r14), %rsi
callq 0x1c924
movq %r14, %r15
movq (%r15), %r15
cmpq %r14, %r15
je 0x1a46d
movq 0x10(%r15), %rdi
callq 0x19fca
movzbl %al, %esi
movq %rbx, %rdi
callq 0x1c956
jmp 0x1a44f
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7331(%rip), %rsi      # 0x217c9
leaq 0x733f(%rip), %rdx      # 0x217de
leaq 0x8(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x71f7(%rip), %rsi      # 0x216aa
leaq 0x734a(%rip), %rdx      # 0x21804
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x438, %ecx            # imm = 0x438
callq 0x1ee7c
leaq 0xe82d(%rip), %rax      # 0x28d00
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe7d5(%rip), %rsi      # 0x28cb8
leaq 0x23ee(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a514
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1a514
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1a530
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1a530
jmp 0x1a525
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d00a
movq %r14, %rdi
callq 0xb3b0
movq %rax, %rdi
callq 0x168fb
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantRealVector() const
std::vector<double> Json::wantRealVector() const
{
	if (_type != JSON_Array)
		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");

	std::list<JsonPtr>* data = (std::list<JsonPtr>*)_data;
	std::vector<double> res;
	res.reserve(data->size());

	for (auto& node: *data)
		res.push_back(node->wantReal());

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x1, (%rsi)
jne 0x1a5c5
movq %rdi, %rbx
movq 0x8(%rsi), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x10(%r15), %rsi
callq 0x1c9a4
movq (%r15), %r12
cmpq %r15, %r12
je 0x1a5b5
movq %rsp, %r14
movq 0x10(%r12), %rdi
callq 0x1a262
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1a5a1
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1a5ac
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1de9e
movq (%r12), %r12
cmpq %r15, %r12
jne 0x1a57a
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x71e7(%rip), %rsi      # 0x217c9
leaq 0x71f5(%rip), %rdx      # 0x217de
movq %rsp, %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x70af(%rip), %rsi      # 0x216aa
leaq 0x7211(%rip), %rdx      # 0x21813
movq %rsp, %r8
movq %rbx, %rdi
movl $0x447, %ecx            # imm = 0x447
callq 0x1ee7c
leaq 0xe6e7(%rip), %rax      # 0x28d00
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe68f(%rip), %rsi      # 0x28cb8
leaq 0x22a8(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1a659
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1a659
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1a681
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1a681
jmp 0x1a66a
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1a681
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xb260
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantIntVector() const
std::vector<intmax_t> Json::wantIntVector() const
{
	if (_type != JSON_Array)
		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");

	std::list<JsonPtr>* data = (std::list<JsonPtr>*)_data;
	std::vector<intmax_t> res;
	res.reserve(data->size());

	for (auto& node: *data)
		res.push_back(node->wantInt());

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x1, (%rsi)
jne 0x1a70d
movq %rdi, %rbx
movq 0x8(%rsi), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x10(%r15), %rsi
callq 0x1ca3a
movq (%r15), %r12
cmpq %r15, %r12
je 0x1a6fd
movq %rsp, %r14
movq 0x10(%r12), %rdi
callq 0x1a09a
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1a6e9
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1a6f4
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1dfde
movq (%r12), %r12
cmpq %r15, %r12
jne 0x1a6c4
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x709f(%rip), %rsi      # 0x217c9
leaq 0x70ad(%rip), %rdx      # 0x217de
movq %rsp, %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x6f67(%rip), %rsi      # 0x216aa
leaq 0x70d8(%rip), %rdx      # 0x21822
movq %rsp, %r8
movq %rbx, %rdi
movl $0x456, %ecx            # imm = 0x456
callq 0x1ee7c
leaq 0xe59f(%rip), %rax      # 0x28d00
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe547(%rip), %rsi      # 0x28cb8
leaq 0x2160(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1a7a1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1a7a1
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1a7c9
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1a7c9
jmp 0x1a7b2
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1a7c9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xb260
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantStringVector[abi:cxx11]() const
std::vector<std::string> Json::wantStringVector() const
{
	if (_type != JSON_Array)
		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");

	std::list<JsonPtr>* data = (std::list<JsonPtr>*)_data;
	std::vector<std::string> res;
	res.reserve(data->size());

	for (auto& node: *data)
		res.push_back(node->wantString());

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, (%rsi)
jne 0x1a85e
movq %rdi, %rbx
movq 0x8(%rsi), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x10(%r15), %rsi
callq 0x1cad0
movq (%r15), %r13
cmpq %r15, %r13
je 0x1a84c
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r14
movq 0x10(%r13), %rsi
movq %r14, %rdi
callq 0x1a332
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d038
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a843
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb260
movq (%r13), %r13
cmpq %r15, %r13
jne 0x1a815
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6f4e(%rip), %rsi      # 0x217c9
leaq 0x6f5c(%rip), %rdx      # 0x217de
leaq 0x8(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x6e14(%rip), %rsi      # 0x216aa
leaq 0x6f93(%rip), %rdx      # 0x21830
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x465, %ecx            # imm = 0x465
callq 0x1ee7c
leaq 0xe44a(%rip), %rax      # 0x28d00
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe3f2(%rip), %rsi      # 0x28cb8
leaq 0x200b(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a8f7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1a8f7
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1a92f
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1a92f
jmp 0x1a908
movq %rax, %r14
jmp 0x1a927
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1a927
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb260
movq %rbx, %rdi
callq 0x16430
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantBoolDict[abi:cxx11]() const
std::map<std::string, bool> Json::wantBoolDict() const
{
	if (_type != JSON_Object)
		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");

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

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

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, (%rsi)
jne 0x1a9b0
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x18(%r15), %r14
addq $0x8, %r15
cmpq %r15, %r14
je 0x1a9a2
movq 0x40(%r14), %rdi
callq 0x19fca
movl %eax, %ebp
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x1cbb8
movb %bpl, (%rax)
movq %r14, %rdi
callq 0xb190
movq %rax, %r14
cmpq %r15, %rax
jne 0x1a978
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6dfc(%rip), %rsi      # 0x217c9
leaq 0x6e0a(%rip), %rdx      # 0x217de
leaq 0x8(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x6cc2(%rip), %rsi      # 0x216aa
leaq 0x6e52(%rip), %rdx      # 0x21841
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x474, %ecx            # imm = 0x474
callq 0x1ee7c
leaq 0xe2f8(%rip), %rax      # 0x28d00
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe2a0(%rip), %rsi      # 0x28cb8
leaq 0x1eb9(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1aa49
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1aa49
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1aa63
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1aa63
movq %rax, %r14
movq %rbx, %rdi
callq 0x17150
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantRealDict[abi:cxx11]() const
std::map<std::string, double> Json::wantRealDict() const
{
	if (_type != JSON_Object)
		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");

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

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

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, (%rsi)
jne 0x1aaed
movq %rdi, %rbx
movq 0x8(%rsi), %r15
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x18(%r15), %r14
addq $0x8, %r15
cmpq %r15, %r14
je 0x1aadf
movq 0x40(%r14), %rdi
callq 0x1a262
movsd %xmm0, (%rsp)
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x1cc34
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %rdi
callq 0xb190
movq %rax, %r14
cmpq %r15, %rax
jne 0x1aaac
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6cbf(%rip), %rsi      # 0x217c9
leaq 0x6ccd(%rip), %rdx      # 0x217de
leaq 0x8(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x6b85(%rip), %rsi      # 0x216aa
leaq 0x6d22(%rip), %rdx      # 0x2184e
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x482, %ecx            # imm = 0x482
callq 0x1ee7c
leaq 0xe1bb(%rip), %rax      # 0x28d00
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe163(%rip), %rsi      # 0x28cb8
leaq 0x1d7c(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ab86
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1ab86
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1aba0
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1aba0
movq %rax, %r14
movq %rbx, %rdi
callq 0x170d8
movq %r14, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantIntDict[abi:cxx11]() const
std::map<std::string, intmax_t> Json::wantIntDict() const
{
	if (_type != JSON_Object)
		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");

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

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

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpl $0x0, (%rsi)
jne 0x1ac26
movq %rdi, %rbx
movq 0x8(%rsi), %r12
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x18(%r12), %r14
addq $0x8, %r12
cmpq %r12, %r14
je 0x1ac16
movq 0x40(%r14), %rdi
callq 0x1a09a
movq %rax, %r15
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x1ccb0
movq %r15, (%rax)
movq %r14, %rdi
callq 0xb190
movq %rax, %r14
cmpq %r12, %rax
jne 0x1abeb
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6b86(%rip), %rsi      # 0x217c9
leaq 0x6b94(%rip), %rdx      # 0x217de
movq %rsp, %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x6a4e(%rip), %rsi      # 0x216aa
leaq 0x6bf8(%rip), %rdx      # 0x2185b
movq %rsp, %r8
movq %rbx, %rdi
movl $0x490, %ecx            # imm = 0x490
callq 0x1ee7c
leaq 0xe086(%rip), %rax      # 0x28d00
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xe02e(%rip), %rsi      # 0x28cb8
leaq 0x1c47(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1acba
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1acba
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1acd4
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1acd4
movq %rax, %r14
movq %rbx, %rdi
callq 0x17060
movq %r14, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantStringDict[abi:cxx11]() const
std::map<std::string, std::string> Json::wantStringDict() const
{
	if (_type != JSON_Object)
		throw JSON_ERROR_MSG(JsonNodeTypeMissMatchError, "Node type miss match.");

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

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

	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, (%rsi)
jne 0x1ad8b
movq %rdi, %rbx
movq 0x8(%rsi), %r12
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x18(%r12), %r14
addq $0x8, %r12
cmpq %r12, %r14
je 0x1ad79
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq 0x40(%r14), %rsi
movq %r15, %rdi
callq 0x1a332
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x1cd2c
movq %rax, %rdi
movq %r15, %rsi
callq 0xb2c0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1ad69
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb260
movq %r14, %rdi
callq 0xb190
movq %rax, %r14
cmpq %r12, %rax
jne 0x1ad2f
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6a21(%rip), %rsi      # 0x217c9
leaq 0x6a2f(%rip), %rdx      # 0x217de
leaq 0x8(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x68e7(%rip), %rsi      # 0x216aa
leaq 0x6a9d(%rip), %rdx      # 0x21867
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x49e, %ecx            # imm = 0x49E
callq 0x1ee7c
leaq 0xdf1d(%rip), %rax      # 0x28d00
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xdec5(%rip), %rsi      # 0x28cb8
leaq 0x1ade(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ae24
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1ae24
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1ae5a
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1ae5a
movq %rax, %r14
jmp 0x1ae52
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1ae52
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb260
movq %rbx, %rdi
callq 0x16fce
movq %r14, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getBool(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&)
bool Json::getBool(const std::string& path, bool dft, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->getBool(dft);
	else
		return dft;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rax
testq %rax, %rax
je 0x1ae9b
xorl %ecx, %ecx
cmpq $0x0, 0x8(%rax)
setne %cl
cmpl $0x6, (%rax)
movzbl %bl, %eax
cmovnel %eax, %ecx
movl %ecx, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1aeaa
callq 0x16eec
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
intmax_t Json::getInt(const std::string& path, intmax_t dft, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->getInt(dft);
	else
		return dft;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rax
testq %rax, %rax
je 0x1aefa
movl (%rax), %ecx
cmpl $0x4, %ecx
je 0x1aeee
cmpl $0x3, %ecx
jne 0x1aefa
movq 0x8(%rax), %rax
movq (%rax), %r14
jmp 0x1aefd
movq 0x8(%rax), %rax
movq (%rax), %r14
testq %r14, %r14
jns 0x1aefd
movq %rbx, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1af0c
callq 0x16eec
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getUInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
uintmax_t Json::getUInt(const std::string& path, uintmax_t dft, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->getUInt(dft);
	else
		return dft;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rax
testq %rax, %rax
je 0x1af5e
movl (%rax), %ecx
cmpl $0x3, %ecx
je 0x1af52
cmpl $0x4, %ecx
jne 0x1af5e
movq 0x8(%rax), %rax
movq (%rax), %r14
jmp 0x1af61
movq 0x8(%rax), %rax
movq (%rax), %r14
testq %r14, %r14
jns 0x1af61
movq %rbx, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1af70
callq 0x16eec
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getReal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double Json::getReal(const std::string& path, double dft, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->getReal(dft);
	else
		return dft;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rcx
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x178d6
movq (%rbx), %rax
testq %rax, %rax
je 0x1afb8
cmpl $0x5, (%rax)
jne 0x1afb8
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1afc7
callq 0x16eec
movsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getStringAt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Json::getStringAt(const std::string& path, const std::string& dft, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->getString(dft);
	else
		return dft;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %r8, %rcx
callq 0x178d6
movq (%r15), %rsi
testq %rsi, %rsi
je 0x1b006
movq %rbx, %rdi
movq %r14, %rdx
callq 0x19f82
jmp 0x1b01f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x171c8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1b02e
callq 0x16eec
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1b04d
callq 0x16eec
movq %rbx, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getList(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 std::list<JsonPtr> * const Json::getList(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->getList();
	else
		return NULL;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x178d6
movq (%rbx), %rax
testq %rax, %rax
je 0x1b082
cmpl $0x1, (%rax)
jne 0x1b082
movq 0x8(%rax), %rbx
jmp 0x1b084
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1b093
callq 0x16eec
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getDict(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 std::map<std::string, JsonPtr> * const Json::getDict(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->getDict();
	else
		return NULL;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x178d6
movq (%rbx), %rax
testq %rax, %rax
je 0x1b0c8
cmpl $0x0, (%rax)
jne 0x1b0c8
movq 0x8(%rax), %rbx
jmp 0x1b0ca
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1b0d9
callq 0x16eec
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantBool(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 Json::wantBool(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantBool();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x178d6
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1b12d
callq 0x19fca
movl %eax, %ebx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b120
callq 0x16eec
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x672c(%rip), %rsi      # 0x21876
leaq 0x673f(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x6545(%rip), %rsi      # 0x216aa
leaq 0x6654(%rip), %rdx      # 0x217c0
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x4f9, %ecx            # imm = 0x4F9
callq 0x1ee7c
leaq 0xdbf3(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xdb53(%rip), %rsi      # 0x28ce8
leaq 0x173c(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b1c6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1b1c6
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1b1d8
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1b1d8
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b1e7
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop