LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11618
cmpl $0x384, %esi            # imm = 0x384
jne 0x1163d
xorl %ebx, %ebx
cmpl $0x0, 0x668(%r14)
je 0x1169a
leaq 0x271d2(%rip), %rdi     # 0x387d5
callq 0xb370
movl $0x0, 0x668(%r14)
jmp 0x1169a
xorl %ebx, %ebx
cmpl $0x1, 0x668(%r14)
je 0x1169a
leaq 0x271d9(%rip), %rdi     # 0x38804
callq 0xb370
movl $0x1, 0x668(%r14)
jmp 0x1169a
movq %rdi, %rbx
leaq 0x271ef(%rip), %rdi     # 0x38836
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x32900(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x25df2(%rip), %rsi     # 0x3746a
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_O1/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 0x116e8
cmpl $0x385, %esi            # imm = 0x385
jne 0x1170d
xorl %ebx, %ebx
cmpl $0x0, 0x66c(%r14)
je 0x1176a
leaq 0x2717b(%rip), %rdi     # 0x3884e
callq 0xb370
movl $0x0, 0x66c(%r14)
jmp 0x1176a
xorl %ebx, %ebx
cmpl $0x1, 0x66c(%r14)
je 0x1176a
leaq 0x27186(%rip), %rdi     # 0x38881
callq 0xb370
movl $0x1, 0x66c(%r14)
jmp 0x1176a
movq %rdi, %rbx
leaq 0x2711f(%rip), %rdi     # 0x38836
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x32830(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x25d73(%rip), %rsi     # 0x374bb
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_O1/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 0x11824
cmpl $0x46, %esi
jne 0x118af
xorl %ebx, %ebx
cmpb $0x0, 0x1e6d8(%r14)
jne 0x118fe
cmpb $0x1, 0x270(%rdx)
jne 0x117bf
movsd 0x278(%rdx), %xmm0
mulsd 0x23851(%rip), %xmm0    # 0x35008
movsd %xmm0, 0x278(%rdx)
cmpl $0x2f8, 0x1d8(%rdx)     # imm = 0x2F8
jne 0x1180b
movsd 0x23835(%rip), %xmm0    # 0x35008
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 0x270a5(%rip), %rdi     # 0x388b7
callq 0xa800
movb $0x1, 0x1e6d8(%r14)
jmp 0x118fe
xorl %ebx, %ebx
cmpb $0x1, 0x1e6d8(%r14)
jne 0x118fe
cmpb $0x1, 0x270(%rdx)
jne 0x11851
movsd 0x278(%rdx), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 0x278(%rdx)
cmpl $0x2f8, 0x1d8(%rdx)     # imm = 0x2F8
jne 0x11899
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 0x2704c(%rip), %rdi     # 0x388ec
callq 0xa800
movb $0x0, 0x1e6d8(%r14)
jmp 0x118fe
leaq 0x27069(%rip), %rsi     # 0x3891f
xorl %eax, %eax
callq 0xa850
movq 0x3269c(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x25c30(%rip), %rsi     # 0x3750c
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_O1/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 0x11997
cmpl $0x3ac, %esi            # imm = 0x3AC
je 0x1195f
cmpl $0x3a2, %esi            # imm = 0x3A2
jne 0x119cf
leaq 0x26ff5(%rip), %rdi     # 0x38936
callq 0xb370
movl $0x1, 0x670(%rbx)
xorl %r14d, %r14d
xorl %edi, %edi
callq 0xa830
jmp 0x11a1f
leaq 0x26ffb(%rip), %rdi     # 0x38961
callq 0xb370
movl $0x0, 0x670(%rbx)
xorl %r14d, %r14d
xorl %edi, %edi
callq 0xa830
movq $0x0, 0x678(%rbx)
xorps %xmm0, %xmm0
callq 0xa7a0
jmp 0x11a1f
leaq 0x26ff2(%rip), %rdi     # 0x38990
callq 0xb370
movl $0x2, 0x670(%rbx)
movl $0x1, %edi
callq 0xa830
movq $0x0, 0x678(%rbx)
xorps %xmm0, %xmm0
callq 0xa7a0
xorl %r14d, %r14d
jmp 0x11a1f
leaq 0x26fed(%rip), %rsi     # 0x389c3
xorl %eax, %eax
callq 0xa850
movq 0x3257c(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x25b61(%rip), %rsi     # 0x3755d
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x121b7
cmpl $0x1, 0xc67c(%r14)
jne 0x121fe
testl %eax, %eax
sete %cl
cmpl $0xb4, %esi
setne %dl
orb %cl, %dl
jne 0x121d3
cmpl $0x3, 0xc67c(%r14)
jne 0x121fe
testl %eax, %eax
setne %cl
cmpl $0xbe, %esi
sete %al
andb %cl, %al
cmpb $0x1, %al
jne 0x1225a
cmpl $0x2, 0xc67c(%r14)
jne 0x121fe
testb %al, %al
je 0x1225a
leaq 0x2645e(%rip), %rdi     # 0x3865a
jmp 0x12205
leaq 0x26fdc(%rip), %rdi     # 0x391e1
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x31d42(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x253c9(%rip), %rsi     # 0x375ff
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x122b7
cmpl $0xaa, %esi
jne 0x12279
movl $0x1, %edi
callq 0xabc0
movl $0x1, 0xc67c(%r14)
jmp 0x122b5
cmpl $0xb4, %esi
jne 0x12298
movl $0x3, %edi
callq 0xabc0
movl $0x3, 0xc67c(%r14)
jmp 0x122b5
cmpl $0xbe, %esi
jne 0x122bc
movl $0x2, %edi
callq 0xabc0
movl $0x2, 0xc67c(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0xbf, %esi
je 0x12302
cmpl $0xb5, %esi
je 0x122eb
cmpl $0xab, %esi
jne 0x12319
movl $0x4, %edi
callq 0xabc0
movl $0x4, 0xc67c(%r14)
jmp 0x122b5
movl $0x6, %edi
callq 0xabc0
movl $0x6, 0xc67c(%r14)
jmp 0x122b5
movl $0x5, %edi
callq 0xabc0
movl $0x5, 0xc67c(%r14)
jmp 0x122b5
leaq 0x26ef9(%rip), %rdi     # 0x39219
jmp 0x12205
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12e7b
leaq 0x26223(%rip), %rdi     # 0x39049
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x31121(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x2489b(%rip), %rsi     # 0x376f2
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x12ec0
movq %rdx, %r14
cmpl $0x3de, %esi            # imm = 0x3DE
je 0x12ea7
cmpl $0x3d4, %esi            # imm = 0x3D4
jne 0x12ec5
leaq 0x261f2(%rip), %rdi     # 0x39087
callq 0xb370
movl $0x1, 0xc6a8(%r14)
jmp 0x12ebe
leaq 0x26200(%rip), %rdi     # 0x390ae
callq 0xb370
movl $0x0, 0xc6a8(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2620b(%rip), %rdi     # 0x390d7
jmp 0x12e26
nop
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_modal_0(int, block_struct*, setup_struct*)
int Interp::convert_modal_0(int code,    //!< G code, must be from group 0                
                           block_pointer block, //!< pointer to a block of RS274/NGC instructions
                           setup_pointer settings)      //!< pointer to machine settings                 
{

  if (code == G_10) {
      if(block->l_number == 1 || block->l_number == 10)
          CHP(convert_setup_tool(block, settings));
      else
          CHP(convert_setup(block, settings));
  } else if ((code == G_28) || (code == G_30)) {
    CHP(convert_home(code, block, settings));
  } else if ((code == G_28_1) || (code == G_30_1)) {
    CHP(convert_savehome(code, block, settings));
  } else if ((code == G_92) || (code == G_92_1) ||
             (code == G_92_2) || (code == G_92_3)) {
    CHP(convert_axis_offsets(code, block, settings));
  } else if (code == G_5_3) {
    CHP(convert_nurbs(code, block, settings));
  } else if ((code == G_4) || (code == G_53));  /* handled elsewhere */
  else
    ERS(NCE_BUG_CODE_NOT_G4_G10_G28_G30_G53_OR_G92_SERIES);
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x12c, %esi            # imm = 0x12C
jg 0x12f2a
cmpl $0x117, %esi            # imm = 0x117
jg 0x12f42
cmpl $0x28, %esi
je 0x13071
cmpl $0x35, %esi
je 0x12fe8
cmpl $0x64, %esi
jne 0x12f7f
movl 0x1c8(%rdx), %eax
cmpl $0xa, %eax
je 0x12f17
cmpl $0x1, %eax
jne 0x12ff7
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xa330
jmp 0x13005
leal -0x398(%rsi), %eax
cmpl $0x4, %eax
jae 0x12f6b
movq %rbx, %rdi
callq 0xb630
jmp 0x13005
cmpl $0x118, %esi            # imm = 0x118
je 0x12f5e
cmpl $0x119, %esi            # imm = 0x119
je 0x12fde
cmpl $0x12c, %esi            # imm = 0x12C
jne 0x12f7f
movq %rbx, %rdi
callq 0xaea0
jmp 0x13005
cmpl $0x12d, %esi            # imm = 0x12D
je 0x12fde
cmpl $0x212, %esi            # imm = 0x212
je 0x13071
leaq 0x25f8b(%rip), %rdi     # 0x38f11
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x30fc1(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x2478c(%rip), %rsi     # 0x37743
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
jmp 0x13073
movq %rbx, %rdi
callq 0xa410
jmp 0x13005
movq %rbx, %rdi
movl $0x35, %esi
callq 0xb460
jmp 0x13005
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0xa790
testl %eax, %eax
je 0x13071
movl %eax, %ebx
movq 0x30f4e(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x1306d
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x2470a(%rip), %rsi     # 0x37743
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%r14), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
testl %ebx, %ebx
jne 0x13073
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1758e
cmpb $0x1, 0x138(%rsi)
jne 0x17586
movsd 0x130(%rsi), %xmm0
jmp 0x1758e
movsd 0x1f962(%rip), %xmm0    # 0x36ef0
pushq %rbp
movq %rsp, %rbp
callq 0xa6a0
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x495c5(%rip), %rax     # 0x63370
cmpq 0x495c6(%rip), %rax     # 0x63378
je 0x19df6
movl $0x3, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0xa210
movq 0x495a7(%rip), %rax     # 0x63378
cmpq 0x495a8(%rip), %rax     # 0x63380
je 0x19e08
leaq -0x80(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x49584(%rip)     # 0x63378
jmp 0x19e1b
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
jmp 0xab70
leaq 0x49561(%rip), %rdi     # 0x63370
leaq -0x80(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49530(%rip), %rax     # 0x63370
cmpq 0x49531(%rip), %rax     # 0x63378
je 0x19e8b
movl $0x4, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0xa210
movq 0x49512(%rip), %rax     # 0x63378
cmpq 0x49513(%rip), %rax     # 0x63380
je 0x19e9d
leaq -0x80(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x494ef(%rip)     # 0x63378
jmp 0x19eb0
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
jmp 0xa040
leaq 0x494cc(%rip), %rdi     # 0x63370
leaq -0x80(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x494a0(%rip), %rax     # 0x63370
cmpq 0x494a1(%rip), %rax     # 0x63378
je 0x19f14
movl $0x5, -0x80(%rbp)
movl %ebx, -0x78(%rbp)
callq 0xa210
movq 0x49489(%rip), %rax     # 0x63378
cmpq 0x4948a(%rip), %rax     # 0x63380
je 0x19f21
leaq -0x80(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x49466(%rip)     # 0x63378
jmp 0x19f34
movl %ebx, %edi
addq $0x78, %rsp
popq %rbx
popq %rbp
jmp 0xb1e0
leaq 0x49448(%rip), %rdi     # 0x63370
leaq -0x80(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4941e(%rip), %rax     # 0x63370
cmpq 0x4941f(%rip), %rax     # 0x63378
je 0x19f93
movl $0x6, -0x78(%rbp)
callq 0xa210
movq 0x4940a(%rip), %rax     # 0x63378
cmpq 0x4940b(%rip), %rax     # 0x63380
je 0x19fa0
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x493e7(%rip)     # 0x63378
jmp 0x19fb3
addq $0x80, %rsp
popq %rbp
jmp 0xb260
leaq 0x493c9(%rip), %rdi     # 0x63370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4939d(%rip), %rax     # 0x63370
cmpq 0x4939e(%rip), %rax     # 0x63378
je 0x1a014
movl $0x7, -0x78(%rbp)
callq 0xa210
movq 0x49389(%rip), %rax     # 0x63378
cmpq 0x4938a(%rip), %rax     # 0x63380
je 0x1a021
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x49366(%rip)     # 0x63378
jmp 0x1a034
addq $0x80, %rsp
popq %rbp
jmp 0xa0f0
leaq 0x49348(%rip), %rdi     # 0x63370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4931c(%rip), %rax     # 0x63370
cmpq 0x4931d(%rip), %rax     # 0x63378
je 0x1a095
movl $0x8, -0x78(%rbp)
callq 0xa210
movq 0x49308(%rip), %rax     # 0x63378
cmpq 0x49309(%rip), %rax     # 0x63380
je 0x1a0a2
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x492e5(%rip)     # 0x63378
jmp 0x1a0b5
addq $0x80, %rsp
popq %rbp
jmp 0xa7e0
leaq 0x492c7(%rip), %rdi     # 0x63370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4929b(%rip), %rax     # 0x63370
cmpq 0x4929c(%rip), %rax     # 0x63378
je 0x1a116
movl $0x9, -0x78(%rbp)
callq 0xa210
movq 0x49287(%rip), %rax     # 0x63378
cmpq 0x49288(%rip), %rax     # 0x63380
je 0x1a123
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x49264(%rip)     # 0x63378
jmp 0x1a136
addq $0x80, %rsp
popq %rbp
jmp 0xa710
leaq 0x49246(%rip), %rdi     # 0x63370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4921a(%rip), %rax     # 0x63370
cmpq 0x4921b(%rip), %rax     # 0x63378
je 0x1a197
movl $0xa, -0x78(%rbp)
callq 0xa210
movq 0x49206(%rip), %rax     # 0x63378
cmpq 0x49207(%rip), %rax     # 0x63380
je 0x1a1a4
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x491e3(%rip)     # 0x63378
jmp 0x1a1b7
addq $0x80, %rsp
popq %rbp
jmp 0xaba0
leaq 0x491c5(%rip), %rdi     # 0x63370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49199(%rip), %rax     # 0x63370
cmpq 0x4919a(%rip), %rax     # 0x63378
je 0x1a218
movl $0xb, -0x78(%rbp)
callq 0xa210
movq 0x49185(%rip), %rax     # 0x63378
cmpq 0x49186(%rip), %rax     # 0x63380
je 0x1a225
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x49162(%rip)     # 0x63378
jmp 0x1a238
addq $0x80, %rsp
popq %rbp
jmp 0xaf20
leaq 0x49144(%rip), %rdi     # 0x63370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49118(%rip), %rax     # 0x63370
cmpq 0x49119(%rip), %rax     # 0x63378
je 0x1a299
movl $0xc, -0x78(%rbp)
callq 0xa210
movq 0x49104(%rip), %rax     # 0x63378
cmpq 0x49105(%rip), %rax     # 0x63380
je 0x1a2a6
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x490e1(%rip)     # 0x63378
jmp 0x1a2b9
addq $0x80, %rsp
popq %rbp
jmp 0xabb0
leaq 0x490c3(%rip), %rdi     # 0x63370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x49092(%rip), %rax     # 0x63370
cmpq 0x49093(%rip), %rax     # 0x63378
je 0x1a329
movl $0xd, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0xa210
movq 0x49074(%rip), %rax     # 0x63378
cmpq 0x49075(%rip), %rax     # 0x63380
je 0x1a33b
leaq -0x80(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x49051(%rip)     # 0x63378
jmp 0x1a34e
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
jmp 0xab80
leaq 0x4902e(%rip), %rdi     # 0x63370
leaq -0x80(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48ffd(%rip), %rax     # 0x63370
cmpq 0x48ffe(%rip), %rax     # 0x63378
je 0x1a3be
movl $0xe, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0xa210
movq 0x48fdf(%rip), %rax     # 0x63378
cmpq 0x48fe0(%rip), %rax     # 0x63380
je 0x1a3d0
leaq -0x80(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x48fbc(%rip)     # 0x63378
jmp 0x1a3e3
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
jmp 0xa4f0
leaq 0x48f99(%rip), %rdi     # 0x63370
leaq -0x80(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_COMMENT(char*)
void enqueue_COMMENT(char *c) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate comment \"%s\"\n", c);
        COMMENT(c);
        return;
    }
    queued_canon q;
    q.type = QCOMMENT;
    q.data.comment.comment = strdup(c);
    if(debug_qc) printf("enqueue comment \"%s\"\n", c);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
callq 0xa210
movq 0x48f6c(%rip), %rax     # 0x63370
cmpq 0x48f6d(%rip), %rax     # 0x63378
je 0x1a451
movl $0xf, -0x80(%rbp)
movq %rbx, %rdi
callq 0xb4e0
movq %rax, -0x78(%rbp)
callq 0xa210
movq 0x48f4c(%rip), %rax     # 0x63378
cmpq 0x48f4d(%rip), %rax     # 0x63380
je 0x1a45f
leaq -0x80(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x48f29(%rip)     # 0x63378
jmp 0x1a472
movq %rbx, %rdi
addq $0x78, %rsp
popq %rbx
popq %rbp
jmp 0xa800
leaq 0x48f0a(%rip), %rdi     # 0x63370
leaq -0x80(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_STRAIGHT_FEED(setup_struct*, int, double, double, double, double, double, double, double, double, double, double, double, double)
int enqueue_STRAIGHT_FEED(setup_pointer settings, int l, 
                           double dx, double dy, double dz,
                           double x, double y, double z, 
                           double a, double b, double c, 
                           double u, double v, double w) {
    queued_canon q;
    q.type = QSTRAIGHT_FEED;
    q.data.straight_feed.line_number = l;
    switch(settings->plane) {
    case CANON_PLANE_XY:
        q.data.straight_feed.dx = dx;
        q.data.straight_feed.dy = dy;
        q.data.straight_feed.dz = dz;
        q.data.straight_feed.x = x;
        q.data.straight_feed.y = y;
        q.data.straight_feed.z = z;
        break;
    case CANON_PLANE_XZ:
        q.data.straight_feed.dz = dx;
        q.data.straight_feed.dx = dy;
        q.data.straight_feed.dy = dz;
        q.data.straight_feed.z = x;
        q.data.straight_feed.x = y;
        q.data.straight_feed.y = z;
        break;
    default:
        ;
    }        
    q.data.straight_feed.a = a;
    q.data.straight_feed.b = b;
    q.data.straight_feed.c = c;
    q.data.straight_feed.u = u;
    q.data.straight_feed.v = v;
    q.data.straight_feed.w = w;
    qc().push_back(q);
    if(debug_qc) printf("enqueue straight feed lineno %d to %f %f %f direction %f %f %f\n", l, x,y,z, dx, dy, dz);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd 0x28(%rbp), %xmm8
movsd 0x20(%rbp), %xmm9
movsd 0x18(%rbp), %xmm10
movsd 0x10(%rbp), %xmm11
movl $0x1, -0x78(%rbp)
movl %esi, -0x70(%rbp)
movl 0xc67c(%rdi), %eax
cmpl $0x1, %eax
je 0x1a4d0
cmpl $0x3, %eax
jne 0x1a501
leaq -0x58(%rbp), %r8
leaq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x50(%rbp), %rcx
leaq -0x48(%rbp), %rax
jmp 0x1a4e8
leaq -0x40(%rbp), %rax
leaq -0x48(%rbp), %rcx
leaq -0x50(%rbp), %rdx
leaq -0x58(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %r8
movsd %xmm0, (%r8)
movsd %xmm1, (%rdi)
movsd %xmm2, (%rsi)
movsd %xmm3, (%rdx)
movsd %xmm4, (%rcx)
movsd %xmm5, (%rax)
movsd %xmm6, -0x38(%rbp)
movsd %xmm7, -0x30(%rbp)
movsd %xmm11, -0x28(%rbp)
movsd %xmm10, -0x20(%rbp)
movsd %xmm9, -0x18(%rbp)
movsd %xmm8, -0x10(%rbp)
callq 0xa210
movq 0x48e49(%rip), %rax     # 0x63378
cmpq 0x48e4a(%rip), %rax     # 0x63380
je 0x1a554
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x48e26(%rip)     # 0x63378
jmp 0x1a567
leaq 0x48e15(%rip), %rdi     # 0x63370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_STRAIGHT_TRAVERSE(setup_struct*, int, double, double, double, double, double, double, double, double, double, double, double, double)
int enqueue_STRAIGHT_TRAVERSE(setup_pointer settings, int l, 
                               double dx, double dy, double dz,
                               double x, double y, double z, 
                               double a, double b, double c, 
                               double u, double v, double w) {
    queued_canon q;
    q.type = QSTRAIGHT_TRAVERSE;
    q.data.straight_traverse.line_number = l;
    switch(settings->plane) {
    case CANON_PLANE_XY:
        q.data.straight_traverse.dx = dx;
        q.data.straight_traverse.dy = dy;
        q.data.straight_traverse.dz = dz;
        q.data.straight_traverse.x = x;
        q.data.straight_traverse.y = y;
        q.data.straight_traverse.z = z;
        break;
    case CANON_PLANE_XZ:
        q.data.straight_traverse.dz = dx;
        q.data.straight_traverse.dx = dy;
        q.data.straight_traverse.dy = dz;
        q.data.straight_traverse.z = x;
        q.data.straight_traverse.x = y;
        q.data.straight_traverse.y = z;
        break;
    default:
        ;
    }        
    q.data.straight_traverse.a = a;
    q.data.straight_traverse.b = b;
    q.data.straight_traverse.c = c;
    q.data.straight_traverse.u = u;
    q.data.straight_traverse.v = v;
    q.data.straight_traverse.w = w;
    if(debug_qc) printf("enqueue straight traverse lineno %d to %f %f %f direction %f %f %f\n", l, x,y,z, dx, dy, dz);
    qc().push_back(q);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd 0x28(%rbp), %xmm8
movsd 0x20(%rbp), %xmm9
movsd 0x18(%rbp), %xmm10
movsd 0x10(%rbp), %xmm11
movl $0x0, -0x78(%rbp)
movl %esi, -0x70(%rbp)
movl 0xc67c(%rdi), %eax
cmpl $0x1, %eax
je 0x1a5c9
cmpl $0x3, %eax
jne 0x1a5fa
leaq -0x58(%rbp), %r8
leaq -0x68(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x50(%rbp), %rcx
leaq -0x48(%rbp), %rax
jmp 0x1a5e1
leaq -0x40(%rbp), %rax
leaq -0x48(%rbp), %rcx
leaq -0x50(%rbp), %rdx
leaq -0x58(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %r8
movsd %xmm0, (%r8)
movsd %xmm1, (%rdi)
movsd %xmm2, (%rsi)
movsd %xmm3, (%rdx)
movsd %xmm4, (%rcx)
movsd %xmm5, (%rax)
movsd %xmm6, -0x38(%rbp)
movsd %xmm7, -0x30(%rbp)
movsd %xmm11, -0x28(%rbp)
movsd %xmm10, -0x20(%rbp)
movsd %xmm9, -0x18(%rbp)
movsd %xmm8, -0x10(%rbp)
callq 0xa210
movq 0x48d50(%rip), %rax     # 0x63378
cmpq 0x48d51(%rip), %rax     # 0x63380
je 0x1a64d
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x48d2d(%rip)     # 0x63378
jmp 0x1a660
leaq 0x48d1c(%rip), %rdi     # 0x63370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_ARC_FEED(setup_struct*, int, double, double, double, double, double, int, double, double, double, double, double, double, double)
void enqueue_ARC_FEED(setup_pointer settings, int l, 
                      double original_turns,
                      double end1, double end2, double center1, double center2,
                      int turn,
                      double end3,
                      double a, double b, double c,
                      double u, double v, double w) {
    queued_canon q;

    q.type = QARC_FEED;
    q.data.arc_feed.line_number = l;
    q.data.arc_feed.original_turns = original_turns;
    q.data.arc_feed.end1 = end1;
    q.data.arc_feed.end2 = end2;
    q.data.arc_feed.center1 = center1;
    q.data.arc_feed.center2 = center2;
    q.data.arc_feed.turn = turn;
    q.data.arc_feed.end3 = end3;
    q.data.arc_feed.a = a;
    q.data.arc_feed.b = b;
    q.data.arc_feed.c = c;
    q.data.arc_feed.u = u;
    q.data.arc_feed.v = v;
    q.data.arc_feed.w = w;

    if(debug_qc) printf("enqueue arc lineno %d to %f %f center %f %f turn %d sweeping %f\n", l, end1, end2, center1, center2, turn, original_turns);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movaps 0x20(%rbp), %xmm8
movaps 0x10(%rbp), %xmm9
movl $0x2, -0x78(%rbp)
movl %esi, -0x70(%rbp)
movsd %xmm0, -0x68(%rbp)
movsd %xmm1, -0x60(%rbp)
movsd %xmm2, -0x58(%rbp)
movsd %xmm3, -0x50(%rbp)
movsd %xmm4, -0x48(%rbp)
movl %edx, -0x40(%rbp)
movsd %xmm5, -0x38(%rbp)
movsd %xmm6, -0x30(%rbp)
movsd %xmm7, -0x28(%rbp)
movups %xmm9, -0x20(%rbp)
movups %xmm8, -0x10(%rbp)
callq 0xa210
movq 0x48cad(%rip), %rax     # 0x63378
cmpq 0x48cae(%rip), %rax     # 0x63380
je 0x1a6f0
leaq -0x78(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x48c8a(%rip)     # 0x63378
jmp 0x1a703
leaq 0x48c79(%rip), %rdi     # 0x63370
leaq -0x78(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_M_USER_COMMAND(int, double, double)
void enqueue_M_USER_COMMAND (int index, double p_number, double q_number) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate M_USER_COMMAND index=%d p=%f q=%f\n",
                           index,p_number,q_number);
        (*(USER_DEFINED_FUNCTION[index - 100])) (index - 100,p_number,q_number);
        return;
    }
    queued_canon q;
    q.type = QM_USER_COMMAND;
    q.data.mcommand.index    = index;
    q.data.mcommand.p_number = p_number;
    q.data.mcommand.q_number = q_number;
    if(debug_qc) printf("enqueue M_USER_COMMAND index=%d p=%f q=%f\n",
                        index,p_number,q_number);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movsd %xmm1, -0x18(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %edi, %ebx
callq 0xa210
movq 0x48c40(%rip), %rax     # 0x63370
cmpq 0x48c41(%rip), %rax     # 0x63378
je 0x1a791
movl $0x10, -0x90(%rbp)
movl %ebx, -0x88(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0xa210
movq 0x48c0f(%rip), %rax     # 0x63378
cmpq 0x48c10(%rip), %rax     # 0x63380
je 0x1a7bd
leaq -0x90(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x48be9(%rip)     # 0x63378
jmp 0x1a7d3
movslq %ebx, %rax
addl $-0x64, %ebx
movq 0x2983a(%rip), %rcx     # 0x43fd8
movq -0x320(%rcx,%rax,8), %rax
movl %ebx, %edi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
addq $0x88, %rsp
popq %rbx
popq %rbp
jmpq *%rax
leaq 0x48bac(%rip), %rdi     # 0x63370
leaq -0x90(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_cycles.cc
// Function: Interp::convert_cycle_g82(block_struct*, int, double, double, double, double, double)
int Interp::convert_cycle_g82(block_pointer block,
                              CANON_PLANE plane, //!< selected plane                  
                              double x,  //!< x-value where cycle is executed 
                              double y,  //!< y-value where cycle is executed 
                              double clear_z,    //!< z-value of clearance plane      
                              double bottom_z,   //!< value of z at bottom of cycle   
                              double dwell)      //!< dwell time                      
{
  cycle_feed(block, plane, x, y, bottom_z);
  DWELL(dwell);
  cycle_traverse(block, plane, x, y, clear_z);

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm4, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movl %edx, %ebx
movq %rsi, %r14
movaps %xmm3, %xmm2
callq 0xa180
movsd -0x28(%rbp), %xmm0
callq 0xa040
movq %r14, %rsi
movl %ebx, %edx
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
callq 0xb120
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_cycles.cc
// Function: Interp::convert_cycle_g86(block_struct*, int, double, double, double, double, double, int)
int Interp::convert_cycle_g86(block_pointer block,
                              CANON_PLANE plane, //!< selected plane                     
                              double x,  //!< x-value where cycle is executed    
                              double y,  //!< y-value where cycle is executed    
                              double clear_z,    //!< z-value of clearance plane         
                              double bottom_z,   //!< value of z at bottom of cycle      
                              double dwell,      //!< dwell time                         
                              CANON_DIRECTION direction) //!< direction spindle turning at outset
{
  CHKS(((direction != CANON_CLOCKWISE) &&
       (direction != CANON_COUNTERCLOCKWISE)),
      NCE_SPINDLE_NOT_TURNING_IN_G86);

  cycle_feed(block, plane, x, y, bottom_z);
  DWELL(dwell);
  STOP_SPINDLE_TURNING();
  cycle_traverse(block, plane, x, y, clear_z);
  if (direction == CANON_CLOCKWISE)
    START_SPINDLE_CLOCKWISE();
  else
    START_SPINDLE_COUNTERCLOCKWISE();

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
leal -0x4(%rbx), %eax
cmpl $-0x3, %eax
ja 0x1bb20
movq %rdi, %r12
leaq 0x1e306(%rip), %rdi     # 0x39dd1
callq 0xa1f0
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x2847c(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x1e2f0(%rip), %rsi     # 0x39dec
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x1bb7e
movl %edx, %r14d
movq %rsi, %r15
movsd %xmm0, -0x30(%rbp)
movsd %xmm1, -0x38(%rbp)
movsd %xmm2, -0x40(%rbp)
movaps %xmm3, %xmm2
movsd %xmm4, -0x28(%rbp)
callq 0xa180
movsd -0x28(%rbp), %xmm0
callq 0xa040
callq 0xabb0
movq %r15, %rsi
movl %r14d, %edx
movsd -0x30(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
movsd -0x40(%rbp), %xmm2
callq 0xb120
cmpl $0x2, %ebx
jne 0x1bb77
callq 0xaba0
jmp 0x1bb7c
callq 0xaf20
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_cycles.cc
// Function: Interp::convert_cycle_g88(block_struct*, int, double, double, double, double, int)
int Interp::convert_cycle_g88(block_pointer block,
                              CANON_PLANE plane, //!< selected plane                     
                              double x,  //!< x-value where cycle is executed    
                              double y,  //!< y-value where cycle is executed    
                              double bottom_z,   //!< value of z at bottom of cycle      
                              double dwell,      //!< dwell time                         
                              CANON_DIRECTION direction) //!< direction spindle turning at outset
{
  CHKS(((direction != CANON_CLOCKWISE) &&
       (direction != CANON_COUNTERCLOCKWISE)),
      NCE_SPINDLE_NOT_TURNING_IN_G88);

  cycle_feed(block, plane, x, y, bottom_z);
  DWELL(dwell);
  STOP_SPINDLE_TURNING();
  PROGRAM_STOP();               /* operator retracts the spindle here */
  if (direction == CANON_CLOCKWISE)
    START_SPINDLE_CLOCKWISE();
  else
    START_SPINDLE_COUNTERCLOCKWISE();

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
leal -0x4(%rbx), %eax
cmpl $-0x3, %eax
ja 0x1bdb8
movq %rdi, %r14
leaq 0x1e1a2(%rip), %rdi     # 0x39f05
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x281e4(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x1e18c(%rip), %rsi     # 0x39f20
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x1bde9
movsd %xmm3, -0x18(%rbp)
callq 0xa180
movsd -0x18(%rbp), %xmm0
callq 0xa040
callq 0xabb0
callq 0xac80
cmpl $0x2, %ebx
jne 0x1bde2
callq 0xaba0
jmp 0x1bde7
callq 0xaf20
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq