LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: read_line_quote(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, FileSource&, char)
static void read_line_quote(string &line,FileSource &src,const char c) {
    int c2;

    line += c;
    do {
        c2 = src.getc();
        if (c == EOF)
            break;
        else if (c == '\n')
            break;
        else if (c == '\\')
            read_line_esc(line,src);
        else {
            line += c2;
            if (c2 == c)
                break;
        }
    } while(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movq -0x8(%rbp), %rdi
movsbl %al, %esi
callq 0x3190
movq -0x10(%rbp), %rdi
callq 0x43b0
movl %eax, -0x18(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $-0x1, %eax
jne 0x4c6b
jmp 0x4cba
movsbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0x4c76
jmp 0x4cba
movsbl -0x11(%rbp), %eax
cmpl $0x5c, %eax
jne 0x4c8e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4bd0
jmp 0x4cac
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rdi
movsbl %al, %esi
callq 0x3190
movl -0x18(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x4caa
jmp 0x4cba
jmp 0x4cac
jmp 0x4cae
jmp 0x4cb0
jmp 0x4cb2
movb $0x1, %al
testb $0x1, %al
jne 0x4c54
jmp 0x4cba
addq $0x20, %rsp
popq %rbp
retq
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: read_line_skip_cpp_comment(FileSource&)
static bool read_line_skip_cpp_comment(FileSource &src) {
    string tmp;
    int c;

    do {
        c = src.getc();
        if (c == EOF)
            break;
        else if (c == '\n')
            return false;
        else if (c == '\\') {
            c = src.getc();
            if (c == '\n') break;
        }
    } while(1);

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x33d0
movq -0x10(%rbp), %rdi
callq 0x43b0
movl %eax, -0x4c(%rbp)
jmp 0x4ce3
movl -0x4c(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x4d08
jmp 0x4d4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3598
jmp 0x4d6c
cmpl $0xa, -0x34(%rbp)
jne 0x4d1b
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x4d58
cmpl $0x5c, -0x34(%rbp)
jne 0x4d3f
movq -0x10(%rbp), %rdi
callq 0x43b0
movl %eax, -0x50(%rbp)
jmp 0x4d2f
movl -0x50(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jne 0x4d3d
jmp 0x4d4d
jmp 0x4d3f
jmp 0x4d41
jmp 0x4d43
jmp 0x4d45
movb $0x1, %al
testb $0x1, %al
jne 0x4cd5
jmp 0x4d4d
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3598
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: read_line_skip_c_comment(FileSource&)
static void read_line_skip_c_comment(FileSource &src) {
    string tmp;
    int c;

    do {
        c = src.getc();
        if (c == EOF)
            break;
        else if (c == '*') { /* C comment closing */
            c = src.getc();
            if (c == '/') break;
        }
        else if (c == '/') {
            c = src.getc();
            if (c == '*') /* another C comment opening. we allow nesting */
                read_line_skip_c_comment(src);
        }
    } while(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x33d0
movq -0x8(%rbp), %rdi
callq 0x43b0
movl %eax, -0x40(%rbp)
jmp 0x4da3
movl -0x40(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x4dc8
jmp 0x4e2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3598
jmp 0x4e3c
cmpl $0x2a, -0x2c(%rbp)
jne 0x4dec
movq -0x8(%rbp), %rdi
callq 0x43b0
movl %eax, -0x44(%rbp)
jmp 0x4ddc
movl -0x44(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x2f, -0x2c(%rbp)
jne 0x4dea
jmp 0x4e2d
jmp 0x4e1d
cmpl $0x2f, -0x2c(%rbp)
jne 0x4e1b
movq -0x8(%rbp), %rdi
callq 0x43b0
movl %eax, -0x48(%rbp)
jmp 0x4e00
movl -0x48(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x2a, -0x2c(%rbp)
jne 0x4e19
movq -0x8(%rbp), %rdi
callq 0x4d80
jmp 0x4e17
jmp 0x4e19
jmp 0x4e1b
jmp 0x4e1d
jmp 0x4e1f
jmp 0x4e21
movb $0x1, %al
testb $0x1, %al
jne 0x4d95
jmp 0x4e2d
leaq -0x28(%rbp), %rdi
callq 0x3598
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: is_pp_keyword(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
enum token::token_t is_pp_keyword(const string &s) {
    if (s == "if")
        return token::IF;
    if (s == "else")
        return token::ELSE;
    if (s == "elif")
        return token::ELIF;
    if (s == "endif")
        return token::ENDIF;
    if (s == "defined")
        return token::DEFINED;
    if (s == "ifdef")
        return token::IFDEF;
    if (s == "ifndef")
        return token::IFNDEF;
    if (s == "define")
        return token::DEFINE;
    if (s == "undef")
        return token::UNDEF;
    if (s == "include")
        return token::INCLUDE;
    if (s == "line")
        return token::LINE;
    if (s == "error")
        return token::ERROR;
    if (s == "pragma")
        return token::PRAGMA;

    return token::NONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x20a2e(%rip), %rsi     # 0x25915
callq 0x15ab0
testb $0x1, %al
jne 0x4ef2
jmp 0x4efe
movl $0x60, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x1fb8d(%rip), %rsi     # 0x24a96
callq 0x15ab0
testb $0x1, %al
jne 0x4f14
jmp 0x4f20
movl $0x5a, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x1fb70(%rip), %rsi     # 0x24a9b
callq 0x15ab0
testb $0x1, %al
jne 0x4f36
jmp 0x4f42
movl $0x61, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x209c5(%rip), %rsi     # 0x25912
callq 0x15ab0
testb $0x1, %al
jne 0x4f58
jmp 0x4f64
movl $0x62, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x1fb31(%rip), %rsi     # 0x24aa0
callq 0x15ab0
testb $0x1, %al
jne 0x4f7a
jmp 0x4f86
movl $0x63, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x1fb17(%rip), %rsi     # 0x24aa8
callq 0x15ab0
testb $0x1, %al
jne 0x4f9c
jmp 0x4fa8
movl $0x64, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x1fafb(%rip), %rsi     # 0x24aae
callq 0x15ab0
testb $0x1, %al
jne 0x4fbe
jmp 0x4fca
movl $0x65, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x1fae0(%rip), %rsi     # 0x24ab5
callq 0x15ab0
testb $0x1, %al
jne 0x4fe0
jmp 0x4fec
movl $0x66, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x1fac5(%rip), %rsi     # 0x24abc
callq 0x15ab0
testb $0x1, %al
jne 0x5002
jmp 0x500e
movl $0x67, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x1faa9(%rip), %rsi     # 0x24ac2
callq 0x15ab0
testb $0x1, %al
jne 0x5024
jmp 0x502d
movl $0x68, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x1fe3c(%rip), %rsi     # 0x24e74
callq 0x15ab0
testb $0x1, %al
jne 0x5043
jmp 0x504c
movl $0x69, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x1fa73(%rip), %rsi     # 0x24aca
callq 0x15ab0
testb $0x1, %al
jne 0x5062
jmp 0x506b
movl $0x6a, -0x4(%rbp)
jmp 0x5091
movq -0x10(%rbp), %rdi
leaq 0x1fa5a(%rip), %rsi     # 0x24ad0
callq 0x15ab0
testb $0x1, %al
jne 0x5081
jmp 0x508a
movl $0x31, -0x4(%rbp)
jmp 0x5091
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: char2hex_assume(char)
unsigned char char2hex_assume(const char c) { /* assumes you checked first! */
    if (c >= 'A' && c <= 'F')
        return (c + 10 - 'A');
    if (c >= 'a' && c <= 'f')
        return (c + 10 - 'a');

    return (c - '0');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
cmpl $0x41, %eax
jl 0x591b
movsbl -0x2(%rbp), %eax
cmpl $0x46, %eax
jg 0x591b
movsbl -0x2(%rbp), %eax
addl $0xa, %eax
subl $0x41, %eax
movb %al, -0x1(%rbp)
jmp 0x5946
movsbl -0x2(%rbp), %eax
cmpl $0x61, %eax
jl 0x593c
movsbl -0x2(%rbp), %eax
cmpl $0x66, %eax
jg 0x593c
movsbl -0x2(%rbp), %eax
addl $0xa, %eax
subl $0x61, %eax
movb %al, -0x1(%rbp)
jmp 0x5946
movsbl -0x2(%rbp), %eax
subl $0x30, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_escape_oct(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned int, unsigned int)
unsigned long long parse_escape_oct(string::iterator &li,const string::iterator lie,const unsigned int min_digits,const unsigned int max_digits) {
    unsigned long long r = 0;
    unsigned int digits = 0;

    while (li != lie && digits < max_digits) {
        if (isoctdigit(*li)) {
            r = (r << 3ull) + char2oct_assume(*(li++));
            digits++;
        }
        else {
            break;
        }
    }

    if (digits < min_digits)
        throw invalid_argument("octal parse: not enough digits");

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x15a10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x3d(%rbp)
jne 0x5990
jmp 0x599c
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
setb %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x59a5
jmp 0x5a0a
movq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x5780
testb $0x1, %al
jne 0x59bc
jmp 0x5a03
movq -0x20(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x5870
movb %al, %cl
movq -0x48(%rbp), %rax
movzbl %cl, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5a05
jmp 0x5a0a
jmp 0x5975
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x5a62
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x1f1ec(%rip), %rsi     # 0x24c19
callq 0x3530
jmp 0x5a34
movq -0x50(%rbp), %rdi
movq 0x2d599(%rip), %rsi     # 0x32fd8
movq 0x2d57a(%rip), %rdx     # 0x32fc0
callq 0x34b0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x31f0
jmp 0x5a6c
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_escape_hex(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned int, unsigned int)
unsigned long long parse_escape_hex(string::iterator &li,const string::iterator lie,const unsigned int min_digits,const unsigned int max_digits) {
    unsigned long long r = 0;
    unsigned int digits = 0;

    while (li != lie && digits < max_digits) {
        if (ishexdigit(*li)) {
            r = (r << 4ull) + char2hex_assume(*(li++));
            digits++;
        }
        else {
            break;
        }
    }

    if (digits < min_digits)
        throw invalid_argument("hex parse: not enough digits");

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x15a10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x3d(%rbp)
jne 0x5ac0
jmp 0x5acc
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
setb %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x5ad5
jmp 0x5b3a
movq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x5890
testb $0x1, %al
jne 0x5aec
jmp 0x5b33
movq -0x20(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x58f0
movb %al, %cl
movq -0x48(%rbp), %rax
movzbl %cl, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5b35
jmp 0x5b3a
jmp 0x5aa5
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x5b92
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x1f0db(%rip), %rsi     # 0x24c38
callq 0x3530
jmp 0x5b64
movq -0x50(%rbp), %rdi
movq 0x2d469(%rip), %rsi     # 0x32fd8
movq 0x2d44a(%rip), %rdx     # 0x32fc0
callq 0x34b0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x31f0
jmp 0x5b9c
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_string_char(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
char parse_string_char(string::iterator &li,const string::iterator lie) {
    if (li == lie) throw invalid_argument("expected string char");

    if (*li == '\\') {
        unsigned long long c = parse_string_char_escape(li,lie);
        if (c > 0xFFu) fprintf(stderr,"WARNING: Char constant exceeds type range\n");

        return (char)(c & 0xFFul);
    }

    return *(li++);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x15b70
testb $0x1, %al
jne 0x5f03
jmp 0x5f56
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
leaq 0x1edc0(%rip), %rsi     # 0x24cde
callq 0x3530
jmp 0x5f25
movq -0x48(%rbp), %rdi
movq 0x2d0a8(%rip), %rsi     # 0x32fd8
movq 0x2d089(%rip), %rdx     # 0x32fc0
callq 0x34b0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31f0
jmp 0x5fd7
movq -0x18(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x5fb1
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x5bb0
movq %rax, -0x30(%rbp)
cmpq $0xff, -0x30(%rbp)
jbe 0x5fa2
movq 0x2d027(%rip), %rax     # 0x32fb8
movq (%rax), %rdi
leaq 0x1ed58(%rip), %rsi     # 0x24cf3
movb $0x0, %al
callq 0x33f0
movq -0x30(%rbp), %rax
andq $0xff, %rax
movb %al, -0x1(%rbp)
jmp 0x5fce
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x15a50
movb (%rax), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34e0
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_hex_number(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
unsigned long long parse_hex_number(string::iterator &li,const string::iterator lie) {
    unsigned long long r = 0;

    while (li != lie && ishexdigit(*li))
        r = (r << 4ull) + char2hex_assume(*(li++));

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x15a10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x6223
jmp 0x6237
movq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x5890
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6240
jmp 0x627e
movq -0x18(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x58f0
movb %al, %cl
movq -0x30(%rbp), %rax
movzbl %cl, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6208
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_oct_number(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
unsigned long long parse_oct_number(string::iterator &li,const string::iterator lie) {
    unsigned long long r = 0;

    while (li != lie && isoctdigit_throw(*li))
        r = (r << 3ull) + char2oct_assume(*(li++));

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x15a10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x62c3
jmp 0x62d7
movq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x57b0
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x62e0
jmp 0x631e
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x5870
movb %al, %cl
movq -0x30(%rbp), %rax
movzbl %cl, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x62a8
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_dec_number(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
unsigned long long parse_dec_number(string::iterator &li,const string::iterator lie) {
    unsigned long long r = 0;

    while (li != lie && isdigit(*li))
        r = (r * 10ull) + char2dec_assume(*(li++));

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x15a10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x6363
jmp 0x637d
movq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x3260
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6386
jmp 0x63c1
imulq $0xa, -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x5850
movb %al, %cl
movq -0x30(%rbp), %rax
movzbl %cl, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6348
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_float_hexponent(long long&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void parse_float_hexponent(signed long long &exponent,string::iterator &li,const string::iterator lie) {
    /* e.g. "p-3". caller has already eaten the 'p' */
    signed long long exp_adjust;

    if (strit_next_match_inc(li,lie,'-'))
        exp_adjust = -((signed long long)parse_dec_number(li,lie));
    else if (strit_next_match_inc(li,lie,'+'))
        exp_adjust =   (signed long long)parse_dec_number(li,lie);
    else
        exp_adjust =   (signed long long)parse_dec_number(li,lie);

    exponent += exp_adjust;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl $0x2d, %edx
callq 0x64a0
testb $0x1, %al
jne 0x6404
jmp 0x6427
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x6330
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x647d
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl $0x2b, %edx
callq 0x64a0
testb $0x1, %al
jne 0x6447
jmp 0x6462
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x6330
movq %rax, -0x20(%rbp)
jmp 0x647b
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
callq 0x6330
movq %rax, -0x20(%rbp)
jmp 0x647d
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: strit_next_match_inc(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char)
static inline bool strit_next_match_inc(string::iterator &ti,const string::iterator lie,const char c) {
    if (ti != lie && *ti == c) {
        ti++;
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x15a10
testb $0x1, %al
jne 0x64c8
jmp 0x64f1
movq -0x18(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x64f1
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x28(%rbp)
movb $0x1, -0x1(%rbp)
jmp 0x64f5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_float_exponent(long double&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void parse_float_exponent(long double &r,string::iterator &li,const string::iterator lie) {
    /* e.g. "e-3". caller has already eaten the 'e' */
    signed long long exp_adjust;

    if (strit_next_match_inc(li,lie,'-'))
        exp_adjust = -((signed long long)parse_dec_number(li,lie));
    else if (strit_next_match_inc(li,lie,'+'))
        exp_adjust =   (signed long long)parse_dec_number(li,lie);
    else
        exp_adjust =   (signed long long)parse_dec_number(li,lie);

    if (exp_adjust != 0) {
        long double m = 1;
        while (exp_adjust <= -9) {
            exp_adjust += 9;
            m /= 1000000000;
        }
        while (exp_adjust < 0) {
            exp_adjust++;
            m /= 10;
        }

        while (exp_adjust >= 9) {
            exp_adjust -= 9;
            m *= 1000000000;
        }
        while (exp_adjust > 0) {
            exp_adjust--;
            m *= 10;
        }

        r *= m;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl $0x2d, %edx
callq 0x64a0
testb $0x1, %al
jne 0x6534
jmp 0x6557
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x6330
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x65ad
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl $0x2b, %edx
callq 0x64a0
testb $0x1, %al
jne 0x6577
jmp 0x6592
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x6330
movq %rax, -0x20(%rbp)
jmp 0x65ab
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
callq 0x6330
movq %rax, -0x20(%rbp)
jmp 0x65ad
cmpq $0x0, -0x20(%rbp)
je 0x665a
fld1
fstpt -0x60(%rbp)
cmpq $-0x9, -0x20(%rbp)
jg 0x65e0
movq -0x20(%rbp), %rax
addq $0x9, %rax
movq %rax, -0x20(%rbp)
fldt -0x60(%rbp)
flds 0x1e43b(%rip)           # 0x24a14
fdivrp %st, %st(1)
fstpt -0x60(%rbp)
jmp 0x65bd
jmp 0x65e2
cmpq $0x0, -0x20(%rbp)
jge 0x6604
movq -0x20(%rbp), %rax
incq %rax
movq %rax, -0x20(%rbp)
fldt -0x60(%rbp)
flds 0x1e413(%rip)           # 0x24a10
fdivrp %st, %st(1)
fstpt -0x60(%rbp)
jmp 0x65e2
jmp 0x6606
cmpq $0x9, -0x20(%rbp)
jl 0x6629
movq -0x20(%rbp), %rax
addq $-0x9, %rax
movq %rax, -0x20(%rbp)
fldt -0x60(%rbp)
flds 0x1e3f2(%rip)           # 0x24a14
fmulp %st, %st(1)
fstpt -0x60(%rbp)
jmp 0x6606
jmp 0x662b
cmpq $0x0, -0x20(%rbp)
jle 0x664d
movq -0x20(%rbp), %rax
decq %rax
movq %rax, -0x20(%rbp)
fldt -0x60(%rbp)
flds 0x1e3ca(%rip)           # 0x24a10
fmulp %st, %st(1)
fstpt -0x60(%rbp)
jmp 0x662b
fldt -0x60(%rbp)
movq -0x10(%rbp), %rax
fldt (%rax)
fmulp %st, %st(1)
fstpt (%rax)
addq $0x60, %rsp
popq %rbp
retq
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_float_suffixes(token&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void parse_float_suffixes(token &r,string::iterator &li,const string::iterator lie) {
    if (strit_next_match_inc(li,lie,'f'))
        r.bsize = 32; /* float */
    else if (strit_next_match_inc(li,lie,'F'))
        r.bsize = 32; /* float */
    else if (strit_next_match_inc(li,lie,'d'))
        r.bsize = 64; /* double */
    else if (strit_next_match_inc(li,lie,'D'))
        r.bsize = 64; /* double */
    else if (strit_next_match_inc(li,lie,'l'))
        r.bsize = 80; /* long double */
    else if (strit_next_match_inc(li,lie,'L'))
        r.bsize = 80; /* long double */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x66, %edx
callq 0x64a0
testb $0x1, %al
jne 0x6694
jmp 0x66a1
movq -0x10(%rbp), %rax
movb $0x20, 0x4(%rax)
jmp 0x6781
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl $0x46, %edx
callq 0x64a0
testb $0x1, %al
jne 0x66c1
jmp 0x66ce
movq -0x10(%rbp), %rax
movb $0x20, 0x4(%rax)
jmp 0x677f
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movl $0x64, %edx
callq 0x64a0
testb $0x1, %al
jne 0x66ee
jmp 0x66fb
movq -0x10(%rbp), %rax
movb $0x40, 0x4(%rax)
jmp 0x677d
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl $0x44, %edx
callq 0x64a0
testb $0x1, %al
jne 0x671b
jmp 0x6725
movq -0x10(%rbp), %rax
movb $0x40, 0x4(%rax)
jmp 0x677b
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movl $0x6c, %edx
callq 0x64a0
testb $0x1, %al
jne 0x6745
jmp 0x674f
movq -0x10(%rbp), %rax
movb $0x50, 0x4(%rax)
jmp 0x6779
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movl $0x4c, %edx
callq 0x64a0
testb $0x1, %al
jne 0x676f
jmp 0x6777
movq -0x10(%rbp), %rax
movb $0x50, 0x4(%rax)
jmp 0x6779
jmp 0x677b
jmp 0x677d
jmp 0x677f
jmp 0x6781
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_int_suffixes(token&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void parse_int_suffixes(token &r,string::iterator &li,const string::iterator lie) {
    if (strit_next_match_inc(li,lie,'u'))
        r.i.sign = false;
    else if (strit_next_match_inc(li,lie,'U'))
        r.i.sign = false;

    if (strit_next_match_inc(li,lie,'i','6','4'))
        r.bsize = 64; /* long long */
    else if (strit_next_match_inc(li,lie,'I','6','4'))
        r.bsize = 64; /* long long */
    else if (strit_next_match_inc(li,lie,'l','l'))
        r.bsize = 64; /* long long */
    else if (strit_next_match_inc(li,lie,'L','L'))
        r.bsize = 64; /* long long */
    else if (strit_next_match_inc(li,lie,'l'))
        r.bsize = 32; /* long */
    else if (strit_next_match_inc(li,lie,'L'))
        r.bsize = 32; /* long */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x75, %edx
callq 0x64a0
testb $0x1, %al
jne 0x67c4
jmp 0x67ce
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
jmp 0x67f8
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl $0x55, %edx
callq 0x64a0
testb $0x1, %al
jne 0x67ee
jmp 0x67f6
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
jmp 0x67f8
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movl $0x69, %edx
movl $0x36, %ecx
movl $0x34, %r8d
callq 0x6930
testb $0x1, %al
jne 0x6823
jmp 0x6830
movq -0x10(%rbp), %rax
movb $0x40, 0x4(%rax)
jmp 0x691f
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl $0x49, %edx
movl $0x36, %ecx
movl $0x34, %r8d
callq 0x6930
testb $0x1, %al
jne 0x685b
jmp 0x6868
movq -0x10(%rbp), %rax
movb $0x40, 0x4(%rax)
jmp 0x691d
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movl $0x6c, %ecx
movl %ecx, %edx
callq 0x6a30
testb $0x1, %al
jne 0x688a
jmp 0x6897
movq -0x10(%rbp), %rax
movb $0x40, 0x4(%rax)
jmp 0x691b
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movl $0x4c, %ecx
movl %ecx, %edx
callq 0x6a30
testb $0x1, %al
jne 0x68b9
jmp 0x68c3
movq -0x10(%rbp), %rax
movb $0x40, 0x4(%rax)
jmp 0x6919
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
movl $0x6c, %edx
callq 0x64a0
testb $0x1, %al
jne 0x68e3
jmp 0x68ed
movq -0x10(%rbp), %rax
movb $0x20, 0x4(%rax)
jmp 0x6917
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
movl $0x4c, %edx
callq 0x64a0
testb $0x1, %al
jne 0x690d
jmp 0x6915
movq -0x10(%rbp), %rax
movb $0x20, 0x4(%rax)
jmp 0x6917
jmp 0x6919
jmp 0x691b
jmp 0x691d
jmp 0x691f
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: strit_next_match_inc(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, char, char)
static inline bool strit_next_match_inc(string::iterator &ti,const string::iterator lie,const char c,const char c2,const char c3) {
    auto tmp = ti;

    if (tmp != lie && *tmp == c) {
        tmp++;
        if (tmp != lie && *tmp == c2) {
            tmp++;
            if (tmp != lie && *tmp == c3) {
                tmp++;
                ti = tmp;
                return true;
            }
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movb %dl, -0x19(%rbp)
movb %cl, -0x1a(%rbp)
movb %al, -0x1b(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x15a10
testb $0x1, %al
jne 0x696d
jmp 0x6a15
leaq -0x28(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6a15
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x15a10
testb $0x1, %al
jne 0x69a7
jmp 0x6a13
leaq -0x28(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
movsbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6a13
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x15a10
testb $0x1, %al
jne 0x69dd
jmp 0x6a11
leaq -0x28(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
movsbl -0x1b(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6a11
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x6a19
jmp 0x6a13
jmp 0x6a15
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: strit_next_match_inc(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, char, char)
static inline bool strit_next_match_inc(string::iterator &ti,const string::iterator lie,const char c,const char c2) {
    auto tmp = ti;

    if (tmp != lie && *tmp == c) {
        tmp++;
        if (tmp != lie && *tmp == c2) {
            tmp++;
            ti = tmp;
            return true;
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movb %dl, %cl
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x15a10
testb $0x1, %al
jne 0x6a68
jmp 0x6ad4
leaq -0x28(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6ad4
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x15a10
testb $0x1, %al
jne 0x6a9e
jmp 0x6ad2
leaq -0x28(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
movsbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6ad2
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x6ad8
jmp 0x6ad4
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_number_looks_like_float(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
bool parse_number_looks_like_float(string::iterator /*does not modify caller copy*/li,const string::iterator lie) {
    if (strit_next_match_inc(li,lie,'0','x')) {
        while (li != lie && isxdigit(*li)) li++;
        if (li != lie) return (*li == '.' || *li == 'p' || *li == 'p');
    }
    else {
        while (li != lie && isdigit(*li)) li++;
        if (li != lie) return (*li == '.' || *li == 'e' || *li == 'E');
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdi
movl $0x30, %edx
movl $0x78, %ecx
callq 0x6a30
testb $0x1, %al
jne 0x7258
jmp 0x730f
jmp 0x725a
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x15a10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x7275
jmp 0x728f
leaq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x3090
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x7298
jmp 0x72a9
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x28(%rbp)
jmp 0x725a
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x15a10
testb $0x1, %al
jne 0x72bc
jmp 0x730a
leaq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2e, %ecx
movb %al, -0x32(%rbp)
je 0x72fd
leaq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x70, %ecx
movb %al, -0x32(%rbp)
je 0x72fd
leaq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
cmpl $0x70, %eax
sete %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x73c4
jmp 0x73c0
jmp 0x7311
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x15a10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x33(%rbp)
jne 0x732c
jmp 0x7346
leaq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x3260
cmpl $0x0, %eax
setne %al
movb %al, -0x33(%rbp)
movb -0x33(%rbp), %al
testb $0x1, %al
jne 0x734f
jmp 0x7360
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x30(%rbp)
jmp 0x7311
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x15a10
testb $0x1, %al
jne 0x7373
jmp 0x73be
leaq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2e, %ecx
movb %al, -0x34(%rbp)
je 0x73b4
leaq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x65, %ecx
movb %al, -0x34(%rbp)
je 0x73b4
leaq -0x10(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
cmpl $0x45, %eax
sete %al
movb %al, -0x34(%rbp)
movb -0x34(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x73c4
jmp 0x73c0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: parse_identifier(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
string parse_identifier(string::iterator &li,const string::iterator lie) {
    string r;

    if (li == lie) throw invalid_argument("expected identifier, got end of line");
    if (!isidentifier_fc(*li)) throw invalid_argument("expected identifier");

    do {
        r += *(li++);
        if (li == lie) break;
        if (!isidentifier_mc(*li)) break;
    } while (1);

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x33d0
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x15b70
testb $0x1, %al
jne 0x7b0b
jmp 0x7b74
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0x1d369(%rip), %rsi     # 0x24e8f
callq 0x3530
jmp 0x7b2d
movq -0x50(%rbp), %rdi
movq 0x2b4a0(%rip), %rsi     # 0x32fd8
movq 0x2b481(%rip), %rdx     # 0x32fc0
callq 0x34b0
jmp 0x7c6b
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31f0
jmp 0x7c59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x7c59
movq -0x18(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x5700
testb $0x1, %al
jne 0x7bde
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x1d310(%rip), %rsi     # 0x24eb4
callq 0x3530
jmp 0x7bab
movq -0x58(%rbp), %rdi
movq 0x2b422(%rip), %rsi     # 0x32fd8
movq 0x2b403(%rip), %rdx     # 0x32fc0
callq 0x34b0
jmp 0x7c6b
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31f0
jmp 0x7c59
jmp 0x7be0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x15a50
movq -0x48(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3190
jmp 0x7c06
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x15b70
testb $0x1, %al
jne 0x7c19
jmp 0x7c1b
jmp 0x7c3c
movq -0x18(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %edi
callq 0x5740
testb $0x1, %al
jne 0x7c32
jmp 0x7c3c
jmp 0x7c34
movb $0x1, %al
testb $0x1, %al
jne 0x7be0
jmp 0x7c3c
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7c4f
movq -0x48(%rbp), %rdi
callq 0x3598
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3598
movq -0x28(%rbp), %rdi
callq 0x34e0
nopl (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: print_token(_IO_FILE*, token const&)
void print_token(FILE *fp,const token &t) {
    if (fp == NULL)
        fp = stderr;

    const string s = to_string(t);
    fputs(s.c_str(),fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb535
movq 0x27a8a(%rip), %rax     # 0x32fb8
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x7d10
movq -0x48(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3320
jmp 0xb55d
leaq -0x30(%rbp), %rdi
callq 0x3598
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3598
movq -0x38(%rbp), %rdi
callq 0x34e0
nopw (%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: do_macro_expand_read_invoke_param(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, bool)
string do_macro_expand_read_invoke_param(string::iterator &li,const string::iterator lie,bool final_variadic=false) {
    int paren = 0;
    string r;

    do {
        if (li == lie)
            throw invalid_argument("string terminated unexpectedly");
        if (*li == '(') {
            paren++;
        }
        else if (*li == ')') {
            if (paren > 0)
                paren--;
            else
                break;
        }
        else if (*li == ',' && !final_variadic) {
            break;
        }

        r += *(li++);
    } while (1);

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x33d0
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x15b70
testb $0x1, %al
jne 0xb5d9
jmp 0xb642
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x19bf6(%rip), %rsi     # 0x251ea
callq 0x3530
jmp 0xb5fb
movq -0x58(%rbp), %rdi
movq 0x279d2(%rip), %rsi     # 0x32fd8
movq 0x279b3(%rip), %rdx     # 0x32fc0
callq 0x34b0
jmp 0xb704
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x31f0
jmp 0xb6f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xb6f2
movq -0x18(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0xb65e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb6a1
movq -0x18(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0xb684
cmpl $0x0, -0x20(%rbp)
jle 0xb680
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb682
jmp 0xb6d5
jmp 0xb69f
movq -0x18(%rbp), %rdi
callq 0x15a50
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0xb69d
testb $0x1, -0x19(%rbp)
jne 0xb69d
jmp 0xb6d5
jmp 0xb69f
jmp 0xb6a1
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x15a70
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x15a50
movq -0x50(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3190
jmp 0xb6c7
jmp 0xb6c9
movb $0x1, %al
testb $0x1, %al
jne 0xb5c6
jmp 0xb6d5
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xb6e8
movq -0x50(%rbp), %rdi
callq 0x3598
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3598
movq -0x30(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: pp_stringify(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string pp_stringify(const string &s) {
    string r;

    r += '\"';
    for (auto si=s.begin();si!=s.end();si++) {
        if (*si == '\'' || *si == '\"' || *si == '\\') r += '\\';
        r += *si;
    }
    r += '\"';

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x33d0
movq -0x48(%rbp), %rdi
movl $0x22, %esi
callq 0x3190
jmp 0xb744
movq -0x10(%rbp), %rdi
callq 0x3270
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3520
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x160e0
testb $0x1, %al
jne 0xb774
jmp 0xb7fd
leaq -0x30(%rbp), %rdi
callq 0x16120
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0xb7a7
leaq -0x30(%rbp), %rdi
callq 0x16120
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0xb7a7
leaq -0x30(%rbp), %rdi
callq 0x16120
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0xb7d0
movq -0x48(%rbp), %rdi
movl $0x5c, %esi
callq 0x3190
jmp 0xb7b7
jmp 0xb7d0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3598
jmp 0xb82a
leaq -0x30(%rbp), %rdi
callq 0x16120
movq -0x48(%rbp), %rdi
movsbl (%rax), %esi
callq 0x3190
jmp 0xb7e7
jmp 0xb7e9
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x16140
movq %rax, -0x40(%rbp)
jmp 0xb751
movq -0x48(%rbp), %rdi
movl $0x22, %esi
callq 0x3190
jmp 0xb80d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xb820
movq -0x48(%rbp), %rdi
callq 0x3598
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34e0
nopw %cs:(%rax,%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: tokenit_next_identifier[abi:cxx11](__gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>>&, __gnu_cxx::__normal_iterator<token*, std::vector<token, std::allocator<token>>>)
const string &tokenit_next_identifier(token_string::iterator &ti,const token_string::iterator tie) {
    if (ti != tie) {
        const auto &t = *(ti++);
        if (t.tval == token::IDENTIFIER)
            return t.sval;
    }

    throw invalid_argument("identifier token expected");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x16580
testb $0x1, %al
jne 0x108d3
jmp 0x10908
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x165c0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x16600
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x10906
movq -0x18(%rbp), %rax
addq $0x48, %rax
addq $0x40, %rsp
popq %rbp
retq
jmp 0x10908
movl $0x10, %edi
callq 0x3130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x14ba7(%rip), %rsi     # 0x254ca
callq 0x3530
jmp 0x1092a
movq -0x38(%rbp), %rdi
movq 0x226a3(%rip), %rsi     # 0x32fd8
movq 0x22684(%rip), %rdx     # 0x32fc0
callq 0x34b0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31f0
movq -0x28(%rbp), %rdi
callq 0x34e0
nop
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: expression::newnode(token const&)
expression::node::node_t expression::newnode(const token &nt) {
    const node::node_t r = nodelist.size();
    nodelist.resize(r+size_t(1));
    nodelist[r].tval = nt;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x166e0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x16710
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0x167a0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x167c0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: joncampbell123[P]haxcc/haxpp.cpp
// Function: expression::newnode(token const&, token::token_t)
expression::node::node_t expression::newnode(const token &nt,const token::token_t ntval) {
    const node::node_t r = nodelist.size();
    nodelist.resize(r+size_t(1));
    nodelist[r].tval = nt;
    nodelist[r].tval.tval = ntval;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x166e0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x16710
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x167a0
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x167c0
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rsi
callq 0x167a0
movl -0x24(%rbp), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)