LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rcx
leaq 0x50(%rsp), %rdi
callq 0x36f80
leaq 0x50(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3ca6c
jmp 0x3caac
leaq 0x50(%rsp), %rdi
callq 0x312a0
movq %rax, %rdi
callq 0x3ae80
movq %rax, 0x10(%rsp)
jmp 0x3ca85
leaq 0x50(%rsp), %rdi
callq 0x31150
movq 0x10(%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x3cb6d
movb $0x1, 0x1e(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x1f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xed64(%rip), %rsi      # 0x4b83e
leaq 0x20(%rsp), %rdi
callq 0x30e50
jmp 0x3cae6
movq (%rsp), %rdi
leaq 0xeb81(%rip), %rsi      # 0x4b672
leaq 0xecaf(%rip), %rdx      # 0x4b7a7
movl $0x502, %ecx            # imm = 0x502
leaq 0x20(%rsp), %r8
callq 0x3f210
jmp 0x3cb09
movq (%rsp), %rdi
movb $0x0, 0x1e(%rsp)
leaq 0x1b1cf(%rip), %rsi     # 0x57ce8
leaq 0x2750(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3cb81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x3cb4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x22160
leaq 0x1f(%rsp), %rdi
callq 0x22320
testb $0x1, 0x1e(%rsp)
jne 0x3cb62
jmp 0x3cb6b
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3cb6d
leaq 0x50(%rsp), %rdi
callq 0x31150
movq 0x48(%rsp), %rdi
callq 0x224a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rcx
leaq 0x50(%rsp), %rdi
callq 0x36f80
leaq 0x50(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3cbcc
jmp 0x3cc0c
leaq 0x50(%rsp), %rdi
callq 0x312a0
movq %rax, %rdi
callq 0x3afc0
movq %rax, 0x10(%rsp)
jmp 0x3cbe5
leaq 0x50(%rsp), %rdi
callq 0x31150
movq 0x10(%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x3cccd
movb $0x1, 0x1e(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x1f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xec04(%rip), %rsi      # 0x4b83e
leaq 0x20(%rsp), %rdi
callq 0x30e50
jmp 0x3cc46
movq (%rsp), %rdi
leaq 0xea21(%rip), %rsi      # 0x4b672
leaq 0xeb57(%rip), %rdx      # 0x4b7af
movl $0x50b, %ecx            # imm = 0x50B
leaq 0x20(%rsp), %r8
callq 0x3f210
jmp 0x3cc69
movq (%rsp), %rdi
movb $0x0, 0x1e(%rsp)
leaq 0x1b06f(%rip), %rsi     # 0x57ce8
leaq 0x25f0(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3cce1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x3ccaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x22160
leaq 0x1f(%rsp), %rdi
callq 0x22320
testb $0x1, 0x1e(%rsp)
jne 0x3ccc2
jmp 0x3cccb
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3cccd
leaq 0x50(%rsp), %rdi
callq 0x31150
movq 0x48(%rsp), %rdi
callq 0x224a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rcx
leaq 0x50(%rsp), %rdi
callq 0x36f80
leaq 0x50(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3cd2c
jmp 0x3cd6e
leaq 0x50(%rsp), %rdi
callq 0x312a0
movq %rax, %rdi
callq 0x3b100
movsd %xmm0, 0x10(%rsp)
jmp 0x3cd46
leaq 0x50(%rsp), %rdi
callq 0x31150
movsd 0x10(%rsp), %xmm0
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x3ce2f
movb $0x1, 0x1e(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x1f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xeaa2(%rip), %rsi      # 0x4b83e
leaq 0x20(%rsp), %rdi
callq 0x30e50
jmp 0x3cda8
movq (%rsp), %rdi
leaq 0xe8bf(%rip), %rsi      # 0x4b672
leaq 0xe9fe(%rip), %rdx      # 0x4b7b8
movl $0x514, %ecx            # imm = 0x514
leaq 0x20(%rsp), %r8
callq 0x3f210
jmp 0x3cdcb
movq (%rsp), %rdi
movb $0x0, 0x1e(%rsp)
leaq 0x1af0d(%rip), %rsi     # 0x57ce8
leaq 0x248e(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3ce43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x3ce11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x22160
leaq 0x1f(%rsp), %rdi
callq 0x22320
testb $0x1, 0x1e(%rsp)
jne 0x3ce24
jmp 0x3ce2d
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3ce2f
leaq 0x50(%rsp), %rdi
callq 0x31150
movq 0x48(%rsp), %rdi
callq 0x224a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
callq 0x36f80
leaq 0x58(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3cea4
jmp 0x3cee7
leaq 0x58(%rsp), %rdi
callq 0x312a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3b200
jmp 0x3cebd
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3cfa8
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xe929(%rip), %rsi      # 0x4b83e
leaq 0x28(%rsp), %rdi
callq 0x30e50
jmp 0x3cf21
movq (%rsp), %rdi
leaq 0xe746(%rip), %rsi      # 0x4b672
leaq 0xe88e(%rip), %rdx      # 0x4b7c1
movl $0x51d, %ecx            # imm = 0x51D
leaq 0x28(%rsp), %r8
callq 0x3f210
jmp 0x3cf44
movq (%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x1ad94(%rip), %rsi     # 0x57ce8
leaq 0x2315(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3cfbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3cf8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x22160
leaq 0x27(%rsp), %rdi
callq 0x22320
testb $0x1, 0x26(%rsp)
jne 0x3cf9d
jmp 0x3cfa6
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3cfa8
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x50(%rsp), %rdi
callq 0x224a0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
callq 0x36f80
leaq 0x58(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3d654
jmp 0x3d697
leaq 0x58(%rsp), %rdi
callq 0x312a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3b320
jmp 0x3d66d
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3d758
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xe179(%rip), %rsi      # 0x4b83e
leaq 0x28(%rsp), %rdi
callq 0x30e50
jmp 0x3d6d1
movq (%rsp), %rdi
leaq 0xdf96(%rip), %rsi      # 0x4b672
leaq 0xe0e9(%rip), %rdx      # 0x4b7cc
movl $0x551, %ecx            # imm = 0x551
leaq 0x28(%rsp), %r8
callq 0x3f210
jmp 0x3d6f4
movq (%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x1a5e4(%rip), %rsi     # 0x57ce8
leaq 0x1b65(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3d76c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3d73a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x22160
leaq 0x27(%rsp), %rdi
callq 0x22320
testb $0x1, 0x26(%rsp)
jne 0x3d74d
jmp 0x3d756
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3d758
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x50(%rsp), %rdi
callq 0x224a0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
callq 0x36f80
leaq 0x58(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3d7c4
jmp 0x3d807
leaq 0x58(%rsp), %rdi
callq 0x312a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3b530
jmp 0x3d7dd
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3d8c8
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xe009(%rip), %rsi      # 0x4b83e
leaq 0x28(%rsp), %rdi
callq 0x30e50
jmp 0x3d841
movq (%rsp), %rdi
leaq 0xde26(%rip), %rsi      # 0x4b672
leaq 0xdf88(%rip), %rdx      # 0x4b7db
movl $0x55a, %ecx            # imm = 0x55A
leaq 0x28(%rsp), %r8
callq 0x3f210
jmp 0x3d864
movq (%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x1a474(%rip), %rsi     # 0x57ce8
leaq 0x19f5(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3d8dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3d8aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x22160
leaq 0x27(%rsp), %rdi
callq 0x22320
testb $0x1, 0x26(%rsp)
jne 0x3d8bd
jmp 0x3d8c6
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3d8c8
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x50(%rsp), %rdi
callq 0x224a0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
callq 0x36f80
leaq 0x58(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3d934
jmp 0x3d977
leaq 0x58(%rsp), %rdi
callq 0x312a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3b760
jmp 0x3d94d
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3da38
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xde99(%rip), %rsi      # 0x4b83e
leaq 0x28(%rsp), %rdi
callq 0x30e50
jmp 0x3d9b1
movq (%rsp), %rdi
leaq 0xdcb6(%rip), %rsi      # 0x4b672
leaq 0xde27(%rip), %rdx      # 0x4b7ea
movl $0x563, %ecx            # imm = 0x563
leaq 0x28(%rsp), %r8
callq 0x3f210
jmp 0x3d9d4
movq (%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x1a304(%rip), %rsi     # 0x57ce8
leaq 0x1885(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3da4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3da1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x22160
leaq 0x27(%rsp), %rdi
callq 0x22320
testb $0x1, 0x26(%rsp)
jne 0x3da2d
jmp 0x3da36
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3da38
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x50(%rsp), %rdi
callq 0x224a0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
callq 0x36f80
leaq 0x58(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3daa4
jmp 0x3dae7
leaq 0x58(%rsp), %rdi
callq 0x312a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3b980
jmp 0x3dabd
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3dba8
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xdd29(%rip), %rsi      # 0x4b83e
leaq 0x28(%rsp), %rdi
callq 0x30e50
jmp 0x3db21
movq (%rsp), %rdi
leaq 0xdb46(%rip), %rsi      # 0x4b672
leaq 0xdcc5(%rip), %rdx      # 0x4b7f8
movl $0x56c, %ecx            # imm = 0x56C
leaq 0x28(%rsp), %r8
callq 0x3f210
jmp 0x3db44
movq (%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x1a194(%rip), %rsi     # 0x57ce8
leaq 0x1715(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3dbbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3db8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x22160
leaq 0x27(%rsp), %rdi
callq 0x22320
testb $0x1, 0x26(%rsp)
jne 0x3db9d
jmp 0x3dba6
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3dba8
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x50(%rsp), %rdi
callq 0x224a0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
callq 0x36f80
leaq 0x58(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3dc14
jmp 0x3dc57
leaq 0x58(%rsp), %rdi
callq 0x312a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3bbe0
jmp 0x3dc2d
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3dd18
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xdbb9(%rip), %rsi      # 0x4b83e
leaq 0x28(%rsp), %rdi
callq 0x30e50
jmp 0x3dc91
movq (%rsp), %rdi
leaq 0xd9d6(%rip), %rsi      # 0x4b672
leaq 0xdb66(%rip), %rdx      # 0x4b809
movl $0x576, %ecx            # imm = 0x576
leaq 0x28(%rsp), %r8
callq 0x3f210
jmp 0x3dcb4
movq (%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x1a024(%rip), %rsi     # 0x57ce8
leaq 0x15a5(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3dd2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3dcfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x22160
leaq 0x27(%rsp), %rdi
callq 0x22320
testb $0x1, 0x26(%rsp)
jne 0x3dd0d
jmp 0x3dd16
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3dd18
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x50(%rsp), %rdi
callq 0x224a0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
callq 0x36f80
leaq 0x58(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3dd84
jmp 0x3ddc7
leaq 0x58(%rsp), %rdi
callq 0x312a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3bdf0
jmp 0x3dd9d
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3de88
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xda49(%rip), %rsi      # 0x4b83e
leaq 0x28(%rsp), %rdi
callq 0x30e50
jmp 0x3de01
movq (%rsp), %rdi
leaq 0xd866(%rip), %rsi      # 0x4b672
leaq 0xda03(%rip), %rdx      # 0x4b816
movl $0x57f, %ecx            # imm = 0x57F
leaq 0x28(%rsp), %r8
callq 0x3f210
jmp 0x3de24
movq (%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x19eb4(%rip), %rsi     # 0x57ce8
leaq 0x1435(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3de9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3de6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x22160
leaq 0x27(%rsp), %rdi
callq 0x22320
testb $0x1, 0x26(%rsp)
jne 0x3de7d
jmp 0x3de86
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3de88
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x50(%rsp), %rdi
callq 0x224a0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
callq 0x36f80
leaq 0x58(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3def4
jmp 0x3df37
leaq 0x58(%rsp), %rdi
callq 0x312a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3c010
jmp 0x3df0d
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3dff8
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xd8d9(%rip), %rsi      # 0x4b83e
leaq 0x28(%rsp), %rdi
callq 0x30e50
jmp 0x3df71
movq (%rsp), %rdi
leaq 0xd6f6(%rip), %rsi      # 0x4b672
leaq 0xd8a0(%rip), %rdx      # 0x4b823
movl $0x588, %ecx            # imm = 0x588
leaq 0x28(%rsp), %r8
callq 0x3f210
jmp 0x3df94
movq (%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x19d44(%rip), %rsi     # 0x57ce8
leaq 0x12c5(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3e00c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3dfda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x22160
leaq 0x27(%rsp), %rdi
callq 0x22320
testb $0x1, 0x26(%rsp)
jne 0x3dfed
jmp 0x3dff6
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3dff8
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x50(%rsp), %rdi
callq 0x224a0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
leaq 0x58(%rsp), %rdi
callq 0x36f80
leaq 0x58(%rsp), %rdi
callq 0x31c60
testb $0x1, %al
jne 0x3e064
jmp 0x3e0a7
leaq 0x58(%rsp), %rdi
callq 0x312a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3c220
jmp 0x3e07d
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3e168
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x22100
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x8(%rsp), %rdx
leaq 0xd769(%rip), %rsi      # 0x4b83e
leaq 0x28(%rsp), %rdi
callq 0x30e50
jmp 0x3e0e1
movq (%rsp), %rdi
leaq 0xd586(%rip), %rsi      # 0x4b672
leaq 0xd73c(%rip), %rdx      # 0x4b82f
movl $0x591, %ecx            # imm = 0x591
leaq 0x28(%rsp), %r8
callq 0x3f210
jmp 0x3e104
movq (%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x19bd4(%rip), %rsi     # 0x57ce8
leaq 0x1155(%rip), %rdx      # 0x3f270
callq 0x22480
jmp 0x3e17c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x3e14a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x22160
leaq 0x27(%rsp), %rdi
callq 0x22320
testb $0x1, 0x26(%rsp)
jne 0x3e15d
jmp 0x3e166
movq (%rsp), %rdi
callq 0x221d0
jmp 0x3e168
leaq 0x58(%rsp), %rdi
callq 0x31150
movq 0x50(%rsp), %rdi
callq 0x224a0
nopl (%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x100, -0xc(%rsp)      # imm = 0x100
jge 0x3e204
cmpl $0x1f, -0xc(%rsp)
jle 0x3e1d3
cmpl $0x7f, -0xc(%rsp)
jge 0x3e1d3
movq -0x18(%rsp), %rax
movslq -0xc(%rsp), %rcx
shlq $0x4, %rcx
leaq 0x19fc(%rip), %rdx      # 0x3fbc0
movq %rdx, (%rax,%rcx)
movq $0x0, 0x8(%rax,%rcx)
jmp 0x3e1f5
movq -0x18(%rsp), %rax
movslq -0xc(%rsp), %rcx
shlq $0x4, %rcx
leaq 0x1a18(%rip), %rdx      # 0x3fc00
movq %rdx, (%rax,%rcx)
movq $0x0, 0x8(%rax,%rcx)
jmp 0x3e1f7
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x3e197
movq -0x18(%rsp), %rax
leaq 0x1a80(%rip), %rcx      # 0x3fc90
movq %rcx, 0x5c0(%rax)
movq $0x0, 0x5c8(%rax)
leaq 0x1aa7(%rip), %rcx      # 0x3fcd0
movq %rcx, 0x220(%rax)
movq $0x0, 0x228(%rax)
leaq 0x1ace(%rip), %rcx      # 0x3fd10
movq %rcx, 0x80(%rax)
movq $0x0, 0x88(%rax)
movq %rcx, 0xc0(%rax)
movq $0x0, 0xc8(%rax)
movq %rcx, 0xa0(%rax)
movq $0x0, 0xa8(%rax)
movq %rcx, 0xd0(%rax)
movq $0x0, 0xd8(%rax)
movq %rcx, 0x90(%rax)
movq $0x0, 0x98(%rax)
retq
nopl (%rax)
// File: swxlion[P]swxJson/src/swxJson.cpp
// Function: JsonStringEscaper::jsonSpecialChars(std::ostream&, char const*, int, int&)
void jsonSpecialChars(std::ostream& os, const char * start, int len, int & idx)
	{
		switch (start[idx])
		{
			case '\b': os << "\\b"; break;
			case '\f': os << "\\f"; break;
			case '\n': os << "\\n"; break;
			case '\r': os << "\\r"; break;
			case '\t': os << "\\t"; break;
		}
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
addl $-0x8, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x5, %eax
ja 0x3fdbe
movq 0x8(%rsp), %rax
leaq 0xb8f8(%rip), %rcx      # 0x4b650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%rsp), %rdi
leaq 0xbb31(%rip), %rsi      # 0x4b89e
callq 0x222a0
jmp 0x3fdbe
movq 0x28(%rsp), %rdi
leaq 0xbb21(%rip), %rsi      # 0x4b8a1
callq 0x222a0
jmp 0x3fdbe
movq 0x28(%rsp), %rdi
leaq 0xbb11(%rip), %rsi      # 0x4b8a4
callq 0x222a0
jmp 0x3fdbe
movq 0x28(%rsp), %rdi
leaq 0xbb01(%rip), %rsi      # 0x4b8a7
callq 0x222a0
jmp 0x3fdbe
movq 0x28(%rsp), %rdi
leaq 0xbaf1(%rip), %rsi      # 0x4b8aa
callq 0x222a0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x518, %rsp            # imm = 0x518
movq %rdi, 0x10(%rsp)
movq %rdi, %r10
movq %r10, 0x18(%rsp)
testb %al, %al
je 0x4986f
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)
movq %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x510(%rsp)
movq %rsi, 0x508(%rsp)
cmpq $0x0, 0x508(%rsp)
je 0x49954
leaq 0x20(%rsp), %rax
movq %rax, 0x500(%rsp)
leaq 0x520(%rsp), %rax
movq %rax, 0x4f8(%rsp)
movl $0x30, 0x4f4(%rsp)
movl $0x10, 0x4f0(%rsp)
movq 0x508(%rsp), %rdx
leaq 0xf0(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x400, %esi            # imm = 0x400
leaq 0x4f0(%rsp), %rcx
callq 0x22170
leaq 0xef(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x224b0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x30e50
jmp 0x49922
leaq 0xef(%rsp), %rdi
callq 0x22320
jmp 0x4995e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0xef(%rsp), %rdi
callq 0x22320
jmp 0x4996b
movq 0x10(%rsp), %rdi
callq 0x223f0
movq 0x18(%rsp), %rax
addq $0x518, %rsp            # imm = 0x518
retq
movq 0xe0(%rsp), %rdi
callq 0x224a0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x1dbf(%rip), %rsi      # 0x3028
leaq -0x98(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
movl $0x20, %edx
callq 0x2790
movq -0xd0(%rbp), %rdi
movq $0x0, -0xa0(%rbp)
callq 0x27e0
movq %rax, -0xc8(%rbp)
jmp 0x12a1
movq -0xc8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq $0x0, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2820
movq %rax, -0xd8(%rbp)
jmp 0x12dd
movq -0xe0(%rbp), %rax
movq -0xd8(%rbp), %rcx
cmpq %rcx, %rax
jae 0x1344
movq -0xa8(%rbp), %rax
movq -0xc0(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq -0xa0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xc0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc0(%rbp)
jmp 0x12ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2840
jmp 0x1391
cmpq $0x1356, -0xa0(%rbp) # imm = 0x1356
jne 0x1353
jmp 0x1372
leaq 0x1cd8(%rip), %rdi      # 0x3032
leaq 0x1cdf(%rip), %rsi      # 0x3040
movl $0xb, %edx
leaq 0x1ce5(%rip), %rcx      # 0x3052
callq 0x10a0
movl $0x0, -0x4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2840
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x1110
nopl (%rax)
// File: onai[P]npio/./npio.h
// Function: npio_init_array(npio_Array*)
static inline void npio_init_array(npio_Array* array)
{
  array->major_version = 1;
  array->minor_version = 0;
  array->header_len = 0;
  array->dtype = 0;
  array->dim = 0;
  array->shape = 0;
  array->size = 0;
  array->fortran_order = 0;
  array->little_endian = (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__);
  array->floating_point = 1;
  array->is_signed = 1;
  array->bit_width = 32;
  array->data = 0;
  array->_fd = 0;
  array->_buf = 0;
  array->_buf_size = 0;
  array->_hdr_buf = 0;
  array->_shape_capacity = 0;
  array->_mmapped = 0;
  array->_malloced = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl $0x20, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x78(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x7c(%rax)
popq %rbp
retq
nopl (%rax)
// File: onai[P]npio/./npio.h
// Function: npio_load3(char const*, npio_Array*, unsigned long)
static inline int npio_load3(const char* filename, npio_Array* array
  , size_t max_dim)
{
  int fd, err;
  fd = open(filename, O_RDONLY);
  if (fd < 0)
    return errno;
  err = npio_load_fd3(fd, array, max_dim);
  close(fd);
  return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x10b0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x14c6
callq 0x1030
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x14e7
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x14f0
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %edi
callq 0x1140
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: onai[P]npio/./npio.h
// Function: npio_load_header_fd3(int, npio_Array*, unsigned long)
static inline int npio_load_header_fd3(int fd, npio_Array* array, size_t max_dim)
{
  ssize_t file_size;
  char *p;

  /* Store the file descriptor for load_data */
  if (!array->_opened)
    array->_fd = fd;

  /* Get the file size in preparation to mmap */
  file_size = lseek(fd, 0, SEEK_END);

  /* If we could not lseek, fallback on read. */
  if (file_size < 0)
    return npio_load_header_fd_read_(fd, array, max_dim);

  /* map-in the file */
  p = (char*) mmap(0, file_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
  if (p == MAP_FAILED)
  {
    if (lseek(fd, 0, SEEK_SET))
      return errno;
    return npio_load_header_fd_read_(fd, array, max_dim);
  }

  array->_mmapped = 1;
  array->_buf = p;
  array->_buf_size = file_size;

  return npio_load_header_mem4(p, file_size, array, max_dim);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x80(%rax)
jne 0x156a
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x50(%rax)
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x159e
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1670
movl %eax, -0x4(%rbp)
jmp 0x163e
movq -0x20(%rbp), %rsi
movl -0x8(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x2, %ecx
movq %r9, %rdi
callq 0x1120
movq %rax, -0x28(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x28(%rbp)
jne 0x1603
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1130
cmpq $0x0, %rax
je 0x15ee
callq 0x1030
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x163e
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1670
movl %eax, -0x4(%rbp)
jmp 0x163e
movq -0x10(%rbp), %rax
movl $0x1, 0x78(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x17a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
leaq -0x24(%rbp), %rsi
movl $0xc, %edx
callq 0x10f0
movl %eax, -0x34(%rbp)
cmpl $0xc, -0x34(%rbp)
jge 0x16ac
callq 0x1030
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1788
leaq -0x24(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1860
movl %eax, -0x38(%rbp)
cmpl $0x0, %eax
je 0x16d0
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1788
movq -0x30(%rbp), %rax
leaq -0x24(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
imulq $0x14, -0x18(%rbp), %rcx
addq $0x400, %rcx            # imm = 0x400
cmpq %rcx, %rax
jbe 0x1704
movl $0x22, -0x4(%rbp)
jmp 0x1788
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rdi
callq 0x10e0
movq -0x10(%rbp), %rcx
movq %rax, 0x68(%rcx)
cmpq $0x0, %rax
jne 0x172c
movl $0xc, -0x4(%rbp)
jmp 0x1788
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x24(%rbp), %rcx
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rsi
addq $0xc, %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0xc, %eax
subq -0x40(%rbp), %rax
subq %rax, %rdx
callq 0x10f0
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rsi
addq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1990
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: onai[P]npio/./npio.h
// Function: npio_load_header_mem4(void*, unsigned long, npio_Array*, unsigned long)
static inline int npio_load_header_mem4(void* p_, size_t sz
  , npio_Array* array, size_t max_dim)
{
  int err;
  char* p = (char*) p_;
  char *end = p + sz;

  /* sanity check, to avoid some checks a bit later. */
  if (sz < 16)
    return EINVAL;

  /* Store this buffer address for load_data */
  if (!array->_mmapped)
  {
    array->_buf = p;
    array->_buf_size = sz;
  }

  if ((err = npio_load_header_prelude_(p, array, &p)))
    return err;

  /* Ensure that the header_len doesn't make us go out of bounds */
  if (p + array->header_len < end)
    end = p + array->header_len;

  /* Parse the header and return */
  return npio_ph_parse_dict_(array, p, end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x10, -0x18(%rbp)
jae 0x17dc
movl $0x16, -0x4(%rbp)
jmp 0x1855
movq -0x20(%rbp), %rax
cmpl $0x0, 0x78(%rax)
jne 0x17fe
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x1860
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x181f
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1855
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
addq 0x8(%rcx), %rax
cmpq -0x40(%rbp), %rax
jae 0x1841
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x1990
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: onai[P]npio/./npio.h
// Function: npio_load_header_prelude_(char*, npio_Array*, char**)
static inline int npio_load_header_prelude_(char* p, npio_Array* array, char** end)
{
  /* assert magic string. Basic size check was done above. */
  if (memcmp(p, "\x93NUMPY", 6) != 0)
    return EINVAL;
  p += 6;

  /* get the version numbers */
  array->major_version = *p++;
  array->minor_version = *p++;

  /* get the header length. Version 1 uses 2 bytes, version 2 uses 4 bytes. */
  switch (array->major_version)
  {
    case 1:
      array->header_len = p[0] + (p[1] << 8);
      p += 2;
      break;

    case 2:
      array->header_len = p[0]
        + (p[1] << 8)
        + (p[2] << 16)
        + (p[3] << 24);
      p += 4;
      break;

    default:
      return ENOTSUP;
  }
  *end = p;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x17de(%rip), %rsi      # 0x305d
movl $0x6, %edx
callq 0x1080
cmpl $0x0, %eax
je 0x189a
movl $0x16, -0x4(%rbp)
jmp 0x197d
movq -0x10(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x18ee
jmp 0x18e4
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x191b
jmp 0x1962
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
jmp 0x196b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movq -0x10(%rbp), %rcx
movsbl 0x3(%rcx), %ecx
shll $0x18, %ecx
addl %ecx, %eax
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x196b
movl $0x5f, -0x4(%rbp)
jmp 0x197d
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: onai[P]npio/./npio.h
// Function: npio_ph_parse_dtype_(npio_Array*)
static inline int npio_ph_parse_dtype_(npio_Array* array)
{
  const char* dtype = array->dtype;

  if (strlen(dtype) != 3)
    return ENOTSUP;

  switch (dtype[0])
  {
    case '<': array->little_endian = 1; break;
    case '>': array->little_endian = 0; break;
    default : return ENOTSUP;
  }

  switch (dtype[1])
  {
    case 'i':
      array->is_signed = 1;
      array->floating_point = 0;
      break;

    case 'u':
      array->is_signed = 0;
      array->floating_point = 0;
      break;

    case 'f':
      array->is_signed = 1;
      array->floating_point = 1;
      break;

    default:
      return ENOTSUP;
  }

  switch (dtype[2])
  {
    case '1': array->bit_width = 8; break;
    case '2': array->bit_width = 16; break;
    case '4': array->bit_width = 32; break;
    case '8': array->bit_width = 64; break;
    default: return ENOTSUP;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1070
cmpq $0x3, %rax
je 0x20b3
movl $0x5f, -0x4(%rbp)
jmp 0x21d9
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x3c, %eax
je 0x20ce
jmp 0x20c4
movl -0x1c(%rbp), %eax
subl $0x3e, %eax
je 0x20db
jmp 0x20e8
movq -0x10(%rbp), %rax
movl $0x1, 0x34(%rax)
jmp 0x20f4
movq -0x10(%rbp), %rax
movl $0x0, 0x34(%rax)
jmp 0x20f4
movl $0x5f, -0x4(%rbp)
jmp 0x21d9
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x66, %eax
je 0x214a
jmp 0x2106
movl -0x20(%rbp), %eax
subl $0x69, %eax
je 0x211a
jmp 0x2110
movl -0x20(%rbp), %eax
subl $0x75, %eax
je 0x2132
jmp 0x2162
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x38(%rax)
jmp 0x216b
movq -0x10(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x38(%rax)
jmp 0x216b
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x38(%rax)
jmp 0x216b
movl $0x5f, -0x4(%rbp)
jmp 0x21d9
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
addl $-0x31, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x7, %eax
ja 0x21c9
movq -0x28(%rbp), %rax
leaq 0xe78(%rip), %rcx       # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl $0x8, 0x40(%rax)
jmp 0x21d2
movq -0x10(%rbp), %rax
movl $0x10, 0x40(%rax)
jmp 0x21d2
movq -0x10(%rbp), %rax
movl $0x20, 0x40(%rax)
jmp 0x21d2
movq -0x10(%rbp), %rax
movl $0x40, 0x40(%rax)
jmp 0x21d2
movl $0x5f, -0x4(%rbp)
jmp 0x21d9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: onai[P]npio/./npio.h
// Function: npio_ph_shape_append_(npio_Array*, unsigned long)
static inline int npio_ph_shape_append_(npio_Array* array, size_t val)
{
  size_t *tmp;
  if (array->dim == array->_shape_capacity)
  {
    array->_shape_capacity *= 2;
    tmp = (size_t*) realloc(array->shape, sizeof(size_t) * array->_shape_capacity);
    if (tmp == 0)
      return ENOMEM;
    array->shape = tmp;
  }
  array->shape[array->dim++] = val;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jne 0x225a
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rcx
shlq %rcx
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rsi
shlq $0x3, %rsi
callq 0x1100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x224e
movl $0xc, -0x4(%rbp)
jmp 0x2284
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rsi
movq 0x18(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x18(%rsi)
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: onai[P]npio/./npio.h
// Function: npio_array_size(npio_Array const*)
static inline size_t npio_array_size(const npio_Array* array)
{
  size_t n = 1, i;
  for (i = 0; i < array->dim; ++i)
    n *= array->shape[i];
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x22dd
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
imulq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x22a8
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)