LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::comp_get_current(setup_struct*, double*, double*, double*)
int Interp::comp_get_current(setup_pointer settings, double *x, double *y, double *z) {
    switch(settings->plane) {
    case CANON_PLANE_XY:
        *x = settings->current_x;
        *y = settings->current_y;
        *z = settings->current_z;
        break;
    case CANON_PLANE_XZ:
        *x = settings->current_z;
        *y = settings->current_x;
        *z = settings->current_y;
        break;
    default:
        ERS("BUG: Invalid plane in comp_get_current");
    }
    return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl 0xc67c(%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x15b35
jmp 0x15b28
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0x15b76
jmp 0x15bb7
movq -0x18(%rbp), %rax
movsd 0x600(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0x608(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0x610(%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x15c81
movq -0x18(%rbp), %rax
movsd 0x610(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0x600(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0x608(%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x15c81
jmp 0x15bb9
movq -0x40(%rbp), %rdi
leaq 0x63430(%rip), %rsi     # 0x78ff4
movb $0x0, %al
callq 0x10df0
movq 0x7138e(%rip), %rax     # 0x86f60
movl $0x0, 0xd670(%rax)
movq 0x7137d(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x7136f(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x63415(%rip), %rsi     # 0x7901b
movl $0x50, %edx
callq 0x10840
movq 0x71349(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x7133b(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x71323(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x71313(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x71306(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x712f8(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x15c88
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::comp_set_current(setup_struct*, double, double, double)
int Interp::comp_set_current(setup_pointer settings, double x, double y, double z) {
    switch(settings->plane) {
    case CANON_PLANE_XY:
        settings->current_x = x;
        settings->current_y = y;
        settings->current_z = z;
        break;
    case CANON_PLANE_XZ:
        settings->current_x = y;
        settings->current_y = z;
        settings->current_z = x;
        break;
    default:
        ERS("BUG: Invalid plane in comp_set_current");
    }
    return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl 0xc67c(%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x15ce5
jmp 0x15cdb
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0x15d1d
jmp 0x15d55
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x600(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x608(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x610(%rax)
jmp 0x15e1f
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x600(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x608(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x610(%rax)
jmp 0x15e1f
jmp 0x15d57
movq -0x40(%rbp), %rdi
leaq 0x63303(%rip), %rsi     # 0x79065
movb $0x0, %al
callq 0x10df0
movq 0x711f0(%rip), %rax     # 0x86f60
movl $0x0, 0xd670(%rax)
movq 0x711df(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x711d1(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x632e8(%rip), %rsi     # 0x7908c
movl $0x50, %edx
callq 0x10840
movq 0x711ab(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x7119d(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x71185(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x71175(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x71168(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x7115a(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x15e26
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::comp_get_programmed(setup_struct*, double*, double*, double*)
int Interp::comp_get_programmed(setup_pointer settings, double *x, double *y, double *z) {
    switch(settings->plane) {
    case CANON_PLANE_XY:
        *x = settings->program_x;
        *y = settings->program_y;
        *z = settings->program_z;
        break;
    case CANON_PLANE_XZ:
        *x = settings->program_z;
        *y = settings->program_x;
        *z = settings->program_y;
        break;
    default:
        ERS("BUG: Invalid plane in comp_get_programmed");
    }
    return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl 0xc67c(%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x15e75
jmp 0x15e68
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0x15eb6
jmp 0x15ef7
movq -0x18(%rbp), %rax
movsd 0xc690(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0xc698(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0xc6a0(%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x15fc1
movq -0x18(%rbp), %rax
movsd 0xc6a0(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0xc690(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd 0xc698(%rax), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x15fc1
jmp 0x15ef9
movq -0x40(%rbp), %rdi
leaq 0x631cc(%rip), %rsi     # 0x790d0
movb $0x0, %al
callq 0x10df0
movq 0x7104e(%rip), %rax     # 0x86f60
movl $0x0, 0xd670(%rax)
movq 0x7103d(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x7102f(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x631b4(%rip), %rsi     # 0x790fa
movl $0x50, %edx
callq 0x10840
movq 0x71009(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x70ffb(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x70fe3(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x70fd3(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x70fc6(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x70fb8(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x15fc8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::comp_set_programmed(setup_struct*, double, double, double)
int Interp::comp_set_programmed(setup_pointer settings, double x, double y, double z) {
    switch(settings->plane) {
    case CANON_PLANE_XY:
        settings->program_x = x;
        settings->program_y = y;
        settings->program_z = z;
        break;
    case CANON_PLANE_XZ:
        settings->program_x = y;
        settings->program_y = z;
        settings->program_z = x;
        break;
    default:
        ERS("BUG: Invalid plane in comp_set_programmed");
    }
    return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl 0xc67c(%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x16025
jmp 0x1601b
movl -0x34(%rbp), %eax
subl $0x3, %eax
je 0x1605d
jmp 0x16095
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0xc690(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0xc698(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0xc6a0(%rax)
jmp 0x1615f
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0xc690(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0xc698(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0xc6a0(%rax)
jmp 0x1615f
jmp 0x16097
movq -0x40(%rbp), %rdi
leaq 0x630a5(%rip), %rsi     # 0x79147
movb $0x0, %al
callq 0x10df0
movq 0x70eb0(%rip), %rax     # 0x86f60
movl $0x0, 0xd670(%rax)
movq 0x70e9f(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x70e91(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x6308d(%rip), %rsi     # 0x79171
movl $0x50, %edx
callq 0x10840
movq 0x70e6b(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x70e5d(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x70e45(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x70e35(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x70e28(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x70e1a(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x16166
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::rotate(double*, double*, double)
void Interp::rotate(double *x, double *y, double theta) {
    double xx, yy;
    double t = D2R(theta);
    xx = *x * cos(t) - *y * sin(t); 
    yy = *x * sin(t) + *y * cos(t);
    *x = xx;
    *y = yy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd 0x59a87(%rip), %xmm0    # 0x78e58
mulsd -0x20(%rbp), %xmm0
movsd 0x59a72(%rip), %xmm1    # 0x78e50
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x12160
movsd %xmm0, -0x60(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x10330
movsd -0x68(%rbp), %xmm1
movsd -0x60(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x58(%rbp), %xmm0
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x10330
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x12160
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x40(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_cutter_compensation_off(setup_struct*)
int Interp::convert_cutter_compensation_off(setup_pointer settings)      //!< pointer to machine settings
{
#ifdef DEBUG_EMC
  enqueue_COMMENT("interpreter: cutter radius compensation off");
#endif
  if(settings->cutter_comp_side != OFF && settings->cutter_comp_radius > 0.0) {
      double cx, cy, cz;
      comp_get_current(settings, &cx, &cy, &cz);
      CHP(move_endpoint_and_flush(settings, cx, cy));
      dequeue_canons(settings);
      settings->current_x = settings->program_x;
      settings->current_y = settings->program_y;
      settings->current_z = settings->program_z;
      settings->arc_not_allowed = ON;
  }
  settings->cutter_comp_side = OFF;
  settings->cutter_comp_firstmove = ON;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x599c2(%rip), %rdi     # 0x79e41
callq 0x11f00
movq -0x18(%rbp), %rax
cmpl $0x0, 0x624(%rax)
je 0x20603
movq -0x18(%rbp), %rax
movsd 0x618(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x20603
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0x12360
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x10c40
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x205a5
jmp 0x204ed
movq 0x66a6c(%rip), %rax     # 0x86f60
cmpl $0x31, 0xd670(%rax)
jge 0x2059d
movq 0x66a58(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x66a4a(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x59942(%rip), %rsi     # 0x79e6d
movl $0x50, %edx
callq 0x10840
movq 0x66a24(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x66a16(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x669fe(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x669ee(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x669e1(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x669d3(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x20623
jmp 0x205a7
movq -0x18(%rbp), %rdi
callq 0x10500
movq -0x18(%rbp), %rax
movsd 0xc690(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x600(%rax)
movq -0x18(%rbp), %rax
movsd 0xc698(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x608(%rax)
movq -0x18(%rbp), %rax
movsd 0xc6a0(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x610(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x110(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x624(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0xc689(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_distance_mode(int, setup_struct*)
int Interp::convert_distance_mode(int g_code,    //!< g_code being executed (must be G_90 or G_91)
                                 setup_pointer settings)        //!< pointer to machine settings                 
{
  if (g_code == G_90) {
    if (settings->distance_mode != MODE_ABSOLUTE) {
#ifdef DEBUG_EMC
      enqueue_COMMENT("interpreter: distance mode changed to absolute");
#endif
      settings->distance_mode = MODE_ABSOLUTE;
    }
  } else if (g_code == G_91) {
    if (settings->distance_mode != MODE_INCREMENTAL) {
#ifdef DEBUG_EMC
      enqueue_COMMENT("interpreter: distance mode changed to incremental");
#endif
      settings->distance_mode = MODE_INCREMENTAL;
    }
  } else
    ERS(NCE_BUG_CODE_NOT_G90_OR_G91);
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x384, -0x14(%rbp)     # imm = 0x384
jne 0x210d0
movq -0x20(%rbp), %rax
cmpl $0x0, 0x668(%rax)
je 0x210cb
leaq 0x58fb9(%rip), %rdi     # 0x7a071
callq 0x11f00
movq -0x20(%rbp), %rax
movl $0x0, 0x668(%rax)
jmp 0x211d9
cmpl $0x38e, -0x14(%rbp)     # imm = 0x38E
jne 0x21105
movq -0x20(%rbp), %rax
cmpl $0x1, 0x668(%rax)
je 0x21100
leaq 0x58fb3(%rip), %rdi     # 0x7a0a0
callq 0x11f00
movq -0x20(%rbp), %rax
movl $0x1, 0x668(%rax)
jmp 0x211d7
jmp 0x21107
leaq 0x58fc4(%rip), %rdi     # 0x7a0d2
callq 0x10380
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x10df0
movq 0x65e38(%rip), %rax     # 0x86f60
movl $0x0, 0xd670(%rax)
movq 0x65e27(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x65e19(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x58f8e(%rip), %rsi     # 0x7a0ea
movl $0x50, %edx
callq 0x10840
movq 0x65df3(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x65de5(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x65dcd(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x65dbd(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x65db0(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x65da2(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x211e0
jmp 0x211d9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_ijk_distance_mode(int, setup_struct*)
int Interp::convert_ijk_distance_mode(int g_code,    //!< g_code being executed (must be G_90_1 or G_91_1)
                                 setup_pointer settings)        //!< pointer to machine settings                 
{
  if (g_code == G_90_1) {
    if (settings->ijk_distance_mode != MODE_ABSOLUTE) {
#ifdef DEBUG_EMC
      enqueue_COMMENT("interpreter: IJK distance mode changed to absolute");
#endif
      settings->ijk_distance_mode = MODE_ABSOLUTE;
    }
  } else if (g_code == G_91_1) {
    if (settings->ijk_distance_mode != MODE_INCREMENTAL) {
#ifdef DEBUG_EMC
      enqueue_COMMENT("interpreter: IJK distance mode changed to incremental");
#endif
      settings->ijk_distance_mode = MODE_INCREMENTAL;
    }
  } else
    ERS(NCE_BUG_CODE_NOT_G90_OR_G91);
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x385, -0x14(%rbp)     # imm = 0x385
jne 0x21240
movq -0x20(%rbp), %rax
cmpl $0x0, 0x66c(%rax)
je 0x2123b
leaq 0x58ef8(%rip), %rdi     # 0x7a120
callq 0x11f00
movq -0x20(%rbp), %rax
movl $0x0, 0x66c(%rax)
jmp 0x21349
cmpl $0x38f, -0x14(%rbp)     # imm = 0x38F
jne 0x21275
movq -0x20(%rbp), %rax
cmpl $0x1, 0x66c(%rax)
je 0x21270
leaq 0x58ef6(%rip), %rdi     # 0x7a153
callq 0x11f00
movq -0x20(%rbp), %rax
movl $0x1, 0x66c(%rax)
jmp 0x21347
jmp 0x21277
leaq 0x58e54(%rip), %rdi     # 0x7a0d2
callq 0x10380
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x10df0
movq 0x65cc8(%rip), %rax     # 0x86f60
movl $0x0, 0xd670(%rax)
movq 0x65cb7(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x65ca9(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x58ebd(%rip), %rsi     # 0x7a189
movl $0x50, %edx
callq 0x10840
movq 0x65c83(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x65c75(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x65c5d(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x65c4d(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x65c40(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x65c32(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x21350
jmp 0x21349
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_spindle_mode(block_struct*, setup_struct*)
int Interp::convert_spindle_mode(block_pointer block, setup_pointer settings)
{
    if(block->g_modes[14] == G_97) {
	enqueue_SET_SPINDLE_MODE(0);
    } else { /* G_96 */
	if(block->d_flag)
	    enqueue_SET_SPINDLE_MODE(block->d_number_float);
	else
	    enqueue_SET_SPINDLE_MODE(1e30);
    }
    return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3ca, 0x188(%rax)     # imm = 0x3CA
jne 0x2f15e
xorps %xmm0, %xmm0
callq 0x10a80
jmp 0x2f18d
movq -0x10(%rbp), %rax
testb $0x1, 0x138(%rax)
je 0x2f17e
movq -0x10(%rbp), %rax
movsd 0x130(%rax), %xmm0
callq 0x10a80
jmp 0x2f18b
movsd 0x49cea(%rip), %xmm0    # 0x78e70
callq 0x10a80
jmp 0x2f18d
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_convert.cc
// Function: Interp::convert_tool_select(block_struct*, setup_struct*)
int Interp::convert_tool_select(block_pointer block,     //!< pointer to a block of RS274 instructions
                               setup_pointer settings)  //!< pointer to machine settings             
{
  int pocket;
  CHP((find_tool_pocket(settings, block->t_number, &pocket)));
  SELECT_POCKET(pocket);
  settings->selected_pocket = pocket;
  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x240(%rax), %edx
leaq -0x24(%rbp), %rcx
callq 0x10f70
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x32fbe
jmp 0x32f06
movq 0x54053(%rip), %rax     # 0x86f60
cmpl $0x31, 0xd670(%rax)
jge 0x32fb6
movq 0x5403f(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x54031(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x48555(%rip), %rsi     # 0x7b499
movl $0x50, %edx
callq 0x10840
movq 0x5400b(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x53ffd(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x53fe5(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x53fd5(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x53fc8(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x53fba(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32fdc
jmp 0x32fc0
movl -0x24(%rbp), %edi
callq 0x11a10
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc6b0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_SET_FEED_RATE(double)
void enqueue_SET_FEED_RATE(double feed) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate set feed rate %f\n", feed);
        SET_FEED_RATE(feed);
        return;
    }
    queued_canon q;
    q.type = QSET_FEED_RATE;
    q.data.set_feed_rate.feed = feed;
    if(debug_qc) printf("enqueue set feed rate %f\n", feed);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x344b3
jmp 0x344db
cmpl $0x0, 0x72556(%rip)     # 0xa6a10
je 0x344cf
movsd -0x8(%rbp), %xmm0
leaq 0x47094(%rip), %rdi     # 0x7b55c
movb $0x1, %al
callq 0x10060
movsd -0x8(%rbp), %xmm0
callq 0x11290
jmp 0x34519
movl $0x3, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
cmpl $0x0, 0x7251d(%rip)     # 0xa6a10
je 0x34508
movsd -0x8(%rbp), %xmm0
leaq 0x47077(%rip), %rdi     # 0x7b578
movb $0x1, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x80(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_DWELL(double)
void enqueue_DWELL(double time) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate dwell %f\n", time);
        DWELL(time);
        return;
    }
    queued_canon q;
    q.type = QDWELL;
    q.data.dwell.time = time;
    if(debug_qc) printf("enqueue dwell %f\n", time);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x34553
jmp 0x3457b
cmpl $0x0, 0x724b6(%rip)     # 0xa6a10
je 0x3456f
movsd -0x8(%rbp), %xmm0
leaq 0x4702a(%rip), %rdi     # 0x7b592
movb $0x1, %al
callq 0x10060
movsd -0x8(%rbp), %xmm0
callq 0x10040
jmp 0x345b9
movl $0x4, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
cmpl $0x0, 0x7247d(%rip)     # 0xa6a10
je 0x345a8
movsd -0x8(%rbp), %xmm0
leaq 0x47005(%rip), %rdi     # 0x7b5a6
movb $0x1, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x80(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_SET_FEED_MODE(int)
void enqueue_SET_FEED_MODE(int mode) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate set feed mode %d\n", mode);
        SET_FEED_MODE(mode);
        return;
    }
    queued_canon q;
    q.type = QSET_FEED_MODE;
    q.data.set_feed_mode.mode = mode;
    if(debug_qc) printf("enqueue set feed mode %d\n", mode);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x345f1
jmp 0x34615
cmpl $0x0, 0x72418(%rip)     # 0xa6a10
je 0x3460b
movl -0x4(%rbp), %esi
leaq 0x46fb4(%rip), %rdi     # 0x7b5b8
movb $0x0, %al
callq 0x10060
movl -0x4(%rbp), %edi
callq 0x11d10
jmp 0x3464d
movl $0x5, -0x80(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x78(%rbp)
cmpl $0x0, 0x723e7(%rip)     # 0xa6a10
je 0x3463c
movl -0x4(%rbp), %esi
leaq 0x46f9f(%rip), %rdi     # 0x7b5d4
movb $0x0, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x80(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_MIST_ON()
void enqueue_MIST_ON(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate mist on\n");
        MIST_ON();
        return;
    }
    queued_canon q;
    q.type = QMIST_ON;
    if(debug_qc) printf("enqueue mist on\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x3467e
jmp 0x3469c
cmpl $0x0, 0x7238b(%rip)     # 0xa6a10
je 0x34695
leaq 0x46f60(%rip), %rdi     # 0x7b5ee
movb $0x0, %al
callq 0x10060
callq 0x11d90
jmp 0x346cb
movl $0x6, -0x78(%rbp)
cmpl $0x0, 0x72366(%rip)     # 0xa6a10
je 0x346ba
leaq 0x46f4e(%rip), %rdi     # 0x7b601
movb $0x0, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x78(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_MIST_OFF()
void enqueue_MIST_OFF(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate mist off\n");
        MIST_OFF();
        return;
    }
    queued_canon q;
    q.type = QMIST_OFF;
    if(debug_qc) printf("enqueue mist off\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x346fe
jmp 0x3471c
cmpl $0x0, 0x7230b(%rip)     # 0xa6a10
je 0x34715
leaq 0x46f04(%rip), %rdi     # 0x7b612
movb $0x0, %al
callq 0x10060
callq 0x10190
jmp 0x3474b
movl $0x7, -0x78(%rbp)
cmpl $0x0, 0x722e6(%rip)     # 0xa6a10
je 0x3473a
leaq 0x46ef3(%rip), %rdi     # 0x7b626
movb $0x0, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x78(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_FLOOD_ON()
void enqueue_FLOOD_ON(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate flood on\n");
        FLOOD_ON();
        return;
    }
    queued_canon q;
    q.type = QFLOOD_ON;
    if(debug_qc) printf("enqueue flood on\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x3477e
jmp 0x3479c
cmpl $0x0, 0x7228b(%rip)     # 0xa6a10
je 0x34795
leaq 0x46eaa(%rip), %rdi     # 0x7b638
movb $0x0, %al
callq 0x10060
callq 0x10d40
jmp 0x347cb
movl $0x8, -0x78(%rbp)
cmpl $0x0, 0x72266(%rip)     # 0xa6a10
je 0x347ba
leaq 0x46e99(%rip), %rdi     # 0x7b64c
movb $0x0, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x78(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_FLOOD_OFF()
void enqueue_FLOOD_OFF(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate flood on\n");
        FLOOD_OFF();
        return;
    }
    queued_canon q;
    q.type = QFLOOD_OFF;
    if(debug_qc) printf("enqueue flood off\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x347fe
jmp 0x3481c
cmpl $0x0, 0x7220b(%rip)     # 0xa6a10
je 0x34815
leaq 0x46e2a(%rip), %rdi     # 0x7b638
movb $0x0, %al
callq 0x10060
callq 0x10b90
jmp 0x3484b
movl $0x9, -0x78(%rbp)
cmpl $0x0, 0x721e6(%rip)     # 0xa6a10
je 0x3483a
leaq 0x46e2b(%rip), %rdi     # 0x7b65e
movb $0x0, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x78(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_START_SPINDLE_CLOCKWISE()
void enqueue_START_SPINDLE_CLOCKWISE(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate spindle clockwise\n");
        START_SPINDLE_CLOCKWISE();
        return;
    }
    queued_canon q;
    q.type = QSTART_SPINDLE_CLOCKWISE;
    if(debug_qc) printf("enqueue spindle clockwise\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x3487e
jmp 0x3489c
cmpl $0x0, 0x7218b(%rip)     # 0xa6a10
je 0x34895
leaq 0x46de3(%rip), %rdi     # 0x7b671
movb $0x0, %al
callq 0x10060
callq 0x112f0
jmp 0x348cb
movl $0xa, -0x78(%rbp)
cmpl $0x0, 0x72166(%rip)     # 0xa6a10
je 0x348ba
leaq 0x46ddb(%rip), %rdi     # 0x7b68e
movb $0x0, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x78(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_START_SPINDLE_COUNTERCLOCKWISE()
void enqueue_START_SPINDLE_COUNTERCLOCKWISE(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate spindle counterclockwise\n");
        START_SPINDLE_COUNTERCLOCKWISE();
        return;
    }
    queued_canon q;
    q.type = QSTART_SPINDLE_COUNTERCLOCKWISE;
    if(debug_qc) printf("enqueue spindle counterclockwise\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x348fe
jmp 0x3491c
cmpl $0x0, 0x7210b(%rip)     # 0xa6a10
je 0x34915
leaq 0x46d9b(%rip), %rdi     # 0x7b6a9
movb $0x0, %al
callq 0x10060
callq 0x118b0
jmp 0x3494b
movl $0xb, -0x78(%rbp)
cmpl $0x0, 0x720e6(%rip)     # 0xa6a10
je 0x3493a
leaq 0x46d9a(%rip), %rdi     # 0x7b6cd
movb $0x0, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x78(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_STOP_SPINDLE_TURNING()
void enqueue_STOP_SPINDLE_TURNING(void) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate spindle stop\n");
        STOP_SPINDLE_TURNING();
        return;
    }
    queued_canon q;
    q.type = QSTOP_SPINDLE_TURNING;
    if(debug_qc) printf("enqueue spindle stop\n");
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x3497e
jmp 0x3499c
cmpl $0x0, 0x7208b(%rip)     # 0xa6a10
je 0x34995
leaq 0x46d61(%rip), %rdi     # 0x7b6ef
movb $0x0, %al
callq 0x10060
callq 0x11300
jmp 0x349cb
movl $0xc, -0x78(%rbp)
cmpl $0x0, 0x72066(%rip)     # 0xa6a10
je 0x349ba
leaq 0x46d54(%rip), %rdi     # 0x7b707
movb $0x0, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x78(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_SET_SPINDLE_MODE(double)
void enqueue_SET_SPINDLE_MODE(double mode) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate spindle mode %f\n", mode);
        SET_SPINDLE_MODE(mode);
        return;
    }
    queued_canon q;
    q.type = QSET_SPINDLE_MODE;
    q.data.set_spindle_mode.mode = mode;
    if(debug_qc) printf("enqueue spindle mode %f\n", mode);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x34a03
jmp 0x34a2b
cmpl $0x0, 0x72006(%rip)     # 0xa6a10
je 0x34a1f
movsd -0x8(%rbp), %xmm0
leaq 0x46d05(%rip), %rdi     # 0x7b71d
movb $0x1, %al
callq 0x10060
movsd -0x8(%rbp), %xmm0
callq 0x112c0
jmp 0x34a69
movl $0xd, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
cmpl $0x0, 0x71fcd(%rip)     # 0xa6a10
je 0x34a58
movsd -0x8(%rbp), %xmm0
leaq 0x46ce7(%rip), %rdi     # 0x7b738
movb $0x1, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x80(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_SET_SPINDLE_SPEED(double)
void enqueue_SET_SPINDLE_SPEED(double speed) {
    if(qc().empty()) {
    if(debug_qc) printf("immediate set spindle speed %f\n", speed);
        SET_SPINDLE_SPEED(speed);
        return;
    }
    queued_canon q;
    q.type = QSET_SPINDLE_SPEED;
    q.data.set_spindle_speed.speed = speed;
    if(debug_qc) printf("enqueue set spindle speed %f\n", speed);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x34aa3
jmp 0x34acb
cmpl $0x0, 0x71f66(%rip)     # 0xa6a10
je 0x34abf
movsd -0x8(%rbp), %xmm0
leaq 0x46c99(%rip), %rdi     # 0x7b751
movb $0x1, %al
callq 0x10060
movsd -0x8(%rbp), %xmm0
callq 0x10790
jmp 0x34b09
movl $0xe, -0x80(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
cmpl $0x0, 0x71f2d(%rip)     # 0xa6a10
je 0x34af8
movsd -0x8(%rbp), %xmm0
leaq 0x46c80(%rip), %rdi     # 0x7b771
movb $0x1, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x80(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_COMMENT(char*)
void enqueue_COMMENT(char *c) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate comment \"%s\"\n", c);
        COMMENT(c);
        return;
    }
    queued_canon q;
    q.type = QCOMMENT;
    q.data.comment.comment = strdup(c);
    if(debug_qc) printf("enqueue comment \"%s\"\n", c);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x34b42
jmp 0x34b68
cmpl $0x0, 0x71ec7(%rip)     # 0xa6a10
je 0x34b5d
movq -0x8(%rbp), %rsi
leaq 0x46c39(%rip), %rdi     # 0x7b78f
movb $0x0, %al
callq 0x10060
movq -0x8(%rbp), %rdi
callq 0x10d60
jmp 0x34ba8
movl $0xf, -0x80(%rbp)
movq -0x8(%rbp), %rdi
callq 0x120d0
movq %rax, -0x78(%rbp)
cmpl $0x0, 0x71e8d(%rip)     # 0xa6a10
je 0x34b97
movq -0x8(%rbp), %rsi
leaq 0x46c17(%rip), %rdi     # 0x7b7a7
movb $0x0, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x80(%rbp), %rsi
callq 0x10320
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_ARC_FEED(setup_struct*, int, double, double, double, double, double, int, double, double, double, double, double, double, double)
void enqueue_ARC_FEED(setup_pointer settings, int l, 
                      double original_turns,
                      double end1, double end2, double center1, double center2,
                      int turn,
                      double end3,
                      double a, double b, double c,
                      double u, double v, double w) {
    queued_canon q;

    q.type = QARC_FEED;
    q.data.arc_feed.line_number = l;
    q.data.arc_feed.original_turns = original_turns;
    q.data.arc_feed.end1 = end1;
    q.data.arc_feed.end2 = end2;
    q.data.arc_feed.center1 = center1;
    q.data.arc_feed.center2 = center2;
    q.data.arc_feed.turn = turn;
    q.data.arc_feed.end3 = end3;
    q.data.arc_feed.a = a;
    q.data.arc_feed.b = b;
    q.data.arc_feed.c = c;
    q.data.arc_feed.u = u;
    q.data.arc_feed.v = v;
    q.data.arc_feed.w = w;

    if(debug_qc) printf("enqueue arc lineno %d to %f %f center %f %f turn %d sweeping %f\n", l, end1, end2, center1, center2, turn, original_turns);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movsd 0x28(%rbp), %xmm8
movsd 0x20(%rbp), %xmm8
movsd 0x18(%rbp), %xmm8
movsd 0x10(%rbp), %xmm8
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movl %edx, -0x3c(%rbp)
movsd %xmm5, -0x48(%rbp)
movsd %xmm6, -0x50(%rbp)
movsd %xmm7, -0x58(%rbp)
movl $0x2, -0xd0(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xc8(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x98(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x88(%rbp)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd 0x10(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movsd 0x18(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd 0x20(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd 0x28(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
cmpl $0x0, 0x719ab(%rip)     # 0xa6a10
je 0x35094
movl -0xc(%rbp), %esi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm3
movl -0x3c(%rbp), %edx
movsd -0x18(%rbp), %xmm4
leaq 0x467b4(%rip), %rdi     # 0x7b841
movb $0x5, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0xd0(%rbp), %rsi
callq 0x10320
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: enqueue_M_USER_COMMAND(int, double, double)
void enqueue_M_USER_COMMAND (int index, double p_number, double q_number) {
    if(qc().empty()) {
        if(debug_qc) printf("immediate M_USER_COMMAND index=%d p=%f q=%f\n",
                           index,p_number,q_number);
        (*(USER_DEFINED_FUNCTION[index - 100])) (index - 100,p_number,q_number);
        return;
    }
    queued_canon q;
    q.type = QM_USER_COMMAND;
    q.data.mcommand.index    = index;
    q.data.mcommand.p_number = p_number;
    q.data.mcommand.q_number = q_number;
    if(debug_qc) printf("enqueue M_USER_COMMAND index=%d p=%f q=%f\n",
                        index,p_number,q_number);
    qc().push_back(q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
callq 0x103d0
movq %rax, %rdi
callq 0x11220
testb $0x1, %al
jne 0x350eb
jmp 0x35137
cmpl $0x0, 0x7191e(%rip)     # 0xa6a10
je 0x3510f
movl -0x4(%rbp), %esi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
leaq 0x4677a(%rip), %rdi     # 0x7b882
movb $0x2, %al
callq 0x10060
movl -0x4(%rbp), %eax
subl $0x64, %eax
movslq %eax, %rcx
movq 0x51eb9(%rip), %rax     # 0x86fd8
movq (%rax,%rcx,8), %rax
movl -0x4(%rbp), %edi
subl $0x64, %edi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq *%rax
jmp 0x35196
movl $0x10, -0x90(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x88(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
cmpl $0x0, 0x718ab(%rip)     # 0xa6a10
je 0x35182
movl -0x4(%rbp), %esi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
leaq 0x46734(%rip), %rdi     # 0x7b8af
movb $0x2, %al
callq 0x10060
callq 0x103d0
movq %rax, %rdi
leaq -0x90(%rbp), %rsi
callq 0x10320
addq $0x90, %rsp
popq %rbp
retq
nop
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: latheorigin_z(setup_struct*, double)
static double latheorigin_z(setup_pointer settings, double z) {
    int o = settings->cutter_comp_orientation;
    double r = settings->cutter_comp_radius;
    if(settings->plane != CANON_PLANE_XZ) return z;

    if(o==2 || o==7 || o==3) z -= r;
    if(o==1 || o==5 || o==4) z += r;
    return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x620(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsd 0x618(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0xc67c(%rax)
je 0x35a04
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x35a54
cmpl $0x2, -0x1c(%rbp)
je 0x35a16
cmpl $0x7, -0x1c(%rbp)
je 0x35a16
cmpl $0x3, -0x1c(%rbp)
jne 0x35a29
movsd -0x28(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
cmpl $0x1, -0x1c(%rbp)
je 0x35a3b
cmpl $0x5, -0x1c(%rbp)
je 0x35a3b
cmpl $0x4, -0x1c(%rbp)
jne 0x35a4a
movsd -0x28(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_queue.cc
// Function: latheorigin_x(setup_struct*, double)
static double latheorigin_x(setup_pointer settings, double x) {
    int o = settings->cutter_comp_orientation;
    double r = settings->cutter_comp_radius;
    if(settings->plane != CANON_PLANE_XZ) return x;

    if(o==2 || o==6 || o==1) x -= r;
    if(o==3 || o==8 || o==4) x += r;
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x620(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsd 0x618(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0xc67c(%rax)
je 0x35aa4
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x35af4
cmpl $0x2, -0x1c(%rbp)
je 0x35ab6
cmpl $0x6, -0x1c(%rbp)
je 0x35ab6
cmpl $0x1, -0x1c(%rbp)
jne 0x35ac9
movsd -0x28(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
cmpl $0x3, -0x1c(%rbp)
je 0x35adb
cmpl $0x8, -0x1c(%rbp)
je 0x35adb
cmpl $0x4, -0x1c(%rbp)
jne 0x35aea
movsd -0x28(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: sundale[P]gcode/rs274ngc/interp_cycles.cc
// Function: Interp::convert_cycle_g82(block_struct*, int, double, double, double, double, double)
int Interp::convert_cycle_g82(block_pointer block,
                              CANON_PLANE plane, //!< selected plane                  
                              double x,  //!< x-value where cycle is executed 
                              double y,  //!< y-value where cycle is executed 
                              double clear_z,    //!< z-value of clearance plane      
                              double bottom_z,   //!< value of z at bottom of cycle   
                              double dwell)      //!< dwell time                      
{
  cycle_feed(block, plane, x, y, bottom_z);
  DWELL(dwell);
  cycle_traverse(block, plane, x, y, clear_z);

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm3, -0x38(%rbp)
movsd %xmm4, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
callq 0x10290
movsd -0x40(%rbp), %xmm0
callq 0x10040
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
callq 0x11bf0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
// File: sundale[P]gcode/rs274ngc/interp_cycles.cc
// Function: Interp::convert_cycle_g86(block_struct*, int, double, double, double, double, double, int)
int Interp::convert_cycle_g86(block_pointer block,
                              CANON_PLANE plane, //!< selected plane                     
                              double x,  //!< x-value where cycle is executed    
                              double y,  //!< y-value where cycle is executed    
                              double clear_z,    //!< z-value of clearance plane         
                              double bottom_z,   //!< value of z at bottom of cycle      
                              double dwell,      //!< dwell time                         
                              CANON_DIRECTION direction) //!< direction spindle turning at outset
{
  CHKS(((direction != CANON_CLOCKWISE) &&
       (direction != CANON_COUNTERCLOCKWISE)),
      NCE_SPINDLE_NOT_TURNING_IN_G86);

  cycle_feed(block, plane, x, y, bottom_z);
  DWELL(dwell);
  STOP_SPINDLE_TURNING();
  cycle_traverse(block, plane, x, y, clear_z);
  if (direction == CANON_CLOCKWISE)
    START_SPINDLE_CLOCKWISE();
  else
    START_SPINDLE_COUNTERCLOCKWISE();

  return INTERP_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd %xmm1, -0x30(%rbp)
movsd %xmm2, -0x38(%rbp)
movsd %xmm3, -0x40(%rbp)
movsd %xmm4, -0x48(%rbp)
movl %ecx, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpl $0x2, -0x4c(%rbp)
je 0x37fcd
cmpl $0x3, -0x4c(%rbp)
je 0x37fcd
jmp 0x37efd
leaq 0x43fde(%rip), %rdi     # 0x7bee2
callq 0x10380
movq -0x58(%rbp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x10df0
movq 0x4f042(%rip), %rax     # 0x86f60
movl $0x0, 0xd670(%rax)
movq 0x4f031(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rax
movq 0x4f023(%rip), %rdi     # 0x86f60
addq $0xc6d0, %rdi           # imm = 0xC6D0
imulq $0x50, %rax, %rax
addq %rax, %rdi
leaq 0x43fab(%rip), %rsi     # 0x7befd
movl $0x50, %edx
callq 0x10840
movq 0x4effd(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x4efef(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x4f(%rax)
movq 0x4efd7(%rip), %rax     # 0x86f60
movl 0xd670(%rax), %ecx
addl $0x1, %ecx
movq 0x4efc7(%rip), %rax     # 0x86f60
movl %ecx, 0xd670(%rax)
movq 0x4efba(%rip), %rax     # 0x86f60
movslq 0xd670(%rax), %rcx
movq 0x4efac(%rip), %rax     # 0x86f60
addq $0xc6d0, %rax           # imm = 0xC6D0
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
movl $0x5, -0x4(%rbp)
jmp 0x38035
jmp 0x37fcf
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x40(%rbp), %xmm2
callq 0x10290
movsd -0x48(%rbp), %xmm0
callq 0x10040
callq 0x11300
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
callq 0x11bf0
cmpl $0x2, -0x4c(%rbp)
jne 0x38029
callq 0x112f0
jmp 0x3802e
callq 0x118b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop