LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantInt(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&)
intmax_t Json::wantInt(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantInt();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x178d6
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1b23d
callq 0x1a09a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b22f
callq 0x16eec
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x661c(%rip), %rsi      # 0x21876
leaq 0x662f(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x6435(%rip), %rsi      # 0x216aa
leaq 0x6563(%rip), %rdx      # 0x217df
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x502, %ecx            # imm = 0x502
callq 0x1ee7c
leaq 0xdae3(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xda43(%rip), %rsi      # 0x28ce8
leaq 0x162c(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b2d6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1b2d6
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1b2e8
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1b2e8
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b2f7
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantUInt(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&)
uintmax_t Json::wantUInt(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantUInt();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x178d6
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1b34d
callq 0x1a17e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b33f
callq 0x16eec
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x650c(%rip), %rsi      # 0x21876
leaq 0x651f(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x6325(%rip), %rsi      # 0x216aa
leaq 0x645b(%rip), %rdx      # 0x217e7
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x50b, %ecx            # imm = 0x50B
callq 0x1ee7c
leaq 0xd9d3(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd933(%rip), %rsi      # 0x28ce8
leaq 0x151c(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b3e6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1b3e6
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1b3f8
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1b3f8
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b407
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantReal(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&)
double Json::wantReal(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantReal();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x178d6
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1b461
callq 0x1a262
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b456
movsd %xmm0, (%rsp)
callq 0x16eec
movsd (%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x63f8(%rip), %rsi      # 0x21876
leaq 0x640b(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x6211(%rip), %rsi      # 0x216aa
leaq 0x6350(%rip), %rdx      # 0x217f0
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x514, %ecx            # imm = 0x514
callq 0x1ee7c
leaq 0xd8bf(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd81f(%rip), %rsi      # 0x28ce8
leaq 0x1408(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b4fa
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1b4fa
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1b50c
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1b50c
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b51b
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Json::wantString(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantString();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1b56b
movq %rbx, %rdi
callq 0x1a332
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b55d
callq 0x16eec
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x62ee(%rip), %rsi      # 0x21876
leaq 0x6301(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x6107(%rip), %rsi      # 0x216aa
leaq 0x624f(%rip), %rdx      # 0x217f9
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x51d, %ecx            # imm = 0x51D
callq 0x1ee7c
leaq 0xd7b5(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd715(%rip), %rsi      # 0x28ce8
leaq 0x12fe(%rip), %rdx      # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1b604
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1b604
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1b616
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1b616
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1b625
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantBoolVector(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<bool> Json::wantBoolVector(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantBoolVector();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1ba75
movq %rbx, %rdi
callq 0x1a41a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ba67
callq 0x16eec
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5de4(%rip), %rsi      # 0x21876
leaq 0x5df7(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x5bfd(%rip), %rsi      # 0x216aa
leaq 0x5d50(%rip), %rdx      # 0x21804
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x551, %ecx            # imm = 0x551
callq 0x1ee7c
leaq 0xd2ab(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd20b(%rip), %rsi      # 0x28ce8
leaq 0xdf4(%rip), %rdx       # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1bb0e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1bb0e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1bb20
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1bb20
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bb2f
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantRealVector(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<double> Json::wantRealVector(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantRealVector();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1bb7f
movq %rbx, %rdi
callq 0x1a540
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bb71
callq 0x16eec
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5cda(%rip), %rsi      # 0x21876
leaq 0x5ced(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x5af3(%rip), %rsi      # 0x216aa
leaq 0x5c55(%rip), %rdx      # 0x21813
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x55a, %ecx            # imm = 0x55A
callq 0x1ee7c
leaq 0xd1a1(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xd101(%rip), %rsi      # 0x28ce8
leaq 0xcea(%rip), %rdx       # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1bc18
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1bc18
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1bc2a
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1bc2a
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bc39
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantIntVector(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<intmax_t> Json::wantIntVector(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantIntVector();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1bc89
movq %rbx, %rdi
callq 0x1a68a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bc7b
callq 0x16eec
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5bd0(%rip), %rsi      # 0x21876
leaq 0x5be3(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x59e9(%rip), %rsi      # 0x216aa
leaq 0x5b5a(%rip), %rdx      # 0x21822
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x563, %ecx            # imm = 0x563
callq 0x1ee7c
leaq 0xd097(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xcff7(%rip), %rsi      # 0x28ce8
leaq 0xbe0(%rip), %rdx       # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1bd22
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1bd22
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1bd34
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1bd34
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bd43
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantStringVector(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::string> Json::wantStringVector(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantStringVector();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1bd93
movq %rbx, %rdi
callq 0x1a7d2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bd85
callq 0x16eec
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5ac6(%rip), %rsi      # 0x21876
leaq 0x5ad9(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x58df(%rip), %rsi      # 0x216aa
leaq 0x5a5e(%rip), %rdx      # 0x21830
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x56c, %ecx            # imm = 0x56C
callq 0x1ee7c
leaq 0xcf8d(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xceed(%rip), %rsi      # 0x28ce8
leaq 0xad6(%rip), %rdx       # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1be2c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1be2c
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1be3e
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1be3e
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1be4d
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantBoolDict(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::map<std::string, bool> Json::wantBoolDict(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantBoolDict();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1be9d
movq %rbx, %rdi
callq 0x1a938
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1be8f
callq 0x16eec
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x59bc(%rip), %rsi      # 0x21876
leaq 0x59cf(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x57d5(%rip), %rsi      # 0x216aa
leaq 0x5965(%rip), %rdx      # 0x21841
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x576, %ecx            # imm = 0x576
callq 0x1ee7c
leaq 0xce83(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xcde3(%rip), %rsi      # 0x28ce8
leaq 0x9cc(%rip), %rdx       # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1bf36
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1bf36
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1bf48
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1bf48
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bf57
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantRealDict(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::map<std::string, double> Json::wantRealDict(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantRealDict();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1bfa7
movq %rbx, %rdi
callq 0x1aa6c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bf99
callq 0x16eec
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x58b2(%rip), %rsi      # 0x21876
leaq 0x58c5(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x56cb(%rip), %rsi      # 0x216aa
leaq 0x5868(%rip), %rdx      # 0x2184e
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x57f, %ecx            # imm = 0x57F
callq 0x1ee7c
leaq 0xcd79(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xccd9(%rip), %rsi      # 0x28ce8
leaq 0x8c2(%rip), %rdx       # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c040
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1c040
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1c052
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1c052
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c061
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantIntDict(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::map<std::string, intmax_t> Json::wantIntDict(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantIntDict();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1c0b1
movq %rbx, %rdi
callq 0x1aba8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c0a3
callq 0x16eec
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x57a8(%rip), %rsi      # 0x21876
leaq 0x57bb(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x55c1(%rip), %rsi      # 0x216aa
leaq 0x576b(%rip), %rdx      # 0x2185b
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x588, %ecx            # imm = 0x588
callq 0x1ee7c
leaq 0xcc6f(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xcbcf(%rip), %rsi      # 0x28ce8
leaq 0x7b8(%rip), %rdx       # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c14a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1c14a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1c15c
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1c15c
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c16b
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: swxJson::Json::wantStringDict(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::map<std::string, std::string> Json::wantStringDict(const std::string& path, const std::string& delim)
{
	JsonPtr node = getNode(path, delim);
	if (node)
		return node->wantStringDict();
	
	throw JSON_ERROR_MSG(JosnNodeNotExistError, "Target node doesn't exist.");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x178d6
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1c1bb
movq %rbx, %rdi
callq 0x1acdc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c1ad
callq 0x16eec
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x60, %edi
callq 0xb0f0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x569e(%rip), %rsi      # 0x21876
leaq 0x56b1(%rip), %rdx      # 0x21890
leaq 0x18(%rsp), %rdi
callq 0x17258
movb $0x1, %bpl
leaq 0x54b7(%rip), %rsi      # 0x216aa
leaq 0x566d(%rip), %rdx      # 0x21867
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movl $0x591, %ecx            # imm = 0x591
callq 0x1ee7c
leaq 0xcb65(%rip), %rax      # 0x28d78
addq $0x10, %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xcac5(%rip), %rsi      # 0x28ce8
leaq 0x6ae(%rip), %rdx       # 0x1c8d8
movq %rbx, %rdi
callq 0xb390
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1c254
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb260
jmp 0x1c254
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1c266
movq %rbx, %rdi
callq 0xb1c0
jmp 0x1c266
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c275
callq 0x16eec
movq %r14, %rdi
callq 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJson.cpp
// Function: JsonStringEscaper::JsonStringEscaper()
JsonStringEscaper()
	{
		for (int i = 0; i < 256; i++)
		{
			if (i > 0x1f && i < 0x7f)
				_callMap[i] = &JsonStringEscaper::normal;
			else
				_callMap[i] = &JsonStringEscaper::hexadecimal;
		}

		_callMap[(uint8_t)'\\'] = &JsonStringEscaper::slash;
		_callMap[(uint8_t)'"'] = &JsonStringEscaper::quotationMarks;

		_callMap[(uint8_t)'\b'] = &JsonStringEscaper::jsonSpecialChars;
		_callMap[(uint8_t)'\f'] = &JsonStringEscaper::jsonSpecialChars;
		_callMap[(uint8_t)'\n'] = &JsonStringEscaper::jsonSpecialChars;
		_callMap[(uint8_t)'\r'] = &JsonStringEscaper::jsonSpecialChars;
		_callMap[(uint8_t)'\t'] = &JsonStringEscaper::jsonSpecialChars;
	}

// Assembly:
movl $0xffffffe0, %eax       # imm = 0xFFFFFFE0
xorl %ecx, %ecx
leaq 0xb3a(%rip), %rdx       # 0x1cdc6
leaq 0xb15(%rip), %rsi       # 0x1cda8
movq %rdx, %r8
cmpl $0x5f, %eax
jae 0x1c29e
movq %rsi, %r8
movq %r8, (%rdi,%rcx)
movq $0x0, 0x8(%rdi,%rcx)
incl %eax
addq $0x10, %rcx
cmpq $0x1000, %rcx           # imm = 0x1000
jne 0x1c293
leaq 0xb79(%rip), %rax       # 0x1ce3a
movq %rax, 0x5c0(%rdi)
xorl %eax, %eax
movq %rax, 0x5c8(%rdi)
leaq 0xb76(%rip), %rcx       # 0x1ce4e
movq %rcx, 0x220(%rdi)
movq %rax, 0x228(%rdi)
leaq 0xb75(%rip), %rcx       # 0x1ce62
movq %rcx, 0x80(%rdi)
movq %rax, 0x88(%rdi)
movq %rcx, 0xc0(%rdi)
movq %rax, 0xc8(%rdi)
movq %rcx, 0xa0(%rdi)
movq %rax, 0xa8(%rdi)
movq %rcx, 0xd0(%rdi)
movq %rax, 0xd8(%rdi)
movq %rcx, 0x90(%rdi)
movq %rax, 0x98(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/src/swxJsonUtils.cpp
// Function: swxJson::JsonError::format[abi:cxx11](char const*, ...)
std::string JsonError::format(const char *fmt, ...)
{
	if (fmt)
	{
		va_list ap; 
		va_start(ap, fmt);
		char buf[1024];
		vsnprintf(buf, sizeof(buf), fmt, ap);
		va_end(ap);
		return std::string(buf);
	}

	return std::string();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x4d8, %rsp            # imm = 0x4D8
movq %rdi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x1f13a
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rsi, %rsi
je 0x1f1a6
movq %rsi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x4f0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rcx)
leaq 0xd0(%rsp), %r14
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdi
movq %r10, %rdx
callq 0xb150
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0xb0d0
leaq (%rsp,%rax), %rdx
addq $0xd0, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17258
jmp 0x1f1b9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x4d8, %rsp            # imm = 0x4D8
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/onai[P]npio/npio_test_cpp.cpp
// Function: main
int main()
{
  npio::Array a("test1.npy");
  int64_t total = 0;
  int64_t* values = a.get<int64_t>();
  for (size_t i = 0; i < a.size(); ++i)
    total += values[i];
  assert(total == 4950);
  return 0;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
leaq 0xe05(%rip), %rsi       # 0x2040
movq %rsp, %rbx
movl $0x20, %edx
movq %rbx, %rdi
callq 0x1930
xorl %eax, %eax
cmpl $0x0, 0x38(%rbx)
jne 0x1262
cmpl $0x1, 0x3c(%rsp)
jne 0x1262
cmpl $0x40, 0x40(%rsp)
sete %al
testb %al, %al
je 0x126d
movq 0x48(%rsp), %rax
jmp 0x126f
xorl %eax, %eax
movq 0x28(%rsp), %rcx
testq %rcx, %rcx
je 0x12a5
xorl %edx, %edx
xorl %esi, %esi
addq (%rax,%rdx,8), %rsi
incq %rdx
cmpq %rdx, %rcx
jne 0x127d
cmpq $0x1356, %rsi           # imm = 0x1356
jne 0x12a5
movq %rsp, %rdi
callq 0x1cc8
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
leaq 0xd9e(%rip), %rdi       # 0x204a
leaq 0xda5(%rip), %rsi       # 0x2058
leaq 0xdb0(%rip), %rcx       # 0x206a
movl $0xb, %edx
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/onai[P]npio/./npio.h
// Function: npio_load_header_fd_read_(int, npio_Array*, unsigned long)
static inline int npio_load_header_fd_read_(int fd, npio_Array* array, size_t max_dim)
{
  /* Read just enough to know how much more we need to read */
  char prelude[12];
  char *end;
  int nr, err;
  size_t prelude_size;

  nr = read(fd, prelude, sizeof(prelude));
  if (nr < (int) sizeof(prelude))
    return errno;

  if ((err = npio_load_header_prelude_(prelude, array, &end)))
    return err;

  /* Keep track of how many bytes of prelude were present */
  prelude_size = end - prelude;

  /* We suppose here that each dimension in shape should not take more than 20
  characters to estimate a limit on the header_len. Admitted, this is sloppy. */
  if (array->header_len > 1024 + max_dim * 20)
    return ERANGE;

  /* We stick the prelude back together with the rest of the header */
  if ((array->_hdr_buf = (char*) malloc(prelude_size + array->header_len)) == 0)
    return ENOMEM;
  memcpy(array->_hdr_buf, prelude, sizeof(prelude));

  /* Now read in the rest of the header, accounting for excess bytes possibly
     read in with the prelude. */
  nr = read(fd, array->_hdr_buf + sizeof(prelude)
    , array->header_len - (sizeof(prelude) - prelude_size));

  /* Parse the header */
  return npio_ph_parse_dict_(array, array->_hdr_buf + prelude_size, end);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc(%rsp), %r14
movl $0xc, %edx
movq %r14, %rsi
callq 0x10e0
cmpl $0xb, %eax
jg 0x12fd
callq 0x1030
movl (%rax), %eax
jmp 0x1406
movl $0x4d554e93, %eax       # imm = 0x4D554E93
xorl 0xc(%rsp), %eax
movzwl 0x10(%rsp), %ecx
xorl $0x5950, %ecx           # imm = 0x5950
orl %eax, %ecx
je 0x131e
xorl %ecx, %ecx
movl $0x16, %eax
jmp 0x1386
movzbl 0x12(%rsp), %eax
movb %al, (%rbx)
movb 0x13(%rsp), %cl
movb %cl, 0x1(%rbx)
cmpl $0x2, %eax
je 0x1350
cmpl $0x1, %eax
jne 0x13f5
leaq 0x16(%rsp), %r12
movsbl -0x2(%r12), %ecx
movsbl -0x1(%r12), %eax
shll $0x8, %eax
jmp 0x137a
leaq 0x18(%rsp), %r12
movsbl -0x4(%r12), %eax
movsbl -0x3(%r12), %ecx
shll $0x8, %ecx
addl %eax, %ecx
movsbl -0x2(%r12), %edx
shll $0x10, %edx
movzbl -0x1(%r12), %eax
shll $0x18, %eax
addl %edx, %eax
addl %ecx, %eax
cltq
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movb $0x1, %cl
testb %cl, %cl
je 0x1406
movq 0x8(%rbx), %r13
leaq (%r15,%r15,4), %rax
leaq 0x400(,%rax,4), %rcx
movl $0x22, %eax
cmpq %rcx, %r13
ja 0x1406
movq %r12, %r15
subq %r14, %r15
leaq (%r15,%r13), %rdi
callq 0x10d0
movq %rax, 0x68(%rbx)
testq %rax, %rax
je 0x1401
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movq 0xc(%rsp), %rcx
movq %rcx, (%rax)
addq $0xc, %rax
leaq (%r15,%r13), %rdx
addq $-0xc, %rdx
movl %ebp, %edi
movq %rax, %rsi
callq 0x10e0
addq 0x68(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1415
jmp 0x1406
xorl %ecx, %ecx
movl $0x5f, %eax
jmp 0x131c
movl $0xc, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/permutationlock[P]aes_math/lib/galois_field.cpp
// Function: Polynomial::Polynomial(int, int, int)
Polynomial::Polynomial(int value, int p, int n): _p(p) {
    for(int i=0; i<n; i++){
        _a.push_back(0);
    }
    
    for(int i=n-1; i>=0; i--){
        int num = pow(_p, i);
        if(value >= num){
            int m = (value/num)%_p;
            _a[i] = Modular<int>(m);
            value -= m * num;
        }
        if(value==0) break;
    }
    
    reduce();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %edx, 0x18(%rdi)
testl %ecx, %ecx
jle 0x3001
leaq 0xc(%rsp), %r15
movl %r14d, %r12d
movl $0x0, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2ff1
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2ffc
movq %rbx, %rdi
movq %r15, %rdx
callq 0x50de
decl %r12d
jne 0x2fcf
movl %r14d, %eax
testl %eax, %eax
jle 0x3048
leaq -0x1(%rax), %r14
decl %eax
xorps %xmm0, %xmm0
cvtsi2sdl 0x18(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
callq 0x21a0
cvttsd2si %xmm0, %ecx
cmpl %ecx, %ebp
jl 0x3041
movl %ebp, %eax
cltd
idivl %ecx
cltd
idivl 0x18(%rbx)
movl %r14d, %eax
movq (%rbx), %rsi
movl %edx, (%rsi,%rax,4)
imull %ecx, %edx
subl %edx, %ebp
movq %r14, %rax
testl %ebp, %ebp
jne 0x3004
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
je 0x306d
addq $-0x4, %rcx
cmpl $0x0, (%rcx)
jne 0x306d
movq %rcx, 0x8(%rbx)
leaq -0x4(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jne 0x3058
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3091
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2110
movq %r14, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/permutationlock[P]aes_math/lib/galois_field.cpp
// Function: Polynomial::Polynomial(Polynomial const&)
Polynomial::Polynomial(const Polynomial & other){
    _p = other._p;
    
    for(int i=0; i<other.size(); i++){
        _a.push_back(other[i]);
    }
    
    reduce();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl 0x18(%rsi), %eax
movl %eax, 0x18(%rdi)
movq (%rsi), %rdx
movq 0x8(%rsi), %rax
subq %rdx, %rax
shrq $0x2, %rax
testl %eax, %eax
jle 0x31f5
movq %rsi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
addq %r15, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x31d1
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x31d9
movq %rbx, %rdi
callq 0x5204
incq %r12
movq (%r14), %rdx
movq 0x8(%r14), %rax
subq %rdx, %rax
shrq $0x2, %rax
cltq
addq $0x4, %r15
cmpq %rax, %r12
jl 0x31b6
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
je 0x321a
addq $-0x4, %rcx
cmpl $0x0, (%rcx)
jne 0x321a
movq %rcx, 0x8(%rbx)
leaq -0x4(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jne 0x3205
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x323d
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2110
movq %r14, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/permutationlock[P]aes_math/lib/galois_field.cpp
// Function: Polynomial::operator+=(Polynomial const&)
Polynomial & Polynomial::operator+=(const Polynomial & other){
    if(_p != other._p) throw runtime_error("Mismatched prime.");
    
    while(_a.size()<other.size())
        _a.push_back(0);
    
    Modular<int>::globalSetModulus(_p);
    
    for(int i=0; i<other.size(); i++){
        _a[i] += other[i];
    }
    
    reduce();
    
    return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0x18(%rdi), %eax
cmpl 0x18(%rsi), %eax
jne 0x3361
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rsi
movq %rsi, %rax
subq %rcx, %rax
sarq $0x2, %rax
movq (%r14), %rdi
movq 0x8(%r14), %r8
subq %rdi, %r8
movq %r8, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
cmpq %rdx, %rax
jae 0x32fb
leaq 0xc(%rsp), %r15
movl $0x0, 0xc(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x32c6
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x32d1
movq %rbx, %rdi
movq %r15, %rdx
callq 0x50de
movq (%rbx), %rcx
movq 0x8(%rbx), %rsi
movq %rsi, %rax
subq %rcx, %rax
sarq $0x2, %rax
movq (%r14), %rdi
movq 0x8(%r14), %r8
subq %rdi, %r8
movq %r8, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
cmpq %rdx, %rax
jb 0x32a8
shrq $0x2, %r8
movl 0x18(%rbx), %eax
movl %eax, 0xbe30(%rip)      # 0xf138
testl %r8d, %r8d
jle 0x3336
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
movl (%rcx,%r9,4), %eax
addl (%rdi,%r9,4), %eax
movl %eax, (%rcx,%r9,4)
cltd
idivl 0xbe0e(%rip)            # 0xf138
movl %edx, (%rcx,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x3317
cmpq %rcx, %rsi
je 0x3354
addq $-0x4, %rsi
cmpl $0x0, (%rsi)
jne 0x3354
movq %rsi, 0x8(%rbx)
leaq -0x4(%rsi), %rax
cmpq %rcx, %rsi
movq %rax, %rsi
jne 0x333f
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x6ccf(%rip), %rsi      # 0xa044
movq %rax, %rdi
callq 0x2060
movq 0xbc6c(%rip), %rsi      # 0xeff0
movq 0xbc3d(%rip), %rdx      # 0xefc8
movq %rbx, %rdi
callq 0x2190
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/permutationlock[P]aes_math/lib/galois_field.cpp
// Function: Polynomial::operator*=(Polynomial const&)
Polynomial & Polynomial::operator*=(const Polynomial & other){
    if(_p != other._p) throw runtime_error("Mismatched prime.");
    
    vector<Modular<int>> a;
    
    for(int i=0; i<other.size()+this->size(); i++){
        a.push_back(0);
    }
    
    Modular<int>::globalSetModulus(_p);
    // FOIL multiplication
    for(int i=0; i<this->size(); i++){
        for(int j=0; j<other.size(); j++){
            a[i+j] += _a[i]*other[j];
        }
    }
    
    // Swap in the product coefficients
    swap(_a,a);
    
    reduce();
    
    return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl 0x18(%rdi), %eax
cmpl 0x18(%rsi), %eax
jne 0x3669
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rsi), %rcx
movq 0x8(%rsi), %rsi
subq %rcx, %rsi
shrq $0x2, %rsi
movq (%rdi), %rdi
movq 0x8(%rbx), %r8
movq %r8, %rax
subq %rdi, %rax
shrq $0x2, %rax
movl %eax, %edx
addl %esi, %edx
jle 0x35a9
xorl %ebp, %ebp
movq %rsp, %r15
leaq 0x1c(%rsp), %r12
movl $0x0, 0x1c(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x3576
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x3581
movq %r15, %rdi
movq %r12, %rdx
callq 0x50de
incl %ebp
movq (%r14), %rcx
movq 0x8(%r14), %rsi
subq %rcx, %rsi
shrq $0x2, %rsi
movq (%rbx), %rdi
movq 0x8(%rbx), %r8
movq %r8, %rax
subq %rdi, %rax
shrq $0x2, %rax
leal (%rax,%rsi), %edx
cmpl %edx, %ebp
jl 0x3551
movl 0x18(%rbx), %edx
movl %edx, 0xbb86(%rip)      # 0xf138
testl %eax, %eax
jle 0x3603
movq (%rsp), %r9
movl %eax, %r10d
movl %esi, %r11d
xorl %r14d, %r14d
testl %esi, %esi
jle 0x35f7
xorl %r15d, %r15d
movl (%rcx,%r15,4), %eax
imull (%rdi,%r14,4), %eax
cltd
idivl 0xbb5e(%rip)            # 0xf138
movl %edx, %eax
addl (%r9,%r15,4), %eax
movl %eax, (%r9,%r15,4)
cltd
idivl 0xbb4d(%rip)            # 0xf138
movl %edx, (%r9,%r15,4)
incq %r15
cmpq %r15, %r11
jne 0x35ca
incq %r14
addq $0x4, %r9
cmpq %r10, %r14
jne 0x35c3
movq 0x10(%rbx), %rsi
movq (%rsp), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq 0x10(%rsp), %rdx
movq %rdx, 0x10(%rbx)
movq %rdi, (%rsp)
movq %r8, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
cmpq %rax, %rcx
je 0x364c
addq $-0x4, %rcx
cmpl $0x0, (%rcx)
jne 0x364c
movq %rcx, 0x8(%rbx)
leaq -0x4(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jne 0x3637
testq %rdi, %rdi
je 0x3659
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x2080
movq %rax, %r14
leaq 0x69c7(%rip), %rsi      # 0xa044
movq %rax, %rdi
callq 0x2060
movq 0xb964(%rip), %rsi      # 0xeff0
movq 0xb935(%rip), %rdx      # 0xefc8
movq %r14, %rdi
callq 0x2190
movq %rax, %rbx
movq %r14, %rdi
callq 0x20c0
jmp 0x36c1
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x36c1
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/permutationlock[P]aes_math/lib/galois_field.cpp
// Function: Polynomial::toString[abi:cxx11]() const
string Polynomial::toString() const{
    string s = "";
    for(int i=0; i<_a.size(); i++){
        s.insert(0,to_string(_a[i].value()));
    }
    return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
leaq 0x5fae(%rip), %rdx      # 0xa3da
movq %rdi, 0x8(%rsp)
movq %rdx, %rsi
callq 0x52e6
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x4528
xorl %r15d, %r15d
movl $0xd1b71759, %ebx       # imm = 0xD1B71759
movl (%rax,%r15,4), %r12d
movl %r12d, %ebp
negl %ebp
cmovsl %r12d, %ebp
movl $0x1, %r13d
cmpl $0xa, %ebp
jb 0x44a7
movl $0x4, %r13d
movl %ebp, %eax
cmpl $0x63, %eax
jbe 0x449e
cmpl $0x3e7, %eax            # imm = 0x3E7
jbe 0x44a4
cmpl $0x2710, %eax           # imm = 0x2710
jb 0x44a7
movl %eax, %ecx
imulq %rbx, %rcx
shrq $0x2d, %rcx
addl $0x4, %r13d
cmpl $0x1869f, %eax          # imm = 0x1869F
movl %ecx, %eax
ja 0x446e
addl $-0x3, %r13d
jmp 0x44a7
addl $-0x2, %r13d
jmp 0x44a7
decl %r13d
shrl $0x1f, %r12d
leal (%r12,%r13), %esi
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x2d, %edx
callq 0x2140
addq 0x18(%rsp), %r12
movq %r12, %rdi
movl %r13d, %esi
movl %ebp, %edx
callq 0x4ed1
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x450e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2110
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
ja 0x444e
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4560
movq %rax, %r14
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x4560
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2110
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0x457f
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2110
movq %r14, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/permutationlock[P]aes_math/lib/galois_field.cpp
// Function: GaloisPolynomial::toString[abi:cxx11]() const
string GaloisPolynomial::toString() const{
    string s = _polynomial.toString();
    for(int i=0; i<_modulus.size()-_polynomial.size()-1; i++)
        s.insert(0, "0");
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4408
movq 0xa430(%rip), %rax      # 0xf120
subq 0xa421(%rip), %rax      # 0xf118
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x2, %rax
shrq $0x2, %rcx
subl %eax, %ecx
cmpl $-0x2, %ecx
jg 0x4d55
xorl %r12d, %r12d
leaq 0x5345(%rip), %r15      # 0xa05c
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x2120
incl %r12d
movq 0xa3ea(%rip), %rax      # 0xf120
subq 0xa3db(%rip), %rax      # 0xf118
shrq $0x2, %rax
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x2, %rcx
notl %ecx
addl %eax, %ecx
cmpl %ecx, %r12d
jl 0x4d17
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x4d7e
movq (%rbx), %rsi
incq %rsi
callq 0x2110
movq %r14, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/permutationlock[P]aes_math/lib/modular_arithmetic.cpp
// Function: Modular<int>::mulInverse() const
Modular<T> Modular<T>::mulInverse() const{
    T t = 0;
    T r = _modulus;
    T new_t = 1;
    T new_r = _val;
    while(new_r != 0){
        T quotient = r / new_r;
        T temp_t = t;
        t = new_t;
        new_t = temp_t - quotient * new_t;
        T temp_r = r;
        r = new_r;
        new_r = temp_r - quotient * new_r;
    }
    if(r>1) throw;    // Should never happen for prime field
    if(t<0) t = t+_modulus;
    return Modular<T>(t);
}

// Assembly:
movl 0xa388(%rip), %ecx      # 0xf138
movl (%rdi), %edx
testl %edx, %edx
je 0x4dde
xorl %edi, %edi
movl $0x1, %r9d
movl %ecx, %eax
movl %edx, %r8d
cltd
idivl %r8d
movl %r9d, %esi
imull %r9d, %eax
subl %eax, %edi
movl %r8d, %eax
movl %edi, %r9d
movl %esi, %edi
testl %edx, %edx
jne 0x4dc0
jmp 0x4de3
xorl %esi, %esi
movl %ecx, %r8d
cmpl $0x2, %r8d
jge 0x4df3
movl %esi, %eax
sarl $0x1f, %eax
andl %ecx, %eax
addl %esi, %eax
retq
pushq %rax
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/permutationlock[P]aes_math/lib/aes.cpp
// Function: sBox(GaloisPolynomial&)
GaloisPolynomial & sBox(GaloisPolynomial & p){
    // Invert each element
    p = p.inverse();
    
    // Calculate affine transformation
    vector<Modular<int>> coef;
    for(int r=0; r<8; r++){
        Modular<int> sum(0);
        for(int c=0; c<8; c++){
            sum += p[c] * rijndael_A[r*8+c];
        }
        coef.push_back(sum);
    }
    p = GaloisPolynomial(coef);
    
    // Add polynomial b
    p += rijndael_b;
    
    return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x46ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4fba
movl 0x18(%rsp), %eax
movl %eax, 0x18(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x581b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
xorl %r13d, %r13d
movq %rsp, %r15
xorl %ebp, %ebp
movl $0x0, (%rsp)
xorl %r12d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x4ca0
movq 0x9915(%rip), %rcx      # 0xf168
addq %r13, %rcx
imull (%rcx,%r12,4), %eax
movl 0x98d7(%rip), %ecx      # 0xf138
cltd
idivl %ecx
movl %edx, %eax
addl (%rsp), %eax
cltd
idivl %ecx
movl %edx, (%rsp)
incq %r12
cmpq $0x8, %r12
jne 0x5841
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x5894
movl (%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x28(%rsp)
jmp 0x589f
movq %r14, %rdi
movq %r15, %rdx
callq 0x5204
incq %rbp
addq $0x20, %r13
cmpq $0x8, %rbp
jne 0x5837
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movl $0x2, %edx
callq 0x45ca
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4fba
movl 0x18(%rsp), %eax
movl %eax, 0x18(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x58e6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
leaq 0x98ab(%rip), %rsi      # 0xf198
movq %rbx, %rdi
callq 0x464e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x590c
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5952
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5955
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
jmp 0x5955
jmp 0x5952
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x596c
movq 0x10(%rsp), %rsi
jmp 0x5964
jmp 0x5952
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x596c
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/permutationlock[P]aes_math/lib/aes.cpp
// Function: sBox_inverse(GaloisPolynomial&)
GaloisPolynomial & sBox_inverse(GaloisPolynomial & p){
    // Calculate affine transformation
    vector<Modular<int>> coef;
    for(int r=0; r<8; r++){
        Modular<int> sum(0);
        for(int c=0; c<8; c++){
            sum += p[c] * rijndael_A_inverse[r*8+c];
        }
        coef.push_back(sum);
    }
    p = GaloisPolynomial(coef);
    
    // Add polynomial b inverse
    p += rijndael_b_inverse;
    
    // Invert each element
    p = p.inverse();
    
    return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
xorl %r13d, %r13d
movq %rsp, %r15
xorl %ebp, %ebp
movl $0x0, (%rsp)
xorl %r12d, %r12d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x4ca0
movq 0x97c3(%rip), %rcx      # 0xf180
addq %r13, %rcx
imull (%rcx,%r12,4), %eax
movl 0x976d(%rip), %ecx      # 0xf138
cltd
idivl %ecx
movl %edx, %eax
addl (%rsp), %eax
cltd
idivl %ecx
movl %edx, (%rsp)
incq %r12
cmpq $0x8, %r12
jne 0x59ab
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x59fe
movl (%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x28(%rsp)
jmp 0x5a09
movq %r14, %rdi
movq %r15, %rdx
callq 0x5204
incq %rbp
addq $0x20, %r13
cmpq $0x8, %rbp
jne 0x59a1
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movl $0x2, %edx
callq 0x45ca
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4fba
movl 0x18(%rsp), %eax
movl %eax, 0x18(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5a50
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
leaq 0x9761(%rip), %rsi      # 0xf1b8
movq %rbx, %rdi
callq 0x464e
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x46ea
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4fba
movl 0x18(%rsp), %eax
movl %eax, 0x18(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5a92
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5aa9
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ac1
jmp 0x5ae0
jmp 0x5ae0
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5ae3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
jmp 0x5ae3
jmp 0x5ae0
jmp 0x5ae0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5afa
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/permutationlock[P]aes_math/lib/aes.cpp
// Function: subBytes(QSMatrix<GaloisPolynomial>&)
QSMatrix<GaloisPolynomial> & subBytes(QSMatrix<GaloisPolynomial> & state){
    Modular<int>::globalSetModulus(2);
    for(int i=0; i<state.getRows(); i++){
        for(int j=0; j<state.getCols(); j++){
            sBox(state(i,j));
        }
    }
    
    return state;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x2, 0x9620(%rip)      # 0xf138
cmpl $0x0, 0x20(%rdi)
jle 0x5b5d
xorl %r14d, %r14d
cmpl $0x0, 0x24(%rbx)
jle 0x5b51
leaq (%r14,%r14,2), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %r12, %rdi
callq 0x57d4
incq %r13
movslq 0x24(%rbx), %rax
addq $0x20, %r12
cmpq %rax, %r13
jl 0x5b31
incq %r14
movslq 0x20(%rbx), %rax
cmpq %rax, %r14
jl 0x5b21
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq