LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_execute.cc
// Function: Interp::execute_binary1(double*, int, double*)
int Interp::execute_binary1(double *left,        //!< pointer to the left operand    
                           int operation,       //!< integer code for the operation 
                           double *right)       //!< pointer to the right operand   
{
  switch (operation) {
  case DIVIDED_BY:
    CHKS((*right == 0.0), NCE_ATTEMPT_TO_DIVIDE_BY_ZERO);
    *left = (*left / *right);
    break;
  case MODULO:                 /* always calculates a positive answer */
    *left = fmod(*left, *right);
    if (*left < 0.0) {
      *left = (*left + fabs(*right));
    }
    break;
  case POWER:
    CHKS(((*left < 0.0) && (floor(*right) != *right)),
        NCE_ATTEMPT_TO_RAISE_NEGATIVE_TO_NON_INTEGER_POWER);
    *left = pow(*left, *right);
    break;
  case TIMES:
    *left = (*left * *right);
    break;
  default:
    ERS(NCE_BUG_UNKNOWN_OPERATION);
  }
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
decl %edx
cmpl $0x3, %edx
ja 0x2639c
movq %rcx, %r15
movq %rsi, %rbx
leaq 0x14262(%rip), %rax     # 0x3a548
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movsd (%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x26417
jp 0x26417
leaq 0x14449(%rip), %rdi     # 0x3a758
jmp 0x263a3
movsd (%rbx), %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm0
jbe 0x263f8
movsd (%r15), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
callq 0xb2f0
movsd -0x28(%rbp), %xmm2
ucomisd -0x20(%rbp), %xmm0
jne 0x2634c
jnp 0x263f8
leaq 0x1441f(%rip), %rdi     # 0x3a772
jmp 0x263a3
movsd (%rbx), %xmm0
mulsd (%r15), %xmm0
jmp 0x26406
movsd (%rbx), %xmm0
movsd (%r15), %xmm1
callq 0xae10
movsd %xmm0, (%rbx)
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2640c
movsd (%r15), %xmm1
andpd 0xec8e(%rip), %xmm1     # 0x35020
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
jmp 0x2640c
leaq 0x143fe(%rip), %rdi     # 0x3a7a1
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1dba4(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x14239(%rip), %rsi     # 0x3a60d
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x2640c
movsd (%r15), %xmm1
movapd %xmm2, %xmm0
callq 0xb360
movsd %xmm0, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movsd (%rbx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
jmp 0x2640a
nop
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_find.cc
// Function: Interp::find_arc_length(double, double, double, double, double, int, double, double, double)
double Interp::find_arc_length(double x1,        //!< X-coordinate of start point       
                              double y1,        //!< Y-coordinate of start point       
                              double z1,        //!< Z-coordinate of start point       
                              double center_x,  //!< X-coordinate of arc center        
                              double center_y,  //!< Y-coordinate of arc center        
                              int turn, //!< no. of full or partial circles CCW
                              double x2,        //!< X-coordinate of end point         
                              double y2,        //!< Y-coordinate of end point         
                              double z2)        //!< Z-coordinate of end point         
{
  double radius;
  double theta;                 /* amount of turn of arc in radians */

  radius = hypot((center_x - x1), (center_y - y1));
  theta = find_turn(x1, y1, center_x, center_y, turn, x2, y2);
  if (z2 == z1)
    return (radius * fabs(theta));
  else
    return hypot((radius * theta), (z2 - z1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movsd %xmm7, -0x50(%rbp)
movsd %xmm6, -0x48(%rbp)
movsd %xmm5, -0x40(%rbp)
movl %esi, %ebx
movsd %xmm4, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm2, -0x38(%rbp)
movapd %xmm1, %xmm2
movsd %xmm1, -0x18(%rbp)
movapd %xmm0, %xmm1
movsd %xmm0, -0x20(%rbp)
movapd %xmm3, %xmm0
subsd %xmm1, %xmm0
movapd %xmm4, %xmm1
subsd %xmm2, %xmm1
callq 0xa290
movsd %xmm0, -0x10(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x28(%rbp), %xmm3
movl %ebx, %esi
movsd -0x40(%rbp), %xmm4
movsd -0x48(%rbp), %xmm5
callq 0xab90
movsd -0x38(%rbp), %xmm2
movsd -0x50(%rbp), %xmm1
ucomisd %xmm2, %xmm1
jne 0x26e10
jp 0x26e10
andpd 0xe224(%rip), %xmm0     # 0x35020
movsd -0x10(%rbp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movsd -0x10(%rbp), %xmm3
mulsd %xmm0, %xmm3
subsd %xmm2, %xmm1
movapd %xmm3, %xmm0
addq $0x48, %rsp
popq %rbx
popq %rbp
jmp 0xa290
// File: /workspace/github_cpp_makefile_star2_O1/sundale[P]gcode/rs274ngc/interp_find.cc
// Function: Interp::find_turn(double, double, double, double, int, double, double)
double Interp::find_turn(double x1,      //!< X-coordinate of start point       
                        double y1,      //!< Y-coordinate of start point       
                        double center_x,        //!< X-coordinate of arc center        
                        double center_y,        //!< Y-coordinate of arc center        
                        int turn,       //!< no. of full or partial circles CCW
                        double x2,      //!< X-coordinate of end point         
                        double y2)      //!< Y-coordinate of end point         
{
  double alpha;                 /* angle of first radius */
  double beta;                  /* angle of second radius */
  double theta;                 /* amount of turn of arc CCW - negative if CW */

  if (turn == 0)
    return 0.0;
  alpha = atan2((y1 - center_y), (x1 - center_x));
  beta = atan2((y2 - center_y), (x2 - center_x));
  if (turn > 0) {
    if (beta <= alpha)
      beta = (beta + (2 * M_PIl));
    theta = ((beta - alpha) + ((turn - 1) * (2 * M_PIl)));
  } else {                      /* turn < 0 */

    if (alpha <= beta)
      alpha = (alpha + (2 * M_PIl));
    theta = ((beta - alpha) + ((turn + 1) * (2 * M_PIl)));
  }
  return (theta);
}

// Assembly:
testl %esi, %esi
je 0x26eda
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
movapd %xmm0, %xmm6
subsd %xmm3, %xmm1
subsd %xmm2, %xmm6
movapd %xmm1, %xmm0
movapd %xmm6, %xmm1
movsd %xmm5, -0x20(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x18(%rbp)
callq 0xa100
movapd %xmm0, -0x80(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
subsd -0x30(%rbp), %xmm1
callq 0xa100
testl %ebx, %ebx
jle 0x26ede
movsd %xmm0, -0x50(%rbp)
fldt 0x100a7(%rip)           # 0x36f40
fld %st(0)
faddl -0x50(%rbp)
fstpl -0x48(%rbp)
movapd %xmm0, %xmm1
movapd -0x80(%rbp), %xmm3
cmpnlesd %xmm3, %xmm1
movapd %xmm1, %xmm2
andpd %xmm0, %xmm2
movsd -0x48(%rbp), %xmm0
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
subsd %xmm3, %xmm1
movsd %xmm1, -0x40(%rbp)
decl %ebx
movl %ebx, -0xc(%rbp)
fimull -0xc(%rbp)
faddl -0x40(%rbp)
jmp 0x26f28
xorps %xmm0, %xmm0
retq
movapd -0x80(%rbp), %xmm3
movsd %xmm3, -0x68(%rbp)
fldt 0x10052(%rip)           # 0x36f40
fld %st(0)
faddl -0x68(%rbp)
fstpl -0x60(%rbp)
movapd %xmm3, %xmm1
cmpnlesd %xmm0, %xmm1
movapd %xmm1, %xmm2
andpd %xmm3, %xmm2
movsd -0x60(%rbp), %xmm3
andnpd %xmm3, %xmm1
orpd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
incl %ebx
movl %ebx, -0x10(%rbp)
fimull -0x10(%rbp)
faddl -0x58(%rbp)
fstpl -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe0d3(%rip), %xmm3     # 0x35020
andpd %xmm0, %xmm3
ucomisd 0xff5f(%rip), %xmm3     # 0x36eb8
jae 0x26fcc
movq %rsi, %rbx
movq %xmm0, %r14
movsd 0xff4d(%rip), %xmm3     # 0x36eb8
movapd %xmm2, %xmm0
divsd %xmm3, %xmm0
movapd %xmm2, -0x30(%rbp)
movaps %xmm1, -0x40(%rbp)
callq 0xb2f0
movsd 0xff2f(%rip), %xmm3     # 0x36eb8
movapd -0x40(%rbp), %xmm1
andpd 0xe08a(%rip), %xmm1     # 0x35020
mulsd %xmm3, %xmm0
addsd %xmm1, %xmm0
testq %r14, %r14
js 0x2703c
addsd %xmm0, %xmm3
movapd %xmm0, %xmm1
movapd -0x30(%rbp), %xmm2
cmpnltsd %xmm2, %xmm1
andpd %xmm1, %xmm0
andnpd %xmm3, %xmm1
orpd %xmm1, %xmm0
js 0x27043
jmp 0x27064
movl %edx, %r14d
movq %rdi, %r15
leaq 0x113cc(%rip), %rdi     # 0x383a5
movapd %xmm0, -0x30(%rbp)
callq 0xa1f0
movsbl %r14b, %edx
movq %r15, %rdi
movq %rax, %rsi
movapd -0x30(%rbp), %xmm0
movb $0x1, %al
callq 0xa850
movq 0x1cf60(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x13a85(%rip), %rsi     # 0x3aa9d
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x2706a
movapd -0x30(%rbp), %xmm2
jns 0x27064
movsd 0x137e5(%rip), %xmm1    # 0x3a830
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x288fc
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl $0xffffffff, (%rcx)     # imm = 0xFFFFFFFF
addq $0xd6c8, %rsi           # imm = 0xD6C8
xorl %eax, %eax
cmpl %ebx, (%rsi)
jne 0x28887
movl %eax, (%rcx)
incq %rax
addq $0x70, %rsi
cmpq $0x38, %rax
jne 0x28881
xorl %eax, %eax
cmpl $-0x1, (%rcx)
jne 0x288f7
leaq 0x121cd(%rip), %rdi     # 0x3aa6f
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0xa850
movq 0x1b6a3(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x12219(%rip), %rsi     # 0x3aaee
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x0, (%rcx)
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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
movb (%rsi), %r8b
xorl %eax, %eax
testb %r8b, %r8b
je 0x289c2
leaq 0x1(%rsi), %rcx
xorl %edx, %edx
movzbl %r8b, %r9d
testl %eax, %eax
jne 0x28971
xorl %eax, %eax
movb $0x1, %dil
cmpl $0xc, %r9d
jg 0x2894e
cmpl $0x9, %r9d
je 0x289ae
cmpl $0xa, %r9d
jne 0x2895a
cmpb $0x0, (%rcx)
je 0x289ae
jmp 0x28a3c
cmpl $0xd, %r9d
je 0x289ae
cmpl $0x20, %r9d
je 0x289ae
leal -0x41(%r8), %r10d
leal 0x1(%rdx), %r9d
movslq %edx, %rdx
cmpb $0x19, %r10b
ja 0x2899a
orb $0x20, %r8b
jmp 0x289a7
movslq %edx, %rax
incl %edx
movb %r8b, (%rsi,%rax)
cmpb $0x29, %r8b
je 0x28993
cmpl $0x28, %r9d
je 0x28a33
movl $0x1, %eax
xorl %edi, %edi
jmp 0x289ae
xorl %eax, %eax
movb $0x1, %dil
jmp 0x289ae
xorl %eax, %eax
cmpb $0x28, %r8b
setne %dil
sete %al
movb %r8b, (%rsi,%rdx)
movl %r9d, %edx
movb (%rcx), %r8b
incq %rcx
testb %r8b, %r8b
jne 0x28925
movslq %edx, %rax
jmp 0x289c5
movb $0x1, %dil
testb %dil, %dil
je 0x289d2
movb $0x0, (%rsi,%rax)
xorl %eax, %eax
jmp 0x28a2c
leaq 0x121a7(%rip), %rdi     # 0x3ab80
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1b56e(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x1234e(%rip), %rsi     # 0x3ad58
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x12116(%rip), %rdi     # 0x3ab50
jmp 0x289d9
leaq 0x12122(%rip), %rdi     # 0x3ab65
jmp 0x289d9
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
movb %al, (%rsi)
movb %al, 0x10(%rsi)
movb %al, 0x20(%rsi)
movb %al, 0x30(%rsi)
movw %ax, 0x138(%rsi)
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, 0x148(%rsi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x150(%rsi)
movdqu %xmm0, 0x160(%rsi)
movdqu %xmm0, 0x170(%rsi)
movdqu %xmm0, 0x180(%rsi)
movb %al, 0x190(%rsi)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %edx, 0x194(%rsi)
movb %al, 0x198(%rsi)
movb %al, 0x1a8(%rsi)
movb %al, 0x1b8(%rsi)
movl %edx, 0x1c8(%rsi)
movb %al, 0x1cc(%rsi)
movaps 0x11d8d(%rip), %xmm1    # 0x3ab40
movups %xmm1, 0x1d0(%rsi)
movdqu %xmm0, 0x1fc(%rsi)
movdqu %xmm0, 0x1f0(%rsi)
movdqu %xmm0, 0x1e0(%rsi)
movl %eax, 0x20c(%rsi)
movq %rcx, 0x210(%rsi)
movb %al, 0x218(%rsi)
movw %ax, 0x228(%rsi)
movq %rcx, 0x220(%rsi)
movq %rcx, 0x238(%rsi)
movl %edx, 0x240(%rsi)
movb %al, 0x244(%rsi)
movb %al, 0x250(%rsi)
movb %al, 0x260(%rsi)
movb %al, 0x270(%rsi)
movb %al, 0x280(%rsi)
movb %al, 0x290(%rsi)
movl %eax, 0x2b0(%rsi)
movl %eax, 0x2a0(%rsi)
movq $0x0, 0x2c8(%rsi)
movq 0x2d0(%rsi), %rdi
testq %rdi, %rdi
je 0x28e66
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xacf0
movq $0x0, 0x2d0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rsi
callq 0xaab0
leaq 0x17c0(%rbx), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xa3e0
movl %eax, %r13d
testl %eax, %eax
je 0x28f12
movq 0x1b0b1(%rip), %r12     # 0x43f60
movslq 0xd670(%r12), %rax
cmpq $0x30, %rax
jg 0x28f0d
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r12,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11f23(%rip), %rsi     # 0x3adfa
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%r12), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r12,%rcx)
incl %eax
movl %eax, 0xd670(%r12)
movb %dl, 0xc720(%r12,%rcx)
movl %r13d, %r12d
jmp 0x28f15
xorl %r12d, %r12d
testl %r13d, %r13d
jne 0x29037
cmpq $0x0, 0xef70(%rbx)
je 0x28f30
xorl %r12d, %r12d
jmp 0x29037
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xade0
movl %eax, %r13d
testl %eax, %eax
je 0x28fad
movq 0x1b014(%rip), %r12     # 0x43f60
movslq 0xd670(%r12), %rax
cmpq $0x30, %rax
jg 0x28faa
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r12,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11e86(%rip), %rsi     # 0x3adfa
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%r12), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r12,%rcx)
incl %eax
movl %eax, 0xd670(%r12)
movb %dl, 0xc720(%r12,%rcx)
movl %r13d, %r12d
testl %r13d, %r13d
jne 0x29037
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xae00
movl %eax, %ebx
testl %eax, %eax
je 0x2902f
movq 0x1af8f(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2902c
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11e02(%rip), %rsi     # 0x3adfa
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)
movl %ebx, %r12d
testl %ebx, %ebx
je 0x28f28
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb5a0
movsd %xmm0, 0x600(%rbx)
callq 0xa770
movsd %xmm0, 0x608(%rbx)
callq 0xa360
movsd %xmm0, 0x610(%rbx)
callq 0xa280
movsd %xmm0, 0x8(%rbx)
callq 0xa860
movsd %xmm0, 0x20(%rbx)
callq 0xb110
movsd %xmm0, 0x38(%rbx)
callq 0xb640
movsd %xmm0, 0x50(%rbx)
callq 0xab50
movsd %xmm0, 0x68(%rbx)
callq 0xa420
movsd %xmm0, 0x80(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xad90
callq 0xa700
movsd %xmm0, 0xb5e8(%rbx)
callq 0xa190
movsd %xmm0, 0xb5f0(%rbx)
callq 0xadc0
movsd %xmm0, 0xb5f8(%rbx)
callq 0xa6b0
cmpl $0x0, 0x1e6cc(%rbx)
je 0x2913e
movsd 0xdd91(%rip), %xmm1     # 0x36eb8
callq 0xae10
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2913e
addsd 0xdd7a(%rip), %xmm0     # 0x36eb8
movsd %xmm0, 0xb600(%rbx)
callq 0xb490
cmpl $0x0, 0x1e6d0(%rbx)
je 0x29173
movsd 0xdd5c(%rip), %xmm1     # 0x36eb8
callq 0xae10
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x29173
addsd 0xdd45(%rip), %xmm0     # 0x36eb8
movsd %xmm0, 0xb608(%rbx)
callq 0xa2e0
cmpl $0x0, 0x1e6d4(%rbx)
je 0x291a8
movsd 0xdd27(%rip), %xmm1     # 0x36eb8
callq 0xae10
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x291a8
addsd 0xdd10(%rip), %xmm0     # 0x36eb8
movsd %xmm0, 0xb610(%rbx)
callq 0xa900
movsd %xmm0, 0xb618(%rbx)
callq 0xb040
movsd %xmm0, 0xb620(%rbx)
callq 0xafb0
movsd %xmm0, 0xb628(%rbx)
callq 0xb320
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0xb630(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x1, 0x670(%rcx)
jne 0x29252
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
callq 0xb660
mulsd 0x148(%r14), %xmm0
movsd 0xbdd7(%rip), %xmm1     # 0x35000
maxsd %xmm0, %xmm1
movsd %xmm1, -0x18(%rbp)
movapd %xmm1, %xmm0
callq 0xa7a0
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x678(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x293bc
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, (%rcx)
jne 0x29421
leaq 0x12b57(%rip), %rdi     # 0x3bf11
jmp 0x293c3
leaq 0x10e94(%rip), %rdi     # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1ab84(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x11b9c(%rip), %rsi     # 0x3af90
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xaf10
testl %eax, %eax
je 0x2949a
movl %eax, %ebx
movq 0x1ab26(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x29416
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11b2f(%rip), %rsi     # 0x3af90
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)
jmp 0x29416
movb $0x1, (%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%r14)
xorl %ebx, %ebx
jmp 0x29416
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2976d
movq %rcx, %r14
leaq 0x1(%rax), %rcx
movl %ecx, (%rdx)
cmpb $0x5b, 0x1(%rsi,%rax)
jne 0x29776
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0xafc0
testl %eax, %eax
je 0x297db
movl %eax, %ebx
movq 0x1a854(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x297d0
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x118fb(%rip), %rsi     # 0x3b032
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)
jmp 0x297d0
leaq 0x127ba(%rip), %rdi     # 0x3bf2e
jmp 0x2977d
leaq 0x127d9(%rip), %rdi     # 0x3bf56
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1a7ca(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x11884(%rip), %rsi     # 0x3b032
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movsd (%r14), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0xa100
mulsd 0xd6e6(%rip), %xmm0     # 0x36ed8
movsd %xmm0, -0x18(%rbp)
fldt 0xd763(%rip)            # 0x36f60
fdivrl -0x18(%rbp)
fstpl (%r14)
xorl %ebx, %ebx
jmp 0x297d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x29ccd
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x10(%rcx)
jne 0x29d32
leaq 0x122b6(%rip), %rdi     # 0x3bf81
jmp 0x29cd4
leaq 0x10583(%rip), %rdi     # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1a273(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x113cf(%rip), %rsi     # 0x3b0d4
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xaf10
testl %eax, %eax
je 0x29dab
movl %eax, %ebx
movq 0x1a215(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x29d27
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11362(%rip), %rsi     # 0x3b0d4
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)
jmp 0x29d27
movb $0x1, 0x10(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x18(%r14)
xorl %ebx, %ebx
jmp 0x29d27
// File: /workspace/github_cpp_makefile_star2_O1/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 0x29def
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x20(%rcx)
jne 0x29e54
leaq 0x121b1(%rip), %rdi     # 0x3bf9e
jmp 0x29df6
leaq 0x10461(%rip), %rdi     # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1a151(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x112fe(%rip), %rsi     # 0x3b125
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xaf10
testl %eax, %eax
je 0x29ecd
movl %eax, %ebx
movq 0x1a0f3(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x29e49
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11291(%rip), %rsi     # 0x3b125
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)
jmp 0x29e49
movb $0x1, 0x20(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x28(%r14)
xorl %ebx, %ebx
jmp 0x29e49
// File: /workspace/github_cpp_makefile_star2_O1/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:
movslq (%rdx), %rax
cmpb $0x28, (%rsi,%rax)
jne 0x29f07
leaq 0x1(%rax), %rdi
movl %edi, (%rdx)
movb 0x1(%rsi,%rax), %r8b
xorl %eax, %eax
cmpb $0x29, %r8b
jne 0x29f71
xorl %esi, %esi
jmp 0x29f92
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10340(%rip), %rdi     # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1a030(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x1122e(%rip), %rsi     # 0x3b176
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %edi, %edi
movb %r8b, 0x30(%rcx,%rdi)
movslq (%rdx), %r8
leaq 0x1(%r8), %r9
movl %r9d, (%rdx)
incq %rdi
movb 0x1(%rsi,%r8), %r8b
cmpb $0x29, %r8b
jne 0x29f73
movl %edi, %esi
movb $0x0, 0x30(%rcx,%rsi)
incl (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a04e
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x138(%rcx)
jne 0x2a0b3
leaq 0x11f6f(%rip), %rdi     # 0x3bfbb
jmp 0x2a055
leaq 0x10202(%rip), %rdi     # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x19ef2(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x11192(%rip), %rsi     # 0x3b218
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xaf10
testl %eax, %eax
je 0x2a12c
movl %eax, %ebx
movq 0x19e94(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2a0a8
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11125(%rip), %rsi     # 0x3b218
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)
jmp 0x2a0a8
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x130(%r14)
movb $0x1, 0x138(%r14)
xorl %ebx, %ebx
jmp 0x2a0a8
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a17a
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x139(%rcx)
jne 0x2a1df
leaq 0x11e60(%rip), %rdi     # 0x3bfd8
jmp 0x2a181
leaq 0x100d6(%rip), %rdi     # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x19dc6(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x110b7(%rip), %rsi     # 0x3b269
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xaf10
testl %eax, %eax
je 0x2a258
movl %eax, %ebx
movq 0x19d68(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2a1d4
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x1104a(%rip), %rsi     # 0x3b269
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)
jmp 0x2a1d4
movb $0x1, 0x139(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x140(%r14)
xorl %ebx, %ebx
jmp 0x2a1d4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a2ae
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
movsd 0x148(%rcx), %xmm0
ucomisd 0xc5cd(%rip), %xmm0     # 0x36870
jbe 0x2a317
leaq 0x11d49(%rip), %rdi     # 0x3bff5
jmp 0x2a2b5
leaq 0xffa2(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x19c92(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x10fd4(%rip), %rsi     # 0x3b2ba
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0xaf10
testl %eax, %eax
je 0x2a38e
movl %eax, %r14d
movq 0x19c2f(%rip), %rbx     # 0x43f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x2a309
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x10f62(%rip), %rsi     # 0x3b2ba
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%rbx), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
jmp 0x2a309
movsd -0x20(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2a3a9
leaq 0x11c6e(%rip), %rdi     # 0x3c012
jmp 0x2a2b5
movsd %xmm0, 0x148(%r15)
xorl %r14d, %r14d
jmp 0x2a309
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a5d3
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x190(%rcx)
jne 0x2a63c
leaq 0x11aba(%rip), %rdi     # 0x3c08b
jmp 0x2a5da
leaq 0xfc7d(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1996d(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x10d51(%rip), %rsi     # 0x3b35c
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1c(%rbp), %rcx
movq %rbx, %rdi
callq 0xab30
testl %eax, %eax
je 0x2a6b3
movl %eax, %r14d
movq 0x1990a(%rip), %rbx     # 0x43f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x2a62e
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x10cdf(%rip), %rsi     # 0x3b35c
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%rbx), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
jmp 0x2a62e
movl -0x1c(%rbp), %eax
cmpl $-0x2, %eax
jg 0x2a6c7
leaq 0x119e6(%rip), %rdi     # 0x3c0a8
jmp 0x2a5da
movb $0x1, 0x190(%r15)
movl %eax, 0x194(%r15)
xorl %r14d, %r14d
jmp 0x2a62e
// File: /workspace/github_cpp_makefile_star2_O1/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 0xaf10
testl %eax, %eax
je 0x2a76b
movl %eax, %ebx
movq 0x19859(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2a81a
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x10c7b(%rip), %rsi     # 0x3b3ad
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)
jmp 0x2a81a
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0xb2f0
movsd -0x20(%rbp), %xmm2
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
movl %eax, (%r15)
cvtdq2pd %xmm0, %xmm1
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
ucomisd 0x10702(%rip), %xmm0    # 0x3aea0
jbe 0x2a7b4
movapd %xmm2, %xmm0
callq 0xa160
cvttsd2si %xmm0, %eax
movl %eax, (%r15)
xorl %ebx, %ebx
jmp 0x2a81a
xorl %ebx, %ebx
ucomisd 0xc0a2(%rip), %xmm0     # 0x36860
jbe 0x2a81a
leaq 0x1193d(%rip), %rdi     # 0x3c104
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x19780(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x10bb5(%rip), %rsi     # 0x3b3ad
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop