LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movsd %xmm2, -0x38(%rbp)
movsd %xmm3, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpl $0x2, -0x44(%rbp)
je 0x383d8
cmpl $0x3, -0x44(%rbp)
je 0x383d8
jmp 0x38308
leaq 0x43d07(%rip), %rdi     # 0x7c016
callq 0x10380
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x10df0
movq 0x4ec37(%rip), %rax     # 0x86f60
movl $0x0, 0xd670(%rax)
movq 0x4ec26(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x4ec18(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x43cd4(%rip), %rsi     # 0x7c031
movl $0x50, %edx
callq 0x10840
movq 0x4ebf2(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x4ebe4(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x4ebcc(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x4ebbc(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x4ebaf(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x4eba1(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x38426
jmp 0x383da
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
callq 0x10290
movsd -0x40(%rbp), %xmm0
callq 0x10040
callq 0x11300
callq 0x11420
cmpl $0x2, -0x44(%rbp)
jne 0x3841a
callq 0x112f0
jmp 0x3841f
callq 0x118b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: sundale[P]gcode/rs274ngc/interp_execute.cc
// Function: Interp::execute_binary(double*, int, double*)
int Interp::execute_binary(double *left, int operation, double *right)
{
  if (operation < AND2)
    CHP(execute_binary1(left, operation, right));
  else
    CHP(execute_binary2(left, operation, right));
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x5, -0x1c(%rbp)
jge 0x55030
jmp 0x54f4b
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x11e20
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x55029
jmp 0x54f6e
movq 0x31feb(%rip), %rax     # 0x86f60
cmpl $0x31, 0xd670(%rax)
jge 0x5501e
movq 0x31fd7(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x31fc9(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x278f0(%rip), %rsi     # 0x7c89c
movl $0x50, %edx
callq 0x10840
movq 0x31fa3(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x31f95(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x31f7d(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x31f6d(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x31f60(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x31f52(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x55118
jmp 0x5502b
jmp 0x55111
jmp 0x55032
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x11b50
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x5510d
jmp 0x55055
movq 0x31f04(%rip), %rax     # 0x86f60
cmpl $0x31, 0xd670(%rax)
jge 0x55105
movq 0x31ef0(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x31ee2(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x27809(%rip), %rsi     # 0x7c89c
movl $0x50, %edx
callq 0x10840
movq 0x31ebc(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x31eae(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x31e96(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x31e86(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x31e79(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x31e6b(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x55118
jmp 0x5510f
jmp 0x55111
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movl %esi, -0x3c(%rbp)
movsd %xmm5, -0x48(%rbp)
movsd %xmm6, -0x50(%rbp)
movsd %xmm7, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
subsd -0x20(%rbp), %xmm1
callq 0x10460
movq -0x70(%rbp), %rdi
movsd %xmm0, -0x60(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm3
movl -0x3c(%rbp), %esi
movsd -0x48(%rbp), %xmm4
movsd -0x50(%rbp), %xmm5
callq 0x112d0
movsd %xmm0, -0x68(%rbp)
movsd -0x58(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jne 0x56bba
jp 0x56bba
movsd -0x60(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
movaps 0x20475(%rip), %xmm2    # 0x77020
pand %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x56bd8
movsd -0x60(%rbp), %xmm0
mulsd -0x68(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
subsd -0x28(%rbp), %xmm1
callq 0x10460
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc6ac(%rax)
jne 0x59f58
cmpl $0x0, -0x1c(%rbp)
jne 0x59f58
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x5a08e
movq -0x28(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, -0x2c(%rbp)
cmpl $0x38, -0x2c(%rbp)
jge 0x59fa1
movq -0x18(%rbp), %rax
addq $0xd6c8, %rax           # imm = 0xD6C8
movslq -0x2c(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x59f94
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x59f96
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x59f69
jmp 0x59fa3
movq -0x28(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x5a085
jmp 0x59fb2
leaq 0x22d50(%rip), %rdi     # 0x7cd09
callq 0x10380
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl -0x1c(%rbp), %edx
movb $0x0, %al
callq 0x10df0
movq 0x2cf8a(%rip), %rax     # 0x86f60
movl $0x0, 0xd670(%rax)
movq 0x2cf79(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x2cf6b(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x22d2d(%rip), %rsi     # 0x7cd37
movl $0x50, %edx
callq 0x10840
movq 0x2cf45(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x2cf37(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x2cf1f(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x2cf0f(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x2cf02(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x2cef4(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x5a08e
jmp 0x5a087
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x121e0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x600(%rax)
callq 0x10c50
movq -0x10(%rbp), %rax
movsd %xmm0, 0x608(%rax)
callq 0x10580
movq -0x10(%rbp), %rax
movsd %xmm0, 0x610(%rax)
callq 0x10450
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
callq 0x10e00
movq -0x10(%rbp), %rax
movsd %xmm0, 0x20(%rax)
callq 0x11be0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x38(%rax)
callq 0x122d0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x50(%rax)
callq 0x11270
movq -0x10(%rbp), %rax
movsd %xmm0, 0x68(%rax)
callq 0x10660
movq -0x10(%rbp), %rax
movsd %xmm0, 0x80(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movl %esi, -0x3c(%rbp)
movsd %xmm5, -0x48(%rbp)
movsd %xmm6, -0x50(%rbp)
movsd %xmm7, -0x58(%rbp)
movq %rdx, -0x60(%rbp)
movq %rcx, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rax
cmpl $0x1, 0x670(%rax)
je 0x5bdd3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5be85
movq -0x80(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm3
movsd -0x38(%rbp), %xmm4
movl -0x3c(%rbp), %esi
movsd -0x48(%rbp), %xmm5
movsd -0x50(%rbp), %xmm6
movsd -0x58(%rbp), %xmm7
callq 0x12300
movsd %xmm0, -0x70(%rbp)
movsd -0x70(%rbp), %xmm1
movq -0x60(%rbp), %rax
mulsd 0x148(%rax), %xmm1
movsd 0x1b1db(%rip), %xmm0    # 0x77000
ucomisd %xmm1, %xmm0
jbe 0x5be3d
movsd 0x1b1cd(%rip), %xmm0    # 0x77000
movsd %xmm0, -0x88(%rbp)
jmp 0x5be56
movsd -0x70(%rbp), %xmm0
movq -0x60(%rbp), %rax
mulsd 0x148(%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movsd -0x88(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x78(%rbp), %xmm0
callq 0x10ce0
movsd -0x78(%rbp), %xmm0
movq -0x68(%rbp), %rax
movsd %xmm0, 0x678(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_comment(char*, int*, block_struct*, double*)
int Interp::read_comment(char *line,     //!< string: line of RS274 code being processed   
                        int *counter,   //!< pointer to a counter for position on the line
                        block_pointer block,    //!< pointer to a block being filled from the line
                        double *parameters)     //!< array of system parameters                   
{
  int n;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
je 0x5e02e
jmp 0x5df5e
leaq 0x1e480(%rip), %rdi     # 0x7c3e5
callq 0x10380
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x10df0
movq 0x28fe1(%rip), %rax     # 0x86f60
movl $0x0, 0xd670(%rax)
movq 0x28fd0(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x28fc2(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x1f47d(%rip), %rsi     # 0x7d430
movl $0x50, %edx
callq 0x10840
movq 0x28f9c(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x28f8e(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x28f76(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x28f66(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x28f59(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x28f4b(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x5e0a5
jmp 0x5e030
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x0, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x29, %eax
je 0x5e086
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, 0x30(%rax,%rcx)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5e042
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, 0x30(%rax,%rcx)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::find_named_param(char*, int*, double*)
int Interp::find_named_param(
    char *nameBuf, //!< pointer to name to be read
    int *status,    //!< pointer to return status 1 => found
    double *value   //!< pointer to value of found parameter
    )   
{
    //static char name[] = "find_named_param";
  struct named_parameters_struct *nameList;

  int level;
  int i;

  // now look it up
  if(nameBuf[0] != '_') // local scope
  {
      level = _setup.call_level;
  }
  else
  {
      // call level zero is global scope
      level = 0;
  }

  nameList = &_setup.sub_context[level].named_parameters;

  for(i=0; i<nameList->named_parameter_used_size; i++)
  {
      if(0 == strcmp(nameList->named_parameters[i], nameBuf))
      {
          *value = nameList->named_param_values[i];
          *status = 1;
          return INTERP_OK;
      }
  }

  *value = 0.0;
  *status = 0;

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
je 0x65116
movq 0x21e55(%rip), %rax     # 0x86f60
movl 0xef90(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x6511d
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rcx
movq 0x21e38(%rip), %rax     # 0x86f60
addq $0xef98, %rax           # imm = 0xEF98
imulq $0x128, %rcx, %rcx      # imm = 0x128
addq %rcx, %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x651af
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x11820
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x651a2
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x38(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x651cb
jmp 0x651a4
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x65149
movq -0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::free_named_parameters(int, setup_struct*)
int Interp::free_named_parameters( // ARGUMENTS
    int level,      // level to free
    setup_pointer settings)   // pointer to machine settings
{
    struct named_parameters_struct *nameList;
    int i;
 
    nameList = &settings->sub_context[level].named_parameters;

    for(i=0; i<nameList->named_parameter_used_size; i++)
    {
        free(nameList->named_parameters[i]);
    }
    nameList->named_parameter_used_size = 0;

    return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0xef98, %rax           # imm = 0xEF98
movslq -0xc(%rbp), %rcx
imulq $0x128, %rcx, %rcx      # imm = 0x128
addq %rcx, %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x66268
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x114b0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6623c
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::isreadonly(int)
bool Interp::isreadonly(int index)
{
  int i;
  for (i=0; i< _n_readonly_parameters; i++) {
    if (_readonly_parameters[i] == index) return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq 0x1fd14(%rip), %rcx     # 0x86f70
cmpl (%rcx), %eax
jge 0x67286
movslq -0x18(%rbp), %rcx
movq 0x1fd3d(%rip), %rax     # 0x86fa8
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
jne 0x67279
movb $0x1, -0x1(%rbp)
jmp 0x6728a
jmp 0x6727b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x67252
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_real_number(char*, int*, double*)
int Interp::read_real_number(char *line, //!< string: line of RS274/NGC code being processed
                            int *counter,       //!< pointer to a counter for position on the line 
                            double *double_ptr) //!< pointer to double to be read                  
{
  char *start, *end, save;
  size_t after;

  start = line + *counter;

  after = strspn(start, "0123456789+-.");
  save = start[after];
  start[after] = 0;

  *double_ptr = strtod(start, &end);
  start[after] = save;

  if(end == start) {
    ERS(NCE_BAD_NUMBER_FORMAT);
  }

  *counter = end - line;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x16d91(%rip), %rsi     # 0x7e6ce
callq 0x106d0
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10d00
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movb -0x39(%rbp), %dl
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x67a63
jmp 0x67993
leaq 0x16d42(%rip), %rdi     # 0x7e6dc
callq 0x10380
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x10df0
movq 0x1f5ac(%rip), %rax     # 0x86f60
movl $0x0, 0xd670(%rax)
movq 0x1f59b(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x1f58d(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x16d06(%rip), %rsi     # 0x7e6ee
movl $0x50, %edx
callq 0x10840
movq 0x1f567(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x1f559(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x1f541(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x1f531(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x1f524(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x1f516(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x67a7d
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_write.cc
// Function: Interp::write_settings(setup_struct*)
int Interp::write_settings(setup_pointer settings)       //!< pointer to machine settings
{
  double *vals;

  vals = settings->active_settings;
  vals[0] = settings->sequence_number;  /* 0 sequence number */
  vals[1] = settings->feed_rate;        /* 1 feed rate       */
  vals[2] = settings->speed;    /* 2 spindle speed   */

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xf8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cvtsi2sdl 0xc6b4(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x678(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd 0xc6b8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: sundale[P]gcode/rs274ngc/nurbs_additional_functions.cc
// Function: knot_vector_creator(unsigned int, unsigned int)
std::vector<unsigned int> knot_vector_creator(unsigned int n, unsigned int k) {
    
    unsigned int i;
    std::vector<unsigned int> knot_vector;
    for (i=0; i<=n+k; i++) {
	if (i < k)  
            knot_vector.push_back(0);
        else if (i >= k && i <= n)
            knot_vector.push_back(i - k + 1);
        else
            knot_vector.push_back(n - k + 2);
    }
    return knot_vector;
 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x10270
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
cmpl %ecx, %eax
ja 0x6ea64
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x6ea05
movq -0x48(%rbp), %rdi
movl $0x0, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x104e0
jmp 0x6e9ec
jmp 0x6ea54
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x12390
jmp 0x6ea81
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jb 0x6ea33
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
ja 0x6ea33
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %eax
movl -0x10(%rbp), %ecx
subl %ecx, %eax
incl %eax
movl %eax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x104e0
jmp 0x6ea31
jmp 0x6ea52
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
subl %ecx, %eax
addl $0x2, %eax
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x104e0
jmp 0x6ea50
jmp 0x6ea52
jmp 0x6ea54
jmp 0x6ea56
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6e9bd
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x6ea77
movq -0x48(%rbp), %rdi
callq 0x12390
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x11f50
nopw (%rax,%rax)
// File: sundale[P]gcode/rs274ngc/nurbs_additional_functions.cc
// Function: Rden(double, unsigned int, std::vector<CONTROL_POINT, std::allocator<CONTROL_POINT>>, std::vector<unsigned int, std::allocator<unsigned int>>)
double Rden(double u, unsigned int k,
                  std::vector<CONTROL_POINT> nurbs_control_points,
                  std::vector<unsigned int> knot_vector) {

    unsigned int i;
    double d = 0.0;   
    for (i=0; i<(nurbs_control_points.size()); i++)
        d = d + Nmix(i,k,u,knot_vector)*nurbs_control_points[i].W;
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x68(%rbp), %rdi
movl -0x24(%rbp), %eax
movq %rax, -0x70(%rbp)
callq 0x10bf0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x6f2ee
movq -0x60(%rbp), %rsi
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8c(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x88(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x10400
movl -0x90(%rbp), %edi
movl -0x8c(%rbp), %esi
movsd -0x88(%rbp), %xmm0
movq -0x80(%rbp), %rdx
callq 0x12260
movsd %xmm0, -0x78(%rbp)
jmp 0x6f293
movq -0x68(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x12250
movsd -0x78(%rbp), %xmm0
movsd -0x98(%rbp), %xmm1
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x12390
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6f212
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x12390
jmp 0x6f2fc
movsd -0x30(%rbp), %xmm0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x11f50
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::doLog(char*, ...)
void Interp::doLog(char *fmt, ...)
{
#ifdef LOG_FILE
    struct timeval tv;
    struct tm *tm;
    va_list ap;

    va_start(ap, fmt);

    if(log_file == NULL)
    {
       log_file = fopen(LOG_FILE, "a");
    }

    if(log_file == NULL)
    {
         fprintf(stderr, "(%d)Unable to open log file:%s\n",
                  getpid(), LOG_FILE);
    }

    gettimeofday(&tv, NULL);
    tm = localtime(&tv.tv_sec);

    fprintf(log_file, "%04d%02d%02d-%02d:%02d:%02d.%03ld ",
	    tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
	    tm->tm_hour, tm->tm_min, tm->tm_sec,
	    tv.tv_usec/1000);

    vfprintf(log_file, fmt, ap);
    fflush(log_file);

    va_end(ap);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
testb %al, %al
je 0x70caf
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x50(%rbp), %rcx
leaq -0x100(%rbp), %rdx
movq %rdx, 0x10(%rcx)
leaq 0x10(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movl $0x30, 0x4(%rcx)
movl $0x10, (%rcx)
cmpq $0x0, (%rax)
jne 0x70d2f
movq 0x16251(%rip), %rdi     # 0x86f60
addq $0x1b6b8, %rdi          # imm = 0x1B6B8
leaq 0xcf1a(%rip), %rsi      # 0x7dc37
callq 0x11490
movq %rax, %rcx
movq -0x108(%rbp), %rax
movq %rcx, (%rax)
movq -0x108(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x70d77
movq 0x1627d(%rip), %rax     # 0x86fc0
movq (%rax), %rax
movq %rax, -0x110(%rbp)
callq 0x11950
movq -0x110(%rbp), %rdi
movl %eax, %edx
leaq 0xeb16(%rip), %rsi      # 0x7f878
movq 0x161f7(%rip), %rcx     # 0x86f60
addq $0x1b6b8, %rcx          # imm = 0x1B6B8
movb $0x0, %al
callq 0x11890
xorl %eax, %eax
movl %eax, -0x118(%rbp)
movl %eax, %esi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x11c80
movq -0x120(%rbp), %rdi
callq 0x10bc0
movq %rax, %rcx
movq -0x108(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x76c, %ecx            # imm = 0x76C
movl %ecx, -0x114(%rbp)
movl 0x10(%rax), %ecx
incl %ecx
movl 0xc(%rax), %r8d
movl 0x8(%rax), %r9d
movl (%rax), %r11d
movl 0x4(%rax), %r10d
movq -0x20(%rbp), %rax
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
imulq %rdx
movl -0x118(%rbp), %eax
movq %rdx, %rbx
movl -0x114(%rbp), %edx
movq %rbx, %rsi
shrq $0x3f, %rsi
sarq $0x7, %rbx
addq %rsi, %rbx
movq %rsp, %rsi
movq %rbx, 0x10(%rsi)
movl %r11d, 0x8(%rsi)
movl %r10d, (%rsi)
leaq 0xea80(%rip), %rsi      # 0x7f898
callq 0x11890
movq -0x108(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x11660
movq -0x108(%rbp), %rax
movq (%rax), %rdi
callq 0x11470
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::close()
int Interp::close()
{
  if(_setup.use_lazy_close)
    {
      _setup.lazy_closing = 1;
      return INTERP_OK;
    }

  if (_setup.file_pointer != NULL) {
    fclose(_setup.file_pointer);
    _setup.file_pointer = NULL;
    _setup.percent_flag = OFF;
  }
  reset();

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x160f5(%rip), %rax     # 0x86f60
cmpl $0x0, 0x1d6b8(%rax)
je 0x70e8e
movq 0x160e5(%rip), %rax     # 0x86f60
movl $0x1, 0x1d6bc(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x70ee2
movq 0x160cb(%rip), %rax     # 0x86f60
cmpq $0x0, 0x1680(%rax)
je 0x70ed2
movq 0x160ba(%rip), %rax     # 0x86f60
movq 0x1680(%rax), %rdi
callq 0x11160
movq 0x160a7(%rip), %rax     # 0x86f60
movq $0x0, 0x1680(%rax)
movq 0x16095(%rip), %rax     # 0x86f60
movb $0x0, 0xc678(%rax)
movq -0x18(%rbp), %rdi
callq 0x10a10
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::reset()
int Interp::reset()
{
  _setup.linetext[0] = 0;
  _setup.blocktext[0] = 0;
  _setup.line_length = 0;

  //!!!KL According to the comment,
  //!!!KL this should not be here because this is for
  //!!!KL more than one line.
  //!!!KL But the comment seems wrong -- it is only called at open, close,
  //!!!KL init times which should affect the more global structure.
  //!!!KL (also called by external -- but probably OK)
  //
  // initialization stuff for subroutines and control structures
  _setup.call_level = 0;
  _setup.defining_sub = 0;
  _setup.skipping_o = 0;
  _setup.oword_labels = 0;

  qc_reset();

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1605d(%rip), %rax     # 0x86f60
movb $0x0, 0x1698(%rax)
movq 0x1604f(%rip), %rax     # 0x86f60
movb $0x0, 0x4f8(%rax)
movq 0x16041(%rip), %rax     # 0x86f60
movl $0x0, 0x1694(%rax)
movq 0x16030(%rip), %rax     # 0x86f60
movl $0x0, 0xef90(%rax)
movq 0x1601f(%rip), %rax     # 0x86f60
movl $0x0, 0xef50(%rax)
movq 0x1600e(%rip), %rax     # 0x86f60
movq $0x0, 0xef70(%rax)
movq 0x15ffc(%rip), %rax     # 0x86f60
movl $0x0, 0xfb28(%rax)
callq 0x100e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::exit()
int Interp::exit()
{
  char file_name[LINELEN];

  GET_EXTERNAL_PARAMETER_FILE_NAME(file_name, (LINELEN - 1));
  save_parameters(((file_name[0] ==
                             0) ?
                            RS274NGC_PARAMETER_FILE_NAME_DEFAULT :
                            file_name), _setup.parameters);
  reset();

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0x110(%rbp), %rdi
movl $0xfe, %esi
callq 0x10f10
movsbl -0x110(%rbp), %eax
cmpl $0x0, %eax
jne 0x72127
leaq 0xd937(%rip), %rax      # 0x7fa55
movq %rax, -0x120(%rbp)
jmp 0x72135
leaq -0x110(%rbp), %rax
movq %rax, -0x120(%rbp)
movq -0x118(%rbp), %rdi
movq -0x120(%rbp), %rsi
movq 0x14e16(%rip), %rdx     # 0x86f60
addq $0x17c0, %rdx           # imm = 0x17C0
callq 0x12280
movq -0x118(%rbp), %rdi
callq 0x10a10
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax)
// File: sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::error_text(int, char*, int)
void Interp::error_text(int error_code,        //!< code number of error                
                         char *error_text,      //!< char array to copy error text into  
                         int max_size)  //!< maximum number of characters to copy
{
    if(error_code == INTERP_ERROR)
    {
        strncpy(error_text, savedError, max_size);
        error_text[max_size-1] = 0;

        return;
    }

    error_text[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x5, -0xc(%rbp)
jne 0x76713
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
leaq 0x30435(%rip), %rsi     # 0xa6b30
callq 0x10840
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x7671a
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::line_text(char*, int)
void Interp::line_text(char *line_text,        //!< string: to copy line into           
                        int max_size)   //!< maximum number of characters to copy
{
  int n;
  char *the_text;

  the_text = _setup.linetext;
  for (n = 0; n < (max_size - 1); n++) {
    if (the_text[n] != 0)
      line_text[n] = the_text[n];
    else
      break;
  }
  line_text[n] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0x107aa(%rip), %rax     # 0x86f60
addq $0x1698, %rax           # imm = 0x1698
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x7680c
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x767fd
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x767ff
jmp 0x7680c
jmp 0x76801
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x767c7
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopw (%rax,%rax)
// File: sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::stack_name(int, char*, int)
void Interp::stack_name(int stack_index,       //!< index into stack of function names  
                         char *function_name,   //!< string: to copy function name into
                         int max_size)  //!< maximum number of characters to copy
{
  int n;
  char *the_name;

  if ((stack_index > -1) && (stack_index < STACK_LEN)) {
    the_name = _setup.stack[stack_index];
    for (n = 0; n < (max_size - 1); n++) {
      if (the_name[n] != 0)
        function_name[n] = the_name[n];
      else
        break;
    }
    function_name[n] = 0;
  } else
    function_name[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $-0x1, -0xc(%rbp)
jle 0x768d4
cmpl $0x32, -0xc(%rbp)
jge 0x768d4
movslq -0xc(%rbp), %rcx
movq 0x106f7(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x768c6
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x768b7
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x768b9
jmp 0x768c6
jmp 0x768bb
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x76881
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x768db
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopl (%rax)
// File: sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::default_tool_parameters()
int Interp::default_tool_parameters()
{
  _setup.parameters[5400] =  0; // toolno
  _setup.parameters[5401] =  0; // x offset
  _setup.parameters[5402] =  0; // y offset RESERVED
  _setup.parameters[5403] =  0; // z offset
  _setup.parameters[5404] =  0; // a offset RESERVED
  _setup.parameters[5405] =  0; // b offset RESERVED
  _setup.parameters[5406] =  0; // c offset RESERVED
  _setup.parameters[5407] =  0; // u offset RESERVED
  _setup.parameters[5408] =  0; // v offset RESERVED
  _setup.parameters[5409] =  0; // w offset RESERVED
  _setup.parameters[5410] =  0; // diameter
  _setup.parameters[5411] =  0; // frontangle
  _setup.parameters[5412] =  0; // backangle
  _setup.parameters[5413] =  0; // orientation
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq 0x10401(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc080(%rax)
movq 0x103ef(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc088(%rax)
movq 0x103dd(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc090(%rax)
movq 0x103cb(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc098(%rax)
movq 0x103b9(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0a0(%rax)
movq 0x103a7(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0a8(%rax)
movq 0x10395(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0b0(%rax)
movq 0x10383(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0b8(%rax)
movq 0x10371(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0c0(%rax)
movq 0x1035f(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0c8(%rax)
movq 0x1034d(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0d0(%rax)
movq 0x1033b(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0d8(%rax)
movq 0x10329(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0e0(%rax)
movq 0x10317(%rip), %rax     # 0x86f60
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0e8(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: WbtLm[P]mempool/./mempool.h
// Function: myErrorOperate(char const*, int, int)
int myErrorOperate(char const * const error_str,int error_line,int error_exit=1)
{
    #include<stdio.h>
    printf("%d\n",error_line);
    if(error_exit==1)
        exit(1);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %esi
leaq 0x3c48(%rip), %rdi      # 0x5004
movb $0x0, %al
callq 0x1030
cmpl $0x1, -0x10(%rbp)
jne 0x13d3
movl $0x1, %edi
callq 0x1120
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: WbtLm[P]mempool/./mempool.cpp
// Function: mpnsp::memPool::clean(long long)
int mpnsp::memPool::clean(long long size/*=-1*/)
{
    // cout<<"--------------AutoCleanSize="<<AutoCleanSize<<endl;
    if(size<0)
    {
        size=AutoCleanSize;
    }
    if(size>=maxNumInNode)
    {
        return -1;  //把最大的都删了就不合适了
    }
    int cnt=0;
    for(int i=1;i<=MaxNodeNum;i++)
    {
        if(nodeArr[i] && nodeArr[i]->size<=AutoCleanSize && !nodeArr[i]->deleted)
        {
            nodeArr[i]->deleted=1;
            cnt++;
        }
    }
    nodeNum-=cnt;
    deletedNum+=cnt;
    return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x140b
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %eax
shrl $0x4, %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x1c(%rcx), %ecx
cmpq %rcx, %rax
jl 0x1427
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14c9
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
cmpl $0x7f, -0x20(%rbp)
jg 0x14ab
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x149e
movq -0x28(%rbp), %rcx
movq 0x20(%rcx), %rax
movslq -0x20(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl 0x14(%rax), %eax
movl 0x1c(%rcx), %ecx
shrl $0x4, %ecx
cmpl %ecx, %eax
ja 0x149e
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
testb $0x1, 0x10(%rax)
jne 0x149e
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movb $0x1, 0x10(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x14a0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1435
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %edx
movl 0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: WbtLm[P]mempool/./mempool.cpp
// Function: mpnsp::memPool::freeMemNode(int)
void mpnsp::memPool::freeMemNode(int idx) //删除被标记为deleted的node
{
    if(__builtin_expect(MaxNodeNum<idx,0))
    {
        myErrorOperate("fatal error ! freeMemNode.nodeNumidx.",__LINE__,1);
        return;
    }
    if(__builtin_expect(!nodeArr[idx],0))
    {
        myErrorOperate("freeMemNode.node is already NULL.",__LINE__,0);
        return;
    }
    if(!__builtin_expect(nodeArr[idx]->deleted,1))
    {
        myErrorOperate("freeMemNode.deleted must be true.",__LINE__,0);
        return;
    }
    int fptr=nodeArr[idx]->fptr;
    int nptr=nodeArr[idx]->nptr;
    nodeArr[fptr]->nptr=nptr;
    if(nptr<=MaxNodeNum)
    {
        nodeArr[nptr]->fptr=fptr;
    }
    free(nodeArr[idx]->memory);
    free(nodeArr[idx]->ptrArr);
    free(nodeArr[idx]);
    nodeArr[idx]=NULL;
    deletedNum--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x7f, %eax
cmpl -0xc(%rbp), %eax
jge 0x150c
leaq 0x3b10(%rip), %rdi      # 0x5008
movl $0x1e, %esi
movl $0x1, %edx
callq 0x13a0
jmp 0x1627
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1528
jmp 0x1540
leaq 0x3aff(%rip), %rdi      # 0x502e
movl $0x23, %esi
xorl %edx, %edx
callq 0x13a0
jmp 0x1627
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
testb $0x1, 0x10(%rax)
jne 0x156e
leaq 0x3af3(%rip), %rdi      # 0x5050
movl $0x28, %esi
xorl %edx, %edx
callq 0x13a0
jmp 0x1627
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x30(%rcx), %ecx
movl %ecx, -0x10(%rbp)
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl 0x2c(%rcx), %ecx
movl %ecx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x2c(%rax)
cmpl $0x7f, -0x14(%rbp)
jg 0x15c4
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x1110
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rax), %rdi
callq 0x1110
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1110
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq $0x0, (%rcx,%rdx,8)
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)