LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x76099(%rip), %rdi     # 0x10ffe8
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x99f99
leaq 0x28badc(%rip), %rdi    # 0x325a40
callq 0x9470
mulsd 0x590b7(%rip), %xmm0    # 0xf3028
mulsd 0x590bf(%rip), %xmm0    # 0xf3038
leaq 0x25c840(%rip), %rax    # 0x2f67c0
movsd %xmm0, (%rax)
leaq 0x25d2a9(%rip), %rax    # 0x2f7234
pushq $0x42
popq %rcx
movl %ecx, (%rax)
leaq 0x25d2b1(%rip), %rax    # 0x2f7248
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x76021(%rip), %rdi     # 0x10ffc7
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x99fe0
leaq 0x28ba85(%rip), %rdi    # 0x325a40
callq 0x9470
mulsd 0x59060(%rip), %xmm0    # 0xf3028
leaq 0x28d689(%rip), %rax    # 0x327658
movsd %xmm0, (%rax)
leaq 0x28d686(%rip), %rax    # 0x327660
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75fe8(%rip), %rdi     # 0x10ffd5
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a01f
leaq 0x28ba3e(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x28d65a(%rip), %rax    # 0x327668
movsd %xmm0, (%rax)
leaq 0x28d657(%rip), %rax    # 0x327670
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5d902(%rip), %rdi     # 0xf795a
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a087
leaq 0x28b9d3(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x173487(%rip), %rax    # 0x20d500
movsd %xmm0, (%rax)
leaq 0x173460(%rip), %rax    # 0x20d4e4
orb $0x8, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75f4b(%rip), %rdi     # 0x10ffdf
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a0ce
leaq 0x28b997(%rip), %rdi    # 0x325a40
callq 0x9470
mulsd 0x58f72(%rip), %xmm0    # 0xf3028
leaq 0x28d5bb(%rip), %rax    # 0x327678
movsd %xmm0, (%rax)
leaq 0x28d5b8(%rip), %rax    # 0x327680
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75ebd(%rip), %rdi     # 0x110016
callq 0x520bf
leaq 0x28d543(%rip), %r13    # 0x3276a8
pushq $0x2
popq %rax
movl %eax, (%r13)
leaq 0x28d545(%rip), %rbx    # 0x3276b8
movl %eax, (%rbx)
leaq 0x28d538(%rip), %r14    # 0x3276b4
movl %eax, (%r14)
leaq 0x28d52a(%rip), %r15    # 0x3276b0
movl %eax, (%r15)
leaq 0x28d51c(%rip), %r12    # 0x3276ac
movl %eax, (%r12)
callq 0x75767
testl %eax, %eax
je 0x9a1ad
leaq 0x28b89c(%rip), %rdi    # 0x325a40
callq 0x95e0
movl %eax, (%r13)
callq 0x75767
testl %eax, %eax
je 0x9a1c6
leaq 0x28b883(%rip), %rdi    # 0x325a40
callq 0x95e0
movl %eax, (%r12)
callq 0x75767
testl %eax, %eax
je 0x9a1de
leaq 0x28b86a(%rip), %rdi    # 0x325a40
callq 0x95e0
movl %eax, (%r15)
callq 0x75767
testl %eax, %eax
je 0x9a1f6
leaq 0x28b852(%rip), %rdi    # 0x325a40
callq 0x95e0
movl %eax, (%r14)
callq 0x75767
testl %eax, %eax
je 0x9a20d
leaq 0x28b83a(%rip), %rdi    # 0x325a40
callq 0x95e0
movl %eax, (%rbx)
leaq 0x28d490(%rip), %rax    # 0x3276a4
movl $0x1, (%rax)
leaq 0x25d08f(%rip), %rax    # 0x2f72b0
andl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x73499(%rip), %rdi     # 0x10d6da
callq 0x520bf
callq 0x75767
xorl %ebx, %ebx
movl $0x0, %r14d
testl %eax, %eax
je 0x9a266
leaq 0x28b7e2(%rip), %rdi    # 0x325a40
callq 0x95e0
movl %eax, %r14d
callq 0x75767
testl %eax, %eax
je 0x9a27d
leaq 0x28b7ca(%rip), %rdi    # 0x325a40
callq 0x95e0
movl %eax, %ebx
testl %r14d, %r14d
je 0x9a2a0
leaq 0x25d4ab(%rip), %rax    # 0x2f7734
cmpl $0x0, (%rax)
jne 0x9a298
leaq 0x25d493(%rip), %rax    # 0x2f7728
movl %r14d, (%rax)
pushq $0x21
popq %rdi
callq 0x51a91
leaq 0x25cf31(%rip), %rax    # 0x2f71d8
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 0x25cfd4(%rip), %rax    # 0x2f7298
movl $0x21, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x64068(%rip), %rdi     # 0xfe342
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a328
leaq 0x28b751(%rip), %rdi    # 0x325a40
callq 0x9470
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x9a328
movsd 0x5b68a(%rip), %xmm1    # 0xf5990
ucomisd %xmm0, %xmm1
jb 0x9a328
cvtsd2ss %xmm0, %xmm0
leaq 0x25cd9d(%rip), %rax    # 0x2f70b4
movss %xmm0, (%rax)
leaq 0x25d0da(%rip), %rax    # 0x2f73fc
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75cf4(%rip), %rdi     # 0x110029
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a35c
leaq 0x28b6f6(%rip), %rdi    # 0x325a40
callq 0x95e0
testl %eax, %eax
je 0x9a35c
leaq 0x25d0fe(%rip), %rcx    # 0x2f7458
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x74841(%rip), %rdi     # 0x10ebaa
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a3a0
leaq 0x28b6c2(%rip), %rdi    # 0x325a40
callq 0x9470
divsd 0x58c9d(%rip), %xmm0    # 0xf3028
leaq 0x25da46(%rip), %rax    # 0x2f7dd8
movsd %xmm0, (%rax)
leaq 0x25cf1b(%rip), %rax    # 0x2f72b8
orb $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75c87(%rip), %rdi     # 0x110039
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a54e
leaq 0x28b675(%rip), %rdi    # 0x325a40
callq 0x9470
movsd %xmm0, -0x18(%rbp)
callq 0x75767
testl %eax, %eax
je 0x9a54e
leaq 0x28b657(%rip), %rbx    # 0x325a40
movq %rbx, %rdi
callq 0x9470
movsd %xmm0, -0x10(%rbp)
callq 0x75767
testl %eax, %eax
je 0x9a54e
movsd -0x10(%rbp), %xmm1
divsd 0x58bf8(%rip), %xmm1    # 0xf3008
movsd -0x18(%rbp), %xmm0
addsd %xmm1, %xmm0
movzbl (%rbx), %eax
cmpl $0x4e, %eax
je 0x9a436
cmpl $0x53, %eax
jne 0x9a54e
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
subsd %xmm1, %xmm0
mulsd 0x5b462(%rip), %xmm0    # 0xf58a0
divsd 0x5b462(%rip), %xmm0    # 0xf58a8
leaq 0x25cb83(%rip), %rax    # 0x2f6fd0
movsd %xmm0, (%rax)
callq 0x75767
testl %eax, %eax
je 0x9a54e
leaq 0x28b5db(%rip), %rdi    # 0x325a40
callq 0x9470
movsd %xmm0, -0x18(%rbp)
callq 0x75767
testl %eax, %eax
je 0x9a54e
leaq 0x28b5bd(%rip), %rbx    # 0x325a40
movq %rbx, %rdi
callq 0x9470
movsd %xmm0, -0x10(%rbp)
callq 0x75767
testl %eax, %eax
je 0x9a54e
movsd -0x10(%rbp), %xmm1
divsd 0x58b5e(%rip), %xmm1    # 0xf3008
movsd -0x18(%rbp), %xmm0
addsd %xmm1, %xmm0
movzbl (%rbx), %eax
cmpl $0x45, %eax
je 0x9a4d0
cmpl $0x57, %eax
jne 0x9a54e
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
subsd %xmm1, %xmm0
mulsd 0x5b3c8(%rip), %xmm0    # 0xf58a0
divsd 0x5b3c8(%rip), %xmm0    # 0xf58a8
leaq 0x25caf1(%rip), %rax    # 0x2f6fd8
movsd %xmm0, (%rax)
callq 0x75767
testl %eax, %eax
je 0x9a54e
leaq 0x28b545(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x25cad9(%rip), %rax    # 0x2f6fe0
movsd %xmm0, (%rax)
callq 0x75767
testl %eax, %eax
je 0x9a54e
leaq 0x28b525(%rip), %rdi    # 0x325a40
callq 0x95e0
cvtsi2sd %eax, %xmm0
divsd 0x58ae4(%rip), %xmm0    # 0xf3010
mulsd 0x58b2c(%rip), %xmm0    # 0xf3060
cvttsd2si %xmm0, %eax
leaq 0x25d94d(%rip), %rcx    # 0x2f7e8c
movl %eax, (%rcx)
leaq 0x25d948(%rip), %rax    # 0x2f7e90
movl $0x8, (%rax)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75aec(%rip), %rdi     # 0x11004c
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a585
leaq 0x28b4cb(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28cfe0(%rip), %rdi    # 0x327560
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9a5a5
leaq 0x28b4ab(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28d020(%rip), %rdi    # 0x3275c0
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9a5c5
leaq 0x28b48b(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28cf70(%rip), %rdi    # 0x327530
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9a5e5
leaq 0x28b46b(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28cfb0(%rip), %rdi    # 0x327590
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9a605
leaq 0x28b44b(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28cff0(%rip), %rdi    # 0x3275f0
callq 0x9330
leaq 0x25d368(%rip), %rax    # 0x2f7974
orb $0x4, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75a3d(%rip), %rdi     # 0x110059
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a641
leaq 0x28b40f(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28ce94(%rip), %rdi    # 0x3274d0
callq 0x9330
leaq 0x25d32c(%rip), %rax    # 0x2f7974
orb $0x8, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75a0a(%rip), %rdi     # 0x110062
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a67d
leaq 0x28b3d3(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28cd38(%rip), %rdi    # 0x3273b0
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9a69d
leaq 0x28b3b3(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28cd48(%rip), %rdi    # 0x3273e0
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9a6bd
leaq 0x28b393(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28cd58(%rip), %rdi    # 0x327410
callq 0x9330
leaq 0x25d2b0(%rip), %rax    # 0x2f7974
orb $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75999(%rip), %rdi     # 0x11006d
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a6f9
leaq 0x28b357(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28cd4c(%rip), %rdi    # 0x327440
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9a719
leaq 0x28b337(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28cd8c(%rip), %rdi    # 0x3274a0
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9a739
leaq 0x28b317(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28cdcc(%rip), %rdi    # 0x327500
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9a759
leaq 0x28b2f7(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28ccbc(%rip), %rdi    # 0x327410
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9a779
leaq 0x28b2d7(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28ccfc(%rip), %rdi    # 0x327470
callq 0x9330
leaq 0x25d1f4(%rip), %rax    # 0x2f7974
orb $0x2, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x758e5(%rip), %rdi     # 0x110075
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a7cf
leaq 0x28b29b(%rip), %rax    # 0x325a40
movzbl (%rax), %eax
cmpl $0x2b, %eax
je 0x9a7b7
cmpl $0x2d, %eax
jne 0x9a7cf
pushq $0x1
popq %rax
jmp 0x9a7b9
xorl %eax, %eax
leaq 0x25d558(%rip), %rcx    # 0x2f7d18
movl %eax, (%rcx)
leaq 0x25cb17(%rip), %rax    # 0x2f72e0
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x74383(%rip), %rdi     # 0x10eb5f
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a81c
leaq 0x28b24f(%rip), %rdi    # 0x325a40
callq 0x95e0
cmpl $0x1, %eax
je 0x9a804
cmpl $0x2, %eax
jne 0x9a81c
movb $-0x7e, %al
jmp 0x9a806
movb $0x2, %al
leaq 0x25d516(%rip), %rcx    # 0x2f7d23
movb %al, (%rcx)
leaq 0x25caba(%rip), %rax    # 0x2f72d0
movl $0x21, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x74074(%rip), %rdi     # 0x10e89d
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a85b
leaq 0x28b202(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x25d50e(%rip), %rax    # 0x2f7d58
movsd %xmm0, (%rax)
leaq 0x25d50f(%rip), %rax    # 0x2f7d64
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7581a(%rip), %rdi     # 0x110082
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a8c0
callq 0x56b4a
movl $0x348, %eax            # imm = 0x348
addq 0x9f6c1(%rip), %rax     # 0x139f48
xorl %ecx, %ecx
leaq 0x28b1b0(%rip), %rdx    # 0x325a40
cmpq $0x20, %rcx
je 0x9a8c0
movzbl (%rdx,%rcx), %esi
cmpl $0x30, %esi
je 0x9a8af
cmpl $0x31, %esi
je 0x9a8aa
testl %esi, %esi
jne 0x9a8b5
jmp 0x9a8c0
movb $0x2, %sil
jmp 0x9a8b2
movb $0x1, %sil
movb %sil, (%rax)
addq $0x348, %rax            # imm = 0x348
incq %rcx
jmp 0x9a890
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x757c0(%rip), %rdi     # 0x11008d
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a92b
movl $0x349, %eax            # imm = 0x349
addq 0x9f661(%rip), %rax     # 0x139f48
xorl %ecx, %ecx
leaq 0x28b150(%rip), %rdx    # 0x325a40
xorl %esi, %esi
cmpq $0x20, %rcx
je 0x9a922
movzbl (%rdx,%rcx), %edi
cmpl $0x30, %edi
je 0x9a911
cmpl $0x31, %edi
je 0x9a90c
testl %edi, %edi
jne 0x9a917
jmp 0x9a922
movb $0x1, (%rax)
jmp 0x9a917
movb $0x0, (%rax)
btsl %ecx, %esi
incq %rcx
addq $0x348, %rax            # imm = 0x348
jmp 0x9a8f2
leaq 0x25c7bb(%rip), %rax    # 0x2f70e4
movl %esi, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7512d(%rip), %rdi     # 0x10fa65
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a9a6
callq 0x75767
testl %eax, %eax
je 0x9a9a6
leaq 0x28b0ea(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28ccbf(%rip), %rdi    # 0x327620
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9a9a6
leaq 0x28b0ca(%rip), %rdi    # 0x325a40
callq 0x98b2
callq 0x75767
testl %eax, %eax
je 0x9a9a6
leaq 0x28b0b5(%rip), %rdi    # 0x325a40
callq 0x98b2
callq 0x75767
testl %eax, %eax
je 0x9a9a6
leaq 0x28b0a0(%rip), %rdi    # 0x325a40
popq %rbp
jmp 0x98b2
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x73a0e(%rip), %rdi     # 0x10e3c1
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9a9e5
leaq 0x28b078(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x25c044(%rip), %rax    # 0x2f6a18
movsd %xmm0, (%rax)
leaq 0x25c86d(%rip), %rax    # 0x2f724c
movl $0x73, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x756a7(%rip), %rdi     # 0x110099
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9aa2c
leaq 0x28b039(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x25bda5(%rip), %rax    # 0x2f67b8
movsd %xmm0, (%rax)
leaq 0x25c81a(%rip), %rax    # 0x2f7238
pushq $0x42
popq %rcx
movl %ecx, (%rax)
leaq 0x25c81a(%rip), %rax    # 0x2f7244
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75670(%rip), %rdi     # 0x1100a9
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9aa73
leaq 0x28aff2(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x25bd5e(%rip), %rax    # 0x2f67b8
movsd %xmm0, (%rax)
leaq 0x25c7d3(%rip), %rax    # 0x2f7238
pushq $0x45
popq %rcx
movl %ecx, (%rax)
leaq 0x25c7d3(%rip), %rax    # 0x2f7244
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x73f5a(%rip), %rdi     # 0x10ebb4
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9acab
leaq 0x28add1(%rip), %rdi    # 0x325a40
callq 0x95e0
cmpl $0x4, %eax
je 0x9ac7e
cmpl $0x1, %eax
jne 0x9acad
leaq 0x25c81f(%rip), %rax    # 0x2f74a4
movl (%rax), %eax
andl $-0x2, %eax
xorl %ecx, %ecx
leaq 0x25c811(%rip), %rdx    # 0x2f74a4
movl %eax, (%rdx)
leaq 0x25c821(%rip), %rax    # 0x2f74bd
movb %cl, (%rax)
leaq 0x25c727(%rip), %rax    # 0x2f73cc
movl $0x1, (%rax)
popq %rbp
retq
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x9acab
leaq 0x25c7e8(%rip), %rax    # 0x2f74a4
movl (%rax), %eax
orl $0x1, %eax
movb $0x3, %cl
jmp 0x9ac8c
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_zy_trmo()
void parse_zy_trmo()
{
char trmo;

   // surveying / position hold mode
   log_packet_id("survey info");

   if(get_msg_field()) {
      trmo = msg_field[0];  // P=position average mode   K=known position
      if(trmo == 'P') {
         minor_alarms |= MINOR_SURVEY;
         rcvr_mode = RCVR_MODE_SURVEY;
      }
      else if(trmo == 'K') {
         minor_alarms &= (~MINOR_SURVEY);
         rcvr_mode = RCVR_MODE_HOLD;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x753e7(%rip), %rdi     # 0x1100b7
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9ad22
leaq 0x28ad5b(%rip), %rax    # 0x325a40
movzbl (%rax), %eax
cmpl $0x4b, %eax
je 0x9ad02
cmpl $0x50, %eax
jne 0x9ad22
leaq 0x25c4df(%rip), %rax    # 0x2f71d8
movl (%rax), %eax
orl $0x20, %eax
movb $0xb, %cl
jmp 0x9ad10
leaq 0x25c4cf(%rip), %rax    # 0x2f71d8
movl (%rax), %eax
andl $-0x21, %eax
movb $0x7, %cl
leaq 0x25c4c1(%rip), %rdx    # 0x2f71d8
movl %eax, (%rdx)
leaq 0x25c3b0(%rip), %rax    # 0x2f70d0
movb %cl, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_clock()
void parse_true_clock()
{
double jd;
int utc;

   log_packet_id("clock");

   if(get_msg_field()) jd = atof(msg_field);
   else return;

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

   if(get_msg_field()) {
      tfom = atoi(msg_field);
      have_tfom = 1;
   }
   else return;

   jd /= (24.0*60.0*60.0);
   jd += GPS_EPOCH;

   if(!user_set_utc_ofs && utc) utc_offset = (int) utc;
   check_utc_ofs(33);

   set_gregorian_time(jd);
   if(time_flags & TFLAGS_UTC) {
      gps_to_utc();
   }

   update_gps_screen(4387);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x812e4(%rip), %rdi     # 0x11c03c
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9ae2f
leaq 0x28accf(%rip), %rdi    # 0x325a40
callq 0x9470
movsd %xmm0, -0x10(%rbp)
callq 0x75767
testl %eax, %eax
je 0x9ae2f
leaq 0x28acb1(%rip), %rdi    # 0x325a40
callq 0x95e0
movl %eax, %ebx
callq 0x75767
testl %eax, %eax
je 0x9ae2f
leaq 0x28ac96(%rip), %rdi    # 0x325a40
callq 0x95e0
leaq 0x25be9a(%rip), %rcx    # 0x2f6c50
movl %eax, (%rcx)
leaq 0x25be95(%rip), %rax    # 0x2f6c54
movl $0x1, (%rax)
movsd -0x10(%rbp), %xmm0
divsd 0x58246(%rip), %xmm0    # 0xf3018
addsd 0x5ab36(%rip), %xmm0    # 0xf5910
movsd %xmm0, -0x10(%rbp)
leaq 0x25c94e(%rip), %rax    # 0x2f7734
cmpl $0x0, (%rax)
sete %al
testl %ebx, %ebx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x9ae01
leaq 0x25c929(%rip), %rax    # 0x2f7728
movl %ebx, (%rax)
pushq $0x21
popq %rdi
callq 0x51a91
movsd -0x10(%rbp), %xmm0
callq 0x55392
leaq 0x25c68a(%rip), %rax    # 0x2f74a4
testb $0x1, (%rax)
je 0x9ae24
callq 0x55500
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x694f6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_extstatus()
void parse_true_extstatus()
{
   log_packet_id("extstatus");

   if(get_msg_field()) {  // position questionable?  0=normal  1=survey?
   }
   else return;

   if(get_msg_field()) {  // sat count related?
   }
   else return;

   if(get_msg_field()) {  // seems to be related to operating mode 
      true_eval = atof(msg_field);  // ,,, much noisier during survey, 
                                    // ... stable in position hold mode
                                    // ... might be 1PPS or osc error related
      have_true_eval = 1;
   }
   else return;

   if(get_msg_field()) {
      temperature = (DATA_SIZE) atof(msg_field);
      if(temperature && (have_temperature == 0)) {
         new_queue(RESET_ALL_QUEUES, 6543); // clear the queues so temp scales nicely
         have_temperature = 116;
      }
   }
   else return;

   if(get_msg_field()) {  // ?
   }
   else return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x752f9(%rip), %rdi     # 0x11013c
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9aee5
callq 0x75767
testl %eax, %eax
je 0x9aee5
callq 0x75767
testl %eax, %eax
je 0x9aee5
leaq 0x28abce(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x28c4ea(%rip), %rax    # 0x327368
movsd %xmm0, (%rax)
leaq 0x28c4e7(%rip), %rax    # 0x327370
movl $0x1, (%rax)
callq 0x75767
testl %eax, %eax
je 0x9aee5
leaq 0x28aba1(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x25bb6d(%rip), %rax    # 0x2f6a18
movsd %xmm0, (%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9aebb
jnp 0x9aeda
leaq 0x25c38a(%rip), %rbx    # 0x2f724c
cmpl $0x0, (%rbx)
jne 0x9aeda
pushq $0x7
popq %rdi
movl $0x198f, %esi           # imm = 0x198F
callq 0x10a99
movl $0x74, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x75767
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_geta()
void parse_true_geta()
{
   // attenuator
   log_packet_id("geta");

   if(get_msg_field()) {
      atten_val = atof(msg_field);
      have_atten = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7524f(%rip), %rdi     # 0x110146
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9af29
leaq 0x28ab34(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x28c470(%rip), %rax    # 0x327388
movsd %xmm0, (%rax)
leaq 0x28c46d(%rip), %rax    # 0x327390
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_getp()
void parse_true_getp()
{
   // get "pot" values
   log_packet_id("getp");

   if(get_msg_field()) {  // integer
      true_pot1 = atoi(msg_field);
      have_true_pot |= 0x01;
   }
   if(get_msg_field()) {  // integer
      true_pot2 = atoi(msg_field);
      have_true_pot |= 0x02;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x75215(%rip), %rdi     # 0x11014b
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9af63
leaq 0x28aaf5(%rip), %rdi    # 0x325a40
callq 0x95e0
leaq 0x28c43d(%rip), %rcx    # 0x327394
movl %eax, (%rcx)
leaq 0x28c43c(%rip), %rax    # 0x32739c
orb $0x1, (%rax)
callq 0x75767
testl %eax, %eax
je 0x9af8b
leaq 0x28aacd(%rip), %rdi    # 0x325a40
callq 0x95e0
leaq 0x28c419(%rip), %rcx    # 0x327398
movl %eax, (%rcx)
leaq 0x28c414(%rip), %rax    # 0x32739c
orb $0x2, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_getdelay()
void parse_true_getdelay()
{
   log_packet_id("getdelay");

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x751b8(%rip), %rdi     # 0x110150
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9afd2
leaq 0x28aa93(%rip), %rdi    # 0x325a40
callq 0x9470
divsd 0x5806e(%rip), %xmm0    # 0xf3028
leaq 0x25ce07(%rip), %rax    # 0x2f7dc8
movsd %xmm0, (%rax)
leaq 0x25c2e8(%rip), %rax    # 0x2f72b4
movl $0x1bc, (%rax)          # imm = 0x1BC
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_getbdelay()
void parse_true_getbdelay()
{
   log_packet_id("getbdelay");

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7517a(%rip), %rdi     # 0x110159
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9b016
leaq 0x28aa4c(%rip), %rdi    # 0x325a40
callq 0x9470
divsd 0x58027(%rip), %xmm0    # 0xf3028
leaq 0x25cdd0(%rip), %rax    # 0x2f7dd8
movsd %xmm0, (%rax)
leaq 0x25c2a5(%rip), %rax    # 0x2f72b8
orb $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_ppsdbg()
void parse_true_ppsdbg()
{
   log_packet_id("ppsdbg");

   get_msg_field();  // GPS time
   get_msg_field();  // Status - 0
   if(get_msg_field()) { // 32.42914e3   // EFC?
      dac_voltage = (DATA_SIZE) (atof(msg_field) * 4.096 / 65536.0);  // EFC DAC
      if(dac_voltage && (have_dac == 0)) {
         new_queue(RESET_ALL_QUEUES, 6544); // clear the queues so dac scales nicely
         have_dac = 66;
      }
   }
   get_msg_field();  // 0, -3, -2, -1

   if(get_msg_field()) {
//    dac_voltage = (DATA_SIZE) atof(msg_field);  // sawtooth?
//    have_sawtooth = 1;
   }

   get_msg_field();  // 0, 2
   get_msg_field();  // 0,1,3

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x7513e(%rip), %rdi     # 0x110163
callq 0x520bf
callq 0x75767
callq 0x75767
callq 0x75767
testl %eax, %eax
je 0x9b08f
leaq 0x28a9fc(%rip), %rdi    # 0x325a40
callq 0x9470
mulsd 0x6d717(%rip), %xmm0    # 0x108768
mulsd 0x6d6cf(%rip), %xmm0    # 0x108728
leaq 0x25b9a0(%rip), %rax    # 0x2f6a00
movsd %xmm0, (%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9b070
jnp 0x9b08f
leaq 0x25c285(%rip), %rbx    # 0x2f72fc
cmpl $0x0, (%rbx)
jne 0x9b08f
pushq $0x7
popq %rdi
movl $0x1990, %esi           # imm = 0x1990
callq 0x10a99
movl $0x42, (%rbx)
callq 0x75767
callq 0x75767
callq 0x75767
callq 0x75767
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x75767
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_kaldbg()
void parse_true_kaldbg()
{
   log_packet_id("kaldbg");

   if(get_msg_field()) {} ;  // Unix time
   if(get_msg_field()) {} ;  // -0.32
   if(get_msg_field()) {} ;  // PPS related - 31.42890e3
   if(get_msg_field()) {} ;  // -0.336e-3
   if(get_msg_field()) {} ;  // 0.291      // smoothed phase error in approx 6.5 ns steps
   if(get_msg_field()) {} ;  // 0
   if(get_msg_field()) {} ;  // 0
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x750b1(%rip), %rdi     # 0x11016a
callq 0x520bf
callq 0x75767
callq 0x75767
callq 0x75767
callq 0x75767
callq 0x75767
callq 0x75767
popq %rbp
jmp 0x75767
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_scale()
void parse_true_scale()
{
   log_packet_id("scalefactor");

   if(get_msg_field()) {
      true_scalefactor = atof(msg_field);
      have_true_scale = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x75084(%rip), %rdi     # 0x110171
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9b11f
leaq 0x28a93e(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x28c26a(%rip), %rax    # 0x327378
movsd %xmm0, (%rax)
leaq 0x28c267(%rip), %rax    # 0x327380
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_getver()
void parse_true_getver()
{
   log_packet_id("getver");

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

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(tp_boot, msg_field);
      if(strstr(msg_field, "BOOT")) {
         send_true_cmd("$PROCEED");  // get out of boot mode
      }
   }

   if(get_msg_field()) {  // FPGA version
      msg_field[32] = 0;
      strcpy(tp_num1, msg_field);
   }

   if(get_msg_field()) {  // software checmsum
      msg_field[32] = 0;
      strcpy(tp_num2, msg_field);
   }

   if(get_msg_field()) {  // FPGA checksum
      msg_field[32] = 0;
      strcpy(tp_num3, msg_field);
   }

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

   have_info |= ALL_ID_INFO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x74f10(%rip), %rdi     # 0x110184
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9b299
leaq 0x28a7b7(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28bd5c(%rip), %rdi    # 0x326ff0
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9b2dc
leaq 0x28a797(%rip), %rbx    # 0x325a40
movb $0x0, 0x20(%rbx)
leaq 0x28bd6c(%rip), %rdi    # 0x327020
movq %rbx, %rsi
callq 0x9330
leaq 0x74ec8(%rip), %rsi     # 0x11018b
movq %rbx, %rdi
callq 0x9090
testq %rax, %rax
je 0x9b2dc
leaq 0x70438(%rip), %rdi     # 0x10b70f
callq 0x57acc
callq 0x75767
testl %eax, %eax
je 0x9b2fc
leaq 0x28a754(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28bd59(%rip), %rdi    # 0x327050
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9b31c
leaq 0x28a734(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28bd69(%rip), %rdi    # 0x327080
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9b33c
leaq 0x28a714(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28bd79(%rip), %rdi    # 0x3270b0
callq 0x9330
callq 0x75767
testl %eax, %eax
je 0x9b35c
leaq 0x28a6f4(%rip), %rsi    # 0x325a40
movb $0x0, 0x20(%rsi)
leaq 0x28bd89(%rip), %rdi    # 0x3270e0
callq 0x9330
leaq 0x25c611(%rip), %rax    # 0x2f7974
orb $0xf, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_sat()
void parse_true_sat()
{
int prn;
double az, el, sig;

   log_packet_id("sat info");

   if(get_msg_field()) {  // receiver channel
   }
   else return;

   if(get_msg_field()) {
      prn = atoi(msg_field);
      if(prn < 1) return;
      else if(prn > 255) return;
   }
   else return;

   az = el = 999.0;
   if(get_msg_field()) {
      el = atof(msg_field);
   }
   else return;
   if(get_msg_field()) {
      az = atof(msg_field);
   }
   else return;
   if((az < 999.0) && (el < 999.0)) {
      set_sat_azel(prn, (float) az, (float) el);
   }

   if(get_msg_field()) {
      sig = atof(msg_field);
      if(sig) {
         sat[prn].tracking = prn;
         sat[prn].level_msg = 55;
         sat[prn].sig_level = (float) sig;
         have_snr |= rinex_gnss(prn);
         record_sig_levels(prn);
      }
      else {
         sat[prn].level_msg = 0;
         sat[prn].tracking = 0;
      }
   }
   else return;

   level_type = "dBc";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x7389d(%rip), %rdi     # 0x10ec17
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9b493
callq 0x75767
testl %eax, %eax
je 0x9b493
leaq 0x28a6a0(%rip), %rdi    # 0x325a40
callq 0x95e0
movl %eax, %ebx
leal -0x100(%rbx), %eax
cmpl $0xffffff01, %eax       # imm = 0xFFFFFF01
jb 0x9b493
callq 0x75767
testl %eax, %eax
je 0x9b493
leaq 0x28a674(%rip), %rdi    # 0x325a40
callq 0x9470
movsd %xmm0, -0x10(%rbp)
callq 0x75767
testl %eax, %eax
je 0x9b493
leaq 0x28a656(%rip), %rdi    # 0x325a40
callq 0x9470
movsd 0x6d379(%rip), %xmm1    # 0x108770
ucomisd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm2
jbe 0x9b417
ucomisd %xmm2, %xmm1
jbe 0x9b417
cvtsd2ss %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm1
movl %ebx, %edi
callq 0x53b74
callq 0x75767
testl %eax, %eax
je 0x9b493
leaq 0x28a619(%rip), %rdi    # 0x325a40
callq 0x9470
movl %ebx, %eax
imulq $0x348, %rax, %rax      # imm = 0x348
xorpd %xmm1, %xmm1
addq 0x9eb08(%rip), %rax     # 0x139f48
ucomisd %xmm1, %xmm0
jne 0x9b448
jnp 0x9b477
movl %ebx, 0x218(%rax)
movl $0x37, 0x1c(%rax)
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20(%rax)
movl %ebx, %edi
callq 0xca4da
leaq 0x25bee0(%rip), %rcx    # 0x2f734c
orl %eax, (%rcx)
movl %ebx, %edi
callq 0x559ba
jmp 0x9b482
andl $0x0, 0x1c(%rax)
andl $0x0, 0x218(%rax)
leaq 0x70799(%rip), %rax     # 0x10bc22
leaq 0x18da68(%rip), %rcx    # 0x228ef8
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_true_status()
void parse_true_status()
{
u32 ho;
int val;

   log_packet_id("status");

   if(get_msg_field()) {  // 10MHz
      val = atoi(msg_field);
   }
   else return;

   if(get_msg_field()) {  // 1PPS
      val = atoi(msg_field);
   }
   else return;

   if(get_msg_field()) {  // antenna          
      val = atoi(msg_field);
      if(val) minor_alarms |= (MINOR_ANT_NO_PWR);
      else    minor_alarms &= (~MINOR_ANT_NO_PWR);
      have_antenna = 56;
   }
   else return;

   if(get_msg_field()) {  // holdover duration
      ho = (u32) atoi(msg_field);
      if(ho) holdover = ho;
   }
   else return;

   if(get_msg_field()) {  // num sats
      val = atoi(msg_field);
   }
   else return;

   if(get_msg_field()) {  // state
      val = atoi(msg_field);
      if     (val == 0) discipline_mode = DIS_MODE_NORMAL;
      else if(val == 1) discipline_mode = DIS_MODE_ACQUIRE;     // acquiring
      else if(val == 2) discipline_mode = DIS_MODE_POWERUP;
      else if(val == 3) discipline_mode = DIS_MODE_AUTO_HOLD;
      else if(val == 4) discipline_mode = DIS_MODE_MANUAL_HOLD;
      else if(val == 5) discipline_mode = DIS_MODE_SOFT_HOLD;
      else if(val == 6) discipline_mode = DIS_MODE_NO_GPS;      // no gps
      else if(val == 7) discipline_mode = DIS_MODE_LEARNING;    // training OCXO
      else if(1 || ((val >= 8) && (val <= 17))) {
         true_wait = val;
         discipline_mode = DIS_MODE_WAIT;
      }
      else discipline_mode = DIS_MODE_UNKNOWN;

      true_debug = atoi(msg_field);
      have_true_debug = 1;
      have_ffom = 1;
   }
   else return;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7447f(%rip), %rdi     # 0x10fa65
callq 0x520bf
callq 0x75767
testl %eax, %eax
je 0x9b6db
callq 0x75767
testl %eax, %eax
je 0x9b6db
callq 0x75767
testl %eax, %eax
je 0x9b6db
leaq 0x28a427(%rip), %rdi    # 0x325a40
callq 0x95e0
leaq 0x25bbb3(%rip), %rcx    # 0x2f71d8
movl (%rcx), %edx
andl $-0x7, %edx
testl %eax, %eax
pushq $0x6
popq %rsi
cmovel %eax, %esi
orl %edx, %esi
movl %esi, (%rcx)
leaq 0x25bbef(%rip), %rax    # 0x2f722c
movl $0x38, (%rax)
callq 0x75767
testl %eax, %eax
je 0x9b6db
leaq 0x28a3e9(%rip), %rdi    # 0x325a40
callq 0x95e0
testl %eax, %eax
je 0x9b669
leaq 0x25bdf1(%rip), %rcx    # 0x2f7458
movl %eax, (%rcx)
callq 0x75767
testl %eax, %eax
je 0x9b6db
callq 0x75767
testl %eax, %eax
je 0x9b6db
leaq 0x28a3be(%rip), %rdi    # 0x325a40
callq 0x95e0
cmpl $0x8, %eax
jae 0x9b6a0
shll $0x3, %eax
movabsq $0x1415160302011700, %rdx # imm = 0x1415160302011700
movl %eax, %ecx
shrq %cl, %rdx
jmp 0x9b6a8
movl %eax, 0x2be94e(%rip)    # 0x359ff4
movb $0x18, %dl
leaq 0x25bde8(%rip), %rax    # 0x2f7497
movb %dl, (%rax)
leaq 0x28a388(%rip), %rdi    # 0x325a40
callq 0x95e0
leaq 0x28bcdc(%rip), %rcx    # 0x3273a0
movl %eax, (%rcx)
leaq 0x28bcd7(%rip), %rax    # 0x3273a4
pushq $0x1
popq %rcx
movl %ecx, (%rax)
leaq 0x25b583(%rip), %rax    # 0x2f6c5c
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: two_enviro_mode()
int two_enviro_mode()
{
   // returns true if there is a environmental sensor thermometer on the main 
   // receiver port and on the auxiliary ENVIRO_PORT  - Heather does not 
   // currently support this.

   if((rcvr_type == THERMO_RCVR) && enviro_port_open()) return 1;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x16715c(%rip), %rax    # 0x2028d0
cmpq $0x80000, (%rax)        # imm = 0x80000
jne 0x9b79d
leaq 0x25cb5c(%rip), %rax    # 0x2f82e0
cmpl $0x0, 0x225d4(%rax)
je 0x9b79d
cmpl $0x0, 0x225d0(%rax)
jle 0x9b79d
movl $0x1, %eax
jmp 0x9b79f
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: get_enviro_field()
int get_enviro_field()
{
char c;
int i;

   // extract the next field from a sensorr message.  Fields are separated
   // by commas, spaces, or tabs.

   enviro_field[0] = 0;
   if(enviro_msg[enviro_col] == 0) return 0;  // at end-of-message

   i = 0;
   while(enviro_col < (int)sizeof(enviro_msg)) {   // get next field from the thermometer message
      c = enviro_msg[enviro_col];
      if(c == 0) {  // reached end-of-message
         break;
      }
      else if(c == ' ') {  // skip leading spaces, end field on a space
         ++enviro_col;
         if(i) break;
      }
      else if(c == '\t') {  // skip leading spaces, end field on a tab
         ++enviro_col;
         if(i) break;
      }
      else if(c == ',') {  // skip leading spaces, end field on a comma
         ++enviro_col;
         if(i) break;
      }
      else {        // add char to extracted field
         enviro_field[i++] = c;
         enviro_field[i] = 0;
         ++enviro_col;
      }
   }

   return enviro_field[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, 0x2baca4(%rip)    # 0x356450
movslq 0x2baea1(%rip), %rax    # 0x356654
leaq 0x2baa86(%rip), %rcx    # 0x356240
cmpb $0x0, (%rax,%rcx)
je 0x9b81f
xorl %esi, %esi
leaq 0x2bac87(%rip), %rdx    # 0x356450
cmpl $0x200, %eax            # imm = 0x200
jg 0x9b816
movslq %eax, %rdi
movzbl (%rdi,%rcx), %edi
cmpl $0x9, %edi
je 0x9b805
cmpl $0x20, %edi
je 0x9b805
cmpl $0x2c, %edi
je 0x9b805
testl %edi, %edi
je 0x9b816
movslq %esi, %r8
leaq 0x1(%r8), %rsi
movb %dil, (%r8,%rdx)
movb $0x0, 0x1(%r8,%rdx)
incl %eax
movl %eax, 0x2bae51(%rip)    # 0x356654
jmp 0x9b7c9
incl %eax
movl %eax, 0x2bae47(%rip)    # 0x356654
testl %esi, %esi
movl $0x0, %esi
je 0x9b7c9
movsbl 0x2bac33(%rip), %eax    # 0x356450
jmp 0x9b821
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: save_temp1()
void save_temp1()
{
   // if the enviro sensor is the main receiver or the GPS device does not
   // report temperatures, store the main temp sensor reading in the regular 
   // temperature variable/plot (GT plot).

   if(rcvr_type == THERMO_RCVR) {
      temperature = tc1;
      have_temperature = 900;
   }
   else if(have_temperature == 0) {
      temperature = tc1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x166cd3(%rip), %rax    # 0x2028d0
cmpq $0x80000, (%rax)        # imm = 0x80000
jne 0x9bc2b
leaq 0x25afa3(%rip), %rax    # 0x2f6bb0
movsd (%rax), %xmm0
leaq 0x25ae00(%rip), %rax    # 0x2f6a18
movsd %xmm0, (%rax)
leaq 0x25b629(%rip), %rax    # 0x2f724c
movl $0x384, (%rax)          # imm = 0x384
jmp 0x9bc4d
leaq 0x25b61a(%rip), %rax    # 0x2f724c
cmpl $0x0, (%rax)
jne 0x9bc4d
leaq 0x25af72(%rip), %rax    # 0x2f6bb0
movsd (%rax), %xmm0
leaq 0x25adcf(%rip), %rax    # 0x2f6a18
movsd %xmm0, (%rax)
popq %rbp
retq