LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fd6
movq %rbx, %rdi
callq 0x3068
cmpl $0x0, 0x504(%rbx)
jle 0x2bab
leaq 0x7ac(%rbx), %r14
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3962
incq %r15
movslq 0x504(%rbx), %rax
addq $0x10, %r14
cmpq %rax, %r15
jl 0x2b8d
movq %rbx, %rdi
callq 0x3134
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_O1/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 0x356a
movq %rbx, %rdi
callq 0x2e14
movq 0x43c8(%rip), %r14      # 0x6fd0
leaq 0x1501(%rip), %rsi      # 0x4110
movl $0x6, %edx
movq %r14, %rdi
callq 0x20f0
movl 0x504(%rbx), %esi
movq %r14, %rdi
callq 0x2190
leaq 0x14e6(%rip), %rsi      # 0x4117
movl $0x19, %edx
movq %rax, %rdi
callq 0x20f0
callq 0x322c
callq 0x356a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2e14
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d98
cmpb $0x0, 0x508(%r14)
jne 0x2d98
movl $0x2, %edi
callq 0x3493
cmpb $0x47, %al
je 0x2ca5
movzbl %al, %ecx
cmpl $0x71, %ecx
jne 0x2cad
jmp 0x2da7
movb $0x1, 0x508(%r14)
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24bc
testb %al, %al
je 0x2cfb
movq %rbx, %rdi
callq 0x272a
movl %eax, %r15d
movq %rbx, %rdi
callq 0x2720
movq %r14, %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x30b6
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 0x2d12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26e6
callq 0x3655
movq %r14, %rdi
callq 0x2e14
movq %rbx, %rdi
callq 0x2702
testb $0x1, %al
jne 0x2d86
cmpb $0x0, 0x508(%r14)
jne 0x2d86
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 0x2d6e
movq %rbx, %rdi
callq 0x26dc
movq %r15, %rdi
movq %r14, %rsi
callq 0x289e
addq $0xc, %r13
cmpq $0x554, %r13            # imm = 0x554
jne 0x2d3b
callq 0x3655
movq %r14, %rdi
callq 0x2e14
jmp 0x2c6c
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_O1/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 0x419a(%rip), %r14      # 0x6fd0
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 0x2e7b
orb %r15b, %al
jne 0x2e7b
movb 0x1(%rbx,%r12), %al
movb %al, -0x2a(%rbp)
movl $0x1, %edx
movq %r14, %rdi
leaq -0x2a(%rbp), %rsi
jmp 0x2eb2
cmpl $0x15, %r13d
je 0x2e89
movb $0x7c, %al
cmpl $-0x1, %r13d
jne 0x2ea3
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 0x2e53
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 0x2e3a
movq 0x40d5(%rip), %r14      # 0x6fd0
leaq 0x1206(%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_O1/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 0x3014
leaq 0x7ac(%rbx), %r14
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3962
incq %r15
movslq 0x504(%rbx), %rax
addq $0x10, %r14
cmpq %rax, %r15
jl 0x2ff6
movl $0x554, %r15d           # imm = 0x554
leaq (%rbx,%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3836
movq %r14, %rdi
xorl %esi, %esi
callq 0x38ac
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3884
addq $0xc, %r15
cmpq $0x7ac, %r15            # imm = 0x7AC
jne 0x301a
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_O1/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 0x3111
movl %edx, %r14d
movl %esi, %r15d
leaq 0x554(%rbx), %r12
xorl %r13d, %r13d
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x389c
testb %al, %al
je 0x30fa
movq %r12, %rdi
callq 0x38b6
incq %r13
movslq 0x504(%rbx), %rax
leaq (%rax,%rax,4), %rax
addq $0xc, %r12
cmpq %rax, %r13
jl 0x30e0
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_O1/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
leaq 0xe8a(%rip), %r12       # 0x4004
movq %r14, %r13
cmpl $0x3, %r15d
ja 0x31d8
movl %r15d, %eax
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r14, %rdi
xorl %esi, %esi
jmp 0x319f
movq -0x38(%rbp), %rdi
movl $0x14, %esi
xorl %edx, %edx
jmp 0x31b9
movq -0x40(%rbp), %rdi
movl $0x14, %esi
jmp 0x31b4
movq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x3c, %edx
callq 0x278a
movq %r13, %rdi
movq %rbx, %rsi
callq 0x289e
incq %r15
addq $0xc, %r13
cmpq $0x4, %r15
jne 0x317d
jmp 0x31e2
movq %r13, %rdi
callq 0x2796
jmp 0x31be
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x88, %rsp
leaq 0xf01(%rip), %rdi       # 0x4144
callq 0x2120
movq %rax, %rbx
testq %rax, %rax
je 0x3256
movsbl (%rbx), %r15d
jmp 0x3259
xorl %r15d, %r15d
movq 0x3d70(%rip), %rdi      # 0x6fd0
callq 0x2060
xorl %edi, %edi
callq 0x21a0
testl %eax, %eax
je 0x32eb
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 -0x19(%rbp), %rsi
movl $0x1, %edx
xorl %edi, %edi
callq 0x2150
movq %rax, %r14
cmpl $0x1, %r14d
jne 0x32dc
cmpb $0x1b, -0x19(%rbp)
jne 0x32dc
callq 0x334f
movb %al, -0x19(%rbp)
leaq -0x60(%rbp), %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x2130
jmp 0x3319
movq 0x3cee(%rip), %rdi      # 0x6fe0
leaq -0x19(%rbp), %rsi
callq 0x2140
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %eax
xorl %r14d, %r14d
andl $0x5, %eax
sete %r14b
testq %rbx, %rbx
je 0x3319
testl %eax, %eax
jne 0x3348
movb -0x19(%rbp), %al
testq %rbx, %rbx
je 0x332f
cmpl $0x1, %r14d
jne 0x332f
movsbl %al, %ecx
cmpl %ecx, %r15d
je 0x3348
xorl %ecx, %ecx
testl %r14d, %r14d
movzbl %al, %eax
cmovlel %ecx, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3411
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 0x3415
movsbl -0x19(%rbp), %edi
movb %dil, -0xd0(%rbp,%r15)
callq 0x2180
movl $0x1, %ecx
testl %eax, %eax
jne 0x3418
leaq 0x1(%r15), %rax
cmpq $0x62, %r15
movq %rax, %r15
jb 0x33d3
jmp 0x3418
movb $0x1b, %al
jmp 0x3473
movl %r15d, %ecx
testl %ecx, %ecx
je 0x3452
movzbl -0xd0(%rbp), %eax
cmpl $0x4f, %eax
je 0x342d
cmpl $0x5b, %eax
jne 0x3452
movzbl -0xcf(%rbp), %eax
addl $-0x41, %eax
cmpl $0x3, %eax
ja 0x3452
leaq 0xcf1(%rip), %rcx       # 0x4134
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $-0x7e, -0x19(%rbp)
jmp 0x3456
movb $0x1b, -0x19(%rbp)
leaq -0x60(%rbp), %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x2130
movl $0x2, %edi
movq %rbx, %rsi
callq 0x2100
movb -0x19(%rbp), %al
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $-0x7b, -0x19(%rbp)
jmp 0x3456
movb $-0x7c, -0x19(%rbp)
jmp 0x3456
movb $-0x7d, -0x19(%rbp)
jmp 0x3456
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x80, %rsp
movl %edi, %ebx
movq 0x3b26(%rip), %rdi      # 0x6fd0
callq 0x2060
xorl %edi, %edi
callq 0x21a0
testl %eax, %eax
je 0x352e
leaq -0x8c(%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, -0x50(%rbp)
movaps %xmm1, -0x40(%rbp)
andb $-0xb, 0xc(%r14)
movaps %xmm2, -0x30(%rbp)
movups %xmm3, -0x24(%rbp)
movb $0x0, 0x17(%r14)
movb %bl, 0x16(%r14)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2130
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
xorl %edi, %edi
callq 0x2150
cmpq $0x1, %rax
jne 0x354a
cmpb $0x1b, -0x11(%rbp)
jne 0x354e
callq 0x334f
movb %al, -0x11(%rbp)
jmp 0x354e
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
xorl %edi, %edi
callq 0x2150
cmpq $0x1, %rax
je 0x355b
movb $0x0, -0x11(%rbp)
jmp 0x355b
movb $0x0, -0x11(%rbp)
leaq -0x50(%rbp), %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0x2130
movb -0x11(%rbp), %al
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x39e1(%rip)     # 0x7100
jne 0x3750
leaq 0xa29(%rip), %rdi       # 0x4151
callq 0x2120
testq %rax, %rax
je 0x3777
movq %rax, %rdi
callq 0x2170
movl %eax, %r15d
testl %eax, %eax
jle 0x3750
movl %r15d, %edi
callq 0x20b0
movl %r15d, 0x39b0(%rip)     # 0x7100
testl %r14d, %r14d
js 0x3767
incl %r14d
callq 0x2040
cltd
idivl %r14d
movl %edx, %eax
addl %ebx, %eax
jmp 0x376c
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 0x3741
jmp 0x3750
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3706
movl %eax, (%rbx)
xorl %edi, %edi
movl $0x3c, %esi
callq 0x3706
movl %eax, 0x4(%rbx)
movl $0x2, %edi
movl $0x5, %esi
callq 0x3706
movl %eax, 0x8(%rbx)
movl $0x6, %edi
movl $0xf, %esi
callq 0x3706
movl %eax, 0xc(%rbx)
movl (%rbx), %ecx
cmpl $0xa, %ecx
jg 0x3928
addl 0x8(%rbx), %ecx
cmpl $0xa, %ecx
jl 0x3928
movl 0x4(%rbx), %ecx
cmpl $0x1e, %ecx
jg 0x3928
addl %eax, %ecx
cmpl $0x1d, %ecx
jg 0x38c9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/justinjo[P]Pacman/boulder.cpp
// Function: Boulder::overlaps_middle()
bool Boulder::overlaps_middle()
{
        bool center_row = (ROWS / 2) >= top_left_r &&
                          (ROWS / 2) <= (top_left_r + height);

        bool center_col = (COLS / 2) >= top_left_c &&
                          (COLS / 2) <= (top_left_c + width);

        return (center_row and center_col);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
cmpl $0xb, %eax
setl %dl
addl 0x8(%rdi), %eax
cmpl $0xa, %eax
setge %sil
cmpl $0x1f, %ecx
setl %al
andb %dl, %al
addl 0xc(%rdi), %ecx
cmpl $0x1e, %ecx
setge %cl
andb %sil, %al
andb %cl, %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x8(%rdi)
js 0x39ca
pushq %rbp
movq %rsp, %rbp
movslq (%rdi), %rax
imulq $0x3d, %rax, %rcx
addq %rcx, %rsi
cmpl $0x0, 0xc(%rdi)
js 0x39af
movslq 0x4(%rdi), %rcx
cmpq $0x15, %rax
setge %dl
cmpq $0x3d, %rcx
setge %r8b
orb %dl, %r8b
jne 0x3998
movb $0x58, (%rsi,%rcx)
leaq 0x1(%rcx), %rdx
movslq 0x4(%rdi), %r8
movslq 0xc(%rdi), %r9
addq %r8, %r9
cmpq %r9, %rcx
movq %rdx, %rcx
jl 0x3980
leaq 0x1(%rax), %rcx
movslq (%rdi), %rdx
movslq 0x8(%rdi), %r8
addq %rdx, %r8
addq $0x3d, %rsi
cmpq %r8, %rax
movq %rcx, %rax
jl 0x3976
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd891(%rip), %r15      # 0x11020
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 0x3792
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 0x6dac
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_O1/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 0x754b
movq (%r15), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rdi,%rax)
jne 0x754b
leaq 0x10(%r15), %r13
leaq -0x68(%rbp), %rbx
movq %r13, %rsi
callq 0x3320
movb (%r13), %al
movb %al, -0x68(%rbp)
movl $0x1, %edx
movq 0x10ab2(%rip), %rdi     # 0x17fd0
movq %rbx, %rsi
callq 0x32d0
movb (%r13), %r14b
movsbl %r14b, %r12d
movl %r12d, %edi
callq 0x3080
testl %eax, %eax
je 0x754b
movq (%r15), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%rdi,%rax)
je 0x7503
movl %r12d, %edi
callq 0x33b0
testl %eax, %eax
je 0x7565
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x767c
jmp 0x757b
addl $-0x30, %r12d
cmpl $0x9, %r12d
ja 0x75c6
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x77c0
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 0x75b4
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 0x75de
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x787c
movq -0x38(%rbp), %r14
jmp 0x75ff
movq (%r15), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x2, 0x20(%rax,%rcx)
movq -0x38(%rbp), %r14
jne 0x760b
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x79d4
leaq -0x60(%rbp), %rbx
movl -0x8(%rbx), %eax
jmp 0x7586
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 0x75af
jmp 0x75b4
jmp 0x765e
jmp 0x765e
jmp 0x765e
jmp 0x765e
movq %rax, %rbx
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x70(%rbp), %rdi
je 0x7673
callq 0x3250
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7705
leaq 0x10(%r14), %r15
movq 0x1090d(%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 0x76c7
leaq 0x10c1c(%rip), %rdi     # 0x18328
leaq -0x58(%rbp), %rsi
callq 0x86d0
leaq 0x10c14(%rip), %rcx     # 0x18330
cmpq %rcx, %rax
movq -0x38(%rbp), %rbx
je 0x7740
movl 0x40(%rax), %eax
movl %eax, (%rbx)
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
jmp 0x776a
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 0x777c
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 0x77a5
callq 0x3250
jmp 0x77a5
jmp 0x77a2
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x77b7
callq 0x3250
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7850
movq %rsi, %r14
leaq 0x10(%rsi), %r15
movq 0x107bd(%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 0x7817
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 0x7874
callq 0x3250
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7946
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 0x10715(%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 0x106cf(%rip), %rdi     # 0x17fd0
movl $0x1, %edx
callq 0x32d0
cmpb $0x27, (%r14)
jne 0x7970
movq (%r15), %rdi
movq %r14, %rsi
callq 0x3320
movb (%r14), %al
leaq -0x21(%rbp), %rsi
movb %al, (%rsi)
movq 0x106a4(%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 0xa92f(%rip), %rsi      # 0x12284
leaq 0xa940(%rip), %rdx      # 0x1229c
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0x8354
movq %rbx, %rsi
callq 0x7bae
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xa91e(%rip), %rsi      # 0x1229d
leaq 0xa941(%rip), %rdx      # 0x122c7
leaq -0x48(%rbp), %rdi
callq 0x8354
leaq -0x48(%rbp), %rsi
callq 0x7bae
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x79be
callq 0x3250
jmp 0x79be
jmp 0x79bb
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
jne 0x79c7
jmp 0x79cc
movq %rax, %r14
movq 0x8(%rbx), %rdi
cmpq %r12, %rdi
je 0x79cc
callq 0x3250
movq %r14, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf771(%rip), %r14      # 0x17fd0
leaq 0x9b91(%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 0x8942
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 0x9bec(%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 0x9ffd
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x891a
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 0x893a
callq 0x3250
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/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 0x89f1
movq %r14, %r15
addq $0x8, %r15
leaq -0x30(%rbp), %r12
leaq -0x34(%rbp), %r13
movq %rbx, %rdi
movl $0x2, %esi
callq 0x8dee
movq %rbx, %rdi
cmpl $0x4, %eax
jne 0x89ad
callq 0x8e66
movq %rax, -0x30(%rbp)
jmp 0x89c8
callq 0x8f58
movq %rax, -0x30(%rbp)
movl $0x3, -0x34(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x903c
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x89e0
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x89eb
movq %r15, %rdi
movq %r12, %rdx
callq 0xadc8
cmpl $0xb, 0x18(%rbx)
jne 0x898d
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_O1/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 0x8ad7
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 0x6992
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 0x8c6b
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0xf53b(%rip), %rdi      # 0x17fd0
callq 0x32d0
leaq 0x9db1(%rip), %rsi      # 0x12852
movl $0x1, %edx
movq %rax, %rdi
callq 0x32d0
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
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x991c(%rip), %rsi      # 0x12402
leaq 0x9923(%rip), %rdx      # 0x12410
leaq -0x30(%rbp), %rdi
callq 0x8354
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x8b40
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x8b2e
movq %rax, %rbx
jmp 0x8b38
movq %rax, %rbx
jmp 0x8b2a
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8b2a
callq 0x3250
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x8b38
callq 0x3250
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
movq 0xf746(%rip), %rdx      # 0x183d0
leaq 0xf737(%rip), %rax      # 0x183c8
movq %rax, %rcx
testq %rdx, %rdx
je 0x8cba
movl (%r14), %esi
leaq 0xf725(%rip), %rcx      # 0x183c8
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x8ca3
movq %rax, %r12
cmpq %rax, %rcx
je 0x8cd3
movl (%r14), %edx
cmpl 0x20(%rcx), %edx
leaq 0xf6f9(%rip), %r12      # 0x183c8
cmovgeq %rcx, %r12
cmpq %rax, %r12
je 0x8d2c
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 0x8d4b
cmpl $0xf, %eax
jne 0x8d83
leaq 0x995a(%rip), %rsi      # 0x1266b
movl $0x1, %edx
movq %r15, %rdi
callq 0x32d0
movl 0x28(%r14), %esi
movq %r15, %rdi
callq 0x3410
jmp 0x8d6f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x95ae(%rip), %rsi      # 0x122e8
leaq 0x95bf(%rip), %rdx      # 0x12300
movq %rbx, %rdi
callq 0x8354
jmp 0x8db1
leaq 0x9919(%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 0x958b(%rip), %rsi      # 0x12301
movl $0x1, %edx
movq %rax, %rdi
callq 0x32d0
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x33a0
movq 0xf20f(%rip), %rsi      # 0x17fa8
leaq -0x1a8(%rbp), %rdi
callq 0x31e0
leaq -0x128(%rbp), %rdi
callq 0x3100
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0xf1da(%rip), %rsi      # 0x17fa8
leaq -0x1a8(%rbp), %rdi
callq 0x31e0
leaq -0x128(%rbp), %rdi
callq 0x3100
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
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 0x9164
movq %rax, -0x20(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x8eb9
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x8ec5
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
callq 0xaf02
movq %r15, %rdi
callq 0x920e
movq %rax, -0x20(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x8ee5
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x8ef1
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
callq 0xaf02
movq %r15, %rdi
callq 0x92c0
movq %rax, -0x20(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x8f11
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x8f1d
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
callq 0xaf02
movq %r15, %rdi
callq 0x93ae
movq %rax, -0x20(%rbp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x8f3d
movq %rax, (%rsi)
addq $0x8, 0x10(%rbx)
jmp 0x8f49
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
callq 0xaf02
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9164
movq %rax, -0x28(%rbp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x8fb0
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x8fbc
leaq -0x28(%rbp), %rdx
movq %r15, %rdi
callq 0xaf02
movq %rbx, %rdi
callq 0x9944
movq %rax, -0x28(%rbp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x8fdc
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x8fe8
leaq -0x28(%rbp), %rdx
movq %r15, %rdi
callq 0xaf02
cmpl $0xa, 0x18(%rbx)
jne 0x902b
leaq -0x28(%rbp), %r12
movq %rbx, %rdi
callq 0x8a04
movq %rbx, %rdi
callq 0x9944
movq %rax, -0x28(%rbp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x901a
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x9025
movq %r15, %rdi
movq %r12, %rdx
callq 0xaf02
cmpl $0xa, 0x18(%rbx)
je 0x8ff2
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/taurheim[P]AgNES/parser.cpp
// Function: Parser::expect(TokenType const&)
void Parser::expect(const TokenType & type) {
    if (t.type != type) {
        std::string err("Expected: ");
        std::string nodeString;
        auto search = tokenToStrMap.find(type);
        if (search != tokenToStrMap.end()) {
            nodeString = search->second;
        } else {
            nodeString = "NOTFOUND";
        }
        err.append(nodeString);
        reject(err);
    } else {
        // Consume
        next();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl 0x18(%rdi), %eax
cmpl (%rsi), %eax
jne 0x9069
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8a04
movq %rsi, %r14
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x93d7(%rip), %rsi      # 0x12452
leaq 0x93da(%rip), %rdx      # 0x1245c
leaq -0x60(%rbp), %rdi
callq 0x8354
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0xf327(%rip), %rdx      # 0x183d0
leaq 0xf318(%rip), %rax      # 0x183c8
movq %rax, %rcx
testq %rdx, %rdx
je 0x90d9
movl (%r14), %esi
leaq 0xf306(%rip), %rcx      # 0x183c8
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x90c2
movq %rax, %rsi
cmpq %rax, %rcx
je 0x90f2
movl (%r14), %edx
cmpl 0x20(%rcx), %edx
leaq 0xf2da(%rip), %rsi      # 0x183c8
cmovgeq %rcx, %rsi
cmpq %rax, %rsi
jne 0x9113
leaq 0x935f(%rip), %rcx      # 0x1245d
leaq -0x40(%rbp), %rdi
movl $0x8, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x3390
jmp 0x9120
addq $0x28, %rsi
leaq -0x40(%rbp), %rdi
callq 0x3180
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x30f0
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x8b40
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x914e
callq 0x3250
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x915c
callq 0x3250
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O1/taurheim[P]AgNES/parser.cpp
// Function: Parser::type()
ASTNode * Parser::type() {
    /*
        Terminal
    */
    TypeNode * node = new TypeNode();
    switch(t.type) {
        case T_INT: {
            node->varType = VT_INT;
            break;
        }
        case T_CHAR: {
            node->varType = VT_CHAR;
            break;
        }
        default: {
            reject("Type not recognized");
        }
    }

    next();
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x28, %edi
callq 0x3290
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x6, (%rax)
movl 0x18(%rbx), %ecx
movl $0x1, %eax
cmpl $0xe, %ecx
je 0x91ad
cmpl $0x10, %ecx
jne 0x91c7
movl $0x2, %eax
movl %eax, 0x20(%r14)
movq %rbx, %rdi
callq 0x8a04
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x924f(%rip), %rsi      # 0x12425
leaq 0x925b(%rip), %rdx      # 0x12438
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x8354
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8b40
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x9205
callq 0x3250
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/taurheim[P]AgNES/parser.cpp
// Function: Parser::identifier()
ASTNode * Parser::identifier() {
    /*
        Terminal
    */
    if (t.type != TokenType::T_IDENT) {
        reject("Expected identifier");
    }

    IdentifierNode * node = new IdentifierNode();
    node->name = t.stringVal;

    next();
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x9, 0x18(%rdi)
jne 0x9279
movl $0x40, %edi
callq 0x3290
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
xorl %eax, %eax
movq %rax, 0x18(%r14)
movl $0x4, (%r14)
leaq 0x20(%r14), %rdi
leaq 0x30(%r14), %rcx
movq %rcx, 0x20(%r14)
movq %rax, 0x28(%r14)
movb $0x0, 0x30(%r14)
leaq 0x20(%rbx), %rsi
callq 0x3180
movq %rbx, %rdi
callq 0x8a04
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x9189(%rip), %rsi      # 0x12411
leaq 0x9195(%rip), %rdx      # 0x12424
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x8354
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8b40
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x92b7
callq 0x3250
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O1/taurheim[P]AgNES/parser.cpp
// Function: Parser::parameterList()
ASTNode * Parser::parameterList() {
    /*
        "(" [<parameter> {"," <parameter> }] ")"
    */
    ASTNode * node = new ASTNode(AST_PARAMETERLIST);

    expect(T_LPAREN);

    if(t.type != T_RPAREN) {
        // We have one or more parameters
        node->children.push_back(parameter());

        // Consume the rest of the params
        while(t.type == T_COMMA) {
            expect(T_COMMA);
            node->children.push_back(parameter());
        }
    }

    
    expect(T_RPAREN);

    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, %r15
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x7, (%rax)
leaq -0x28(%rbp), %rsi
movl $0x4, (%rsi)
movq %rbx, %rdi
callq 0x903c
cmpl $0x5, 0x18(%rbx)
je 0x938c
addq $0x8, %r15
movq %rbx, %rdi
callq 0x98aa
movq %rax, -0x28(%rbp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x9333
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x933f
leaq -0x28(%rbp), %rdx
movq %r15, %rdi
callq 0xaf02
cmpl $0xa, 0x18(%rbx)
jne 0x938c
leaq -0x28(%rbp), %r12
movl $0xa, -0x28(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x903c
movq %rbx, %rdi
callq 0x98aa
movq %rax, -0x28(%rbp)
movq 0x10(%r14), %rsi
cmpq 0x18(%r14), %rsi
je 0x937b
movq %rax, (%rsi)
addq $0x8, 0x10(%r14)
jmp 0x9386
movq %r15, %rdi
movq %r12, %rdx
callq 0xaf02
cmpl $0xa, 0x18(%rbx)
je 0x9349
leaq -0x28(%rbp), %rsi
movl $0x5, (%rsi)
movq %rbx, %rdi
callq 0x903c
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq