LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_COMMENT(char*)
void enqueue_COMMENT(char *c) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate comment \"%s\"\n", c);
        COMMENT(c);
        return;
    }
    queued_canon q;
    q.type = QCOMMENT;
    q.data.comment.comment = strdup(c);
    if(debug_qc) printf("enqueue comment \"%s\"\n", c);
    qc().push_back(q);
}

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movsd %xmm1, -0x18(%rbp)
movsd %xmm0, -0x10(%rbp)
movl %edi, %ebx
callq 0xa210
movq 0x46ad4(%rip), %rax     # 0x60370
cmpq 0x46ad5(%rip), %rax     # 0x60378
je 0x198fd
movl $0x10, -0x90(%rbp)
movl %ebx, -0x88(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
callq 0xa210
movq 0x46aa3(%rip), %rax     # 0x60378
cmpq 0x46aa4(%rip), %rax     # 0x60380
je 0x19929
leaq -0x90(%rbp), %rsi
movl $0xf, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rax
movq %rax, 0x46a7d(%rip)     # 0x60378
jmp 0x1993f
movslq %ebx, %rax
addl $-0x64, %ebx
movq 0x276ce(%rip), %rcx     # 0x40fd8
movq -0x320(%rcx,%rax,8), %rax
movl %ebx, %edi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
addq $0x88, %rsp
popq %rbx
popq %rbp
jmpq *%rax
leaq 0x46a40(%rip), %rdi     # 0x60370
leaq -0x90(%rbp), %rdx
movq %rax, %rsi
callq 0xa5c0
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_cycles.cc
// Function: Interp::convert_cycle_g86(block_struct*, int, double, double, double, double, double, int)
int Interp::convert_cycle_g86(block_pointer block,
                              CANON_PLANE plane, //!< selected plane                     
                              double x,  //!< x-value where cycle is executed    
                              double y,  //!< y-value where cycle is executed    
                              double clear_z,    //!< z-value of clearance plane         
                              double bottom_z,   //!< value of z at bottom of cycle      
                              double dwell,      //!< dwell time                         
                              CANON_DIRECTION direction) //!< direction spindle turning at outset
{
  CHKS(((direction != CANON_CLOCKWISE) &&
       (direction != CANON_COUNTERCLOCKWISE)),
      NCE_SPINDLE_NOT_TURNING_IN_G86);

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

  return INTERP_OK;
}

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

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

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
leal -0x4(%rbx), %eax
cmpl $-0x3, %eax
ja 0x1af38
movq %rdi, %r14
leaq 0x1c010(%rip), %rdi     # 0x36efd
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x2605a(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x1c004(%rip), %rsi     # 0x36f18
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x1af69
movsd %xmm3, -0x18(%rbp)
callq 0xa180
movsd -0x18(%rbp), %xmm0
callq 0xa040
callq 0xabb0
callq 0xac80
cmpl $0x2, %ebx
jne 0x1af62
callq 0xaba0
jmp 0x1af67
callq 0xaf20
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x23b00
movq %rcx, %r15
movq %rsi, %rbx
leaq 0x13afa(%rip), %rax     # 0x37540
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movsd (%r15), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x23b6c
jp 0x23b6c
leaq 0x13ce1(%rip), %rdi     # 0x37750
jmp 0x23b07
movsd (%rbx), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd (%r15), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0xb2f0
movsd -0x20(%rbp), %xmm1
xorpd %xmm2, %xmm2
movsd -0x28(%rbp), %xmm3
ucomisd %xmm3, %xmm2
movapd %xmm3, %xmm2
jbe 0x23b52
ucomisd %xmm1, %xmm0
jne 0x23ab4
jnp 0x23b52
leaq 0x13caf(%rip), %rdi     # 0x3776a
jmp 0x23b07
movsd (%rbx), %xmm0
mulsd (%r15), %xmm0
jmp 0x23b5b
movsd (%rbx), %xmm0
movsd (%r15), %xmm1
callq 0xae10
movsd %xmm0, (%rbx)
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x23b61
movsd (%r15), %xmm1
andpd 0xe52a(%rip), %xmm1     # 0x32020
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
jmp 0x23b61
leaq 0x13c92(%rip), %rdi     # 0x37799
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1d440(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x13ad7(%rip), %rsi     # 0x37605
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x23b61
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 0x23b5f
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2420c
jp 0x2420c
andpd 0xde28(%rip), %xmm0     # 0x32020
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_O3/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 0x242d6
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 0x242da
movsd %xmm0, -0x50(%rbp)
fldt 0xfcab(%rip)            # 0x33f40
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 0x24324
xorps %xmm0, %xmm0
retq
movapd -0x80(%rbp), %xmm3
movsd %xmm3, -0x68(%rbp)
fldt 0xfc56(%rip)            # 0x33f40
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_O3/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 0xdcd7(%rip), %xmm3     # 0x32020
andpd %xmm0, %xmm3
ucomisd 0xfb63(%rip), %xmm3     # 0x33eb8
jae 0x243c8
movq %rsi, %rbx
movq %xmm0, %r14
movsd 0xfb51(%rip), %xmm3     # 0x33eb8
movapd %xmm2, %xmm0
divsd %xmm3, %xmm0
movapd %xmm2, -0x30(%rbp)
movaps %xmm1, -0x40(%rbp)
callq 0xb2f0
movsd 0xfb33(%rip), %xmm3     # 0x33eb8
movapd -0x40(%rbp), %xmm1
andpd 0xdc8e(%rip), %xmm1     # 0x32020
mulsd %xmm3, %xmm0
addsd %xmm1, %xmm0
testq %r14, %r14
js 0x2442e
addsd %xmm0, %xmm3
movapd %xmm0, %xmm1
movapd -0x30(%rbp), %xmm2
cmpnltsd %xmm2, %xmm1
andpd %xmm1, %xmm0
andnpd %xmm3, %xmm1
orpd %xmm1, %xmm0
js 0x24435
jmp 0x24456
movl %edx, %r14d
movq %rdi, %r15
leaq 0x10fd0(%rip), %rdi     # 0x353a5
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 0x1cb64(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x1368b(%rip), %rsi     # 0x37a95
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
jmp 0x2445c
movapd -0x30(%rbp), %xmm2
jns 0x24456
movsd 0x133eb(%rip), %xmm1    # 0x37828
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_O3/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 0x2594b
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
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpl %ebx, (%rsi)
jne 0x258e0
movl %eax, (%rcx)
movl %eax, %edx
incq %rax
addq $0x70, %rsi
cmpq $0x38, %rax
jne 0x258d8
xorl %eax, %eax
cmpl $-0x1, %edx
jne 0x25946
leaq 0x1216c(%rip), %rdi     # 0x37a67
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0xa850
movq 0x1b64a(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x121c2(%rip), %rsi     # 0x37ae6
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
// File: /workspace/github_cpp_makefile_star2_O3/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
movb (%rsi), %r8b
xorl %ecx, %ecx
testb %r8b, %r8b
je 0x25a13
movq %rdi, %rbx
leaq 0x1(%rsi), %rax
xorl %edx, %edx
movzbl %r8b, %r9d
testl %ecx, %ecx
jne 0x259bd
xorl %ecx, %ecx
movb $0x1, %dil
cmpl $0xc, %r9d
jg 0x2599a
cmpl $0x9, %r9d
je 0x259fc
cmpl $0xa, %r9d
jne 0x259a6
cmpb $0x0, (%rax)
je 0x259fc
jmp 0x25a2d
cmpl $0xd, %r9d
je 0x259fc
cmpl $0x20, %r9d
je 0x259fc
leal -0x41(%r8), %r10d
leal 0x1(%rdx), %r9d
movslq %edx, %rdx
cmpb $0x19, %r10b
ja 0x259e2
orb $0x20, %r8b
jmp 0x259f5
movslq %edx, %rcx
incl %edx
movb %r8b, (%rsi,%rcx)
cmpb $0x29, %r8b
je 0x259db
cmpl $0x28, %r9d
je 0x25a24
movl $0x1, %ecx
xorl %edi, %edi
jmp 0x259fc
xorl %ecx, %ecx
movb $0x1, %dil
jmp 0x259fc
cmpb $0x28, %r8b
jne 0x259f5
movb $0x28, (%rsi,%rdx)
movl $0x1, %ecx
xorl %edi, %edi
jmp 0x259f9
movb %r8b, (%rsi,%rdx)
movl %r9d, %edx
movb (%rax), %r8b
incq %rax
testb %r8b, %r8b
jne 0x25971
testb %dil, %dil
je 0x25a1b
movslq %edx, %rcx
movb $0x0, (%rsi,%rcx)
xorl %eax, %eax
jmp 0x25a7d
leaq 0x1215e(%rip), %rdi     # 0x37b80
jmp 0x25a34
leaq 0x12125(%rip), %rdi     # 0x37b50
jmp 0x25a34
leaq 0x12131(%rip), %rdi     # 0x37b65
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1b513(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x122fd(%rip), %rsi     # 0x37d58
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_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 0xaab0
leaq 0x17c0(%r14), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xa3e0
testl %eax, %eax
je 0x25f4e
movl %eax, %ebx
movq 0x1b078(%rip), %rax     # 0x40f60
movslq 0xd670(%rax), %rcx
cmpq $0x30, %rcx
jg 0x25f49
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11eeb(%rip), %rsi     # 0x37dfa
movl $0x50, %edx
callq 0xa8a0
movq 0x1b040(%rip), %rax     # 0x40f60
movslq 0xd670(%rax), %rcx
leaq (%rcx,%rcx,4), %rdx
shlq $0x4, %rdx
xorl %esi, %esi
movb %sil, 0xc71f(%rax,%rdx)
incl %ecx
movl %ecx, 0xd670(%rax)
movb %sil, 0xc720(%rax,%rdx)
movl %ebx, %r15d
jmp 0x25f5b
xorl %r15d, %r15d
cmpq $0x0, 0xef70(%r14)
je 0x25f6d
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 0xade0
testl %eax, %eax
jne 0x25edf
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xae00
testl %eax, %eax
jne 0x25edf
jmp 0x25f5b
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26090
movsd 0xde3f(%rip), %xmm1     # 0x33eb8
callq 0xae10
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x26090
addsd 0xde28(%rip), %xmm0     # 0x33eb8
movsd %xmm0, 0xb600(%rbx)
callq 0xb490
cmpl $0x0, 0x1e6d0(%rbx)
je 0x260c5
movsd 0xde0a(%rip), %xmm1     # 0x33eb8
callq 0xae10
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x260c5
addsd 0xddf3(%rip), %xmm0     # 0x33eb8
movsd %xmm0, 0xb608(%rbx)
callq 0xa2e0
cmpl $0x0, 0x1e6d4(%rbx)
je 0x260fa
movsd 0xddd5(%rip), %xmm1     # 0x33eb8
callq 0xae10
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x260fa
addsd 0xddbe(%rip), %xmm0     # 0x33eb8
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x261a6
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 0xbe83(%rip), %xmm1     # 0x32000
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_O3/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 0x26310
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, (%rcx)
jne 0x2636b
leaq 0x12c03(%rip), %rdi     # 0x38f11
jmp 0x26317
leaq 0x10f38(%rip), %rdi     # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1ac30(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x11c52(%rip), %rsi     # 0x37f90
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 0x263e4
movl %eax, %ebx
movq 0x1abdc(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x26360
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11be5(%rip), %rsi     # 0x37f90
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 0x26360
movb $0x1, (%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%r14)
xorl %ebx, %ebx
jmp 0x26360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x266a9
movq %rcx, %r14
leaq 0x1(%rax), %rcx
movl %ecx, (%rdx)
cmpb $0x5b, 0x1(%rsi,%rax)
jne 0x266b2
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0xafc0
testl %eax, %eax
je 0x2670d
movl %eax, %ebx
movq 0x1a918(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x26702
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x119bf(%rip), %rsi     # 0x38032
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 0x26702
leaq 0x1287e(%rip), %rdi     # 0x38f2e
jmp 0x266b9
leaq 0x1289d(%rip), %rdi     # 0x38f56
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1a88e(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x11952(%rip), %rsi     # 0x38032
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 0xd7bc(%rip), %xmm0     # 0x33ee0
movsd %xmm0, -0x18(%rbp)
fldt 0xd831(%rip)            # 0x33f60
fdivrl -0x18(%rbp)
fstpl (%r14)
xorl %ebx, %ebx
jmp 0x26702
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x269f9
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x10(%rcx)
jne 0x26a54
leaq 0x1258a(%rip), %rdi     # 0x38f81
jmp 0x26a00
leaq 0x1084f(%rip), %rdi     # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1a547(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x116ad(%rip), %rsi     # 0x380d4
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 0x26acd
movl %eax, %ebx
movq 0x1a4f3(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x26a49
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11640(%rip), %rsi     # 0x380d4
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 0x26a49
movb $0x1, 0x10(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x18(%r14)
xorl %ebx, %ebx
jmp 0x26a49
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26b11
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x20(%rcx)
jne 0x26b6c
leaq 0x1248f(%rip), %rdi     # 0x38f9e
jmp 0x26b18
leaq 0x10737(%rip), %rdi     # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1a42f(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x115e6(%rip), %rsi     # 0x38125
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 0x26be5
movl %eax, %ebx
movq 0x1a3db(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x26b61
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11579(%rip), %rsi     # 0x38125
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 0x26b61
movb $0x1, 0x20(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x28(%r14)
xorl %ebx, %ebx
jmp 0x26b61
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26c1f
leaq 0x1(%rax), %rdi
movl %edi, (%rdx)
movb 0x1(%rsi,%rax), %r8b
xorl %eax, %eax
cmpb $0x29, %r8b
jne 0x26c7f
xorl %esi, %esi
jmp 0x26ca0
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10620(%rip), %rdi     # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1a318(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x11520(%rip), %rsi     # 0x38176
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 0x26c81
movl %edi, %esi
movb $0x0, 0x30(%rcx,%rsi)
incl (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26d52
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x138(%rcx)
jne 0x26dad
leaq 0x1226b(%rip), %rdi     # 0x38fbb
jmp 0x26d59
leaq 0x104f6(%rip), %rdi     # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1a1ee(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x11498(%rip), %rsi     # 0x38218
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 0x26e26
movl %eax, %ebx
movq 0x1a19a(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x26da2
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x1142b(%rip), %rsi     # 0x38218
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 0x26da2
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x130(%r14)
movb $0x1, 0x138(%r14)
xorl %ebx, %ebx
jmp 0x26da2
nop