LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
callq 0x3d00
movq %rax, %rbx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x3d54
leaq 0x39a2(%rip), %rsi      # 0x809a
movq %r12, %rdi
callq 0x2090
movl %eax, %r15d
movq (%r12), %rdi
leaq -0x38(%rbp), %r13
cmpq %r13, %rdi
je 0x471c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %r15d, %r15d
jne 0x4806
movq %rbx, %rdi
callq 0x3e36
movl $0x10, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x489c
movq %r15, (%r14)
movq %r15, %rdi
callq 0x48ee
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3d54
leaq 0x3943(%rip), %rsi      # 0x80a2
movq %r12, %rdi
callq 0x2090
movl %eax, %r15d
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x477f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %r15d, %r15d
jne 0x482d
movq %rbx, %rdi
callq 0x3e36
movl $0x18, %edi
callq 0x2190
movq %rax, %r15
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x4c40
movq %r15, 0x8(%r14)
movq %r15, %rdi
callq 0x4c96
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3d54
leaq 0x38dd(%rip), %rsi      # 0x80a8
movq %r15, %rdi
callq 0x2090
movl %eax, %r14d
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x47ea
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %r14d, %r14d
jne 0x483d
movq %rbx, %rdi
callq 0x3e36
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x77cb(%rip), %rbx      # 0xbfd8
leaq 0x3b1a(%rip), %rsi      # 0x832e
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x3b33(%rip), %rsi      # 0x835e
jmp 0x4862
movq 0x77a4(%rip), %rbx      # 0xbfd8
leaq 0x3b35(%rip), %rsi      # 0x8370
jmp 0x484b
movq 0x7794(%rip), %rbx      # 0xbfd8
leaq 0x3b56(%rip), %rsi      # 0x83a1
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x38b8(%rip), %rsi      # 0x811a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
movq %rax, %rbx
movl $0x18, %esi
jmp 0x488b
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d00
movq %rax, %r14
movl $0x8, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x4a50
movq %r15, (%rbx)
movq %r15, %rdi
callq 0x4b0a
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x3d54
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %r14
movq %r14, %rsi
callq 0x2200
movq (%r14), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x496e
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq 0x3737(%rip), %rsi      # 0x80ac
leaq -0x38(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x49e5
leaq 0x3719(%rip), %rsi      # 0x80a2
leaq -0x38(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x4a01
movq 0x763b(%rip), %rdi      # 0xbfd8
leaq 0x3a2c(%rip), %rsi      # 0x83d0
movl $0x1d, %edx
callq 0x21d0
movq 0x7623(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x7617(%rip), %rdi      # 0xbfd8
leaq 0x37ce(%rip), %rsi      # 0x8196
movl $0x10, %edx
callq 0x21d0
movq 0x75ff(%rip), %rdi      # 0xbfd8
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
movl $0x10, %edi
callq 0x2190
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x48ee
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4a16
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4a30
movq %rax, %rbx
movl $0x8, %esi
movq %r15, %rdi
jmp 0x4a43
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4a48
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
testl %esi, %esi
jle 0x4a96
movl %esi, %r14d
movq 0x755e(%rip), %r15      # 0xbfd8
leaq 0x396d(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r14d
jne 0x4a81
movq 0x753b(%rip), %r14      # 0xbfd8
leaq 0x394c(%rip), %rsi      # 0x83f0
movl $0x4, %edx
movq %r14, %rdi
callq 0x21d0
movq (%rbx), %rdi
callq 0x4d88
leaq 0x3cac(%rip), %rsi      # 0x876c
movl $0x1, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d00
movq %rax, %rbx
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x3d54
leaq 0x3572(%rip), %rsi      # 0x80ac
movq %r12, %rdi
callq 0x2090
movl %eax, %r15d
movq (%r12), %rdi
leaq -0x30(%rbp), %r12
cmpq %r12, %rdi
je 0x4b5e
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %r15d, %r15d
jne 0x4bda
movq %rbx, %rdi
callq 0x3e36
movl $0x10, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x4d7c
movq %r15, (%r14)
movq %r15, %rdi
callq 0x4df6
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3d54
leaq 0x3bcb(%rip), %rsi      # 0x876c
movq %r15, %rdi
callq 0x2090
movl %eax, %r14d
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x4bc0
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %r14d, %r14d
jne 0x4bea
movq %rbx, %rdi
callq 0x3e36
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x73f7(%rip), %rbx      # 0xbfd8
leaq 0x380d(%rip), %rsi      # 0x83f5
jmp 0x4bf8
movq 0x73e7(%rip), %rbx      # 0xbfd8
leaq 0x3817(%rip), %rsi      # 0x840f
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x350b(%rip), %rsi      # 0x811a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x30, %edi
callq 0x2190
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x5534
movq %r14, (%rbx)
movq %r14, %rdi
callq 0x5670
callq 0x3d00
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3d54
leaq 0x33c5(%rip), %rsi      # 0x80a8
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x4d27
leaq 0x373a(%rip), %rsi      # 0x8430
leaq -0x30(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x4d27
movl $0x18, %edi
callq 0x2190
movq 0x10(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x4c96
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4d40
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4d72
movq -0x20(%rbp), %rsi
incq %rsi
jmp 0x4d6d
movq %rax, %rbx
movl $0x30, %esi
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x723c(%rip), %r14      # 0xbfd8
leaq 0x3692(%rip), %r15      # 0x8435
movq (%rbx), %rdi
callq 0x51e4
cmpq $0x0, 0x8(%rbx)
je 0x4dc8
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d0
movq 0x8(%rbx), %rbx
jmp 0x4da3
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d00
movq %rax, %r14
callq 0x4fe0
movq %rax, (%rbx)
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d54
leaq 0x360c(%rip), %rsi      # 0x8438
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
je 0x4ed7
leaq 0x3929(%rip), %rsi      # 0x876c
leaq -0x38(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x4efb
movq 0x717d(%rip), %rdi      # 0xbfd8
leaq 0x35d8(%rip), %rsi      # 0x843a
movl $0xb, %edx
callq 0x21d0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x715d(%rip), %rdi      # 0xbfd8
callq 0x21d0
movq %rax, %rdi
callq 0x20c0
movq 0x7149(%rip), %rdi      # 0xbfd8
leaq 0x35b0(%rip), %rsi      # 0x8446
movl $0x1a, %edx
callq 0x21d0
movq 0x7131(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x7125(%rip), %rdi      # 0xbfd8
leaq 0x3260(%rip), %rsi      # 0x811a
movl $0x10, %edx
callq 0x21d0
movq 0x710d(%rip), %rdi      # 0xbfd8
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
movq %r14, %rdi
callq 0x3e36
movl $0x10, %edi
callq 0x2190
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x4df6
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f14
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f3b
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x20e0
movw $0x0, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x4fd8
movq (%r15), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
callq 0x3d00
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x3d54
movq %rbx, %rdi
callq 0x403c
leaq 0x3310(%rip), %rcx      # 0x8324
cmpl (%rcx), %eax
jne 0x510e
cmpl $0x0, 0x761d(%rip)      # 0xc640
setg %r13b
leaq 0x7572(%rip), %r12      # 0xc5a0
jle 0x5060
xorl %r14d, %r14d
leaq -0x48(%rbp), %r15
movq (%r12), %rsi
movq %r15, %rdi
callq 0x2040
testl %eax, %eax
je 0x5062
incq %r14
movslq 0x75ef(%rip), %rax      # 0xc640
addq $0x8, %r12
cmpq %rax, %r14
setl %r13b
jl 0x5037
jmp 0x506e
jmp 0x506e
movq %rbx, %rdi
callq 0x3e36
movq (%r12), %rcx
testb $0x1, %r13b
movq %rcx, %r15
jne 0x50e3
movl $0x28, %edi
callq 0x2190
movq %rax, %r15
leaq -0x58(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x4146
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
callq 0x4f8c
leaq 0x74ed(%rip), %r12      # 0xc5a0
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x50c8
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21a0
movslq 0x7571(%rip), %rax      # 0xc640
movq %r15, (%r12,%rax,8)
incl %eax
movl %eax, 0x7565(%rip)      # 0xc640
movq %rbx, %rdi
callq 0x3e36
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50fc
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6ec3(%rip), %rdi      # 0xbfd8
leaq 0x3345(%rip), %rsi      # 0x8461
movl $0x7, %edx
callq 0x21d0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x6ea3(%rip), %rdi      # 0xbfd8
callq 0x21d0
movq %rax, %rbx
leaq 0x3325(%rip), %rsi      # 0x8469
movl $0x1b, %edx
movq %rax, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x20c0
movq 0x6e78(%rip), %rdi      # 0xbfd8
leaq 0x2fb3(%rip), %rsi      # 0x811a
movl $0x10, %edx
callq 0x21d0
movq 0x6e60(%rip), %rdi      # 0xbfd8
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
jmp 0x51b6
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0x51a3
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21a0
jmp 0x51a3
movq %rax, %rbx
movl $0x28, %esi
movq %r15, %rdi
callq 0x21a0
jmp 0x51b9
jmp 0x51b6
jmp 0x51b6
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51d2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5214
movl 0x20(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x6dbd(%rip), %r14      # 0xbfd8
leaq 0x3263(%rip), %rsi      # 0x8485
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2160
leaq 0x325f(%rip), %rsi      # 0x849b
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2ec7(%rip), %rsi      # 0x811a
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5561
movq %rax, %rdi
jmp 0x57f0
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x5572
movq %rax, %rdi
jmp 0x6b9c
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x5583
movq %rax, %rdi
jmp 0x6260
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x5594
movq %rax, %rdi
jmp 0x66be
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
jne 0x692a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x6a2a(%rip), %rbx      # 0xbfd8
leaq 0x2f9f(%rip), %rsi      # 0x8554
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2b4e(%rip), %rsi      # 0x811a
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/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 0x55f5
movq %rax, %rdi
jmp 0x5898
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x5606
movq %rax, %rdi
jmp 0x6d3a
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x5617
movq %rax, %rdi
jmp 0x6376
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x5628
movq %rax, %rdi
jmp 0x675c
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
jne 0x69c8
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x6996(%rip), %rbx      # 0xbfd8
leaq 0x2f3b(%rip), %rsi      # 0x8584
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2aba(%rip), %rsi      # 0x811a
movq %rbx, %rdi
callq 0x2180
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Stmt.cpp
// Function: Stmt::ParseStmt()
void Stmt::ParseStmt(){
  Tokenizer *tokensStmt;
  tokensStmt = Tokenizer::getInstance();
  int tokenType = tokensStmt->getTokenType();
  if (tokenType == tokensStmt->idNum){
    assign = new Assign();
    assign->ParseAssign();
  }
  else if (tokenType == 5){//5 for 'ifc'
    ifc = new Ifc(infile);
    ifc->ParseIfc();
  }
  else if (tokenType == 8){// 8 for 'while'
    loop = new Loop(infile);
    loop->ParseLoop();
  }
  else if (tokenType == 10){//10 for 'read'
    input = new Input(infile);
    input->ParseInput();
  }
  else if (tokenType == 11){//11 for 'write'
    output = new Output();
    output->ParseOutput();
  }
  else{
    cout << "Error: Stmt" << endl;
    cout << "program stopped" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3d00
movq %rax, %rdi
callq 0x403c
leaq 0x2c96(%rip), %rcx      # 0x8324
cmpl (%rcx), %eax
jne 0x56b7
movl $0x10, %edi
callq 0x2190
movq %rax, %r14
movq %rax, %rdi
callq 0x57e4
movq %r14, 0x8(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x58ba
addl $-0x5, %eax
cmpl $0x6, %eax
ja 0x5770
leaq 0x2e6e(%rip), %rcx      # 0x8538
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x20, %edi
callq 0x2190
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x6b84
movq %r14, 0x10(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6d70
movl $0x10, %edi
callq 0x2190
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x66ac
movq %r14, 0x20(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6770
movl $0x8, %edi
callq 0x2190
movq %rax, %r14
movq %rax, %rdi
callq 0x691c
movq %r14, 0x28(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x69d6
movl $0x18, %edi
callq 0x2190
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x6250
movq %r14, 0x18(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x63a0
movq 0x6861(%rip), %rbx      # 0xbfd8
leaq 0x2e30(%rip), %rsi      # 0x85ae
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2e25(%rip), %rsi      # 0x85ba
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
movq %rax, %rbx
movl $0x18, %esi
jmp 0x57d4
movq %rax, %rbx
movl $0x20, %esi
jmp 0x57d4
movq %rax, %rbx
movl $0x8, %esi
jmp 0x57d4
jmp 0x57cc
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Assign.cpp
// Function: Assign::PrintAssign(int)
void Assign::PrintAssign(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  id->PrintId();
  cout << " = ";
  expr->PrintExpr();
  cout << ";" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x5828
movl %esi, %r14d
movq 0x67cc(%rip), %r15      # 0xbfd8
leaq 0x2bdb(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r14d
jne 0x5813
movq (%rbx), %rdi
callq 0x51e4
movq 0x67a1(%rip), %r14      # 0xbfd8
leaq 0x2cf3(%rip), %rsi      # 0x8531
movl $0x3, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rdi
callq 0x5b14
leaq 0x2f11(%rip), %rsi      # 0x876c
movl $0x1, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Expr.cpp
// Function: Expr::PrintExpr()
void Expr::PrintExpr(){
  fac->PrintFac();
  if (alterId == 2){
    cout << " + ";
    expr->PrintExpr();
    return;
  }
  else if (alterId == 3){
    cout << " - ";
    expr->PrintExpr();
    return;
  }
  else if (alterId == 1){
    return;
  }
  else {
    cout << "Error: PrintExpr: Wrong alterId" << endl;
    cout << "program stopped" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x2b2c(%rip), %r15      # 0x8655
movq 0x64a8(%rip), %r14      # 0xbfd8
leaq 0x2b22(%rip), %r12      # 0x8659
movq (%rbx), %rdi
callq 0x5d90
movl 0x10(%rbx), %eax
movq %r15, %rsi
cmpl $0x2, %eax
je 0x5b52
cmpl $0x3, %eax
jne 0x5b65
movq %r12, %rsi
movl $0x3, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rbx
jmp 0x5b37
cmpl $0x1, %eax
jne 0x5b73
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x645e(%rip), %rbx      # 0xbfd8
leaq 0x2adc(%rip), %rsi      # 0x865d
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2a22(%rip), %rsi      # 0x85ba
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/Expr.cpp
// Function: Expr::EvalExpr()
int Expr::EvalExpr(){
  if (alterId == 1){
    return fac->EvalFac();
  }
  else if (alterId == 2){
    return fac->EvalFac() + expr->EvalExpr();
  }
  else if (alterId == 3){
    return fac->EvalFac() - expr->EvalExpr();
  }
  else {
    cout << "Error: EvalExpr: Wrong alterId"  << endl;
    cout << "program stopped" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movl 0x10(%r14), %eax
cmpl $0x2, %eax
jne 0x5bd8
movq (%r14), %rdi
callq 0x5ddc
movq 0x8(%r14), %r14
addl %eax, %ebx
jmp 0x5bbf
cmpl $0x3, %eax
je 0x5bee
cmpl $0x1, %eax
jne 0x5c15
movq (%r14), %rdi
callq 0x5ddc
addl %eax, %ebx
jmp 0x5c08
movq (%r14), %rdi
callq 0x5ddc
movl %eax, %r15d
movq 0x8(%r14), %rdi
callq 0x5bb0
subl %eax, %r15d
addl %r15d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x63bc(%rip), %rbx      # 0xbfd8
leaq 0x2a5a(%rip), %rsi      # 0x867d
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2980(%rip), %rsi      # 0x85ba
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/Expr.cpp
// Function: Expr::ParseExpr()
void Expr::ParseExpr(){
  Tokenizer *tokensExpr;
  tokensExpr = Tokenizer::getInstance();
  fac = new Fac();
  fac->ParseFac();
  string tokenTemp = tokensExpr->getToken();
  if (tokenTemp.compare("+") == 0){
    tokensExpr->skipToken();
    expr = new Expr();
    expr->ParseExpr();
    alterId = 2;
    return;
  }
  else if (tokenTemp.compare("-") == 0){
    tokensExpr->skipToken();
    expr = new Expr();
    expr->ParseExpr();
    alterId = 3;
    return;
  }
  else{
    alterId = 1;
    return;
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x3d00
movq %rax, %r14
movl $0x10, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x5d84
movq %r15, (%rbx)
movq %r15, %rdi
callq 0x5e18
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d54
leaq 0x29fc(%rip), %rsi      # 0x869c
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
je 0x5cf9
leaq 0x2802(%rip), %rsi      # 0x84b5
leaq -0x38(%rbp), %rdi
callq 0x2090
movl $0x1, %r15d
testl %eax, %eax
jne 0x5d2a
movq %r14, %rdi
callq 0x3e36
movl $0x18, %edi
callq 0x2190
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
movl $0x3, %r15d
movq %rax, %rdi
callq 0x5c52
jmp 0x5d2a
movq %r14, %rdi
callq 0x3e36
movl $0x18, %edi
callq 0x2190
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
movl $0x2, %r15d
movq %rax, %rdi
callq 0x5c52
movl %r15d, 0x10(%rbx)
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d47
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
jmp 0x5d76
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d7b
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Fac.cpp
// Function: Fac::PrintFac()
void Fac::PrintFac(){
  op->PrintOp();
  if (fac != NULL){
    cout << " * ";
    fac->PrintFac();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x6234(%rip), %r14      # 0xbfd8
leaq 0x28f3(%rip), %r15      # 0x869e
movq (%rbx), %rdi
callq 0x5efc
cmpq $0x0, 0x8(%rbx)
je 0x5dd0
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d0
movq 0x8(%rbx), %rbx
jmp 0x5dab
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Fac.cpp
// Function: Fac::EvalFac()
int Fac::EvalFac(){
  if (fac == NULL){
    return op->EvalOp();
  }  
  else{
    return op->EvalOp() * fac->EvalFac();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %ebx
movq 0x8(%r14), %r15
movq (%r14), %rdi
callq 0x5faa
testq %r15, %r15
je 0x5e08
movq 0x8(%r14), %r14
imull %eax, %ebx
jmp 0x5dee
imull %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Fac.cpp
// Function: Fac::ParseFac()
void Fac::ParseFac(){
  Tokenizer *tokensFac;
  tokensFac = Tokenizer::getInstance();
  op = new Op();
  op->ParseOp();
  string tokenTemp = tokensFac->getToken();
  if (tokenTemp.compare("*") != 0){
    return;
  }
  else{
    tokensFac->skipToken();
    fac = new Fac();
    fac->ParseFac();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x3d00
movq %rax, %r14
movl $0x20, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x5eec
movq %r15, (%rbx)
movq %r15, %rdi
callq 0x6018
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d54
leaq 0x283c(%rip), %rsi      # 0x86a2
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
jne 0x5e96
movq %r14, %rdi
callq 0x3e36
movl $0x10, %edi
callq 0x2190
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x5e18
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5eaf
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
jmp 0x5ede
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5ee3
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Op.cpp
// Function: Op::PrintOp()
void Op::PrintOp(){
  if (alterId == 1){
    inte->PrintInte();
    return;
  }
  else if (alterId == 2){
    id->PrintId();
    return;
  }
  else if (alterId == 3){
    cout << "( ";
    expr->PrintExpr();
    cout << " )";
    return;
  }
  else {
    cout << "Error: PrintOp: Wrong alterId" << endl;
    cout << "program stopped" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %eax
cmpl $0x3, %eax
je 0x5f31
cmpl $0x2, %eax
je 0x5f24
cmpl $0x1, %eax
jne 0x5f6d
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6176
movq 0x8(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x51e4
movq 0x60a0(%rip), %r14      # 0xbfd8
leaq 0x2765(%rip), %rsi      # 0x86a4
movl $0x2, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x10(%rbx), %rdi
callq 0x5b14
leaq 0x274b(%rip), %rsi      # 0x86a7
movl $0x2, %edx
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21d0
movq 0x6064(%rip), %rbx      # 0xbfd8
leaq 0x272f(%rip), %rsi      # 0x86aa
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2628(%rip), %rsi      # 0x85ba
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/Op.cpp
// Function: Op::EvalOp()
int Op::EvalOp(){
  
  if (alterId == 1){
    return inte->EvalInte();
  }
  else if (alterId ==2){
    return id->GetIdVal();
  }
  else if (alterId ==3){
    return expr->EvalExpr();
  }
  else {
    cout << "Error: EvalOp: Wrong alterId" << endl;
    cout << "program stopped" << endl;
    exit(0);
  }
}

// Assembly:
movl 0x18(%rdi), %eax
cmpl $0x3, %eax
je 0x5fcd
cmpl $0x2, %eax
je 0x5fc4
cmpl $0x1, %eax
jne 0x5fd6
movq (%rdi), %rdi
jmp 0x618e
movq 0x8(%rdi), %rdi
jmp 0x51fc
movq 0x10(%rdi), %rdi
jmp 0x5bb0
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x5ff5(%rip), %rbx      # 0xbfd8
leaq 0x26de(%rip), %rsi      # 0x86c8
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x25b9(%rip), %rsi      # 0x85ba
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/Op.cpp
// Function: Op::ParseOp()
void Op::ParseOp(){
  Tokenizer *tokensOp;
  tokensOp = Tokenizer::getInstance();
  int tokenType = tokensOp->getTokenType();
  if (tokenType == tokensOp->intNum){
    alterId = 1;
    inte = new Inte();
    inte->ParseInte();
  }
  else if (tokenType == tokensOp->idNum){
    //cout << "token.name: "<< tokensOp->getToken() << endl;
    alterId = 2;
    id = Id::ParseId();    
  }
  else if (tokenType == 20){//20 for "("
    alterId = 3;
    tokensOp->skipToken();
    expr = new Expr();
    expr->ParseExpr();
    tokenType = tokensOp->getTokenType();
    if (tokenType == 21){//21 for ")"
      tokensOp->skipToken();
    }
    else {
      cout << "Error: ParseOp: \")\" not found or not in right place!" << endl;
      cout << "program stopped." << endl;
      exit(0);
    }
  }
  else {
    cout << "Error: ParseOp: no Op is found!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3d00
movq %rax, %r14
movq %rax, %rdi
callq 0x403c
leaq 0x22e4(%rip), %rcx      # 0x8320
cmpl (%rcx), %eax
jne 0x6071
movl $0x1, 0x18(%rbx)
movl $0x28, %edi
callq 0x2190
movq %rax, %r14
movq %rax, %rdi
callq 0x615c
movq %r14, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6198
leaq 0x22ac(%rip), %rcx      # 0x8324
cmpl (%rcx), %eax
jne 0x6097
movl $0x2, 0x18(%rbx)
callq 0x4fe0
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x14, %eax
jne 0x60eb
movl $0x3, 0x18(%rbx)
movq %r14, %rdi
callq 0x3e36
movl $0x18, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x5b00
movq %r15, 0x10(%rbx)
movq %r15, %rdi
callq 0x5c52
movq %r14, %rdi
callq 0x403c
cmpl $0x15, %eax
jne 0x60fb
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3e36
movq 0x5ee6(%rip), %rbx      # 0xbfd8
leaq 0x2621(%rip), %rsi      # 0x871a
jmp 0x6109
movq 0x5ed6(%rip), %rbx      # 0xbfd8
leaq 0x25dc(%rip), %rsi      # 0x86e5
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1ffa(%rip), %rsi      # 0x811a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
jmp 0x614f
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Inte.cpp
// Function: Inte::ParseInte()
void Inte::ParseInte(){
  Tokenizer *tokensInte;
  tokensInte = Tokenizer::getInstance();
  int tokenType = tokensInte->getTokenType();
  if (tokenType != tokensInte->intNum){
    cout << "Error: ParseInte: not an integer!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
  else {
    name = tokensInte->getToken();
    value = atoi(name.c_str());
    tokensInte->skipToken();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x3d00
movq %rax, %r14
movq %rax, %rdi
callq 0x403c
leaq 0x2161(%rip), %rcx      # 0x8320
cmpl (%rcx), %eax
jne 0x6213
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d54
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2200
movq (%r15), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x61f5
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq (%rbx), %rdi
callq 0x2270
movl %eax, 0x20(%rbx)
movq %r14, %rdi
callq 0x3e36
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5dbe(%rip), %rbx      # 0xbfd8
leaq 0x2519(%rip), %rsi      # 0x873a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1ee2(%rip), %rsi      # 0x811a
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/Loop.cpp
// Function: Loop::PrintLoop(int)
void Loop::PrintLoop(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "while ";
  cond->PrintCond();
  cout << " loop" << endl;
  stmtSeq->PrintStmtSeq(level+1);
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  
  cout << "end;" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
testl %esi, %esi
jle 0x629d
movq 0x5d5a(%rip), %r14      # 0xbfd8
leaq 0x2169(%rip), %r12      # 0x83ee
movl %ebx, %r13d
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r13d
jne 0x6288
movq 0x5d34(%rip), %r14      # 0xbfd8
leaq 0x24b1(%rip), %rsi      # 0x875c
movl $0x6, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r15), %rdi
callq 0x7180
leaq 0x249c(%rip), %rsi      # 0x8763
movl $0x5, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x8(%r15), %rdi
leal 0x1(%rbx), %esi
callq 0x4c50
testl %ebx, %ebx
jle 0x632d
movq 0x5cc6(%rip), %r15      # 0xbfd8
leaq 0x20d5(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %ebx
jne 0x6319
leaq 0x2435(%rip), %rsi      # 0x8769
movl $0x4, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Input.cpp
// Function: Input::PrintInput(int)
void Input::PrintInput(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "read ";
  idList->PrintIdList();
  cout << ";" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x66f6
movl %esi, %r14d
movq 0x58fe(%rip), %r15      # 0xbfd8
leaq 0x1d0d(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r14d
jne 0x66e1
movq 0x58db(%rip), %r14      # 0xbfd8
leaq 0x2106(%rip), %rsi      # 0x880a
movl $0x5, %edx
movq %r14, %rdi
callq 0x21d0
movq (%rbx), %rdi
callq 0x4d88
leaq 0x204c(%rip), %rsi      # 0x876c
movl $0x1, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Input.cpp
// Function: Input::ParseInput()
void Input::ParseInput(){
  Tokenizer *tokensInput;
  tokensInput = Tokenizer::getInstance();
  string tokenTemp = tokensInput->getToken();
  if (tokenTemp.compare("read") == 0){
    //cout << "read is parsed." << endl;
    tokensInput->skipToken();
    idList = new IdList();
    idList->ParseIdList();
    tokenTemp = tokensInput->getToken();
    if (tokenTemp.compare(";") == 0){
      tokensInput->skipToken();
      return;
    }
    else{
      cout << "Syntax Error: ParseInput: ';' not found or not in the right place!" << endl;
      cout << "program stopped." << endl;
      exit(0);
    }
  }
  else{
    cout << "Syntax Error: ParseInput: 'read' not found or not in the right place!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
callq 0x3d00
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3d54
leaq 0x2072(%rip), %rsi      # 0x8810
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
jne 0x684a
movq %rbx, %rdi
callq 0x3e36
movl $0x10, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x4d7c
movq %r15, (%r14)
movq %r15, %rdi
callq 0x4df6
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x3d54
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %r14
movq %r14, %rsi
callq 0x2200
movq (%r14), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x680a
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq 0x1f5b(%rip), %rsi      # 0x876c
leaq -0x38(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x6894
movq %rbx, %rdi
callq 0x3e36
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x683f
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5787(%rip), %rdi      # 0xbfd8
leaq 0x2000(%rip), %rsi      # 0x8858
movl $0x45, %edx
callq 0x21d0
movq 0x576f(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x5763(%rip), %rdi      # 0xbfd8
leaq 0x189e(%rip), %rsi      # 0x811a
movl $0x10, %edx
callq 0x21d0
movq 0x574b(%rip), %rdi      # 0xbfd8
callq 0x20c0
jmp 0x68dc
movq 0x573d(%rip), %rdi      # 0xbfd8
leaq 0x1f73(%rip), %rsi      # 0x8815
movl $0x42, %edx
callq 0x21d0
movq 0x5725(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x5719(%rip), %rdi      # 0xbfd8
leaq 0x1854(%rip), %rsi      # 0x811a
movl $0x10, %edx
callq 0x21d0
movq 0x5701(%rip), %rdi      # 0xbfd8
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
jmp 0x68f7
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x21a0
jmp 0x68fa
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6913
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Output.cpp
// Function: Output::PrintOutput(int)
void Output::PrintOutput(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "write ";
  idList->PrintIdList();
  cout << ";" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x6962
movl %esi, %r14d
movq 0x5692(%rip), %r15      # 0xbfd8
leaq 0x1aa1(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r14d
jne 0x694d
movq 0x566f(%rip), %r14      # 0xbfd8
leaq 0x1f2e(%rip), %rsi      # 0x889e
movl $0x6, %edx
movq %r14, %rdi
callq 0x21d0
movq (%rbx), %rdi
callq 0x4d88
leaq 0x1de0(%rip), %rsi      # 0x876c
movl $0x1, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/smallsimple[P]CoreInterpreter-CSE5341/Output.cpp
// Function: Output::ParseOutput()
void Output::ParseOutput(){
  Tokenizer *tokensOutput;
  tokensOutput = Tokenizer::getInstance();
  string tokenTemp = tokensOutput->getToken();
  if (tokenTemp.compare("write") == 0){
    tokensOutput->skipToken();
    idList = new IdList();
    idList->ParseIdList();
    tokenTemp = tokensOutput->getToken();
    if (tokenTemp.compare(";") == 0){
      tokensOutput->skipToken();
    }
    else{
      cout << "Syntax Error: no \";\" is found or not in the right place" << endl;
      cout << "program stopped!" << endl;
      exit(0);
    }
  }
  else{
    cout << "Error: ParseOutput: no \"wrte\" is found." << endl;
    cout << "program stopped!" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
callq 0x3d00
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3d54
leaq 0x16b2(%rip), %rsi      # 0x80b6
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
jne 0x6ab0
movq %rbx, %rdi
callq 0x3e36
movl $0x10, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x4d7c
movq %r15, (%r14)
movq %r15, %rdi
callq 0x4df6
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x3d54
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %r14
movq %r14, %rsi
callq 0x2200
movq (%r14), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x6a70
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq 0x1cf5(%rip), %rsi      # 0x876c
leaq -0x38(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x6afa
movq %rbx, %rdi
callq 0x3e36
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6aa5
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5521(%rip), %rdi      # 0xbfd8
leaq 0x1e1f(%rip), %rsi      # 0x88dd
movl $0x27, %edx
callq 0x21d0
movq 0x5509(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x54fd(%rip), %rdi      # 0xbfd8
leaq 0x16b4(%rip), %rsi      # 0x8196
movl $0x10, %edx
callq 0x21d0
movq 0x54e5(%rip), %rdi      # 0xbfd8
callq 0x20c0
jmp 0x6b42
movq 0x54d7(%rip), %rdi      # 0xbfd8
leaq 0x1d9d(%rip), %rsi      # 0x88a5
movl $0x37, %edx
callq 0x21d0
movq 0x54bf(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x54b3(%rip), %rdi      # 0xbfd8
leaq 0x166a(%rip), %rsi      # 0x8196
movl $0x10, %edx
callq 0x21d0
movq 0x549b(%rip), %rdi      # 0xbfd8
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
jmp 0x6b5d
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x21a0
jmp 0x6b60
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b79
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
nopl (%rax)