LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::getElementType(long&)
__attribute__((always_inline)) int QueryProcessor::getElementType(long& pos) {
    while (mRecord[pos] == ' ') ++pos;
    if (mRecord[pos] == '{') return OBJECT;
    if (mRecord[pos] == '[') return ARRAY;
    return PRIMITIVE;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x23732
movq -0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x23704
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7b, %eax
jne 0x23759
movl $0x65, -0x4(%rsp)
jmp 0x23788
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5b, %eax
jne 0x23780
movl $0x66, -0x4(%rsp)
jmp 0x23788
movl $0x67, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::getAttributeType(long&)
__attribute__((always_inline)) int QueryProcessor::getAttributeType(long& pos) {
    while (mRecord[pos] == ' ') ++pos;
    if (mRecord[pos] == '{') return OBJECT;
    if (mRecord[pos] == '[') return ARRAY;
    return PRIMITIVE;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x291a2
movq -0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x29174
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7b, %eax
jne 0x291c9
movl $0x65, -0x4(%rsp)
jmp 0x291f8
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5b, %eax
jne 0x291f0
movl $0x66, -0x4(%rsp)
jmp 0x291f8
movl $0x67, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::hasMoreAttributes(long&)
__attribute__((always_inline)) bool QueryProcessor::hasMoreAttributes(long& pos) {
    // if current character is blank, skip this character until meeting a non-blank character
    while (mRecord[pos] == ' ') ++pos;
    ++pos;
    while (mRecord[pos] == ' ') {
        ++pos;
    }
    if (mRecord[pos] == '}') {
        return false;
    }
    if (mRecord[pos] == ',') ++pos;
    while (mRecord[pos] == ' ' || mRecord[pos] == '\n') ++pos; 
    return true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x29242
movq -0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x29214
movq -0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x2927f
movq -0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x29251
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7d, %eax
jne 0x292a6
movb $0x0, -0x1(%rsp)
jmp 0x29339
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
jne 0x292d2
movq -0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x292d4
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x21(%rsp)
je 0x29319
movq -0x20(%rsp), %rax
movq 0x2c8(%rax), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
testb $0x1, %al
jne 0x29323
jmp 0x29334
movq -0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x292d4
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
// File: AutomataLab[P]JSONSki/src/QueryProcessor.cpp
// Function: QueryProcessor::runQuery[abi:cxx11](Record*)
string QueryProcessor::runQuery(Record* rec) {
    setRecordText(rec->text + rec->rec_start_pos, rec->rec_length);
    init();
    long cur_pos = 0;
    char ch = getNextNonEmptyCharacter(cur_pos);
    bitmap bm;
    if (ch == '{' && qa.typeExpectedInObj() != NONE)
        object(cur_pos, bm);
    else if(ch == '[' && qa.typeExpectedInArr() != NONE)
        array(cur_pos, bm);
    return mOutput;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x78(%rsp), %rax
movq (%rax), %rsi
movq 0x78(%rsp), %rax
addq 0x8(%rax), %rsi
movq 0x78(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x18b20
movq 0x28(%rsp), %rdi
callq 0x16c10
movq 0x28(%rsp), %rdi
movq $0x0, 0x70(%rsp)
leaq 0x70(%rsp), %rsi
callq 0x62150
movb %al, 0x6f(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x625e0
movsbl 0x6f(%rsp), %eax
cmpl $0x7b, %eax
jne 0x622f9
movq 0x28(%rsp), %rax
addq $0x6e0, %rax            # imm = 0x6E0
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, (%rax)
jne 0x622a5
movl $0x0, 0xa0(%rsp)
jmp 0x622d6
movq 0x10(%rsp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x94(%rsp)
addq $0x4, %rax
movslq 0x94(%rsp), %rcx
imulq $0x49c, %rcx, %rcx      # imm = 0x49C
addq %rcx, %rax
movl 0x68(%rax), %eax
movl %eax, 0xa0(%rsp)
cmpl $0x6c, 0xa0(%rsp)
je 0x622f9
movq 0x28(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x3ccc0
jmp 0x6238a
movsbl 0x6f(%rsp), %eax
cmpl $0x5b, %eax
jne 0x62388
movq 0x28(%rsp), %rax
addq $0x6e0, %rax            # imm = 0x6E0
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, (%rax)
jne 0x62339
movl $0x0, 0xb4(%rsp)
jmp 0x6236a
movq 0x8(%rsp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0xa4(%rsp)
addq $0x4, %rax
movslq 0xa4(%rsp), %rcx
imulq $0x49c, %rcx, %rcx      # imm = 0x49C
addq %rcx, %rax
movl 0x6c(%rax), %eax
movl %eax, 0xb4(%rsp)
cmpl $0x6c, 0xb4(%rsp)
je 0x62388
movq 0x28(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x4a510
jmp 0x6238a
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0xef00, %rsi           # imm = 0xEF00
callq 0xd5660
movq 0x20(%rsp), %rax
addq $0xb8, %rsp
retq
nopl (%rax)
// File: AutomataLab[P]JSONSki/src/./lib/QueryAutomaton.h
// Function: QueryAutomaton::getIndexInfo(int)
IndexInfo getIndexInfo(int state) {
        IndexInfo idx_info;
        if (state == UNMATCHED_STATE) {
            idx_info.start_idx = -1;
            return idx_info;
        }
        idx_info.start_idx = mDfa.trans_ele[state - 1].start_idx;
        idx_info.end_idx = mDfa.trans_ele[state - 1].end_idx;    
        return idx_info;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0x0, -0x14(%rsp)
jne 0x62584
movl $0xffffffff, -0x8(%rsp) # imm = 0xFFFFFFFF
jmp 0x625d0
movq -0x20(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movl -0x14(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
imulq $0x49c, %rdx, %rdx      # imm = 0x49C
addq %rdx, %rcx
movl 0x490(%rcx), %ecx
movl %ecx, -0x8(%rsp)
addq $0x4, %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x49c, %rcx, %rcx      # imm = 0x49C
addq %rcx, %rax
movl 0x494(%rax), %eax
movl %eax, -0x4(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: AutomataLab[P]JSONSki/src/./lib/Records.h
// Function: Record::Record()
Record() {
        text = NULL;
        rec_start_pos = 0;
        rec_length = 0;
        can_delete_text = true;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movb $0x1, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
// File: AutomataLab[P]JSONSki/example/example2.cpp
// Function: main
int main() {
    char* file_path = "../dataset/bestbuy_sample_large_record.json";
    Record* rec = RecordLoader::loadSingleRecord(file_path);
    if (rec == NULL) {
        cout<<"record loading fails."<<endl;
        return -1;
    }

    QueryProcessor processor("$.products[*].categoryPath[1:3].name");
    string output = processor.runQuery(rec);
    cout<<"matches are: "<<output<<endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0xefe0, %rsp           # imm = 0xEFE0
movl $0x0, 0xefcc(%rsp)
leaq 0x9f9a6(%rip), %rax     # 0x103107
movq %rax, 0xefc0(%rsp)
movq 0xefc0(%rsp), %rdi
callq 0x62790
movq %rax, 0xefb8(%rsp)
cmpq $0x0, 0xefb8(%rsp)
jne 0x637bb
leaq 0xdacf0(%rip), %rdi     # 0x13e480
leaq 0x9f99c(%rip), %rsi     # 0x103133
callq 0xccb00
movq %rax, %rdi
leaq 0x68c3a(%rip), %rsi     # 0xcc3e0
callq 0xcb5f0
movl $0xffffffff, 0xefcc(%rsp) # imm = 0xFFFFFFFF
jmp 0x638f8
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x64930
movq 0x20(%rsp), %rdx
leaq 0x9f973(%rip), %rsi     # 0x103149
leaq 0x60(%rsp), %rdi
callq 0xd5900
jmp 0x637e2
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x16b00
jmp 0x637f6
leaq 0x60(%rsp), %rdi
callq 0xd2ed0
leaq 0x5f(%rsp), %rdi
callq 0x64950
movq 0xefb8(%rsp), %rdx
leaq 0x28(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x621e0
jmp 0x63826
leaq 0xdac53(%rip), %rdi     # 0x13e480
leaq 0x9f93a(%rip), %rsi     # 0x10316e
callq 0xccb00
movq %rax, 0x18(%rsp)
jmp 0x63840
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd59d0
movq %rax, 0x10(%rsp)
jmp 0x63856
movq 0x10(%rsp), %rdi
leaq 0x68b7e(%rip), %rsi     # 0xcc3e0
callq 0xcb5f0
jmp 0x63869
movl $0x0, 0xefcc(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd2ed0
leaq 0x80(%rsp), %rdi
callq 0x18ab0
jmp 0x638f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x638b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xd2ed0
leaq 0x5f(%rsp), %rdi
callq 0x64950
jmp 0x63904
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x638e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd2ed0
leaq 0x80(%rsp), %rdi
callq 0x18ab0
jmp 0x63904
movl 0xefcc(%rsp), %eax
movq %rbp, %rsp
popq %rbp
retq
movq 0x50(%rsp), %rdi
callq 0x13710
nop
// File: eschwabe[P]interview-practice/src/stablesort.cpp
// Function: stablesort(int*, int)
void stablesort(int array[], int length) {
    for(int idx = 0; idx < length-1; idx++) {
        int target = idx;
        for(int tidx = idx; tidx < length; tidx++) {
            if( array[target] > array[tidx] ) {
                target = tidx;
            }
        }
        std::cout << target << std::endl;
        int val = array[target];
        memmove(array+idx+1, array+idx, (target-idx)*sizeof(int));
        array[idx] = val;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x12c2
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1246
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x1239
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x123b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1213
movl -0x14(%rbp), %esi
movq 0x2d88(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %rdi
movq 0x2d69(%rip), %rsi      # 0x3fc8
callq 0x1060
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
movslq %eax, %rdx
shlq $0x2, %rdx
callq 0x1080
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11f6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: eschwabe[P]interview-practice/src/stablesort.cpp
// Function: main
int main()
{
    int array[10] = {3,4,5,23,7,21,4,7,1,87};
    for(auto a : array) {
        std::cout << a << " ";
    }
    std::cout << std::endl;
    stablesort(array, 10);
    for(auto a : array) {
        std::cout << a << " ";
    }
    std::cout << std::endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0xd26(%rip), %rsi       # 0x2010
movl $0x28, %edx
callq 0x1030
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x134f
movq -0x40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %esi
movq 0x2cab(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %rdi
leaq 0xcfc(%rip), %rsi       # 0x2038
callq 0x1050
movq -0x40(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
jmp 0x1310
movq 0x2c82(%rip), %rdi      # 0x3fd8
movq 0x2c6b(%rip), %rsi      # 0x3fc8
callq 0x1060
leaq -0x30(%rbp), %rdi
movl $0xa, %esi
callq 0x11e0
leaq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x68(%rbp), %rax
je 0x13cb
movq -0x60(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %esi
movq 0x2c2f(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %rdi
leaq 0xc80(%rip), %rsi       # 0x2038
callq 0x1050
movq -0x60(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x60(%rbp)
jmp 0x138c
movq 0x2c06(%rip), %rdi      # 0x3fd8
movq 0x2bef(%rip), %rsi      # 0x3fc8
callq 0x1060
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
// File: yaansz[P]just-a-terminal/terminal.cpp
// Function: BuiltInCommands::help(char**)
int BuiltInCommands::help(char** args) { 
    cout << "*****************" << endl; 
    cout << "List of builtins commands" << endl; 
     
     for (const auto &p : this->commands) { 
        cout << p.first << endl;
    }

    cout << "*****************" << endl; 

    return 0;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0xa751(%rip), %rdi      # 0xdfd0
leaq 0x57e7(%rip), %rsi      # 0x906d
callq 0x3210
movq %rax, %rdi
movq 0xa723(%rip), %rsi      # 0xdfb8
callq 0x3270
movq 0xa72f(%rip), %rdi      # 0xdfd0
leaq 0x5779(%rip), %rsi      # 0x9021
callq 0x3210
movq %rax, %rdi
movq 0xa701(%rip), %rsi      # 0xdfb8
callq 0x3270
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4620
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4650
testb $0x1, %al
jne 0x38f1
jmp 0x3928
leaq -0x20(%rbp), %rdi
callq 0x4680
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq 0xa6c7(%rip), %rdi      # 0xdfd0
callq 0x31f0
movq %rax, %rdi
movq 0xa6a0(%rip), %rsi      # 0xdfb8
callq 0x3270
leaq -0x20(%rbp), %rdi
callq 0x46a0
jmp 0x38de
movq 0xa6a1(%rip), %rdi      # 0xdfd0
leaq 0x5737(%rip), %rsi      # 0x906d
callq 0x3210
movq %rax, %rdi
movq 0xa673(%rip), %rsi      # 0xdfb8
callq 0x3270
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yaansz[P]just-a-terminal/terminal.cpp
// Function: execute(BuiltInCommands, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char**)
int execute(BuiltInCommands bic, const string cmd, char** args) 
{   
    int bic_return = bic.execute(cmd, args);
    // found in built in
    if(bic_return == 0) return 0;
    else if(bic_return == -1) return bic_return;

    #ifdef DEBUG
    cout << "bic_return: " << bic_return << endl;
    #endif

    pid_t pid = fork();
    
    if(pid == -1)
        cout << "Error to fork" << endl;

    // Running child proccess
    else if(pid == 0) {
        
        #ifdef DEBUG
        cout << "Path: " << std::filesystem::current_path() << endl; 
        cout << ":" << cmd.c_str() << ":" << endl;
        cout << ":" << args[1] << ":" << endl;
        #endif

        if(execvp(cmd.c_str(), args) < 0) {
            perror("error");
            cout << "Error to exec the command" << endl;
        }
        // Killing it 🤬😡😡😠
        exit(0);
    // Wait until the child process is killed
    } else {
        wait(NULL);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x30f0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3980
movl %eax, -0x5c(%rbp)
jmp 0x3a42
leaq -0x48(%rbp), %rdi
callq 0x3150
movl -0x5c(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x3a7d
movl $0x0, -0x4(%rbp)
jmp 0x3b29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3150
jmp 0x3b35
cmpl $-0x1, -0x24(%rbp)
jne 0x3a8e
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3b29
jmp 0x3a90
callq 0x3090
movl %eax, -0x58(%rbp)
cmpl $-0x1, -0x58(%rbp)
jne 0x3ac2
movq 0xa52b(%rip), %rdi      # 0xdfd0
leaq 0x558f(%rip), %rsi      # 0x903b
callq 0x3210
movq %rax, %rdi
movq 0xa4fd(%rip), %rsi      # 0xdfb8
callq 0x3270
jmp 0x3b22
cmpl $0x0, -0x58(%rbp)
jne 0x3b17
movq -0x78(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x3190
cmpl $0x0, %eax
jge 0x3b10
leaq 0x5560(%rip), %rdi      # 0x9049
callq 0x31c0
movq 0xa4db(%rip), %rdi      # 0xdfd0
leaq 0x5553(%rip), %rsi      # 0x904f
callq 0x3210
movq %rax, %rdi
movq 0xa4ad(%rip), %rsi      # 0xdfb8
callq 0x3270
xorl %edi, %edi
callq 0x32e0
xorl %eax, %eax
movl %eax, %edi
callq 0x3310
jmp 0x3b22
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33d0
nop
// File: yaansz[P]just-a-terminal/terminal.cpp
// Function: blank(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int blank(string str) {
    const char * cstr = str.c_str();
    
    for(int i = 0; i < str.length(); i++) {
        if (cstr[i] != ' ')
            return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x30e0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3370
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x3ba4
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x3b97
movl $0x0, -0x4(%rbp)
jmp 0x3bab
jmp 0x3b99
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3b60
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yaansz[P]just-a-terminal/terminal.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> split(const string& str, const string& delim)
{
    vector<string> tokens;
    size_t prev = 0, pos = 0;
    do
    {
        pos = str.find(delim, prev);
        if (pos == string::npos) pos = str.length();
        string token = str.substr(prev, pos-prev);
        if (!token.empty()) tokens.push_back(token);
        prev = pos + delim.length();
    }
    while (pos < str.length() && prev < str.length());
    return tokens;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x47e0
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3420
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
jne 0x3c24
movq -0x10(%rbp), %rdi
callq 0x3370
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
subq %rdx, %rcx
leaq -0x50(%rbp), %rdi
callq 0x3250
jmp 0x3c3e
leaq -0x50(%rbp), %rdi
callq 0x33b0
testb $0x1, %al
jne 0x3c87
movq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4800
jmp 0x3c5a
jmp 0x3c87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x3d29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
jmp 0x3d29
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3370
movq %rax, %rcx
movq -0x78(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3150
movq -0x30(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3370
movq -0x88(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x79(%rbp)
jae 0x3cfe
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3370
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x79(%rbp)
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x3bfb
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3d1c
movq -0x70(%rbp), %rdi
callq 0x4870
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x4870
movq -0x58(%rbp), %rdi
callq 0x33d0
nopl (%rax,%rax)
// File: Wheatwizard[P]Waldo/Atom.cpp
// Function: Atom::operator+(Atom&) const
Atom Atom::operator+(Atom& other) const {
	if (this->type == other.type) {
		return Atom(this->type, this->value + other.value);
	} else {
		//TODO throw an error
		throw 10; // this should stop it from generating a warning
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x2c7d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movl 0x4(%rax), %edx
movq -0x10(%rbp), %rax
addl 0x4(%rax), %edx
callq 0x28f0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movl $0x4, %edi
callq 0x20d0
movq %rax, %rdi
movl $0xa, (%rdi)
movq 0xe309(%rip), %rsi      # 0x10fa0
xorl %eax, %eax
movl %eax, %edx
callq 0x2280
// File: Wheatwizard[P]Waldo/Atom.cpp
// Function: Atom::roll(Rotation)
void Atom::roll(Rotation direction) {
	Bond bonds_copy[4];
	unsigned diff = 3;
	if (direction) {
		diff = 1;
	}
	for (unsigned i = 0; i < 4; ++i) {
		bonds_copy[(i+diff)%4] = bonds[i];
	}
	for (unsigned i = 0; i < 4; ++i) {
		bonds[i] = bonds_copy[i];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x40, %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x6a40
movq -0x80(%rbp), %rax
movq -0x70(%rbp), %rcx
addq $0x10, %rax
cmpq %rcx, %rax
movq %rax, -0x68(%rbp)
jne 0x2ccd
movl $0x3, -0x54(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x2d03
movl $0x1, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
cmpl $0x4, -0x58(%rbp)
jae 0x2d51
movq -0x78(%rbp), %rcx
addq $0x8, %rcx
movl -0x58(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rcx
movl -0x58(%rbp), %eax
addl -0x54(%rbp), %eax
andl $0x3, %eax
movl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rax
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x2d0a
movl $0x0, -0x5c(%rbp)
cmpl $0x4, -0x5c(%rbp)
jae 0x2d97
movq -0x78(%rbp), %rax
movl -0x5c(%rbp), %ecx
movl %ecx, %edx
leaq -0x50(%rbp), %rcx
shlq $0x4, %rdx
addq %rdx, %rcx
addq $0x8, %rax
movl -0x5c(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x2d58
addq $0x80, %rsp
popq %rbp
retq
// File: Wheatwizard[P]Waldo/Atom.cpp
// Function: Atom::rotate(Rotation)
void Atom::rotate(Rotation direction) {
	//I think there might be a better way to do this algorithm
	//Roll this (the root)
	roll(direction);
	for (unsigned i = 0; i < 4; ++i) {
		if (bonds[i].getAtom() //Check that there is a bond to a non-Null atom
		    &&
		    bonds[i].getAtom()->getBond((i+2)%4).getAtom() != this //Check that the other atom has not been rotated as well
		) {
			//recurse
			bonds[i].getAtom()->rotate(direction);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl -0xc(%rbp), %esi
callq 0x2ca0
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jae 0x2e58
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0x10(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x2e48
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0x10(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3250
movq %rax, %rdi
movl -0x10(%rbp), %esi
addl $0x2, %esi
andl $0x3, %esi
callq 0x3270
movq %rax, %rdi
callq 0x3250
movq -0x18(%rbp), %rcx
cmpq %rcx, %rax
je 0x2e48
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0x10(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3250
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2da0
jmp 0x2e4a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2dc6
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Wheatwizard[P]Waldo/Atom.cpp
// Function: Atom::unbond()
void Atom::unbond() {
	//Iterate through all the bonds
	for (unsigned i = 0; i < 4; ++i) {
		//Zero out the bond
		while (bonds[i].isValid()) {
			--bonds[i];
		}
		//Zero out the complement of the bond
		while (bonds[i].getAtom()->bonds[(i+2)%4].isValid()) {
			--bonds[i].getAtom()->bonds[(i+2)%4];
		}
		//Tell the conected atom to clean itself
		bonds[i].getAtom()->cleanBonds();
	}
	//Clean this atom
	this->cleanBonds();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jae 0x2fae
jmp 0x2ed7
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3290
testb $0x1, %al
jne 0x2ef4
jmp 0x2f0d
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x6b00
jmp 0x2ed7
jmp 0x2f0f
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3250
movq %rax, %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %eax
addl $0x2, %eax
andl $0x3, %eax
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3290
testb $0x1, %al
jne 0x2f4a
jmp 0x2f81
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3250
movq %rax, %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %eax
addl $0x2, %eax
andl $0x3, %eax
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x6b00
jmp 0x2f0f
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x2e60
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ecb
movq -0x18(%rbp), %rdi
callq 0x2e60
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Wheatwizard[P]Waldo/Atom.cpp
// Function: Atom::isPreferred(Atom*) const
bool Atom::isPreferred(Atom* other) const {
	if (this->creationDate == other->creationDate) {
		//If they have the same creation date and priority there is ambiguity
		assert(this->priority != other->priority);
		return this->priority < other->priority;
	}
	return this->creationDate < other->creationDate;
}

// 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)
movl 0x48(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x48(%rcx), %eax
jne 0x302d
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4c(%rcx), %eax
je 0x2ff6
jmp 0x3015
leaq 0x8087(%rip), %rdi      # 0xb084
leaq 0x80a2(%rip), %rsi      # 0xb0a6
movl $0x53, %edx
leaq 0x809f(%rip), %rcx      # 0xb0af
callq 0x2110
movq -0x20(%rbp), %rax
movl 0x4c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4c(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x3043
movq -0x20(%rbp), %rax
movl 0x48(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x48(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Wheatwizard[P]Waldo/Atom.cpp
// Function: Atom::getMolecule(Atom*, std::unordered_set<Atom*, std::hash<Atom*>, std::equal_to<Atom*>, std::allocator<Atom*>>&)
std::unordered_set<Atom*> Atom::getMolecule(Atom* root, std::unordered_set<Atom*>& found) {
	for (unsigned b = 0; b < 4; ++b) {
		if (found.end() == found.find(bonds[b].getAtom())) {
			found.insert(bonds[b].getAtom());
			getMolecule(bonds[b].getAtom(), found);
		}
	}
	return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jae 0x3228
movq -0x20(%rbp), %rdi
callq 0x3320
movq -0x98(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0x8, %rdi
movl -0x24(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3250
movq -0xb0(%rbp), %rdi
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x3350
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x32f0
testb $0x1, %al
jne 0x3198
jmp 0x3218
movq -0x98(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0xb8(%rbp)
addq $0x8, %rdi
movl -0x24(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3250
movq -0xb8(%rbp), %rdi
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x3380
movq -0x98(%rbp), %rdi
movq %rax, -0x58(%rbp)
movb %dl, -0x50(%rbp)
addq $0x8, %rdi
movl -0x24(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x3250
movq -0x98(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
leaq -0x90(%rbp), %rdi
callq 0x30f0
leaq -0x90(%rbp), %rdi
callq 0x32d0
jmp 0x321a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x312e
movq -0xa8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x33c0
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Wheatwizard[P]Waldo/Reactor.cpp
// Function: Reactor::~Reactor()
Reactor::~ Reactor() {
	for (unsigned i = 0; i < h; ++i) {
		delete [] board[i];
	}
	delete [] waldos;
	delete [] board;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x55a5
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5595
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
imulq $0x28, %rax, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x28(%rbp)
je 0x5580
movq -0x28(%rbp), %rdi
addq $-0x28, %rdi
movq %rdi, -0x40(%rbp)
callq 0x6e60
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x28(%rbp)
jne 0x555e
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
imulq $0x28, %rax, %rsi
addq $0x8, %rsi
callq 0x22c0
jmp 0x5597
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x550b
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x5618
movq -0x48(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rcx), %rdx
movq %rdx, -0x58(%rbp)
shlq $0x6, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x50(%rbp)
je 0x5603
movq -0x50(%rbp), %rdi
addq $-0x40, %rdi
movq %rdi, -0x68(%rbp)
callq 0x6580
movq -0x48(%rbp), %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x55e1
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
shlq $0x6, %rsi
addq $0x8, %rsi
callq 0x22c0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x5633
movq -0x70(%rbp), %rdi
callq 0x2210
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x65c0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Wheatwizard[P]Waldo/Reactor.cpp
// Function: Reactor::advance(unsigned int)
void Reactor::advance(unsigned cycle) {
	if (init_waldos != waldo_num) throw 7;
	//Iterate through the waldos in priority order 
	for (unsigned i = 0; i < waldo_num; ++i) {
		//Redirect
		waldos[i].setDirection(board[waldos[i].getRow()][waldos[i].getCol()].getArrow(i));
		//Perform instruction
		handleInstruction(i);
		//Move the Waldo
		waldos[i].move(*this);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0xc(%rcx), %eax
cmpl 0x8(%rcx), %eax
je 0x5f12
movl $0x4, %edi
callq 0x20d0
movq %rax, %rdi
movl $0x7, (%rdi)
movq 0xb097(%rip), %rsi      # 0x10fa0
xorl %eax, %eax
movl %eax, %edx
callq 0x2280
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x5fd2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movl -0x10(%rbp), %edx
shlq $0x6, %rdx
addq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x20(%rax), %rdi
movl -0x10(%rbp), %eax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x6620
movq -0x30(%rbp), %rcx
movl %eax, %edx
movq -0x18(%rbp), %rax
movl %edx, %edx
movq (%rcx,%rdx,8), %rcx
movq %rcx, -0x28(%rbp)
movq 0x20(%rax), %rdi
movl -0x10(%rbp), %eax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x6640
movq -0x28(%rbp), %rdi
movl %eax, %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x6ed0
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x7c00
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5690
movq -0x18(%rbp), %rsi
movq 0x20(%rsi), %rdi
movl -0x10(%rbp), %eax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x7a40
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5f19
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Wheatwizard[P]Waldo/Reactor.cpp
// Function: Reactor::popAtom(Atom*, unsigned int, unsigned int)
void Reactor::popAtom(Atom* root, unsigned row, unsigned col) {
	if (board[row][col].getAtom()) {
		board[row][col].removeAtom();
		if (root->getBond(UP).getAtom()) {
			popAtom(root->getBond(UP).getAtom(), row-1, col);
		}
		else if (root->getBond(DOWN).getAtom()) {
			popAtom(root->getBond(DOWN).getAtom(), row+1, col);
		}
		else if (root->getBond(RIGHT).getAtom()) {
			popAtom(root->getBond(RIGHT).getAtom(), row, col+1);
		}
		else if (root->getBond(LEFT).getAtom()) {
			popAtom(root->getBond(LEFT).getAtom(), row, col-1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x18(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movl -0x18(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x6f90
cmpq $0x0, %rax
je 0x6170
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movl -0x18(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x7160
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x608c
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
subl $0x1, %edx
movl -0x18(%rbp), %ecx
callq 0x5fe0
jmp 0x616e
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x60d8
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
movl -0x18(%rbp), %ecx
callq 0x5fe0
jmp 0x616c
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x6121
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
callq 0x5fe0
jmp 0x616a
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x6168
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
callq 0x5fe0
jmp 0x616a
jmp 0x616c
jmp 0x616e
jmp 0x6170
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Wheatwizard[P]Waldo/Reactor.cpp
// Function: Reactor::dropAtom(Atom*, unsigned int, unsigned int)
void Reactor::dropAtom(Atom* root, unsigned row, unsigned col) {
	if (board[row][col].getAtom() != root) {
		board[row][col].addAtom(root);
		if (root->getBond(UP).getAtom()) {
			dropAtom(root->getBond(UP).getAtom(), row-1, col);
		}
		else if (root->getBond(DOWN).getAtom()) {
			dropAtom(root->getBond(DOWN).getAtom(), row+1, col);
		}
		else if (root->getBond(RIGHT).getAtom()) {
			dropAtom(root->getBond(RIGHT).getAtom(), row, col+1);
		}
		else if (root->getBond(LEFT).getAtom()) {
			dropAtom(root->getBond(LEFT).getAtom(), row, col-1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x18(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movl -0x18(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x6f90
cmpq -0x10(%rbp), %rax
je 0x6314
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movl -0x18(%rbp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x7100
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x6230
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
subl $0x1, %edx
movl -0x18(%rbp), %ecx
callq 0x6180
jmp 0x6312
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x627c
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
movl -0x18(%rbp), %ecx
callq 0x6180
jmp 0x6310
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x62c5
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
callq 0x6180
jmp 0x630e
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x630c
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x66e0
movq %rax, %rdi
callq 0x3250
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
callq 0x6180
jmp 0x630e
jmp 0x6310
jmp 0x6312
jmp 0x6314
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Wheatwizard[P]Waldo/Bond.cpp
// Function: Bond::operator--()
Bond& Bond::operator--() {
	if (strength > 0) {
		--strength;
		update();
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x8(%rax)
jbe 0x6b2c
movq -0x10(%rbp), %rdi
movl 0x8(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rdi)
callq 0x6a80
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Wheatwizard[P]Waldo/Bond.cpp
// Function: Bond::operator--(int)
Bond Bond::operator--(int) {
	if (strength > 0) {
		Bond copy(*this);
		--strength;
		update();
		return copy;
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x8(%rax)
jbe 0x6b80
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x8(%rbp)
movl 0x8(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rdi)
callq 0x6a80
jmp 0x6b93
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x30, %rsp
popq %rbp
retq
// File: Wheatwizard[P]Waldo/Tile.cpp
// Function: Tile::initialize(unsigned int)
void Tile::initialize(unsigned waldo_max) {
	assert(arrows == NULL && instructions == NULL);
	waldos = waldo_max;
	arrows = new Direction[waldo_max]();
	instructions = new Instruction[waldo_max];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x1d(%rbp)
jne 0x6d32
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x6d3b
jmp 0x6d3d
jmp 0x6d5c
leaq 0x440e(%rip), %rdi      # 0xb152
leaq 0x442e(%rip), %rsi      # 0xb179
movl $0xa, %edx
leaq 0x442b(%rip), %rcx      # 0xb182
callq 0x2110
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x50(%rbp)
callq 0x2030
movq -0x50(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
xorl %esi, %esi
callq 0x20f0
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %eax
movq %rax, -0x38(%rbp)
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x2030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
cmpq $0x0, %rax
je 0x6e26
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rdx
shlq $0x2, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x7780
jmp 0x6e11
movq -0x60(%rbp), %rcx
movq -0x68(%rbp), %rax
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0x6e02
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x22c0
movq -0x18(%rbp), %rdi
callq 0x2290
nopw (%rax,%rax)
// File: Wheatwizard[P]Waldo/Tile.cpp
// Function: Tile::setArrow(unsigned int, Direction)
void Tile::setArrow(unsigned waldo, Direction end_state) {
	assert(waldo < this->waldos);
	if (arrows[waldo]) {
		throw std::runtime_error("Attempted to assign arrow where one existed");
	}
	arrows[waldo] = end_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jae 0x7053
jmp 0x7072
leaq 0x414c(%rip), %rdi      # 0xb1a6
leaq 0x4118(%rip), %rsi      # 0xb179
movl $0x2e, %edx
leaq 0x41e7(%rip), %rcx      # 0xb254
callq 0x2110
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
je 0x70d3
movl $0x10, %edi
callq 0x20d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x41e3(%rip), %rsi      # 0xb281
callq 0x2090
jmp 0x70a5
movq -0x30(%rbp), %rdi
movq 0x9f40(%rip), %rsi      # 0x10ff0
movq 0x9f09(%rip), %rdx      # 0x10fc0
callq 0x2280
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2140
jmp 0x70ea
movq -0x28(%rbp), %rax
movl -0x10(%rbp), %edx
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
// File: Wheatwizard[P]Waldo/Tile.cpp
// Function: Tile::addAtom(Atom*)
void Tile::addAtom(Atom* atom) {
	if (this->atom == NULL) {
		this->atom = atom;
	} else {
		throw "Atom collision";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
jne 0x712d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x7154
movl $0x8, %edi
callq 0x20d0
movq %rax, %rdi
leaq 0x416c(%rip), %rax      # 0xb2ad
movq %rax, (%rdi)
movq 0x9e65(%rip), %rsi      # 0x10fb0
xorl %eax, %eax
movl %eax, %edx
callq 0x2280
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Wheatwizard[P]Waldo/Tile.cpp
// Function: Tile::debond(Reactor&, unsigned int, unsigned int)
void Tile::debond( Reactor& board, unsigned row, unsigned col) {
	//TODO Implement reprioritization of atoms
	//(Once we figure out how the hell it works)
	if (mat != BONDER) return;
	if (row > 0 && board[row-1][col].mat == BONDER) {
		Bond& bond = atom->getBond(UP);
		if (bond.getAtom()) {
			--bond;
		}
	}
	if (row+1 < board.getNumRows() && board[row+1][col].mat == BONDER) {
		Bond& bond = atom->getBond(DOWN);
		if (bond.getAtom()) {
			--bond;
		}
	}
	if (col > 0 && board[row][col-1].mat == BONDER) {
		Bond& bond = atom->getBond(LEFT);
		if (bond.getAtom()) {
			--bond;
		}
	}
	if (col+1 < board.getNumCols() && board[row][col+1].mat == BONDER) {
		Bond& bond = atom->getBond(RIGHT);
		if (bond.getAtom()) {
			--bond;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpl $0x1, 0x20(%rax)
je 0x7589
jmp 0x770b
cmpl $0x0, -0x14(%rbp)
jbe 0x75de
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x2880
movl -0x18(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x20(%rax)
jne 0x75de
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x2, %esi
callq 0x66e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x75dc
movq -0x20(%rbp), %rdi
callq 0x6b00
jmp 0x75de
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2970
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jae 0x7648
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x2880
movl -0x18(%rbp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x20(%rax)
jne 0x7648
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x4, %esi
callq 0x66e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x7646
movq -0x28(%rbp), %rdi
callq 0x6b00
jmp 0x7648
cmpl $0x0, -0x18(%rbp)
jbe 0x769f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2880
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x20(%rax)
jne 0x769f
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x3, %esi
callq 0x66e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x769d
movq -0x30(%rbp), %rdi
callq 0x6b00
jmp 0x769f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6700
movl %eax, %ecx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
jae 0x770b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2880
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, 0x20(%rax)
jne 0x770b
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %esi
callq 0x66e0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3250
cmpq $0x0, %rax
je 0x7709
movq -0x38(%rbp), %rdi
callq 0x6b00
jmp 0x770b
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Wheatwizard[P]Waldo/Tile.cpp
// Function: Tile::setMat(Mat)
void Tile::setMat(Mat mat) {
	if (!this->mat) {
		this->mat = mat;
		if (mat == FUSOR) {
			//Add a mat to the tile on the right
		}
	} else {
		throw 15;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x20(%rax)
jne 0x7751
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x20(%rax)
cmpl $0x3, -0xc(%rbp)
jne 0x774f
jmp 0x774f
jmp 0x7774
movl $0x4, %edi
callq 0x20d0
movq %rax, %rdi
movl $0xf, (%rdi)
movq 0x9835(%rip), %rsi      # 0x10fa0
xorl %eax, %eax
movl %eax, %edx
callq 0x2280
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)