LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Player.cpp
// Function: Player::getWager()
int Player::getWager()
{
	if (getMoney() > 50)
	{
		wager = 0;
		while(wager < 50 || getMoney() < wager)
		{
			cout << "How much would you like to wager (min. $50)? " << endl;
			cout << "You have $" << getMoney() << ": ";
			cin >> wager;
			cin.ignore();  // Drop newline char
		}
	}
	else
	{
		wager = getMoney();
	}
	cout << "Your wager is: $" << wager << endl;
	return wager;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %eax
leaq 0x14(%rdi), %r14
cmpl $0x33, %eax
jl 0x5e59
movl $0x0, (%r14)
movq 0x521c(%rip), %r15      # 0xafd0
leaq 0x158d(%rip), %r13      # 0x7348
leaq 0x15d9(%rip), %rbp      # 0x739b
movq 0x5217(%rip), %r12      # 0xafe0
movl $0x2d, %edx
movq %r15, %rdi
leaq 0x1542(%rip), %rsi      # 0x731a
callq 0x2190
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movl $0xa, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x2190
movl 0x10(%rbx), %esi
movq %r15, %rdi
callq 0x2220
movl $0x2, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2190
movq %r12, %rdi
movq %r14, %rsi
callq 0x20e0
movq %r12, %rdi
callq 0x2250
movl 0x14(%rbx), %eax
cmpl $0x32, %eax
jl 0x5dc9
cmpl %eax, 0x10(%rbx)
jl 0x5dc9
jmp 0x5e5c
movl %eax, (%r14)
movq 0x516d(%rip), %r14      # 0xafd0
leaq 0x14e9(%rip), %rsi      # 0x7353
movl $0x10, %edx
movq %r14, %rdi
callq 0x2190
movl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x2220
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movl 0x14(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/main.cpp
// Function: main
int main()
{
	string playAgain;
	bool playGame = true;
	Blackjack game;
	while (playGame)
	{
		game.playGame();
		cout << "Would you like to play again? [Y/n]: ";
		getline(cin, playAgain);
		if (playAgain != "y" && playAgain != "Y") // Only check affirmative
		{
			playGame = false; // Stop playing game
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x3780
movb $0x1, %bl
movq 0x48b8(%rip), %r14      # 0xafd0
leaq 0xc59(%rip), %r15       # 0x7378
movq 0x48ba(%rip), %r12      # 0xafe0
leaq 0x8(%rsp), %r13
leaq 0xc6c(%rip), %rbp       # 0x739e
leaq 0x28(%rsp), %rdi
callq 0x404c
movl $0x25, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2260
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2060
testl %eax, %eax
je 0x679a
movq %r13, %rdi
leaq 0xc18(%rip), %rsi       # 0x73a0
callq 0x2060
testl %eax, %eax
movzbl %bl, %ebx
movl $0x0, %eax
cmovnel %eax, %ebx
testb $0x1, %bl
jne 0x6732
leaq 0x28(%rsp), %rdi
callq 0x383e
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x67c5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x67eb
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x383e
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6807
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r12d, %r12d
movl $0x60, %edi
callq 0x2220
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x37f0
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x2642
cmpl $0x2, %eax
je 0x2628
testl %eax, %eax
jne 0x2616
jmp 0x264c
movq %rbx, %rdi
callq 0x40b0
movq %rbx, %rdi
callq 0x3a88
movq %rbx, %rdi
callq 0x40d2
jmp 0x2616
movq %rbx, %rdi
callq 0x3b78
jmp 0x2616
movq %rbx, %r12
movq %rbx, %rdi
callq 0x3a64
movq %rbx, %rdi
callq 0x39a8
movl $0x60, %esi
movq %rbx, %rdi
callq 0x2230
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
movl $0x60, %esi
movq %rbx, %rdi
callq 0x2230
xorl %ebx, %ebx
jmp 0x269f
movq %rdx, %r15
movq %rax, %r14
movq %r12, %rbx
jmp 0x269f
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x2719
movq %r14, %rdi
callq 0x2100
movq %rax, %r14
testq %rbx, %rbx
je 0x26ca
movq %rbx, %rdi
callq 0x39a8
movl $0x60, %esi
movq %rbx, %rdi
callq 0x2230
movq 0x691f(%rip), %rdi      # 0x8ff0
leaq 0x292c(%rip), %rsi      # 0x5004
movl $0xb, %edx
callq 0x2260
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq 0x68fe(%rip), %rdi      # 0x8ff0
movq %rax, %rsi
callq 0x2210
movq %rax, %rdi
callq 0x2130
callq 0x2310
movl $0x1, %eax
jmp 0x266e
movq %rax, %r14
callq 0x2310
movq %r14, %rdi
callq 0x2340
movq %rax, %rdi
callq 0x2729
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x637a(%rip), %rax      # 0x8bc8
movq %rax, (%rdi)
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x2866
callq 0x22a0
incq %r14
cmpq $0x15, %r14
jne 0x2854
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x287d
callq 0x22a0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x288b
callq 0x22a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x45b2
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
addq $0x38, %rdi
movl $0xe1, %edx
movl $0x5f, %esi
callq 0x2160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movb $0x0, 0x20(%rbx)
movl $0xffffffff, 0x2c(%rbx) # imm = 0xFFFFFFFF
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x24(%rbx)
movabsq $0xa0000000a, %rax      # imm = 0xA0000000A
movq %rax, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0x30(%rdi), %r8d
movl 0x34(%rdi), %eax
addl $-0x3, %r8d
cmpl $-0x1, %edx
cmovnel %edx, %r8d
addl $-0x3, %eax
cmpl $-0x1, %ecx
cmovnel %ecx, %eax
movslq %eax, %rcx
leaq (%rcx,%rcx,4), %rcx
leaq (%rcx,%rcx,2), %rdx
addq %rdi, %rdx
movslq %r8d, %r8
movb 0x38(%r8,%rdx), %cl
cmpb $0x5f, %cl
jne 0x2eb6
incl 0x24(%rdi)
addq %r8, %rdx
addq $0x38, %rdx
movl %eax, 0x28(%rdi)
movl %r8d, 0x2c(%rdi)
movb %sil, (%rdx)
cmpb $0x5f, %cl
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x3, %esi
ja 0x2f25
movl %esi, %eax
leaq 0x2504(%rip), %rcx      # 0x53d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x34(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x4, %eax
movl $0x11, %eax
cmovgel %ecx, %eax
jmp 0x2ef9
movl 0x34(%rdi), %eax
leal 0x1(%rax), %ecx
cmpl $0x11, %eax
movl $0x3, %eax
cmovll %ecx, %eax
movl %eax, 0x34(%rdi)
jmp 0x2f25
movl 0x30(%rdi), %eax
leal 0x1(%rax), %ecx
cmpl $0x11, %eax
movl $0x3, %eax
cmovll %ecx, %eax
jmp 0x2f22
movl 0x30(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x4, %eax
movl $0x11, %eax
cmovgel %ecx, %eax
movl %eax, 0x30(%rdi)
movl 0x30(%rdi), %eax
movl 0x34(%rdi), %edi
leal -0x1(,%rax,2), %esi
jmp 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2465(%rip), %rdx      # 0x5870
movl $0x16, %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f0
leaq 0x1f55(%rip), %rdx      # 0x5383
movl $0x16, %edi
movl $0x4, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0x22b0
movl 0x30(%r14), %eax
movl 0x34(%r14), %edi
leal -0x1(,%rax,2), %esi
callq 0x2170
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O1/nesro[P]NCursesGomoku/src/client.cpp
// Function: CClient::CClient(CBoard*, char, CGame*)
CClient::CClient(CBoard * board, char mark, CGame * game) :
CPlayer(board, mark), CNetwork(game) {

    if (m_Game->m_IsConnectionUp == true) {
        return;
    } else {
        m_Game->m_IsConnectionUp = true;
    }

    hostent * host;

    if ((host = gethostbyname(m_Game->m_Host.c_str())) == NULL) {
        throw CNetworkException("Fatal network error: Client host is invalid.");
    }

    if ((m_Game->m_ConnectionSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))
            == -1) {
        throw CNetworkException("Fatal network error: Client socket error.");
    }

    sockaddr_in serverSock;

    serverSock.sin_family = AF_INET;
    serverSock.sin_port = htons(m_Game->m_Port);
    memcpy(&(serverSock.sin_addr), host->h_addr, host->h_length);

    if (connect(m_Game->m_ConnectionSocket, (sockaddr *) & serverSock,
            sizeof (serverSock)) == -1) {
        throw CNetworkException("Fatal network error: Client connect failed.");
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdi, %rbx
callq 0x4598
leaq 0x18(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x4430
leaq 0x5778(%rip), %rax      # 0x8c08
movq %rax, (%rbx)
movq 0x20(%rbx), %rax
cmpb $0x0, 0x10(%rax)
jne 0x3516
movb $0x1, 0x10(%rax)
movq 0x18(%rax), %rdi
callq 0x2250
movq %rax, %r15
testq %rax, %rax
je 0x3522
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x2080
movq 0x20(%rbx), %r12
movl %eax, 0xc(%r12)
cmpl $-0x1, %eax
je 0x3540
leaq 0xc(%rsp), %rdi
movw $0x2, -0x4(%rdi)
movzwl 0x38(%r12), %eax
rolw $0x8, %ax
movw %ax, -0x2(%rdi)
movq 0x18(%r15), %rax
movq (%rax), %rsi
movslq 0x14(%r15), %rdx
callq 0x21b0
movl 0xc(%r12), %edi
leaq 0x8(%rsp), %rsi
movl $0x10, %edx
callq 0x21c0
cmpl $-0x1, %eax
je 0x3572
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x28, %edi
callq 0x2140
movq %rax, %r12
leaq 0x235a(%rip), %rsi      # 0x5890
movq %rax, %rdi
callq 0x4440
jmp 0x355c
movl $0x28, %edi
callq 0x2140
movq %rax, %r12
leaq 0x2369(%rip), %rsi      # 0x58bd
movq %rax, %rdi
callq 0x4440
leaq 0x576d(%rip), %rsi      # 0x8cd0
leaq 0xf10(%rip), %rdx       # 0x447a
movq %r12, %rdi
callq 0x2330
movl $0x28, %edi
callq 0x2140
movq %rax, %r12
leaq 0x2361(%rip), %rsi      # 0x58e7
movq %rax, %rdi
callq 0x4440
leaq 0x573b(%rip), %rsi      # 0x8cd0
leaq 0xede(%rip), %rdx       # 0x447a
movq %r12, %rdi
callq 0x2330
jmp 0x35a8
jmp 0x35a8
movq %rax, %r15
movq %r12, %rdi
callq 0x2190
jmp 0x35ba
jmp 0x35b7
movq %rax, %r15
movq %r14, %rdi
callq 0x443c
jmp 0x35c7
movq %rax, %r15
movq %rbx, %rdi
callq 0x45b2
movq %r15, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O1/nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::CGame(int, char**)
CGame::CGame(int argc, char ** argv) {

	this->m_PlayerOnTurn = 0;
	this->m_ServerSocket = 0;
	this->m_ConnectionSocket = 0;

	if (argc > 1) {
		m_Port = atoi(argv[1]);
	} else {
		m_Port = CNetwork::DEFAULT_PORT;
	}

	if (argc > 2) {
		m_Host = argv[2];
	} else {
		m_Host = "localhost";
	}

	m_IsConnectionUp = false;
	m_IsServerUp = false;

	m_Players[0] = NULL;
	m_Players[1] = NULL;

	srand((unsigned) (time(NULL)));

	m_Status = STATUS_MENU;

	initscr();
	raw();
	keypad(stdscr, TRUE);
	noecho();

	/* turn off cursor */
	curs_set(0);

	start_color();
	init_pair(1, COLOR_CYAN, COLOR_BLACK);
	init_pair(6, COLOR_MAGENTA, COLOR_BLACK);

	/* color of old stones*/
	init_pair(2, COLOR_WHITE, COLOR_RED);
	init_pair(3, COLOR_WHITE, COLOR_GREEN);

	/* color of newest stone*/
	init_pair(4, COLOR_BLACK, COLOR_RED);
	init_pair(5, COLOR_BLACK, COLOR_GREEN);

	init_pair(BACKROUND_COLOR_X_PAIR, BACKROUND_COLOR_X, COLOR_BLACK);
	init_pair(BACKROUND_COLOR_O_PAIR, BACKROUND_COLOR_O, COLOR_BLACK);

	m_Board = new CBoard();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x28(%rdi), %r12
movq %r12, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movl $0x0, 0x58(%rdi)
movq %rax, 0x8(%rdi)
movl $0x44d, %eax            # imm = 0x44D
cmpl $0x2, %esi
jl 0x3830
movq 0x8(%r15), %rdi
callq 0x2300
leaq 0x18(%rbx), %r14
movl %eax, 0x38(%rbx)
cmpl $0x3, %ebp
jl 0x385c
movq 0x10(%r15), %r15
movq %r15, %rdi
callq 0x2110
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
movq %rax, %r8
callq 0x22f0
jmp 0x3875
leaq 0x21ed(%rip), %rcx      # 0x5a50
movl $0x9, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22f0
xorl %eax, %eax
movb %al, 0x10(%rbx)
movb %al, 0x4(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
xorl %edi, %edi
callq 0x21e0
movl %eax, %edi
callq 0x2200
movl $0x1, (%rbx)
callq 0x22d0
callq 0x20c0
movq 0x5727(%rip), %rax      # 0x8fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x20f0
callq 0x2270
xorl %edi, %edi
callq 0x21a0
callq 0x2070
movl $0x1, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2050
movl $0x6, %edi
movl $0x5, %esi
xorl %edx, %edx
callq 0x2050
movl $0x2, %edi
movl $0x7, %esi
movl $0x1, %edx
callq 0x2050
movl $0x3, %edi
movl $0x7, %esi
movl $0x2, %edx
callq 0x2050
movl $0x4, %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2050
movl $0x5, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2050
movl $0xc, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2050
movl $0xd, %edi
movl $0x5, %esi
xorl %edx, %edx
callq 0x2050
movl $0x11c, %edi            # imm = 0x11C
callq 0x2220
movq %rax, %r15
movq %rax, %rdi
callq 0x2a88
movq %r15, 0x50(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x11c, %esi            # imm = 0x11C
movq %r15, %rdi
callq 0x2230
jmp 0x398c
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x39a0
movq (%r12), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x3a43
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x40(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x3a5a
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0x3a76
movl 0xc(%rbx), %edi
callq 0x2380
cmpb $0x1, 0x4(%rbx)
jne 0x3a85
movl 0x8(%rbx), %edi
popq %rbx
jmp 0x2380
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x5502(%rip), %rax      # 0x8fb0
cmpl $0x0, (%rax)
jle 0x3b43
movq 0x54fa(%rip), %r13      # 0x8fb8
movq 0x550b(%rip), %rbx      # 0x8fd0
leaq 0x2208(%rip), %r15      # 0x5cd4
xorl %eax, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, (%r13)
jle 0x3b30
xorl %ebp, %ebp
callq 0x2090
andl $0x1, %eax
leal 0xc(%rax), %r14d
shll $0x8, %r14d
testl %eax, %eax
movq (%rbx), %rdi
movq %r15, %r12
leaq 0x21d8(%rip), %rax      # 0x5cd2
cmoveq %rax, %r15
movl %r14d, %esi
xorl %edx, %edx
callq 0x2120
movl 0x4(%rsp), %edi
movl %ebp, %esi
movq %r15, %rdx
movq %r12, %r15
xorl %eax, %eax
callq 0x22b0
movq (%rbx), %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x2290
incl %ebp
cmpl (%r13), %ebp
jl 0x3adb
movl 0x4(%rsp), %edx
incl %edx
movq 0x5473(%rip), %rax      # 0x8fb0
cmpl (%rax), %edx
movl %edx, %eax
jl 0x3ace
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x2, (%rdi)
movl %esi, 0x58(%rdi)
callq 0x3a9c
movq 0x50(%rbx), %rdi
callq 0x2ad2
movq 0x50(%rbx), %rdi
popq %rbx
jmp 0x2b1e
nop
// File: /workspace/github_cpp_makefile_star2_O1/nesro[P]NCursesGomoku/src/local.cpp
// Function: CLocal::nextMove()
void CLocal::nextMove(void) {

    /* nothing to do here */
    if (m_IsWinner == true) {
        return;
    }

    int key;

    char message[CBoard::MESSAGE_LENGTH];
    memset(message, '\0', CBoard::MESSAGE_LENGTH);
    sprintf(message, " Your (%c) turn!", m_Mark);
    m_Board->printMessage(message);

    /* make cursor visible */
    curs_set(2);

    for (;;) {
        key = getch();

        switch (key) {
            case KEY_UP:
                m_Board->moveCursor(CBoard::DIRECTION_UP);
                break;
                
            case KEY_DOWN:
                m_Board->moveCursor(CBoard::DIRECTION_DOWN);
                break;
                
            case KEY_LEFT:
                m_Board->moveCursor(CBoard::DIRECTION_LEFT);
                break;
                
            case KEY_RIGHT:
                m_Board->moveCursor(CBoard::DIRECTION_RIGHT);
                break;
                
            case 'w':
            case 'W':
            case ' ':
                if (m_Board->addStone(m_Mark, -1, -1)) {
                    curs_set(0);
                    return;
                }
                
                break;
                
            case 'q':
            case 'Q':
                m_Surrender = true;

                curs_set(0);
                return;

                break;
                
            default:
                break;
        }
    }
}

// Assembly:
cmpb $0x0, 0xa(%rdi)
jne 0x4417
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movsbl 0x9(%rdi), %edx
leaq 0x1994(%rip), %rsi      # 0x5cf0
movq %r14, %rdi
xorl %eax, %eax
callq 0x2060
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x33fa
movl $0x2, %edi
callq 0x21a0
movq 0x4c4d(%rip), %r14      # 0x8fd0
leaq 0x194e(%rip), %r15      # 0x5cd8
movq (%r14), %rdi
callq 0x20e0
cmpl $0x70, %eax
jle 0x43b4
leal -0x102(%rax), %ecx
cmpl $0x3, %ecx
ja 0x43c5
movslq (%r15,%rcx,4), %rax
addq %r15, %rax
xorl %esi, %esi
jmpq *%rax
movl $0x2, %esi
jmp 0x43f3
cmpl $0x20, %eax
je 0x43ca
cmpl $0x57, %eax
je 0x43ca
cmpl $0x51, %eax
jne 0x438a
jmp 0x4403
cmpl $0x77, %eax
jne 0x43fe
movq 0x10(%rbx), %rdi
movsbl 0x9(%rbx), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2e6c
testb %al, %al
je 0x438a
jmp 0x4407
movl $0x1, %esi
jmp 0x43f3
movl $0x3, %esi
movq 0x10(%rbx), %rdi
callq 0x2ebe
jmp 0x438a
cmpl $0x71, %eax
jne 0x438a
movb $0x1, 0x8(%rbx)
xorl %edi, %edi
callq 0x21a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
movl $0x1, %r13d
movq (%rsp), %rax
movq 0x10(%rax), %r14
movsbl 0x9(%rax), %ebp
movl $0x7, %r15d
subl %r13d, %r15d
callq 0x2090
leal (,%r13,2), %ebx
cltd
idivl %ebx
movl %edx, %r12d
addl %r15d, %r12d
callq 0x2090
cltd
idivl %ebx
addl %edx, %r15d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x2e6c
testb %al, %al
jne 0x461f
cmpl $0x8, %r13d
adcl $0x0, %r13d
jmp 0x45cb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2d79(%rip), %rbx      # 0x3fe0
leaq -0x48(%rbp), %r14
movq 0x2d5e(%rip), %r15      # 0x3fd0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x12f1
movq -0x40(%rbp), %r13
movq %r13, %rdi
callq 0x1030
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x1050
movq %r12, %rdi
callq 0x1060
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x10b0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %r15, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1070
movq %r12, %rdi
callq 0x10d0
jmp 0x1272
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x130a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x10a0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x1337
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x10a0
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x5, %edi
jg 0x2ba0
leaq 0x76b(%rip), %rdi       # 0x32f8
callq 0x2270
leaq 0x79d(%rip), %rdi       # 0x3336
callq 0x2270
jmp 0x2bf4
movq %rsi, %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %rdi
callq 0x2280
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %r13
movq 0x30(%rbx), %rcx
movq %rcx, -0x30(%rbp)
movzwl %ax, %ebx
leaq 0x557(%rip), %rdi       # 0x3125
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2060
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
movq %r12, %rcx
movq %r13, %r8
movq -0x30(%rbp), %r9
callq 0x2802
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
cmpl $0x3, %edi
jl 0x2d31
movl $0x208, %edi            # imm = 0x208
callq 0x2190
movq %rax, %rbx
movq 0x10(%r14), %rsi
movq %rax, %rdi
movl $0x8, %edx
callq 0x22d0
jmp 0x2d75
movq 0x92a0(%rip), %rbx      # 0xbfd8
leaq 0x52c5(%rip), %rsi      # 0x8004
movl $0x35, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
xorl %ebx, %ebx
movq 0x8(%r14), %rdi
callq 0x3c6a
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x45b4
movq %r14, %rdi
callq 0x46c6
movq 0x923c(%rip), %r15      # 0xbfd8
leaq 0x5297(%rip), %rsi      # 0x803a
movl $0x2f, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x45c4
leaq 0x5284(%rip), %rsi      # 0x806a
movl $0x2f, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x46a6
testq %rbx, %rbx
je 0x2e44
leaq 0x78(%rbx), %rdi
callq 0x2060
testb %al, %al
je 0x2e44
movq %rbx, %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x21e0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x208, %esi            # imm = 0x208
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x22b0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x2ee3
movq %rdi, %rbx
movl $0x10, %r12d
xorl %r13d, %r13d
leaq 0x5af7(%rip), %r15      # 0x898d
movabsq $-0x3333333333333333, %r14 # imm = 0xCCCCCCCCCCCCCCCD
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq 0x9128(%rip), %rdi      # 0xbfd8
callq 0x21d0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %r14, %rcx
addq $0x28, %r12
cmpq %r13, %rcx
ja 0x2ea0
movq 0x90ee(%rip), %rbx      # 0xbfd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x40(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
xorl %ebx, %ebx
leaq -0x60(%rbp), %r15
movq %rbx, -0x38(%rbp)
movslq %ebx, %r13
movl $0x13, %r14d
leaq 0x9559(%rip), %r12      # 0xc550
movq 0x8(%r12), %rcx
movq %r15, %rdi
movq -0x40(%rbp), %rsi
movq %r13, %rdx
callq 0x21b0
movq %r12, %rdi
movq %r15, %rsi
callq 0x2040
movl %eax, %ebx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x3031
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %ebx, %ebx
je 0x3044
addq $-0x20, %r12
decq %r14
jne 0x2ff7
movq -0x38(%rbp), %rbx
jmp 0x307f
decl %r14d
movq -0x38(%rbp), %rbx
movl %ebx, -0x60(%rbp)
movl %r14d, -0x5c(%rbp)
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x306e
movq -0x60(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x3076
movq %r15, %rdx
callq 0x41e0
movl 0x8(%r12), %eax
addl %eax, %ebx
decl %ebx
incl %ebx
movslq %ebx, %rax
movq -0x40(%rbp), %rcx
cmpq %rax, 0x8(%rcx)
ja 0x2fe3
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30a7
movq %rax, %r14
jmp 0x30c8
movq %rax, %r14
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x30c8
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21a0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x30e0
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq $-0xb, %rbx
leaq 0x90ad(%rip), %r15      # 0xc1b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2040
testl %eax, %eax
je 0x311f
addq $0x20, %r15
incq %rbx
jne 0x3103
xorl %ebx, %ebx
jmp 0x3122
addl $0xc, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
sete %al
je 0x3172
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movsbl (%rdx), %esi
addl $-0x30, %esi
cmpl $0x9, %esi
ja 0x3171
movl $0x1, %esi
movq %rsi, %rax
cmpq %rsi, %rcx
je 0x316b
movsbl (%rdx,%rax), %edi
addl $-0x30, %edi
leaq 0x1(%rax), %rsi
cmpl $0xa, %edi
jb 0x3153
cmpq %rax, %rcx
setbe %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x3290
movq (%rsi), %r12
movsbl (%r12), %edi
callq 0x2120
testl %eax, %eax
je 0x3256
cmpq $0x1, %r15
je 0x31dc
movl $0x1, %ebx
movsbl (%r12,%rbx), %r14d
movl %r14d, %edi
callq 0x2120
testl %eax, %eax
setne %al
addl $-0x30, %r14d
cmpl $0xa, %r14d
setb %cl
orb %al, %cl
je 0x3256
incq %rbx
cmpq %rbx, %r15
jne 0x31af
cmpq $0x1, %r15
je 0x325a
movq %r15, -0x30(%rbp)
movq %r15, %r13
negq %r13
xorl %ebx, %ebx
movl $0x1, %r14d
leaq (%r14,%r13), %rax
cmpq $0x1, %rax
je 0x326b
movsbl -0x1(%r12,%r14), %r15d
movl %r15d, %edi
callq 0x2120
testl %eax, %eax
je 0x3223
cmpq %r14, -0x30(%rbp)
jbe 0x327b
movsbl (%r12,%r14), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x3241
addl $-0x30, %r15d
cmpl $0x9, %r15d
ja 0x3243
cmpq %r14, -0x30(%rbp)
jbe 0x327b
movsbl (%r12,%r14), %edi
callq 0x2120
testl %eax, %eax
je 0x3243
incl %ebx
incq %r14
movq %r13, %rax
addq %r14, %rax
jne 0x31f4
cmpl $0x2, %ebx
setl %al
jmp 0x325c
xorl %eax, %eax
jmp 0x325c
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x501d(%rip), %rdi      # 0x828f
movq -0x30(%rbp), %rdx
movq %rdx, %rsi
jmp 0x3289
leaq 0x500d(%rip), %rdi      # 0x828f
movq %r14, %rsi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
callq 0x2240
leaq 0x4ff8(%rip), %rdi      # 0x828f
xorl %esi, %esi
movq %r15, %rdx
jmp 0x3289
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rdi, -0x30(%rbp)
movq %rax, 0x10(%rdi)
leaq -0x90(%rbp), %rdi
movq %rax, 0x10(%rdi)
movaps %xmm0, (%rdi)
movb $0x0, 0x8a9e(%rip)      # 0xc574
callq 0x40ce
leaq -0x298(%rbp), %rdi
callq 0x21c0
leaq -0x298(%rbp), %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x20f0
leaq -0x48(%rbp), %r13
leaq -0x68(%rbp), %rbx
leaq -0x298(%rbp), %r14
leaq -0x58(%rbp), %r15
leaq -0x78(%rbp), %r12
movq %r13, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x0, -0x48(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2210
movq %rbx, -0x78(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4146
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x36a4
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3b65
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x21a0
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x3b7a
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
movq -0x298(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x278(%rbp,%rax)
je 0x3b12
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
leaq 0x477f(%rip), %rcx      # 0x832c
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2260
leaq -0x58(%rbp), %rsi
movl $0x21, (%rsi)
movq -0x30(%rbp), %rdi
callq 0x407e
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3be1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq -0x298(%rbp), %rdi
callq 0x2070
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3c4d
movq %rax, %r14
jmp 0x3c59
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3c4d
movq -0x40(%rbp), %rsi
jmp 0x3c45
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3c38
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x21a0
jmp 0x3c38
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x3c4d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq -0x298(%rbp), %rdi
callq 0x2070
movq -0x30(%rbp), %rdi
callq 0x40ce
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
cmpb $0x0, 0x88fc(%rip)      # 0xc574
jne 0x3cab
movq %rdi, %r14
movl $0x18, %edi
callq 0x2190
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3a9a
movq %rbx, 0x88dc(%rip)      # 0xc578
movb $0x1, 0x88d1(%rip)      # 0xc574
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8326(%rip), %rbx      # 0xbfd8
leaq 0x4472(%rip), %rsi      # 0x812b
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x448a(%rip), %rsi      # 0x815a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpb $0x0, 0x886d(%rip)      # 0xc574
je 0x3d11
movq 0x8868(%rip), %rax      # 0xc578
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x82ba(%rip), %rbx      # 0xbfd8
leaq 0x4447(%rip), %rsi      # 0x816c
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x445a(%rip), %rsi      # 0x8196
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movslq 0x8807(%rip), %rsi      # 0xc570
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
imulq %r12, %rdx
cmpq %rsi, %rdx
jbe 0x3e27
movq %rdi, %rbx
leaq (%rsi,%rsi,4), %rcx
cmpl $0x21, (%rax,%rcx,8)
jne 0x3ddd
movq 0x8236(%rip), %r15      # 0xbfd8
leaq 0x43fe(%rip), %rsi      # 0x81a7
movl $0x25, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movslq 0x878c(%rip), %rsi      # 0xc570
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r12, %rdx
cmpq %rsi, %rdx
jbe 0x3e27
leaq (%rsi,%rsi,4), %rcx
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq 0x8(%rax,%rcx,8), %rsi
movq 0x10(%rax,%rcx,8), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4146
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x44a5(%rip), %rdi      # 0x82d3
xorl %eax, %eax
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq 0x8733(%rip), %rax      # 0xc570
movq 0x8(%rdi), %rcx
subq (%rdi), %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rax, %rdx
jbe 0x3e64
incl %eax
movl %eax, 0x870d(%rip)      # 0xc570
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8167(%rip), %rbx      # 0xbfd8
leaq 0x4355(%rip), %rsi      # 0x81cd
movl $0x2c, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movslq 0x86aa(%rip), %rsi      # 0xc570
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x3f44
leaq (%rsi,%rsi,4), %rcx
cmpl $0x1f, (%rax,%rcx,8)
jne 0x3f52
leaq (%rax,%rcx,8), %rax
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x4146
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x2270
movl %eax, %r14d
cmpq %r15, %rbx
je 0x3f36
movq -0x28(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x21a0
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4388(%rip), %rdi      # 0x82d3
xorl %eax, %eax
callq 0x2240
movq 0x807f(%rip), %rbx      # 0xbfd8
leaq 0x429a(%rip), %rsi      # 0x81fa
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x421f(%rip), %rsi      # 0x8196
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rsi, %rax
movslq 0x85d2(%rip), %rsi      # 0xc570
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
cmpq %rsi, %rdx
jbe 0x3ff1
leaq (%rsi,%rsi,4), %rax
cmpl $0x20, (%rcx,%rax,8)
jne 0x3fff
movq %rdi, %rbx
leaq (%rcx,%rax,8), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
callq 0x4146
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x42db(%rip), %rdi      # 0x82d3
xorl %eax, %eax
callq 0x2240
movq 0x7fd2(%rip), %rbx      # 0xbfd8
leaq 0x4214(%rip), %rsi      # 0x8221
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x4172(%rip), %rsi      # 0x8196
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x7a03(%rip), %rbx      # 0xbfd8
leaq 0x3abe(%rip), %rsi      # 0x809a
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%r14), %rdi
movl $0x1, %esi
callq 0x48a8
leaq 0x3a7e(%rip), %rsi      # 0x80a2
movl $0x5, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x8(%r14), %rdi
movl $0x1, %esi
callq 0x4c50
leaq 0x3a3b(%rip), %rsi      # 0x80a8
movl $0x3, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2100
nop