LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_unary(char*, int*, double*, double*)
int Interp::read_unary(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                  
                      double *parameters)       //!< array of system parameters                    
{
  int operation;

  CHP(read_operation_unary(line, counter, &operation));
  CHKS((line[*counter] != '['),
      NCE_LEFT_BRACKET_MISSING_AFTER_UNARY_OPERATION_NAME);
  CHP(read_real_expression(line, counter, double_ptr, parameters));

  if (operation == ATAN)
    CHP(read_atan(line, counter, double_ptr, parameters));
  else
    CHP(execute_unary(double_ptr, operation));
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
leaq -0x2c(%rbp), %rcx
callq 0xabd0
testl %eax, %eax
je 0x2a388
movl %eax, %ecx
movq 0x16c3e(%rip), %r15     # 0x40f60
movslq 0xd670(%r15), %rax
cmpq $0x30, %rax
jg 0x2a432
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r15,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe7f8(%rip), %rsi      # 0x38b45
movl $0x50, %edx
movl %ecx, %ebx
callq 0xa8a0
movslq 0xd670(%r15), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
leaq (%r15,%rcx), %r14
addq $0xc720, %r14           # imm = 0xC720
movl %ebx, %ecx
movb $0x0, -0x1(%r14)
incl %eax
movl %eax, 0xd670(%r15)
jmp 0x2a42e
movq %r15, -0x38(%rbp)
movslq (%r13), %rax
cmpb $0x5b, (%r12,%rax)
jne 0x2a3d7
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq -0x38(%rbp), %r8
callq 0xafc0
testl %eax, %eax
jne 0x2a319
movl -0x2c(%rbp), %edx
movq %r14, %rdi
cmpl $0x4, %edx
jne 0x2a443
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq -0x38(%rbp), %r8
callq 0xa590
jmp 0x2a44b
leaq 0xf8d9(%rip), %rdi      # 0x39cb7
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16b69(%rip), %r14     # 0x40f60
leaq 0xc6d0(%r14), %rdi
leaq 0xe740(%rip), %rsi      # 0x38b45
movl $0x50, %edx
callq 0xa8a0
movb $0x0, 0xc71f(%r14)
movl $0x1, 0xd670(%r14)
addq $0xc720, %r14           # imm = 0xC720
movl $0x5, %ecx
movb $0x0, (%r14)
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
callq 0xab60
testl %eax, %eax
jne 0x2a319
xorl %ecx, %ecx
jmp 0x2a432
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_s(char*, int*, block_struct*, double*)
int Interp::read_s(char *line,   //!< string: line of RS274NGC 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] != 's'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->s_number > -1.0), NCE_MULTIPLE_S_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  CHKS((value < 0.0), NCE_NEGATIVE_SPINDLE_SPEED_USED);
  block->s_number = value;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x73, (%rsi,%rax)
jne 0x2a490
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
movsd 0x238(%rcx), %xmm0
ucomisd 0x93eb(%rip), %xmm0     # 0x33870
jbe 0x2a4ef
leaq 0xf72a(%rip), %rdi      # 0x39bb8
jmp 0x2a497
leaq 0xcdb8(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16ab0(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe6d8(%rip), %rsi      # 0x38b96
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0xaf10
testl %eax, %eax
je 0x2a566
movl %eax, %r14d
movq 0x16a57(%rip), %rbx     # 0x40f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x2a4e1
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe666(%rip), %rsi      # 0x38b96
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%rbx), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
jmp 0x2a4e1
movsd -0x20(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2a581
leaq 0xf659(%rip), %rdi      # 0x39bd5
jmp 0x2a497
movsd %xmm0, 0x238(%r15)
xorl %r14d, %r14d
jmp 0x2a4e1
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_t(char*, int*, block_struct*, double*)
int Interp::read_t(char *line,   //!< string: line of RS274/NGC code being processed
                  int *counter, //!< pointer to a counter for position on the line 
                  block_pointer block,  //!< pointer to a block being filled from the line 
                  double *parameters)   //!< array of system parameters                    
{
  int value;

  CHKS((line[*counter] != 't'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->t_number > -1), NCE_MULTIPLE_T_WORDS_ON_ONE_LINE);
  CHP(read_integer_value(line, counter, &value, parameters));
  CHKS((value < 0), NCE_NEGATIVE_TOOL_ID_USED);
  block->t_number = value;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x74, (%rsi,%rax)
jne 0x2a5c1
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
cmpl $0x0, 0x240(%rcx)
js 0x2a620
leaq 0xf632(%rip), %rdi      # 0x39bf1
jmp 0x2a5c8
leaq 0xcc87(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1697f(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe5f8(%rip), %rsi      # 0x38be7
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1c(%rbp), %rcx
movq %rbx, %rdi
callq 0xab30
testl %eax, %eax
je 0x2a697
movl %eax, %r14d
movq 0x16926(%rip), %rbx     # 0x40f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x2a612
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe586(%rip), %rsi      # 0x38be7
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%rbx), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
jmp 0x2a612
movl -0x1c(%rbp), %eax
testl %eax, %eax
js 0x2a6ad
movl %eax, 0x240(%r15)
xorl %r14d, %r14d
jmp 0x2a612
leaq 0xf55a(%rip), %rdi      # 0x39c0e
jmp 0x2a5c8
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_u(char*, int*, block_struct*, double*)
int Interp::read_u(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] != 'u'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->u_flag != OFF), _("Multiple U words on one line"));
  CHP(read_real_value(line, counter, &value, parameters));
  block->u_flag = ON;
  block->u_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 $0x75, (%rsi,%rax)
jne 0x2a9ac
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x244(%rcx)
jne 0x2aa07
leaq 0xf33d(%rip), %rdi      # 0x39ce7
jmp 0x2a9b3
leaq 0xc89c(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16594(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe2af(%rip), %rsi      # 0x38c89
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 0x2aa80
movl %eax, %ebx
movq 0x16540(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2a9fc
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe242(%rip), %rsi      # 0x38c89
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 0x2a9fc
movb $0x1, 0x244(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x248(%r14)
xorl %ebx, %ebx
jmp 0x2a9fc
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_v(char*, int*, block_struct*, double*)
int Interp::read_v(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] != 'v'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->v_flag != OFF), _("Multiple V words on one line"));
  CHP(read_real_value(line, counter, &value, parameters));
  block->v_flag = ON;
  block->v_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 $0x76, (%rsi,%rax)
jne 0x2aace
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x250(%rcx)
jne 0x2ab29
leaq 0xf238(%rip), %rdi      # 0x39d04
jmp 0x2aad5
leaq 0xc77a(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16472(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe1de(%rip), %rsi      # 0x38cda
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 0x2aba2
movl %eax, %ebx
movq 0x1641e(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2ab1e
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe171(%rip), %rsi      # 0x38cda
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 0x2ab1e
movb $0x1, 0x250(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x258(%r14)
xorl %ebx, %ebx
jmp 0x2ab1e
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_w(char*, int*, block_struct*, double*)
int Interp::read_w(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] != 'w'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->w_flag != OFF), _("Multiple W words on one line"));
  CHP(read_real_value(line, counter, &value, parameters));
  block->w_flag = ON;
  block->w_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 $0x77, (%rsi,%rax)
jne 0x2abf0
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x260(%rcx)
jne 0x2ac4b
leaq 0xf133(%rip), %rdi      # 0x39d21
jmp 0x2abf7
leaq 0xc658(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16350(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe10d(%rip), %rsi      # 0x38d2b
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 0x2acc4
movl %eax, %ebx
movq 0x162fc(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2ac40
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe0a0(%rip), %rsi      # 0x38d2b
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 0x2ac40
movb $0x1, 0x260(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x268(%r14)
xorl %ebx, %ebx
jmp 0x2ac40
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_x(char*, int*, block_struct*, double*)
int Interp::read_x(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] != 'x'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->x_flag != OFF), NCE_MULTIPLE_X_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->x_flag = ON;
  if(_setup.lathe_diameter_mode)
  {
    block->x_number = value / 2;
  }else
  {
  block->x_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 $0x78, (%rsi,%rax)
jne 0x2ad12
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x270(%rcx)
jne 0x2ad6d
leaq 0xf02e(%rip), %rdi      # 0x39d3e
jmp 0x2ad19
leaq 0xc536(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1622e(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe03c(%rip), %rsi      # 0x38d7c
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 0x2ade6
movl %eax, %ebx
movq 0x161da(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2ad62
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xdfcf(%rip), %rsi      # 0x38d7c
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 0x2ad62
movb $0x1, 0x270(%r14)
movq 0x1616b(%rip), %rax     # 0x40f60
movsd -0x18(%rbp), %xmm0
cmpb $0x1, 0x1e6d8(%rax)
jne 0x2ae0b
mulsd 0x71fd(%rip), %xmm0     # 0x32008
movsd %xmm0, 0x278(%r14)
xorl %ebx, %ebx
jmp 0x2ad62
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_atsign(char*, int*, block_struct*, double*)
int Interp::read_atsign(char *line, int *counter, block_pointer block,
                        double *parameters) {
    CHKS((line[*counter] != '@'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
    (*counter)++;
    CHP(read_real_value(line, counter, &block->radius, parameters));
    block->radius_flag = ON;
    return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x40, (%rsi,%rax)
jne 0x2aebb
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
addq $0x2a8, %rcx            # imm = 0x2A8
movq %rbx, %rdi
callq 0xaf10
testl %eax, %eax
je 0x2af0d
movl %eax, %ebx
movq 0x16106(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2af1a
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xdf48(%rip), %rsi      # 0x38dcd
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 0x2af1a
leaq 0xc38d(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16085(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xdee4(%rip), %rsi      # 0x38dcd
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
jmp 0x2af1a
movl $0x1, 0x2a0(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
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_carat(char*, int*, block_struct*, double*)
int Interp::read_carat(char *line, int *counter, block_pointer block,
                       double *parameters) {
    CHKS((line[*counter] != '^'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
    (*counter)++;
    CHP(read_real_value(line, counter, &block->theta, parameters));
    block->theta_flag = ON;
    return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x5e, (%rsi,%rax)
jne 0x2afc1
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
addq $0x2b8, %rcx            # imm = 0x2B8
movq %rbx, %rdi
callq 0xaf10
testl %eax, %eax
je 0x2b013
movl %eax, %ebx
movq 0x16000(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2b020
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xde93(%rip), %rsi      # 0x38e1e
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 0x2b020
leaq 0xc287(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x15f7f(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xde2f(%rip), %rsi      # 0x38e1e
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
jmp 0x2b020
movl $0x1, 0x2b0(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
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_y(char*, int*, block_struct*, double*)
int Interp::read_y(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] != 'y'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->y_flag != OFF), NCE_MULTIPLE_Y_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->y_flag = ON;
  block->y_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 $0x79, (%rsi,%rax)
jne 0x2b058
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x280(%rcx)
jne 0x2b0b3
leaq 0xed05(%rip), %rdi      # 0x39d5b
jmp 0x2b05f
leaq 0xc1f0(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x15ee8(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xdde9(%rip), %rsi      # 0x38e6f
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 0x2b12c
movl %eax, %ebx
movq 0x15e94(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2b0a8
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xdd7c(%rip), %rsi      # 0x38e6f
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 0x2b0a8
movb $0x1, 0x280(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x288(%r14)
xorl %ebx, %ebx
jmp 0x2b0a8
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_z(char*, int*, block_struct*, double*)
int Interp::read_z(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] != 'z'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->z_flag != OFF), NCE_MULTIPLE_Z_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->z_flag = ON;
  block->z_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 $0x7a, (%rsi,%rax)
jne 0x2b17a
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x290(%rcx)
jne 0x2b1d5
leaq 0xec00(%rip), %rdi      # 0x39d78
jmp 0x2b181
leaq 0xc0ce(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x15dc6(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xdd18(%rip), %rsi      # 0x38ec0
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 0x2b24e
movl %eax, %ebx
movq 0x15d72(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2b1ca
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xdcab(%rip), %rsi      # 0x38ec0
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 0x2b1ca
movb $0x1, 0x290(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x298(%r14)
xorl %ebx, %ebx
jmp 0x2b1ca
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_o_word.cc
// Function: Interp::control_find_oword(block_struct*, setup_struct*, int*)
int Interp::control_find_oword( /* ARGUMENTS                       */
  block_pointer block,      /* pointer to block */
  setup_pointer settings,   /* pointer to machine settings      */
  int *o_index)             /* the index of o-word (returned) */
{
  static char name[] = "control_find_oword";
  int i;

  logDebug("Entered:%s", name);
  for(i=0; i<settings->oword_labels; i++)
    {
      if(0 == strcmp(settings->oword_offset[i].o_word_name, block->o_name))
	{
	  *o_index = i;
	  logDebug("Found oword[%d]: |%s|", i, block->o_name);
	  return INTERP_OK;
	}
    }
  logDebug("Unknown oword name: |%s|", block->o_name);
  ERS(NCE_UNKNOWN_OWORD_NUMBER);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x15601(%rip), %rax     # 0x40f60
cmpl $0x0, 0x1b6b4(%rax)
jle 0x2b99a
callq 0xaf80
leaq 0x162ac(%rip), %rcx     # 0x41c20
movq %rcx, (%rsp)
leaq 0xe6bc(%rip), %rsi      # 0x3a03b
leaq 0xe64d(%rip), %r8       # 0x39fd3
movq %rbx, %rdi
xorl %edx, %edx
movl %eax, %ecx
movl $0x8d, %r9d
xorl %eax, %eax
callq 0xb470
movq %rbx, -0x30(%rbp)
movslq 0xfb28(%r12), %rbx
testq %rbx, %rbx
jle 0x2b9dc
movq 0x2d0(%r14), %r13
addq $0xfb38, %r12           # imm = 0xFB38
xorl %r15d, %r15d
movq (%r12), %rdi
movq %r13, %rsi
callq 0xaeb0
testl %eax, %eax
je 0x2ba71
incq %r15
addq $0x30, %r12
cmpq %r15, %rbx
jne 0x2b9bc
movq 0x1557d(%rip), %r15     # 0x40f60
cmpl $0x0, 0x1b6b4(%r15)
movq -0x30(%rbp), %rbx
jle 0x2ba23
callq 0xaf80
movq 0x2d0(%r14), %rcx
movq %rcx, (%rsp)
leaq 0xe67a(%rip), %rsi      # 0x3a082
leaq 0xe5c4(%rip), %r8       # 0x39fd3
movq %rbx, %rdi
xorl %edx, %edx
movl %eax, %ecx
movl $0x97, %r9d
xorl %eax, %eax
callq 0xb470
leaq 0xe684(%rip), %rdi      # 0x3a0ae
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
leaq 0xc6d0(%r15), %rdi
leaq 0xe454(%rip), %rsi      # 0x39e9e
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%r15)
movl $0x1, 0xd670(%r15)
movl $0x5, %r14d
jmp 0x2bac8
movq -0x38(%rbp), %rax
movl %r15d, (%rax)
movq 0x154e1(%rip), %rax     # 0x40f60
cmpl $0x0, 0x1b6b4(%rax)
jle 0x2bac5
callq 0xaf80
movq 0x2d0(%r14), %rcx
movq %rcx, 0x8(%rsp)
movl %r15d, (%rsp)
leaq 0xe5b5(%rip), %rsi      # 0x3a059
leaq 0xe528(%rip), %r8       # 0x39fd3
xorl %r14d, %r14d
movq -0x30(%rbp), %rdi
xorl %edx, %edx
movl %eax, %ecx
movl $0x93, %r9d
xorl %eax, %eax
callq 0xb470
jmp 0x2bac8
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leal (%r14,%rsi), %r13d
movq %rsi, -0x48(%rbp)
movl %esi, %r12d
subl %edx, %r12d
addl $0x2, %r12d
movl $0x1, %eax
subl %edx, %eax
movq %rax, -0x40(%rbp)
xorl %r15d, %r15d
cmpl %r14d, %r15d
jae 0x2d63f
movl $0x0, -0x34(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2d678
movl $0x0, (%rsi)
jmp 0x2d66e
cmpl -0x48(%rbp), %r15d
jbe 0x2d658
movl %r12d, -0x2c(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2d686
movl %r12d, (%rsi)
jmp 0x2d66e
movq -0x40(%rbp), %rax
addl %r15d, %eax
movl %eax, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2d694
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2d6a0
movq %rbx, %rdi
leaq -0x34(%rbp), %rdx
callq 0xa370
jmp 0x2d6a0
movq %rbx, %rdi
leaq -0x2c(%rbp), %rdx
callq 0xa370
jmp 0x2d6a0
movq %rbx, %rdi
leaq -0x30(%rbp), %rdx
callq 0xa370
incl %r15d
cmpl %r13d, %r15d
jbe 0x2d621
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d6c2
jmp 0x2d6c2
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2d6d9
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0xaae0
movq %r14, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, -0x30(%rbp)
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x2dacd
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
leaq -0x58(%rbp), %r13
movsd %xmm0, -0x40(%rbp)
movq %r13, %rdi
movq %rbx, %rsi
callq 0xa240
movl %r12d, %edi
movl %r15d, %esi
movsd -0x30(%rbp), %xmm0
movq %r13, %rdx
callq 0xb5f0
movapd %xmm0, %xmm1
movq (%r14), %rax
leaq (%r12,%r12,2), %rcx
mulsd 0x10(%rax,%rcx,8), %xmm1
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x2daa1
movq -0x48(%rbp), %rsi
subq %rdi, %rsi
movsd %xmm1, -0x38(%rbp)
callq 0xaae0
movsd -0x38(%rbp), %xmm1
movq (%r14), %rax
movsd -0x40(%rbp), %xmm0
addsd %xmm1, %xmm0
incl %r12d
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq %r12, %rcx
ja 0x2da4b
jmp 0x2dad1
xorpd %xmm0, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x2daf8
movq -0x48(%rbp), %rsi
subq %rdi, %rsi
callq 0xaae0
movq %rbx, %rdi
callq 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x100(%rbp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2e2be
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 %rsi, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rdi)
jne 0x2e302
movl $0x1b6b8, %edi          # imm = 0x1B6B8
addq 0x12c76(%rip), %rdi     # 0x40f60
leaq 0xb09d(%rip), %rsi      # 0x3938e
callq 0xace0
movq %rax, (%rbx)
testq %rax, %rax
je 0x2e3a0
leaq -0x50(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xb180
movq %r15, %rdi
callq 0xa730
movq (%rbx), %rdi
movl $0x76c, %r10d           # imm = 0x76C
addl 0x14(%rax), %r10d
movl 0x10(%rax), %ecx
incl %ecx
movl 0xc(%rax), %r8d
movl 0x8(%rax), %r9d
movl (%rax), %r12d
movl 0x4(%rax), %r13d
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%r15)
movq %rdx, %r11
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %r11
addq %rax, %r11
subq $0x8, %rsp
leaq 0xc68d(%rip), %rsi      # 0x3a9f0
movl %r10d, %edx
xorl %eax, %eax
pushq %r11
pushq %r12
pushq %r13
callq 0xaf00
addq $0x20, %rsp
movq (%rbx), %rdi
leaq -0x40(%rbp), %rdx
movq %r14, %rsi
callq 0xadd0
movq (%rbx), %rdi
callq 0xacd0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb7ba
jmp 0x2e302
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq 0x12ba9(%rip), %rbx     # 0x40f60
cmpl $0x0, 0x1d6b8(%rbx)
je 0x2e3cc
movl $0x1, 0x1d6bc(%rbx)
jmp 0x2e425
movq 0x1680(%rbx), %rdi
testq %rdi, %rdi
je 0x2e3ef
callq 0xaa80
movq $0x0, 0x1680(%rbx)
movb $0x0, 0xc678(%rbx)
xorl %eax, %eax
movb %al, 0x1698(%rbx)
movb %al, 0x4f8(%rbx)
movl %eax, 0x1694(%rbx)
movl %eax, 0xef90(%rbx)
movl %eax, 0xef50(%rbx)
movq $0x0, 0xef70(%rbx)
movl %eax, 0xfb28(%rbx)
callq 0xa090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
leaq -0x120(%rbp), %r14
movq %r14, %rdi
movl $0xfe, %esi
callq 0xa8e0
xorl %r15d, %r15d
cmpb %r15b, (%r14)
leaq 0xbee9(%rip), %rsi      # 0x3ab8b
cmovneq %r14, %rsi
movq 0x122b3(%rip), %r14     # 0x40f60
leaq 0x17c0(%r14), %rdx
movq %rbx, %rdi
callq 0xb610
movb %r15b, 0x1698(%r14)
movb %r15b, 0x4f8(%r14)
movl %r15d, 0x1694(%r14)
movl %r15d, 0xef90(%r14)
movl %r15d, 0xef50(%r14)
movq $0x0, 0xef70(%r14)
movl %r15d, 0xfb28(%r14)
callq 0xa090
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::init_tool_parameters()
int Interp::init_tool_parameters()
{
  if (_setup.random_toolchanger) {
     // random_toolchanger: tool at startup expected
    _setup.parameters[5400] = _setup.tool_table[0].toolno;
    _setup.parameters[5401] = _setup.tool_table[0].offset.tran.x;
    _setup.parameters[5402] = _setup.tool_table[0].offset.tran.y;
    _setup.parameters[5403] = _setup.tool_table[0].offset.tran.z;
    _setup.parameters[5404] = _setup.tool_table[0].offset.a;
    _setup.parameters[5405] = _setup.tool_table[0].offset.b;
    _setup.parameters[5406] = _setup.tool_table[0].offset.c;
    _setup.parameters[5407] = _setup.tool_table[0].offset.u;
    _setup.parameters[5408] = _setup.tool_table[0].offset.v;
    _setup.parameters[5409] = _setup.tool_table[0].offset.w;
    _setup.parameters[5410] = _setup.tool_table[0].diameter;
    _setup.parameters[5411] = _setup.tool_table[0].frontangle;
    _setup.parameters[5412] = _setup.tool_table[0].backangle;
    _setup.parameters[5413] = _setup.tool_table[0].orientation;
  } else {
    // non random_toolchanger: no tool at startup, one-time init
    if (_setup.tool_table[0].toolno == -1) {
      default_tool_parameters();
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10835(%rip), %rax     # 0x40f60
cmpl $0x0, 0xc6ac(%rax)
movl 0xd6c8(%rax), %ecx
je 0x307c5
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0xc080(%rax)
movsd 0xd6d0(%rax), %xmm0
movsd %xmm0, 0xc088(%rax)
movups 0xd6d8(%rax), %xmm0
movups %xmm0, 0xc090(%rax)
movups 0xd6e8(%rax), %xmm0
movups %xmm0, 0xc0a0(%rax)
movups 0xd6f8(%rax), %xmm0
movups %xmm0, 0xc0b0(%rax)
movups 0xd708(%rax), %xmm0
movups %xmm0, 0xc0c0(%rax)
movups 0xd718(%rax), %xmm0
movups %xmm0, 0xc0d0(%rax)
movsd 0xd728(%rax), %xmm0
movsd %xmm0, 0xc0e0(%rax)
xorps %xmm0, %xmm0
cvtsi2sdl 0xd730(%rax), %xmm0
movsd %xmm0, 0xc0e8(%rax)
jmp 0x30806
cmpl $-0x1, %ecx
jne 0x30806
xorpd %xmm0, %xmm0
movupd %xmm0, 0xc0e0(%rax)
movupd %xmm0, 0xc0d0(%rax)
movupd %xmm0, 0xc0c0(%rax)
movupd %xmm0, 0xc0b0(%rax)
movupd %xmm0, 0xc0a0(%rax)
movupd %xmm0, 0xc090(%rax)
movupd %xmm0, 0xc080(%rax)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::load_tool_table()
int Interp::load_tool_table()
{
  int n;

  CHKS((_setup.pockets_max > CANON_POCKETS_MAX), NCE_POCKET_MAX_TOO_LARGE);
  for (n = 0; n < _setup.pockets_max; n++) {
    _setup.tool_table[n] = GET_EXTERNAL_TOOL_TABLE(n);
  }
  for (; n < CANON_POCKETS_MAX; n++) {
    _setup.tool_table[n].toolno = -1;
    ZERO_EMC_POSE(_setup.tool_table[n].offset);
    _setup.tool_table[n].diameter = 0;
    _setup.tool_table[n].orientation = 0;
    _setup.tool_table[n].frontangle = 0;
    _setup.tool_table[n].backangle = 0;
  }
  set_tool_parameters();
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq 0x10740(%rip), %r12     # 0x40f60
movl 0xd6c0(%r12), %eax
cmpl $0x38, %eax
jle 0x3087d
leaq 0xa5e6(%rip), %rdi      # 0x3ae1a
callq 0xa1f0
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
leaq 0xc6d0(%r12), %rdi
leaq 0xa97f(%rip), %rsi      # 0x3b1d1
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%r12)
movl $0x1, 0xd670(%r12)
movl $0x5, %eax
jmp 0x30939
testl %eax, %eax
jle 0x308cf
movl $0xd6c8, %r14d          # imm = 0xD6C8
addq 0x106d2(%rip), %r14     # 0x40f60
xorl %ebx, %ebx
leaq -0x90(%rbp), %r15
movq %r15, %rdi
movl %ebx, %esi
callq 0xb390
movl $0xe, %ecx
movq %r14, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
incq %rbx
movslq 0xd6c0(%r12), %rax
addq $0x70, %r14
cmpq %rax, %rbx
jl 0x30897
leaq -0x1(%rbx), %rax
cmpq $0x36, %rax
jbe 0x308d1
jmp 0x30932
xorl %ebx, %ebx
imulq $0x70, %rbx, %rax
xorps %xmm0, %xmm0
movl $0xffffffff, 0xd6c8(%r12,%rax) # imm = 0xFFFFFFFF
movups %xmm0, 0xd6d0(%r12,%rax)
movups %xmm0, 0xd6e0(%r12,%rax)
movups %xmm0, 0xd6f0(%r12,%rax)
movups %xmm0, 0xd700(%r12,%rax)
movups %xmm0, 0xd710(%r12,%rax)
movups %xmm0, 0xd720(%r12,%rax)
movl $0x0, 0xd730(%r12,%rax)
addq $0x70, %rax
cmpq $0x1880, %rax           # imm = 0x1880
jne 0x308d8
callq 0xaf90
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::set_tool_parameters()
int Interp::set_tool_parameters()
{
  // invoke to set tool parameters for current tool (pocket==0)
  // when a tool is absent, set default (zero offset) tool parameters

  if ((! _setup.random_toolchanger) && (_setup.tool_table[0].toolno <= 0)) {
    default_tool_parameters();
    return 0;
  }
  _setup.parameters[5400] = _setup.tool_table[0].toolno;
  _setup.parameters[5401] = _setup.tool_table[0].offset.tran.x;
  _setup.parameters[5402] = _setup.tool_table[0].offset.tran.y;
  _setup.parameters[5403] = _setup.tool_table[0].offset.tran.z;
  _setup.parameters[5404] = _setup.tool_table[0].offset.a;
  _setup.parameters[5405] = _setup.tool_table[0].offset.b;
  _setup.parameters[5406] = _setup.tool_table[0].offset.c;
  _setup.parameters[5407] = _setup.tool_table[0].offset.u;
  _setup.parameters[5408] = _setup.tool_table[0].offset.v;
  _setup.parameters[5409] = _setup.tool_table[0].offset.w;
  _setup.parameters[5410] = _setup.tool_table[0].diameter;
  _setup.parameters[5411] = _setup.tool_table[0].frontangle;
  _setup.parameters[5412] = _setup.tool_table[0].backangle;
  _setup.parameters[5413] = _setup.tool_table[0].orientation;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10585(%rip), %rax     # 0x40f60
cmpl $0x0, 0xc6ac(%rax)
sete %dl
movl 0xd6c8(%rax), %ecx
testl %ecx, %ecx
setle %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x30a3b
xorpd %xmm0, %xmm0
movupd %xmm0, 0xc0e0(%rax)
movupd %xmm0, 0xc0d0(%rax)
movupd %xmm0, 0xc0c0(%rax)
movupd %xmm0, 0xc0b0(%rax)
movupd %xmm0, 0xc0a0(%rax)
movupd %xmm0, 0xc090(%rax)
movupd %xmm0, 0xc080(%rax)
jmp 0x30ac0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0xc080(%rax)
movsd 0xd6d0(%rax), %xmm0
movsd %xmm0, 0xc088(%rax)
movups 0xd6d8(%rax), %xmm0
movups %xmm0, 0xc090(%rax)
movups 0xd6e8(%rax), %xmm0
movups %xmm0, 0xc0a0(%rax)
movups 0xd6f8(%rax), %xmm0
movups %xmm0, 0xc0b0(%rax)
movups 0xd708(%rax), %xmm0
movups %xmm0, 0xc0c0(%rax)
movups 0xd718(%rax), %xmm0
movups %xmm0, 0xc0d0(%rax)
movsd 0xd728(%rax), %xmm0
movsd %xmm0, 0xc0e0(%rax)
xorps %xmm0, %xmm0
cvtsi2sdl 0xd730(%rax), %xmm0
movsd %xmm0, 0xc0e8(%rax)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x2, %edx
jl 0x30e5b
pushq %rbp
movq %rsp, %rbp
decl %edx
movl %edx, %ecx
xorl %eax, %eax
movq 0x10120(%rip), %rdi     # 0x40f60
movb 0x1698(%rdi,%rax), %r8b
testb %r8b, %r8b
je 0x30e5f
movb %r8b, (%rsi,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x30e40
jmp 0x30e61
xorl %eax, %eax
jmp 0x30e64
movl %eax, %edx
movl %edx, %eax
popq %rbp
movb $0x0, (%rsi,%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x31, %esi
ja 0x30ecb
cmpl $0x2, %ecx
jl 0x30ec0
movl %esi, %esi
decl %ecx
movl %ecx, %eax
leaq (%rsi,%rsi,4), %rsi
shlq $0x4, %rsi
movq 0x100c3(%rip), %rdi     # 0x40f60
addq %rsi, %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
xorl %esi, %esi
movb (%rdi,%rsi), %r8b
testb %r8b, %r8b
je 0x30ec4
movb %r8b, (%rdx,%rsi)
incq %rsi
cmpq %rsi, %rax
jne 0x30ea9
jmp 0x30ec6
xorl %eax, %eax
jmp 0x30ec8
movl %esi, %ecx
movl %ecx, %eax
addq %rax, %rdx
pushq %rbp
movq %rsp, %rbp
movb $0x0, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/rs274ngc_pre.cc
// Function: Interp::ini_load(char const*)
int Interp::ini_load(const char *filename)
{
    IniFile inifile;
    const char *inistring;

    // open it
    if (inifile.Open(filename) == false) {
        logDebug("Unable to open inifile:%s:", filename);
	return -1;
    }

    logDebug("Opened inifile:%s:", filename);


    if (NULL != (inistring = inifile.Find("PARAMETER_FILE", "RS274NGC"))) {
	// found it
	strncpy(_parameter_file_name, inistring, LINELEN);
        logDebug("found PARAMETER_FILE:%s:", _parameter_file_name);
    } else {
	// not found, leave RS274NGC_PARAMETER_FILE alone
        logDebug("did not find PARAMETER_FILE");
    }

    // close it
    inifile.Close();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x90(%rbp), %r14
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb380
movq %r14, %rdi
movq %r15, %rsi
callq 0xa650
movq 0x1004f(%rip), %r12     # 0x40f60
movl 0x1b6b4(%r12), %ecx
testb %al, %al
je 0x30fc4
testl %ecx, %ecx
jle 0x30f50
callq 0xaf80
movq %r15, (%rsp)
leaq 0xa077(%rip), %rsi      # 0x3afac
leaq 0x9af6(%rip), %r8       # 0x3aa32
movq %rbx, %rdi
xorl %edx, %edx
movl %eax, %ecx
movl $0x5cf, %r9d            # imm = 0x5CF
xorl %eax, %eax
callq 0xb470
leaq 0xa07b(%rip), %rsi      # 0x3afd2
leaq 0x9d24(%rip), %rdx      # 0x3ac82
leaq -0x90(%rbp), %rdi
movl $0x1, %ecx
callq 0xa630
testq %rax, %rax
je 0x30ffb
movq 0x10019(%rip), %r14     # 0x40f98
movl $0xff, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0xa530
cmpl $0x0, 0x1b6b4(%r12)
jle 0x3102d
callq 0xaf80
movq %r14, (%rsp)
leaq 0xa033(%rip), %rsi      # 0x3afe1
leaq 0x9a7d(%rip), %r8       # 0x3aa32
movq %rbx, %rdi
xorl %edx, %edx
movl %eax, %ecx
movl $0x5d5, %r9d            # imm = 0x5D5
jmp 0x31026
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %ecx, %ecx
jle 0x3103c
callq 0xaf80
movq %r15, (%rsp)
leaq 0x9beb(%rip), %rsi      # 0x3abc9
leaq 0x9a4d(%rip), %r8       # 0x3aa32
movq %rbx, %rdi
xorl %edx, %edx
movl %eax, %ecx
movl $0x5cb, %r9d            # imm = 0x5CB
xorl %eax, %eax
callq 0xb470
jmp 0x3103c
cmpl $0x0, 0x1b6b4(%r12)
jle 0x3102d
callq 0xaf80
leaq 0x9ffb(%rip), %rsi      # 0x3b00d
leaq 0x9a19(%rip), %r8       # 0x3aa32
movq %rbx, %rdi
xorl %edx, %edx
movl %eax, %ecx
movl $0x5d8, %r9d            # imm = 0x5D8
xorl %eax, %eax
callq 0xb470
xorl %r14d, %r14d
leaq -0x90(%rbp), %rdi
callq 0xa4b0
leaq -0x90(%rbp), %rdi
callq 0xa4b0
movl %r14d, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31074
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0xa4b0
movq %rbx, %rdi
callq 0xb3b0
movq %rax, %rdi
callq 0x310bf
// File: /workspace/github_cpp_makefile_star2_O3/WbtLm[P]mempool/./mempool.cpp
// Function: mpnsp::memPool::allocMemFromPool() (.cold.1)
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), %rax
movl 0x2c(%rax), %eax
cmpl $0x7f, %eax
jg 0x1234
movslq %eax, %rcx
movq (%rdi,%rcx,8), %rcx
testq %rcx, %rcx
je 0x1230
cmpb $0x1, 0x10(%rcx)
je 0x1224
movl 0x18(%rcx), %r8d
cmpl 0x14(%rcx), %r8d
jb 0x1238
movl 0x2c(%rcx), %eax
cmpl $0x80, %eax
jl 0x1208
jmp 0x1234
incl %eax
jmp 0x1227
movb $0x1, %al
popq %rbp
retq
movl 0x28(%rcx), %edi
movq 0x8(%rcx), %r9
addq %rdi, %r9
movq %r9, (%rdx)
incl %r8d
movl %r8d, 0x18(%rcx)
movq 0x20(%rcx), %rdx
movl (%rdx,%rdi,4), %edx
movl %edx, 0x28(%rcx)
shll $0x15, %eax
cltq
orq %rdx, %rax
movq %rax, (%rsi)
xorl %eax, %eax
jmp 0x1236
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %edx, %ebx
leaq 0x1bd9(%rip), %rdi      # 0x3004
xorl %eax, %eax
callq 0x1040
cmpl $0x1, %ebx
je 0x1440
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, %edi
callq 0x1130