LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nesro[P]NCursesGomoku/src/main.cpp
// Function: main
int main(int argc, char *argv[]) {
	CGame *game = NULL;
	try {
		game = new CGame(argc, argv);
		for (;;) {
			switch (game->m_Status) {
			case CGame::STATUS_TURN:
				game->playerMove();
				game->renderBoard();
				game->checkForWin();

				break;
			case CGame::STATUS_MENU:
				game->showMenu();

				break;
			case CGame::STATUS_EXIT:
				game->networkCleanup();
				delete game;
				return EXIT_SUCCESS;
			default:
				break;
			}
		}
	} catch (std::exception & e) {
		delete game;
		std::cerr << "Exception: " << e.what() << std::endl;
	}

	return EXIT_FAILURE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x60, %edi
callq 0x3280
movq %rax, -0x38(%rbp)
jmp 0x37ee
movq -0x38(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x5310
jmp 0x3800
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x392f
jmp 0x381b
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x3922
jmp 0x3829
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x38ff
jmp 0x3968
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3862
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x3290
movl -0x24(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x398d
movq -0x20(%rbp), %rdi
callq 0x3120
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x38a4
movq -0x48(%rbp), %rdi
callq 0x5530
movq -0x48(%rbp), %rdi
movl $0x60, %esi
callq 0x3290
movq 0x8745(%rip), %rdi      # 0xbff0
leaq 0x4752(%rip), %rsi      # 0x8004
callq 0x3270
movq %rax, -0x50(%rbp)
jmp 0x38bd
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x3270
movq %rax, -0x58(%rbp)
jmp 0x38dc
movq -0x58(%rbp), %rdi
movq 0x86d1(%rip), %rsi      # 0xbfb8
callq 0x32a0
jmp 0x38ee
callq 0x33e0
movl $0x1, -0x4(%rbp)
jmp 0x3984
movq -0x18(%rbp), %rdi
callq 0x5f50
jmp 0x390a
movq -0x18(%rbp), %rdi
callq 0x5660
jmp 0x3915
movq -0x18(%rbp), %rdi
callq 0x5fa0
jmp 0x3920
jmp 0x396a
movq -0x18(%rbp), %rdi
callq 0x57e0
jmp 0x392d
jmp 0x396a
movq -0x18(%rbp), %rdi
callq 0x5610
jmp 0x393a
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0x395f
movq -0x60(%rbp), %rdi
callq 0x5530
movq -0x60(%rbp), %rdi
movl $0x60, %esi
callq 0x3290
movl $0x0, -0x4(%rbp)
jmp 0x3984
jmp 0x396a
jmp 0x3808
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x33e0
jmp 0x3982
jmp 0x398d
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3410
movq %rax, %rdi
callq 0x39a0
nop
// File: nesro[P]NCursesGomoku/src/ai.cpp
// Function: CAI::~CAI()
CAI::~CAI(void) {
	for (int i = 0; i < STRATEGIES; i++) {
		delete[] m_Patterns[i];
	}

	delete[] m_Patterns;
	delete[] m_Moves;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x7f3d(%rip), %rcx      # 0xbba8
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x15, -0xc(%rbp)
jge 0x3caf
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x3ca2
movq -0x20(%rbp), %rdi
callq 0x3350
jmp 0x3ca4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3c79
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3cca
movq -0x28(%rbp), %rdi
callq 0x3350
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3ce5
movq -0x30(%rbp), %rdi
callq 0x3350
movq -0x18(%rbp), %rdi
callq 0x6950
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nesro[P]NCursesGomoku/src/board.cpp
// Function: CBoard::reset()
void CBoard::reset(void) {
	for (int i = 0; i < BOARD_WIDTH; i++) {
		for (int j = 0; j < BOARD_HEIGHT; j++) {
			m_Stones[i][j] = EMPTY_CELL;
		}
	}

	memset(m_Message, 0, MESSAGE_LENGTH + 1);

	m_LastStone.m_X = -1;
	m_LastStone.m_Y = -1;

	m_StonesOnBoard = 0;

	m_Cursor.m_X = (int) ((CURSOR_MAX + CURSOR_MIN) / 2);
	m_Cursor.m_Y = (int) ((CURSOR_MAX + CURSOR_MIN) / 2);
}

// 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 $0xf, -0xc(%rbp)
jge 0x4001
movl $0x0, -0x10(%rbp)
cmpl $0xf, -0x10(%rbp)
jge 0x3ff4
movq -0x18(%rbp), %rax
addq $0x38, %rax
movslq -0xc(%rbp), %rcx
imulq $0xf, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movb $0x5f, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3fc8
jmp 0x3ff6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3fbb
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x21, %edx
callq 0x3180
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x24(%rax)
movl $0xa, 0x30(%rax)
movl $0xa, 0x34(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: nesro[P]NCursesGomoku/src/board.cpp
// Function: CBoard::addStone(char, int, int)
bool CBoard::addStone(char mark, int x, int y) {

	if (x == -1) {
		x = m_Cursor.m_X - CURSOR_MIN;
	}

	if (y == -1) {
		y = m_Cursor.m_Y - CURSOR_MIN;
	}

	if (m_Stones[y][x] == EMPTY_CELL) {
		m_StonesOnBoard++;

		m_LastStone.m_X = y;
		m_LastStone.m_Y = x;

		m_Stones[y][x] = mark;
	} else {
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x45bf
movq -0x28(%rbp), %rax
movl 0x30(%rax), %eax
subl $0x3, %eax
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x45d2
movq -0x28(%rbp), %rax
movl 0x34(%rax), %eax
subl $0x3, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x38, %rax
movslq -0x1c(%rbp), %rcx
imulq $0xf, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
jne 0x4626
movq -0x28(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x28(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x2c(%rax)
movb -0x11(%rbp), %dl
addq $0x38, %rax
movslq -0x1c(%rbp), %rcx
imulq $0xf, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x462c
movb $0x0, -0x1(%rbp)
jmp 0x4630
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: nesro[P]NCursesGomoku/src/board.cpp
// Function: CBoard::moveCursor(int)
void CBoard::moveCursor(int direction) {
	switch (direction) {
	case DIRECTION_UP:
		m_Cursor.m_Y--;
		if (m_Cursor.m_Y < CURSOR_MIN) {
			m_Cursor.m_Y = CURSOR_MAX;
		}
		break;
	case DIRECTION_DOWN:
		m_Cursor.m_Y++;
		if (m_Cursor.m_Y > CURSOR_MAX) {
			m_Cursor.m_Y = CURSOR_MIN;
		}
		break;
	case DIRECTION_LEFT:
		m_Cursor.m_X--;
		if (m_Cursor.m_X < CURSOR_MIN) {
			m_Cursor.m_X = CURSOR_MAX;
		}
		break;
	case DIRECTION_RIGHT:
		m_Cursor.m_X++;
		if (m_Cursor.m_X > CURSOR_MAX) {
			m_Cursor.m_X = CURSOR_MIN;
		}
		break;
	default:
		break;
	}

	move(m_Cursor.m_Y, m_Cursor.m_X * 2 - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x46fc
movq -0x18(%rbp), %rax
leaq 0x3d5d(%rip), %rcx      # 0x83d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movl 0x34(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x34(%rax)
cmpl $0x3, 0x34(%rax)
jge 0x469a
movq -0x20(%rbp), %rax
movl $0x11, 0x34(%rax)
jmp 0x46fe
movq -0x20(%rbp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
cmpl $0x11, 0x34(%rax)
jle 0x46ba
movq -0x20(%rbp), %rax
movl $0x3, 0x34(%rax)
jmp 0x46fe
movq -0x20(%rbp), %rax
movl 0x30(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x30(%rax)
cmpl $0x3, 0x30(%rax)
jge 0x46da
movq -0x20(%rbp), %rax
movl $0x11, 0x30(%rax)
jmp 0x46fe
movq -0x20(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
cmpl $0x11, 0x30(%rax)
jle 0x46fa
movq -0x20(%rbp), %rax
movl $0x3, 0x30(%rax)
jmp 0x46fe
jmp 0x46fe
movq -0x20(%rbp), %rax
movl 0x34(%rax), %edi
movl 0x30(%rax), %esi
shll %esi
subl $0x1, %esi
callq 0x31b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nesro[P]NCursesGomoku/src/board.cpp
// Function: CBoard::printMessage(char const*)
void CBoard::printMessage(const char * message) {
	mvprintw(22, 4, "                               ");
	strcpy(m_Message, message);
	mvprintw(22, 4, "%s", m_Message);
	move(m_Cursor.m_Y, m_Cursor.m_X * 2 - 1);
	refresh();
}

// 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)
movl $0x16, %edi
movl $0x4, %esi
leaq 0x3b47(%rip), %rdx      # 0x8870
movb $0x0, %al
callq 0x3360
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3250
movq -0x18(%rbp), %rcx
movl $0x16, %edi
movl $0x4, %esi
leaq 0x3631(%rip), %rdx      # 0x8383
movb $0x0, %al
callq 0x3360
movq -0x18(%rbp), %rax
movl 0x34(%rax), %edi
movl 0x30(%rax), %esi
shll %esi
subl $0x1, %esi
callq 0x31b0
callq 0x33f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::playerCleanup()
void CGame::playerCleanup(void) {
	delete m_Players[0];
	m_Players[0] = NULL;

	delete m_Players[1];
	m_Players[1] = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x55cc
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x40(%rax)
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x55f0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::networkCleanup()
void CGame::networkCleanup(void) {
	if (m_IsConnectionUp) {
		close(m_ConnectionSocket);
	}

	if (m_IsServerUp) {
		close(m_ServerSocket);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x10(%rax)
je 0x5636
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x3460
movq -0x10(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x564c
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x3460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::clearScreen() const
void CGame::clearScreen(void) const {
	for (int i = 0; i < LINES; i++) {
		for (int j = 0; j < COLS; j++) {
			if (rand() % 2 == 0) {
				attron(COLOR_PAIR(BACKROUND_COLOR_X_PAIR));
				mvprintw(i, j, ".");
				attroff(COLOR_PAIR(BACKROUND_COLOR_X_PAIR));
			} else {
				attron(COLOR_PAIR(BACKROUND_COLOR_O_PAIR));
				mvprintw(i, j, "o");
				attroff(COLOR_PAIR(BACKROUND_COLOR_O_PAIR));
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq 0x68f3(%rip), %rcx      # 0xbfa0
cmpl (%rcx), %eax
jge 0x578a
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq 0x68e2(%rip), %rcx      # 0xbfa8
cmpl (%rcx), %eax
jge 0x577a
callq 0x30b0
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x5726
movq 0x68e1(%rip), %rax      # 0xbfc8
movq (%rax), %rdi
movl $0xc00, %esi            # imm = 0xC00
xorl %eax, %eax
movl %eax, %edx
callq 0x3150
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
leaq 0x369d(%rip), %rdx      # 0x8da2
movb $0x0, %al
callq 0x3360
movq 0x68b5(%rip), %rax      # 0xbfc8
movq (%rax), %rdi
movl $0xc00, %esi            # imm = 0xC00
xorl %eax, %eax
movl %eax, %edx
callq 0x3340
jmp 0x576a
movq 0x689b(%rip), %rax      # 0xbfc8
movq (%rax), %rdi
movl $0xd00, %esi            # imm = 0xD00
xorl %eax, %eax
movl %eax, %edx
callq 0x3150
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
leaq 0x3659(%rip), %rdx      # 0x8da4
movb $0x0, %al
callq 0x3360
movq 0x686f(%rip), %rax      # 0xbfc8
movq (%rax), %rdi
movl $0xd00, %esi            # imm = 0xD00
xorl %eax, %eax
movl %eax, %edx
callq 0x3340
jmp 0x576c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x56bc
jmp 0x577c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x56a3
addq $0x10, %rsp
popq %rbp
retq
// File: nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::startGame(int)
void CGame::startGame(int playerToStart) {
	m_Status = STATUS_TURN;

	m_PlayerOnTurn = playerToStart;

	clearScreen();
	m_Board->reset();
	m_Board->show();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x2, (%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x58(%rdi)
callq 0x5690
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3fa0
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x4050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::playerMove()
void CGame::playerMove(void) {
	m_Players[m_PlayerOnTurn]->nextMove();

	if (m_PlayerOnTurn == 0) {
		m_PlayerOnTurn = 1;
	} else {
		m_PlayerOnTurn = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movslq 0x58(%rax), %rcx
movq 0x40(%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x58(%rax)
jne 0x5f8a
movq -0x10(%rbp), %rax
movl $0x1, 0x58(%rax)
jmp 0x5f95
movq -0x10(%rbp), %rax
movl $0x0, 0x58(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::waitForChar(char, char) const
void CGame::waitForChar(char waitForSmall, char waitForBig) const {
	int key;

	do {
		key = getch();
	} while (key != waitForSmall && key != waitForBig);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movq 0x5dea(%rip), %rax      # 0xbfc8
movq (%rax), %rdi
callq 0x3100
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movsbl -0x9(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
je 0x6208
movl -0x10(%rbp), %eax
movsbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x61d7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: nesro[P]NCursesGomoku/src/player.cpp
// Function: CPlayer::goRandom() const
void CPlayer::goRandom(void) const {
    int middle = 15 / 2;
    int randomRange = 1;

    /* search for first empty stone in from middle of board */
    while (m_Board->addStone(m_Mark, middle - randomRange + rand() %
            (randomRange * 2), middle - randomRange + rand() % (randomRange * 2)
            ) == false) {
        if (randomRange < 8) {
            randomRange++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x7, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movb 0x9(%rax), %al
movb %al, -0x1d(%rbp)
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0x30b0
movl -0x10(%rbp), %ecx
shll %ecx
cltd
idivl %ecx
movl -0x30(%rbp), %eax
addl %edx, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x30b0
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %esi
shll %esi
cltd
idivl %esi
movb -0x1d(%rbp), %al
movl %edx, %esi
movl -0x1c(%rbp), %edx
addl %esi, %ecx
movsbl %al, %esi
callq 0x4590
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x6a0c
cmpl $0x8, -0x10(%rbp)
jge 0x6a0a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6992
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_24.cc
// Function: main
int main(int argc, char const *argv[])
{
	char* cs;
	std::string str;

	while (std::cin >> str) {
		cs = new char[str.size()];
		str.copy(cs, str.size());

		std::cout << cs << std::endl;
		delete [] cs;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10d0
movq 0x2d77(%rip), %rdi      # 0x3fe0
leaq -0x38(%rbp), %rsi
callq 0x10b0
movq %rax, -0x50(%rbp)
jmp 0x1278
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x10a0
movb %al, -0x51(%rbp)
jmp 0x1290
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x129c
jmp 0x1341
leaq -0x38(%rbp), %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
movq %rax, -0x60(%rbp)
jmp 0x12b3
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1060
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1040
jmp 0x12e6
movq -0x18(%rbp), %rsi
movq 0x2cdf(%rip), %rdi      # 0x3fd0
callq 0x1080
movq %rax, -0x78(%rbp)
jmp 0x12fc
movq -0x78(%rbp), %rdi
movq 0x2cb9(%rip), %rsi      # 0x3fc0
callq 0x1090
jmp 0x130e
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x1325
movq -0x80(%rbp), %rdi
callq 0x10c0
jmp 0x1262
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1050
jmp 0x135d
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1050
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x10f0
// File: akw0088[P]openssl/aes_upload_reverse.cpp
// Function: main
int main(int argc, char *argv[])
{

	if (argc < 6)
	{
		printf("Usage: aes_upload_reverse filename ip port key iv public_key\r\n");
		printf("Example: ./aes_upload_reverse file.tgz 127.0.0.1 65535 01234567890123456789012345678901 0123456789012345 id_rsa.openssl.pub\r\n");
		return 0;
	}

	char *filename = argv[1];
	char *ip_str = argv[2];
	unsigned short port = atoi(argv[3]);
	unsigned char *key = (unsigned char *)argv[4];
	unsigned char *iv = (unsigned char *)argv[5];
	unsigned char *pubkey = (unsigned char *)argv[6];

	printf("Attempting to upload %s to ip %s port %d\r\n", filename, ip_str, (int)port);
	aes_file_upload_reverse(filename, ip_str, port, key, iv, pubkey);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x6, -0x8(%rbp)
jge 0x2df4
leaq 0x51c(%rip), %rdi       # 0x32ef
movb $0x0, %al
callq 0x2060
leaq 0x54d(%rip), %rdi       # 0x332e
movb $0x0, %al
callq 0x2060
movl $0x0, -0x4(%rbp)
jmp 0x2e82
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2280
movw %ax, -0x22(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movzwl -0x22(%rbp), %ecx
leaq 0x558(%rip), %rdi       # 0x33ac
movb $0x0, %al
callq 0x2060
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movw -0x22(%rbp), %ax
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movzwl %ax, %edx
callq 0x2980
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: smallsimple[P]CoreInterpreter-CSE5341/main.cpp
// Function: main
int main(int argc, char* argv[]){    
  //cout << "argc = " << argc << endl;
  ifstream *inputfile;
  inputfile = NULL;
  if (argc >= 3){
    inputfile = new ifstream(argv[2]);
  }
  else {
    cout << "Warning: input file not assigned! Might be a problem." << endl;
  }
  Tokenizer *firstTokens;
  firstTokens = Tokenizer::initialize(argv[1]);
  //firstTokens->printTokensNum();
  //firstTokens->printTokensName();
  
  Prog prog(inputfile);
  prog.ParseProg();  
  cout << "==========Pretty Printed Core Program==========" << endl;
  prog.PrintProg();
  cout << "====================OUTPUT=====================" << endl;
  //cout << "finish PrintProg()." << endl;
  prog.ExecProg();
  if (inputfile != NULL && inputfile->is_open()){
    inputfile->close();
    free(inputfile);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x3, -0x8(%rbp)
jl 0x36f5
movl $0x208, %edi            # imm = 0x208
callq 0x21e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x8, %edx
callq 0x23a0
jmp 0x36cc
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3717
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0x21f0
jmp 0x37c5
movq 0xd8dc(%rip), %rdi      # 0x10fd8
leaq 0x8901(%rip), %rsi      # 0xc004
callq 0x21d0
movq %rax, %rdi
movq 0xd8b6(%rip), %rsi      # 0x10fc8
callq 0x2210
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4800
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x6a20
leaq -0x48(%rbp), %rdi
callq 0x6b30
movq 0xd893(%rip), %rdi      # 0x10fd8
leaq 0x88ee(%rip), %rsi      # 0xc03a
callq 0x21d0
movq %rax, %rdi
movq 0xd86d(%rip), %rsi      # 0x10fc8
callq 0x2210
leaq -0x48(%rbp), %rdi
callq 0x6a50
movq 0xd868(%rip), %rdi      # 0x10fd8
leaq 0x88f3(%rip), %rsi      # 0xc06a
callq 0x21d0
movq %rax, %rdi
movq 0xd842(%rip), %rsi      # 0x10fc8
callq 0x2210
leaq -0x48(%rbp), %rdi
callq 0x6b00
cmpq $0x0, -0x18(%rbp)
je 0x37bc
movq -0x18(%rbp), %rdi
callq 0x2330
testb $0x1, %al
jne 0x37aa
jmp 0x37bc
movq -0x18(%rbp), %rdi
callq 0x2060
movq -0x18(%rbp), %rdi
callq 0x2270
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2370
nop
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::printTokensName()
void Tokenizer::printTokensName(){ 
  int i; 
  for (i = 0; i < this->tokens.size(); i++){
    cout << this->tokens[i].name << " ";
  }
  cout << endl;
}

// 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)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x4c80
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3842
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x4cb0
movq %rax, %rsi
addq $0x8, %rsi
movq 0xd7b5(%rip), %rdi      # 0x10fd8
callq 0x21b0
movq %rax, %rdi
leaq 0x910f(%rip), %rsi      # 0xc941
callq 0x21d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x37eb
movq 0xd78f(%rip), %rdi      # 0x10fd8
movq 0xd778(%rip), %rsi      # 0x10fc8
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::searchSpec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<SpecMarker> Tokenizer::searchSpec(string str){
  vector<SpecMarker> sMarker;
  int i = 0;
  do{
    for (int j = 18; j >= 0; j--){
      if(this->specSymbols[j].compare(str.substr(i,this->specSymbols[j].size()))==0){
	SpecMarker temp;
	temp.start = i;
	temp.id = j;
	sMarker.push_back(temp);
	i += specSymbols[j].size() - 1;
	break;
      }
    }
    i++;    
  }while (i < str.size());

  return sMarker;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x78(%rbp)
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x4cd0
movl $0x0, -0x20(%rbp)
movl $0x12, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x3a09
movslq -0x24(%rbp), %rax
shlq $0x5, %rax
leaq 0xda5a(%rip), %rdi      # 0x11390
addq %rax, %rdi
movq %rdi, -0x88(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x2140
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq %rax, %rcx
leaq -0x48(%rbp), %rdi
callq 0x2200
jmp 0x3963
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2030
movl %eax, -0x8c(%rbp)
jmp 0x397b
leaq -0x48(%rbp), %rdi
callq 0x2110
movl -0x8c(%rbp), %eax
cmpl $0x0, %eax
jne 0x39f9
movq -0x70(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x58(%rbp)
leaq -0x5c(%rbp), %rsi
callq 0x4cf0
jmp 0x39aa
movslq -0x24(%rbp), %rax
leaq 0xd9db(%rip), %rdi      # 0x11390
shlq $0x5, %rax
addq %rax, %rdi
callq 0x2140
movq %rax, %rcx
subq $0x1, %rcx
movslq -0x20(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x20(%rbp)
jmp 0x3a09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x3a59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2110
jmp 0x3a59
jmp 0x39fb
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x391d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x78(%rbp), %rdi
movslq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x2140
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jb 0x3916
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x3a4c
movq -0x70(%rbp), %rdi
callq 0x4d60
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x4d60
movq -0x50(%rbp), %rdi
callq 0x2370
nopl (%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::isRes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Tokenizer::isRes(string str){
  for (int i = 0; i < 11; i++){
    if (str.compare(resWords[i]) == 0){
      return i + 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xb, -0x1c(%rbp)
jge 0x3ac9
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
leaq 0xd790(%rip), %rsi      # 0x11230
shlq $0x5, %rax
addq %rax, %rsi
callq 0x2030
cmpl $0x0, %eax
jne 0x3abc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3ad0
jmp 0x3abe
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3a8b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::isIntegers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Tokenizer::isIntegers(string str){
  for (int i = 0; i < str.size(); i++){
    if (!isdigit(str.at(i)))
      return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2140
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x3b45
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x23c0
movsbl (%rax), %edi
callq 0x21c0
cmpl $0x0, %eax
jne 0x3b38
movb $0x0, -0x1(%rbp)
jmp 0x3b49
jmp 0x3b3a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3afb
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::isIdenti(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Tokenizer::isIdenti(string str){
  int i;
  int judge;

  // if first character is not upper letter
  if (!isupper(str.at(0))){
    return false;
  }
    
  //check each character is uppercase letter or digit
  for (i = 1; i < str.size(); i++){
    if(!(isupper(str.at(i)) || isdigit(str.at(i)))){
      return false;
    }
  }

  //check if the order of the characters is not right
  judge = 0;
  for (i = 0; i < str.size() - 1 ; i++){
    if ((isupper(str.at(i)) && isdigit(str.at(i+1)))
	|| (isdigit(str.at(i)) && isupper(str.at(i+1)))){
      judge++;
    }
  }

  if (judge > 1) return false;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x23c0
movsbl (%rax), %edi
callq 0x2160
cmpl $0x0, %eax
jne 0x3b9e
movb $0x0, -0x1(%rbp)
jmp 0x3cda
movl $0x1, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x2140
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x3c0c
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x23c0
movsbl (%rax), %edi
callq 0x2160
cmpl $0x0, %eax
jne 0x3bff
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x23c0
movsbl (%rax), %edi
callq 0x21c0
cmpl $0x0, %eax
jne 0x3bff
movb $0x0, -0x1(%rbp)
jmp 0x3cda
jmp 0x3c01
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3ba5
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2140
movq %rax, %rcx
movq -0x40(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3cca
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x23c0
movsbl (%rax), %edi
callq 0x2160
cmpl $0x0, %eax
je 0x3c78
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x23c0
movsbl (%rax), %edi
callq 0x21c0
cmpl $0x0, %eax
jne 0x3cb1
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x23c0
movsbl (%rax), %edi
callq 0x21c0
cmpl $0x0, %eax
je 0x3cba
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x23c0
movsbl (%rax), %edi
callq 0x2160
cmpl $0x0, %eax
je 0x3cba
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3cbc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3c1a
cmpl $0x1, -0x20(%rbp)
jle 0x3cd6
movb $0x0, -0x1(%rbp)
jmp 0x3cda
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::Tokenizer(char*)
Tokenizer::Tokenizer(char* filename){
  Tokenizer();
  ifstream inputF;
  inputF.open(filename);
  int i=0;
  do{
    string sub;
    inputF >> sub;
    this->dealToken(sub);
  } while(!inputF.eof());
  // if no illegal token, add EOF to the end
  Token tok;
  tok.name = "\0"; // use "\0" as a EOF character
  tok.num = 33;
  this->tokens.push_back(tok);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2c0(%rbp)
movq %rdi, %rax
movq %rax, -0x2b8(%rbp)
callq 0x4ee0
leaq -0x28(%rbp), %rdi
callq 0x45b0
jmp 0x4638
leaq -0x28(%rbp), %rdi
callq 0x45d0
leaq -0x240(%rbp), %rdi
callq 0x2260
jmp 0x464f
movq -0x10(%rbp), %rsi
leaq -0x240(%rbp), %rdi
movl $0x8, %edx
callq 0x2120
jmp 0x4666
movl $0x0, -0x244(%rbp)
leaq -0x268(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
callq 0x22d0
movq -0x2c8(%rbp), %rsi
leaq -0x240(%rbp), %rdi
callq 0x22b0
jmp 0x4698
leaq -0x288(%rbp), %rdi
leaq -0x268(%rbp), %rsi
callq 0x20d0
jmp 0x46ad
movq -0x2b8(%rbp), %rdi
leaq -0x288(%rbp), %rsi
callq 0x4120
jmp 0x46c2
leaq -0x288(%rbp), %rdi
callq 0x2110
leaq -0x268(%rbp), %rdi
callq 0x2110
movq -0x240(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x240(%rbp,%rax), %rdi
callq 0x23b0
movb %al, -0x2c9(%rbp)
jmp 0x46fa
movb -0x2c9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4670
leaq -0x2b0(%rbp), %rdi
callq 0x4dc0
leaq -0x2a8(%rbp), %rdi
leaq 0x7bf0(%rip), %rsi      # 0xc314
callq 0x22c0
jmp 0x472b
movq -0x2b8(%rbp), %rdi
movl $0x21, -0x2b0(%rbp)
leaq -0x2b0(%rbp), %rsi
callq 0x4de0
jmp 0x474a
leaq -0x2b0(%rbp), %rdi
callq 0x4e50
leaq -0x240(%rbp), %rdi
callq 0x2070
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x47df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x47d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x47ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x288(%rbp), %rdi
callq 0x2110
leaq -0x268(%rbp), %rdi
callq 0x2110
jmp 0x47d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x2b0(%rbp), %rdi
callq 0x4e50
leaq -0x240(%rbp), %rdi
callq 0x2070
movq -0x2c0(%rbp), %rdi
callq 0x4f00
movq -0x30(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::initialize(char*)
Tokenizer* Tokenizer::initialize(char* filename){
  if(! instanceFlag){
    tokenizer = new Tokenizer(filename);
    instanceFlag = true;
    return tokenizer;
  }
  else{
    cout << "Error: Tokenizer has already been initialized!" << endl;
    cout << "program stoppted!" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
testb $0x1, 0xcde1(%rip)      # 0x115f4
jne 0x486f
movl $0x18, %edi
callq 0x21e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
callq 0x4600
jmp 0x4834
movq -0x20(%rbp), %rax
movq %rax, 0xcdb9(%rip)      # 0x115f8
movb $0x1, 0xcdae(%rip)      # 0x115f4
movq 0xcdab(%rip), %rax      # 0x115f8
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x18, %esi
callq 0x21f0
jmp 0x48ba
movq 0xc762(%rip), %rdi      # 0x10fd8
leaq 0x78da(%rip), %rsi      # 0xc157
callq 0x21d0
movq %rax, %rdi
movq 0xc73c(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0xc740(%rip), %rdi      # 0x10fd8
leaq 0x78e7(%rip), %rsi      # 0xc186
callq 0x21d0
movq %rax, %rdi
movq 0xc71a(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::getInstance()
Tokenizer* Tokenizer::getInstance(){
  if (! instanceFlag){
    cout << "Error: Tokenizer has not been initialized" << endl;
    cout << "program stopped!" << endl;
    exit(0);
  }
  else{
    return tokenizer;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testb $0x1, 0xcd19(%rip)      # 0x115f4
jne 0x4928
movq 0xc6f4(%rip), %rdi      # 0x10fd8
leaq 0x78ad(%rip), %rsi      # 0xc198
callq 0x21d0
movq %rax, %rdi
movq 0xc6ce(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0xc6d2(%rip), %rdi      # 0x10fd8
leaq 0x78b5(%rip), %rsi      # 0xc1c2
callq 0x21d0
movq %rax, %rdi
movq 0xc6ac(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
movq 0xccc9(%rip), %rax      # 0x115f8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::getToken[abi:cxx11]()
string Tokenizer::getToken(){ //returns (info about) current token
  /*
  cout << "curTokenNum=" << curTokenNum << endl;
  cout << "TokenType=" << this->tokens.at(curTokenNum).num << endl;
  cout << "tokenName:  " << this->tokens.at(curTokenNum).name << endl;
  */
  if (this->tokens.at(curTokenNum).num == this->eofNum ){
    cout << "Warning: has reached the end-of-file!" << endl;
  }
  return this->tokens.at(curTokenNum).name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movslq 0xcc86(%rip), %rsi      # 0x115f0
callq 0x4f60
cmpl $0x21, (%rax)
jne 0x4996
movq 0xc65d(%rip), %rdi      # 0x10fd8
leaq 0x7851(%rip), %rsi      # 0xc1d3
callq 0x21d0
movq %rax, %rdi
movq 0xc637(%rip), %rsi      # 0x10fc8
callq 0x2210
movq -0x18(%rbp), %rdi
movslq 0xcc4f(%rip), %rsi      # 0x115f0
callq 0x4f60
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x20d0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::skipToken()
void Tokenizer::skipToken(){
  if (curTokenNum < tokens.size()){
    curTokenNum++;
  }
  else{
    cout << "Error: End of the file! There are no tokens!" << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movslq 0xcc19(%rip), %rax      # 0x115f0
movq %rax, -0x10(%rbp)
callq 0x4c80
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x49fd
movl 0xcbfe(%rip), %eax      # 0x115f0
addl $0x1, %eax
movl %eax, 0xcbf5(%rip)      # 0x115f0
jmp 0x4a1f
movq 0xc5d4(%rip), %rdi      # 0x10fd8
leaq 0x77ee(%rip), %rsi      # 0xc1f9
callq 0x21d0
movq %rax, %rdi
movq 0xc5ae(%rip), %rsi      # 0x10fc8
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::intVal()
int Tokenizer::intVal(){
  if (this->tokens.at(curTokenNum).num == 31){
    string intTemp = this->tokens.at(curTokenNum).name;
    return atoi(intTemp.c_str());
  }
  else{
    cout << "Error: current token is not an integer" << endl;
    cout << "program stopped!" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movslq 0xcba5(%rip), %rsi      # 0x115f0
callq 0x4f60
cmpl $0x1f, (%rax)
jne 0x4a9b
movq -0x30(%rbp), %rdi
movslq 0xcb90(%rip), %rsi      # 0x115f0
callq 0x4f60
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x20d0
leaq -0x28(%rbp), %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x2320
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2110
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq 0xc536(%rip), %rdi      # 0x10fd8
leaq 0x777d(%rip), %rsi      # 0xc226
callq 0x21d0
movq %rax, %rdi
movq 0xc510(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0xc514(%rip), %rdi      # 0x10fd8
leaq 0x76f7(%rip), %rsi      # 0xc1c2
callq 0x21d0
movq %rax, %rdi
movq 0xc4ee(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::idName[abi:cxx11]()
string Tokenizer::idName(){
  if(this->tokens.at(curTokenNum).num == 32){
    return this->tokens.at(curTokenNum).name;
  }
  else{
    cout << "Error: current token is not an identifier" << endl;
    cout << "program stopped!" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movslq 0xcad6(%rip), %rsi      # 0x115f0
callq 0x4f60
cmpl $0x20, (%rax)
jne 0x4b4e
movq -0x18(%rbp), %rdi
movslq 0xcac1(%rip), %rsi      # 0x115f0
callq 0x4f60
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x20d0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq 0xc483(%rip), %rdi      # 0x10fd8
leaq 0x76f1(%rip), %rsi      # 0xc24d
callq 0x21d0
movq %rax, %rdi
movq 0xc45d(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0xc461(%rip), %rdi      # 0x10fd8
leaq 0x7644(%rip), %rsi      # 0xc1c2
callq 0x21d0
movq %rax, %rdi
movq 0xc43b(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
nopl (%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Prog.cpp
// Function: Prog::PrintProg()
void Prog::PrintProg(){
  int level = 0;
  cout << "program" << endl;
  ds->PrintDeclSeq(level+1);
  cout << "begin" << endl;
  ss->PrintStmtSeq(level+1);
  cout << "end" << endl;
}

// 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)
movq 0xa566(%rip), %rdi      # 0x10fd8
leaq 0x5621(%rip), %rsi      # 0xc09a
callq 0x21d0
movq %rax, %rdi
movq 0xa540(%rip), %rsi      # 0x10fc8
callq 0x2210
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x6df0
movq 0xa532(%rip), %rdi      # 0x10fd8
leaq 0x55f5(%rip), %rsi      # 0xc0a2
callq 0x21d0
movq %rax, %rdi
movq 0xa50c(%rip), %rsi      # 0x10fc8
callq 0x2210
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x72e0
movq 0xa4fd(%rip), %rdi      # 0x10fd8
leaq 0x55c6(%rip), %rsi      # 0xc0a8
callq 0x21d0
movq %rax, %rdi
movq 0xa4d7(%rip), %rsi      # 0x10fc8
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/DeclSeq.cpp
// Function: DeclSeq::ParseDeclSeq()
void DeclSeq::ParseDeclSeq(){
  Tokenizer *tokensDeclSeq;
  tokensDeclSeq = Tokenizer::getInstance();
  
  decl = new Decl();
  decl->ParseDecl();
  string tokenTemp;
  tokenTemp = tokensDeclSeq->getToken();
  if (tokenTemp.compare("int") == 0){
    declSeq = new DeclSeq();
    declSeq->ParseDeclSeq();
  }
  else if (tokenTemp.compare("begin") == 0){
    return;
  }
  else{
    cout << "Syntax Error: decl seq wrong!" << endl;
    cout << "program stopped!" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x48d0
movq %rax, -0x10(%rbp)
movl $0x8, %edi
callq 0x21e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x7050
jmp 0x6ebb
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x7120
leaq -0x40(%rbp), %rdi
callq 0x22d0
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x4940
jmp 0x6ee6
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2290
leaq -0x60(%rbp), %rdi
callq 0x2110
leaq -0x40(%rbp), %rdi
leaq 0x51a5(%rip), %rsi      # 0xc0ac
callq 0x2090
cmpl $0x0, %eax
jne 0x6f9b
movl $0x10, %edi
callq 0x21e0
movq %rax, -0x80(%rbp)
jmp 0x6f25
movq -0x80(%rbp), %rdi
callq 0x6dd0
jmp 0x6f30
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
callq 0x6e80
jmp 0x6f47
jmp 0x7022
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x8, %esi
callq 0x21f0
jmp 0x7044
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x703b
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x21f0
jmp 0x703b
leaq -0x40(%rbp), %rdi
leaq 0x50fc(%rip), %rsi      # 0xc0a2
callq 0x2090
cmpl $0x0, %eax
jne 0x6fb9
movl $0x1, -0x64(%rbp)
jmp 0x7029
movq 0xa018(%rip), %rdi      # 0x10fd8
leaq 0x53f1(%rip), %rsi      # 0xc3b8
callq 0x21d0
movq %rax, -0x88(%rbp)
jmp 0x6fd5
movq -0x88(%rbp), %rdi
movq 0x9fe5(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x6fea
movq 0x9fe7(%rip), %rdi      # 0x10fd8
leaq 0x51ca(%rip), %rsi      # 0xc1c2
callq 0x21d0
movq %rax, -0x90(%rbp)
jmp 0x7006
movq -0x90(%rbp), %rdi
movq 0x9fb4(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x701b
xorl %edi, %edi
callq 0x2280
movl $0x0, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2110
addq $0x90, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x2110
movq -0x18(%rbp), %rdi
callq 0x2370
nopl (%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Decl.cpp
// Function: Decl::PrintDecl(int)
void Decl::PrintDecl(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "int ";
  idList->PrintIdList();
  cout << ";" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x70b4
movq 0x9f3b(%rip), %rdi      # 0x10fd8
leaq 0x5332(%rip), %rsi      # 0xc3d6
callq 0x21d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x708e
movq 0x9f1d(%rip), %rdi      # 0x10fd8
leaq 0x5316(%rip), %rsi      # 0xc3d8
callq 0x21d0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x74e0
movq 0x9efe(%rip), %rdi      # 0x10fd8
leaq 0x5647(%rip), %rsi      # 0xc728
callq 0x21d0
movq %rax, %rdi
movq 0x9ed8(%rip), %rsi      # 0x10fc8
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Decl.cpp
// Function: Decl::ParseDecl()
void Decl::ParseDecl(){
  Tokenizer *tokensDecl;
  tokensDecl = Tokenizer::getInstance();
  if (tokensDecl->getToken().compare("int") != 0){
    cout << "Syntax error: Decl error!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
  tokensDecl->skipToken();
  idList = new IdList();
  idList->ParseIdList();
  if (tokensDecl->getToken().compare(";") != 0){
    cout << "Sytax error: missing \";\" in Decl" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
  tokensDecl->skipToken();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x48d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4940
leaq -0x30(%rbp), %rdi
leaq 0x4f54(%rip), %rsi      # 0xc0ac
callq 0x2090
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2110
movl -0x64(%rbp), %eax
cmpl $0x0, %eax
je 0x71bc
movq 0x9e60(%rip), %rdi      # 0x10fd8
leaq 0x525e(%rip), %rsi      # 0xc3dd
callq 0x21d0
movq %rax, %rdi
movq 0x9e3a(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x9e3e(%rip), %rdi      # 0x10fd8
leaq 0x4fa5(%rip), %rsi      # 0xc146
callq 0x21d0
movq %rax, %rdi
movq 0x9e18(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x49c0
movl $0x10, %edi
callq 0x21e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x74c0
jmp 0x71e0
movq -0x70(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x7570
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x4940
leaq -0x60(%rbp), %rdi
leaq 0x551d(%rip), %rsi      # 0xc728
callq 0x2090
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2110
movl -0x7c(%rbp), %eax
cmpl $0x0, %eax
je 0x728b
movq 0x9dad(%rip), %rdi      # 0x10fd8
leaq 0x51c5(%rip), %rsi      # 0xc3f7
callq 0x21d0
movq %rax, %rdi
movq 0x9d87(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x9d8b(%rip), %rdi      # 0x10fd8
leaq 0x4ef2(%rip), %rsi      # 0xc146
callq 0x21d0
movq %rax, %rdi
movq 0x9d65(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x21f0
jmp 0x729d
movq -0x10(%rbp), %rdi
callq 0x49c0
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/StmtSeq.cpp
// Function: StmtSeq::ParseStmtSeq()
void StmtSeq::ParseStmtSeq(){
  stmt = new Stmt(infile);
  stmt->ParseStmt();
  Tokenizer *tokensStmtSeq;
  tokensStmtSeq = Tokenizer::getInstance();
  string tokenTemp = tokensStmtSeq->getToken();
  if ((tokenTemp.compare("end") != 0) && (tokenTemp.compare("else") != 0)){
    stmtSeq = new StmtSeq(infile);
    stmtSeq->ParseStmtSeq();
  }
  
  else {
    //tokensStmtSeq->skipToken();
    //cout << "parsing finished" << endl;
    return;
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x30, %edi
callq 0x21e0
movq %rax, %rdi
movq -0x58(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rsi
callq 0x7f10
jmp 0x73a7
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x8160
callq 0x48d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x4940
leaq -0x40(%rbp), %rdi
leaq 0x4ccd(%rip), %rsi      # 0xc0a8
callq 0x2090
cmpl $0x0, %eax
je 0x7484
leaq -0x40(%rbp), %rdi
leaq 0x4cbf(%rip), %rsi      # 0xc0b3
callq 0x2090
cmpl $0x0, %eax
je 0x7484
movl $0x18, %edi
callq 0x21e0
movq %rax, -0x60(%rbp)
jmp 0x7412
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x72b0
jmp 0x7425
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
callq 0x7370
jmp 0x743c
jmp 0x748d
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x30, %esi
callq 0x21f0
jmp 0x74ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x74a3
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x18, %esi
callq 0x21f0
jmp 0x74a3
movl $0x1, -0x44(%rbp)
jmp 0x7494
movl $0x0, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2110
addq $0x60, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x2110
movq -0x10(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
nop