LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_e(char*, int*, block_struct*, double*)
int Interp::read_e(char *line,   //!< string: line of RS274/NGC code being processed
                  int *counter, //!< pointer to a counter for position on the line 
                  block_pointer block,  //!< pointer to a block being filled from the line 
                  double *parameters)   //!< array of system parameters                    
{
  double value;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x65, (%rsi,%rax)
jne 0x26e74
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x139(%rcx)
jne 0x26ecf
leaq 0x12166(%rip), %rdi     # 0x38fd8
jmp 0x26e7b
leaq 0x103d4(%rip), %rdi     # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1a0cc(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x113c7(%rip), %rsi     # 0x38269
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 0x26f48
movl %eax, %ebx
movq 0x1a078(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x26ec4
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x1135a(%rip), %rsi     # 0x38269
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 0x26ec4
movb $0x1, 0x139(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x140(%r14)
xorl %ebx, %ebx
jmp 0x26ec4
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_f(char*, int*, block_struct*, double*)
int Interp::read_f(char *line,   //!< string: line of RS274 code being processed   
                  int *counter, //!< pointer to a counter for position on the line
                  block_pointer block,  //!< pointer to a block being filled from the line
                  double *parameters)   //!< array of system parameters                   
{
  double value;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x66, (%rsi,%rax)
jne 0x26f9e
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
movsd 0x148(%rcx), %xmm0
ucomisd 0xc8dd(%rip), %xmm0     # 0x33870
jbe 0x26ffd
leaq 0x12059(%rip), %rdi     # 0x38ff5
jmp 0x26fa5
leaq 0x102aa(%rip), %rdi     # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x19fa2(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x112ee(%rip), %rsi     # 0x382ba
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 0x27074
movl %eax, %r14d
movq 0x19f49(%rip), %rbx     # 0x40f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x26fef
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x1127c(%rip), %rsi     # 0x382ba
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 0x26fef
movsd -0x20(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2708f
leaq 0x11f88(%rip), %rdi     # 0x39012
jmp 0x26fa5
movsd %xmm0, 0x148(%r15)
xorl %r14d, %r14d
jmp 0x26fef
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_h(char*, int*, block_struct*, double*)
int Interp::read_h(char *line,   //!< string: line of RS274/NGC code being processed
                  int *counter, //!< pointer to a counter for position on the line 
                  block_pointer block,  //!< pointer to a block being filled from the line 
                  double *parameters)   //!< array of system parameters                    
{
  int value;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x68, (%rsi,%rax)
jne 0x272ab
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x190(%rcx)
jne 0x2730a
leaq 0x11de2(%rip), %rdi     # 0x3908b
jmp 0x272b2
leaq 0xff9d(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x19c95(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x11083(%rip), %rsi     # 0x3835c
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 0x27381
movl %eax, %r14d
movq 0x19c3c(%rip), %rbx     # 0x40f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x272fc
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x11011(%rip), %rsi     # 0x3835c
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 0x272fc
movl -0x1c(%rbp), %eax
cmpl $-0x2, %eax
jg 0x27395
leaq 0x11d18(%rip), %rdi     # 0x390a8
jmp 0x272b2
movb $0x1, 0x190(%r15)
movl %eax, 0x194(%r15)
xorl %r14d, %r14d
jmp 0x272fc
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_integer_value(char*, int*, int*, double*)
int Interp::read_integer_value(char *line,       //!< string: line of RS274/NGC code being processed
                              int *counter,     //!< pointer to a counter for position on the line 
                              int *integer_ptr, //!< pointer to the value being read               
                              double *parameters)       //!< array of system parameters                    
{
  double float_value;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdi, %r14
leaq -0x28(%rbp), %rcx
callq 0xaf10
testl %eax, %eax
je 0x27439
movl %eax, %ebx
movq 0x19b8b(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x274de
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x10fad(%rip), %rsi     # 0x383ad
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 0x274de
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0xb2f0
movsd -0x20(%rbp), %xmm2
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
movl %eax, (%r15)
cvtdq2pd %xmm0, %xmm1
movapd %xmm2, %xmm0
subsd %xmm1, %xmm0
ucomisd 0x10a34(%rip), %xmm0    # 0x37ea0
jbe 0x27482
movapd %xmm2, %xmm0
callq 0xa160
cvttsd2si %xmm0, %eax
movl %eax, (%r15)
xorl %ebx, %ebx
jmp 0x274de
xorl %ebx, %ebx
ucomisd 0xc3d4(%rip), %xmm0     # 0x33860
jbe 0x274de
leaq 0x11c6f(%rip), %rdi     # 0x39104
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x19ab2(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x10ef1(%rip), %rsi     # 0x383ad
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_i(char*, int*, block_struct*, double*)
int Interp::read_i(char *line,   //!< string: line of RS274 code being processed    
                  int *counter, //!< pointer to a counter for position on the line 
                  block_pointer block,  //!< pointer to a block being filled from the line 
                  double *parameters)   //!< array of system parameters                    
{
  double value;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x69, (%rsi,%rax)
jne 0x2751c
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x198(%rcx)
jne 0x27577
leaq 0x11ba3(%rip), %rdi     # 0x390bd
jmp 0x27523
leaq 0xfd2c(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x19a24(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x10eb4(%rip), %rsi     # 0x383fe
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 0x275f0
movl %eax, %ebx
movq 0x199d0(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2756c
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x10e47(%rip), %rsi     # 0x383fe
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 0x2756c
movb $0x1, 0x198(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x1a0(%r14)
xorl %ebx, %ebx
jmp 0x2756c
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_integer_unsigned(char*, int*, int*)
int Interp::read_integer_unsigned(char *line,    //!< string: line of RS274 code being processed   
                                 int *counter,  //!< pointer to a counter for position on the line
                                 int *integer_ptr)      //!< pointer to the value being read              
{
  int n;
  char c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movslq (%rdx), %r12
addq %r12, %rsi
xorl %r13d, %r13d
movb (%rsi,%r13), %al
addb $-0x3a, %al
incq %r13
cmpb $-0xb, %al
ja 0x2762b
cmpl $0x1, %r13d
jne 0x27647
leaq 0x11a95(%rip), %rdi     # 0x390da
jmp 0x27677
leaq 0x12606(%rip), %rax     # 0x39c54
xorl %r15d, %r15d
movq %rsi, %rdi
movq %rax, %rsi
movq %rcx, %rdx
xorl %eax, %eax
callq 0xaa50
testl %eax, %eax
je 0x27670
decl %r12d
addq %r13, %r12
movl %r12d, (%r14)
jmp 0x276c1
leaq 0x11a7f(%rip), %rdi     # 0x390f6
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x198d0(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x10db1(%rip), %rsi     # 0x3844f
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_items(block_struct*, char*, double*)
int Interp::read_items(block_pointer block,      //!< pointer to a block being filled from the line 
                      char *line,       //!< string: line of RS274/NGC code being processed
                      double *parameters)   //!< array of system parameters 
{
  int counter;
  int length;

  length = strlen(line);
  counter = 0;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
movq %rdx, %rdi
callq 0xa4a0
movq %rax, %r14
xorl %eax, %eax
cmpb $0x2f, (%r12)
sete %al
movl %eax, -0x2c(%rbp)
cmpb $0x6e, (%r12,%rax)
jne 0x2772a
leaq -0x2c(%rbp), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rcx
callq 0xaf30
testl %eax, %eax
jne 0x27756
movl -0x2c(%rbp), %eax
movslq %eax, %rcx
cmpb $0x6f, (%r12,%rcx)
jne 0x277c6
leaq -0x2c(%rbp), %rdx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq -0x38(%rbp), %r8
callq 0xa1b0
testl %eax, %eax
je 0x277fc
movl %eax, %ebx
movq 0x19801(%rip), %rax     # 0x40f60
movslq 0xd670(%rax), %rcx
cmpq $0x30, %rcx
jg 0x277fe
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x10d16(%rip), %rsi     # 0x384a0
movl $0x50, %edx
callq 0xa8a0
movq 0x197c5(%rip), %rax     # 0x40f60
movslq 0xd670(%rax), %rcx
leaq (%rcx,%rcx,4), %rdx
shlq $0x4, %rdx
xorl %esi, %esi
movb %sil, 0xc71f(%rax,%rdx)
incl %ecx
movl %ecx, 0xd670(%rax)
movb %sil, 0xc720(%rax,%rdx)
jmp 0x277fe
movq 0x19793(%rip), %rcx     # 0x40f60
cmpq $0x0, 0xef70(%rcx)
jne 0x277fc
cmpl %r14d, %eax
jge 0x277fc
movq %r13, %rdi
movq %r12, %rsi
leaq -0x2c(%rbp), %rdx
movq %r15, %rcx
movq -0x38(%rbp), %r8
callq 0xa690
testl %eax, %eax
jne 0x2780f
cmpl %r14d, -0x2c(%rbp)
jl 0x277dc
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
movq 0x19748(%rip), %rcx     # 0x40f60
movslq 0xd670(%rcx), %rax
cmpq $0x30, %rax
jg 0x277fe
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
jmp 0x27783
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_n_number(char*, int*, block_struct*)
int Interp::read_n_number(char *line, //!< string: line of RS274    code being processed 
                          int *counter,       //!< pointer to a counter for position on the line 
                          block_pointer block)        //!< pointer to a block being filled from the line 
{
  int value;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movslq (%rdx), %rax
movb (%rsi,%rax), %cl
andb $-0x2, %cl
cmpb $0x6e, %cl
jne 0x278e3
incl %eax
movl %eax, (%rdx)
leaq -0x14(%rbp), %rcx
movq %rbx, %rdi
callq 0xb210
testl %eax, %eax
je 0x27935
movl %eax, %ebx
movq 0x196de(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x27941
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x10c44(%rip), %rsi     # 0x384f1
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 0x27941
leaq 0xf965(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1965d(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x10be0(%rip), %rsi     # 0x384f1
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
jmp 0x27941
movl -0x14(%rbp), %eax
movl %eax, 0x1d4(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_one_item(char*, int*, block_struct*, double*)
int Interp::read_one_item(
    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  */
{
  read_function_pointer function_pointer;
  char letter;

  letter = line[*counter];      /* check if in array range */
  CHKS(((letter < ' ') || (letter > 'z')),
	_("Bad character '\\%03o' used"), (unsigned char)letter);
  function_pointer = _readers[(int) letter]; /* Find the function pointer in the array */
  CHKS((function_pointer == 0),
	(!isprint(letter) || isspace(letter)) ?
	    _("Bad character '\\%03o' used") : _("Bad character '%c' used"), letter);
  CHP((*this.*function_pointer)(line, counter, block, parameters)); /* Call the function */ 
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rax
movsbl (%rsi,%rax), %r14d
leal -0x7b(%r14), %eax
cmpb $-0x5c, %al
ja 0x283dc
leaq 0x10e1a(%rip), %rdi     # 0x391e2
callq 0xa1f0
movzbl %r14b, %edx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x284c3
movl %r14d, %edi
shlq $0x4, %rdi
movq 0x8(%rbx,%rdi), %rax
testq %rax, %rax
je 0x28480
addq %rbx, %rdi
addq $0x8, %rdi
addq 0x8(%rdi), %rbx
testb $0x1, %al
je 0x28408
movq (%rbx), %rdi
movq -0x1(%rdi,%rax), %rax
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x284aa
movl %eax, %ebx
movq 0x18b42(%rip), %r15     # 0x40f60
movslq 0xd670(%r15), %rax
cmpq $0x30, %rax
jg 0x2850c
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r15,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x1014a(%rip), %rsi     # 0x38593
movl $0x50, %edx
callq 0xa8a0
movslq 0xd670(%r15), %rax
leaq (%rax,%rax,4), %rcx
shlq $0x4, %rcx
leaq (%r15,%rcx), %r14
addq $0xc720, %r14           # imm = 0xC720
movb $0x0, -0x1(%r14)
incl %eax
movl %eax, 0xd670(%r15)
jmp 0x28508
movl %r14d, %edi
callq 0xb3c0
testl %eax, %eax
je 0x284ae
movl %r14d, %edi
callq 0xa0b0
testl %eax, %eax
leaq 0x10d60(%rip), %rax     # 0x391fd
leaq 0x10d3e(%rip), %rdi     # 0x391e2
cmoveq %rax, %rdi
jmp 0x284b5
xorl %ebx, %ebx
jmp 0x2850c
leaq 0x10d2d(%rip), %rdi     # 0x391e2
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0xa850
movq 0x18a8f(%rip), %r14     # 0x40f60
leaq 0xc6d0(%r14), %rdi
leaq 0x100b4(%rip), %rsi     # 0x38593
movl $0x50, %edx
callq 0xa8a0
movb $0x0, 0xc71f(%r14)
movl $0x1, 0xd670(%r14)
addq $0xc720, %r14           # imm = 0xC720
movl $0x5, %ebx
movb $0x0, (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_j(char*, int*, block_struct*, double*)
int Interp::read_j(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] != 'j'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->j_flag != OFF), NCE_MULTIPLE_J_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->j_flag = ON;
  block->j_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 $0x6a, (%rsi,%rax)
jne 0x2854a
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x1a8(%rcx)
jne 0x285a5
leaq 0x10bda(%rip), %rdi     # 0x39122
jmp 0x28551
leaq 0xecfe(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x189f6(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0x1006c(%rip), %rsi     # 0x385e4
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 0x2861e
movl %eax, %ebx
movq 0x189a2(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2859a
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xffff(%rip), %rsi      # 0x385e4
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 0x2859a
movb $0x1, 0x1a8(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x1b0(%r14)
xorl %ebx, %ebx
jmp 0x2859a
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_k(char*, int*, block_struct*, double*)
int Interp::read_k(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] != 'k'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->k_flag != OFF), NCE_MULTIPLE_K_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->k_flag = ON;
  block->k_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 $0x6b, (%rsi,%rax)
jne 0x2866c
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x1b8(%rcx)
jne 0x286c7
leaq 0x10ad5(%rip), %rdi     # 0x3913f
jmp 0x28673
leaq 0xebdc(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x188d4(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xff9b(%rip), %rsi      # 0x38635
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 0x28740
movl %eax, %ebx
movq 0x18880(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x286bc
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xff2e(%rip), %rsi      # 0x38635
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 0x286bc
movb $0x1, 0x1b8(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x1c0(%r14)
xorl %ebx, %ebx
jmp 0x286bc
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_l(char*, int*, block_struct*, double*)
int Interp::read_l(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] != 'l'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->l_number > -1), NCE_MULTIPLE_L_WORDS_ON_ONE_LINE);
  CHP(read_integer_value(line, counter, &value, parameters));
  CHKS((value < 0), NCE_NEGATIVE_L_WORD_USED);
  block->l_number = value;
  block->l_flag = ON;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x6c, (%rsi,%rax)
jne 0x2878d
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
cmpl $0x0, 0x1c8(%rcx)
js 0x287ec
leaq 0x109d1(%rip), %rdi     # 0x3915c
jmp 0x28794
leaq 0xeabb(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x187b3(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xfecb(%rip), %rsi      # 0x38686
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 0x28863
movl %eax, %r14d
movq 0x1875a(%rip), %rbx     # 0x40f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x287de
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xfe59(%rip), %rsi      # 0x38686
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 0x287de
movl -0x1c(%rbp), %eax
testl %eax, %eax
js 0x28881
movl %eax, 0x1c8(%r15)
movb $0x1, 0x1cc(%r15)
xorl %r14d, %r14d
jmp 0x287de
leaq 0x108f1(%rip), %rdi     # 0x39179
jmp 0x28794
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_m(char*, int*, block_struct*, double*)
int Interp::read_m(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 value;
  int mode;

  CHKS((line[*counter] != 'm'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHP(read_integer_value(line, counter, &value, parameters));
  CHKS((value < 0), NCE_NEGATIVE_M_CODE_USED);
  CHKS((value > 199), NCE_M_CODE_GREATER_THAN_199);
  mode = _ems[value];
  CHKS((mode == -1), NCE_UNKNOWN_M_CODE_USED);
  CHKS((block->m_modes[mode] != -1),
      NCE_TWO_M_CODES_USED_FROM_SAME_MODAL_GROUP);
  block->m_modes[mode] = value;
  block->m_count++;
  if (value >= 100 && value < 200) {
    block->user_m = 1;
  }
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x6d, (%rsi,%rax)
jne 0x2892b
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
leaq -0x1c(%rbp), %rcx
movq %rbx, %rdi
callq 0xab30
testl %eax, %eax
je 0x2898a
movl %eax, %r14d
movq 0x18693(%rip), %rbx     # 0x40f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x2897c
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xfddf(%rip), %rsi      # 0x386d7
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 0x2897c
leaq 0xe91d(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x18615(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xfd7e(%rip), %rsi      # 0x386d7
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
movslq -0x1c(%rbp), %rax
testq %rax, %rax
js 0x289a3
cmpl $0xc8, %eax
jb 0x289ac
leaq 0x10802(%rip), %rdi     # 0x391a3
jmp 0x28932
leaq 0x107e4(%rip), %rdi     # 0x3918e
jmp 0x28932
movq 0x1861d(%rip), %rcx     # 0x40fd0
movslq (%rcx,%rax,4), %rcx
cmpq $-0x1, %rcx
je 0x289d4
cmpl $-0x1, 0x1e0(%r15,%rcx,4)
je 0x289e0
leaq 0x107ec(%rip), %rdi     # 0x391bb
jmp 0x28932
leaq 0xd522(%rip), %rdi      # 0x35efd
jmp 0x28932
movl %eax, 0x1e0(%r15,%rcx,4)
incl 0x1dc(%r15)
addl $-0x64, %eax
xorl %r14d, %r14d
cmpl $0x63, %eax
ja 0x2897c
movl $0x1, 0x20c(%r15)
jmp 0x2897c
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_name(char*, int*, char*)
int Interp::read_name(
    char *line,   //!< string: line of RS274/NGC code being processed
    int *counter, //!< pointer to a counter for position on the line 
    char *nameBuf)   //!< pointer to name to be read
{

  int done = 0;
  int i;

  CHKS(((line[*counter] != '<') && !isalpha(line[*(counter)])),
      NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);

  // skip over the '<'
  *counter = (*counter + 1);

  for(i=0; (i<LINELEN) && (line[*counter]); i++)
  {
      if(line[*counter] == '>')
      {
          nameBuf[i] = 0; // terminate the name
          *counter = (*counter + 1);
          done = 1;
          break;
      }
      nameBuf[i] = line[*counter];
      *counter = (*counter + 1);
  }

  // !!!KL need to rename the error message and change text
  CHKS((!done), NCE_NAMED_PARAMETER_NOT_TERMINATED);

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movslq (%rdx), %r13
movsbl (%rsi,%r13), %edi
cmpl $0x3c, %edi
je 0x28efc
callq 0xb140
testl %eax, %eax
je 0x28f42
incl %r13d
movl %r13d, (%r14)
xorl %eax, %eax
movslq %r13d, %rcx
movzbl (%r12,%rcx), %ecx
testl %ecx, %ecx
je 0x28f2d
cmpl $0x3e, %ecx
je 0x28f36
movb %cl, (%r15,%rax)
movl (%r14), %r13d
incl %r13d
movl %r13d, (%r14)
incq %rax
cmpq $0xff, %rax
jne 0x28f04
leaq 0xc4f8(%rip), %rdi      # 0x3542c
jmp 0x28f49
movb $0x0, (%r15,%rax)
incl (%r14)
xorl %eax, %eax
jmp 0x28f92
leaq 0xe306(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x17ffe(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xf85a(%rip), %rsi      # 0x387ca
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_p(char*, int*, block_struct*, double*)
int Interp::read_p(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] != 'p'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->p_number > -1.0), NCE_MULTIPLE_P_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  // FMP removed check for negatives, since we may want them for
  // user-defined codes
  // CHKS((value < 0.0), NCE_NEGATIVE_P_WORD_USED);
  block->p_number = value;
  block->p_flag = ON;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x70, (%rsi,%rax)
jne 0x28fdb
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
movsd 0x210(%rcx), %xmm0
ucomisd 0xa8a0(%rip), %xmm0     # 0x33870
jbe 0x29036
leaq 0x10741(%rip), %rdi     # 0x3971a
jmp 0x28fe2
leaq 0xe26d(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x17f65(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xf812(%rip), %rsi      # 0x3881b
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 0x290af
movl %eax, %ebx
movq 0x17f11(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2902b
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xf7a5(%rip), %rsi      # 0x3881b
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 0x2902b
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x210(%r14)
movb $0x1, 0x218(%r14)
xorl %ebx, %ebx
jmp 0x2902b
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
xorl %eax, %eax
cmpb $0x5f, (%rsi)
movq 0x17e74(%rip), %r8      # 0x40f60
movslq 0xef90(%r8), %rdi
movl $0x0, %esi
cmovneq %rdi, %rsi
imulq $0x128, %rsi, %rsi      # imm = 0x128
movslq 0xf0ac(%r8,%rsi), %r12
xorps %xmm0, %xmm0
testq %r12, %r12
jle 0x29169
movq %rcx, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
leaq (%r8,%rsi), %r13
addq $0xf0a8, %r13           # imm = 0xF0A8
movq 0x8(%r13), %r14
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
movq %r15, %rsi
callq 0xaeb0
testl %eax, %eax
je 0x29153
incq %rbx
cmpq %rbx, %r12
jne 0x2912c
xorl %eax, %eax
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
xorps %xmm0, %xmm0
jmp 0x29169
movq 0x10(%r13), %rax
movsd (%rax,%rbx,8), %xmm0
movl $0x1, %eax
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movsd %xmm0, (%rcx)
movl %eax, (%rdx)
xorl %eax, %eax
addq $0x18, %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/interp_read.cc
// Function: Interp::read_parameter(char*, int*, double*, double*)
int Interp::read_parameter(
    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 index;

  CHKS((line[*counter] != '#'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);

  *counter = (*counter + 1);

  // named parameters look like '<letter...>' or '<_.....>'
  if(line[*counter] == '<')
  {
      //_setup.stack_index = 0; -- reminder of variable we need
      // find the matching string (if any) -- or create it
      // then get the value and store it
      CHP(read_named_parameter(line, counter, double_ptr, parameters));
  }
  else
  {
      CHP(read_integer_value(line, counter, &index, parameters));
      CHKS(((index < 1) || (index >= RS274NGC_MAX_PARAMETERS)),
          NCE_PARAMETER_NUMBER_OUT_OF_RANGE);
      *double_ptr = parameters[index];
  }
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movslq (%rdx), %rax
cmpb $0x23, (%rsi,%rax)
jne 0x2981d
movq %rcx, %r15
leaq 0x1(%rax), %rcx
movl %ecx, (%rdx)
cmpb $0x3c, 0x1(%rsi,%rax)
jne 0x29872
movq %r14, %rdi
movq %r15, %rcx
callq 0xadf0
testl %eax, %eax
jne 0x29885
jmp 0x29911
leaq 0xda2b(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x17723(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xf114(%rip), %rsi      # 0x3895f
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
jmp 0x29913
movq %r8, %r12
leaq -0x24(%rbp), %rcx
movq %r14, %rdi
callq 0xab30
testl %eax, %eax
je 0x298eb
movl %eax, %ebx
movq 0x176d2(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x29913
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xf0aa(%rip), %rsi      # 0x3895f
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 0x29913
movl -0x24(%rbp), %eax
movl $0xffffeada, %ecx       # imm = 0xFFFFEADA
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
ja 0x29906
leaq 0x1007a(%rip), %rdi     # 0x3997b
jmp 0x29824
movsd (%r12,%rax,8), %xmm0
movsd %xmm0, (%r15)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movslq %esi, %rax
imulq $0x128, %rax, %rax      # imm = 0x128
leaq (%rdx,%rax), %rbx
addq $0xf0a8, %rbx           # imm = 0xF0A8
cmpl $0x0, 0x4(%rbx)
jle 0x29960
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xacf0
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x29947
movl $0x0, 0x4(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16fd9(%rip), %rax     # 0x40f70
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x29fca
movq 0x17002(%rip), %rdx     # 0x40fa8
movb $0x1, %al
cmpl %esi, (%rdx)
je 0x29fcc
movl $0x1, %edi
movq %rdi, %rax
cmpq %rdi, %rcx
je 0x29fc2
leaq 0x1(%rax), %rdi
cmpl %esi, (%rdx,%rax,4)
jne 0x29fb1
cmpq %rcx, %rax
setb %al
jmp 0x29fcc
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_q(char*, int*, block_struct*, double*)
int Interp::read_q(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] != 'q'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->q_number > -1.0), NCE_MULTIPLE_Q_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  // FMP removed check for negatives, since we may want them for
  // user-defined codes
  // CHKS((value <= 0.0), NCE_NEGATIVE_OR_ZERO_Q_VALUE_USED);
  block->q_number = value;
  block->q_flag = ON;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rdx), %rax
cmpb $0x71, (%rsi,%rax)
jne 0x2a007
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
movsd 0x220(%rcx), %xmm0
ucomisd 0x9874(%rip), %xmm0     # 0x33870
jbe 0x2a062
leaq 0xfae5(%rip), %rdi      # 0x39aea
jmp 0x2a00e
leaq 0xd241(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16f39(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xea1d(%rip), %rsi      # 0x38a52
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 0x2a0db
movl %eax, %ebx
movq 0x16ee5(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2a057
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe9b0(%rip), %rsi      # 0x38a52
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 0x2a057
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x220(%r14)
movb $0x1, 0x228(%r14)
xorl %ebx, %ebx
jmp 0x2a057
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/rs274ngc/interp_read.cc
// Function: Interp::read_r(char*, int*, block_struct*, double*)
int Interp::read_r(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] != 'r'), NCE_BUG_FUNCTION_SHOULD_NOT_HAVE_BEEN_CALLED);
  *counter = (*counter + 1);
  CHKS((block->r_flag != OFF), NCE_MULTIPLE_R_WORDS_ON_ONE_LINE);
  CHP(read_real_value(line, counter, &value, parameters));
  block->r_flag = ON;
  block->r_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 $0x72, (%rsi,%rax)
jne 0x2a128
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x229(%rcx)
jne 0x2a183
leaq 0xf9e1(%rip), %rdi      # 0x39b07
jmp 0x2a12f
leaq 0xd120(%rip), %rdi      # 0x3724f
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16e18(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe94d(%rip), %rsi      # 0x38aa3
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 0x2a1fc
movl %eax, %ebx
movq 0x16dc4(%rip), %r14     # 0x40f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2a178
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe8e0(%rip), %rsi      # 0x38aa3
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 0x2a178
movb $0x1, 0x229(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x230(%r14)
xorl %ebx, %ebx
jmp 0x2a178
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x40(%rbp)
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movslq (%rdx), %r13
addq %rsi, %r13
leaq 0xf8dd(%rip), %rsi      # 0x39b24
movq %r13, %rdi
callq 0xa470
movq %rax, %rbx
movb (%rax,%r13), %r14b
movb $0x0, (%rax,%r13)
leaq -0x48(%rbp), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0xa7b0
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
movb %r14b, (%rbx,%r13)
movq (%r12), %rax
cmpq %r13, %rax
je 0x2a28c
subl %r15d, %eax
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
jmp 0x2a2dd
leaq 0xf89f(%rip), %rdi      # 0x39b32
callq 0xa1f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16cb3(%rip), %rbx     # 0x40f60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe839(%rip), %rsi      # 0x38af4
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq