LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_track()
void parse_scpi_track()
{
int prn;

   log_packet_id("scpi track");

   for(prn=0; prn<=MAX_PRN; prn++) { 
      sat[prn].tracking = sat[prn].visible;
      if(sat[prn].visible) sat[prn].level_msg = 14;
      else                 sat[prn].level_msg = 0;
      have_snr |= rinex_gnss(prn);
   }

   msg_col = 0;
   while(get_msg_field()) {
      prn = atoi(msg_field);
      if((prn >= 1) && (prn <= MAX_PRN)) { 
         sat[prn].tracking = (1);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x871cf(%rip), %rdi     # 0x124f2e
callq 0x58dc2
movl $0x21c, %r14d           # imm = 0x21C
addq 0xb21cf(%rip), %r14     # 0x14ff40
xorl %ebx, %ebx
movl $0xe, %r15d
leaq 0x26f5cc(%rip), %r12    # 0x30d34c
movl (%r14), %eax
movl %eax, -0x4(%r14)
testl %eax, %eax
cmovnel %r15d, %eax
movl %eax, -0x200(%r14)
movl %ebx, %edi
callq 0xdc1dd
orl %eax, (%r12)
incq %rbx
addq $0x348, %r14            # imm = 0x348
cmpq $0x3e8, %rbx            # imm = 0x3E8
jne 0x9dd80
leaq 0x29de8b(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9de07
leaq 0x29dc71(%rip), %rbx    # 0x33ba40
leaq 0x1a11da(%rip), %r14    # 0x23efb0
movq %rbx, %rdi
callq 0x95e0
leal -0x1(%rax), %ecx
cmpl $0x3e6, %ecx            # imm = 0x3E6
ja 0x9ddfe
movl %eax, %eax
imulq $0x348, %rax, %rax      # imm = 0x348
movl $0x1, 0x218(%r14,%rax)
callq 0x810b1
testl %eax, %eax
jne 0x9ddd6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_efc()
void parse_scpi_efc()
{
   log_packet_id("scpi efc");

   msg_col = 0;
   if(get_msg_field()) {
      dac_voltage = (float) atof(msg_field);
      if(rcvr_type == CS_RCVR) dac_voltage *= 100.0;
      have_dac = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x8711e(%rip), %rdi     # 0x124f39
callq 0x58dc2
leaq 0x29de1d(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9de7e
leaq 0x29dc03(%rip), %rdi    # 0x33ba40
callq 0x9470
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x26ebaf(%rip), %rax    # 0x30ca00
movsd %xmm0, (%rax)
leaq 0x17aa74(%rip), %rcx    # 0x2188d0
cmpq $0x20000, (%rcx)        # imm = 0x20000
jne 0x9de71
mulsd 0x6b1f3(%rip), %xmm0    # 0x109060
movsd %xmm0, (%rax)
leaq 0x26f484(%rip), %rax    # 0x30d2fc
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_efc()
void parse_uccm_efc()
{
u32 val;

//kkkkkkuuuuuu
   log_packet_id("uccm efc");

   msg_col = 0;
   if(strstr(nmea_msg, "TO GPS")) {  // recovering from manual mode
      discipline_mode = DIS_MODE_RECOVERY;  // recovery
   }
   else if(strstr(nmea_msg, "RANGE")) {  // out of range
   }
   else if(get_msg_field() > 2) {
      if(discipline_mode == DIS_MODE_RECOVERY) discipline_mode = DIS_MODE_NORMAL;
      val = atohex(&msg_field[2]);
      uccm_voltage = (float) val;
   }
// sprintf(debug_text, "uccm voltage:%f  msg:%s", uccm_voltage, nmea_msg); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x870b7(%rip), %rdi     # 0x124f42
callq 0x58dc2
leaq 0x29ddad(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
leaq 0x29d98c(%rip), %rdi    # 0x33b830
leaq 0x870a0(%rip), %rsi     # 0x124f4b
callq 0x9090
testq %rax, %rax
je 0x9dec1
leaq 0x26f5db(%rip), %rax    # 0x30d497
movb $0x4, (%rax)
jmp 0x9df18
leaq 0x29d968(%rip), %rdi    # 0x33b830
leaq 0x877e5(%rip), %rsi     # 0x1256b4
callq 0x9090
testq %rax, %rax
jne 0x9df18
callq 0x810b1
cmpl $0x3, %eax
jl 0x9df18
leaq 0x26f5ad(%rip), %rax    # 0x30d497
cmpb $0x4, (%rax)
jne 0x9def2
movb $0x0, (%rax)
leaq 0x29db47(%rip), %rdi    # 0x33ba40
addq $0x2, %rdi
callq 0x98c6
movl %eax, %eax
cvtsi2ss %rax, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x26eaf4(%rip), %rax    # 0x30ca08
movsd %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_led()
void parse_uccm_led()
{
int i;

   log_packet_id("uccm led");

   if(scpi_type == UCCMP_TYPE) { 
      if     (strstr(nmea_msg, "0")) strcpy(uccm_led_msg, "Initializing   ");
      else if(strstr(nmea_msg, "1")) strcpy(uccm_led_msg, "Normal         ");
      else goto uccm_style;
   }
   else {
      uccm_style:
      nmea_msg[16] = 0;
      strcpy(uccm_led_msg, nmea_msg);
      for(i=strlen(uccm_led_msg); i<16; i++) uccm_led_msg[i] = ' ';
      uccm_led_msg[16] = 0;
      strupr(uccm_led_msg);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x8702b(%rip), %rdi     # 0x124f52
callq 0x58dc2
leaq 0x17d0ad(%rip), %rax    # 0x21afe0
cmpl $0x50, (%rax)
jne 0x9df85
leaq 0x29d8f1(%rip), %rdi    # 0x33b830
movl $0x30, %esi
callq 0x9100
testq %rax, %rax
je 0x9df57
movups 0x87006(%rip), %xmm0    # 0x124f5b
jmp 0x9df74
leaq 0x29d8d2(%rip), %rdi    # 0x33b830
movl $0x31, %esi
callq 0x9100
testq %rax, %rax
je 0x9df85
movups 0x86ff7(%rip), %xmm0    # 0x124f6b
leaq 0x26ece5(%rip), %rax    # 0x30cc60
movaps %xmm0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x29d8a4(%rip), %rsi    # 0x33b830
movb $0x0, 0x10(%rsi)
leaq 0x26ecc9(%rip), %rbx    # 0x30cc60
movq %rbx, %rdi
callq 0x9340
movq %rbx, %rdi
callq 0x9120
cmpl $0xf, %eax
jg 0x9dfcc
cltq
leaq 0x26ecab(%rip), %rdi    # 0x30cc60
addq %rax, %rdi
movl $0xf, %edx
subl %eax, %edx
incq %rdx
movl $0x20, %esi
callq 0x91a0
movb $0x0, 0x10(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9899
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_cable()
void parse_scpi_cable()
{
   log_packet_id("scpi cable");

   msg_col = 0;
   if(get_msg_field()) {
      cable_delay = atof(msg_field);
      if(cable_delay >= 1.0) {  // cable delay is probably in nanoseconds (early firmware?)
         cable_delay *= 1.0E-9;
         cable_nsecs = 1;
      }
      else cable_nsecs = 0;  // standard is in seconds

      have_cable_delay = 1;
      show_cable_delay();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x86f92(%rip), %rdi     # 0x124f7b
callq 0x58dc2
leaq 0x29dc4f(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9e050
leaq 0x29da35(%rip), %rdi    # 0x33ba40
callq 0x9470
xorl %eax, %eax
ucomisd 0x6b056(%rip), %xmm0    # 0x109070
setae %cl
jb 0x9e027
mulsd 0x6b121(%rip), %xmm0    # 0x109148
movb %cl, %al
leaq 0x26fd98(%rip), %rcx    # 0x30ddc8
movsd %xmm0, (%rcx)
leaq 0x26fdad(%rip), %rcx    # 0x30dde8
movl %eax, (%rcx)
leaq 0x26f270(%rip), %rax    # 0x30d2b4
movl $0x1, (%rax)
popq %rbp
jmp 0x75326
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_elev()
void parse_scpi_elev()
{
   log_packet_id("scpi elev");

   msg_col = 0;
   if(get_msg_field()) {
      el_mask = (float) atof(msg_field);
      have_el_mask = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x86f29(%rip), %rdi     # 0x124f86
callq 0x58dc2
leaq 0x29dbdb(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9e0a0
leaq 0x29d9c1(%rip), %rdi    # 0x33ba40
callq 0x9470
cvtsd2ss %xmm0, %xmm0
leaq 0x26f025(%rip), %rax    # 0x30d0b4
movss %xmm0, (%rax)
leaq 0x26f362(%rip), %rax    # 0x30d3fc
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_utc_ofs()
void parse_scpi_utc_ofs()
{
   log_packet_id("scpi utc ofs");

   msg_col = 0;
   if(!user_set_utc_ofs && get_msg_field()) {
      utc_offset = (int) atof(msg_field);
      check_utc_ofs(10);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x86ee3(%rip), %rdi     # 0x124f90
callq 0x58dc2
leaq 0x29db8b(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
leaq 0x26f66e(%rip), %rax    # 0x30d734
cmpl $0x0, (%rax)
je 0x9e0cd
popq %rbp
retq
callq 0x810b1
testl %eax, %eax
je 0x9e0cb
leaq 0x29d963(%rip), %rdi    # 0x33ba40
callq 0x9470
cvttsd2si %xmm0, %ecx
leaq 0x26f63b(%rip), %rax    # 0x30d728
movl %ecx, (%rax)
leaq 0x26f226(%rip), %rax    # 0x30d31c
cmpl $0x0, (%rax)
jne 0x9e0cb
leaq 0x26f412(%rip), %rdx    # 0x30d514
cmpl $0x7e1, (%rdx)          # imm = 0x7E1
setge %dl
cmpl $0x12, %ecx
setl %sil
andb %dl, %sil
cmpl $0x11, %ecx
setl %cl
orb %sil, %cl
jne 0x9e0cb
leaq 0x17a71d(%rip), %rcx    # 0x218844
movl $0x7da, (%rcx)          # imm = 0x7DA
movl $0xa, (%rax)
jmp 0x9e0cb
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_tint()
void parse_scpi_tint()
{
   log_packet_id("scpi tint");

   msg_col = 0;
   if(get_msg_field()) {
      if(scpi_type == NORTEL_TYPE) pps_offset = (float) atof(msg_field)*1.0;
      else                         pps_offset = (float) atof(msg_field)*1.0E9;
      // doing adves of TINT handled in secondary_timing()
      have_pps_offset = 7;
      have_rcvr_pps = 7;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x86737(%rip), %rdi     # 0x12506d
callq 0x58dc2
leaq 0x29d302(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9e99d
leaq 0x17c688(%rip), %rax    # 0x21afe0
movl (%rax), %ebx
leaq 0x29d0df(%rip), %rdi    # 0x33ba40
callq 0x9470
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
cmpl $0x4e, %ebx
je 0x9e97b
mulsd 0x6a6ad(%rip), %xmm0    # 0x109028
leaq 0x26de36(%rip), %rax    # 0x30c7b8
movsd %xmm0, (%rax)
leaq 0x26e8ab(%rip), %rax    # 0x30d238
movl $0x7, %ecx
movl %ecx, (%rax)
leaq 0x26e8a9(%rip), %rax    # 0x30d244
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_progress()
void parse_scpi_progress()
{
   log_packet_id("scpi progress");

   msg_col = 0;
   if(get_msg_field()) {
      survey_progress = (int) atof(msg_field);
      have_progress = 5;
      if(scpi_type == NORTEL_TYPE) {
         if(survey_progress != 100) minor_alarms |= MINOR_SURVEY;
         else                       minor_alarms &= (~MINOR_SURVEY);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x866c8(%rip), %rdi     # 0x125077
callq 0x58dc2
leaq 0x29d289(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9ea17
leaq 0x29d06f(%rip), %rdi    # 0x33ba40
callq 0x9470
cvttsd2si %xmm0, %eax
leaq 0x26f4ab(%rip), %rcx    # 0x30de8c
movl %eax, (%rcx)
leaq 0x26f4a6(%rip), %rcx    # 0x30de90
movl $0x5, (%rcx)
leaq 0x17c5e9(%rip), %rcx    # 0x21afe0
cmpl $0x4e, (%rcx)
jne 0x9ea17
xorl %ecx, %ecx
cmpl $0x64, %eax
setne %cl
leaq 0x26e7cd(%rip), %rax    # 0x30d1d8
movl (%rax), %edx
andl $-0x21, %edx
shll $0x5, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_survey()
void parse_scpi_survey()
{
   log_packet_id("scpi survey");

   msg_col = 0;
// !!! should restore com_timeout
   if(get_msg_field()) {
      strupr(msg_field);
      if(strstr(msg_field, "ONCE"))   minor_alarms |= MINOR_SURVEY;
      else if(strstr(msg_field, "1")) minor_alarms |= MINOR_SURVEY;
      else                            minor_alarms &= (~MINOR_SURVEY);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x8665f(%rip), %rdi     # 0x125085
callq 0x58dc2
leaq 0x29d212(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9ea9a
leaq 0x29cff8(%rip), %rbx    # 0x33ba40
movq %rbx, %rdi
callq 0x9899
leaq 0x82f7b(%rip), %rsi     # 0x1219d2
movq %rbx, %rdi
callq 0x9090
testq %rax, %rax
je 0x9ea6f
leaq 0x26e76d(%rip), %rax    # 0x30d1d8
movl (%rax), %ecx
jmp 0x9ea8e
leaq 0x29cfca(%rip), %rdi    # 0x33ba40
movl $0x31, %esi
callq 0x9100
leaq 0x26e751(%rip), %rcx    # 0x30d1d8
movl (%rcx), %ecx
testq %rax, %rax
je 0x9eaa1
orl $0x20, %ecx
leaq 0x26e740(%rip), %rax    # 0x30d1d8
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
andl $-0x21, %ecx
jmp 0x9ea91
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_holdover()
void parse_scpi_holdover()
{
int state;

   log_packet_id("scpi holdover");

   msg_col = 0;
   if(get_msg_field()) {
      holdover = (int) atof(msg_field);
   }

   if(get_msg_field()) {
      state = atoi(msg_field);
      if(state) {  // in holdover mode
         discipline_mode = DIS_MODE_MANUAL_HOLD;
         if(!have_scpi_hold) user_holdover = 1;
if(scpi_type != UCCMP_TYPE) {  // kkkkkk
   rcvr_mode = RCVR_MODE_PROP;
   have_rcvr_mode = 10;
}
      }
      else {   // not in holdover
         discipline_mode = DIS_MODE_NORMAL;
         if(!have_scpi_hold) user_holdover = 0;
if(scpi_type != UCCMP_TYPE) {  // kkkkkk
   rcvr_mode = RCVR_MODE_HOLD;
   have_rcvr_mode = 10;
}
      }
      have_scpi_hold = 1;
   }
// !!! should restore com_timeout
if(debug_file) fprintf(debug_file, "### holdover:%d  dmode:%d  user:%d\n", holdover, discipline_mode, user_holdover);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x865e0(%rip), %rdi     # 0x125091
callq 0x58dc2
leaq 0x29d187(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9eae5
leaq 0x29cf6d(%rip), %rdi    # 0x33ba40
callq 0x9470
cvttsd2si %xmm0, %eax
leaq 0x26e975(%rip), %rcx    # 0x30d458
movl %eax, (%rcx)
callq 0x810b1
testl %eax, %eax
je 0x9eb7b
leaq 0x29cf47(%rip), %rdi    # 0x33ba40
callq 0x95e0
testl %eax, %eax
je 0x9eb2d
leaq 0x26e98e(%rip), %rax    # 0x30d497
movb $0x3, (%rax)
leaq 0x26e94d(%rip), %rax    # 0x30d460
cmpl $0x0, (%rax)
jne 0x9eb22
leaq 0x26e935(%rip), %rax    # 0x30d454
movb $0x1, (%rax)
leaq 0x17c4b7(%rip), %rcx    # 0x21afe0
movb $0x8, %al
jmp 0x9eb56
leaq 0x26e963(%rip), %rax    # 0x30d497
movb $0x0, (%rax)
leaq 0x26e922(%rip), %rax    # 0x30d460
cmpl $0x0, (%rax)
jne 0x9eb4d
leaq 0x26e90a(%rip), %rax    # 0x30d454
movb $0x0, (%rax)
leaq 0x17c48c(%rip), %rcx    # 0x21afe0
movb $0x7, %al
cmpl $0x50, (%rcx)
je 0x9eb6e
leaq 0x26e56e(%rip), %rcx    # 0x30d0d0
movb %al, (%rcx)
leaq 0x26e8a2(%rip), %rax    # 0x30d40d
movb $0xa, (%rax)
leaq 0x26e8eb(%rip), %rax    # 0x30d460
movl $0x1, (%rax)
leaq 0x19f80e(%rip), %rax    # 0x23e390
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9ebb7
leaq 0x26e8c7(%rip), %rax    # 0x30d458
movl (%rax), %edx
leaq 0x26e8fd(%rip), %rax    # 0x30d497
movzbl (%rax), %ecx
leaq 0x26e8b0(%rip), %rax    # 0x30d454
movzbl (%rax), %r8d
leaq 0x864f0(%rip), %rsi     # 0x12509f
xorl %eax, %eax
popq %rbp
jmp 0x9560
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_utc()
void parse_scpi_utc()
{
int state;

   log_packet_id("scpi utc");

   msg_col = 0;
   if(get_msg_field()) {
      state = (int) atof(msg_field);
      if(state == 0) {  // GPS time
         time_flags &= (~TFLAGS_UTC);
         timing_mode = TMODE_GPS;
         have_timing_mode = 1;
      }
      else {  // utc time
         time_flags |= (TFLAGS_UTC);
         timing_mode = TMODE_UTC;
         have_timing_mode = 1;
      }
      have_rcvr_tmode = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x864fb(%rip), %rdi     # 0x1250d0
callq 0x58dc2
leaq 0x29d063(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9ec3a
leaq 0x29ce49(%rip), %rdi    # 0x33ba40
callq 0x9470
cvttsd2si %xmm0, %eax
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leaq 0x26e896(%rip), %rax    # 0x30d4a4
movl (%rax), %edx
andl $-0x2, %edx
orl %ecx, %edx
leal (%rcx,%rcx,2), %ecx
movl %edx, (%rax)
leaq 0x26e89c(%rip), %rax    # 0x30d4bd
movb %cl, (%rax)
leaq 0x26e7a2(%rip), %rax    # 0x30d3cc
movl $0x1, %ecx
movl %ecx, (%rax)
leaq 0x26e798(%rip), %rax    # 0x30d3d0
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_tunc()
void parse_scpi_tunc()
{
   log_packet_id("scpi tunc");

   msg_col = 0;
   if(get_msg_field()) {
      osc_offset = (float) atof(nmea_msg);
      have_osc_offset = 7;
      have_rcvr_osc = 7;
osc_offset *= 1000.0;
//    if(jitter_adev == 0) do_osc_adev(osc_offset);  // makes no sense to ADEV
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x86492(%rip), %rdi     # 0x1250d9
callq 0x58dc2
leaq 0x29cff1(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9eca0
leaq 0x29cbc7(%rip), %rdi    # 0x33b830
callq 0x9470
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x26e5b7(%rip), %rax    # 0x30d234
movl $0x7, %ecx
movl %ecx, (%rax)
leaq 0x26e5bd(%rip), %rax    # 0x30d248
movl %ecx, (%rax)
mulsd 0x6a3a3(%rip), %xmm0    # 0x109038
leaq 0x26db24(%rip), %rax    # 0x30c7c0
movsd %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_edge()
void parse_scpi_edge()
{
   log_packet_id("scpi edge");

   msg_col = 0;
   if(get_msg_field()) {
      strupr(msg_field);
      if     (strstr(msg_field, "RIS")) {
         pps_polarity = 0;
         have_pps_polarity = 12;
      }
      else if(strstr(msg_field, "FAL")) {
         pps_polarity = 1;
         have_pps_polarity = 12;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x86434(%rip), %rdi     # 0x1250e3
callq 0x58dc2
leaq 0x29cf89(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9ed22
leaq 0x29cd6f(%rip), %rbx    # 0x33ba40
movq %rbx, %rdi
callq 0x9899
leaq 0x823f2(%rip), %rsi     # 0x1210d2
movq %rbx, %rdi
callq 0x9090
xorl %ecx, %ecx
testq %rax, %rax
jne 0x9ed0c
leaq 0x29cd4a(%rip), %rdi    # 0x33ba40
leaq 0x863f0(%rip), %rsi     # 0x1250ed
callq 0x9090
movl $0x1, %ecx
testq %rax, %rax
je 0x9ed22
leaq 0x26f005(%rip), %rax    # 0x30dd18
movl %ecx, (%rax)
leaq 0x26e5c4(%rip), %rax    # 0x30d2e0
movl $0xc, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_life()
void parse_scpi_life()
{
   log_packet_id("scpi life");

   msg_col = 0;
   if(get_msg_field()) {
      scpi_life = atoi(msg_field) * 3;
      have_lifetime = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x863bd(%rip), %rdi     # 0x1250f1
callq 0x58dc2
leaq 0x29cf04(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9ed74
leaq 0x29ccea(%rip), %rdi    # 0x33ba40
callq 0x95e0
leal (%rax,%rax,2), %eax
leaq 0x26e6f7(%rip), %rcx    # 0x30d45c
movl %eax, (%rcx)
leaq 0x26e55a(%rip), %rax    # 0x30d2c8
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_test()
void parse_scpi_test()
{
// !!! should restore com_timeout
   log_packet_id("scpi test");

   msg_col = 0;
   if(get_msg_field()) {
      scpi_test = atoi(nmea_msg);
      have_scpi_test = 1;
if(debug_file) fprintf(debug_file, "### self test:%04X\n", scpi_test);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x8639e(%rip), %rdi     # 0x12511f
callq 0x58dc2
leaq 0x29ceb7(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9edde
leaq 0x29ca8d(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x26e689(%rip), %rcx    # 0x30d438
movl %eax, (%rcx)
leaq 0x26e648(%rip), %rcx    # 0x30d400
movl $0x1, (%rcx)
leaq 0x19f5cb(%rip), %rcx    # 0x23e390
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x9edde
leaq 0x86355(%rip), %rsi     # 0x125129
movl %eax, %edx
xorl %eax, %eax
popq %rbp
jmp 0x9560
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_operation()
void parse_scpi_operation()
{
int status;

   log_packet_id("scpi operation");

   if(scpi_type != NORTEL_TYPE) return;

   // 0x0002 - locked
   // 0x0004 - holdover/unlocked modes
   // 0x0008 - position hold
   // 0x0010 - sats tracked
   // 0x0020 - hardware status reg set
   // 0x0040 - diagnostic log almost full
   // 0x0080 - over temp
   // 0x0100 - under temp
   // 0x0200 - antenna fault

   msg_col = 0;
   if(get_msg_field()) {
      status = atoi(nmea_msg);
if(debug_file) fprintf(debug_file, "### operation status:%04X\n", status);
      if(status & 0x0080) {       // over temperature alarm
         temperature = 71.0F;
         have_temperature = 109;
      }
      else if(status & 0x0100) {  // under temperature alarm
         temperature = (-1.0F);
         have_temperature = 110;
      }
      else {
         temperature = 30.0F;     // normal temperature
         have_temperature = 111;
      }

      if(status & 0x0010) minor_alarms &= (~MINOR_NO_TRACK);  // sat tracking OK
      else                minor_alarms |= MINOR_NO_TRACK;
      have_tracking = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x861fb(%rip), %rdi     # 0x125165
callq 0x58dc2
leaq 0x17c06a(%rip), %rax    # 0x21afe0
cmpl $0x4e, (%rax)
jne 0x9f02a
leaq 0x29ccbe(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9f02a
leaq 0x29c890(%rip), %rdi    # 0x33b830
callq 0x95e0
movl %eax, %ebx
leaq 0x19f3e2(%rip), %rax    # 0x23e390
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9efc6
leaq 0x861b7(%rip), %rsi     # 0x125174
movl %ebx, %edx
xorl %eax, %eax
callq 0x9560
testb %bl, %bl
js 0x9efe4
xorl %eax, %eax
btl $0x8, %ebx
setae %al
leaq 0x7faf6(%rip), %rcx     # 0x11ead0
movsd (%rcx,%rax,8), %xmm0
orl $0x6e, %eax
jmp 0x9eff1
movl $0x6d, %eax
movsd 0x7f7c7(%rip), %xmm0    # 0x11e7b8
leaq 0x26da20(%rip), %rcx    # 0x30ca18
movsd %xmm0, (%rcx)
leaq 0x26e249(%rip), %rcx    # 0x30d24c
movl %eax, (%rcx)
leaq 0x26e1cc(%rip), %rax    # 0x30d1d8
movl (%rax), %ecx
andl $-0x9, %ecx
shrl %ebx
andl $0x8, %ebx
orl %ecx, %ebx
xorl $0x8, %ebx
movl %ebx, (%rax)
leaq 0x26e26c(%rip), %rax    # 0x30d290
movl $0x1, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_ignore()
void parse_scpi_ignore()
{
u32 val;
int count;
int prn;
int flag;

   log_packet_id("scpi ignore");

   count = 0;
   val = 0;

   msg_col = 0;
   while(get_msg_field()) {
      prn = atoi(msg_field);
      if((prn >= 1) && (prn <= 32)) { 
         val |= (1 << (prn-1));
         ++count;
      }
   }

   single_sat_prn = 0;
   have_single_prn = 1;
   if(count == 31) {  // all but 1 sat excluded
      for(prn=1; prn <= 32; prn++) {
         flag = (val & (1 << (prn-1)));
         if(flag == 0) {
            single_sat_prn = prn; 
            have_single_prn = 1;
            break;
         }
      }
   }

   val = (~val);
   sats_enabled = val;
   update_disable_list(sats_enabled);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x86144(%rip), %rdi     # 0x125198
callq 0x58dc2
leaq 0x29cbe4(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9f0dd
xorl %r12d, %r12d
leaq 0x29c9c7(%rip), %rbx    # 0x33ba40
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x95e0
decl %eax
movl $0x1, %edx
movl %eax, %ecx
shll %cl, %edx
cmpl $0x20, %eax
adcl $0x0, %r15d
cmpl $0x20, %eax
cmovael %r12d, %edx
orl %edx, %r14d
callq 0x810b1
testl %eax, %eax
jne 0x9f07f
leaq 0x26e029(%rip), %rax    # 0x30d0dc
movl $0x0, (%rax)
leaq 0x26e020(%rip), %rcx    # 0x30d0e0
movl $0x1, (%rcx)
cmpl $0x1f, %r15d
jne 0x9f100
xorl %ecx, %ecx
btl %ecx, %r14d
jae 0x9f0fc
incl %ecx
cmpl $0x20, %ecx
jne 0x9f0ce
jmp 0x9f100
leaq 0x26dff8(%rip), %rax    # 0x30d0dc
movl $0x0, (%rax)
leaq 0x26dfef(%rip), %rax    # 0x30d0e0
movl $0x1, (%rax)
xorl %r14d, %r14d
jmp 0x9f100
incl %ecx
movl %ecx, (%rax)
movl %r14d, %eax
notl %eax
leaq 0x26dfd8(%rip), %rcx    # 0x30d0e4
movl %eax, (%rcx)
movl $0x349, %eax            # imm = 0x349
addq 0xb0e26(%rip), %rax     # 0x14ff40
xorl %ecx, %ecx
btl %ecx, %r14d
setb (%rax)
incq %rcx
addq $0x348, %rax            # imm = 0x348
cmpq $0x20, %rcx
jne 0x9f11c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_ign_count()
void parse_scpi_ign_count()
{
int val;

   log_packet_id("scpi count");

   msg_col = 0;
   if(get_msg_field()) {
      val = atoi(msg_field);  // single_sat_prn
      if(val & (single_sat_prn == 0)) {
         single_sat_prn = 32;  // !!!!! kludge
         have_single_prn = 0;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x8605e(%rip), %rdi     # 0x1251a4
callq 0x58dc2
leaq 0x29caf2(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9f191
leaq 0x29c8d8(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x26df68(%rip), %rcx    # 0x30d0dc
cmpl $0x0, (%rcx)
jne 0x9f191
andl $0x1, %eax
je 0x9f191
movl $0x20, (%rcx)
leaq 0x26df55(%rip), %rax    # 0x30d0e0
movl $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_include()
void parse_scpi_include()
{
u32 val;
int count;
int prn;
int last_prn;

   log_packet_id("scpi include");

   if(scpi_type != NORTEL_TYPE) return;

   count = 0;
   val = 0;
   last_prn = 0;
   msg_col = 0;
   while(get_msg_field()) {
      prn = atoi(msg_field);
      if((prn >= 1) && (prn <= 32)) { 
         val |= 1 << (prn-1);
         last_prn = prn;
         ++count;
      }
   }

   if(count == 1) single_sat_prn = last_prn; 
   else           single_sat_prn = 0;
   have_single_prn = 1;

   sats_enabled = val;
   update_disable_list(sats_enabled);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x86007(%rip), %rdi     # 0x1251af
callq 0x58dc2
leaq 0x17be2c(%rip), %rax    # 0x21afe0
cmpl $0x4e, (%rax)
jne 0x9f26e
leaq 0x29ca80(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9f225
xorl %r12d, %r12d
leaq 0x29c863(%rip), %rbx    # 0x33ba40
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x95e0
leal -0x1(%rax), %ecx
cmpl $0x20, %ecx
adcl $0x0, %r13d
cmpl $0x20, %ecx
cmovbl %eax, %r15d
movl $0x1, %eax
shll %cl, %eax
cmpl $0x20, %ecx
cmovael %r12d, %eax
orl %eax, %r14d
callq 0x810b1
testl %eax, %eax
jne 0x9f1e6
xorl %eax, %eax
cmpl $0x1, %r13d
cmovel %r15d, %eax
jmp 0x9f22a
xorl %eax, %eax
xorl %r14d, %r14d
leaq 0x26deab(%rip), %rcx    # 0x30d0dc
movl %eax, (%rcx)
leaq 0x26dea6(%rip), %rax    # 0x30d0e0
movl $0x1, (%rax)
leaq 0x26de9d(%rip), %rax    # 0x30d0e4
movl %r14d, (%rax)
movl $0x349, %eax            # imm = 0x349
addq 0xb0cea(%rip), %rax     # 0x14ff40
xorl %ecx, %ecx
btl %ecx, %r14d
setae (%rax)
incq %rcx
addq $0x348, %rax            # imm = 0x348
cmpq $0x20, %rcx
jne 0x9f258
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_scpi_antenna()
void parse_scpi_antenna()
{
   log_packet_id("scpi antenna");

   minor_alarms &= (~MINOR_ANT_NO_PWR);
   if(strstr(nmea_msg, "OK")) ;
   else if(strstr(nmea_msg, "SHORT")) minor_alarms |= MINOR_ANT_SHORT;
   else if(strstr(nmea_msg, "OPEN"))  minor_alarms |= MINOR_ANT_OPEN; 
   else                               minor_alarms |= MINOR_ANT_NO_PWR; 
   have_antenna = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x85d16(%rip), %rdi     # 0x1251f4
callq 0x58dc2
leaq 0x26dcee(%rip), %rbx    # 0x30d1d8
movl (%rbx), %r15d
movl %r15d, %r14d
andl $-0x7, %r14d
movl %r14d, (%rbx)
leaq 0x29c332(%rip), %rdi    # 0x33b830
leaq 0x88114(%rip), %rsi     # 0x127619
callq 0x9090
testq %rax, %rax
jne 0x9f555
leaq 0x29c31a(%rip), %rdi    # 0x33b830
leaq 0x85ce4(%rip), %rsi     # 0x125201
callq 0x9090
testq %rax, %rax
je 0x9f52d
orl $0x4, %r14d
jmp 0x9f552
leaq 0x29c2fc(%rip), %rdi    # 0x33b830
leaq 0x85ccc(%rip), %rsi     # 0x125207
callq 0x9090
testq %rax, %rax
je 0x9f54b
orl $0x2, %r14d
jmp 0x9f552
orl $0x6, %r15d
movl %r15d, %r14d
movl %r14d, (%rbx)
leaq 0x26dcd0(%rip), %rax    # 0x30d22c
movl $0x1, (%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_uccm_rate()
void parse_uccm_rate()
{
   log_packet_id("uccm rate");

   msg_col = 0;
   if(get_msg_field()) {
      if(strstr(msg_field, "PP1S")) {
         pps_rate = RATE_1PPS;
         have_pps_rate = 6;
//pps_enabled = 1;
      }
      else if(strstr(msg_field, "PP2S")) {
         pps_rate = RATE_PP2S;
         have_pps_rate = 6;
//pps_enabled = 1;
      }
//    have_pps_enable = 10;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x85c8d(%rip), %rdi     # 0x125216
callq 0x58dc2
leaq 0x29c6af(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9f5ee
leaq 0x29c495(%rip), %rdi    # 0x33ba40
leaq 0x81d05(%rip), %rsi     # 0x1212b7
callq 0x9090
movb $0x2, %cl
testq %rax, %rax
jne 0x9f5d8
leaq 0x29c47b(%rip), %rdi    # 0x33ba40
leaq 0x81cda(%rip), %rsi     # 0x1212a6
callq 0x9090
movb $-0x7e, %cl
testq %rax, %rax
je 0x9f5ee
leaq 0x26e744(%rip), %rax    # 0x30dd23
movb %cl, (%rax)
leaq 0x26dce8(%rip), %rax    # 0x30d2d0
movl $0x6, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_pullin()
void parse_uccm_pullin()
{
char *s;

   log_packet_id("uccm pullin");

   msg_col = 0;
   s = strchr(nmea_msg, '[');
   if(s) {
      if(*s+1) {
         if(strstr(s+1, "UNLIMITED")) pullin_range = 0;
         else                         pullin_range = atoi(s+1);
         have_pullin = 1;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x85bdf(%rip), %rdi     # 0x125231
callq 0x58dc2
leaq 0x29c5e6(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
leaq 0x29c1c5(%rip), %rdi    # 0x33b830
movl $0x5b, %esi
callq 0x9100
testq %rax, %rax
je 0x9f6bc
movq %rax, %rbx
cmpb $-0x1, (%rax)
je 0x9f6bc
incq %rbx
leaq 0x85bb1(%rip), %rsi     # 0x12523d
movq %rbx, %rdi
callq 0x9090
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
jne 0x9f6a6
movq %rbx, %rdi
callq 0x95e0
leaq 0x26dabf(%rip), %rcx    # 0x30d16c
movl %eax, (%rcx)
leaq 0x26daba(%rip), %rax    # 0x30d170
movl $0x1, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_hw_alarm()
void parse_uccm_hw_alarm()
{
   log_packet_id("uccm hw alarm");

   msg_col = 0;
   if(get_msg_field()) {
      have_critical_alarms = 666;
      critical_alarms &= (~CRIT_PWR);
      if(strstr(msg_field, "POWER")) {   // SAMSUNG_TYPE
         critical_alarms |= (CRIT_PWR);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x85b76(%rip), %rdi     # 0x125247
callq 0x58dc2
leaq 0x29c567(%rip), %rax    # 0x33bc44
movl $0x0, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x9f72a
leaq 0x26dbb5(%rip), %rax    # 0x30d2a8
movl $0x29a, (%rax)          # imm = 0x29A
leaq 0x26dad0(%rip), %rbx    # 0x30d1d0
movl (%rbx), %r14d
movl %r14d, %eax
andl $-0x5, %eax
movl %eax, (%rbx)
leaq 0x29c32e(%rip), %rdi    # 0x33ba40
leaq 0x85b3c(%rip), %rsi     # 0x125255
callq 0x9090
testq %rax, %rax
je 0x9f72a
orl $0x4, %r14d
movl %r14d, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_status()
void parse_scpi_status()
{
//if(debug_file) fprintf(debug_file, "%s\n", nmea_msg);

   // decode the HIDEIOUS multi-line SCPI STATUS message (that takes three
   // seconds for the receiver to send.
   log_packet_id("scpi status");

   scpi_status = 1;
   saw_uccm_dmode = 0;
   scpi_tracked = scpi_not_tracked = 0;
   scpi_col = 0;
   scpi_status_line[0] = 0;
   no_uccm_ref = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x85b0e(%rip), %rdi     # 0x12526b
callq 0x58dc2
movl $0x1, 0x2d0878(%rip)    # 0x36ffe4
leaq 0x17b8a5(%rip), %rax    # 0x21b018
xorl %ecx, %ecx
movl %ecx, (%rax)
movl %ecx, 0x2d2757(%rip)    # 0x371ed4
movl %ecx, 0x2d274d(%rip)    # 0x371ed0
movl %ecx, 0x2cd43b(%rip)    # 0x36cbc4
movb $0x0, 0x2cd3b0(%rip)    # 0x36cb40
movl %ecx, 0x2d0852(%rip)    # 0x36ffe8
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: get_scpi_status(unsigned char)
void get_scpi_status(u08 c)
{
   if(c == 0x0D) return;

   if(c == 0x0A) {  // end-of-line, process it
      strupr(scpi_status_line);
      if(strstr(scpi_status_line, "SELF TEST")) {
         parse_scpi_status_test();
         scpi_status = 0;
poll_next_scpi(); //;;;;;;;;
      }
      else if(strstr(scpi_status_line, "PRN") && strstr(scpi_status_line, "EL")) {  // tracking info follows
         if(strstr(scpi_status_line, "SS")) adjust_scpi_ss = 1;
         else                               adjust_scpi_ss = 0;
         scpi_status = 2;
         if(rcvr_type == UCCM_RCVR) {
            reset_sat_tracking();
         }
      }
      else if(strstr(scpi_status_line, "ELEV") && strstr(scpi_status_line, "MASK")) {  // end of tracking info
         scpi_status = 4; // skip lines until we see the "SELF TEST" or "------------" end-of-status line
      }
      if(scpi_status == 2) {
         parse_scpi_azel();
      }

      scpi_col = 0;
      scpi_status_line[0] = 0;
   }
   else {
      if(scpi_col < ((int)sizeof(scpi_status_line)-2)) {
         scpi_status_line[scpi_col++] = c;
         scpi_status_line[scpi_col] = 0;
      }
   }
}

// Assembly:
cmpl $0xd, %edi
je 0xa01f2
cmpl $0xa, %edi
jne 0xa01cb
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2cc9cb(%rip), %rbx    # 0x36cb40
movq %rbx, %rdi
callq 0x9899
leaq 0x8542c(%rip), %rsi     # 0x1255b0
movq %rbx, %rdi
callq 0x9090
testq %rax, %rax
je 0xa01f3
callq 0x9ff60
movl $0x0, 0x2cfe44(%rip)    # 0x36ffe4
callq 0x6f476
cmpl $0x2, 0x2cfe38(%rip)    # 0x36ffe4
jne 0xa01b3
callq 0x9fb68
movl $0x0, 0x2cca07(%rip)    # 0x36cbc4
movb $0x0, 0x2cc97c(%rip)    # 0x36cb40
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movslq 0x2cc9f2(%rip), %rax    # 0x36cbc4
cmpq $0x7e, %rax
jg 0xa01f2
leaq 0x1(%rax), %rcx
movl %ecx, 0x2cc9e2(%rip)    # 0x36cbc4
leaq 0x2cc957(%rip), %rcx    # 0x36cb40
movb %dil, (%rax,%rcx)
movb $0x0, 0x1(%rax,%rcx)
retq
leaq 0x2cc946(%rip), %rdi    # 0x36cb40
leaq 0x92f6e(%rip), %rsi     # 0x13316f
callq 0x9090
testq %rax, %rax
je 0xa0291
leaq 0x2cc92a(%rip), %rdi    # 0x36cb40
leaq 0x69d8f(%rip), %rsi     # 0x109fac
callq 0x9090
testq %rax, %rax
je 0xa0291
leaq 0x2cc912(%rip), %rdi    # 0x36cb40
leaq 0x93205(%rip), %rsi     # 0x13343a
callq 0x9090
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
leaq 0x17add3(%rip), %rax    # 0x21b01c
movl %ecx, (%rax)
movl $0x2, 0x2cfd8f(%rip)    # 0x36ffe4
leaq 0x178674(%rip), %rax    # 0x2188d0
cmpq $0x8, (%rax)
jne 0xa01ae
movl $0x218, %eax            # imm = 0x218
leaq 0x19ed3e(%rip), %rcx    # 0x23efb0
xorl %edx, %edx
movl %edx, (%rcx,%rax)
movl %edx, -0x1fc(%rcx,%rax)
addq $0x348, %rax            # imm = 0x348
cmpq $0xcd358, %rax          # imm = 0xCD358
jne 0xa0274
jmp 0xa01a5
leaq 0x2cc8a8(%rip), %rdi    # 0x36cb40
leaq 0x8531b(%rip), %rsi     # 0x1255ba
callq 0x9090
testq %rax, %rax
je 0xa01a5
leaq 0x2cc88c(%rip), %rdi    # 0x36cb40
leaq 0x82c45(%rip), %rsi     # 0x122f00
callq 0x9090
testq %rax, %rax
je 0xa01a5
movl $0x4, 0x2cfd11(%rip)    # 0x36ffe4
jmp 0xa01b3
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: get_scpi_message()
void get_scpi_message()
{
u08 c;
static int row = 0;

   // This routine buffers up an incomming SCPI message.  When the end of the
   // message is seen, the message is parsed and decoded with decode_scpi_msg()

   if(SERIAL_DATA_AVAILABLE(RCVR_PORT) == 0) {
      check_com_timer(RCVR_PORT);
      return;
   }
   else {
      reset_com_timer(RCVR_PORT);
   }


   c = get_com_char();
   if(scpi_status) {   // we are reading the SYST:STAT? results
      get_scpi_status(c);
      return;
   }

   if(com[RCVR_PORT].rcv_error) {      // parity/framing/overrun errors
      com[RCVR_PORT].rcv_error = 0;
//!!!!!qqqq    goto rst_msg;
   }

   if(tsip_sync == 0) {    // syncing to start of message, search for a '$'
      if(c == '>') {
         tsip_sync = 1;
         get_sync_time();
      }

      rst_msg:
      tsip_wptr = 0;
      tsip_rptr = 0;
      return;
   }
   else if(tsip_sync == 1) { // '>' has been seen, now build the message
      if(c == 0x0D) goto scpi_end; 
      else if(c == 0x0A) goto scpi_end; 
      else if(c == '>')  {  // null response to SCPI command
         decode_scpi_msg();
         packet_end = 1;
         tsip_sync = 1; 
         tsip_rptr = 0;
         tsip_wptr = 0;
         return;
      }

      if(tsip_wptr < MAX_TSIP) {  // so add it to the message buffer
         tsip_buf[tsip_wptr++] = c;
      }
      else {
         tsip_sync = 0;
         goto rst_msg;
      }
   }
   else {
      scpi_end:
      decode_scpi_msg();
      packet_end = 1;
      tsip_sync = 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0xa, %edi
callq 0xb9ad
movl $0xa, %edi
testl %eax, %eax
je 0xa0312
callq 0x1ea0b
callq 0x584bd
cmpl $0x0, 0x2cfce2(%rip)    # 0x36ffe4
je 0xa031d
movzbl %al, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa015a
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1e66a
leaq 0x26dfbc(%rip), %rcx    # 0x30e2e0
cmpb $0x0, 0x17a12(%rcx)
je 0xa0334
movb $0x0, 0x17a12(%rcx)
leaq 0x297f1b(%rip), %rbx    # 0x338256
movzwl (%rbx), %ecx
cmpw $0x1, %cx
je 0xa0372
movzwl %cx, %ecx
testl %ecx, %ecx
jne 0xa03ac
cmpl $0x3e, %eax
jne 0xa035a
movw $0x1, (%rbx)
callq 0x58672
leaq 0x297ef1(%rip), %rax    # 0x338252
xorl %ecx, %ecx
movw %cx, (%rax)
leaq 0x297ee7(%rip), %rax    # 0x338254
movw %cx, (%rax)
jmp 0xa03c0
cmpb $0xa, %al
je 0xa03ac
movzbl %al, %ecx
cmpl $0xd, %ecx
je 0xa03ac
cmpl $0x3e, %ecx
jne 0xa03c7
callq 0x9f798
movl $0x1, 0x2cb902(%rip)    # 0x36bc94
movw $0x1, (%rbx)
leaq 0x297eb6(%rip), %rax    # 0x338254
xorl %ecx, %ecx
movw %cx, (%rax)
leaq 0x297ea8(%rip), %rax    # 0x338252
jmp 0xa036d
callq 0x9f798
movl $0x1, 0x2cb8d9(%rip)    # 0x36bc94
movw $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x297e84(%rip), %rdx    # 0x338252
movzwl (%rdx), %ecx
cmpq $0xfff, %rcx            # imm = 0xFFF
ja 0xa03ec
leal 0x1(%rcx), %esi
movw %si, (%rdx)
leaq 0x296e69(%rip), %rdx    # 0x337250
movb %al, (%rdx,%rcx)
jmp 0xa03c0
movw $0x0, (%rbx)
jmp 0xa035a
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_loop()
void parse_uccm_loop()
{
   // prepare to decode the multi-line UCCM LOOP status message 
   log_packet_id("uccm loop");

   uccm_loop = 1;
   loop_fmt = TRIMBLE_FMT;   // assume Trimble format
   scpi_col = 0;
   scpi_status_line[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x851be(%rip), %rdi     # 0x1255bf
callq 0x58dc2
movl $0x1, 0x2cfbdc(%rip)    # 0x36ffec
xorl %eax, %eax
movl %eax, 0x2cfbd8(%rip)    # 0x36fff0
movl %eax, 0x2cc7a6(%rip)    # 0x36cbc4
movb $0x0, 0x2cc71b(%rip)    # 0x36cb40
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_uccm_temp()
void parse_uccm_temp()
{
char *s;

   log_packet_id("uccm temp");

   s = strstr(nmea_msg, "TEMP = ");  // samsung
   if(s) {
      temperature = (DATA_SIZE) atof(s+7);
      if(user_set_temp_plot == 0) plot[TEMP].show_plot = 1;
      have_temperature = 112;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x84f18(%rip), %rdi     # 0x125631
callq 0x58dc2
leaq 0x29b10b(%rip), %rdi    # 0x33b830
leaq 0x84f0f(%rip), %rsi     # 0x12563b
callq 0x9090
testq %rax, %rax
je 0xa0777
addq $0x7, %rax
movq %rax, %rdi
callq 0x9470
leaq 0x26c2cf(%rip), %rax    # 0x30ca18
movsd %xmm0, (%rax)
leaq 0x26d70e(%rip), %rax    # 0x30de62
cmpb $0x0, (%rax)
jne 0xa076a
leaq 0xbd5d0(%rip), %rax     # 0x15dd30
movl $0x1, 0x2d0(%rax)
leaq 0x26cadb(%rip), %rax    # 0x30d24c
movl $0x70, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: uccm_time_line(int)
int uccm_time_line(int why)
{

   // this routine handles the case where the Symmetricom units send a 
   // time code packet in the middle of another message's response
   
   if(scpi_status_line[0] != 'C') return 0;  // line is not a time code line
   if(scpi_status_line[1] != '5') return 0;

   strcpy(nmea_msg, scpi_status_line);  // prepare to decode the time code line
   parse_uccm_time(why);                   // decode it

   scpi_col = 0;              // prepare to get the next line
   scpi_status_line[0] = 0;

   poll_next_uccm();  //kkkkkk
   return 1;
}

// Assembly:
xorl %eax, %eax
cmpb $0x43, 0x2cc3be(%rip)   # 0x36cb40
jne 0xa07d0
cmpb $0x35, 0x2cc3b6(%rip)   # 0x36cb41
jne 0xa07d0
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x29b094(%rip), %rdi    # 0x33b830
leaq 0x2cc39d(%rip), %rsi    # 0x36cb40
callq 0x9340
movl %ebx, %edi
callq 0xa0427
movl $0x0, 0x2cc40b(%rip)    # 0x36cbc4
movb $0x0, 0x2cc380(%rip)    # 0x36cb40
callq 0x6fe3d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: decode_uccm_temp()
void decode_uccm_temp()
{
char *s;

   if(have_temperature) return;  // samsung

   s = strstr(scpi_status_line, "=");   //kkkkk
   if(s) {
      temperature = (float) atof(s+1);
      temperature *= 1.0E12F;
      if(temperature) have_uccm_tcor = 1;
      if(have_uccm_tcor) plot[TEMP].plot_id = "TCOR";
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x26be50(%rip), %rax    # 0x30d24c
cmpl $0x0, (%rax)
jne 0xa1472
leaq 0x2cb738(%rip), %rdi    # 0x36cb40
movl $0x3d, %esi
callq 0x9100
testq %rax, %rax
je 0xa1472
incq %rax
movq %rax, %rdi
callq 0x9470
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x7d38e(%rip), %xmm0    # 0x11e7c0
leaq 0x26b5df(%rip), %rax    # 0x30ca18
movsd %xmm0, (%rax)
xorpd %xmm1, %xmm1
leaq 0x179bbc(%rip), %rax    # 0x21b004
ucomisd %xmm1, %xmm0
jne 0xa1450
jnp 0xa1458
movl $0x1, (%rax)
jmp 0xa145d
cmpl $0x0, (%rax)
je 0xa1472
leaq 0x690e4(%rip), %rax     # 0x10a548
leaq 0xbc8c5(%rip), %rcx     # 0x15dd30
movq %rax, 0x2b8(%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: decode_uccm_phase()
void decode_uccm_phase()
{
char *s;

   s = strstr(scpi_status_line, "=");   //kkkkk
   if(s) {
      pcorr = atof(s+1) * 1.0E12;
      have_uccm_pcor = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2cb6c1(%rip), %rdi    # 0x36cb40
movl $0x3d, %esi
callq 0x9100
testq %rax, %rax
je 0xa14b9
incq %rax
movq %rax, %rdi
callq 0x9470
mulsd 0x67cb7(%rip), %xmm0    # 0x109158
leaq 0x26b580(%rip), %rax    # 0x30ca28
movsd %xmm0, (%rax)
leaq 0x179b55(%rip), %rax    # 0x21b008
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: decode_uccm_gps_phase()
void decode_uccm_gps_phase()
{
char *s;

   s = strstr(scpi_status_line, "=");   //kkkkk
   if(s) {
      uccm_gps_phase = atof(s+1);
      have_uccm_gps_phase = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2cb67a(%rip), %rdi    # 0x36cb40
movl $0x3d, %esi
callq 0x9100
testq %rax, %rax
je 0xa14f8
incq %rax
movq %rax, %rdi
callq 0x9470
leaq 0x26b549(%rip), %rax    # 0x30ca30
movsd %xmm0, (%rax)
leaq 0x179b1a(%rip), %rax    # 0x21b00c
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: get_cs_message()
void get_cs_message()
{
u08 c;
static int row = 0;

   // This routine buffers up an incoming 5071A message.  When the end of the
   // message is seen, the message is parsed and decoded with decode_cs_msg()

   if(SERIAL_DATA_AVAILABLE(RCVR_PORT) == 0) {
      check_com_timer(RCVR_PORT);
      return;
   }
   else {
      reset_com_timer(RCVR_PORT);
   }

   c = get_com_char();

   if(com[RCVR_PORT].rcv_error) {      // parity/framing/overrun errors
      com[RCVR_PORT].rcv_error = 0;
//!!!!!qqqq    goto rst_msg;
   }

   if(tsip_sync == 0) {    // syncing to start of message, search for a '>'
      if(c == '>') {
         tsip_sync = 1;
         get_sync_time();
      }
      else {
         tsip_sync = 1;
         get_sync_time();
      }

      rst_msg:
      tsip_wptr = 0;
      tsip_rptr = 0;
      return;
   }
   else if(tsip_sync == 1) { // '>' has been seen, now build the message
      if(c == 0x0D) goto cs_end; 
      else if(c == 0x0A) goto cs_end; 
      else if(c == '>')  {  // null response to command
         decode_cs_msg();
         packet_end = 1;
         tsip_sync = 1; 
         tsip_rptr = 0;
         tsip_wptr = 0;
         return;
      }

      if(tsip_wptr < MAX_TSIP) {  // so add it to the message buffer
         tsip_buf[tsip_wptr++] = c;
      }
      else {
         tsip_sync = 0;
         goto rst_msg;
      }
   }
   else {
      cs_end:
      decode_cs_msg();
      packet_end = 1;
      tsip_sync = 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0xa, %edi
callq 0xb9ad
movl $0xa, %edi
testl %eax, %eax
je 0xa1cc8
callq 0x1ea0b
callq 0x584bd
leaq 0x26c661(%rip), %rcx    # 0x30e2e0
cmpb $0x0, 0x17a12(%rcx)
je 0xa1c8f
movb $0x0, 0x17a12(%rcx)
leaq 0x2965c0(%rip), %rbx    # 0x338256
movzwl (%rbx), %ecx
cmpw $0x1, %cx
je 0xa1cd3
movzwl %cx, %eax
testl %eax, %eax
jne 0xa1d0d
movw $0x1, (%rbx)
callq 0x58672
leaq 0x29659b(%rip), %rax    # 0x338252
xorl %ecx, %ecx
movw %cx, (%rax)
leaq 0x296591(%rip), %rax    # 0x338254
movw %cx, (%rax)
jmp 0xa1d21
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1e66a
cmpb $0xa, %al
je 0xa1d0d
movzbl %al, %ecx
cmpl $0xd, %ecx
je 0xa1d0d
cmpl $0x3e, %ecx
jne 0xa1d28
callq 0xa1d57
movl $0x1, 0x2c9fa1(%rip)    # 0x36bc94
movw $0x1, (%rbx)
leaq 0x296555(%rip), %rax    # 0x338254
xorl %ecx, %ecx
movw %cx, (%rax)
leaq 0x296547(%rip), %rax    # 0x338252
jmp 0xa1cc3
callq 0xa1d57
movl $0x1, 0x2c9f78(%rip)    # 0x36bc94
movw $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x296523(%rip), %rdx    # 0x338252
movzwl (%rdx), %ecx
cmpq $0xfff, %rcx            # imm = 0xFFF
ja 0xa1d4d
leal 0x1(%rcx), %esi
movw %si, (%rdx)
leaq 0x295508(%rip), %rdx    # 0x337250
movb %al, (%rdx,%rcx)
jmp 0xa1d21
movw $0x0, (%rbx)
jmp 0xa1cb0
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: poll_cs_log()
void poll_cs_log()
{
static int log_req_tick;
static int all_log_req = 0;
static int last_log_req = 0;
int i;

   if(cs_log_count <= CS_LOG_SHOW) {
      send_polled_cmd("DIAG:LOG?", CS_LOGINFO_MSG);
   }
   else if(log_req_tick & 1) {  // alternate requests for all log entries and last log entries
      if(all_log_req >= cs_log_count) all_log_req = 0;
      sprintf(out, "DIAG:LOG?  %d", all_log_req);
      send_polled_cmd(out, CS_LOGINFO_MSG);
      all_log_req = (all_log_req + 1) % MAX_CS_LOGS;
   }
   else {
      i = cs_log_count - last_log_req - 1;
      if(i >= 0) {
         sprintf(out, "DIAG:LOG? %d", i);
         send_polled_cmd(out, CS_LOGINFO_MSG);
      }
      last_log_req = (last_log_req + 1) % CS_LOG_SHOW;
   }

   ++log_req_tick;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x1782cc(%rip), %rax    # 0x21a8f4
movl (%rax), %edx
cmpl $0x8, %edx
jg 0xa2645
leaq 0x8319b(%rip), %rdi     # 0x1257d1
movl $0x14b, %esi            # imm = 0x14B
callq 0x6e2d1
jmp 0xa2700
testb $0x1, 0x2cf9a4(%rip)    # 0x371ff0
jne 0xa2690
movl 0x2cf9a4(%rip), %eax    # 0x371ff8
notl %eax
addl %eax, %edx
leaq 0x299bc1(%rip), %rbx    # 0x33c220
leaq 0x83183(%rip), %rsi     # 0x1257e9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x14b, %esi            # imm = 0x14B
callq 0x6e2d1
movl 0x2cf975(%rip), %eax    # 0x371ff8
incl %eax
andl $0x7, %eax
movl %eax, 0x2cf96a(%rip)    # 0x371ff8
jmp 0xa2700
movl 0x2cf95e(%rip), %eax    # 0x371ff4
cmpl %edx, %eax
jl 0xa26a6
movl $0x0, 0x2cf950(%rip)    # 0x371ff4
xorl %eax, %eax
leaq 0x299b73(%rip), %rbx    # 0x33c220
leaq 0x83127(%rip), %rsi     # 0x1257db
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x14b, %esi            # imm = 0x14B
callq 0x6e2d1
movl 0x2cf921(%rip), %eax    # 0x371ff4
movl %eax, %ecx
incl %ecx
movslq %ecx, %rcx
imulq $0x2aaaaaab, %rcx, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x25, %rcx
addl %edx, %ecx
shll $0x6, %ecx
leal (%rcx,%rcx,2), %ecx
negl %ecx
addl %ecx, %eax
incl %eax
movl %eax, 0x2cf8f4(%rip)    # 0x371ff4
incl 0x2cf8ea(%rip)          # 0x371ff0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq