LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3692
movq %rax, %rdi
callq 0x38a4
leaq 0x25e0(%rip), %rcx      # 0x730c
cmpl (%rcx), %eax
jne 0x4d53
pushq $0x10
popq %rdi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
callq 0x4e70
movq %r14, 0x8(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4f1c
addl $-0x5, %eax
cmpl $0x6, %eax
ja 0x4e04
leaq 0x27ae(%rip), %rcx      # 0x7514
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x20
popq %rdi
callq 0x2180
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x5f14
movq %r14, 0x10(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6080
pushq $0x10
popq %rdi
callq 0x2180
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x5b48
movq %r14, 0x20(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5be0
pushq $0x8
popq %rdi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
callq 0x5d34
movq %r14, 0x28(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5dc2
pushq $0x18
popq %rdi
callq 0x2180
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x57c8
movq %r14, 0x18(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x58cc
movq 0x61cd(%rip), %rbx      # 0xafd8
leaq 0x2778(%rip), %rsi      # 0x758a
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x276d(%rip), %rsi      # 0x7596
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
movq %rax, %rbx
pushq $0x18
jmp 0x4e5c
movq %rax, %rbx
pushq $0x20
jmp 0x4e5c
movq %rax, %rbx
pushq $0x8
jmp 0x4e5c
jmp 0x4e57
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2290
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/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
xorl %r12d, %r12d
testl %esi, %esi
cmovgl %esi, %r12d
movq 0x613e(%rip), %r14      # 0xafd8
leaq 0x2535(%rip), %r15      # 0x73d6
subl $0x1, %r12d
jb 0x4eb4
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
jmp 0x4ea1
movq (%rbx), %rdi
callq 0x492a
movq 0x6115(%rip), %r14      # 0xafd8
leaq 0x2646(%rip), %rsi      # 0x7510
movq %r14, %rdi
callq 0x2170
movq 0x8(%rbx), %rdi
callq 0x510c
leaq 0x2862(%rip), %rsi      # 0x7744
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Assign.cpp
// Function: Assign::ParseAssign()
void Assign::ParseAssign(){
  Tokenizer *tokensAssign;
  tokensAssign = Tokenizer::getInstance();
  int tokenType;
  tokenType = tokensAssign->getTokenType();
  if (tokenType != tokensAssign->idNum){
    cout << "Error: Assign: not legal identifier" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
  id = Id::ParseId();
  string tokenTemp;
  tokenTemp = tokensAssign->getToken();
  if (tokenTemp.compare("=") != 0){
    cout << "Error: Assign: \"=\" not found after identifier." << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
  else {
    tokensAssign->skipToken();
  }
  
  expr = new Expr();
  expr->ParseExpr();
  tokenTemp = tokensAssign->getToken();
  if (tokenTemp.compare(";") != 0){
    cout << "Error; Assign: \";\" not found or not in the right place!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
  tokensAssign->skipToken();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
callq 0x3692
movq %rax, %rbx
movq %rax, %rdi
callq 0x38a4
leaq 0x23c7(%rip), %rcx      # 0x730c
cmpl (%rcx), %eax
jne 0x5026
callq 0x47b8
movq %rax, (%r14)
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x36e6
leaq -0x40(%rbp), %r15
leaq -0x60(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x21e0
movq %r12, %rdi
callq 0x20c0
leaq 0x2149(%rip), %rsi      # 0x70dc
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
jne 0x5062
movq %rbx, %rdi
callq 0x3746
pushq $0x18
popq %rdi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
callq 0x50fc
movq %r15, 0x8(%r14)
movq %r15, %rdi
callq 0x524c
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
callq 0x36e6
leaq -0x40(%rbp), %r14
leaq -0x60(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x20c0
leaq 0x274c(%rip), %rsi      # 0x7744
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0x509a
movq %rbx, %rdi
callq 0x3746
leaq -0x40(%rbp), %rdi
callq 0x20c0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x5fab(%rip), %rbx      # 0xafd8
leaq 0x2572(%rip), %rsi      # 0x75a6
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x20fb(%rip), %rsi      # 0x7146
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
movq 0x5f6f(%rip), %rdi      # 0xafd8
leaq 0x255a(%rip), %rsi      # 0x75ca
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x5f54(%rip), %rdi      # 0xafd8
leaq 0x20bb(%rip), %rsi      # 0x7146
callq 0x2170
movq %rax, %rdi
callq 0x20d0
jmp 0x505b
movq 0x5f37(%rip), %rdi      # 0xafd8
leaq 0x2551(%rip), %rsi      # 0x75f9
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x5f1c(%rip), %rdi      # 0xafd8
leaq 0x2083(%rip), %rsi      # 0x7146
callq 0x2170
movq %rax, %rdi
callq 0x20d0
jmp 0x505b
jmp 0x50e6
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x2190
jmp 0x50e9
jmp 0x50e6
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/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 0x2514(%rip), %r15      # 0x7635
leaq 0x2509(%rip), %r12      # 0x7631
movq 0x5ea9(%rip), %r14      # 0xafd8
movq (%rbx), %rdi
callq 0x5358
movl 0x10(%rbx), %eax
cmpl $0x2, %eax
je 0x5149
movq %r15, %rsi
cmpl $0x3, %eax
je 0x514c
jmp 0x515a
movq %r12, %rsi
movq %r14, %rdi
callq 0x2170
movq 0x8(%rbx), %rbx
jmp 0x512f
cmpl $0x1, %eax
jne 0x5168
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x5e69(%rip), %rbx      # 0xafd8
leaq 0x24c3(%rip), %rsi      # 0x7639
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x2409(%rip), %rsi      # 0x7596
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/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 0x51cd
movq (%rbx), %rdi
callq 0x539e
movq 0x8(%rbx), %rbx
addl %eax, %r15d
jmp 0x51b4
cmpl $0x3, %eax
je 0x51e7
cmpl $0x1, %eax
jne 0x520f
movq (%rbx), %rdi
callq 0x539e
movl %eax, %r14d
addl %r15d, %r14d
jmp 0x5201
movq (%rbx), %rdi
callq 0x539e
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x51a4
addl %r15d, %r14d
subl %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5dc2(%rip), %rbx      # 0xafd8
leaq 0x243c(%rip), %rsi      # 0x7659
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x2362(%rip), %rsi      # 0x7596
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/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 0x3692
movq %rax, %r14
pushq $0x10
popq %rdi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
callq 0x534c
movq %r15, (%rbx)
movq %r15, %rdi
callq 0x53da
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x36e6
leaq 0x1e3d(%rip), %rsi      # 0x70d5
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
je 0x52bc
leaq 0x1e2c(%rip), %rsi      # 0x70d7
leaq -0x38(%rbp), %rdi
callq 0x2080
testl %eax, %eax
je 0x52e6
pushq $0x1
jmp 0x530e
movq %r14, %rdi
callq 0x3746
pushq $0x18
popq %rdi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andl $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x524c
pushq $0x2
jmp 0x530e
movq %r14, %rdi
callq 0x3746
pushq $0x18
popq %rdi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andl $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x524c
pushq $0x3
popq %rax
movl %eax, 0x10(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x20c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x2190
jmp 0x5342
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Fac.cpp
// Function: Fac::PrintFac()
void Fac::PrintFac(){
  op->PrintOp();
  if (fac != NULL){
    cout << " * ";
    fac->PrintFac();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5c6c(%rip), %r14      # 0xafd8
leaq 0x2305(%rip), %r15      # 0x7678
movq (%rbx), %rdi
callq 0x549c
cmpq $0x0, 0x8(%rbx)
je 0x5393
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movq 0x8(%rbx), %rbx
jmp 0x5373
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Fac.cpp
// Function: Fac::EvalFac()
int Fac::EvalFac(){
  if (fac == NULL){
    return op->EvalOp();
  }  
  else{
    return op->EvalOp() * fac->EvalFac();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %r14
movq 0x8(%rbx), %r15
movq (%rbx), %rdi
callq 0x5540
testq %r15, %r15
je 0x53ca
movq 0x8(%rbx), %rbx
imull %eax, %r14d
jmp 0x53af
imull %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3692
movq %rax, %r14
pushq $0x20
popq %rdi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
callq 0x548c
movq %r15, (%rbx)
movq %r15, %rdi
callq 0x55ae
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x36e6
leaq 0x1cb3(%rip), %rsi      # 0x70d9
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
jne 0x5454
movq %r14, %rdi
callq 0x3746
pushq $0x10
popq %rdi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rdi
callq 0x53da
leaq -0x38(%rbp), %rdi
callq 0x20c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x2190
jmp 0x5484
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Op.cpp
// Function: Op::PrintOp()
void Op::PrintOp(){
  if (alterId == 1){
    inte->PrintInte();
    return;
  }
  else if (alterId == 2){
    id->PrintId();
    return;
  }
  else if (alterId == 3){
    cout << "( ";
    expr->PrintExpr();
    cout << " )";
    return;
  }
  else {
    cout << "Error: PrintOp: Wrong alterId" << endl;
    cout << "program stopped" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %eax
cmpl $0x3, %eax
je 0x54d1
cmpl $0x2, %eax
je 0x54c4
cmpl $0x1, %eax
jne 0x5503
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5702
movq 0x8(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x492a
movq 0x5b00(%rip), %r14      # 0xafd8
leaq 0x219d(%rip), %rsi      # 0x767c
movq %r14, %rdi
callq 0x2170
movq 0x10(%rbx), %rdi
callq 0x510c
leaq 0x2188(%rip), %rsi      # 0x767f
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2170
movq 0x5ace(%rip), %rbx      # 0xafd8
leaq 0x2171(%rip), %rsi      # 0x7682
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x206e(%rip), %rsi      # 0x7596
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Op.cpp
// Function: Op::EvalOp()
int Op::EvalOp(){
  
  if (alterId == 1){
    return inte->EvalInte();
  }
  else if (alterId ==2){
    return id->GetIdVal();
  }
  else if (alterId ==3){
    return expr->EvalExpr();
  }
  else {
    cout << "Error: EvalOp: Wrong alterId" << endl;
    cout << "program stopped" << endl;
    exit(0);
  }
}

// Assembly:
movl 0x18(%rdi), %eax
cmpl $0x3, %eax
je 0x5563
cmpl $0x2, %eax
je 0x555a
cmpl $0x1, %eax
jne 0x556c
movq (%rdi), %rdi
jmp 0x5716
movq 0x8(%rdi), %rdi
jmp 0x493e
movq 0x10(%rdi), %rdi
jmp 0x51a4
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x5a5f(%rip), %rbx      # 0xafd8
leaq 0x2120(%rip), %rsi      # 0x76a0
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x1fff(%rip), %rsi      # 0x7596
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Op.cpp
// Function: Op::ParseOp()
void Op::ParseOp(){
  Tokenizer *tokensOp;
  tokensOp = Tokenizer::getInstance();
  int tokenType = tokensOp->getTokenType();
  if (tokenType == tokensOp->intNum){
    alterId = 1;
    inte = new Inte();
    inte->ParseInte();
  }
  else if (tokenType == tokensOp->idNum){
    //cout << "token.name: "<< tokensOp->getToken() << endl;
    alterId = 2;
    id = Id::ParseId();    
  }
  else if (tokenType == 20){//20 for "("
    alterId = 3;
    tokensOp->skipToken();
    expr = new Expr();
    expr->ParseExpr();
    tokenType = tokensOp->getTokenType();
    if (tokenType == 21){//21 for ")"
      tokensOp->skipToken();
    }
    else {
      cout << "Error: ParseOp: \")\" not found or not in right place!" << endl;
      cout << "program stopped." << endl;
      exit(0);
    }
  }
  else {
    cout << "Error: ParseOp: no Op is found!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3692
movq %rax, %r14
movq %rax, %rdi
callq 0x38a4
leaq 0x1d36(%rip), %rcx      # 0x7308
cmpl (%rcx), %eax
jne 0x5605
movl $0x1, 0x18(%rbx)
pushq $0x28
popq %rdi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
callq 0x56ec
movq %r14, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5720
leaq 0x1d00(%rip), %rcx      # 0x730c
cmpl (%rcx), %eax
jne 0x562b
movl $0x2, 0x18(%rbx)
callq 0x47b8
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x14, %eax
jne 0x567d
movl $0x3, 0x18(%rbx)
movq %r14, %rdi
callq 0x3746
pushq $0x18
popq %rdi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
callq 0x50fc
movq %r15, 0x10(%rbx)
movq %r15, %rdi
callq 0x524c
movq %r14, %rdi
callq 0x38a4
cmpl $0x15, %eax
jne 0x568d
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3746
movq 0x5954(%rip), %rbx      # 0xafd8
leaq 0x2067(%rip), %rsi      # 0x76f2
jmp 0x569b
movq 0x5944(%rip), %rbx      # 0xafd8
leaq 0x2022(%rip), %rsi      # 0x76bd
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x1a94(%rip), %rsi      # 0x7146
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r15, %rdi
jmp 0x56dd
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Inte.cpp
// Function: Inte::ParseInte()
void Inte::ParseInte(){
  Tokenizer *tokensInte;
  tokensInte = Tokenizer::getInstance();
  int tokenType = tokensInte->getTokenType();
  if (tokenType != tokensInte->intNum){
    cout << "Error: ParseInte: not an integer!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
  else {
    name = tokensInte->getToken();
    value = atoi(name.c_str());
    tokensInte->skipToken();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x3692
movq %rax, %r14
movq %rax, %rdi
callq 0x38a4
leaq 0x1bc1(%rip), %rcx      # 0x7308
cmpl (%rcx), %eax
jne 0x578b
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x36e6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x20c0
movq (%rbx), %rdi
callq 0x2250
movl %eax, 0x20(%rbx)
movq %r14, %rdi
callq 0x3746
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5846(%rip), %rbx      # 0xafd8
leaq 0x1f79(%rip), %rsi      # 0x7712
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x1996(%rip), %rsi      # 0x7146
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Loop.cpp
// Function: Loop::PrintLoop(int)
void Loop::PrintLoop(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "while ";
  cond->PrintCond();
  cout << " loop" << endl;
  stmtSeq->PrintStmtSeq(level+1);
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  
  cout << "end;" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
xorl %r15d, %r15d
testl %esi, %esi
cmovgl %esi, %r15d
movq %rdi, -0x30(%rbp)
movq 0x57dc(%rip), %r14      # 0xafd8
leaq 0x1bd3(%rip), %r12      # 0x73d6
movl %r15d, %r13d
subl $0x1, %r13d
jb 0x5819
movq %r14, %rdi
movq %r12, %rsi
callq 0x2170
jmp 0x5806
movq 0x57b8(%rip), %r14      # 0xafd8
leaq 0x1f0d(%rip), %rsi      # 0x7734
movq %r14, %rdi
callq 0x2170
movq -0x30(%rbp), %r12
movq (%r12), %rdi
callq 0x63dc
leaq 0x1ef8(%rip), %rsi      # 0x773b
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x8(%r12), %rdi
incl %ebx
movl %ebx, %esi
callq 0x44ac
leaq 0x1b6e(%rip), %rbx      # 0x73d6
subl $0x1, %r15d
jb 0x587b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2170
jmp 0x5868
movq 0x5756(%rip), %rdi      # 0xafd8
leaq 0x1eb8(%rip), %rsi      # 0x7741
callq 0x2170
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Input.cpp
// Function: Input::PrintInput(int)
void Input::PrintInput(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "read ";
  idList->PrintIdList();
  cout << ";" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
testl %esi, %esi
cmovgl %esi, %r12d
movq 0x5464(%rip), %r14      # 0xafd8
leaq 0x185b(%rip), %r15      # 0x73d6
subl $0x1, %r12d
jb 0x5b8e
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
jmp 0x5b7b
movq 0x5443(%rip), %r14      # 0xafd8
leaq 0x1c46(%rip), %rsi      # 0x77e2
movq %r14, %rdi
callq 0x2170
movq (%rbx), %rdi
callq 0x45c4
leaq 0x1b91(%rip), %rsi      # 0x7744
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Input.cpp
// Function: Input::ParseInput()
void Input::ParseInput(){
  Tokenizer *tokensInput;
  tokensInput = Tokenizer::getInstance();
  string tokenTemp = tokensInput->getToken();
  if (tokenTemp.compare("read") == 0){
    //cout << "read is parsed." << endl;
    tokensInput->skipToken();
    idList = new IdList();
    idList->ParseIdList();
    tokenTemp = tokensInput->getToken();
    if (tokenTemp.compare(";") == 0){
      tokensInput->skipToken();
      return;
    }
    else{
      cout << "Syntax Error: ParseInput: ';' not found or not in the right place!" << endl;
      cout << "program stopped." << endl;
      exit(0);
    }
  }
  else{
    cout << "Syntax Error: ParseInput: 'read' not found or not in the right place!" << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
callq 0x3692
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x36e6
leaq 0x14b0(%rip), %rsi      # 0x70be
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
jne 0x5c96
movq %rbx, %rdi
callq 0x3746
pushq $0x10
popq %rdi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
callq 0x45b8
movq %r15, (%r14)
movq %r15, %rdi
callq 0x462c
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x36e6
leaq -0x38(%rbp), %r14
leaq -0x58(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x20c0
leaq 0x1ad6(%rip), %rsi      # 0x7744
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0x5cce
movq %rbx, %rdi
callq 0x3746
leaq -0x38(%rbp), %rdi
callq 0x20c0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x533b(%rip), %rdi      # 0xafd8
leaq 0x1b87(%rip), %rsi      # 0x782b
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x5320(%rip), %rdi      # 0xafd8
leaq 0x1487(%rip), %rsi      # 0x7146
callq 0x2170
movq %rax, %rdi
callq 0x20d0
jmp 0x5d04
movq 0x5303(%rip), %rdi      # 0xafd8
leaq 0x1b0c(%rip), %rsi      # 0x77e8
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x52e8(%rip), %rdi      # 0xafd8
leaq 0x144f(%rip), %rsi      # 0x7146
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
jmp 0x5d1d
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x2190
jmp 0x5d20
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2290
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Output.cpp
// Function: Output::PrintOutput(int)
void Output::PrintOutput(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "write ";
  idList->PrintIdList();
  cout << ";" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
testl %esi, %esi
cmovgl %esi, %r12d
movq 0x527c(%rip), %r14      # 0xafd8
leaq 0x1673(%rip), %r15      # 0x73d6
subl $0x1, %r12d
jb 0x5d76
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
jmp 0x5d63
movq 0x525b(%rip), %r14      # 0xafd8
leaq 0x1aed(%rip), %rsi      # 0x7871
movq %r14, %rdi
callq 0x2170
movq (%rbx), %rdi
callq 0x45c4
leaq 0x19a9(%rip), %rsi      # 0x7744
movq %r14, %rdi
callq 0x2170
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Output.cpp
// Function: Output::ParseOutput()
void Output::ParseOutput(){
  Tokenizer *tokensOutput;
  tokensOutput = Tokenizer::getInstance();
  string tokenTemp = tokensOutput->getToken();
  if (tokenTemp.compare("write") == 0){
    tokensOutput->skipToken();
    idList = new IdList();
    idList->ParseIdList();
    tokenTemp = tokensOutput->getToken();
    if (tokenTemp.compare(";") == 0){
      tokensOutput->skipToken();
    }
    else{
      cout << "Syntax Error: no \";\" is found or not in the right place" << endl;
      cout << "program stopped!" << endl;
      exit(0);
    }
  }
  else{
    cout << "Error: ParseOutput: no \"wrte\" is found." << endl;
    cout << "program stopped!" << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
callq 0x3692
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x36e6
leaq 0x12d3(%rip), %rsi      # 0x70c3
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
jne 0x5e78
movq %rbx, %rdi
callq 0x3746
pushq $0x10
popq %rdi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
callq 0x45b8
movq %r15, (%r14)
movq %r15, %rdi
callq 0x462c
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x36e6
leaq -0x38(%rbp), %r14
leaq -0x58(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x21e0
movq %r15, %rdi
callq 0x20c0
leaq 0x18f4(%rip), %rsi      # 0x7744
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0x5eb0
movq %rbx, %rdi
callq 0x3746
leaq -0x38(%rbp), %rdi
callq 0x20c0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5159(%rip), %rdi      # 0xafd8
leaq 0x1a2a(%rip), %rsi      # 0x78b0
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x513e(%rip), %rdi      # 0xafd8
leaq 0x1321(%rip), %rsi      # 0x71c2
callq 0x2170
movq %rax, %rdi
callq 0x20d0
jmp 0x5ee6
movq 0x5121(%rip), %rdi      # 0xafd8
leaq 0x19ba(%rip), %rsi      # 0x7878
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x5106(%rip), %rdi      # 0xafd8
leaq 0x12e9(%rip), %rsi      # 0x71c2
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
jmp 0x5eff
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x2190
jmp 0x5f02
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
xorl %r14d, %r14d
testl %esi, %esi
cmovgl %esi, %r14d
movq %rdi, -0x30(%rbp)
movq 0x508a(%rip), %r15      # 0xafd8
leaq 0x1481(%rip), %r12      # 0x73d6
movl %r14d, %r13d
subl $0x1, %r13d
jb 0x5f6b
movq %r15, %rdi
movq %r12, %rsi
callq 0x2170
jmp 0x5f58
movq 0x5066(%rip), %r15      # 0xafd8
leaq 0x195f(%rip), %rsi      # 0x78d8
movq %r15, %rdi
callq 0x2170
movq -0x30(%rbp), %r12
movq (%r12), %rdi
callq 0x63dc
leaq 0x1947(%rip), %rsi      # 0x78dc
movq %r15, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x8(%r12), %rdi
incl %ebx
movl %ebx, %esi
callq 0x44ac
leaq 0x141c(%rip), %r12      # 0x73d6
movl %r14d, %r13d
subl $0x1, %r13d
jb 0x5fd0
movq %r15, %rdi
movq %r12, %rsi
callq 0x2170
jmp 0x5fbd
movq -0x30(%rbp), %r12
cmpq $0x0, 0x10(%r12)
je 0x6020
movq 0x4ff5(%rip), %r15      # 0xafd8
leaq 0x10c9(%rip), %rsi      # 0x70b3
movq %r15, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
movq 0x10(%r12), %rdi
movl %ebx, %esi
callq 0x44ac
leaq 0x13c9(%rip), %rbx      # 0x73d6
subl $0x1, %r14d
jb 0x6020
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2170
jmp 0x600d
movq 0x4fb1(%rip), %rdi      # 0xafd8
leaq 0x1713(%rip), %rsi      # 0x7741
callq 0x2170
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x64ea
testb %al, %al
je 0x6065
movq 0x8(%rbx), %rdi
jmp 0x606e
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x6079
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x44d0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1567(%rip), %r12      # 0x7958
movq 0x4be0(%rip), %r14      # 0xafd8
leaq 0xcf0(%rip), %r15       # 0x70ef
movl 0x18(%rbx), %eax
decl %eax
cmpl $0x3, %eax
ja 0x64ad
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movq 0x8(%rbx), %rbx
jmp 0x63ff
movq 0x4baa(%rip), %r14      # 0xafd8
leaq 0x1543(%rip), %rsi      # 0x7978
movq %r14, %rdi
callq 0x2170
movq 0x8(%rbx), %rdi
callq 0x63dc
leaq 0x1536(%rip), %rsi      # 0x7983
jmp 0x6485
movq (%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x68c0
movq 0x4b72(%rip), %r14      # 0xafd8
leaq 0x150b(%rip), %rsi      # 0x7978
movq %r14, %rdi
callq 0x2170
movq 0x8(%rbx), %rdi
callq 0x63dc
leaq 0x14f6(%rip), %rsi      # 0x797b
movq %r14, %rdi
callq 0x2170
movq 0x10(%rbx), %rdi
callq 0x63dc
leaq 0x14e3(%rip), %rsi      # 0x7980
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2170
movq 0x4b24(%rip), %rbx      # 0xafd8
leaq 0x14cd(%rip), %rsi      # 0x7988
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0xc74(%rip), %rsi       # 0x7146
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0x1468(%rip), %r15      # 0x7968
movl 0x18(%r14), %eax
decl %eax
cmpl $0x3, %eax
ja 0x6570
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x8(%r14), %rdi
callq 0x64ea
testb %al, %al
jne 0x655c
movq 0x10(%r14), %r14
jmp 0x6500
movq 0x8(%r14), %r14
xorb $0x1, %bl
jmp 0x6500
movq 0x8(%r14), %rdi
callq 0x64ea
testb %al, %al
je 0x654e
movq 0x10(%r14), %rdi
callq 0x64ea
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x655e
xorl %eax, %eax
jmp 0x655e
movq (%r14), %rdi
callq 0x6966
jmp 0x655e
movb $0x1, %al
xorb %al, %bl
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x4a61(%rip), %rbx      # 0xafd8
leaq 0x142c(%rip), %rsi      # 0x79aa
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0xbb1(%rip), %rsi       # 0x7146
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x4707(%rip), %rdi      # 0xafd8
leaq 0xda4(%rip), %rsi       # 0x767c
callq 0x2170
movq (%rbx), %rdi
callq 0x549c
movl 0x10(%rbx), %eax
decl %eax
cmpl $0x6, %eax
jae 0x692a
movl %eax, %eax
leaq 0x1134(%rip), %rcx      # 0x7a2c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq 0x46d2(%rip), %r14      # 0xafd8
movq %r14, %rdi
callq 0x2170
movq 0x8(%rbx), %rdi
callq 0x549c
leaq 0xd61(%rip), %rsi       # 0x767f
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2170
movq 0x46a7(%rip), %rbx      # 0xafd8
leaq 0x1128(%rip), %rsi      # 0x7a60
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x873(%rip), %rsi       # 0x71c2
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/smallsimple[P]CoreInterpreter-CSE5341/Comp.cpp
// Function: Comp::EvalComp()
bool Comp::EvalComp(){
  switch(alterId) {
  case 1:
    if (op1->EvalOp() != op2->EvalOp())
      return true;
    else 
      return false;
  case 2:
    if (op1->EvalOp() == op2->EvalOp())
      return true;
    else 
      return false;
  case 3:
    if (op1->EvalOp() < op2->EvalOp())
      return true;
    else 
      return false;
  case 4:
    if (op1->EvalOp() > op2->EvalOp())
      return true;
    else
      return false;
  case 5:
    if (op1->EvalOp() <= op2->EvalOp())
      return true;
    else 
      return false;
  case 6:
    if (op1->EvalOp() >= op2->EvalOp())
      return true;
    else
      return false;
  default:
    cout << "Error: EvalComp: wrong alterId." << endl;
    cout << "program stopped." << endl;
    exit(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x10(%rdi), %eax
decl %eax
cmpl $0x5, %eax
ja 0x6a3c
movq %rdi, %rbx
leaq 0x108f(%rip), %rcx      # 0x7a14
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x5540
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5540
cmpl %eax, %r14d
setne %al
jmp 0x6a37
movq (%rbx), %rdi
callq 0x5540
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5540
cmpl %eax, %r14d
setle %al
jmp 0x6a37
movq (%rbx), %rdi
callq 0x5540
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5540
cmpl %eax, %r14d
setl %al
jmp 0x6a37
movq (%rbx), %rdi
callq 0x5540
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5540
cmpl %eax, %r14d
setg %al
jmp 0x6a37
movq (%rbx), %rdi
callq 0x5540
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5540
cmpl %eax, %r14d
sete %al
jmp 0x6a37
movq (%rbx), %rdi
callq 0x5540
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5540
cmpl %eax, %r14d
setge %al
popq %rbx
popq %r14
popq %rbp
retq
movq 0x4595(%rip), %rbx      # 0xafd8
leaq 0x103e(%rip), %rsi      # 0x7a88
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
leaq 0x6e5(%rip), %rsi       # 0x7146
movq %rbx, %rdi
callq 0x2170
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
callq 0x241c
movq 0x4b29(%rip), %rbx      # 0x6fd0
leaq 0x1b86(%rip), %rsi      # 0x4034
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x20c0
callq 0x2457
movq %rbx, %rdi
callq 0x20c0
leaq 0x1b8d(%rip), %rsi      # 0x4067
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1b7f(%rip), %rsi      # 0x4070
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1b73(%rip), %rsi      # 0x407b
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1b73(%rip), %rsi      # 0x4092
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1b6a(%rip), %rsi      # 0x40a0
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1b70(%rip), %rsi      # 0x40bd
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1b6d(%rip), %rsi      # 0x40d1
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1b6e(%rip), %rsi      # 0x40e9
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1b81(%rip), %rsi      # 0x4113
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1bbe(%rip), %rsi      # 0x4167
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1bd2(%rip), %rsi      # 0x4192
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
popq %rbx
jmp 0x20c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
subq $0x78, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rax
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movabsq $-0x2ffffffad, %r9      # imm = 0xFFFFFFFD00000053
movq %r9, (%rax)
movb %dl, 0x8(%rax)
movb $0x20, 0x9(%rax)
movl %r8d, 0xc(%rax)
movq %rcx, 0x10(%rax)
movq %rsi, 0x18(%rax)
movq %rsp, %rcx
movq %rcx, 0x20(%rax)
movl $0x2285, %esi           # imm = 0x2285
movq %rax, %rdx
xorl %eax, %eax
callq 0x2210
testl %eax, %eax
js 0x2640
cmpb $0x0, 0x60(%rsp)
sete %al
addq $0x78, %rsp
retq
movq 0x49a9(%rip), %rdi      # 0x6ff0
leaq 0x1b99(%rip), %rsi      # 0x41e7
callq 0x2180
movq %rax, %rdi
callq 0x20c0
pushq $0x3
popq %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O2/spjmurray[P]nagios-plugin-check-scsi-smart/check_scsi_smart.cc
// Function: ata_smart_read_data(int, unsigned char*)
bool ata_smart_read_data(int fd, unsigned char* buf) {

  sbc_ata_pass_through ata_pass_through;
  memset(reinterpret_cast<unsigned char*>(&ata_pass_through), 0, sizeof(sbc_ata_pass_through));

  ata_pass_through.operation_code = SBC_ATA_PASS_THROUGH;
  ata_pass_through.protocol       = ATA_PROTOCOL_PIO_DATA_IN;
  ata_pass_through.t_dir          = ATA_TRANSFER_DIRECTION_FROM_DEVICE;
  ata_pass_through.byte_block     = ATA_TRANSFER_SIZE_BLOCK;
  ata_pass_through.t_type         = ATA_TRANSFER_TYPE_SECTOR;
  ata_pass_through.t_length       = ATA_TRANSFER_LENGTH_COUNT;
  ata_pass_through.count_7_0      = 1;
  ata_pass_through.command        = ATA_SMART;
  ata_pass_through.features_7_0   = SMART_READ_DATA;
  ata_pass_through.lba_23_16      = 0xc2;
  ata_pass_through.lba_15_8       = 0x4f;

  return sgio(fd, reinterpret_cast<unsigned char*>(&ata_pass_through), sizeof(ata_pass_through), buf, SECTOR_SIZE);

}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
andq $0x0, 0x3(%rax)
movq %rsi, %rcx
andq $0x0, 0x8(%rax)
movb $-0x7b, (%rax)
movw $0xe08, 0x1(%rax)       # imm = 0xE08
movb $0x1, 0x6(%rax)
movb $-0x50, 0xe(%rax)
movb $-0x30, 0x4(%rax)
movb $-0x3e, 0xc(%rax)
movb $0x4f, 0xa(%rax)
pushq $0x10
popq %rdx
movq %rax, %rsi
movl $0x200, %r8d            # imm = 0x200
callq 0x25d9
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/spjmurray[P]nagios-plugin-check-scsi-smart/check_scsi_smart.cc
// Function: ata_smart_read_log(int, unsigned char*, int, unsigned short)
bool ata_smart_read_log(int fd, unsigned char* buf, int log, uint16_t sectors) {

  sbc_ata_pass_through ata_pass_through;
  memset(reinterpret_cast<unsigned char*>(&ata_pass_through), 0, sizeof(sbc_ata_pass_through));

  ata_pass_through.operation_code = SBC_ATA_PASS_THROUGH;
  ata_pass_through.protocol       = ATA_PROTOCOL_PIO_DATA_IN;
  ata_pass_through.t_dir          = ATA_TRANSFER_DIRECTION_FROM_DEVICE;
  ata_pass_through.byte_block     = ATA_TRANSFER_SIZE_BLOCK;
  ata_pass_through.t_type         = ATA_TRANSFER_TYPE_SECTOR;
  ata_pass_through.t_length       = ATA_TRANSFER_LENGTH_COUNT;
  ata_pass_through.count_15_8     = sectors >> 8;
  ata_pass_through.count_7_0      = sectors;
  ata_pass_through.command        = ATA_SMART;
  ata_pass_through.features_7_0   = SMART_READ_LOG;
  ata_pass_through.lba_23_16      = 0xc2;
  ata_pass_through.lba_15_8       = 0x4f;
  ata_pass_through.lba_7_0        = log;

  return sgio(fd, reinterpret_cast<unsigned char*>(&ata_pass_through), sizeof(ata_pass_through), buf, sectors * SECTOR_SIZE);

}

// Assembly:
subq $0x18, %rsp
movl %ecx, %eax
leaq 0x8(%rsp), %r8
andq $0x0, 0x3(%r8)
andq $0x0, 0x8(%r8)
movq %rsi, %rcx
movb $-0x7b, (%r8)
movw $0xe08, 0x1(%r8)        # imm = 0xE08
movb %ah, 0xd(%rsp)
movb %al, 0x6(%r8)
movb $-0x50, 0xe(%r8)
movb $-0x2b, 0x4(%r8)
movb $-0x3e, 0xc(%r8)
movb $0x4f, 0xa(%r8)
movb %dl, 0x8(%r8)
shll $0x9, %eax
pushq $0x10
popq %rdx
movq %r8, %rsi
movl %eax, %r8d
callq 0x25d9
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/spjmurray[P]nagios-plugin-check-scsi-smart/check_scsi_smart.cc
// Function: check_smart_log(int, int&, int&)
void check_smart_log(int fd, int& code, int& logs) {

  // Read the SMART log directory
  smart_log_directory log_directory;
  ata_smart_read_log_directory(fd, reinterpret_cast<unsigned char*>(&log_directory));

  // Calculate the number of SMART log sectors to read and allocate a buffer
  uint16_t smart_log_sectors = StorageEndian::swap(log_directory.data_blocks[ATA_LOG_ADDRESS_SMART]);
  if(!smart_log_sectors)
    return;

  smart_log_summary* summaries = new smart_log_summary[smart_log_sectors];

  // Read the logs in
  ata_smart_read_log(fd, reinterpret_cast<unsigned char*>(summaries), ATA_LOG_ADDRESS_SMART, smart_log_sectors);

  // Check for any logged errors
  for(int i=0; i<smart_log_sectors; i++) {

    // If the index is zero there are no entries
    if(!StorageEndian::swap(summaries[i].index))
      continue;

    logs += StorageEndian::swap(summaries[i].count);

  }

  if(logs)
    code = max(code, NAGIOS_WARNING);

  delete [] summaries;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %r13d
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x2788
movzwl 0x2(%rbx), %ebx
testq %rbx, %rbx
je 0x2a18
movq %r15, (%rsp)
movl %ebx, %r12d
shll $0x9, %r12d
movq %r12, %rdi
callq 0x2030
movq %rax, %r15
pushq $0x1
popq %rbp
movl %r13d, %edi
movq %rax, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x272f
movl (%r14), %eax
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0x29fe
cmpb $0x0, 0x1(%r15,%rcx)
je 0x29f5
movzwl 0x1c4(%r15,%rcx), %edx
addl %edx, %eax
movl %eax, (%r14)
addq $0x200, %rcx            # imm = 0x200
jmp 0x29da
testl %eax, %eax
je 0x2a10
movq (%rsp), %rcx
movl (%rcx), %eax
cmpl $0x2, %eax
cmovgel %eax, %ebp
movl %ebp, (%rcx)
movq %r15, %rdi
callq 0x21d0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/spjmurray[P]nagios-plugin-check-scsi-smart/smart.cc
// Function: SmartAttribute::SmartAttribute(smart_attribute const&)
SmartAttribute::SmartAttribute(const smart_attribute& attribute)
: id(StorageEndian::swap(attribute.id)),
  pre_fail(StorageEndian::swap(attribute.flags) & 0x1),
  offline(StorageEndian::swap(attribute.flags) & 0x2),
  value(StorageEndian::swap(attribute.value)),
  raw((static_cast<uint64_t>(StorageEndian::swap(attribute.raw_hi)) << 32) |
       static_cast<uint64_t>(StorageEndian::swap(attribute.raw_lo))) {

  // Logic shamelessly lifted from smartmontools
  switch(id) {
    case 3:   // Spin up time
    case 5:   // Reallocated sector count
    case 196: // Reallocated event count
      raw &= 0xffff;
      break;
    case 9:   // Power on hours
    case 240: // Head flying hours
      raw &= 0xffffff;
      break;
    case 190: // Temperature
    case 194: // Temperature
      raw &= 0xff;
      break;
    default:
      break;
  }

}

// Assembly:
movzbl (%rsi), %ecx
movb %cl, (%rdi)
movb 0x1(%rsi), %al
movl %eax, %edx
andb $0x1, %dl
movb %dl, 0x1(%rdi)
shrb %al
andb $0x1, %al
movb %al, 0x2(%rdi)
movb 0x3(%rsi), %al
movb %al, 0x3(%rdi)
movzwl 0x9(%rsi), %edx
shlq $0x20, %rdx
movl 0x5(%rsi), %eax
orq %rax, %rdx
movq %rdx, 0x8(%rdi)
movl $0xffff, %edx           # imm = 0xFFFF
cmpl $0x3, %ecx
je 0x381f
cmpl $0x5, %ecx
je 0x381f
cmpl $0xf0, %ecx
je 0x3813
cmpl $0xbe, %ecx
je 0x381a
cmpl $0xc2, %ecx
je 0x381a
cmpl $0xc4, %ecx
je 0x381f
cmpl $0x9, %ecx
jne 0x3825
movl $0xffffff, %edx         # imm = 0xFFFFFF
jmp 0x381f
movl $0xff, %edx
andl %eax, %edx
movq %rdx, 0x8(%rdi)
retq