LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
andl $0x0, 0x58(%rdi)
andq $0x0, 0x8(%rdi)
cmpl $0x1, %esi
jle 0x3512
movq %rdx, %r15
movl %esi, %ebp
movq 0x8(%rdx), %rdi
callq 0x22e0
movl %eax, 0x38(%r14)
cmpl $0x2, %ebp
je 0x351a
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x2360
jmp 0x3529
movl $0x44d, 0x38(%r14)      # imm = 0x44D
leaq 0x253f(%rip), %rsi      # 0x5a60
movq %rbx, %rdi
callq 0x2360
xorl %eax, %eax
movb %al, 0x10(%r14)
movb %al, 0x4(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r14)
xorl %edi, %edi
callq 0x21e0
movl %eax, %edi
callq 0x2200
movl $0x1, (%r14)
callq 0x22c0
callq 0x20c0
movq 0x5a6f(%rip), %rax      # 0x8fd0
movq (%rax), %rdi
pushq $0x1
popq %rsi
callq 0x20f0
callq 0x2260
xorl %edi, %edi
callq 0x21a0
callq 0x2070
pushq $0x1
popq %rdi
pushq $0x6
popq %rsi
xorl %edx, %edx
callq 0x2050
pushq $0x6
popq %rdi
pushq $0x5
popq %rsi
xorl %edx, %edx
callq 0x2050
pushq $0x2
popq %rdi
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
callq 0x2050
pushq $0x3
popq %rdi
pushq $0x7
popq %rsi
pushq $0x2
popq %rdx
callq 0x2050
pushq $0x4
popq %rdi
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x2050
pushq $0x5
popq %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x2050
pushq $0xc
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2050
pushq $0xd
popq %rdi
pushq $0x5
popq %rsi
xorl %edx, %edx
callq 0x2050
movl $0x11c, %edi            # imm = 0x11C
callq 0x2220
movq %rax, %r15
movq %rax, %rdi
callq 0x2a4c
movq %r15, 0x50(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x11c, %esi            # imm = 0x11C
movq %r15, %rdi
callq 0x2230
jmp 0x3620
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/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 0x368d
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x40(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x36a1
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x36ba
movl 0xc(%rbx), %edi
callq 0x2370
cmpb $0x1, 0x4(%rbx)
jne 0x36c9
movl 0x8(%rbx), %edi
popq %rbx
jmp 0x2370
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x58de(%rip), %r12      # 0x8fd0
leaq 0x25eb(%rip), %r13      # 0x5ce4
xorl %ebx, %ebx
movq 0x58ae(%rip), %rax      # 0x8fb0
cmpl (%rax), %ebx
jge 0x3765
xorl %ebp, %ebp
movq 0x58a9(%rip), %rax      # 0x8fb8
cmpl (%rax), %ebp
jge 0x3761
callq 0x2090
andl $0x1, %eax
leal 0xc(%rax), %r14d
shll $0x8, %r14d
testl %eax, %eax
movq (%r12), %rdi
movq %r13, %r15
leaq 0x25af(%rip), %rax      # 0x5ce2
cmoveq %rax, %r15
movl %r14d, %esi
xorl %edx, %edx
callq 0x2130
movl %ebx, %edi
movl %ebp, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x22a0
movq (%r12), %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x2280
incl %ebp
jmp 0x3708
incl %ebx
jmp 0x36fb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x36e0
movq 0x50(%rbx), %rdi
callq 0x2a52
movq 0x50(%rbx), %rdi
popq %rbx
jmp 0x2aa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e99
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movsbl 0x9(%rdi), %edx
leaq 0x1f1f(%rip), %rsi      # 0x5d00
movq %r14, %rdi
xorl %eax, %eax
callq 0x2060
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x30f4
pushq $0x2
popq %rbp
movl %ebp, %edi
callq 0x21a0
movq 0x51c8(%rip), %r15      # 0x8fd0
pushq $-0x1
popq %r14
leaq 0x1ed5(%rip), %r12      # 0x5ce8
pushq $0x3
popq %r13
movq (%r15), %rdi
callq 0x20e0
leal -0x102(%rax), %ecx
cmpl $0x3, %ecx
jbe 0x3e45
cmpl $0x20, %eax
je 0x3e54
cmpl $0x57, %eax
je 0x3e54
cmpl $0x77, %eax
je 0x3e54
cmpl $0x51, %eax
je 0x3e80
cmpl $0x71, %eax
jne 0x3e17
jmp 0x3e80
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
xorl %esi, %esi
jmpq *%rax
movl %ebp, %esi
jmp 0x3e75
movq 0x10(%rbx), %rdi
movsbl 0x9(%rbx), %esi
movl %r14d, %edx
movl %r14d, %ecx
callq 0x2dd4
testb %al, %al
je 0x3e17
jmp 0x3e84
pushq $0x1
popq %rsi
jmp 0x3e75
movl %r13d, %esi
movq 0x10(%rbx), %rdi
callq 0x2e22
jmp 0x3e17
movb $0x1, 0x8(%rbx)
xorl %edi, %edi
callq 0x21a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $0x1
popq %r13
movq (%rsp), %rax
movq 0x10(%rax), %r14
movsbl 0x9(%rax), %ebp
pushq $0x7
popq %r15
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 0x2dd4
testb %al, %al
jne 0x4087
cmpl $0x8, %r13d
adcl $0x0, %r13d
jmp 0x4035
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2dac(%rip), %rbx      # 0x3fe0
leaq -0x48(%rbp), %r14
movq 0x2d91(%rip), %r15      # 0x3fd0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1090
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1294
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 0x1040
movq %r15, %rdi
movq %r12, %rsi
callq 0x1080
movq %rax, %rdi
callq 0x1060
movq %r12, %rdi
callq 0x10a0
jmp 0x123f
leaq -0x48(%rbp), %rdi
callq 0x1050
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2b54
leaq 0x79b(%rip), %rdi       # 0x32dc
callq 0x2270
leaq 0x7cd(%rip), %rdi       # 0x331a
callq 0x2270
jmp 0x2ba8
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 0x587(%rip), %rdi       # 0x3109
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 0x27df
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_O2/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 0x2bef
movl $0x208, %edi            # imm = 0x208
callq 0x2180
movq %rax, %rbx
movq 0x10(%r14), %rsi
pushq $0x8
popq %rdx
movq %rax, %rdi
callq 0x22b0
jmp 0x2c0c
movq 0x83e2(%rip), %rdi      # 0xafd8
leaq 0x4407(%rip), %rsi      # 0x7004
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %ebx, %ebx
movq 0x8(%r14), %rdi
callq 0x3600
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f30
movq %r14, %rdi
callq 0x3fde
movq 0x83a5(%rip), %r15      # 0xafd8
leaq 0x4400(%rip), %rsi      # 0x703a
movq %r15, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x3f40
leaq 0x4411(%rip), %rsi      # 0x706a
movq %r15, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x3fbe
testq %rbx, %rbx
je 0x2c93
leaq 0x78(%rbx), %rdi
callq 0x2050
testb %al, %al
je 0x2c93
movq %rbx, %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21c0
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 0x2190
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
pushq $0x8
popq %r12
xorl %r13d, %r13d
pushq $0x28
popq %r14
leaq 0x4ca3(%rip), %r15      # 0x797e
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
cqto
idivq %r14
cmpq %r13, %rax
jbe 0x2d12
addq %r12, %rsi
movq 0x82df(%rip), %rdi      # 0xafd8
callq 0x2160
movq %rax, %rdi
movq %r15, %rsi
callq 0x2170
incq %r13
addq $0x28, %r12
jmp 0x2cdb
movq 0x82bf(%rip), %rdi      # 0xafd8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
xorl %ebx, %ebx
leaq -0x60(%rbp), %r15
movq %rbx, -0x38(%rbp)
movslq %ebx, %r13
pushq $0x12
popq %r14
testl %r14d, %r14d
leaq 0x8543(%rip), %rbx      # 0xb310
js 0x2e0b
movl %r14d, %r12d
shlq $0x5, %r12
movq 0x8(%r12,%rbx), %rcx
movq %r15, %rdi
movq -0x40(%rbp), %rsi
movq %r13, %rdx
callq 0x21a0
addq %rbx, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2030
movl %eax, %ebx
movq %r15, %rdi
callq 0x20c0
testl %ebx, %ebx
je 0x2e11
decl %r14d
jmp 0x2dc3
movq -0x38(%rbp), %rbx
jmp 0x2e31
movq -0x38(%rbp), %rbx
movl %ebx, -0x60(%rbp)
movl %r14d, -0x5c(%rbp)
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x38f4
movl 0x8(%r12), %eax
addl %eax, %ebx
decl %ebx
incl %ebx
movslq %ebx, %rax
movq -0x40(%rbp), %rcx
cmpq %rax, 0x8(%rcx)
ja 0x2db8
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e67
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x20c0
jmp 0x2e6a
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x3a4a
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0xb
popq %rbx
leaq 0x831d(%rip), %r15      # 0xb1b0
testq %rbx, %rbx
je 0x2eb0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2030
testl %eax, %eax
je 0x2eb4
incq %rbx
addq $0x20, %r15
jmp 0x2e93
xorl %ebx, %ebx
jmp 0x2eb7
addl $0xc, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %eax, %eax
movq %rax, %r14
movq 0x8(%rbx), %r15
cmpq %rax, %r15
jbe 0x2ef9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22d0
movsbl (%rax), %ecx
addl $-0x30, %ecx
leaq 0x1(%r14), %rax
cmpl $0xa, %ecx
jb 0x2ed3
cmpq %r14, %r15
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %rbx
xorl %r14d, %r14d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x22d0
movsbl (%rax), %edi
callq 0x2120
testl %eax, %eax
je 0x2ffa
pushq $0x1
popq %r14
movq 0x8(%rbx), %rax
cmpq %r14, %rax
jbe 0x2f77
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22d0
movsbl (%rax), %edi
callq 0x2120
testl %eax, %eax
jne 0x2f72
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22d0
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x2ff7
incq %r14
jmp 0x2f38
xorl %r14d, %r14d
xorl %r15d, %r15d
decq %rax
cmpq %r14, %rax
jbe 0x2fed
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22d0
movsbl (%rax), %edi
callq 0x2120
testl %eax, %eax
je 0x2fb3
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x22d0
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x2fe1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22d0
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x2fe4
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x22d0
movsbl (%rax), %edi
callq 0x2120
testl %eax, %eax
je 0x2fe4
incl %r15d
incq %r14
movq 0x8(%rbx), %rax
jmp 0x2f7d
cmpl $0x2, %r15d
setl %r14b
jmp 0x2ffa
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq -0x90(%rbp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x348e
leaq -0x298(%rbp), %rdi
callq 0x21b0
leaq -0x298(%rbp), %rdi
pushq $0x8
popq %rdx
movq %r14, %rsi
callq 0x2100
leaq -0x40(%rbp), %r13
leaq -0x298(%rbp), %r14
leaq -0x50(%rbp), %r15
leaq -0x70(%rbp), %r12
movq %r13, -0x50(%rbp)
andq $0x0, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x21f0
movq %r12, %rdi
movq %r15, %rsi
callq 0x2210
movq %rbx, %rdi
movq %r12, %rsi
callq 0x31fc
movq %r12, %rdi
callq 0x20c0
movq %r15, %rdi
callq 0x20c0
movq -0x298(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x278(%rbp,%rax)
je 0x350a
leaq -0x48(%rbp), %r15
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x3d9c(%rip), %rsi      # 0x7314
movq %r15, %rdi
callq 0x22c0
leaq -0x50(%rbp), %rsi
movl $0x21, (%rsi)
movq %rbx, %rdi
callq 0x3918
movq %r15, %rdi
callq 0x20c0
leaq -0x298(%rbp), %rdi
callq 0x2060
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x35e4
movq %rax, %r14
jmp 0x35f0
movq %rax, %r14
movq %r15, %rdi
jmp 0x35df
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x20c0
jmp 0x35db
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x20c0
leaq -0x298(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x3954
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x7f66(%rip)      # 0xb574
jne 0x363f
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x2180
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x34a0
movq %rbx, 0x7f48(%rip)      # 0xb578
movb $0x1, 0x7f3d(%rip)      # 0xb574
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x7992(%rip), %rbx      # 0xafd8
leaq 0x3b0a(%rip), %rsi      # 0x7157
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x3b22(%rip), %rsi      # 0x7186
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x2190
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x7edb(%rip)      # 0xb574
je 0x36a3
movq 0x7ed6(%rip), %rax      # 0xb578
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x7928(%rip), %rbx      # 0xafd8
leaq 0x3ae1(%rip), %rsi      # 0x7198
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x3af4(%rip), %rsi      # 0x71c2
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x7e76(%rip), %rsi      # 0xb570
movq %r14, %rdi
callq 0x3980
cmpl $0x21, (%rax)
jne 0x3722
movq 0x78ca(%rip), %rdi      # 0xafd8
leaq 0x3abe(%rip), %rsi      # 0x71d3
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movslq 0x7e47(%rip), %rsi      # 0xb570
movq %r14, %rdi
callq 0x3980
leaq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7e23(%rip), %rcx      # 0xb570
movq 0x8(%rdi), %rax
subq (%rdi), %rax
pushq $0x28
popq %rsi
cqto
idivq %rsi
cmpq %rcx, %rax
jbe 0x376a
incl %ecx
movl %ecx, 0x7e07(%rip)      # 0xb570
retq
pushq %rbp
movq %rsp, %rbp
movq 0x7863(%rip), %rdi      # 0xafd8
leaq 0x3a7d(%rip), %rsi      # 0x71f9
callq 0x2170
movq %rax, %rdi
popq %rbp
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movslq 0x7dd1(%rip), %rsi      # 0xb570
callq 0x3980
cmpl $0x1f, (%rax)
jne 0x37e7
movslq 0x7dc0(%rip), %rsi      # 0xb570
movq %rbx, %rdi
callq 0x3980
leaq 0x8(%rax), %rsi
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rdi
callq 0x2250
movl %eax, %r14d
movq %rbx, %rdi
callq 0x20c0
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x77ea(%rip), %rbx      # 0xafd8
leaq 0x3a31(%rip), %rsi      # 0x7226
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x39b6(%rip), %rsi      # 0x71c2
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x7d38(%rip), %rsi      # 0xb570
movq %r14, %rdi
callq 0x3980
cmpl $0x20, (%rax)
jne 0x3868
movslq 0x7d24(%rip), %rsi      # 0xb570
movq %r14, %rdi
callq 0x3980
leaq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x7769(%rip), %rbx      # 0xafd8
leaq 0x39d7(%rip), %rsi      # 0x724d
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x3935(%rip), %rsi      # 0x71c2
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x7084(%rip), %rbx      # 0xafd8
leaq 0x313f(%rip), %rsi      # 0x709a
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq (%r14), %rdi
pushq $0x1
popq %r15
movl %r15d, %esi
callq 0x418c
leaq 0x3121(%rip), %rsi      # 0x70a2
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x8(%r14), %rdi
movl %r15d, %esi
callq 0x44ac
leaq 0x3104(%rip), %rsi      # 0x70a8
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Prog.cpp
// Function: Prog::ParseProg()
void Prog::ParseProg(){
  Tokenizer *tokensProg; // declare a singleton Tokenizer class
  tokensProg = Tokenizer::getInstance();// get instance of the Tokenizer class  
  if (tokensProg->getToken().compare("program") != 0){
    cout << "Syntax error: the first token is not \"program\"!"<< endl;
    cout << "program stoppted." << endl;
    exit(0);
  }
  tokensProg->skipToken();
  ds = new DeclSeq();
  ds->ParseDeclSeq();
  if (tokensProg->getToken().compare("begin") != 0){
    cout << "Syntax error: \"begin\" is not in the right place!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
  tokensProg->skipToken();
  ss = new StmtSeq(infile);
  ss->ParseStmtSeq();
  //tokensProg->skipToken();
  if (tokensProg->getToken().compare("end") != 0){
    cout << "Syntax error: \"end\" is not in the right place!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
  else{
    tokensProg->skipToken();
    return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
callq 0x3692
movq %rax, %rbx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x36e6
leaq 0x308c(%rip), %rsi      # 0x709a
movq %r15, %rdi
callq 0x2080
movl %eax, %r12d
movq %r15, %rdi
callq 0x20c0
testl %r12d, %r12d
jne 0x40f0
movq %rbx, %rdi
callq 0x3746
pushq $0x10
popq %rdi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
callq 0x4180
movq %r15, (%r14)
movq %r15, %rdi
callq 0x41d2
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x36e6
leaq 0x303c(%rip), %rsi      # 0x70a2
movq %r15, %rdi
callq 0x2080
movl %eax, %r12d
movq %r15, %rdi
callq 0x20c0
testl %r12d, %r12d
jne 0x4117
movq %rbx, %rdi
callq 0x3746
pushq $0x18
popq %rdi
callq 0x2180
movq %rax, %r15
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x449c
movq %r15, 0x8(%r14)
movq %r15, %rdi
callq 0x44f2
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36e6
leaq 0x2fe5(%rip), %rsi      # 0x70a8
movq %r14, %rdi
callq 0x2080
movl %eax, %r15d
movq %r14, %rdi
callq 0x20c0
testl %r15d, %r15d
jne 0x4127
movq %rbx, %rdi
callq 0x3746
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x6ee1(%rip), %rbx      # 0xafd8
leaq 0x3218(%rip), %rsi      # 0x7316
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x3231(%rip), %rsi      # 0x7346
jmp 0x414c
movq 0x6eba(%rip), %rbx      # 0xafd8
leaq 0x3233(%rip), %rsi      # 0x7358
jmp 0x4135
movq 0x6eaa(%rip), %rbx      # 0xafd8
leaq 0x3254(%rip), %rsi      # 0x7389
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x2ffa(%rip), %rsi      # 0x7146
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
movq %rax, %rbx
pushq $0x18
jmp 0x416f
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x3692
movq %rax, %r14
pushq $0x8
popq %rdi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
callq 0x42f8
movq %r15, (%rbx)
movq %r15, %rdi
callq 0x4386
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x36e6
leaq -0x38(%rbp), %r14
leaq -0x58(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x20c0
leaq 0x2e66(%rip), %rsi      # 0x70ac
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x42a3
leaq 0x2e49(%rip), %rsi      # 0x70a2
leaq -0x38(%rbp), %rdi
callq 0x2080
testl %eax, %eax
je 0x42bd
movq 0x6d6b(%rip), %rdi      # 0xafd8
leaq 0x3144(%rip), %rsi      # 0x73b8
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x6d50(%rip), %rdi      # 0xafd8
leaq 0x2f33(%rip), %rsi      # 0x71c2
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
pushq $0x10
popq %rdi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x41d2
leaq -0x38(%rbp), %rdi
callq 0x20c0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42e3
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x2190
jmp 0x42ef
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
testl %esi, %esi
cmovgl %esi, %r12d
movq 0x6cb8(%rip), %r14      # 0xafd8
leaq 0x30af(%rip), %r15      # 0x73d6
subl $0x1, %r12d
jb 0x433a
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
jmp 0x4327
movq 0x6c97(%rip), %r14      # 0xafd8
leaq 0x3090(%rip), %rsi      # 0x73d8
movq %r14, %rdi
callq 0x2170
movq (%rbx), %rdi
callq 0x45c4
leaq 0x33e5(%rip), %rsi      # 0x7744
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
callq 0x3692
movq %rax, %rbx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x36e6
leaq 0x2cf6(%rip), %rsi      # 0x70ac
movq %r15, %rdi
callq 0x2080
movl %eax, %r12d
movq %r15, %rdi
callq 0x20c0
testl %r12d, %r12d
jne 0x4437
movq %rbx, %rdi
callq 0x3746
pushq $0x10
popq %rdi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
callq 0x45b8
movq %r15, (%r14)
movq %r15, %rdi
callq 0x462c
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36e6
leaq 0x333a(%rip), %rsi      # 0x7744
movq %r14, %rdi
callq 0x2080
movl %eax, %r15d
movq %r14, %rdi
callq 0x20c0
testl %r15d, %r15d
jne 0x4447
movq %rbx, %rdi
callq 0x3746
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x6b9a(%rip), %rbx      # 0xafd8
leaq 0x2f98(%rip), %rsi      # 0x73dd
jmp 0x4455
movq 0x6b8a(%rip), %rbx      # 0xafd8
leaq 0x2fa2(%rip), %rsi      # 0x73f7
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x2cda(%rip), %rsi      # 0x7146
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2290
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
pushq $0x30
popq %rdi
callq 0x2180
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x4bd4
movq %r14, (%rbx)
movq %r14, %rdi
callq 0x4d0e
callq 0x3692
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x36e6
leaq 0x2b6b(%rip), %rsi      # 0x70a8
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x457f
leaq 0x2b63(%rip), %rsi      # 0x70b3
leaq -0x30(%rbp), %rdi
callq 0x2080
testl %eax, %eax
je 0x457f
pushq $0x18
popq %rdi
callq 0x2180
movq 0x10(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x44f2
leaq -0x30(%rbp), %rdi
callq 0x20c0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x20c0
jmp 0x45ad
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2290
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/IdList.cpp
// Function: IdList::PrintIdList()
void IdList::PrintIdList(){
  id->PrintId();
  if (idList != NULL){
    cout << ", ";
    idList->PrintIdList();
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x6a00(%rip), %r14      # 0xafd8
leaq 0x2e39(%rip), %r15      # 0x7418
movq (%rbx), %rdi
callq 0x492a
cmpq $0x0, 0x8(%rbx)
je 0x45ff
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movq 0x8(%rbx), %rbx
jmp 0x45df
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/IdList.cpp
// Function: IdList::ParseIdList()
void IdList::ParseIdList(){
  Tokenizer *tokensIdList;
  tokensIdList = Tokenizer::getInstance();
  id = Id::ParseId();
  string tokenTemp = tokensIdList->getToken();
  if (tokenTemp.compare(",") == 0){
    tokensIdList->skipToken();
    idList = new IdList();
    idList->ParseIdList();
    return;
  }
  else if (tokenTemp.compare(";") == 0){
    return;
  }
  else{
    cout << "token is : " << tokenTemp << endl;
    cout << "Syntax error: IdList error" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x3692
movq %rax, %r14
callq 0x47b8
movq %rax, (%rbx)
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x36e6
leaq 0x2a67(%rip), %rsi      # 0x70c9
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
je 0x46ea
leaq 0x30cf(%rip), %rsi      # 0x7744
leaq -0x38(%rbp), %rdi
callq 0x2080
testl %eax, %eax
je 0x470c
movq 0x694b(%rip), %rdi      # 0xafd8
leaq 0x2d87(%rip), %rsi      # 0x741b
callq 0x2170
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
movq 0x6924(%rip), %rdi      # 0xafd8
leaq 0x2d6c(%rip), %rsi      # 0x7427
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x6909(%rip), %rdi      # 0xafd8
leaq 0x2a70(%rip), %rsi      # 0x7146
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
movq %r14, %rdi
callq 0x3746
pushq $0x10
popq %rdi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x462c
leaq -0x38(%rbp), %rdi
callq 0x20c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Id.cpp
// Function: Id::Id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Id::Id(string n){  
  //cout << "Id::Id(string n) before initialize:" << endl;
  name = n;
  //cout << "name = " << name << endl;
  declared = false;
  //cout << "declared = " << declared << endl;
  initialized = false;
  //cout << "Id::Id(string n) after initialize" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x20f0
andw $0x0, 0x24(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Id.cpp
// Function: Id::ParseId()
Id* Id::ParseId(){
  Tokenizer *tokensId;
  tokensId = Tokenizer::getInstance();
  string tokenTemp = tokensId->getToken();
  int tokenType = tokensId->getTokenType();
  if (tokenType != tokensId->idNum) {
    cout << "Error: " << tokenTemp << " is not a legal identifier!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }

  for (int k = 0; k < idCount; k++){
    if (tokenTemp.compare(eIds[k]->name) == 0){
      tokensId->skipToken();
      return eIds[k];
    }
  }
  // if not found
  Id *nId = new Id(tokenTemp);
  eIds[idCount] = nId;
  idCount++;
  tokensId->skipToken();
  return nId;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
callq 0x3692
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x36e6
movq %rbx, %rdi
callq 0x38a4
leaq 0x2b22(%rip), %rcx      # 0x730c
cmpl (%rcx), %eax
jne 0x488f
xorl %r12d, %r12d
leaq 0x6da4(%rip), %r15      # 0xb5a0
leaq -0x40(%rbp), %r14
movslq 0x6e39(%rip), %rax      # 0xb640
cmpq %rax, %r12
jge 0x482e
movq (%r15,%r12,8), %rsi
movq %r14, %rdi
callq 0x2030
incq %r12
testl %eax, %eax
jne 0x4800
movq %rbx, %rdi
callq 0x3746
movq -0x8(%r15,%r12,8), %r14
jmp 0x4876
pushq $0x28
popq %rdi
callq 0x2180
movq %rax, %r14
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2210
leaq -0x60(%rbp), %rsi
movq %r14, %rdi
callq 0x477c
leaq -0x60(%rbp), %rdi
callq 0x20c0
movslq 0x6dde(%rip), %rax      # 0xb640
movq %r14, (%r15,%rax,8)
incl %eax
movl %eax, 0x6dd2(%rip)      # 0xb640
movq %rbx, %rdi
callq 0x3746
leaq -0x40(%rbp), %rdi
callq 0x20c0
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x6742(%rip), %rdi      # 0xafd8
leaq 0x2ba5(%rip), %rsi      # 0x7442
callq 0x2170
leaq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x2160
leaq 0x2b95(%rip), %rsi      # 0x744a
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x670c(%rip), %rdi      # 0xafd8
leaq 0x2873(%rip), %rsi      # 0x7146
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
jmp 0x490b
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20c0
jmp 0x48fa
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x2190
jmp 0x490e
jmp 0x490b
jmp 0x490b
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Id.cpp
// Function: Id::GetIdVal()
int Id::GetIdVal(){
  if (initialized){
    return val;
  }
  else {
    cout << "Error: GetIdVal: id \"" << name << "\" is not initialzied yet!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x25(%rdi)
jne 0x4956
movl 0x20(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x667b(%rip), %r14      # 0xafd8
leaq 0x2b02(%rip), %rsi      # 0x7466
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2160
leaq 0x2afe(%rip), %rsi      # 0x747c
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x27b1(%rip), %rsi      # 0x7146
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Stmt.cpp
// Function: Stmt::PrintStmt(int)
void Stmt::PrintStmt(int level){
  if (assign != NULL){
    assign->PrintAssign(level);
  }
  else if (ifc != NULL){
    ifc->PrintIfc(level);
  }
  else if (loop != NULL){
    loop->PrintLoop(level);
  }
  else if (input != NULL){
    input->PrintInput(level);
  }
  else if (output != NULL){
    output->PrintOutput(level);
  }
  else{
    cout << "Error: PrintStmt: None of alternative is found!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4bff
movq %rax, %rdi
jmp 0x4e7c
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x4c10
movq %rax, %rdi
jmp 0x5f2a
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x4c21
movq %rax, %rdi
jmp 0x57d8
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x4c32
movq %rax, %rdi
jmp 0x5b56
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
jne 0x5d3e
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x638c(%rip), %rbx      # 0xafd8
leaq 0x28dd(%rip), %rsi      # 0x7530
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x24dc(%rip), %rsi      # 0x7146
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Stmt.cpp
// Function: Stmt::ExecStmt()
void Stmt::ExecStmt(){
  if (assign != NULL){
    assign->ExecAssign();
  }
  else if (ifc != NULL){
    ifc->ExecIfc();
  }
  else if (loop != NULL){
    loop->ExecLoop();
  }
  else if (input != NULL){
    input->ExecInput();
  }
  else if (output != NULL){
    output->ExecOutput();
  }
  else {
    cout << "Error: ExecStmt: No alternative is found!" << endl;
    cout << "program stopped.";
    exit(0);
  }
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x4c93
movq %rax, %rdi
jmp 0x4efa
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x4ca4
movq %rax, %rdi
jmp 0x604a
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x4cb5
movq %rax, %rdi
jmp 0x58a4
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x4cc6
movq %rax, %rdi
jmp 0x5bcc
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
jne 0x5db4
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x62f8(%rip), %rbx      # 0xafd8
leaq 0x2879(%rip), %rsi      # 0x7560
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x2448(%rip), %rsi      # 0x7146
movq %rbx, %rdi
callq 0x2170
xorl %edi, %edi
callq 0x21d0
nop