LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Eronana[P]strawberry/src/assembler.cpp
// Function: get_asm_line(std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int get_asm_line(ifstream &stream,string &s)
{
    string str;
    if(!getline(stream,str,'\n'))return -0x80000000;
    istringstream ss(str);
    getline(ss,s,';');
    if(s.empty())return 1+get_asm_line(stream,s);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x7470
movq -0x1d8(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl $0xa, %edx
callq 0x7630
movq %rax, -0x1d0(%rbp)
jmp 0x421f1
movq -0x1d0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x7160
movb %al, -0x1d9(%rbp)
jmp 0x4220f
movb -0x1d9(%rbp), %al
testb $0x1, %al
jne 0x4221b
jmp 0x4223f
movl $0x80000000, -0x4(%rbp) # imm = 0x80000000
movl $0x1, -0x48(%rbp)
jmp 0x422da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x422ef
leaq -0x1c8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x8, %edx
callq 0x75b0
jmp 0x42256
movq -0x18(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
movl $0x3b, %edx
callq 0x7630
jmp 0x4226d
movq -0x18(%rbp), %rdi
callq 0x75a0
testb $0x1, %al
jne 0x4227c
jmp 0x422c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x421b0
movl %eax, -0x1e0(%rbp)
jmp 0x42291
movl -0x1e0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x422ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x7170
jmp 0x422ef
movl $0x1, -0x4(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x7170
leaq -0x38(%rbp), %rdi
callq 0x71d0
movl -0x4(%rbp), %eax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x71d0
movq -0x40(%rbp), %rdi
callq 0x75e0
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/assembler.cpp
// Function: get_opnd_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
OPND_TYPE get_opnd_type(const string &s)
{
    char b=s[0],e=*s.rbegin();
    if((b=='"'&&e=='"')||(b=='\''&e=='\''))return OT_STRING;
    if(s=="NULL")return OT_NULL;
    if(s=="TRUE")return OT_BOOL;
    if(s=="FALSE")return OT_BOOL;

    OPND_TYPE t=OT_INT;
    for(int i=0;i<s.length();i++)if(!isdigit(s[i])&&(i&&s[0]!='-'))
    {
        if(s[i]=='.'||(i==s.length()-1&&(s[i]=='f'||s[i]=='F')))
        {
            t=OT_FLOAT;
        }
        else
        {
            t=OT_LABEL;
            break;
        }
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7330
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x7500
leaq -0x20(%rbp), %rdi
callq 0x43fb0
movb (%rax), %al
movb %al, -0x12(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x22, %eax
jne 0x4235b
movsbl -0x12(%rbp), %eax
cmpl $0x22, %eax
je 0x42381
movsbl -0x11(%rbp), %eax
cmpl $0x27, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movsbl -0x12(%rbp), %ecx
cmpl $0x27, %ecx
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x4238d
movl $0x4, -0x4(%rbp)
jmp 0x424e9
movq -0x10(%rbp), %rdi
leaq 0x16b95(%rip), %rsi     # 0x58f2d
callq 0xfc30
testb $0x1, %al
jne 0x423a3
jmp 0x423af
movl $0x1, -0x4(%rbp)
jmp 0x424e9
movq -0x10(%rbp), %rdi
leaq 0x16b48(%rip), %rsi     # 0x58f02
callq 0xfc30
testb $0x1, %al
jne 0x423c5
jmp 0x423d1
movl $0x2, -0x4(%rbp)
jmp 0x424e9
movq -0x10(%rbp), %rdi
leaq 0x16b2d(%rip), %rsi     # 0x58f09
callq 0xfc30
testb $0x1, %al
jne 0x423e7
jmp 0x423f3
movl $0x2, -0x4(%rbp)
jmp 0x424e9
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x74f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x424e3
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x7330
movsbl (%rax), %edi
callq 0x72a0
cmpl $0x0, %eax
jne 0x424d3
cmpl $0x0, -0x28(%rbp)
je 0x424d3
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7330
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x424d3
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x7330
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x424bf
movslq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x74f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x424c8
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x7330
movsbl (%rax), %eax
cmpl $0x66, %eax
je 0x424bf
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x7330
movsbl (%rax), %eax
cmpl $0x46, %eax
jne 0x424c8
movl $0x3, -0x24(%rbp)
jmp 0x424d1
movl $0x5, -0x24(%rbp)
jmp 0x424e3
jmp 0x424d3
jmp 0x424d5
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x42401
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/assembler.cpp
// Function: init_escape_table()
void init_escape_table()
{
    if(escape_table[1])return;
    for(int i=0;i<sizeof(escape_table);i++)escape_table[i]=i;
    escape_table['0']='\0';
    escape_table['e']='\e';
    escape_table['a']='\a';
    escape_table['b']='\b';
    escape_table['t']='\t';
    escape_table['n']='\n';
    escape_table['v']='\v';
    escape_table['f']='\f';
    escape_table['r']='\r';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x48456(%rip)     # 0x8a961
je 0x4250f
jmp 0x4257f
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq $0x80, %rax
jae 0x42540
movl -0x4(%rbp), %eax
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0x4842e(%rip), %rax     # 0x8a960
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x42516
movb $0x0, 0x48449(%rip)     # 0x8a990
movb $0x1b, 0x48477(%rip)    # 0x8a9c5
movb $0x7, 0x4846c(%rip)     # 0x8a9c1
movb $0x8, 0x48466(%rip)     # 0x8a9c2
movb $0x9, 0x48471(%rip)     # 0x8a9d4
movb $0xa, 0x48464(%rip)     # 0x8a9ce
movb $0xb, 0x48465(%rip)     # 0x8a9d6
movb $0xc, 0x4844e(%rip)     # 0x8a9c6
movb $0xd, 0x48453(%rip)     # 0x8a9d2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/assembler.cpp
// Function: process_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string process_string(const string &s)
{
    string x;
    for(int i=1;i<s.length()-1;i++)
        x.push_back(s[i]=='\\'?escape_table[s[++i]]:s[i]);
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7470
movl $0x1, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x74f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x42667
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x7330
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x4261d
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movslq %eax, %rsi
callq 0x7330
movsbq (%rax), %rcx
leaq 0x4834b(%rip), %rax     # 0x8a960
movb (%rax,%rcx), %al
movb %al, -0x41(%rbp)
jmp 0x4262f
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x7330
movb (%rax), %al
movb %al, -0x41(%rbp)
movq -0x38(%rbp), %rdi
movb -0x41(%rbp), %al
movsbl %al, %esi
callq 0x7280
jmp 0x42640
jmp 0x42642
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x425bb
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x71d0
jmp 0x42684
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4267a
movq -0x38(%rbp), %rdi
callq 0x71d0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x75e0
nopl (%rax)
// File: Eronana[P]strawberry/src/disassembler.cpp
// Function: disassemble(char const*, char const*)
bool disassemble(const char *binfile,const char *outfile)
{
    FILE *in=fopen(binfile,"rb");
    if(!in)return false;
    FILE *out=fopen(outfile,"w");
    if(!out)
    {
        fclose(in);
        return false;
    }
    bool ret=disassemble(in,out);
    fclose(in);
    fclose(out);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xb4a5(%rip), %rsi      # 0x59060
callq 0x73b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4dbd1
movb $0x0, -0x1(%rbp)
jmp 0x4dc27
movq -0x18(%rbp), %rdi
leaq 0xa5f6(%rip), %rsi      # 0x581d2
callq 0x73b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4dbfb
movq -0x20(%rbp), %rdi
callq 0x72b0
movb $0x0, -0x1(%rbp)
jmp 0x4dc27
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4dc40
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x20(%rbp), %rdi
callq 0x72b0
movq -0x28(%rbp), %rdi
callq 0x72b0
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/disassembler.cpp
// Function: init_r_escape_table()
void init_r_escape_table()
{
    if(r_escape_table['\0'])return;
    r_escape_table['\0']='0';
    r_escape_table['\e']='e';
    r_escape_table['\a']='a';
    r_escape_table['\b']='b';
    r_escape_table['\t']='t';
    r_escape_table['\n']='n';
    r_escape_table['\v']='v';
    r_escape_table['\f']='f';
    r_escape_table['\r']='r';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x3cc55(%rip)     # 0x8ab90
je 0x4df3f
jmp 0x4df7e
movb $0x30, 0x3cc4a(%rip)    # 0x8ab90
movb $0x65, 0x3cc5e(%rip)    # 0x8abab
movb $0x61, 0x3cc43(%rip)    # 0x8ab97
movb $0x62, 0x3cc3d(%rip)    # 0x8ab98
movb $0x74, 0x3cc37(%rip)    # 0x8ab99
movb $0x6e, 0x3cc31(%rip)    # 0x8ab9a
movb $0x76, 0x3cc2b(%rip)    # 0x8ab9b
movb $0x66, 0x3cc25(%rip)    # 0x8ab9c
movb $0x72, 0x3cc1f(%rip)    # 0x8ab9d
popq %rbp
retq
// File: Eronana[P]strawberry/src/disassembler.cpp
// Function: print_string(_IO_FILE*, char const*)
void print_string(FILE *fp,const char *s)
{
    init_r_escape_table();
    fputc('"',fp);
    for(int i=0;s[i];i++)
    {
        if(r_escape_table[s[i]])fputc('\\',fp),fputc(r_escape_table[s[i]],fp);
        else fputc(s[i],fp);
    }
    fputc('"',fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4df30
movq -0x8(%rbp), %rsi
movl $0x22, %edi
callq 0x7400
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4e025
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbq (%rax,%rcx), %rcx
leaq 0x3cbc4(%rip), %rax     # 0x8ab90
cmpb $0x0, (%rax,%rcx)
je 0x4e003
movq -0x8(%rbp), %rsi
movl $0x5c, %edi
callq 0x7400
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbq (%rax,%rcx), %rcx
leaq 0x3cb9c(%rip), %rax     # 0x8ab90
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rsi
callq 0x7400
jmp 0x4e018
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rsi
callq 0x7400
jmp 0x4e01a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4dfaa
movq -0x8(%rbp), %rsi
movl $0x22, %edi
callq 0x7400
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Eronana[P]strawberry/src/lexer.cpp
// Function: Lexer::createToken(TOKEN_TYPE, int)
Token Lexer::createToken(TOKEN_TYPE type, int len = 1)
{
    Token t;
    t.type = type;
    t.line = line_number;
    t.col = col_number;
    t.raw = std::string(lookhead_buffer.begin(), len);
    clearChar(len);
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x1c450
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movl 0x28(%rdi), %ecx
movl %ecx, 0x4(%rax)
movl 0x2c(%rdi), %ecx
movl %ecx, 0x8(%rax)
addq $0x8, %rdi
callq 0x504d0
movq %rax, -0x58(%rbp)
jmp 0x4e65d
movslq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x4d(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x75f0
movq -0x58(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x7360
jmp 0x4e689
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0x88(%rbp)
callq 0x73c0
movq -0x88(%rbp), %rdi
callq 0x71d0
leaq -0x4d(%rbp), %rdi
callq 0x7310
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x4e3d0
jmp 0x4e6c4
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x4e6fe
jmp 0x4e6f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4e70b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x4d(%rbp), %rdi
callq 0x7310
jmp 0x4e70b
movq -0x68(%rbp), %rdi
callq 0x9600
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x9600
movq -0x48(%rbp), %rdi
callq 0x75e0
nopl (%rax)
// File: Eronana[P]strawberry/src/lexer.cpp
// Function: Lexer::load(char const*)
bool Lexer::load(const char *file)
{
    fp = fopen(file, "r");
    if (!fp) return false;
    line_number = 1;
    col_number = 1;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x95ae(%rip), %rsi      # 0x581b1
callq 0x73b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x4ec1e
movb $0x0, -0x1(%rbp)
jmp 0x4ec34
movq -0x20(%rbp), %rax
movl $0x1, 0x28(%rax)
movl $0x1, 0x2c(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Eronana[P]strawberry/src/codedata.cpp
// Function: CodeData::check(char const*)
bool CodeData::check(const char *filename)
{
    FILE *fp=fopen(filename,"rb");
    if(!fp)return false;
    uint32_t magic;
    fread(&magic,sizeof(magic),1,fp);
    fclose(fp);
    return magic==HEADER_MAGIC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8119(%rip), %rsi      # 0x59060
callq 0x73b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x50f5d
movb $0x0, -0x1(%rbp)
jmp 0x50f8c
movq -0x18(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x74e0
movq -0x18(%rbp), %rdi
callq 0x72b0
cmpl $0x414e5245, -0x1c(%rbp) # imm = 0x414E5245
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Eronana[P]strawberry/src/codedata.cpp
// Function: CodeData::load(char const*)
bool CodeData::load(const char *filename)
{
    FILE *fp=fopen(filename,"rb");
    if(!fp)return false;
    bool ret=load(fp);
    fclose(fp);
    return ret;
}

// 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 0x809d(%rip), %rsi      # 0x59060
callq 0x73b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x50fd9
movb $0x0, -0x1(%rbp)
jmp 0x50ffc
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x51010
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
callq 0x72b0
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: variantMethod(Symbol*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
void variantMethod(Symbol *symbol,const string &id,const char *method)
{
    int allowIndex;
    switch(symbol->lookup(id,allowIndex))
    {
        case ST_GLOBAL:
            PRINTF("%s_global %d\n",method,allowIndex);
            break;
        case ST_LOCAL:
            PRINTF("%s %d\n",method,allowIndex);
            break;
        case ST_EXTERNAL:
        {
            auto &func=*functionStack.top();
            if(!func.ext_map.count(id))
            {
                func.ext_map[id]=func.ext_list.size();
                func.ext_list.push_back(id);
            }
            PRINTF("%s_external %d\n",method,func.ext_map[id]);
            break;
        }
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x184e0
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
testl %eax, %eax
je 0x521e7
jmp 0x521d0
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x5224d
jmp 0x521da
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x5221a
jmp 0x522f2
movl 0x38a23(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x38a1a(%rip)     # 0x8ac10
leaq 0x386eb(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x7552(%rip), %rsi      # 0x59760
movb $0x0, %al
callq 0x74c0
jmp 0x522f4
movl 0x389f0(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x389e7(%rip)     # 0x8ac10
leaq 0x386b8(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x6e4e(%rip), %rsi      # 0x5908f
movb $0x0, %al
callq 0x74c0
jmp 0x522f4
leaq 0x38634(%rip), %rdi     # 0x8a888
callq 0x554a0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x18850
cmpq $0x0, %rax
jne 0x522a6
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x49dc0
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x188b0
movl -0x30(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x44620
movl 0x38964(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x3895b(%rip)     # 0x8ac10
leaq 0x3862c(%rip), %rax     # 0x8a8e8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x188b0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl (%rax), %ecx
leaq 0x7485(%rip), %rsi      # 0x5976e
movb $0x0, %al
callq 0x74c0
jmp 0x522f4
jmp 0x522f4
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_Literal::codeGen(Symbol*)
DEF_AST_METHOD(Literal,AST_CODEGEN)
{
    switch(token.type)
    {
        case TOKEN_IDENTIFIER:
        {
            AST_PTR tmp(this);
            loadVariant(symbol,tmp);
            tmp.release();
        }
        break;
        case TOKEN_BIN_INTEGER_LITERAL:
            PRINTF("push %ld\n",strtol(token.raw.c_str(),NULL,2));
            break;
        case TOKEN_OCT_INTEGER_LITERAL:
        case TOKEN_DEC_INTEGER_LITERAL:
        case TOKEN_HEX_INTEGER_LITERAL:
            PRINTF("push %ld\n",strtol(token.raw.c_str(),NULL,0));
            break;
        default:
            PRINTF("push %s\n",token.raw.c_str());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x2e, %eax
je 0x523c3
jmp 0x523a5
movl -0x28(%rbp), %eax
subl $0x30, %eax
je 0x52414
jmp 0x523af
movl -0x28(%rbp), %eax
addl $-0x31, %eax
subl $0x3, %eax
jb 0x5246d
jmp 0x524c0
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x33320
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x554c0
jmp 0x523e3
leaq -0x18(%rbp), %rdi
callq 0x55510
leaq -0x18(%rbp), %rdi
callq 0x8f10
jmp 0x52503
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8f10
jmp 0x52509
movq -0x30(%rbp), %rdi
movl 0x387f2(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x387e9(%rip)     # 0x8ac10
leaq 0x384ba(%rip), %rax     # 0x8a8e8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x7120
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x74b0
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0x731d(%rip), %rsi      # 0x5977e
movb $0x0, %al
callq 0x74c0
jmp 0x52503
movq -0x30(%rbp), %rdi
movl 0x38799(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x38790(%rip)     # 0x8ac10
leaq 0x38461(%rip), %rax     # 0x8a8e8
movq (%rax), %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x7120
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x74b0
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq 0x72c7(%rip), %rsi      # 0x5977e
movb $0x0, %al
callq 0x74c0
jmp 0x52503
movq -0x30(%rbp), %rdi
movl 0x38746(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x3873d(%rip)     # 0x8ac10
leaq 0x3840e(%rip), %rax     # 0x8a8e8
movq (%rax), %rax
movq %rax, -0x50(%rbp)
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x7120
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq 0x728c(%rip), %rsi      # 0x59788
movb $0x0, %al
callq 0x74c0
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x75e0
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_ArrayLiteral::codeGen(Symbol*)
DEF_AST_METHOD(ArrayLiteral,AST_CODEGEN)
{
    PRINTF("new_array\n");
    int this_bak=++this_count;
    FOREACH(nodes)
    {
        CODEGEN(x);
        if(this_bak!=this_count)
        {
            PRINTF("reset_this\n");
            this_bak=++this_count;
        }
        PRINTF("array_push\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x386d2(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x386c9(%rip)     # 0x8ac10
leaq 0x3839a(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x7239(%rip), %rsi      # 0x59791
movb $0x0, %al
callq 0x74c0
movq -0x40(%rbp), %rax
leaq 0x38372(%rip), %rcx     # 0x8a8dc
movl (%rcx), %ecx
addl $0x1, %ecx
leaq 0x38366(%rip), %rdx     # 0x8a8dc
movl %ecx, (%rdx)
movl %ecx, -0x14(%rbp)
addq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1d7f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1d820
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1d850
testb $0x1, %al
jne 0x525b3
jmp 0x52658
leaq -0x28(%rbp), %rdi
callq 0x1d890
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl -0x14(%rbp), %eax
leaq 0x382fc(%rip), %rcx     # 0x8a8dc
cmpl (%rcx), %eax
je 0x52623
movl 0x38626(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x3861d(%rip)     # 0x8ac10
leaq 0x382ee(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x7198(%rip), %rsi      # 0x5979c
movb $0x0, %al
callq 0x74c0
leaq 0x382ca(%rip), %rax     # 0x8a8dc
movl (%rax), %eax
addl $0x1, %eax
leaq 0x382be(%rip), %rcx     # 0x8a8dc
movl %eax, (%rcx)
movl %eax, -0x14(%rbp)
movl 0x385e7(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x385de(%rip)     # 0x8ac10
leaq 0x382af(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x7165(%rip), %rsi      # 0x597a8
movb $0x0, %al
callq 0x74c0
leaq -0x28(%rbp), %rdi
callq 0x1d8b0
jmp 0x5259d
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_Expression::codeGen(Symbol*)
DEF_AST_METHOD(Expression,AST_CODEGEN)
{
    if(nodes.size())CODEGEN(nodes[0]);
    FOR2ND(nodes)
    {
        PRINTF("pop\n");
        CODEGEN(nodes[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
callq 0x1d7d0
cmpq $0x0, %rax
je 0x528dd
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1d7b0
movq %rax, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl $0x1, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x1d7d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x5295d
movl 0x38305(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x382fc(%rip)     # 0x8ac10
leaq 0x37fcd(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x6eb2(%rip), %rsi      # 0x597d7
movb $0x0, %al
callq 0x74c0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x1d7b0
movq %rax, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x528e4
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_ArgumentList::codeGen(Symbol*)
DEF_AST_METHOD(ArgumentList,AST_CODEGEN)
{
    bool isGlobalThis=last_object_get!=print_count;
    PRINTF("; callee\n");
    PRINTF("dup\n"); 
    PRINTF("; this\n");
    if(isGlobalThis)PRINTF("load_global 0\n");
    else PRINTF("get_this\n");
    for(int i=nodes.size()-1;~i;i--)
    {
        PRINTF("; arugment %d\n",i);
        CODEGEN(nodes[i]);
    }
    PRINTF("call %lu\n",nodes.size()+2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x38286(%rip), %eax     # 0x8ac14
cmpl 0x3827c(%rip), %eax     # 0x8ac10
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movl 0x3826e(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x38265(%rip)     # 0x8ac10
leaq 0x37f36(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x6e20(%rip), %rsi      # 0x597dc
movb $0x0, %al
callq 0x74c0
movl 0x38247(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x3823e(%rip)     # 0x8ac10
leaq 0x37f0f(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x6e03(%rip), %rsi      # 0x597e6
movb $0x0, %al
callq 0x74c0
movl 0x38220(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x38217(%rip)     # 0x8ac10
leaq 0x37ee8(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x6de1(%rip), %rsi      # 0x597eb
movb $0x0, %al
callq 0x74c0
testb $0x1, -0x11(%rbp)
je 0x52a40
movl 0x381f3(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x381ea(%rip)     # 0x8ac10
leaq 0x37ebb(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x6dbc(%rip), %rsi      # 0x597f3
movb $0x0, %al
callq 0x74c0
jmp 0x52a67
movl 0x381ca(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x381c1(%rip)     # 0x8ac10
leaq 0x37e92(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x6da2(%rip), %rsi      # 0x59802
movb $0x0, %al
callq 0x74c0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d7d0
subq $0x1, %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
xorl $-0x1, %eax
cmpl $0x0, %eax
je 0x52ae1
movl 0x38184(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x3817b(%rip)     # 0x8ac10
leaq 0x37e4c(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movl -0x18(%rbp), %edx
leaq 0x6d63(%rip), %rsi      # 0x5980c
movb $0x0, %al
callq 0x74c0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movslq -0x18(%rbp), %rsi
callq 0x1d7b0
movq %rax, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x52a7b
movq -0x20(%rbp), %rdi
movl 0x38125(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x3811c(%rip)     # 0x8ac10
leaq 0x37ded(%rip), %rax     # 0x8a8e8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x1d7d0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
addq $0x2, %rdx
leaq 0x6cfe(%rip), %rsi      # 0x5981b
movb $0x0, %al
callq 0x74c0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_MemberPartExpression::codeGen(Symbol*)
DEF_AST_METHOD(MemberPartExpression,AST_CODEGEN)
{
    PRINTF("dup\n");
    PRINTF("set_this\n");
    int this_bak=++this_count;
    CODEGEN(expr);
    PRINTF("swap\n");
    if(this_bak!=this_count)
    {
        PRINTF("set_this\n");
        this_count++;
    
    }else PRINTF("pop\n");
    PRINTF("object_get\n");
    last_object_get=print_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x37cc2(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37cb9(%rip)     # 0x8ac10
leaq 0x3798a(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x687e(%rip), %rsi      # 0x597e6
movb $0x0, %al
callq 0x74c0
movl 0x37c9b(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37c92(%rip)     # 0x8ac10
leaq 0x37963(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x680f(%rip), %rsi      # 0x5979e
movb $0x0, %al
callq 0x74c0
movq -0x20(%rbp), %rdi
leaq 0x3793b(%rip), %rax     # 0x8a8dc
movl (%rax), %eax
addl $0x1, %eax
leaq 0x3792f(%rip), %rcx     # 0x8a8dc
movl %eax, (%rcx)
movl %eax, -0x14(%rbp)
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x37c42(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37c39(%rip)     # 0x8ac10
leaq 0x3790a(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x683d(%rip), %rsi      # 0x59825
movb $0x0, %al
callq 0x74c0
movl -0x14(%rbp), %eax
leaq 0x378e3(%rip), %rcx     # 0x8a8dc
cmpl (%rcx), %eax
je 0x5303b
movl 0x37c0d(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37c04(%rip)     # 0x8ac10
leaq 0x378d5(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x6781(%rip), %rsi      # 0x5979e
movb $0x0, %al
callq 0x74c0
leaq 0x378b1(%rip), %rax     # 0x8a8dc
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x378a5(%rip), %rax     # 0x8a8dc
movl %ecx, (%rax)
jmp 0x53062
movl 0x37bcf(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37bc6(%rip)     # 0x8ac10
leaq 0x37897(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x677c(%rip), %rsi      # 0x597d7
movb $0x0, %al
callq 0x74c0
movl 0x37ba8(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37b9f(%rip)     # 0x8ac10
leaq 0x37870(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x67a9(%rip), %rsi      # 0x5982b
movb $0x0, %al
callq 0x74c0
movl 0x37b81(%rip), %eax     # 0x8ac10
movl %eax, 0x37b7f(%rip)     # 0x8ac14
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_MemberPartIdentifer::codeGen(Symbol*)
DEF_AST_METHOD(MemberPartIdentifer,AST_CODEGEN)
{
    PRINTF("set_this\n");
    this_count++;
    PRINTF("push \"%s\"\n",GET_LITERAL(identifer).raw.c_str());
    PRINTF("object_get\n");
    last_object_get=print_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x37b52(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37b49(%rip)     # 0x8ac10
leaq 0x3781a(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x66c6(%rip), %rsi      # 0x5979e
movb $0x0, %al
callq 0x74c0
movq -0x20(%rbp), %rdi
leaq 0x377f2(%rip), %rax     # 0x8a8dc
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x377e6(%rip), %rax     # 0x8a8dc
movl %ecx, (%rax)
movl 0x37b12(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37b09(%rip)     # 0x8ac10
leaq 0x377da(%rip), %rax     # 0x8a8e8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0xabd0
movq %rax, %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x7120
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0x6684(%rip), %rsi      # 0x597c0
movb $0x0, %al
callq 0x74c0
movl 0x37ac7(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37abe(%rip)     # 0x8ac10
leaq 0x3778f(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x66c8(%rip), %rsi      # 0x5982b
movb $0x0, %al
callq 0x74c0
movl 0x37aa0(%rip), %eax     # 0x8ac10
movl %eax, 0x37a9e(%rip)     # 0x8ac14
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_PostfixExpression::codeGen(Symbol*)
DEF_AST_METHOD(PostfixExpression,AST_CODEGEN)
{
    bool isIdentifier=is_identifier(expr);
    if(isIdentifier)loadVariant(symbol,expr);
    else CODEGEN(expr);
    PRINTF("dup\n");
    if(GET_LITERAL(optr).type==TOKEN_INCREMENT)PRINTF("inc\n");
    else PRINTF("dec\n");
    if(isIdentifier)storeVariant(symbol,expr);
    else PRINTF("object_reset\n");
    PRINTF("pop\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
callq 0x52300
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x5328f
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rsi
callq 0x554c0
jmp 0x532a9
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x37961(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37958(%rip)     # 0x8ac10
leaq 0x37629(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x651d(%rip), %rsi      # 0x597e6
movb $0x0, %al
callq 0x74c0
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0xabd0
cmpl $0x2, 0x8(%rax)
jne 0x5330c
movl 0x37927(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x3791e(%rip)     # 0x8ac10
leaq 0x375ef(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x6534(%rip), %rsi      # 0x59837
movb $0x0, %al
callq 0x74c0
jmp 0x53333
movl 0x378fe(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x378f5(%rip)     # 0x8ac10
leaq 0x375c6(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x6510(%rip), %rsi      # 0x5983c
movb $0x0, %al
callq 0x74c0
testb $0x1, -0x11(%rbp)
je 0x5334c
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rsi
callq 0x55530
jmp 0x53373
movl 0x378be(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x378b5(%rip)     # 0x8ac10
leaq 0x37586(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x64d5(%rip), %rsi      # 0x59841
movb $0x0, %al
callq 0x74c0
movl 0x37897(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x3788e(%rip)     # 0x8ac10
leaq 0x3755f(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x6444(%rip), %rsi      # 0x597d7
movb $0x0, %al
callq 0x74c0
addq $0x20, %rsp
popq %rbp
retq
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_ConditionalExpression::codeGen(Symbol*)
DEF_AST_METHOD(ConditionalExpression,AST_CODEGEN)
{
    PRINTF("; conditional expression\n");
    CODEGEN(expr);
    PRINTF("istrue\n");
    int falseLabel=nextLabel();
    int jmpLabel=nextLabel();
    PRINTF("jmp label_%d\n",falseLabel);
    PRINTF("; true branch\n");
    CODEGEN(trueExpr);
    PRINTF("jmp label_%d\n",jmpLabel);
    PRINTF("label_%d:\n",falseLabel);
    PRINTF("; false branch\n");
    CODEGEN(falseExpr);
    PRINTF("label_%d:\n",jmpLabel);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x370d2(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x370c9(%rip)     # 0x8ac10
leaq 0x36d9a(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x5d89(%rip), %rsi      # 0x598e1
movb $0x0, %al
callq 0x74c0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x37091(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37088(%rip)     # 0x8ac10
leaq 0x36d59(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x5cd4(%rip), %rsi      # 0x5986d
movb $0x0, %al
callq 0x74c0
callq 0x1a000
movl %eax, -0x14(%rbp)
callq 0x1a000
movl %eax, -0x18(%rbp)
movl 0x3705a(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37051(%rip)     # 0x8ac10
leaq 0x36d22(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x5ca2(%rip), %rsi      # 0x59875
movb $0x0, %al
callq 0x74c0
movl 0x37030(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x37027(%rip)     # 0x8ac10
leaq 0x36cf8(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x5d01(%rip), %rsi      # 0x598fb
movb $0x0, %al
callq 0x74c0
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x36fef(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x36fe6(%rip)     # 0x8ac10
leaq 0x36cb7(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movl -0x18(%rbp), %edx
leaq 0x5c37(%rip), %rsi      # 0x59875
movb $0x0, %al
callq 0x74c0
movl 0x36fc5(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x36fbc(%rip)     # 0x8ac10
leaq 0x36c8d(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x5c6e(%rip), %rsi      # 0x598d6
movb $0x0, %al
callq 0x74c0
movl 0x36f9b(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x36f92(%rip)     # 0x8ac10
leaq 0x36c63(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x5c7b(%rip), %rsi      # 0x5990a
movb $0x0, %al
callq 0x74c0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x36f5a(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x36f51(%rip)     # 0x8ac10
leaq 0x36c22(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movl -0x18(%rbp), %edx
leaq 0x5c03(%rip), %rsi      # 0x598d6
movb $0x0, %al
callq 0x74c0
addq $0x20, %rsp
popq %rbp
retq
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_VariableDeclaration::codeGen(Symbol*)
DEF_AST_METHOD(VariableDeclaration,AST_CODEGEN)
{
    if(!assignExpr)return;
    CODEGEN(assignExpr);
    storeVariant(symbol,identifier);
    PRINTF("pop\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
callq 0x1d8d0
testb $0x1, %al
jne 0x542a7
jmp 0x542f9
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rsi
callq 0x55530
movl 0x36938(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x3692f(%rip)     # 0x8ac10
leaq 0x36600(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x54e5(%rip), %rsi      # 0x597d7
movb $0x0, %al
callq 0x74c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_CaseBlock::codeGen(Symbol*)
DEF_AST_METHOD(CaseBlock,AST_CODEGEN)
{
    int endLabel=nextLabel();
    breakStack.push(endLabel);
    defaultClauseStack.push(-1);
    CODEGEN(caseClausesList);
    int defaultLabel=defaultClauseStack.top();
    if(defaultLabel!=-1)PRINTF("jmp label_%d\n",defaultLabel);
    PRINTF("label_%d:\n",endLabel);
    breakStack.pop();
    defaultClauseStack.pop();
}

// 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)
callq 0x1a000
movl %eax, -0x14(%rbp)
leaq 0x35b41(%rip), %rdi     # 0x8a7e8
leaq -0x14(%rbp), %rsi
callq 0x55580
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
leaq 0x35b7a(%rip), %rdi     # 0x8a838
leaq -0x18(%rbp), %rsi
callq 0x555f0
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x35b50(%rip), %rdi     # 0x8a838
callq 0x555d0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
je 0x54d22
movl 0x35f12(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x35f09(%rip)     # 0x8ac10
leaq 0x35bda(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movl -0x1c(%rbp), %edx
leaq 0x4b5a(%rip), %rsi      # 0x59875
movb $0x0, %al
callq 0x74c0
movl 0x35ee8(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x35edf(%rip)     # 0x8ac10
leaq 0x35bb0(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x4b91(%rip), %rsi      # 0x598d6
movb $0x0, %al
callq 0x74c0
leaq 0x35a95(%rip), %rdi     # 0x8a7e8
callq 0x555b0
leaq 0x35ad9(%rip), %rdi     # 0x8a838
callq 0x555b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_SwitchStatement::codeGen(Symbol*)
DEF_AST_METHOD(SwitchStatement,AST_CODEGEN)
{
    GET_SCOPE();
    PRINTF("; switch statement\n");
    CODEGEN(expr);
    CODEGEN(caseBlock);
    PRINTF("pop\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
leaq 0x359d5(%rip), %rdi     # 0x8a768
leaq -0x18(%rbp), %rsi
callq 0x20310
movq %rax, %rdi
callq 0x203f0
movq %rax, -0x10(%rbp)
movl 0x35e62(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x35e59(%rip)     # 0x8ac10
leaq 0x35b2a(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x4bf3(%rip), %rsi      # 0x599bb
movb $0x0, %al
callq 0x74c0
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x35e07(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x35dfe(%rip)     # 0x8ac10
leaq 0x35acf(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x49b4(%rip), %rsi      # 0x597d7
movb $0x0, %al
callq 0x74c0
addq $0x20, %rsp
popq %rbp
retq
// File: Eronana[P]strawberry/src/ast_codegen.cpp
// Function: AST_Program::codeGen(Symbol*)
DEF_AST_METHOD(Program,AST_CODEGEN)
{
    GET_SCOPE();
    auto localCount=symbol->localCount;
    if(localCount)PRINTF("addsp %d\n",symbol->localCount);
    CODEGEN(stmtList);
    if(localCount)PRINTF("subsp %d\n",symbol->localCount);
    PRINTF("halt\n\n");
    for(FILE *x:func_tmpfile)copy_stream(AST::fp,x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rax, -0x18(%rbp)
leaq 0x35405(%rip), %rdi     # 0x8a768
leaq -0x18(%rbp), %rsi
callq 0x20310
movq %rax, %rdi
callq 0x203f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x553b6
movl 0x35882(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x35879(%rip)     # 0x8ac10
leaq 0x3554a(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %edx
leaq 0x4637(%rip), %rsi      # 0x599e6
movb $0x0, %al
callq 0x74c0
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x8f60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x0, -0x1c(%rbp)
je 0x55404
movl 0x35834(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x3582b(%rip)     # 0x8ac10
leaq 0x354fc(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %edx
leaq 0x4622(%rip), %rsi      # 0x59a1f
movb $0x0, %al
callq 0x74c0
movl 0x35806(%rip), %eax     # 0x8ac10
addl $0x1, %eax
movl %eax, 0x357fd(%rip)     # 0x8ac10
leaq 0x354ce(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
leaq 0x4605(%rip), %rsi      # 0x59a29
movb $0x0, %al
callq 0x74c0
leaq 0x357e6(%rip), %rax     # 0x8ac18
movq %rax, -0x28(%rbp)
leaq 0x357db(%rip), %rdi     # 0x8ac18
callq 0x55840
movq %rax, -0x30(%rbp)
leaq 0x357cb(%rip), %rdi     # 0x8ac18
callq 0x55870
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x558a0
testb $0x1, %al
jne 0x55469
jmp 0x55497
leaq -0x30(%rbp), %rdi
callq 0x558e0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
leaq 0x35468(%rip), %rax     # 0x8a8e8
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x552f0
leaq -0x30(%rbp), %rdi
callq 0x55900
jmp 0x55456
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: scattana[P]Crossword-Anagram-CPP/crossword.cpp
// Function: checkForLetters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool checkForLetters(string word){
	// first, check if the word is 15 characters or less
	if(word.size()>15) return false;
	// next, check if the word contains all valid letters
	// using ascii values for valid uppercase and lowercase letters
	for(int i=0; i<word.size(); i++){
		if(word[i]<65 || word[i]>122 || (word[i]>90&&word[i]<97)){
			return false;
		}
	}
	// if the function "makes it out" without returning false, then all
	// characters are valid letters - return true
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x2130
cmpq $0xf, %rax
jbe 0x38d4
movb $0x0, -0x1(%rbp)
jmp 0x3966
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2130
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x3962
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x22e0
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x394c
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x22e0
movsbl (%rax), %eax
cmpl $0x7a, %eax
jg 0x394c
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x22e0
movsbl (%rax), %eax
cmpl $0x5a, %eax
jle 0x3952
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x22e0
movsbl (%rax), %eax
cmpl $0x61, %eax
jge 0x3952
movb $0x0, -0x1(%rbp)
jmp 0x3966
jmp 0x3954
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x38db
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: scattana[P]Crossword-Anagram-CPP/crossword.cpp
// Function: sortHighLow(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>>>>&)
void sortHighLow(vector<string>& list){
	string temp;
	// run bubble sort algorithm
	for(int i=0; i<list.size()-1; i++){
		for(int j=0; j<list.size()-i-1; j++){
			if(list[j].size() < list[j+1].size()){
				temp = list[j];
				list[j] = list[j+1];
				list[j+1] = temp;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2220
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3bf0
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3ada
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3bf0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movslq -0x2c(%rbp), %rdx
subq %rdx, %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3aca
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x3cb0
movq %rax, %rdi
callq 0x2130
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x3cb0
movq %rax, %rdi
callq 0x2130
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x3aba
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x3cb0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2030
jmp 0x3a52
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %eax
incl %eax
movslq %eax, %rsi
callq 0x3cb0
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x3cb0
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x2030
jmp 0x3a82
movq -0x8(%rbp), %rdi
movl -0x30(%rbp), %eax
incl %eax
movslq %eax, %rsi
callq 0x3cb0
movq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x2030
jmp 0x3aa1
jmp 0x3aba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2120
jmp 0x3ae9
jmp 0x3abc
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x39c8
jmp 0x3acc
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x399c
leaq -0x28(%rbp), %rdi
callq 0x2120
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)