LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x7aa0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7527
movq 0x9aca(%rip), %rdi      # 0x10fd8
leaq 0x4f03(%rip), %rsi      # 0xc418
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x74e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x48d0
movq %rax, -0x10(%rbp)
callq 0x7820
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4940
leaq -0x30(%rbp), %rdi
leaq 0x4b15(%rip), %rsi      # 0xc0c9
callq 0x2090
cmpl $0x0, %eax
jne 0x7637
movq -0x10(%rbp), %rdi
callq 0x49c0
jmp 0x75c9
movl $0x10, %edi
callq 0x21e0
movq %rax, -0x50(%rbp)
jmp 0x75d9
movq -0x50(%rbp), %rdi
callq 0x74c0
jmp 0x75e4
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
callq 0x7570
jmp 0x75fb
movl $0x1, -0x40(%rbp)
jmp 0x76f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7702
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x21f0
jmp 0x7702
leaq -0x30(%rbp), %rdi
leaq 0x50e6(%rip), %rsi      # 0xc728
callq 0x2090
cmpl $0x0, %eax
jne 0x7658
movl $0x1, -0x40(%rbp)
jmp 0x76f3
movq 0x9979(%rip), %rdi      # 0x10fd8
leaq 0x4db5(%rip), %rsi      # 0xc41b
callq 0x21d0
movq %rax, -0x58(%rbp)
jmp 0x7671
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x21b0
movq %rax, -0x60(%rbp)
jmp 0x7684
movq -0x60(%rbp), %rdi
movq 0x9939(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x7696
movq 0x993b(%rip), %rdi      # 0x10fd8
leaq 0x4d83(%rip), %rsi      # 0xc427
callq 0x21d0
movq %rax, -0x68(%rbp)
jmp 0x76af
movq -0x68(%rbp), %rdi
movq 0x990e(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x76c1
movq 0x9910(%rip), %rdi      # 0x10fd8
leaq 0x4a77(%rip), %rsi      # 0xc146
callq 0x21d0
movq %rax, -0x70(%rbp)
jmp 0x76da
movq -0x70(%rbp), %rdi
movq 0x98e3(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x76ec
xorl %edi, %edi
callq 0x2280
leaq -0x30(%rbp), %rdi
callq 0x2110
addq $0x70, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x2110
movq -0x38(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x22d0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2040
jmp 0x77e7
movq -0x38(%rbp), %rax
movb $0x0, 0x24(%rax)
movb $0x0, 0x25(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
movq -0x18(%rbp), %rdi
callq 0x2370
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x25(%rax)
je 0x7af7
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
movq 0x94da(%rip), %rdi      # 0x10fd8
leaq 0x4961(%rip), %rsi      # 0xc466
callq 0x21d0
movq -0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x21b0
movq %rax, %rdi
leaq 0x495c(%rip), %rsi      # 0xc47c
callq 0x21d0
movq %rax, %rdi
movq 0x9499(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x949d(%rip), %rdi      # 0x10fd8
leaq 0x4604(%rip), %rsi      # 0xc146
callq 0x21d0
movq %rax, %rdi
movq 0x9477(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
nopl (%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Stmt.cpp
// Function: Stmt::Stmt(std::basic_ifstream<char, std::char_traits<char>>*)
Stmt::Stmt(ifstream *inputfile){
  assign = NULL;
  ifc = NULL;
  loop = NULL;
  input = NULL;
  output = NULL;
  infile = inputfile;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x7f93
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x83f0
jmp 0x8060
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7fb3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x9d40
jmp 0x805e
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x7fd3
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x9280
jmp 0x805c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x7ff0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x97a0
jmp 0x805a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x800d
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x9a60
jmp 0x8058
movq 0x8fc4(%rip), %rdi      # 0x10fd8
leaq 0x44f9(%rip), %rsi      # 0xc514
callq 0x21d0
movq %rax, %rdi
movq 0x8f9e(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x8fa2(%rip), %rdi      # 0x10fd8
leaq 0x4109(%rip), %rsi      # 0xc146
callq 0x21d0
movq %rax, %rdi
movq 0x8f7c(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
jmp 0x805a
jmp 0x805c
jmp 0x805e
jmp 0x8060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x809d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8490
jmp 0x814c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x80ba
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9ed0
jmp 0x814a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x80d4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x9370
jmp 0x8148
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x80ee
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x9830
jmp 0x8146
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x8108
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x9af0
jmp 0x8144
movq 0x8ec9(%rip), %rdi      # 0x10fd8
leaq 0x442e(%rip), %rsi      # 0xc544
callq 0x21d0
movq %rax, %rdi
movq 0x8ea3(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x8ea7(%rip), %rdi      # 0x10fd8
leaq 0x400e(%rip), %rsi      # 0xc146
callq 0x21d0
xorl %edi, %edi
callq 0x2280
jmp 0x8146
jmp 0x8148
jmp 0x814a
jmp 0x814c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8434
movq 0x8bbb(%rip), %rdi      # 0x10fd8
leaq 0x3fb2(%rip), %rsi      # 0xc3d6
callq 0x21d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x840e
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x7aa0
movq 0x8b91(%rip), %rdi      # 0x10fd8
leaq 0x40c2(%rip), %rsi      # 0xc510
callq 0x21d0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x87a0
movq 0x8b71(%rip), %rdi      # 0x10fd8
leaq 0x42ba(%rip), %rsi      # 0xc728
callq 0x21d0
movq %rax, %rdi
movq 0x8b4b(%rip), %rsi      # 0x10fc8
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x8b60
movq -0x10(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x87eb
movq 0x880b(%rip), %rdi      # 0x10fd8
leaq 0x3e41(%rip), %rsi      # 0xc615
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x87a0
jmp 0x886e
movq -0x10(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x8817
movq 0x87dc(%rip), %rdi      # 0x10fd8
leaq 0x3e16(%rip), %rsi      # 0xc619
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x87a0
jmp 0x886e
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x8823
jmp 0x886e
movq 0x87ae(%rip), %rdi      # 0x10fd8
leaq 0x3dec(%rip), %rsi      # 0xc61d
callq 0x21d0
movq %rax, %rdi
movq 0x8788(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x878c(%rip), %rdi      # 0x10fd8
leaq 0x3d27(%rip), %rsi      # 0xc57a
callq 0x21d0
movq %rax, %rdi
movq 0x8766(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, 0x10(%rax)
jne 0x88ae
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x8bb0
movl %eax, -0x4(%rbp)
jmp 0x8961
movq -0x18(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x88e2
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x8bb0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq 0x8(%rax), %rdi
callq 0x8880
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8961
movq -0x18(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x8916
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x8bb0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x20(%rbp)
movq 0x8(%rax), %rdi
callq 0x8880
movl %eax, %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8961
movq 0x86bb(%rip), %rdi      # 0x10fd8
leaq 0x3d19(%rip), %rsi      # 0xc63d
callq 0x21d0
movq %rax, %rdi
movq 0x8695(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x8699(%rip), %rdi      # 0x10fd8
leaq 0x3c34(%rip), %rsi      # 0xc57a
callq 0x21d0
movq %rax, %rdi
movq 0x8673(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x48d0
movq %rax, -0x10(%rbp)
movl $0x10, %edi
callq 0x21e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x8b40
jmp 0x89a8
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x8c10
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x4940
leaq -0x40(%rbp), %rdi
leaq 0x3702(%rip), %rsi      # 0xc0d5
callq 0x2090
cmpl $0x0, %eax
jne 0x8a84
movq -0x10(%rbp), %rdi
callq 0x49c0
jmp 0x89ec
movl $0x18, %edi
callq 0x21e0
movq %rax, -0x60(%rbp)
jmp 0x89fc
movq -0x60(%rbp), %rdi
callq 0x8770
jmp 0x8a07
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
callq 0x8970
jmp 0x8a1e
movq -0x58(%rbp), %rax
movl $0x2, 0x10(%rax)
movl $0x1, -0x44(%rbp)
jmp 0x8b18
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x21f0
jmp 0x8b30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x8b27
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x21f0
jmp 0x8b27
leaq -0x40(%rbp), %rdi
leaq 0x3648(%rip), %rsi      # 0xc0d7
callq 0x2090
cmpl $0x0, %eax
jne 0x8b06
movq -0x10(%rbp), %rdi
callq 0x49c0
jmp 0x8aa4
movl $0x18, %edi
callq 0x21e0
movq %rax, -0x68(%rbp)
jmp 0x8ab4
movq -0x68(%rbp), %rdi
callq 0x8770
jmp 0x8abf
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
callq 0x8970
jmp 0x8ad6
movq -0x58(%rbp), %rax
movl $0x3, 0x10(%rax)
movl $0x1, -0x44(%rbp)
jmp 0x8b18
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x21f0
jmp 0x8b27
movq -0x58(%rbp), %rax
movl $0x1, 0x10(%rax)
movl $0x1, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2110
addq $0x70, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x2110
movq -0x18(%rbp), %rdi
callq 0x2370
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x8d70
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8ba7
movq 0x844a(%rip), %rdi      # 0x10fd8
leaq 0x3ac7(%rip), %rsi      # 0xc65c
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8b60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x8bdc
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x8e50
movl %eax, -0x4(%rbp)
jmp 0x8c05
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x8e50
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq 0x8(%rax), %rdi
callq 0x8bb0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x48d0
movq %rax, -0x10(%rbp)
movl $0x20, %edi
callq 0x21e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x8d40
jmp 0x8c48
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x8f10
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x4940
leaq -0x40(%rbp), %rdi
leaq 0x3466(%rip), %rsi      # 0xc0d9
callq 0x2090
cmpl $0x0, %eax
je 0x8ca8
movl $0x1, -0x44(%rbp)
jmp 0x8d18
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x21f0
jmp 0x8d30
movq -0x10(%rbp), %rdi
callq 0x49c0
jmp 0x8cb3
movl $0x10, %edi
callq 0x21e0
movq %rax, -0x60(%rbp)
jmp 0x8cc3
movq -0x60(%rbp), %rdi
callq 0x8b40
jmp 0x8cce
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
callq 0x8c10
jmp 0x8ce5
jmp 0x8d11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x8d27
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x21f0
jmp 0x8d27
movl $0x0, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2110
addq $0x60, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x2110
movq -0x18(%rbp), %rdi
callq 0x2370
nopl (%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Op.cpp
// Function: Op::Op()
Op::Op(){
  inte = NULL;
  id = NULL;
  expr = NULL;
  alterId = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movl $0x0, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, 0x18(%rax)
jne 0x8d9b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x9130
jmp 0x8e41
movq -0x10(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jne 0x8db7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7aa0
jmp 0x8e41
movq -0x10(%rbp), %rax
cmpl $0x3, 0x18(%rax)
jne 0x8df6
movq 0x8210(%rip), %rdi      # 0x10fd8
leaq 0x3891(%rip), %rsi      # 0xc660
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x87a0
movq 0x81f0(%rip), %rdi      # 0x10fd8
leaq 0x3874(%rip), %rsi      # 0xc663
callq 0x21d0
jmp 0x8e41
movq 0x81db(%rip), %rdi      # 0x10fd8
leaq 0x3862(%rip), %rsi      # 0xc666
callq 0x21d0
movq %rax, %rdi
movq 0x81b5(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x81b9(%rip), %rdi      # 0x10fd8
leaq 0x3754(%rip), %rsi      # 0xc57a
callq 0x21d0
movq %rax, %rdi
movq 0x8193(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, 0x18(%rax)
jne 0x8e7e
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x9160
movl %eax, -0x4(%rbp)
jmp 0x8f01
movq -0x18(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jne 0x8e9a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7ad0
movl %eax, -0x4(%rbp)
jmp 0x8f01
movq -0x18(%rbp), %rax
cmpl $0x3, 0x18(%rax)
jne 0x8eb6
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8880
movl %eax, -0x4(%rbp)
jmp 0x8f01
movq 0x811b(%rip), %rdi      # 0x10fd8
leaq 0x37c0(%rip), %rsi      # 0xc684
callq 0x21d0
movq %rax, %rdi
movq 0x80f5(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x80f9(%rip), %rdi      # 0x10fd8
leaq 0x3694(%rip), %rsi      # 0xc57a
callq 0x21d0
movq %rax, %rdi
movq 0x80d3(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x48d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ba0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x3155(%rip), %rcx      # 0xc308
cmpl (%rcx), %eax
je 0x9202
movq 0x7e1a(%rip), %rdi      # 0x10fd8
leaq 0x3531(%rip), %rsi      # 0xc6f6
callq 0x21d0
movq %rax, %rdi
movq 0x7df4(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x7df8(%rip), %rdi      # 0x10fd8
leaq 0x2f5f(%rip), %rsi      # 0xc146
callq 0x21d0
movq %rax, %rdi
movq 0x7dd2(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4940
movq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2290
leaq -0x38(%rbp), %rdi
callq 0x2110
movq -0x40(%rbp), %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x2320
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x49c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x92c4
movq 0x7d2b(%rip), %rdi      # 0x10fd8
leaq 0x3122(%rip), %rsi      # 0xc3d6
callq 0x21d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x929e
movq 0x7d0d(%rip), %rdi      # 0x10fd8
leaq 0x3446(%rip), %rsi      # 0xc718
callq 0x21d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xa490
movq 0x7cee(%rip), %rdi      # 0x10fd8
leaq 0x342e(%rip), %rsi      # 0xc71f
callq 0x21d0
movq %rax, %rdi
movq 0x7cc8(%rip), %rsi      # 0x10fc8
callq 0x2210
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x72e0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9345
movq 0x7caa(%rip), %rdi      # 0x10fd8
leaq 0x30a1(%rip), %rsi      # 0xc3d6
callq 0x21d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x931f
movq 0x7c8c(%rip), %rdi      # 0x10fd8
leaq 0x33d2(%rip), %rsi      # 0xc725
callq 0x21d0
movq %rax, %rdi
movq 0x7c66(%rip), %rsi      # 0x10fc8
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x97e4
movq 0x780b(%rip), %rdi      # 0x10fd8
leaq 0x2c02(%rip), %rsi      # 0xc3d6
callq 0x21d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x97be
movq 0x77ed(%rip), %rdi      # 0x10fd8
leaq 0x2fd4(%rip), %rsi      # 0xc7c6
callq 0x21d0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x74e0
movq 0x77ce(%rip), %rdi      # 0x10fd8
leaq 0x2f17(%rip), %rsi      # 0xc728
callq 0x21d0
movq %rax, %rdi
movq 0x77a8(%rip), %rsi      # 0x10fc8
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x48d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4940
leaq -0x30(%rbp), %rdi
leaq 0x2826(%rip), %rsi      # 0xc0be
callq 0x2090
cmpl $0x0, %eax
jne 0x99c5
movq -0x10(%rbp), %rdi
callq 0x49c0
jmp 0x98b1
movl $0x10, %edi
callq 0x21e0
movq %rax, -0x70(%rbp)
jmp 0x98c1
movq -0x70(%rbp), %rdi
callq 0x74c0
jmp 0x98cc
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x7570
jmp 0x98e1
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x4940
jmp 0x98f0
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2290
leaq -0x60(%rbp), %rdi
callq 0x2110
leaq -0x30(%rbp), %rdi
leaq 0x2e17(%rip), %rsi      # 0xc728
callq 0x2090
cmpl $0x0, %eax
jne 0x9968
movq -0x10(%rbp), %rdi
callq 0x49c0
jmp 0x9926
leaq -0x30(%rbp), %rdi
callq 0x2110
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x9a2e
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x21f0
jmp 0x9a2e
movq 0x7669(%rip), %rdi      # 0x10fd8
leaq 0x2e56(%rip), %rsi      # 0xc7cc
callq 0x21d0
movq %rax, -0x78(%rbp)
jmp 0x9981
movq -0x78(%rbp), %rdi
movq 0x763c(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x9993
movq 0x763e(%rip), %rdi      # 0x10fd8
leaq 0x27a5(%rip), %rsi      # 0xc146
callq 0x21d0
movq %rax, -0x80(%rbp)
jmp 0x99ac
movq -0x80(%rbp), %rdi
movq 0x7611(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x99be
xorl %edi, %edi
callq 0x2280
movq 0x760c(%rip), %rdi      # 0x10fd8
leaq 0x2e3c(%rip), %rsi      # 0xc80f
callq 0x21d0
movq %rax, -0x88(%rbp)
jmp 0x99e1
movq -0x88(%rbp), %rdi
movq 0x75d9(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x99f6
movq 0x75db(%rip), %rdi      # 0x10fd8
leaq 0x2742(%rip), %rsi      # 0xc146
callq 0x21d0
movq %rax, -0x90(%rbp)
jmp 0x9a12
movq -0x90(%rbp), %rdi
movq 0x75a8(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x9a27
xorl %edi, %edi
callq 0x2280
leaq -0x30(%rbp), %rdi
callq 0x2110
movq -0x38(%rbp), %rdi
callq 0x2370
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9aa4
movq 0x754b(%rip), %rdi      # 0x10fd8
leaq 0x2942(%rip), %rsi      # 0xc3d6
callq 0x21d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9a7e
movq 0x752d(%rip), %rdi      # 0x10fd8
leaq 0x2da3(%rip), %rsi      # 0xc855
callq 0x21d0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x74e0
movq 0x750e(%rip), %rdi      # 0x10fd8
leaq 0x2c57(%rip), %rsi      # 0xc728
callq 0x21d0
movq %rax, %rdi
movq 0x74e8(%rip), %rsi      # 0x10fc8
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x48d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4940
leaq -0x30(%rbp), %rdi
leaq 0x257b(%rip), %rsi      # 0xc0c3
callq 0x2090
cmpl $0x0, %eax
jne 0x9c6a
movq -0x10(%rbp), %rdi
callq 0x49c0
jmp 0x9b61
movl $0x10, %edi
callq 0x21e0
movq %rax, -0x70(%rbp)
jmp 0x9b71
movq -0x70(%rbp), %rdi
callq 0x74c0
jmp 0x9b7c
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x7570
jmp 0x9b91
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x4940
jmp 0x9ba0
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2290
leaq -0x60(%rbp), %rdi
callq 0x2110
leaq -0x30(%rbp), %rdi
leaq 0x2b67(%rip), %rsi      # 0xc728
callq 0x2090
cmpl $0x0, %eax
jne 0x9c0b
movq -0x10(%rbp), %rdi
callq 0x49c0
jmp 0x9bd6
jmp 0x9c68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x9ce5
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x21f0
jmp 0x9ce5
movq 0x73c6(%rip), %rdi      # 0x10fd8
leaq 0x2c43(%rip), %rsi      # 0xc85c
callq 0x21d0
movq %rax, -0x78(%rbp)
jmp 0x9c24
movq -0x78(%rbp), %rdi
movq 0x7399(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x9c36
movq 0x739b(%rip), %rdi      # 0x10fd8
leaq 0x257e(%rip), %rsi      # 0xc1c2
callq 0x21d0
movq %rax, -0x80(%rbp)
jmp 0x9c4f
movq -0x80(%rbp), %rdi
movq 0x736e(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x9c61
xorl %edi, %edi
callq 0x2280
jmp 0x9cd3
movq 0x7367(%rip), %rdi      # 0x10fd8
leaq 0x2c1c(%rip), %rsi      # 0xc894
callq 0x21d0
movq %rax, -0x88(%rbp)
jmp 0x9c86
movq -0x88(%rbp), %rdi
movq 0x7334(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x9c9b
movq 0x7336(%rip), %rdi      # 0x10fd8
leaq 0x2519(%rip), %rsi      # 0xc1c2
callq 0x21d0
movq %rax, -0x90(%rbp)
jmp 0x9cb7
movq -0x90(%rbp), %rdi
movq 0x7303(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x9ccc
xorl %edi, %edi
callq 0x2280
leaq -0x30(%rbp), %rdi
callq 0x2110
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x2110
movq -0x38(%rbp), %rdi
callq 0x2370
nopw (%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Ifc.cpp
// Function: Ifc::Ifc(std::basic_ifstream<char, std::char_traits<char>>*)
Ifc::Ifc(ifstream *inputfile){
  cond = NULL;
  stmtSeq1 = NULL;
  stmtSeq2 = NULL;
  infile = inputfile;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Ifc.cpp
// Function: Ifc::PrintIfc(int)
void Ifc::PrintIfc(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "if ";
  cond->PrintCond();
  cout << " then" << endl;
  stmtSeq1->PrintStmtSeq(level + 1);
  for (int i = 0; i < level; i++){
    cout << "\t";
  }

  if (stmtSeq2 == NULL){
    cout << "end;" << endl;
  }
  else {
    cout << "else" << endl;
    stmtSeq2->PrintStmtSeq(level + 1);
    for (int i = 0; i < level; i++){
      cout << "\t";
    }
    
    cout << "end;" << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9d84
movq 0x726b(%rip), %rdi      # 0x10fd8
leaq 0x2662(%rip), %rsi      # 0xc3d6
callq 0x21d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9d5e
movq 0x724d(%rip), %rdi      # 0x10fd8
leaq 0x2b2a(%rip), %rsi      # 0xc8bc
callq 0x21d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0xa490
movq 0x722e(%rip), %rdi      # 0x10fd8
leaq 0x2b0f(%rip), %rsi      # 0xc8c0
callq 0x21d0
movq %rax, %rdi
movq 0x7208(%rip), %rsi      # 0x10fc8
callq 0x2210
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x72e0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9e05
movq 0x71ea(%rip), %rdi      # 0x10fd8
leaq 0x25e1(%rip), %rsi      # 0xc3d6
callq 0x21d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9ddf
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x9e37
movq 0x71c1(%rip), %rdi      # 0x10fd8
leaq 0x2907(%rip), %rsi      # 0xc725
callq 0x21d0
movq %rax, %rdi
movq 0x719b(%rip), %rsi      # 0x10fc8
callq 0x2210
jmp 0x9ebb
movq 0x719a(%rip), %rdi      # 0x10fd8
leaq 0x226e(%rip), %rsi      # 0xc0b3
callq 0x21d0
movq %rax, %rdi
movq 0x7174(%rip), %rsi      # 0x10fc8
callq 0x2210
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x72e0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9e99
movq 0x7156(%rip), %rdi      # 0x10fd8
leaq 0x254d(%rip), %rsi      # 0xc3d6
callq 0x21d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9e73
movq 0x7138(%rip), %rdi      # 0x10fd8
leaq 0x287e(%rip), %rsi      # 0xc725
callq 0x21d0
movq %rax, %rdi
movq 0x7112(%rip), %rsi      # 0x10fc8
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Ifc.cpp
// Function: Ifc::ExecIfc()
void Ifc::ExecIfc(){
  if (cond->EvalCond()){
    stmtSeq1->ExecStmtSeq();
  }
  else{
    if(stmtSeq2 != NULL){
      stmtSeq2->ExecStmtSeq();
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0xa610
testb $0x1, %al
jne 0x9ef2
jmp 0x9f01
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7330
jmp 0x9f1b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x9f19
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7330
jmp 0x9f1b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Cond.cpp
// Function: Cond::PrintCond()
void Cond::PrintCond(){
  if (alterId == 1){
    comp->PrintComp();
  }
  else if (alterId == 2){
    cout << "!";
    cond1->PrintCond();
  }
  else if (alterId == 3){
    cout << "[ ";
    cond1->PrintCond();
    cout << " && ";
    cond2->PrintCond();
    cout << " ]";
  }
  else if (alterId == 4){
    cout << "[ ";
    cond1->PrintCond();
    cout << " || ";
    cond2->PrintCond();
    cout << " ]";
  }
  else {
    cout << "PrintError: alterId is not right." << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, 0x18(%rax)
jne 0xa4bb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xac90
jmp 0xa5fc
movq -0x10(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jne 0xa4ea
movq 0x6b0c(%rip), %rdi      # 0x10fd8
leaq 0x1c1c(%rip), %rsi      # 0xc0ef
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa490
jmp 0xa5fa
movq -0x10(%rbp), %rax
cmpl $0x3, 0x18(%rax)
jne 0xa54c
movq 0x6add(%rip), %rdi      # 0x10fd8
leaq 0x2439(%rip), %rsi      # 0xc93b
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa490
movq 0x6abd(%rip), %rdi      # 0x10fd8
leaq 0x241c(%rip), %rsi      # 0xc93e
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa490
movq 0x6a9d(%rip), %rdi      # 0x10fd8
leaq 0x2401(%rip), %rsi      # 0xc943
callq 0x21d0
jmp 0xa5f8
movq -0x10(%rbp), %rax
cmpl $0x4, 0x18(%rax)
jne 0xa5ab
movq 0x6a7b(%rip), %rdi      # 0x10fd8
leaq 0x23d7(%rip), %rsi      # 0xc93b
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa490
movq 0x6a5b(%rip), %rdi      # 0x10fd8
leaq 0x23c2(%rip), %rsi      # 0xc946
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa490
movq 0x6a3b(%rip), %rdi      # 0x10fd8
leaq 0x239f(%rip), %rsi      # 0xc943
callq 0x21d0
jmp 0xa5f6
movq 0x6a26(%rip), %rdi      # 0x10fd8
leaq 0x2392(%rip), %rsi      # 0xc94b
callq 0x21d0
movq %rax, %rdi
movq 0x6a00(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x6a04(%rip), %rdi      # 0x10fd8
leaq 0x1b6b(%rip), %rsi      # 0xc146
callq 0x21d0
movq %rax, %rdi
movq 0x69de(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
jmp 0xa5f8
jmp 0xa5fa
jmp 0xa5fc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: smallsimple[P]CoreInterpreter-CSE5341/Cond.cpp
// Function: Cond::EvalCond()
bool Cond::EvalCond(){
  if (alterId == 1){
    if (comp->EvalComp())  
      return true;
    else
      return false;
  }
  else if (alterId == 2){
    if (cond1->EvalCond()) return false;
    else return true;
  }
  else if (alterId == 3){
    if (cond1->EvalCond() && cond2->EvalCond()) 
      return true;
    else 
      return false;
  }
  else if (alterId == 4){
    if (cond1->EvalCond() || cond2->EvalCond())
      return true;
    else
      return false;
  } 
  else {
    cout << "EvalCond Error: alterId is not right!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, 0x18(%rax)
jne 0xa64e
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xae10
testb $0x1, %al
jne 0xa63c
jmp 0xa645
movb $0x1, -0x1(%rbp)
jmp 0xa744
movb $0x0, -0x1(%rbp)
jmp 0xa744
movq -0x18(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jne 0xa67d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa610
testb $0x1, %al
jne 0xa66b
jmp 0xa674
movb $0x0, -0x1(%rbp)
jmp 0xa744
movb $0x1, -0x1(%rbp)
jmp 0xa744
movq -0x18(%rbp), %rax
cmpl $0x3, 0x18(%rax)
jne 0xa6bf
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa610
testb $0x1, %al
jne 0xa69a
jmp 0xa6b6
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa610
testb $0x1, %al
jne 0xa6ad
jmp 0xa6b6
movb $0x1, -0x1(%rbp)
jmp 0xa744
movb $0x0, -0x1(%rbp)
jmp 0xa744
movq -0x18(%rbp), %rax
cmpl $0x4, 0x18(%rax)
jne 0xa6f9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa610
testb $0x1, %al
jne 0xa6ed
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa610
testb $0x1, %al
jne 0xa6ed
jmp 0xa6f3
movb $0x1, -0x1(%rbp)
jmp 0xa744
movb $0x0, -0x1(%rbp)
jmp 0xa744
movq 0x68d8(%rip), %rdi      # 0x10fd8
leaq 0x2266(%rip), %rsi      # 0xc96d
callq 0x21d0
movq %rax, %rdi
movq 0x68b2(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x68b6(%rip), %rdi      # 0x10fd8
leaq 0x1a1d(%rip), %rsi      # 0xc146
callq 0x21d0
movq %rax, %rdi
movq 0x6890(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: smallsimple[P]CoreInterpreter-CSE5341/Comp.cpp
// Function: Comp::PrintComp()
void Comp::PrintComp(){
  cout << "( ";
  op1->PrintOp();
  if (alterId == 1)
    cout << " != ";
  else if (alterId == 2)
    cout << " == ";
  else if (alterId == 3)
    cout << " < ";
  else if (alterId == 4)
    cout << " > ";
  else if (alterId == 5)
    cout << " <= ";
  else if (alterId == 6)
    cout << " >= ";
  else {
    cout << "Error: PrintComp: alterId is not right!" << endl;
    cout << "program stopped!" << endl;
    exit(0);
  }
  op2->PrintOp();
  cout << " )";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x632d(%rip), %rdi      # 0x10fd8
leaq 0x19ae(%rip), %rsi      # 0xc660
callq 0x21d0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x8d70
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0xace5
movq 0x6304(%rip), %rdi      # 0x10fd8
leaq 0x1d15(%rip), %rsi      # 0xc9f0
callq 0x21d0
jmp 0xadde
movq -0x10(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0xad07
movq 0x62e2(%rip), %rdi      # 0x10fd8
leaq 0x1cf8(%rip), %rsi      # 0xc9f5
callq 0x21d0
jmp 0xaddc
movq -0x10(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0xad29
movq 0x62c0(%rip), %rdi      # 0x10fd8
leaq 0x1cdb(%rip), %rsi      # 0xc9fa
callq 0x21d0
jmp 0xadda
movq -0x10(%rbp), %rax
cmpl $0x4, 0x10(%rax)
jne 0xad4b
movq 0x629e(%rip), %rdi      # 0x10fd8
leaq 0x1cbd(%rip), %rsi      # 0xc9fe
callq 0x21d0
jmp 0xadd8
movq -0x10(%rbp), %rax
cmpl $0x5, 0x10(%rax)
jne 0xad6a
movq 0x627c(%rip), %rdi      # 0x10fd8
leaq 0x1c9f(%rip), %rsi      # 0xca02
callq 0x21d0
jmp 0xadd6
movq -0x10(%rbp), %rax
cmpl $0x6, 0x10(%rax)
jne 0xad89
movq 0x625d(%rip), %rdi      # 0x10fd8
leaq 0x1c85(%rip), %rsi      # 0xca07
callq 0x21d0
jmp 0xadd4
movq 0x6248(%rip), %rdi      # 0x10fd8
leaq 0x1c75(%rip), %rsi      # 0xca0c
callq 0x21d0
movq %rax, %rdi
movq 0x6222(%rip), %rsi      # 0x10fc8
callq 0x2210
movq 0x6226(%rip), %rdi      # 0x10fd8
leaq 0x1409(%rip), %rsi      # 0xc1c2
callq 0x21d0
movq %rax, %rdi
movq 0x6200(%rip), %rsi      # 0x10fc8
callq 0x2210
xorl %edi, %edi
callq 0x2280
jmp 0xadd6
jmp 0xadd8
jmp 0xadda
jmp 0xaddc
jmp 0xadde
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8d70
movq 0x61e6(%rip), %rdi      # 0x10fd8
leaq 0x186a(%rip), %rsi      # 0xc663
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: spjmurray[P]nagios-plugin-check-scsi-smart/check_scsi_smart.cc
// Function: help()
void help() {

  version();

  cout << "(C) 2015-2016 Simon Murray <spjmurray@yahoo.co.uk>" << endl
       << endl;

  usage();

  cout << endl
       << "Options:" << endl
       << "-h, --help" << endl
       << "   Print detailed help" << endl
       << "-V, --version" << endl
       << "   Print version information" << endl
       << "-d, --device=DEVICE" << endl
       << "   Select device DEVICE" << endl
       << "-w, --warning=ID:THRESHOLD[,ID:THRESHOLD]" << endl
       << "   Specify warning thresholds as a list of integer attributes to integer thresholds" << endl
       << "-c, --critical=ID:THRESHOLD[,ID:THRESHOLD]" << endl
       << "   Specify critical thresholds as a list of integer attributes to integer thresholds" << endl
       << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x4570
movq 0x8998(%rip), %rdi      # 0xcfc8
leaq 0x4a8d(%rip), %rsi      # 0x90c4
callq 0x4200
movq %rax, %rdi
movq 0x896a(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
movq 0x895b(%rip), %rsi      # 0xcfb0
callq 0x4240
callq 0x45c0
movq 0x8962(%rip), %rdi      # 0xcfc8
movq 0x8943(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
leaq 0x4a7b(%rip), %rsi      # 0x90f7
callq 0x4200
movq %rax, %rdi
movq 0x8925(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
leaq 0x4a66(%rip), %rsi      # 0x9100
callq 0x4200
movq %rax, %rdi
movq 0x8907(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
leaq 0x4a53(%rip), %rsi      # 0x910b
callq 0x4200
movq %rax, %rdi
movq 0x88e9(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
leaq 0x4a4c(%rip), %rsi      # 0x9122
callq 0x4200
movq %rax, %rdi
movq 0x88cb(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
leaq 0x4a3c(%rip), %rsi      # 0x9130
callq 0x4200
movq %rax, %rdi
movq 0x88ad(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
leaq 0x4a3b(%rip), %rsi      # 0x914d
callq 0x4200
movq %rax, %rdi
movq 0x888f(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
leaq 0x4a31(%rip), %rsi      # 0x9161
callq 0x4200
movq %rax, %rdi
movq 0x8871(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
leaq 0x4a2b(%rip), %rsi      # 0x9179
callq 0x4200
movq %rax, %rdi
movq 0x8853(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
leaq 0x4a37(%rip), %rsi      # 0x91a3
callq 0x4200
movq %rax, %rdi
movq 0x8835(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
leaq 0x4a6d(%rip), %rsi      # 0x91f7
callq 0x4200
movq %rax, %rdi
movq 0x8817(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
leaq 0x4a7a(%rip), %rsi      # 0x9222
callq 0x4200
movq %rax, %rdi
movq 0x87f9(%rip), %rsi      # 0xcfb0
callq 0x4240
movq %rax, %rdi
movq 0x87ea(%rip), %rsi      # 0xcfb0
callq 0x4240
popq %rbp
retq
nopl (%rax)
// File: spjmurray[P]nagios-plugin-check-scsi-smart/check_scsi_smart.cc
// Function: sgio(int, unsigned char*, int, unsigned char*, int)
bool sgio(int fd, unsigned char* cmdp, int cmd_len, unsigned char* dxferp, int dxfer_len) {

  sg_io_hdr_t sgio_hdr;
  unsigned char sense[32];

  memset(&sgio_hdr, 0, sizeof(sg_io_hdr_t));
  sgio_hdr.interface_id = 'S';
  sgio_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
  sgio_hdr.cmd_len = cmd_len;
  sgio_hdr.mx_sb_len = 32;
  sgio_hdr.dxfer_len = dxfer_len;
  sgio_hdr.dxferp = dxferp;
  sgio_hdr.cmdp = cmdp;
  sgio_hdr.sbp = sense;

  if(ioctl(fd, SG_IO, &sgio_hdr) < 0) {
    cerr << "UNKNOWN: SG_IO ioctl error" << endl;
    exit(NAGIOS_UNKNOWN);
  }

  return !sgio_hdr.status;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x4110
movl $0x53, -0x80(%rbp)
movl $0xfffffffd, -0x7c(%rbp) # imm = 0xFFFFFFFD
movl -0x14(%rbp), %eax
movb %al, -0x78(%rbp)
movb $0x20, -0x77(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x74(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0xa0(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x4(%rbp), %edi
movl $0x2285, %esi           # imm = 0x2285
leaq -0x80(%rbp), %rdx
movb $0x0, %al
callq 0x4300
cmpl $0x0, %eax
jge 0x487a
movq 0x8793(%rip), %rdi      # 0xcfe8
leaq 0x4a1b(%rip), %rsi      # 0x9277
callq 0x4200
movq %rax, %rdi
movq 0x8745(%rip), %rsi      # 0xcfb0
callq 0x4240
movl $0x3, %edi
callq 0x4290
cmpb $0x0, -0x40(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nop