LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/shisharka[P]interactive_deduction/formula.cpp
// Function: UnaryConnective::equalTo(std::shared_ptr<BaseFormula> const&) const
bool UnaryConnective::equalTo(const Formula & f) const {
  if(f->getType() != getType())
    return false;

  UnaryConnective * uc = (UnaryConnective *) f.get();
  
  return uc->getOperand()->equalTo(_op);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl %eax, %ebp
jne 0x7ee5
movq (%r14), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/shisharka[P]interactive_deduction/formula.cpp
// Function: BinaryConnective::equalTo(std::shared_ptr<BaseFormula> const&) const
bool BinaryConnective::equalTo(const Formula & f) const {
  if(f->getType() != getType())
    return false;

  BinaryConnective * bc = (BinaryConnective *) f.get();
  
  return bc->getOperand1()->equalTo(_op1) &&
          bc->getOperand2()->equalTo(_op2);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl %eax, %ebp
jne 0x7f39
movq (%r14), %r14
movq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x7f39
movq 0x28(%r14), %rdi
addq $0x28, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rax
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: addAssumption(std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>&, std::shared_ptr<BaseFormula> const&)
void addAssumption(vector<Formula> & assumptions, const Formula & f) {
  bool shouldAdd = true; // indicator for whether or not f should be added to assumptions
  for(unsigned i = 0; i < assumptions.size(); i++)
    if(f->equalTo(assumptions[i]))
      shouldAdd = false;
  if(shouldAdd)
    assumptions.push_back(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x8714
movb $0x1, %bpl
movl $0x1, %r15d
xorl %esi, %esi
movq (%rbx), %rdi
shlq $0x4, %rsi
addq %rax, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
xorb $0x1, %al
andb %al, %bpl
movl %r15d, %esi
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
incl %r15d
cmpq %rsi, %rcx
ja 0x86e1
testb %bpl, %bpl
je 0x8729
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9c3c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyNotI(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyNotI(Goal & g) {
  if(g.second->getType() == T_NOT) {
    Formula notOp = ((Not *)g.second.get())->getOperand();

    addAssumption(g.first, notOp);

    g.second = make_shared<False>();
  }
  else
    cerr << "Failed to apply NotI" << endl;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x8866
movq 0x18(%rbx), %rdi
callq 0x7be8
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x88b1
movq 0x873c(%rip), %rcx      # 0x10f98
cmpb $0x0, (%rcx)
je 0x88ad
incl 0x8(%rax)
jmp 0x88b1
movq 0x8773(%rip), %rbx      # 0x10fe0
leaq 0x37cb(%rip), %rsi      # 0xc03f
movl $0x14, %edx
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0x3100
lock
incl 0x8(%rax)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x86c0
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0x61ac
movaps 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
movq 0x20(%rbx), %rdi
movups %xmm0, 0x18(%rbx)
testq %rdi, %rdi
je 0x88fb
callq 0x56cc
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x88fb
callq 0x56cc
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x890a
callq 0x56cc
addq $0x30, %rsp
popq %rbx
retq
jmp 0x8912
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8924
callq 0x56cc
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyConjI(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>> const&, std::vector<std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>, std::allocator<std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>>>&)
void applyConjI(const Goal & g, vector<Goal> & subgoals) {
  if(g.second->getType() == T_AND) {
    Goal goal1, goal2;

    goal1.first = g.first;
    goal1.second = ((And *)g.second.get())->getOperand1();

    goal2.first = g.first;
    goal2.second = ((And *)g.second.get())->getOperand2();

    subgoals.push_back(goal1);
    subgoals.push_back(goal2);
  }
  else
    cerr << "Failed to apply ConjI" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x4, %eax
jne 0x8a13
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %r14, %rsi
callq 0x9c82
movq 0x18(%r14), %rdi
callq 0x7bee
movq (%rax), %rcx
leaq 0x50(%rsp), %rdi
movq %rcx, -0x8(%rdi)
addq $0x8, %rax
movq %rax, %rsi
callq 0x5678
movq %rsp, %rdi
movq %r14, %rsi
callq 0x9c82
movq 0x18(%r14), %rdi
callq 0x7bf4
movq (%rax), %rcx
leaq 0x20(%rsp), %rdi
movq %rcx, -0x8(%rdi)
addq $0x8, %rax
movq %rax, %rsi
callq 0x5678
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x9e44
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9e44
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x89ea
callq 0x56cc
movq %rsp, %rdi
callq 0x55b0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x8a01
callq 0x56cc
leaq 0x30(%rsp), %rdi
callq 0x55b0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq 0x85c6(%rip), %rbx      # 0x10fe0
leaq 0x3633(%rip), %rsi      # 0xc054
movl $0x15, %edx
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x58, %rsp
popq %rbx
popq %r14
jmp 0x3100
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5594
leaq 0x30(%rsp), %rdi
callq 0x5594
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyDisjI1(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyDisjI1(Goal & g) {
  if(g.second->getType() == T_OR)
    g.second = (((Or *)g.second.get())->getOperand1());
  else
    cerr << "Failed to apply DisjI1" << endl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x5, %eax
jne 0x8aac
movq 0x18(%rbx), %rdi
callq 0x7bee
movq (%rax), %rcx
movq %rcx, 0x18(%rbx)
addq $0x20, %rbx
leaq 0x8(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x5678
movq 0x852d(%rip), %rbx      # 0x10fe0
leaq 0x35b0(%rip), %rsi      # 0xc06a
movl $0x16, %edx
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O3/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyDisjI2(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyDisjI2(Goal & g) {
  if(g.second->getType() == T_OR)
    g.second = (((Or *)g.second.get())->getOperand2());
  else
    cerr << "Failed to apply DisjI2" << endl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x5, %eax
jne 0x8b22
movq 0x18(%rbx), %rdi
callq 0x7bf4
movq (%rax), %rcx
movq %rcx, 0x18(%rbx)
addq $0x20, %rbx
leaq 0x8(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x5678
movq 0x84b7(%rip), %rbx      # 0x10fe0
leaq 0x3551(%rip), %rsi      # 0xc081
movl $0x16, %edx
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O3/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyImpI(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyImpI(Goal & g) {
  if(g.second->getType() == T_IMP) {
    Formula a = (((Imp *)g.second.get())->getOperand1());
    Formula b = (((Imp *)g.second.get())->getOperand2());

    addAssumption(g.first, a);

    g.second = b;
  }
  else
    cerr << "Failed to apply ImpI" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x6, %eax
jne 0x8bad
movq 0x18(%rbx), %rdi
callq 0x7bee
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x8bfa
movq 0x83f5(%rip), %rcx      # 0x10f98
cmpb $0x0, (%rcx)
je 0x8bf6
incl 0x8(%rax)
jmp 0x8bfa
movq 0x842c(%rip), %rbx      # 0x10fe0
leaq 0x34dd(%rip), %rsi      # 0xc098
movl $0x14, %edx
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x3100
lock
incl 0x8(%rax)
movq 0x18(%rbx), %rdi
callq 0x7bf4
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x8c2e
movq 0x8378(%rip), %rcx      # 0x10f98
cmpb $0x0, (%rcx)
je 0x8c2a
incl 0x8(%rax)
jmp 0x8c2e
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x86c0
leaq 0x20(%rsp), %r14
movq -0x8(%r14), %rax
movq %rax, 0x18(%rbx)
addq $0x20, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5678
movq (%r14), %rdi
testq %rdi, %rdi
je 0x8c64
callq 0x56cc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8c73
callq 0x56cc
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8c92
callq 0x56cc
jmp 0x8c92
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8ca1
callq 0x56cc
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyExcludedMiddle(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>> const&)
bool applyExcludedMiddle(const Goal & g) {
  if(g.second->getType() == T_OR) {
    Formula a = ((Or *)g.second.get())->getOperand1();
    Formula b = ((Or *)g.second.get())->getOperand1();
    if(a->getType() == T_NOT && ((Not *)a.get())->getOperand()->equalTo(b))
      return true;
    if(b->getType() == T_NOT && ((Not *)b.get())->getOperand()->equalTo(a))
      return true;
  };

  cerr << "Failed to apply ExcludedMiddle" << endl;
  return false; 
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x5, %eax
jne 0x97ae
movq 0x18(%rbx), %rdi
callq 0x7bee
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x96fe
movq 0x78a8(%rip), %rcx      # 0x10f98
cmpb $0x0, (%rcx)
je 0x96fa
incl 0x8(%rax)
jmp 0x96fe
lock
incl 0x8(%rax)
movq 0x18(%rbx), %rdi
callq 0x7bee
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x9731
movq 0x7875(%rip), %rcx      # 0x10f98
cmpb $0x0, (%rcx)
je 0x972d
incl 0x8(%rax)
jmp 0x9731
lock
incl 0x8(%rax)
movq 0x10(%rsp), %rbx
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl $0x3, %eax
jne 0x975b
movq %rbx, %rdi
callq 0x7be8
movq (%rax), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x10(%rax)
testb %al, %al
jne 0x9784
movq (%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x9788
movq (%rsp), %rdi
callq 0x7be8
movq (%rax), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
callq *0x10(%rax)
testb %al, %al
je 0x9788
xorl %ebx, %ebx
jmp 0x978a
movb $0x1, %bl
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9799
callq 0x56cc
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x97a8
callq 0x56cc
movb $0x1, %al
testb %bl, %bl
je 0x97f2
movq 0x782b(%rip), %rbx      # 0x10fe0
leaq 0x29a2(%rip), %rsi      # 0xc15e
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3100
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
jmp 0x980f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x980f
callq 0x56cc
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x981e
callq 0x56cc
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/shisharka[P]interactive_deduction/naturaldeduction.cpp
// Function: applyDoubleNegationI(std::pair<std::vector<std::shared_ptr<BaseFormula>, std::allocator<std::shared_ptr<BaseFormula>>>, std::shared_ptr<BaseFormula>>&)
void applyDoubleNegationI(Goal & g) {
  if(g.second->getType() == T_NOT && ((Not *)(g.second.get()))->getOperand()->getType() == T_NOT)
    g.second = ((Not*)((Not *)(g.second.get()))->getOperand().get())->getOperand();
  else
    cerr << "Failed to apply DoubleNegationI" << endl;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x9877
movq 0x18(%rbx), %rdi
callq 0x7be8
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x9877
movq 0x18(%rbx), %rdi
callq 0x7be8
movq (%rax), %rdi
callq 0x7be8
movq (%rax), %rcx
movq %rcx, 0x18(%rbx)
addq $0x20, %rbx
leaq 0x8(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x5678
movq 0x7762(%rip), %rbx      # 0x10fe0
leaq 0x28f8(%rip), %rsi      # 0xc17d
movl $0x1f, %edx
movq %rbx, %rdi
callq 0x31b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
popq %rbx
jmp 0x3100
// File: /workspace/github_cpp_makefile_star2_O3/willprice[P]parallel-cpp-workshop/include/part1.h
// Function: part1::calc_distance(part1::Point const&, part1::Point const&)
float calc_distance(const Point &p1, const Point &p2)
{
    const float dx = p1.x - p2.x;
    const float dy = p1.y - p2.y;
    const float dz = p1.z - p2.z;

    return std::sqrt(dx*dx + dy*dy + dz*dz);
}

// Assembly:
movss (%rdi), %xmm0
movss 0x4(%rdi), %xmm1
subss (%rsi), %xmm0
subss 0x4(%rsi), %xmm1
movss 0x8(%rdi), %xmm2
subss 0x8(%rsi), %xmm2
mulss %xmm1, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
mulss %xmm2, %xmm2
addss %xmm0, %xmm2
xorps %xmm0, %xmm0
sqrtss %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/willprice[P]parallel-cpp-workshop/include/part1.h
// Function: part1::create_random_points(int, float)
auto create_random_points(int n, float sz=50.0)
{
    auto points = std::vector<Point>(n);

    for (int i=0; i<n; ++i)
    {
        points[i] = Point(sz * detail::distribution(detail::generator),
                          sz * detail::distribution(detail::generator),
                          sz * detail::distribution(detail::generator) );
    }

    return points;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movss %xmm0, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x309c
testl %r14d, %r14d
jle 0x24cb
xorps %xmm0, %xmm0
cvtss2sd 0x8(%rsp), %xmm0
movl %ebp, %eax
movaps %xmm0, 0x30(%rsp)
movlhps %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movaps %xmm0, 0x20(%rsp)
shlq $0x2, %rax
leaq (%rax,%rax,2), %r15
xorl %r12d, %r12d
leaq 0x3d3a(%rip), %r14      # 0x6138
movq %r14, %rdi
callq 0x3279
movsd %xmm0, 0x8(%rsp)
movsd 0x3d34(%rip), %xmm0     # 0x6148
movsd %xmm0, 0x10(%rsp)
movsd 0x3d1e(%rip), %xmm0     # 0x6140
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
callq 0x3279
movaps %xmm0, 0x50(%rsp)
movaps 0x3d04(%rip), %xmm0     # 0x6140
movaps %xmm0, 0x40(%rsp)
movq %r14, %rdi
callq 0x3279
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm3
subsd %xmm2, %xmm3
movsd 0x8(%rsp), %xmm1
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
mulsd 0x30(%rsp), %xmm1
cvtsd2ss %xmm1, %xmm1
movq (%rbx), %rax
movsd 0x3ccc(%rip), %xmm2     # 0x6148
movapd 0x40(%rsp), %xmm4
movapd %xmm4, %xmm3
movhpd 0x3cb2(%rip), %xmm3     # xmm3 = xmm3[0],mem[0]
shufpd $0x1, %xmm2, %xmm4      # xmm4 = xmm4[1],xmm2[0]
subpd %xmm3, %xmm4
movaps 0x50(%rsp), %xmm2
movlhps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd %xmm4, %xmm2
addpd %xmm3, %xmm2
mulpd 0x20(%rsp), %xmm2
cvtpd2ps %xmm2, %xmm0
movss %xmm1, (%rax,%r12)
movlpd %xmm0, 0x4(%rax,%r12)
addq $0xc, %r12
cmpq %r12, %r15
jne 0x23fe
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x24f2
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/willprice[P]parallel-cpp-workshop/energy.cpp
// Function: mapreduce_energy(std::vector<part1::Point, std::allocator<part1::Point>> const&, std::vector<part1::Point, std::allocator<part1::Point>> const&)
double mapreduce_energy(const std::vector<Point> &group1,
                        const std::vector<Point> &group2)
{
    return parallel::mapReduce( [=](const Point &point1)
                      {
                          return mapReduce([=](const Point &point2)
                          {
                              return calculate_energy(point1, point2);
                          },
                          std::plus<double>(), group2 );
                      },
                      std::plus<double>(), group1 );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3112
movq 0x8(%rbx), %r15
subq (%rbx), %r15
xorl %eax, %eax
leaq 0x78(%rsp), %rcx
movq %rax, (%rcx)
leaq 0xf(%rsp), %rdx
leaq 0x80(%rsp), %rsi
movq %rdx, (%rsi)
movq %r14, 0x8(%rsi)
movq %rbx, 0x10(%rsi)
movq %rcx, 0x38(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq %rax, 0x50(%rsp)
leaq 0x98(%rsp), %rdi
movw $0x401, 0xc(%rdi)       # imm = 0x401
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq $0x4, 0x40(%rdi)
callq 0x2190
shrq $0x2, %r15
imull $0xaaaaaaab, %r15d, %ebp # imm = 0xAAAAAAAB
testl %ebp, %ebp
jle 0x2744
xorl %eax, %eax
movq %rax, 0x58(%rsp)
movl $0x1, 0x60(%rsp)
movl $0x1, %ecx
movq %rcx, 0x68(%rsp)
movq %rcx, 0x70(%rsp)
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movl $0x80, %esi
callq 0x2050
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movq $0x0, 0x38(%rax)
leaq 0x3668(%rip), %rax      # 0x5d38
movq %rax, (%rbx)
movl %ebp, 0x40(%rbx)
movl $0x0, 0x44(%rbx)
movq $0x1, 0x48(%rbx)
leaq 0x38(%rsp), %rax
movq %rax, 0x50(%rbx)
xorl %edi, %edi
callq 0x21f0
leaq 0x68(%rsp), %rdx
cltq
movl $0x0, 0x68(%rbx)
movb $0x5, 0x6c(%rbx)
addq %rax, %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
andq %rax, %rcx
movq %rcx, 0x60(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x70(%rbx)
movb $0x0, 0x78(%rbx)
leaq 0x58(%rsp), %rax
movq %rax, 0x58(%rbx)
leaq 0x98(%rsp), %rcx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x2180
leaq 0x98(%rsp), %rdi
callq 0x2140
movsd 0x50(%rsp), %xmm0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x277a
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
movsd %xmm0, 0x10(%rsp)
callq 0x2130
movsd 0x10(%rsp), %xmm0
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27be
movq %rax, %rbx
jmp 0x279f
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x2140
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x27b6
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x31a1
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/main.cpp
// Function: usage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void usage(string strName){

  printf("%s Version %s - %s\n", strName.c_str(), version, AppDescription);
  printf("USAGE:\n");
  printf(" -i <input file>      Picoblaze source file\n");
  printf(" [-t <template file>] verilog/VHDL template file.\n" 
	 "                      Default = %s\n"
	 "                      Extension determines verilog/VHDL processing\n"
	 "                      \"%s\" = verilog, otherwise VHDL\n", 
	 LA_PICOASM_DEF_TPL, LA_PICOASM_VERILOG_EXT);
  printf(" [-m <module name>]   Verilog module or VHDL entity name.\n"
	 "                      Default = input file base name\n");  
  printf(" [-d <directory>]     Output file directory.\n"
	 "                      Default = input file directory\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rsi
leaq 0x17c9ae(%rip), %rdi    # 0x581004
leaq 0x17cd53(%rip), %rdx    # 0x5813b0
leaq 0x17cd5c(%rip), %rcx    # 0x5813c0
xorl %eax, %eax
callq 0x4d4740
leaq 0x17cc33(%rip), %rdi    # 0x5812a5
callq 0x4e3f70
leaq 0x17cc2e(%rip), %rdi    # 0x5812ac
callq 0x4e3f70
leaq 0x17c98e(%rip), %rdi    # 0x581018
leaq 0x17ca55(%rip), %rsi    # 0x5810e6
leaq 0x17ca56(%rip), %rdx    # 0x5810ee
xorl %eax, %eax
callq 0x4d4740
leaq 0x17cc32(%rip), %rdi    # 0x5812d8
callq 0x4e3f70
leaq 0x17cc95(%rip), %rdi    # 0x581347
popq %rbp
jmp 0x4e3f70
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cassembler.cpp
// Function: toUpper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string toUpper( string str )
{
	string upperStr ;
	unsigned int i ; 
	
	upperStr = "" ;
	for ( i = 0 ; i < str.length() ; i++ )
		upperStr += toupper( str[ i ] ) ;

	return upperStr ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x19c41b(%rip), %rcx    # 0x5a19f2
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x47d660
cmpq $0x0, 0x8(%r14)
je 0x405615
movl $0x1, %r12d
xorl %eax, %eax
movq (%r14), %rcx
movsbl (%rcx,%rax), %edi
callq 0x4c2700
movsbl %al, %esi
movq %rbx, %rdi
callq 0x47d0a0
movl %r12d, %eax
incl %r12d
cmpq %rax, 0x8(%r14)
ja 0x4055f2
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x405623
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x405639
movq (%r15), %rsi
incq %rsi
callq 0x40d020
movq %r14, %rdi
callq 0x4ad8c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cassembler.cpp
// Function: CAssembler::error(unsigned int, char const*)
void CAssembler::error( unsigned int line, const char *description )
{
  cout << "ERROR line: " << line+1 << ": " << description << endl ; 
  
// RDC 12/31/2007 - comment out
//   if ( m_messageList ) {
//     char str[ 128 ] ;
//     sprintf( str, "%u", line + 1 ) ;
//     QListViewItem *item = new QListViewItem( m_messageList, m_messageList->lastChild() ) ;
    
//     if ( line != NO_LINE_NR )
//       item->setText( 0, str ) ;
//     item->setText( 1, description ) ;
//   }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq $0x5f4580, %r15         # imm = 0x5F4580
leaq 0x17bda6(%rip), %rsi    # 0x58150d
movl $0xc, %edx
movq %r15, %rdi
callq 0x476110
incl %ebx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x476a10
movq %rax, %rbx
leaq 0x17c6cf(%rip), %rsi    # 0x581e5a
movl $0x2, %edx
movq %rax, %rdi
callq 0x476110
testq %r14, %r14
je 0x4057b5
movq %r14, %rdi
callq 0x401118
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x476110
jmp 0x4057ce
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x456f90
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x457260
movsbl %al, %esi
movq %rbx, %rdi
callq 0x475c10
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4751e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cassembler.cpp
// Function: CAssembler::getInstruction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int CAssembler::getInstruction( string name )
{
	unsigned int i ;
	string str = toUpper( name ) ;
	for ( i = 0 ; i < sizeof( instructions ) / sizeof( char *); i++ )
		if ( str == instructions[ i ] )
			return i ;
	return -1 ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40546e
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0x4055ac
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x4058c1
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x40d020
leaq 0x1eb898(%rip), %r15    # 0x5f1160
xorl %ebx, %ebx
leaq -0x58(%rbp), %r14
movq (%r15), %rsi
movq %r14, %rdi
callq 0x47ec20
testl %eax, %eax
je 0x4058ef
incq %rbx
addq $0x8, %r15
cmpq $0x1f, %rbx
jne 0x4058ce
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x405908
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x40d020
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x40592d
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x40d020
movq %rbx, %rdi
callq 0x4ad8c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cassembler.cpp
// Function: CAssembler::translateRegister(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string CAssembler::translateRegister( string name )
{
	list<CNamereg*>::iterator it1 ;
	for ( it1 = m_registerTable.begin() ; it1 != m_registerTable.end() ; it1++ ) {
		if ( (*it1)->name == name )
			return (*it1)->reg ;
	}
	
	return name ;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq 0x18(%rsi), %r13
addq $0x18, %r15
cmpq %r15, %r13
je 0x40694a
movq 0x8(%r14), %r12
movq 0x10(%r13), %rbx
cmpq %r12, 0x28(%rbx)
jne 0x406941
testq %r12, %r12
je 0x40696d
movq (%r14), %rsi
movq 0x20(%rbx), %rdi
movq %r12, %rdx
callq 0x401080
testl %eax, %eax
je 0x40696d
movq (%r13), %r13
cmpq %r15, %r13
jne 0x40691f
movq -0x30(%rbp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%r14), %rdx
leaq 0x10(%r14), %rsi
cmpq %rsi, %rdx
je 0x40698f
movq %rdx, (%rax)
movq (%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x406995
movq -0x30(%rbp), %r14
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x40546e
movq %r14, %rax
jmp 0x4069ad
movups (%rsi), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rsi, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cassembler.cpp
// Function: CAssembler::translateConstant(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string CAssembler::translateConstant( string name )
{
	list<CConstant*>::iterator it1 ;
	for ( it1 = m_constantTable.begin() ; it1 != m_constantTable.end() ; it1++ ) {
		if ( (*it1)->name == name )
			return (*it1)->value ;
	}
	
	return name ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq 0x30(%rsi), %r13
addq $0x30, %r15
cmpq %r15, %r13
je 0x406a10
movq 0x8(%r14), %r12
movq 0x10(%r13), %rbx
cmpq %r12, 0x28(%rbx)
jne 0x406a07
testq %r12, %r12
je 0x406a33
movq (%r14), %rsi
movq 0x20(%rbx), %rdi
movq %r12, %rdx
callq 0x401080
testl %eax, %eax
je 0x406a33
movq (%r13), %r13
cmpq %r15, %r13
jne 0x4069e5
movq -0x30(%rbp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%r14), %rdx
leaq 0x10(%r14), %rsi
cmpq %rsi, %rdx
je 0x406a55
movq %rdx, (%rax)
movq (%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x406a5b
movq -0x30(%rbp), %r14
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x40546e
movq %r14, %rax
jmp 0x406a73
movups (%rsi), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rsi, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cassembler.cpp
// Function: CAssembler::translateLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string CAssembler::translateLabel( string label )
{
	list<CLabel*>::iterator it1 ;
	for ( it1 = m_labelTable.begin() ; it1 != m_labelTable.end() ; it1++ ) {
		if ( (*it1)->name == label )
			return (*it1)->value ;
	}
	
	return label ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq 0x48(%rsi), %r13
addq $0x48, %r15
cmpq %r15, %r13
je 0x406ad6
movq 0x8(%r14), %r12
movq 0x10(%r13), %rbx
cmpq %r12, 0x28(%rbx)
jne 0x406acd
testq %r12, %r12
je 0x406af9
movq (%r14), %rsi
movq 0x20(%rbx), %rdi
movq %r12, %rdx
callq 0x401080
testl %eax, %eax
je 0x406af9
movq (%r13), %r13
cmpq %r15, %r13
jne 0x406aab
movq -0x30(%rbp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%r14), %rdx
leaq 0x10(%r14), %rsi
cmpq %rsi, %rdx
je 0x406b1b
movq %rdx, (%rax)
movq (%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x406b21
movq -0x30(%rbp), %r14
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x40546e
movq %r14, %rax
jmp 0x406b39
movups (%rsi), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rsi, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cassembler.cpp
// Function: CAssembler::createOpcodes()
bool CAssembler::createOpcodes()
{
	list<CSourceLine*>::iterator it ;
	int columnOffset ; 
	
	for ( it = m_source.begin() ; it != m_source.end() ; it++ ) {
		if ( (*it)->m_type == CSourceLine::stNamereg || 
		     (*it)->m_type == CSourceLine::stConstant || 
			 (*it)->m_type == CSourceLine::stAddress )
			continue ;
			
		if ( (*it)->m_type == CSourceLine::stLabel )
			columnOffset = 2 ;
		else 
			columnOffset = 0 ;	

		if ( !(*it)->isColumn( columnOffset + 0 ) )						// just a label
			continue ;
								
		int instr = getInstruction( (*it)->getColumn( columnOffset + 0 ) ) ;
		
		if ( instr < 0  ) {
			error( (*it)->m_lineNr, "Unknown instruction" ) ;
			return FALSE ;
		}
		
		
		if ( addInstruction( (instrNumber) instr, **it, columnOffset )  == FALSE )
			return FALSE ;
			
	} 
	return TRUE ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq (%rdi), %r15
movb $0x1, %al
cmpq %rdi, %r15
je 0x4089a9
movq %rdi, %r12
leaq -0x70(%rbp), %r14
movq %rdi, -0x30(%rbp)
movq 0x10(%r15), %rsi
movl 0x24(%rsi), %eax
leal -0x2(%rax), %ecx
cmpl $0x3, %ecx
jb 0x40898b
xorl %ebx, %ebx
cmpl $0x1, %eax
sete %bl
addl %ebx, %ebx
movq 0x10(%rsi), %rax
subq 0x8(%rsi), %rax
sarq $0x5, %rax
cmpq %rbx, %rax
jbe 0x40898b
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movl %ebx, %edx
callq 0x408e9a
movq %r13, %rsi
callq 0x405872
movl %eax, %r13d
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x408942
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x40d020
movq 0x10(%r15), %r12
movl (%r12), %esi
testl %r13d, %r13d
js 0x40899b
movl %esi, -0x78(%rbp)
leaq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x408fa0
movq 0x20(%r12), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %r12
movq %r12, %rdi
movl %r13d, %esi
leaq -0x78(%rbp), %rdx
movl %ebx, %ecx
callq 0x406b48
movl %eax, %ebx
movq %r14, %rdi
callq 0x409116
testb %bl, %bl
je 0x4089a7
movq (%r15), %r15
cmpq %r12, %r15
jne 0x4088e2
movb $0x1, %al
jmp 0x4089a9
leaq 0x178d92(%rip), %rdx    # 0x581734
callq 0x40574a
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x409116
jmp 0x4089e1
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x4089e1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x40d020
movq %rbx, %rdi
callq 0x4ad8c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cassembler.cpp
// Function: CAssembler::assemble()
bool CAssembler::assemble( )
{
	if ( loadFile() == FALSE )
		return FALSE ;

	if ( buildSymbolTable() == FALSE )
		return FALSE ;
	// Check that the CONSTANT table and the NAMEREG table do not collide
       list<CConstant*>::iterator it0 ;

       list<CNamereg*>::iterator it1 ;

       for ( it1 = m_registerTable.begin() ; it1 != m_registerTable.end() ; it1++ ) {
	 for ( it0 = m_constantTable.begin() ; it0 != m_constantTable.end() ; it0++ ) {
	   if( (*it1)->name == (*it0)->name ) {
	     cout << "ERROR :: NAMEREG alias:(" << (*it1)->name << ") conflicts with CONSTANT: (" << (*it0)->name<<")\n";
	     return FALSE;
	   }
	 }
       }

	if ( createOpcodes() == FALSE )
		return FALSE ;
	return TRUE ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x408b20
testb %al, %al
je 0x408b0e
movq %rbx, %rdi
callq 0x405936
testb %al, %al
je 0x408b0e
leaq 0x18(%rbx), %rax
movq %rbx, -0x30(%rbp)
movq 0x18(%rbx), %r15
movq %rax, -0x40(%rbp)
cmpq %rax, %r15
je 0x408a88
movq -0x30(%rbp), %rax
leaq 0x30(%rax), %r13
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq %r13, -0x38(%rbp)
je 0x408a7f
movq 0x10(%r15), %rbx
movq 0x28(%rbx), %r14
movq -0x38(%rbp), %r12
movq 0x10(%r12), %rax
cmpq 0x28(%rax), %r14
jne 0x408a76
testq %r14, %r14
je 0x408a9f
movq 0x20(%rax), %rsi
movq 0x20(%rbx), %rdi
movq %r14, %rdx
callq 0x401080
testl %eax, %eax
je 0x408a9f
movq (%r12), %r12
cmpq %r13, %r12
jne 0x408a52
movq (%r15), %r15
cmpq -0x40(%rbp), %r15
jne 0x408a40
movq -0x30(%rbp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4088b8
movq $0x5f4580, %rbx         # imm = 0x5F4580
leaq 0x178d31(%rip), %rsi    # 0x5817de
movl $0x18, %edx
movq %rbx, %rdi
callq 0x476110
movq 0x10(%r15), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0x476110
movq %rax, %rbx
leaq 0x178d1f(%rip), %rsi    # 0x5817f7
movl $0x1c, %edx
movq %rax, %rdi
callq 0x476110
movq 0x10(%r12), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0x476110
leaq 0x18a958(%rip), %rsi    # 0x593459
movl $0x2, %edx
movq %rax, %rdi
callq 0x476110
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cassembler.cpp
// Function: CAssembler::loadFile()
bool CAssembler::loadFile()
{
	FILE *f ;

	f = fopen( m_filename.c_str(), "r" ) ;

	if ( f == NULL ) {
		string str =  "Unable to load file '" + m_filename + "'";
		error( NO_LINE_NR, str.c_str() ) ;							// No linenumber information
		return FALSE ;
	}
	char buf[ 256 ] ;
	int linenr = 0 ;
	while( fgets( buf, sizeof( buf ), f ) ) {
		CSourceLine *sourceLine = formatLine( linenr++, buf ) ;
		if ( sourceLine != NULL )
			m_source.push_back( sourceLine ) ;
	}

	list<CSourceLine*>::iterator it ;

	// RDC 01/31/2007 - don't print parsed info
// 	for ( it = m_source.begin() ; it != m_source.end() ; it++ ) {
// 		cout << "(" << (*it)->m_lineNr << ")" ;
// 		int j = 0 ;
// 		while ( (*it)->isColumn( j ) )
// 			 cout << "[" << (*it)->getColumn( j++ ) << "]";
// 		cout << endl ;
// 	}
		
// 	cout << "File " << m_filename << " succesfully loaded" << endl ;

	return TRUE ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %r14
movq 0x60(%rdi), %rdi
leaq 0x17da1d(%rip), %rsi    # 0x58655f
callq 0x4e3500
movq %rax, %rbx
testq %rax, %rax
je 0x408bc3
leaq -0x150(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
callq 0x4e3250
testq %rax, %rax
je 0x408c82
xorl %r15d, %r15d
leaq -0x150(%rbp), %r12
movl %r15d, %esi
movq %r12, %rdx
callq 0x408d80
testq %rax, %rax
je 0x408ba6
movq %rax, %r13
movl $0x18, %edi
callq 0x40dec0
movq %r13, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40efd0
incq 0x10(%r14)
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
callq 0x4e3250
incl %r15d
testq %rax, %rax
jne 0x408b76
jmp 0x408c82
addq $0x60, %r14
leaq 0x1785fd(%rip), %rsi    # 0x5811cb
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x408f00
leaq 0x1785fb(%rip), %rsi    # 0x5811df
movq %r15, %rdi
callq 0x47e1c0
leaq -0x140(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x408c19
movq %rdx, -0x150(%rbp)
movq (%rcx), %rsi
movq %rsi, -0x140(%rbp)
jmp 0x408c23
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %rdx
movq 0x8(%rax), %rsi
movq %rsi, -0x148(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x408c5d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x40d020
movq -0x150(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x40574a
movq -0x150(%rbp), %rdi
cmpq %r14, %rdi
je 0x408c82
movq -0x140(%rbp), %rsi
incq %rsi
callq 0x40d020
testq %rbx, %rbx
setne %al
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x150(%rbp), %rdi
cmpq %r14, %rdi
je 0x408cce
movq -0x140(%rbp), %rsi
jmp 0x408cc6
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x408cce
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x40d020
movq %rbx, %rdi
callq 0x4ad8c0
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cassembler.cpp
// Function: CAssembler::getWord(char*, char*)
char * CAssembler::getWord( char *s, char *word ) {
	char *start, *end ;
	
	*word = '\0' ;
	
	while ( *s == ' ' || *s == '\t' )							// skip whitespaces
		s++ ;
	
	start = s ;
	
	if ( *start == '\0' || *start == '\r' || *start == '\n' || *start == ';' )	// end of line
		return NULL ;
		
	while ( *s != ' ' && *s != '\t' && *s != '\0' && *s != '\r' && *s != '\n' && 
	        *s != ';'  && *s != ',' && *s != ':' && *s != '(' && *s != ')' )
		s++ ;
	
	end = s ;
	
	if ( start != end ) {
		while ( start < end )
			*word++ = *start++ ;
		*word = '\0' ;
		return end ;
	} else if ( *s == ',' || *s == ':' || *s == '(' || *s == ')' ) {
		*word++ = *s ;
		*word = '\0' ;
		return end + 1 ;
	} else
		return NULL ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, (%rdx)
movabsq $0x100000200, %rax      # imm = 0x100000200
movzbl (%rsi), %ecx
cmpq $0x3b, %rcx
ja 0x408d0f
btq %rcx, %rax
jae 0x408cfb
incq %rsi
jmp 0x408ce7
movabsq $0x800000000002401, %rax # imm = 0x800000000002401
btq %rcx, %rax
jae 0x408d0f
xorl %eax, %eax
popq %rbp
retq
xorl %edi, %edi
movabsq $0xc00130100002601, %rax # imm = 0xC00130100002601
cmpb $0x3b, %cl
ja 0x408d2a
movzbl %cl, %r8d
btq %r8, %rax
jb 0x408d33
movb 0x1(%rsi,%rdi), %cl
incq %rdi
jmp 0x408d1b
testq %rdi, %rdi
je 0x408d5b
leaq (%rsi,%rdi), %rax
cmpq %rax, %rsi
jae 0x408d56
xorl %ecx, %ecx
movb (%rsi,%rcx), %r8b
movb %r8b, (%rdx,%rcx)
incq %rcx
decq %rdi
jne 0x408d43
addq %rcx, %rdx
movb $0x0, (%rdx)
jmp 0x408d0d
xorl %eax, %eax
cmpb $0x3a, %cl
ja 0x408d0d
movabsq $0x400130000000000, %rdi # imm = 0x400130000000000
btq %r8, %rdi
jae 0x408d0d
movb %cl, (%rdx)
movb $0x0, 0x1(%rdx)
incq %rsi
movq %rsi, %rax
jmp 0x408d0d
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cassembler.cpp
// Function: CAssembler::formatLine(int, char*)
CSourceLine * CAssembler::formatLine( int lineNr, char *s )
{
	CSourceLine *sourceLine = new CSourceLine( lineNr ) ;
	char *next, word[ 256 ] ;
	
	next = getWord( s, word ) ; 
	if ( word[ 0 ] == '\0' ) {			// empty line
		delete sourceLine ;
		return NULL ;
	}
	
	do {
		sourceLine->addColumn( word ) ;
		next = getWord( next, word ) ;	
		if ( word[ 0 ] == '\0' )
			break ;
	} while ( next != NULL ) ;
	
	return sourceLine ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdx, %r15
movl %esi, %r14d
movl $0x28, %edi
callq 0x40dec0
movq %rax, %rbx
movl %r14d, (%rax)
leaq 0x8(%rax), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movl $0x0, 0x24(%rax)
leaq -0x150(%rbp), %r12
movq %r15, %rsi
movq %r12, %rdx
callq 0x408cd6
cmpb $0x0, (%r12)
je 0x408e50
movq %rax, %r15
movq %rbx, -0x30(%rbp)
leaq -0x40(%rbp), %rbx
leaq -0x50(%rbp), %r13
movq %rbx, -0x50(%rbp)
movq %r12, %rdi
callq 0x401118
leaq (%rax,%rbp), %rdx
addq $-0x150, %rdx           # imm = 0xFEB0
movq %r13, %rdi
movq %r12, %rsi
callq 0x40550c
movq %r14, %rdi
movq %r13, %rsi
callq 0x409184
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x408e2e
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x40d020
movq %r15, %rsi
movq %r12, %rdx
callq 0x408cd6
testq %rax, %rax
je 0x408e4a
movq %rax, %r15
cmpb $0x0, -0x150(%rbp)
jne 0x408dec
movq -0x30(%rbp), %rax
jmp 0x408e67
movq %r14, %rdi
callq 0x409116
movl $0x28, %esi
movq %rbx, %rdi
callq 0x40d020
xorl %eax, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x408e91
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x40d020
movq %r14, %rdi
callq 0x4ad8c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/./cassembler.h
// Function: CSourceLine::getColumn[abi:cxx11](int)
string getColumn( int index ) 
		{ 
			if ( !isColumn( index ) ) 
				return "" ; 
			else 
				return m_line[index] ; 
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
movl %edx, %esi
cmpq %rsi, %rcx
jbe 0x408edd
movslq %edx, %rcx
shlq $0x5, %rcx
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x40546e
jmp 0x408ef6
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x198b07(%rip), %rdx    # 0x5a19f2
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x40550c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cinstruction.cpp
// Function: CInstruction::CInstruction(CPicoBlaze*, unsigned int)
CInstruction::CInstruction( CPicoBlaze *cpu, uint32_t opcode )
{
	m_cpu = cpu ;

	sX = ( opcode & 0x0f00 ) >> 8 ;
	sY = ( opcode & 0x00f0 ) >> 4 ;
	kk = ( opcode & 0x00ff ) >> 0 ;
	pp = ( opcode & 0x00ff ) >> 0 ;
	ss = ( opcode & 0x003f ) >> 0 ;
	address = ( opcode & 0x03ff ) >> 0 ;
	
	hexcode = opcode ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1dfdcd(%rip), %rax    # 0x5e91c8
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movl %edx, %eax
shrl $0x8, %eax
andl $0xf, %eax
movw %ax, 0x10(%rdi)
movl %edx, %eax
shrl $0x4, %eax
andl $0xf, %eax
movw %ax, 0x12(%rdi)
movzbl %dl, %eax
movw %ax, 0x18(%rdi)
movw %ax, 0x16(%rdi)
movl %edx, %eax
andl $0x3f, %eax
movw %ax, 0x14(%rdi)
movl %edx, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movw %ax, 0x1a(%rdi)
movl %edx, 0x1c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cinstruction.cpp
// Function: ADD_SX_KK::Execute()
void ADD_SX_KK::Execute() 
{
	uint16_t val = m_cpu->s[ sX ] + kk ;
	
	m_cpu->flags.carry = ( val > 255 ) ;
	m_cpu->flags.zero = ( val == 0 ) || ( val == 256 ) ;
	
	m_cpu->s[ sX ] = val ; 
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movzbl (%rax,%rcx), %edx
addw 0x18(%rdi), %dx
movzwl %dx, %esi
cmpl $0x100, %esi            # imm = 0x100
setae 0x11(%rax)
testl $0xfeff, %edx           # imm = 0xFEFF
sete 0x10(%rax)
movb %sil, (%rax,%rcx)
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b68a
nop
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cinstruction.cpp
// Function: ADDCY_SX_SY::Execute()
void ADDCY_SX_SY::Execute()
{
	uint16_t val ;

	if ( m_cpu->flags.carry ) 
		val = m_cpu->s[ sX ] + 1 + m_cpu->s[ sY ] ;
	else
		val = m_cpu->s[ sX ] + m_cpu->s[ sY ] ;
	
	m_cpu->s[ sX ] = val ;
	m_cpu->flags.carry = (val > 255)  ;
	m_cpu->flags.zero = (val == 0) || (val == 256) ;
		
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movzbl (%rax,%rcx), %edx
cmpb $0x1, 0x11(%rax)
jne 0x4096a7
movzwl %dx, %edx
movzwl 0x12(%rdi), %esi
movzbl (%rax,%rsi), %esi
addl %esi, %edx
incl %edx
jmp 0x4096b4
movzwl 0x12(%rdi), %esi
movzbl (%rax,%rsi), %esi
movzwl %dx, %edx
addl %esi, %edx
movzwl %dx, %edx
movb %dl, (%rax,%rcx)
cmpl $0x100, %edx            # imm = 0x100
movq 0x8(%rdi), %rax
setae 0x11(%rax)
testl $0x2ff, %edx            # imm = 0x2FF
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b68a
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cinstruction.cpp
// Function: CALLC::Execute()
void CALLC::Execute()
{
	if ( m_cpu->flags.carry ) {
		m_cpu->stack->Push( m_cpu->pc->Get() ) ;
		m_cpu->pc->Set( address ) ;
	} else
		m_cpu->pc->Next() ;
}

// Assembly:
movq 0x8(%rdi), %rax
cmpb $0x1, 0x11(%rax)
jne 0x409975
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rax), %rdi
movq 0x28(%rax), %r14
callq 0x40b6ae
movzwl %ax, %esi
movq %r14, %rdi
callq 0x40b6f4
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
movzwl 0x1a(%rbx), %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x40b69e
movq 0x18(%rax), %rdi
jmp 0x40b68a
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cinstruction.cpp
// Function: CALLNC::Execute()
void CALLNC::Execute()
{
	if ( !m_cpu->flags.carry ) {
		m_cpu->stack->Push( m_cpu->pc->Get() ) ;
		m_cpu->pc->Set( address ) ;
	} else
		m_cpu->pc->Next() ;
}

// Assembly:
movq 0x8(%rdi), %rax
cmpb $0x0, 0x11(%rax)
je 0x4099c7
movq 0x18(%rax), %rdi
jmp 0x40b68a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rax), %rdi
movq 0x28(%rax), %r14
callq 0x40b6ae
movzwl %ax, %esi
movq %r14, %rdi
callq 0x40b6f4
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
movzwl 0x1a(%rbx), %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x40b69e
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cinstruction.cpp
// Function: CALLNZ::Execute()
void CALLNZ::Execute()
{
	if ( !m_cpu->flags.zero ) {
		m_cpu->stack->Push( m_cpu->pc->Get() ) ;
		m_cpu->pc->Set( address ) ;
	} else
		m_cpu->pc->Next() ;
}

// Assembly:
movq 0x8(%rdi), %rax
cmpb $0x0, 0x10(%rax)
je 0x409a47
movq 0x18(%rax), %rdi
jmp 0x40b68a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rax), %rdi
movq 0x28(%rax), %r14
callq 0x40b6ae
movzwl %ax, %esi
movq %r14, %rdi
callq 0x40b6f4
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
movzwl 0x1a(%rbx), %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x40b69e
// File: /workspace/github_cpp_makefile_star2_O3/stacksmith[P]picoasm/cinstruction.cpp
// Function: CALLZ::Execute()
void CALLZ::Execute()
{
	if ( m_cpu->flags.zero ) {
		m_cpu->stack->Push( m_cpu->pc->Get() ) ;
		m_cpu->pc->Set( address ) ;
	} else
		m_cpu->pc->Next() ;
}

// Assembly:
movq 0x8(%rdi), %rax
cmpb $0x1, 0x10(%rax)
jne 0x409af5
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rax), %rdi
movq 0x28(%rax), %r14
callq 0x40b6ae
movzwl %ax, %esi
movq %r14, %rdi
callq 0x40b6f4
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
movzwl 0x1a(%rbx), %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x40b69e
movq 0x18(%rax), %rdi
jmp 0x40b68a