LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::printTokensName()
void Tokenizer::printTokensName(){ 
  int i; 
  for (i = 0; i < this->tokens.size(); i++){
    cout << this->tokens[i].name << " ";
  }
  cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x2ed3
movq %rdi, %rbx
movl $0x10, %r12d
xorl %r13d, %r13d
leaq 0x5b05(%rip), %r15      # 0x898b
movabsq $-0x3333333333333333, %r14 # imm = 0xCCCCCCCCCCCCCCCD
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq 0x9138(%rip), %rdi      # 0xbfd8
callq 0x21d0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
incq %r13
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %r14, %rcx
addq $0x28, %r12
cmpq %r13, %rcx
ja 0x2e90
movq 0x90fe(%rip), %rbx      # 0xbfd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::searchSpec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<SpecMarker> Tokenizer::searchSpec(string str){
  vector<SpecMarker> sMarker;
  int i = 0;
  do{
    for (int j = 18; j >= 0; j--){
      if(this->specSymbols[j].compare(str.substr(i,this->specSymbols[j].size()))==0){
	SpecMarker temp;
	temp.start = i;
	temp.id = j;
	sMarker.push_back(temp);
	i += specSymbols[j].size() - 1;
	break;
      }
    }
    i++;    
  }while (i < str.size());

  return sMarker;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x40(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
xorl %ebx, %ebx
leaq -0x60(%rbp), %r15
movq %rbx, -0x38(%rbp)
movslq %ebx, %r13
movl $0x13, %r14d
leaq 0x9559(%rip), %r12      # 0xc540
movq 0x8(%r12), %rcx
movq %r15, %rdi
movq -0x40(%rbp), %rsi
movq %r13, %rdx
callq 0x21b0
movq %r12, %rdi
movq %r15, %rsi
callq 0x2040
movl %eax, %ebx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x3021
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %ebx, %ebx
je 0x3034
addq $-0x20, %r12
decq %r14
jne 0x2fe7
movq -0x38(%rbp), %rbx
jmp 0x306f
decl %r14d
movq -0x38(%rbp), %rbx
movl %ebx, -0x60(%rbp)
movl %r14d, -0x5c(%rbp)
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x305e
movq -0x60(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x3066
movq %r15, %rdx
callq 0x4158
movl 0x8(%r12), %eax
addl %eax, %ebx
decl %ebx
incl %ebx
movslq %ebx, %rax
movq -0x40(%rbp), %rcx
cmpq %rax, 0x8(%rcx)
ja 0x2fd3
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3097
movq %rax, %r14
jmp 0x30b8
movq %rax, %r14
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x30b8
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21a0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x30d0
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::isRes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Tokenizer::isRes(string str){
  for (int i = 0; i < 11; i++){
    if (str.compare(resWords[i]) == 0){
      return i + 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq $-0xb, %rbx
leaq 0x90ad(%rip), %r15      # 0xc1a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2040
testl %eax, %eax
je 0x310f
addq $0x20, %r15
incq %rbx
jne 0x30f3
xorl %ebx, %ebx
jmp 0x3112
addl $0xc, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::isIntegers(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Tokenizer::isIntegers(string str){
  for (int i = 0; i < str.size(); i++){
    if (!isdigit(str.at(i)))
      return false;
  }
  return true;
}

// Assembly:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x3160
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rcx
movsbl (%rcx), %edx
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x3163
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x3158
movsbl (%rcx,%rdx), %edi
addl $-0x30, %edi
leaq 0x1(%rdx), %rsi
cmpl $0xa, %edi
jb 0x3140
cmpq %rdx, %rax
setbe %al
jmp 0x3165
movb $0x1, %al
retq
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::isIdenti(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Tokenizer::isIdenti(string str){
  int i;
  int judge;

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

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

  if (judge > 1) return false;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x323d
movq (%rsi), %r12
movsbl (%r12), %edi
callq 0x2120
testl %eax, %eax
je 0x322a
movb $0x1, %bl
cmpq $0x1, %r15
je 0x322c
movl $0x1, %r13d
movsbl (%r12,%r13), %r14d
movl %r14d, %edi
callq 0x2120
testl %eax, %eax
setne %al
addl $-0x30, %r14d
cmpl $0xa, %r14d
setb %cl
orb %al, %cl
je 0x322a
incq %r13
cmpq %r13, %r15
jne 0x31aa
cmpq $0x1, %r15
je 0x322c
xorl %r14d, %r14d
movl $0x1, %r13d
movsbl -0x1(%r12,%r13), %ebx
movl %ebx, %edi
callq 0x2120
testl %eax, %eax
je 0x3200
movsbl (%r12,%r13), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x3216
addl $-0x30, %ebx
cmpl $0x9, %ebx
ja 0x3219
movsbl (%r12,%r13), %edi
callq 0x2120
testl %eax, %eax
je 0x3219
incl %r14d
incq %r13
cmpq %r13, %r15
jne 0x31e2
cmpl $0x2, %r14d
setl %bl
jmp 0x322c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x504b(%rip), %rdi      # 0x828f
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::Tokenizer(char*)
Tokenizer::Tokenizer(char* filename){
  Tokenizer();
  ifstream inputF;
  inputF.open(filename);
  int i=0;
  do{
    string sub;
    inputF >> sub;
    this->dealToken(sub);
  } while(!inputF.eof());
  // if no illegal token, add EOF to the end
  Token tok;
  tok.name = "\0"; // use "\0" as a EOF character
  tok.num = 33;
  this->tokens.push_back(tok);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rdi, -0x30(%rbp)
movq %rax, 0x10(%rdi)
leaq -0x90(%rbp), %rdi
movq %rax, 0x10(%rdi)
movaps %xmm0, (%rdi)
movb $0x0, 0x8b1e(%rip)      # 0xc564
callq 0x403e
leaq -0x298(%rbp), %rdi
callq 0x21c0
leaq -0x298(%rbp), %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x20f0
leaq -0x48(%rbp), %r13
leaq -0x68(%rbp), %rbx
leaq -0x298(%rbp), %r14
leaq -0x58(%rbp), %r15
leaq -0x78(%rbp), %r12
movq %r13, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x0, -0x48(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2210
movq %rbx, -0x78(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x40ba
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x3618
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3ad5
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x21a0
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x3aea
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
movq -0x298(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x278(%rbp,%rax)
je 0x3a82
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq $0x0, -0x8(%rbx)
movb $0x0, (%rbx)
leaq 0x480f(%rip), %rcx      # 0x832c
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2250
leaq -0x58(%rbp), %rsi
movl $0x21, (%rsi)
movq -0x30(%rbp), %rdi
callq 0x3fee
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3b51
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq -0x298(%rbp), %rdi
callq 0x2070
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3bbd
movq %rax, %r14
jmp 0x3bc9
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3bbd
movq -0x40(%rbp), %rsi
jmp 0x3bb5
movq %rax, %r14
movq -0x78(%rbp), %rdi
cmpq %rbx, %rdi
je 0x3ba8
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x21a0
jmp 0x3ba8
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x3bbd
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq -0x298(%rbp), %rdi
callq 0x2070
movq -0x30(%rbp), %rdi
callq 0x403e
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x897c(%rip)      # 0xc564
jne 0x3c1b
movq %rdi, %r14
movl $0x18, %edi
callq 0x2190
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3a0a
movq %rbx, 0x895c(%rip)      # 0xc568
movb $0x1, 0x8951(%rip)      # 0xc564
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x83b6(%rip), %rbx      # 0xbfd8
leaq 0x4502(%rip), %rsi      # 0x812b
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x451a(%rip), %rsi      # 0x815a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x88ed(%rip)      # 0xc564
je 0x3c81
movq 0x88e8(%rip), %rax      # 0xc568
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x834a(%rip), %rbx      # 0xbfd8
leaq 0x44d7(%rip), %rsi      # 0x816c
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x44ea(%rip), %rsi      # 0x8196
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::getToken[abi:cxx11]()
string Tokenizer::getToken(){ //returns (info about) current token
  /*
  cout << "curTokenNum=" << curTokenNum << endl;
  cout << "TokenType=" << this->tokens.at(curTokenNum).num << endl;
  cout << "tokenName:  " << this->tokens.at(curTokenNum).name << endl;
  */
  if (this->tokens.at(curTokenNum).num == this->eofNum ){
    cout << "Warning: has reached the end-of-file!" << endl;
  }
  return this->tokens.at(curTokenNum).name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movslq 0x8887(%rip), %rsi      # 0xc560
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
imulq %r12, %rdx
cmpq %rsi, %rdx
jbe 0x3d97
movq %rdi, %rbx
leaq (%rsi,%rsi,4), %rcx
cmpl $0x21, (%rax,%rcx,8)
jne 0x3d66
movq 0x82c6(%rip), %r15      # 0xbfd8
leaq 0x448e(%rip), %rsi      # 0x81a7
movl $0x25, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movslq 0x880c(%rip), %rsi      # 0xc560
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r12, %rdx
cmpq %rsi, %rdx
jbe 0x3d97
leaq (%rsi,%rsi,4), %rcx
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq 0x8(%rax,%rcx,8), %rsi
movq 0x10(%rax,%rcx,8), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x40ba
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4535(%rip), %rdi      # 0x82d3
xorl %eax, %eax
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x87b3(%rip), %rax      # 0xc560
movq 0x8(%rdi), %rcx
subq (%rdi), %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rax, %rdx
jbe 0x3dd4
incl %eax
movl %eax, 0x878d(%rip)      # 0xc560
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x81f7(%rip), %rbx      # 0xbfd8
leaq 0x43e5(%rip), %rsi      # 0x81cd
movl $0x2c, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::intVal()
int Tokenizer::intVal(){
  if (this->tokens.at(curTokenNum).num == 31){
    string intTemp = this->tokens.at(curTokenNum).name;
    return atoi(intTemp.c_str());
  }
  else{
    cout << "Error: current token is not an integer" << endl;
    cout << "program stopped!" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movslq 0x872a(%rip), %rsi      # 0xc560
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x3eb4
leaq (%rsi,%rsi,4), %rcx
cmpl $0x1f, (%rax,%rcx,8)
jne 0x3ec2
leaq (%rax,%rcx,8), %rax
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x40ba
movq (%rbx), %rbx
movq %rbx, %rdi
callq 0x2260
movl %eax, %r14d
cmpq %r15, %rbx
je 0x3ea6
movq -0x28(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x21a0
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4418(%rip), %rdi      # 0x82d3
xorl %eax, %eax
callq 0x2230
movq 0x810f(%rip), %rbx      # 0xbfd8
leaq 0x432a(%rip), %rsi      # 0x81fa
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x42af(%rip), %rsi      # 0x8196
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Tokenizer.cpp
// Function: Tokenizer::idName[abi:cxx11]()
string Tokenizer::idName(){
  if(this->tokens.at(curTokenNum).num == 32){
    return this->tokens.at(curTokenNum).name;
  }
  else{
    cout << "Error: current token is not an identifier" << endl;
    cout << "program stopped!" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movslq 0x8652(%rip), %rsi      # 0xc560
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rdx
cmpq %rsi, %rdx
jbe 0x3f61
leaq (%rsi,%rsi,4), %rax
cmpl $0x20, (%rcx,%rax,8)
jne 0x3f6f
movq %rdi, %rbx
leaq (%rcx,%rax,8), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
callq 0x40ba
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x436b(%rip), %rdi      # 0x82d3
xorl %eax, %eax
callq 0x2230
movq 0x8062(%rip), %rbx      # 0xbfd8
leaq 0x42a4(%rip), %rsi      # 0x8221
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x4202(%rip), %rsi      # 0x8196
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Prog.cpp
// Function: Prog::PrintProg()
void Prog::PrintProg(){
  int level = 0;
  cout << "program" << endl;
  ds->PrintDeclSeq(level+1);
  cout << "begin" << endl;
  ss->PrintStmtSeq(level+1);
  cout << "end" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x7ac3(%rip), %rbx      # 0xbfd8
leaq 0x3b7e(%rip), %rsi      # 0x809a
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%r14), %rdi
movl $0x1, %esi
callq 0x47e8
leaq 0x3b3e(%rip), %rsi      # 0x80a2
movl $0x5, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x8(%r14), %rdi
movl $0x1, %esi
callq 0x4b90
leaq 0x3afb(%rip), %rsi      # 0x80a8
movl $0x3, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c70
movq %rax, %rbx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x3cc4
leaq 0x3a62(%rip), %rsi      # 0x809a
movq %r12, %rdi
callq 0x2090
movl %eax, %r15d
movq (%r12), %rdi
leaq -0x38(%rbp), %r13
cmpq %r13, %rdi
je 0x465c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %r15d, %r15d
jne 0x4746
movq %rbx, %rdi
callq 0x3da6
movl $0x10, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x47dc
movq %r15, (%r14)
movq %r15, %rdi
callq 0x482e
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3cc4
leaq 0x3a03(%rip), %rsi      # 0x80a2
movq %r12, %rdi
callq 0x2090
movl %eax, %r15d
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x46bf
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %r15d, %r15d
jne 0x476d
movq %rbx, %rdi
callq 0x3da6
movl $0x18, %edi
callq 0x2190
movq %rax, %r15
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x4b80
movq %r15, 0x8(%r14)
movq %r15, %rdi
callq 0x4bd6
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3cc4
leaq 0x399d(%rip), %rsi      # 0x80a8
movq %r15, %rdi
callq 0x2090
movl %eax, %r14d
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x472a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %r14d, %r14d
jne 0x477d
movq %rbx, %rdi
callq 0x3da6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x788b(%rip), %rbx      # 0xbfd8
leaq 0x3bda(%rip), %rsi      # 0x832e
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x3bf3(%rip), %rsi      # 0x835e
jmp 0x47a2
movq 0x7864(%rip), %rbx      # 0xbfd8
leaq 0x3bf5(%rip), %rsi      # 0x8370
jmp 0x478b
movq 0x7854(%rip), %rbx      # 0xbfd8
leaq 0x3c16(%rip), %rsi      # 0x83a1
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x3978(%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 0x47cb
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c70
movq %rax, %r14
movl $0x8, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x4990
movq %r15, (%rbx)
movq %r15, %rdi
callq 0x4a4a
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x3cc4
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %r14
movq %r14, %rsi
callq 0x2200
movq (%r14), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x48ae
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq 0x37f7(%rip), %rsi      # 0x80ac
leaq -0x38(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x4925
leaq 0x37d9(%rip), %rsi      # 0x80a2
leaq -0x38(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x4941
movq 0x76fb(%rip), %rdi      # 0xbfd8
leaq 0x3aec(%rip), %rsi      # 0x83d0
movl $0x1d, %edx
callq 0x21d0
movq 0x76e3(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x76d7(%rip), %rdi      # 0xbfd8
leaq 0x388e(%rip), %rsi      # 0x8196
movl $0x10, %edx
callq 0x21d0
movq 0x76bf(%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 0x482e
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4956
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4970
movq %rax, %rbx
movl $0x8, %esi
movq %r15, %rdi
jmp 0x4983
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4988
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x49d6
movl %esi, %r14d
movq 0x761e(%rip), %r15      # 0xbfd8
leaq 0x3a2d(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r14d
jne 0x49c1
movq 0x75fb(%rip), %r14      # 0xbfd8
leaq 0x3a0c(%rip), %rsi      # 0x83f0
movl $0x4, %edx
movq %r14, %rdi
callq 0x21d0
movq (%rbx), %rdi
callq 0x4cc8
leaq 0x3d6a(%rip), %rsi      # 0x876a
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_O3/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 0x3c70
movq %rax, %rbx
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x3cc4
leaq 0x3632(%rip), %rsi      # 0x80ac
movq %r12, %rdi
callq 0x2090
movl %eax, %r15d
movq (%r12), %rdi
leaq -0x30(%rbp), %r12
cmpq %r12, %rdi
je 0x4a9e
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %r15d, %r15d
jne 0x4b1a
movq %rbx, %rdi
callq 0x3da6
movl $0x10, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x4cbc
movq %r15, (%r14)
movq %r15, %rdi
callq 0x4d4c
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3cc4
leaq 0x3c89(%rip), %rsi      # 0x876a
movq %r15, %rdi
callq 0x2090
movl %eax, %r14d
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x4b00
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21a0
testl %r14d, %r14d
jne 0x4b2a
movq %rbx, %rdi
callq 0x3da6
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x74b7(%rip), %rbx      # 0xbfd8
leaq 0x38cd(%rip), %rsi      # 0x83f5
jmp 0x4b38
movq 0x74a7(%rip), %rbx      # 0xbfd8
leaq 0x38d7(%rip), %rsi      # 0x840f
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x35cb(%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 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5468
movq %r14, (%rbx)
movq %r14, %rdi
callq 0x55a4
callq 0x3c70
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3cc4
leaq 0x3485(%rip), %rsi      # 0x80a8
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x4c67
leaq 0x37fa(%rip), %rsi      # 0x8430
leaq -0x30(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x4c67
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 0x4bd6
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c80
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 0x4cb2
movq -0x20(%rbp), %rsi
incq %rsi
jmp 0x4cad
movq %rax, %rbx
movl $0x30, %esi
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x5126
cmpq $0x0, 0x8(%rbx)
je 0x4d20
addq $0x8, %rbx
movq 0x72e8(%rip), %r14      # 0xbfd8
leaq 0x373e(%rip), %r15      # 0x8435
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d0
movq (%rbx), %r12
movq (%r12), %rdi
callq 0x5126
leaq 0x8(%r12), %rbx
cmpq $0x0, 0x8(%r12)
jne 0x4cf7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c70
movq %rax, %r14
callq 0x4f38
movq %rax, (%rbx)
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cc4
leaq 0x36b6(%rip), %rsi      # 0x8438
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
je 0x4e2d
leaq 0x39d1(%rip), %rsi      # 0x876a
leaq -0x38(%rbp), %rdi
callq 0x2090
testl %eax, %eax
je 0x4e51
movq 0x7227(%rip), %rdi      # 0xbfd8
leaq 0x3682(%rip), %rsi      # 0x843a
movl $0xb, %edx
callq 0x21d0
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x7207(%rip), %rdi      # 0xbfd8
callq 0x21d0
movq %rax, %rdi
callq 0x20c0
movq 0x71f3(%rip), %rdi      # 0xbfd8
leaq 0x365a(%rip), %rsi      # 0x8446
movl $0x1a, %edx
callq 0x21d0
movq 0x71db(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x71cf(%rip), %rdi      # 0xbfd8
leaq 0x330a(%rip), %rsi      # 0x811a
movl $0x10, %edx
callq 0x21d0
movq 0x71b7(%rip), %rdi      # 0xbfd8
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
movq %r14, %rdi
callq 0x3da6
movl $0x10, %edi
callq 0x2190
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x4d4c
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e6a
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 0x4e91
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c70
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x3cc4
movq %rbx, %rdi
callq 0x3fac
leaq 0x33b8(%rip), %rcx      # 0x8324
cmpl (%rcx), %eax
jne 0x5050
cmpl $0x0, 0x76b5(%rip)      # 0xc630
leaq 0x760e(%rip), %r15      # 0xc590
jle 0x4fb1
xorl %r13d, %r13d
leaq -0x48(%rbp), %r14
movq %r15, %r12
movq (%r12), %rsi
movq %r14, %rdi
callq 0x2040
testl %eax, %eax
je 0x5019
incq %r13
movslq 0x7688(%rip), %rax      # 0xc630
addq $0x8, %r12
cmpq %rax, %r13
jl 0x4f8e
movl $0x28, %edi
callq 0x2190
movq %rax, %r14
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x40ba
leaq -0x68(%rbp), %rsi
movq %r14, %rdi
callq 0x4ee4
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x4ffc
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21a0
movslq 0x762d(%rip), %rax      # 0xc630
movq %r14, (%r15,%rax,8)
incl %eax
movl %eax, 0x7621(%rip)      # 0xc630
movq %rbx, %rdi
callq 0x3da6
jmp 0x5025
movq %rbx, %rdi
callq 0x3da6
movq (%r12), %r14
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x503e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6f81(%rip), %rdi      # 0xbfd8
leaq 0x3403(%rip), %rsi      # 0x8461
movl $0x7, %edx
callq 0x21d0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x6f61(%rip), %rdi      # 0xbfd8
callq 0x21d0
movq %rax, %rbx
leaq 0x33e3(%rip), %rsi      # 0x8469
movl $0x1b, %edx
movq %rax, %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x20c0
movq 0x6f36(%rip), %rdi      # 0xbfd8
leaq 0x3071(%rip), %rsi      # 0x811a
movl $0x10, %edx
callq 0x21d0
movq 0x6f1e(%rip), %rdi      # 0xbfd8
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
jmp 0x50f8
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x50e5
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21a0
jmp 0x50e5
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x21a0
jmp 0x50fb
jmp 0x50f8
jmp 0x50f8
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5114
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5156
movl 0x20(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x6e7b(%rip), %r14      # 0xbfd8
leaq 0x3321(%rip), %rsi      # 0x8485
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2160
leaq 0x331d(%rip), %rsi      # 0x849b
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2f85(%rip), %rsi      # 0x811a
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5495
movq %rax, %rdi
jmp 0x5724
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x54a6
movq %rax, %rdi
jmp 0x6afc
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x54b7
movq %rax, %rdi
jmp 0x61c0
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x54c8
movq %rax, %rdi
jmp 0x661e
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
jne 0x688a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x6af6(%rip), %rbx      # 0xbfd8
leaq 0x3067(%rip), %rsi      # 0x8550
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2c1a(%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_O3/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 0x5529
movq %rax, %rdi
jmp 0x57cc
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x553a
movq %rax, %rdi
jmp 0x6c9a
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x554b
movq %rax, %rdi
jmp 0x62d6
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x555c
movq %rax, %rdi
jmp 0x66bc
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
jne 0x6928
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x6a62(%rip), %rbx      # 0xbfd8
leaq 0x3003(%rip), %rsi      # 0x8580
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2b86(%rip), %rsi      # 0x811a
movq %rbx, %rdi
callq 0x2180
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c70
movq %rax, %rdi
callq 0x3fac
leaq 0x2d62(%rip), %rcx      # 0x8324
cmpl (%rcx), %eax
jne 0x55eb
movl $0x10, %edi
callq 0x2190
movq %rax, %r14
movq %rax, %rdi
callq 0x5718
movq %r14, 0x8(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x57ee
addl $-0x5, %eax
cmpl $0x6, %eax
ja 0x56a4
leaq 0x2f36(%rip), %rcx      # 0x8534
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 0x6ae4
movq %r14, 0x10(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6cd0
movl $0x10, %edi
callq 0x2190
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x660c
movq %r14, 0x20(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x66d0
movl $0x8, %edi
callq 0x2190
movq %rax, %r14
movq %rax, %rdi
callq 0x687c
movq %r14, 0x28(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6936
movl $0x18, %edi
callq 0x2190
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x61b0
movq %r14, 0x18(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6300
movq 0x692d(%rip), %rbx      # 0xbfd8
leaq 0x2ef8(%rip), %rsi      # 0x85aa
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2eed(%rip), %rsi      # 0x85b6
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
movq %rax, %rbx
movl $0x18, %esi
jmp 0x5708
movq %rax, %rbx
movl $0x20, %esi
jmp 0x5708
movq %rax, %rbx
movl $0x8, %esi
jmp 0x5708
jmp 0x5700
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x575c
movl %esi, %r14d
movq 0x6898(%rip), %r15      # 0xbfd8
leaq 0x2ca7(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r14d
jne 0x5747
movq (%rbx), %rdi
callq 0x5126
movq 0x686d(%rip), %r14      # 0xbfd8
leaq 0x2dbd(%rip), %rsi      # 0x852f
movl $0x3, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rdi
callq 0x5a48
leaq 0x2fdb(%rip), %rsi      # 0x876a
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_O3/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 0x2bf8(%rip), %r15      # 0x8655
leaq 0x2bed(%rip), %r12      # 0x8651
movq 0x656d(%rip), %r14      # 0xbfd8
movq (%rbx), %rdi
callq 0x5ccc
movl 0x10(%rbx), %eax
cmpl $0x2, %eax
je 0x5a85
movq %r15, %rsi
cmpl $0x3, %eax
je 0x5a88
jmp 0x5a9b
movq %r12, %rsi
movl $0x3, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rbx
jmp 0x5a6b
cmpl $0x1, %eax
jne 0x5aa9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x6528(%rip), %rbx      # 0xbfd8
leaq 0x2ba2(%rip), %rsi      # 0x8659
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2ae8(%rip), %rsi      # 0x85b6
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
xorl %r15d, %r15d
movl 0x10(%rbx), %eax
cmpl $0x2, %eax
jne 0x5b0f
movq (%rbx), %rdi
callq 0x5d2e
movq 0x8(%rbx), %rbx
addl %eax, %r15d
jmp 0x5af6
cmpl $0x3, %eax
je 0x5b29
cmpl $0x1, %eax
jne 0x5b51
movq (%rbx), %rdi
callq 0x5d2e
movl %eax, %r14d
addl %r15d, %r14d
jmp 0x5b43
movq (%rbx), %rdi
callq 0x5d2e
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5ae6
addl %r15d, %r14d
subl %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x6480(%rip), %rbx      # 0xbfd8
leaq 0x2b1a(%rip), %rsi      # 0x8679
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2a40(%rip), %rsi      # 0x85b6
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c70
movq %rax, %r14
movl $0x10, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x5cc0
movq %r15, (%rbx)
movq %r15, %rdi
callq 0x5d76
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cc4
leaq 0x2abc(%rip), %rsi      # 0x8698
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
je 0x5c35
leaq 0x2aab(%rip), %rsi      # 0x869a
leaq -0x38(%rbp), %rdi
callq 0x2090
movl $0x1, %r15d
testl %eax, %eax
jne 0x5c66
movq %r14, %rdi
callq 0x3da6
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 0x5b8e
jmp 0x5c66
movq %r14, %rdi
callq 0x3da6
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 0x5b8e
movl %r15d, 0x10(%rbx)
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c83
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 0x5cb2
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5cb7
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x5e5c
cmpq $0x0, 0x8(%rbx)
je 0x5d24
addq $0x8, %rbx
movq 0x62e4(%rip), %r14      # 0xbfd8
leaq 0x29a1(%rip), %r15      # 0x869c
movl $0x3, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d0
movq (%rbx), %r12
movq (%r12), %rdi
callq 0x5e5c
leaq 0x8(%r12), %rbx
cmpq $0x0, 0x8(%r12)
jne 0x5cfb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x5d5e
movl $0x1, %r14d
movq (%rbx), %rdi
callq 0x5f0a
movq 0x8(%rbx), %rbx
imull %eax, %r14d
cmpq $0x0, 0x8(%rbx)
jne 0x5d45
jmp 0x5d64
movl $0x1, %r14d
movq (%rbx), %rdi
callq 0x5f0a
imull %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c70
movq %rax, %r14
movl $0x20, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x5e4c
movq %r15, (%rbx)
movq %r15, %rdi
callq 0x5f78
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cc4
leaq 0x28dc(%rip), %rsi      # 0x86a0
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
jne 0x5df4
movq %r14, %rdi
callq 0x3da6
movl $0x10, %edi
callq 0x2190
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x5d76
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e0d
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 0x5e3c
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e41
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22a0
nopl (%rax)