LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
movq 0x18(%rsp), %rax
subss (%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x20(%rsp), %rax
movss 0x4(%rax), %xmm0
movq 0x18(%rsp), %rax
subss 0x4(%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movss 0x8(%rax), %xmm0
movq 0x18(%rsp), %rax
subss 0x8(%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x14(%rsp), %xmm1
movss 0x14(%rsp), %xmm2
movss 0x10(%rsp), %xmm0
mulss 0x10(%rsp), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
movss 0xc(%rsp), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x42a0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movss %xmm0, 0x88(%rsp)
movb $0x0, 0x87(%rsp)
movslq 0x8c(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x86(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x42c0
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x42d0
jmp 0x24a9
leaq 0x86(%rsp), %rdi
callq 0x4350
movl $0x0, 0x70(%rsp)
movl 0x70(%rsp), %eax
cmpl 0x8c(%rsp), %eax
jge 0x261e
movss 0x88(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
leaq 0x8c57(%rip), %rdi      # 0xb140
leaq 0x8c48(%rip), %rsi      # 0xb138
callq 0x4360
movsd %xmm0, 0x38(%rsp)
jmp 0x24fd
movsd 0x38(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0x88(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x8c0f(%rip), %rdi      # 0xb140
leaq 0x8c00(%rip), %rsi      # 0xb138
callq 0x4360
movsd %xmm0, 0x28(%rsp)
jmp 0x2545
movsd 0x28(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movss 0x88(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x8bc7(%rip), %rdi      # 0xb140
leaq 0x8bb8(%rip), %rsi      # 0xb138
callq 0x4360
movsd %xmm0, 0x10(%rsp)
jmp 0x258d
movss 0x4(%rsp), %xmm1
movss 0x1c(%rsp), %xmm0
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm2
mulsd %xmm3, %xmm2
cvtsd2ss %xmm2, %xmm2
leaq 0x64(%rsp), %rdi
callq 0x4390
jmp 0x25b9
movq 0x48(%rsp), %rdi
movslq 0x70(%rsp), %rsi
callq 0x43d0
movq 0x64(%rsp), %rcx
movq %rcx, (%rax)
movl 0x6c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x70(%rsp)
jmp 0x24be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x86(%rsp), %rdi
callq 0x4350
jmp 0x2647
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x43f0
jmp 0x2647
movb $0x1, 0x87(%rsp)
testb $0x1, 0x87(%rsp)
jne 0x263a
movq 0x48(%rsp), %rdi
callq 0x43f0
movq 0x40(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x21c0
nopw %cs:(%rax,%rax)
// File: willprice[P]parallel-cpp-workshop/energy.cpp
// Function: calculate_energy(std::vector<part1::Point, std::allocator<part1::Point>> const&, std::vector<part1::Point, std::allocator<part1::Point>> const&)
double calculate_energy(const std::vector<Point> &group1,
                        const std::vector<Point> &group2)
{
    double total = 0;

    for (const Point &point1 : group1)
    {
        for (const Point &point2 : group2)
        {
            total += calculate_energy(point1, point2);
        }
    }

    return total;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4450
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4480
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x44b0
testb $0x1, %al
jne 0x26f7
jmp 0x2788
leaq 0x30(%rsp), %rdi
callq 0x44f0
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4450
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4480
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x44b0
testb $0x1, %al
jne 0x2743
jmp 0x2777
leaq 0x10(%rsp), %rdi
callq 0x44f0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x2660
addsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x4500
jmp 0x272e
jmp 0x2779
leaq 0x30(%rsp), %rdi
callq 0x4500
jmp 0x26df
movsd 0x40(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4520
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x2810
movsd %xmm0, 0x10(%rsp)
jmp 0x27d9
leaq 0x30(%rsp), %rdi
callq 0x28a0
movsd 0x10(%rsp), %xmm0
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x28a0
movq 0x20(%rsp), %rdi
callq 0x21c0
// File: willprice[P]parallel-cpp-workshop/include/part1.h
// Function: auto part1::parallel::mapReduce<mapreduce_energy(std::vector<part1::Point, std::allocator<part1::Point>> const&, std::vector<part1::Point, std::allocator<part1::Point>> const&)::$_0, std::plus<double>, part1::Point>(mapreduce_energy(std::vector<part1::Point, std::allocator<part1::Point>> const&, std::vector<part1::Point, std::allocator<part1::Point>> const&)::$_0, std::plus<double>, std::vector<part1::Point, std::allocator<part1::Point>> const&)
auto mapReduce(MAPFUNC mapfunc, REDFUNC redfunc, const std::vector<ARGS>&... args)
{
    typedef typename std::result_of<MAPFUNC(ARGS...)>::type RETURN_TYPE;

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

    RETURN_TYPE result =
         tbb::parallel_reduce( tbb::blocked_range<int>(0,nvals),
                               RETURN_TYPE(0),
               [&](tbb::blocked_range<int> r, RETURN_TYPE task_result)
         {
             for (int i=r.begin(); i<r.end(); ++i)
             {
                 task_result = redfunc(task_result, mapfunc(args[i]...) );
             }

             return task_result;

         }, redfunc );

    return result;                               
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x46c0
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %edx
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %ecx
callq 0x46d0
movq 0x8(%rsp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
leaq 0x67(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x67(%rsp), %rcx
callq 0x2c60
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: willprice[P]parallel-cpp-workshop/include/part1.h
// Function: auto part1::mapReduce<mapreduce_energy(std::vector<part1::Point, std::allocator<part1::Point>> const&, std::vector<part1::Point, std::allocator<part1::Point>> const&)::$_0::operator()(part1::Point const&) const::'lambda'(part1::Point const&), std::plus<double>, part1::Point>(mapreduce_energy(std::vector<part1::Point, std::allocator<part1::Point>> const&, std::vector<part1::Point, std::allocator<part1::Point>> const&)::$_0::operator()(part1::Point const&) const::'lambda'(part1::Point const&), std::plus<double>, std::vector<part1::Point, std::allocator<part1::Point>> const&)
auto mapReduce(MAPFUNC mapfunc, REDFUNC redfunc, const std::vector<ARGS>&... args)
{
    typedef typename std::result_of<MAPFUNC(ARGS...)>::type RETURN_TYPE;
     
    int nvals=detail::get_min_container_size(args...);

    if (nvals == 0)
    {
        return RETURN_TYPE();
    }

    RETURN_TYPE result = mapfunc(args[0]...);

    if (nvals == 1)
    {
        return result;
    }
         
    for (size_t i=1; i<nvals; ++i)
    {
        result = redfunc( result, mapfunc(args[i]...) );
    }
     
    return result;
}

// Assembly:
subq $0x58, %rsp
movlpd %xmm0, 0x34(%rsp)
movss %xmm1, 0x3c(%rsp)
movq 0x34(%rsp), %rax
movq %rax, 0x44(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x4c(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x46c0
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x3cba
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x3d60
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x55f0
movq %rax, %rsi
leaq 0x44(%rsp), %rdi
callq 0x3d70
movsd %xmm0, 0x18(%rsp)
cmpl $0x1, 0x24(%rsp)
jne 0x3cf0
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x3d60
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq 0x24(%rsp), %rcx
cmpq %rcx, %rax
jae 0x3d54
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x55f0
movq %rax, %rsi
leaq 0x44(%rsp), %rdi
callq 0x3d70
movsd %xmm0, 0x8(%rsp)
leaq 0x33(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x55c0
movsd %xmm0, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3cf9
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x487510
movq %rax, %rsi
leaq 0x18689b(%rip), %rdi    # 0x58b086
leaq 0x186862(%rip), %rdx    # 0x58b054
leaq 0x186867(%rip), %rcx    # 0x58b060
movb $0x0, %al
callq 0x4de360
leaq 0x186893(%rip), %rdi    # 0x58b09a
movb $0x0, %al
callq 0x4de360
leaq 0x18688d(%rip), %rdi    # 0x58b0a2
movb $0x0, %al
callq 0x4de360
leaq 0x1868ac(%rip), %rdi    # 0x58b0cf
leaq 0x186973(%rip), %rsi    # 0x58b19d
leaq 0x186974(%rip), %rdx    # 0x58b1a5
movb $0x0, %al
callq 0x4de360
leaq 0x186969(%rip), %rdi    # 0x58b1a8
movb $0x0, %al
callq 0x4de360
leaq 0x1869cb(%rip), %rdi    # 0x58b218
movb $0x0, %al
callq 0x4de360
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x4859c0
movq -0x30(%rbp), %rdi
leaq 0x1a5ddf(%rip), %rsi    # 0x5aba32
callq 0x486b20
jmp 0x405c5a
movl $0x0, -0x18(%rbp)
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x48(%rbp)
callq 0x485d00
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x405ccf
movq -0x40(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x486010
movq %rax, -0x50(%rbp)
jmp 0x405c91
movq -0x50(%rbp), %rax
movsbl (%rax), %edi
callq 0x4cc320
movq -0x30(%rbp), %rdi
movsbl %al, %esi
callq 0x4860e0
jmp 0x405cab
jmp 0x405cad
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x405c61
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x485ad0
jmp 0x405cec
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x405ce2
movq -0x30(%rbp), %rdi
callq 0x485ad0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4b74e0
nopw %cs:(%rax,%rax)
// File: stacksmith[P]picoasm/cassembler.cpp
// Function: CAssembler::getRegister(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int CAssembler::getRegister( string name ) 
{

  // If the name is a register name then get it.
  // Otherwise it must be a constant so we return

  if( (name[0] == 's' || name[0] == 'S') && name.length() == 2) {
    if( (name[1] >= '0' && name[1] <= '9') || (name[1] >= 'a' && name[1] <= 'f')
	|| (name[1] >= 'A' && name[1] <= 'F')) {
      
      int reg ;
      
      if ( sscanf( name.c_str() + 1, "%X", &reg ) != 1 )
	return -1 ;
      
      if ( reg < 0 || reg > 15 )
	return -1 ;
      
      return reg ;
      
    }
  }
  // wasn't a register.
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x486010
movsbl (%rax), %eax
cmpl $0x73, %eax
je 0x405e79
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x486010
movsbl (%rax), %eax
cmpl $0x53, %eax
jne 0x405f5f
movq -0x28(%rbp), %rdi
callq 0x485d00
cmpq $0x2, %rax
jne 0x405f5f
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x486010
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x405eb8
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x486010
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x405f10
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x486010
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x405ee4
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x486010
movsbl (%rax), %eax
cmpl $0x66, %eax
jle 0x405f10
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x486010
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x405f5d
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x486010
movsbl (%rax), %eax
cmpl $0x46, %eax
jg 0x405f5d
movq -0x28(%rbp), %rdi
callq 0x487510
movq %rax, %rdi
addq $0x1, %rdi
leaq 0x185753(%rip), %rsi    # 0x58b67a
leaq -0x1c(%rbp), %rdx
movb $0x0, %al
callq 0x4de5c0
cmpl $0x1, %eax
je 0x405f40
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x405f66
cmpl $0x0, -0x1c(%rbp)
jl 0x405f4c
cmpl $0xf, -0x1c(%rbp)
jle 0x405f55
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x405f66
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x405f66
jmp 0x405f5f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4881b0
movq -0x78(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x405c20
jmp 0x405f9f
leaq -0x60(%rbp), %rdi
callq 0x485ad0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0x1f, %rax
jae 0x406029
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x1f919c(%rip), %rax    # 0x5ff160
movq (%rax,%rcx,8), %rsi
leaq -0x40(%rbp), %rdi
callq 0x40a3c0
movb %al, -0x79(%rbp)
jmp 0x405fd6
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x405fdf
jmp 0x40601c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0x406037
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x485ad0
jmp 0x40604c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x485ad0
jmp 0x40604c
jmp 0x40601e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x405faf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x485ad0
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x4b74e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x40a5d0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x40a5f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0x40a650
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x40a620
testb $0x1, %al
jne 0x407501
jmp 0x40754a
leaq -0x20(%rbp), %rdi
callq 0x40a710
movq -0x58(%rbp), %rsi
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x40a680
testb $0x1, %al
jne 0x407520
jmp 0x407537
leaq -0x20(%rbp), %rdi
callq 0x40a710
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
callq 0x4881b0
jmp 0x407557
jmp 0x407539
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x40a7d0
movq %rax, -0x38(%rbp)
jmp 0x4074dd
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x485a20
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x40a870
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x40a890
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x40a8f0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x40a8c0
testb $0x1, %al
jne 0x4075e1
jmp 0x40762a
leaq -0x20(%rbp), %rdi
callq 0x40a920
movq -0x58(%rbp), %rsi
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x40a680
testb $0x1, %al
jne 0x407600
jmp 0x407617
leaq -0x20(%rbp), %rdi
callq 0x40a920
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
callq 0x4881b0
jmp 0x407637
jmp 0x407619
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x40a940
movq %rax, -0x38(%rbp)
jmp 0x4075bd
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x485a20
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdx, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x40a9e0
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
callq 0x40aa00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
addq $0x48, %rdi
callq 0x40aa60
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x40aa30
testb $0x1, %al
jne 0x4076c1
jmp 0x40770a
leaq -0x20(%rbp), %rdi
callq 0x40aa90
movq -0x58(%rbp), %rsi
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x40a680
testb $0x1, %al
jne 0x4076e0
jmp 0x4076f7
leaq -0x20(%rbp), %rdi
callq 0x40aa90
movq -0x50(%rbp), %rdi
movq (%rax), %rsi
callq 0x4881b0
jmp 0x407717
jmp 0x4076f9
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x40aab0
movq %rax, -0x38(%rbp)
jmp 0x40769d
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x485a20
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x409d50
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x409b9c
movb $0x0, -0x1(%rbp)
jmp 0x409d37
movq -0x58(%rbp), %rdi
callq 0x406060
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x409bb8
movb $0x0, -0x1(%rbp)
jmp 0x409d37
leaq -0x18(%rbp), %rdi
callq 0x40a870
leaq -0x20(%rbp), %rdi
callq 0x40a5d0
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
callq 0x40a5f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
callq 0x40a650
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x40a620
testb $0x1, %al
jne 0x409c0a
jmp 0x409d1a
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
callq 0x40a890
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rdi
addq $0x30, %rdi
callq 0x40a8f0
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x40a8c0
testb $0x1, %al
jne 0x409c4a
jmp 0x409d04
leaq -0x20(%rbp), %rdi
callq 0x40a710
movq (%rax), %rax
addq $0x20, %rax
movq %rax, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x40a920
movq -0x60(%rbp), %rdi
movq (%rax), %rsi
addq $0x20, %rsi
callq 0x40a680
testb $0x1, %al
jne 0x409c7d
jmp 0x409cee
movq $0x602580, %rdi         # imm = 0x602580
leaq 0x181cb8(%rip), %rsi    # 0x58b943
callq 0x47f700
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x40a710
movq -0x70(%rbp), %rdi
movq (%rax), %rsi
addq $0x20, %rsi
callq 0x488450
movq %rax, %rdi
leaq 0x181ca5(%rip), %rsi    # 0x58b95c
callq 0x47f700
movq %rax, -0x68(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x40a920
movq -0x68(%rbp), %rdi
movq (%rax), %rsi
addq $0x20, %rsi
callq 0x488450
movq %rax, %rdi
leaq 0x1937b6(%rip), %rsi    # 0x59d499
callq 0x47f700
movb $0x0, -0x1(%rbp)
jmp 0x409d37
jmp 0x409cf0
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x40a940
movq %rax, -0x48(%rbp)
jmp 0x409c23
jmp 0x409d06
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x40a7d0
movq %rax, -0x50(%rbp)
jmp 0x409be3
movq -0x58(%rbp), %rdi
callq 0x409930
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x409d33
movb $0x0, -0x1(%rbp)
jmp 0x409d37
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x190(%rbp)
addq $0x60, %rdi
callq 0x487510
movq %rax, %rdi
leaq 0x186822(%rip), %rsi    # 0x59059f
callq 0x4ed120
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x409e3a
movq -0x190(%rbp), %rdx
addq $0x60, %rdx
leaq 0x1815b2(%rip), %rsi    # 0x58b355
leaq -0x58(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x40ac50
movq -0x198(%rbp), %rsi
leaq 0x1815a8(%rip), %rdx    # 0x58b369
leaq -0x38(%rbp), %rdi
callq 0x40a730
jmp 0x409dcc
leaq -0x58(%rbp), %rdi
callq 0x485ad0
leaq -0x38(%rbp), %rdi
callq 0x487510
movq -0x190(%rbp), %rdi
movq %rax, %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x405dc0
jmp 0x409df4
movb $0x0, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x485ad0
jmp 0x409eb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x485ad0
jmp 0x409ec7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x485ad0
jmp 0x409ec7
movl $0x0, -0x174(%rbp)
leaq -0x170(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x4ece70
cmpq $0x0, %rax
je 0x409ea9
movq -0x190(%rbp), %rdi
movl -0x174(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x174(%rbp)
leaq -0x170(%rbp), %rdx
callq 0x40a0f0
movq %rax, -0x180(%rbp)
cmpq $0x0, -0x180(%rbp)
je 0x409ea7
movq -0x190(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x40ae40
jmp 0x409e44
leaq -0x188(%rbp), %rdi
callq 0x40a3f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x4b74e0
// File: 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
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x178(%rbp)
movl $0x28, %edi
callq 0x416f20
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x170(%rbp)
movl -0x14(%rbp), %esi
callq 0x40add0
jmp 0x40a132
movq -0x178(%rbp), %rdi
movq -0x170(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x140(%rbp), %rdx
callq 0x409ed0
movq %rax, -0x40(%rbp)
movsbl -0x140(%rbp), %eax
cmpl $0x0, %eax
jne 0x40a1c1
movq -0x28(%rbp), %rax
movq %rax, -0x180(%rbp)
cmpq $0x0, %rax
je 0x40a192
movq -0x180(%rbp), %rdi
callq 0x40adb0
movq -0x180(%rbp), %rdi
movl $0x28, %esi
callq 0x416080
movq $0x0, -0x8(%rbp)
jmp 0x40a29c
movq -0x170(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x28, %esi
callq 0x416080
jmp 0x40a2a9
jmp 0x40a1c3
movq -0x28(%rbp), %rax
movq %rax, -0x190(%rbp)
leaq -0x161(%rbp), %rdi
movq %rdi, -0x188(%rbp)
callq 0x4173f0
movq -0x188(%rbp), %rdx
leaq -0x160(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x405840
jmp 0x40a1fd
movq -0x190(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x40ae10
jmp 0x40a212
leaq -0x160(%rbp), %rdi
callq 0x485ad0
leaq -0x161(%rbp), %rdi
callq 0x417410
movq -0x178(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x140(%rbp), %rdx
callq 0x409ed0
movq %rax, -0x40(%rbp)
movsbl -0x140(%rbp), %eax
cmpl $0x0, %eax
jne 0x40a287
jmp 0x40a294
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x40a279
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x485ad0
leaq -0x161(%rbp), %rdi
callq 0x417410
jmp 0x40a2a9
jmp 0x40a289
cmpq $0x0, -0x40(%rbp)
jne 0x40a1c3
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4b74e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0x40a570
testb $0x1, %al
jne 0x40a537
leaq -0x15(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4173f0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x1a1524(%rip), %rsi    # 0x5aba32
callq 0x405840
jmp 0x40a515
leaq -0x15(%rbp), %rdi
callq 0x417410
jmp 0x40a554
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x417410
jmp 0x40a55e
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x40ba00
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4881b0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4b74e0
nopw (%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
leaq 0x1e994e(%rip), %rcx    # 0x5f71b8
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
andl $0xf00, %ecx            # imm = 0xF00
shrl $0x8, %ecx
movw %cx, 0x10(%rax)
movl -0x14(%rbp), %ecx
andl $0xf0, %ecx
shrl $0x4, %ecx
movw %cx, 0x12(%rax)
movl -0x14(%rbp), %ecx
andl $0xff, %ecx
shrl $0x0, %ecx
movw %cx, 0x18(%rax)
movl -0x14(%rbp), %ecx
andl $0xff, %ecx
shrl $0x0, %ecx
movw %cx, 0x16(%rax)
movl -0x14(%rbp), %ecx
andl $0x3f, %ecx
shrl $0x0, %ecx
movw %cx, 0x14(%rax)
movl -0x14(%rbp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
shrl $0x0, %ecx
movw %cx, 0x1a(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x1c(%rax)
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
movzwl 0x18(%rax), %edx
addl %edx, %ecx
movw %cx, -0xa(%rbp)
movzwl -0xa(%rbp), %ecx
cmpl $0xff, %ecx
setg %cl
movq 0x8(%rax), %rax
andb $0x1, %cl
movb %cl, 0x11(%rax)
movzwl -0xa(%rbp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0xb(%rbp)
je 0x40d98e
movzwl -0xa(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
sete %al
movb %al, -0xb(%rbp)
movq -0x18(%rbp), %rax
movb -0xb(%rbp), %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x10(%rcx)
movw -0xa(%rbp), %cx
movb %cl, %sil
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movb %sil, (%rcx,%rdx)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
addl $0x1, %ecx
movzwl 0x18(%rax), %edx
addl %edx, %ecx
movw %cx, -0xa(%rbp)
movq 0x8(%rax), %rax
testb $0x1, 0x11(%rax)
je 0x40dbb6
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movzwl 0x10(%rcx), %edx
movzbl (%rax,%rdx), %eax
addl $0x1, %eax
movzwl 0x18(%rcx), %ecx
addl %ecx, %eax
movw %ax, -0xa(%rbp)
jmp 0x40dbd0
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movzwl 0x10(%rcx), %edx
movzbl (%rax,%rdx), %eax
movzwl 0x18(%rcx), %ecx
addl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x18(%rbp), %rax
movw -0xa(%rbp), %cx
movb %cl, %sil
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movb %sil, (%rcx,%rdx)
movzwl -0xa(%rbp), %ecx
cmpl $0xff, %ecx
setg %cl
movq 0x8(%rax), %rax
andb $0x1, %cl
movb %cl, 0x11(%rax)
movzwl -0xa(%rbp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x40dc1b
movzwl -0xa(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
sete %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb -0x19(%rbp), %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x10(%rcx)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
testb $0x1, 0x11(%rax)
je 0x40dcf5
movq -0x18(%rbp), %rdx
movq 0x8(%rdx), %rax
movzwl 0x10(%rdx), %ecx
movzbl (%rax,%rcx), %eax
addl $0x1, %eax
movq 0x8(%rdx), %rcx
movzwl 0x12(%rdx), %edx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movw %ax, -0xa(%rbp)
jmp 0x40dd17
movq -0x18(%rbp), %rdx
movq 0x8(%rdx), %rax
movzwl 0x10(%rdx), %ecx
movzbl (%rax,%rcx), %eax
movq 0x8(%rdx), %rcx
movzwl 0x12(%rdx), %edx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movw %ax, -0xa(%rbp)
movq -0x18(%rbp), %rax
movw -0xa(%rbp), %cx
movb %cl, %sil
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movb %sil, (%rcx,%rdx)
movzwl -0xa(%rbp), %ecx
cmpl $0xff, %ecx
setg %cl
movq 0x8(%rax), %rax
andb $0x1, %cl
movb %cl, 0x11(%rax)
movzwl -0xa(%rbp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x40dd62
movzwl -0xa(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
sete %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb -0x19(%rbp), %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x10(%rcx)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
movzwl 0x18(%rax), %edx
andl %edx, %ecx
movb %cl, %sil
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movb %sil, (%rcx,%rdx)
movq 0x8(%rax), %rcx
movb $0x0, 0x11(%rcx)
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
cmpl $0x0, %ecx
sete %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x10(%rcx)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
movq 0x8(%rax), %rdx
movzwl 0x12(%rax), %esi
movzbl (%rdx,%rsi), %edx
andl %edx, %ecx
movb %cl, %sil
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movb %sil, (%rcx,%rdx)
movq 0x8(%rax), %rcx
movb $0x0, 0x11(%rcx)
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
cmpl $0x0, %ecx
sete %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x10(%rcx)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x10, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rax
testb $0x1, 0x11(%rax)
je 0x40e0ee
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411b40
movq -0x18(%rbp), %rdi
movzwl %ax, %esi
callq 0x411c00
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rdi
movzwl 0x1a(%rax), %esi
callq 0x411b10
jmp 0x40e0ff
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rax
testb $0x1, 0x11(%rax)
jne 0x40e1ae
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411b40
movq -0x18(%rbp), %rdi
movzwl %ax, %esi
callq 0x411c00
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rdi
movzwl 0x1a(%rax), %esi
callq 0x411b10
jmp 0x40e1bf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rax
testb $0x1, 0x10(%rax)
jne 0x40e26e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411b40
movq -0x18(%rbp), %rdi
movzwl %ax, %esi
callq 0x411c00
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rdi
movzwl 0x1a(%rax), %esi
callq 0x411b10
jmp 0x40e27f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rax
testb $0x1, 0x10(%rax)
je 0x40e32e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411b40
movq -0x18(%rbp), %rdi
movzwl %ax, %esi
callq 0x411c00
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rdi
movzwl 0x1a(%rax), %esi
callq 0x411b10
jmp 0x40e33f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq 0x28(%rax), %rdi
callq 0x411c90
movq -0x18(%rbp), %rdi
movzwl %ax, %esi
callq 0x411b10
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movb 0x14(%rcx), %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x11(%rcx)
movq 0x8(%rax), %rcx
movb 0x13(%rcx), %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x10(%rcx)
movq 0x8(%rax), %rax
movb $0x0, 0x12(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
andl $0x80, %ecx
cmpl $0x0, %ecx
setne %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x11(%rcx)
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %esi
shll %esi
movb %sil, (%rcx,%rdx)
movq 0x8(%rax), %rax
testb $0x1, 0x11(%rax)
je 0x40f568
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movzwl 0x10(%rcx), %ecx
movzbl (%rax,%rcx), %edx
orl $0x1, %edx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
cmpl $0x0, %ecx
sete %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x10(%rcx)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: stacksmith[P]picoasm/cinstruction.cpp
// Function: SL0_SX::Execute()
void SL0_SX::Execute()
{
	m_cpu->flags.carry = ( m_cpu->s[ sX ] & 0x80 ) != 0 ;

	m_cpu->s[ sX ] <<= 1 ;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
andl $0x80, %ecx
cmpl $0x0, %ecx
setne %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x11(%rcx)
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %esi
shll %esi
movb %sil, (%rcx,%rdx)
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
cmpl $0x0, %ecx
sete %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x10(%rcx)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: stacksmith[P]picoasm/cinstruction.cpp
// Function: SLA_SX::Execute()
void SLA_SX::Execute()
{
	bool c ;

	c = m_cpu->flags.carry ;

	m_cpu->flags.carry = ( m_cpu->s[ sX ] & 0x80 ) != 0 ;

	m_cpu->s[ sX ] <<= 1 ;
	if ( c )
		m_cpu->s[ sX ] |= 1 ;
	
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rcx), %rax
movb 0x11(%rax), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movq 0x8(%rcx), %rax
movzwl 0x10(%rcx), %edx
movzbl (%rax,%rdx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %dl
movq 0x8(%rcx), %rax
andb $0x1, %dl
movb %dl, 0x11(%rax)
movq 0x8(%rcx), %rax
movzwl 0x10(%rcx), %ecx
movzbl (%rax,%rcx), %edx
shll %edx
movb %dl, (%rax,%rcx)
testb $0x1, -0x9(%rbp)
je 0x40f8be
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movzwl 0x10(%rcx), %ecx
movzbl (%rax,%rcx), %edx
orl $0x1, %edx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
cmpl $0x0, %ecx
sete %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x10(%rcx)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: stacksmith[P]picoasm/cinstruction.cpp
// Function: SLX_SX::Execute()
void SLX_SX::Execute()
{
	m_cpu->flags.carry = ( m_cpu->s[ sX ] & 0x80 ) != 0 ;

	m_cpu->s[ sX ] <<= 1 ;
	if ( m_cpu->s[ sX ] & 0x02 )
		m_cpu->s[ sX ] |= 1 ;
	
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rcx), %rax
movzwl 0x10(%rcx), %edx
movzbl (%rax,%rdx), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %dl
movq 0x8(%rcx), %rax
andb $0x1, %dl
movb %dl, 0x11(%rax)
movq 0x8(%rcx), %rax
movzwl 0x10(%rcx), %edx
movzbl (%rax,%rdx), %esi
shll %esi
movb %sil, (%rax,%rdx)
movq 0x8(%rcx), %rax
movzwl 0x10(%rcx), %ecx
movzbl (%rax,%rcx), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x40f9b1
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movzwl 0x10(%rcx), %ecx
movzbl (%rax,%rcx), %edx
orl $0x1, %edx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
cmpl $0x0, %ecx
sete %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x10(%rcx)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: stacksmith[P]picoasm/cinstruction.cpp
// Function: SR0_SX::Execute()
void SR0_SX::Execute()
{
	m_cpu->flags.carry = m_cpu->s[ sX ] & 0x01 ;
	m_cpu->s[ sX ] >>= 1 ;
	m_cpu->flags.zero = m_cpu->s[ sX ] == 0 ;
	m_cpu->pc->Next() ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
andl $0x1, %ecx
cmpl $0x0, %ecx
setne %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x11(%rcx)
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %esi
sarl %esi
movb %sil, (%rcx,%rdx)
movq 0x8(%rax), %rcx
movzwl 0x10(%rax), %edx
movzbl (%rcx,%rdx), %ecx
cmpl $0x0, %ecx
sete %dl
movq 0x8(%rax), %rcx
andb $0x1, %dl
movb %dl, 0x10(%rcx)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x411ae0
addq $0x10, %rsp
popq %rbp
retq