LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> swxJson::Json::wantDict<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(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, T, Compare, Alloc> wantDict(const std::string& path, const std::string& delim = "./")
	{
		JsonPtr node = getNode(path, delim);
		if (node)
			return node->wantDict<T, Compare, Alloc>();
		
		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 0x6a3b0
leaq 0x58(%rsp), %rdi
callq 0x52990
testb $0x1, %al
jne 0x63864
jmp 0x638a7
leaq 0x58(%rsp), %rdi
callq 0x4ddf0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x63a60
jmp 0x6387d
leaq 0x58(%rsp), %rdi
callq 0x4e270
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x63968
movb $0x1, 0x26(%rsp)
movl $0x60, %edi
callq 0x4a160
movq %rax, (%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4a530
movq 0x8(%rsp), %rdx
leaq 0x1ed29(%rip), %rsi     # 0x825fe
leaq 0x28(%rsp), %rdi
callq 0x4dcf0
jmp 0x638e1
movq (%rsp), %rdi
leaq 0x1ece7(%rip), %rsi     # 0x825d3
leaq 0x1edeb(%rip), %rdx     # 0x826de
movl $0x41c, %ecx            # imm = 0x41C
leaq 0x28(%rsp), %r8
callq 0x52c60
jmp 0x63904
movq (%rsp), %rdi
movb $0x0, 0x26(%rsp)
leaq 0x342c4(%rip), %rsi     # 0x97bd8
leaq -0x10c5b(%rip), %rdx    # 0x52cc0
callq 0x4a500
jmp 0x6397c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x6394a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4a5b8
leaq 0x27(%rsp), %rdi
callq 0x4a390
testb $0x1, 0x26(%rsp)
jne 0x6395d
jmp 0x63966
movq (%rsp), %rdi
callq 0x4a220
jmp 0x63968
leaq 0x58(%rsp), %rdi
callq 0x4e270
movq 0x50(%rsp), %rdi
callq 0x4a520
nopl (%rax)
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::insertNode(std::shared_ptr<swxJson::Json>)
JsonPtr insertNode(JsonPtr node)
	{
		if (_nodeStack.empty())
			return node;
	
		if (_wantValue)
			fillValue(node);
		else
		{
			_nodeStack.top()->pushNode(node);
			_wantComma = true;
		}
		
		return nullptr;
	}

// Assembly:
subq $0x88, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x38(%rsp)
addq $0x1278, %rdi           # imm = 0x1278
callq 0x7e080
testb $0x1, %al
jne 0x7d187
jmp 0x7d19b
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x72050
jmp 0x7d27d
movq 0x38(%rsp), %rax
testb $0x1, 0x12e9(%rax)
je 0x7d1fa
movq 0x20(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4e240
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7e0a0
jmp 0x7d1ce
leaq 0x60(%rsp), %rdi
callq 0x4e270
jmp 0x7d26f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x4e270
jmp 0x7d28a
movq 0x38(%rsp), %rdi
addq $0x1278, %rdi           # imm = 0x1278
callq 0x7e260
movq %rax, %rdi
callq 0x4ddf0
movq 0x20(%rsp), %rsi
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4e240
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x6bba0
jmp 0x7d23d
leaq 0x40(%rsp), %rdi
callq 0x4e270
movq 0x38(%rsp), %rax
movb $0x1, 0x12ea(%rax)
jmp 0x7d26f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4e270
jmp 0x7d28a
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71ea0
movq 0x30(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x4a520
nopw %cs:(%rax,%rax)
nop
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::JsonParser()
JsonParser(): _numberChars("0123456789+-.eE"), _pos(0)
	{
		_wantKey = false;
		_wantValue = false;
		_wantComma = false;
		_wantSemicolon = false;

		for (int i = 0; i < 256; i++)
			_callMap[i] = &JsonParser::generalProcess;

		_callMap[(uint8_t)'{'] = &JsonParser::enterObject;
		_callMap[(uint8_t)'}'] = &JsonParser::exitObject;
		_callMap[(uint8_t)'['] = &JsonParser::enterArray;
		_callMap[(uint8_t)']'] = &JsonParser::exitArray;
		_callMap[(uint8_t)','] = &JsonParser::processComma;
		_callMap[(uint8_t)':'] = &JsonParser::processSemicolon;
		_callMap[(uint8_t)'"'] = &JsonParser::processString;
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x1000, %rax           # imm = 0x1000
movq %rax, 0x18(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4a530
movq 0x20(%rsp), %rdx
leaq 0x4e7f(%rip), %rsi      # 0x82c88
leaq 0x40(%rsp), %rdi
callq 0x4dcf0
jmp 0x7de15
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7e4b0
jmp 0x7de26
leaq 0x40(%rsp), %rdi
callq 0x4a5b8
leaq 0x3f(%rsp), %rdi
callq 0x4a390
movq 0x10(%rsp), %rdi
addq $0x1100, %rdi           # imm = 0x1100
movq %rdi, 0x8(%rsp)
callq 0x4a460
movq 0x10(%rsp), %rdi
addq $0x1278, %rdi           # imm = 0x1278
callq 0x7e500
jmp 0x7de63
movq 0x10(%rsp), %rdi
addq $0x12c8, %rdi           # imm = 0x12C8
callq 0x4a480
movq 0x10(%rsp), %rax
movq $0x0, 0x12f0(%rax)
movb $0x0, 0x12e8(%rax)
movb $0x0, 0x12e9(%rax)
movb $0x0, 0x12ea(%rax)
movb $0x0, 0x12eb(%rax)
movl $0x0, 0x28(%rsp)
cmpl $0x100, 0x28(%rsp)      # imm = 0x100
jge 0x7df39
movq 0x10(%rsp), %rax
movslq 0x28(%rsp), %rcx
shlq $0x4, %rcx
leaq -0x182b(%rip), %rdx     # 0x7c6a0
movq %rdx, (%rax,%rcx)
movq $0x0, 0x8(%rax,%rcx)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x7dea8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x7df0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4a5b8
leaq 0x3f(%rsp), %rdi
callq 0x4a390
jmp 0x7dff2
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x4a0c0
jmp 0x7dff2
movq 0x10(%rsp), %rax
leaq 0x5eb(%rip), %rcx       # 0x7e530
movq %rcx, 0x7b0(%rax)
movq $0x0, 0x7b8(%rax)
leaq 0x852(%rip), %rcx       # 0x7e7b0
movq %rcx, 0x7d0(%rax)
movq $0x0, 0x7d8(%rax)
leaq 0x9b9(%rip), %rcx       # 0x7e930
movq %rcx, 0x5b0(%rax)
movq $0x0, 0x5b8(%rax)
leaq 0xc20(%rip), %rcx       # 0x7ebb0
movq %rcx, 0x5d0(%rax)
movq $0x0, 0x5d8(%rax)
leaq 0xd87(%rip), %rcx       # 0x7ed30
movq %rcx, 0x2c0(%rax)
movq $0x0, 0x2c8(%rax)
leaq 0xeee(%rip), %rcx       # 0x7eeb0
movq %rcx, 0x3a0(%rax)
movq $0x0, 0x3a8(%rax)
leaq 0x1025(%rip), %rcx      # 0x7f000
movq %rcx, 0x220(%rax)
movq $0x0, 0x228(%rax)
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x4a520
nopl (%rax)
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::fillValue(std::shared_ptr<swxJson::Json>)
void fillValue(JsonPtr node)
	{
		if (_nodeStack.top()->addNode(_key, node) == false)
			throw JSON_ERROR_FMT(JosnInvalidContentError, "Json parser: content error, reduplicated key: %s.", _key.c_str());
		
		_wantKey = false;
		_wantValue = false;
		_wantComma = true;
		_wantSemicolon = false;
	}

// Assembly:
subq $0x98, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x1278, %rdi           # imm = 0x1278
callq 0x7e260
movq %rax, %rdi
callq 0x4ddf0
movq 0x18(%rsp), %rsi
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rsp)
addq $0x12c8, %rax           # imm = 0x12C8
movq %rax, 0x30(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x4e240
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x6b420
movb %al, 0x46(%rsp)
jmp 0x7e123
movb 0x46(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x14(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x4e270
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
jne 0x7e221
movb $0x1, 0x47(%rsp)
movl $0x60, %edi
callq 0x4a160
movq 0x20(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x12c8, %rdi           # imm = 0x12C8
callq 0x4a100
movq %rax, %rdx
leaq 0x4a5a(%rip), %rsi      # 0x82bd0
xorl %eax, %eax
leaq 0x48(%rsp), %rdi
callq 0x81bd0
jmp 0x7e184
movq 0x8(%rsp), %rdi
leaq 0x4970(%rip), %rsi      # 0x82b00
leaq 0x4a2f(%rip), %rdx      # 0x82bc6
movl $0x42, %ecx
leaq 0x48(%rsp), %r8
callq 0x7d0d0
jmp 0x7e1a8
movq 0x8(%rsp), %rdi
movb $0x0, 0x47(%rsp)
leaq 0x19b9f(%rip), %rsi     # 0x97d58
leaq -0x1090(%rip), %rdx     # 0x7d130
callq 0x4a500
jmp 0x7e254
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x4e270
jmp 0x7e24a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x7e20c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4a5b8
testb $0x1, 0x47(%rsp)
jne 0x7e215
jmp 0x7e21f
movq 0x8(%rsp), %rdi
callq 0x4a220
jmp 0x7e24a
movq 0x20(%rsp), %rax
movb $0x0, 0x12e8(%rax)
movb $0x0, 0x12e9(%rax)
movb $0x1, 0x12ea(%rax)
movb $0x0, 0x12eb(%rax)
addq $0x98, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x4a520
nopw %cs:(%rax,%rax)
nop
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::enterObject()
JsonPtr enterObject()
	{
		if (_wantKey || _wantSemicolon || _wantComma)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, '{' at improper place.");

		JsonPtr node(new Json());
		node->setDict();
		insertNode(node);
		_nodeStack.push(node);

		_wantKey = true;
		_wantValue = false;
		_wantComma = false;
		_wantSemicolon = false;

		_pos++;
		return nullptr;
	}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x38(%rsp)
testb $0x1, 0x12e8(%rax)
jne 0x7e58a
movq 0x38(%rsp), %rax
testb $0x1, 0x12eb(%rax)
jne 0x7e58a
movq 0x38(%rsp), %rax
testb $0x1, 0x12ea(%rax)
je 0x7e664
movb $0x1, 0x73(%rsp)
movl $0x60, %edi
callq 0x4a160
movq %rax, 0x18(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4a530
movq 0x20(%rsp), %rdx
leaq 0x46e8(%rip), %rsi      # 0x82ca4
leaq 0x88(%rsp), %rdi
callq 0x4dcf0
jmp 0x7e5cb
movq 0x18(%rsp), %rdi
leaq 0x4529(%rip), %rsi      # 0x82b00
leaq 0x46ba(%rip), %rdx      # 0x82c98
movl $0x24, %ecx
leaq 0x88(%rsp), %r8
callq 0x7d0d0
jmp 0x7e5f2
movq 0x18(%rsp), %rdi
movb $0x0, 0x73(%rsp)
leaq 0x19755(%rip), %rsi     # 0x97d58
leaq -0x14da(%rip), %rdx     # 0x7d130
callq 0x4a500
jmp 0x7e7af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x7e63f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x4a5b8
leaq 0x87(%rsp), %rdi
callq 0x4a390
testb $0x1, 0x73(%rsp)
jne 0x7e655
jmp 0x7e65f
movq 0x18(%rsp), %rdi
callq 0x4a220
jmp 0x7e7a5
movl $0x10, %edi
callq 0x4a310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x72080
jmp 0x7e680
movq 0x10(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x720a0
movq 0x8(%rsp), %rdi
callq 0x4ddf0
movq %rax, %rdi
callq 0x6b240
jmp 0x7e6a8
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x60(%rsp), %rsi
callq 0x4e240
movq 0x38(%rsp), %rsi
movq (%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x7d140
jmp 0x7e6d0
leaq 0x50(%rsp), %rdi
callq 0x4e270
leaq 0x40(%rsp), %rdi
callq 0x4e270
movq 0x38(%rsp), %rdi
addq $0x1278, %rdi           # imm = 0x1278
leaq 0x60(%rsp), %rsi
callq 0x7fb50
jmp 0x7e6fc
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rax
movb $0x1, 0x12e8(%rax)
movb $0x0, 0x12e9(%rax)
movb $0x0, 0x12ea(%rax)
movb $0x0, 0x12eb(%rax)
movq 0x12f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x12f0(%rax)
xorl %eax, %eax
movl %eax, %esi
callq 0x71ea0
leaq 0x60(%rsp), %rdi
callq 0x4e270
movq 0x30(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
movl $0x10, %esi
callq 0x4a320
jmp 0x7e7a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x7e79b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4e270
leaq 0x60(%rsp), %rdi
callq 0x4e270
movq 0x78(%rsp), %rdi
callq 0x4a520
nop
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::exitObject()
JsonPtr exitObject()
	{
		if (_wantSemicolon || _wantValue || _nodeStack.empty() || _nodeStack.top()->type() != Json::JSON_Object)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, '}' at improper place.");

		_pos++;
		return finishNode();
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
testb $0x1, 0x12eb(%rax)
jne 0x7e82b
movq 0x28(%rsp), %rax
testb $0x1, 0x12e9(%rax)
jne 0x7e82b
movq 0x28(%rsp), %rdi
addq $0x1278, %rdi           # imm = 0x1278
callq 0x7e080
testb $0x1, %al
jne 0x7e82b
movq 0x28(%rsp), %rdi
addq $0x1278, %rdi           # imm = 0x1278
callq 0x7e260
movq %rax, %rdi
callq 0x4ddf0
movq %rax, %rdi
callq 0x72010
cmpl $0x0, %eax
je 0x7e8f0
movb $0x1, 0x33(%rsp)
movl $0x60, %edi
callq 0x4a160
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4a530
movq 0x10(%rsp), %rdx
leaq 0x4488(%rip), %rsi      # 0x82ce2
leaq 0x48(%rsp), %rdi
callq 0x4dcf0
jmp 0x7e866
movq 0x8(%rsp), %rdi
leaq 0x428e(%rip), %rsi      # 0x82b00
leaq 0x445e(%rip), %rdx      # 0x82cd7
movl $0x4d, %ecx
leaq 0x48(%rsp), %r8
callq 0x7d0d0
jmp 0x7e88a
movq 0x8(%rsp), %rdi
movb $0x0, 0x33(%rsp)
leaq 0x194bd(%rip), %rsi     # 0x97d58
leaq -0x1772(%rip), %rdx     # 0x7d130
callq 0x4a500
jmp 0x7e925
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x7e8d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4a5b8
leaq 0x47(%rsp), %rdi
callq 0x4a390
testb $0x1, 0x33(%rsp)
jne 0x7e8e4
jmp 0x7e8ee
movq 0x8(%rsp), %rdi
callq 0x4a220
jmp 0x7e91b
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq 0x12f0(%rsi), %rax
addq $0x1, %rax
movq %rax, 0x12f0(%rsi)
callq 0x803d0
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x4a520
nopw %cs:(%rax,%rax)
nop
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::enterArray()
JsonPtr enterArray()
	{
		if (_wantKey || _wantSemicolon || _wantComma)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, '[' at improper place.");

		JsonPtr node(new Json());
		node->setArray();
		insertNode(node);
		_nodeStack.push(node);

		_wantKey = false;
		_wantValue = false;
		_wantComma = false;
		_wantSemicolon = false;

		_pos++;
		return nullptr;
	}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x38(%rsp)
testb $0x1, 0x12e8(%rax)
jne 0x7e98a
movq 0x38(%rsp), %rax
testb $0x1, 0x12eb(%rax)
jne 0x7e98a
movq 0x38(%rsp), %rax
testb $0x1, 0x12ea(%rax)
je 0x7ea64
movb $0x1, 0x73(%rsp)
movl $0x60, %edi
callq 0x4a160
movq %rax, 0x18(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4a530
movq 0x20(%rsp), %rdx
leaq 0x4364(%rip), %rsi      # 0x82d20
leaq 0x88(%rsp), %rdi
callq 0x4dcf0
jmp 0x7e9cb
movq 0x18(%rsp), %rdi
leaq 0x4129(%rip), %rsi      # 0x82b00
leaq 0x4337(%rip), %rdx      # 0x82d15
movl $0x56, %ecx
leaq 0x88(%rsp), %r8
callq 0x7d0d0
jmp 0x7e9f2
movq 0x18(%rsp), %rdi
movb $0x0, 0x73(%rsp)
leaq 0x19355(%rip), %rsi     # 0x97d58
leaq -0x18da(%rip), %rdx     # 0x7d130
callq 0x4a500
jmp 0x7ebaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x7ea3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x4a5b8
leaq 0x87(%rsp), %rdi
callq 0x4a390
testb $0x1, 0x73(%rsp)
jne 0x7ea55
jmp 0x7ea5f
movq 0x18(%rsp), %rdi
callq 0x4a220
jmp 0x7eba5
movl $0x10, %edi
callq 0x4a310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
callq 0x72080
jmp 0x7ea80
movq 0x10(%rsp), %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x720a0
movq 0x8(%rsp), %rdi
callq 0x4ddf0
movq %rax, %rdi
callq 0x6bb10
jmp 0x7eaa8
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x60(%rsp), %rsi
callq 0x4e240
movq 0x38(%rsp), %rsi
movq (%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x7d140
jmp 0x7ead0
leaq 0x50(%rsp), %rdi
callq 0x4e270
leaq 0x40(%rsp), %rdi
callq 0x4e270
movq 0x38(%rsp), %rdi
addq $0x1278, %rdi           # imm = 0x1278
leaq 0x60(%rsp), %rsi
callq 0x7fb50
jmp 0x7eafc
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rax
movb $0x0, 0x12e8(%rax)
movb $0x0, 0x12e9(%rax)
movb $0x0, 0x12ea(%rax)
movb $0x0, 0x12eb(%rax)
movq 0x12f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x12f0(%rax)
xorl %eax, %eax
movl %eax, %esi
callq 0x71ea0
leaq 0x60(%rsp), %rdi
callq 0x4e270
movq 0x30(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
movl $0x10, %esi
callq 0x4a320
jmp 0x7eba5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x7eb9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4e270
leaq 0x60(%rsp), %rdi
callq 0x4e270
movq 0x78(%rsp), %rdi
callq 0x4a520
nop
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::exitArray()
JsonPtr exitArray()
	{
		if (_wantSemicolon || _wantValue || _nodeStack.empty() || _nodeStack.top()->type() != Json::JSON_Array)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, ']' at improper place.");

		_pos++;
		return finishNode();
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
testb $0x1, 0x12eb(%rax)
jne 0x7ec2b
movq 0x28(%rsp), %rax
testb $0x1, 0x12e9(%rax)
jne 0x7ec2b
movq 0x28(%rsp), %rdi
addq $0x1278, %rdi           # imm = 0x1278
callq 0x7e080
testb $0x1, %al
jne 0x7ec2b
movq 0x28(%rsp), %rdi
addq $0x1278, %rdi           # imm = 0x1278
callq 0x7e260
movq %rax, %rdi
callq 0x4ddf0
movq %rax, %rdi
callq 0x72010
cmpl $0x1, %eax
je 0x7ecf0
movb $0x1, 0x33(%rsp)
movl $0x60, %edi
callq 0x4a160
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4a530
movq 0x10(%rsp), %rdx
leaq 0x4103(%rip), %rsi      # 0x82d5d
leaq 0x48(%rsp), %rdi
callq 0x4dcf0
jmp 0x7ec66
movq 0x8(%rsp), %rdi
leaq 0x3e8e(%rip), %rsi      # 0x82b00
leaq 0x40da(%rip), %rdx      # 0x82d53
movl $0x69, %ecx
leaq 0x48(%rsp), %r8
callq 0x7d0d0
jmp 0x7ec8a
movq 0x8(%rsp), %rdi
movb $0x0, 0x33(%rsp)
leaq 0x190bd(%rip), %rsi     # 0x97d58
leaq -0x1b72(%rip), %rdx     # 0x7d130
callq 0x4a500
jmp 0x7ed25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x7ecd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4a5b8
leaq 0x47(%rsp), %rdi
callq 0x4a390
testb $0x1, 0x33(%rsp)
jne 0x7ece4
jmp 0x7ecee
movq 0x8(%rsp), %rdi
callq 0x4a220
jmp 0x7ed1b
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq 0x12f0(%rsi), %rax
addq $0x1, %rax
movq %rax, 0x12f0(%rsi)
callq 0x803d0
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x4a520
nopw %cs:(%rax,%rax)
nop
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::processComma()
JsonPtr processComma()
	{
		if (_wantComma == false)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, ',' at error position.");

		_wantComma = false;
		if (_nodeStack.top()->type() == Json::JSON_Object)
			_wantKey = true;

		_pos++;
		return nullptr;
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movb 0x12ea(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x7ee31
movb $0x1, 0x33(%rsp)
movl $0x60, %edi
callq 0x4a160
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4a530
movq 0x10(%rsp), %rdx
leaq 0x4005(%rip), %rsi      # 0x82d9d
leaq 0x48(%rsp), %rdi
callq 0x4dcf0
jmp 0x7eda4
movq 0x8(%rsp), %rdi
leaq 0x3d50(%rip), %rsi      # 0x82b00
leaq 0x3fd9(%rip), %rdx      # 0x82d90
movl $0x16d, %ecx            # imm = 0x16D
leaq 0x48(%rsp), %r8
callq 0x7d0d0
jmp 0x7edc8
movq 0x8(%rsp), %rdi
movb $0x0, 0x33(%rsp)
leaq 0x18f7f(%rip), %rsi     # 0x97d58
leaq -0x1cb0(%rip), %rdx     # 0x7d130
callq 0x4a500
jmp 0x7eea3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x7ee12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4a5b8
leaq 0x47(%rsp), %rdi
callq 0x4a390
testb $0x1, 0x33(%rsp)
jne 0x7ee25
jmp 0x7ee2f
movq 0x8(%rsp), %rdi
callq 0x4a220
jmp 0x7ee99
movq 0x28(%rsp), %rdi
movb $0x0, 0x12ea(%rdi)
addq $0x1278, %rdi           # imm = 0x1278
callq 0x7e260
movq %rax, %rdi
callq 0x4ddf0
movq %rax, %rdi
callq 0x72010
cmpl $0x0, %eax
jne 0x7ee6a
movq 0x28(%rsp), %rax
movb $0x1, 0x12e8(%rax)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x12f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x12f0(%rax)
xorl %eax, %eax
movl %eax, %esi
callq 0x71ea0
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x4a520
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::processSemicolon()
JsonPtr processSemicolon()
	{
		if (_wantSemicolon == false)
			throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, ':' at error position.");

		_wantSemicolon = false;
		_wantValue = true;
		_pos++;
		return nullptr;
	}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movb 0x12eb(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x7efb1
movb $0x1, 0x33(%rsp)
movl $0x60, %edi
callq 0x4a160
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4a530
movq 0x10(%rsp), %rdx
leaq 0x3ec9(%rip), %rsi      # 0x82de1
leaq 0x48(%rsp), %rdi
callq 0x4dcf0
jmp 0x7ef24
movq 0x8(%rsp), %rdi
leaq 0x3bd0(%rip), %rsi      # 0x82b00
leaq 0x3e99(%rip), %rdx      # 0x82dd0
movl $0x17a, %ecx            # imm = 0x17A
leaq 0x48(%rsp), %r8
callq 0x7d0d0
jmp 0x7ef48
movq 0x8(%rsp), %rdi
movb $0x0, 0x33(%rsp)
leaq 0x18dff(%rip), %rsi     # 0x97d58
leaq -0x1e30(%rip), %rdx     # 0x7d130
callq 0x4a500
jmp 0x7eff8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x7ef92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4a5b8
leaq 0x47(%rsp), %rdi
callq 0x4a390
testb $0x1, 0x33(%rsp)
jne 0x7efa5
jmp 0x7efaf
movq 0x8(%rsp), %rdi
callq 0x4a220
jmp 0x7efee
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movb $0x0, 0x12eb(%rax)
movb $0x1, 0x12e9(%rax)
movq 0x12f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x12f0(%rax)
xorl %eax, %eax
movl %eax, %esi
callq 0x71ea0
movq 0x20(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x4a520
nopl (%rax,%rax)
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::processString()
JsonPtr processString()
	{
		if(_wantComma || _wantSemicolon)
				throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error.");

		std::string str = fetchString();
		
		if (_wantKey)
		{
			fillKey(str);
			return nullptr;
		}
		else
		{
			JsonPtr node(new Json(str));
			return insertNode(node);
		}
	}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x30(%rsp)
testb $0x1, 0x12ea(%rax)
jne 0x7f04c
movq 0x30(%rsp), %rax
testb $0x1, 0x12eb(%rax)
je 0x7f13b
movb $0x1, 0x83(%rsp)
movl $0x60, %edi
callq 0x4a160
movq %rax, 0x10(%rsp)
leaq 0x97(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4a530
movq 0x18(%rsp), %rdx
leaq 0x3aa0(%rip), %rsi      # 0x82b21
leaq 0x98(%rsp), %rdi
callq 0x4dcf0
jmp 0x7f090
movq 0x10(%rsp), %rdi
leaq 0x3a64(%rip), %rsi      # 0x82b00
leaq 0x3d71(%rip), %rdx      # 0x82e14
movl $0x15a, %ecx            # imm = 0x15A
leaq 0x98(%rsp), %r8
callq 0x7d0d0
jmp 0x7f0b7
movq 0x10(%rsp), %rdi
movb $0x0, 0x83(%rsp)
leaq 0x18c8d(%rip), %rsi     # 0x97d58
leaq -0x1fa2(%rip), %rdx     # 0x7d130
callq 0x4a500
jmp 0x7f293
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x7f113
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x4a5b8
leaq 0x97(%rsp), %rdi
callq 0x4a390
testb $0x1, 0x83(%rsp)
jne 0x7f12c
jmp 0x7f136
movq 0x10(%rsp), %rdi
callq 0x4a220
jmp 0x7f286
movq 0x30(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x80630
movq 0x30(%rsp), %rax
testb $0x1, 0x12e8(%rax)
je 0x7f19d
movq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x80a50
jmp 0x7f169
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71ea0
movl $0x1, 0x5c(%rsp)
jmp 0x7f265
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x7f27c
movl $0x10, %edi
callq 0x4a310
movq %rax, 0x8(%rsp)
jmp 0x7f1ae
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x73bc0
jmp 0x7f1bf
movq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x720a0
jmp 0x7f1d0
leaq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x48(%rsp), %rsi
callq 0x4e240
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq (%rsp), %rdx
callq 0x7d140
jmp 0x7f1f8
leaq 0x38(%rsp), %rdi
callq 0x4e270
movl $0x1, 0x5c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4e270
jmp 0x7f265
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
movl $0x10, %esi
callq 0x4a320
jmp 0x7f27c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4e270
leaq 0x48(%rsp), %rdi
callq 0x4e270
jmp 0x7f27c
leaq 0x60(%rsp), %rdi
callq 0x4a5b8
movq 0x28(%rsp), %rax
addq $0xc8, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x4a5b8
movq 0x88(%rsp), %rdi
callq 0x4a520
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::finishNode()
JsonPtr finishNode()
	{
		if (_nodeStack.size() == 1)
		{
			JsonPtr root = _nodeStack.top();
			_nodeStack.pop();
			return root;
		}
		else
		{
			_nodeStack.pop();
			
			_wantKey = false;
			_wantValue = false;
			_wantComma = true;
			_wantSemicolon = false;
		}
		
		return nullptr;
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x1278, %rdi           # imm = 0x1278
callq 0x804d0
cmpq $0x1, %rax
jne 0x8046d
movq 0x18(%rsp), %rdi
movb $0x0, 0x37(%rsp)
addq $0x1278, %rdi           # imm = 0x1278
movq %rdi, (%rsp)
callq 0x7e260
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4e240
movq (%rsp), %rdi
callq 0x804e0
jmp 0x80439
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x8046b
jmp 0x80461
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x4e270
jmp 0x804b7
movq 0x8(%rsp), %rdi
callq 0x4e270
jmp 0x804ad
movq 0x18(%rsp), %rdi
addq $0x1278, %rdi           # imm = 0x1278
callq 0x804e0
movq 0x18(%rsp), %rax
movb $0x0, 0x12e8(%rax)
movb $0x0, 0x12e9(%rax)
movb $0x1, 0x12ea(%rax)
movb $0x0, 0x12eb(%rax)
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x71ea0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x4a520
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::fillKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void fillKey(std::string& key)
	{
		_key.swap(key);

		_wantKey = false;
		_wantValue = false;
		_wantComma = false;
		_wantSemicolon = true;

	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x12c8, %rdi           # imm = 0x12C8
movq 0x8(%rsp), %rsi
callq 0x4a210
movq (%rsp), %rax
movb $0x0, 0x12e8(%rax)
movb $0x0, 0x12e9(%rax)
movb $0x0, 0x12ea(%rax)
movb $0x1, 0x12eb(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::parseUTF16Char()
uint16_t parseUTF16Char()
	{
		uint16_t utf16Char = 0;
		for (int i = 0; i < 4; i++)
		{
			char c = *(_pos + i);

			if (c <= '9' && c >= '0')
				c -= '0';
			else if (c <= 'f' && c>= 'a')
			{
				c -= 'a';
				c += 10;
			}
			else if (c <= 'F' && c>= 'A')
			{
				c -= 'A';
				c += 10;
			}
			else
				throw JSON_ERROR_MSG(JosnInvalidContentError, "Json parser: content error, uncompleted string.");

			utf16Char <<= 4;
			utf16Char += (uint16_t)c;
		}

		return utf16Char;
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movw $0x0, 0x5e(%rsp)
movl $0x0, 0x58(%rsp)
cmpl $0x4, 0x58(%rsp)
jge 0x813a5
movq 0x10(%rsp), %rax
movq 0x12f0(%rax), %rax
movslq 0x58(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x57(%rsp)
movsbl 0x57(%rsp), %eax
cmpl $0x39, %eax
jg 0x8124a
movsbl 0x57(%rsp), %eax
cmpl $0x30, %eax
jl 0x8124a
movsbl 0x57(%rsp), %eax
subl $0x30, %eax
movb %al, 0x57(%rsp)
jmp 0x81374
movsbl 0x57(%rsp), %eax
cmpl $0x66, %eax
jg 0x8127b
movsbl 0x57(%rsp), %eax
cmpl $0x61, %eax
jl 0x8127b
movsbl 0x57(%rsp), %eax
subl $0x61, %eax
movb %al, 0x57(%rsp)
movsbl 0x57(%rsp), %eax
addl $0xa, %eax
movb %al, 0x57(%rsp)
jmp 0x81372
movsbl 0x57(%rsp), %eax
cmpl $0x46, %eax
jg 0x812ac
movsbl 0x57(%rsp), %eax
cmpl $0x41, %eax
jl 0x812ac
movsbl 0x57(%rsp), %eax
subl $0x41, %eax
movb %al, 0x57(%rsp)
movsbl 0x57(%rsp), %eax
addl $0xa, %eax
movb %al, 0x57(%rsp)
jmp 0x81370
movb $0x1, 0x1b(%rsp)
movl $0x60, %edi
callq 0x4a160
movq %rax, (%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4a530
movq 0x8(%rsp), %rdx
leaq 0x1b54(%rip), %rsi      # 0x82e2e
leaq 0x30(%rsp), %rdi
callq 0x4dcf0
jmp 0x812e6
movq (%rsp), %rdi
leaq 0x180f(%rip), %rsi      # 0x82b00
leaq 0x1c69(%rip), %rdx      # 0x82f61
movl $0xd1, %ecx
leaq 0x30(%rsp), %r8
callq 0x7d0d0
jmp 0x81309
movq (%rsp), %rdi
movb $0x0, 0x1b(%rsp)
leaq 0x16a3f(%rip), %rsi     # 0x97d58
leaq -0x41f0(%rip), %rdx     # 0x7d130
callq 0x4a500
jmp 0x813b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x81352
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4a5b8
leaq 0x2f(%rsp), %rdi
callq 0x4a390
testb $0x1, 0x1b(%rsp)
jne 0x81365
jmp 0x8136e
movq (%rsp), %rdi
callq 0x4a220
jmp 0x813af
jmp 0x81372
jmp 0x81374
movzwl 0x5e(%rsp), %eax
shll $0x4, %eax
movw %ax, 0x5e(%rsp)
movsbl 0x57(%rsp), %eax
movzwl %ax, %ecx
movzwl 0x5e(%rsp), %eax
addl %ecx, %eax
movw %ax, 0x5e(%rsp)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x81202
movw 0x5e(%rsp), %ax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x4a520
nopl (%rax)
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::UTF16ToUTF8(unsigned short)
void UTF16ToUTF8(uint16_t utf16Char)
	{
		const uint8_t utf82 = 0xc0;	//-- 1100 0000
		const uint8_t utf83 = 0xe0;	//-- 1110 0000
		const uint8_t low6BitsMask = 0x3F;	//-- 0011 1111

		if (utf16Char <= 0x7F)
		{
			_outStringStream<<(char)utf16Char;
		}
		else if (utf16Char <= 0x7FF)
		{
			char a = utf82 | (utf16Char >> 6);
			char b = 0x80 | (utf16Char & low6BitsMask);

			_outStringStream << a << b;
		}
		else
		{
			char a = utf83 | (utf16Char >> 12);
			char b = 0x80 | ((utf16Char >> 6) & low6BitsMask);
			char c = 0x80 | (utf16Char & low6BitsMask);

			_outStringStream << a << b << c;
		}
	}

// Assembly:
subq $0x28, %rsp
movw %si, %ax
movq %rdi, 0x20(%rsp)
movw %ax, 0x1e(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $-0x40, 0x1d(%rsp)
movb $-0x20, 0x1c(%rsp)
movb $0x3f, 0x1b(%rsp)
movzwl 0x1e(%rsp), %eax
cmpl $0x7f, %eax
jg 0x81412
movq 0x8(%rsp), %rdi
addq $0x1100, %rdi           # imm = 0x1100
movw 0x1e(%rsp), %ax
movsbl %al, %esi
callq 0x4a3e0
jmp 0x814cd
movzwl 0x1e(%rsp), %eax
cmpl $0x7ff, %eax            # imm = 0x7FF
jg 0x81465
movq 0x8(%rsp), %rdi
movzwl 0x1e(%rsp), %eax
sarl $0x6, %eax
orl $0xc0, %eax
movb %al, 0x1a(%rsp)
movzwl 0x1e(%rsp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, 0x19(%rsp)
addq $0x1100, %rdi           # imm = 0x1100
movsbl 0x1a(%rsp), %esi
callq 0x4a3e0
movq %rax, %rdi
movsbl 0x19(%rsp), %esi
callq 0x4a3e0
jmp 0x814cb
movq 0x8(%rsp), %rdi
movzwl 0x1e(%rsp), %eax
sarl $0xc, %eax
orl $0xe0, %eax
movb %al, 0x18(%rsp)
movzwl 0x1e(%rsp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, 0x17(%rsp)
movzwl 0x1e(%rsp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, 0x16(%rsp)
addq $0x1100, %rdi           # imm = 0x1100
movsbl 0x18(%rsp), %esi
callq 0x4a3e0
movq %rax, %rdi
movsbl 0x17(%rsp), %esi
callq 0x4a3e0
movq %rax, %rdi
movsbl 0x16(%rsp), %esi
callq 0x4a3e0
jmp 0x814cd
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: swxlion[P]swxJson/src/swxJsonParser.cpp
// Function: swxJson::JsonParser::UTF16ToUTF8(unsigned short, unsigned short)
void UTF16ToUTF8(uint16_t W1, uint16_t W2)
	{
		const uint8_t low6BitsMask = 0x3F;	//-- 0011 1111

		uint32_t utf16SurrogatePair = (((W1 - 0xD800) << 10) | (W2 - 0xDC00)) + 0x10000;

		char a = 0xF0 | (utf16SurrogatePair >> 18);
		char b = 0x80 | ((utf16SurrogatePair >> 12) & low6BitsMask);
		char c = 0x80 | ((utf16SurrogatePair >> 6) & low6BitsMask);
		char d = 0x80 | (utf16SurrogatePair & low6BitsMask);
		
		_outStringStream << a << b << c << d;
	}

// Assembly:
subq $0x18, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, 0x10(%rsp)
movw %cx, 0xe(%rsp)
movw %ax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movb $0x3f, 0xb(%rsp)
movzwl 0xe(%rsp), %eax
subl $0xd800, %eax           # imm = 0xD800
shll $0xa, %eax
movzwl 0xc(%rsp), %ecx
subl $0xdc00, %ecx           # imm = 0xDC00
orl %ecx, %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
shrl $0x12, %eax
orl $0xf0, %eax
movb %al, 0x3(%rsp)
movl 0x4(%rsp), %eax
shrl $0xc, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, 0x2(%rsp)
movl 0x4(%rsp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, 0x1(%rsp)
movl 0x4(%rsp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, (%rsp)
addq $0x1100, %rdi           # imm = 0x1100
movsbl 0x3(%rsp), %esi
callq 0x4a3e0
movq %rax, %rdi
movsbl 0x2(%rsp), %esi
callq 0x4a3e0
movq %rax, %rdi
movsbl 0x1(%rsp), %esi
callq 0x4a3e0
movq %rax, %rdi
movsbl (%rsp), %esi
callq 0x4a3e0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day03/ex03/NinjaTrap.cpp
// Function: NinjaTrap::NinjaTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
NinjaTrap::NinjaTrap(std::string name) : ClapTrap(name)
{
	this->hitPoints = 60;
	this->maxHit = 60;
	this->energyPoints = 120;
	this->maxEnergyPoints = 120;
	this->meleeAttackDamage = 60;
	this->rangedAttackDamage = 5;
	this->armorDamageReduction = 0;
	this->level = 1.0;
	std::cout << this->name << ": IIAAAA ! I'm a ninja !" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2080
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x24a0
jmp 0x3054
leaq -0x30(%rbp), %rdi
callq 0x20a0
movq -0x50(%rbp), %rsi
leaq 0x4cc8(%rip), %rax      # 0x7d30
movq %rax, (%rsi)
movl $0x3c, 0x8(%rsi)
movl $0x3c, 0xc(%rsi)
movl $0x78, 0x10(%rsi)
movl $0x78, 0x14(%rsi)
movl $0x3c, 0x40(%rsi)
movl $0x5, 0x44(%rsi)
movl $0x0, 0x48(%rsi)
movl $0x3f800000, 0x18(%rsi) # imm = 0x3F800000
addq $0x20, %rsi
movq 0x4f2a(%rip), %rdi      # 0x7fd8
callq 0x2100
movq %rax, -0x58(%rbp)
jmp 0x30b9
movq -0x58(%rbp), %rdi
leaq 0x20f1(%rip), %rsi      # 0x51b5
callq 0x2130
movq %rax, -0x60(%rbp)
jmp 0x30cf
movq -0x60(%rbp), %rdi
movq 0x4eee(%rip), %rsi      # 0x7fc8
callq 0x2150
jmp 0x30e1
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20a0
jmp 0x3113
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x26f0
movq -0x38(%rbp), %rdi
callq 0x2220
nopl (%rax)
// File: ian-howell[P]configparser/src/config_parser.cpp
// Function: Config::get_section(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::map<std::string, std::string> Config::get_section(const std::string& section_name)
{
    if (sections.count(section_name) == 0)
    {
        std::string error = "No such key: `" + section_name + "`";
        throw std::out_of_range(error);
    }
    return sections.at(section_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4f30
cmpq $0x0, %rax
jne 0x4220
movq -0x18(%rbp), %rdx
leaq 0x4ed4(%rip), %rsi      # 0x903c
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4e00
movq -0x88(%rbp), %rsi
leaq 0x4f1e(%rip), %rdx      # 0x90a4
leaq -0x38(%rbp), %rdi
callq 0x4db0
jmp 0x4191
leaq -0x58(%rbp), %rdi
callq 0x31a0
movl $0x10, %edi
callq 0x3150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x3390
jmp 0x41bc
movq -0x90(%rbp), %rdi
movq 0x9e06(%rip), %rsi      # 0xdfd0
movq 0x9df7(%rip), %rdx      # 0xdfc8
callq 0x3410
jmp 0x424f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x31a0
jmp 0x4246
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x31f0
jmp 0x4215
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31a0
jmp 0x4246
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4f90
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x5030
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3440
nop
// File: ian-howell[P]configparser/src/config_parser.cpp
// Function: Config::dump(_IO_FILE*)
void Config::dump(FILE* log_file)
{
    // Set up iterators
    std::map<std::string, std::string>::iterator itr1;
    std::map<std::string, std::map<std::string, std::string> >::iterator itr2;
    for(itr2 = sections.begin(); itr2 != sections.end(); itr2++)
    {
        fprintf(log_file, "[%s]\n", itr2->first.c_str());
        for(itr1 = itr2->second.begin(); itr1 != itr2->second.end(); itr1++)
        {
            fprintf(log_file, "%s=%s\n", itr1->first.c_str(), itr1->second.c_str());
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5060
leaq -0x20(%rbp), %rdi
callq 0x5080
movq -0x58(%rbp), %rdi
callq 0x50a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5100
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x50d0
testb $0x1, %al
jne 0x42f2
jmp 0x43e2
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5130
movq %rax, %rdi
callq 0x3110
movq -0x60(%rbp), %rdi
movq %rax, %rdx
leaq 0x4d32(%rip), %rsi      # 0x904b
movb $0x0, %al
callq 0x3360
leaq -0x20(%rbp), %rdi
callq 0x5130
movq %rax, %rdi
addq $0x20, %rdi
callq 0x5150
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5130
movq %rax, %rdi
addq $0x20, %rdi
callq 0x51b0
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5180
testb $0x1, %al
jne 0x436d
jmp 0x43cc
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x51e0
movq %rax, %rdi
callq 0x3110
movq %rax, -0x68(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x51e0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x3110
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
movq %rax, %rcx
leaq 0x4ca0(%rip), %rsi      # 0x9051
movb $0x0, %al
callq 0x3360
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x5200
movq %rax, -0x48(%rbp)
jmp 0x4341
jmp 0x43ce
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x5240
movq %rax, -0x50(%rbp)
jmp 0x42cf
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ian-howell[P]configparser/src/main.cpp
// Function: main
int main()
{
    Config config("example1.ini");

    for (const auto& it : config["Example"])
    {
        std::cout << "`" << it.first << "` -> `" << it.second << "`\n";
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x4(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3450
movq -0xf0(%rbp), %rdx
leaq 0x66a(%rip), %rsi       # 0x90fa
leaq -0x58(%rbp), %rdi
callq 0x4d00
jmp 0x8a9b
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3640
jmp 0x8aaa
leaq -0x58(%rbp), %rdi
callq 0x31a0
leaq -0x59(%rbp), %rdi
callq 0x32c0
leaq -0xc9(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x3450
movq -0xf8(%rbp), %rdx
leaq 0x62a(%rip), %rsi       # 0x9107
leaq -0xc8(%rbp), %rdi
callq 0x4d00
jmp 0x8aeb
leaq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x4250
jmp 0x8b04
leaq -0xc8(%rbp), %rdi
callq 0x31a0
leaq -0xc9(%rbp), %rdi
callq 0x32c0
leaq -0xa8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x5150
movq %rax, -0xd8(%rbp)
movq -0x78(%rbp), %rdi
callq 0x51b0
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x5180
testb $0x1, %al
jne 0x8bd7
leaq -0xa8(%rbp), %rdi
callq 0x5880
jmp 0x8ca0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x8b92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x31a0
leaq -0x59(%rbp), %rdi
callq 0x32c0
jmp 0x8cc5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x8bc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x31a0
leaq -0xc9(%rbp), %rdi
callq 0x32c0
jmp 0x8cbc
leaq -0xd8(%rbp), %rdi
callq 0x7c40
movq %rax, -0xe8(%rbp)
movq 0x53cf(%rip), %rdi      # 0xdfc0
leaq 0x4ac(%rip), %rsi       # 0x90a4
callq 0x3260
movq %rax, -0x100(%rbp)
jmp 0x8c06
movq -0x100(%rbp), %rdi
movq -0xe8(%rbp), %rsi
callq 0x3250
movq %rax, -0x108(%rbp)
jmp 0x8c22
movq -0x108(%rbp), %rdi
leaq 0x4df(%rip), %rsi       # 0x910f
callq 0x3260
movq %rax, -0x110(%rbp)
jmp 0x8c3e
movq -0x110(%rbp), %rdi
movq -0xe8(%rbp), %rsi
addq $0x20, %rsi
callq 0x3250
movq %rax, -0x118(%rbp)
jmp 0x8c5e
movq -0x118(%rbp), %rdi
leaq 0x4aa(%rip), %rsi       # 0x9116
callq 0x3260
jmp 0x8c73
jmp 0x8c75
leaq -0xd8(%rbp), %rdi
callq 0x87f0
jmp 0x8b47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x5880
jmp 0x8cbc
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8cd0
movl -0x4(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x8cd0
movq -0x68(%rbp), %rdi
callq 0x3440
nop
// File: OtherCrashOverride[P]xu4enc/./M2M.h
// Function: M2M::GetEncodedData(void*)
int GetEncodedData(void* dataOut)
	{
		int result;


		// deque
		v4l2_plane planes[VIDEO_MAX_PLANES];

		v4l2_buffer buffer = { 0 };
		buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
		buffer.memory = V4L2_MEMORY_MMAP;
		buffer.m.planes = planes;
		buffer.length = 1;

		int ret = ioctl(mfc_fd, VIDIOC_DQBUF, &buffer);
		if (ret != 0)
		{
			printf("Waiting on V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE buffer.\n");
			result = 0;
		}
		else
		{
			result = buffer.m.planes[0].bytesused;

			// Copy data
			BufferMapping mapping = outputBuffers[buffer.index];

			memcpy(dataOut, mapping.Start0, buffer.m.planes[0].bytesused);


			// Re-queue buffer
			ret = ioctl(mfc_fd, VIDIOC_QBUF, &buffer);
			if (ret != 0)
			{
				throw Exception("VIDIOC_QBUF failed.");
			}
		}

		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x2b8(%rbp)
leaq -0x278(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x20b0
movq -0x2b8(%rbp), %rax
movl $0x9, -0x274(%rbp)
movl $0x1, -0x23c(%rbp)
leaq -0x220(%rbp), %rcx
movq %rcx, -0x238(%rbp)
movl $0x1, -0x230(%rbp)
movl 0x8(%rax), %edi
movl $0xc0585611, %esi       # imm = 0xC0585611
leaq -0x278(%rbp), %rdx
movb $0x0, %al
callq 0x2120
movl %eax, -0x27c(%rbp)
cmpl $0x0, -0x27c(%rbp)
je 0x3243
leaq 0x4306(%rip), %rdi      # 0x7536
movb $0x0, %al
callq 0x2040
movl $0x0, -0x14(%rbp)
jmp 0x333a
movq -0x2b8(%rbp), %rdi
movq -0x238(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
addq $0x38, %rdi
movl -0x278(%rbp), %eax
movl %eax, %esi
callq 0x62a0
movq (%rax), %rcx
movq %rcx, -0x2a0(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x298(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x290(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x288(%rbp)
movq -0x10(%rbp), %rdi
movq -0x2a0(%rbp), %rsi
movq -0x238(%rbp), %rax
movl (%rax), %eax
movl %eax, %edx
callq 0x20f0
movq -0x2b8(%rbp), %rax
movl 0x8(%rax), %edi
movl $0xc058560f, %esi       # imm = 0xC058560F
leaq -0x278(%rbp), %rdx
movb $0x0, %al
callq 0x2120
movl %eax, -0x27c(%rbp)
cmpl $0x0, -0x27c(%rbp)
je 0x3338
movl $0x8, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x2c0(%rbp)
leaq 0x41e3(%rip), %rsi      # 0x74da
callq 0x28c0
jmp 0x32fe
movq -0x2c0(%rbp), %rdi
leaq 0x7a64(%rip), %rsi      # 0xad70
leaq -0x9f3(%rip), %rdx      # 0x2920
callq 0x21b0
movq -0x2c0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2a8(%rbp)
movl %eax, -0x2ac(%rbp)
callq 0x20c0
jmp 0x3346
jmp 0x333a
movl -0x14(%rbp), %eax
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
movq -0x2a8(%rbp), %rdi
callq 0x21c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: OtherCrashOverride[P]xu4enc/./M2M.h
// Function: M2M::~M2M()
~M2M()
	{
		// Stop output stream
		int val = (int)V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;

		int ret = ioctl(mfc_fd, VIDIOC_STREAMOFF, &val);
		if (ret != 0)
		{
			throw Exception("VIDIOC_STREAMOFF failed.");
		}

		// Stop input stream
		val = (int)V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;

		ret = ioctl(mfc_fd, VIDIOC_STREAMOFF, &val);
		if (ret != 0)
		{
			throw Exception("VIDIOC_STREAMOFF failed.");
		}


		close(mfc_fd);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x9, -0xc(%rbp)
movl 0x8(%rax), %edi
movl $0x40045613, %esi       # imm = 0x40045613
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x2120
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x33d5
movl $0x8, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
leaq 0x41bb(%rip), %rsi      # 0x756d
callq 0x28c0
jmp 0x33b9
movq -0x20(%rbp), %rdi
leaq 0x79ac(%rip), %rsi      # 0xad70
leaq -0xaab(%rip), %rdx      # 0x2920
callq 0x21b0
jmp 0x347a
movq -0x18(%rbp), %rax
movl $0xa, -0xc(%rbp)
movl 0x8(%rax), %edi
movl $0x40045613, %esi       # imm = 0x40045613
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x2120
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x3437
movl $0x8, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x4156(%rip), %rsi      # 0x756d
callq 0x28c0
jmp 0x341e
movq -0x28(%rbp), %rdi
leaq 0x7947(%rip), %rsi      # 0xad70
leaq -0xb10(%rip), %rdx      # 0x2920
callq 0x21b0
jmp 0x347a
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x21f0
jmp 0x3445
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0x41b0
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x41d0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x41d0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x47d0
nopw (%rax,%rax)