LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/JameyWoo[P]csmile/assembly.cpp
// Function: genAssembly(TreeNode*)
void genAssembly(TreeNode* root) {
    // 汇编代码的头部
    assout << "\t.section\t.rodata" << endl
           << ".LC0:" << endl
           << "\t"
           << ".string \"%d\\n\"" << endl
           << ".LC1:" << endl
           << "\t"
           << ".string \"%d\"" << endl
           << "\t"
           << ".text" << endl;

    // 函数部分, 遍历每个 function, 单独处理
    TreeNode* func = root;
    while (func != NULL) {
        genFunc(func);
        func = func->sibling;
        LFB_id++;
        LFE_id++;
    }

    assout << "\t.ident	\"GCC: (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3\"" << endl
           << "\t.section"
           << "\t"
           << ".note.GNU-stack,\"\",@progbits " << endl;

    cout << "the end..." << endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9ee8(%rip), %rdi      # 0x16be0
leaq 0x2c03(%rip), %rsi      # 0xf902
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
leaq 0x2c01(%rip), %rsi      # 0xf914
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
leaq 0x29ea(%rip), %r14      # 0xf714
movq %rax, %rdi
movq %r14, %rsi
callq 0x21b0
leaq 0x2bde(%rip), %rsi      # 0xf91a
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
leaq 0x2bd6(%rip), %rsi      # 0xf929
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21b0
leaq 0x2bba(%rip), %rsi      # 0xf92f
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21b0
leaq 0x2ba5(%rip), %rsi      # 0xf93c
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
testq %rbx, %rbx
je 0xcdc6
movq %rbx, %rdi
callq 0xc6e5
movq 0x20(%rbx), %rbx
incl 0xa082(%rip)            # 0x16e40
incl 0xa080(%rip)            # 0x16e44
jmp 0xcda7
leaq 0x9e13(%rip), %rdi      # 0x16be0
leaq 0x2b6e(%rip), %rsi      # 0xf942
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
leaq 0x2b8e(%rip), %rsi      # 0xf976
movq %rax, %rdi
callq 0x21b0
leaq 0x291d(%rip), %rsi      # 0xf714
movq %rax, %rdi
callq 0x21b0
leaq 0x2b7a(%rip), %rsi      # 0xf980
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
callq 0x20f0
movq 0x91ab(%rip), %rdi      # 0x15fc8
leaq 0x2b7a(%rip), %rsi      # 0xf99e
callq 0x21b0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: pathSplit(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::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
std::vector<std::string>& pathSplit(const std::string& s, const std::string& delim, std::vector<std::string> &elems)
{

	std::string::size_type start = 0;
	while (true)
	{
		if (start == s.size())
		{
			elems.push_back("");
			return elems;
		}

		std::string::size_type pos = s.find_first_of(delim, start);
		if (pos == start)
		{
			elems.push_back("");
			start += 1;
		}
		else if (pos != std::string::npos)
		{
			std::string tmp = s.substr(start, pos - start);
			elems.push_back(tmp);
			start = pos + 1;
		}
		else
		{
			std::string tmp = s.substr(start);
			elems.push_back(tmp);
			return elems;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
cmpq 0x8(%r14), %r12
je 0x1699b
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xe200
movq %rax, %rcx
subq %r12, %rcx
jne 0x16969
movq %r13, %rdi
leaq 0x8b2a(%rip), %rsi      # 0x1f474
leaq 0x7(%rsp), %rdx
callq 0x14fc0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1afe0
movq %r13, %rdi
callq 0xe0c0
jmp 0x16996
movq %rax, %rbp
cmpq $-0x1, %rax
je 0x169c0
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xe260
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1a7e6
movq %r13, %rdi
callq 0xe0c0
movq %rbp, %r12
incq %r12
jmp 0x16924
leaq 0x8ad2(%rip), %rsi      # 0x1f474
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x14fc0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1afe0
jmp 0x169e1
leaq 0x8(%rsp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xe260
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a7e6
leaq 0x8(%rsp), %rdi
callq 0xe0c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16a0a
jmp 0x16a0a
jmp 0x16a05
jmp 0x16a0a
movq %rax, %rbx
jmp 0x16a17
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe0c0
movq %rbx, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getNodeByKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
JsonPtr Json::getNodeByKey(const std::string& key)
{
	if (_type != JSON_Object)
		return nullptr;

	std::map<std::string, JsonPtr>* data = (std::map<std::string, JsonPtr>*)_data;
	auto it = data->find(key);
	if (it != data->end())
		return it->second;
	else
		return nullptr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rsi)
je 0x16a34
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x16a5b
movq 0x8(%rsi), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x1b2b0
addq $0x8, %r14
cmpq %r14, %rax
je 0x16a2c
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x161bc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getNodeByIndex(int)
JsonPtr Json::getNodeByIndex(int index)
{
	if (_type != JSON_Array)
		return nullptr;

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

	return nullptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, (%rsi)
jne 0x16a92
movq 0x8(%rsi), %rax
incl %edx
movq %rax, %rsi
movq (%rsi), %rsi
cmpq %rax, %rsi
je 0x16a92
decl %edx
jne 0x16a78
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x161bc
jmp 0x16a98
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::getNode(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::getNode(const std::string& path, const std::string& delim)
{
	std::vector<std::string> sections;
	pathSplit(path, delim, sections);

	if (sections.empty())
		return getNodeByKey("");

	JsonPtr node = getNodeByKey(sections[0]);
	for (size_t i = 1; i < sections.size() && node != nullptr; i++)
		node = node->getNodeByKey(sections[i]);

	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movq %rax, %rdi
movq %rcx, %rsi
callq 0x16905
movq 0x10(%rsp), %rdx
cmpq 0x18(%rsp), %rdx
je 0x16b3d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16a20
pushq $0x1
popq %r12
pushq $0x20
popq %r13
leaq 0x38(%rsp), %r14
leaq 0x30(%rsp), %r15
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
subq %rdx, %rax
sarq $0x5, %rax
cmpq %rax, %r12
jae 0x16b6d
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x16b6d
addq %r13, %rdx
movq %r15, %rdi
callq 0x16a20
movq %rbx, %rdi
movq %r15, %rsi
callq 0x16632
movq %r14, %rdi
callq 0x161f0
incq %r12
addq $0x20, %r13
jmp 0x16af8
leaq 0x8930(%rip), %rsi      # 0x1f474
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16a20
leaq 0x30(%rsp), %rdi
callq 0xe0c0
leaq 0x10(%rsp), %rdi
callq 0x15930
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xe0c0
jmp 0x16bad
jmp 0x16b99
movq %rax, %r14
jmp 0x16bad
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x161f0
leaq 0x10(%rsp), %rdi
callq 0x15930
movq %r14, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::setDict()
void Json::setDict()
{
	if (_type != JSON_Object)
	{
		clean();
		_type = JSON_Object;
		_data = new std::map<std::string, JsonPtr>();
	}
	else
	{
		std::map<std::string, JsonPtr>* data = (std::map<std::string, JsonPtr>*)_data;
		data->clear();
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x17163
movq %rbx, %rdi
callq 0x1728a
andl $0x0, (%rbx)
pushq $0x30
popq %rdi
callq 0xe240
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
movq %rax, 0x8(%rbx)
popq %rbx
retq
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x1b33a
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::addNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<swxJson::Json>)
bool Json::addNode(const std::string& key, JsonPtr node)
{
	if (_type != JSON_Object)
	{
		if (_type == JSON_Uninit)
			setDict();
		else
			return false;
	}

	std::map<std::string, JsonPtr>* data = (std::map<std::string, JsonPtr>*)_data;
	auto it = data->find(key);
	if (it != data->end())
		return false;

	(*data)[key] = node;
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdi), %eax
testl %eax, %eax
je 0x1724f
cmpl $0x8, %eax
jne 0x17267
movq %r15, %rdi
callq 0x17126
movq 0x8(%r15), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b2b0
leaq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x1726b
xorl %eax, %eax
jmp 0x17283
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a8f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1ae3a
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::setBool(bool)
void Json::setBool(bool value)
{
	if (_type != JSON_Boolean)
	{
		clean();
		_type = JSON_Boolean;
	}

	_data = (value ? (void*)1 : 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x6, (%rdi)
je 0x1733d
movq %rbx, %rdi
callq 0x1728a
movl $0x6, (%rbx)
movzbl %bpl, %eax
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::setInt(long)
void Json::setInt(intmax_t value)
{
	if (_type != JSON_Integer)
	{
		clean();
		_type = JSON_Integer;
		_data = new intmax_t(value);
	}
	else
	{
		intmax_t *data = (intmax_t*)_data;
		*data = value;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x3, (%rdi)
jne 0x17364
movq 0x8(%r14), %rax
movq %rbx, (%rax)
jmp 0x17382
movq %r14, %rdi
callq 0x1728a
movl $0x3, (%r14)
pushq $0x8
popq %rdi
callq 0xe240
movq %rbx, (%rax)
movq %rax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::setUInt(unsigned long)
void Json::setUInt(uintmax_t value)
{
	if (_type != JSON_UInteger)
	{
		clean();
		_type = JSON_UInteger;
		_data = new uintmax_t(value);
	}
	else
	{
		uintmax_t *data = (uintmax_t*)_data;
		*data = value;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x4, (%rdi)
jne 0x173a2
movq 0x8(%r14), %rax
movq %rbx, (%rax)
jmp 0x173c0
movq %r14, %rdi
callq 0x1728a
movl $0x4, (%r14)
pushq $0x8
popq %rdi
callq 0xe240
movq %rbx, (%rax)
movq %rax, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::setReal(double)
void Json::setReal(double value)
{
	if (_type != JSON_Real)
	{
		clean();
		_type = JSON_Real;
		_data = new double(value);
	}
	else
	{
		double * data = (double*)_data;
		*data = value;
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x5, (%rdi)
jne 0x173df
movq 0x8(%rbx), %rax
movsd %xmm0, (%rax)
jmp 0x17409
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x1728a
movl $0x5, (%rbx)
pushq $0x8
popq %rdi
callq 0xe240
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %rax, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::setString(char const*)
void Json::setString(const char* value)
{
	if (_type != JSON_String)
	{
		clean();
		_type = JSON_String;
		if (value)
			_data = new std::string(value);
		else
			_data = new std::string("");
	}
	else
	{
		std::string * data = (std::string*)_data;
		if (value)
			data->assign(value);
		else
			data->assign("");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x2, (%rdi)
jne 0x17432
movq 0x8(%rbx), %rdi
testq %r15, %r15
je 0x17462
movq %r15, %rsi
jmp 0x17469
movq %rbx, %rdi
callq 0x1728a
movl $0x2, (%rbx)
pushq $0x20
popq %rdi
callq 0xe240
movq %rax, %r14
testq %r15, %r15
je 0x17477
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x14fc0
jmp 0x1748b
leaq 0x800b(%rip), %rsi      # 0x1f474
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xe3d0
leaq 0x7ff6(%rip), %rsi      # 0x1f474
leaq 0xe(%rsp), %rdx
movq %r14, %rdi
callq 0x14fc0
movq %r14, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1749b
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0xe250
movq %rbx, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::setString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Json::setString(const std::string& value)
{
	if (_type != JSON_String)
	{
		clean();
		_type = JSON_String;
		_data = new std::string(value);
	}
	else
	{
		std::string * data = (std::string*)_data;
		data->assign(value);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, (%rdi)
jne 0x174d3
movq 0x8(%rbx), %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xe110
movq %rbx, %rdi
callq 0x1728a
movl $0x2, (%rbx)
pushq $0x20
popq %rdi
callq 0xe240
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xe2e0
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0xe250
movq %rbx, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::setArray()
void Json::setArray()
{
	if (_type != JSON_Array)
	{
		clean();
		_type = JSON_Array;
		_data = new std::list<JsonPtr>();
	}
	else
	{
		std::list<JsonPtr>* data = (std::list<JsonPtr>*)_data;
		data->clear();
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x1752b
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x1a82c
movq %rbx, %rdi
callq 0x1728a
movl $0x1, (%rbx)
pushq $0x18
popq %rdi
callq 0xe240
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::pushNode(std::shared_ptr<swxJson::Json>)
bool Json::pushNode(JsonPtr node)
{
	if (_type != JSON_Array)
	{
		if (_type == JSON_Uninit)
			setArray();
		else
			return false;
	}

	std::list<JsonPtr>* data = (std::list<JsonPtr>*)_data;
	data->push_back(node);
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x17572
cmpl $0x8, %eax
jne 0x17582
movq %r14, %rdi
callq 0x17518
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x1a844
movb $0x1, %al
jmp 0x17584
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::pushNull(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::pushNull(const std::string& path, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->pushNull())
		return;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
pushq $0x1
popq %r8
movq %rbx, %rdi
callq 0x16d9c
movq (%rbx), %rdi
callq 0x1758c
testb %al, %al
je 0x177bf
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x7f14(%rip), %rsi      # 0x1f6e5
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x7eac(%rip), %rsi      # 0x1f696
leaq 0x7eeb(%rip), %rdx      # 0x1f6dc
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x29d, %ecx            # imm = 0x29D
callq 0x1a812
xorl %ebp, %ebp
leaq 0x104bc(%rip), %rsi     # 0x27cc8
leaq 0x3185(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x17832
jmp 0x1783f
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x1783f
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::pushBool(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&)
void Json::pushBool(const std::string& path, bool value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->pushBool(value))
		return;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x16d9c
movq (%r14), %rdi
movl %ebx, %esi
callq 0x16048
testb %al, %al
je 0x17894
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x7e3f(%rip), %rsi      # 0x1f6e5
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x7dd7(%rip), %rsi      # 0x1f696
leaq 0x7e39(%rip), %rdx      # 0x1f6ff
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2a6, %ecx            # imm = 0x2A6
callq 0x1a812
xorl %ebp, %ebp
leaq 0x103e7(%rip), %rsi     # 0x27cc8
leaq 0x30b0(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x17907
jmp 0x17914
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x17914
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::pushReal(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&)
void Json::pushReal(const std::string& path, double value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->pushReal(value))
		return;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rcx
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
pushq $0x1
popq %r8
movq %rbx, %rdi
callq 0x16d9c
movq (%rbx), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x15e70
testb %al, %al
je 0x17973
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x7d60(%rip), %rsi      # 0x1f6e5
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x7cf8(%rip), %rsi      # 0x1f696
leaq 0x7d63(%rip), %rdx      # 0x1f708
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2af, %ecx            # imm = 0x2AF
callq 0x1a812
xorl %ebp, %ebp
leaq 0x10308(%rip), %rsi     # 0x27cc8
leaq 0x2fd1(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x179e6
jmp 0x179f3
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x179f3
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::pushInt(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::pushInt(const std::string& path, intmax_t value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->pushInt(value))
		return;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x16d9c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x15cea
testb %al, %al
je 0x17a4a
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x7c89(%rip), %rsi      # 0x1f6e5
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x7c21(%rip), %rsi      # 0x1f696
leaq 0x7c95(%rip), %rdx      # 0x1f711
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2b8, %ecx            # imm = 0x2B8
callq 0x1a812
xorl %ebp, %ebp
leaq 0x10231(%rip), %rsi     # 0x27cc8
leaq 0x2efa(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x17abd
jmp 0x17aca
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x17aca
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::pushUInt(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::pushUInt(const std::string& path, uintmax_t value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->pushUInt(value))
		return;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x16d9c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1a850
testb %al, %al
je 0x17b20
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x7bb3(%rip), %rsi      # 0x1f6e5
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x7b4b(%rip), %rsi      # 0x1f696
leaq 0x7bc7(%rip), %rdx      # 0x1f719
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2c1, %ecx            # imm = 0x2C1
callq 0x1a812
xorl %ebp, %ebp
leaq 0x1015b(%rip), %rsi     # 0x27cc8
leaq 0x2e24(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x17b93
jmp 0x17ba0
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x17ba0
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::pushString(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::pushString(const std::string& path, const char* value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->pushString(value))
		return;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x16d9c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x15f48
testb %al, %al
je 0x17bf6
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x7add(%rip), %rsi      # 0x1f6e5
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x7a75(%rip), %rsi      # 0x1f696
leaq 0x7afa(%rip), %rdx      # 0x1f722
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2ca, %ecx            # imm = 0x2CA
callq 0x1a812
xorl %ebp, %ebp
leaq 0x10085(%rip), %rsi     # 0x27cc8
leaq 0x2d4e(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x17c69
jmp 0x17c76
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x17c76
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::pushString(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::pushString(const std::string& path, const std::string& value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->pushString(value))
		return;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x16d9c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x160d4
testb %al, %al
je 0x17ccc
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x7a07(%rip), %rsi      # 0x1f6e5
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x799f(%rip), %rsi      # 0x1f696
leaq 0x7a24(%rip), %rdx      # 0x1f722
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2d3, %ecx            # imm = 0x2D3
callq 0x1a812
xorl %ebp, %ebp
leaq 0xffaf(%rip), %rsi      # 0x27cc8
leaq 0x2c78(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x17d3f
jmp 0x17d4c
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x17d4c
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::pushArray(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::pushArray(const std::string& path, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	node = node->pushArray();
	if (node) return node;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x1
popq %r8
callq 0x16d9c
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1761e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x16632
leaq 0x10(%rsp), %rdi
callq 0x161f0
cmpq $0x0, (%rbx)
je 0x17dac
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %r14
leaq 0x7927(%rip), %rsi      # 0x1f6e5
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x78bf(%rip), %rsi      # 0x1f696
leaq 0x794f(%rip), %rdx      # 0x1f72d
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movl $0x2dc, %ecx            # imm = 0x2DC
callq 0x1a812
xorl %ebp, %ebp
leaq 0xfecf(%rip), %rsi      # 0x27cc8
leaq 0x2b98(%rip), %rdx      # 0x1a998
movq %r14, %rdi
callq 0xe380
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x17e1f
jmp 0x17e2c
movq %rax, %r15
movq %r14, %rdi
callq 0xe190
jmp 0x17e2c
movq %rax, %r15
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x161f0
movq %r15, %rdi
callq 0xe3a0
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::pushDict(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::pushDict(const std::string& path, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	node = node->pushDict();
	if (node) return node;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x1
popq %r8
callq 0x16d9c
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x176ce
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x16632
leaq 0x10(%rsp), %rdi
callq 0x161f0
cmpq $0x0, (%rbx)
je 0x17e8e
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %r14
leaq 0x7845(%rip), %rsi      # 0x1f6e5
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x77dd(%rip), %rsi      # 0x1f696
leaq 0x7877(%rip), %rdx      # 0x1f737
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movl $0x2e5, %ecx            # imm = 0x2E5
callq 0x1a812
xorl %ebp, %ebp
leaq 0xfded(%rip), %rsi      # 0x27cc8
leaq 0x2ab6(%rip), %rdx      # 0x1a998
movq %r14, %rdi
callq 0xe380
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x17f01
jmp 0x17f0e
movq %rax, %r15
movq %r14, %rdi
callq 0xe190
jmp 0x17f0e
movq %rax, %r15
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x161f0
movq %r15, %rdi
callq 0xe3a0
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::addBool(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&)
void Json::addBool(const std::string& path, bool value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->type() == JSON_Uninit)
		node->setBool(value);
	else
		throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x16d9c
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x17f66
movzbl %bl, %esi
callq 0x17322
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x77d0(%rip), %rsi      # 0x1f748
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x7705(%rip), %rsi      # 0x1f696
leaq 0x77a8(%rip), %rdx      # 0x1f740
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x31e, %ecx            # imm = 0x31E
callq 0x1a956
xorl %ebp, %ebp
leaq 0xfd2d(%rip), %rsi      # 0x27ce0
leaq 0x29de(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x17fd9
jmp 0x17fe1
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::addReal(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&)
void Json::addReal(const std::string& path, double value, const std::string& delim)
{
	JsonPtr node = createNode(path, delim, true);
	if (node->type() == JSON_Uninit)
		node->setReal(value);
	else
		throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rcx
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
pushq $0x1
popq %r8
movq %rbx, %rdi
callq 0x16d9c
movq (%rbx), %rdi
cmpl $0x8, (%rdi)
jne 0x18042
movsd 0x8(%rsp), %xmm0
callq 0x173c8
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x76f4(%rip), %rsi      # 0x1f748
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x7629(%rip), %rsi      # 0x1f696
leaq 0x76e6(%rip), %rdx      # 0x1f75a
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x327, %ecx            # imm = 0x327
callq 0x1a956
xorl %ebp, %ebp
leaq 0xfc51(%rip), %rsi      # 0x27ce0
leaq 0x2902(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x180b5
jmp 0x180c2
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x180c2
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x16d9c
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x18119
movq %rbx, %rsi
callq 0x1734c
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x761d(%rip), %rsi      # 0x1f748
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x7552(%rip), %rsi      # 0x1f696
leaq 0x7617(%rip), %rdx      # 0x1f762
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x330, %ecx            # imm = 0x330
callq 0x1a956
xorl %ebp, %ebp
leaq 0xfb7a(%rip), %rsi      # 0x27ce0
leaq 0x282b(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x1818c
jmp 0x18199
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x18199
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x16d9c
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x181f1
movq %rbx, %rsi
callq 0x1738a
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x7545(%rip), %rsi      # 0x1f748
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x747a(%rip), %rsi      # 0x1f696
leaq 0x7546(%rip), %rdx      # 0x1f769
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x339, %ecx            # imm = 0x339
callq 0x1a956
xorl %ebp, %ebp
leaq 0xfaa2(%rip), %rsi      # 0x27ce0
leaq 0x2753(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x18264
jmp 0x18271
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x18271
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x16d9c
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x182c9
movq %rbx, %rsi
callq 0x17410
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x746d(%rip), %rsi      # 0x1f748
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x73a2(%rip), %rsi      # 0x1f696
leaq 0x7476(%rip), %rdx      # 0x1f771
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x342, %ecx            # imm = 0x342
callq 0x1a956
xorl %ebp, %ebp
leaq 0xf9ca(%rip), %rsi      # 0x27ce0
leaq 0x267b(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x1833c
jmp 0x18349
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x18349
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x16d9c
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x183a1
movq %rbx, %rsi
callq 0x174b2
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x7395(%rip), %rsi      # 0x1f748
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x72ca(%rip), %rsi      # 0x1f696
leaq 0x739e(%rip), %rdx      # 0x1f771
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x34b, %ecx            # imm = 0x34B
callq 0x1a956
xorl %ebp, %ebp
leaq 0xf8f2(%rip), %rsi      # 0x27ce0
leaq 0x25a3(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x18414
jmp 0x18421
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
jmp 0x18421
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
pushq $0x1
popq %r8
movq %rbx, %rdi
callq 0x16d9c
movq (%rbx), %rdi
cmpl $0x8, (%rdi)
jne 0x18476
callq 0x1730c
leaq 0x18(%rsp), %rdi
callq 0x161f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x72c0(%rip), %rsi      # 0x1f748
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x71f5(%rip), %rsi      # 0x1f696
leaq 0x72d3(%rip), %rdx      # 0x1f77b
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x354, %ecx            # imm = 0x354
callq 0x1a956
xorl %ebp, %ebp
leaq 0xf81d(%rip), %rsi      # 0x27ce0
leaq 0x24ce(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x184e9
jmp 0x184f1
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x1
popq %r8
callq 0x16d9c
movq (%rbx), %rdi
cmpl $0x8, (%rdi)
jne 0x18535
callq 0x17518
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %r14
leaq 0x7201(%rip), %rsi      # 0x1f748
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x7136(%rip), %rsi      # 0x1f696
leaq 0x721c(%rip), %rdx      # 0x1f783
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movl $0x360, %ecx            # imm = 0x360
callq 0x1a956
xorl %ebp, %ebp
leaq 0xf75e(%rip), %rsi      # 0x27ce0
leaq 0x240f(%rip), %rdx      # 0x1a998
movq %r14, %rdi
callq 0xe380
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x185a8
jmp 0x185b5
movq %rax, %r15
movq %r14, %rdi
callq 0xe190
jmp 0x185b5
movq %rax, %r15
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x161f0
movq %r15, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
pushq $0x1
popq %r8
callq 0x16d9c
movq (%rbx), %rdi
cmpl $0x8, (%rdi)
jne 0x185fb
callq 0x17126
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %r14
leaq 0x713b(%rip), %rsi      # 0x1f748
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x7070(%rip), %rsi      # 0x1f696
leaq 0x715f(%rip), %rdx      # 0x1f78c
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movl $0x36c, %ecx            # imm = 0x36C
callq 0x1a956
xorl %ebp, %ebp
leaq 0xf698(%rip), %rsi      # 0x27ce0
leaq 0x2349(%rip), %rdx      # 0x1a998
movq %r14, %rdi
callq 0xe380
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x1866e
jmp 0x1867b
movq %rax, %r15
movq %r14, %rdi
callq 0xe190
jmp 0x1867b
movq %rax, %r15
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x161f0
movq %r15, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x186b5
movq 0x8(%rdi), %rdi
incl %esi
movq %rdi, %rax
movq (%rax), %rax
cmpq %rdi, %rax
je 0x186b5
decl %esi
jne 0x186a1
movq %rax, %rsi
callq 0x1a970
cmpl $0x1, %ebx
sete %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x16(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %r8
leaq 0x17(%rsp), %r9
movq %r14, %rsi
callq 0x16bc0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x1871b
movq 0x8(%rax), %rdi
movb $0x1, %bl
leaq 0x28(%rsp), %rsi
callq 0x1b7be
jmp 0x1873d
movb $0x1, %bl
cmpb $0x0, 0x16(%rsp)
jne 0x1873d
cmpb $0x0, 0x17(%rsp)
je 0x1872f
xorl %ebx, %ebx
jmp 0x1873d
movq 0x8(%r14), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1b7be
leaq 0x20(%rsp), %rdi
callq 0x161f0
leaq 0x28(%rsp), %rdi
callq 0xe0c0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x1875d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x161f0
jmp 0x1876f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xe0c0
movq %rbx, %rdi
callq 0xe3a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x16a9e
movq (%rbx), %rax
testq %rax, %rax
je 0x18803
movl (%rax), %ebx
leaq 0x18(%rsp), %rdi
callq 0x161f0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0xe0e0
movq %rax, %rbx
leaq 0x6f84(%rip), %rsi      # 0x1f799
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x14fc0
movb $0x1, %bpl
leaq 0x6e68(%rip), %rsi      # 0x1f696
leaq 0x6f5f(%rip), %rdx      # 0x1f794
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x3af, %ecx            # imm = 0x3AF
callq 0x1a97e
xorl %ebp, %ebp
leaq 0xf4a8(%rip), %rsi      # 0x27cf8
leaq 0x2141(%rip), %rdx      # 0x1a998
movq %rbx, %rdi
callq 0xe380
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xe0c0
testb %bpl, %bpl
jne 0x18876
jmp 0x1887e
movq %rax, %r14
movq %rbx, %rdi
callq 0xe190
leaq 0x18(%rsp), %rdi
callq 0x161f0
movq %r14, %rdi
callq 0xe3a0