LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_sig_levels()
void request_sig_levels()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x27);
      send_tsip_end();
   }
   else if(rcvr_type == UBX_RCVR) {
      if(raw_msg_rate == 0) {   // poll for doppler, etc
         request_ubx_msg(UBX_SVN); // sat info
         request_ubx_msg(UBX_RAW);  
         request_ubx_msg(UBX_RAWX);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1d8b10(%rip), %rax    # 0x23ef3e
leaq 0x2d0beb(%rip), %rcx    # 0x337020
movb (%rcx), %cl
orb (%rax), %cl
je 0x6643d
popq %rbp
retq
leaq 0x1b248c(%rip), %rax    # 0x2188d0
movq (%rax), %rax
cmpq $0x1, %rax
jne 0x6645d
movl $0x27, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
cmpq $0x4, %rax
jne 0x6643b
leaq 0x1b4f0e(%rip), %rax    # 0x21b378
cmpl $0x0, (%rax)
jne 0x6643b
movl $0x130, %edi            # imm = 0x130
xorl %esi, %esi
callq 0x5f3f5
callq 0x5f4ce
movl $0x210, %edi            # imm = 0x210
xorl %esi, %esi
callq 0x5f3f5
callq 0x5f4ce
movl $0x215, %edi            # imm = 0x215
xorl %esi, %esi
callq 0x5f3f5
popq %rbp
jmp 0x5f4ce
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_alm_health()
void request_alm_health()
{
   if(no_poll) return;
   if(res_t) return;
   if(luxor) return;

   if(rcvr_type == TSIP_RCVR) {
      if(ACU_GG) ;
      else if(ACU_360) ;
      else if(ACUTIME) ;
      else if(PALISADE) ;
      else if(SV6_FAMILY) return;
      send_tsip_start(0x29);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x2d0b76(%rip), %rax    # 0x337020
leaq 0x1b2453(%rip), %rcx    # 0x218904
movb (%rcx), %cl
orb (%rax), %cl
je 0x664b8
retq
leaq 0x1d8a7f(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x664b7
leaq 0x1b2405(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x664b7
leaq 0x1b4afc(%rip), %rax    # 0x21afd4
movl (%rax), %eax
movl %eax, %edx
xorl $0x41, %edx
leaq 0x1b2412(%rip), %rcx    # 0x2188f8
movl (%rcx), %ecx
movl %ecx, %esi
xorl $0x47, %esi
orl %edx, %esi
jne 0x66505
pushq %rbp
movq %rsp, %rbp
movl $0x29, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
cmpl $0x41, %eax
jne 0x66528
cmpl $0x33, %ecx
je 0x664f1
cmpl $0x47, %ecx
je 0x664f1
cmpl $0x41, %eax
je 0x664f1
addl $-0x33, %eax
cmpl $0x1d, %eax
ja 0x664f1
movl $0x20004009, %ecx       # imm = 0x20004009
jmp 0x66535
addl $-0x33, %eax
cmpl $0xe, %eax
ja 0x664f1
movl $0x4009, %ecx           # imm = 0x4009
btl %eax, %ecx
jb 0x664b7
jmp 0x664f1
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_xyz(float, float, float)
void set_xyz(float x, float y, float z)
{
   if(read_only) return;
   if(luxor) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x31);
      send_single(x);
      send_single(y);
      send_single(z);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x2d0ad3(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6654d
retq
leaq 0x1d89ea(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x6654c
leaq 0x1b2370(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x6654c
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x31, %edi
movss %xmm2, -0xc(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm0, -0x4(%rbp)
callq 0x5e740
movss -0x4(%rbp), %xmm0
callq 0x59440
movss -0x8(%rbp), %xmm0
callq 0x59440
movss -0xc(%rbp), %xmm0
callq 0x59440
addq $0x10, %rsp
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_ref_input(int)
void set_ref_input(int ref)
{
   // ref=0: GPS
   // ref=1: AUX PPS input

   if(read_only) return;
   if(luxor) return;

   if(rcvr_type == STAR_RCVR) {
      if     (ref == 0) queue_star_cmd("INPUT_TYPE(1)=GPS;", STAR_INP_TYPE_MSG);       // gps input
      else if(ref == 1) queue_star_cmd("INPUT_TYPE(1)=AUX;", STAR_INP_TYPE_MSG);  // pps input
      queue_star_cmd("INPUT_TYPE(1);", STAR_INP_TYPE_MSG);  // !!! this command is not valid for ATDC model
   }
   else request_rcvr_config(7788);
}

// Assembly:
leaq 0x2d0a64(%rip), %rax    # 0x33701a
leaq 0x1d8981(%rip), %rcx    # 0x23ef3e
movb (%rcx), %cl
orb (%rax), %cl
je 0x665c4
retq
leaq 0x1b2305(%rip), %rax    # 0x2188d0
cmpq $0x1000, (%rax)         # imm = 0x1000
jne 0x665e6
testl %edi, %edi
je 0x665f0
cmpl $0x1, %edi
jne 0x66606
leaq 0xba2d0(%rip), %rdi     # 0x1208b4
jmp 0x665f7
movl $0x1e6c, %edi           # imm = 0x1E6C
jmp 0x66617
leaq 0xba2aa(%rip), %rdi     # 0x1208a1
pushq %rbp
movq %rsp, %rbp
movl $0xcb, %esi
callq 0x5ee52
popq %rbp
leaq 0xba2ba(%rip), %rdi     # 0x1208c7
movl $0xcb, %esi
jmp 0x5ee52
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_venus_survey(int, double, double, double)
void set_venus_survey(int mode, double slat,double slon,double salt)
{
   if(read_only) return;

   if(saw_venus_raw) send_venus_start(SET_VENUS_RTK_SURVEY);
   else              send_venus_start(SET_VENUS_SURVEY);
   send_byte(mode);       // 0=timing pvt mode  1=do survey  2=posn hold mode
   send_dword(do_survey);
   send_dword(100);             // standard deviation
   send_double(slat*180.0/PI);  // lla only used for position hold mode
   send_double(slon*180.0/PI);
   send_single((float)salt);
   send_venus_save(1);
}

// Assembly:
leaq 0x2d041d(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x66c03
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq 0x2d71df(%rip), %rax    # 0x33ddf4
cmpl $0x0, (%rax)
movl $0x54, %eax
movl $0x22, %edi
cmovel %eax, %edi
movl $0x1f, %esi
movsd %xmm2, -0x20(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm0, -0x10(%rbp)
callq 0x5fbb4
movzbl %bl, %edi
callq 0x591af
leaq 0x2a722b(%rip), %rax    # 0x30de78
movl (%rax), %edi
callq 0x593b5
movl $0x64, %edi
callq 0x593b5
movsd -0x10(%rbp), %xmm0
mulsd 0xa4bb5(%rip), %xmm0    # 0x10b820
divsd 0xa4ba5(%rip), %xmm0    # 0x10b818
callq 0x59487
movsd -0x18(%rbp), %xmm0
mulsd 0xa4b9b(%rip), %xmm0    # 0x10b820
divsd 0xa4b8b(%rip), %xmm0    # 0x10b818
callq 0x59487
xorps %xmm0, %xmm0
cvtsd2ss -0x20(%rbp), %xmm0
callq 0x59440
movl $0x1, %edi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x5fc43
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_filter_factor(double)
void set_filter_factor(DATA_SIZE val)
{
   if(read_only) return;

   if(rcvr_type == NVS_RCVR) {
      send_nvs_start(0x0D);
      send_byte(0x04);
      send_single((float) val);
      send_nvs_end();
   }
}

// Assembly:
leaq 0x2d0364(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x66d03
leaq 0x1b1c0e(%rip), %rax    # 0x2188d0
cmpq $0x800, (%rax)          # imm = 0x800
jne 0x66d03
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xd, %edi
movsd %xmm0, -0x8(%rbp)
callq 0x5e740
movl $0x4, %edi
callq 0x591af
xorps %xmm0, %xmm0
cvtsd2ss -0x8(%rbp), %xmm0
callq 0x59440
addq $0x10, %rsp
popq %rbp
jmp 0x5e844
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rtcm_mode(int)
void set_rtcm_mode(int enable)
{
   if(rcvr_type == VENUS_RCVR) {  // raw Hz !!!!
      send_venus_start(SET_VENUS_RTCM);
      send_byte(enable);
      send_byte(0);   // 1Hz rnx2  0..6 -> 1/2/4/5/10/20/8 Hz

      send_byte(1);   // base station ARP
      if(gnss_mask & GPS)     send_byte(1);
      else                    send_byte(0);

      if(gnss_mask & GLONASS) send_byte(1);
      else                    send_byte(0);

      if(1)                   send_byte(0);  // reserved

      if(gnss_mask & SBAS)    send_byte(1);
      else                    send_byte(0);

      if(gnss_mask & QZSS)    send_byte(1);
      else                    send_byte(0);

      if(gnss_mask & BEIDOU)  send_byte(1);
      else                    send_byte(0);

      send_byte(0);  // reserved
      send_byte(0);  // reserved
      send_byte(0);  // reserved
      send_byte(0);  // reserved
      send_byte(0);  // reserved
      send_byte(0);  // reserved
      send_venus_save(1);
   }
}

// Assembly:
leaq 0x1b1bc5(%rip), %rax    # 0x2188d0
cmpq $0x80, (%rax)
jne 0x66dcf
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x20, %edi
movl $0x11, %esi
callq 0x5fbb4
movzbl %bl, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
movl $0x1, %edi
callq 0x591af
leaq 0x109f25(%rip), %rbx    # 0x170c74
movl (%rbx), %edi
andl $0x1, %edi
callq 0x591af
movzbl (%rbx), %edi
shrl %edi
andl $0x1, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
movl (%rbx), %edi
shrl $0xf, %edi
andl $0x1, %edi
callq 0x591af
movl (%rbx), %edi
shrl $0xe, %edi
andl $0x1, %edi
callq 0x591af
movzbl (%rbx), %edi
shrl $0x3, %edi
andl $0x1, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5fc43
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_ubx_rate(int, int)
void set_ubx_rate(int id, int rate)
{
   // set periodic output rate for a UBX message
   if(read_only) return;

   send_ubx_start(UBX_SET_RATE, 3);
   send_byte((id >> 8) & 0xFF);
   send_byte(id & 0xFF);
   send_byte(rate);
   send_ubx_end();
}

// Assembly:
leaq 0x2cfd88(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x67298
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
movl $0x601, %edi            # imm = 0x601
movl $0x3, %esi
callq 0x5f3f5
movl %r14d, %edi
shrl $0x8, %edi
movl $0xff, %r15d
andl %r15d, %edi
callq 0x591af
andl %r15d, %r14d
movl %r14d, %edi
callq 0x591af
andl %r15d, %ebx
movl %ebx, %edi
callq 0x591af
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5f4ce
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rinex_site(char*)
void set_rinex_site(char *s)
{
   // set RINEX site name
   if(read_only) return;

   if(s == 0) return;

   if(rcvr_type == Z12_RCVR) {
      out[4] = 0;
      sprintf(out, "PASHS,SIT,%s", s);
      send_z12_cmd(out);
   }
}

// Assembly:
leaq 0x2cfd25(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x672fb
retq
movq %rdi, %rdx
testq %rdi, %rdi
je 0x672fa
leaq 0x1b15c6(%rip), %rax    # 0x2188d0
movabsq $0x100000000, %rcx      # imm = 0x100000000
cmpq %rcx, (%rax)
jne 0x672fa
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2d4efa(%rip), %rbx    # 0x33c220
movb $0x0, 0x4(%rbx)
leaq 0xb963d(%rip), %rsi     # 0x12096e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5f340
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rftg_lla(int, int, int)
void set_rftg_lla(S32 slat, S32 slon, S32 salt)
{
   if(read_only) return;

   start_rftg_request2(0);

   send_rftg_start(0x32);
   send_dword(slat);
   send_dword(slon);
   send_dword(salt);
   send_rftg_end();
}

// Assembly:
leaq 0x2cef4e(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x680d2
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %r15d
xorl %edi, %edi
callq 0x65636
movl $0x32, %edi
callq 0x5e740
movl %r15d, %edi
callq 0x593b5
movl %r14d, %edi
callq 0x593b5
movl %ebx, %edi
callq 0x593b5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_zod_config(int, double, double, double, unsigned int, int)
void set_zod_config(int mode, double slat,double slon,double salt, u32 traim, int why)
{
S32 val;
u16 pps_suppress;

//sprintf(debug_text2, "set zod config: %d", why);
   if(read_only) return;

   send_zod_start(ZOD_SET_CONFIG, 24, 0);
   send_zod_seq();

   send_word(mode);
   send_word(1);     // power up in posn hold mode
   send_dword((S32) (cable_delay*1.0E9));
   send_word((u16) do_survey);  // hours

   val = (S32) (slat * 1.0E8);    // lat lon alt
   send_dword(val);
   val = (S32) (slon * 1.0E8);
   send_dword(val);
   val = (S32) (salt * 1.0E2);
   send_dword(val);

   pps_suppress = 0;  // !!!! zorky set to 1 to suppress PPS pulses if traim error

   if(time_flags & TFLAGS_UTC) send_word(0x0000 | pps_suppress);  // align to UTC
   else                        send_word(0x0002 | pps_suppress);  // align to GPS

   send_word(0x0007);  // traim alarm due to any time fault

   if(traim == 0) send_word(1);  // traim disabled
   else           send_word(0);  // traim enabled
   send_word(traim/50);

   send_dword(0);  // reserved

   send_zod_end();

   Sleep(200);  // zorky
   query_zod_msg(ZOD_TRAIM_CONFIG_MSG);
}

// Assembly:
leaq 0x2cec46(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x683da
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %r14d
movl $0x4e7, %edi            # imm = 0x4E7
movl $0x18, %esi
xorl %edx, %edx
movsd %xmm2, -0x30(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x20(%rbp)
callq 0x645ec
movzwl 0x30471d(%rip), %edi    # 0x36cb30
callq 0x5936c
movl $0xffff, %r15d          # imm = 0xFFFF
andl %r15d, %r14d
movl %r14d, %edi
callq 0x5936c
movl $0x1, %edi
callq 0x5936c
leaq 0x2a598e(%rip), %rax    # 0x30ddc8
movsd (%rax), %xmm0
mulsd 0xa0be2(%rip), %xmm0    # 0x109028
cvttsd2si %xmm0, %edi
callq 0x593b5
leaq 0x2a5a22(%rip), %rax    # 0x30de78
movzwl (%rax), %edi
callq 0x5936c
movsd -0x20(%rbp), %xmm0
mulsd 0xb5cb5(%rip), %xmm0    # 0x11e120
cvttsd2si %xmm0, %edi
callq 0x593b5
movsd -0x28(%rbp), %xmm0
mulsd 0xb5c9f(%rip), %xmm0    # 0x11e120
cvttsd2si %xmm0, %edi
callq 0x593b5
movsd -0x30(%rbp), %xmm0
mulsd 0xa0bc9(%rip), %xmm0    # 0x109060
cvttsd2si %xmm0, %edi
callq 0x593b5
leaq 0x2a4ffd(%rip), %rax    # 0x30d4a4
movl (%rax), %edi
notl %edi
addl %edi, %edi
andl $0x2, %edi
callq 0x5936c
movl $0x7, %edi
callq 0x5936c
xorl %edi, %edi
testl %ebx, %ebx
sete %dil
callq 0x5936c
movl %ebx, %eax
imulq $0x51eb851f, %rax, %rdi # imm = 0x51EB851F
shrq $0x24, %rdi
andl %r15d, %edi
callq 0x5936c
xorl %edi, %edi
callq 0x593b5
callq 0x646c7
movl $0xc8, %edi
callq 0xaff7
movl $0x41f, %edi            # imm = 0x41F
movl $0x6, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x645ec
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x646c7
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_io_options()
void request_io_options()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x35);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x1d6a1d(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
je 0x68527
retq
leaq 0x2ceaf2(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x68526
leaq 0x1b0396(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x68526
pushq %rbp
movq %rsp, %rbp
movl $0x35, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_io_options(unsigned char, unsigned char, unsigned char, unsigned char)
void set_io_options(u08 posn, u08 vel, u08 timing, u08 aux)
{
   if(read_only) return;
   if(luxor) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x35);
      send_byte(posn);
      send_byte(vel);
      send_byte(timing);
      send_byte(aux);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x2ceabf(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x68561
retq
leaq 0x1d69d6(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x68560
leaq 0x1b035c(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x68560
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %r12d
movl $0x35, %edi
callq 0x5e740
movzbl %r12b, %edi
callq 0x591af
movzbl %r15b, %edi
callq 0x591af
movzbl %r14b, %edi
callq 0x591af
movzbl %bl, %edi
callq 0x591af
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_last_posn()
void request_last_posn()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      if(ACU_GG) ;
      else if(ACU_360) ;
      else if(ACUTIME) ;
      else if(PALISADE) ;
      else if(SV6_FAMILY) return;
      send_tsip_start(0x37);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x1d696d(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
je 0x685d7
retq
leaq 0x2cea42(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x685d6
leaq 0x1b02e6(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x685d6
leaq 0x1b29dd(%rip), %rax    # 0x21afd4
movl (%rax), %eax
movl %eax, %edx
xorl $0x41, %edx
leaq 0x1b02f3(%rip), %rcx    # 0x2188f8
movl (%rcx), %ecx
movl %ecx, %esi
xorl $0x47, %esi
orl %edx, %esi
jne 0x68624
pushq %rbp
movq %rsp, %rbp
movl $0x37, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
cmpl $0x41, %eax
jne 0x68647
cmpl $0x33, %ecx
je 0x68610
cmpl $0x47, %ecx
je 0x68610
cmpl $0x41, %eax
je 0x68610
addl $-0x33, %eax
cmpl $0x1d, %eax
ja 0x68610
movl $0x20004009, %ecx       # imm = 0x20004009
jmp 0x68654
addl $-0x33, %eax
cmpl $0xe, %eax
ja 0x68610
movl $0x4009, %ecx           # imm = 0x4009
btl %eax, %ecx
jb 0x685d6
jmp 0x68610
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_gps_system_msg()
void request_gps_system_msg()
{
  // request GPS system message

   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x28);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x1d68d8(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
je 0x6866c
retq
leaq 0x2ce9ad(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x6866b
leaq 0x1b0251(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x6866b
pushq %rbp
movq %rsp, %rbp
movl $0x28, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_system_data(unsigned char, int)
void request_system_data(u08 mode, int prn)
{
   if(luxor) return;
   if(no_poll) return;
   if(rcvr_type != TSIP_RCVR) return;
   if(have_info == 0) return;

   if(res_t == RES_T) {  // this message can hose up the original res-t for 3 seconds
      if(raw_msg_rate < 3) {  // user can force raw data by setting the rate to 3 secs
         return;
      }
   }

   // mode 2: almanac
   // mode 3: health page
   // mode 4: ionosphere
   // mode 5: UTC params
   // mode 6: ephemeris

   if((prn >= 1) && (prn <= MAX_PRN)) {  // flag that we have asked about this sat
      eph_polled |= (0x01 << (prn-1));
   }

   send_tsip_start(0x38);
   send_byte(0x01);
   send_byte(mode);
   send_byte((u08) prn);
   send_tsip_end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x1d6897(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x686ee
leaq 0x2ce96d(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x686ee
leaq 0x1b0211(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x686ee
leaq 0x2a52a8(%rip), %rax    # 0x30d974
cmpl $0x0, (%rax)
je 0x686ee
movl %esi, %ebx
movl %edi, %r14d
leaq 0x1b0227(%rip), %rax    # 0x218904
cmpb $0x1, (%rax)
jne 0x686f3
leaq 0x1b2c8f(%rip), %rax    # 0x21b378
cmpl $0x3, (%rax)
jge 0x686f3
popq %rbx
popq %r14
popq %rbp
retq
leal -0x1(%rbx), %ecx
cmpl $0x3e6, %ecx            # imm = 0x3E6
ja 0x6870e
movl $0x1, %eax
shll %cl, %eax
leaq 0x2a4d40(%rip), %rcx    # 0x30d44c
orl %eax, (%rcx)
movl $0x38, %edi
callq 0x5e740
movl $0x1, %edi
callq 0x591af
movzbl %r14b, %edi
callq 0x591af
movzbl %bl, %edi
callq 0x591af
popq %rbx
popq %r14
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_health_config(unsigned char, int)
void set_health_config(u08 mode, int prn)
{
   // mode 1: enable sat
   // mode 2: disable sat
   // mode 3: get enable/disable status of all sats
   // mode 4: set sat healthy
   // mode 5: set sat unhealthy
   // mode 6: get health of all sats

   if(read_only) return;
   if(luxor) return;
   if((res_t && (res_t != RES_T))) return;
   if(rcvr_type != TSIP_RCVR) return;

   send_tsip_start(0x39); 
   send_byte(mode);
   send_byte((u08) prn);
   send_tsip_end();
}

// Assembly:
leaq 0x2ce8d7(%rip), %rax    # 0x33701a
leaq 0x1d67f4(%rip), %rcx    # 0x23ef3e
movb (%rcx), %cl
orb (%rax), %cl
je 0x68751
retq
leaq 0x1b01ac(%rip), %rax    # 0x218904
cmpb $0x1, (%rax)
ja 0x68750
leaq 0x1b016c(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x68750
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
movl $0x39, %edi
callq 0x5e740
movzbl %r14b, %edi
callq 0x591af
movzbl %bl, %edi
callq 0x591af
popq %rbx
popq %r14
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_zod_sat_mask(unsigned int)
void set_zod_sat_mask(u32 val)
{
   if(read_only) return;

   send_zod_start(ZOD_SET_SAT_MASK, 10, 0);
   send_zod_seq();
   send_dword(val);
   send_word(0);     // don't write to EEPROM
   send_zod_end();

   query_zod_msg(ZOD_SETTINGS_MSG);
}

// Assembly:
leaq 0x2cd904(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6971c
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x4bd, %edi            # imm = 0x4BD
movl $0xa, %esi
xorl %edx, %edx
callq 0x645ec
movzwl 0x3033f4(%rip), %edi    # 0x36cb30
callq 0x5936c
movl %ebx, %edi
callq 0x593b5
xorl %edi, %edi
callq 0x5936c
callq 0x646c7
movl $0x3f4, %edi            # imm = 0x3F4
movl $0x6, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x645ec
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x646c7
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_eph_status(int)
void request_eph_status(int prn)
{
   if(res_t) return;
   if(luxor) return;
   if(no_poll) return;
   if(rcvr_type != TSIP_RCVR) return;

   send_tsip_start(0x3B);
   send_byte((u08) prn);
   send_tsip_end();
}

// Assembly:
leaq 0x1af18a(%rip), %rax    # 0x218904
cmpb $0x0, (%rax)
jne 0x697c9
leaq 0x1d57b8(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x697c9
leaq 0x2cd88e(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x697c9
leaq 0x1af132(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x697c9
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x3b, %edi
callq 0x5e740
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_last_raw(int)
void request_last_raw(int prn)
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x3A);
      send_byte((u08) prn);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x1d576d(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
je 0x697d7
retq
leaq 0x2cd842(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x697d6
leaq 0x1af0e6(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x697d6
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x3a, %edi
callq 0x5e740
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_sat_status(int)
void request_sat_status(int prn)
{
   if(luxor) return;
   if(no_poll) return;
   if(rcvr_type != TSIP_RCVR) return;

   send_tsip_start(0x3C);
   send_byte((u08) prn);
   send_tsip_end();
}

// Assembly:
leaq 0x1d5722(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x6985f
leaq 0x2cd7f8(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x6985f
leaq 0x1af09c(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x6985f
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x3c, %edi
callq 0x5e740
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_eeprom_status()
void request_eeprom_status()
{
   if(luxor) return;
   if(no_poll) return;
   if(rcvr_type != TSIP_RCVR) return;
   if(ACU_GG) return;
   if(ACU_360) return;
   if(ACUTIME) ;
   else if(PALISADE) return;
   else if(SV6_FAMILY) return;
   if(res_t) return;          // !!! Thunderbolt only
   if(saw_ntpx) return;

   send_tsip_start(0x3F);
   send_byte(0x11);
   send_tsip_end();
}

// Assembly:
leaq 0x1d56d7(%rip), %rax    # 0x23ef3e
leaq 0x2cd7b2(%rip), %rcx    # 0x337020
movb (%rcx), %cl
orb (%rax), %cl
setne %al
leaq 0x1af054(%rip), %rcx    # 0x2188d0
movq (%rcx), %rcx
cmpq $0x1, %rcx
setne %dl
orb %al, %dl
jne 0x698aa
leaq 0x1b1743(%rip), %rax    # 0x21afd4
movl (%rax), %eax
movl %eax, %esi
xorl $0x41, %esi
leaq 0x1af059(%rip), %rdx    # 0x2188f8
movl (%rdx), %edx
movl %edx, %edi
xorl $0x47, %edi
orl %esi, %edi
jne 0x698ab
retq
cmpl $0x41, %eax
jne 0x698ba
cmpl $0x33, %edx
je 0x698aa
cmpl $0x47, %edx
je 0x698aa
cmpl $0x41, %eax
sete %dl
cmpq $0x1, %rcx
sete %sil
testb %dl, %sil
je 0x698ff
leaq 0x1af030(%rip), %rax    # 0x218904
leaq 0x1d5661(%rip), %rcx    # 0x23ef3c
movb (%rcx), %cl
orb (%rax), %cl
jne 0x698aa
pushq %rbp
movq %rsp, %rbp
movl $0x3f, %edi
callq 0x5e740
movl $0x11, %edi
callq 0x591af
popq %rbp
jmp 0x5e7c0
cmpq $0x1, %rcx
sete %dl
cmpl $0x50, %eax
sete %sil
testb %sil, %dl
jne 0x698aa
cmpq $0x1, %rcx
jne 0x698cd
leaq 0x1aefe5(%rip), %rcx    # 0x218904
cmpb $0x0, (%rcx)
jne 0x698aa
addl $-0x33, %eax
cmpl $0x1d, %eax
ja 0x6993a
movl $0x20004009, %ecx       # imm = 0x20004009
btl %eax, %ecx
jb 0x698aa
leaq 0x1d55fb(%rip), %rax    # 0x23ef3c
cmpb $0x0, (%rax)
jne 0x698aa
jmp 0x698e1
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_diff_mode()
void request_diff_mode()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x62);
      send_byte(0xFF);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x1d55eb(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
je 0x69959
retq
leaq 0x2cd6c0(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x69958
leaq 0x1aef64(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x69958
pushq %rbp
movq %rsp, %rbp
movl $0x62, %edi
callq 0x5e740
movl $0xff, %edi
callq 0x591af
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_diff_mode(unsigned char)
void set_diff_mode(u08 mode)
{
   if(read_only) return;
   if(luxor) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x62);
      send_byte(mode);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x2cd683(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6999d
retq
leaq 0x1d559a(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x6999c
leaq 0x1aef20(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x6999c
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x62, %edi
callq 0x5e740
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_posn_filter()
void request_posn_filter()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x71);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x1d555c(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
je 0x699e8
retq
leaq 0x2cd631(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x699e7
leaq 0x1aeed5(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x699e7
pushq %rbp
movq %rsp, %rbp
movl $0x71, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_alt_filter()
void request_alt_filter()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x73);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x1d5522(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
je 0x69a22
retq
leaq 0x2cd5f7(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x69a21
leaq 0x1aee9b(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x69a21
pushq %rbp
movq %rsp, %rbp
movl $0x73, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_high8_mode()
void request_high8_mode()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x75);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x1d54e8(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
je 0x69a5c
retq
leaq 0x2cd5bd(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x69a5b
leaq 0x1aee61(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x69a5b
pushq %rbp
movq %rsp, %rbp
movl $0x75, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_high6_mode()
void request_high6_mode()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x76);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x1d54ae(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
je 0x69a96
retq
leaq 0x2cd583(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x69a95
leaq 0x1aee27(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x69a95
pushq %rbp
movq %rsp, %rbp
movl $0x76, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_diff_age()
void request_diff_age()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x77);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x1d5474(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
je 0x69ad0
retq
leaq 0x2cd549(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x69acf
leaq 0x1aeded(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x69acf
pushq %rbp
movq %rsp, %rbp
movl $0x77, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_filter_config()
void request_filter_config()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == TSIP_RCVR) {
      if(ACU_GG) return;
      if(ACU_360) return;
      if(ACUTIME) return;     // responds to filter commands, but settings do not stick
      if(PALISADE) return;

      if(ACUTIME) {
         send_tsip_start(0x70);
         send_tsip_end();
      }
      else if(SV6_FAMILY) {
         request_alt_filter();
         request_posn_filter();
      }
      else {
         send_tsip_start(0x70);
         send_tsip_end();
      }
   }
   else if(rcvr_type == MOTO_RCVR) {
      send_moto_start("AN");  // marine (velocity) filter
      send_byte(0xFF);
      send_moto_end();

      send_moto_start("AQ");  // position filter
      send_byte(0xFF);
      send_moto_end();

      send_moto_start("Aq");  // ionosphere corrections
      send_byte(0xFF);
      send_moto_end();

      send_moto_start("Ar");  // fix type
      send_byte(0xFF);
      send_moto_end();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1d5436(%rip), %rax    # 0x23ef3e
leaq 0x2cd511(%rip), %rcx    # 0x337020
movb (%rcx), %cl
orb (%rax), %cl
jne 0x69b72
leaq 0x1aedb4(%rip), %rax    # 0x2188d0
movq (%rax), %rax
cmpq $0x20, %rax
je 0x69b74
cmpq $0x1, %rax
jne 0x69b72
leaq 0x1b14a2(%rip), %rcx    # 0x21afd4
movl (%rcx), %ecx
movl %ecx, %esi
xorl $0x41, %esi
leaq 0x1aedb8(%rip), %rdx    # 0x2188f8
movl (%rdx), %edx
movl %edx, %edi
xorl $0x47, %edi
orl %esi, %edi
je 0x69b72
cmpl $0x41, %ecx
jne 0x69b5a
cmpl $0x33, %edx
je 0x69b72
cmpl $0x47, %edx
je 0x69b72
cmpl $0x41, %ecx
sete %dl
cmpl $0x50, %ecx
sete %sil
cmpq $0x1, %rax
jne 0x69be1
orb %sil, %dl
je 0x69be1
popq %rbp
retq
leaq 0xba652(%rip), %rdi     # 0x1241cd
callq 0x61694
movl $0xff, %edi
callq 0x591af
callq 0x6170f
leaq 0xb7110(%rip), %rdi     # 0x120ca6
callq 0x61694
movl $0xff, %edi
callq 0x591af
callq 0x6170f
leaq 0xb70f8(%rip), %rdi     # 0x120ca9
callq 0x61694
movl $0xff, %edi
callq 0x591af
callq 0x6170f
leaq 0xb70e0(%rip), %rdi     # 0x120cac
callq 0x61694
movl $0xff, %edi
callq 0x591af
popq %rbp
jmp 0x6170f
cmpq $0x1, %rax
jne 0x69c04
addl $-0x33, %ecx
cmpl $0x1d, %ecx
ja 0x69c04
movl $0x20004009, %eax       # imm = 0x20004009
btl %ecx, %eax
jae 0x69c04
callq 0x69a15
popq %rbp
jmp 0x699db
movl $0x70, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_posn_filter(unsigned char, unsigned char)
void set_posn_filter(u08 static_mode, u08 dynamic_mode)
{
u08 val;

   if(read_only) return;
   if(luxor) return;

   if(rcvr_type == TSIP_RCVR) {
      if(static_mode || dynamic_mode) val = 1;
      else val = 0;
      send_tsip_start(0x71);
      send_byte(val);
      if(dynamic_mode) send_single(0.0625F);
      else             send_single(1.0F);
      send_byte(1);
      send_byte(1);
      send_byte(0);
      send_byte(6);
      send_single(0.1F);
      send_single(100.0F);
      send_single(1.21F);
      send_single(1.0E6F);
      if(static_mode) send_byte(6);
      else            send_byte(255);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x2cd3ff(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x69d07
leaq 0x1d5313(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x69d07
leaq 0x1aec95(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x69d07
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r15d, %r15d
testb %sil, %sil
sete %r15b
xorl %r14d, %r14d
orb %bl, %sil
setne %r14b
movl $0x71, %edi
callq 0x5e740
movl %r14d, %edi
callq 0x591af
leaq 0xb44aa(%rip), %rax     # 0x11e128
movss (%rax,%r15,4), %xmm0
callq 0x59440
movl $0x1, %edi
callq 0x591af
movl $0x1, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
movl $0x6, %r14d
movl $0x6, %edi
callq 0x591af
movss 0xb4cd8(%rip), %xmm0    # 0x11e994
callq 0x59440
movss 0xa330f(%rip), %xmm0    # 0x10cfd8
callq 0x59440
movss 0xb4cc2(%rip), %xmm0    # 0x11e998
callq 0x59440
movss 0xb4cb9(%rip), %xmm0    # 0x11e99c
callq 0x59440
testb %bl, %bl
movl $0xff, %edi
cmovnel %r14d, %edi
callq 0x591af
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5e7c0
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_alt_filter(unsigned char)
void set_alt_filter(u08 mode)
{
   if(read_only) return;
   if(luxor) return;

   // mode > 1: filter count
   // mode = 1: filter off
   // mode = 0: filter default
   if(mode) mode = 0;
   else     mode = 1;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x73);
      send_single((float) mode);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x2cd176(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x69ed4
leaq 0x1d508e(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x69ed4
leaq 0x1aea14(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x69ed4
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb %dil, %dil
je 0x69ed5
xorps %xmm0, %xmm0
jmp 0x69edd
retq
movss 0xa30f7(%rip), %xmm0    # 0x10cfd4
movss %xmm0, -0x4(%rbp)
movl $0x73, %edi
callq 0x5e740
movss -0x4(%rbp), %xmm0
callq 0x59440
addq $0x10, %rsp
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_high8_mode(unsigned char)
void set_high8_mode(u08 mode)
{
   if(read_only) return;
   if(luxor) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x75);
      send_single((float) mode);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x2cd113(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x69f0d
retq
leaq 0x1d502a(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x69f0c
leaq 0x1ae9b0(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x69f0c
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x75, %edi
callq 0x5e740
movzbl %bl, %eax
cvtsi2ss %eax, %xmm0
callq 0x59440
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_high6_mode(unsigned char)
void set_high6_mode(u08 mode)
{
   if(read_only) return;
   if(luxor) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x76);
      send_single((float) mode);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x2cd0c4(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x69f5c
retq
leaq 0x1d4fdb(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x69f5b
leaq 0x1ae961(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x69f5b
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x76, %edi
callq 0x5e740
movzbl %bl, %eax
cvtsi2ss %eax, %xmm0
callq 0x59440
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_diff_age(unsigned short)
void set_diff_age(u16 age)
{
   if(read_only) return;
   if(luxor) return;

   if(rcvr_type == TSIP_RCVR) {
      send_tsip_start(0x77);
      send_word(age);
      send_tsip_end();
   }
}

// Assembly:
leaq 0x2cd075(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x69fab
retq
leaq 0x1d4f8c(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x69faa
leaq 0x1ae912(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x69faa
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x77, %edi
callq 0x5e740
movzwl %bx, %edi
callq 0x5936c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: send_rt17_start(int, int)
void send_rt17_start(int msg, int len)
{
// flush_rt17_cmd();   // toots - RT17 fix needed
if(debug_file) fprintf(debug_file, "send rt17: %02x  len:%d\n", msg, len);

   send_byte(0x02);
   rt17_tx_cksum = 0;

   send_byte(0x00);   // status
   send_byte(msg);    // msg type
   send_byte(len);    // header len
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
leaq 0x1d434f(%rip), %rax    # 0x23e390
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6a05c
leaq 0xb8a32(%rip), %rsi     # 0x122a82
movl %r14d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x9560
movl $0x2, %edi
callq 0x591af
movb $0x0, 0x302a53(%rip)    # 0x36cac0
xorl %edi, %edi
callq 0x591af
movl $0xff, %r15d
andl %r15d, %r14d
movl %r14d, %edi
callq 0x591af
andl %r15d, %ebx
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x591af
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_gnss_system()
void request_gnss_system()
{
   // request the current GNSS system selections
   if(no_poll) return;
   if(luxor) return;

   if(rcvr_type == ESIP_RCVR) {
      send_esip_cmd("PERDAPI,GNSS,QUERY");
   }
   else if(rcvr_type == NVS_RCVR) {
      send_nvs_start(0x0D);  // gnss system info
      send_byte(0x02);
      send_nvs_end();
   }
   else if(rcvr_type == TSIP_RCVR) {
      if(PALISADE) return;
      if(SV6_FAMILY) return;

      if(saw_icm || (res_t == RES_T_360) || ACU_GG || ACU_360) {
         request_rcvr_config(666);
      }
   }
   else if(rcvr_type == UBX_RCVR) {
      request_ubx_msg(UBX_GNSS);
   }
   else if(rcvr_type == VENUS_RCVR) {
      query_venus_msg(QUERY_VENUS_GNSS);
      query_venus_msg(QUERY_VENUS_SBAS);
      query_venus_msg(QUERY_VENUS_QZSS);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2ccf3d(%rip), %rax    # 0x337020
leaq 0x1d4e54(%rip), %rcx    # 0x23ef3e
movb (%rcx), %cl
orb (%rax), %cl
je 0x6a0f2
popq %rbp
retq
leaq 0x1ae7d7(%rip), %rax    # 0x2188d0
movq (%rax), %rax
cmpq $0x7f, %rax
jle 0x6a12d
cmpq $0x80, %rax
je 0x6a14f
cmpq $0x800, %rax            # imm = 0x800
je 0x6a1aa
movl $0x80000000, %ecx       # imm = 0x80000000
cmpq %rcx, %rax
jne 0x6a0f0
leaq 0xb770a(%rip), %rdi     # 0x121831
popq %rbp
jmp 0x5ef13
cmpq $0x1, %rax
je 0x6a1c4
cmpq $0x4, %rax
jne 0x6a0f0
movl $0x63e, %edi            # imm = 0x63E
xorl %esi, %esi
callq 0x5f3f5
popq %rbp
jmp 0x5f4ce
movl $0x64, %edi
movl $0x2, %esi
callq 0x5fbb4
movl $0x1a, %edi
callq 0x591af
callq 0x61bc3
movl $0x62, %edi
movl $0x2, %esi
callq 0x5fbb4
movl $0x2, %edi
callq 0x591af
callq 0x61bc3
movl $0x62, %edi
movl $0x2, %esi
callq 0x5fbb4
movl $0x4, %edi
callq 0x591af
popq %rbp
jmp 0x61bc3
movl $0xd, %edi
callq 0x5e740
movl $0x2, %edi
callq 0x591af
popq %rbp
jmp 0x5e844
leaq 0x1b0e09(%rip), %rcx    # 0x21afd4
movl (%rcx), %ecx
leal -0x33(%rcx), %edx
cmpl $0x1d, %edx
ja 0x6a1e3
movl $0x20004009, %esi       # imm = 0x20004009
btl %edx, %esi
jb 0x6a0f0
leaq 0x1d4d43(%rip), %rdx    # 0x23ef2d
cmpb $0x0, (%rdx)
jne 0x6a21d
leaq 0x1ae70e(%rip), %rdx    # 0x218904
cmpb $0x4, (%rdx)
je 0x6a21d
cmpq $0x1, %rax
sete %al
cmpl $0x41, %ecx
sete %cl
andb %al, %cl
leaq 0x1ae6e7(%rip), %rax    # 0x2188f8
movl (%rax), %eax
cmpl $0x47, %eax
sete %dl
testb %dl, %cl
je 0x6a228
movl $0x29a, %edi            # imm = 0x29A
popq %rbp
jmp 0x66617
testb %cl, %cl
je 0x6a0f0
cmpl $0x47, %eax
je 0x6a21d
cmpl $0x33, %eax
je 0x6a21d
jmp 0x6a0f0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_ubx_amu(float)
void set_ubx_amu(float amu)
{
   if(read_only) return;

   send_ubx_start(UBX_NAVX5, 40);

   send_word(0);      // msg version
   send_word(0x0008); // only update amu mask 
   send_dword(0);
   send_byte(0);      // rsvd
   send_byte(0);      // rsvd
   send_byte(1);      // min sv
   send_byte(16);     // max sv
   send_byte((s08) amu);
   send_byte(0);      // rsvd
   send_byte(0);      // initial fix
   send_byte(0);      // rsvd
   send_byte(0);      // rsvd
   send_byte(0);      // rsvd
   send_word(0);      // rollover week
   send_dword(0);     // rsvd
   send_dword(0);     // rsvd
   send_dword(0);     // rsvd
   send_dword(0);     // rsvd
   send_dword(0);     // rsvd

   send_ubx_end();
}

// Assembly:
leaq 0x2ccdd4(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x6a24c
retq
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x623, %edi            # imm = 0x623
movl $0x28, %esi
movss %xmm0, -0x4(%rbp)
callq 0x5f3f5
xorl %edi, %edi
callq 0x5936c
movl $0x8, %edi
callq 0x5936c
xorl %edi, %edi
callq 0x593b5
xorl %edi, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
movl $0x1, %edi
callq 0x591af
movl $0x10, %edi
callq 0x591af
cvttss2si -0x4(%rbp), %eax
movzbl %al, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
xorl %edi, %edi
callq 0x5936c
xorl %edi, %edi
callq 0x593b5
xorl %edi, %edi
callq 0x593b5
xorl %edi, %edi
callq 0x593b5
xorl %edi, %edi
callq 0x593b5
xorl %edi, %edi
callq 0x593b5
addq $0x10, %rsp
popq %rbp
jmp 0x5f4ce
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rcvr_smoothing(int)
void set_rcvr_smoothing(int val)
{
   if(read_only) return;

   if(rcvr_type == FURUNO_RCVR) {
      if((val >= 1) && (val <= 3)) {
         sprintf(out, "GPset,W%d", val);
         send_furuno_cmd(out);
         send_furuno_cmd("GPsrq");
      }
   }
}

// Assembly:
movl %edi, %edx
leal -0x1(%rdx), %eax
cmpl $0x2, %eax
ja 0x6a695
leaq 0x2cc9d2(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
jne 0x6a695
leaq 0x1ae27c(%rip), %rax    # 0x2188d0
cmpq $0x20000000, (%rax)     # imm = 0x20000000
jne 0x6a695
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2d1bb6(%rip), %rbx    # 0x33c220
leaq 0xb6875(%rip), %rsi     # 0x120ee6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
callq 0x5f070
leaq 0xb6367(%rip), %rdi     # 0x1209f1
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5f070
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_serial_config(unsigned char)
void request_serial_config(u08 port)
{
   if(luxor) return;
   if(no_poll) return;
   if(rcvr_type != TSIP_RCVR) return;

   send_tsip_start(0xBC);
   send_byte(port);
   send_tsip_end();
}

// Assembly:
leaq 0x1d48a1(%rip), %rax    # 0x23ef3e
cmpb $0x0, (%rax)
jne 0x6a6e0
leaq 0x2cc977(%rip), %rax    # 0x337020
cmpb $0x0, (%rax)
jne 0x6a6e0
leaq 0x1ae21b(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x6a6e0
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0xbc, %edi
callq 0x5e740
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: set_trimble_protocol(int, int, int, int, int, int)
int set_trimble_protocol(int baud,int data_bits,int parity,int stop_bits, int in_prot,int out_prot)
{
   if(read_only) return 2;
   if(rcvr_type != TSIP_RCVR) return 2;

   // in_prot, out_prot:  2=TSIP  4=NMEA
   in_prot = out_prot = 2;  // !!!! always use TSIP

   if     (baud == 4800)   baud = 6;
   else if(baud == 9600)   baud = 7;
   else if(baud == 19200)  baud = 8;
   else if(baud == 38400)  baud = 9;
   else if(baud == 57600)  baud = 10;
   else if(baud == 115200) baud = 11;
   else return 1;

   data_bits = 3;   // !!!! we always use 8 bits

   if     (parity == ODD_PAR)  parity = 1;
   else if(parity == EVEN_PAR) parity = 2;
   else                        parity = 0;

   if(stop_bits == 2) stop_bits = 1;
   else               stop_bits = 0;

   send_tsip_start(0xBC);
   send_byte(0xFF);       // current com port (0=main com)
   send_byte(baud);       // 9600 baud
   send_byte(baud);       // 9600 baud
   send_byte(3);          // 8-bit
   send_byte(parity);     // no parity
   send_byte(stop_bits);  // 1 stop bit
   send_byte(0);          // rsvd (flow control)
   send_byte(in_prot);    // 2=tsip 4=nmea
   send_byte(out_prot);   // 
   send_byte(0);          // rsvd
   send_tsip_end();

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2cc928(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
movl $0x2, %ebx
jne 0x6a7f8
leaq 0x1ae1c9(%rip), %rax    # 0x2188d0
cmpq $0x1, (%rax)
jne 0x6a7f8
movl $0x1, %ebx
cmpl $0x95ff, %edi           # imm = 0x95FF
jg 0x6a73f
cmpl $0x12c0, %edi           # imm = 0x12C0
je 0x6a760
cmpl $0x2580, %edi           # imm = 0x2580
je 0x6a76a
cmpl $0x4b00, %edi           # imm = 0x4B00
jne 0x6a7f8
movb $0x8, %r14b
jmp 0x6a772
cmpl $0x9600, %edi           # imm = 0x9600
je 0x6a765
cmpl $0xe100, %edi           # imm = 0xE100
je 0x6a76f
cmpl $0x1c200, %edi          # imm = 0x1C200
jne 0x6a7f8
movb $0xb, %r14b
jmp 0x6a772
movb $0x6, %r14b
jmp 0x6a772
movb $0x9, %r14b
jmp 0x6a772
movb $0x7, %r14b
jmp 0x6a772
movb $0xa, %r14b
cmpl $0x2, %edx
sete %al
addb %al, %al
cmpl $0x1, %edx
movzbl %al, %r15d
cmovel %edx, %r15d
xorl %ebx, %ebx
cmpl $0x2, %ecx
sete %bl
movl $0xbc, %edi
callq 0x5e740
movl $0xff, %edi
callq 0x591af
movzbl %r14b, %r14d
movl %r14d, %edi
callq 0x591af
movl %r14d, %edi
callq 0x591af
movl $0x3, %edi
callq 0x591af
movzbl %r15b, %edi
callq 0x591af
movl %ebx, %edi
callq 0x591af
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x591af
movl $0x2, %edi
callq 0x591af
movl $0x2, %edi
callq 0x591af
xorl %edi, %edi
callq 0x591af
callq 0x5e7c0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: request_datum()
void request_datum()
{
   if(luxor) return;
   if(no_poll) return;

   if(rcvr_type == FURUNO_RCVR) {
//      send_furuno_cmd("GPsrq");  // we get this from request_rcvr_config()
   }
   else if(rcvr_type == MOTO_RCVR) {
      send_moto_start("Ao");
      send_byte(0xFF);
      send_moto_end();
   }
   else if(rcvr_type == TSIP_RCVR) {
      if(SV6_FAMILY && !ACU_GG && !ACU_360) return;
      send_tsip_start(0x8E);
      send_byte(0x15);
      send_tsip_end();
   }
   else if(rcvr_type == UBX_RCVR) {
      request_ubx_msg(UBX_DATUM);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1d4728(%rip), %rax    # 0x23ef3e
leaq 0x2cc803(%rip), %rcx    # 0x337020
movb (%rcx), %cl
orb (%rax), %cl
setne %cl
leaq 0x1ae0a5(%rip), %rax    # 0x2188d0
movq (%rax), %rax
cmpq $0x20000000, %rax       # imm = 0x20000000
sete %dl
orb %cl, %dl
je 0x6a83d
popq %rbp
retq
cmpq $0x1, %rax
je 0x6a87d
cmpq $0x4, %rax
je 0x6a86b
cmpq $0x20, %rax
jne 0x6a83b
leaq 0xb669a(%rip), %rdi     # 0x120ef0
callq 0x61694
movl $0xff, %edi
callq 0x591af
popq %rbp
jmp 0x6170f
movl $0x606, %edi            # imm = 0x606
xorl %esi, %esi
callq 0x5f3f5
popq %rbp
jmp 0x5f4ce
leaq 0x1b0750(%rip), %rax    # 0x21afd4
movl (%rax), %eax
leal -0x33(%rax), %ecx
cmpl $0x1d, %ecx
ja 0x6a8af
movl $0x20004009, %edx       # imm = 0x20004009
btl %ecx, %edx
jae 0x6a8af
movl %eax, %edx
xorl $0x41, %edx
leaq 0x1ae054(%rip), %rcx    # 0x2188f8
movl (%rcx), %ecx
movl %ecx, %esi
xorl $0x47, %esi
orl %edx, %esi
jne 0x6a8c9
movl $0x8e, %edi
callq 0x5e740
movl $0x15, %edi
callq 0x591af
popq %rbp
jmp 0x5e7c0
cmpl $0x41, %eax
jne 0x6a83b
cmpl $0x47, %ecx
je 0x6a8af
cmpl $0x33, %ecx
je 0x6a8af
jmp 0x6a83b