LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/ghost.cpp
// Function: Ghost::move(char (*) [61], int, int)
bool Ghost::move(char board[ROWS][COLS], int target_r, int target_c)
{
        int new_row = row;
        int new_col = col; 
        board[row][col] = board_char;   // replace element of board
        if (abs(row-target_r) > abs(col-target_c)){     // never wraps
                if (row > target_r){
                        new_row--;
                } else if (row < target_r){
                        new_row++;
                }
                if (board[new_row][new_col] != GHOST)
                        row = new_row;
        } else {
                if (col > target_c){
                        new_col--;
                } else if (col < target_c){
                        new_col++;
                }
                if (board[new_row][new_col] != GHOST)
                        col = new_col;
        }
        place_on_board(board);
        return (target_r == row && target_c == col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movslq (%rdi), %r10
movslq 0x4(%rdi), %r9
movb 0x8(%rdi), %al
imulq $0x3d, %r10, %r11
addq %rsi, %r11
movb %al, (%r9,%r11)
movl (%rdi), %r8d
movl %r8d, %eax
subl %edx, %eax
movl %eax, %ebx
negl %ebx
cmovsl %eax, %ebx
movl 0x4(%rdi), %eax
movl %eax, %r14d
subl %ecx, %r14d
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
cmpl %r15d, %ebx
jbe 0x283e
xorl %ebx, %ebx
cmpl %edx, %r8d
setl %bl
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
cmovlel %ebx, %r11d
addl %r10d, %r11d
movslq %r11d, %r10
imulq $0x3d, %r10, %r10
addq %rsi, %r10
cmpb $0x6d, (%r9,%r10)
je 0x2863
movl %r11d, (%rdi)
jmp 0x2866
xorl %ebx, %ebx
cmpl %ecx, %eax
setl %bl
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
cmovlel %ebx, %r10d
addl %r9d, %r10d
movslq %r10d, %r9
cmpb $0x6d, (%r9,%r11)
je 0x2863
movl %r10d, 0x4(%rdi)
movl %r10d, %eax
movl %r8d, %r11d
movslq %r11d, %r8
movslq %eax, %r9
imulq $0x3d, %r8, %rax
addq %rax, %rsi
leaq (%rsi,%r9), %rax
movb (%r9,%rsi), %sil
cmpb $0x6d, %sil
je 0x2885
movb %sil, 0x8(%rdi)
movb $0x6d, (%rax)
xorl (%rdi), %edx
xorl 0x4(%rdi), %ecx
orl %edx, %ecx
sete %al
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/game.cpp
// Function: Game::print_manual()
void Game::print_manual()
{
        screen_clear();
        cout << "PACMAN GAME\n"
                "            \n"
                " Move left:    " << CMD_LFT << "\n"
                " Move right:   " << CMD_RGT << "\n"
                " Move up:      " << CMD_UP  << "\n"
                " Move down:    " << CMD_DWN << "\n"
                "\n"
                " Collect all the dots. They look like: " << DOT << "\n"
                " Avoid the ghosts.     They look like: " << GHOST << "\n"
                "\n"
                " Good luck!\n"
                "\n"
                " Press any key to continue...\n";

        getachar();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x356e
movq 0x365a(%rip), %rbx      # 0x5fd0
leaq 0x1697(%rip), %rsi      # 0x4014
movl $0x28, %edx
movq %rbx, %rdi
callq 0x20f0
leaq -0x9(%rbp), %rsi
movb $0x61, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x1695(%rip), %rsi      # 0x403d
movl $0x10, %edx
movq %rax, %rdi
callq 0x20f0
leaq -0xa(%rbp), %rsi
movb $0x64, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x167b(%rip), %rsi      # 0x404e
movl $0x10, %edx
movq %rax, %rdi
callq 0x20f0
leaq -0xb(%rbp), %rsi
movb $0x77, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x1661(%rip), %rsi      # 0x405f
movl $0x10, %edx
movq %rax, %rdi
callq 0x20f0
leaq -0xc(%rbp), %rsi
movb $0x73, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x1647(%rip), %rsi      # 0x4070
movl $0x29, %edx
movq %rax, %rdi
callq 0x20f0
leaq -0xd(%rbp), %rsi
movb $0x6f, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rbx
leaq 0x1646(%rip), %rsi      # 0x409a
movl $0x28, %edx
movq %rax, %rdi
callq 0x20f0
leaq -0xe(%rbp), %rsi
movb $0x6d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x20f0
leaq 0x1647(%rip), %rsi      # 0x40c3
movl $0x2d, %edx
movq %rax, %rdi
callq 0x20f0
callq 0x3224
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/game.cpp
// Function: Game::run()
void Game::run()
{
        while (!game_won && p.is_alive()){
                reset_level();
                start_level();
                play_level();
                if (p.is_alive())
                        complete_level();
        }
        if (game_won){
                cout << "You win!\n";
        } else {
                cout << "You lost :(\n";
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movb 0x509(%rdi), %al
testb %al, %al
jne 0x2b1e
movq %rdi, %rbx
leaq 0x50c(%rdi), %r14
movq %r14, %rdi
callq 0x275a
testb %al, %al
je 0x2b18
movq %rbx, %rdi
callq 0x2b4c
movq %rbx, %rdi
callq 0x2be8
movq %rbx, %rdi
callq 0x2c52
movq %r14, %rdi
callq 0x275a
testb %al, %al
je 0x2b0c
movq %r14, %rdi
movl $0xa, %esi
callq 0x2746
movl 0x504(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x504(%rbx)
cmpl $0xa, %eax
setge %al
setge 0x509(%rbx)
jmp 0x2b12
movb 0x509(%rbx), %al
testb $0x1, %al
je 0x2ab1
jmp 0x2b1e
movb 0x509(%rbx), %al
movq 0x34ab(%rip), %rdi      # 0x5fd0
testb $0x1, %al
je 0x2b37
leaq 0x15c1(%rip), %rsi      # 0x40f1
movl $0x9, %edx
jmp 0x2b43
leaq 0x15bd(%rip), %rsi      # 0x40fb
movl $0xc, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x20f0
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/game.cpp
// Function: Game::reset_level()
void Game::reset_level()
{
        clear_board();
        init_dots();    // prepare dots, boulders, and ghosts
        set_dots();
        set_boulders();
        set_ghosts();
        p.center();     // prepare pacman
        p.place_on_board(board);
        p.set_dots(0);
        level_over = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x501, %edx            # imm = 0x501
movl $0x20, %esi
callq 0x2050
movq %rbx, %rdi
callq 0x2fd4
movq %rbx, %rdi
callq 0x3066
cmpl $0x0, 0x504(%rbx)
jle 0x2ba9
leaq 0x7ac(%rbx), %r14
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x396a
incq %r15
movslq 0x504(%rbx), %rax
addq $0x10, %r14
cmpq %rax, %r15
jl 0x2b8b
movq %rbx, %rdi
callq 0x3132
leaq 0x50c(%rbx), %r14
movq %r14, %rdi
callq 0x24a4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26e6
movq %r14, %rdi
xorl %esi, %esi
callq 0x2762
movb $0x0, 0x508(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/game.cpp
// Function: Game::start_level()
void Game::start_level()
{
        screen_clear();
        print_board();
        cout << "Level " << level << ": Press any key to start\n";
        getachar();
        screen_clear(); // print initial state of boar
        print_board(); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x356e
movq %rbx, %rdi
callq 0x2e12
movq 0x33ca(%rip), %r14      # 0x5fd0
leaq 0x1503(%rip), %rsi      # 0x4110
movl $0x6, %edx
movq %r14, %rdi
callq 0x20f0
movl 0x504(%rbx), %esi
movq %r14, %rdi
callq 0x2190
leaq 0x14e8(%rip), %rsi      # 0x4117
movl $0x19, %edx
movq %rax, %rdi
callq 0x20f0
callq 0x3224
callq 0x356e
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2e12
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/game.cpp
// Function: Game::play_level()
void Game::play_level()
{
        char move;
        while (p.is_alive() && !level_over){
                // Pacman moves
                move = getacharnow(2);
                if (move == CMD_QUIT){
                        level_over = true;
                        p.die();
                        return;
                } else if (move == CHEAT){
                        level_over = true;
                }
                if (p.move(board, move)){
                        eat_dot(p.get_row(), p.get_col());
                        level_over = !(p.get_dots() < level*DOTS_PER_LEVEL);
                }
                if (p.is_alive())   // Show Ghost if Pacman is eaten
                        p.place_on_board(board);
                screen_home();
                print_board();
                
                // Ghosts move
                if (p.get_num_moves()%GHOST_FREQ==0 && !level_over){
                        for (int i=0; i<NUM_GHOSTS; i++){
                                if (ghosts[i].move(board, p.get_row(),
                                                          p.get_col()))
                                        p.die();        // Pacman eaten
                                ghosts[i].place_on_board(board);
                        }
                }
                screen_home();
                print_board();
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x50c(%rdi), %rbx
movq %rbx, %rdi
callq 0x275a
testb %al, %al
je 0x2d96
cmpb $0x0, 0x508(%r14)
jne 0x2d96
movl $0x2, %edi
callq 0x348b
cmpb $0x47, %al
je 0x2ca3
movzbl %al, %ecx
cmpl $0x71, %ecx
jne 0x2cab
jmp 0x2da5
movb $0x1, 0x508(%r14)
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24bc
testb %al, %al
je 0x2cf9
movq %rbx, %rdi
callq 0x272a
movl %eax, %r15d
movq %rbx, %rdi
callq 0x2720
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x30b4
movq %rbx, %rdi
callq 0x276c
movl 0x504(%r14), %ecx
leal (%rcx,%rcx,4), %ecx
cmpl %ecx, %eax
setge 0x508(%r14)
movq %rbx, %rdi
callq 0x275a
testb %al, %al
je 0x2d10
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26e6
callq 0x3659
movq %r14, %rdi
callq 0x2e12
movq %rbx, %rdi
callq 0x2702
testb $0x1, %al
jne 0x2d84
cmpb $0x0, 0x508(%r14)
jne 0x2d84
movl $0x524, %r13d           # imm = 0x524
leaq (%r14,%r13), %r15
movq %rbx, %rdi
callq 0x272a
movl %eax, %r12d
movq %rbx, %rdi
callq 0x2720
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %eax, %ecx
callq 0x27ce
testb %al, %al
je 0x2d6c
movq %rbx, %rdi
callq 0x26dc
movq %r15, %rdi
movq %r14, %rsi
callq 0x289a
addq $0xc, %r13
cmpq $0x554, %r13            # imm = 0x554
jne 0x2d39
callq 0x3659
movq %r14, %rdi
callq 0x2e12
jmp 0x2c6a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, 0x508(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x26dc
nop
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/game.cpp
// Function: Game::print_board()
void Game::print_board()
{
        for (int r=-1; r<=ROWS; r++){
                for (int c=-1; c<=COLS; c++){
                        if ((r==-1||r==ROWS)||(c==-1||c==COLS)){
                                cout << border(r,c);
                        } else {
                                cout << board[r][c];
                        }
                }
                cout << endl;
        }
        cout << "Score: " << p.get_score() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $-0x1, %r13
movq 0x319c(%rip), %r14      # 0x5fd0
movq %rdi, -0x38(%rbp)
cmpq $-0x1, %r13
sete %al
cmpq $0x15, %r13
sete %r15b
orb %al, %r15b
movq $-0x3f, %r12
cmpq $-0x3f, %r12
sete %al
cmpq $-0x1, %r12
je 0x2e79
orb %r15b, %al
jne 0x2e79
movb 0x1(%rbx,%r12), %al
movb %al, -0x2a(%rbp)
movl $0x1, %edx
movq %r14, %rdi
leaq -0x2a(%rbp), %rsi
jmp 0x2eb0
cmpl $0x15, %r13d
je 0x2e87
movb $0x7c, %al
cmpl $-0x1, %r13d
jne 0x2ea1
cmpq $-0x1, %r12
setne %al
addb %al, %al
addb $0x2b, %al
cmpq $-0x3f, %r12
movzbl %al, %eax
movl $0x2b, %ecx
cmovel %ecx, %eax
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r14, %rdi
leaq -0x29(%rbp), %rsi
callq 0x20f0
incq %r12
jne 0x2e51
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x20c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2060
incq %r13
addq $0x3d, %rbx
cmpq $0x16, %r13
jne 0x2e38
movq 0x30d7(%rip), %r14      # 0x5fd0
leaq 0x1208(%rip), %rsi      # 0x4108
movl $0x7, %edx
movq %r14, %rdi
callq 0x20f0
movq -0x38(%rbp), %rdi
addq $0x50c, %rdi            # imm = 0x50C
callq 0x2750
movq %r14, %rdi
movl %eax, %esi
callq 0x2190
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2060
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/game.cpp
// Function: Game::init_dots()
void Game::init_dots()
{
        set_boulders(); // to avoid boulders in each level
        for (int i=0; i<NUM_DOTS; i++){
                dots[i].set_random_location(board);
                dots[i].set_eaten(false);
                dots[i].place_on_board(board); // to ensure no dots overlap
        }
        clear_board();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x504(%rdi)
jle 0x3012
leaq 0x7ac(%rbx), %r14
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x396a
incq %r15
movslq 0x504(%rbx), %rax
addq $0x10, %r14
cmpq %rax, %r15
jl 0x2ff4
movl $0x554, %r15d           # imm = 0x554
leaq (%rbx,%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x383e
movq %r14, %rdi
xorl %esi, %esi
callq 0x38b4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x388c
addq $0xc, %r15
cmpq $0x7ac, %r15            # imm = 0x7AC
jne 0x3018
movl $0x501, %edx            # imm = 0x501
movq %rbx, %rdi
movl $0x20, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2050
nop
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/game.cpp
// Function: Game::eat_dot(int, int)
void Game::eat_dot(int r, int c)
{
        for (int i=0; i<DOTS_PER_LEVEL*level; i++)
                if (dots[i].is_at(r,c))
                        dots[i].was_eaten();
        p.add_to_score(DOT_REWARD);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x504(%rdi)
jle 0x310f
movl %edx, %r14d
movl %esi, %r15d
leaq 0x554(%rbx), %r12
xorl %r13d, %r13d
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x38a4
testb %al, %al
je 0x30f8
movq %r12, %rdi
callq 0x38be
incq %r13
movslq 0x504(%rbx), %rax
leaq (%rax,%rax,4), %rax
addq $0xc, %r12
cmpq %rax, %r13
jl 0x30de
addq $0x50c, %rbx            # imm = 0x50C
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2746
nop
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/game.cpp
// Function: Game::set_ghosts()
void Game::set_ghosts()
{
        for (int i=0; i<NUM_GHOSTS; i++){
                if (i==0){
                        ghosts[i].set_location(0,0);
                } else if (i==1){
                        ghosts[i].set_location(0,COLS-1);
                } else if (i==2){
                        ghosts[i].set_location(ROWS-1,0);
                } else if (i==3){
                        ghosts[i].set_location(ROWS-1,COLS-1);
                } else {
                        ghosts[i].set_random_location();
                }
                ghosts[i].place_on_board(board);
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x548(%rdi), %rax
movq %rax, -0x40(%rbp)
leaq 0x53c(%rdi), %rax
movq %rax, -0x38(%rbp)
leaq 0x530(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0x524(%rdi), %r14
xorl %r15d, %r15d
movl %r15d, %eax
leaq 0xe89(%rip), %r12       # 0x4004
movslq (%r12,%rax,4), %rax
addq %r12, %rax
movq %r14, %r13
jmpq *%rax
addq $0xc, %r13
movl %r15d, %eax
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r14, %rdi
xorl %esi, %esi
jmp 0x31bf
movq -0x40(%rbp), %rdi
movl $0x14, %esi
jmp 0x31af
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x3c, %edx
jmp 0x31c1
movq -0x38(%rbp), %rdi
movl $0x14, %esi
xorl %edx, %edx
callq 0x278a
movq %r13, %rdi
movq %rbx, %rsi
callq 0x289a
incq %r15
cmpq $0x4, %r15
jne 0x3187
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/termfuncs.cpp
// Function: getachar()
char getachar()
{
	char q_key = 0;
	char *qk = NULL;
	char c;
	int  nread;

	if ( ( qk = getenv("TF_QUIT") ) != NULL ){
		q_key = qk[0];
	}
	cout << std::flush;
	if ( isatty(0) ){
		struct termios	info, orig;
		// system("stty -echo -icanon");
		tcgetattr(0, &info);
		orig = info;
		prev_tty_state = orig;
		prev_state_stored = 1;

		info.c_lflag &= ~ECHO;
		info.c_lflag &= ~ICANON;
		tcsetattr(0, TCSANOW, &info);

		nread = read(0, &c, 1);
		if ( nread == 1 && c == ESCAPE )
			c = handle_escape_seq();

		// system("stty echo icanon");
		tcsetattr(0, TCSANOW, &orig);
	}
	else {
		if ( cin.get(c) )
			nread = 1;
		else
			nread = 0;
		// cout << "got " << nread << " chars [" << c << "]\n";
		if ( nread == 0 && qk != NULL )
			exit(0);
	}

	if ( nread == 1 && qk != NULL && c == q_key ){
		exit(0);
	}

	return ( nread > 0 ? c : 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
leaq 0xef4(%rip), %rdi       # 0x4131
callq 0x2120
movq %rax, %rbx
testq %rax, %rax
je 0x3250
movsbl (%rbx), %r12d
jmp 0x3253
xorl %r12d, %r12d
movq 0x2d76(%rip), %rdi      # 0x5fd0
callq 0x2060
xorl %edi, %edi
callq 0x21a0
testl %eax, %eax
je 0x32fb
leaq -0x9c(%rbp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x20e0
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x2c(%r14), %xmm3
movaps %xmm0, -0x60(%rbp)
movaps %xmm1, -0x50(%rbp)
movaps %xmm2, -0x40(%rbp)
movups %xmm3, -0x34(%rbp)
andb $-0xb, 0xc(%r14)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2130
leaq -0x21(%rbp), %r15
movl $0x1, %edx
xorl %edi, %edi
movq %r15, %rsi
callq 0x2150
movq %rax, %r14
cmpl $0x1, %r14d
sete %al
movb (%r15), %r15b
cmpb $0x1b, %r15b
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x32ec
callq 0x3366
movl %eax, %r15d
movb %al, -0x21(%rbp)
leaq -0x60(%rbp), %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x2130
jmp 0x332f
movq 0x2cde(%rip), %rdi      # 0x5fe0
leaq -0x21(%rbp), %rsi
callq 0x2140
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %eax
testq %rbx, %rbx
je 0x3322
movl %eax, %ecx
andl $0x5, %ecx
jne 0x335f
xorl %r14d, %r14d
testb $0x5, %al
sete %r14b
movb -0x21(%rbp), %r15b
testq %rbx, %rbx
je 0x3343
cmpl $0x1, %r14d
jne 0x3343
movsbl %r15b, %eax
cmpl %eax, %r12d
je 0x335f
xorl %ecx, %ecx
testl %r14d, %r14d
movzbl %r15b, %eax
cmovlel %ecx, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/termfuncs.cpp
// Function: handle_escape_seq()
char handle_escape_seq()
{
	struct termios	info, orig;
	char		buf[100];
	int		pos = 0;
	char		c;
	void		(*oldhand)(int);

	if ( !isatty(0) ) 
		return ESCAPE;

	oldhand = signal(SIGINT, SIG_IGN);

	// system("stty -echo -icanon");
	tcgetattr(0, &info);
	orig = info;

	info.c_lflag &= ~ECHO;
	info.c_lflag &= ~ICANON;
	info.c_cc[VMIN] = 0;
	info.c_cc[VTIME] = 1;			// 1/10 second
	tcsetattr(0, TCSANOW, &info);

	do
	{
		if ( read(0, &c, 1) == 1 )	// if got one
			buf[pos++] = c;		// store it
		else
			break;			// else timeout
	}
	while( !isalpha((int)c) && pos < 99 );	// until alpha or full

	if ( pos == 0 || (buf[0] != '[' && buf[0] != 'O' ) )
		c = ESCAPE;
	else 
		switch(buf[1]){
			case 'A':		c = KEY_UP;	break;
			case 'B':		c = KEY_DOWN;	break;
			case 'C':		c = KEY_RIGHT;	break;
			case 'D':		c = KEY_LEFT;	break;
			default :
						c = ESCAPE;
		}

	tcsetattr(0, TCSANOW, &orig);
	signal(SIGINT, oldhand);
	// system("stty echo icanon");
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xf8, %rsp
xorl %edi, %edi
callq 0x21a0
testl %eax, %eax
je 0x3423
movl $0x1, %esi
movl $0x2, %edi
callq 0x2100
movq %rax, %rbx
xorl %r15d, %r15d
leaq -0x10c(%rbp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x20e0
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x2c(%r14), %xmm3
movaps %xmm0, -0x60(%rbp)
movaps %xmm1, -0x50(%rbp)
movaps %xmm2, -0x40(%rbp)
movups %xmm3, -0x34(%rbp)
andb $-0xb, 0xc(%r14)
movw $0x1, 0x16(%r14)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2130
leaq -0x19(%rbp), %r14
movl $0x1, %edx
xorl %edi, %edi
movq %r14, %rsi
callq 0x2150
cmpq $0x1, %rax
jne 0x3428
movsbl -0x19(%rbp), %edi
movb %dil, -0xd0(%rbp,%r15)
callq 0x2180
testl %eax, %eax
jne 0x342d
leaq 0x1(%r15), %rax
cmpq $0x62, %r15
movq %rax, %r15
jb 0x33ea
jmp 0x342d
movb $0x1b, %r14b
jmp 0x347a
testq %r15, %r15
je 0x345d
movzbl -0xd0(%rbp), %eax
movb $0x1b, %r14b
cmpl $0x5b, %eax
je 0x3441
cmpl $0x4f, %eax
jne 0x3460
movb -0xcf(%rbp), %cl
addb $-0x41, %cl
cmpb $0x3, %cl
ja 0x3460
shlb $0x3, %cl
movl $0x84858382, %r14d      # imm = 0x84858382
shrl %cl, %r14d
jmp 0x3460
movb $0x1b, %r14b
leaq -0x60(%rbp), %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x2130
movl $0x2, %edi
movq %rbx, %rsi
callq 0x2100
movl %r14d, %eax
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/termfuncs.cpp
// Function: getacharnow(int)
char getacharnow(int decisecs)
{
	char c;

	cout << std::flush;
	if ( isatty(0) ) 
	{
		struct termios	info, orig;
		// system("stty -echo -icanon");
		tcgetattr(0, &info);
		orig = info;
		prev_tty_state = orig;
		prev_state_stored = 1;

		info.c_lflag &= ~ECHO;
		info.c_lflag &= ~ICANON;
		info.c_cc[VMIN] = 0;
		info.c_cc[VTIME] = decisecs;
		tcsetattr(0, TCSANOW, &info);

		if ( read(0, &c, 1) == 1 ){
			if ( c == ESCAPE )
				c = handle_escape_seq();
		}
		else
			c = '\0';

		tcsetattr(0, TCSANOW, &orig);
		// system("stty echo icanon");
	}
	else {
		if ( read(0, &c, 1) != 1 )
			c = '\0';
	}

	return (int) c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %edi, %r14d
movq 0x2b2b(%rip), %rdi      # 0x5fd0
callq 0x2060
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x21a0
testl %eax, %eax
je 0x3540
xorl %ebx, %ebx
leaq -0x9c(%rbp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x20e0
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x2c(%r15), %xmm3
movaps %xmm0, -0x60(%rbp)
movaps %xmm1, -0x50(%rbp)
andb $-0xb, 0xc(%r15)
movaps %xmm2, -0x40(%rbp)
movups %xmm3, -0x34(%rbp)
movb $0x0, 0x17(%r15)
movb %r14b, 0x16(%r15)
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2130
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
xorl %edi, %edi
callq 0x2150
cmpq $0x1, %rax
jne 0x3531
movb -0x19(%rbp), %bl
cmpb $0x1b, %bl
jne 0x3531
callq 0x3366
movl %eax, %ebx
leaq -0x60(%rbp), %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x2130
jmp 0x355e
leaq -0x19(%rbp), %rbx
movl $0x1, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2150
cmpq $0x1, %rax
movzbl (%rbx), %ebx
cmovnel %r15d, %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/termfuncs.cpp
// Function: random_int(int, int)
int random_int(int lo, int hi)
{
	int	range = hi - lo + 1;
	char	*seed_str;

	if ( rand_seed == -1 ) {
		seed_str = getenv( "SNAKE_SEED" );
		if ( seed_str != NULL )
			seed_random( (unsigned) atoi(seed_str) );
		else 
			seed_random( (unsigned) time(NULL) );
	}
	if ( range <= 0 )
		return 17;		// add to function specs

	return lo + ( rand() % range );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebx
subl %edi, %r14d
cmpl $-0x1, 0x29dd(%rip)     # 0x6100
jne 0x3754
leaq 0xa12(%rip), %rdi       # 0x413e
callq 0x2120
testq %rax, %rax
je 0x377b
movq %rax, %rdi
callq 0x2170
movl %eax, %r15d
testl %eax, %eax
jle 0x3754
movl %r15d, %edi
callq 0x20b0
movl %r15d, 0x29ac(%rip)     # 0x6100
testl %r14d, %r14d
js 0x376b
incl %r14d
callq 0x2040
cltd
idivl %r14d
movl %edx, %eax
addl %ebx, %eax
jmp 0x3770
movl $0x11, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x20a0
movq %rax, %r15
testl %r15d, %r15d
jg 0x3745
jmp 0x3754
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/boulder.cpp
// Function: Boulder::Boulder()
Boulder::Boulder()
{
        /* keep randomly choosing a location until we find a location and size
         * that doesn't overlap the middle */
        do {
                top_left_r = random_int(0, ROWS-1);
                top_left_c = random_int(0, COLS-1);
                height = random_int(MIN_BOULDER_HEIGHT, MAX_BOULDER_HEIGHT);
                width  = random_int(MIN_BOULDER_WIDTH, MAX_BOULDER_WIDTH);
        } while ( overlaps_middle() );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
movl $0x14, %esi
callq 0x370a
movl %eax, (%rbx)
xorl %edi, %edi
movl $0x3c, %esi
callq 0x370a
movl %eax, 0x4(%rbx)
movl $0x2, %edi
movl $0x5, %esi
callq 0x370a
movl %eax, 0x8(%rbx)
movl $0x6, %edi
movl $0xf, %esi
callq 0x370a
movl %eax, 0xc(%rbx)
movl (%rbx), %ecx
cmpl $0xa, %ecx
jg 0x3930
addl 0x8(%rbx), %ecx
cmpl $0xa, %ecx
jl 0x3930
movl 0x4(%rbx), %ecx
cmpl $0x1e, %ecx
jg 0x3930
addl %eax, %ecx
cmpl $0x1d, %ecx
jg 0x38d1
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/justinjo[P]Pacman/boulder.cpp
// Function: Boulder::place_on_board(char (*) [61])
void Boulder::place_on_board(char board[ROWS][COLS])
{
        for (int r = top_left_r; r <= top_left_r + height; r++) {
                for (int c = top_left_c; c <= top_left_c + width; c++) {
                        if (r < ROWS && c < COLS) {
                                board[r][c] = BOULDER;
                        }
                }
        }
}

// Assembly:
movl 0x8(%rdi), %edx
testl %edx, %edx
js 0x39e0
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %r8d
movl 0xc(%rdi), %eax
movslq %r8d, %rcx
imulq $0x3d, %rcx, %r9
addq %r9, %rsi
testl %eax, %eax
js 0x39c8
movl 0x4(%rdi), %edx
movslq %edx, %r8
cmpq $0x15, %rcx
setge %r9b
cmpq $0x3d, %r8
setge %r10b
orb %r9b, %r10b
jne 0x39af
movb $0x58, (%rsi,%r8)
movl 0x4(%rdi), %edx
movl 0xc(%rdi), %eax
leaq 0x1(%r8), %r9
leal (%rax,%rdx), %r10d
movslq %r10d, %r10
cmpq %r10, %r8
movq %r9, %r8
jl 0x398f
movl (%rdi), %r8d
movl 0x8(%rdi), %edx
leaq 0x1(%rcx), %r9
leal (%rdx,%r8), %r10d
movslq %r10d, %r10
addq $0x3d, %rsi
cmpq %r10, %rcx
movq %r9, %rcx
jl 0x3985
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/allardlamberink[P]fritz-curl/fritz-curl.cpp
// Function: getmd5sum(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string getmd5sum(string inpstr)
{
	unsigned char digest[MD5_DIGEST_LENGTH];
	char inpa[inpstr.size()];
	strcpy(inpa, inpstr.c_str());

	MD5((unsigned char*)&inpa, strlen(inpa), (unsigned char*)&digest);
	char mdString[33];
	for(int i = 0; i < 16; i++)
		sprintf(&mdString[i*2], "%02x", (unsigned int)digest[i]);

	return string(mdString);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rsp, %r12
movq 0x8(%rsi), %rax
movq %rsp, %r14
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movq (%rsi), %rsi
movq %r14, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x31b0
leaq -0x40(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3370
leaq -0x70(%rbp), %r14
leaq 0xc871(%rip), %r15      # 0x10020
xorl %r13d, %r13d
movzbl -0x40(%rbp,%r13), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x3430
incq %r13
addq $0x2, %r14
cmpq $0x10, %r13
jne 0x37b2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x31b0
leaq (%rax,%rbp), %rdx
addq $-0x70, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6d9c
movq %r12, %rsp
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/taurheim[P]AgNES/scanner.cpp
// Function: Scanner::getNextToken()
Token Scanner::getNextToken() {
    Token sym;
    while (std::isspace(ch) && !input.eof()) getChar(); // skip to next non-whitespace character
    if (std::isalpha(ch)) {
        // Identifier
        sym = identifyKeyword();
    } else if (std::isdigit(ch)) {
        // Number
        sym = identifyNumber();  
    } else if (ch == '\'') {
        // Char
        sym = identifyChar();
    } else if (input.eof()) {
        sym = { T_EOF_TOKEN };
    } else {
        sym = identifySpecialToken();
    }
    return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
leaq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0x18(%rdi), %rax
movq %rax, -0x70(%rbp)
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq %rdi, -0x38(%rbp)
movb $0x0, 0x18(%rdi)
movb 0x10(%rsi), %r14b
movsbl %r14b, %r12d
movl %r12d, %edi
callq 0x3080
testl %eax, %eax
je 0x7523
movq (%r15), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rdi,%rax)
jne 0x7523
leaq 0x10(%r15), %r13
leaq -0x68(%rbp), %rbx
movq %r13, %rsi
callq 0x3320
movb (%r13), %al
movb %al, -0x68(%rbp)
movl $0x1, %edx
movq 0x10ada(%rip), %rdi     # 0x17fd0
movq %rbx, %rsi
callq 0x32d0
movb (%r13), %r14b
movsbl %r14b, %r12d
movl %r12d, %edi
callq 0x3080
testl %eax, %eax
je 0x7523
movq (%r15), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rdi,%rax)
je 0x74db
movl %r12d, %edi
callq 0x33b0
testl %eax, %eax
je 0x753d
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x7654
jmp 0x7553
addl $-0x30, %r12d
cmpl $0x9, %r12d
ja 0x759e
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x7798
leaq -0x60(%rbp), %rbx
movl -0x8(%rbx), %eax
movq -0x38(%rbp), %r14
movl %eax, (%r14)
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x3300
movb 0x24(%rbx), %al
movb %al, 0x2c(%r14)
movl 0x20(%rbx), %eax
movl %eax, 0x28(%r14)
movq (%rbx), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x758c
callq 0x3250
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x27, %r14b
jne 0x75b6
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x7854
movq -0x38(%rbp), %r14
jmp 0x75d7
movq (%r15), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rax,%rcx)
movq -0x38(%rbp), %r14
jne 0x75e3
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x79ac
leaq -0x60(%rbp), %rbx
movl -0x8(%rbx), %eax
jmp 0x755e
movl $0xb, %eax
leaq -0x60(%rbp), %rsi
movl %eax, -0x8(%rsi)
leaq -0x50(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
movl %eax, (%r14)
movq -0x30(%rbp), %rdi
callq 0x3300
movb 0x14(%rbx), %al
movb %al, 0x2c(%r14)
movl 0x10(%rbx), %eax
movl %eax, 0x28(%r14)
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
jne 0x7587
jmp 0x758c
jmp 0x7636
jmp 0x7636
jmp 0x7636
jmp 0x7636
movq %rax, %rbx
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x70(%rbp), %rdi
je 0x764b
callq 0x3250
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O3/taurheim[P]AgNES/scanner.cpp
// Function: Scanner::identifyKeyword()
Token Scanner::identifyKeyword() {
    std::string word;
    while (std::isalpha(ch)) { // create string... TODO: include numeric
        word += ch;
        getChar();
    }
    auto search = stringToToken.find(word);
    if (search == stringToToken.end()) {
        Token identToken;
        identToken.type = TokenType::T_IDENT;
        identToken.stringVal = word;
        return identToken;
    } else {
        return { search->second };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movb 0x10(%rsi), %r12b
movsbl %r12b, %edi
callq 0x33b0
testl %eax, %eax
je 0x76dd
leaq 0x10(%r14), %r15
movq 0x10935(%rip), %r13     # 0x17fd0
leaq -0x29(%rbp), %rbx
movsbl %r12b, %esi
leaq -0x58(%rbp), %rdi
callq 0x3220
movq (%r14), %rdi
movq %r15, %rsi
callq 0x3320
movb (%r15), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x32d0
movb (%r15), %r12b
movsbl %r12b, %edi
callq 0x33b0
testl %eax, %eax
jne 0x769f
leaq 0x10c44(%rip), %rdi     # 0x18328
leaq -0x58(%rbp), %rsi
callq 0x8666
leaq 0x10c3c(%rip), %rcx     # 0x18330
cmpq %rcx, %rax
movq -0x38(%rbp), %rbx
je 0x7718
movl 0x40(%rax), %eax
movl %eax, (%rbx)
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
jmp 0x7742
leaq 0x8(%rbx), %r14
leaq 0x18(%rbx), %r15
movq %r15, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movl $0x9, (%rbx)
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x3180
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x7754
callq 0x3250
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x777d
callq 0x3250
jmp 0x777d
jmp 0x777a
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x778f
callq 0x3250
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O3/taurheim[P]AgNES/scanner.cpp
// Function: Scanner::identifyNumber()
Token Scanner::identifyNumber() {
    Token numberToken;
    numberToken.type = TokenType::T_INTVALUE;
    numberToken.intVal = 0;

    // Go through all the digits to get the full number
    while (std::isdigit(ch)) {
        numberToken.intVal = (numberToken.intVal * 10) + (ch - '0');
        getChar();
    }

    return numberToken;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movl $0xf, (%rdi)
movl $0x0, 0x28(%rdi)
movsbl 0x10(%rsi), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x7828
movq %rsi, %r14
leaq 0x10(%rsi), %r15
movq 0x107e5(%rip), %r12     # 0x17fd0
leaq -0x29(%rbp), %r13
movl 0x28(%rbx), %ecx
leal (%rcx,%rcx,4), %ecx
leal (%rax,%rcx,2), %eax
movl %eax, 0x28(%rbx)
movq (%r14), %rdi
movq %r15, %rsi
callq 0x3320
movb (%r15), %al
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x32d0
movsbl (%r15), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x77ef
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0x784c
callq 0x3250
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/taurheim[P]AgNES/scanner.cpp
// Function: Scanner::identifyChar()
Token Scanner::identifyChar() {
    if(ch != '\'') {
        reject("Char must begin with \"'\"");
    }

    getChar();
    Token charToken;
    charToken.type = TokenType::T_CHARVALUE;
    charToken.charVal = ch;
    getChar();

    if(ch != '\'') {
        reject("Char can only be of length 1, expected \"'\"");
    }
    getChar();

    return charToken;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
cmpb $0x27, 0x10(%rsi)
jne 0x791e
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsi), %r14
movq (%rsi), %rdi
movq %r14, %rsi
callq 0x3320
movb 0x10(%r15), %al
leaq -0x21(%rbp), %rsi
movb %al, (%rsi)
movq 0x1073d(%rip), %rdi     # 0x17fd0
movl $0x1, %edx
callq 0x32d0
leaq 0x18(%rbx), %r12
movq %r12, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movl $0x11, (%rbx)
movb 0x10(%r15), %al
movb %al, 0x2c(%rbx)
movq (%r15), %rdi
movq %r14, %rsi
callq 0x3320
movb (%r14), %al
leaq -0x21(%rbp), %rsi
movb %al, (%rsi)
movq 0x106f7(%rip), %rdi     # 0x17fd0
movl $0x1, %edx
callq 0x32d0
cmpb $0x27, (%r14)
jne 0x7948
movq (%r15), %rdi
movq %r14, %rsi
callq 0x3320
movb (%r14), %al
leaq -0x21(%rbp), %rsi
movb %al, (%rsi)
movq 0x106cc(%rip), %rdi     # 0x17fd0
movl $0x1, %edx
callq 0x32d0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xa957(%rip), %rsi      # 0x12284
leaq 0xa968(%rip), %rdx      # 0x1229c
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0x82f0
movq %rbx, %rsi
callq 0x7b70
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xa946(%rip), %rsi      # 0x1229d
leaq 0xa969(%rip), %rdx      # 0x122c7
leaq -0x48(%rbp), %rdi
callq 0x82f0
leaq -0x48(%rbp), %rsi
callq 0x7b70
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x7996
callq 0x3250
jmp 0x7996
jmp 0x7993
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
jne 0x799f
jmp 0x79a4
movq %rax, %r14
movq 0x8(%rbx), %rdi
cmpq %r12, %rdi
je 0x79a4
callq 0x3250
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/taurheim[P]AgNES/parser.cpp
// Function: Parser::parse()
ASTNode * Parser::parse() {
    std::cout << "Parsing..." << std::endl;
    root = program();
    std::cout << std::endl;
    printAST(root);
    return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0xf7db(%rip), %r14      # 0x17fd0
leaq 0x9bfb(%rip), %rsi      # 0x123f7
movl $0xa, %edx
movq %r14, %rdi
callq 0x32d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq %rbx, %rdi
callq 0x88d8
movq %rax, 0x10(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3260
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31a0
movq 0x10(%rbx), %r15
leaq 0x9c56(%rip), %rsi      # 0x124c4
movl $0x10, %edx
movq %r14, %rdi
callq 0x32d0
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movw $0x9, (%r14)
movq $0x1, -0x8(%r14)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
movq %r15, %rdx
callq 0x9ef1
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x88b0
callq 0x3250
movq 0x10(%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x88d0
callq 0x3250
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/taurheim[P]AgNES/parser.cpp
// Function: Parser::program()
ASTNode * Parser::program() {
    /*
        {<function> | <declaration>}

        Lookahead:
        <type> <identifier>
            ";" -> declaration
            "(" -> function
    */

    ASTNode * node = new ASTNode(AST_PROGRAM);

    while (t.type != T_EOF_TOKEN) {
        TokenType decider = lookahead(2);

        ASTNode * childNode;

        if(decider == T_LPAREN) {
            childNode = function();
        } else {
            childNode = declaration();
            expect(T_SEMI);
        }

        node->children.push_back(childNode);
    }

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3290
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x1, (%rax)
cmpl $0xb, 0x18(%rbx)
je 0x8987
movq %r14, %r15
addq $0x8, %r15
leaq -0x30(%rbp), %r12
leaq -0x34(%rbp), %r13
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8d78
movq %rbx, %rdi
cmpl $0x4, %eax
jne 0x8943
callq 0x8df0
movq %rax, -0x30(%rbp)
jmp 0x895e
callq 0x8eda
movq %rax, -0x30(%rbp)
movl $0x3, -0x34(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8f9a
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x8976
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x8981
movq %r15, %rdi
movq %r12, %rdx
callq 0xac72
cmpl $0xb, 0x18(%rbx)
jne 0x8923
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/taurheim[P]AgNES/parser.cpp
// Function: Parser::next()
void Parser::next() {
    if (t.type == T_EOF_TOKEN) {
        reject("Unexpected EOF");
        return;
    }
    std::advance(tokenIterator, 1);
    t = *tokenIterator;

    std::cout << tokenToStr(t) << " ";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
cmpl $0xb, 0x18(%rdi)
je 0x8a6d
movq 0x8(%rbx), %rax
movq (%rax), %r14
movq %r14, 0x8(%rbx)
movl 0x10(%r14), %eax
movl %eax, 0x18(%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x18(%r14), %rsi
callq 0x3180
movb 0x3c(%r14), %al
movb %al, 0x44(%rbx)
movl 0x38(%r14), %eax
movl %eax, 0x40(%rbx)
movl 0x18(%rbx), %eax
leaq -0x58(%rbp), %rdi
movl %eax, -0x8(%rdi)
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
callq 0x6906
movb 0x44(%rbx), %al
movb %al, 0x14(%r14)
movl 0x40(%rbx), %eax
movl %eax, 0x10(%r14)
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8c01
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0xf5a5(%rip), %rdi      # 0x17fd0
callq 0x32d0
leaq 0x9e1b(%rip), %rsi      # 0x12852
movl $0x1, %edx
movq %rax, %rdi
callq 0x32d0
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a56
callq 0x3250
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x8a64
callq 0x3250
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x9986(%rip), %rsi      # 0x12402
leaq 0x998d(%rip), %rdx      # 0x12410
leaq -0x30(%rbp), %rdi
callq 0x82f0
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x8ad6
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x8ac4
movq %rax, %rbx
jmp 0x8ace
movq %rax, %rbx
jmp 0x8ac0
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ac0
callq 0x3250
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x8ace
callq 0x3250
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O3/taurheim[P]AgNES/./util/tokenUtil.h
// Function: tokenToStr[abi:cxx11](Token)
static std::string tokenToStr(Token t) {
    auto search = tokenToStrMap.find(t.type);
    if (search == tokenToStrMap.end()) {
        return "TOKEN_UTIL_MISSING_TOKEN";
    } else {
        std::stringstream outputString;
        outputString << search->second;
        switch(t.type) {
            case T_INTVALUE:
                outputString << "(" << t.intVal << ")";
                break;
            case T_IDENT:
                outputString << "(" << t.stringVal << ")";
                break;
        }

        return outputString.str();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
movq 0xf7b3(%rip), %rcx      # 0x183d0
testq %rcx, %rcx
je 0x8c57
movq %rsi, %r14
movl (%rsi), %eax
leaq 0xf79a(%rip), %r12      # 0x183c8
xorl %edx, %edx
cmpl %eax, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %r12
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x8c2e
leaq 0xf77d(%rip), %rcx      # 0x183c8
cmpq %rcx, %r12
je 0x8c57
cmpl 0x20(%r12), %eax
jge 0x8c83
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x9683(%rip), %rsi      # 0x122e8
leaq 0x9694(%rip), %rdx      # 0x12300
movq %rbx, %rdi
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x82f0
leaq -0x1a8(%rbp), %rdi
callq 0x31c0
leaq -0x198(%rbp), %r15
movq 0x28(%r12), %rsi
movq 0x30(%r12), %rdx
movq %r15, %rdi
callq 0x32d0
movl (%r14), %eax
cmpl $0x9, %eax
je 0x8cd7
cmpl $0xf, %eax
jne 0x8d0f
leaq 0x99af(%rip), %rsi      # 0x1266b
movl $0x1, %edx
movq %r15, %rdi
callq 0x32d0
movl 0x28(%r14), %esi
movq %r15, %rdi
callq 0x3410
jmp 0x8cfb
leaq 0x998d(%rip), %rsi      # 0x1266b
movl $0x1, %edx
movq %r15, %rdi
callq 0x32d0
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x32d0
leaq 0x95ff(%rip), %rsi      # 0x12301
movl $0x1, %edx
movq %rax, %rdi
callq 0x32d0
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x33a0
movq 0xf283(%rip), %rsi      # 0x17fa8
leaq -0x1a8(%rbp), %rdi
callq 0x31e0
leaq -0x128(%rbp), %rdi
callq 0x3100
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0xf251(%rip), %rsi      # 0x17fa8
leaq -0x1a8(%rbp), %rdi
callq 0x31e0
leaq -0x128(%rbp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O3/taurheim[P]AgNES/parser.cpp
// Function: Parser::function()
ASTNode * Parser::function() {
    /*
        <type> <identifier> <parameterList> <functionBody>
    */
    ASTNode * node = new ASTNode(AST_FUNCTION);

    node->children.push_back(type());
    node->children.push_back(identifier());
    node->children.push_back(parameterList());
    node->children.push_back(functionBody());

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movl $0x20, %edi
callq 0x3290
movq %rax, %rbx
leaq 0x8(%rax), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x2, (%rax)
movq %r15, %rdi
callq 0x90aa
leaq -0x28(%rbp), %r12
movq %rax, (%r12)
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xadac
movq %r15, %rdi
callq 0x9154
movq %rax, (%r12)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x8e65
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x8e71
leaq -0x28(%rbp), %rdx
movq %r14, %rdi
callq 0xadac
movq %r15, %rdi
callq 0x9206
movq %rax, -0x28(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x8e91
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x8e9d
leaq -0x28(%rbp), %rdx
movq %r14, %rdi
callq 0xadac
movq %r15, %rdi
callq 0x92e2
movq %rax, -0x28(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x8ebd
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x8ec9
leaq -0x28(%rbp), %rdx
movq %r14, %rdi
callq 0xadac
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/taurheim[P]AgNES/parser.cpp
// Function: Parser::declaration()
ASTNode * Parser::declaration() {
    /*
        This could be extended to include forward declarations of functions. 
        For now, we only support forward declarations of variables.
        <type> <variableDeclaration> { "," variableDeclaration }
    */
    ASTNode * node = new ASTNode(AST_DECLARATION);
    node->children.push_back(type());
    node->children.push_back(variableDeclaration());

    while (t.type == T_COMMA) {
        next();
        node->children.push_back(variableDeclaration());
    }
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x20, %edi
callq 0x3290
movq %rax, %r14
leaq 0x8(%rax), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x3, (%rax)
movq %rbx, %rdi
callq 0x90aa
leaq -0x28(%rbp), %r12
movq %rax, (%r12)
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xadac
movq %rbx, %rdi
callq 0x9870
movq %rax, (%r12)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
jne 0x8f4e
leaq -0x28(%rbp), %rdx
movq %r15, %rdi
jmp 0x8f58
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x8f5d
callq 0xadac
cmpl $0xa, 0x18(%rbx)
jne 0x8f89
movq %rbx, %rdi
callq 0x899a
movq %rbx, %rdi
callq 0x9870
movq %rax, -0x28(%rbp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
jne 0x8f4e
movq %r15, %rdi
movq %r12, %rdx
jmp 0x8f58
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop