LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/nicluo[P]sorting-numbers/sort.cpp
// Function: readFromFile(char*)
std::vector<int> readFromFile(char* filename) {
    std::vector<int> values = std::vector<int>();
    
    /* Open input file */
    std::ifstream in(filename);
    
    /* Read all integers from file */
    if(in) {
        int v;
        while(in >> v) {
            values.push_back(v);
        }
    }
    
    in.close();
    
    return values;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
je 0x2409
leaq 0x8(%rsp), %rdi
callq 0x2050
leaq 0x8(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x20b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x23e5
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2446
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2413
movq %rbx, %rdi
movq %r15, %rdx
callq 0x26a2
jmp 0x2413
jmp 0x2455
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2060
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2476
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2120
movq %r14, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/nicluo[P]sorting-numbers/sort.cpp
// Function: writeToFile(char*, std::vector<int, std::allocator<int>>&)
void writeToFile(char* filename, std::vector<int> &values) {
    /* Open output file */
    std::ofstream out;
    out.open(filename, std::ofstream::out);
    
    /* Write all integers to file */
    for(int v : values) {
        out << v << "\n";
    }
    
    out.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2190
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x2040
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x24eb
leaq 0x8(%rsp), %rbx
leaq 0xb54(%rip), %r14       # 0x301b
movl (%r15), %esi
movq %rbx, %rdi
callq 0x21a0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2130
addq $0x4, %r15
cmpq %r12, %r15
jne 0x24c7
leaq 0x8(%rsp), %rdi
callq 0x2140
movq 0x2ad4(%rip), %rax      # 0x4fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x20e0
leaq 0x100(%rsp), %rdi
callq 0x2070
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2538
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/nicluo[P]sorting-numbers/sort.cpp
// Function: sortHelper(std::vector<int, std::allocator<int>>&, int, int)
void sortHelper(std::vector<int> &values, int start, int end) {
    /* Check if already sorted */
    if(end - start <= 1) return;

    /* Pick the first element as the pivot,
       we already know the elements are random
       so this is as good as a random pivot */
    int pivot = values[start];

    int swapIndex = start + 1;
    for(int index = start + 1; index < end; index++) {
        /* Move elements smaller than pivot value to the front
           of the list */
        if(values[index] < pivot) {
            swap(values, index, swapIndex);
            swapIndex++;
        }
    }

    /* Swap pivot to appropriate point in list,
       since elements to the left of the pivot are smaller,
       and the pivot is at the zeroth position,
       it should swap with a smaller value, i.e. swapIndex - 1 */
    swap(values, start, swapIndex - 1);

    /* Sort sublists */
    sortHelper(values, start, swapIndex);
    sortHelper(values, swapIndex, end);
}

// Assembly:
movl %edx, %eax
subl %esi, %eax
cmpl $0x2, %eax
jl 0x25ea
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
leal -0x1(%rbx), %r13d
movslq %r15d, %rsi
movq (%r14), %rax
movl (%rax,%rsi,4), %ecx
leal 0x1(%rsi), %r15d
cmpl %ebx, %r15d
jge 0x25bc
movq %rsi, %rdx
movl 0x4(%rax,%rdx,4), %edi
cmpl %ecx, %edi
jge 0x25b1
movslq %r15d, %r15
movl (%rax,%r15,4), %r8d
movl %r8d, 0x4(%rax,%rdx,4)
movl %edi, (%rax,%r15,4)
incl %r15d
incq %rdx
cmpl %edx, %r13d
jne 0x2596
movl (%rax,%rsi,4), %ecx
movslq %r15d, %r12
movl -0x4(%rax,%r12,4), %edx
movl %edx, (%rax,%rsi,4)
movl %ecx, -0x4(%rax,%r12,4)
movq %r14, %rdi
movl %r12d, %edx
callq 0x2563
movl %ebx, %eax
subl %r12d, %eax
cmpl $0x2, %eax
jge 0x2581
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/nicluo[P]sorting-numbers/sort.cpp
// Function: main
int main(int argc, char *argv[]) {
    /* Must provide -f */
    if (argc != 3 || strncmp(argv[1], "-f", 3) != 0) {
        printUsage(argv[0]);
        return 1;
    }
    
    std::vector<int> values = readFromFile(argv[2]);
    sort(values);
    writeToFile(argv[2], values);
    
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
cmpl $0x3, %edi
jne 0x2621
movq 0x8(%rbx), %rax
cmpb $0x2d, (%rax)
jne 0x2621
cmpb $0x66, 0x1(%rax)
jne 0x2621
cmpb $0x0, 0x2(%rax)
je 0x2636
movq (%rbx), %rdi
callq 0x230c
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x10(%rbx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x23a8
movq 0x8(%r14), %rdx
subq (%r14), %rdx
shrq $0x2, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2563
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x247e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x267c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2120
xorl %eax, %eax
jmp 0x262e
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2699
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2120
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_arc.cc
// Function: Interp::arc_data_comp_r(int, int, int, double, double, double, double, double, double, double*, double*, int*, double)
int Interp::arc_data_comp_r(int move,    //!< either G_2 (cw arc) or G_3 (ccw arc)
                            int plane,
                           int side,    //!< either RIGHT or LEFT
                           double tool_radius,  //!< radius of the tool
                           double current_x,    //!< first coordinate of current point
                           double current_y,    //!< second coordinate of current point
                           double end_x,        //!< first coordinate of arc end point
                           double end_y,        //!< second coordinate of arc end point
                           double big_radius,   //!< radius of arc
                           double *center_x,    //!< pointer to first coordinate of center of arc
                           double *center_y,    //!< pointer to second coordinate of center of arc
                           int *turn,           //!< pointer to number of full or partial circles CCW
                           double tolerance)    //!< tolerance of differing radii
{
  double abs_radius;            // absolute value of big_radius

  abs_radius = fabs(big_radius);
  CHKS(((abs_radius <= tool_radius) && (((side == LEFT) && (move == G_3)) ||
                                       ((side == RIGHT) && (move == G_2)))),
      NCE_TOOL_RADIUS_NOT_LESS_THAN_ARC_RADIUS_WITH_COMP);

  return arc_data_r(move, plane, current_x, current_y, end_x, end_y, big_radius, 
             center_x, center_y, turn, tolerance);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rbp), %rax
movapd 0x264c7(%rip), %xmm7    # 0x32020
andpd %xmm5, %xmm7
ucomisd %xmm7, %xmm0
jae 0xbb8d
movq %rbx, %rdi
movaps %xmm1, %xmm0
movaps %xmm2, %xmm1
movaps %xmm3, %xmm2
movaps %xmm4, %xmm3
movapd %xmm5, %xmm4
movq %r8, %rcx
movq %r9, %r8
movq %rax, %r9
movaps %xmm6, %xmm5
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xac60
movl %ecx, %edx
xorl $0x2, %edx
movl %esi, %edi
xorl $0x1e, %edi
orl %edx, %edi
je 0xbba7
xorl $0x1, %ecx
movl %esi, %edx
xorl $0x14, %edx
orl %ecx, %edx
jne 0xbb63
leaq 0x265c3(%rip), %rdi     # 0x32171
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x35399(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x265e1(%rip), %rsi     # 0x321b6
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_check.cc
// Function: Interp::check_items(block_struct*, setup_struct*)
int Interp::check_items(block_pointer block,     //!< pointer to a block to be checked
                       setup_pointer settings)  //!< pointer to machine settings
{

  CHP(check_g_codes(block, settings));
  CHP(check_m_codes(block));
  CHP(check_other_codes(block));
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0xa1a0
testl %eax, %eax
jne 0xc279
movq %r15, %rdi
movq %r14, %rsi
callq 0xafe0
testl %eax, %eax
jne 0xc279
movq %r15, %rdi
movq %r14, %rsi
callq 0xa390
testl %eax, %eax
je 0xc2f0
movl %eax, %ebx
movq 0x34cde(%rip), %rax     # 0x40f60
movslq 0xd670(%rax), %rcx
cmpq $0x30, %rcx
jg 0xc2e3
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x27b01(%rip), %rsi     # 0x33daa
movl $0x50, %edx
callq 0xa8a0
movq 0x34ca6(%rip), %rax     # 0x40f60
movslq 0xd670(%rax), %rcx
leaq (%rcx,%rcx,4), %rdx
shlq $0x4, %rdx
xorl %esi, %esi
movb %sil, 0xc71f(%rax,%rdx)
incl %ecx
movl %ecx, 0xd670(%rax)
movb %sil, 0xc720(%rax,%rdx)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
jmp 0xc2e3
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::comp_set_current(setup_struct*, double, double, double)
int Interp::comp_set_current(setup_pointer settings, double x, double y, double z) {
    switch(settings->plane) {
    case CANON_PLANE_XY:
        settings->current_x = x;
        settings->current_y = y;
        settings->current_z = z;
        break;
    case CANON_PLANE_XZ:
        settings->current_x = y;
        settings->current_y = z;
        settings->current_z = x;
        break;
    default:
        ERS("BUG: Invalid plane in comp_set_current");
    }
    return INTERP_OK;
}

// Assembly:
movl 0xc67c(%rsi), %eax
cmpl $0x3, %eax
je 0xc96e
cmpl $0x1, %eax
jne 0xc989
movsd %xmm0, 0x600(%rsi)
movsd %xmm1, 0x608(%rsi)
movsd %xmm2, 0x610(%rsi)
jmp 0xc986
movsd %xmm1, 0x600(%rsi)
movsd %xmm2, 0x608(%rsi)
movsd %xmm0, 0x610(%rsi)
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x281c5(%rip), %rsi     # 0x34b5b
xorl %eax, %eax
callq 0xa850
movq 0x345bc(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x2769b(%rip), %rsi     # 0x3404d
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::comp_set_programmed(setup_struct*, double, double, double)
int Interp::comp_set_programmed(setup_pointer settings, double x, double y, double z) {
    switch(settings->plane) {
    case CANON_PLANE_XY:
        settings->program_x = x;
        settings->program_y = y;
        settings->program_z = z;
        break;
    case CANON_PLANE_XZ:
        settings->program_x = y;
        settings->program_y = z;
        settings->program_z = x;
        break;
    default:
        ERS("BUG: Invalid plane in comp_set_programmed");
    }
    return INTERP_OK;
}

// Assembly:
movl 0xc67c(%rsi), %eax
cmpl $0x3, %eax
je 0xcaaa
cmpl $0x1, %eax
jne 0xcac5
movsd %xmm0, 0xc690(%rsi)
movsd %xmm1, 0xc698(%rsi)
movsd %xmm2, 0xc6a0(%rsi)
jmp 0xcac2
movsd %xmm1, 0xc690(%rsi)
movsd %xmm2, 0xc698(%rsi)
movsd %xmm0, 0xc6a0(%rsi)
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x280da(%rip), %rsi     # 0x34bac
xorl %eax, %eax
callq 0xa850
movq 0x34480(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x27601(%rip), %rsi     # 0x340ef
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_control_mode(int, double, double, setup_struct*)
int Interp::convert_control_mode(int g_code,     //!< g_code being executed (G_61, G61_1, || G_64)
				double tolerance,    //tolerance for the path following in G64
				double naivecam_tolerance,    //tolerance for the naivecam
                                setup_pointer settings) //!< pointer to machine settings                 
{
  CHKS((settings->cutter_comp_side != OFF),
       (_("Cannot change control mode with cutter radius compensation on")));
  if (g_code == G_61) {
    SET_MOTION_CONTROL_MODE(CANON_EXACT_PATH, 0);
    settings->control_mode = CANON_EXACT_PATH;
  } else if (g_code == G_61_1) {
    SET_MOTION_CONTROL_MODE(CANON_EXACT_STOP, 0);
    settings->control_mode = CANON_EXACT_STOP;
  } else if (g_code == G_64) {
	if (tolerance >= 0) {
	    SET_MOTION_CONTROL_MODE(CANON_CONTINUOUS, tolerance);
	} else {
	    SET_MOTION_CONTROL_MODE(CANON_CONTINUOUS, 0);
	}
	if (naivecam_tolerance >= 0) {
	    SET_NAIVECAM_TOLERANCE(naivecam_tolerance);
	} else if (tolerance >= 0) {
	    SET_NAIVECAM_TOLERANCE(tolerance);   // if no naivecam_tolerance specified use same for both
	} else {
	    SET_NAIVECAM_TOLERANCE(0);
	}
    settings->control_mode = CANON_CONTINUOUS;
  } else 
    ERS(NCE_BUG_CODE_NOT_G61_G61_1_OR_G64);
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
cmpl $0x0, 0x624(%rdx)
je 0x10534
leaq 0x25026(%rip), %rdi     # 0x3550c
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x30a61(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x23dc8(%rip), %rsi     # 0x342d5
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x105f8
movq %rdx, %rbx
cmpl $0x280, %esi            # imm = 0x280
je 0x10586
cmpl $0x263, %esi            # imm = 0x263
je 0x1056c
cmpl $0x262, %esi            # imm = 0x262
jne 0x105b8
xorpd %xmm0, %xmm0
movl $0x2, %edi
callq 0xa0d0
movl $0x2, 0x5f8(%rbx)
jmp 0x105f6
xorpd %xmm0, %xmm0
movl $0x1, %edi
callq 0xa0d0
movl $0x1, 0x5f8(%rbx)
jmp 0x105f6
movsd %xmm1, -0x18(%rbp)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x105c4
xorpd %xmm0, %xmm0
movl $0x3, %edi
callq 0xa0d0
movsd -0x18(%rbp), %xmm0
ucomisd 0x23920(%rip), %xmm0    # 0x33ed0
jae 0x105e7
xorpd %xmm0, %xmm0
jmp 0x105e7
leaq 0x24f8b(%rip), %rdi     # 0x3554a
jmp 0x104e6
movl $0x3, %edi
movsd %xmm0, -0x20(%rbp)
callq 0xa0d0
movsd -0x18(%rbp), %xmm0
ucomisd 0x238f0(%rip), %xmm0    # 0x33ed0
jae 0x105e7
movsd -0x20(%rbp), %xmm0
callq 0xa960
movl $0x3, 0x5f8(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::rotate(double*, double*, double)
void Interp::rotate(double *x, double *y, double theta) {
    double xx, yy;
    double t = D2R(theta);
    xx = *x * cos(t) - *y * sin(t); 
    yy = *x * sin(t) + *y * cos(t);
    *x = xx;
    *y = yy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
mulsd 0x238c0(%rip), %xmm0    # 0x33ed8
movq %rsi, %r14
divsd 0x238bd(%rip), %xmm0    # 0x33ee0
movsd %xmm0, -0x30(%rbp)
movsd (%rsi), %xmm1
movsd %xmm1, -0x20(%rbp)
callq 0xb550
movsd %xmm0, -0x28(%rbp)
movsd (%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa1d0
mulsd -0x18(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd (%r14), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xa1d0
movsd %xmm0, -0x18(%rbp)
movsd (%rbx), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0xb550
mulsd -0x38(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%r14)
movsd %xmm1, (%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_cutter_compensation(int, block_struct*, setup_struct*)
int Interp::convert_cutter_compensation(int g_code,      //!< must be G_40, G_41, or G_42             
                                       block_pointer block,     //!< pointer to a block of RS274 instructions
                                       setup_pointer settings)  //!< pointer to machine settings             
{

  if (g_code == G_40) {
    CHP(convert_cutter_compensation_off(settings));
  } else if (g_code == G_41) {
    CHP(convert_cutter_compensation_on(LEFT, block, settings));
  } else if (g_code == G_42) {
    CHP(convert_cutter_compensation_on(RIGHT, block, settings));
  } else if (g_code == G_41_1) {
    CHP(convert_cutter_compensation_on(LEFT, block, settings));
  } else if (g_code == G_42_1) {
    CHP(convert_cutter_compensation_on(RIGHT, block, settings));
  } else
    ERS("BUG: Code not G40, G41, G41.1, G42, G42.2");

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x19a, %esi            # imm = 0x19A
jle 0x10bab
cmpl $0x19b, %esi            # imm = 0x19B
je 0x10bc3
cmpl $0x1a4, %esi            # imm = 0x1A4
je 0x10ba4
cmpl $0x1a5, %esi            # imm = 0x1A5
jne 0x10c47
movl $0x1, %esi
jmp 0x10bc8
cmpl $0x190, %esi            # imm = 0x190
je 0x10c3d
cmpl $0x19a, %esi            # imm = 0x19A
jne 0x10c47
movl $0x2, %esi
callq 0xa260
testl %eax, %eax
je 0x10c39
movl %eax, %ebx
movq 0x30386(%rip), %r15     # 0x40f60
movslq 0xd670(%r15), %rax
cmpq $0x30, %rax
jg 0x10c97
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r15,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x23772(%rip), %rsi     # 0x34377
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%r15), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
leaq (%r15,%rcx), %r14
addq $0xc720, %r14           # imm = 0xC720
movb $0x0, -0x1(%r14)
incl %eax
movl %eax, 0xd670(%r15)
jmp 0x10c93
xorl %ebx, %ebx
jmp 0x10c97
movq %rcx, %rsi
callq 0xaf70
jmp 0x10bcd
leaq 0x249b6(%rip), %rsi     # 0x35604
xorl %eax, %eax
callq 0xa850
movq 0x30304(%rip), %r14     # 0x40f60
leaq 0xc6d0(%r14), %rdi
leaq 0x2370d(%rip), %rsi     # 0x34377
movl $0x50, %edx
callq 0xa8a0
movb $0x0, 0xc71f(%r14)
movl $0x1, 0xd670(%r14)
addq $0xc720, %r14           # imm = 0xC720
movl $0x5, %ebx
movb $0x0, (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_cutter_compensation_off(setup_struct*)
int Interp::convert_cutter_compensation_off(setup_pointer settings)      //!< pointer to machine settings
{
#ifdef DEBUG_EMC
  enqueue_COMMENT("interpreter: cutter radius compensation off");
#endif
  if(settings->cutter_comp_side != OFF && settings->cutter_comp_radius > 0.0) {
      double cx, cy, cz;
      comp_get_current(settings, &cx, &cy, &cz);
      CHP(move_endpoint_and_flush(settings, cx, cy));
      dequeue_canons(settings);
      settings->current_x = settings->program_x;
      settings->current_y = settings->program_y;
      settings->current_z = settings->program_z;
      settings->arc_not_allowed = ON;
  }
  settings->cutter_comp_side = OFF;
  settings->cutter_comp_firstmove = ON;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2496e(%rip), %rdi     # 0x3562e
callq 0xb370
cmpl $0x0, 0x624(%rbx)
je 0x10db6
movsd 0x618(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x10db6
leaq -0x38(%rbp), %r15
leaq -0x30(%rbp), %r12
leaq -0x28(%rbp), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0xb6b0
movsd (%r15), %xmm0
movsd (%r12), %xmm1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa760
testl %eax, %eax
je 0x10d87
movl %eax, %r14d
movq 0x30237(%rip), %rbx     # 0x40f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x10dca
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x23674(%rip), %rsi     # 0x343c8
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%rbx), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
jmp 0x10dca
movq %rbx, %rdi
callq 0xa300
movsd 0xc690(%rbx), %xmm0
movsd %xmm0, 0x600(%rbx)
movupd 0xc698(%rbx), %xmm0
movupd %xmm0, 0x608(%rbx)
movb $0x1, 0x110(%rbx)
movl $0x0, 0x624(%rbx)
movb $0x1, 0xc689(%rbx)
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_distance_mode(int, setup_struct*)
int Interp::convert_distance_mode(int g_code,    //!< g_code being executed (must be G_90 or G_91)
                                 setup_pointer settings)        //!< pointer to machine settings                 
{
  if (g_code == G_90) {
    if (settings->distance_mode != MODE_ABSOLUTE) {
#ifdef DEBUG_EMC
      enqueue_COMMENT("interpreter: distance mode changed to absolute");
#endif
      settings->distance_mode = MODE_ABSOLUTE;
    }
  } else if (g_code == G_91) {
    if (settings->distance_mode != MODE_INCREMENTAL) {
#ifdef DEBUG_EMC
      enqueue_COMMENT("interpreter: distance mode changed to incremental");
#endif
      settings->distance_mode = MODE_INCREMENTAL;
    }
  } else
    ERS(NCE_BUG_CODE_NOT_G90_OR_G91);
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
cmpl $0x38e, %esi            # imm = 0x38E
je 0x111b7
cmpl $0x384, %esi            # imm = 0x384
jne 0x111dc
xorl %ebx, %ebx
cmpl $0x0, 0x668(%r14)
je 0x1122f
leaq 0x24630(%rip), %rdi     # 0x357d5
callq 0xb370
movl $0x0, 0x668(%r14)
jmp 0x1122f
xorl %ebx, %ebx
cmpl $0x1, 0x668(%r14)
je 0x1122f
leaq 0x2463a(%rip), %rdi     # 0x35804
callq 0xb370
movl $0x1, 0x668(%r14)
jmp 0x1122f
movq %rdi, %rbx
leaq 0x24650(%rip), %rdi     # 0x35836
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x2fd61(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x2325d(%rip), %rsi     # 0x3446a
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_ijk_distance_mode(int, setup_struct*)
int Interp::convert_ijk_distance_mode(int g_code,    //!< g_code being executed (must be G_90_1 or G_91_1)
                                 setup_pointer settings)        //!< pointer to machine settings                 
{
  if (g_code == G_90_1) {
    if (settings->ijk_distance_mode != MODE_ABSOLUTE) {
#ifdef DEBUG_EMC
      enqueue_COMMENT("interpreter: IJK distance mode changed to absolute");
#endif
      settings->ijk_distance_mode = MODE_ABSOLUTE;
    }
  } else if (g_code == G_91_1) {
    if (settings->ijk_distance_mode != MODE_INCREMENTAL) {
#ifdef DEBUG_EMC
      enqueue_COMMENT("interpreter: IJK distance mode changed to incremental");
#endif
      settings->ijk_distance_mode = MODE_INCREMENTAL;
    }
  } else
    ERS(NCE_BUG_CODE_NOT_G90_OR_G91);
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
cmpl $0x38f, %esi            # imm = 0x38F
je 0x11279
cmpl $0x385, %esi            # imm = 0x385
jne 0x1129e
xorl %ebx, %ebx
cmpl $0x0, 0x66c(%r14)
je 0x112f1
leaq 0x245e7(%rip), %rdi     # 0x3584e
callq 0xb370
movl $0x0, 0x66c(%r14)
jmp 0x112f1
xorl %ebx, %ebx
cmpl $0x1, 0x66c(%r14)
je 0x112f1
leaq 0x245f5(%rip), %rdi     # 0x35881
callq 0xb370
movl $0x1, 0x66c(%r14)
jmp 0x112f1
movq %rdi, %rbx
leaq 0x2458e(%rip), %rdi     # 0x35836
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x2fc9f(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x231ec(%rip), %rsi     # 0x344bb
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_lathe_diameter_mode(int, block_struct*, setup_struct*)
int Interp::convert_lathe_diameter_mode(int g_code,    //!< g_code being executed (must be G_90_1 or G_91_1)
                  block_pointer block,           //!< pointer to current block
                  setup_pointer settings)        //!< pointer to machine settings
{
  if (g_code == G_7) {
    if (settings->lathe_diameter_mode != ON) {
      if(block->x_flag)
      {
        block->x_number /= 2; //Apply scaling now
      }
      if(block->motion_to_be == G_76) {
          block->i_number /= 2;
          block->j_number /= 2;
          block->k_number /= 2;
      }              
#ifdef DEBUG_EMC
      COMMENT("interpreter: Lathe diameter mode changed to diameter");
#endif
      settings->lathe_diameter_mode = ON;
    }
  } else if (g_code == G_8) {
    if (settings->lathe_diameter_mode != OFF) {
      if(block->x_flag)
      {
        block->x_number *= 2; //Remove any existing scaling
      }
      if(block->motion_to_be == G_76) {
          block->i_number *= 2;
          block->j_number *= 2;
          block->k_number *= 2;
      }              
#ifdef DEBUG_EMC
      COMMENT("interpreter: Lathe diameter mode changed to radius");
#endif
      settings->lathe_diameter_mode = OFF;
    }
  } else
    ERS("BUG: Code not G7 or G8");
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
cmpl $0x50, %esi
je 0x113aa
cmpl $0x46, %esi
jne 0x11435
xorl %ebx, %ebx
cmpb $0x0, 0x1e6d8(%r14)
jne 0x1147a
cmpb $0x1, 0x270(%rdx)
jne 0x11345
movsd 0x278(%rdx), %xmm0
mulsd 0x20ccb(%rip), %xmm0    # 0x32008
movsd %xmm0, 0x278(%rdx)
cmpl $0x2f8, 0x1d8(%rdx)     # imm = 0x2F8
jne 0x11391
movsd 0x20caf(%rip), %xmm0    # 0x32008
movsd 0x1a0(%rdx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x1a0(%rdx)
movsd 0x1b0(%rdx), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x1b0(%rdx)
mulsd 0x1c0(%rdx), %xmm0
movsd %xmm0, 0x1c0(%rdx)
leaq 0x2451f(%rip), %rdi     # 0x358b7
callq 0xa800
movb $0x1, 0x1e6d8(%r14)
jmp 0x1147a
xorl %ebx, %ebx
cmpb $0x1, 0x1e6d8(%r14)
jne 0x1147a
cmpb $0x1, 0x270(%rdx)
jne 0x113d7
movsd 0x278(%rdx), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 0x278(%rdx)
cmpl $0x2f8, 0x1d8(%rdx)     # imm = 0x2F8
jne 0x1141f
movsd 0x1a0(%rdx), %xmm0
movsd 0x1b0(%rdx), %xmm1
addsd %xmm0, %xmm0
movsd %xmm0, 0x1a0(%rdx)
addsd %xmm1, %xmm1
movsd %xmm1, 0x1b0(%rdx)
movsd 0x1c0(%rdx), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 0x1c0(%rdx)
leaq 0x244c6(%rip), %rdi     # 0x358ec
callq 0xa800
movb $0x0, 0x1e6d8(%r14)
jmp 0x1147a
leaq 0x244e3(%rip), %rsi     # 0x3591f
xorl %eax, %eax
callq 0xa850
movq 0x2fb16(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x230b4(%rip), %rsi     # 0x3450c
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_feed_mode(int, setup_struct*)
int Interp::convert_feed_mode(int g_code,        //!< g_code being executed (must be G_93, G_94 or G_95)
                             setup_pointer settings)    //!< pointer to machine settings                 
{
  if (g_code == G_93) {
#ifdef DEBUG_EMC
    enqueue_COMMENT("interpreter: feed mode set to inverse time");
#endif
    settings->feed_mode = INVERSE_TIME;
    enqueue_SET_FEED_MODE(0);
  } else if (g_code == G_94) {
#ifdef DEBUG_EMC
    enqueue_COMMENT("interpreter: feed mode set to units per minute");
#endif
    settings->feed_mode = UNITS_PER_MINUTE;
    enqueue_SET_FEED_MODE(0);
    settings->feed_rate = 0.0;
    enqueue_SET_FEED_RATE(0);
  } else if(g_code == G_95) {
#ifdef DEBUG_EMC
    enqueue_COMMENT("interpreter: feed mode set to units per revolution");
#endif
    settings->feed_mode = UNITS_PER_REVOLUTION;
    enqueue_SET_FEED_MODE(1);
    settings->feed_rate = 0.0;
    enqueue_SET_FEED_RATE(0);
  } else
    ERS("BUG: Code not G93, G94, or G95");
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
cmpl $0x3b6, %esi            # imm = 0x3B6
je 0x11510
cmpl $0x3ac, %esi            # imm = 0x3AC
je 0x114db
cmpl $0x3a2, %esi            # imm = 0x3A2
jne 0x11548
leaq 0x24479(%rip), %rdi     # 0x35936
callq 0xb370
movl $0x1, 0x670(%rbx)
xorl %r14d, %r14d
xorl %edi, %edi
callq 0xa830
jmp 0x1158e
leaq 0x2447f(%rip), %rdi     # 0x35961
callq 0xb370
movl $0x0, 0x670(%rbx)
xorl %r14d, %r14d
xorl %edi, %edi
callq 0xa830
movq $0x0, 0x678(%rbx)
xorps %xmm0, %xmm0
callq 0xa7a0
jmp 0x1158e
leaq 0x24479(%rip), %rdi     # 0x35990
callq 0xb370
movl $0x2, 0x670(%rbx)
movl $0x1, %edi
callq 0xa830
movq $0x0, 0x678(%rbx)
xorps %xmm0, %xmm0
callq 0xa7a0
xorl %r14d, %r14d
jmp 0x1158e
leaq 0x24474(%rip), %rsi     # 0x359c3
xorl %eax, %eax
callq 0xa850
movq 0x2fa03(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x22ff2(%rip), %rsi     # 0x3455d
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_set_plane(int, setup_struct*)
int Interp::convert_set_plane(int g_code,        //!< must be G_17, G_18, or G_19 
                             setup_pointer settings)    //!< pointer to machine settings 
{
  CHKS((settings->cutter_comp_side != OFF && g_code == G_17 && settings->plane != CANON_PLANE_XY),
        NCE_CANNOT_CHANGE_PLANES_WITH_CUTTER_RADIUS_COMP_ON);
  CHKS((settings->cutter_comp_side != OFF && g_code == G_18 && settings->plane != CANON_PLANE_XZ),
        NCE_CANNOT_CHANGE_PLANES_WITH_CUTTER_RADIUS_COMP_ON);
  CHKS((settings->cutter_comp_side != OFF && g_code == G_19 && settings->plane != CANON_PLANE_YZ),
        NCE_CANNOT_CHANGE_PLANES_WITH_CUTTER_RADIUS_COMP_ON);

  CHKS((settings->cutter_comp_side != OFF && g_code == G_19), 
          NCE_RADIUS_COMP_ONLY_IN_XY_OR_XZ);

  if (g_code == G_17) {
    SELECT_PLANE(CANON_PLANE_XY);
    settings->plane = CANON_PLANE_XY;
  } else if (g_code == G_18) {
    SELECT_PLANE(CANON_PLANE_XZ);
    settings->plane = CANON_PLANE_XZ;
  } else if (g_code == G_19) {
    SELECT_PLANE(CANON_PLANE_YZ);
    settings->plane = CANON_PLANE_YZ;
  } else if (g_code == G_17_1) {
    SELECT_PLANE(CANON_PLANE_UV);
    settings->plane = CANON_PLANE_UV;
  } else if (g_code == G_18_1) {
    SELECT_PLANE(CANON_PLANE_UW);
    settings->plane = CANON_PLANE_UW;
  } else if (g_code == G_19_1) {
    SELECT_PLANE(CANON_PLANE_VW);
    settings->plane = CANON_PLANE_VW;
  } else
    ERS(NCE_BUG_CODE_NOT_G17_G18_OR_G19);
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movl 0x624(%rdx), %eax
testl %eax, %eax
sete %cl
cmpl $0xaa, %esi
setne %dl
orb %cl, %dl
jne 0x1182c
cmpl $0x1, 0xc67c(%r14)
jne 0x11886
movl $0x1, %edi
callq 0xabc0
movl $0x1, 0xc67c(%r14)
jmp 0x1185d
testl %eax, %eax
sete %cl
cmpl $0xb4, %esi
setne %dl
orb %cl, %dl
jne 0x11861
cmpl $0x3, 0xc67c(%r14)
jne 0x11886
movl $0x3, %edi
callq 0xabc0
movl $0x3, 0xc67c(%r14)
xorl %eax, %eax
jmp 0x118d6
testl %eax, %eax
sete %al
cmpl $0xbe, %esi
setne %cl
orb %al, %cl
jne 0x118db
cmpl $0x2, 0xc67c(%r14)
jne 0x11886
leaq 0x23dd6(%rip), %rdi     # 0x3565a
jmp 0x1188d
leaq 0x24954(%rip), %rdi     # 0x361e1
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x2f6ba(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x22d4b(%rip), %rsi     # 0x345ff
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0xaa, %esi
je 0x11815
cmpl $0xb4, %esi
je 0x11848
cmpl $0xbe, %esi
jne 0x11915
movl $0x2, %edi
callq 0xabc0
movl $0x2, 0xc67c(%r14)
jmp 0x1185d
cmpl $0xbf, %esi
je 0x11961
cmpl $0xb5, %esi
je 0x11947
cmpl $0xab, %esi
jne 0x1197b
movl $0x4, %edi
callq 0xabc0
movl $0x4, 0xc67c(%r14)
jmp 0x1185d
movl $0x6, %edi
callq 0xabc0
movl $0x6, 0xc67c(%r14)
jmp 0x1185d
movl $0x5, %edi
callq 0xabc0
movl $0x5, 0xc67c(%r14)
jmp 0x1185d
leaq 0x24897(%rip), %rdi     # 0x36219
jmp 0x1188d
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_retract_mode(int, setup_struct*)
int Interp::convert_retract_mode(int g_code,     //!< g_code being executed (must be G_98 or G_99)
                                setup_pointer settings) //!< pointer to machine settings                 
{
  CHKS((settings->cutter_comp_side != OFF),
       (_("Cannot change retract mode with cutter radius compensation on")));
  if (g_code == G_98) {
#ifdef DEBUG_EMC
    enqueue_COMMENT("interpreter: retract mode set to old_z");
#endif
    settings->retract_mode = OLD_Z;
  } else if (g_code == G_99) {
#ifdef DEBUG_EMC
    enqueue_COMMENT("interpreter: retract mode set to r_plane");
#endif
    settings->retract_mode = R_PLANE;
  } else
    ERS(NCE_BUG_CODE_NOT_G98_OR_G99);
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x624(%rdx)
je 0x124c5
leaq 0x23bcf(%rip), %rdi     # 0x36049
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x2eacd(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x22251(%rip), %rsi     # 0x346f2
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x1250a
movq %rdx, %r14
cmpl $0x3de, %esi            # imm = 0x3DE
je 0x124f1
cmpl $0x3d4, %esi            # imm = 0x3D4
jne 0x1250f
leaq 0x23ba8(%rip), %rdi     # 0x36087
callq 0xb370
movl $0x1, 0xc6a8(%r14)
jmp 0x12508
leaq 0x23bb6(%rip), %rdi     # 0x360ae
callq 0xb370
movl $0x0, 0xc6a8(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x23bc1(%rip), %rdi     # 0x360d7
jmp 0x1247a
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_spindle_mode(block_struct*, setup_struct*)
int Interp::convert_spindle_mode(block_pointer block, setup_pointer settings)
{
    if(block->g_modes[14] == G_97) {
	enqueue_SET_SPINDLE_MODE(0);
    } else { /* G_96 */
	if(block->d_flag)
	    enqueue_SET_SPINDLE_MODE(block->d_number_float);
	else
	    enqueue_SET_SPINDLE_MODE(1e30);
    }
    return INTERP_OK;
}

// Assembly:
xorps %xmm0, %xmm0
cmpl $0x3ca, 0x188(%rsi)     # imm = 0x3CA
je 0x16a00
cmpb $0x1, 0x138(%rsi)
jne 0x169f8
movsd 0x130(%rsi), %xmm0
jmp 0x16a00
movsd 0x1d4f8(%rip), %xmm0    # 0x33ef8
pushq %rbp
movq %rsp, %rbp
callq 0xa6a0
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_SET_FEED_RATE(double)
void enqueue_SET_FEED_RATE(double feed) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate set feed rate %f\n", feed);
        SET_FEED_RATE(feed);
        return;
    }
    queued_canon q;
    q.type = QSET_FEED_RATE;
    q.data.set_feed_rate.feed = feed;
    if(debug_qc) printf("enqueue set feed rate %f\n", feed);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0xa210
movq 0x47459(%rip), %rax     # 0x60370
cmpq 0x4745a(%rip), %rax     # 0x60378
je 0x18f62
movl $0x3, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0xa210
movq 0x4743b(%rip), %rax     # 0x60378
cmpq 0x4743c(%rip), %rax     # 0x60380
je 0x18f74
leaq -0x80(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x47418(%rip)     # 0x60378
jmp 0x18f87
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
jmp 0xab70
leaq 0x473f5(%rip), %rdi     # 0x60370
leaq -0x80(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_DWELL(double)
void enqueue_DWELL(double time) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate dwell %f\n", time);
        DWELL(time);
        return;
    }
    queued_canon q;
    q.type = QDWELL;
    q.data.dwell.time = time;
    if(debug_qc) printf("enqueue dwell %f\n", time);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0xa210
movq 0x473c4(%rip), %rax     # 0x60370
cmpq 0x473c5(%rip), %rax     # 0x60378
je 0x18ff7
movl $0x4, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0xa210
movq 0x473a6(%rip), %rax     # 0x60378
cmpq 0x473a7(%rip), %rax     # 0x60380
je 0x19009
leaq -0x80(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x47383(%rip)     # 0x60378
jmp 0x1901c
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
jmp 0xa040
leaq 0x47360(%rip), %rdi     # 0x60370
leaq -0x80(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_SET_FEED_MODE(int)
void enqueue_SET_FEED_MODE(int mode) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate set feed mode %d\n", mode);
        SET_FEED_MODE(mode);
        return;
    }
    queued_canon q;
    q.type = QSET_FEED_MODE;
    q.data.set_feed_mode.mode = mode;
    if(debug_qc) printf("enqueue set feed mode %d\n", mode);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movl %edi, %ebx
callq 0xa210
movq 0x47334(%rip), %rax     # 0x60370
cmpq 0x47335(%rip), %rax     # 0x60378
je 0x19080
movl $0x5, -0x80(%rbp)
movl %ebx, -0x78(%rbp)
callq 0xa210
movq 0x4731d(%rip), %rax     # 0x60378
cmpq 0x4731e(%rip), %rax     # 0x60380
je 0x1908d
leaq -0x80(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x472fa(%rip)     # 0x60378
jmp 0x190a0
movl %ebx, %edi
addq $0x78, %rsp
popq %rbx
popq %rbp
jmp 0xb1e0
leaq 0x472dc(%rip), %rdi     # 0x60370
leaq -0x80(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_MIST_ON()
void enqueue_MIST_ON(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate mist on\n");
        MIST_ON();
        return;
    }
    queued_canon q;
    q.type = QMIST_ON;
    if(debug_qc) printf("enqueue mist on\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0xa210
movq 0x472b2(%rip), %rax     # 0x60370
cmpq 0x472b3(%rip), %rax     # 0x60378
je 0x190ff
movl $0x6, -0x78(%rbp)
callq 0xa210
movq 0x4729e(%rip), %rax     # 0x60378
cmpq 0x4729f(%rip), %rax     # 0x60380
je 0x1910c
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x4727b(%rip)     # 0x60378
jmp 0x1911f
addq $0x80, %rsp
popq %rbp
jmp 0xb260
leaq 0x4725d(%rip), %rdi     # 0x60370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_MIST_OFF()
void enqueue_MIST_OFF(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate mist off\n");
        MIST_OFF();
        return;
    }
    queued_canon q;
    q.type = QMIST_OFF;
    if(debug_qc) printf("enqueue mist off\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0xa210
movq 0x47231(%rip), %rax     # 0x60370
cmpq 0x47232(%rip), %rax     # 0x60378
je 0x19180
movl $0x7, -0x78(%rbp)
callq 0xa210
movq 0x4721d(%rip), %rax     # 0x60378
cmpq 0x4721e(%rip), %rax     # 0x60380
je 0x1918d
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x471fa(%rip)     # 0x60378
jmp 0x191a0
addq $0x80, %rsp
popq %rbp
jmp 0xa0f0
leaq 0x471dc(%rip), %rdi     # 0x60370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_FLOOD_ON()
void enqueue_FLOOD_ON(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate flood on\n");
        FLOOD_ON();
        return;
    }
    queued_canon q;
    q.type = QFLOOD_ON;
    if(debug_qc) printf("enqueue flood on\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0xa210
movq 0x471b0(%rip), %rax     # 0x60370
cmpq 0x471b1(%rip), %rax     # 0x60378
je 0x19201
movl $0x8, -0x78(%rbp)
callq 0xa210
movq 0x4719c(%rip), %rax     # 0x60378
cmpq 0x4719d(%rip), %rax     # 0x60380
je 0x1920e
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x47179(%rip)     # 0x60378
jmp 0x19221
addq $0x80, %rsp
popq %rbp
jmp 0xa7e0
leaq 0x4715b(%rip), %rdi     # 0x60370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_FLOOD_OFF()
void enqueue_FLOOD_OFF(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate flood on\n");
        FLOOD_OFF();
        return;
    }
    queued_canon q;
    q.type = QFLOOD_OFF;
    if(debug_qc) printf("enqueue flood off\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0xa210
movq 0x4712f(%rip), %rax     # 0x60370
cmpq 0x47130(%rip), %rax     # 0x60378
je 0x19282
movl $0x9, -0x78(%rbp)
callq 0xa210
movq 0x4711b(%rip), %rax     # 0x60378
cmpq 0x4711c(%rip), %rax     # 0x60380
je 0x1928f
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x470f8(%rip)     # 0x60378
jmp 0x192a2
addq $0x80, %rsp
popq %rbp
jmp 0xa710
leaq 0x470da(%rip), %rdi     # 0x60370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_START_SPINDLE_CLOCKWISE()
void enqueue_START_SPINDLE_CLOCKWISE(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate spindle clockwise\n");
        START_SPINDLE_CLOCKWISE();
        return;
    }
    queued_canon q;
    q.type = QSTART_SPINDLE_CLOCKWISE;
    if(debug_qc) printf("enqueue spindle clockwise\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0xa210
movq 0x470ae(%rip), %rax     # 0x60370
cmpq 0x470af(%rip), %rax     # 0x60378
je 0x19303
movl $0xa, -0x78(%rbp)
callq 0xa210
movq 0x4709a(%rip), %rax     # 0x60378
cmpq 0x4709b(%rip), %rax     # 0x60380
je 0x19310
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x47077(%rip)     # 0x60378
jmp 0x19323
addq $0x80, %rsp
popq %rbp
jmp 0xaba0
leaq 0x47059(%rip), %rdi     # 0x60370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_START_SPINDLE_COUNTERCLOCKWISE()
void enqueue_START_SPINDLE_COUNTERCLOCKWISE(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate spindle counterclockwise\n");
        START_SPINDLE_COUNTERCLOCKWISE();
        return;
    }
    queued_canon q;
    q.type = QSTART_SPINDLE_COUNTERCLOCKWISE;
    if(debug_qc) printf("enqueue spindle counterclockwise\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0xa210
movq 0x4702d(%rip), %rax     # 0x60370
cmpq 0x4702e(%rip), %rax     # 0x60378
je 0x19384
movl $0xb, -0x78(%rbp)
callq 0xa210
movq 0x47019(%rip), %rax     # 0x60378
cmpq 0x4701a(%rip), %rax     # 0x60380
je 0x19391
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x46ff6(%rip)     # 0x60378
jmp 0x193a4
addq $0x80, %rsp
popq %rbp
jmp 0xaf20
leaq 0x46fd8(%rip), %rdi     # 0x60370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_STOP_SPINDLE_TURNING()
void enqueue_STOP_SPINDLE_TURNING(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate spindle stop\n");
        STOP_SPINDLE_TURNING();
        return;
    }
    queued_canon q;
    q.type = QSTOP_SPINDLE_TURNING;
    if(debug_qc) printf("enqueue spindle stop\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0xa210
movq 0x46fac(%rip), %rax     # 0x60370
cmpq 0x46fad(%rip), %rax     # 0x60378
je 0x19405
movl $0xc, -0x78(%rbp)
callq 0xa210
movq 0x46f98(%rip), %rax     # 0x60378
cmpq 0x46f99(%rip), %rax     # 0x60380
je 0x19412
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x46f75(%rip)     # 0x60378
jmp 0x19425
addq $0x80, %rsp
popq %rbp
jmp 0xabb0
leaq 0x46f57(%rip), %rdi     # 0x60370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_SET_SPINDLE_MODE(double)
void enqueue_SET_SPINDLE_MODE(double mode) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate spindle mode %f\n", mode);
        SET_SPINDLE_MODE(mode);
        return;
    }
    queued_canon q;
    q.type = QSET_SPINDLE_MODE;
    q.data.set_spindle_mode.mode = mode;
    if(debug_qc) printf("enqueue spindle mode %f\n", mode);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0xa210
movq 0x46f26(%rip), %rax     # 0x60370
cmpq 0x46f27(%rip), %rax     # 0x60378
je 0x19495
movl $0xd, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0xa210
movq 0x46f08(%rip), %rax     # 0x60378
cmpq 0x46f09(%rip), %rax     # 0x60380
je 0x194a7
leaq -0x80(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x46ee5(%rip)     # 0x60378
jmp 0x194ba
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
jmp 0xab80
leaq 0x46ec2(%rip), %rdi     # 0x60370
leaq -0x80(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_SET_SPINDLE_SPEED(double)
void enqueue_SET_SPINDLE_SPEED(double speed) {
    if(qc().empty()) {
    if(debug_qc) printf("immediate set spindle speed %f\n", speed);
        SET_SPINDLE_SPEED(speed);
        return;
    }
    queued_canon q;
    q.type = QSET_SPINDLE_SPEED;
    q.data.set_spindle_speed.speed = speed;
    if(debug_qc) printf("enqueue set spindle speed %f\n", speed);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0xa210
movq 0x46e91(%rip), %rax     # 0x60370
cmpq 0x46e92(%rip), %rax     # 0x60378
je 0x1952a
movl $0xe, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0xa210
movq 0x46e73(%rip), %rax     # 0x60378
cmpq 0x46e74(%rip), %rax     # 0x60380
je 0x1953c
leaq -0x80(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x46e50(%rip)     # 0x60378
jmp 0x1954f
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
jmp 0xa4f0
leaq 0x46e2d(%rip), %rdi     # 0x60370
leaq -0x80(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq