LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::setUseColour(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void setUseColour( ConfigData& config, std::string const& value ) {
        std::string mode = toLower( value );

        if( mode == "yes" )
            config.useColour = UseColour::Yes;
        else if( mode == "no" )
            config.useColour = UseColour::No;
        else if( mode == "auto" )
            config.useColour = UseColour::Auto;
        else
            throw std::runtime_error( "colour mode must be one of: auto, yes or no" );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xff90
movq -0x48(%rbp), %rdi
leaq 0x29cb6(%rip), %rsi     # 0x772e2
callq 0x2e0a0
movb %al, -0x3d(%rbp)
jmp 0x4d636
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x4d63f
jmp 0x4d660
movq -0x8(%rbp), %rax
movl $0x1, 0x24(%rax)
jmp 0x4d70c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4d71b
leaq 0x29e28(%rip), %rsi     # 0x7748f
leaq -0x30(%rbp), %rdi
callq 0x2e0a0
movb %al, -0x49(%rbp)
jmp 0x4d675
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x4d67e
jmp 0x4d68b
movq -0x8(%rbp), %rax
movl $0x2, 0x24(%rax)
jmp 0x4d70a
leaq 0x29dcf(%rip), %rsi     # 0x77461
leaq -0x30(%rbp), %rdi
callq 0x2e0a0
movb %al, -0x4a(%rbp)
jmp 0x4d6a0
movb -0x4a(%rbp), %al
testb $0x1, %al
jne 0x4d6a9
jmp 0x4d6b6
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
jmp 0x4d708
movl $0x10, %edi
callq 0xc2c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x29d95(%rip), %rsi     # 0x77466
callq 0xc1f0
jmp 0x4d6d8
movq -0x58(%rbp), %rdi
movq 0x5a90d(%rip), %rsi     # 0xa7ff0
movq 0x5a8a6(%rip), %rdx     # 0xa7f90
callq 0xc940
jmp 0x4d72d
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xc420
jmp 0x4d71b
jmp 0x4d70a
jmp 0x4d70c
leaq -0x30(%rbp), %rdi
callq 0xcac0
addq $0x60, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xcac0
movq -0x38(%rbp), %rdi
callq 0xc990
nopl (%rax)
// File: dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::parseInto(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, Catch::ConfigData&) const
std::vector<Parser::Token> parseInto( std::vector<std::string> const& args, ConfigT& config ) const {
            std::string processName = args[0];
            std::size_t lastSlash = processName.find_last_of( "/\\" );
            if( lastSlash != std::string::npos )
                processName = processName.substr( lastSlash+1 );
            m_boundProcessName.set( config, processName );
            std::vector<Parser::Token> tokens;
            Parser parser;
            parser.parseIntoTokens( args, tokens );
            return populate( tokens, config );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x52400
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0xc250
leaq -0x40(%rbp), %rdi
leaq 0x25bec(%rip), %rsi     # 0x774a7
movq $-0x1, %rdx
callq 0xc520
movq %rax, -0x48(%rbp)
cmpq $-0x1, -0x48(%rbp)
je 0x51918
movq -0x48(%rbp), %rdx
incq %rdx
leaq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq $-0x1, %rcx
callq 0xc5b0
jmp 0x518ef
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xc6b0
leaq -0x68(%rbp), %rdi
callq 0xcac0
jmp 0x51918
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x519be
movq -0xb0(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x52420
jmp 0x5192e
leaq -0x90(%rbp), %rdi
callq 0x4c0f0
leaq -0xa8(%rbp), %rdi
callq 0x52450
jmp 0x51948
movq -0x18(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x52470
jmp 0x51961
movq -0xb0(%rbp), %rsi
movq -0xc0(%rbp), %rdi
movq -0x20(%rbp), %rcx
leaq -0x90(%rbp), %rdx
callq 0x52590
jmp 0x51981
leaq -0x90(%rbp), %rdi
callq 0x4c290
leaq -0x40(%rbp), %rdi
callq 0xcac0
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4c290
leaq -0x40(%rbp), %rdi
callq 0xcac0
movq -0x70(%rbp), %rdi
callq 0xc990
// File: dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::argsToVector[abi:cxx11](int, char const* const*)
inline std::vector<std::string> argsToVector( int argc, char const* const* const argv ) {
        std::vector<std::string> args( static_cast<std::size_t>( argc ) );
        for( std::size_t i = 0; i < static_cast<std::size_t>( argc ); ++i )
            args[i] = argv[i];

        return args;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x558b0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x558d0
jmp 0x51a1a
leaq -0x1a(%rbp), %rdi
callq 0x343e0
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jae 0x51a9d
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rsi
movq (%rax,%rsi,8), %rax
movq %rax, -0x60(%rbp)
callq 0x55940
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0xc770
jmp 0x51a5f
jmp 0x51a61
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x51a2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x343e0
jmp 0x51aba
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2ad70
jmp 0x51aba
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x51ab0
movq -0x50(%rbp), %rdi
callq 0x2ad70
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc990
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::Parser::parseIntoTokens(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&)
void parseIntoTokens( std::string const& arg, std::vector<Token>& tokens ) {
            for( std::size_t i = 0; i <= arg.size(); ++i ) {
                char c = arg[i];
                if( c == '"' )
                    inQuotes = !inQuotes;
                mode = handleMode( i, c, arg, tokens );
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc3e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
ja 0x5272d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc610
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x22, %eax
jne 0x526fc
movq -0x30(%rbp), %rax
movb 0x10(%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb -0x21(%rbp), %al
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movsbl %al, %edx
callq 0x52740
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x526b4
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::Parser::handleMode(unsigned long, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&)
Mode handleMode( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
            switch( mode ) {
                case None: return handleNone( i, c );
                case MaybeShortOpt: return handleMaybeShortOpt( i, c );
                case ShortOpt:
                case LongOpt:
                case SlashOpt: return handleOpt( i, c, arg, tokens );
                case Positional: return handlePositional( i, c, arg, tokens );
                default: throw std::logic_error( "Unknown mode" );
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl (%rax), %eax
movq %rax, -0x48(%rbp)
subq $0x5, %rax
ja 0x527fb
movq -0x48(%rbp), %rax
leaq 0x23ff8(%rip), %rcx     # 0x76778
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsbl -0x19(%rbp), %edx
callq 0x52860
movl %eax, -0x4(%rbp)
jmp 0x5284b
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsbl -0x19(%rbp), %edx
callq 0x528c0
movl %eax, -0x4(%rbp)
jmp 0x5284b
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x19(%rbp), %al
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movsbl %al, %edx
callq 0x52920
movl %eax, -0x4(%rbp)
jmp 0x5284b
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x19(%rbp), %al
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movsbl %al, %edx
callq 0x52c40
movl %eax, -0x4(%rbp)
jmp 0x5284b
movl $0x10, %edi
callq 0xc2c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x24c94(%rip), %rsi     # 0x774aa
callq 0xc790
jmp 0x5281d
movq -0x58(%rbp), %rdi
movq 0x557a8(%rip), %rsi     # 0xa7fd0
movq 0x55771(%rip), %rdx     # 0xa7fa0
callq 0xc940
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xc420
jmp 0x52854
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xc990
nopl (%rax)
// File: dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::Parser::handleNone(unsigned long, char)
Mode handleNone( std::size_t i, char c ) {
            if( inQuotes ) {
                from = i;
                return Positional;
            }
            switch( c ) {
                case '-': return MaybeShortOpt;
#ifdef CLARA_PLATFORM_WINDOWS
                case '/': from = i+1; return SlashOpt;
#endif
                default: from = i; return Positional;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x10(%rax)
je 0x52894
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x5, -0x4(%rbp)
jmp 0x528b9
movb -0x19(%rbp), %al
subb $0x2d, %al
jne 0x528a6
jmp 0x5289d
movl $0x1, -0x4(%rbp)
jmp 0x528b9
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::Parser::handlePositional(unsigned long, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&)
Mode handlePositional( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
            if( inQuotes || std::string( "\0", 3 ).find( c ) == std::string::npos )
                return mode;

            std::string data = arg.substr( from, i-from );
            tokens.push_back( Token( Token::Positional, data ) );
            return None;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movb 0x10(%rax), %cl
movb $0x0, -0x52(%rbp)
movb $0x0, -0x65(%rbp)
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xb1(%rbp)
jne 0x52cd7
leaq -0x51(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xc9a0
movq -0xc8(%rbp), %rcx
movb $0x1, -0x52(%rbp)
leaq 0x23acf(%rip), %rsi     # 0x76774
leaq -0x50(%rbp), %rdi
movl $0x3, %edx
callq 0xc630
jmp 0x52cb5
movb $0x1, -0x65(%rbp)
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x19(%rbp), %esi
callq 0xc730
cmpq $-0x1, %rax
sete %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
movb %al, -0xc9(%rbp)
testb $0x1, -0x65(%rbp)
jne 0x52ceb
jmp 0x52cf4
leaq -0x50(%rbp), %rdi
callq 0xcac0
testb $0x1, -0x52(%rbp)
jne 0x52cfc
jmp 0x52d05
leaq -0x51(%rbp), %rdi
callq 0xc5f0
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x52d11
jmp 0x52d44
movq -0xc0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x52df9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
testb $0x1, -0x52(%rbp)
jne 0x52d36
jmp 0x52d3f
leaq -0x51(%rbp), %rdi
callq 0xc5f0
jmp 0x52e05
movq -0xc0(%rbp), %rax
movq -0x28(%rbp), %rsi
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rcx
subq %rdx, %rcx
leaq -0x88(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xc5b0
movq -0xe0(%rbp), %rdx
movq -0x30(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
callq 0x52e40
jmp 0x52d8f
movq -0xd8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x52e10
jmp 0x52da4
leaq -0xb0(%rbp), %rdi
callq 0x50d10
movl $0x0, -0x4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xcac0
jmp 0x52df9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x52deb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x50d10
leaq -0x88(%rbp), %rdi
callq 0xcac0
jmp 0x52e05
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xc990
nop
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::insert(std::pair<int const, myvalue> const&)
std::pair<iterator, bool> insert(const value_type& item)
		{
			if (_size >= max_size())
			{
				return std::pair<iterator, bool>(end(), false);
			}
			
			new (&_keys[_size]) key_type(item.first);
			new (&_values[_size]) mapped_type(item.second);
			return std::pair<iterator, bool>(iterator(this, _size++), true);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl (%rdi), %eax
shrl $0x10, %eax
movl %eax, -0x48(%rbp)
callq 0x5abb0
movw %ax, %cx
movl -0x48(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jl 0x5afc5
movq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5acc0
movq -0x60(%rbp), %rdi
movb $0x0, -0x29(%rbp)
leaq -0x28(%rbp), %rsi
leaq -0x29(%rbp), %rdx
callq 0x5dd10
jmp 0x5b032
movq -0x50(%rbp), %rsi
movq 0x8(%rsi), %rax
movl (%rsi), %ecx
shrl $0x10, %ecx
movl %ecx, %ecx
movq -0x18(%rbp), %rdx
movl (%rdx), %edx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsi), %rax
movl (%rsi), %ecx
shrl $0x10, %ecx
movl %ecx, %ecx
movq -0x18(%rbp), %rdx
movl 0x4(%rdx), %edx
movl %edx, (%rax,%rcx,4)
movl (%rsi), %eax
shrl $0x10, %eax
movl %eax, %edx
addl $0x1, %edx
movl (%rsi), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
shll $0x10, %edx
andl $0xffff, %ecx           # imm = 0xFFFF
orl %edx, %ecx
movl %ecx, (%rsi)
leaq -0x40(%rbp), %rdi
movzwl %ax, %edx
callq 0x5c790
movq -0x60(%rbp), %rdi
movb $0x1, -0x41(%rbp)
leaq -0x40(%rbp), %rsi
leaq -0x41(%rbp), %rdx
callq 0x5dd10
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::at(int const&)
mapped_type& at(const key_type& key)
		{
			const_iterator it(_find(key));
			
			if (it == end())
			{
				throw std::out_of_range("item not found");
			}
			
			return _values[it._index];
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x5ddb0
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5acc0
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5d0a0
testb $0x1, %al
jne 0x5b275
jmp 0x5b2c5
movl $0x10, %edi
callq 0xc2c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x1d245(%rip), %rsi     # 0x784d5
callq 0xc0b0
jmp 0x5b297
movq -0x50(%rbp), %rdi
movq 0x4cd1e(%rip), %rsi     # 0xa7fc0
movq 0x4cd07(%rip), %rdx     # 0xa7fb0
callq 0xc940
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xc420
jmp 0x5b2de
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movzwl -0x18(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xc990
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::operator[](int const&)
mapped_type& operator[](const key_type& key)
		{
			iterator it = find(key);
			
			if (it == end())
			{
				if (_size >= _capacity)
				{
					throw std::overflow_error("nanomap is full");
				}
				
				size_type i = _size++;
				new (&_keys[i]) key_type(key);
				new (&_values[i]) mapped_type();
				return _values[i];
			}
			
			return _values[it._index];
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x5b0e0
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x5acc0
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5ca10
testb $0x1, %al
jne 0x5b338
jmp 0x5b407
movq -0x50(%rbp), %rcx
movl (%rcx), %eax
shrl $0x10, %eax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
cmpl %ecx, %eax
jl 0x5b3a0
movl $0x10, %edi
callq 0xc2c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x1d17c(%rip), %rsi     # 0x784e4
callq 0xc0d0
jmp 0x5b36f
movq -0x58(%rbp), %rdi
movq 0x4cbe6(%rip), %rsi     # 0xa7f60
movq 0x4cbcf(%rip), %rdx     # 0xa7f50
callq 0xc940
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xc420
jmp 0x5b428
movq -0x50(%rbp), %rax
movl (%rax), %ecx
shrl $0x10, %ecx
movl %ecx, %esi
addl $0x1, %esi
movl (%rax), %edx
andl $0xffff, %esi           # imm = 0xFFFF
shll $0x10, %esi
andl $0xffff, %edx           # imm = 0xFFFF
orl %esi, %edx
movl %edx, (%rax)
movw %cx, -0x46(%rbp)
movq 0x8(%rax), %rcx
movzwl -0x46(%rbp), %edx
movq -0x18(%rbp), %rsi
movl (%rsi), %esi
movl %esi, (%rcx,%rdx,4)
movq 0x10(%rax), %rdi
movzwl -0x46(%rbp), %eax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x5bb10
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movzwl -0x46(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x5b41e
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movzwl -0x20(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xc990
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::operator[](int&&)
mapped_type& operator[](key_type&& key)
		{
			iterator it = find(key);
			
			if (it == end())
			{
				if (_size >= _capacity)
				{
					throw std::overflow_error("nanomap is full");
				}
				
				size_type i = _size++;
				new (&_keys[i]) key_type(std::move(key));
				new (&_values[i]) mapped_type();
				return _values[i];
			}
			
			return _values[it._index];
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x5b0e0
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x5acc0
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5ca10
testb $0x1, %al
jne 0x5b4d8
jmp 0x5b5a7
movq -0x50(%rbp), %rcx
movl (%rcx), %eax
shrl $0x10, %eax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
cmpl %ecx, %eax
jl 0x5b540
movl $0x10, %edi
callq 0xc2c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x1cfdc(%rip), %rsi     # 0x784e4
callq 0xc0d0
jmp 0x5b50f
movq -0x58(%rbp), %rdi
movq 0x4ca46(%rip), %rsi     # 0xa7f60
movq 0x4ca2f(%rip), %rdx     # 0xa7f50
callq 0xc940
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0xc420
jmp 0x5b5c8
movq -0x50(%rbp), %rax
movl (%rax), %ecx
shrl $0x10, %ecx
movl %ecx, %esi
addl $0x1, %esi
movl (%rax), %edx
andl $0xffff, %esi           # imm = 0xFFFF
shll $0x10, %esi
andl $0xffff, %edx           # imm = 0xFFFF
orl %esi, %edx
movl %edx, (%rax)
movw %cx, -0x46(%rbp)
movq 0x8(%rax), %rcx
movzwl -0x46(%rbp), %edx
movq -0x18(%rbp), %rsi
movl (%rsi), %esi
movl %esi, (%rcx,%rdx,4)
movq 0x10(%rax), %rdi
movzwl -0x46(%rbp), %eax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
callq 0x5bb10
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movzwl -0x46(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x5b5be
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movzwl -0x20(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xc990
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: std::pair<gdc::nanomap_iterator<false, int, myvalue, std::equal_to<int>>, bool> gdc::nanomap<int, myvalue, std::equal_to<int>>::emplace<int>(int const&, int&&)
std::pair<iterator, bool> emplace(const key_type& key, Args&& ... value_args)
		{
			if (_size >= max_size())
			{
				return std::pair<iterator, bool>(end(), false);
			}
			
			new (&_keys[_size]) key_type(key);
			new (&_values[_size]) mapped_type(value_args ...);
			return std::pair<iterator, bool>(iterator(this, _size++), true);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl (%rdi), %eax
shrl $0x10, %eax
movl %eax, -0x50(%rbp)
callq 0x5abb0
movw %ax, %cx
movl -0x50(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jl 0x5b699
movq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5acc0
movq -0x68(%rbp), %rdi
movb $0x0, -0x31(%rbp)
leaq -0x30(%rbp), %rsi
leaq -0x31(%rbp), %rdx
callq 0x5dd10
jmp 0x5b712
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rcx
movl (%rax), %edx
shrl $0x10, %edx
movl %edx, %edx
movq -0x18(%rbp), %rsi
movl (%rsi), %esi
movl %esi, (%rcx,%rdx,4)
movq 0x10(%rax), %rdi
movl (%rax), %eax
shrl $0x10, %eax
movl %eax, %eax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0x5bb10
movq -0x58(%rbp), %rsi
movl (%rsi), %eax
shrl $0x10, %eax
movl %eax, %edx
addl $0x1, %edx
movl (%rsi), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
shll $0x10, %edx
andl $0xffff, %ecx           # imm = 0xFFFF
orl %edx, %ecx
movl %ecx, (%rsi)
leaq -0x48(%rbp), %rdi
movzwl %ax, %edx
callq 0x5c790
movq -0x68(%rbp), %rdi
movb $0x1, -0x49(%rbp)
leaq -0x48(%rbp), %rsi
leaq -0x49(%rbp), %rdx
callq 0x5dd10
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::clear()
void clear()
		{
			for (size_type i = 0; i < _size; ++i)
			{
				_keys[i].~key_type();
			}
			
			for (size_type i = 0; i < _size; ++i)
			{
				_values[i].~mapped_type();
			}
			
			_size = 0;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw $0x0, -0xa(%rbp)
movq -0x18(%rbp), %rcx
movzwl -0xa(%rbp), %eax
movl (%rcx), %ecx
shrl $0x10, %ecx
cmpl %ecx, %eax
jge 0x5b819
movw -0xa(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x5b7fa
movw $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movzwl -0xc(%rbp), %eax
movl (%rcx), %ecx
shrl $0x10, %ecx
cmpl %ecx, %eax
jge 0x5b856
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movzwl -0xc(%rbp), %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x5bb30
movw -0xc(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x5b81f
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
orl $0x0, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::erase(gdc::nanomap_iterator<true, int, myvalue, std::equal_to<int>>)
iterator erase(const_iterator it)
		{
			if (it._index == max_size())
			{
				std::abort();
			}
			
			_keys[it._index].~key_type();
			_values[it._index].~mapped_type();

			if (it._index < --_size)
			{
				new (&_keys[it._index]) key_type(std::move(_keys[_size]));
				new (&_values[it._index]) mapped_type(std::move(_values[_size]));
				_keys[_size].~key_type();
				_values[_size].~mapped_type();
			}
			else
			{
				it._index = end()._index;
			}

			return iterator(it._map, it._index);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movzwl 0x8(%rdx), %eax
movl %eax, -0x2c(%rbp)
callq 0x5abb0
movw %ax, %cx
movl -0x2c(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jne 0x5b8b9
callq 0xc300
movq -0x38(%rbp), %rcx
movq -0x50(%rbp), %rax
movq 0x10(%rcx), %rdi
movzwl 0x8(%rax), %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x5bb30
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rdx
movzwl 0x8(%rax), %eax
movl (%rdx), %ecx
shrl $0x10, %ecx
addl $-0x1, %ecx
movl (%rdx), %esi
andl $0xffff, %ecx           # imm = 0xFFFF
movl %ecx, %edi
shll $0x10, %edi
andl $0xffff, %esi           # imm = 0xFFFF
orl %edi, %esi
movl %esi, (%rdx)
cmpl %ecx, %eax
jge 0x5b95b
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rdx
movq 0x8(%rax), %rcx
movzwl 0x8(%rdx), %esi
movq 0x8(%rax), %rdi
movl (%rax), %r8d
shrl $0x10, %r8d
movl %r8d, %r8d
movl (%rdi,%r8,4), %edi
movl %edi, (%rcx,%rsi,4)
movq 0x10(%rax), %rcx
movzwl 0x8(%rdx), %edx
movq 0x10(%rax), %rsi
movl (%rax), %edi
shrl $0x10, %edi
movl %edi, %edi
movl (%rsi,%rdi,4), %esi
movl %esi, (%rcx,%rdx,4)
movq 0x10(%rax), %rdi
movl (%rax), %eax
shrl $0x10, %eax
movl %eax, %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x5bb30
jmp 0x5b974
movq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5acc0
movq -0x50(%rbp), %rax
movw -0x20(%rbp), %cx
movw %cx, 0x8(%rax)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq (%rax), %rsi
movzwl 0x8(%rax), %edx
callq 0x5c790
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::init(int*, myvalue*, unsigned short, unsigned short)
void init(key_type* keys, mapped_type* values, size_type capacity, size_type size = 0)
		{
			_capacity = capacity;
			_size = size;
			_keys = keys;
			_values = values;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw %cx, -0x1a(%rbp)
movw %ax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movzwl -0x1a(%rbp), %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %edx, %ecx
movl %ecx, (%rax)
movzwl -0x1c(%rbp), %edx
movl (%rax), %ecx
andl $0xffff, %edx           # imm = 0xFFFF
shll $0x10, %edx
andl $0xffff, %ecx           # imm = 0xFFFF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap_iterator<false, int, myvalue, std::equal_to<int>>::operator=(gdc::nanomap_iterator<false, int, myvalue, std::equal_to<int>>&&)
nanomap_iterator& operator=(nanomap_iterator&& it)
		{
			_map = it._map;
			_index = it._index;
			
			if (it._map != nullptr)
			{
				it._index = it._map->max_size();
				it._map = nullptr;
			}
			
			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movw 0x8(%rcx), %cx
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5bdda
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5abb0
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>::nanomap_factory(gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>> const&)
nanomap_factory(const nanomap_factory& f) : _map(_keys, _values, _capacity, f._map.size())
		{
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_keys[i]) key_type(f._keys[i]);
			}
			
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_values[i]) mapped_type(f._values[i]);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x50(%rbp)
addq $0x98, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5ab60
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rdi
movl $0x20, %ecx
movzwl %ax, %r8d
callq 0x5c160
movq -0x40(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x38(%rbp)
movq %rax, %rcx
addq $0x80, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
xorl %esi, %esi
callq 0x5bb10
jmp 0x5bf11
movq -0x30(%rbp), %rcx
movq -0x58(%rbp), %rax
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, -0x28(%rbp)
jne 0x5bf00
movw $0x0, -0x1e(%rbp)
movzwl -0x1e(%rbp), %eax
cmpl $0x20, %eax
jge 0x5bfa3
movq -0x40(%rbp), %rax
movzwl -0x1e(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzwl -0x1e(%rbp), %esi
movl 0x18(%rdx,%rsi,4), %edx
movl %edx, 0x18(%rax,%rcx,4)
movw -0x1e(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1e(%rbp)
jmp 0x5bf2c
movq -0x38(%rbp), %rcx
movq %rax, %rsi
movq -0x58(%rbp), %rax
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0x60(%rbp)
je 0x5bf98
movq -0x60(%rbp), %rdi
addq $-0x4, %rdi
movq %rdi, -0x68(%rbp)
callq 0x5bb30
movq -0x38(%rbp), %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x60(%rbp)
jne 0x5bf76
movq -0x40(%rbp), %rdi
callq 0x5bbc0
jmp 0x5bfe4
movw $0x0, -0x20(%rbp)
movzwl -0x20(%rbp), %eax
cmpl $0x20, %eax
jge 0x5bfde
movq -0x40(%rbp), %rax
movzwl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzwl -0x20(%rbp), %esi
movl 0x98(%rdx,%rsi,4), %edx
movl %edx, 0x98(%rax,%rcx,4)
movw -0x20(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x20(%rbp)
jmp 0x5bfa9
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xc990
nopl (%rax)
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>::nanomap_factory(gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>&&)
nanomap_factory(nanomap_factory&& f) : _map(_keys, _values, _capacity, f._map.size())
		{
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_keys[i]) key_type(std::move(f._keys[i]));
			}
			
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_values[i]) mapped_type(std::move(f._values[i]));
			}
			
			f._map.clear();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x50(%rbp)
addq $0x98, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5ab60
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rdi
movl $0x20, %ecx
movzwl %ax, %r8d
callq 0x5c160
movq -0x40(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x38(%rbp)
movq %rax, %rcx
addq $0x80, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
xorl %esi, %esi
callq 0x5bb10
jmp 0x5c071
movq -0x30(%rbp), %rcx
movq -0x58(%rbp), %rax
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, -0x28(%rbp)
jne 0x5c060
movw $0x0, -0x1e(%rbp)
movzwl -0x1e(%rbp), %eax
cmpl $0x20, %eax
jge 0x5c103
movq -0x40(%rbp), %rax
movzwl -0x1e(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzwl -0x1e(%rbp), %esi
movl 0x18(%rdx,%rsi,4), %edx
movl %edx, 0x18(%rax,%rcx,4)
movw -0x1e(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1e(%rbp)
jmp 0x5c08c
movq -0x38(%rbp), %rcx
movq %rax, %rsi
movq -0x58(%rbp), %rax
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0x60(%rbp)
je 0x5c0f8
movq -0x60(%rbp), %rdi
addq $-0x4, %rdi
movq %rdi, -0x68(%rbp)
callq 0x5bb30
movq -0x38(%rbp), %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x60(%rbp)
jne 0x5c0d6
movq -0x40(%rbp), %rdi
callq 0x5bbc0
jmp 0x5c14d
movw $0x0, -0x20(%rbp)
movzwl -0x20(%rbp), %eax
cmpl $0x20, %eax
jge 0x5c13e
movq -0x40(%rbp), %rax
movzwl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzwl -0x20(%rbp), %esi
movl 0x98(%rdx,%rsi,4), %edx
movl %edx, 0x98(%rax,%rcx,4)
movw -0x20(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x20(%rbp)
jmp 0x5c109
movq -0x10(%rbp), %rdi
callq 0x5b7e0
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xc990
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::_find(int const&) const
const_iterator _find(const key_type& key) const
		{
			key_equal eq;
			
			for (size_type i = 0; i < size(); ++i)
			{
				if (eq(_keys[i], key))
				{
					return const_iterator(this, i);
				}
			}
			
			return cend();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movw $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movzwl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x5ab60
movw %ax, %cx
movl -0x3c(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jge 0x5de43
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movzwl -0x1c(%rbp), %eax
shlq $0x2, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x19(%rbp), %rdi
callq 0x5de60
testb $0x1, %al
jne 0x5de20
jmp 0x5de33
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
movzwl -0x1c(%rbp), %edx
callq 0x5ce30
jmp 0x5de50
jmp 0x5de35
movw -0x1c(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1c(%rbp)
jmp 0x5dddd
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x5ada0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: devinsmith[P]qvdreader/LineageInfo.cpp
// Function: QvdLineageInfo::ParseXml(_xmlNode const*)
void QvdLineageInfo::ParseXml(const xmlNode *node)
{
  for (const xmlNode *child = node->children; child; child = child->next) {
    if (child->type == XML_ELEMENT_NODE) {
      xmlChar *nodeContent = xmlNodeGetContent(child);
      if (nodeContent == NULL)
        continue;

      if (strlen((char *)nodeContent) == 0) {
        xmlFree(nodeContent);
        continue;
      }

      if (strcmp((char *)child->name, "Discriminator") == 0) {
        Discriminator = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "Statement") == 0) {
        Statement = (char *)nodeContent;
      } else {
        printf("Unprocessed LineageInfo tag: %s\n", child->name);
      }
      xmlFree(nodeContent);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb756
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xb743
movq -0x18(%rbp), %rdi
callq 0xabb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb6a6
jmp 0xb745
movq -0x20(%rbp), %rdi
callq 0xa4c0
cmpq $0x0, %rax
jne 0xb6c7
movq 0xc924(%rip), %rax      # 0x17fe0
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0xb745
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x792a(%rip), %rsi      # 0x13000
callq 0xaf40
cmpl $0x0, %eax
jne 0xb6ef
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xae60
jmp 0xb733
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x7910(%rip), %rsi      # 0x1300e
callq 0xaf40
cmpl $0x0, %eax
jne 0xb71b
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x20, %rdi
callq 0xae60
jmp 0xb731
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x78ee(%rip), %rdi      # 0x13018
movb $0x0, %al
callq 0xa070
jmp 0xb733
movq 0xc8a6(%rip), %rax      # 0x17fe0
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0xb745
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xb674
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: devinsmith[P]qvdreader/main.cpp
// Function: main
int
main(int argc, char *argv[])
{
  if (argc < 2) {
    fprintf(stderr, "usage: %s qvdfile.qvd\n", argv[0]);
    exit(1);
  }

  QvdFile qvd;

  if (!qvd.Load(argv[1])) {
    fprintf(stderr, "The file '%s' could not be loaded.\n", argv[1]);
    exit(1);
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2180, %rsp           # imm = 0x2180
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0xb7a8
movq 0xc852(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x78a2(%rip), %rsi      # 0x13039
movb $0x0, %al
callq 0xaf80
movl $0x1, %edi
callq 0xad00
leaq -0x2160(%rbp), %rdi
movq %rdi, -0x2178(%rbp)
callq 0xb1e0
movq -0x2178(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xa640
movb %al, -0x216d(%rbp)
jmp 0xb7d7
movb -0x216d(%rbp), %al
testb $0x1, %al
jne 0xb82d
jmp 0xb7e3
movq 0xc7ee(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x7854(%rip), %rsi      # 0x13050
movb $0x0, %al
callq 0xaf80
movl $0x1, %edi
callq 0xad00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2168(%rbp)
movl %eax, -0x216c(%rbp)
leaq -0x2160(%rbp), %rdi
callq 0xa750
jmp 0xb84c
movl $0x0, -0x4(%rbp)
leaq -0x2160(%rbp), %rdi
callq 0xa750
movl -0x4(%rbp), %eax
addq $0x2180, %rsp           # imm = 0x2180
popq %rbp
retq
movq -0x2168(%rbp), %rdi
callq 0xb340
nopl (%rax,%rax)
// File: devinsmith[P]qvdreader/QvdField.cpp
// Function: QvdField::ParseNumberFormat(_xmlNode const*)
void QvdField::ParseNumberFormat(const xmlNode *node)
{
  for (const xmlNode *child = node->children; child; child = child->next) {
    if (child->type == XML_ELEMENT_NODE) {
      xmlChar *nodeContent = xmlNodeGetContent(child);
      if (nodeContent == NULL)
        continue;

      if (strlen((char *)nodeContent) == 0) {
        xmlFree(nodeContent);
        continue;
      }

      if (strcmp((char *)child->name, "Type") == 0) {
        Type = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "Dec") == 0) {
        Dec = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "Thou") == 0) {
        Thou = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "nDec") == 0) {
        nDec = atoi((char *)nodeContent);
      } else if (strcmp((char *)child->name, "UseThou") == 0) {
        UseThou = atoi((char *)nodeContent);
      } else {
        printf("Unprocessed NumberFormat tag: %s\n", child->name);
      }
      xmlFree(nodeContent);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc87f
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xc86c
movq -0x18(%rbp), %rdi
callq 0xabb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc736
jmp 0xc86e
movq -0x20(%rbp), %rdi
callq 0xa4c0
cmpq $0x0, %rax
jne 0xc75a
movq 0xb894(%rip), %rax      # 0x17fe0
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0xc86e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x690b(%rip), %rsi      # 0x13074
callq 0xaf40
cmpl $0x0, %eax
jne 0xc789
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x30, %rdi
callq 0xae60
jmp 0xc85c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x68e2(%rip), %rsi      # 0x1307a
callq 0xaf40
cmpl $0x0, %eax
jne 0xc7b8
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x58, %rdi
callq 0xae60
jmp 0xc85a
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x68ba(%rip), %rsi      # 0x13081
callq 0xaf40
cmpl $0x0, %eax
jne 0xc7e4
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x78, %rdi
callq 0xae60
jmp 0xc858
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x6886(%rip), %rsi      # 0x13079
callq 0xaf40
cmpl $0x0, %eax
jne 0xc811
movq -0x20(%rbp), %rdi
callq 0xb0b0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x50(%rax)
jmp 0xc856
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x685e(%rip), %rsi      # 0x1307e
callq 0xaf40
cmpl $0x0, %eax
jne 0xc83e
movq -0x20(%rbp), %rdi
callq 0xb0b0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x54(%rax)
jmp 0xc854
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x6839(%rip), %rdi      # 0x13086
movb $0x0, %al
callq 0xa070
jmp 0xc856
jmp 0xc858
jmp 0xc85a
jmp 0xc85c
movq 0xb77d(%rip), %rax      # 0x17fe0
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0xc86e
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc704
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::Load(char const*)
bool QvdFile::Load(const char *filename)
{
  _fp = fopen(filename, "rb");
  if (_fp == NULL) {
    return false;
  }

  if (!parseXmlHeader(filename)) {
    return false;
  }

  if (_eof && _bufLen == 0) {
    // XML header parsed but missing symbol table and data.
    return false;
  }

  // The start of the dataPtr might have the ending \r and \n from
  // the XML portion, if so skip past that.
  char c;
  while (_bufLen > 0) {
    c = peekByte();
    if (c == '\r' || c == '\n' || c == '\0') {
      advanceBytes(1);
      continue;
    }
    break;
  }

  if (_eof && _bufLen == 0) {
    // XML header parsed but missing symbol table and data.
    return false;
  }

  DEBUG(fprintf(stdout, "%zu bytes left\n", _bufLen););

  parseSymbolAndData();

  // First 2 bytes seem to store a type:
  // 00 01 - INT
  // 00 04 - Text
  // 00 05 - Dual INT


  //dump_hex(0, _dataPtrStart, _bufLen);

  // Read rest of file.
  while (!_eof) {
    size_t len = readBytes();

    DEBUG(printf("Read %zu bytes.\n", len););
  }

  fclose(_fp);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x6015(%rip), %rsi      # 0x13138
callq 0xacd0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x128(%rax)
cmpq $0x0, 0x128(%rax)
jne 0xd149
movb $0x0, -0x1(%rbp)
jmp 0xd22f
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa320
testb $0x1, %al
jne 0xd163
movb $0x0, -0x1(%rbp)
jmp 0xd22f
movq -0x30(%rbp), %rax
testb $0x1, 0x2140(%rax)
je 0xd187
movq -0x30(%rbp), %rax
cmpq $0x0, 0x2138(%rax)
jne 0xd187
movb $0x0, -0x1(%rbp)
jmp 0xd22f
jmp 0xd189
movq -0x30(%rbp), %rax
cmpq $0x0, 0x2138(%rax)
jbe 0xd1d0
movq -0x30(%rbp), %rdi
callq 0xaa60
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0xd, %eax
je 0xd1be
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
je 0xd1be
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0xd1ce
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0xb530
jmp 0xd189
jmp 0xd1d0
movq -0x30(%rbp), %rax
testb $0x1, 0x2140(%rax)
je 0xd1f1
movq -0x30(%rbp), %rax
cmpq $0x0, 0x2138(%rax)
jne 0xd1f1
movb $0x0, -0x1(%rbp)
jmp 0xd22f
movq -0x30(%rbp), %rdi
callq 0xaff0
movq -0x30(%rbp), %rax
movb 0x2140(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xd20c
jmp 0xd21b
movq -0x30(%rbp), %rdi
callq 0xb500
movq %rax, -0x28(%rbp)
jmp 0xd1fa
movq -0x30(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0xab00
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::peekByte()
char QvdFile::peekByte()
{
  char c;

  if (_bufLen == 0) {
    if (!_eof) {
      readBytes();
    } else {
      return 0; // throw an error.
    }
  }

  c = *_dataPtrStart;

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x2138(%rax)
jne 0xd45e
movq -0x20(%rbp), %rax
testb $0x1, 0x2140(%rax)
jne 0xd456
movq -0x20(%rbp), %rdi
callq 0xb500
jmp 0xd45c
movb $0x0, -0x1(%rbp)
jmp 0xd474
jmp 0xd45e
movq -0x20(%rbp), %rax
movq 0x2130(%rax), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::advanceBytes(unsigned long)
void QvdFile::advanceBytes(size_t nBytes)
{
  if (_bufLen < nBytes) {
    if (!_eof) {
      readBytes();
    } else {
      return; // throw an error.
    }
  }

  if (_bufLen < nBytes) {
    return; // throw an error.
  }

  _bufLen -= nBytes;
  _dataPtrStart += nBytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x2138(%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0xd4c1
movq -0x18(%rbp), %rax
testb $0x1, 0x2140(%rax)
jne 0xd4bd
movq -0x18(%rbp), %rdi
callq 0xb500
jmp 0xd4bf
jmp 0xd4ff
jmp 0xd4c1
movq -0x18(%rbp), %rax
movq 0x2138(%rax), %rax
cmpq -0x10(%rbp), %rax
jae 0xd4d4
jmp 0xd4ff
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x2138(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x2138(%rax)
movq -0x10(%rbp), %rcx
addq 0x2130(%rax), %rcx
movq %rcx, 0x2130(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::readBytes()
size_t QvdFile::readBytes()
{
  size_t len = fread(_buf, 1, sizeof(_buf), _fp);
  if (len < sizeof(_buf)) {
    _eof = true;
  }
  _dataPtrStart = _buf;
  _bufLen = len;
  return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, %rdi
addq $0x130, %rdi            # imm = 0x130
movq 0x128(%rax), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0xb000
movq %rax, -0x10(%rbp)
cmpq $0x2000, -0x10(%rbp)    # imm = 0x2000
jae 0xd9bd
movq -0x18(%rbp), %rax
movb $0x1, 0x2140(%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x130, %rcx            # imm = 0x130
movq %rcx, 0x2130(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x2138(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::readByte()
char QvdFile::readByte()
{
  char c;

  if (_bufLen == 0) {
    if (!_eof) {
      readBytes();
    } else {
      return 0; // throw an error.
    }
  }

  _bufLen--;
  c = *_dataPtrStart++;

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x2138(%rax)
jne 0xda2e
movq -0x20(%rbp), %rax
testb $0x1, 0x2140(%rax)
jne 0xda26
movq -0x20(%rbp), %rdi
callq 0xb500
jmp 0xda2c
movb $0x0, -0x1(%rbp)
jmp 0xda64
jmp 0xda2e
movq -0x20(%rbp), %rcx
movq 0x2138(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x2138(%rcx)
movq 0x2130(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x2130(%rcx)
movb (%rax), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)