LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::ReadFile(char const*)
void CPUProgramDyn::ReadFile(const char* fileName){

    numberOfLines = determineNumberOfLines(fileName);

    if(fileString != nullptr)
    {
        delete [] fileString;
    }

    fileString = new string[numberOfLines];
    fstream file;
    string line;
    file.open(fileName);

    for(int i = 0; i < numberOfLines; ++i)
    {
        getline (file,fileString[i]);
    }

    file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x258(%rbp)
movq -0x10(%rbp), %rsi
callq 0xa760
movl %eax, %ecx
movq -0x258(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0xa4f3
movq -0x258(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x260(%rbp)
cmpq $0x0, %rax
je 0xa4f1
movq -0x260(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x270(%rbp)
movq -0x8(%rcx), %rdx
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x268(%rbp)
je 0xa4e5
movq -0x268(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x278(%rbp)
callq 0x20a0
movq -0x260(%rbp), %rcx
movq -0x278(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x268(%rbp)
jne 0xa4b4
movq -0x270(%rbp), %rdi
callq 0x2160
jmp 0xa4f3
movq -0x258(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x288(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x288(%rbp), %rax
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x280(%rbp)
cmpq $0x0, %rax
je 0xa5a3
movq -0x280(%rbp), %rax
movq -0x288(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x298(%rbp)
movq %rax, -0x290(%rbp)
movq -0x290(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
callq 0x2190
movq -0x2a0(%rbp), %rax
movq -0x298(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x290(%rbp)
jne 0xa572
movq -0x258(%rbp), %rax
movq -0x280(%rbp), %rcx
movq %rcx, 0x8(%rax)
leaq -0x220(%rbp), %rdi
callq 0x2130
leaq -0x240(%rbp), %rdi
callq 0x2190
movq -0x10(%rbp), %rax
movq %rax, -0x2b0(%rbp)
movl $0x8, %edi
movl $0x10, %esi
callq 0xbc20
movl %eax, -0x2a4(%rbp)
jmp 0xa5ef
movl -0x2a4(%rbp), %edx
movq -0x2b0(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x20e0
jmp 0xa60a
movl $0x0, -0x250(%rbp)
movq -0x258(%rbp), %rcx
movl -0x250(%rbp), %eax
cmpl (%rcx), %eax
jge 0xa68b
movq -0x258(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x250(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
leaq -0x220(%rbp), %rdi
callq 0x2060
jmp 0xa64c
jmp 0xa64e
movl -0x250(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x250(%rbp)
jmp 0xa614
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x20a0
leaq -0x220(%rbp), %rdi
callq 0x2070
jmp 0xa6ba
leaq -0x220(%rbp), %rdi
callq 0x2050
jmp 0xa699
leaq -0x240(%rbp), %rdi
callq 0x20a0
leaq -0x220(%rbp), %rdi
callq 0x2070
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
movq -0x248(%rbp), %rdi
callq 0x21d0
nopw %cs:(%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::determineNumberOfLines(char const*) const
const int CPUProgramDyn::determineNumberOfLines(const char* fileName)const
{
    int line = 0;
    string buffer;
    fstream file;

    file.open(fileName);

    for(getline(file, buffer); !(file.eof()) ; getline(file, buffer)){
        ++line;
    }

    file.close();
    return line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2190
leaq -0x248(%rbp), %rdi
callq 0x2130
jmp 0xa791
movq -0x10(%rbp), %rax
movq %rax, -0x260(%rbp)
movl $0x8, %edi
movl $0x10, %esi
callq 0xbc20
movl %eax, -0x258(%rbp)
jmp 0xa7b3
movl -0x258(%rbp), %edx
movq -0x260(%rbp), %rsi
leaq -0x248(%rbp), %rdi
callq 0x20e0
jmp 0xa7ce
leaq -0x248(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2060
jmp 0xa7e0
jmp 0xa7e2
movq -0x248(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x248(%rbp,%rax), %rdi
callq 0x21f0
movb %al, -0x261(%rbp)
jmp 0xa802
movb -0x261(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xa810
jmp 0xa861
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq -0x248(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2060
jmp 0xa82b
jmp 0xa7e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
jmp 0xa89c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x250(%rbp)
movl %eax, -0x254(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x2070
jmp 0xa89c
leaq -0x248(%rbp), %rdi
callq 0x2050
jmp 0xa86f
movl -0x14(%rbp), %eax
movl %eax, -0x268(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x2070
leaq -0x38(%rbp), %rdi
callq 0x20a0
movl -0x268(%rbp), %eax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x20a0
movq -0x250(%rbp), %rdi
callq 0x21d0
nopw %cs:(%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::getLine[abi:cxx11](int) const
const string CPUProgramDyn::getLine(int line) const
{

    if(line >= numberOfLines || line < 0){
            cout << "Error: Overflow fileString." << endl
                 << "Returned empty string" << endl;

            string empty;

            return empty;
        }

    return fileString[line];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0xa8f3
cmpl $0x0, -0x14(%rbp)
jge 0xa955
movq 0x56d6(%rip), %rdi      # 0xffd0
leaq 0x292e(%rip), %rsi      # 0xd22f
callq 0x20f0
movq %rax, %rdi
movq 0x56b0(%rip), %rsi      # 0xffc0
callq 0x2100
movq %rax, %rdi
leaq 0x292c(%rip), %rsi      # 0xd24b
callq 0x20f0
movq %rax, %rdi
movq 0x5692(%rip), %rsi      # 0xffc0
callq 0x2100
movq -0x30(%rbp), %rdi
movb $0x0, -0x15(%rbp)
callq 0x2190
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xa953
movq -0x30(%rbp), %rdi
callq 0x20a0
jmp 0xa971
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x2090
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator--()
const CPUProgramDyn CPUProgramDyn::operator--()
{
    CPUProgramDyn temp;
    temp = *this;
    delete [] fileString;
    --numberOfLines;
    fileString = new string[numberOfLines];
    for(int i = 0; i < numberOfLines; ++i)
    {
        fileString[i] = temp.fileString[i];
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0xb8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0xa1f0
jmp 0xa9dd
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0xac30
jmp 0xa9f3
leaq -0x70(%rbp), %rdi
callq 0xa6d0
leaq -0xa0(%rbp), %rdi
callq 0xa6d0
movq -0xb8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd0(%rbp)
cmpq $0x0, %rax
je 0xaa8c
movq -0xd0(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0xe0(%rbp)
movq -0x8(%rcx), %rdx
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0xd8(%rbp)
je 0xaa80
movq -0xd8(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0xe8(%rbp)
callq 0x20a0
movq -0xd0(%rbp), %rcx
movq -0xe8(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xd8(%rbp)
jne 0xaa4f
movq -0xe0(%rbp), %rdi
callq 0x2160
movq -0xb8(%rbp), %rax
movl (%rax), %ecx
decl %ecx
movl %ecx, (%rax)
movslq (%rax), %rax
movq %rax, -0xf8(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
movq $-0x1, %rax
cmovbq %rax, %rdi
testb %cl, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, -0xf0(%rbp)
jmp 0xaad4
movq -0xf8(%rbp), %rax
movq -0xf0(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x100(%rbp)
cmpq $0x0, %rax
je 0xab4d
movq -0x100(%rbp), %rax
movq -0xf8(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x110(%rbp)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x2190
movq -0x118(%rbp), %rax
movq -0x110(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x108(%rbp)
jne 0xab1c
movq -0xb8(%rbp), %rax
movq -0x100(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0xb0(%rbp)
movq -0xb8(%rbp), %rcx
movl -0xb0(%rbp), %eax
cmpl (%rcx), %eax
jge 0xabe8
movq -0xb8(%rbp), %rcx
movq -0x38(%rbp), %rsi
movslq -0xb0(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq 0x8(%rcx), %rdi
addq %rax, %rdi
callq 0x2040
jmp 0xaba1
jmp 0xaba3
movl -0xb0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb0(%rbp)
jmp 0xab69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xac16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xa6d0
jmp 0xac16
movq -0xb8(%rbp), %rsi
movq -0xc8(%rbp), %rdi
callq 0xa1f0
jmp 0xabfd
leaq -0x40(%rbp), %rdi
callq 0xa6d0
movq -0xc0(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0xa6d0
movq -0xa8(%rbp), %rdi
callq 0x21d0
nopl (%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator=(CPUProgramDyn)
CPUProgramDyn CPUProgramDyn::operator = (CPUProgramDyn rSide)
{
    if(rSide.numberOfLines != numberOfLines)
    {
        delete [] fileString;
        fileString = new string[rSide.numberOfLines];
        numberOfLines = rSide.numberOfLines;
    }
    for(int i = 0; i < rSide.numberOfLines; ++i)
    {
        fileString[i] = rSide.fileString[i];
    }

    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl (%rdx), %eax
cmpl (%rcx), %eax
je 0xad6e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xaccb
movq -0x48(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rcx), %rdx
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x50(%rbp)
je 0xacc2
movq -0x50(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x60(%rbp)
callq 0x20a0
movq -0x48(%rbp), %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0xaca0
movq -0x58(%rbp), %rdi
callq 0x2160
movq -0x40(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x70(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x68(%rbp)
cmpq $0x0, %rax
je 0xad5a
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x80(%rbp)
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2190
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x78(%rbp)
jne 0xad32
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq -0x68(%rbp), %rdx
movq %rdx, 0x8(%rax)
movl (%rcx), %ecx
movl %ecx, (%rax)
movl $0x0, -0x1c(%rbp)
movq -0x40(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jge 0xadb6
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rsi
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rsi
movq 0x8(%rax), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x2040
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xad75
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0xa1f0
movq -0x30(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator--(int)
const CPUProgramDyn CPUProgramDyn::operator--(int)
{
    CPUProgramDyn newObj;
    newObj = *this;
    delete [] fileString;
    --numberOfLines;
    fileString = new string[numberOfLines];
    for(int i = 0; i < numberOfLines; ++i)
    {
        fileString[i] = newObj.fileString[i];
    }

    return newObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x9ff0
movq -0x90(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xa1f0
jmp 0xae1d
movq -0xa0(%rbp), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0xac30
jmp 0xae33
leaq -0x48(%rbp), %rdi
callq 0xa6d0
leaq -0x78(%rbp), %rdi
callq 0xa6d0
movq -0x90(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0xaec9
movq -0xa8(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0xb8(%rbp)
movq -0x8(%rcx), %rdx
shlq $0x5, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0xb0(%rbp)
je 0xaebd
movq -0xb0(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0xc0(%rbp)
callq 0x20a0
movq -0xa8(%rbp), %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xb0(%rbp)
jne 0xae8c
movq -0xb8(%rbp), %rdi
callq 0x2160
movq -0x90(%rbp), %rax
movl (%rax), %ecx
decl %ecx
movl %ecx, (%rax)
movslq (%rax), %rax
movq %rax, -0xd0(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
movq $-0x1, %rax
cmovbq %rax, %rdi
testb %cl, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, -0xc8(%rbp)
jmp 0xaf11
movq -0xd0(%rbp), %rax
movq -0xc8(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0xd8(%rbp)
cmpq $0x0, %rax
je 0xaf8a
movq -0xd8(%rbp), %rax
movq -0xd0(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0xe8(%rbp)
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x2190
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0xe0(%rbp)
jne 0xaf59
movq -0x90(%rbp), %rax
movq -0xd8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x88(%rbp)
movq -0x90(%rbp), %rcx
movl -0x88(%rbp), %eax
cmpl (%rcx), %eax
jge 0xb023
movq -0x90(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x88(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq 0x8(%rcx), %rdi
addq %rax, %rdi
callq 0x2040
jmp 0xafe5
jmp 0xafe7
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0xafa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xb049
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xa6d0
jmp 0xb049
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xb039
movq -0xa0(%rbp), %rdi
callq 0xa6d0
movq -0x98(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0xa6d0
movq -0x80(%rbp), %rdi
callq 0x21d0
nop
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator[][abi:cxx11](int)
string& CPUProgramDyn::operator[](int line)
{
    if(line >= numberOfLines || line < 0){
        cout << "Error: Overflow fileString." << endl
             << "Returned empty string" << endl;

        return empty;
    }

    return fileString[line];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jge 0xb3f4
cmpl $0x0, -0x14(%rbp)
jge 0xb442
movq 0x4bd5(%rip), %rdi      # 0xffd0
leaq 0x1e2d(%rip), %rsi      # 0xd22f
callq 0x20f0
movq %rax, %rdi
movq 0x4baf(%rip), %rsi      # 0xffc0
callq 0x2100
movq %rax, %rdi
leaq 0x1e2b(%rip), %rsi      # 0xd24b
callq 0x20f0
movq %rax, %rdi
movq 0x4b91(%rip), %rsi      # 0xffc0
callq 0x2100
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0xb459
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator+(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
CPUProgramDyn CPUProgramDyn::operator+(const string instraction) const
{
    CPUProgramDyn newObj;
    newObj = *this;
    newObj+= instraction;
    return newObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0x100(%rbp)
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x9ff0
movq -0xe8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0xa1f0
jmp 0xb4c5
movq -0xf8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0xac30
jmp 0xb4db
leaq -0x50(%rbp), %rdi
callq 0xa6d0
leaq -0x80(%rbp), %rdi
callq 0xa6d0
movq -0x100(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
callq 0x2090
jmp 0xb502
movq -0xf8(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
callq 0xb060
jmp 0xb51e
leaq -0xc0(%rbp), %rdi
callq 0xa6d0
leaq -0xe0(%rbp), %rdi
callq 0x20a0
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xb59f
jmp 0xb593
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xb5af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xa6d0
jmp 0xb5af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x20a0
jmp 0xb5af
movq -0xf8(%rbp), %rdi
callq 0xa6d0
movq -0xf0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0xa6d0
movq -0x88(%rbp), %rdi
callq 0x21d0
nopw (%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator+(CPUProgramDyn&) const
CPUProgramDyn CPUProgramDyn::operator+(CPUProgramDyn& rSide) const
{
    CPUProgramDyn newObj;
    newObj = *this;
    for(int i = 0; i < rSide.size(); ++i)
    {
        newObj += rSide.getLine(i);
    }

    return newObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x9ff0
movq -0xe8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0xa1f0
jmp 0xb61e
movq -0xf8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0xac30
jmp 0xb634
leaq -0x50(%rbp), %rdi
callq 0xa6d0
leaq -0x80(%rbp), %rdi
callq 0xa6d0
movl $0x0, -0x90(%rbp)
movl -0x90(%rbp), %eax
movl %eax, -0xfc(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa980
movl %eax, %ecx
movl -0xfc(%rbp), %eax
cmpl %ecx, %eax
jge 0xb726
movq -0x18(%rbp), %rsi
movl -0x90(%rbp), %edx
leaq -0xe0(%rbp), %rdi
callq 0xa8c0
jmp 0xb68d
movq -0xf8(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
callq 0xb060
jmp 0xb6a9
leaq -0xc0(%rbp), %rdi
callq 0xa6d0
leaq -0xe0(%rbp), %rdi
callq 0x20a0
movl -0x90(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x90(%rbp)
jmp 0xb650
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xb74c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xa6d0
jmp 0xb74c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x20a0
jmp 0xb74c
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xb73c
movq -0xf8(%rbp), %rdi
callq 0xa6d0
movq -0xf0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0xa6d0
movq -0x88(%rbp), %rdi
callq 0x21d0
nopw %cs:(%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator()(int, int) const
const CPUProgramDyn CPUProgramDyn::operator()(int start, int end) const
{
    CPUProgramDyn newObj, emptyObj;

    if(start > size()-1 || end > size()-1){
        cout << "Error: Overflow fileString." << endl;

        return emptyObj;
    }

    for(int i = start; i <= end; ++i)
    {
        newObj += this->getLine(i);
    }

    return newObj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9ff0
leaq -0x78(%rbp), %rdi
callq 0x9ff0
jmp 0xb7b9
movq -0xe8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0xfc(%rbp)
callq 0xa980
movl %eax, %ecx
movl -0xfc(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0xb801
movq -0xe8(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x100(%rbp)
callq 0xa980
movl %eax, %ecx
movl -0x100(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0xb87b
movq 0x47c8(%rip), %rdi      # 0xffd0
leaq 0x1a20(%rip), %rsi      # 0xd22f
callq 0x20f0
movq %rax, -0x108(%rbp)
jmp 0xb81d
movq -0x108(%rbp), %rdi
movq 0x4795(%rip), %rsi      # 0xffc0
callq 0x2100
jmp 0xb832
movq -0xf8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xa1f0
jmp 0xb844
movl $0x1, -0x88(%rbp)
jmp 0xb925
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xb950
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xb947
movl -0x14(%rbp), %eax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0xb909
movq -0xe8(%rbp), %rsi
movl -0x8c(%rbp), %edx
leaq -0xe0(%rbp), %rdi
callq 0xa8c0
jmp 0xb8aa
leaq -0xc0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0xb060
jmp 0xb8c3
leaq -0xc0(%rbp), %rdi
callq 0xa6d0
leaq -0xe0(%rbp), %rdi
callq 0x20a0
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0xb884
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x20a0
jmp 0xb947
movq -0xf8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xa1f0
jmp 0xb91b
movl $0x1, -0x88(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xa6d0
leaq -0x48(%rbp), %rdi
callq 0xa6d0
movq -0xf0(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x78(%rbp), %rdi
callq 0xa6d0
leaq -0x48(%rbp), %rdi
callq 0xa6d0
movq -0x80(%rbp), %rdi
callq 0x21d0
nopw %cs:(%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator==(CPUProgramDyn) const
const bool CPUProgramDyn::operator==(CPUProgramDyn rSide)const
{
    bool result = false;

    if (size() == rSide.size())
        result = true;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0xa980
movq -0x20(%rbp), %rdi
movl %eax, -0x18(%rbp)
callq 0xa980
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jne 0xb9aa
movb $0x1, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator<(CPUProgramDyn) const
const bool CPUProgramDyn::operator<(CPUProgramDyn rSide)const
{
    bool result = false;

    if(size() < rSide.size())
        result = true;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0xa980
movq -0x20(%rbp), %rdi
movl %eax, -0x18(%rbp)
callq 0xa980
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jge 0xba4a
movb $0x1, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: CPUProgramDyn::operator<=(CPUProgramDyn) const
const bool CPUProgramDyn::operator<=(CPUProgramDyn rSide)const
{
    bool result = false;

    if(size() <= rSide.size())
        result = true;

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0xa980
movq -0x20(%rbp), %rdi
movl %eax, -0x18(%rbp)
callq 0xa980
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jg 0xba9a
movb $0x1, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: salihbektas[P]Simple-CPU-emulator/CPUProgramDyn.cpp
// Function: operator<<(std::ostream&, CPUProgramDyn const&)
ostream& operator << (ostream& out, const CPUProgramDyn& myProg)
{
    for(int i = 0; i < myProg.size(); ++i)
    {
        out << myProg.getLine(i);

        if(i != myProg.size()-1)
            out << endl;
    }
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa980
movl %eax, %ecx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
jge 0xbc0b
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xa8c0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x20d0
jmp 0xbbae
leaq -0x38(%rbp), %rdi
callq 0x20a0
movl -0x14(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa980
movl %eax, %ecx
movl -0x5c(%rbp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
je 0xbbfb
movq -0x8(%rbp), %rdi
movq 0x43e3(%rip), %rsi      # 0xffc0
callq 0x2100
jmp 0xbbfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20a0
jmp 0xbc15
jmp 0xbbfd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbb67
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x21d0
nop
// File: salihbektas[P]Simple-CPU-emulator/computer.cpp
// Function: Computer::Computer(CPU, CPUProgramDyn, Memory, int)
Computer::Computer(CPU oCpu, CPUProgramDyn oCpuProgram, Memory oMemory, int option)
{
    setCPU(oCpu);
    setCPUProgram(oCpuProgram);
    setMemory(oMemory);
    debug = option;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rsi, -0x160(%rbp)
leaq 0x30(%rbp), %rax
movq %rax, -0x158(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x28a0
movq -0x140(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x148(%rbp)
callq 0x9ff0
movq -0x140(%rbp), %rdi
addq $0x50, %rdi
callq 0x2730
jmp 0xbcdc
movq -0x140(%rbp), %rdi
movq -0x150(%rbp), %rax
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, -0x34(%rbp)
movaps %xmm0, -0x40(%rbp)
movups -0x34(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, 0xc(%rax)
movaps -0x40(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0xbdd0
jmp 0xbd12
movq -0x160(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0xa1f0
jmp 0xbd24
movq -0x140(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xbe00
jmp 0xbd36
leaq -0x70(%rbp), %rdi
callq 0xa6d0
movq -0x158(%rbp), %rsi
leaq -0x138(%rbp), %rdi
movq %rdi, -0x168(%rbp)
movl $0xc8, %edx
callq 0x20b0
movq -0x168(%rbp), %rsi
movq %rsp, %rdi
movl $0x19, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq -0x140(%rbp), %rdi
callq 0xbe90
jmp 0xbd7e
movq -0x140(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x118(%rax)
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xbdba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa6d0
movq -0x148(%rbp), %rdi
callq 0xa6d0
movq -0x20(%rbp), %rdi
callq 0x21d0
nop
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_04.cc
// Function: _gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>> find<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, int>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>, int const&)
InputIt find(InputIt first, InputIt last, const T& value)
{
	for (; first != last; ++first)
		if (*first == value)
			return first;
	return first;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1990
testb $0x1, %al
jne 0x18e7
jmp 0x1911
leaq -0x10(%rbp), %rdi
callq 0x2730
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1904
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1919
jmp 0x1906
leaq -0x10(%rbp), %rdi
callq 0x2750
jmp 0x18d4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: snuke[P]a/src/a.cc
// Function: main
int main(int argc, char** argv) {
  if (argc != 2) {
    std::cerr << "Usage : " << argv[0] << " SOURCE_FILE" << std::endl;
    return 0;
  }
  std::string code;
  ReadCode(argv[1], &code);
  Interpreter interpreter;
  interpreter.Run(code, &std::cin, &std::cout);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x5f0, %rsp            # imm = 0x5F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x36cb
movq 0x1296a(%rip), %rdi     # 0x15ff0
leaq 0xb977(%rip), %rsi      # 0xf004
callq 0x3230
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3230
movq %rax, %rdi
leaq 0xb962(%rip), %rsi      # 0xf00d
callq 0x3230
movq %rax, %rdi
movq 0x128fe(%rip), %rsi     # 0x15fb8
callq 0x3270
movl $0x0, -0x4(%rbp)
jmp 0x376e
leaq -0x30(%rbp), %rdi
movq %rdi, -0x5e8(%rbp)
callq 0x3360
movq -0x5e8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3790
jmp 0x36f1
leaq -0x5e0(%rbp), %rdi
callq 0x3950
jmp 0x36ff
movq 0x128d2(%rip), %rdx     # 0x15fd8
movq 0x128bb(%rip), %rcx     # 0x15fc8
leaq -0x5e0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4130
jmp 0x371f
movl $0x0, -0x4(%rbp)
leaq -0x5e0(%rbp), %rdi
callq 0x3990
leaq -0x30(%rbp), %rdi
callq 0x3140
jmp 0x376e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3763
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x5e0(%rbp), %rdi
callq 0x3990
leaq -0x30(%rbp), %rdi
callq 0x3140
jmp 0x377a
movl -0x4(%rbp), %eax
addq $0x5f0, %rsp            # imm = 0x5F0
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: snuke[P]a/src/a.cc
// Function: ReadCode(char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void ReadCode(char* filename, std::string* result) {
  std::ifstream ifs(filename);
  if (ifs.fail()) {
    std::cerr << "Error : SOURCE_FILE not found" << std::endl;
    exit(0);
  }
  std::string str;
  while (std::getline(ifs, str)) result->append(str + '\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x33f0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x269(%rbp)
jmp 0x37d8
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x37e4
jmp 0x3833
movq 0x12805(%rip), %rdi     # 0x15ff0
leaq 0xb828(%rip), %rsi      # 0xf01a
callq 0x3230
movq %rax, -0x278(%rbp)
jmp 0x3800
movq -0x278(%rbp), %rdi
movq 0x127aa(%rip), %rsi     # 0x15fb8
callq 0x3270
jmp 0x3815
xorl %edi, %edi
callq 0x32e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x3931
leaq -0x248(%rbp), %rdi
callq 0x3360
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x3060
movq %rax, -0x280(%rbp)
jmp 0x385b
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3300
movb %al, -0x281(%rbp)
jmp 0x3879
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x3885
jmp 0x3904
movq -0x10(%rbp), %rax
movq %rax, -0x290(%rbp)
leaq -0x268(%rbp), %rdi
leaq -0x248(%rbp), %rsi
movl $0xa, %edx
callq 0x39d0
jmp 0x38aa
movq -0x290(%rbp), %rdi
leaq -0x268(%rbp), %rsi
callq 0x3410
jmp 0x38bf
leaq -0x268(%rbp), %rdi
callq 0x3140
jmp 0x383f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x3925
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x268(%rbp), %rdi
callq 0x3140
jmp 0x3925
leaq -0x248(%rbp), %rdi
callq 0x3140
leaq -0x218(%rbp), %rdi
callq 0x3080
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x248(%rbp), %rdi
callq 0x3140
leaq -0x218(%rbp), %rdi
callq 0x3080
movq -0x220(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: snuke[P]a/src/interpreter.cc
// Function: Interpreter::Data::operator<(Interpreter::Data const&) const
bool Interpreter::Data::operator<(const Data& x) const {
  if (type == NONE || x.type == NONE) return false;
  if (type == INT) {
    if (x.type == INT) return Int() < x.Int();
    else return Int() < x.Float() + EPS;
  } else if (type == FLOAT) {
    if (x.type == INT) return Float() < x.Int() + EPS;
    else return Float() < x.Float() + EPS;
  } else if (type == ARRAY) return Array() < x.Array();
  else return Str() < x.Str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, (%rax)
je 0x3da6
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x3daf
movb $0x0, -0x1(%rbp)
jmp 0x3f16
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x3e2f
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x3df1
movq -0x20(%rbp), %rdi
callq 0x6430
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6430
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq (%rcx), %rax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3f16
movq -0x20(%rbp), %rdi
callq 0x6430
cvtsi2sdq (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6460
movsd -0x30(%rbp), %xmm1
movsd (%rax), %xmm0
addsd 0xb23a(%rip), %xmm0     # 0xf058
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3f16
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x3ebd
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x3e83
movq -0x20(%rbp), %rdi
callq 0x6460
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6430
movsd -0x38(%rbp), %xmm1
cvtsi2sdq (%rax), %xmm0
addsd 0xb1e6(%rip), %xmm0     # 0xf058
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3f16
movq -0x20(%rbp), %rdi
callq 0x6460
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6460
movsd -0x40(%rbp), %xmm1
movsd (%rax), %xmm0
addsd 0xb1a9(%rip), %xmm0     # 0xf058
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3f16
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x3eef
movq -0x20(%rbp), %rdi
callq 0x6500
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6500
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x6490
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3f16
movq -0x20(%rbp), %rdi
callq 0x6570
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6570
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x6530
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: snuke[P]a/src/interpreter.cc
// Function: Interpreter::Data::operator==(Interpreter::Data const&) const
bool Interpreter::Data::operator==(const Data& x) const {
  if (type == NONE && x.type == NONE) return true;
  if (type == NONE || x.type == NONE) return false;
  if (type == INT) {
    if (x.type == INT) return Int() == x.Int();
    else return abs(Int() - x.Float()) < EPS;
  } else if (type == FLOAT) {
    if (x.type == INT) return abs(Float() - x.Int()) < EPS;
    else return abs(Float() - x.Float()) < EPS;
  } else if (type == ARRAY) return Array() == x.Array();
  else return Str() == x.Str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, (%rax)
jne 0x3f5f
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x3f5f
movb $0x1, -0x1(%rbp)
jmp 0x4116
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3f71
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x3f7a
movb $0x0, -0x1(%rbp)
jmp 0x4116
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x400d
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x3fc0
movq -0x20(%rbp), %rdi
callq 0x6430
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6430
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4116
movq -0x20(%rbp), %rdi
callq 0x6430
cvtsi2sdq (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6460
movsd -0x30(%rbp), %xmm0
subsd (%rax), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cvtsi2sd %eax, %xmm1
movsd 0xb05c(%rip), %xmm0     # 0xf058
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4116
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x40bd
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x4074
movq -0x20(%rbp), %rdi
callq 0x6460
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6430
movsd -0x38(%rbp), %xmm0
cvtsi2sdq (%rax), %xmm1
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cvtsi2sd %eax, %xmm1
movsd 0xaff5(%rip), %xmm0     # 0xf058
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4116
movq -0x20(%rbp), %rdi
callq 0x6460
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6460
movsd -0x40(%rbp), %xmm0
subsd (%rax), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cvtsi2sd %eax, %xmm1
movsd 0xafa9(%rip), %xmm0     # 0xf058
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4116
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x40ef
movq -0x20(%rbp), %rdi
callq 0x6500
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6500
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x65a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4116
movq -0x20(%rbp), %rdi
callq 0x6570
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6570
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x6620
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: snuke[P]a/src/interpreter.cc
// Function: Interpreter::Run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::istream*, std::ostream*)
void Interpreter::Run(const std::string& code,
                            std::istream* input,
                            std::ostream* output) {
  input_ = input;
  output_ = output;
  InitVars();
  State cur = code.begin();
  while (*cur != '\0') Expr(cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x8(%rdi)
callq 0x41a0
movq -0x10(%rbp), %rdi
callq 0x3210
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x66b0
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x4195
movq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4360
movq %rax, -0x30(%rbp)
jmp 0x4171
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: snuke[P]a/src/interpreter.cc
// Function: Interpreter::InitVars()
void Interpreter::InitVars() {
  pool_int_.reserve(MAX_POOL_INT);
  pool_float_.reserve(MAX_POOL_FLOAT);
  pool_str_.reserve(MAX_POOL_STR);
  pool_array_.reserve(MAX_POOL_ARRAY);
  vars_ = std::vector<Data>(256);
  std::string defs = "AFILMOPRSTUVW0123456789?!~-+*/%&|^{}<>=#:";
  for (int i = 0; i < (int)defs.size(); ++i) vars_[defs[i]].type = DEF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq 0x12082(%rip), %rdi     # 0x16240
movl $0x989680, %esi         # imm = 0x989680
callq 0x68d0
leaq 0x12089(%rip), %rdi     # 0x16258
movl $0xf4240, %esi          # imm = 0xF4240
movq %rsi, -0x70(%rbp)
callq 0x69d0
movq -0x70(%rbp), %rsi
leaq 0x12088(%rip), %rdi     # 0x16270
callq 0x6ad0
movq -0x70(%rbp), %rsi
leaq 0x12090(%rip), %rdi     # 0x16288
callq 0x6bd0
leaq -0x21(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3ac0
movq -0x68(%rbp), %rdx
leaq -0x20(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x6cd0
jmp 0x421e
movq -0x78(%rbp), %rdi
addq $0x188, %rdi            # imm = 0x188
leaq -0x20(%rbp), %rsi
movq %rsi, -0x88(%rbp)
callq 0x6d40
movq -0x88(%rbp), %rdi
callq 0x3b20
leaq -0x21(%rbp), %rdi
callq 0x3d10
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x33d0
movq -0x80(%rbp), %rdx
leaq 0xadfa(%rip), %rsi      # 0xf060
leaq -0x58(%rbp), %rdi
callq 0x6d70
jmp 0x4271
leaq -0x59(%rbp), %rdi
callq 0x32a0
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3170
movq %rax, %rcx
movl -0x8c(%rbp), %eax
cmpl %ecx, %eax
jge 0x4338
movq -0x78(%rbp), %rax
addq $0x188, %rax            # imm = 0x188
movq %rax, -0xa0(%rbp)
movslq -0x60(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x3430
movq %rax, -0x98(%rbp)
jmp 0x42cb
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rax
movsbq (%rax), %rsi
callq 0x6e20
movl $0x1, (%rax)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x4281
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x3d10
jmp 0x434a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x32a0
jmp 0x434a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3140
jmp 0x434a
leaq -0x58(%rbp), %rdi
callq 0x3140
addq $0xa0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: snuke[P]a/src/interpreter.cc
// Function: Interpreter::Expr(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&)
Interpreter::Data Interpreter::Expr(State& cur) {
  while (vars_[*cur].type == NONE) {
    if (*cur == '\0') return Data();
    ++cur;
  }
  if (vars_[*cur].type == DEF && *cur != 'V') return Defined(cur);
  return Var(cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x188, %rax            # imm = 0x188
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x66b0
movq -0x28(%rbp), %rdi
movsbq (%rax), %rsi
callq 0x6e20
cmpl $0x0, (%rax)
jne 0x43c8
movq -0x18(%rbp), %rdi
callq 0x66b0
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x43bd
leaq -0x8(%rbp), %rdi
callq 0x3d40
jmp 0x4429
movq -0x18(%rbp), %rdi
callq 0x7090
jmp 0x4378
movq -0x20(%rbp), %rax
addq $0x188, %rax            # imm = 0x188
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x66b0
movq -0x30(%rbp), %rdi
movsbq (%rax), %rsi
callq 0x6e20
cmpl $0x1, (%rax)
jne 0x4415
movq -0x18(%rbp), %rdi
callq 0x66b0
movsbl (%rax), %eax
cmpl $0x56, %eax
je 0x4415
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4580
movq %rax, -0x8(%rbp)
jmp 0x4429
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4800
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: snuke[P]a/src/interpreter.cc
// Function: Interpreter::Var(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&)
Interpreter::Data& Interpreter::Var(State& cur) {
  if(*cur == 'V' && vars_['V'].type == DEF) {
    ++cur;
    char name = *cur; ++cur;
    return Vector(cur, vars_[name]);
  } else {
    Data& res = vars_[*cur];
    ++cur;
    return res;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x66b0
movsbl (%rax), %eax
cmpl $0x56, %eax
jne 0x4896
movq -0x30(%rbp), %rdi
addq $0x188, %rdi            # imm = 0x188
movl $0x56, %esi
callq 0x6e20
cmpl $0x1, (%rax)
jne 0x4896
movq -0x18(%rbp), %rdi
callq 0x7090
movq -0x18(%rbp), %rdi
callq 0x66b0
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7090
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x188, %rdi            # imm = 0x188
movsbq -0x19(%rbp), %rsi
callq 0x6e20
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x48e0
movq %rax, -0x8(%rbp)
jmp 0x48cf
movq -0x30(%rbp), %rax
addq $0x188, %rax            # imm = 0x188
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x66b0
movq -0x40(%rbp), %rdi
movsbq (%rax), %rsi
callq 0x6e20
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7090
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: snuke[P]a/src/interpreter.cc
// Function: Interpreter::Vector(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, Interpreter::Data&)
Interpreter::Data& Interpreter::Vector(State& cur, Data& x) {
  if (*cur == ':') {
    ++cur;
    return x;
  }
  int i = Expr(cur).Int();
  if (x.type != ARRAY) {
    x = NewArray(std::vector<Data>());
  }
  std::vector<Data>& v = x.Array();
  if ((int)v.size() <= i) v.resize(i+1);
  return Vector(cur, v[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x66b0
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x4926
movq -0x18(%rbp), %rdi
callq 0x7090
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a0f
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4360
movq %rax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0x6430
movq (%rax), %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
je 0x49b3
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3a50
movq -0x70(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x4530
movq %rax, -0x78(%rbp)
jmp 0x497e
movq -0x78(%rbp), %rax
movq %rax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq -0x34(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x3b20
jmp 0x49b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3b20
jmp 0x4a1c
movq -0x20(%rbp), %rdi
callq 0x6500
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x70b0
cmpl -0x24(%rbp), %eax
jg 0x49e0
movq -0x68(%rbp), %rdi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x70d0
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x68(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x6e20
movq -0x70(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
callq 0x48e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x33c0
nopw %cs:(%rax,%rax)
// File: snuke[P]a/src/interpreter.cc
// Function: Interpreter::Assign(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&)
Interpreter::Data Interpreter::Assign(State& cur) {
  ++cur;
  Data& x = Var(cur);
  x = Expr(cur);
  return x;
}

// 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
callq 0x7090
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4800
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4360
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)