LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a858
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x198(%rcx)
jne 0x2a8bd
leaq 0x11867(%rip), %rdi     # 0x3c0bd
jmp 0x2a85f
leaq 0xf9f8(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x196e8(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x10b6e(%rip), %rsi     # 0x3b3fe
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 0x2a936
movl %eax, %ebx
movq 0x1968a(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2a8b2
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x10b01(%rip), %rsi     # 0x3b3fe
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 0x2a8b2
movb $0x1, 0x198(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x1a0(%r14)
xorl %ebx, %ebx
jmp 0x2a8b2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2a971
cmpl $0x1, %r13d
jne 0x2a98d
leaq 0x1174f(%rip), %rdi     # 0x3c0da
jmp 0x2a9bd
leaq 0x122cb(%rip), %rax     # 0x3cc5f
xorl %r15d, %r15d
movq %rsi, %rdi
movq %rax, %rsi
movq %rcx, %rdx
xorl %eax, %eax
callq 0xaa50
testl %eax, %eax
je 0x2a9b6
decl %r12d
addq %r13, %r12
movl %r12d, (%r14)
jmp 0x2aa11
leaq 0x11739(%rip), %rdi     # 0x3c0f6
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1958a(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x10a61(%rip), %rsi     # 0x3b44f
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_O1/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 0x2ac89
incl %eax
movl %eax, (%rdx)
leaq -0x14(%rbp), %rcx
movq %rbx, %rdi
callq 0xb210
testl %eax, %eax
je 0x2ace5
movl %eax, %ebx
movq 0x19338(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2acf1
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0x1089e(%rip), %rsi     # 0x3b4f1
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 0x2acf1
leaq 0xf5c7(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x192b7(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0x10830(%rip), %rsi     # 0x3b4f1
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
jmp 0x2acf1
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_O1/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 0x2b96c
leaq 0x1088a(%rip), %rdi     # 0x3c1e2
callq 0xa1f0
movzbl %r14b, %edx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x2ba4f
movl %r14d, %edi
shlq $0x4, %rdi
movq 0x8(%rbx,%rdi), %rax
testq %rax, %rax
je 0x2ba10
addq %rbx, %rdi
addq $0x8, %rdi
addq 0x8(%rdi), %rbx
testb $0x1, %al
je 0x2b998
movq (%rbx), %rdi
movq -0x1(%rdi,%rax), %rax
movq %rbx, %rdi
callq *%rax
movl %eax, %ebx
testl %eax, %eax
je 0x2baa3
movq 0x185b2(%rip), %r15     # 0x43f60
movslq 0xd670(%r15), %rax
cmpq $0x30, %rax
jg 0x2baa3
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r15,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xfbba(%rip), %rsi      # 0x3b593
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 0x2ba9f
movl %r14d, %edi
callq 0xb3c0
testl %eax, %eax
je 0x2ba3a
movl %r14d, %edi
callq 0xa0b0
testl %eax, %eax
leaq 0x107d0(%rip), %rax     # 0x3c1fd
leaq 0x107ae(%rip), %rdi     # 0x3c1e2
cmoveq %rax, %rdi
jmp 0x2ba41
leaq 0x107a1(%rip), %rdi     # 0x3c1e2
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0xa850
movq 0x18503(%rip), %r14     # 0x43f60
movl $0x0, 0xd670(%r14)
leaq 0xc6d0(%r14), %rdi
leaq 0xfb1d(%rip), %rsi      # 0x3b593
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2bae0
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x1a8(%rcx)
jne 0x2bb45
leaq 0x10644(%rip), %rdi     # 0x3c122
jmp 0x2bae7
leaq 0xe770(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x18460(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xfacc(%rip), %rsi      # 0x3b5e4
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 0x2bbbe
movl %eax, %ebx
movq 0x18402(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2bb3a
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xfa5f(%rip), %rsi      # 0x3b5e4
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 0x2bb3a
movb $0x1, 0x1a8(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x1b0(%r14)
xorl %ebx, %ebx
jmp 0x2bb3a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2bc0c
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x1b8(%rcx)
jne 0x2bc71
leaq 0x10535(%rip), %rdi     # 0x3c13f
jmp 0x2bc13
leaq 0xe644(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x18334(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xf9f1(%rip), %rsi      # 0x3b635
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 0x2bcea
movl %eax, %ebx
movq 0x182d6(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2bc66
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xf984(%rip), %rsi      # 0x3b635
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 0x2bc66
movb $0x1, 0x1b8(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x1c0(%r14)
xorl %ebx, %ebx
jmp 0x2bc66
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2bd37
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
cmpl $0x0, 0x1c8(%rcx)
js 0x2bda0
leaq 0x10427(%rip), %rdi     # 0x3c15c
jmp 0x2bd3e
leaq 0xe519(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x18209(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xf917(%rip), %rsi      # 0x3b686
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 0x2be17
movl %eax, %r14d
movq 0x181a6(%rip), %rbx     # 0x43f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x2bd92
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xf8a5(%rip), %rsi      # 0x3b686
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 0x2bd92
movl -0x1c(%rbp), %eax
testl %eax, %eax
js 0x2be35
movl %eax, 0x1c8(%r15)
movb $0x1, 0x1cc(%r15)
xorl %r14d, %r14d
jmp 0x2bd92
leaq 0x1033d(%rip), %rdi     # 0x3c179
jmp 0x2bd3e
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2bedf
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
leaq -0x1c(%rbp), %rcx
movq %rbx, %rdi
callq 0xab30
testl %eax, %eax
je 0x2bf48
movl %eax, %r14d
movq 0x180df(%rip), %rbx     # 0x43f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x2bf3a
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xf82b(%rip), %rsi      # 0x3b6d7
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 0x2bf3a
leaq 0xe371(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x18061(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xf7c0(%rip), %rsi      # 0x3b6d7
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 0x2bf61
cmpl $0xc8, %eax
jl 0x2bf6d
leaq 0x10244(%rip), %rdi     # 0x3c1a3
jmp 0x2bee6
leaq 0x10226(%rip), %rdi     # 0x3c18e
jmp 0x2bee6
movq 0x1805c(%rip), %rcx     # 0x43fd0
movslq (%rcx,%rax,4), %rcx
cmpq $-0x1, %rcx
je 0x2bf95
cmpl $-0x1, 0x1e0(%r15,%rcx,4)
je 0x2bfa1
leaq 0x1022b(%rip), %rdi     # 0x3c1bb
jmp 0x2bee6
leaq 0xcf61(%rip), %rdi      # 0x38efd
jmp 0x2bee6
movl %eax, 0x1e0(%r15,%rcx,4)
incl 0x1dc(%r15)
addl $-0x64, %eax
xorl %r14d, %r14d
cmpl $0x63, %eax
ja 0x2bf3a
movl $0x1, 0x20c(%r15)
jmp 0x2bf3a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c500
callq 0xb140
testl %eax, %eax
je 0x2c540
incl %r13d
movl %r13d, (%r14)
xorl %eax, %eax
movslq (%r14), %rcx
movzbl (%r12,%rcx), %ecx
testl %ecx, %ecx
je 0x2c52b
cmpl $0x3e, %ecx
je 0x2c534
movb %cl, (%r15,%rax)
incl (%r14)
incq %rax
cmpq $0xff, %rax
jne 0x2c508
leaq 0xbefa(%rip), %rdi      # 0x3842c
jmp 0x2c547
movb $0x0, (%r15,%rax)
incl (%r14)
xorl %eax, %eax
jmp 0x2c59a
leaq 0xdd10(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x17a00(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xf252(%rip), %rsi      # 0x3b7ca
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_O1/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 0x2c5e3
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
movsd 0x210(%rcx), %xmm0
ucomisd 0xa298(%rip), %xmm0     # 0x36870
jbe 0x2c648
leaq 0x10144(%rip), %rdi     # 0x3c725
jmp 0x2c5ea
leaq 0xdc6d(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x1795d(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xf200(%rip), %rsi      # 0x3b81b
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 0x2c6c1
movl %eax, %ebx
movq 0x178ff(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2c63d
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xf193(%rip), %rsi      # 0x3b81b
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 0x2c63d
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x210(%r14)
movb $0x1, 0x218(%r14)
xorl %ebx, %ebx
jmp 0x2c63d
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17862(%rip), %r8      # 0x43f60
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 0x2c77b
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 0x2c765
incq %rbx
cmpq %rbx, %r12
jne 0x2c73e
xorl %eax, %eax
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
xorps %xmm0, %xmm0
jmp 0x2c77b
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_O1/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 0x2ce53
movq %rcx, %r15
leaq 0x1(%rax), %rcx
movl %ecx, (%rdx)
cmpb $0x3c, 0x1(%rsi,%rax)
jne 0x2ceb2
movq %r14, %rdi
movq %r15, %rcx
callq 0xadf0
testl %eax, %eax
jne 0x2cec5
jmp 0x2cf51
leaq 0xd3fd(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x170ed(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xead4(%rip), %rsi      # 0x3b95f
movl $0x50, %edx
callq 0xa8a0
movw $0x0, 0xc71f(%rbx)
movl $0x1, 0xd670(%rbx)
movl $0x5, %ebx
jmp 0x2cf53
movq %r8, %r12
leaq -0x24(%rbp), %rcx
movq %r14, %rdi
callq 0xab30
testl %eax, %eax
je 0x2cf2b
movl %eax, %ebx
movq 0x17092(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2cf53
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xea6a(%rip), %rsi      # 0x3b95f
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 0x2cf53
movl -0x24(%rbp), %eax
movl $0xffffeada, %ecx       # imm = 0xFFFFEADA
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
ja 0x2cf46
leaq 0xfa45(%rip), %rdi      # 0x3c986
jmp 0x2ce5a
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_O1/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 0x2cfa0
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xacf0
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x2cf87
movl $0x0, 0x4(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1685b(%rip), %rax     # 0x43f70
movslq (%rax), %rcx
testq %rcx, %rcx
setg %al
jle 0x2d747
movq 0x16881(%rip), %rdx     # 0x43fa8
cmpl %esi, (%rdx)
je 0x2d747
movl $0x1, %edi
movq %rdi, %rax
cmpq %rdi, %rcx
je 0x2d741
leaq 0x1(%rax), %rdi
cmpl %esi, (%rdx,%rax,4)
jne 0x2d730
cmpq %rcx, %rax
setb %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d783
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
movsd 0x220(%rcx), %xmm0
ucomisd 0x90f8(%rip), %xmm0     # 0x36870
jbe 0x2d7e8
leaq 0xf374(%rip), %rdi      # 0x3caf5
jmp 0x2d78a
leaq 0xcacd(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x167bd(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xe297(%rip), %rsi      # 0x3ba52
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 0x2d861
movl %eax, %ebx
movq 0x1675f(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2d7dd
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe22a(%rip), %rsi      # 0x3ba52
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 0x2d7dd
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x220(%r14)
movb $0x1, 0x228(%r14)
xorl %ebx, %ebx
jmp 0x2d7dd
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d8ae
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x229(%rcx)
jne 0x2d913
leaq 0xf266(%rip), %rdi      # 0x3cb12
jmp 0x2d8b5
leaq 0xc9a2(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16692(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xe1bd(%rip), %rsi      # 0x3baa3
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 0x2d98c
movl %eax, %ebx
movq 0x16634(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2d908
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xe150(%rip), %rsi      # 0x3baa3
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 0x2d908
movb $0x1, 0x229(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x230(%r14)
xorl %ebx, %ebx
jmp 0x2d908
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf158(%rip), %rsi      # 0x3cb2f
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 0x2da1c
subl %r15d, %eax
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
jmp 0x2da77
leaq 0xf11a(%rip), %rdi      # 0x3cb3d
callq 0xa1f0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16523(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xe09f(%rip), %rsi      # 0x3baf4
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2dd1c
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
movsd 0x238(%rcx), %xmm0
ucomisd 0x8b5f(%rip), %xmm0     # 0x36870
jbe 0x2dd85
leaq 0xeea9(%rip), %rdi      # 0x3cbc3
jmp 0x2dd23
leaq 0xc534(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x16224(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xde42(%rip), %rsi      # 0x3bb96
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 0x2ddfc
movl %eax, %r14d
movq 0x161c1(%rip), %rbx     # 0x43f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x2dd77
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xddd0(%rip), %rsi      # 0x3bb96
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 0x2dd77
movsd -0x20(%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2de17
leaq 0xedce(%rip), %rdi      # 0x3cbe0
jmp 0x2dd23
movsd %xmm0, 0x238(%r15)
xorl %r14d, %r14d
jmp 0x2dd77
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2de57
movq %rcx, %r15
incl %eax
movl %eax, (%rdx)
cmpl $0x0, 0x240(%rcx)
js 0x2dec0
leaq 0xeda7(%rip), %rdi      # 0x3cbfc
jmp 0x2de5e
leaq 0xc3f9(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x160e9(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xdd58(%rip), %rsi      # 0x3bbe7
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 0x2df37
movl %eax, %r14d
movq 0x16086(%rip), %rbx     # 0x43f60
movslq 0xd670(%rbx), %rax
cmpq $0x30, %rax
jg 0x2deb2
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rbx,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xdce6(%rip), %rsi      # 0x3bbe7
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 0x2deb2
movl -0x1c(%rbp), %eax
testl %eax, %eax
js 0x2df4d
movl %eax, 0x240(%r15)
xorl %r14d, %r14d
jmp 0x2deb2
leaq 0xecc5(%rip), %rdi      # 0x3cc19
jmp 0x2de5e
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e256
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x244(%rcx)
jne 0x2e2bb
leaq 0xea9e(%rip), %rdi      # 0x3ccf2
jmp 0x2e25d
leaq 0xbffa(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x15cea(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xd9fb(%rip), %rsi      # 0x3bc89
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 0x2e334
movl %eax, %ebx
movq 0x15c8c(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2e2b0
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xd98e(%rip), %rsi      # 0x3bc89
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 0x2e2b0
movb $0x1, 0x244(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x248(%r14)
xorl %ebx, %ebx
jmp 0x2e2b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e382
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x250(%rcx)
jne 0x2e3e7
leaq 0xe98f(%rip), %rdi      # 0x3cd0f
jmp 0x2e389
leaq 0xbece(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x15bbe(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xd920(%rip), %rsi      # 0x3bcda
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 0x2e460
movl %eax, %ebx
movq 0x15b60(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2e3dc
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xd8b3(%rip), %rsi      # 0x3bcda
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 0x2e3dc
movb $0x1, 0x250(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x258(%r14)
xorl %ebx, %ebx
jmp 0x2e3dc
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e4ae
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x260(%rcx)
jne 0x2e513
leaq 0xe880(%rip), %rdi      # 0x3cd2c
jmp 0x2e4b5
leaq 0xbda2(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x15a92(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xd845(%rip), %rsi      # 0x3bd2b
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 0x2e58c
movl %eax, %ebx
movq 0x15a34(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2e508
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xd7d8(%rip), %rsi      # 0x3bd2b
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 0x2e508
movb $0x1, 0x260(%r14)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x268(%r14)
xorl %ebx, %ebx
jmp 0x2e508
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e5da
movq %rcx, %r14
incl %eax
movl %eax, (%rdx)
cmpb $0x1, 0x270(%rcx)
jne 0x2e63f
leaq 0xe771(%rip), %rdi      # 0x3cd49
jmp 0x2e5e1
leaq 0xbc76(%rip), %rdi      # 0x3a257
callq 0xa1f0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xa850
movq 0x15966(%rip), %rbx     # 0x43f60
movl $0x0, 0xd670(%rbx)
leaq 0xc6d0(%rbx), %rdi
leaq 0xd76a(%rip), %rsi      # 0x3bd7c
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 0x2e6b8
movl %eax, %ebx
movq 0x15908(%rip), %r14     # 0x43f60
movslq 0xd670(%r14), %rax
cmpq $0x30, %rax
jg 0x2e634
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0xc6d0, %rdi           # imm = 0xC6D0
leaq 0xd6fd(%rip), %rsi      # 0x3bd7c
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 0x2e634
movb $0x1, 0x270(%r14)
movq 0x15899(%rip), %rax     # 0x43f60
movsd -0x18(%rbp), %xmm0
cmpb $0x1, 0x1e6d8(%rax)
jne 0x2e6dd
mulsd 0x692b(%rip), %xmm0     # 0x35008
movsd %xmm0, 0x278(%r14)
xorl %ebx, %ebx
jmp 0x2e634
nop