LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: revert_segment(unsigned char)
void revert_segment(u08 segment)
{
   if(read_only) return;
   if(luxor) return;
   if(rcvr_type != TSIP_RCVR) return;

   send_tsip_start(0x8E);
   send_byte(0x45);
   send_byte(segment);
   send_tsip_end();
}

// Assembly:
leaq 0x2cc732(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x6a935
leaq 0x1d464a(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x6a935
leaq 0x1adfd0(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x6a935
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x8e, %edi
callq 0x5e740
movl $0x45, %edi
callq 0x591af
movzbl %bl, %edi
callq 0x591af
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5e7c0
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_osc_sense()
void request_osc_sense()
{
   if(luxor) return;
   if(no_poll) return;
   if(res_t) return;
   if(rcvr_type != TSIP_RCVR) return;
   if(ACU_GG) return;
   if(ACU_360) return;
   if(ACUTIME) return;
   if(PALISADE) return;
   if(SV6_FAMILY) return;

   send_tsip_start(0x8E);  // not available on ThunderBolt-E or early ThunderBolts
   send_byte(0xA1);
   send_tsip_end();
}

// Assembly:
leaq 0x1d4601(%rip), %rax    # 0x23ef3e
leaq 0x2cc6dc(%rip), %rcx    # 0x337020
movb (%rcx), %cl
orb (%rax), %cl
leaq 0x1adfb5(%rip), %rax    # 0x218904
orb (%rax), %cl
setne %al
leaq 0x1adf75(%rip), %rcx    # 0x2188d0
movq (%rcx), %rcx
cmpq $0x1, %rcx
setne %dl
orb %al, %dl
jne 0x6a9c8
leaq 0x1b0664(%rip), %rax    # 0x21afd4
movl (%rax), %eax
movl %eax, %esi
xorl $0x41, %esi
leaq 0x1adf7a(%rip), %rdx    # 0x2188f8
movl (%rdx), %edx
movl %edx, %edi
xorl $0x47, %edi
orl %esi, %edi
je 0x6a9c8
cmpl $0x41, %eax
jne 0x6a998
cmpl $0x33, %edx
je 0x6a9c8
cmpl $0x47, %edx
je 0x6a9c8
cmpl $0x41, %eax
sete %dl
cmpl $0x50, %eax
sete %sil
cmpq $0x1, %rcx
jne 0x6a9b0
orb %sil, %dl
jne 0x6a9c8
cmpq $0x1, %rcx
jne 0x6a9c9
addl $-0x33, %eax
cmpl $0x1d, %eax
ja 0x6a9c9
movl $0x20004009, %ecx       # imm = 0x20004009
btl %eax, %ecx
jae 0x6a9c9
retq
pushq %rbp
movq %rsp, %rbp
movl $0x8e, %edi
callq 0x5e740
movl $0xa1, %edi
callq 0x591af
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_ubx_tp5(int)
void request_ubx_tp5(int chan)
{
   if(no_poll) return;

   send_ubx_start(UBX_TP5, 1);
   send_byte(chan);
   send_ubx_end();
}

// Assembly:
leaq 0x2cc333(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
je 0x6acf3
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x631, %edi            # imm = 0x631
movl $0x1, %esi
callq 0x5f3f5
movzbl %bl, %edi
callq 0x591af
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5f4ce
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rftg_cable(double)
void set_rftg_cable(double delay)
{
   if(read_only) return;

   delay *= 1.0E9;
   delay *= VELOCITY_FACTOR;  // assumed velocity factor

   start_rftg_request(1);

   send_rftg_start(0x35);
   send_byte(1);   // 1=set?
   send_single((float) delay);
   send_rftg_end();
   set_rftg_normal();
}

// Assembly:
leaq 0x2cb612(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6ba0e
retq
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
mulsd 0x9d60a(%rip), %xmm0    # 0x109028
mulsd 0x9ff4a(%rip), %xmm0    # 0x10b970
movsd %xmm0, -0x8(%rbp)
movl $0x35, %edi
callq 0x5e740
movl $0x1, %edi
callq 0x591af
xorps %xmm0, %xmm0
cvtsd2ss -0x8(%rbp), %xmm0
callq 0x59440
callq 0x5e7c0
xorl %edi, %edi
callq 0x655b0
movl $0x45, %edi
callq 0x5e740
addq $0x10, %rsp
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rftg_offset(double)
void set_rftg_offset(double val)
{
   // pps offset - in nanoseconds
   if(read_only) return;

   val = (val / 1000.0);   // convert nanoseconds to microseconds
   if(val >= 0.0) set_rftg_advance((float) val);
   else           set_rftg_delay((float) (0.0-val));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2cb5a3(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6ba7e
popq %rbp
retq
divsd 0x9d5b2(%rip), %xmm0    # 0x109038
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x6baa1
subsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
popq %rbp
jmp 0x891aa
cvtsd2ss %xmm0, %xmm0
popq %rbp
jmp 0x89161
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_x72_creg(int)
void set_x72_creg(int val)
{
   // set the X72 control reg value
   if(read_only) return;


   val &= 0xFFFF;
   sprintf(out, "q%04X", val);
   queue_x72_cmd(out, X72_SET_CREG_MSG);
}

// Assembly:
leaq 0x2cb398(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6bc88
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movzwl %di, %edx
leaq 0x2d0588(%rip), %rbx    # 0x33c220
leaq 0xb81b3(%rip), %rsi     # 0x123e52
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x2c6, %esi            # imm = 0x2C6
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ee52
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_pps_source(int)
void set_pps_source(int source)
{
   if(read_only) return;

   if(rcvr_type == TM4_RCVR) {
      sprintf(out, "#24,%d", source);
      send_tm4_cmd(out);
   }
}

// Assembly:
leaq 0x2cb137(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x6bf2c
leaq 0x1ac9e1(%rip), %rax    # 0x2188d0
movabsq $0x400000000, %rcx      # imm = 0x400000000
cmpq %rcx, (%rax)
jne 0x6bf2c
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
leaq 0x2d0313(%rip), %rbx    # 0x33c220
leaq 0xb51b1(%rip), %rsi     # 0x1210c5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5f1e8
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_time_code(char)
void set_time_code(char mode)
{
   // set time code output format
   if(read_only) return;

   if(rcvr_type == BRANDY_RCVR) {
      if(mode == 'D') {  // enable digital time code
         sprintf(out, "$PRCCG,E,X,1,X,X");
      }
      else {
         sprintf(out, "$PRCCG,E,%c,X,X,X", mode);
      }
      queue_brandy_cmd(out, BRANDY_CODE_MSG);
   }
   else if(rcvr_type == TM4_RCVR) {
      if     (mode == '0') send_tm4_cmd("#16,0"); // IRIG
      else if(mode == '1') send_tm4_cmd("#16,1"); // NASA36
   }
}

// Assembly:
leaq 0x2cb0e6(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6bf3a
retq
leaq 0x1ac98f(%rip), %rax    # 0x2188d0
movq (%rax), %rax
movabsq $0x400000000, %rcx      # imm = 0x400000000
cmpq %rcx, %rax
je 0x6bf7c
cmpq $0x40000, %rax          # imm = 0x40000
jne 0x6bf39
pushq %rbp
movq %rsp, %rbp
cmpb $0x44, %dil
jne 0x6bf96
movups 0xb5160(%rip), %xmm0    # 0x1210cc
leaq 0x2d02ad(%rip), %rax    # 0x33c220
movaps %xmm0, (%rax)
movb $0x0, 0x10(%rax)
jmp 0x6bfaf
movsbl %dil, %eax
cmpl $0x31, %eax
je 0x6bfc1
cmpl $0x30, %eax
jne 0x6bf39
leaq 0xb515e(%rip), %rdi     # 0x1210ef
jmp 0x5f1e8
movsbl %dil, %edx
leaq 0x2d027f(%rip), %rdi    # 0x33c220
leaq 0xb5135(%rip), %rsi     # 0x1210dd
xorl %eax, %eax
callq 0x9060
leaq 0x2d026a(%rip), %rdi    # 0x33c220
movl $0x192, %esi            # imm = 0x192
popq %rbp
jmp 0x5ee52
leaq 0xb512d(%rip), %rdi     # 0x1210f5
jmp 0x5f1e8
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_timeport_format(int)
void set_timeport_format(int format)
{
   if(read_only) return;

   if(rcvr_type == TM4_RCVR) {
      sprintf(out, "#15,%d", format);
      send_tm4_cmd(out);
   }
}

// Assembly:
leaq 0x2cb046(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x6c01d
leaq 0x1ac8f0(%rip), %rax    # 0x2188d0
movabsq $0x400000000, %rcx      # imm = 0x400000000
cmpq %rcx, (%rax)
jne 0x6c01d
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
leaq 0x2d0222(%rip), %rbx    # 0x33c220
leaq 0xb50f6(%rip), %rsi     # 0x1210fb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5f1e8
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_pps_mode()
void request_pps_mode()
{
   if(read_only) return;    // !!!Resolution-T, RES360 only
   if(no_poll) return;
   if(luxor) return;
   if(saw_ntpx) return;

   if(rcvr_type == BRANDY_RCVR) {
      queue_brandy_cmd("c", BRANDY_PULSE_MSG);
      queue_brandy_cmd("e", BRANDY_CODE_MSG);
   }
   else if(rcvr_type == FURUNO_RCVR) {
   }
   else if(rcvr_type == MOTO_RCVR) {
      send_moto_start("Gc");
      send_byte(0xFF);
      send_moto_end();

      send_moto_start("AP");   // get pps rate
      send_byte(0xFF);
      send_moto_end();
   }
   else if(rcvr_type == TSIP_RCVR) {
      if(ACU_GG) ;
      else if(ACU_360) ;
      else if(ACUTIME) ;
      else if(PALISADE) return;
      else if(SV6_FAMILY) return;
      send_tsip_start(0x8E);
      send_byte(0x4E);
      send_tsip_end();
   }
   else if(rcvr_type == UBX_RCVR) {
      if(saw_ubx_tp5) request_ubx_tp5(0);
      else            request_ubx_msg(UBX_PPS);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2caff1(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x6c1ab
leaq 0x2cafe7(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x6c1ab
leaq 0x1d2ef5(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x6c1ab
leaq 0x1d2ee3(%rip), %rax    # 0x23ef3c
cmpb $0x0, (%rax)
jne 0x6c1ab
leaq 0x1ac867(%rip), %rax    # 0x2188d0
movq (%rax), %rax
cmpq $0x1f, %rax
jg 0x6c09a
cmpq $0x1, %rax
je 0x6c0d3
cmpq $0x4, %rax
jne 0x6c1ab
leaq 0x2a13a3(%rip), %rax    # 0x30d42c
cmpl $0x0, (%rax)
je 0x6c166
xorl %edi, %edi
popq %rbp
jmp 0x6ace6
cmpq $0x20, %rax
je 0x6c12f
cmpq $0x40000, %rax          # imm = 0x40000
jne 0x6c1ab
leaq 0xc1960(%rip), %rdi     # 0x12da17
movl $0x191, %esi            # imm = 0x191
callq 0x5ee52
leaq 0xa4af9(%rip), %rdi     # 0x110bc1
movl $0x192, %esi            # imm = 0x192
popq %rbp
jmp 0x5ee52
leaq 0x1aeefa(%rip), %rcx    # 0x21afd4
movl (%rcx), %ecx
movl %ecx, %esi
xorl $0x41, %esi
leaq 0x1ac810(%rip), %rdx    # 0x2188f8
movl (%rdx), %edx
movl %edx, %edi
xorl $0x47, %edi
orl %esi, %edi
je 0x6c115
cmpl $0x41, %ecx
jne 0x6c102
cmpl $0x33, %edx
je 0x6c115
cmpl $0x47, %edx
je 0x6c115
cmpl $0x41, %ecx
sete %dl
cmpq $0x1, %rax
sete %sil
testb %dl, %sil
je 0x6c178
movl $0x8e, %edi
callq 0x5e740
movl $0x4e, %edi
callq 0x591af
popq %rbp
jmp 0x5e7c0
leaq 0xb4dc3(%rip), %rdi     # 0x120ef9
callq 0x61694
movl $0xff, %edi
callq 0x591af
callq 0x6170f
leaq 0x9ea71(%rip), %rdi     # 0x10abc2
callq 0x61694
movl $0xff, %edi
callq 0x591af
popq %rbp
jmp 0x6170f
movl $0x607, %edi            # imm = 0x607
xorl %esi, %esi
callq 0x5f3f5
popq %rbp
jmp 0x5f4ce
cmpq $0x1, %rax
sete %dl
cmpl $0x50, %ecx
sete %sil
testb %sil, %dl
jne 0x6c1ab
cmpq $0x1, %rax
jne 0x6c115
addl $-0x33, %ecx
cmpl $0x1d, %ecx
ja 0x6c115
movl $0x20004009, %eax       # imm = 0x20004009
btl %ecx, %eax
jae 0x6c115
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_pps_width()
void request_pps_width()
{
   if(read_only) return;    // !!!Which receivers can do this?
   if(no_poll) return;
   if(luxor) return;

   if(rcvr_type == BRANDY_RCVR) {
      queue_brandy_cmd("c", BRANDY_PULSE_MSG);
      queue_brandy_cmd("e", BRANDY_CODE_MSG);
   }
   else if(rcvr_type == NVS_RCVR) {
      send_nvs_start(0xD7);
      send_byte(0x05);
      send_nvs_end();
   }
   else if(rcvr_type == TSIP_RCVR) {
      if(ACU_GG) ;
      else if(ACU_360) ;
      else if(ACUTIME) ;
      else if(PALISADE) return;
      else if(SV6_FAMILY) return;
      send_tsip_start(0x8E);
      send_byte(0x4F);
      send_tsip_end();
   }
   else if(rcvr_type == UBX_RCVR) {
      if(saw_ubx_tp5) request_ubx_tp5(0);
      else            request_ubx_msg(UBX_PPS);
   }
   else if(rcvr_type == ZYFER_RCVR) {
      send_zyfer_cmd("$PULW");
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2cae62(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x6c31a
leaq 0x2cae58(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x6c31a
leaq 0x1d2d66(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x6c31a
leaq 0x1ac6e8(%rip), %rax    # 0x2188d0
movq (%rax), %rax
cmpq $0x7ff, %rax            # imm = 0x7FF
jle 0x6c232
cmpq $0x800, %rax            # imm = 0x800
je 0x6c25a
cmpq $0x100000, %rax         # imm = 0x100000
je 0x6c274
cmpq $0x40000, %rax          # imm = 0x40000
jne 0x6c31a
leaq 0xc1801(%rip), %rdi     # 0x12da17
movl $0x191, %esi            # imm = 0x191
callq 0x5ee52
leaq 0xa499a(%rip), %rdi     # 0x110bc1
movl $0x192, %esi            # imm = 0x192
popq %rbp
jmp 0x5ee52
cmpq $0x1, %rax
je 0x6c281
cmpq $0x4, %rax
jne 0x6c31a
leaq 0x2a11e3(%rip), %rax    # 0x30d42c
cmpl $0x0, (%rax)
je 0x6c2dd
xorl %edi, %edi
popq %rbp
jmp 0x6ace6
movl $0xd7, %edi
callq 0x5e740
movl $0x5, %edi
callq 0x591af
popq %rbp
jmp 0x5e844
leaq 0xb4e88(%rip), %rdi     # 0x121103
popq %rbp
jmp 0x5f15d
leaq 0x1aed4c(%rip), %rcx    # 0x21afd4
movl (%rcx), %ecx
movl %ecx, %esi
xorl $0x41, %esi
leaq 0x1ac662(%rip), %rdx    # 0x2188f8
movl (%rdx), %edx
movl %edx, %edi
xorl $0x47, %edi
orl %esi, %edi
je 0x6c2c3
cmpl $0x41, %ecx
jne 0x6c2b0
cmpl $0x33, %edx
je 0x6c2c3
cmpl $0x47, %edx
je 0x6c2c3
cmpl $0x41, %ecx
sete %dl
cmpq $0x1, %rax
sete %sil
testb %dl, %sil
je 0x6c2ef
movl $0x8e, %edi
callq 0x5e740
movl $0x4f, %edi
callq 0x591af
popq %rbp
jmp 0x5e7c0
movl $0x607, %edi            # imm = 0x607
xorl %esi, %esi
callq 0x5f3f5
popq %rbp
jmp 0x5f4ce
cmpq $0x1, %rax
sete %dl
cmpl $0x50, %ecx
sete %sil
testb %sil, %dl
jne 0x6c31a
cmpq $0x1, %rax
jne 0x6c2c3
addl $-0x33, %ecx
cmpl $0x1d, %ecx
ja 0x6c2c3
movl $0x20004009, %eax       # imm = 0x20004009
btl %ecx, %eax
jae 0x6c2c3
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: x72_fw_discipline()
int x72_fw_discipline()
{
   // returns true if the X72 supports firmware PPS disciplining
   if(rcvr_type != X72_RCVR) return 0;

   if(1 && have_x72_fw_dis) {  // use "j" command results to determine capability
      if(x72_type == X72_TYPE)  return 72;
      if(x72_type == X99_TYPE)  return 99;   // !!!!! what X99 firmware supports pps disciplining?
      if(x72_type == SA22_TYPE) return 22;
      return 1;
   }

   if(1 && have_x72_type) {  // use firmware rev to determine capability
      if((x72_type == X72_TYPE) && (x72_fw >= 5.02)) return -72;
      if((x72_type == X99_TYPE) && (x72_fw >= 5.02)) return -99;   // !!!!! what X99 firmware supports pps disciplining?
      if((x72_type == SA22_TYPE) && (x72_fw >= 6.05)) return -22;
   }

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1abcb1(%rip), %rcx    # 0x2188d0
xorl %eax, %eax
cmpq $0x2000000, (%rcx)      # imm = 0x2000000
jne 0x6ccb7
leaq 0x1ae0df(%rip), %rax    # 0x21ad14
cmpl $0x0, (%rax)
je 0x6cc5a
leaq 0x1ae0ff(%rip), %rax    # 0x21ad40
movl (%rax), %ecx
movl $0x1, %eax
cmpq $0x4, %rcx
jae 0x6ccb7
leaq 0xb1dfb(%rip), %rax     # 0x11ea50
movl (%rax,%rcx,4), %eax
jmp 0x6ccb7
leaq 0x1ae07f(%rip), %rax    # 0x21ace0
cmpl $0x0, (%rax)
je 0x6ccb5
leaq 0x1ae0d3(%rip), %rax    # 0x21ad40
movl (%rax), %ecx
leaq 0x1ae132(%rip), %rax    # 0x21ada8
movsd (%rax), %xmm0
testl %ecx, %ecx
jne 0x6cc8d
movl $0xffffffb8, %eax       # imm = 0xFFFFFFB8
ucomisd 0xb14ad(%rip), %xmm0    # 0x11e138
jae 0x6ccb7
cmpl $0x3, %ecx
jne 0x6cca1
movl $0xffffff9d, %eax       # imm = 0xFFFFFF9D
ucomisd 0xb1499(%rip), %xmm0    # 0x11e138
jae 0x6ccb7
cmpl $0x1, %ecx
jne 0x6ccb5
movl $0xffffffea, %eax       # imm = 0xFFFFFFEA
ucomisd 0xb148d(%rip), %xmm0    # 0x11e140
jae 0x6ccb7
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: save_prs_param(char*)
void save_prs_param(char *s)
{
   if(s == 0) return;
   if(!strcmp(s, "AL")) {
      queue_prs_cmd("LM!", SCPI_USER_MSG);  // in verbose mode, these return an OK response
      queue_prs_cmd("FC!", SCPI_USER_MSG);  // ... so no need for -SCPI_USER_MSG
      queue_prs_cmd("GA!", SCPI_USER_MSG);
      queue_prs_cmd("SP!", SCPI_USER_MSG);
      queue_prs_cmd("MO!", SCPI_USER_MSG);
      queue_prs_cmd("TO!", SCPI_USER_MSG);
      queue_prs_cmd("PL!", SCPI_USER_MSG);
      queue_prs_cmd("PF!", SCPI_USER_MSG);
      queue_prs_cmd("PT!", SCPI_USER_MSG);
   }
   else {
      strcpy(out, s);
      strcat(out, "!");
      queue_prs_cmd(out, SCPI_USER_MSG);
   }
}

// Assembly:
testq %rdi, %rdi
je 0x6cd14
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xc6365(%rip), %rsi     # 0x13304a
callq 0x9520
testl %eax, %eax
je 0x6cd15
leaq 0x2cf52b(%rip), %r14    # 0x33c220
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9340
movq %r14, %rdi
callq 0x9120
movw $0x21, (%r14,%rax)
jmp 0x6cda4
retq
leaq 0xb4524(%rip), %rdi     # 0x121240
movl $0x25, %esi
callq 0x5ee52
leaq 0xb4517(%rip), %rdi     # 0x121244
movl $0x25, %esi
callq 0x5ee52
leaq 0xb450a(%rip), %rdi     # 0x121248
movl $0x25, %esi
callq 0x5ee52
leaq 0xb44fd(%rip), %rdi     # 0x12124c
movl $0x25, %esi
callq 0x5ee52
leaq 0xb44f0(%rip), %rdi     # 0x121250
movl $0x25, %esi
callq 0x5ee52
leaq 0xb44e3(%rip), %rdi     # 0x121254
movl $0x25, %esi
callq 0x5ee52
leaq 0xb44d6(%rip), %rdi     # 0x121258
movl $0x25, %esi
callq 0x5ee52
leaq 0xb44c9(%rip), %rdi     # 0x12125c
movl $0x25, %esi
callq 0x5ee52
leaq 0xb44bc(%rip), %r14     # 0x121260
movq %r14, %rdi
movl $0x25, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x5ee52
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: rftg_clear_errlog()
void rftg_clear_errlog()
{
   if(read_only) return;

   start_rftg_request2(0);

   send_rftg_start(0x37);  // clear error history from eeprom
   send_byte(1); 
   send_rftg_end();

   set_rftg_normal();
}

// Assembly:
leaq 0x2ca236(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6cdea
retq
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x65636
movl $0x37, %edi
callq 0x5e740
movl $0x1, %edi
callq 0x591af
callq 0x5e7c0
xorl %edi, %edi
callq 0x655b0
movl $0x45, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_dac_voltage()
void request_dac_voltage()
{
   if(luxor) return;
   if(no_poll) return;
   if(res_t) return;
   if(rcvr_type != TSIP_RCVR) return;
   if(ACU_GG) return;
   if(ACU_360) return;
   if(ACUTIME) return;
   if(PALISADE) return;
   if(SV6_FAMILY) return;

   send_tsip_start(0x8E);
   send_byte(0xA0);
   send_tsip_end();
}

// Assembly:
leaq 0x1d2112(%rip), %rax    # 0x23ef3e
leaq 0x2ca1ed(%rip), %rcx    # 0x337020
movb (%rcx), %cl
orb (%rax), %cl
leaq 0x1abac6(%rip), %rax    # 0x218904
orb (%rax), %cl
setne %al
leaq 0x1aba86(%rip), %rcx    # 0x2188d0
movq (%rcx), %rcx
cmpq $0x1, %rcx
setne %dl
orb %al, %dl
jne 0x6ceb7
leaq 0x1ae175(%rip), %rax    # 0x21afd4
movl (%rax), %eax
movl %eax, %esi
xorl $0x41, %esi
leaq 0x1aba8b(%rip), %rdx    # 0x2188f8
movl (%rdx), %edx
movl %edx, %edi
xorl $0x47, %edi
orl %esi, %edi
je 0x6ceb7
cmpl $0x41, %eax
jne 0x6ce87
cmpl $0x33, %edx
je 0x6ceb7
cmpl $0x47, %edx
je 0x6ceb7
cmpl $0x41, %eax
sete %dl
cmpl $0x50, %eax
sete %sil
cmpq $0x1, %rcx
jne 0x6ce9f
orb %sil, %dl
jne 0x6ceb7
cmpq $0x1, %rcx
jne 0x6ceb8
addl $-0x33, %eax
cmpl $0x1d, %eax
ja 0x6ceb8
movl $0x20004009, %ecx       # imm = 0x20004009
btl %eax, %ecx
jae 0x6ceb8
retq
pushq %rbp
movq %rsp, %rbp
movl $0x8e, %edi
callq 0x5e740
movl $0xa0, %edi
callq 0x591af
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_dac_value(unsigned int)
void set_dac_value(u32 value)
{
   if(read_only) return;
   if(luxor) return;
   if(rcvr_type != TSIP_RCVR) return;
   if(ACU_GG) return;
   if(ACU_360) return;
   if(ACUTIME) return;
   if(PALISADE) return;
   if(SV6_FAMILY) return;

   send_tsip_start(0x8E);
   send_byte(0xA0);
   send_byte(0x01);
   send_dword(value);
   send_tsip_end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2c9eff(%rip), %rax    # 0x33701a
leaq 0x1d1e1c(%rip), %rcx    # 0x23ef3e
movb (%rcx), %cl
orb (%rax), %cl
setne %al
leaq 0x1ab7a0(%rip), %rcx    # 0x2188d0
movq (%rcx), %rcx
cmpq $0x1, %rcx
setne %dl
orb %al, %dl
jne 0x6d19f
movl %edi, %ebx
leaq 0x1ade8d(%rip), %rax    # 0x21afd4
movl (%rax), %eax
movl %eax, %esi
xorl $0x41, %esi
leaq 0x1ab7a3(%rip), %rdx    # 0x2188f8
movl (%rdx), %edx
movl %edx, %edi
xorl $0x47, %edi
orl %esi, %edi
je 0x6d19f
cmpl $0x41, %eax
jne 0x6d16f
cmpl $0x33, %edx
je 0x6d19f
cmpl $0x47, %edx
je 0x6d19f
cmpl $0x41, %eax
sete %dl
cmpl $0x50, %eax
sete %sil
cmpq $0x1, %rcx
jne 0x6d187
orb %sil, %dl
jne 0x6d19f
cmpq $0x1, %rcx
jne 0x6d1a6
addl $-0x33, %eax
cmpl $0x1d, %eax
ja 0x6d1a6
movl $0x20004009, %ecx       # imm = 0x20004009
btl %eax, %ecx
jae 0x6d1a6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x8e, %edi
callq 0x5e740
movl $0xa0, %edi
callq 0x591af
movl $0x1, %edi
callq 0x591af
movl %ebx, %edi
callq 0x593b5
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_osc_sense(unsigned char, int)
void set_osc_sense(u08 mode, int save)
{
   if(read_only) return;
   if(luxor) return;
   if(rcvr_type != TSIP_RCVR) return;
   if(ACU_GG) return;
   if(ACU_360) return;
   if(ACUTIME) return;
   if(PALISADE) return;
   if(SV6_FAMILY) return;

   send_tsip_start(0x8E);  // not available on ThunderBolt-E or early ThunderBolts
   send_byte(0xA1);
   send_byte(mode);
   send_tsip_end();

   if(save) save_segment(6, 24);       // save timing config in EEPROM
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x2c9e36(%rip), %rax    # 0x33701a
leaq 0x1d1d53(%rip), %rcx    # 0x23ef3e
movb (%rcx), %cl
orb (%rax), %cl
setne %al
leaq 0x1ab6d7(%rip), %rcx    # 0x2188d0
movq (%rcx), %rcx
cmpq $0x1, %rcx
setne %dl
orb %al, %dl
jne 0x6d2a3
movl %esi, %ebx
movl %edi, %r14d
leaq 0x1addbd(%rip), %rax    # 0x21afd4
movl (%rax), %eax
movl %eax, %esi
xorl $0x41, %esi
leaq 0x1ab6d3(%rip), %rdx    # 0x2188f8
movl (%rdx), %edx
movl %edx, %edi
xorl $0x47, %edi
orl %esi, %edi
je 0x6d2a3
cmpl $0x41, %eax
jne 0x6d23f
cmpl $0x33, %edx
je 0x6d2a3
cmpl $0x47, %edx
je 0x6d2a3
cmpl $0x41, %eax
sete %dl
cmpl $0x50, %eax
sete %sil
cmpq $0x1, %rcx
jne 0x6d257
orb %sil, %dl
jne 0x6d2a3
cmpq $0x1, %rcx
jne 0x6d26f
addl $-0x33, %eax
cmpl $0x1d, %eax
ja 0x6d26f
movl $0x20004009, %ecx       # imm = 0x20004009
btl %eax, %ecx
jb 0x6d2a3
movl $0x8e, %edi
callq 0x5e740
movl $0xa1, %edi
callq 0x591af
movzbl %r14b, %edi
callq 0x591af
callq 0x5e7c0
testl %ebx, %ebx
je 0x6d2a3
movl $0x6, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x6a306
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_traim_info()
void request_traim_info()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == FURUNO_RCVR) {
      send_furuno_cmd("GPrrq");   // get traim settings
      send_furuno_cmd("GPint,rrm00");  // get pps info
   }
   else if(rcvr_type == MOTO_RCVR) {
      send_moto_start("Ge");  // 12 chan traim data
      send_byte(0xFF);
      send_moto_end();
      send_moto_start("Gf");  // 12 chan traim data
      send_word(0xFFFF);
      send_moto_end();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1d1c8b(%rip), %rax    # 0x23ef3e
leaq 0x2c9d66(%rip), %rcx    # 0x337020
movb (%rcx), %cl
orb (%rax), %cl
jne 0x6d2f1
leaq 0x1ab609(%rip), %rax    # 0x2188d0
movq (%rax), %rax
cmpq $0x20, %rax
je 0x6d2f3
cmpq $0x20000000, %rax       # imm = 0x20000000
jne 0x6d2f1
leaq 0xb39f9(%rip), %rdi     # 0x120cd8
callq 0x5f070
leaq 0xb3fdd(%rip), %rdi     # 0x1212c8
popq %rbp
jmp 0x5f070
popq %rbp
retq
leaq 0xb3fda(%rip), %rdi     # 0x1212d4
callq 0x61694
movl $0xff, %edi
callq 0x591af
callq 0x6170f
leaq 0xb3fc2(%rip), %rdi     # 0x1212d7
callq 0x61694
movl $0xffff, %edi           # imm = 0xFFFF
callq 0x5936c
popq %rbp
jmp 0x6170f
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_timing_mode()
void request_timing_mode()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == FURUNO_RCVR) {
   }
   else if(rcvr_type == MOTO_RCVR) {
      send_moto_start("Aw");  // get GPS/UTC mode
      send_byte(0xFF);
      send_moto_end();

      send_moto_start("Bo");  // get UTC offset command
      send_byte(0);
      send_moto_end();
   }
   else if(rcvr_type == NVS_RCVR) {
      send_nvs_start(0x1E);  // !!!! gets leapsecond info, timing mode comes from request_pps_info()
      send_nvs_end();
   }
   else if(rcvr_type == TM4_RCVR) {
      request_tm4_msg("57");  // timing mode
   }
   else if(rcvr_type == TSIP_RCVR) {
      if(ACU_GG) ;
      else if(ACU_360) ;
      else if(ACUTIME) return;
      else if(PALISADE) return;
      else if(SV6_FAMILY) return;

      send_tsip_start(0x8E);
      send_byte(0xA2);
      send_tsip_end();
   }
   else if(rcvr_type == ZYFER_RCVR) {
      send_zyfer_cmd("$TIMM");
   }

   request_traim_info();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1d1c09(%rip), %rax    # 0x23ef3e
leaq 0x2c9ce4(%rip), %rcx    # 0x337020
movb (%rcx), %cl
orb (%rax), %cl
je 0x6d344
popq %rbp
retq
leaq 0x1ab585(%rip), %rax    # 0x2188d0
movq (%rax), %rax
cmpq $0x7ff, %rax            # imm = 0x7FF
jg 0x6d39b
cmpq $0x1, %rax
je 0x6d3b9
cmpq $0x20, %rax
jne 0x6d403
leaq 0xb3f6d(%rip), %rdi     # 0x1212da
callq 0x61694
movl $0xff, %edi
callq 0x591af
callq 0x6170f
leaq 0xb3f55(%rip), %rdi     # 0x1212dd
callq 0x61694
xorl %edi, %edi
callq 0x591af
callq 0x6170f
jmp 0x6d403
cmpq $0x800, %rax            # imm = 0x800
je 0x6d3f4
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x6d403
leaq 0xb3f2f(%rip), %rdi     # 0x1212e1
callq 0x5f15d
jmp 0x6d403
leaq 0x1adc14(%rip), %rcx    # 0x21afd4
movl (%rcx), %ecx
movl %ecx, %esi
xorl $0x41, %esi
leaq 0x1ab52a(%rip), %rdx    # 0x2188f8
movl (%rdx), %edx
movl %edx, %edi
xorl $0x47, %edi
orl %esi, %edi
jne 0x6d409
movl $0x8e, %edi
callq 0x5e740
movl $0xa2, %edi
callq 0x591af
callq 0x5e7c0
jmp 0x6d403
movl $0x1e, %edi
callq 0x5e740
callq 0x5e844
popq %rbp
jmp 0x6d2a8
cmpl $0x41, %ecx
jne 0x6d418
cmpl $0x33, %edx
je 0x6d3d9
cmpl $0x47, %edx
je 0x6d3d9
cmpl $0x41, %ecx
sete %dl
cmpl $0x50, %ecx
sete %sil
cmpq $0x1, %rax
jne 0x6d434
orb %sil, %dl
jne 0x6d342
cmpq $0x1, %rax
jne 0x6d3d9
addl $-0x33, %ecx
cmpl $0x1d, %ecx
ja 0x6d3d9
movl $0x20004009, %eax       # imm = 0x20004009
btl %ecx, %eax
jb 0x6d342
jmp 0x6d3d9
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rcvr_utc_ofs(int)
void set_rcvr_utc_ofs(int i)
{
   // sets the receiver default UTC offset value
   if(read_only) return;

   if(rcvr_type == ESIP_RCVR) {
      sprintf(out, "PERDAPI,DEFLS,%d,AUTO", i);
      send_esip_cmd(out);
      Sleep(1000);
      save_segment(128,8787);
   }
}

// Assembly:
leaq 0x2c9bc1(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x6d4b1
leaq 0x1ab46b(%rip), %rax    # 0x2188d0
movl $0x80000000, %ecx       # imm = 0x80000000
cmpq %rcx, (%rax)
jne 0x6d4b1
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
leaq 0x2ceda2(%rip), %rbx    # 0x33c220
leaq 0xb3ed5(%rip), %rsi     # 0x12135a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
callq 0x5ef13
movl $0x3e8, %edi            # imm = 0x3E8
callq 0xaff7
movl $0x80, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6a306
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rftg_traim(int)
void set_rftg_traim(int mode)
{
   // (mode == 1) -> enable  (0 == disable)
   // note: this does not seem to change anything!!!!!
   if(read_only) return;

   start_rftg_request2(0);

   if(mode == 0) mode = 2;  // disable

   send_rftg_start(0x64);
   send_byte(mode);
   send_rftg_end();
}

// Assembly:
leaq 0x2c9988(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6d698
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
callq 0x65636
movl $0x64, %edi
callq 0x5e740
testl %ebx, %ebx
movl $0x2, %eax
cmovnel %ebx, %eax
movzbl %al, %edi
callq 0x591af
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_sy(int)
void set_sro_sy(int mode)
{
   if(read_only) return;

   if(mode < 0) mode = 0;
   if(mode > 3) mode = 1;
   sprintf(out, "SY%d", mode);
   queue_sro_cmd(out, SRO_SY_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2c94a0(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6db80
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %edi, %edi
movl $0x0, %eax
cmovgl %edi, %eax
cmpl $0x4, %edi
movl $0x1, %edx
cmovll %eax, %edx
leaq 0x2ce67e(%rip), %rbx    # 0x33c220
leaq 0xb5cfc(%rip), %rsi     # 0x1238a5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x326, %esi            # imm = 0x326
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_tr(int)
void set_sro_tr(int mode)
{
   if(read_only) return;

   if(mode < 0) mode = 0;
   if(mode > 3) mode = 1;
   sprintf(out, "TR%d", mode);
   queue_sro_cmd(out, SRO_TR_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2c9443(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6dbdd
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %edi, %edi
movl $0x0, %eax
cmovgl %edi, %eax
cmpl $0x4, %edi
movl $0x1, %edx
cmovll %eax, %edx
leaq 0x2ce621(%rip), %rbx    # 0x33c220
leaq 0xb5ca4(%rip), %rsi     # 0x1238aa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x325, %esi            # imm = 0x325
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: exit_test_mode()
void exit_test_mode()
{
   // this is a set_() type function
   if(read_only) return;
   if(luxor) return;
   if(rcvr_type != TSIP_RCVR) return;

   send_tsip_start(0x8E);
   send_byte(0xA4);
   send_byte(0x00);
   send_tsip_end();
}

// Assembly:
leaq 0x2c92a2(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x6ddbb
leaq 0x1d11ba(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x6ddbb
leaq 0x1aab40(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x6ddbb
pushq %rbp
movq %rsp, %rbp
movl $0x8e, %edi
callq 0x5e740
movl $0xa4, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
popq %rbp
jmp 0x5e7c0
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_packet_mask()
void request_packet_mask()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type != TSIP_RCVR) return;
   if(ACU_GG) ;
   else if(ACU_360) ;
   else if(ACUTIME) ;
   else if(PALISADE) ;
   else if(SV6_FAMILY) return;

   send_tsip_start(0x8E);
   send_byte(0xA5);
   send_tsip_end();
}

// Assembly:
leaq 0x1d1175(%rip), %rax    # 0x23ef3e
leaq 0x2c9250(%rip), %rcx    # 0x337020
movb (%rcx), %cl
orb (%rax), %cl
setne %al
leaq 0x1aaaf2(%rip), %rcx    # 0x2188d0
movq (%rcx), %rcx
cmpq $0x1, %rcx
setne %dl
orb %al, %dl
je 0x6dded
retq
leaq 0x1ad1e0(%rip), %rax    # 0x21afd4
movl (%rax), %eax
movl %eax, %esi
xorl $0x41, %esi
leaq 0x1aaaf6(%rip), %rdx    # 0x2188f8
movl (%rdx), %edx
movl %edx, %edi
xorl $0x47, %edi
orl %esi, %edi
jne 0x6de2b
pushq %rbp
movq %rsp, %rbp
movl $0x8e, %edi
callq 0x5e740
movl $0xa5, %edi
callq 0x591af
popq %rbp
jmp 0x5e7c0
cmpl $0x41, %eax
jne 0x6de3a
cmpl $0x33, %edx
je 0x6de0d
cmpl $0x47, %edx
je 0x6de0d
cmpl $0x41, %eax
sete %dl
cmpl $0x50, %eax
setne %sil
cmpq $0x1, %rcx
jne 0x6de0d
xorb %sil, %dl
je 0x6de0d
addl $-0x33, %eax
cmpl $0x1d, %eax
ja 0x6de0d
movl $0x20004009, %ecx       # imm = 0x20004009
btl %eax, %ecx
jb 0x6ddec
jmp 0x6de0d
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rtk_mode(int)
void set_rtk_mode(int mode)
{
   if(read_only) return;

   if(rcvr_type == VENUS_RCVR) {
      if(mode < 0) mode = ROVER_MODE;
      else if(mode > 1) mode = BASE_MODE;

      send_venus_start(SET_VENUS_RTK_MODE);
      send_byte(1); 
      send_byte(mode);  // 0=rover  1=base
      send_venus_save(1);

      query_venus_msg(QUERY_VENUS_RTK_MODE);
   }
}

// Assembly:
leaq 0x2c91ad(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x6dedd
leaq 0x1aaa57(%rip), %rax    # 0x2188d0
cmpq $0x80, (%rax)
jne 0x6dedd
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testl %edi, %edi
setg %bl
movl $0x6a, %edi
movl $0x4, %esi
callq 0x5fbb4
movl $0x1, %edi
callq 0x591af
movl %ebx, %edi
callq 0x591af
movl $0x1, %edi
callq 0x5fc43
movl $0x6a, %edi
movl $0x2, %esi
callq 0x5fbb4
movl $0x2, %edi
callq 0x591af
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x61bc3
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_nav_rate(double)
void set_nav_rate(DATA_SIZE hz)
{
   if(read_only) return;

   if(hz <= 0.0) hz = 1.0;

   if(rcvr_type == CS_RCVR) {
      if(!pause_data) nav_rate = hz;
   }
   else if((rcvr_type == NO_RCVR) || (rcvr_type == TIDE_RCVR) || (rcvr_type == THERMO_RCVR)) {
      if(!pause_data) nav_rate = hz;
   }
   else if(rcvr_type == NVS_RCVR) {
      send_nvs_start(0xD7); // set nav rate (1 Hz)
      send_byte(0x02);
      send_byte((u08) hz);
      send_nvs_end();
   }
   else if(rcvr_type == TICC_RCVR) {
      if(!pause_data) nav_rate = hz;
   }
   else if(rcvr_type == UBX_RCVR) {
      if(time_flags & TFLAGS_UTC) {       // sync to UTC time
         set_ubx_nav_rate((DATA_SIZE) 1000.0/hz, 1); // 1Hz, align to UTC
      }
      else {
         set_ubx_nav_rate((DATA_SIZE) 1000.0/hz, 0); // 1Hz, align to GPS
      }
   }
   else if(rcvr_type == VENUS_RCVR) {
      send_venus_start(SET_VENUS_OUT_RATE);
      send_byte(1);  // 1 Hz
      send_venus_save(1);
      Sleep(1000);

      // doing this causes the receiver to effectively warm start
      send_venus_start(SET_VENUS_NAV_RATE);
      send_byte((u08) hz);  // raw Hz !!!!
      send_venus_save(1);
   }

   log_written = 0;  // force new log header
}

// Assembly:
leaq 0x2c9135(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6deeb
retq
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpnlesd %xmm1, %xmm2
andpd %xmm2, %xmm0
movsd 0x9b164(%rip), %xmm1    # 0x109070
andnpd %xmm1, %xmm2
orpd %xmm0, %xmm2
leaq 0x1aa9b5(%rip), %rax    # 0x2188d0
movq (%rax), %rax
cmpq $0xffff, %rax           # imm = 0xFFFF
jg 0x6dfa5
cmpq $0x3ff, %rax            # imm = 0x3FF
jg 0x6dfc2
cmpq $0x4, %rax
je 0x6e028
cmpq $0x80, %rax
jne 0x6e04e
movl $0x11, %edi
movl $0x3, %esi
movapd %xmm2, -0x10(%rbp)
callq 0x5fbb4
movl $0x1, %edi
callq 0x591af
movl $0x1, %edi
callq 0x5fc43
movl $0x3e8, %edi            # imm = 0x3E8
callq 0xaff7
movl $0xe, %edi
movl $0x3, %esi
callq 0x5fbb4
cvttsd2si -0x10(%rbp), %eax
movzbl %al, %edi
callq 0x591af
movl $0x1, %edi
callq 0x5fc43
jmp 0x6e04e
cmpq $0x7ffff, %rax          # imm = 0x7FFFF
jg 0x6dfff
cmpq $0x10000, %rax          # imm = 0x10000
je 0x6e00f
cmpq $0x20000, %rax          # imm = 0x20000
je 0x6e00f
jmp 0x6e04e
cmpq $0x400, %rax            # imm = 0x400
je 0x6e00f
cmpq $0x800, %rax            # imm = 0x800
jne 0x6e04e
movl $0xd7, %edi
movapd %xmm2, -0x10(%rbp)
callq 0x5e740
movl $0x2, %edi
callq 0x591af
cvttsd2si -0x10(%rbp), %eax
movzbl %al, %edi
callq 0x591af
callq 0x5e844
jmp 0x6e04e
cmpq $0x80000, %rax          # imm = 0x80000
je 0x6e00f
cmpq $0x800000, %rax         # imm = 0x800000
jne 0x6e04e
leaq 0x1ad21e(%rip), %rax    # 0x21b234
cmpb $0x0, (%rax)
jne 0x6e04e
leaq 0x1ad336(%rip), %rax    # 0x21b358
movsd %xmm2, (%rax)
jmp 0x6e04e
leaq 0x29f475(%rip), %rax    # 0x30d4a4
testb $0x1, (%rax)
movsd 0x9affe(%rip), %xmm0    # 0x109038
divsd %xmm2, %xmm0
jne 0x6e044
xorl %edi, %edi
jmp 0x6e049
movl $0x1, %edi
callq 0x6e05e
leaq 0x1d0395(%rip), %rax    # 0x23e3ea
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_ubx_nav_rate(double, int)
void set_ubx_nav_rate(DATA_SIZE rate, int align)
{
   if(read_only) return;

   send_ubx_start(UBX_NAV_RATE, 6);
   send_word((u16) rate);  // in msecs
   send_word(1);
   send_word(align);
   send_ubx_end();
}

// Assembly:
leaq 0x2c8fb5(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6e06b
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
movl $0x608, %edi            # imm = 0x608
movl $0x6, %esi
movsd %xmm0, -0x18(%rbp)
callq 0x5f3f5
cvttsd2si -0x18(%rbp), %edi
movl $0xffff, %r14d          # imm = 0xFFFF
andl %r14d, %edi
callq 0x5936c
movl $0x1, %edi
callq 0x5936c
andl %r14d, %ebx
movl %ebx, %edi
callq 0x5936c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x5f4ce
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: init_enviro(unsigned int)
void init_enviro(unsigned port)
{
   // intialize the environmental sensor device to start sending data
   // We request the device ID.

   if(port >= NUM_COM_PORTS) return;
   drain_port(port);
   reset_com_timer(port);

   last_enviro = ENV_ID;
   if(enviro_type == DOG_ENVIRO) {
      send_enviro_cmd("GI\r", port);
      send_enviro_cmd("GI\r", port);
   }
   else if(enviro_type == LFS_ENVIRO) {
      send_enviro_cmd("GETID\r", port);
      send_enviro_cmd("GETID\r", port);
   }
   else if(enviro_type == DETECT_ENVIRO) {
      send_enviro_cmd("GI\n", port); 
      send_enviro_cmd("GI\n", port);
      send_enviro_cmd("\n", port);

      send_enviro_cmd("GETID\r", port);  //lfs
      send_enviro_cmd("GETID\r", port);
      if(rcvr_type == THERMO_RCVR) {  //lfs
         send_enviro_cmd("GETID\r", port);
         send_enviro_cmd("GETID\r", port);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x12, %edi
jbe 0x6e296
popq %rbx
popq %r14
popq %rbp
retq
movl %edi, %ebx
callq 0x5804f
movl %ebx, %edi
callq 0x1ea2c
leaq 0x1aa679(%rip), %rax    # 0x218924
movl $0x8000, (%rax)         # imm = 0x8000
leaq 0x1aa65c(%rip), %rax    # 0x218914
movl (%rax), %eax
testl %eax, %eax
je 0x6e2da
cmpl $0x1, %eax
je 0x6e2d1
cmpl $0x3, %eax
jne 0x6e291
leaq 0xb3262(%rip), %r14     # 0x121531
jmp 0x6e332
leaq 0xb3255(%rip), %r14     # 0x12152d
jmp 0x6e332
leaq 0xb3257(%rip), %r14     # 0x121538
movq %r14, %rdi
movl %ebx, %esi
callq 0x60ef6
movq %r14, %rdi
movl %ebx, %esi
callq 0x60ef6
leaq 0xc76a8(%rip), %rdi     # 0x1359a4
movl %ebx, %esi
callq 0x60ef6
leaq 0xb3227(%rip), %r14     # 0x121531
movq %r14, %rdi
movl %ebx, %esi
callq 0x60ef6
movq %r14, %rdi
movl %ebx, %esi
callq 0x60ef6
leaq 0x1aa5ab(%rip), %rax    # 0x2188d0
cmpq $0x80000, (%rax)        # imm = 0x80000
jne 0x6e291
movq %r14, %rdi
movl %ebx, %esi
callq 0x60ef6
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x60ef6
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: poll_z12_time(int)
void poll_z12_time(int sleep)
{
   if(rcvr_type == Z12_RCVR) {
if(raw_msg_rate) return; //lfs // !!!!! we get time from the system clock
      if(ZDA_TIME) send_z12_cmd("PASHQ,ZDA");
      else         send_z12_cmd("PASHQ,RID");
      if(sleep) Sleep(150);
   }
}

// Assembly:
leaq 0x1aa57f(%rip), %rax    # 0x2188d0
movabsq $0x100000000, %rcx      # imm = 0x100000000
cmpq %rcx, (%rax)
jne 0x6e395
leaq 0x1ad011(%rip), %rax    # 0x21b378
cmpl $0x0, (%rax)
jne 0x6e395
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0xb25e9(%rip), %rdi     # 0x120964
callq 0x5f340
testl %ebx, %ebx
leaq 0x8(%rsp), %rsp
popq %rbx
popq %rbp
je 0x6e395
movl $0x96, %edi
jmp 0xaff7
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: enable_gpsd()
void enable_gpsd()
{
   if(gpsd_device[0]) {
      sprintf(out, "?WATCH={\"enable\":true,\"json\":true,\"pps\":true,\"devicename\":\"%s\"}", gpsd_device);
   }
   else {
      sprintf(out, "?WATCH={\"enable\":true,\"json\":true,\"pps\":true}");
   }
   send_nmea_string(out, 0);
//    send_byte(0x0D);
   eom_flag = EOM;
   send_byte(0x0A);
   eom_flag = ADD_CHAR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2cd755(%rip), %rax    # 0x33c430
cmpb $0x0, (%rax)
je 0x6ecfe
leaq 0x2cd539(%rip), %rdi    # 0x33c220
leaq 0xb6f2f(%rip), %rsi     # 0x125c1d
leaq 0x2cd73b(%rip), %rdx    # 0x33c430
xorl %eax, %eax
callq 0x9060
jmp 0x6ed25
movups 0xb6f76(%rip), %xmm0    # 0x125c7b
leaq 0x2cd514(%rip), %rax    # 0x33c220
movups %xmm0, 0x1e(%rax)
movups 0xb6f56(%rip), %xmm0    # 0x125c6d
movaps %xmm0, 0x10(%rax)
movups 0xb6f3b(%rip), %xmm0    # 0x125c5d
movaps %xmm0, (%rax)
leaq 0x2cd4f4(%rip), %rdi    # 0x33c220
xorl %esi, %esi
callq 0x5e92a
movl $0x1, 0x2fd0d3(%rip)    # 0x36be10
movl $0xa, %edi
callq 0x591af
movl $0x0, 0x2fd0bf(%rip)    # 0x36be10
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_ubx_antenna(unsigned char)
void set_ubx_antenna(u08 mode)
{ 
   if(read_only) return;

   send_ubx_start(UBX_CFG_ANT, 4);
   send_word(mode);
   send_word(0x0000);  // dont re-config pins - LEA-5T has a98b
   send_ubx_end();
}

// Assembly:
leaq 0x2c71f2(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6fe2e
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x613, %edi            # imm = 0x613
movl $0x4, %esi
callq 0x5f3f5
movzbl %bl, %edi
callq 0x5936c
xorl %edi, %edi
callq 0x5936c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5f4ce
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_zod_nav_mode(int)
void set_zod_nav_mode(int flags)
{
   if(read_only) return;

   send_zod_start(ZOD_SET_NAV_MODE, 15, 0);
   send_zod_seq();
   send_word(flags);
   send_word(0);
   send_word(0);
   send_word(0);
   send_word(0);
   send_word(0);
   send_word(0);
   send_word(0);
   send_zod_end();
}

// Assembly:
leaq 0x2c6e97(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x70189
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x4c5, %edi            # imm = 0x4C5
movl $0xf, %esi
xorl %edx, %edx
callq 0x645ec
movzwl 0x2fc987(%rip), %edi    # 0x36cb30
callq 0x5936c
movzwl %bx, %edi
callq 0x5936c
xorl %edi, %edi
callq 0x5936c
xorl %edi, %edi
callq 0x5936c
xorl %edi, %edi
callq 0x5936c
xorl %edi, %edi
callq 0x5936c
xorl %edi, %edi
callq 0x5936c
xorl %edi, %edi
callq 0x5936c
xorl %edi, %edi
callq 0x5936c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x646c7
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_discipline_params(unsigned char)
void request_discipline_params(u08 type)
{
   if(luxor) return;
   if(no_poll) return;
   if(res_t) return;

   if(rcvr_type == PRS_RCVR) {
      if     (type == 0x00) {   // time constant
         queue_prs_cmd("PT?", PRS_PT_MSG);
      }
      else if(type == 0x01) {  // gain
         queue_prs_cmd("GA?", PRS_GA_MSG);
      }
      else if(type == 0x02) {  // stability
         queue_prs_cmd("PF?", PRS_PF_MSG);
      }
      else if(type == 0x03) {  // integrator
         queue_prs_cmd("PI?", PRS_PI_MSG);
      }
   }
   else if(rcvr_type == STAR_RCVR) {
      if(type == 0x00) {
         request_rcvr_config(5577);
      }
   }
   else if(rcvr_type == TSIP_RCVR) {
      if(ACU_GG) return;
      if(ACU_360) return;
      if(ACUTIME) return;
      if(PALISADE) return;
      if(SV6_FAMILY) return;
      send_tsip_start(0x8E);
      send_byte(0xA8);
      send_byte(type);
      send_tsip_end();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x1ce7db(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x70852
leaq 0x2c68ad(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x70852
leaq 0x1a8181(%rip), %rax    # 0x218904
cmpb $0x0, (%rax)
jne 0x70852
movl %edi, %ebx
leaq 0x1a813b(%rip), %rax    # 0x2188d0
movq (%rax), %rax
cmpq $0x1, %rax
je 0x707f3
cmpq $0x1000, %rax           # imm = 0x1000
je 0x707df
cmpq $0x1000000, %rax        # imm = 0x1000000
jne 0x70852
cmpb $0x3, %bl
ja 0x70852
movzbl %bl, %eax
leaq 0xae64f(%rip), %rcx     # 0x11ee14
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xb1081(%rip), %rdi     # 0x121856
movl $0x20b, %esi            # imm = 0x20B
jmp 0x70881
testb %bl, %bl
jne 0x70852
movl $0x15c9, %edi           # imm = 0x15C9
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x66617
leaq 0x1aa7da(%rip), %rcx    # 0x21afd4
movl (%rcx), %ecx
movl %ecx, %esi
xorl $0x41, %esi
leaq 0x1a80f0(%rip), %rdx    # 0x2188f8
movl (%rdx), %edx
movl %edx, %edi
xorl $0x47, %edi
orl %esi, %edi
je 0x70852
cmpl $0x41, %ecx
jne 0x70822
cmpl $0x33, %edx
je 0x70852
cmpl $0x47, %edx
je 0x70852
cmpl $0x41, %ecx
sete %dl
cmpl $0x50, %ecx
sete %sil
cmpq $0x1, %rax
jne 0x7083a
orb %sil, %dl
jne 0x70852
cmpq $0x1, %rax
jne 0x7088c
addl $-0x33, %ecx
cmpl $0x1d, %ecx
ja 0x7088c
movl $0x20004009, %eax       # imm = 0x20004009
btl %ecx, %eax
jae 0x7088c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xb0ffe(%rip), %rdi     # 0x12185e
movl $0x20c, %esi            # imm = 0x20C
jmp 0x70881
leaq 0xb0ff4(%rip), %rdi     # 0x121862
movl $0x20d, %esi            # imm = 0x20D
jmp 0x70881
leaq 0xb0fde(%rip), %rdi     # 0x12185a
movl $0x200, %esi            # imm = 0x200
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ee52
movl $0x8e, %edi
callq 0x5e740
movl $0xa8, %edi
callq 0x591af
movzbl %bl, %edi
callq 0x591af
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_all_dis_params()
void request_all_dis_params()
{
   if(luxor) return;
   if(no_poll) return;

   request_discipline_params(0x00); // time constant
   request_discipline_params(0x01); // gain / DAC range
   request_discipline_params(0x02); // sync / freq thresholds
   request_discipline_params(0x03); // initial DAC voltage
   request_discipline_params(0x04); // undocumented - allowable DAC range?
}

// Assembly:
leaq 0x1ce684(%rip), %rax    # 0x23ef3e
leaq 0x2c675f(%rip), %rcx    # 0x337020
movb (%rcx), %cl
orb (%rax), %cl
je 0x708c8
retq
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x70756
movl $0x1, %edi
callq 0x70756
movl $0x2, %edi
callq 0x70756
movl $0x3, %edi
callq 0x70756
movl $0x4, %edi
popq %rbp
jmp 0x70756
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_pullin_range(int)
void set_pullin_range(int i)
{
   if(read_only) return;

   if(rcvr_type == UCCM_RCVR) {
      sprintf(out, "PULLINRANGE %d", i/10);
      queue_uccm_cmd(out, UCCM_SET_PULLIN_MSG);
      queue_uccm_cmd("PULLINRANGE?", UCCM_GET_PULLIN_MSG);
   }
}

// Assembly:
leaq 0x2c6717(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x7096e
leaq 0x1a7fc1(%rip), %rax    # 0x2188d0
cmpq $0x8, (%rax)
jne 0x7096e
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq %edi, %rax
imulq $0x66666667, %rax, %rdx # imm = 0x66666667
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x22, %rdx
addl %eax, %edx
leaq 0x2cb8e7(%rip), %rbx    # 0x33c220
leaq 0xb0f26(%rip), %rsi     # 0x121866
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x6c, %esi
callq 0x5ee52
leaq 0xb03e1(%rip), %rdi     # 0x120d3f
movl $0x6d, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ee52
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_prs_pt(int)
void set_prs_pt(int val)
{
   if(read_only) return;

   sprintf(out, "PT%d", val);
   queue_prs_cmd(out, PRS_PT_MSG);
   queue_prs_cmd("PT?", PRS_PT_MSG);
}

// Assembly:
leaq 0x2c628b(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x70d95
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
leaq 0x2cb47c(%rip), %rbx    # 0x33c220
leaq 0xb2e44(%rip), %rsi     # 0x123bef
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x20b, %esi            # imm = 0x20B
callq 0x5ee52
leaq 0xb0a8d(%rip), %rdi     # 0x121856
movl $0x20b, %esi            # imm = 0x20B
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ee52
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_prs_pf(int)
void set_prs_pf(int val)
{
   if(read_only) return;

   sprintf(out, "PF%d", val);
   queue_prs_cmd(out, PRS_PF_MSG);
   queue_prs_cmd("PF?", PRS_PF_MSG);
}

// Assembly:
leaq 0x2c623a(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x70de6
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
leaq 0x2cb42b(%rip), %rbx    # 0x33c220
leaq 0xb2de4(%rip), %rsi     # 0x123be0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x20c, %esi            # imm = 0x20C
callq 0x5ee52
leaq 0xb0a44(%rip), %rdi     # 0x12185e
movl $0x20c, %esi            # imm = 0x20C
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ee52