LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalComparison()
AbstractExpressionNode* evalComparison() {

  AbstractExpressionNode* head = evalBitShift();
  AbstractExpressionNode* next;

  while(isInequalityTokenType(peek()->type)) {
    ParseOperatorType op = binaryTokenConversion(consume()->type);
    next = evalBitShift();

    if(typecheckComparisonExpression(op, head->evalType, next->evalType)) {
      head = new ComparisonOperatorNode(op, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), toWordParseOperatorType(op), head->evalType, next->evalType); 
    }
  }
  
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x1c439
movq %rax, %rbx
callq 0x1781b
movl (%rax), %edi
callq 0x63eb
testb %al, %al
je 0x1c5e9
callq 0x177cc
movl (%rax), %edi
callq 0x815d
movl %eax, %r15d
callq 0x1c439
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r15d, %edi
callq 0x16239
testb %al, %al
je 0x1c5fb
movl $0x30, %edi
callq 0x4210
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8e9c
movq %r12, %rbx
jmp 0x1c58d
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x4110
movq %rax, %r12
movl 0x8(%rbx), %r13d
movl 0xc(%r14), %eax
leal -0x1(%r13), %edi
movq %rax, -0x38(%rbp)
leal -0x1(%rax), %esi
callq 0x17891
movq %rax, -0x30(%rbp)
movl %r15d, %edi
callq 0x81c7
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0xefd6(%rip), %rsi      # 0x2b610
addq $0x10, %rsi
movq %rsi, (%r12)
movw $0x1, 0x8(%r12)
movq -0x30(%rbp), %rsi
movq %rsi, 0x10(%r12)
movq %rax, 0x18(%r12)
movq $0x0, 0x20(%r12)
movl %r13d, 0x28(%r12)
movq -0x38(%rbp), %rax
movl %eax, 0x2c(%r12)
movl %ecx, 0x30(%r12)
movl %edx, 0x34(%r12)
leaq 0xefb8(%rip), %rsi      # 0x2b638
movq 0xf951(%rip), %rdx      # 0x2bfd8
movq %r12, %rdi
callq 0x4350
movq %rax, %rbx
movq %r12, %rdi
callq 0x4190
jmp 0x1c6a7
movq %rax, %rbx
movq %r12, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalEquality()
AbstractExpressionNode* evalEquality() {

  AbstractExpressionNode* head = evalComparison();
  AbstractExpressionNode* next;

  while(isEqualityTokenType(peek()->type)) {
    ParseOperatorType op = binaryTokenConversion(consume()->type);
    next = evalComparison();

    if(typecheckComparisonExpression(op, head->evalType, next->evalType)) {
      head = new ComparisonOperatorNode(op, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), toWordParseOperatorType(op), head->evalType, next->evalType);  
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x1c574
movq %rax, %rbx
callq 0x1781b
movl (%rax), %edi
callq 0x63fa
testb %al, %al
je 0x1c724
callq 0x177cc
movl (%rax), %edi
callq 0x815d
movl %eax, %r15d
callq 0x1c574
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl %r15d, %edi
callq 0x16239
testb %al, %al
je 0x1c736
movl $0x30, %edi
callq 0x4210
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8e9c
movq %r12, %rbx
jmp 0x1c6c8
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x4110
movq %rax, %r12
movl 0x8(%rbx), %r13d
movl 0xc(%r14), %eax
leal -0x1(%r13), %edi
movq %rax, -0x38(%rbp)
leal -0x1(%rax), %esi
callq 0x17891
movq %rax, -0x30(%rbp)
movl %r15d, %edi
callq 0x81c7
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0xee9b(%rip), %rsi      # 0x2b610
addq $0x10, %rsi
movq %rsi, (%r12)
movw $0x1, 0x8(%r12)
movq -0x30(%rbp), %rsi
movq %rsi, 0x10(%r12)
movq %rax, 0x18(%r12)
movq $0x0, 0x20(%r12)
movl %r13d, 0x28(%r12)
movq -0x38(%rbp), %rax
movl %eax, 0x2c(%r12)
movl %ecx, 0x30(%r12)
movl %edx, 0x34(%r12)
leaq 0xee7d(%rip), %rsi      # 0x2b638
movq 0xf816(%rip), %rdx      # 0x2bfd8
movq %r12, %rdi
callq 0x4350
movq %rax, %rbx
movq %r12, %rdi
callq 0x4190
jmp 0x1c7e2
movq %rax, %rbx
movq %r12, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalBitAnd()
AbstractExpressionNode* evalBitAnd() {

  AbstractExpressionNode* head = evalEquality();
  AbstractExpressionNode* next;

  while(peek()->type == BIT_AND) {
    consume();
    next = evalEquality();

    if(typecheckBitLogicalExpression(BIT_AND_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(BIT_AND_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "bitwise AND", head->evalType, next->evalType); 
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1c6af
movq %rax, %rbx
callq 0x1781b
cmpl $0x17, (%rax)
jne 0x1c850
callq 0x177cc
callq 0x1c6af
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl $0x19, %edi
callq 0x161d9
testb %al, %al
je 0x1c862
movl $0x30, %edi
callq 0x4210
movq %rax, %r15
movq %rax, %rdi
movl $0x19, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8e3e
movq %r15, %rbx
jmp 0x1c800
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x17891
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0xed7d(%rip), %rsi      # 0x2b610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x2682(%rip), %rax      # 0x1ef2e
movq %rax, 0x18(%r15)
movq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0xed69(%rip), %rsi      # 0x2b638
movq 0xf702(%rip), %rdx      # 0x2bfd8
movq %r15, %rdi
callq 0x4350
movq %rax, %rbx
movq %r15, %rdi
callq 0x4190
jmp 0x1c8f6
movq %rax, %rbx
movq %r15, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalBitXor()
AbstractExpressionNode* evalBitXor() {

  AbstractExpressionNode* head = evalBitAnd();
  AbstractExpressionNode* next;

  while(peek()->type == BIT_XOR) {
    consume();
    next = evalBitAnd();

    if(typecheckBitLogicalExpression(BIT_XOR_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(BIT_XOR_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "bitwise XOR", head->evalType, next->evalType); 
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1c7ea
movq %rax, %rbx
callq 0x1781b
cmpl $0x18, (%rax)
jne 0x1c964
callq 0x177cc
callq 0x1c7ea
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl $0x1a, %edi
callq 0x161d9
testb %al, %al
je 0x1c976
movl $0x30, %edi
callq 0x4210
movq %rax, %r15
movq %rax, %rdi
movl $0x1a, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8e3e
movq %r15, %rbx
jmp 0x1c914
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x17891
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0xec69(%rip), %rsi      # 0x2b610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x257a(%rip), %rax      # 0x1ef3a
movq %rax, 0x18(%r15)
movq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0xec55(%rip), %rsi      # 0x2b638
movq 0xf5ee(%rip), %rdx      # 0x2bfd8
movq %r15, %rdi
callq 0x4350
movq %rax, %rbx
movq %r15, %rdi
callq 0x4190
jmp 0x1ca0a
movq %rax, %rbx
movq %r15, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalBitOr()
AbstractExpressionNode* evalBitOr() {

  AbstractExpressionNode* head = evalBitXor();
  AbstractExpressionNode* next;

  while(peek()->type == BIT_OR) {
    consume();
    next = evalBitXor();

    if(typecheckBitLogicalExpression(BIT_OR_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(BIT_OR_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "bitwise OR", head->evalType, next->evalType);
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1c8fe
movq %rax, %rbx
callq 0x1781b
cmpl $0x19, (%rax)
jne 0x1ca78
callq 0x177cc
callq 0x1c8fe
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl $0x1b, %edi
callq 0x161d9
testb %al, %al
je 0x1ca8a
movl $0x30, %edi
callq 0x4210
movq %rax, %r15
movq %rax, %rdi
movl $0x1b, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8e3e
movq %r15, %rbx
jmp 0x1ca28
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x17891
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0xeb55(%rip), %rsi      # 0x2b610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x2472(%rip), %rax      # 0x1ef46
movq %rax, 0x18(%r15)
movq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0xeb41(%rip), %rsi      # 0x2b638
movq 0xf4da(%rip), %rdx      # 0x2bfd8
movq %r15, %rdi
callq 0x4350
movq %rax, %rbx
movq %r15, %rdi
callq 0x4190
jmp 0x1cb1e
movq %rax, %rbx
movq %r15, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalLogicAnd()
AbstractExpressionNode* evalLogicAnd() {

  AbstractExpressionNode* head = evalBitOr();
  AbstractExpressionNode* next;

  while(peek()->type == AND) {
    consume();
    next = evalBitOr();

    if(typecheckBitLogicalExpression(AND_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(AND_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "logical AND", head->evalType, next->evalType);  
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1ca12
movq %rax, %rbx
callq 0x1781b
cmpl $0x1a, (%rax)
jne 0x1cb8c
callq 0x177cc
callq 0x1ca12
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl $0x1c, %edi
callq 0x161d9
testb %al, %al
je 0x1cb9e
movl $0x30, %edi
callq 0x4210
movq %rax, %r15
movq %rax, %rdi
movl $0x1c, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8e3e
movq %r15, %rbx
jmp 0x1cb3c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x17891
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0xea41(%rip), %rsi      # 0x2b610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x2369(%rip), %rax      # 0x1ef51
movq %rax, 0x18(%r15)
movq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0xea2d(%rip), %rsi      # 0x2b638
movq 0xf3c6(%rip), %rdx      # 0x2bfd8
movq %r15, %rdi
callq 0x4350
movq %rax, %rbx
movq %r15, %rdi
callq 0x4190
jmp 0x1cc32
movq %rax, %rbx
movq %r15, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalLogicXor()
AbstractExpressionNode* evalLogicXor() {

  AbstractExpressionNode* head = evalLogicAnd();
  AbstractExpressionNode* next;

  while(peek()->type == XOR) {
    consume();
    next = evalLogicAnd();

    if(typecheckBitLogicalExpression(XOR_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(XOR_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "logical XOR", head->evalType, next->evalType); 
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1cb26
movq %rax, %rbx
callq 0x1781b
cmpl $0x1b, (%rax)
jne 0x1cca0
callq 0x177cc
callq 0x1cb26
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl $0x1d, %edi
callq 0x161d9
testb %al, %al
je 0x1ccb2
movl $0x30, %edi
callq 0x4210
movq %rax, %r15
movq %rax, %rdi
movl $0x1d, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8e3e
movq %r15, %rbx
jmp 0x1cc50
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x17891
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0xe92d(%rip), %rsi      # 0x2b610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x2261(%rip), %rax      # 0x1ef5d
movq %rax, 0x18(%r15)
movq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0xe919(%rip), %rsi      # 0x2b638
movq 0xf2b2(%rip), %rdx      # 0x2bfd8
movq %r15, %rdi
callq 0x4350
movq %rax, %rbx
movq %r15, %rdi
callq 0x4190
jmp 0x1cd46
movq %rax, %rbx
movq %r15, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: evalLogicOr()
AbstractExpressionNode* evalLogicOr() {

  AbstractExpressionNode* head = evalLogicXor();
  AbstractExpressionNode* next;

  while(peek()->type == OR) {
    consume();
    next = evalLogicXor();

    if(typecheckBitLogicalExpression(OR_OP, head->evalType, next->evalType)) {
      head = new BitLogicalOperatorNode(OR_OP, head, next);
    } else {
      throw StaticTypeError(head->startLine, next->endLine, getCodeLineBlock(head->startLine-1, next->endLine-1), "logical OR", head->evalType, next->evalType);  
    }
  }
 
  return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1cc3a
movq %rax, %rbx
callq 0x1781b
cmpl $0x1c, (%rax)
jne 0x1cdb4
callq 0x177cc
callq 0x1cc3a
movq %rax, %r14
movl 0x10(%rbx), %esi
movl 0x10(%rax), %edx
movl $0x1e, %edi
callq 0x161d9
testb %al, %al
je 0x1cdc6
movl $0x30, %edi
callq 0x4210
movq %rax, %r15
movq %rax, %rdi
movl $0x1e, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x8e3e
movq %r15, %rbx
jmp 0x1cd64
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x4110
movq %rax, %r15
movl 0x8(%rbx), %r12d
movl 0xc(%r14), %r13d
leal -0x1(%r12), %edi
leal -0x1(%r13), %esi
callq 0x17891
movl 0x10(%rbx), %ecx
movl 0x10(%r14), %edx
leaq 0xe819(%rip), %rsi      # 0x2b610
addq $0x10, %rsi
movq %rsi, (%r15)
movw $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
leaq 0x2159(%rip), %rax      # 0x1ef69
movq %rax, 0x18(%r15)
movq $0x0, 0x20(%r15)
movl %r12d, 0x28(%r15)
movl %r13d, 0x2c(%r15)
movl %ecx, 0x30(%r15)
movl %edx, 0x34(%r15)
leaq 0xe805(%rip), %rsi      # 0x2b638
movq 0xf19e(%rip), %rdx      # 0x2bfd8
movq %r15, %rdi
callq 0x4350
movq %rax, %rbx
movq %r15, %rdi
callq 0x4190
jmp 0x1ce5a
movq %rax, %rbx
movq %r15, %rdi
callq 0x41e0
movq %rbx, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/AshOlogn[P]ash-language-interpreter/src/parser.cpp
// Function: parse(std::vector<Token, std::allocator<Token>>*, std::vector<char*, std::allocator<char*>>*)
vector<AbstractStatementNode*>* parse(vector<Token>* tokenRef, vector<char*>* sourceCodeLines) {

  codeLines = sourceCodeLines;

  //set static variables to correct initial values
  tokenIndex = 0;
  tokens = tokenRef;
  symbolTable = new SymbolTable();
	returnFlag = vector<bool*>();
	returnValue = vector<ParseData*>();
	returnType = vector<ParseDataType>();
	insideClassDefinition = false;
  
  //create empty statement vector
  vector<AbstractStatementNode*>* statements = new vector<AbstractStatementNode*>();
  
  //append statement nodes until END is reached
  while(peek()->type != END) {
    statements->push_back(addStatement());
  }
  
  return statements;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0xedfd(%rip)      # 0x2c288
movl $0x0, 0xedeb(%rip)      # 0x2c280
movq %rdi, 0xeddc(%rip)      # 0x2c278
movl $0x10, %edi
callq 0x4210
movq %rax, %rbx
movq %rax, %rdi
callq 0x163ec
movq %rbx, 0xedd8(%rip)      # 0x2c290
movq 0xed71(%rip), %rdi      # 0x2c230
xorps %xmm0, %xmm0
movups %xmm0, 0xed67(%rip)     # 0x2c230
movq $0x0, 0xed6c(%rip) # 0x2c240
testq %rdi, %rdi
je 0x1d4e1
callq 0x41e0
xorps %xmm0, %xmm0
movq 0xed60(%rip), %rdi      # 0x2c248
movups %xmm0, 0xed59(%rip)     # 0x2c248
movq $0x0, 0xed5e(%rip) # 0x2c258
testq %rdi, %rdi
je 0x1d504
callq 0x41e0
movq 0xed55(%rip), %rdi      # 0x2c260
xorps %xmm0, %xmm0
movups %xmm0, 0xed4b(%rip)     # 0x2c260
movq $0x0, 0xed50(%rip) # 0x2c270
testq %rdi, %rdi
je 0x1d52a
callq 0x41e0
movl $0x18, %edi
callq 0x4210
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
callq 0x1781b
cmpl $0x4e, (%rax)
je 0x1d585
leaq -0x18(%rbp), %r14
callq 0x18475
movq %rax, -0x18(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x1d570
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x1d57b
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1da1e
callq 0x1781b
cmpl $0x4e, (%rax)
jne 0x1d553
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4380
// File: /workspace/github_cpp_makefile_star2_O3/vividvilla[P]hackerrank/src/median.cpp
// Function: main
int main() {
    int n;
    long long x;
    char o;
    cin >> n;

    vector<char> ops;
    vector<long long> ints;
    for (int i = 0; i < n; i++) {
        cin >> o >> x;
        ops.push_back(o);
        ints.push_back(x);
    }

    outputMedians(ops, ints);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0x28ea(%rip), %rdi      # 0x3fe0
leaq 0x2c(%rsp), %r14
movq %r14, %rsi
callq 0x10d0
xorl %ebx, %ebx
movq %rbx, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rbx, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
cmpl $0x0, (%r14)
jle 0x180f
movq 0x28b3(%rip), %r14      # 0x3fe0
leaq 0xf(%rsp), %r15
leaq 0x80(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0x30(%rsp), %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x1160
movq %rax, %rdi
movq %r12, %rsi
callq 0x1170
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x1773
movb 0xf(%rsp), %al
movb %al, (%rsi)
incq 0x18(%rsp)
jmp 0x177e
movq %r13, %rdi
movq %r15, %rdx
callq 0x1ae8
movq 0x38(%rsp), %rsi
cmpq 0x40(%rsp), %rsi
je 0x17a0
movq 0x80(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x38(%rsp)
jmp 0x17ab
movq %rbp, %rdi
movq %r12, %rdx
callq 0x1bda
incl %ebx
cmpl 0x2c(%rsp), %ebx
jl 0x1744
movq 0x18(%rsp), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movq $0x0, 0x60(%rsp)
subq 0x10(%rsp), %rbx
je 0x180f
js 0x18ae
movq %rbx, %rdi
callq 0x1120
movq %rax, %r14
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %r15
movq %rax, 0x50(%rsp)
movq %rax, 0x58(%rsp)
addq %rbx, %rax
movq %rax, 0x60(%rsp)
subq %rsi, %r15
je 0x181f
movq %r14, %rdi
movq %r15, %rdx
callq 0x1190
jmp 0x181f
movaps %xmm0, 0x50(%rsp)
movq %rbx, 0x60(%rsp)
xorl %r15d, %r15d
xorl %r14d, %r14d
addq %r14, %r15
movq %r15, 0x58(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1920
leaq 0x50(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x12ec
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x185c
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
testq %r14, %r14
je 0x186c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1130
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1883
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x189a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1070
movq %rax, %r15
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x18d2
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
jmp 0x18d2
movq %rax, %r15
testq %r14, %r14
je 0x18e9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1130
jmp 0x18e9
jmp 0x18e6
movq %rax, %r15
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1900
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1917
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1130
movq %r15, %rdi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/vividvilla[P]hackerrank/src/insertionsort2.cpp
// Function: main
int main() {
    int s, x;
    cin >> s;

    vector<int> ar;
    for (int i = 0; i < s; i++) {
        cin >> x;
        ar.push_back(x);
    }

    outputSteps(ar);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq 0x2c76(%rip), %rdi      # 0x3fe0
leaq 0xc(%rsp), %rbx
movq %rbx, %rsi
callq 0x1060
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl $0x0, (%rbx)
jle 0x13db
xorl %ebp, %ebp
movq 0x2c4a(%rip), %rbx      # 0x3fe0
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1060
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x13c8
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x13d3
movq %r15, %rdi
movq %r14, %rdx
callq 0x14f0
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x13a0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1470
leaq 0x30(%rsp), %rdi
callq 0x125c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x140b
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1422
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1450
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
jmp 0x1450
jmp 0x144d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1467
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1110
nop
// File: /workspace/github_cpp_makefile_star2_O3/jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: MBSearch::storeMem(unsigned short, unsigned short)
unsigned short MBSearch::storeMem(unsigned short addr, unsigned short val)
{
    // NB: writes to an addr always occurs after a read to the same addr, so we never have to consider path branching 
    // or any other recording here. 
    if (addr >= MAX_TRIT)
    { 
	std::cerr << "MBSearch::storeMem called with addr " << addr << " with is outside legal bounds\n";
	throw ILLEGAL_ADDR_EXCEPTION; // program made an illegal reference, which will not fare well with the original interpreter, so abort this branch
    }
    if (addr >= maxAllowedProgLen) 
	throw MAX_APLEN_EXCEPTION;

    mem[addr] = val;
    return 0; 
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpl $0xe6a9, %esi           # imm = 0xE6A9
jae 0x404893
cmpl %ebx, 0x1eb8bd(%rip)    # 0x5f0130
jle 0x4048d2
movzwl %dx, %ebp
addq $0x18, %rdi
leaq 0x4(%rsp), %rsi
movl %ebx, (%rsi)
callq 0x405800
movl %ebp, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq $0x5f3420, %rdi         # imm = 0x5F3420
leaq 0x17d85b(%rip), %rsi    # 0x5820fc
callq 0x4705c0
movzwl %bx, %esi
movq %rax, %rdi
callq 0x470be0
leaq 0x17d869(%rip), %rsi    # 0x582121
movq %rax, %rdi
callq 0x4705c0
movl $0x4, %edi
callq 0x4064f0
movl $0x2b, (%rax)
jmp 0x4048e2
movl $0x4, %edi
callq 0x4064f0
movl $0x2c, (%rax)
leaq 0x1e40c7(%rip), %rsi    # 0x5e89b0
movq %rax, %rdi
xorl %edx, %edx
callq 0x407540
nop
// File: /workspace/github_cpp_makefile_star2_O3/jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: MBSearch::initExec()
void MBSearch::initExec()
{
    Ra = 0;
    Rc = 0; 
    Rd = 0; 
    output = ""; 
    odepth = 0; 
    iStage = STAGE_IFETCH; 
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl %r14d, (%rdi)
movw $0x0, 0x4(%rdi)
addq $0x88, %rdi
movq 0x90(%rbx), %rdx
leaq 0x19b8b8(%rip), %rcx    # 0x5a0532
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x481110
movl %r14d, 0x14(%rbx)
movl %r14d, 0x7c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: MBSearch::dumpProgram(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void MBSearch::dumpProgram(std::string fname)
{
    std::ofstream f(fname.c_str(), std::ios::trunc); 

    for (int i = 0; i <= highestAddrRead; i++) 
    {
	MBMemory::iterator pos = mem.find(i); 
	if (pos == mem.end())
	    f << (char) (encode_op(OP_NOP, i));   // Since these aren't fetched, I could dump anything here
	else
	    f << (char) orig[i]; 
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x8(%rsp), %rdi
movl $0x20, %edx
callq 0x44cfc0
cmpl $0x0, 0x78(%rbx)
js 0x404d90
leaq 0x20(%rbx), %rbp
leaq 0x48(%rbx), %r14
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
leaq 0x4(%rsp), %r12
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x404d07
movq %rbp, %rcx
xorl %edx, %edx
cmpl %r13d, 0x20(%rax)
setb %dl
cmovaeq %rax, %rcx
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x404ce5
cmpq %rbp, %rcx
je 0x404d07
cmpl 0x20(%rcx), %r13d
jae 0x404d66
movzwl %r13w, %eax
movl $0x23, %ecx
subl %eax, %ecx
movslq %ecx, %rax
imulq $-0x51b3bea3, %rax, %rcx # imm = 0xAE4C415D
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x6, %ecx
addl %edx, %ecx
imull $0x5e, %ecx, %ecx
subl %ecx, %eax
leal 0x5e(%rax), %ecx
testl %eax, %eax
movzbl %cl, %ecx
cmovnsl %eax, %ecx
addb $0x21, %cl
movb %cl, 0x4(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x470090
leal 0x1(%r13), %eax
cmpl 0x78(%rbx), %r13d
movl %eax, %r13d
jl 0x404cd9
jmp 0x404d90
movl %r13d, 0x4(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x405800
movb (%rax), %al
movb %al, 0x3(%rsp)
movl $0x1, %edx
movq %r15, %rdi
leaq 0x3(%rsp), %rsi
callq 0x470090
jmp 0x404d53
movq $0x5eb8a8, %rax         # imm = 0x5EB8A8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x44b6d0
leaq 0x100(%rsp), %rdi
callq 0x452600
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x404dd6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x44d670
movq %rbx, %rdi
callq 0x4b1210
// File: /workspace/github_cpp_makefile_star2_O3/jmbjorndalen[P]Malbolge-gen/mbolge-gen.cpp
// Function: printCurOutput(MBSearch*, int)
void printCurOutput(MBSearch *cur, int newline = true)
{
    std::cout << "\r   output from program '" << cur->output << "' "
	      << "maxMemLoc " << cur->maxMemLoc() 
	      << " nFetches " << cur->nFetches << "                     "; 
    if (newline)
	std::cout << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq $0x5f3540, %rbx         # imm = 0x5F3540
leaq 0x17d36e(%rip), %rsi    # 0x582173
movl $0x19, %edx
movq %rbx, %rdi
callq 0x470090
movq 0x88(%r14), %rsi
movq 0x90(%r14), %rdx
movq %rbx, %rdi
callq 0x470090
movq %rax, %r15
leaq 0x17d35b(%rip), %rsi    # 0x58218d
movl $0x2, %edx
movq %rax, %rdi
callq 0x470090
leaq 0x17d34a(%rip), %rsi    # 0x582190
movl $0xa, %edx
movq %r15, %rdi
callq 0x470090
movl 0x78(%r14), %esi
movq %r15, %rdi
callq 0x470960
movq %rax, %r15
leaq 0x17d332(%rip), %rsi    # 0x58219b
movl $0xa, %edx
movq %rax, %rdi
callq 0x470090
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x470960
leaq 0x17d31d(%rip), %rsi    # 0x5821a6
movl $0x15, %edx
movq %rax, %rdi
callq 0x470090
testl %ebp, %ebp
je 0x404ecb
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4511e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x46fb90
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x46f160
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ft-thread.cc
// Function: ft::Thread::Start(int, unsigned int)
void Thread::Start(int priority, uint32_t affinity_mask) {
    assert(!started_);  // Did you call WaitStopped() ?
    pthread_create(&thread_, NULL, &PthreadCallRun, this);

    if (priority > 0) {
        struct sched_param p;
        p.sched_priority = priority;
        pthread_setschedparam(thread_, SCHED_FIFO, &p);
    }

#ifndef __APPLE__
    if (affinity_mask != 0) {
        cpu_set_t cpu_mask;
        CPU_ZERO(&cpu_mask);
        for (int i = 0; i < 32; ++i) {
            if ((affinity_mask & (1<<i)) != 0) {
                CPU_SET(i, &cpu_mask);
            }
        }
        pthread_setaffinity_np(thread_, sizeof(cpu_mask), &cpu_mask);
    }
#endif

    started_ = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
cmpb $0x1, 0x8(%rdi)
je 0x28f2
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq -0x8a(%rip), %rdx       # 0x27c0
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x2350
testl %r15d, %r15d
jle 0x2871
leaq 0x8(%rsp), %rdx
movl %r15d, (%rdx)
movq (%r14), %rdi
movl $0x1, %esi
callq 0x2150
testl %ebp, %ebp
je 0x28e0
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rsp)
movups %xmm0, 0x60(%rsp)
movups %xmm0, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
movups %xmm0, 0x10(%rsp)
movq $0x0, 0x80(%rsp)
xorl %ecx, %ecx
xorl %eax, %eax
movl $0x1, %edx
shlq %cl, %rdx
btl %ecx, %ebp
movl $0x0, %esi
cmovbq %rdx, %rsi
orq %rsi, %rax
incq %rcx
cmpq $0x20, %rcx
jne 0x28ab
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq (%r14), %rdi
movl $0x80, %esi
callq 0x2310
movb $0x1, 0x8(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28ba(%rip), %rdi      # 0x51b3
leaq 0x28bd(%rip), %rsi      # 0x51bd
leaq 0x28c3(%rip), %rcx      # 0x51ca
movl $0x31, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ft-server.cc
// Function: udp_server_init(int)
bool udp_server_init(int port) {
    if ((server_socket = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
        perror("IPv6 enabled ? While reating listen socket");
        return false;
    }
    int opt = 0;   // Unset IPv6-only, in case it is set. Best effort.
    setsockopt(server_socket, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt));

    struct sockaddr_in6 addr = {0};
    addr.sin6_family = AF_INET6;
    addr.sin6_addr = in6addr_any;
    addr.sin6_port = htons(port);
    if (bind(server_socket, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        perror("bind");
        return false;
    }

    fprintf(stderr, "FlaschenTaschen server: ready to listen on %d\n", port);
    return true;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movl $0xa, %edi
movl $0x2, %esi
movl $0x11, %edx
callq 0x2080
movl %eax, 0x5862(%rip)      # 0x8238
testl %eax, %eax
jns 0x29ed
leaq 0x283f(%rip), %rdi      # 0x5220
callq 0x21a0
xorl %ebp, %ebp
jmp 0x2a80
leaq 0x8(%rsp), %rcx
movl $0x0, (%rcx)
movl %eax, %edi
movl $0x29, %esi
movl $0x1a, %edx
movl $0x4, %r8d
callq 0x2330
xorps %xmm0, %xmm0
leaq 0xc(%rsp), %rsi
movups %xmm0, 0x4(%rsi)
movq $0x0, 0x14(%rsi)
movw $0xa, (%rsi)
movq 0x55b1(%rip), %rax      # 0x7fe0
movups (%rax), %xmm0
movups %xmm0, 0x8(%rsi)
movl %ebx, %eax
rolw $0x8, %ax
movw %ax, 0x2(%rsi)
movl 0x57f2(%rip), %edi      # 0x8238
movl $0x1c, %edx
callq 0x2070
testl %eax, %eax
setns %bpl
js 0x2a74
movq 0x5579(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
leaq 0x27e7(%rip), %rsi      # 0x5250
movl %ebx, %edx
xorl %eax, %eax
callq 0x2290
jmp 0x2a80
leaq 0x27d0(%rip), %rdi      # 0x524b
callq 0x21a0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::~CompositeFlaschenTaschen()
CompositeFlaschenTaschen::~CompositeFlaschenTaschen() {
    if (garbage_collect_) {
        garbage_collect_->TriggerExit();
        garbage_collect_->WaitStopped();
    }
    for (size_t i = 0; i < screens_.size(); ++i) delete screens_[i];
    delete z_buffer_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4dd9(%rip), %rax      # 0x7c60
movq %rax, (%rdi)
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x2ea1
callq 0x328a
movq 0x60(%rbx), %rdi
callq 0x27f6
movq 0x28(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x2ee9
xorl %r15d, %r15d
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x2ec5
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x2ec5
callq 0x2240
movl $0x10, %esi
movq %r14, %rdi
callq 0x21e0
incq %r15
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
jb 0x2eae
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x2f00
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x2f00
callq 0x2240
movl $0x10, %esi
movq %r14, %rdi
callq 0x21e0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x2f22
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x21e0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2f3c
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x21e0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x29a7
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::SetPixelAtLayer(int, int, int, Color const&)
void CompositeFlaschenTaschen::SetPixelAtLayer(int x, int y, int layer,
                                               const Color &col) {
    screens_[layer]->At(x, y) = col;
    if (layer >= z_buffer_->At(x, y)) {
        any_visible_pixel_drawn_ = true;
        if (col.is_black()) {
            // Transparent pixel. Find closest stacked below us that is not.
            for (/**/; layer > 0; --layer) {
                if (!screens_[layer]->At(x, y).is_black())
                    break;
            }
            delegatee_->SetPixel(x, y, screens_[layer]->At(x, y));
        } else {
            delegatee_->SetPixel(x, y, col);
        }
        z_buffer_->At(x, y) = layer;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %ebx
movl %esi, %ebp
movslq %ecx, %rax
movq 0x28(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x8(%rcx), %rdx
movl (%rcx), %ecx
imull %ebx, %ecx
addl %esi, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movb 0x2(%r8), %sil
movb %sil, 0x2(%rdx,%rcx)
movzwl (%r8), %esi
movw %si, (%rdx,%rcx)
movq 0x40(%rdi), %rcx
movq 0x8(%rcx), %rdx
movl (%rcx), %ecx
imull %ebx, %ecx
addl %ebp, %ecx
movslq %ecx, %rcx
cmpl %eax, (%rdx,%rcx,4)
jg 0x3083
movq %rdi, %r15
movb $0x1, 0x1c(%rdi)
cmpb $0x0, (%r8)
jne 0x305e
cmpb $0x0, 0x1(%r8)
jne 0x305e
cmpb $0x0, 0x2(%r8)
jne 0x305e
movq 0x28(%r15), %rcx
testl %r14d, %r14d
jle 0x303b
movl %r14d, %eax
movq (%rcx,%rax,8), %rdx
movq 0x8(%rdx), %rax
movl (%rdx), %edx
imull %ebx, %edx
addl %ebp, %edx
movslq %edx, %rdx
leaq (%rdx,%rdx,2), %rdx
movb 0x1(%rax,%rdx), %sil
orb (%rax,%rdx), %sil
jne 0x3038
addq %rdx, %rax
cmpb $0x0, 0x2(%rax)
jne 0x3038
leal -0x1(%r14), %eax
cmpl $0x1, %r14d
movl %eax, %r14d
jg 0x2ffb
xorl %r14d, %r14d
movl %r14d, %eax
movq 0x8(%r15), %rdi
movq (%rcx,%rax,8), %rax
movl (%rax), %ecx
imull %ebx, %ecx
addl %ebp, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
addq 0x8(%rax), %rcx
movq (%rdi), %rax
movl %ebp, %esi
movl %ebx, %edx
jmp 0x306c
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movl %ebp, %esi
movl %ebx, %edx
movq %r8, %rcx
callq *0x20(%rax)
movq 0x40(%r15), %rax
imull (%rax), %ebx
movq 0x8(%rax), %rax
addl %ebp, %ebx
movslq %ebx, %rcx
movl %r14d, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::Send()
void CompositeFlaschenTaschen::Send() {
    // Don't send anything if we only had pixels in hidden layers.
    if (any_visible_pixel_drawn_)
        delegatee_->Send();
    any_visible_pixel_drawn_ = false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x1c(%rdi)
jne 0x30a2
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x0, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::StartLayerGarbageCollection(ft::Mutex*, int)
void CompositeFlaschenTaschen::StartLayerGarbageCollection(ft::Mutex *lock,
                                                           int timeout_seconds) {
    assert(garbage_collect_ == NULL);  // only start once.
    assert(lock != NULL);  // Must provide mutex.
    garbage_collect_ = new LayerGarbageCollector(this, lock, timeout_seconds);
    garbage_collect_->Start();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x60(%rdi)
jne 0x3157
movq %rsi, %r15
testq %rsi, %rsi
je 0x3176
movl %edx, %ebp
movq %rdi, %rbx
movl $0x68, %edi
callq 0x21d0
movq %rax, %r14
movq %rax, %rdi
callq 0x27cc
leaq 0x4bb9(%rip), %rax      # 0x7cc8
movq %rax, (%r14)
movq %rbx, 0x18(%r14)
movq %r15, 0x20(%r14)
movl %ebp, 0x28(%r14)
movb $0x1, 0x60(%r14)
movl $0x0, 0x64(%r14)
movq %r14, %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x2210
movq %r14, 0x60(%rbx)
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
leaq 0x21a9(%rip), %rdi      # 0x5307
leaq 0x2139(%rip), %rsi      # 0x529e
leaq 0x21b4(%rip), %rcx      # 0x5320
movl $0x9e, %edx
callq 0x2140
leaq 0x21f0(%rip), %rdi      # 0x536d
leaq 0x211a(%rip), %rsi      # 0x529e
leaq 0x2195(%rip), %rcx      # 0x5320
movl $0x9f, %edx
callq 0x2140
movq %rax, %rbx
movl $0x68, %esi
movq %r14, %rdi
callq 0x21e0
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/composite-flaschen-taschen.cc
// Function: CompositeFlaschenTaschen::LayerGarbageCollector::Run()
void Run() {
        for (;;) {
            ft::MutexLock m(lock_);
            lock_->WaitOnWithTimeout(&running_cond_, 1000);
            if (!running_) break;
            owner_->ClearLayersOlderThan(ticks_ - max_age_);
            owner_->SetTimeTicks(ticks_);
            ++ticks_;  // one tick, roughly one second.
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movq 0x20(%rbx), %r15
movq %r15, %rdi
callq 0x22a0
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x2912
cmpb $0x0, 0x60(%rbx)
je 0x3333
movq 0x18(%rbx), %rdi
movl 0x64(%rbx), %esi
subl 0x28(%rbx), %esi
callq 0x31ae
movq 0x18(%rbx), %rax
movl 0x64(%rbx), %ecx
movl %ecx, 0x20(%rax)
incl %ecx
movl %ecx, 0x64(%rbx)
movq %r15, %rdi
callq 0x2160
jmp 0x32e8
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2160
movq %rax, %rbx
movq %r15, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ppm-reader.cc
// Function: ReadImageData(char const*, unsigned long, ImageMetaInfo*)
const char *ReadImageData(const char *in_buffer, size_t buf_len,
                          struct ImageMetaInfo *info) {
    if (in_buffer[0] != 'P' || in_buffer[1] != '6' ||
        (!isspace(in_buffer[2]) && in_buffer[2] != '#')) {
        return in_buffer;  // raw image. No P6 magic header.
    }
    const char *const end = in_buffer + buf_len;
    const char *parse_buffer = in_buffer + 2;
    const int width = readNextNumber(&parse_buffer, end, info);
    if (parse_buffer == NULL) return in_buffer;
    const int height = readNextNumber(&parse_buffer, end, info);
    if (parse_buffer == NULL) return in_buffer;
    const int range = readNextNumber(&parse_buffer, end, info);
    if (parse_buffer == NULL) return in_buffer;
    if (!isspace(*parse_buffer++)) return in_buffer;   // last char before data
    // Now make sure that the rest of the buffer still makes sense
    const size_t expected_image_data = width * height * 3;
    const size_t actual_data = end - parse_buffer;
    if (actual_data < expected_image_data)
        return in_buffer;   // Uh, not enough data.
    if (actual_data > expected_image_data) {
        // Our extension: at the end of the binary data, we provide an optional
        // offset. We can't store it in the header, as it is fixed in number
        // of fields. But nobody cares what is at the end of the buffer.
        // Note, this also can be supplied in the specially formatted comment
        // in the header.
        parseOffsets(parse_buffer + expected_image_data, end, info);
    }
    info->width = width;
    info->height = height;
    info->range = range;
    return parse_buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x50, (%rdi)
jne 0x36f8
cmpb $0x36, 0x1(%rbx)
jne 0x36f8
movq %rdx, %r14
movq %rsi, %r15
movsbl 0x2(%rbx), %ebp
movl %ebp, %edi
callq 0x2060
cmpl $0x23, %ebp
je 0x3646
testl %eax, %eax
je 0x36f8
leaq 0x2(%rbx), %rax
addq %rbx, %r15
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x370a
cmpq $0x0, (%r12)
je 0x36f8
movl %eax, %ebp
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x370a
cmpq $0x0, (%r13)
je 0x36f8
movl %eax, %r12d
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x370a
movq (%r13), %r13
testq %r13, %r13
je 0x36f8
movl %eax, 0xc(%rsp)
movsbl (%r13), %edi
callq 0x2060
testl %eax, %eax
je 0x36f8
incq %r13
movl %ebp, %eax
imull %r12d, %eax
leal (%rax,%rax,2), %eax
movslq %eax, %rdi
movq %r15, %rax
subq %r13, %rax
cmpq %rdi, %rax
jb 0x36f8
jbe 0x36e6
addq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x37f8
movl %ebp, (%r14)
movl %r12d, 0x4(%r14)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%r14)
movq %r13, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ppm-reader.cc
// Function: readNextNumber(char const**, char const*, ImageMetaInfo*)
static int readNextNumber(const char **start, const char *end,
                          struct ImageMetaInfo *info) {
    const char *start_number = skipWhitespace(*start, end, info);
    if (start_number == NULL) { *start = NULL; return 0; }
    char *end_number = NULL;
    int result = strtol(start_number, &end_number, 10);
    if (end_number == start_number) { *start = NULL; return 0; }
    *start = end_number;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
cmpq %rsi, %r15
jae 0x37b4
movq %rdx, %r14
movq %rsi, %r12
movq %r15, %rbp
movq %r15, %r13
movb (%r13), %r15b
movsbl %r15b, %edi
callq 0x2060
testl %eax, %eax
je 0x374e
incq %r13
incq %rbp
cmpq %r12, %r13
jb 0x3730
jmp 0x37b4
cmpb $0x23, %r15b
jne 0x37cc
movq %r13, %r15
cmpq %r12, %r13
jae 0x3770
movq %r13, %r15
cmpb $0xa, (%r15)
je 0x3770
incq %r15
cmpq %r12, %r15
jb 0x375f
movq %r12, %r15
testq %r14, %r14
je 0x37ab
movq %r15, %rax
subq %rbp, %rax
cmpq $0x4, %rax
jl 0x37ab
movl $0x4, %edx
movq %r13, %rdi
leaq 0x1c65(%rip), %rsi      # 0x53f5
callq 0x20d0
testl %eax, %eax
jne 0x37ab
addq $0x4, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x37f8
cmpq %r12, %r15
jb 0x372a
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
movq %rsp, %r14
movq %r15, (%r14)
movq %r13, %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x2270
movq (%r14), %rcx
cmpq %rcx, %r13
cmoveq %r15, %rcx
cmovel %r15d, %eax
movq %rcx, (%rbx)
jmp 0x37bd
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/ppm-reader.cc
// Function: parseOffsets(char const*, char const*, ImageMetaInfo*)
static void parseOffsets(const char *start, const char *end,
                         struct ImageMetaInfo *info) {
    info->offset_x = readNextNumber(&start, end, NULL);
    if (start != NULL) {
        info->offset_y = readNextNumber(&start, end, NULL);
    }
    if (start != NULL) {
        info->layer = readNextNumber(&start, end, NULL);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
movq %r15, %rdi
xorl %edx, %edx
callq 0x370a
movl %eax, 0xc(%rbx)
cmpq $0x0, (%r15)
je 0x384f
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x370a
movl %eax, 0x10(%rbx)
cmpq $0x0, (%r15)
je 0x384f
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x370a
movl %eax, 0x14(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/hzeller[P]FlaschenTaschen-PixelPusher-bridge/pixel-pusher-client.cc
// Function: PixelPusherClient::SetPixel(int, int, Color const&)
void PixelPusherClient::SetPixel(int x, int y, const Color &col) {
    if (x < 0 || x >= width_ || y < 0 || y >= height_) return;
    Color *row = (Color*) (pixel_buffer_ + y*row_size_ + 1);
    Color new_color = CIEMapColor(brightness_percent_, col);
    const int packet = y / rows_per_packet_;
    block_dirty_[packet] |= (row[x].r != new_color.r ||
                             row[x].g != new_color.g ||
                             row[x].b != new_color.b);
    row[x] = new_color;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x3b8a
movl %edx, %r14d
testl %edx, %edx
js 0x3b8a
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, 0x8(%rdi)
jle 0x3b8a
cmpl %r14d, 0xc(%rbx)
jle 0x3b8a
movq %rcx, %r15
movl %r14d, %r12d
imulq 0x18(%rbx), %r12
movq 0x38(%rbx), %rax
movq %rax, (%rsp)
movzbl 0x28(%rbx), %r13d
movb 0x4746(%rip), %al       # 0x8250
testb %al, %al
je 0x3b99
shll $0x9, %r13d
addq 0x472b(%rip), %r13      # 0x8248
movzbl (%r15), %eax
movb -0x200(%r13,%rax,2), %cl
movzbl 0x1(%r15), %eax
movb -0x200(%r13,%rax,2), %sil
movzbl 0x2(%r15), %eax
movb -0x200(%r13,%rax,2), %dil
movl %r14d, %eax
cltd
idivl 0x20(%rbx)
movq (%rsp), %rdx
leaq (%rdx,%r12), %r9
incq %r9
movl %ebp, %edx
leaq (%rdx,%rdx,2), %r10
leaq (%r9,%r10), %rdx
movb $0x1, %r8b
cmpb %cl, (%r9,%r10)
jne 0x3b76
cmpb %sil, 0x1(%rdx)
jne 0x3b76
cmpb %dil, 0x2(%rdx)
setne %r8b
movq 0x30(%rbx), %r9
cltq
orb %r8b, (%r9,%rax)
movb %cl, (%rdx)
movb %sil, 0x1(%rdx)
movb %dil, 0x2(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x46b0(%rip), %rdi      # 0x8250
callq 0x2340
testl %eax, %eax
je 0x3b12
callq 0x3cb5
movq %rax, 0x468f(%rip)      # 0x8248
leaq 0x4690(%rip), %rdi      # 0x8250
callq 0x2130
jmp 0x3b12
movq %rax, %rbx
leaq 0x467c(%rip), %rdi      # 0x8250
callq 0x2120
movq %rbx, %rdi
callq 0x2320
nop