LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x39dd
cmpl $0x0, -0xc(%rbp)
jne 0x390f
movq -0x18(%rbp), %rdi
addq $0x524, %rdi            # imm = 0x524
movslq -0xc(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2c40
jmp 0x39b1
cmpl $0x1, -0xc(%rbp)
jne 0x3939
movq -0x18(%rbp), %rdi
addq $0x524, %rdi            # imm = 0x524
movslq -0xc(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x3c, %edx
callq 0x2c40
jmp 0x39af
cmpl $0x2, -0xc(%rbp)
jne 0x3963
movq -0x18(%rbp), %rdi
addq $0x524, %rdi            # imm = 0x524
movslq -0xc(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
movl $0x14, %esi
xorl %edx, %edx
callq 0x2c40
jmp 0x39ad
cmpl $0x3, -0xc(%rbp)
jne 0x3990
movq -0x18(%rbp), %rdi
addq $0x524, %rdi            # imm = 0x524
movslq -0xc(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
movl $0x14, %esi
movl $0x3c, %edx
callq 0x2c40
jmp 0x39ab
movq -0x18(%rbp), %rdi
addq $0x524, %rdi            # imm = 0x524
movslq -0xc(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
callq 0x2c60
jmp 0x39ad
jmp 0x39af
jmp 0x39b1
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x524, %rdi            # imm = 0x524
movslq -0xc(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
callq 0x2e20
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x38db
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movb $0x0, -0x1(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x16e9(%rip), %rdi      # 0x5137
callq 0x21c0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x3a66
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x1(%rbp)
movq 0x455b(%rip), %rdi      # 0x7fc8
movq 0x455c(%rip), %rsi      # 0x7fd0
callq 0x2130
xorl %edi, %edi
callq 0x2280
cmpl $0x0, %eax
je 0x3b26
xorl %edi, %edi
leaq -0x54(%rbp), %rsi
callq 0x2180
leaq -0x90(%rbp), %rdi
leaq -0x54(%rbp), %rsi
movl $0x3c, %edx
callq 0x20c0
leaq 0x4710(%rip), %rdi      # 0x81c0
leaq -0x90(%rbp), %rsi
movl $0x3c, %edx
callq 0x20c0
movl $0x1, 0x4731(%rip)      # 0x81fc
movl -0x48(%rbp), %eax
andl $-0x9, %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x48(%rbp)
xorl %esi, %esi
leaq -0x54(%rbp), %rdx
movl %esi, %edi
callq 0x21f0
xorl %edi, %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x2210
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jne 0x3b14
movsbl -0x11(%rbp), %eax
cmpl $0x1b, %eax
jne 0x3b14
callq 0x3bc0
movb %al, -0x11(%rbp)
xorl %esi, %esi
leaq -0x90(%rbp), %rdx
movl %esi, %edi
callq 0x21f0
jmp 0x3b71
movq 0x44b3(%rip), %rdi      # 0x7fe0
leaq -0x11(%rbp), %rsi
callq 0x2200
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x21e0
testb $0x1, %al
jne 0x3b4b
jmp 0x3b54
movl $0x1, -0x18(%rbp)
jmp 0x3b5b
movl $0x0, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x3b6f
cmpq $0x0, -0x10(%rbp)
je 0x3b6f
xorl %edi, %edi
callq 0x21b0
jmp 0x3b71
cmpl $0x1, -0x18(%rbp)
jne 0x3b91
cmpq $0x0, -0x10(%rbp)
je 0x3b91
movsbl -0x11(%rbp), %eax
movsbl -0x1(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3b91
xorl %edi, %edi
callq 0x21b0
cmpl $0x0, -0x18(%rbp)
jle 0x3ba3
movsbl -0x11(%rbp), %eax
movl %eax, -0x94(%rbp)
jmp 0x3bad
xorl %eax, %eax
movl %eax, -0x94(%rbp)
jmp 0x3bad
movl -0x94(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0xe4(%rbp)
xorl %edi, %edi
callq 0x2280
cmpl $0x0, %eax
jne 0x3bea
movb $0x1b, -0x1(%rbp)
jmp 0x3d65
movl $0x2, %edi
movl $0x1, %esi
callq 0x21a0
movq %rax, -0xf0(%rbp)
xorl %edi, %edi
leaq -0x40(%rbp), %rsi
callq 0x2180
leaq -0x7c(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x3c, %edx
callq 0x20c0
movl -0x34(%rbp), %eax
andl $-0x9, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x34(%rbp)
movb $0x0, -0x29(%rbp)
movb $0x1, -0x2a(%rbp)
xorl %esi, %esi
leaq -0x40(%rbp), %rdx
movl %esi, %edi
callq 0x21f0
xorl %edi, %edi
leaq -0xe5(%rbp), %rsi
movl $0x1, %edx
callq 0x2210
cmpq $0x1, %rax
jne 0x3c7f
movb -0xe5(%rbp), %cl
movl -0xe4(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0xe4(%rbp)
cltq
movb %cl, -0xe0(%rbp,%rax)
jmp 0x3c81
jmp 0x3cb8
jmp 0x3c83
movsbl -0xe5(%rbp), %edi
callq 0x2250
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xf1(%rbp)
jne 0x3cae
cmpl $0x63, -0xe4(%rbp)
setl %al
movb %al, -0xf1(%rbp)
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x3c44
cmpl $0x0, -0xe4(%rbp)
je 0x3cd9
movsbl -0xe0(%rbp), %eax
cmpl $0x5b, %eax
je 0x3ce2
movsbl -0xe0(%rbp), %eax
cmpl $0x4f, %eax
je 0x3ce2
movb $0x1b, -0xe5(%rbp)
jmp 0x3d3e
movsbl -0xdf(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x100(%rbp)
subl $0x3, %eax
ja 0x3d35
movq -0x100(%rbp), %rax
leaq 0x141c(%rip), %rcx      # 0x5124
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $-0x7e, -0xe5(%rbp)
jmp 0x3d3c
movb $-0x7d, -0xe5(%rbp)
jmp 0x3d3c
movb $-0x7b, -0xe5(%rbp)
jmp 0x3d3c
movb $-0x7c, -0xe5(%rbp)
jmp 0x3d3c
movb $0x1b, -0xe5(%rbp)
jmp 0x3d3e
xorl %esi, %esi
leaq -0x7c(%rbp), %rdx
movl %esi, %edi
callq 0x21f0
movq -0xf0(%rbp), %rsi
movl $0x2, %edi
callq 0x21a0
movb -0xe5(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq 0x4233(%rip), %rdi      # 0x7fc8
movq 0x4234(%rip), %rsi      # 0x7fd0
callq 0x2130
xorl %edi, %edi
callq 0x2280
cmpl $0x0, %eax
je 0x3e52
xorl %edi, %edi
leaq -0x44(%rbp), %rsi
callq 0x2180
leaq -0x80(%rbp), %rdi
leaq -0x44(%rbp), %rsi
movl $0x3c, %edx
callq 0x20c0
leaq 0x43eb(%rip), %rdi      # 0x81c0
leaq -0x80(%rbp), %rsi
movl $0x3c, %edx
callq 0x20c0
movl $0x1, 0x440f(%rip)      # 0x81fc
movl -0x38(%rbp), %eax
andl $-0x9, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x38(%rbp)
movb $0x0, -0x2d(%rbp)
movl -0x4(%rbp), %eax
movb %al, -0x2e(%rbp)
xorl %esi, %esi
leaq -0x44(%rbp), %rdx
movl %esi, %edi
callq 0x21f0
xorl %edi, %edi
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x2210
cmpq $0x1, %rax
jne 0x3e3f
movsbl -0x5(%rbp), %eax
cmpl $0x1b, %eax
jne 0x3e3d
callq 0x3bc0
movb %al, -0x5(%rbp)
jmp 0x3e43
movb $0x0, -0x5(%rbp)
xorl %esi, %esi
leaq -0x80(%rbp), %rdx
movl %esi, %edi
callq 0x21f0
jmp 0x3e6e
xorl %edi, %edi
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x2210
cmpq $0x1, %rax
je 0x3e6c
movb $0x0, -0x5(%rbp)
jmp 0x3e6e
movsbl -0x5(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $-0x1, 0x418f(%rip)     # 0x8180
jne 0x402e
leaq 0x114a(%rip), %rdi      # 0x5144
callq 0x21c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x401c
movq -0x18(%rbp), %rdi
callq 0x2240
movl %eax, %edi
callq 0x3fa0
jmp 0x402c
xorl %eax, %eax
movl %eax, %edi
callq 0x2100
movl %eax, %edi
callq 0x3fa0
jmp 0x402e
cmpl $0x0, -0x10(%rbp)
jg 0x403d
movl $0x11, -0x4(%rbp)
jmp 0x4054
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x2040
cltd
idivl -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl %edx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: justinjo[P]Pacman/dot.cpp
// Function: Dot::set_random_location(char (*) [61])
void Dot::set_random_location(char board[ROWS][COLS])
{
        do {
                row = random_int(0, ROWS-1);
                col = random_int(0, COLS-1);
        } while (board[row][col]!=SPACE || (row==MIDROW || col==MIDCOL));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %edi, %edi
movl $0x14, %esi
callq 0x3fd0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
xorl %edi, %edi
movl $0x3c, %esi
callq 0x3fd0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq (%rcx), %rdx
imulq $0x3d, %rdx, %rdx
addq %rdx, %rax
movslq 0x4(%rcx), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x19(%rbp)
jne 0x44d7
movq -0x18(%rbp), %rcx
movb $0x1, %al
cmpl $0xa, (%rcx)
movb %al, -0x1a(%rbp)
je 0x44d1
movq -0x18(%rbp), %rax
cmpl $0x1e, 0x4(%rax)
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x4468
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %edi, %edi
movl $0x14, %esi
callq 0x3fd0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
xorl %edi, %edi
movl $0x3c, %esi
callq 0x3fd0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x2, %edi
movl $0x5, %esi
callq 0x3fd0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x6, %edi
movl $0xf, %esi
callq 0x3fd0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x4620
testb $0x1, %al
jne 0x45b4
addq $0x10, %rsp
popq %rbp
retq
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
movl $0xa, %ecx
cmpl (%rdx), %ecx
movb %al, -0xb(%rbp)
jl 0x4654
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl 0x8(%rax), %ecx
movl $0xa, %eax
cmpl %ecx, %eax
setle %al
movb %al, -0xb(%rbp)
movq -0x18(%rbp), %rdx
movb -0xb(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
xorl %eax, %eax
movl $0x1e, %ecx
cmpl 0x4(%rdx), %ecx
movb %al, -0x19(%rbp)
jl 0x4686
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
addl 0xc(%rax), %ecx
movl $0x1e, %eax
cmpl %ecx, %eax
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0xa(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0x1a(%rbp)
je 0x469f
movb -0xa(%rbp), %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %eax
movl (%rdx), %ecx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jg 0x4731
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rdx
movl -0x18(%rbp), %eax
movl 0x4(%rdx), %ecx
addl 0xc(%rdx), %ecx
cmpl %ecx, %eax
jg 0x4724
cmpl $0x15, -0x14(%rbp)
jge 0x4717
cmpl $0x3d, -0x18(%rbp)
jge 0x4717
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x3d, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb $0x58, (%rax,%rcx)
jmp 0x4719
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x46e3
jmp 0x4726
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x46c9
popq %rbp
retq
// File: 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
subq $0xa0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rax, -0x98(%rbp)
movq %rax, %rcx
movq %rcx, -0x90(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x4220
movq -0x88(%rbp), %rdi
movq %rax, %rdx
movq %rdx, %rax
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x80(%rbp)
movq %rcx, %rsp
movq %rax, -0x30(%rbp)
callq 0x4110
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x42e0
movq -0x80(%rbp), %rdi
callq 0x42c0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
leaq -0x20(%rbp), %rdx
callq 0x44c0
movl $0x0, -0x64(%rbp)
cmpl $0x10, -0x64(%rbp)
jge 0x4ade
movl -0x64(%rbp), %eax
shll %eax
cltq
leaq -0x60(%rbp), %rdi
addq %rax, %rdi
movslq -0x64(%rbp), %rax
movzbl -0x20(%rbp,%rax), %edx
leaq 0x18548(%rip), %rsi     # 0x1d014
movb $0x0, %al
callq 0x45e0
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x4aa8
leaq -0x65(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4590
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rdx
leaq -0x60(%rbp), %rsi
callq 0x72c0
jmp 0x4b07
leaq -0x65(%rbp), %rdi
callq 0x4670
movq -0x90(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x65(%rbp), %rdi
callq 0x4670
movq -0x70(%rbp), %rdi
callq 0x43f0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x120(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xe5e0
movq -0x120(%rbp), %rax
movsbl 0x10(%rax), %edi
callq 0x3080
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x131(%rbp)
je 0xd3c6
movq -0x120(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3580
movb %al, -0x132(%rbp)
jmp 0xd3b8
movb -0x132(%rbp), %al
xorb $-0x1, %al
movb %al, -0x131(%rbp)
movb -0x131(%rbp), %al
testb $0x1, %al
jne 0xd3d2
jmp 0xd3ff
movq -0x120(%rbp), %rdi
callq 0xd300
jmp 0xd3e0
jmp 0xd378
movq -0x130(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9260
jmp 0xd59c
movq -0x120(%rbp), %rax
movsbl 0x10(%rax), %edi
callq 0x34b0
cmpl $0x0, %eax
je 0xd444
movq -0x120(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xd5b0
jmp 0xd426
movq -0x130(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe600
leaq -0x58(%rbp), %rdi
callq 0x9260
jmp 0xd576
movq -0x120(%rbp), %rax
movsbl 0x10(%rax), %edi
callq 0x32b0
cmpl $0x0, %eax
je 0xd492
movq -0x120(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0xd710
jmp 0xd46e
movq -0x130(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xe600
leaq -0x88(%rbp), %rdi
callq 0x9260
jmp 0xd574
movq -0x120(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x27, %eax
jne 0xd4db
movq -0x120(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0xd7d0
jmp 0xd4b7
movq -0x130(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0xe600
leaq -0xb8(%rbp), %rdi
callq 0x9260
jmp 0xd572
movq -0x120(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3580
movb %al, -0x133(%rbp)
jmp 0xd4fc
movb -0x133(%rbp), %al
testb $0x1, %al
jne 0xd508
jmp 0xd53c
leaq -0xe8(%rbp), %rdi
movl $0xb, %esi
callq 0xe650
jmp 0xd51b
movq -0x130(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0xe600
leaq -0xe8(%rbp), %rdi
callq 0x9260
jmp 0xd570
movq -0x120(%rbp), %rsi
leaq -0x118(%rbp), %rdi
callq 0xd9a0
jmp 0xd551
movq -0x130(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0xe600
leaq -0x118(%rbp), %rdi
callq 0x9260
jmp 0xd572
jmp 0xd574
jmp 0xd576
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xd58c
movq -0x130(%rbp), %rdi
callq 0x9260
movq -0x128(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3520
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3410
movq -0x60(%rbp), %rax
movsbl 0x10(%rax), %edi
callq 0x34b0
cmpl $0x0, %eax
je 0xd622
movq -0x60(%rbp), %rax
movsbl 0x10(%rax), %esi
leaq -0x30(%rbp), %rdi
callq 0x31e0
jmp 0xd604
movq -0x60(%rbp), %rdi
callq 0xd300
jmp 0xd60f
jmp 0xd5df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd6f4
leaq 0x27daf(%rip), %rdi     # 0x353d8
leaq -0x30(%rbp), %rsi
callq 0xe680
movq %rax, -0x78(%rbp)
jmp 0xd638
movq -0x78(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x27d91(%rip), %rdi     # 0x353d8
callq 0xe6e0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xe6b0
testb $0x1, %al
jne 0xd663
jmp 0xd6c0
movq -0x70(%rbp), %rdi
movb $0x0, -0x51(%rbp)
callq 0xe5e0
jmp 0xd672
movq -0x70(%rbp), %rdi
movl $0x9, (%rdi)
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x3040
jmp 0xd68b
movb $0x1, -0x51(%rbp)
movl $0x1, -0x58(%rbp)
testb $0x1, -0x51(%rbp)
jne 0xd6be
jmp 0xd6b5
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x9260
jmp 0xd6f4
movq -0x70(%rbp), %rdi
callq 0x9260
jmp 0xd6de
leaq -0x48(%rbp), %rdi
callq 0xe710
movq -0x70(%rbp), %rdi
movl 0x20(%rax), %esi
callq 0xe650
jmp 0xd6d7
movl $0x1, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31d0
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31d0
movq -0x38(%rbp), %rdi
callq 0x3520
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xe5e0
movq -0x30(%rbp), %rdi
movl $0xf, (%rdi)
movl $0x0, 0x28(%rdi)
movq -0x38(%rbp), %rax
movsbl 0x10(%rax), %edi
callq 0x32b0
cmpl $0x0, %eax
je 0xd79e
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x28(%rax), %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %esi
movsbl 0x10(%rdi), %edx
movl %edx, %ecx
movl %esi, %edx
leal -0x30(%rcx,%rdx,2), %ecx
movl %ecx, 0x28(%rax)
callq 0xd300
jmp 0xd785
jmp 0xd74d
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9260
jmp 0xd7bb
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xd7b1
movq -0x30(%rbp), %rdi
callq 0x9260
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3520
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movsbl 0x10(%rax), %eax
cmpl $0x27, %eax
je 0xd87f
leaq -0x31(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3530
movq -0x90(%rbp), %rdx
leaq 0x16a69(%rip), %rsi     # 0x24289
leaq -0x30(%rbp), %rdi
callq 0x33f0
jmp 0xd82b
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdb20
jmp 0xd83a
leaq -0x30(%rbp), %rdi
callq 0x31d0
leaq -0x31(%rbp), %rdi
callq 0x3350
jmp 0xd87f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xd871
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31d0
leaq -0x31(%rbp), %rdi
callq 0x3350
jmp 0xd989
movq -0x78(%rbp), %rdi
callq 0xd300
movq -0x88(%rbp), %rdi
movb $0x0, -0x45(%rbp)
callq 0xe5e0
movq -0x88(%rbp), %rax
movq -0x78(%rbp), %rdi
movl $0x11, (%rax)
movb 0x10(%rdi), %cl
movb %cl, 0x2c(%rax)
callq 0xd300
jmp 0xd8b6
movq -0x78(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x27, %eax
je 0xd94f
leaq -0x69(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3530
movq -0x98(%rbp), %rdx
leaq 0x169bd(%rip), %rsi     # 0x242a2
leaq -0x68(%rbp), %rdi
callq 0x33f0
jmp 0xd8f0
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xdb20
jmp 0xd8ff
leaq -0x68(%rbp), %rdi
callq 0x31d0
leaq -0x69(%rbp), %rdi
callq 0x3350
jmp 0xd94f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xd97d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xd944
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31d0
leaq -0x69(%rbp), %rdi
callq 0x3350
jmp 0xd97d
movq -0x78(%rbp), %rdi
callq 0xd300
jmp 0xd95a
movb $0x1, -0x45(%rbp)
testb $0x1, -0x45(%rbp)
jne 0xd970
movq -0x88(%rbp), %rdi
callq 0x9260
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x9260
movq -0x40(%rbp), %rdi
callq 0x3520
nopw %cs:(%rax,%rax)
// File: taurheim[P]AgNES/scanner.cpp
// Function: Scanner::identifySpecialToken()
Token Scanner::identifySpecialToken() {
    char firstChar = ch;
    getChar();
    switch (firstChar) {
        case '<': {
            if (ch == '=') {
                getChar();
                return Token(T_LESSEQUAL);
            }
        }
        case '>': {
            if (ch == '=') {
                getChar();
                return Token(T_GREATEREQUAL);
            }
        }
        case '&': {
            if (ch == '&') {
                getChar();
                return Token(T_AND);
            }
        }
        case '|' : {
            if (ch == '|') {
                getChar();
                return Token(T_OR);
            }
        }
        default: {
           break;
        }
    }
    auto search = charToToken.find(firstChar);
    if (search == charToToken.end()) {
        std::cerr << "Invalid character!";
        exit(1);
    } 
    return { search->second };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movb 0x10(%rdi), %al
movb %al, -0x11(%rbp)
callq 0xd300
movsbl -0x11(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0x26, %eax
je 0xda57
jmp 0xd9dc
movl -0x2c(%rbp), %eax
subl $0x3c, %eax
je 0xda01
jmp 0xd9e6
movl -0x2c(%rbp), %eax
subl $0x3e, %eax
je 0xda2c
jmp 0xd9f0
movl -0x2c(%rbp), %eax
subl $0x7c, %eax
je 0xda82
jmp 0xdaaa
movq -0x38(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x3d, %eax
jne 0xda2a
movq -0x38(%rbp), %rdi
callq 0xd300
movq -0x48(%rbp), %rdi
movl $0x1a, %esi
callq 0xe650
jmp 0xdb15
jmp 0xda2c
movq -0x38(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x3d, %eax
jne 0xda55
movq -0x38(%rbp), %rdi
callq 0xd300
movq -0x48(%rbp), %rdi
movl $0x1b, %esi
callq 0xe650
jmp 0xdb15
jmp 0xda57
movq -0x38(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x26, %eax
jne 0xda80
movq -0x38(%rbp), %rdi
callq 0xd300
movq -0x48(%rbp), %rdi
movl $0x1c, %esi
callq 0xe650
jmp 0xdb15
jmp 0xda82
movq -0x38(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x7c, %eax
jne 0xdaa8
movq -0x38(%rbp), %rdi
callq 0xd300
movq -0x48(%rbp), %rdi
movl $0x1d, %esi
callq 0xe650
jmp 0xdb15
jmp 0xdaaa
jmp 0xdaac
leaq 0x278f5(%rip), %rdi     # 0x353a8
leaq -0x11(%rbp), %rsi
callq 0xe730
movq %rax, -0x20(%rbp)
leaq 0x278e1(%rip), %rdi     # 0x353a8
callq 0xe790
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe760
testb $0x1, %al
jne 0xdae3
jmp 0xdb00
movq 0x27506(%rip), %rdi     # 0x34ff0
leaq 0x16785(%rip), %rsi     # 0x24276
callq 0x32e0
movl $0x1, %edi
callq 0x3390
leaq -0x20(%rbp), %rdi
callq 0xe7c0
movq -0x48(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0xe650
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: taurheim[P]AgNES/scanner.cpp
// Function: Scanner::scan[abi:cxx11]()
std::list<Token> Scanner::scan() {
    std::cout << "Scanning...\n";
    getChar();

    std::list<Token> tokenList;
    while (true) {
        Token t = getNextToken();
        tokenList.push_back(t);

        if (t.type == T_EOF_TOKEN) break;
    }

    if (debug) {
        std::cout << "Scanner output: \n\t";
        for (auto const & i : tokenList) {
            std::cout << tokenToStr(i) << " ";
        }
        std::cout << std::endl;
    }

    return tokenList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq 0x27422(%rip), %rdi     # 0x34fc8
leaq 0x16720(%rip), %rsi     # 0x242cd
callq 0x32e0
movq -0xd8(%rbp), %rdi
callq 0xd300
movq -0xd0(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x82f0
jmp 0xdbd0
movq -0xd8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xd340
jmp 0xdbe2
movq -0xd0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xe7e0
jmp 0xdbf4
cmpl $0xb, -0x48(%rbp)
jne 0xdc2e
movl $0x3, -0x58(%rbp)
jmp 0xdc35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xddaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9260
jmp 0xddaf
movl $0x0, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9260
movl -0x58(%rbp), %eax
testl %eax, %eax
je 0xdc49
jmp 0xdc47
jmp 0xdc4b
jmp 0xdbce
movq -0xd8(%rbp), %rax
testb $0x1, 0x11(%rax)
je 0xdd82
movq 0x27365(%rip), %rdi     # 0x34fc8
leaq 0x16670(%rip), %rsi     # 0x242da
callq 0x32e0
jmp 0xdc71
movq -0xd0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0xe820
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0xe850
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xe880
testb $0x1, %al
jne 0xdcac
jmp 0xdd6b
leaq -0x68(%rbp), %rdi
callq 0xe8b0
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
callq 0xe8d0
jmp 0xdccb
leaq -0x98(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xddd0
jmp 0xdce0
movq 0x272e1(%rip), %rdi     # 0x34fc8
leaq -0x98(%rbp), %rsi
callq 0x32a0
movq %rax, -0xe8(%rbp)
jmp 0xdcfc
movq -0xe8(%rbp), %rdi
leaq 0x16c1c(%rip), %rsi     # 0x24926
callq 0x32e0
jmp 0xdd11
leaq -0x98(%rbp), %rdi
callq 0x31d0
leaq -0xc8(%rbp), %rdi
callq 0x9260
leaq -0x68(%rbp), %rdi
callq 0xe920
jmp 0xdc96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xdd5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x31d0
leaq -0xc8(%rbp), %rdi
callq 0x9260
jmp 0xddaf
movq 0x27256(%rip), %rdi     # 0x34fc8
movq 0x2723f(%rip), %rsi     # 0x34fb8
callq 0x3330
jmp 0xdd80
jmp 0xdd82
movb $0x1, -0x11(%rbp)
movl $0x1, -0x58(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xdd9f
movq -0xd0(%rbp), %rdi
callq 0x8340
movq -0xe0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd0(%rbp), %rdi
callq 0x8340
movq -0x50(%rbp), %rdi
callq 0x3520
nopw %cs:(%rax,%rax)
// File: 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
subq $0x210, %rsp            # imm = 0x210
movq %rsi, -0x1d8(%rbp)
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x27606(%rip), %rdi     # 0x35408
callq 0xef90
movq %rax, -0x18(%rbp)
leaq 0x275f6(%rip), %rdi     # 0x35408
callq 0xefc0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb360
testb $0x1, %al
jne 0xde2e
jmp 0xde82
leaq -0x21(%rbp), %rdi
movq %rdi, -0x1e0(%rbp)
callq 0x3530
movq -0x1d0(%rbp), %rdi
movq -0x1e0(%rbp), %rdx
leaq 0x1649a(%rip), %rsi     # 0x242ed
callq 0x33f0
jmp 0xde5a
leaq -0x21(%rbp), %rdi
callq 0x3350
jmp 0xdfc7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x3350
jmp 0xdfd7
leaq -0x1c0(%rbp), %rdi
callq 0x3230
leaq -0x1b0(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xeff0
movq -0x1e8(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x32a0
jmp 0xdeba
movq -0x1d8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1ec(%rbp)
subl $0x9, %eax
je 0xdf53
jmp 0xded4
movl -0x1ec(%rbp), %eax
subl $0xf, %eax
je 0xdf01
jmp 0xdfa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3240
jmp 0xdfd7
leaq -0x1b0(%rbp), %rdi
leaq 0x16831(%rip), %rsi     # 0x24740
callq 0x32e0
movq %rax, -0x1f8(%rbp)
jmp 0xdf1d
movq -0x1f8(%rbp), %rdi
movq -0x1d8(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x3500
movq %rax, -0x200(%rbp)
jmp 0xdf3c
movq -0x200(%rbp), %rdi
leaq 0x163bc(%rip), %rsi     # 0x24306
callq 0x32e0
jmp 0xdf51
jmp 0xdfa6
leaq -0x1b0(%rbp), %rdi
leaq 0x167df(%rip), %rsi     # 0x24740
callq 0x32e0
movq %rax, -0x208(%rbp)
jmp 0xdf6f
movq -0x208(%rbp), %rdi
movq -0x1d8(%rbp), %rsi
addq $0x8, %rsi
callq 0x32a0
movq %rax, -0x210(%rbp)
jmp 0xdf8f
movq -0x210(%rbp), %rdi
leaq 0x16369(%rip), %rsi     # 0x24306
callq 0x32e0
jmp 0xdfa4
jmp 0xdfa6
movq -0x1d0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x32d0
jmp 0xdfbb
leaq -0x1c0(%rbp), %rdi
callq 0x3240
movq -0x1c8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3520
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x23cfd(%rip), %rdi     # 0x34fc8
leaq 0x131c4(%rip), %rsi     # 0x24496
callq 0x32e0
movq %rax, %rdi
movq 0x23cd7(%rip), %rsi     # 0x34fb8
callq 0x3330
movq -0x10(%rbp), %rdi
callq 0x11330
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x23cc7(%rip), %rdi     # 0x34fc8
movq 0x23cb0(%rip), %rsi     # 0x34fb8
callq 0x3330
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11400
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x20, %edi
callq 0x3300
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl $0x1, %esi
callq 0x14270
jmp 0x11364
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
cmpl $0xb, 0x18(%rax)
je 0x113e7
movq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0x11970
movl %eax, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jne 0x113b3
movq -0x40(%rbp), %rdi
callq 0x119d0
movq %rax, -0x28(%rbp)
jmp 0x113d4
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x32c0
jmp 0x113f1
movq -0x40(%rbp), %rdi
callq 0x11ad0
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl $0x3, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x11bc0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x28(%rbp), %rsi
callq 0x142a0
jmp 0x1136c
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3520
nopw (%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpl $0xb, 0x18(%rax)
jne 0x11557
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3530
movq -0xa0(%rbp), %rdx
leaq 0x12faf(%rip), %rsi     # 0x244a1
leaq -0x28(%rbp), %rdi
callq 0x33f0
jmp 0x114fd
movq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11650
jmp 0x1150f
leaq -0x28(%rbp), %rdi
callq 0x31d0
leaq -0x29(%rbp), %rdi
callq 0x3350
jmp 0x11608
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11549
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31d0
leaq -0x29(%rbp), %rdi
callq 0x3350
jmp 0x11640
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0xb8(%rbp)
movl $0x1, %esi
callq 0x14220
movq -0xb8(%rbp), %rdi
callq 0xe8b0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
addq $0x18, %rdi
movq %rdi, -0xb0(%rbp)
callq 0x141d0
movq -0xb0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xe8d0
movq -0xa8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x11760
jmp 0x115c5
movq 0x239fc(%rip), %rdi     # 0x34fc8
leaq -0x60(%rbp), %rsi
callq 0x32a0
movq %rax, -0xc0(%rbp)
jmp 0x115de
movq -0xc0(%rbp), %rdi
leaq 0x1333a(%rip), %rsi     # 0x24926
callq 0x32e0
jmp 0x115f3
leaq -0x60(%rbp), %rdi
callq 0x31d0
leaq -0x90(%rbp), %rdi
callq 0x9260
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11634
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31d0
leaq -0x90(%rbp), %rdi
callq 0x9260
movq -0x38(%rbp), %rdi
callq 0x3520
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x20, %edi
callq 0x3300
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movl $0x2, %esi
callq 0x14270
jmp 0x11a04
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
callq 0x11d30
movq -0x70(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x14310
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
callq 0x11e50
movq -0x68(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x14310
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
callq 0x11f50
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x14310
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
callq 0x12060
movq -0x58(%rbp), %rdi
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x14310
movq -0x10(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x32c0
movq -0x18(%rbp), %rdi
callq 0x3520
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x20, %edi
callq 0x3300
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl $0x3, %esi
callq 0x14270
jmp 0x11b04
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
callq 0x11d30
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x14310
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
callq 0x12860
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x14310
movq -0x48(%rbp), %rax
cmpl $0xa, 0x18(%rax)
jne 0x11baa
movq -0x48(%rbp), %rdi
callq 0x114b0
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
callq 0x12860
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x14310
jmp 0x11b58
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x32c0
jmp 0x11bb4
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3520
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x18(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x11d06
leaq -0x31(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3530
movq -0x88(%rbp), %rdx
leaq 0x128e9(%rip), %rsi     # 0x244f1
leaq -0x30(%rbp), %rdi
callq 0x33f0
jmp 0x11c13
leaq -0x31(%rbp), %rdi
callq 0x3350
leaq -0x68(%rbp), %rdi
callq 0x3410
movq -0x10(%rbp), %rsi
leaq 0x23840(%rip), %rdi     # 0x35470
callq 0xef90
movq %rax, -0x90(%rbp)
jmp 0x11c3e
movq -0x90(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x23820(%rip), %rdi     # 0x35470
callq 0xefc0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x143a0
testb $0x1, %al
jne 0x11c6c
jmp 0x11cc0
leaq -0x70(%rbp), %rdi
callq 0xeff0
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x68(%rbp), %rdi
callq 0x3040
jmp 0x11c87
jmp 0x11cd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3350
jmp 0x11d18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31d0
leaq -0x30(%rbp), %rdi
callq 0x31d0
jmp 0x11d18
leaq 0x12835(%rip), %rsi     # 0x244fc
leaq -0x68(%rbp), %rdi
callq 0x33e0
jmp 0x11cd2
jmp 0x11cd4
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x35a0
jmp 0x11ce3
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11650
jmp 0x11cf2
leaq -0x68(%rbp), %rdi
callq 0x31d0
leaq -0x30(%rbp), %rdi
callq 0x31d0
jmp 0x11d0f
movq -0x80(%rbp), %rdi
callq 0x114b0
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3520
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x28, %edi
callq 0x3300
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x14380
jmp 0x11d5f
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x18(%rax), %eax
movl %eax, -0x5c(%rbp)
subl $0xe, %eax
je 0x11d9c
jmp 0x11d78
movl -0x5c(%rbp), %eax
subl $0x10, %eax
je 0x11da9
jmp 0x11db6
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x32c0
jmp 0x11e39
movq -0x10(%rbp), %rax
movl $0x1, 0x20(%rax)
jmp 0x11dfa
movq -0x10(%rbp), %rax
movl $0x2, 0x20(%rax)
jmp 0x11dfa
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3530
movq -0x68(%rbp), %rdx
leaq 0x126f6(%rip), %rsi     # 0x244c4
leaq -0x40(%rbp), %rdi
callq 0x33f0
jmp 0x11dd9
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11650
jmp 0x11de8
leaq -0x40(%rbp), %rdi
callq 0x31d0
leaq -0x41(%rbp), %rdi
callq 0x3350
movq -0x58(%rbp), %rdi
callq 0x114b0
movq -0x10(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x11e30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31d0
leaq -0x41(%rbp), %rdi
callq 0x3350
movq -0x18(%rbp), %rdi
callq 0x3520
nopw %cs:(%rax,%rax)