LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5e91
cmpl $0x2, %eax
je 0x5e84
cmpl $0x1, %eax
jne 0x5ecd
movq (%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x60d6
movq 0x8(%rbx), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5126
movq 0x6140(%rip), %r14      # 0xbfd8
leaq 0x2803(%rip), %rsi      # 0x86a2
movl $0x2, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x10(%rbx), %rdi
callq 0x5a48
leaq 0x27e9(%rip), %rsi      # 0x86a5
movl $0x2, %edx
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21d0
movq 0x6104(%rip), %rbx      # 0xbfd8
leaq 0x27cd(%rip), %rsi      # 0x86a8
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x26c4(%rip), %rsi      # 0x85b6
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/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 0x5f2d
cmpl $0x2, %eax
je 0x5f24
cmpl $0x1, %eax
jne 0x5f36
movq (%rdi), %rdi
jmp 0x60ee
movq 0x8(%rdi), %rdi
jmp 0x513e
movq 0x10(%rdi), %rdi
jmp 0x5ae6
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x6095(%rip), %rbx      # 0xbfd8
leaq 0x277c(%rip), %rsi      # 0x86c6
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x2655(%rip), %rsi      # 0x85b6
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/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 0x3c70
movq %rax, %r14
movq %rax, %rdi
callq 0x3fac
leaq 0x2384(%rip), %rcx      # 0x8320
cmpl (%rcx), %eax
jne 0x5fd1
movl $0x1, 0x18(%rbx)
movl $0x28, %edi
callq 0x2190
movq %rax, %r14
movq %rax, %rdi
callq 0x60bc
movq %r14, (%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x60f8
leaq 0x234c(%rip), %rcx      # 0x8324
cmpl (%rcx), %eax
jne 0x5ff7
movl $0x2, 0x18(%rbx)
callq 0x4f38
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x14, %eax
jne 0x604b
movl $0x3, 0x18(%rbx)
movq %r14, %rdi
callq 0x3da6
movl $0x18, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x5a34
movq %r15, 0x10(%rbx)
movq %r15, %rdi
callq 0x5b8e
movq %r14, %rdi
callq 0x3fac
cmpl $0x15, %eax
jne 0x605b
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3da6
movq 0x5f86(%rip), %rbx      # 0xbfd8
leaq 0x26bf(%rip), %rsi      # 0x8718
jmp 0x6069
movq 0x5f76(%rip), %rbx      # 0xbfd8
leaq 0x267a(%rip), %rsi      # 0x86e3
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x209a(%rip), %rsi      # 0x811a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
jmp 0x60af
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c70
movq %rax, %r14
movq %rax, %rdi
callq 0x3fac
leaq 0x2201(%rip), %rcx      # 0x8320
cmpl (%rcx), %eax
jne 0x6173
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cc4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2200
movq (%r15), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x6155
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq (%rbx), %rdi
callq 0x2260
movl %eax, 0x20(%rbx)
movq %r14, %rdi
callq 0x3da6
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5e5e(%rip), %rbx      # 0xbfd8
leaq 0x25b7(%rip), %rsi      # 0x8738
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1f82(%rip), %rsi      # 0x811a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Loop.cpp
// Function: Loop::PrintLoop(int)
void Loop::PrintLoop(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "while ";
  cond->PrintCond();
  cout << " loop" << endl;
  stmtSeq->PrintStmtSeq(level+1);
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  
  cout << "end;" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
testl %esi, %esi
jle 0x61fd
movq 0x5dfa(%rip), %r14      # 0xbfd8
leaq 0x2209(%rip), %r12      # 0x83ee
movl %ebx, %r13d
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r13d
jne 0x61e8
movq 0x5dd4(%rip), %r14      # 0xbfd8
leaq 0x254f(%rip), %rsi      # 0x875a
movl $0x6, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r15), %rdi
callq 0x70e0
leaq 0x253a(%rip), %rsi      # 0x8761
movl $0x5, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x8(%r15), %rdi
leal 0x1(%rbx), %esi
callq 0x4b90
testl %ebx, %ebx
jle 0x628d
movq 0x5d66(%rip), %r15      # 0xbfd8
leaq 0x2175(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %ebx
jne 0x6279
leaq 0x24d3(%rip), %rsi      # 0x8767
movl $0x4, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Input.cpp
// Function: Input::PrintInput(int)
void Input::PrintInput(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "read ";
  idList->PrintIdList();
  cout << ";" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x6656
movl %esi, %r14d
movq 0x599e(%rip), %r15      # 0xbfd8
leaq 0x1dad(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r14d
jne 0x6641
movq 0x597b(%rip), %r14      # 0xbfd8
leaq 0x21a4(%rip), %rsi      # 0x8808
movl $0x5, %edx
movq %r14, %rdi
callq 0x21d0
movq (%rbx), %rdi
callq 0x4cc8
leaq 0x20ea(%rip), %rsi      # 0x876a
movl $0x1, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/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 0x3c70
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3cc4
leaq 0x2110(%rip), %rsi      # 0x880e
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
jne 0x67aa
movq %rbx, %rdi
callq 0x3da6
movl $0x10, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x4cbc
movq %r15, (%r14)
movq %r15, %rdi
callq 0x4d4c
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x3cc4
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %r14
movq %r14, %rsi
callq 0x2200
movq (%r14), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x676a
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq 0x1ff9(%rip), %rsi      # 0x876a
leaq -0x38(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x67f4
movq %rbx, %rdi
callq 0x3da6
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x679f
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x5827(%rip), %rdi      # 0xbfd8
leaq 0x209e(%rip), %rsi      # 0x8856
movl $0x45, %edx
callq 0x21d0
movq 0x580f(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x5803(%rip), %rdi      # 0xbfd8
leaq 0x193e(%rip), %rsi      # 0x811a
movl $0x10, %edx
callq 0x21d0
movq 0x57eb(%rip), %rdi      # 0xbfd8
callq 0x20c0
jmp 0x683c
movq 0x57dd(%rip), %rdi      # 0xbfd8
leaq 0x2011(%rip), %rsi      # 0x8813
movl $0x42, %edx
callq 0x21d0
movq 0x57c5(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x57b9(%rip), %rdi      # 0xbfd8
leaq 0x18f4(%rip), %rsi      # 0x811a
movl $0x10, %edx
callq 0x21d0
movq 0x57a1(%rip), %rdi      # 0xbfd8
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
jmp 0x6857
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x21a0
jmp 0x685a
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6873
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/Output.cpp
// Function: Output::PrintOutput(int)
void Output::PrintOutput(int level){
  for (int i = 0; i < level; i++){
    cout << "\t";
  }
  cout << "write ";
  idList->PrintIdList();
  cout << ";" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x68c2
movl %esi, %r14d
movq 0x5732(%rip), %r15      # 0xbfd8
leaq 0x1b41(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r14d
jne 0x68ad
movq 0x570f(%rip), %r14      # 0xbfd8
leaq 0x1fcc(%rip), %rsi      # 0x889c
movl $0x6, %edx
movq %r14, %rdi
callq 0x21d0
movq (%rbx), %rdi
callq 0x4cc8
leaq 0x1e7e(%rip), %rsi      # 0x876a
movl $0x1, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/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 0x3c70
movq %rax, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3cc4
leaq 0x1752(%rip), %rsi      # 0x80b6
movq %r15, %rdi
callq 0x2090
testl %eax, %eax
jne 0x6a10
movq %rbx, %rdi
callq 0x3da6
movl $0x10, %edi
callq 0x2190
movq %rax, %r15
movq %rax, %rdi
callq 0x4cbc
movq %r15, (%r14)
movq %r15, %rdi
callq 0x4d4c
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x3cc4
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %r14
movq %r14, %rsi
callq 0x2200
movq (%r14), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x69d0
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21a0
leaq 0x1d93(%rip), %rsi      # 0x876a
leaq -0x38(%rbp), %rdi
callq 0x2090
testl %eax, %eax
jne 0x6a5a
movq %rbx, %rdi
callq 0x3da6
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6a05
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x55c1(%rip), %rdi      # 0xbfd8
leaq 0x1ebd(%rip), %rsi      # 0x88db
movl $0x27, %edx
callq 0x21d0
movq 0x55a9(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x559d(%rip), %rdi      # 0xbfd8
leaq 0x1754(%rip), %rsi      # 0x8196
movl $0x10, %edx
callq 0x21d0
movq 0x5585(%rip), %rdi      # 0xbfd8
callq 0x20c0
jmp 0x6aa2
movq 0x5577(%rip), %rdi      # 0xbfd8
leaq 0x1e3b(%rip), %rsi      # 0x88a3
movl $0x37, %edx
callq 0x21d0
movq 0x555f(%rip), %rdi      # 0xbfd8
callq 0x20c0
movq 0x5553(%rip), %rdi      # 0xbfd8
leaq 0x170a(%rip), %rsi      # 0x8196
movl $0x10, %edx
callq 0x21d0
movq 0x553b(%rip), %rdi      # 0xbfd8
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
jmp 0x6abd
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x21a0
jmp 0x6ac0
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ad9
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22a0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %r15
testl %esi, %esi
jle 0x6b39
movq 0x54be(%rip), %r14      # 0xbfd8
leaq 0x18cd(%rip), %r12      # 0x83ee
movl %ebx, %r13d
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r13d
jne 0x6b24
movq 0x5498(%rip), %r14      # 0xbfd8
leaq 0x1dbc(%rip), %rsi      # 0x8903
movl $0x3, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r15), %rdi
callq 0x70e0
leaq 0x1da4(%rip), %rsi      # 0x8907
movl $0x5, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %r15, %r14
movq 0x8(%r15), %rdi
leal 0x1(%rbx), %esi
movl %esi, -0x2c(%rbp)
callq 0x4b90
testl %ebx, %ebx
jle 0x6bd3
movq 0x5424(%rip), %r13      # 0xbfd8
leaq 0x1833(%rip), %r12      # 0x83ee
movl %ebx, %r15d
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x21d0
decl %r15d
jne 0x6bbe
movq %r14, %r15
cmpq $0x0, 0x10(%r14)
movq 0x53f6(%rip), %r14      # 0xbfd8
je 0x6c51
leaq 0x1845(%rip), %rsi      # 0x8430
movl $0x4, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x10(%r15), %rdi
movl -0x2c(%rbp), %esi
callq 0x4b90
testl %ebx, %ebx
jle 0x6c51
movq 0x53a2(%rip), %r15      # 0xbfd8
leaq 0x17b1(%rip), %r12      # 0x83ee
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
decl %ebx
jne 0x6c3d
leaq 0x1b0f(%rip), %rsi      # 0x8767
movl $0x4, %edx
movq %r14, %rdi
callq 0x21d0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7206
testb %al, %al
je 0x6cb5
movq 0x8(%rbx), %rdi
jmp 0x6cbe
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x6cc9
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4bb4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4ee4(%rip), %r14      # 0xbfd8
leaq 0xfc8(%rip), %r15       # 0x80c3
movl 0x18(%rbx), %eax
cmpl $0x2, %eax
jne 0x7119
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21d0
movq 0x8(%rbx), %rbx
jmp 0x70fb
cmpl $0x4, %eax
je 0x716b
cmpl $0x3, %eax
je 0x713e
cmpl $0x1, %eax
jne 0x71ca
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7650
movq 0x4e93(%rip), %r14      # 0xbfd8
leaq 0x1839(%rip), %rsi      # 0x8985
movl $0x2, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rdi
callq 0x70e0
leaq 0x181f(%rip), %rsi      # 0x8988
jmp 0x7196
movq 0x4e66(%rip), %r14      # 0xbfd8
leaq 0x180c(%rip), %rsi      # 0x8985
movl $0x2, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x8(%rbx), %rdi
callq 0x70e0
leaq 0x17fa(%rip), %rsi      # 0x8990
movl $0x4, %edx
movq %r14, %rdi
callq 0x21d0
movq 0x10(%rbx), %rdi
callq 0x70e0
leaq 0x17da(%rip), %rsi      # 0x898d
movl $0x2, %edx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
movq 0x4e07(%rip), %rbx      # 0xbfd8
leaq 0x17bd(%rip), %rsi      # 0x8995
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0xf2b(%rip), %rsi       # 0x811a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/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 %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
movl 0x18(%r14), %eax
cmpl $0x4, %eax
jne 0x722e
movq 0x8(%r14), %rdi
callq 0x7206
testb %al, %al
jne 0x7272
movq 0x10(%r14), %r14
jmp 0x7212
cmpl $0x3, %eax
je 0x7250
cmpl $0x2, %eax
jne 0x7241
movq 0x8(%r14), %r14
xorb $0x1, %bl
jmp 0x7212
cmpl $0x1, %eax
jne 0x7280
movq (%r14), %rdi
callq 0x7768
jmp 0x7274
movq 0x8(%r14), %rdi
callq 0x7206
testb %al, %al
je 0x726e
movq 0x10(%r14), %rdi
callq 0x7206
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x7274
xorl %eax, %eax
jmp 0x7274
movb $0x1, %al
xorb %al, %bl
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x4d51(%rip), %rbx      # 0xbfd8
leaq 0x1729(%rip), %rsi      # 0x89b7
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0xe75(%rip), %rsi       # 0x811a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4978(%rip), %rdi      # 0xbfd8
leaq 0x103b(%rip), %rsi      # 0x86a2
movl $0x2, %edx
callq 0x21d0
movq (%rbx), %rdi
callq 0x5e5c
movl 0x10(%rbx), %eax
decl %eax
cmpl $0x5, %eax
ja 0x772b
leaq 0x139e(%rip), %rcx      # 0x8a2c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x493a(%rip), %rdi      # 0xbfd8
leaq 0x13b7(%rip), %rsi      # 0x8a5c
jmp 0x76fa
movq 0x492a(%rip), %rdi      # 0xbfd8
leaq 0x13b9(%rip), %rsi      # 0x8a6e
jmp 0x76fa
movq 0x491a(%rip), %rdi      # 0xbfd8
leaq 0x13a1(%rip), %rsi      # 0x8a66
jmp 0x76d5
movq 0x490a(%rip), %rdi      # 0xbfd8
leaq 0x1395(%rip), %rsi      # 0x8a6a
movl $0x3, %edx
jmp 0x76ff
movq 0x48f5(%rip), %rdi      # 0xbfd8
leaq 0x1377(%rip), %rsi      # 0x8a61
jmp 0x76fa
movq 0x48e5(%rip), %rdi      # 0xbfd8
leaq 0x1379(%rip), %rsi      # 0x8a73
movl $0x4, %edx
callq 0x21d0
movq 0x8(%rbx), %rdi
callq 0x5e5c
movq 0x48c4(%rip), %rdi      # 0xbfd8
leaq 0xf8a(%rip), %rsi       # 0x86a5
movl $0x2, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21d0
movq 0x48a6(%rip), %rbx      # 0xbfd8
leaq 0x133f(%rip), %rsi      # 0x8a78
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0xa46(%rip), %rsi       # 0x8196
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/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 0x783e
movq %rdi, %rbx
leaq 0x12bd(%rip), %rcx      # 0x8a44
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x5f0a
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5f0a
cmpl %eax, %r14d
setne %al
jmp 0x7839
movq (%rbx), %rdi
callq 0x5f0a
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5f0a
cmpl %eax, %r14d
setle %al
jmp 0x7839
movq (%rbx), %rdi
callq 0x5f0a
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5f0a
cmpl %eax, %r14d
setl %al
jmp 0x7839
movq (%rbx), %rdi
callq 0x5f0a
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5f0a
cmpl %eax, %r14d
setg %al
jmp 0x7839
movq (%rbx), %rdi
callq 0x5f0a
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5f0a
cmpl %eax, %r14d
sete %al
jmp 0x7839
movq (%rbx), %rdi
callq 0x5f0a
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x5f0a
cmpl %eax, %r14d
setge %al
popq %rbx
popq %r14
popq %rbp
retq
movq 0x4793(%rip), %rbx      # 0xbfd8
leaq 0x1254(%rip), %rsi      # 0x8aa0
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x8b7(%rip), %rsi       # 0x811a
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4200
testl %eax, %eax
js 0x4911
cmpb $0x0, 0x60(%rsp)
sete %al
addq $0x78, %rsp
retq
movq 0x46d0(%rip), %rdi      # 0x8fe8
leaq 0x18c8(%rip), %rsi      # 0x61e7
callq 0x4180
movq %rax, %rdi
callq 0x40b0
movl $0x3, %edi
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rsi, %rcx
xorl %r8d, %r8d
leaq 0x8(%rsp), %rsi
movq %r8, 0x3(%rsi)
movq %r8, 0x8(%rsi)
movb $-0x7b, (%rsi)
movw $0xe08, 0x1(%rsi)       # imm = 0xE08
movb %ah, 0xd(%rsp)
movb %al, 0x6(%rsi)
movb $-0x50, 0xe(%rsi)
movb $-0x2b, 0x4(%rsi)
movb $-0x3e, 0xc(%rsi)
movb $0x4f, 0xa(%rsi)
movb %dl, 0x8(%rsi)
shll $0x9, %eax
movl $0x10, %edx
movl %eax, %r8d
callq 0x48aa
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x218, %rsp            # imm = 0x218
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, 0x3(%rsi)
movq %rax, 0x8(%rsi)
movb $-0x7b, (%rsi)
movw $0xe08, 0x1(%rsi)       # imm = 0xE08
movb $0x1, 0x6(%rsi)
movb $-0x50, 0xe(%rsi)
movb $-0x2b, 0x4(%rsi)
movb $-0x3e, 0xc(%rsi)
movb $0x4f, 0xa(%rsi)
leaq 0x18(%rsp), %r15
movl $0x10, %edx
movq %r15, %rcx
movl $0x200, %r8d            # imm = 0x200
callq 0x48aa
movzwl 0x2(%r15), %r13d
testq %r13, %r13
je 0x4de5
movl %r13d, %r12d
shll $0x9, %r12d
movq %r12, %rdi
callq 0x4030
movq %rax, %r15
movl %ebp, %edi
movq %rax, %rsi
movl $0x1, %edx
movl %r13d, %ecx
callq 0x4a02
movl (%r14), %eax
xorl %ecx, %ecx
cmpb $0x0, 0x1(%r15,%rcx)
je 0x4dbe
movzwl 0x1c4(%r15,%rcx), %edx
addl %edx, %eax
movl %eax, (%r14)
addq $0x200, %rcx            # imm = 0x200
cmpq %rcx, %r12
jne 0x4da8
testl %eax, %eax
je 0x4ddd
movl (%rbx), %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movl %ecx, (%rbx)
movq %r15, %rdi
callq 0x41e0
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0xbd, %ecx
jle 0x5ea7
cmpl $0xc3, %ecx
jg 0x5eb7
cmpl $0xbe, %ecx
je 0x5ea0
cmpl $0xc2, %ecx
jne 0x5eb6
movl $0xff, %edx
jmp 0x5ecc
cmpl $0x3, %ecx
je 0x5ecc
cmpl $0x5, %ecx
je 0x5ecc
cmpl $0x9, %ecx
je 0x5ec7
retq
cmpl $0xc4, %ecx
je 0x5ecc
cmpl $0xf0, %ecx
jne 0x5eb6
movl $0xffffff, %edx         # imm = 0xFFFFFF
andl %eax, %edx
movq %rdx, 0x8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/willprice[P]parallel-cpp-workshop/include/filecounter.h
// Function: filecounter::count_lines(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int count_lines(const std::string &filename)
{
    std::ifstream file( filename );

    int nlines = 0;

    std::string str;
    while (std::getline(file, str))
    {
        nlines += 1;
    }

    return nlines;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x1140
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
xorl %ebx, %ebx
movq %rsp, %r15
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1170
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1372
incl %ebx
jmp 0x133c
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1388
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1100
leaq 0x20(%rsp), %rdi
callq 0x1040
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13bc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1100
leaq 0x20(%rsp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/willprice[P]parallel-cpp-workshop/include/filecounter.h
// Function: filecounter::get_arguments[abi:cxx11](int, char**)
std::vector<std::string> get_arguments(int argc, char **argv)
{
    if (argc < 2)
    {
        return std::vector<std::string>();
    }

    auto args = std::vector<std::string>(argc-1);

    for (int i=1; i<argc; ++i)
    {
        args[i-1] = argv[i];
    }

    return args;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
cmpl $0x1, %esi
jg 0x13f7
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
jmp 0x1463
movq %rdx, %r14
movl %esi, %r15d
leal -0x1(%r15), %esi
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0x17cc
movl %r15d, %eax
addq $0x8, %r14
shlq $0x5, %rax
addq $-0x20, %rax
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
movq (%r14), %r15
movq %r12, %rbp
movq (%r12), %r12
movq 0x8(%r12,%rbx), %r13
addq %rbx, %r12
movq %r15, %rdi
callq 0x1060
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x1130
addq $0x8, %r14
addq $0x20, %rbx
cmpq %rbx, 0x10(%rsp)
movq %rbp, %r12
jne 0x1424
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbp, %rdi
callq 0x1858
movq %r14, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/willprice[P]parallel-cpp-workshop/countlines.cpp
// Function: main
int main(int argc, char** argv) {
    auto file_paths = get_arguments(argc, argv);
    auto line_counts = map(count_lines, file_paths);
    auto total_line_count = reduce([](int a, int b) { return a + b; }, line_counts);
    std::cout << "Total line count: " << total_line_count << std::endl;
    for (int i = 0; i < file_paths.size(); i++) {
        std::cout << file_paths[i] << ": " << line_counts[i] << std::endl;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movl %edi, %esi
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x13ce
leaq -0x340(%rip), %rsi      # 0x12fc
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x192c
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x1676
movl (%rax), %ebx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq $0x2, %rcx
jb 0x1678
movl $0x1, %edx
addl (%rax,%rdx,4), %ebx
incq %rdx
cmpq %rdx, %rcx
jne 0x1669
jmp 0x1678
xorl %ebx, %ebx
movq 0x2959(%rip), %rdi      # 0x3fd8
leaq 0x9ba(%rip), %rsi       # 0x2040
movl $0x12, %edx
callq 0x1110
movq 0x2941(%rip), %rdi      # 0x3fd8
movl %ebx, %esi
callq 0x1150
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
movq 0x18(%rsp), %rax
cmpq %rax, 0x20(%rsp)
je 0x176a
movl $0x8, %r12d
xorl %r13d, %r13d
movq 0x28f0(%rip), %rbx      # 0x3fd8
leaq 0x961(%rip), %r14       # 0x2050
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x1110
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1110
movq (%rsp), %rax
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x1150
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
incq %r13
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r12
cmpq %r13, %rcx
ja 0x16ef
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1780
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
leaq 0x18(%rsp), %rdi
callq 0x1858
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x17ba
jmp 0x17a1
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x17ba
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
leaq 0x18(%rsp), %rdi
callq 0x1858
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/willprice[P]parallel-cpp-workshop/include/part1.h
// Function: auto part1::map<int (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&), std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(int (*)(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&), std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
auto map(FUNC func, const std::vector<ARGS>&... args)
{
    typedef typename std::result_of<FUNC(ARGS...)>::type RETURN_TYPE;

    int nvals=detail::get_min_container_size(args...);

    std::vector<RETURN_TYPE> result(nvals);

    for (size_t i=0; i<nvals; ++i)
    {
        result[i] = func(args[i]...);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdx), %rax
subq (%rdx), %rax
movq %rax, %r13
shlq $0x1b, %r13
shrq $0x5, %rax
movslq %eax, %r12
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r12, %rsi
callq 0x19e0
testq %r13, %r13
je 0x199b
cmpq $0x1, %r12
adcq $0x0, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r14), %rdi
addq %r13, %rdi
callq *%r15
movq 0x10(%rsp), %rcx
movl %eax, (%rcx,%rbp,4)
incq %rbp
addq $0x20, %r13
cmpq %rbp, %r12
jne 0x197c
jmp 0x19a0
movq 0x10(%rsp), %rcx
movq %rcx, (%rbx)
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19d8
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x1160
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/src/test-case/unit.cpp
// Function: testMetricMultipliers(std::ostream&)
bool testMetricMultipliers(std::ostream &log) {
  if (metricMultiplier<fraction, 1, 1>::get() != fraction(10)) {
    log << "metric multiplier <1,1> is "
        << metricMultiplier<fraction, 1, 1>::get()
        << " but should have been 10/1\n";
    return false;
  }

  if (metricMultiplier<fraction, 1, 2>::get() != fraction(100)) {
    log << "metric multiplier <1,2> is "
        << metricMultiplier<fraction, 1, 2>::get()
        << " but should have been 100/1\n";
    return false;
  }

  if (metricMultiplier<fraction, 0, 2>::get() != fraction(1)) {
    log << "metric multiplier <0,2> is "
        << metricMultiplier<fraction, 0, 2>::get()
        << " but should have been 1/1\n";
    return false;
  }

  if (metricMultiplier<fraction, 3, 2>::get() != fraction(1000000)) {
    log << "metric multiplier <3,2> is "
        << metricMultiplier<fraction, 3, 2>::get()
        << " but should have been 1000000/1\n";
    return false;
  }

  if (metricMultiplier<fraction, 3, 3>::get() != fraction(1000000000)) {
    log << "metric multiplier <3,3> is "
        << metricMultiplier<fraction, 3, 3>::get()
        << " but should have been 1000000000/1\n";
    return false;
  }

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq $0x64, (%r14)
movq $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x13d6a
cmpq $0x64, (%r14)
jne 0x4f59
cmpq $0x1, 0x8(%rsp)
jne 0x4f59
movq %rsp, %rdi
movq $0xa, (%rdi)
movq $0x1, 0x8(%rdi)
callq 0x13d30
xorq $0xf4240, %rax          # imm = 0xF4240
xorq $0x1, %rdx
orq %rax, %rdx
jne 0x4fa8
movq %rsp, %rdi
movq $0xa, (%rdi)
movq $0x1, 0x8(%rdi)
callq 0x13df0
movq %rax, %rcx
xorq $0x3b9aca00, %rcx       # imm = 0x3B9ACA00
xorq $0x1, %rdx
movb $0x1, %al
orq %rcx, %rdx
je 0x4ffe
leaq 0x104ec(%rip), %rsi     # 0x153fb
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x42b0
movq %rsp, %r14
movq $0xa, (%r14)
movq $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x13df0
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5755
leaq 0x104c8(%rip), %rsi     # 0x15417
movl $0x23, %edx
jmp 0x4ff4
leaq 0x10425(%rip), %rsi     # 0x15385
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x42b0
movq %rsp, %r14
movq $0x64, (%r14)
movq $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x13d6a
movaps (%r14), %xmm0
movaps %xmm0, (%r14)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5755
leaq 0x10400(%rip), %rsi     # 0x153a1
movl $0x1c, %edx
jmp 0x4ff4
leaq 0x1040f(%rip), %rsi     # 0x153be
movl $0x1b, %edx
movq %rbx, %rdi
callq 0x42b0
movq %rsp, %r14
movq $0xa, (%r14)
movq $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x13d30
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5755
leaq 0x103eb(%rip), %rsi     # 0x153da
movl $0x20, %edx
movq %rax, %rdi
callq 0x42b0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/src/test-case/unit.cpp
// Function: testUnitEMetric(std::ostream&)
bool testUnitEMetric(std::ostream &log) {
  second<fraction, 2>::unit s2_5_7(fraction(5, 7));

  if (fraction(5, 7) != fraction(s2_5_7)) {
    log << "variable was not initialised to the expected value\n";
    return false;
  }

  second<fraction, 2>::milli ms2_5_7 = s2_5_7;

  if (fraction(5000000, 7) != ms2_5_7) {
    log << "variable was not converted to the expected value\n";
    return false;
  }

  second<fraction, -2>::unit si2_5_7(fraction(5, 7));

  if (fraction(5, 7) != fraction(si2_5_7)) {
    log << "variable was not initialised to the expected value\n";
    return false;
  }

  second<fraction, -2>::milli msi2_5_7 = si2_5_7;

  if (fraction(5, 7000000) != msi2_5_7) {
    log << "variable was not converted to the expected value\n";
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x5, %r15d
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movl $0x7, %ebp
movq %rbp, 0x8(%r14)
movq %r14, %rdi
callq 0x13d6a
movq (%r14), %r12
movq 0x8(%r14), %r13
movq %r15, (%r14)
movq %rbp, 0x8(%r14)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x13d6a
cmpq %r12, (%r14)
jne 0x5147
cmpq %r13, 0x10(%rsp)
jne 0x5147
leaq 0x8(%rsp), %r15
movq %r12, (%r15)
movq %r13, 0x8(%r15)
movq %r15, %rdi
callq 0x13eaa
movq %rax, %r12
movq %rdx, %r14
movq $0x4c4b40, (%r15)       # imm = 0x4C4B40
movq $0x7, 0x8(%r15)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x13d6a
cmpq %r12, (%r15)
jne 0x5139
cmpq %r14, 0x10(%rsp)
jne 0x5139
movl $0x5, %r15d
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movl $0x7, %ebp
movq %rbp, 0x8(%r14)
movq %r14, %rdi
callq 0x13d6a
movq (%r14), %r12
movq 0x8(%r14), %r13
movq %r15, (%r14)
movq %rbp, 0x8(%r14)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x13d6a
cmpq %r12, (%r14)
jne 0x5147
cmpq %r13, 0x10(%rsp)
jne 0x5147
leaq 0x8(%rsp), %r15
movq %r12, (%r15)
movq %r13, 0x8(%r15)
movq %r15, %rdi
callq 0x13efc
movq %rax, %r12
movq %rdx, %r14
movq $0x5, (%r15)
movq $0x6acfc0, 0x8(%r15)    # imm = 0x6ACFC0
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x13d6a
cmpq %r12, (%r15)
jne 0x5139
movb $0x1, %al
cmpq %r14, 0x10(%rsp)
je 0x515d
leaq 0x1032f(%rip), %rsi     # 0x1546f
movl $0x31, %edx
jmp 0x5153
leaq 0x102ed(%rip), %rsi     # 0x1543b
movl $0x33, %edx
movq %rbx, %rdi
callq 0x42b0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/include/ef.gy/units.h
// Function: efgy::unit::exponentialScaledUnitValue<efgy::unit::unitValue<efgy::math::numeric::fractional<long long>, (char)109, 1>, -3, efgy::unit::metricMultiplier>::convert(efgy::math::numeric::fractional<long long> const&)
static base convert(const base &value) {
    return ((exponent * unitExponent) <= 0) ? value * multiplier < base,
           exponent < 0 ? -exponent : exponent,
           unitExponent < 0 ? -unitExponent : unitExponent > ::get()
                                            : value / multiplier < base,
           exponent < 0 ? -exponent : exponent,
           unitExponent < 0 ? -unitExponent : unitExponent > ::get();
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0xa, (%r14)
movq $0x1, 0x8(%r14)
movq %r14, %rdi
callq 0x13c2c
imulq (%rbx), %rax
imulq 0x8(%rbx), %rdx
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x13d6a
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq