LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_find.cc
// Function: Interp::unwrap_rotary(double*, double, double, double, char)
int Interp::unwrap_rotary(double *r, double sign_of, double commanded, double current, char axis) {
    double result;
    int neg = copysign(1.0, sign_of) < 0.0;
    CHKS((sign_of <= -360.0 || sign_of >= 360.0), (_("Invalid absolute position %5.2f for wrapped rotary axis %c")), sign_of, axis);
    
    double d = floor(current/360.0);
    result = fabs(commanded) + (d*360.0);
    if(!neg && result < current) result += 360.0;
    if(neg && result > current) result -= 360.0;
    *r = result;

    return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movapd 0xc3ff(%rip), %xmm3     # 0x2e020
andpd %xmm0, %xmm3
ucomisd 0xe28b(%rip), %xmm3     # 0x2feb8
jae 0x21ca0
movq %rsi, %rbx
movq %xmm0, %r14
movsd 0xe279(%rip), %xmm3     # 0x2feb8
movapd %xmm2, %xmm0
divsd %xmm3, %xmm0
movapd %xmm2, -0x30(%rbp)
movaps %xmm1, -0x40(%rbp)
callq 0xc450
movsd 0xe25b(%rip), %xmm3     # 0x2feb8
movapd -0x40(%rbp), %xmm1
andpd 0xc3b6(%rip), %xmm1     # 0x2e020
mulsd %xmm3, %xmm0
addsd %xmm1, %xmm0
testq %r14, %r14
js 0x21d01
addsd %xmm0, %xmm3
movapd %xmm0, %xmm1
movapd -0x30(%rbp), %xmm2
cmpnltsd %xmm2, %xmm1
andpd %xmm1, %xmm0
andnpd %xmm3, %xmm1
orpd %xmm1, %xmm0
js 0x21d08
jmp 0x21d29
movl %edx, %r14d
movq %rdi, %r15
leaq 0xf6f8(%rip), %rdi      # 0x313a5
movapd %xmm0, -0x30(%rbp)
callq 0xb220
movsbl %r14b, %edx
movq %r15, %rdi
movq %rax, %rsi
movapd -0x30(%rbp), %xmm0
movb $0x1, %al
callq 0xb8e0
movq 0x1b28c(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0x11db3(%rip), %rsi     # 0x33a95
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rax
jmp 0x21d2f
movapd -0x30(%rbp), %xmm2
jns 0x21d29
movsd 0x11b18(%rip), %xmm1    # 0x33828
addsd %xmm0, %xmm1
cmpltsd %xmm0, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
movapd %xmm2, %xmm0
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_find.cc
// Function: Interp::find_tool_pocket(setup_struct*, int, int*)
int Interp::find_tool_pocket(setup_pointer settings, int toolno, int *pocket)
{
    if(!settings->random_toolchanger && toolno == 0) {
        *pocket = 0;
        return INTERP_OK;
    }
    *pocket = -1;
    for(int i=0; i<CANON_POCKETS_MAX; i++) {
        if(settings->tool_table[i].toolno == toolno)
            *pocket = i;
    }

    CHKS((*pocket == -1), (_("Requested tool %d not found in the tool table")), toolno);
    return INTERP_OK;
}

// Assembly:
movl 0xc6ac(%rsi), %eax
orl %edx, %eax
je 0x231d9
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
orl $-0x1, (%rcx)
addq $0xd6c8, %rsi           # imm = 0xD6C8
pushq $-0x1
popq %rdx
xorl %eax, %eax
cmpq $0x38, %rax
je 0x23180
cmpl %ebx, (%rsi)
jne 0x23177
movl %eax, (%rcx)
movl %eax, %edx
incq %rax
addq $0x70, %rsi
jmp 0x23169
xorl %eax, %eax
cmpl $-0x1, %edx
jne 0x231d4
leaq 0x108d9(%rip), %rdi     # 0x33a67
callq 0xb220
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0xb8e0
movq 0x19db7(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0x1092f(%rip), %rsi     # 0x33ae6
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
andl $0x0, (%rcx)
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_internal.cc
// Function: Interp::close_and_downcase(char*)
int Interp::close_and_downcase(char *line)       //!< string: one line of NC code
{
  int m;
  int n;
  int comment;
  char item;
  comment = 0;
  for (n = 0, m = 0; (item = line[m]) != (char) NULL; m++) {
    if (comment) {
      line[n++] = item;
      if (item == ')') {
        comment = 0;
      } else if (item == '(')
        ERS(NCE_NESTED_COMMENT_FOUND);
    } else if ((item == ' ') || (item == '\t') || (item == '\r'));
    /* don't copy blank or tab or CR */
    else if (item == '\n') {    /* don't copy newline            *//* but check null follows        */
      CHKS((line[m + 1] != 0), NCE_NULL_MISSING_AFTER_NEWLINE);
    } else if ((64 < item) && (item < 91)) {    /* downcase upper case letters */
      line[n++] = (32 + item);
    } else if (item == '(') {   /* comment is starting */
      comment = 1;
      line[n++] = item;
    } else {
      line[n++] = item;         /* copy anything else */
    }
  }
  CHKS((comment), NCE_UNCLOSED_COMMENT_FOUND);
  line[n] = 0;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1(%rsi), %rax
xorl %edx, %edx
pushq $0x1
popq %rcx
xorl %edi, %edi
movzbl -0x1(%rax), %r8d
movslq %edx, %r9
testl %r8d, %r8d
je 0x23268
testl %edi, %edi
jne 0x23226
xorl %edi, %edi
cmpl $0x9, %r8d
je 0x23263
cmpl $0x20, %r8d
je 0x23263
cmpl $0xd, %r8d
je 0x23263
cmpl $0xa, %r8d
jne 0x23240
cmpb $0x0, (%rax)
je 0x23263
jmp 0x23287
leal 0x1(%r9), %edx
movb %r8b, (%rsi,%r9)
xorl %edi, %edi
cmpl $0x29, %r8d
je 0x23263
cmpl $0x28, %r8d
je 0x2327e
movl %ecx, %edi
jmp 0x23263
leal -0x41(%r8), %r10d
incl %edx
cmpb $0x19, %r10b
ja 0x23252
orb $0x20, %r8b
jmp 0x2325f
cmpb $0x28, %r8b
jne 0x2325f
movb $0x28, (%rsi,%r9)
jmp 0x2323c
movb %r8b, (%rsi,%r9)
incq %rax
jmp 0x231f4
testl %edi, %edi
je 0x23275
leaq 0x1090d(%rip), %rdi     # 0x33b80
jmp 0x2328e
movb $0x0, (%rsi,%r9)
xorl %eax, %eax
jmp 0x232d2
leaq 0x108cb(%rip), %rdi     # 0x33b50
jmp 0x2328e
leaq 0x108d7(%rip), %rdi     # 0x33b65
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x19cb9(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0x10aa3(%rip), %rsi     # 0x33d58
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_internal.cc
// Function: Interp::init_block(block_struct*)
int Interp::init_block(block_pointer block)      //!< pointer to a block to be initialized or reset
{
  int n;
  block->a_flag = OFF;
  block->b_flag = OFF;
  block->c_flag = OFF;
  block->comment[0] = 0;
  block->d_flag = OFF;
  block->e_flag = OFF;
  block->f_number = -1.0;
  for (n = 0; n < 16; n++) {
    block->g_modes[n] = -1;
  }
  block->h_flag = OFF;
  block->h_number = -1;
  block->i_flag = OFF;
  block->j_flag = OFF;
  block->k_flag = OFF;
  block->l_number = -1;
  block->l_flag = OFF;
  block->line_number = -1;
  block->n_number = -1;
  block->motion_to_be = -1;
  block->m_count = 0;
  for (n = 0; n < 11; n++) {
    block->m_modes[n] = -1;
  }
  block->user_m = 0;
  block->p_number = -1.0;
  block->p_flag = OFF;
  block->q_flag = OFF;
  block->q_number = -1.0;
  block->r_flag = OFF;
  block->s_number = -1.0;
  block->t_number = -1;
  block->u_flag = OFF;
  block->v_flag = OFF;
  block->w_flag = OFF;
  block->x_flag = OFF;
  block->y_flag = OFF;
  block->z_flag = OFF;

  block->theta_flag = OFF;
  block->radius_flag = OFF;

  block->o_type = O_none;
  block->o_number = 0;

  if(block->o_name)
    {
      free(block->o_name);
      block->o_name = 0;
    }

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %ecx, %ecx
movb %cl, (%rsi)
movb %cl, 0x10(%rsi)
movb %cl, 0x20(%rsi)
movb %cl, 0x30(%rsi)
andw $0x0, 0x138(%rsi)
movabsq $-0x4010000000000000, %rax # imm = 0xBFF0000000000000
movq %rax, 0x148(%rsi)
cmpq $0x10, %rcx
je 0x235f6
orl $-0x1, 0x150(%rbx,%rcx,4)
incq %rcx
jmp 0x235e3
xorl %ecx, %ecx
movb %cl, 0x190(%rbx)
orl $-0x1, 0x194(%rbx)
movb %cl, 0x198(%rbx)
movb %cl, 0x1a8(%rbx)
movb %cl, 0x1b8(%rbx)
orl $-0x1, 0x1c8(%rbx)
movb %cl, 0x1cc(%rbx)
movaps 0x10515(%rip), %xmm0    # 0x33b40
movups %xmm0, 0x1d0(%rbx)
cmpq $0xb, %rcx
je 0x23645
orl $-0x1, 0x1e0(%rbx,%rcx,4)
incq %rcx
jmp 0x23632
andl $0x0, 0x20c(%rbx)
movq %rax, 0x210(%rbx)
xorl %ecx, %ecx
movb %cl, 0x218(%rbx)
andw $0x0, 0x228(%rbx)
movq %rax, 0x220(%rbx)
movq %rax, 0x238(%rbx)
orl $-0x1, 0x240(%rbx)
movb %cl, 0x244(%rbx)
movb %cl, 0x250(%rbx)
movb %cl, 0x260(%rbx)
movb %cl, 0x270(%rbx)
movb %cl, 0x280(%rbx)
movb %cl, 0x290(%rbx)
andl $0x0, 0x2b0(%rbx)
andl $0x0, 0x2a0(%rbx)
andq $0x0, 0x2c8(%rbx)
movq 0x2d0(%rbx), %rdi
testq %rdi, %rdi
je 0x236cb
callq 0xbde0
andq $0x0, 0x2d0(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_internal.cc
// Function: Interp::parse_line(char*, block_struct*, setup_struct*)
int Interp::parse_line(char *line,       //!< array holding a line of RS274 code  
                      block_pointer block,      //!< pointer to a block to be filled     
                      setup_pointer settings)   //!< pointer to machine settings         
{
  CHP(init_block(block));
  CHP(read_items(block, line, settings->parameters));

  if(settings->skipping_o == 0)
  {
    CHP(enhance_block(block, settings));
    CHP(check_items(block, settings));
  }
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movq %rdx, %rsi
callq 0xbb80
leaq 0x17c0(%r14), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xb420
testl %eax, %eax
je 0x23774
movl %eax, %ebx
movq 0x19848(%rip), %rax     # 0x3cf60
movslq 0xd670(%rax), %rcx
cmpq $0x30, %rcx
jg 0x2376f
imulq $0x50, %rcx, %rcx
leaq (%rax,%rcx), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x106bf(%rip), %rsi     # 0x33dfa
pushq $0x50
popq %rdx
callq 0xb940
movq 0x19816(%rip), %rax     # 0x3cf60
movslq 0xd670(%rax), %rcx
imulq $0x50, %rcx, %rdx
xorl %esi, %esi
movb %sil, 0xc71f(%rax,%rdx)
incl %ecx
movl %ecx, 0xd670(%rax)
movb %sil, 0xc720(%rax,%rdx)
movl %ebx, %r15d
jmp 0x23781
xorl %r15d, %r15d
cmpq $0x0, 0xef70(%r14)
je 0x23793
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xbef0
testl %eax, %eax
jne 0x2370f
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xbf10
testl %eax, %eax
jne 0x2370f
jmp 0x23781
nop
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_internal.cc
// Function: Interp::refresh_actual_position(setup_struct*)
int Interp::refresh_actual_position(setup_pointer settings) 
{
  settings->current_x = GET_EXTERNAL_POSITION_X();
  settings->current_y = GET_EXTERNAL_POSITION_Y();
  settings->current_z = GET_EXTERNAL_POSITION_Z();
  settings->AA_current = GET_EXTERNAL_POSITION_A();
  settings->BB_current = GET_EXTERNAL_POSITION_B();
  settings->CC_current = GET_EXTERNAL_POSITION_C();
  settings->u_current = GET_EXTERNAL_POSITION_U();
  settings->v_current = GET_EXTERNAL_POSITION_V();
  settings->w_current = GET_EXTERNAL_POSITION_W();

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xc710
movsd %xmm0, 0x600(%rbx)
callq 0xb7d0
movsd %xmm0, 0x608(%rbx)
callq 0xb3a0
movsd %xmm0, 0x610(%rbx)
callq 0xb2b0
movsd %xmm0, 0x8(%rbx)
callq 0xb8f0
movsd %xmm0, 0x20(%rbx)
callq 0xc260
movsd %xmm0, 0x38(%rbx)
callq 0xc7b0
movsd %xmm0, 0x50(%rbx)
callq 0xbc40
movsd %xmm0, 0x68(%rbx)
callq 0xb460
movsd %xmm0, 0x80(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_internal.cc
// Function: Interp::set_probe_data(setup_struct*)
int Interp::set_probe_data(setup_pointer settings)       //!< pointer to machine settings
{
  double a, b, c;
  refresh_actual_position(settings);
  settings->parameters[5061] = GET_EXTERNAL_PROBE_POSITION_X();
  settings->parameters[5062] = GET_EXTERNAL_PROBE_POSITION_Y();
  settings->parameters[5063] = GET_EXTERNAL_PROBE_POSITION_Z();

  a = GET_EXTERNAL_PROBE_POSITION_A();
  if(settings->a_axis_wrapped) {
      a = fmod(a, 360.0);
      if(a<0) a += 360.0;
  }
  settings->parameters[5064] = a;

  b = GET_EXTERNAL_PROBE_POSITION_B();
  if(settings->b_axis_wrapped) {
      b = fmod(b, 360.0);
      if(b<0) b += 360.0;
  }
  settings->parameters[5065] = b;

  c = GET_EXTERNAL_PROBE_POSITION_C();
  if(settings->c_axis_wrapped) {
      c = fmod(c, 360.0);
      if(c<0) c += 360.0;
  }
  settings->parameters[5066] = c;

  settings->parameters[5067] = GET_EXTERNAL_PROBE_POSITION_U();
  settings->parameters[5068] = GET_EXTERNAL_PROBE_POSITION_V();
  settings->parameters[5069] = GET_EXTERNAL_PROBE_POSITION_W();
  settings->parameters[5070] = (double) GET_EXTERNAL_PROBE_TRIPPED_VALUE();

  // was an undocumented feature?: settings->parameters[5067] = GET_EXTERNAL_PROBE_VALUE();
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xbea0
callq 0xb750
movsd %xmm0, 0xb5e8(%rbx)
callq 0xb1b0
movsd %xmm0, 0xb5f0(%rbx)
callq 0xbed0
movsd %xmm0, 0xb5f8(%rbx)
callq 0xb700
cmpl $0x0, 0x1e6cc(%rbx)
je 0x238b6
movsd 0xc619(%rip), %xmm1     # 0x2feb8
callq 0xbf20
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x238b6
addsd 0xc602(%rip), %xmm0     # 0x2feb8
movsd %xmm0, 0xb600(%rbx)
callq 0xc600
cmpl $0x0, 0x1e6d0(%rbx)
je 0x238eb
movsd 0xc5e4(%rip), %xmm1     # 0x2feb8
callq 0xbf20
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x238eb
addsd 0xc5cd(%rip), %xmm0     # 0x2feb8
movsd %xmm0, 0xb608(%rbx)
callq 0xb310
cmpl $0x0, 0x1e6d4(%rbx)
je 0x23920
movsd 0xc5af(%rip), %xmm1     # 0x2feb8
callq 0xbf20
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x23920
addsd 0xc598(%rip), %xmm0     # 0x2feb8
movsd %xmm0, 0xb610(%rbx)
callq 0xb9a0
movsd %xmm0, 0xb618(%rbx)
callq 0xc180
movsd %xmm0, 0xb620(%rbx)
callq 0xc0e0
movsd %xmm0, 0xb628(%rbx)
callq 0xc480
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0xb630(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_inverse.cc
// Function: Interp::inverse_time_rate_arc(double, double, double, double, double, int, double, double, double, block_struct*, setup_struct*)
int Interp::inverse_time_rate_arc(double x1,     //!< x coord of start point of arc           
                                 double y1,     //!< y coord of start point of arc           
                                 double z1,     //!< z coord of start point of arc           
                                 double cx,     //!< x coord of center of arc                
                                 double cy,     //!< y coord of center of arc                
                                 int turn,      //!< turn of arc                             
                                 double x2,     //!< x coord of end point of arc             
                                 double y2,     //!< y coord of end point of arc             
                                 double z2,     //!< z coord of end point of arc             
                                 block_pointer block,   //!< pointer to a block of RS274 instructions
                                 setup_pointer settings)        //!< pointer to machine settings             
{
  double length;
  double rate;

  if (settings->feed_mode != INVERSE_TIME) return -1;

  length = find_arc_length(x1, y1, z1, cx, cy, turn, x2, y2, z2);
  rate = MAX(0.1, (length * block->f_number));
  enqueue_SET_FEED_RATE(rate);
  settings->feed_rate = rate;

  return INTERP_OK;
}

// Assembly:
cmpl $0x1, 0x670(%rcx)
jne 0x239c6
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
callq 0xc7d0
mulsd 0x148(%r14), %xmm0
movsd 0xa664(%rip), %xmm1     # 0x2e000
maxsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
movapd %xmm1, %xmm0
callq 0xb800
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x678(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_a(char*, int*, block_struct*, double*)
int Interp::read_a(char *line,   //!< string: line of RS274/NGC code being processed
                  int *counter, //!< pointer to a counter for position on the line 
                  block_pointer block,  //!< pointer to a block being filled from the line 
                  double *parameters)   //!< array of system parameters                    
{
  double value;

  CHKS((line[*counter] != 'a'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->a_flag != OFF), NCE_MULTIPLE_A_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->a_flag = ON;
  block->a_number = value;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x61, (%rsi,%rax)
jne 0x23b30
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, (%rcx)
jne 0x23b86
leaq 0x113e3(%rip), %rdi     # 0x34f11
jmp 0x23b37
leaq 0xf718(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x19410(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0x10432(%rip), %rsi     # 0x33f90
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x23bf2
movl %eax, %ebx
movq 0x193c1(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x23b7b
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x103ce(%rip), %rsi     # 0x33f90
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x23b7b
movb $0x1, (%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%r14)
xorl %ebx, %ebx
jmp 0x23b7b
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_atan(char*, int*, double*, double*)
int Interp::read_atan(char *line,        //!< string: line of RS274/NGC code being processed
                     int *counter,      //!< pointer to a counter for position on line     
                     double *double_ptr,        //!< pointer to double to be read                  
                     double *parameters)        //!< array of system parameters                    
{
  double argument2;

  CHKS((line[*counter] != '/'), NCE_SLASH_MISSING_AFTER_FIRST_ATAN_ARGUMENT);
  *counter = (*counter + 1);
  CHKS((line[*counter] != '['),
      NCE_LEFT_BRACKET_MISSING_AFTER_SLASH_WITH_ATAN);
  CHP(read_real_expression(line, counter, &argument2, parameters));
  *double_ptr = atan2(*double_ptr, argument2);  /* value in radians */
  *double_ptr = ((*double_ptr * 180.0) / M_PIl);   /* convert to degrees */
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x2f, (%rsi,%rax)
jne 0x23e9b
movq %rcx, %r14
leaq 0x1(%rax), %rcx
movl %ecx, (%rdx)
cmpb $0x5b, 0x1(%rsi,%rax)
jne 0x23ea4
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0xc0f0
testl %eax, %eax
je 0x23efa
movl %eax, %ebx
movq 0x1911c(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x23eef
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x101c7(%rip), %rsi     # 0x34032
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x23eef
leaq 0x1108c(%rip), %rdi     # 0x34f2e
jmp 0x23eab
leaq 0x110ab(%rip), %rdi     # 0x34f56
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x1909c(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0x10160(%rip), %rsi     # 0x34032
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movsd (%r14), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0xb110
mulsd 0xbfcf(%rip), %xmm0     # 0x2fee0
movsd %xmm0, -0x18(%rbp)
fldt 0xc044(%rip)            # 0x2ff60
fdivrl -0x18(%rbp)
fstpl (%r14)
xorl %ebx, %ebx
jmp 0x23eef
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_b(char*, int*, block_struct*, double*)
int Interp::read_b(char *line,   //!< string: line of RS274/NGC code being processed
                  int *counter, //!< pointer to a counter for position on the line 
                  block_pointer block,  //!< pointer to a block being filled from the line 
                  double *parameters)   //!< array of system parameters                    
{
  double value;

  CHKS((line[*counter] != 'b'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->b_flag != OFF), NCE_MULTIPLE_B_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->b_flag = ON;
  block->b_number = value;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x62, (%rsi,%rax)
jne 0x241e9
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x10(%rcx)
jne 0x2423f
leaq 0x10d9a(%rip), %rdi     # 0x34f81
jmp 0x241f0
leaq 0xf05f(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x18d57(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xfebd(%rip), %rsi      # 0x340d4
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x242ab
movl %eax, %ebx
movq 0x18d08(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x24234
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xfe59(%rip), %rsi      # 0x340d4
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x24234
movb $0x1, 0x10(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x18(%r14)
xorl %ebx, %ebx
jmp 0x24234
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_c(char*, int*, block_struct*, double*)
int Interp::read_c(char *line,   //!< string: line of RS274/NGC code being processed
                  int *counter, //!< pointer to a counter for position on the line 
                  block_pointer block,  //!< pointer to a block being filled from the line 
                  double *parameters)   //!< array of system parameters                    
{
  double value;

  CHKS((line[*counter] != 'c'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->c_flag != OFF), NCE_MULTIPLE_C_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->c_flag = ON;
  block->c_number = value;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x63, (%rsi,%rax)
jne 0x242ef
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x20(%rcx)
jne 0x24345
leaq 0x10cb1(%rip), %rdi     # 0x34f9e
jmp 0x242f6
leaq 0xef59(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x18c51(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xfe08(%rip), %rsi      # 0x34125
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x243b1
movl %eax, %ebx
movq 0x18c02(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2433a
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xfda4(%rip), %rsi      # 0x34125
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x2433a
movb $0x1, 0x20(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x28(%r14)
xorl %ebx, %ebx
jmp 0x2433a
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_comment(char*, int*, block_struct*, double*)
int Interp::read_comment(char *line,     //!< string: line of RS274 code being processed   
                        int *counter,   //!< pointer to a counter for position on the line
                        block_pointer block,    //!< pointer to a block being filled from the line
                        double *parameters)     //!< array of system parameters                   
{
  int n;

  CHKS((line[*counter] != '('), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  (*counter)++;
  for (n = 0; line[*counter] != ')'; (*counter)++, n++) {
    block->comment[n] = line[*counter];
  }
  block->comment[n] = 0;
  (*counter)++;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rdi
cmpb $0x28, (%rsi,%rdi)
jne 0x243fd
incl %edi
movl %edi, (%rdx)
xorl %eax, %eax
movslq %edi, %rdi
movb (%rsi,%rdi), %dil
cmpb $0x29, %dil
je 0x2444a
movb %dil, 0x30(%rcx,%rax)
movl (%rdx), %edi
incl %edi
movl %edi, (%rdx)
incq %rax
jmp 0x243e0
leaq 0xee4b(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x18b43(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xfd4b(%rip), %rsi      # 0x34176
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rax
jmp 0x24455
movl %eax, %eax
movb $0x0, 0x30(%rcx,%rax)
incl (%rdx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_d(char*, int*, block_struct*, double*)
int Interp::read_d(char *line,   //!< string: line of RS274 code being processed   
                  int *counter, //!< pointer to a counter for position on the line
                  block_pointer block,  //!< pointer to a block being filled from the line
                  double *parameters)   //!< array of system parameters                   
{
  double value;

  CHKS((line[*counter] != 'd'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->d_flag != OFF), NCE_MULTIPLE_D_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->d_number_float = value;
  block->d_flag = ON;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x64, (%rsi,%rax)
jne 0x24502
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x138(%rcx)
jne 0x24558
leaq 0x10abb(%rip), %rdi     # 0x34fbb
jmp 0x24509
leaq 0xed46(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x18a3e(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xfce8(%rip), %rsi      # 0x34218
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x245c4
movl %eax, %ebx
movq 0x189ef(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2454d
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xfc84(%rip), %rsi      # 0x34218
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x2454d
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x130(%r14)
movb $0x1, 0x138(%r14)
xorl %ebx, %ebx
jmp 0x2454d
nop
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_e(char*, int*, block_struct*, double*)
int Interp::read_e(char *line,   //!< string: line of RS274/NGC code being processed
                  int *counter, //!< pointer to a counter for position on the line 
                  block_pointer block,  //!< pointer to a block being filled from the line 
                  double *parameters)   //!< array of system parameters                    
{
  double value;

  CHKS((line[*counter] != 'e'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->e_flag != OFF), NCE_MULTIPLE_E_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->e_flag = ON;
  block->e_number = value;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x65, (%rsi,%rax)
jne 0x24612
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x139(%rcx)
jne 0x24668
leaq 0x109c8(%rip), %rdi     # 0x34fd8
jmp 0x24619
leaq 0xec36(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x1892e(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xfc29(%rip), %rsi      # 0x34269
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x246d4
movl %eax, %ebx
movq 0x188df(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2465d
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xfbc5(%rip), %rsi      # 0x34269
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x2465d
movb $0x1, 0x139(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x140(%r14)
xorl %ebx, %ebx
jmp 0x2465d
nop
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_f(char*, int*, block_struct*, double*)
int Interp::read_f(char *line,   //!< string: line of RS274 code being processed   
                  int *counter, //!< pointer to a counter for position on the line
                  block_pointer block,  //!< pointer to a block being filled from the line
                  double *parameters)   //!< array of system parameters                   
{
  double value;

  CHKS((line[*counter] != 'f'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->f_number > -1.0), NCE_MULTIPLE_F_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  CHKS((value < 0.0), NCE_NEGATIVE_F_WORD_USED);
  block->f_number = value;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x66, (%rsi,%rax)
jne 0x2472a
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
movsd 0x148(%rcx), %xmm0
ucomisd 0xb151(%rip), %xmm0     # 0x2f870
jbe 0x24784
leaq 0x108cd(%rip), %rdi     # 0x34ff5
jmp 0x24731
leaq 0xeb1e(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x18816(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xfb62(%rip), %rsi      # 0x342ba
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x247ee
movl %eax, %r14d
movq 0x187c2(%rip), %rbx     # 0x3cf60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x24776
imulq $0x50, %rax, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xfaf9(%rip), %rsi      # 0x342ba
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%rbx), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
jmp 0x24776
movsd -0x20(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x24809
leaq 0x1080e(%rip), %rdi     # 0x35012
jmp 0x24731
movsd %xmm0, 0x148(%r15)
xorl %r14d, %r14d
jmp 0x24776
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_h(char*, int*, block_struct*, double*)
int Interp::read_h(char *line,   //!< string: line of RS274/NGC code being processed
                  int *counter, //!< pointer to a counter for position on the line 
                  block_pointer block,  //!< pointer to a block being filled from the line 
                  double *parameters)   //!< array of system parameters                    
{
  int value;

  CHKS((line[*counter] != 'h'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->h_flag == ON), NCE_MULTIPLE_H_WORDS_ON_ONE_LINE);
  CHP(read_integer_value(line, counter, &value, parameters));
  CHKS((value < -1), NCE_NEGATIVE_H_WORD_USED);
  block->h_flag = ON;
  block->h_number = value;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x68, (%rsi,%rax)
jne 0x24a11
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x190(%rcx)
jne 0x24a6b
leaq 0x1067c(%rip), %rdi     # 0x3508b
jmp 0x24a18
leaq 0xe837(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x1852f(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xf91d(%rip), %rsi      # 0x3435c
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1c(%rbp), %rcx
movq %rbx, %rdi
callq 0xbc20
testl %eax, %eax
je 0x24ad5
movl %eax, %r14d
movq 0x184db(%rip), %rbx     # 0x3cf60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x24a5d
imulq $0x50, %rax, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xf8b4(%rip), %rsi      # 0x3435c
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%rbx), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
jmp 0x24a5d
movl -0x1c(%rbp), %eax
cmpl $-0x2, %eax
jg 0x24ae9
leaq 0x105c4(%rip), %rdi     # 0x350a8
jmp 0x24a18
movb $0x1, 0x190(%r15)
movl %eax, 0x194(%r15)
xorl %r14d, %r14d
jmp 0x24a5d
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_integer_value(char*, int*, int*, double*)
int Interp::read_integer_value(char *line,       //!< string: line of RS274/NGC code being processed
                              int *counter,     //!< pointer to a counter for position on the line 
                              int *integer_ptr, //!< pointer to the value being read               
                              double *parameters)       //!< array of system parameters                    
{
  double float_value;

  CHP(read_real_value(line, counter, &float_value, parameters));
  *integer_ptr = (int) floor(float_value);
  if ((float_value - *integer_ptr) > 0.9999) {
    *integer_ptr = (int) ceil(float_value);
  } else if ((float_value - *integer_ptr) > 0.0001)
    ERS(NCE_NON_INTEGER_VALUE_FOR_INTEGER);
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdi, %r14
leaq -0x28(%rbp), %rcx
callq 0xc040
testl %eax, %eax
je 0x24b83
movl %eax, %ebx
movq 0x18437(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x24c23
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xf85d(%rip), %rsi      # 0x343ad
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x24c23
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0xc450
movsd -0x20(%rbp), %xmm2
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
movl %eax, (%r15)
cvtdq2pd %xmm0, %xmm1
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
ucomisd 0xf2ea(%rip), %xmm0     # 0x33ea0
jbe 0x24bcc
movapd %xmm2, %xmm0
callq 0xb170
cvttsd2si %xmm0, %eax
movl %eax, (%r15)
xorl %ebx, %ebx
jmp 0x24c23
xorl %ebx, %ebx
ucomisd 0xac8a(%rip), %xmm0     # 0x2f860
jbe 0x24c23
leaq 0x10525(%rip), %rdi     # 0x35104
callq 0xb220
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x18368(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xf7a7(%rip), %rsi      # 0x343ad
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_i(char*, int*, block_struct*, double*)
int Interp::read_i(char *line,   //!< string: line of RS274 code being processed    
                  int *counter, //!< pointer to a counter for position on the line 
                  block_pointer block,  //!< pointer to a block being filled from the line 
                  double *parameters)   //!< array of system parameters                    
{
  double value;

  CHKS((line[*counter] != 'i'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->i_flag != OFF), NCE_MULTIPLE_I_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->i_flag = ON;
  block->i_number = value;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x69, (%rsi,%rax)
jne 0x24c60
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x198(%rcx)
jne 0x24cb6
leaq 0x1045f(%rip), %rdi     # 0x350bd
jmp 0x24c67
leaq 0xe5e8(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x182e0(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xf770(%rip), %rsi      # 0x343fe
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x24d22
movl %eax, %ebx
movq 0x18291(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x24cab
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xf70c(%rip), %rsi      # 0x343fe
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x24cab
movb $0x1, 0x198(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x1a0(%r14)
xorl %ebx, %ebx
jmp 0x24cab
nop
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_integer_unsigned(char*, int*, int*)
int Interp::read_integer_unsigned(char *line,    //!< string: line of RS274 code being processed   
                                 int *counter,  //!< pointer to a counter for position on the line
                                 int *integer_ptr)      //!< pointer to the value being read              
{
  int n;
  char c;

  for (n = *counter;; n++) {
    c = line[n];
    if ((c < 48) || (c > 57))
      break;
  }
  CHKS((n == *counter), NCE_BAD_FORMAT_UNSIGNED_INTEGER);
  if (sscanf(line + *counter, "%d", integer_ptr) == 0)
    ERS(NCE_SSCANF_FAILED);
  *counter = n;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movslq (%rdx), %r12
addq %r12, %rsi
xorl %r13d, %r13d
movb (%rsi,%r13), %al
addb $-0x3a, %al
incq %r13
cmpb $-0xb, %al
ja 0x24d5d
cmpl $0x1, %r13d
jne 0x24d79
leaq 0x10363(%rip), %rdi     # 0x350da
jmp 0x24da9
leaq 0x10ed4(%rip), %rax     # 0x35c54
xorl %r15d, %r15d
movq %rsi, %rdi
movq %rax, %rsi
movq %rcx, %rdx
xorl %eax, %eax
callq 0xbb10
testl %eax, %eax
je 0x24da2
decl %r12d
addq %r13, %r12
movl %r12d, (%r14)
jmp 0x24dee
leaq 0x1034d(%rip), %rdi     # 0x350f6
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x1819e(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xf67f(%rip), %rsi      # 0x3444f
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_items(block_struct*, char*, double*)
int Interp::read_items(block_pointer block,      //!< pointer to a block being filled from the line 
                      char *line,       //!< string: line of RS274/NGC code being processed
                      double *parameters)   //!< array of system parameters 
{
  int counter;
  int length;

  length = strlen(line);
  counter = 0;

  if (line[counter] == '/')     /* skip the slash character if first */
    counter++;

  if (line[counter] == 'n') {
    CHP(read_n_number(line, &counter, block));
  }

  if (line[counter] == 'o')
 /* Handle 'o' explicitly here. Default is
    to read letters via pointer calls to related
    reader functions. 'o' control lines have their
    own commands and command handlers. */
    {
      CHP(read_o(line, &counter, block, parameters));
      return INTERP_OK;
    }
  else if(_setup.skipping_o != 0)
  {
      // if we are skipping, do NOT evaluate non-olines
      return INTERP_OK;
  }

  for (; counter < length;) {
    CHP(read_one_item(line, &counter, block, parameters));
  }
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
movq %rdx, %rdi
callq 0xb4e0
movq %rax, %r14
xorl %eax, %eax
cmpb $0x2f, (%r12)
sete %al
movl %eax, -0x2c(%rbp)
cmpb $0x6e, (%r12,%rax)
jne 0x24e56
leaq -0x2c(%rbp), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0xc060
testl %eax, %eax
jne 0x24e82
movl -0x2c(%rbp), %eax
movslq %eax, %rcx
cmpb $0x6f, (%r12,%rcx)
jne 0x24ee8
leaq -0x2c(%rbp), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq -0x38(%rbp), %r8
callq 0xb1d0
testl %eax, %eax
je 0x24f1e
movl %eax, %ebx
movq 0x180d5(%rip), %rax     # 0x3cf60
movslq 0xd670(%rax), %rcx
cmpq $0x30, %rcx
jg 0x24f20
imulq $0x50, %rcx, %rcx
leaq (%rax,%rcx), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xf5ee(%rip), %rsi      # 0x344a0
pushq $0x50
popq %rdx
callq 0xb940
movq 0x1809f(%rip), %rax     # 0x3cf60
movslq 0xd670(%rax), %rcx
imulq $0x50, %rcx, %rdx
xorl %esi, %esi
movb %sil, 0xc71f(%rax,%rdx)
incl %ecx
movl %ecx, 0xd670(%rax)
movb %sil, 0xc720(%rax,%rdx)
jmp 0x24f20
movq 0x18071(%rip), %rcx     # 0x3cf60
cmpq $0x0, 0xef70(%rcx)
jne 0x24f1e
cmpl %r14d, %eax
jge 0x24f1e
movq %r13, %rdi
movq %r12, %rsi
leaq -0x2c(%rbp), %rdx
movq %r15, %rcx
movq -0x38(%rbp), %r8
callq 0xb6e0
testl %eax, %eax
jne 0x24f31
cmpl %r14d, -0x2c(%rbp)
jl 0x24efe
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
movq 0x18026(%rip), %rcx     # 0x3cf60
movslq 0xd670(%rcx), %rax
cmpq $0x30, %rax
jg 0x24f20
imulq $0x50, %rax, %rax
leaq (%rcx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
jmp 0x24eab
nop
// File: /workspace/github_cpp_makefile_star2_O2/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_n_number(char*, int*, block_struct*)
int Interp::read_n_number(char *line, //!< string: line of RS274    code being processed 
                          int *counter,       //!< pointer to a counter for position on the line 
                          block_pointer block)        //!< pointer to a block being filled from the line 
{
  int value;

  CHKS(((line[*counter] != 'n') && (line[*counter] != 'o')),
      NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHP(read_integer_unsigned(line, counter, &value));
/* This next test is problematic as many CAM systems will exceed this !
  CHKS((value > 99999), NCE_LINE_NUMBER_GREATER_THAN_99999); */
  block->n_number = value;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movslq (%rdx), %rax
movb (%rsi,%rax), %cl
andb $-0x2, %cl
cmpb $0x6e, %cl
jne 0x24ff3
incl %eax
movl %eax, (%rdx)
leaq -0x14(%rbp), %rcx
movq %rbx, %rdi
callq 0xc370
testl %eax, %eax
je 0x25040
movl %eax, %ebx
movq 0x17fc4(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2504c
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xf52e(%rip), %rsi      # 0x344f1
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x2504c
leaq 0xe255(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x17f4d(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xf4d0(%rip), %rsi      # 0x344f1
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
jmp 0x2504c
movl -0x14(%rbp), %eax
movl %eax, 0x1d4(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop