LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8e3c
movq 0x18(%rbx), %rdi
callq 0x7eb8
movq (%rax), %rcx
movq %rcx, 0x18(%rbx)
addq $0x20, %rbx
leaq 0x8(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x59a2
movq 0x81a5(%rip), %rbx      # 0x10fe8
leaq 0x3237(%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_O1/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 0x8ec7
movq 0x18(%rbx), %rdi
callq 0x7eb2
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x8f14
movq 0x80e3(%rip), %rcx      # 0x10fa0
cmpb $0x0, (%rcx)
je 0x8f10
incl 0x8(%rax)
jmp 0x8f14
movq 0x811a(%rip), %rbx      # 0x10fe8
leaq 0x31c3(%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 0x7eb8
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x8f48
movq 0x8066(%rip), %rcx      # 0x10fa0
cmpb $0x0, (%rcx)
je 0x8f44
incl 0x8(%rax)
jmp 0x8f48
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x89c8
leaq 0x20(%rsp), %r14
movq -0x8(%r14), %rax
movq %rax, 0x18(%rbx)
addq $0x20, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x59a2
movq (%r14), %rdi
testq %rdi, %rdi
je 0x8f7e
callq 0x59f4
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8f8d
callq 0x59f4
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8fac
callq 0x59f4
jmp 0x8fac
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8fbb
callq 0x59f4
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9b1a
movq 0x18(%rbx), %rdi
callq 0x7eb2
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x9a6b
movq 0x7543(%rip), %rcx      # 0x10fa0
cmpb $0x0, (%rcx)
je 0x9a67
incl 0x8(%rax)
jmp 0x9a6b
lock
incl 0x8(%rax)
movq 0x18(%rbx), %rdi
callq 0x7eb2
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x9a9e
movq 0x7510(%rip), %rcx      # 0x10fa0
cmpb $0x0, (%rcx)
je 0x9a9a
incl 0x8(%rax)
jmp 0x9a9e
lock
incl 0x8(%rax)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x9ac7
movq 0x10(%rsp), %rdi
callq 0x7eac
movq (%rax), %rdi
movq (%rdi), %rax
movq %rsp, %rsi
callq *0x10(%rax)
testb %al, %al
jne 0x9af0
movq (%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x9af4
movq (%rsp), %rdi
callq 0x7eac
movq (%rax), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
callq *0x10(%rax)
testb %al, %al
je 0x9af4
xorl %ebx, %ebx
jmp 0x9af6
movb $0x1, %bl
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9b05
callq 0x59f4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9b14
callq 0x59f4
movb $0x1, %al
testb %bl, %bl
je 0x9b5e
movq 0x74c7(%rip), %rbx      # 0x10fe8
leaq 0x2636(%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 0x9b7b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9b7b
callq 0x59f4
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9b8a
callq 0x59f4
movq %rbx, %rdi
callq 0x32b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9be3
movq 0x18(%rbx), %rdi
callq 0x7eac
movq (%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0x9be3
movq 0x18(%rbx), %rdi
callq 0x7eac
movq (%rax), %rdi
callq 0x7eac
movq (%rax), %rcx
movq %rcx, 0x18(%rbx)
addq $0x20, %rbx
leaq 0x8(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x59a2
movq 0x73fe(%rip), %rbx      # 0x10fe8
leaq 0x258c(%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_O1/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), %xmm1
movss 0x4(%rdi), %xmm2
subss (%rsi), %xmm1
subss 0x4(%rsi), %xmm2
movss 0x8(%rdi), %xmm0
subss 0x8(%rsi), %xmm0
mulss %xmm2, %xmm2
mulss %xmm1, %xmm1
addss %xmm2, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x2200
sqrtss %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x31c4
testl %r14d, %r14d
jle 0x24e4
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 0x3d31(%rip), %r14      # 0x6148
movq %r14, %rdi
callq 0x33bf
movsd %xmm0, 0x8(%rsp)
movsd 0x3d2b(%rip), %xmm0     # 0x6158
movsd %xmm0, 0x10(%rsp)
movsd 0x3d15(%rip), %xmm0     # 0x6150
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
callq 0x33bf
movaps %xmm0, 0x50(%rsp)
movaps 0x3cfb(%rip), %xmm0     # 0x6150
movaps %xmm0, 0x40(%rsp)
movq %r14, %rdi
callq 0x33bf
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 0x3cc3(%rip), %xmm2     # 0x6158
movapd 0x40(%rsp), %xmm4
movapd %xmm4, %xmm3
movhpd 0x3ca9(%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 0x2417
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 0x250b
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2130
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x324c
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 0x27b9
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 0x35f3(%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
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
andq %rax, %rcx
movl $0x0, 0x68(%rbx)
movb $0x5, 0x6c(%rbx)
addq %rcx, %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 0x27ef
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 0x2833
movq %rax, %rbx
jmp 0x2814
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x2140
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x282b
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x32db
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d47e0
leaq 0x17cc33(%rip), %rdi    # 0x5812a5
callq 0x4e4010
leaq 0x17cc2e(%rip), %rdi    # 0x5812ac
callq 0x4e4010
leaq 0x17c98e(%rip), %rdi    # 0x581018
leaq 0x17ca55(%rip), %rsi    # 0x5810e6
leaq 0x17ca56(%rip), %rdx    # 0x5810ee
xorl %eax, %eax
callq 0x4d47e0
leaq 0x17cc32(%rip), %rdi    # 0x5812d8
callq 0x4e4010
leaq 0x17cc95(%rip), %rdi    # 0x581347
popq %rbp
jmp 0x4e4010
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19c423(%rip), %rcx    # 0x5a19f2
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x47d700
cmpq $0x0, 0x8(%r14)
je 0x40560d
movl $0x1, %r12d
xorl %eax, %eax
movq (%r14), %rcx
movsbl (%rcx,%rax), %edi
callq 0x4c27a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x47d140
movl %r12d, %eax
incl %r12d
cmpq %rax, 0x8(%r14)
ja 0x4055ea
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40561b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x405631
movq (%r15), %rsi
incq %rsi
callq 0x40d0c0
movq %r14, %rdi
callq 0x4ad960
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17bdae(%rip), %rsi    # 0x58150d
movl $0xc, %edx
movq %r15, %rdi
callq 0x4761b0
incl %ebx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x476ab0
movq %rax, %rbx
leaq 0x17c6d7(%rip), %rsi    # 0x581e5a
movl $0x2, %edx
movq %rax, %rdi
callq 0x4761b0
testq %r14, %r14
je 0x4057ad
movq %r14, %rdi
callq 0x401118
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x4761b0
jmp 0x4057c6
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x457030
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x457300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x475cb0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x475280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4055a4
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x4058c1
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x40d0c0
leaq 0x1eb898(%rip), %r15    # 0x5f1160
xorl %ebx, %ebx
leaq -0x58(%rbp), %r14
movq (%r15), %rsi
movq %r14, %rdi
callq 0x47ecc0
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 0x40d0c0
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 0x40d0c0
movq %rbx, %rdi
callq 0x4ad960
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
addq $0x18, %r15
cmpq %r15, %r12
je 0x40697b
movq 0x8(%r14), %r13
movq 0x10(%r12), %rbx
movq 0x28(%rbx), %rdx
cmpq %r13, %rdx
jne 0x406972
testq %rdx, %rdx
je 0x40699e
movq (%r14), %rsi
movq 0x20(%rbx), %rdi
callq 0x401080
testl %eax, %eax
je 0x40699e
movq (%r12), %r12
cmpq %r15, %r12
jne 0x40694f
movq -0x30(%rbp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%r14), %rdx
leaq 0x10(%r14), %rsi
cmpq %rsi, %rdx
je 0x4069c0
movq %rdx, (%rax)
movq (%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x4069c6
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 0x4069de
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
addq $0x30, %r15
cmpq %r15, %r12
je 0x406a43
movq 0x8(%r14), %r13
movq 0x10(%r12), %rbx
movq 0x28(%rbx), %rdx
cmpq %r13, %rdx
jne 0x406a3a
testq %rdx, %rdx
je 0x406a66
movq (%r14), %rsi
movq 0x20(%rbx), %rdi
callq 0x401080
testl %eax, %eax
je 0x406a66
movq (%r12), %r12
cmpq %r15, %r12
jne 0x406a17
movq -0x30(%rbp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%r14), %rdx
leaq 0x10(%r14), %rsi
cmpq %rsi, %rdx
je 0x406a88
movq %rdx, (%rax)
movq (%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x406a8e
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 0x406aa6
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
addq $0x48, %r15
cmpq %r15, %r12
je 0x406b0b
movq 0x8(%r14), %r13
movq 0x10(%r12), %rbx
movq 0x28(%rbx), %rdx
cmpq %r13, %rdx
jne 0x406b02
testq %rdx, %rdx
je 0x406b2e
movq (%r14), %rsi
movq 0x20(%rbx), %rdi
callq 0x401080
testl %eax, %eax
je 0x406b2e
movq (%r12), %r12
cmpq %r15, %r12
jne 0x406adf
movq -0x30(%rbp), %rax
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq (%r14), %rdx
leaq 0x10(%r14), %rsi
cmpq %rsi, %rdx
je 0x406b50
movq %rdx, (%rax)
movq (%rsi), %rcx
movq %rcx, 0x10(%rax)
jmp 0x406b56
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 0x406b6e
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
cmpq %rdi, %r12
sete %bl
je 0x4089d2
movq %rdi, %r14
movq %rdi, -0x30(%rbp)
movq 0x10(%r12), %rsi
movl 0x24(%rsi), %eax
leal -0x2(%rax), %ecx
cmpl $0x3, %ecx
jb 0x4089b4
xorl %r13d, %r13d
cmpl $0x1, %eax
sete %r13b
addl %r13d, %r13d
movq 0x10(%rsi), %rax
subq 0x8(%rsi), %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x4089b4
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movl %r13d, %edx
callq 0x408edc
movq %r15, %rsi
callq 0x405872
movl %eax, %r15d
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x408968
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x40d0c0
movq 0x10(%r12), %r14
movl (%r14), %esi
testl %r15d, %r15d
js 0x4089c6
movl %esi, -0x78(%rbp)
leaq 0x8(%r14), %rsi
leaq -0x70(%rbp), %rdi
callq 0x408fe2
movq 0x20(%r14), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %r14
movq %r14, %rdi
movl %r15d, %esi
leaq -0x78(%rbp), %rdx
movl %r13d, %ecx
callq 0x406b7e
movl %eax, %r15d
leaq -0x70(%rbp), %rdi
callq 0x409158
testb %r15b, %r15b
je 0x4089d2
movq (%r12), %r12
cmpq %r14, %r12
sete %bl
jne 0x408903
jmp 0x4089d2
leaq 0x178d67(%rip), %rdx    # 0x581734
callq 0x405742
andb $0x1, %bl
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x409158
jmp 0x408a10
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x408a10
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x40d0c0
movq %rbx, %rdi
callq 0x4ad960
// File: /workspace/github_cpp_makefile_star2_O1/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 0x408b4e
testb %al, %al
je 0x408b3c
movq %rbx, %rdi
callq 0x405936
testb %al, %al
je 0x408b3c
leaq 0x18(%rbx), %rax
movq %rbx, -0x30(%rbp)
movq 0x18(%rbx), %r15
movq %rax, -0x40(%rbp)
cmpq %rax, %r15
je 0x408ab6
movq -0x30(%rbp), %rax
leaq 0x30(%rax), %r13
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq %r13, -0x38(%rbp)
je 0x408aad
movq 0x10(%r15), %rbx
movq 0x28(%rbx), %r14
movq -0x38(%rbp), %r12
movq 0x10(%r12), %rax
cmpq 0x28(%rax), %r14
jne 0x408aa4
testq %r14, %r14
je 0x408acd
movq 0x20(%rax), %rsi
movq 0x20(%rbx), %rdi
movq %r14, %rdx
callq 0x401080
testl %eax, %eax
je 0x408acd
movq (%r12), %r12
cmpq %r13, %r12
jne 0x408a80
movq (%r15), %r15
cmpq -0x40(%rbp), %r15
jne 0x408a6e
movq -0x30(%rbp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4088dc
movq $0x5f4580, %rbx         # imm = 0x5F4580
leaq 0x178d03(%rip), %rsi    # 0x5817de
movl $0x18, %edx
movq %rbx, %rdi
callq 0x4761b0
movq 0x10(%r15), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0x4761b0
movq %rax, %rbx
leaq 0x178cf1(%rip), %rsi    # 0x5817f7
movl $0x1c, %edx
movq %rax, %rdi
callq 0x4761b0
movq 0x10(%r12), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0x4761b0
leaq 0x18a92a(%rip), %rsi    # 0x593459
movl $0x2, %edx
movq %rax, %rdi
callq 0x4761b0
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_O1/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 0x17d9ef(%rip), %rsi    # 0x58655f
callq 0x4e35a0
movq %rax, %rbx
testq %rax, %rax
je 0x408bf1
leaq -0x150(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
callq 0x4e32f0
testq %rax, %rax
je 0x408cad
xorl %r15d, %r15d
leaq -0x150(%rbp), %r12
movl %r15d, %esi
movq %r12, %rdx
callq 0x408dc2
testq %rax, %rax
je 0x408bd4
movq %rax, %r13
movl $0x18, %edi
callq 0x40df60
movq %r13, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x40f070
incq 0x10(%r14)
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdx
callq 0x4e32f0
incl %r15d
testq %rax, %rax
jne 0x408ba4
jmp 0x408cad
addq $0x60, %r14
leaq 0x1785cf(%rip), %rsi    # 0x5811cb
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x408f42
leaq 0x1785cd(%rip), %rsi    # 0x5811df
movq %r15, %rdi
callq 0x47e260
leaq -0x140(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x408c47
movq %rdx, -0x150(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x140(%rbp)
jmp 0x408c4e
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, -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 0x408c81
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x40d0c0
movq -0x150(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x405742
movq -0x150(%rbp), %rdi
cmpq %r14, %rdi
je 0x408cad
movq -0x140(%rbp), %rsi
incq %rsi
callq 0x40d0c0
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 0x408cf9
movq -0x140(%rbp), %rsi
jmp 0x408cf1
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x408cf9
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x40d0c0
movq %rbx, %rdi
callq 0x4ad960
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x408d3b
btq %rcx, %rax
jae 0x408d27
incq %rsi
jmp 0x408d13
movabsq $0x800000000002401, %rax # imm = 0x800000000002401
btq %rcx, %rax
jae 0x408d3b
xorl %eax, %eax
popq %rbp
retq
movl $0x1, %eax
xorl %ecx, %ecx
movabsq $0xc00130100002601, %r8 # imm = 0xC00130100002601
movzbl -0x1(%rsi,%rax), %edi
cmpq $0x3b, %rdi
ja 0x408d5d
btq %rdi, %r8
jb 0x408d65
decq %rcx
incq %rax
jmp 0x408d4c
testq %rcx, %rcx
je 0x408d92
movq %rsi, %rax
subq %rcx, %rax
cmpq %rax, %rsi
jae 0x408d8d
negq %rcx
xorl %edi, %edi
movb (%rsi,%rdi), %r8b
movb %r8b, (%rdx,%rdi)
incq %rdi
decq %rcx
jne 0x408d7a
addq %rdi, %rdx
movb $0x0, (%rdx)
jmp 0x408d39
xorl %eax, %eax
cmpl $0x3a, %edi
ja 0x408d39
movl %edi, %r8d
movabsq $0x400130000000000, %r9 # imm = 0x400130000000000
btq %r8, %r9
jae 0x408d39
movb %dil, (%rdx)
movb $0x0, 0x1(%rdx)
subq %rcx, %rsi
incq %rsi
movq %rsi, %rax
jmp 0x408d39
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40df60
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 0x408d02
cmpb $0x0, (%r12)
je 0x408e92
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 0x405508
movq %r14, %rdi
movq %r13, %rsi
callq 0x4091c2
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x408e70
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x40d0c0
movq %r15, %rsi
movq %r12, %rdx
callq 0x408d02
testq %rax, %rax
je 0x408e8c
movq %rax, %r15
cmpb $0x0, -0x150(%rbp)
jne 0x408e2e
movq -0x30(%rbp), %rax
jmp 0x408ea9
movq %r14, %rdi
callq 0x409158
movl $0x28, %esi
movq %rbx, %rdi
callq 0x40d0c0
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 0x408ed3
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x40d0c0
movq %r14, %rdi
callq 0x4ad960
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x408f1f
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 0x408f38
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x198ac5(%rip), %rdx    # 0x5a19f2
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x405508
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1dfd65(%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_O1/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 0x40b6f2
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: ADDCY_SX_KK::Execute()
void ADDCY_SX_KK::Execute()
{
	uint16_t val = m_cpu->s[ sX ] + 1 + kk ;
	
	if ( m_cpu->flags.carry ) 
		val = m_cpu->s[ sX ] + 1 + kk ;
	else
		val = m_cpu->s[ sX ] + kk ;
	
	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
movzbl 0x11(%rax), %esi
addw 0x18(%rdi), %dx
addl %esi, %edx
movb %dl, (%rax,%rcx)
movzwl %dx, %eax
cmpl $0x100, %eax            # imm = 0x100
movq 0x8(%rdi), %rax
setae 0x11(%rax)
testl $0xfeff, %edx           # imm = 0xFEFF
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %ecx
cmpb $0x1, 0x11(%rax)
jne 0x40970f
movzwl %cx, %ecx
movzwl 0x12(%rdi), %edx
movzbl (%rax,%rdx), %edx
addl %edx, %ecx
incl %ecx
jmp 0x40971c
movzwl 0x12(%rdi), %edx
movzbl (%rax,%rdx), %edx
movzwl %cx, %ecx
addl %edx, %ecx
movzwl %cx, %ecx
movzwl 0x10(%rdi), %edx
movb %cl, (%rax,%rdx)
cmpl $0x100, %ecx            # imm = 0x100
movq 0x8(%rdi), %rax
setae 0x11(%rax)
testl $0x2ff, %ecx            # imm = 0x2FF
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: AND_SX_KK::Execute()
void AND_SX_KK::Execute()
{

	m_cpu->s[ sX ] = m_cpu->s[ sX ] & kk ;
	m_cpu->flags.carry = 0 ;
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;

	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movb 0x18(%rdi), %dl
andb %dl, (%rax,%rcx)
movq 0x8(%rdi), %rax
movb $0x0, 0x11(%rax)
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: AND_SX_SY::Execute()
void AND_SX_SY::Execute()
{

	m_cpu->s[ sX ] = m_cpu->s[ sX ] & m_cpu->s[ sY ] ;
	m_cpu->flags.carry = 0 ;
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;

	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movzwl 0x12(%rdi), %edx
movb (%rax,%rdx), %dl
andb %dl, (%rax,%rcx)
movq 0x8(%rdi), %rax
movb $0x0, 0x11(%rax)
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4099e1
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rax), %rdi
movq 0x28(%rax), %r14
callq 0x40b716
movzwl %ax, %esi
movq %r14, %rdi
callq 0x40b760
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
movzwl 0x1a(%rbx), %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x40b706
movq 0x18(%rax), %rdi
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/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 0x409a33
movq 0x18(%rax), %rdi
jmp 0x40b6f2
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rax), %rdi
movq 0x28(%rax), %r14
callq 0x40b716
movzwl %ax, %esi
movq %r14, %rdi
callq 0x40b760
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
movzwl 0x1a(%rbx), %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x40b706
// File: /workspace/github_cpp_makefile_star2_O1/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 0x409ab3
movq 0x18(%rax), %rdi
jmp 0x40b6f2
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rax), %rdi
movq 0x28(%rax), %r14
callq 0x40b716
movzwl %ax, %esi
movq %r14, %rdi
callq 0x40b760
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
movzwl 0x1a(%rbx), %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x40b706
// File: /workspace/github_cpp_makefile_star2_O1/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 0x409b61
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rax), %rdi
movq 0x28(%rax), %r14
callq 0x40b716
movzwl %ax, %esi
movq %r14, %rdi
callq 0x40b760
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
movzwl 0x1a(%rbx), %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x40b706
movq 0x18(%rax), %rdi
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: JUMPC::Execute()
void JUMPC::Execute()
{
	if ( m_cpu->flags.carry )
		m_cpu->pc->Set( address ) ;
	else
		m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdi
cmpb $0x1, 0x11(%rcx)
jne 0x40a061
movzwl 0x1a(%rax), %esi
popq %rbp
jmp 0x40b706
popq %rbp
jmp 0x40b6f2
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: JUMPNC::Execute()
void JUMPNC::Execute()
{
	if ( !m_cpu->flags.carry )
		m_cpu->pc->Set( address ) ;
	else
		m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdi
cmpb $0x0, 0x11(%rcx)
je 0x40a0b9
popq %rbp
jmp 0x40b6f2
movzwl 0x1a(%rax), %esi
popq %rbp
jmp 0x40b706
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: JUMPNZ::Execute()
void JUMPNZ::Execute()
{
	if ( !m_cpu->flags.zero )
		m_cpu->pc->Set( address ) ;
	else
		m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdi
cmpb $0x0, 0x10(%rcx)
je 0x40a115
popq %rbp
jmp 0x40b6f2
movzwl 0x1a(%rax), %esi
popq %rbp
jmp 0x40b706
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: JUMPZ::Execute()
void JUMPZ::Execute()
{
	if ( m_cpu->flags.zero )
		m_cpu->pc->Set( address ) ;
	else
		m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x8(%rdi), %rcx
movq 0x18(%rcx), %rdi
cmpb $0x1, 0x10(%rcx)
jne 0x40a175
movzwl 0x1a(%rax), %esi
popq %rbp
jmp 0x40b706
popq %rbp
jmp 0x40b6f2
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: OR_SX_KK::Execute()
void OR_SX_KK::Execute()
{
	m_cpu->s[ sX ] = m_cpu->s[ sX ] | kk ;
	m_cpu->flags.carry = 0 ;
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movb 0x18(%rdi), %dl
orb %dl, (%rax,%rcx)
movq 0x8(%rdi), %rax
movb $0x0, 0x11(%rax)
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: RETURNC::Execute()
void RETURNC::Execute()
{
	if ( m_cpu->flags.carry )
		m_cpu->pc->Set( m_cpu->stack->Pop() ) ;
	else
		m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rbx
cmpb $0x1, 0x11(%rax)
jne 0x40a61e
movq 0x28(%rax), %rdi
callq 0x40b7ee
movzwl %ax, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40b706
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: RETURNNC::Execute()
void RETURNNC::Execute()
{
	if ( !m_cpu->flags.carry )
		m_cpu->pc->Set( m_cpu->stack->Pop() ) ;
	else
		m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rbx
cmpb $0x0, 0x11(%rax)
je 0x40a66c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40b6f2
movq 0x28(%rax), %rdi
callq 0x40b7ee
movzwl %ax, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40b706
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: RETURNNZ::Execute()
void RETURNNZ::Execute()
{
	if ( !m_cpu->flags.zero )
		m_cpu->pc->Set( m_cpu->stack->Pop() ) ;
	else
		m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rbx
cmpb $0x0, 0x10(%rax)
je 0x40a6c6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40b6f2
movq 0x28(%rax), %rdi
callq 0x40b7ee
movzwl %ax, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40b706
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: RETURNZ::Execute()
void RETURNZ::Execute()
{
	if ( m_cpu->flags.zero )
		m_cpu->pc->Set( m_cpu->stack->Pop() ) ;
	else
		m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rbx
cmpb $0x1, 0x10(%rax)
jne 0x40a72c
movq 0x28(%rax), %rdi
callq 0x40b7ee
movzwl %ax, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40b706
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x40b6f2
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: RETURNI_DISABLE::Execute()
void RETURNI_DISABLE::Execute()
{
	m_cpu->pc->Set( m_cpu->stack->Pop() ) ;
	m_cpu->flags.carry = m_cpu->flags.preserved_carry ;
	m_cpu->flags.zero = m_cpu->flags.preserved_zero ;
	m_cpu->flags.interrupt_enable = false ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %r14
movq 0x28(%rax), %rdi
callq 0x40b7ee
movzwl %ax, %esi
movq %r14, %rdi
callq 0x40b706
movq 0x8(%rbx), %rax
movzwl 0x13(%rax), %ecx
movw %cx, 0x10(%rax)
movb $0x0, 0x12(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/stacksmith[P]picoasm/cinstruction.cpp
// Function: RL_SX::Execute()
void RL_SX::Execute()
{
	m_cpu->flags.carry = ( m_cpu->s[ sX ] & 0x80 ) != 0 ;

	m_cpu->s[ sX ] <<= 1 ;
	if ( m_cpu->flags.carry )
		m_cpu->s[ sX ] |= 1 ;

	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
movb (%rax,%rcx), %dl
shrb $0x7, %dl
movb %dl, 0x11(%rax)
shlb (%rax,%rcx)
movq 0x8(%rdi), %rax
cmpb $0x1, 0x11(%rax)
jne 0x40a836
movzwl 0x10(%rdi), %ecx
orb $0x1, (%rax,%rcx)
movq 0x8(%rdi), %rax
movzwl 0x10(%rdi), %ecx
cmpb $0x0, (%rax,%rcx)
sete 0x10(%rax)
movq 0x18(%rax), %rdi
popq %rbp
jmp 0x40b6f2