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

// Assembly:
pushq %rbp
pushq %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 0x27700
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x209ff
movq %rbx, %rsi
callq 0x1e530
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xda04(%rip), %rsi      # 0x2e415
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xd9a7(%rip), %rsi      # 0x2e3d1
leaq 0xd9e0(%rip), %rdx      # 0x2e411
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x26f, %ecx            # imm = 0x26F
callq 0x26f64
xorl %ebp, %ebp
leaq 0x1a2e4(%rip), %rsi     # 0x3ad30
leaq 0x652b(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x20a72
jmp 0x20a7f
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x20a7f
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool add(const std::string& path, const std::unordered_set<Key, Hash, Pred, Alloc>& collections, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setArray(collections);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
pushq %rbp
pushq %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 0x27700
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x20ad9
movq %rbx, %rsi
callq 0x1e56c
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xd92a(%rip), %rsi      # 0x2e415
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xd8cd(%rip), %rsi      # 0x2e3d1
leaq 0xd906(%rip), %rdx      # 0x2e411
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x27c, %ecx            # imm = 0x27C
callq 0x26f64
xorl %ebp, %ebp
leaq 0x1a20a(%rip), %rsi     # 0x3ad30
leaq 0x6451(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x20b4c
jmp 0x20b59
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x20b59
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool add(const std::string& path, const std::map<std::string, T, Compare, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setDict(theMap);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
pushq %rbp
pushq %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 0x27700
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x20bb3
movq %rbx, %rsi
callq 0x1e59c
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xd850(%rip), %rsi      # 0x2e415
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xd7f3(%rip), %rsi      # 0x2e3d1
leaq 0xd82c(%rip), %rdx      # 0x2e411
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x289, %ecx            # imm = 0x289
callq 0x26f64
xorl %ebp, %ebp
leaq 0x1a130(%rip), %rsi     # 0x3ad30
leaq 0x6377(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x20c26
jmp 0x20c33
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x20c33
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::add<int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool add(const std::string& path, const std::unordered_map<std::string, T, Hash, Pred, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->type() == JSON_Uninit)
		{
			node->setDict(theMap);
			return true;
		}
		else
			throw JSON_ERROR_MSG(JosnNodeExistError, "Node has existed.");
	}

// Assembly:
pushq %rbp
pushq %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 0x27700
movq (%r14), %rdi
cmpl $0x8, (%rdi)
jne 0x20f1b
movq %rbx, %rsi
callq 0x1e6de
leaq 0x18(%rsp), %rdi
callq 0x2541a
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xd4e8(%rip), %rsi      # 0x2e415
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xd48b(%rip), %rsi      # 0x2e3d1
leaq 0xd4c4(%rip), %rdx      # 0x2e411
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x296, %ecx            # imm = 0x296
callq 0x26f64
xorl %ebp, %ebp
leaq 0x19dc8(%rip), %rsi     # 0x3ad30
leaq 0x600f(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x20f8e
jmp 0x20f9b
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x20f9b
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
nop
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<int, 4ul>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::array<int, 4ul> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::array<T, N>& arr, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(arr))
			return;

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

// Assembly:
pushq %rbp
pushq %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 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1f1a0
testb %al, %al
je 0x211e2
leaq 0x18(%rsp), %rdi
callq 0x2541a
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xd203(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xd1c4(%rip), %rsi      # 0x2e3d1
leaq 0xd21a(%rip), %rdx      # 0x2e42e
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2af, %ecx            # imm = 0x2AF
callq 0x26f18
xorl %ebp, %ebp
leaq 0x19a99(%rip), %rsi     # 0x3acc8
leaq 0x5d48(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x21255
jmp 0x21262
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x21262
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<int, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::deque<int, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::deque<T, Alloc>& deq, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(deq))
			return;

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

// Assembly:
pushq %rbp
pushq %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 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1f1e0
testb %al, %al
je 0x212b8
leaq 0x18(%rsp), %rdi
callq 0x2541a
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xd12d(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xd0ee(%rip), %rsi      # 0x2e3d1
leaq 0xd144(%rip), %rdx      # 0x2e42e
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2b9, %ecx            # imm = 0x2B9
callq 0x26f18
xorl %ebp, %ebp
leaq 0x199c3(%rip), %rsi     # 0x3acc8
leaq 0x5c72(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x2132b
jmp 0x21338
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x21338
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<std::vector, bool, std::allocator<bool>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<bool, std::allocator<bool>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const Container<T, Alloc>& container, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(container))
			return;

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

// Assembly:
pushq %rbp
pushq %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 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1f248
testb %al, %al
je 0x2138e
leaq 0x18(%rsp), %rdi
callq 0x2541a
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xd057(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xd018(%rip), %rsi      # 0x2e3d1
leaq 0xd06e(%rip), %rdx      # 0x2e42e
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2c5, %ecx            # imm = 0x2C5
callq 0x26f18
xorl %ebp, %ebp
leaq 0x198ed(%rip), %rsi     # 0x3acc8
leaq 0x5b9c(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x21401
jmp 0x2140e
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x2140e
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<int, std::less<int>, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::set<int, std::less<int>, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::set<T, Compare, Alloc>& collections, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(collections))
			return;

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

// Assembly:
pushq %rbp
pushq %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 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1f3a4
testb %al, %al
je 0x217bc
leaq 0x18(%rsp), %rdi
callq 0x2541a
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xcc29(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xcbea(%rip), %rsi      # 0x2e3d1
leaq 0xcc40(%rip), %rdx      # 0x2e42e
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2cf, %ecx            # imm = 0x2CF
callq 0x26f18
xorl %ebp, %ebp
leaq 0x194bf(%rip), %rsi     # 0x3acc8
leaq 0x576e(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x2182f
jmp 0x2183c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x2183c
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::unordered_set<Key, Hash, Pred, Alloc>& collections, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(collections))
			return;

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

// Assembly:
pushq %rbp
pushq %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 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1f3f0
testb %al, %al
je 0x21892
leaq 0x18(%rsp), %rdi
callq 0x2541a
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xcb53(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xcb14(%rip), %rsi      # 0x2e3d1
leaq 0xcb6a(%rip), %rdx      # 0x2e42e
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2d9, %ecx            # imm = 0x2D9
callq 0x26f18
xorl %ebp, %ebp
leaq 0x193e9(%rip), %rsi     # 0x3acc8
leaq 0x5698(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x21905
jmp 0x21912
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x21912
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::map<std::string, T, Compare, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(theMap))
			return;

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

// Assembly:
pushq %rbp
pushq %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 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1f426
testb %al, %al
je 0x21968
leaq 0x18(%rsp), %rdi
callq 0x2541a
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xca7d(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xca3e(%rip), %rsi      # 0x2e3d1
leaq 0xca94(%rip), %rdx      # 0x2e42e
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2e3, %ecx            # imm = 0x2E3
callq 0x26f18
xorl %ebp, %ebp
leaq 0x19313(%rip), %rsi     # 0x3acc8
leaq 0x55c2(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x219db
jmp 0x219e8
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x219e8
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: void swxJson::Json::merge<int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void merge(const std::string& path, const std::unordered_map<std::string, T, Hash, Pred, Alloc>& theMap, const std::string& delim = "./")
	{
		JsonPtr node = createNode(path, delim, true);
		if (node->merge(theMap))
			return;

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

// Assembly:
pushq %rbp
pushq %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 0x27700
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1f5c6
testb %al, %al
je 0x21cc0
leaq 0x18(%rsp), %rdi
callq 0x2541a
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x60
popq %rdi
callq 0x1a0f0
movq %rax, %rbx
leaq 0xc725(%rip), %rsi      # 0x2e3f7
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1dc4a
movb $0x1, %bpl
leaq 0xc6e6(%rip), %rsi      # 0x2e3d1
leaq 0xc73c(%rip), %rdx      # 0x2e42e
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x2ed, %ecx            # imm = 0x2ED
callq 0x26f18
xorl %ebp, %ebp
leaq 0x18fbb(%rip), %rsi     # 0x3acc8
leaq 0x526a(%rip), %rdx      # 0x26f7e
movq %rbx, %rdi
callq 0x1a360
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1a0d0
testb %bpl, %bpl
jne 0x21d33
jmp 0x21d40
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a1a0
jmp 0x21d40
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x2541a
movq %r14, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/swxlion[P]swxJson/tests/../src/swxJson.h
// Function: bool swxJson::Json::addBasicValue<bool>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
inline bool addBasicValue(const std::string& key, TYPE value)
	{
		//JsonPtr node(new Json(value));
		JsonPtr node(new Json());
		(*node) = value;
		return addNode(key, node);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x1a230
movl $0x8, (%rax)
andq $0x0, 0x8(%rax)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x25328
movq (%r15), %rdi
movl %ebp, %esi
callq 0x27c86
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x253e6
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x27b92
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x2541a
leaq 0x10(%rsp), %rdi
callq 0x2541a
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2541a
jmp 0x26c9e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2541a
movq %rbx, %rdi
callq 0x1a380
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/download.cpp
// Function: get_file(char*, unsigned int*)
char *get_file(char *filename, unsigned int *size)
{
	FILE	*file;
	char	*buffer;
	int	file_size, bytes_read;
	
	file = fopen(filename, "rb");
	if (file == NULL)
		return 0;
	fseek(file, 0, SEEK_END);
	file_size = ftell(file);
	fseek(file, 0, SEEK_SET);
	buffer = new char [file_size + 1];
	bytes_read = (int)fread(buffer, sizeof(char), file_size, file);
	if (bytes_read != file_size)
	{
		delete [] buffer;
		fclose(file);
		return 0;
	}
	fclose(file);
	buffer[file_size] = '\0';

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

	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xcd0(%rip), %rsi       # 0x2004
callq 0x1190
testq %rax, %rax
je 0x13b5
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1170
movq %r14, %rdi
callq 0x1030
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1170
leal 0x1(%r12), %eax
movslq %eax, %rdi
callq 0x1040
movq %rax, %r15
movslq %r12d, %r13
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r13, %rdx
movq %r14, %rcx
callq 0x11c0
cmpl %r13d, %eax
jne 0x13a5
movq %r14, %rdi
callq 0x1150
movb $0x0, (%r15,%r13)
testq %rbx, %rbx
je 0x13b8
movl %r12d, (%rbx)
jmp 0x13b8
movq %r15, %rdi
callq 0x11a0
movq %r14, %rdi
callq 0x1150
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/download.cpp
// Function: StripChars(char const*, char*, char*)
void StripChars(const char *in, char *out, char *stripc)
{
    while (*in)
    {
    	bool flag = false;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
movb (%r15), %r13b
testb %r13b, %r13b
je 0x1801
movq %r14, %rdi
callq 0x10d0
testl %eax, %eax
cmovlel %r12d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x17f6
leaq 0x1(%rcx), %rdx
cmpb (%r14,%rcx), %r13b
movq %rdx, %rcx
jne 0x17e2
jmp 0x17fc
movb %r13b, (%rbx)
incq %rbx
incq %r15
jmp 0x17ca
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/download.cpp
// Function: main
int main(int argc, char *argv[])
{
	unsigned short port = 65535;
	unsigned int size = 0;

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

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
cmpl $0x3, %edi
jg 0x1838
leaq 0xa6f(%rip), %rdi       # 0x22a2
jmp 0x18e2
movq %rsi, %r14
movq 0x10(%rsi), %rdi
callq 0x11e0
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x11e0
movl %eax, %r12d
leaq 0x857(%rip), %rdi       # 0x20b1
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movl %r12d, %edi
callq 0x11b0
movq %rax, %r13
testq %rax, %rax
je 0x1995
leaq -0x2c(%rbp), %rax
andl $0x0, (%rax)
xorps %xmm0, %xmm0
leaq -0xb0(%rbp), %rbx
movaps %xmm0, 0x70(%rbx)
movaps %xmm0, 0x60(%rbx)
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq 0x8(%r14), %rsi
movzwl %r15w, %edx
leaq 0x81f(%rip), %rdi       # 0x20d5
xorl %eax, %eax
callq 0x1060
movq 0x8(%r14), %rdi
movzwl %r15w, %esi
movq %r13, %rdx
movl %r12d, %ecx
leaq -0x2c(%rbp), %r8
movq %rbx, %r9
callq 0x1443
testl %eax, %eax
je 0x18fb
leaq 0x9af(%rip), %rdi       # 0x2291
callq 0x11d0
xorl %eax, %eax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x97c(%rip), %rdi       # 0x227e
callq 0x11d0
movl -0x2c(%rbp), %r14d
leaq 0x7f4(%rip), %rdi       # 0x2106
movl %r14d, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
leaq -0x2b0(%rbp), %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x1100
leaq -0x1b0(%rbp), %r12
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
xorl %esi, %esi
callq 0x1100
leaq 0x7d0(%rip), %rdx       # 0x2122
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17b0
leaq 0x7ca(%rip), %rsi       # 0x212e
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1080
leaq 0x7c4(%rip), %rdi       # 0x213c
movq %r15, %rsi
xorl %eax, %eax
callq 0x1060
movq %r15, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0x13ca
jmp 0x18e7
leaq 0x72b(%rip), %rdi       # 0x20c7
callq 0x1130
jmp 0x1877
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/word_transform.cc
// Function: buildMap[abi:cxx11](std::basic_ifstream<char, std::char_traits<char>>&)
map<string, string> buildMap(ifstream& map_file)
{
	map<string, string> trans_map;   // holds the transformations
	string key;    // a word to transform
	string value;  // phrase to use instead
	// read the first word into key and the rest of the line into value
	while (map_file >> key && getline(map_file, value))
		if (value.size() > 1) // check that there is a transformation
			trans_map[key] = value.substr(1); // skip leading space
		else
			throw runtime_error("no rule for " + key);
	return trans_map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, %r14
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rax)
movb %dl, (%rcx)
leaq -0x88(%rbp), %r15
leaq -0x68(%rbp), %r12
leaq -0x48(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x21c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2486
movq %r14, %rdi
movq %r12, %rsi
callq 0x2060
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2486
cmpq $0x2, -0x60(%rbp)
jb 0x24ad
movq %r13, %rdi
movq %r12, %rsi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
callq 0x2190
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2930
movq %rax, %rdi
movq %r13, %rsi
callq 0x21b0
movq %r13, %rdi
callq 0x20d0
jmp 0x241c
leaq -0x68(%rbp), %rdi
callq 0x20d0
leaq -0x88(%rbp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x2100
movq %rax, %r14
leaq 0xb45(%rip), %rsi       # 0x3004
leaq -0x48(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x2999
movb $0x1, %r12b
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x2210
xorl %r12d, %r12d
movq 0x2b08(%rip), %rsi      # 0x4ff0
movq 0x2ad9(%rip), %rdx      # 0x4fc8
movq %r14, %rdi
callq 0x2240
movq %rax, %r15
leaq -0x48(%rbp), %rdi
callq 0x20d0
testb %r12b, %r12b
jne 0x250d
jmp 0x252a
movq %rax, %r15
movq %r14, %rdi
callq 0x2120
jmp 0x252a
movq %rax, %r15
leaq -0x48(%rbp), %rdi
callq 0x20d0
jmp 0x252a
jmp 0x2527
movq %rax, %r15
leaq -0x68(%rbp), %rdi
callq 0x20d0
leaq -0x88(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2a78
movq %r15, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/word_transform.cc
// Function: main
int main(int argc, char **argv)
{
	// open and check both files
	if (argc != 3)
		throw runtime_error("wrong number of arguments");

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

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

	word_transform(map_file, input);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
cmpl $0x3, %edi
jne 0x284c
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
leaq -0x420(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2260
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x400(%rbp,%rax)
jne 0x287c
movq 0x10(%rbx), %rsi
leaq -0x218(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2260
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
jne 0x28ae
leaq -0x420(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x257e
leaq -0x218(%rbp), %rdi
callq 0x2070
leaq -0x420(%rbp), %rdi
callq 0x2070
xorl %eax, %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x2100
movq %rax, %r14
leaq 0x7e5(%rip), %rsi       # 0x3043
movq %rax, %rdi
callq 0x20a0
movq 0x2783(%rip), %rsi      # 0x4ff0
movq 0x2754(%rip), %rdx      # 0x4fc8
movq %r14, %rdi
callq 0x2240
pushq $0x10
popq %rdi
callq 0x2100
movq %rax, %r14
leaq 0x7cf(%rip), %rsi       # 0x305d
movq %rax, %rdi
callq 0x20a0
movq 0x2753(%rip), %rsi      # 0x4ff0
movq 0x2724(%rip), %rdx      # 0x4fc8
movq %r14, %rdi
callq 0x2240
jmp 0x28de
pushq $0x10
popq %rdi
callq 0x2100
movq %rax, %r14
leaq 0x7b4(%rip), %rsi       # 0x3074
movq %rax, %rdi
callq 0x20a0
movq 0x2721(%rip), %rsi      # 0x4ff0
movq 0x26f2(%rip), %rdx      # 0x4fc8
movq %r14, %rdi
callq 0x2240
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
jmp 0x290f
jmp 0x2907
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
jmp 0x291b
movq %rax, %rbx
movq %r14, %rdi
callq 0x2120
jmp 0x2927
movq %rax, %rbx
jmp 0x291b
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2070
leaq -0x420(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day04/ex00/main.cpp
// Function: main
int main(void)
{
	Sorcerer john("John", "Master");
	std::cout << john << std::endl;
	Victim micheal("Micheal");
	Victim tmp = micheal;
	Peon rose("Rose");
	Peon roseCopy = rose;
	Victim michealCopy(micheal);
	john.polymorph(micheal);
	john.polymorph(rose);
	john.polymorph(roseCopy);
	std::cout << micheal << std::endl;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
leaq 0x766(%rip), %rsi       # 0x2145
leaq -0x128(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x1c30
leaq 0x754(%rip), %rsi       # 0x214a
leaq -0x108(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x1c30
leaq -0x168(%rbp), %rdi
leaq -0x128(%rbp), %rsi
leaq -0x108(%rbp), %rdx
callq 0x14a4
leaq -0x108(%rbp), %rdi
callq 0x1060
leaq -0x128(%rbp), %rdi
callq 0x1060
movq 0x2596(%rip), %rdi      # 0x3fd8
leaq -0x168(%rbp), %rsi
callq 0x16b2
movq %rax, %rdi
callq 0x1070
leaq 0x6f4(%rip), %rsi       # 0x2151
leaq -0xe8(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x1c30
leaq -0x30(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1774
leaq -0xe8(%rbp), %rdi
callq 0x1060
leaq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17e2
leaq 0x6b6(%rip), %rsi       # 0x2159
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x1c30
leaq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x12fc
leaq -0x78(%rbp), %rdi
callq 0x1060
leaq -0x58(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x138c
leaq -0x190(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17e2
leaq -0x168(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x16a4
leaq -0x168(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x16a4
leaq -0x168(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x16a4
movq 0x24b5(%rip), %rdi      # 0x3fd8
leaq -0x30(%rbp), %rsi
callq 0x194c
movq %rax, %rdi
callq 0x1070
leaq -0x190(%rbp), %rdi
callq 0x1882
leaq -0x58(%rbp), %rdi
callq 0x1404
leaq -0xa0(%rbp), %rdi
callq 0x1404
leaq -0xc8(%rbp), %rdi
callq 0x1882
leaq -0x30(%rbp), %rdi
callq 0x1882
leaq -0x168(%rbp), %rdi
callq 0x1606
xorl %eax, %eax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %rbp
retq
movq %rax, %rbx
jmp 0x1bf2
movq %rax, %rbx
jmp 0x1bfb
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x1060
jmp 0x1c07
movq %rax, %rbx
jmp 0x1c07
movq %rax, %rbx
jmp 0x1c13
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x1060
jmp 0x1c1c
jmp 0x1bde
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x1060
jmp 0x1bcb
movq %rax, %rbx
leaq -0x128(%rbp), %rdi
callq 0x1060
jmp 0x1c28
movq %rax, %rbx
jmp 0x1c28
movq %rax, %rbx
jmp 0x1c1c
movq %rax, %rbx
leaq -0x190(%rbp), %rdi
callq 0x1882
leaq -0x58(%rbp), %rdi
callq 0x1404
leaq -0xa0(%rbp), %rdi
callq 0x1404
leaq -0xc8(%rbp), %rdi
callq 0x1882
leaq -0x30(%rbp), %rdi
callq 0x1882
leaq -0x168(%rbp), %rdi
callq 0x1606
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_vectornorm.cpp
// Function: double norm<double>::norm_impl<7u>(exprtk::type_store<double>::type_view<double> const&, unsigned long, unsigned long)
inline T norm_impl(const vector_t& vector, const std::size_t r0, const std::size_t r1)
   {
      T sum = T(0);

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

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

// Assembly:
movq 0x8(%rsi), %rax
xorpd %xmm0, %xmm0
movapd 0x12372e(%rip), %xmm1   # 0x237040
cmpq %rcx, %rdx
ja 0x11393d
movsd (%rax,%rdx,8), %xmm2
movapd %xmm2, %xmm3
andpd %xmm1, %xmm3
mulsd %xmm2, %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm3, %xmm2
addsd %xmm2, %xmm0
incq %rdx
jmp 0x113912
movsd 0x12377b(%rip), %xmm1   # 0x2370c0
jmp 0x10e190
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_vectornorm.cpp
// Function: norm<double>::norm_impl(exprtk::type_store<double>::type_view<double> const&, unsigned int, unsigned long, unsigned long)
inline T norm_impl(const vector_t& vector, unsigned int pow, const std::size_t r0, const std::size_t r1)
   {
      T sum = T(0);

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movl %edx, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
cmpq %rbx, %r14
ja 0x114360
movq 0x8(%r15), %rax
movsd %xmm0, (%rsp)
movsd (%rax,%r14,8), %xmm0
andpd 0x122d03(%rip), %xmm0   # 0x237040
movsd 0x8(%rsp), %xmm1
callq 0x10e190
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r14
jmp 0x114321
movsd 0x122e28(%rip), %xmm1   # 0x237190
divsd 0x8(%rsp), %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x10e190
// File: /workspace/github_cpp_makefile_star2_O2/zengfenfei[P]codility/src/PassingCars.cpp
// Function: solution(std::vector<int, std::allocator<int>>&)
int solution(vector<int> &A) {
	int carsToEast = 0;
	int pairs = 0;
	for (int i = 0; i < A.size(); i++) {
		if (A[i] == 0) {
			carsToEast++;
		} else {
			pairs += carsToEast;
		}
		if (pairs > 1000000000) {
			return -1;
		}
	}
	return pairs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
xorl %esi, %esi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
xorl %eax, %eax
cmpq %rsi, %rdx
je 0x1276
movl (%rcx,%rsi,4), %r9d
testl %r9d, %r9d
movl %r8d, %r10d
cmovel %r9d, %r10d
addl %r10d, %eax
cmpl $0x3b9aca00, %eax       # imm = 0x3B9ACA00
ja 0x1274
cmpl $0x1, %r9d
adcl $0x0, %r8d
incq %rsi
jmp 0x124a
movl %edi, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/zengfenfei[P]codility/src/PassingCars.cpp
// Function: main
int main() {
	vector<int> A(5);
	A[0] = 0;
	A[1] = 1;
	A[2] = 0;
	A[3] = 1;
	A[4] = 1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x28(%rbp), %rbx
pushq $0x5
popq %rsi
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x12f0
movq (%rbx), %rax
movaps 0xd72(%rip), %xmm0      # 0x2010
movups %xmm0, (%rax)
movl $0x1, 0x10(%rax)
movq %rbx, %rdi
callq 0x122c
movq 0x2d21(%rip), %rdi      # 0x3fd8
movl %eax, %esi
callq 0x10d0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x10b0
leaq -0x28(%rbp), %rdi
callq 0x137c
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x137c
movq %rbx, %rdi
callq 0x10e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<MulticolorValue, true>::print_simple(std::ostream&)
void print_simple(std::ostream &os) {
		for(int i = 0; i < height; ++i) {
			if(i == 0) {
				field[0].begin_screen(os);
			}

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movslq 0x18(%r14), %rax
cmpq %rax, %r15
jge 0x49f5
xorl %ebp, %ebp
movl 0x1c(%r14), %eax
cmpl %eax, %ebp
jge 0x49d6
imull %r15d, %eax
addl %ebp, %eax
cltq
leaq (%rax,%rax,4), %rdi
addq (%r14), %rdi
movq %rbx, %rsi
callq 0x5910
incl %ebp
jmp 0x49b3
movl 0x18(%r14), %eax
decl %eax
cmpq %rax, %r15
jne 0x49f0
leaq (%r15,%r15,4), %rdi
addq (%r14), %rdi
movq %rbx, %rsi
callq 0x59d2
incq %r15
jmp 0x49a8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/sgielen[P]clife/multicolor.cpp
// Function: MulticolorValue::MulticolorValue(bool)
MulticolorValue(bool value) : value(value), red(0), green(0), blue(0), age(0) {
		if(value) {
			char color = (rand() % 6) + 1;
			red   = (color & 1) ? 255 : 0;
			green = (color & 2) ? 255 : 0;
			blue  = (color & 4) ? 255 : 0;
		}
	}

// Assembly:
movb %sil, (%rdi)
andl $0x0, 0x1(%rdi)
testl %esi, %esi
je 0x4ca0
pushq %rbx
movq %rdi, %rbx
callq 0x2030
pushq $0x6
popq %rcx
cltd
idivl %ecx
leal 0x1(%rdx), %eax
andb $0x1, %dl
decb %dl
movb %dl, 0x1(%rbx)
movl %eax, %ecx
shll $0x1e, %ecx
sarl $0x1f, %ecx
movb %cl, 0x2(%rbx)
shll $0x1d, %eax
sarl $0x1f, %eax
movb %al, 0x3(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sgielen[P]clife/multicolor.cpp
// Function: MulticolorValue::print(std::ostream&) const
void print(std::ostream &os) const {
		if(value && to_ledscreen) {
			os << red << green << blue;
		} else if(value) {
			double brightness = std::max(0.3, 1 - age / 20.);

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

// Assembly:
movq %rsi, %rax
cmpb $0x1, (%rdi)
jne 0x59c6
pushq %rbx
movzbl 0x4(%rdi), %ecx
cvtsi2sd %ecx, %xmm0
divsd 0x77b(%rip), %xmm0      # 0x60a8
addsd 0x77b(%rip), %xmm0      # 0x60b0
maxsd 0x77b(%rip), %xmm0      # 0x60b8
movzbl 0x3(%rdi), %ecx
cvtsi2sd %ecx, %xmm1
mulsd %xmm0, %xmm1
divsd 0x76f(%rip), %xmm1      # 0x60c0
cvttsd2si %xmm1, %ecx
movzwl 0x1(%rdi), %edx
movd %edx, %xmm1
pxor %xmm2, %xmm2
punpcklbw %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3],xmm1[4],xmm2[4],xmm1[5],xmm2[5],xmm1[6],xmm2[6],xmm1[7],xmm2[7]
punpcklwd %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
cvtdq2pd %xmm1, %xmm1
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
mulpd %xmm1, %xmm0
divpd 0x6e3(%rip), %xmm0      # 0x6060
cvttpd2dq %xmm0, %xmm0
pshuflw $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3,4,5,6,7]
pmullw 0x6e2(%rip), %xmm0      # 0x6070
movd %xmm0, %ebx
addl %ebx, %ecx
shrl $0x10, %ebx
addb %cl, %bl
addb $0x10, %bl
leaq 0x93b(%rip), %rsi       # 0x62de
movq %rax, %rdi
callq 0x2180
movzbl %bl, %esi
movq %rax, %rdi
callq 0x2270
leaq 0x929(%rip), %rsi       # 0x62e6
movq %rax, %rdi
popq %rbx
jmp 0x2180
pushq $0x20
popq %rsi
movq %rax, %rdi
jmp 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/rollhash_x.c
// Function: main
int main(void)
{
    plan_tests(14);

    uint8_t test[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    uint32_t i, arg = rollhash_arg(12), roll = rollhash_init(test, 12);

    for (i = 0; i < 26 - 12; i++) {
        uint hash = rollhash_init(test + i + 1, 12);
        roll = rollhash_step(arg, roll, test[i], test[i+12]);
        ok(roll == hash, "-%c +%c", test[i], test[i+12]);
    }   

    return exit_status();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0xe
popq %rdi
callq 0x1c73
leaq 0xd8a(%rip), %rdi       # 0x2010
callq 0x1341
movl %eax, %r15d
movl $0x7f807f, %ebp         # imm = 0x7F807F
leaq 0xd96(%rip), %rbx       # 0x2030
leaq 0xd8a(%rip), %r14       # 0x202b
xorl %r13d, %r13d
cmpq $0xe, %r13
je 0x132e
leaq 0xd5b(%rip), %rax       # 0x2010
leaq (%rax,%r13), %r12
incq %r12
movq %r12, %rdi
callq 0x1341
movl %eax, %ecx
movzbl -0x1(%r12), %r10d
movzbl 0xb(%r12), %r11d
imull $0xfffafdf0, %r10d, %eax # imm = 0xFFFAFDF0
addl %r15d, %eax
addl $0x7f807f00, %eax       # imm = 0x7F807F00
xorl %edx, %edx
divl %ebp
shll $0x8, %edx
leal (%rdx,%r11), %eax
xorl %edx, %edx
divl %ebp
xorl %esi, %esi
movl %edx, %r15d
cmpl %ecx, %edx
sete %sil
subq $0x8, %rsp
xorl %edi, %edi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
xorl %eax, %eax
pushq %r11
pushq %r10
leaq 0xd25(%rip), %r10       # 0x203d
pushq %r10
pushq $0xe
pushq %rbx
callq 0x1364
addq $0x30, %rsp
incq %r13
jmp 0x12a4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f11
// File: /workspace/github_cpp_makefile_star2_O2/eschwabe[P]interview-practice/src/stringcombinations.cpp
// Function: combinations(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
void combinations(string source, string str, size_t target_len) {
    if(str.size() == target_len) {
        cout << str << endl;
    }
    else {
        string tmpsource = source;
        while(tmpsource.size() > 0) {
            string tmpstr = str;
            tmpstr.push_back(tmpsource.at(0));
            tmpsource.erase(0, 1);
            combinations(tmpsource, tmpstr, target_len);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
cmpq %rdx, 0x8(%rsi)
jne 0x127e
movq 0x2d7b(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
callq 0x10b0
movq %rax, %rdi
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
movq %rdx, %r14
movq %rdi, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x10c0
leaq 0x68(%rsp), %r12
leaq 0x48(%rsp), %rbp
leaq 0x28(%rsp), %r13
cmpq $0x0, 0x10(%rsp)
je 0x1313
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10c0
movq %r15, %rdi
xorl %esi, %esi
callq 0x1100
movsbl (%rax), %esi
movq %r12, %rdi
callq 0x1090
movq %r15, %rdi
xorl %esi, %esi
pushq $0x1
popq %rdx
callq 0x1030
movq %rbp, %rdi
movq %r15, %rsi
callq 0x10c0
movq %r13, %rdi
movq %r12, %rsi
callq 0x10c0
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x123c
movq %r13, %rdi
callq 0x1050
movq %rbp, %rdi
callq 0x1050
movq %r12, %rdi
callq 0x1050
jmp 0x12a0
leaq 0x8(%rsp), %rdi
callq 0x1050
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1341
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1050
leaq 0x48(%rsp), %rdi
callq 0x1050
jmp 0x1355
movq %rax, %rbx
jmp 0x135f
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x1050
leaq 0x8(%rsp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x10e0