LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25a8e
leaq 0xf768(%rip), %rdi      # 0x351e2
callq 0xb220
movzbl %r14b, %edx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x25b6b
movl %r14d, %edi
shlq $0x4, %rdi
movq 0x8(%rbx,%rdi), %rax
testq %rax, %rax
je 0x25b28
addq %rbx, %rdi
addq $0x8, %rdi
addq 0x8(%rdi), %rbx
testb $0x1, %al
je 0x25aba
movq (%rbx), %rdi
movq -0x1(%rdi,%rax), %rax
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
je 0x25b52
movl %eax, %ebx
movq 0x17490(%rip), %r15     # 0x3cf60
movslq 0xd670(%r15), %rax
cmpq $0x30, %rax
jg 0x25bb0
imulq $0x50, %rax, %rax
leaq (%r15,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xea9c(%rip), %rsi      # 0x34593
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r15), %rax
imulq $0x50, %rax, %rcx
leaq (%r15,%rcx), %r14
addq $0xc720, %r14           # imm = 0xC720
movb $0x0, -0x1(%r14)
incl %eax
movl %eax, 0xd670(%r15)
jmp 0x25bac
movl %r14d, %edi
callq 0xc530
testl %eax, %eax
je 0x25b56
movl %r14d, %edi
callq 0xb0c0
testl %eax, %eax
leaq 0xf6b8(%rip), %rax      # 0x351fd
leaq 0xf696(%rip), %rdi      # 0x351e2
cmoveq %rax, %rdi
jmp 0x25b5d
xorl %ebx, %ebx
jmp 0x25bb0
leaq 0xf685(%rip), %rdi      # 0x351e2
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0xb8e0
movq 0x173e7(%rip), %r14     # 0x3cf60
leaq 0xc6d0(%r14), %rdi
leaq 0xea0c(%rip), %rsi      # 0x34593
pushq $0x50
popq %rdx
callq 0xb940
movb $0x0, 0xc71f(%r14)
movl $0x1, 0xd670(%r14)
addq $0xc720, %r14           # imm = 0xC720
pushq $0x5
popq %rbx
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_O2/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 0x25bee
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x1a8(%rcx)
jne 0x25c44
leaq 0xf536(%rip), %rdi      # 0x35122
jmp 0x25bf5
leaq 0xd65a(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x17352(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe9c8(%rip), %rsi      # 0x345e4
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x25cb0
movl %eax, %ebx
movq 0x17303(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x25c39
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe964(%rip), %rsi      # 0x345e4
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x25c39
movb $0x1, 0x1a8(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x1b0(%r14)
xorl %ebx, %ebx
jmp 0x25c39
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25cfe
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x1b8(%rcx)
jne 0x25d54
leaq 0xf443(%rip), %rdi      # 0x3513f
jmp 0x25d05
leaq 0xd54a(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x17242(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe909(%rip), %rsi      # 0x34635
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x25dc0
movl %eax, %ebx
movq 0x171f3(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x25d49
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe8a5(%rip), %rsi      # 0x34635
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x25d49
movb $0x1, 0x1b8(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x1c0(%r14)
xorl %ebx, %ebx
jmp 0x25d49
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25e0d
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
cmpl $0x0, 0x1c8(%rcx)
js 0x25e67
leaq 0xf351(%rip), %rdi      # 0x3515c
jmp 0x25e14
leaq 0xd43b(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x17133(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe84b(%rip), %rsi      # 0x34686
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1c(%rbp), %rcx
movq %rbx, %rdi
callq 0xbc20
testl %eax, %eax
je 0x25ed1
movl %eax, %r14d
movq 0x170df(%rip), %rbx     # 0x3cf60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x25e59
imulq $0x50, %rax, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe7e2(%rip), %rsi      # 0x34686
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%rbx), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
jmp 0x25e59
movl -0x1c(%rbp), %eax
testl %eax, %eax
js 0x25eef
movl %eax, 0x1c8(%r15)
movb $0x1, 0x1cc(%r15)
xorl %r14d, %r14d
jmp 0x25e59
leaq 0xf283(%rip), %rdi      # 0x35179
jmp 0x25e14
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25f8b
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
leaq -0x1c(%rbp), %rcx
movq %rbx, %rdi
callq 0xbc20
testl %eax, %eax
je 0x25fe5
movl %eax, %r14d
movq 0x17029(%rip), %rbx     # 0x3cf60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x25fd7
imulq $0x50, %rax, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe779(%rip), %rsi      # 0x346d7
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%rbx), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
jmp 0x25fd7
leaq 0xd2bd(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x16fb5(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe71e(%rip), %rsi      # 0x346d7
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movslq -0x1c(%rbp), %rax
testq %rax, %rax
js 0x25ffe
cmpl $0xc8, %eax
jb 0x26007
leaq 0xf1a7(%rip), %rdi      # 0x351a3
jmp 0x25f92
leaq 0xf189(%rip), %rdi      # 0x3518e
jmp 0x25f92
movq 0x16fc2(%rip), %rcx     # 0x3cfd0
movslq (%rcx,%rax,4), %rcx
cmpq $-0x1, %rcx
je 0x2602f
cmpl $-0x1, 0x1e0(%r15,%rcx,4)
je 0x2603b
leaq 0xf191(%rip), %rdi      # 0x351bb
jmp 0x25f92
leaq 0xbed1(%rip), %rdi      # 0x31f07
jmp 0x25f92
movl %eax, 0x1e0(%r15,%rcx,4)
incl 0x1dc(%r15)
addl $-0x64, %eax
xorl %r14d, %r14d
cmpl $0x63, %eax
ja 0x25fd7
movl $0x1, 0x20c(%r15)
jmp 0x25fd7
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26544
callq 0xc290
testl %eax, %eax
je 0x2658c
incl %r13d
movl %r13d, (%r14)
xorl %eax, %eax
cmpq $0xff, %rax
je 0x26577
movslq %r13d, %rcx
movzbl (%r12,%rcx), %ecx
testl %ecx, %ecx
je 0x26577
cmpl $0x3e, %ecx
je 0x26580
movb %cl, (%r15,%rax)
movl (%r14), %r13d
incl %r13d
movl %r13d, (%r14)
incq %rax
jmp 0x2654c
leaq 0xaeae(%rip), %rdi      # 0x3142c
jmp 0x26593
movb $0x0, (%r15,%rax)
incl (%r14)
xorl %eax, %eax
jmp 0x265d7
leaq 0xccbc(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x169b4(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe210(%rip), %rsi      # 0x347ca
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2661f
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
movsd 0x210(%rcx), %xmm0
ucomisd 0x925c(%rip), %xmm0     # 0x2f870
jbe 0x26675
leaq 0xf0fd(%rip), %rdi      # 0x3571a
jmp 0x26626
leaq 0xcc29(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x16921(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xe1ce(%rip), %rsi      # 0x3481b
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x266e1
movl %eax, %ebx
movq 0x168d2(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2666a
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe16a(%rip), %rsi      # 0x3481b
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x2666a
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x210(%r14)
movb $0x1, 0x218(%r14)
xorl %ebx, %ebx
jmp 0x2666a
// File: /workspace/github_cpp_makefile_star2_O2/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 %rcx, -0x38(%rbp)
movq %rsi, %r15
xorl %r12d, %r12d
cmpb $0x5f, (%rsi)
movq 0x1683d(%rip), %rax     # 0x3cf60
movslq 0xef90(%rax), %rcx
cmoveq %r12, %rcx
movq %rdx, -0x30(%rbp)
imulq $0x128, %rcx, %rcx      # imm = 0x128
leaq (%rax,%rcx), %r13
addq $0xf0a8, %r13           # imm = 0xF0A8
movl 0x4(%r13), %ebx
testl %ebx, %ebx
cmovlel %r12d, %ebx
xorl %r14d, %r14d
cmpq %r14, %rbx
je 0x2677e
movq 0x8(%r13), %rax
movq (%rax,%r14,8), %rdi
movq %r15, %rsi
callq 0xbfd0
incq %r14
testl %eax, %eax
jne 0x26751
movq 0x10(%r13), %rax
movsd -0x8(%rax,%r14,8), %xmm0
pushq $0x1
popq %r12
jmp 0x26781
xorps %xmm0, %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
movl %r12d, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x26dfb
movq %rcx, %r15
leaq 0x1(%rax), %rcx
movl %ecx, (%rdx)
cmpb $0x3c, 0x1(%rsi,%rax)
jne 0x26e4b
movq %r14, %rdi
movq %r15, %rcx
callq 0xbf00
testl %eax, %eax
jne 0x26e5e
jmp 0x26ee0
leaq 0xc44d(%rip), %rdi      # 0x3324f
callq 0xb220
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x16145(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xdb36(%rip), %rsi      # 0x3495f
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
jmp 0x26ee2
movq %r8, %r12
leaq -0x24(%rbp), %rcx
movq %r14, %rdi
callq 0xbc20
testl %eax, %eax
je 0x26eba
movl %eax, %ebx
movq 0x160f9(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x26ee2
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xdad5(%rip), %rsi      # 0x3495f
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x26ee2
movl -0x24(%rbp), %eax
movl $0xffffeada, %ecx       # imm = 0xFFFFEADA
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
ja 0x26ed5
leaq 0xeaab(%rip), %rdi      # 0x3597b
jmp 0x26e02
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
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r14d, %r14d
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jge 0x26f2c
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xbde0
incq %r14
jmp 0x26f11
andl $0x0, 0x4(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27575
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
movsd 0x220(%rcx), %xmm0
ucomisd 0x8306(%rip), %xmm0     # 0x2f870
jbe 0x275cb
leaq 0xe577(%rip), %rdi      # 0x35aea
jmp 0x2757c
leaq 0xbcd3(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x159cb(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xd4af(%rip), %rsi      # 0x34a52
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x27637
movl %eax, %ebx
movq 0x1597c(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x275c0
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xd44b(%rip), %rsi      # 0x34a52
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x275c0
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x220(%r14)
movb $0x1, 0x228(%r14)
xorl %ebx, %ebx
jmp 0x275c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27684
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x229(%rcx)
jne 0x276da
leaq 0xe485(%rip), %rdi      # 0x35b07
jmp 0x2768b
leaq 0xbbc4(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x158bc(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xd3f1(%rip), %rsi      # 0x34aa3
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x27746
movl %eax, %ebx
movq 0x1586d(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x276cf
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xd38d(%rip), %rsi      # 0x34aa3
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x276cf
movb $0x1, 0x229(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x230(%r14)
xorl %ebx, %ebx
jmp 0x276cf
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe393(%rip), %rsi      # 0x35b24
movq %r13, %rdi
callq 0xb4b0
movq %rax, %rbx
movb (%rax,%r13), %r14b
movb $0x0, (%rax,%r13)
leaq -0x48(%rbp), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0xb820
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
movb %r14b, (%rbx,%r13)
movq (%r12), %rax
cmpq %r13, %rax
je 0x277d6
subl %r15d, %eax
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
jmp 0x27822
leaq 0xe355(%rip), %rdi      # 0x35b32
callq 0xb220
movq -0x30(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x15769(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xd2ef(%rip), %rsi      # 0x34af4
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbcc0
testl %eax, %eax
je 0x278c4
movl %eax, %ecx
movq 0x156f8(%rip), %r15     # 0x3cf60
movslq 0xd670(%r15), %rax
cmpq $0x30, %rax
jg 0x27966
imulq $0x50, %rax, %rax
leaq (%r15,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xd2b6(%rip), %rsi      # 0x34b45
pushq $0x50
popq %rdx
movl %ecx, %ebx
callq 0xb940
movslq 0xd670(%r15), %rax
imulq $0x50, %rax, %rcx
leaq (%r15,%rcx), %r14
addq $0xc720, %r14           # imm = 0xC720
movl %ebx, %ecx
movb $0x0, -0x1(%r14)
incl %eax
movl %eax, 0xd670(%r15)
jmp 0x27962
movq %r15, -0x38(%rbp)
movslq (%r13), %rax
cmpb $0x5b, (%r12,%rax)
jne 0x2790f
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq -0x38(%rbp), %r8
callq 0xc0f0
testl %eax, %eax
jne 0x2785f
movl -0x2c(%rbp), %edx
movq %r14, %rdi
cmpl $0x4, %edx
jne 0x27977
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
movq -0x38(%rbp), %r8
callq 0xb5d0
jmp 0x2797f
leaq 0xe3a1(%rip), %rdi      # 0x35cb7
callq 0xb220
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x15631(%rip), %r14     # 0x3cf60
leaq 0xc6d0(%r14), %rdi
leaq 0xd208(%rip), %rsi      # 0x34b45
pushq $0x50
popq %rdx
callq 0xb940
movb $0x0, 0xc71f(%r14)
movl $0x1, 0xd670(%r14)
addq $0xc720, %r14           # imm = 0xC720
pushq $0x5
popq %rcx
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 0xbc50
testl %eax, %eax
jne 0x2785f
xorl %ecx, %ecx
jmp 0x27966
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x279c4
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
movsd 0x238(%rcx), %xmm0
ucomisd 0x7eb7(%rip), %xmm0     # 0x2f870
jbe 0x27a1e
leaq 0xe1f6(%rip), %rdi      # 0x35bb8
jmp 0x279cb
leaq 0xb884(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x1557c(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xd1a4(%rip), %rsi      # 0x34b96
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x20(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x27a88
movl %eax, %r14d
movq 0x15528(%rip), %rbx     # 0x3cf60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x27a10
imulq $0x50, %rax, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xd13b(%rip), %rsi      # 0x34b96
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%rbx), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
jmp 0x27a10
movsd -0x20(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x27aa3
leaq 0xe137(%rip), %rdi      # 0x35bd5
jmp 0x279cb
movsd %xmm0, 0x238(%r15)
xorl %r14d, %r14d
jmp 0x27a10
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27ae3
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
cmpl $0x0, 0x240(%rcx)
js 0x27b3d
leaq 0xe110(%rip), %rdi      # 0x35bf1
jmp 0x27aea
leaq 0xb765(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x1545d(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xd0d6(%rip), %rsi      # 0x34be7
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1c(%rbp), %rcx
movq %rbx, %rdi
callq 0xbc20
testl %eax, %eax
je 0x27ba7
movl %eax, %r14d
movq 0x15409(%rip), %rbx     # 0x3cf60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x27b2f
imulq $0x50, %rax, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xd06d(%rip), %rsi      # 0x34be7
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%rbx), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%rbx,%rcx)
incl %eax
movl %eax, 0xd670(%rbx)
movb %dl, 0xc720(%rbx,%rcx)
jmp 0x27b2f
movl -0x1c(%rbp), %eax
testl %eax, %eax
js 0x27bbd
movl %eax, 0x240(%r15)
xorl %r14d, %r14d
jmp 0x27b2f
leaq 0xe04a(%rip), %rdi      # 0x35c0e
jmp 0x27aea
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27eb6
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x244(%rcx)
jne 0x27f0c
leaq 0xde33(%rip), %rdi      # 0x35ce7
jmp 0x27ebd
leaq 0xb392(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x1508a(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xcda5(%rip), %rsi      # 0x34c89
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x27f78
movl %eax, %ebx
movq 0x1503b(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x27f01
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xcd41(%rip), %rsi      # 0x34c89
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x27f01
movb $0x1, 0x244(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x248(%r14)
xorl %ebx, %ebx
jmp 0x27f01
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27fc6
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x250(%rcx)
jne 0x2801c
leaq 0xdd40(%rip), %rdi      # 0x35d04
jmp 0x27fcd
leaq 0xb282(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x14f7a(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xcce6(%rip), %rsi      # 0x34cda
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x28088
movl %eax, %ebx
movq 0x14f2b(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x28011
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xcc82(%rip), %rsi      # 0x34cda
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x28011
movb $0x1, 0x250(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x258(%r14)
xorl %ebx, %ebx
jmp 0x28011
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x280d6
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x260(%rcx)
jne 0x2812c
leaq 0xdc4d(%rip), %rdi      # 0x35d21
jmp 0x280dd
leaq 0xb172(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x14e6a(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xcc27(%rip), %rsi      # 0x34d2b
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x28198
movl %eax, %ebx
movq 0x14e1b(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x28121
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xcbc3(%rip), %rsi      # 0x34d2b
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x28121
movb $0x1, 0x260(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x268(%r14)
xorl %ebx, %ebx
jmp 0x28121
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x281e6
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x270(%rcx)
jne 0x2823c
leaq 0xdb5a(%rip), %rdi      # 0x35d3e
jmp 0x281ed
leaq 0xb062(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x14d5a(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xcb68(%rip), %rsi      # 0x34d7c
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x18(%rbp), %rcx
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x282a8
movl %eax, %ebx
movq 0x14d0b(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x28231
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xcb04(%rip), %rsi      # 0x34d7c
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x28231
movb $0x1, 0x270(%r14)
movq 0x14ca9(%rip), %rax     # 0x3cf60
movsd -0x18(%rbp), %xmm0
cmpb $0x1, 0x1e6d8(%rax)
jne 0x282cd
mulsd 0x5d3b(%rip), %xmm0     # 0x2e008
movsd %xmm0, 0x278(%r14)
xorl %ebx, %ebx
jmp 0x28231
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2836f
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
addq $0x2a8, %rcx            # imm = 0x2A8
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x283bc
movl %eax, %ebx
movq 0x14c48(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x283c9
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xca8e(%rip), %rsi      # 0x34dcd
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x283c9
leaq 0xaed9(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x14bd1(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xca30(%rip), %rsi      # 0x34dcd
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
jmp 0x283c9
movl $0x1, 0x2a0(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28461
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
addq $0x2b8, %rcx            # imm = 0x2B8
movq %rbx, %rdi
callq 0xc040
testl %eax, %eax
je 0x284ae
movl %eax, %ebx
movq 0x14b56(%rip), %r14     # 0x3cf60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x284bb
imulq $0x50, %rax, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xc9ed(%rip), %rsi      # 0x34e1e
pushq $0x50
popq %rdx
callq 0xb940
movslq 0xd670(%r14), %rax
imulq $0x50, %rax, %rcx
xorl %edx, %edx
movb %dl, 0xc71f(%r14,%rcx)
incl %eax
movl %eax, 0xd670(%r14)
movb %dl, 0xc720(%r14,%rcx)
jmp 0x284bb
leaq 0xade7(%rip), %rdi      # 0x3324f
callq 0xb220
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xb8e0
movq 0x14adf(%rip), %rbx     # 0x3cf60
leaq 0xc6d0(%rbx), %rdi
leaq 0xc98f(%rip), %rsi      # 0x34e1e
pushq $0x50
popq %rdx
callq 0xb940
andw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
pushq $0x5
popq %rbx
jmp 0x284bb
movl $0x1, 0x2b0(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq