LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_nvs_mode()
void parse_nvs_mode()
{
u08 mode;
double delay;
int avg_time;

   // 0x55 packet
   log_packet_id("nvs_mode");

   mode = tsip_byte();
   delay = tsip_double();
   avg_time = (int) tsip_word();

   if(mode == 0) {
      if(nvs_traim & 0x04) rcvr_mode = RCVR_MODE_3D;
      else                 rcvr_mode = RCVR_MODE_2D_3D;
   }
   else if(mode == 1) rcvr_mode = RCVR_MODE_HOLD;
   else if(mode == 2) rcvr_mode = RCVR_MODE_SURVEY;
   else               rcvr_mode = RCVR_MODE_UNKNOWN;

   if(mode == 2) {
      minor_alarms |= MINOR_SURVEY;
      do_survey = avg_time;
      survey_why = 33;
   }
   else {
      minor_alarms &= (~MINOR_SURVEY);
      if(precision_survey == 0) {
         do_survey = 0;
         survey_why = (-333);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x7d839(%rip), %rdi     # 0x125fb0
callq 0x58dc2
callq 0x587be
movl %eax, %ebx
cmpl $0x100, %eax            # imm = 0x100
jb 0xa8794
leaq 0x1967df(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
callq 0x58b08
callq 0x588d2
cmpb $0x2, %bl
je 0xa87c0
movzbl %bl, %eax
cmpl $0x1, %eax
je 0xa87bc
testl %eax, %eax
jne 0xa87de
leaq 0x172916(%rip), %rax    # 0x21b0cc
movb (%rax), %al
andb $0x4, %al
jmp 0xa87e0
movb $0x7, %al
jmp 0xa87e0
leaq 0x264a11(%rip), %rcx    # 0x30d1d8
orb $0x20, (%rcx)
leaq 0x2648ff(%rip), %rcx    # 0x30d0d0
movb $0xb, (%rcx)
movzwl %ax, %ecx
movl $0x21, %eax
jmp 0xa8806
movb $0x63, %al
leaq 0x2648e9(%rip), %rcx    # 0x30d0d0
leaq 0x2649ea(%rip), %rdx    # 0x30d1d8
andb $-0x21, (%rdx)
movb %al, (%rcx)
leaq 0x26569e(%rip), %rax    # 0x30de98
cmpb $0x0, (%rax)
jne 0xa8819
movl $0xfffffeb3, %eax       # imm = 0xFFFFFEB3
xorl %ecx, %ecx
leaq 0x26566b(%rip), %rdx    # 0x30de78
movq %rcx, (%rdx)
leaq 0x265671(%rip), %rcx    # 0x30de88
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_nvs_dops()
void parse_nvs_dops()
{
int gps_count;
int glonass_count;

   // 0x60 packet
   log_packet_id("nvs_dops");

   gps_count = tsip_byte();
   glonass_count = tsip_byte();
   hdop = tsip_single();
   vdop = tsip_single();
   have_dops |= (HDOP | VDOP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7d78e(%rip), %rdi     # 0x125fb9
callq 0x58dc2
callq 0x587be
cmpl $0x100, %eax            # imm = 0x100
jb 0xa8846
leaq 0x19672d(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
callq 0x587be
cmpl $0x100, %eax            # imm = 0x100
jb 0xa885c
leaq 0x196717(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
callq 0x58a30
cvtss2sd %xmm0, %xmm0
leaq 0x17ac84(%rip), %rax    # 0x2234f0
movsd %xmm0, (%rax)
callq 0x58a30
cvtss2sd %xmm0, %xmm0
leaq 0x17ac78(%rip), %rax    # 0x2234f8
movsd %xmm0, (%rax)
leaq 0x17ac59(%rip), %rax    # 0x2234e4
orb $0x6, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_nvs_pvtdops()
void parse_nvs_pvtdops()
{
   // 0x61 packet
   log_packet_id("nvs_pvtdops");

   hdop = tsip_single();
   vdop = tsip_single();
   tdop = tsip_single();
   // we ignore the rest of this message
   have_dops |= (HDOP | VDOP | TDOP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7d727(%rip), %rdi     # 0x125fc2
callq 0x58dc2
callq 0x58a30
cvtss2sd %xmm0, %xmm0
leaq 0x17ac40(%rip), %rax    # 0x2234f0
movsd %xmm0, (%rax)
callq 0x58a30
cvtss2sd %xmm0, %xmm0
leaq 0x17ac34(%rip), %rax    # 0x2234f8
movsd %xmm0, (%rax)
callq 0x58a30
cvtss2sd %xmm0, %xmm0
leaq 0x17ac30(%rip), %rax    # 0x223508
movsd %xmm0, (%rax)
leaq 0x17ac01(%rip), %rax    # 0x2234e4
orb $0x16, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_nvs_version()
void parse_nvs_version()
{
int i;

   // 0x70 packet
   log_packet_id("nvs_version");

   nvs_chans = tsip_byte();
   for(i=0; i<21; i++) {  // version string
      nvs_id[i] = tsip_byte();
      nvs_id[i+1] = 0;
   }
   nvs_sn = tsip_dword();

   for(i=0; i<21; i++) {  // version string
      nvs_id2[i] = tsip_byte();
      nvs_id2[i+1] = 0;
   }
   nvs_sn2 = tsip_dword();

   for(i=0; i<21; i++) {  // version string
      nvs_id3[i] = tsip_byte();
      nvs_id3[i+1] = 0;
   }
   nvs_sn3 = tsip_dword();

   saw_version |= 0x2000;
   have_info |= ALL_ID_INFO;

   // we ignore the rest of this message
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x7d6d5(%rip), %rdi     # 0x125fce
callq 0x58dc2
callq 0x587be
cmpl $0x100, %eax            # imm = 0x100
jb 0xa8914
leaq 0x19665f(%rip), %rcx    # 0x23ef70
orb $0x8, (%rcx)
movzbl %al, %eax
leaq 0x1726a6(%rip), %rcx    # 0x21afc4
movl %eax, (%rcx)
movl $0x1, %r14d
leaq 0x172613(%rip), %r15    # 0x21af40
leaq 0x19663c(%rip), %rbx    # 0x23ef70
callq 0x587be
cmpl $0x100, %eax            # imm = 0x100
jb 0xa8943
orb $0x8, (%rbx)
movb %al, -0x1(%r15,%r14)
movb $0x0, (%r15,%r14)
incq %r14
cmpq $0x16, %r14
jne 0xa8934
callq 0x58964
leaq 0x1725fe(%rip), %rcx    # 0x21af60
movl %eax, (%rcx)
movl $0x1, %r14d
leaq 0x1725ff(%rip), %r15    # 0x21af70
callq 0x587be
cmpl $0x100, %eax            # imm = 0x100
jb 0xa8980
orb $0x8, (%rbx)
movb %al, -0x1(%r15,%r14)
movb $0x0, (%r15,%r14)
incq %r14
cmpq $0x16, %r14
jne 0xa8971
callq 0x58964
leaq 0x1725f1(%rip), %rcx    # 0x21af90
movl %eax, (%rcx)
movl $0x1, %r14d
leaq 0x1725f2(%rip), %r15    # 0x21afa0
callq 0x587be
cmpl $0x100, %eax            # imm = 0x100
jb 0xa89bd
orb $0x8, (%rbx)
movb %al, -0x1(%r15,%r14)
movb $0x0, (%r15,%r14)
incq %r14
cmpq $0x16, %r14
jne 0xa89ae
callq 0x58964
leaq 0x1725e4(%rip), %rcx    # 0x21afc0
movl %eax, (%rcx)
leaq 0x264a23(%rip), %rax    # 0x30d408
orb $0x20, 0x1(%rax)
leaq 0x264f84(%rip), %rax    # 0x30d974
orb $0xf, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_nvs_time()
void parse_nvs_time()
{
double msecs;
u08 scale;
int week;
int i;
double gen_dev;
double time_dev;

   // 0x72 packet
   log_packet_id("nvs_time");

   nvs_msecs = msecs = tsip_fp80(); //  - 67108864.0;  // qqqqqqqqqqqqqq - 67....
   week = (int) (s16) tsip_word();
   scale = tsip_byte();
   gen_dev = tsip_double();   // ref gen deviation
   time_dev = tsip_double();  // sawtooth
   i = (int) (s16) tsip_word();
   if(!user_set_utc_ofs) {
      utc_offset = i;
      check_utc_ofs(12);
   }

   tsip_byte();
   tsip_word();

   dac_voltage = (float) time_dev;
   have_sawtooth = 6666;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x7d5cd(%rip), %rdi     # 0x125fda
callq 0x58dc2
callq 0x58ba0
movsd %xmm0, 0x2c40f1(%rip)   # 0x36cb10
callq 0x588d2
callq 0x587be
cmpl $0x100, %eax            # imm = 0x100
jb 0xa8a3a
leaq 0x196539(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
callq 0x58b08
callq 0x58b08
movsd %xmm0, -0x8(%rbp)
callq 0x588d2
leaq 0x264cdf(%rip), %rcx    # 0x30d734
cmpl $0x0, (%rcx)
jne 0xa8aa8
movswl %ax, %ecx
leaq 0x264cc4(%rip), %rdx    # 0x30d728
movl %ecx, (%rdx)
leaq 0x2648af(%rip), %rcx    # 0x30d31c
cmpl $0x0, (%rcx)
jne 0xa8aa8
leaq 0x264a9b(%rip), %rdx    # 0x30d514
cmpl $0x7e1, (%rdx)          # imm = 0x7E1
setge %dl
cmpw $0x12, %ax
setl %sil
cmpw $0x11, %ax
jl 0xa8aa8
andb %dl, %sil
jne 0xa8aa8
leaq 0x16fda8(%rip), %rax    # 0x218844
movl $0x7dc, (%rax)          # imm = 0x7DC
movl $0xc, (%rcx)
callq 0x587be
cmpl $0x100, %eax            # imm = 0x100
jb 0xa8abe
leaq 0x1964b5(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
callq 0x588d2
xorps %xmm0, %xmm0
cvtsd2ss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x263f2a(%rip), %rax    # 0x30ca00
movsd %xmm0, (%rax)
leaq 0x2648e3(%rip), %rax    # 0x30d3c4
movl $0x1a0a, (%rax)         # imm = 0x1A0A
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_nvs_survey()
void parse_nvs_survey()
{
u08 mode;
double delay;
int avg_time;

   // 0x73 packet
   log_packet_id("nvs_survey");

   mode = tsip_byte();
   delay = tsip_double();
   avg_time = (int) tsip_word();

   if(mode == 0) {
      if(nvs_traim & 0x04) rcvr_mode = RCVR_MODE_3D;
      else                 rcvr_mode = RCVR_MODE_2D_3D;
   }
   else if(mode == 1) rcvr_mode = RCVR_MODE_HOLD;
   else if(mode == 2) rcvr_mode = RCVR_MODE_SURVEY;
   else               rcvr_mode = RCVR_MODE_UNKNOWN;

   if(mode == 2) {
      minor_alarms |= MINOR_SURVEY;
      do_survey = avg_time;
      survey_why = 33;
   }
   else {
      minor_alarms &= (~MINOR_SURVEY);
      if(precision_survey == 0) {
         do_survey = 0;
         survey_why = (-334);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x7d4e9(%rip), %rdi     # 0x125fe3
callq 0x58dc2
callq 0x587be
movl %eax, %ebx
cmpl $0x100, %eax            # imm = 0x100
jb 0xa8b17
leaq 0x19645c(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
callq 0x58b08
callq 0x588d2
cmpb $0x2, %bl
je 0xa8b43
movzbl %bl, %eax
cmpl $0x1, %eax
je 0xa8b3f
testl %eax, %eax
jne 0xa8b61
leaq 0x172593(%rip), %rax    # 0x21b0cc
movb (%rax), %al
andb $0x4, %al
jmp 0xa8b63
movb $0x7, %al
jmp 0xa8b63
leaq 0x26468e(%rip), %rcx    # 0x30d1d8
orb $0x20, (%rcx)
leaq 0x26457c(%rip), %rcx    # 0x30d0d0
movb $0xb, (%rcx)
movzwl %ax, %ecx
movl $0x21, %eax
jmp 0xa8b89
movb $0x63, %al
leaq 0x264566(%rip), %rcx    # 0x30d0d0
leaq 0x264667(%rip), %rdx    # 0x30d1d8
andb $-0x21, (%rdx)
movb %al, (%rcx)
leaq 0x26531b(%rip), %rax    # 0x30de98
cmpb $0x0, (%rax)
jne 0xa8b9c
movl $0xfffffeb2, %eax       # imm = 0xFFFFFEB2
xorl %ecx, %ecx
leaq 0x2652e8(%rip), %rdx    # 0x30de78
movq %rcx, (%rdx)
leaq 0x2652ee(%rip), %rcx    # 0x30de88
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_nvs_timescale()
void parse_nvs_timescale()
{
double scale_shift;
u08 flags;
int gps_flags;
int glo_flags;

   // !!!! qqqqq do we need anything from here?
   // 0x74 packet
   log_packet_id("nvs_timescale");

   scale_shift = tsip_fp80();
   tsip_fp80();
   tsip_fp80();
   tsip_fp80();
   tsip_fp80();
   flags = tsip_byte();

   gps_flags = glo_flags = TFLAGS_NULL;
   if(!have_gnss_mask) {
      gps_flags |= TFLAGS_INVALID;
      glo_flags |= TFLAGS_INVALID;
   }

   if(time_flags & TFLAGS_UTC) {  // UTC time
      if(gnss_mask & GPS) {
         if((flags & 0x04) == 0) gps_flags |= TFLAGS_INVALID;
      }
      if(gnss_mask & GLONASS) {
         if((flags & 0x08) == 0) glo_flags |= TFLAGS_INVALID;
      }
   }
   else { // GPS time
      if(gnss_mask & GPS) {
         if((flags & 0x01) == 0) gps_flags |= TFLAGS_INVALID;
      }
      if(gnss_mask & GLONASS) {
         if((flags & 0x02) == 0) glo_flags |= TFLAGS_INVALID;
      }
   }
   if((gnss_mask & GPS) && (gnss_mask & GLONASS)) {  // see if we have valid time from at least one system
      if(gps_flags == 0) glo_flags = TFLAGS_NULL;  // we have GPS time
      if(glo_flags == 0) gps_flags = TFLAGS_NULL;  // we have GLONASS time
   }


   time_flags &= (~TFLAGS_INVALID);
   time_flags |= (gps_flags | glo_flags);
//sprintf(plot_title, "shift:%.10f  flags:%02X  tflags:%04X  gnss:%04X  have_utc:%d", 
//scale_shift, flags, time_flags, gnss_mask, have_utc_ofs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7d3e0(%rip), %rdi     # 0x125f8e
callq 0x58dc2
callq 0x58ba0
callq 0x58ba0
callq 0x58ba0
callq 0x58ba0
callq 0x58ba0
callq 0x587be
cmpl $0x100, %eax            # imm = 0x100
jb 0xa8be2
leaq 0x196391(%rip), %rcx    # 0x23ef70
orb $0x8, (%rcx)
leaq 0xc808f(%rip), %rcx     # 0x170c78
xorl %esi, %esi
cmpl $0x0, (%rcx)
sete %sil
shll $0x2, %esi
leaq 0x2648a8(%rip), %rcx    # 0x30d4a4
movl (%rcx), %edx
xorl %r8d, %r8d
testb $0x1, %dl
leaq 0xc8069(%rip), %rdi     # 0x170c74
movl (%rdi), %edi
setne %r8b
movl $0x2, %r9d
movl $0x8, %r10d
cmovel %r9d, %r10d
testb $0x1, %dil
movl $0x4, %r9d
movl %esi, %r11d
cmovnel %r9d, %r11d
leal (%r8,%r8,2), %r8d
incl %r8d
testl %eax, %r8d
cmovnel %esi, %r11d
testb $0x2, %dil
cmovel %esi, %r9d
testl %eax, %r10d
cmovnel %esi, %r9d
notl %edi
andl $0x3, %edi
testl %r11d, %r11d
movl %r9d, %eax
cmovel %r11d, %eax
xorl %esi, %esi
movl %edi, %r8d
orl %eax, %r8d
cmovnel %r11d, %esi
testl %edi, %edi
cmovnel %r9d, %eax
andl $-0x5, %edx
orl %eax, %edx
orl %esi, %edx
movl %edx, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: fix_nvs_week(int)
int fix_nvs_week(int week)
{
   // adjust week for rollover

   week += 1024;
   if(year > 2019) week += 1024;
   else if(year == 2019) {
      if(month > 4) week += 1024;
      else if((month == 4) && (day >= 6)) week += 1024;
   }

   return week;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x264856(%rip), %rax    # 0x30d4dc
movl (%rax), %ecx
cmpl $0x7e4, %ecx            # imm = 0x7E4
jl 0xa8c9a
addl $0x800, %edi            # imm = 0x800
movl %edi, %eax
jmp 0xa8cd1
leal 0x400(%rdi), %eax
cmpl $0x7e3, %ecx            # imm = 0x7E3
jne 0xa8cd1
leaq 0x264829(%rip), %rcx    # 0x30d4d8
movl (%rcx), %ecx
cmpl $0x5, %ecx
jge 0xa8c90
leaq 0x264817(%rip), %rdx    # 0x30d4d4
addl $0x800, %edi            # imm = 0x800
cmpl $0x6, (%rdx)
cmovll %eax, %edi
cmpl $0x4, %ecx
cmovnel %eax, %edi
jmp 0xa8c96
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_antd()
void parse_zy_antd()
{
   // cable delay
   log_packet_id("cable delay");

   if(get_msg_field()) {
      cable_delay = atof(msg_field) / 1.0E9;
      have_cable_delay = 62;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7b469(%rip), %rdi     # 0x124c78
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xa9849
leaq 0x29221c(%rip), %rdi    # 0x33ba40
callq 0x9470
divsd 0x5f7f7(%rip), %xmm0    # 0x109028
leaq 0x264590(%rip), %rax    # 0x30ddc8
movsd %xmm0, (%rax)
leaq 0x263a71(%rip), %rax    # 0x30d2b4
movl $0x3e, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_alrm()
void parse_zy_alrm()
{
int val;
int survey;

   // alarms
   log_packet_id("alarms");

   if(get_msg_field()) {
      val = atohex(msg_field);
      survey = (minor_alarms & (~MINOR_SURVEY));
      minor_alarms = 0x0000;
      critical_alarms = 0x0000;

      if(val & 0x0100) minor_alarms |= MINOR_OSC_AGE;
      if(val & 0x0200) critical_alarms |= CRIT_OCXO;
      if(val & 0x0010) critical_alarms |= CRIT_FPGA;
      if(val & 0x0020) minor_alarms |= MINOR_EEPROM;
      if(val & 0x0040) critical_alarms |= CRIT_GPS;
      if(val & 0x0080) minor_alarms |= MINOR_OSC_AGE;
      if(val & 0x0001) minor_alarms |= MINOR_NO_TRACK;
      if(val & 0x0002) minor_alarms |= (MINOR_ANT_NO_PWR);
      if(val & 0x0004) minor_alarms |= MINOR_OSC_CTRL;   // !!!!! TFOM
      if(val & 0x0008) critical_alarms |= CRIT_RAM;
      minor_alarms |= survey;
      have_antenna = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7b62e(%rip), %rdi     # 0x124e84
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xa9920
leaq 0x2921d1(%rip), %rdi    # 0x33ba40
callq 0x98c6
leaq 0x26395d(%rip), %rcx    # 0x30d1d8
movl (%rcx), %edx
leaq 0x26394c(%rip), %rsi    # 0x30d1d0
movl $0x0, (%rsi)
xorl %edi, %edi
btl $0x8, %eax
jae 0xa989d
movl $0x1, (%rcx)
movl $0x1, %edi
andl $-0x21, %edx
movl %eax, %r8d
andl $0x20, %r8d
shll $0x5, %r8d
testb %al, %al
movl $0x1, %r9d
cmovnsl %edi, %r9d
orl %r8d, %r9d
movl %eax, %edi
andl $0x1, %edi
leal (%r9,%rdi,8), %r8d
testb $0x2, %al
leal 0x6(%r9,%rdi,8), %edi
cmovel %r8d, %edi
movl %eax, %r8d
andl $0x4, %r8d
leal (%rdi,%r8,4), %edi
testl $0x258, %eax            # imm = 0x258
je 0xa990f
movl %eax, %r8d
shrl $0x5, %r8d
andl $0x10, %r8d
movl %eax, %r9d
shrl %r9d
andl $0x8, %r9d
testb $0x40, %al
movl $0x8, %r10d
cmovel %r9d, %r10d
orl %r8d, %r10d
shrl $0x2, %eax
andl $0x2, %eax
orl %r10d, %eax
movl %eax, (%rsi)
orl %edx, %edi
movl %edi, (%rcx)
leaq 0x263912(%rip), %rax    # 0x30d22c
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_azel()
void parse_zy_azel()
{
int prn;
double az,el;

   // satellite positions
   log_packet_id("sat info");

   reset_sat_tracking();

   while(1) {
      if(get_msg_field()) prn = atoi(msg_field);
      else break;

      if(get_msg_field()) el = atof(msg_field);
      else break;

      if(get_msg_field()) az = atof(msg_field);
      else break;

      if((prn >= 1) && (prn <= 32)) { 
         set_sat_azel(prn, (float) az, (float) el);
         if(az && el && sat[prn].sig_level) {
            sat[prn].level_msg = 52;
            sat[prn].visible = 1;
            have_snr |= rinex_gnss(prn);
         }
         else sat[prn].visible = 0;

         if(az && el) sat[prn].tracking = prn;
         else         sat[prn].tracking = (-1);
         have_sat_azel = 2;
         level_type = "dBc";
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x7b395(%rip), %rdi     # 0x124ccf
callq 0x58dc2
movl $0x218, %eax            # imm = 0x218
leaq 0x195665(%rip), %r15    # 0x23efb0
xorl %ecx, %ecx
movl %ecx, (%r15,%rax)
movl %ecx, -0x1fc(%r15,%rax)
addq $0x348, %rax            # imm = 0x348
cmpq $0xcd358, %rax          # imm = 0xCD358
jne 0xa994d
callq 0x810b1
testl %eax, %eax
je 0xa9a9d
leaq 0x2920c5(%rip), %rbx    # 0x33ba40
leaq 0x195576(%rip), %r13    # 0x23eef8
movq %rbx, %rdi
callq 0x95e0
movl %eax, %r14d
callq 0x810b1
testl %eax, %eax
je 0xa9a9d
movq %rbx, %rdi
callq 0x9470
movsd %xmm0, -0x30(%rbp)
callq 0x810b1
testl %eax, %eax
je 0xa9a9d
leal -0x1(%r14), %eax
cmpl $0x1f, %eax
ja 0xa9a90
movq %rbx, %rdi
callq 0x9470
movsd %xmm0, -0x38(%rbp)
cvtsd2ss %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtsd2ss -0x30(%rbp), %xmm1
movl %r14d, %edi
callq 0x5ace1
xorps %xmm0, %xmm0
movsd -0x38(%rbp), %xmm1
ucomisd %xmm0, %xmm1
movl %r14d, %r12d
jne 0xa99f5
jnp 0xa9a42
movsd -0x30(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jne 0xa9a02
jnp 0xa9a42
imulq $0x348, %r12, %rax      # imm = 0x348
movss 0x20(%r15,%rax), %xmm0
ucomiss 0x63679(%rip), %xmm0    # 0x10d090
jne 0xa9a1b
jnp 0xa9a5d
addq %r15, %rax
movl $0x34, 0x1c(%rax)
movl $0x1, 0x21c(%rax)
movl %r14d, %edi
callq 0xdc1dd
leaq 0x26390e(%rip), %rcx    # 0x30d34c
orl %eax, (%rcx)
jmp 0xa9a69
imulq $0x348, %r12, %rax      # imm = 0x348
movl $0x0, 0x21c(%r15,%rax)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0xa9a69
movl $0x0, 0x21c(%r15,%rax)
imulq $0x348, %r12, %rax      # imm = 0x348
movl %r14d, 0x218(%r15,%rax)
leaq 0x263815(%rip), %rax    # 0x30d294
movl $0x2, (%rax)
leaq 0x7824e(%rip), %rax     # 0x121cda
movq %rax, (%r13)
callq 0x810b1
testl %eax, %eax
jne 0xa9982
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_sigq()
void parse_zy_sigq()
{
int prn;
double snr;
int mode;

   // signal quality
   log_packet_id("signal quality");

   while(1) {
      if(get_msg_field()) prn = atoi(msg_field);
      else break;

      if(get_msg_field()) snr = (atof(msg_field) * 2.500) + 25.0;
      else break;

      if(get_msg_field()) mode = atoi(msg_field);
      else break;

      if((prn >= 1) && (prn <= 32)) { 
         sat[prn].sig_level = (float) snr;
         record_sig_levels(prn);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x7c5a0(%rip), %rdi     # 0x12605d
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xa9b46
leaq 0x291f6e(%rip), %rbx    # 0x33ba40
leaq 0x1954d7(%rip), %r15    # 0x23efb0
movq %rbx, %rdi
callq 0x95e0
movl %eax, %r14d
callq 0x810b1
testl %eax, %eax
je 0xa9b46
movq %rbx, %rdi
callq 0x9470
mulsd 0x5f633(%rip), %xmm0    # 0x109130
addsd 0x74ce3(%rip), %xmm0    # 0x11e7e8
movsd %xmm0, -0x20(%rbp)
callq 0x810b1
testl %eax, %eax
je 0xa9b46
leal -0x1(%r14), %eax
cmpl $0x1f, %eax
ja 0xa9b3d
xorps %xmm0, %xmm0
cvtsd2ss -0x20(%rbp), %xmm0
movl %r14d, %eax
imulq $0x348, %rax, %rax      # imm = 0x348
movss %xmm0, 0x20(%r15,%rax)
movl %r14d, %edi
callq 0x5cdab
callq 0x810b1
testl %eax, %eax
jne 0xa9ad9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_dacv()
void parse_zy_dacv()
{
double val;

   // dac voltage
   log_packet_id("dac voltage");

   if(get_msg_field()) {
      val = atof(msg_field);
      dac_voltage = (DATA_SIZE) (((val - 32768.0) / 32768.0) * 100.0);
      have_dac = 62;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7c510(%rip), %rdi     # 0x12606c
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xa9ba6
leaq 0x291ecf(%rip), %rdi    # 0x33ba40
callq 0x9470
addsd 0x74bd2(%rip), %xmm0    # 0x11e750
mulsd 0x7472a(%rip), %xmm0    # 0x11e2b0
mulsd 0x5f4d2(%rip), %xmm0    # 0x109060
leaq 0x262e6b(%rip), %rax    # 0x30ca00
movsd %xmm0, (%rax)
leaq 0x26375c(%rip), %rax    # 0x30d2fc
movl $0x3e, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_drft()
void parse_zy_drft()
{
   // osc drift
   log_packet_id("osc drift");

   if(get_msg_field()) {
      zyfer_drift = (DATA_SIZE) (atof(msg_field)*1.0E9);
      have_zyfer_drift = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7c4c5(%rip), %rdi     # 0x126078
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xa9bed
leaq 0x291e78(%rip), %rdi    # 0x33ba40
callq 0x9470
mulsd 0x5f453(%rip), %xmm0    # 0x109028
leaq 0x293a6c(%rip), %rax    # 0x33d648
movsd %xmm0, (%rax)
leaq 0x293a69(%rip), %rax    # 0x33d650
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_efer()
void parse_zy_efer()
{
double efer;

   // osc freq error
   log_packet_id("freq error");

   if(get_msg_field()) {
      efer = atof(msg_field);
      osc_offset = (DATA_SIZE) ((efer * 1.0E9)*1000.0);
      have_osc_offset = 66;
      have_rcvr_osc = 66;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7c4a9(%rip), %rdi     # 0x1260a3
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xa9c46
leaq 0x291e31(%rip), %rdi    # 0x33ba40
callq 0x9470
mulsd 0x5f40c(%rip), %xmm0    # 0x109028
mulsd 0x5f414(%rip), %xmm0    # 0x109038
leaq 0x262b95(%rip), %rax    # 0x30c7c0
movsd %xmm0, (%rax)
leaq 0x2635fe(%rip), %rax    # 0x30d234
movl $0x42, %ecx
movl %ecx, (%rax)
leaq 0x263604(%rip), %rax    # 0x30d248
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_essd()
void parse_zy_essd()
{
   // estimator of tdev
   log_packet_id("tdev estimate");

   if(get_msg_field()) {
      zyfer_tdev = (DATA_SIZE) (atof(msg_field)*1.0E9);
      have_zyfer_tdev = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7c42f(%rip), %rdi     # 0x126082
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xa9c8d
leaq 0x291dd8(%rip), %rdi    # 0x33ba40
callq 0x9470
mulsd 0x5f3b3(%rip), %xmm0    # 0x109028
leaq 0x2939dc(%rip), %rax    # 0x33d658
movsd %xmm0, (%rax)
leaq 0x2939d9(%rip), %rax    # 0x33d660
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_essn()
void parse_zy_essn()
{
   // undocumented - incrementing counter
   log_packet_id("essn");

   if(get_msg_field()) {
      zyfer_essn = (DATA_SIZE) atof(msg_field);
      have_zyfer_essn = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7c3f6(%rip), %rdi     # 0x126090
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xa9ccc
leaq 0x291d91(%rip), %rdi    # 0x33ba40
callq 0x9470
leaq 0x2939ad(%rip), %rax    # 0x33d668
movsd %xmm0, (%rax)
leaq 0x2939aa(%rip), %rax    # 0x33d670
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_gdop()
void parse_zy_gdop()
{
   // undocumented GDOP command
   log_packet_id("gdop");

   if(get_msg_field()) {
      gdop = (DATA_SIZE) atof(msg_field);
      have_dops |= GDOP;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x63bd5(%rip), %rdi     # 0x10d8da
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xa9d34
leaq 0x291d26(%rip), %rdi    # 0x33ba40
callq 0x9470
leaq 0x1797da(%rip), %rax    # 0x223500
movsd %xmm0, (%rax)
leaq 0x1797b3(%rip), %rax    # 0x2234e4
orb $0x8, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_hefe()
void parse_zy_hefe()
{

   // undocumented (holdover estimated freq error?)
   log_packet_id("holdover freq error");

   if(get_msg_field()) {
      zyfer_hefe = atof(msg_field)*1.0E9;
      have_zyfer_hefe = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7c359(%rip), %rdi     # 0x12609a
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xa9d7b
leaq 0x291cea(%rip), %rdi    # 0x33ba40
callq 0x9470
mulsd 0x5f2c5(%rip), %xmm0    # 0x109028
leaq 0x29390e(%rip), %rax    # 0x33d678
movsd %xmm0, (%rax)
leaq 0x29390b(%rip), %rax    # 0x33d680
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_hint()
void parse_zy_hint()
{
   // holdover integrity
   log_packet_id("holdover integrity");

   zy_hflag = 2;
   zy_pll_bad = zy_gps_bad = zy_fix_bad = zy_bias_bad = (2);

   if(get_msg_field()) zy_hflag = atoi(msg_field);

   if(get_msg_field()) zy_pll_bad = atoi(msg_field);  // holdover reason
   if(get_msg_field()) zy_gps_bad = atoi(msg_field);
   if(get_msg_field()) zy_fix_bad = atoi(msg_field);
   if(get_msg_field()) zy_bias_bad = atoi(msg_field);

   have_zyfer_hint = 1;
   have_gps_status = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x7c2cb(%rip), %rdi     # 0x1260d1
callq 0x58dc2
leaq 0x293896(%rip), %r13    # 0x33d6a8
movl $0x2, %eax
movl %eax, (%r13)
leaq 0x293896(%rip), %rbx    # 0x33d6b8
movl %eax, (%rbx)
leaq 0x293889(%rip), %r14    # 0x33d6b4
movl %eax, (%r14)
leaq 0x29387b(%rip), %r15    # 0x33d6b0
movl %eax, (%r15)
leaq 0x29386d(%rip), %r12    # 0x33d6ac
movl %eax, (%r12)
callq 0x810b1
testl %eax, %eax
je 0xa9e5c
leaq 0x291bed(%rip), %rdi    # 0x33ba40
callq 0x95e0
movl %eax, (%r13)
callq 0x810b1
testl %eax, %eax
je 0xa9e75
leaq 0x291bd4(%rip), %rdi    # 0x33ba40
callq 0x95e0
movl %eax, (%r12)
callq 0x810b1
testl %eax, %eax
je 0xa9e8d
leaq 0x291bbb(%rip), %rdi    # 0x33ba40
callq 0x95e0
movl %eax, (%r15)
callq 0x810b1
testl %eax, %eax
je 0xa9ea5
leaq 0x291ba3(%rip), %rdi    # 0x33ba40
callq 0x95e0
movl %eax, (%r14)
callq 0x810b1
testl %eax, %eax
je 0xa9ebc
leaq 0x291b8b(%rip), %rdi    # 0x33ba40
callq 0x95e0
movl %eax, (%rbx)
leaq 0x2937e1(%rip), %rax    # 0x33d6a4
movl $0x1, (%rax)
leaq 0x2633e0(%rip), %rax    # 0x30d2b0
movl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_leap()
void parse_zy_leap()
{
int p, f;

   // utc and leapsecond info
   log_packet_id("leapsecond info");

   p = f = 0;
   if(get_msg_field()) p = atoi(msg_field);
   if(get_msg_field()) f = atoi(msg_field);

   if(p) {
      if(!user_set_utc_ofs) utc_offset = p;
      check_utc_ofs(33);
   }

   minor_alarms &= (~MINOR_LEAP_PEND);
   if(p != f) {  // leap pending
      minor_alarms |= MINOR_LEAP_PEND;
   }
   have_leap_info = 33;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x7989f(%rip), %rdi     # 0x123792
callq 0x58dc2
callq 0x810b1
xorl %ebx, %ebx
movl $0x0, %r14d
testl %eax, %eax
je 0xa9f18
leaq 0x291b30(%rip), %rdi    # 0x33ba40
callq 0x95e0
movl %eax, %r14d
callq 0x810b1
testl %eax, %eax
je 0xa9f2f
leaq 0x291b18(%rip), %rdi    # 0x33ba40
callq 0x95e0
movl %eax, %ebx
testl %r14d, %r14d
je 0xa9f97
leaq 0x2637f9(%rip), %rax    # 0x30d734
cmpl $0x0, (%rax)
jne 0xa9f4a
leaq 0x2637e1(%rip), %rax    # 0x30d728
movl %r14d, (%rax)
leaq 0x2633cb(%rip), %rax    # 0x30d31c
cmpl $0x0, (%rax)
jne 0xa9f97
leaq 0x2635b7(%rip), %rcx    # 0x30d514
cmpl $0x7e1, (%rcx)          # imm = 0x7E1
setge %cl
leaq 0x2637bb(%rip), %rdx    # 0x30d728
movl (%rdx), %edx
cmpl $0x12, %edx
setl %sil
andb %cl, %sil
cmpl $0x11, %edx
setl %cl
orb %sil, %cl
jne 0xa9f97
leaq 0x16e8b9(%rip), %rcx    # 0x218844
movl $0x7f1, (%rcx)          # imm = 0x7F1
movl $0x21, (%rax)
leaq 0x26323a(%rip), %rax    # 0x30d1d8
movl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
andl (%rax), %ecx
xorl %edx, %edx
cmpl %ebx, %r14d
setne %dl
shll $0x7, %edx
orl %ecx, %edx
movl %edx, (%rax)
leaq 0x2632dd(%rip), %rax    # 0x30d298
movl $0x21, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_mang()
void parse_zy_mang()
{
double el_val;

   // elevation mask
   log_packet_id("elevation mask");

   if(get_msg_field()) {
      el_val = atof(msg_field);
      if((el_val >= 0.0) && (el_val <= 90.0)) {
         el_mask = (float) el_val;
         have_el_mask = 1;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6a2f1(%rip), %rdi     # 0x1142c2
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa01f
leaq 0x291a5a(%rip), %rdi    # 0x33ba40
callq 0x9470
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xaa01f
movsd 0x6191b(%rip), %xmm1    # 0x10b918
ucomisd %xmm0, %xmm1
jb 0xaa01f
cvtsd2ss %xmm0, %xmm0
leaq 0x2630a6(%rip), %rax    # 0x30d0b4
movss %xmm0, (%rax)
leaq 0x2633e3(%rip), %rax    # 0x30d3fc
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_ntlc()
void parse_zy_ntlc()
{
u32 val;
   // not time locked (holdover) count
   log_packet_id("not time locked");

   if(get_msg_field()) {
      val = (u32) atoi(msg_field);
      if(val) holdover = val;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7c0b8(%rip), %rdi     # 0x1260e4
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa053
leaq 0x2919ff(%rip), %rdi    # 0x33ba40
callq 0x95e0
testl %eax, %eax
je 0xaa053
leaq 0x263407(%rip), %rcx    # 0x30d458
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_ofst()
void parse_zy_ofst()
{
   // PPS output delay
   log_packet_id("pps delay");

   if(get_msg_field()) {  // PPS output delay
      pps1_delay = atof(msg_field) / 1.0E9;
      have_pps_delay |= 0x01;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7ac02(%rip), %rdi     # 0x124c62
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa097
leaq 0x2919cb(%rip), %rdi    # 0x33ba40
callq 0x9470
divsd 0x5efa6(%rip), %xmm0    # 0x109028
leaq 0x263d4f(%rip), %rax    # 0x30ddd8
movsd %xmm0, (%rax)
leaq 0x263224(%rip), %rax    # 0x30d2b8
orb $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_pavg()
void parse_zy_pavg()
{
double val;

   // position averaging
   log_packet_id("position averaging");

   val = 0.0;
   if(get_msg_field()) val = atof(msg_field);
   else return;

   if(get_msg_field()) val += atof(msg_field)/ 60.0;
   else return;

   if(get_msg_field()) {
      if(msg_field[0] == 'N') ;
      else if(msg_field[0] == 'S') val = 0.0 - val;
      else return;
      lat = val * PI / 180.0;
   }
   else return;

   val = 0.0;
   if(get_msg_field()) val = atof(msg_field);
   else return;

   if(get_msg_field()) val += atof(msg_field)/ 60.0;
   else return;

   if(get_msg_field()) {
      if(msg_field[0] == 'E') ;
      else if(msg_field[0] == 'W') val = 0.0 - val;
      else return;
      lon = val * PI / 180.0;
   }
   else return;

   if(get_msg_field()) {
      alt = atof(msg_field);
   }
   else return;

   if(get_msg_field()) {  // averaging count
      val = atoi(msg_field);
      survey_progress = (int) (val / 3600.0 * 100.0);
      have_progress = 8;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x7c04b(%rip), %rdi     # 0x1260f4
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa248
leaq 0x29197e(%rip), %rdi    # 0x33ba40
callq 0x9470
movsd %xmm0, -0x18(%rbp)
callq 0x810b1
testl %eax, %eax
je 0xaa248
leaq 0x291960(%rip), %rbx    # 0x33ba40
movq %rbx, %rdi
callq 0x9470
movsd %xmm0, -0x10(%rbp)
callq 0x810b1
testl %eax, %eax
je 0xaa248
movsd -0x10(%rbp), %xmm1
divsd 0x5ef01(%rip), %xmm1    # 0x109008
movsd -0x18(%rbp), %xmm0
addsd %xmm1, %xmm0
movzbl (%rbx), %eax
cmpl $0x4e, %eax
je 0xaa12d
cmpl $0x53, %eax
jne 0xaa248
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
subsd %xmm1, %xmm0
mulsd 0x616f3(%rip), %xmm0    # 0x10b828
divsd 0x616f3(%rip), %xmm0    # 0x10b830
leaq 0x262e8c(%rip), %rax    # 0x30cfd0
movsd %xmm0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0xaa248
leaq 0x2918e4(%rip), %rdi    # 0x33ba40
callq 0x9470
movsd %xmm0, -0x18(%rbp)
callq 0x810b1
testl %eax, %eax
je 0xaa248
leaq 0x2918c6(%rip), %rbx    # 0x33ba40
movq %rbx, %rdi
callq 0x9470
movsd %xmm0, -0x10(%rbp)
callq 0x810b1
testl %eax, %eax
je 0xaa248
movsd -0x10(%rbp), %xmm1
divsd 0x5ee67(%rip), %xmm1    # 0x109008
movsd -0x18(%rbp), %xmm0
addsd %xmm1, %xmm0
movzbl (%rbx), %eax
cmpl $0x45, %eax
je 0xaa1c7
cmpl $0x57, %eax
jne 0xaa248
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
subsd %xmm1, %xmm0
mulsd 0x61659(%rip), %xmm0    # 0x10b828
divsd 0x61659(%rip), %xmm0    # 0x10b830
leaq 0x262dfa(%rip), %rax    # 0x30cfd8
movsd %xmm0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0xaa248
leaq 0x29184e(%rip), %rdi    # 0x33ba40
callq 0x9470
leaq 0x262de2(%rip), %rax    # 0x30cfe0
movsd %xmm0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0xaa248
leaq 0x29182e(%rip), %rdi    # 0x33ba40
callq 0x95e0
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x5edea(%rip), %xmm0    # 0x109010
mulsd 0x5ee32(%rip), %xmm0    # 0x109060
cvttsd2si %xmm0, %eax
leaq 0x263c53(%rip), %rcx    # 0x30de8c
movl %eax, (%rcx)
leaq 0x263c4e(%rip), %rax    # 0x30de90
movl $0x8, (%rax)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_vers()
void parse_zy_vers()
{
   // version info
   log_packet_id("version info");

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_app_vers, msg_field);
   }

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_app_date, msg_field);
   }

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_gps, msg_field);
   }

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_app_prog, msg_field);
   }

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_option, msg_field);
   }

   have_info |= VERSION_INFO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7bead(%rip), %rdi     # 0x126107
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa27f
leaq 0x2917d1(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x2932e6(%rip), %rdi    # 0x33d560
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0xaa29f
leaq 0x2917b1(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x293326(%rip), %rdi    # 0x33d5c0
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0xaa2bf
leaq 0x291791(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x293276(%rip), %rdi    # 0x33d530
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0xaa2df
leaq 0x291771(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x2932b6(%rip), %rdi    # 0x33d590
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0xaa2ff
leaq 0x291751(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x2932f6(%rip), %rdi    # 0x33d5f0
callq 0x9340
leaq 0x26366e(%rip), %rax    # 0x30d974
orb $0x4, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_mani()
void parse_zy_mani()
{
   // mfg info
   log_packet_id("mfg info");

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_mfgid, msg_field);
   }

   have_info |= MFG_INFO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7bdfe(%rip), %rdi     # 0x126114
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa33b
leaq 0x291715(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x29319a(%rip), %rdi    # 0x33d4d0
callq 0x9340
leaq 0x263632(%rip), %rax    # 0x30d974
orb $0x8, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_prid()
void parse_zy_prid()
{
   // product id
   log_packet_id("product id");

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_id, msg_field);
   }

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_prod, msg_field);
   }

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_sn, msg_field);
   }

   have_info |= MANUF_PARAMS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7bdcb(%rip), %rdi     # 0x12611d
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa377
leaq 0x2916d9(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x29303e(%rip), %rdi    # 0x33d3b0
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0xaa397
leaq 0x2916b9(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x29304e(%rip), %rdi    # 0x33d3e0
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0xaa3b7
leaq 0x291699(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x29305e(%rip), %rdi    # 0x33d410
callq 0x9340
leaq 0x2635b6(%rip), %rax    # 0x30d974
orb $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_unid()
void parse_zy_unid()
{
   // unit id
   log_packet_id("unit id");

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_pn, msg_field);
   }

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_rev, msg_field);
   }

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_date, msg_field);
   }

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_sn, msg_field);
   }

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_fw, msg_field);
   }

   have_info |= PRODN_PARAMS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7bd5a(%rip), %rdi     # 0x126128
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa3f3
leaq 0x29165d(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x293052(%rip), %rdi    # 0x33d440
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0xaa413
leaq 0x29163d(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x293092(%rip), %rdi    # 0x33d4a0
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0xaa433
leaq 0x29161d(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x2930d2(%rip), %rdi    # 0x33d500
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0xaa453
leaq 0x2915fd(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x292fc2(%rip), %rdi    # 0x33d410
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0xaa473
leaq 0x2915dd(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x293002(%rip), %rdi    # 0x33d470
callq 0x9340
leaq 0x2634fa(%rip), %rax    # 0x30d974
orb $0x2, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_pulp()
void parse_zy_pulp()
{
   // pps polarity
   log_packet_id("pps polarity");

   if(get_msg_field()) {
      if(msg_field[0] == '+') pps_polarity = 0;
      else if(msg_field[0] == '-') pps_polarity = 1;
      else return;
      have_pps_polarity = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7bca6(%rip), %rdi     # 0x126130
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa4cb
leaq 0x2915a1(%rip), %rax    # 0x33ba40
movzbl (%rax), %eax
cmpl $0x2b, %eax
je 0xaa4b3
cmpl $0x2d, %eax
jne 0xaa4cb
movl $0x1, %eax
jmp 0xaa4b5
xorl %eax, %eax
leaq 0x26385c(%rip), %rcx    # 0x30dd18
movl %eax, (%rcx)
leaq 0x262e1b(%rip), %rax    # 0x30d2e0
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_pulr()
void parse_zy_pulr()
{
int rate;

   // PPS pulse rate
   log_packet_id("pps rate");

   if(get_msg_field()) {
      rate = atoi(msg_field);
      if(rate == 1) pps_rate = RATE_1PPS;
      else if(rate == 2) pps_rate = RATE_PP2S;
      else return;
      have_pps_rate = 33;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7a73f(%rip), %rdi     # 0x124c17
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa518
leaq 0x291553(%rip), %rdi    # 0x33ba40
callq 0x95e0
cmpl $0x1, %eax
je 0xaa500
cmpl $0x2, %eax
jne 0xaa518
movb $-0x7e, %al
jmp 0xaa502
movb $0x2, %al
leaq 0x26381a(%rip), %rcx    # 0x30dd23
movb %al, (%rcx)
leaq 0x262dbe(%rip), %rax    # 0x30d2d0
movl $0x21, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_pulw()
void parse_zy_pulw()
{
double width;

   // PPS pulse width
   log_packet_id("pps width");

   if(get_msg_field()) {
      width = atof(msg_field);
      zyfer_pps_width = width;
      if(width == (-2.0)) width = 20.0E-6;
      else if(width == (-1.0)) width = 10.0E-6;
      else width /= 1000.0;
      have_pps_duty = 0x01;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7a430(%rip), %rdi     # 0x124955
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa557
leaq 0x291506(%rip), %rdi    # 0x33ba40
callq 0x9470
leaq 0x263812(%rip), %rax    # 0x30dd58
movsd %xmm0, (%rax)
leaq 0x263813(%rip), %rax    # 0x30dd64
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_rsah()
void parse_zy_rsah()
{
int prn;
int c;

   // sat health
   log_packet_id("sat health");

   if(get_msg_field()) {
      reset_sat_health();
      for(prn=1; prn<=32; prn++) {
         c = msg_field[prn-1];
         if(c == 0) break;
         if(c == '0') sat[prn].health_flag = 1;      // unhealthy
         else if(c == '1') sat[prn].health_flag = 2; // healthy
         else continue;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7bbd9(%rip), %rdi     # 0x12613d
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa5d0
xorl %eax, %eax
leaq 0x194a35(%rip), %rcx    # 0x23efb0
movb $0x0, (%rcx,%rax)
addq $0x348, %rax            # imm = 0x348
cmpq $0xcd140, %rax          # imm = 0xCD140
jne 0xaa57b
movl $0x348, %eax            # imm = 0x348
addq 0xa59a7(%rip), %rax     # 0x14ff40
xorl %ecx, %ecx
leaq 0x29149e(%rip), %rdx    # 0x33ba40
movzbl (%rdx,%rcx), %esi
cmpl $0x30, %esi
je 0xaa5bb
cmpl $0x31, %esi
je 0xaa5b6
testl %esi, %esi
jne 0xaa5c1
jmp 0xaa5d0
movb $0x2, %sil
jmp 0xaa5be
movb $0x1, %sil
movb %sil, (%rax)
addq $0x348, %rax            # imm = 0x348
incq %rcx
cmpq $0x20, %rcx
jne 0xaa5a2
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_sslt()
void parse_zy_sslt()
{
u32 val;
int prn;
int c;

   // satellite enables
   log_packet_id("sat enables");

   val = 0;
   if(get_msg_field()) {
      for(prn=1; prn<=32; prn++) {
         c = msg_field[prn-1];
         if(c == 0) break;
         if(c == '0') sat[prn].disabled = 0;
         else if(c == '1') sat[prn].disabled = 1;
         else continue;
         if(!sat[prn].disabled) val |= 1 << (prn-1);
      }
      sats_enabled = val;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7bb6b(%rip), %rdi     # 0x126148
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa639
movl $0x349, %eax            # imm = 0x349
addq 0xa5949(%rip), %rax     # 0x14ff40
xorl %ecx, %ecx
leaq 0x291440(%rip), %rsi    # 0x33ba40
xorl %edx, %edx
movzbl (%rsi,%rcx), %edi
cmpl $0x30, %edi
je 0xaa61b
cmpl $0x31, %edi
je 0xaa616
testl %edi, %edi
jne 0xaa621
jmp 0xaa630
movb $0x1, (%rax)
jmp 0xaa621
movb $0x0, (%rax)
btsl %ecx, %edx
incq %rcx
addq $0x348, %rax            # imm = 0x348
cmpq $0x20, %rcx
jne 0xaa602
leaq 0x262aad(%rip), %rax    # 0x30d0e4
movl %edx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_stat()
void parse_zy_stat()
{
int sats;
int hex1,hex2,hex3;

   // status
   log_packet_id("status");

   if(get_msg_field()) sats = atoi(msg_field);
   else return;

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(zy_osc_type, msg_field);
   }
   else return;

   if(get_msg_field()) hex1 = atohex(msg_field);
   else return;
   if(get_msg_field()) hex2 = atohex(msg_field);
   else return;
   if(get_msg_field()) hex3 = atohex(msg_field);
   else return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7b4d7(%rip), %rdi     # 0x125b1d
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa6b4
callq 0x810b1
testl %eax, %eax
je 0xaa6b4
leaq 0x2913dc(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x292fb1(%rip), %rdi    # 0x33d620
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0xaa6b4
leaq 0x2913bc(%rip), %rdi    # 0x33ba40
callq 0x98c6
callq 0x810b1
testl %eax, %eax
je 0xaa6b4
leaq 0x2913a7(%rip), %rdi    # 0x33ba40
callq 0x98c6
callq 0x810b1
testl %eax, %eax
je 0xaa6b4
leaq 0x291392(%rip), %rdi    # 0x33ba40
popq %rbp
jmp 0x98c6
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_temp()
void parse_zy_temp()
{
   // temperature
   log_packet_id("temperature");

   if(get_msg_field()) {
      temperature = (DATA_SIZE) atof(msg_field);
      have_temperature = 115;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x79db8(%rip), %rdi     # 0x124479
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa6f3
leaq 0x29136a(%rip), %rdi    # 0x33ba40
callq 0x9470
leaq 0x262336(%rip), %rax    # 0x30ca18
movsd %xmm0, (%rax)
leaq 0x262b5f(%rip), %rax    # 0x30d24c
movl $0x73, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_timd()
void parse_zy_timd()
{
double timd;

   // gps/pps time difference
   log_packet_id("time difference");

   if(get_msg_field()) {
      timd = atof(msg_field);// / 1.0E9;
      pps_offset = timd;
      have_pps_offset = 66;
      have_rcvr_pps = 66;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7ba54(%rip), %rdi     # 0x126154
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa73c
leaq 0x29132b(%rip), %rdi    # 0x33ba40
callq 0x9470
leaq 0x262097(%rip), %rax    # 0x30c7b8
movsd %xmm0, (%rax)
leaq 0x262b0c(%rip), %rax    # 0x30d238
movl $0x42, %ecx
movl %ecx, (%rax)
leaq 0x262b0a(%rip), %rax    # 0x30d244
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_timi()
void parse_zy_timi()
{
double timi;

   // undocumented  (time interval?)
   log_packet_id("time interval");

   if(get_msg_field()) {
      timi = atof(msg_field);// / 1.0E9;
      pps_offset = timi;
      have_pps_offset = 69;
      have_rcvr_pps = 69;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7ba1b(%rip), %rdi     # 0x126164
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa785
leaq 0x2912e2(%rip), %rdi    # 0x33ba40
callq 0x9470
leaq 0x26204e(%rip), %rax    # 0x30c7b8
movsd %xmm0, (%rax)
leaq 0x262ac3(%rip), %rax    # 0x30d238
movl $0x45, %ecx
movl %ecx, (%rax)
leaq 0x262ac1(%rip), %rax    # 0x30d244
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_timm()
void parse_zy_timm()
{
int tmode;

   // timing mode
   log_packet_id("timing mode");

   if(get_msg_field()) {
      tmode = atoi(msg_field);
      if((tmode == 1) || (tmode == 4)) { 
         time_flags &= (~TFLAGS_UTC);
         timing_mode = TMODE_GPS;
         have_timing_mode = 1;
      }
      else if((tmode == 2) || (tmode == 3)) {  // utc time
         time_flags |= (TFLAGS_UTC);
         timing_mode = TMODE_UTC;
         have_timing_mode = 1;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7a2fb(%rip), %rdi     # 0x124c6c
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0xaa9c2
leaq 0x2910ba(%rip), %rdi    # 0x33ba40
callq 0x95e0
cmpl $0x4, %eax
je 0xaa995
cmpl $0x1, %eax
jne 0xaa9c4
leaq 0x262b08(%rip), %rax    # 0x30d4a4
movl (%rax), %eax
andl $-0x2, %eax
xorl %ecx, %ecx
leaq 0x262afa(%rip), %rdx    # 0x30d4a4
movl %eax, (%rdx)
leaq 0x262b0a(%rip), %rax    # 0x30d4bd
movb %cl, (%rax)
leaq 0x262a10(%rip), %rax    # 0x30d3cc
movl $0x1, (%rax)
popq %rbp
retq
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0xaa9c2
leaq 0x262ad1(%rip), %rax    # 0x30d4a4
movl (%rax), %eax
orl $0x1, %eax
movb $0x3, %cl
jmp 0xaa9a3