LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7eee0(%rip), %rdi     # 0x10f0ec
callq 0x520bf
leaq 0x295a2c(%rip), %rax    # 0x325c44
andl $0x0, (%rax)
callq 0x75767
testl %eax, %eax
je 0x90251
leaq 0x295815(%rip), %rdi    # 0x325a40
callq 0x95e0
leaq 0x266ea5(%rip), %rcx    # 0x2f70dc
cmpl $0x0, (%rcx)
jne 0x90251
andl $0x1, %eax
je 0x90251
movl $0x20, (%rcx)
leaq 0x266e92(%rip), %rax    # 0x2f70e0
andl $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7ee8f(%rip), %rdi     # 0x10f0f7
callq 0x520bf
leaq 0x174d6c(%rip), %rax    # 0x204fe0
cmpl $0x4e, (%rax)
jne 0x902cc
leaq 0x2959c4(%rip), %rax    # 0x325c44
andl $0x0, (%rax)
leaq 0x2957b6(%rip), %r14    # 0x325a40
pushq $0x1
popq %r15
xorl %r12d, %r12d
xorl %ebx, %ebx
xorl %r13d, %r13d
callq 0x75767
testl %eax, %eax
je 0x902db
movq %r14, %rdi
callq 0x95e0
leal -0x1(%rax), %ecx
cmpl $0x20, %ecx
adcl $0x0, %r12d
cmpl $0x20, %ecx
cmovbl %eax, %r13d
movl %r15d, %eax
shll %cl, %eax
cmpl $0x20, %ecx
movl $0x0, %ecx
cmovael %ecx, %eax
orl %eax, %ebx
jmp 0x90296
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
cmpl $0x1, %r12d
cmovel %r13d, %eax
leaq 0x266df0(%rip), %rcx    # 0x2f70dc
movl %eax, (%rcx)
leaq 0x266deb(%rip), %rax    # 0x2f70e0
movl $0x1, (%rax)
leaq 0x266de2(%rip), %rax    # 0x2f70e4
movl %ebx, (%rax)
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x56b6d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7ebc5(%rip), %rdi     # 0x10f13c
callq 0x520bf
leaq 0x266c55(%rip), %rbx    # 0x2f71d8
movl (%rbx), %r15d
movl %r15d, %r14d
andl $-0x7, %r14d
movl %r14d, (%rbx)
leaq 0x295299(%rip), %rdi    # 0x325830
leaq 0x80fc0(%rip), %rsi     # 0x11155e
callq 0x9090
testq %rax, %rax
jne 0x905ee
leaq 0x295281(%rip), %rdi    # 0x325830
leaq 0x7eb93(%rip), %rsi     # 0x10f149
callq 0x9090
testq %rax, %rax
je 0x905c6
orl $0x4, %r14d
jmp 0x905eb
leaq 0x295263(%rip), %rdi    # 0x325830
leaq 0x7eb7b(%rip), %rsi     # 0x10f14f
callq 0x9090
testq %rax, %rax
je 0x905e4
orl $0x2, %r14d
jmp 0x905eb
orl $0x6, %r15d
movl %r15d, %r14d
movl %r14d, (%rbx)
leaq 0x266c37(%rip), %rax    # 0x2f722c
movl $0x1, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7eb3c(%rip), %rdi     # 0x10f15e
callq 0x520bf
leaq 0x295616(%rip), %rax    # 0x325c44
andl $0x0, (%rax)
callq 0x75767
testl %eax, %eax
je 0x90684
leaq 0x2953ff(%rip), %rdi    # 0x325a40
leaq 0x7abb7(%rip), %rsi     # 0x10b1ff
callq 0x9090
movb $0x2, %cl
testq %rax, %rax
jne 0x9066e
leaq 0x2953e5(%rip), %rdi    # 0x325a40
leaq 0x7ab8c(%rip), %rsi     # 0x10b1ee
callq 0x9090
movb $-0x7e, %cl
testq %rax, %rax
je 0x90684
leaq 0x2676ae(%rip), %rax    # 0x2f7d23
movb %cl, (%rax)
leaq 0x266c52(%rip), %rax    # 0x2f72d0
movl $0x6, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7ea94(%rip), %rdi     # 0x10f179
callq 0x520bf
leaq 0x295553(%rip), %rax    # 0x325c44
andl $0x0, (%rax)
leaq 0x295135(%rip), %rdi    # 0x325830
pushq $0x5b
popq %rsi
callq 0x9100
testq %rax, %rax
je 0x9074a
movq %rax, %rbx
cmpb $-0x1, (%rax)
je 0x9074a
incq %rbx
leaq 0x7ea6b(%rip), %rsi     # 0x10f185
movq %rbx, %rdi
callq 0x9090
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
jne 0x90734
movq %rbx, %rdi
callq 0x95e0
leaq 0x266a31(%rip), %rcx    # 0x2f716c
movl %eax, (%rcx)
leaq 0x266a2c(%rip), %rax    # 0x2f7170
movl $0x1, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7ea30(%rip), %rdi     # 0x10f18f
callq 0x520bf
leaq 0x2954d9(%rip), %rax    # 0x325c44
andl $0x0, (%rax)
callq 0x75767
testl %eax, %eax
je 0x907b5
leaq 0x266b2a(%rip), %rax    # 0x2f72a8
movl $0x29a, (%rax)          # imm = 0x29A
leaq 0x266a45(%rip), %rbx    # 0x2f71d0
movl (%rbx), %r14d
movl %r14d, %eax
andl $-0x5, %eax
movl %eax, (%rbx)
leaq 0x2952a3(%rip), %rdi    # 0x325a40
leaq 0x7e9f9(%rip), %rsi     # 0x10f19d
callq 0x9090
testq %rax, %rax
je 0x907b5
orl $0x4, %r14d
movl %r14d, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7e9ce(%rip), %rdi     # 0x10f1b3
callq 0x520bf
leaq 0x174827(%rip), %rax    # 0x205018
andl $0x0, (%rax)
andl $0x0, 0x2cb6d9(%rip)    # 0x35bed4
andl $0x0, 0x2cb6ce(%rip)    # 0x35bed0
movl $0x1, 0x2c97d8(%rip)    # 0x359fe4
andl $0x0, 0x2c63b1(%rip)    # 0x356bc4
movb $0x0, 0x2c6326(%rip)    # 0x356b40
andl $0x0, 0x2c97c7(%rip)    # 0x359fe8
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x911de
cmpl $0xa, %edi
jne 0x911b7
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2c59d9(%rip), %rbx    # 0x356b40
movq %rbx, %rdi
callq 0x988f
leaq 0x7e382(%rip), %rsi     # 0x10f4f8
movq %rbx, %rdi
callq 0x9090
testq %rax, %rax
je 0x911df
callq 0x90f4e
andl $0x0, 0x2c8e55(%rip)    # 0x359fe4
callq 0x65f5a
cmpl $0x2, 0x2c8e49(%rip)    # 0x359fe4
jne 0x911a2
callq 0x90b85
andl $0x0, 0x2c5a1b(%rip)    # 0x356bc4
movb $0x0, 0x2c5990(%rip)    # 0x356b40
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movslq 0x2c5a06(%rip), %rax    # 0x356bc4
cmpq $0x7e, %rax
jg 0x911de
leaq 0x1(%rax), %rcx
movl %ecx, 0x2c59f6(%rip)    # 0x356bc4
leaq 0x2c596b(%rip), %rcx    # 0x356b40
movb %dil, (%rax,%rcx)
movb $0x0, 0x1(%rax,%rcx)
retq
leaq 0x2c595a(%rip), %rdi    # 0x356b40
leaq 0x8bea2(%rip), %rsi     # 0x11d08f
callq 0x9090
testq %rax, %rax
je 0x91258
leaq 0x2c5942(%rip), %rdi    # 0x356b40
leaq 0x62df7(%rip), %rsi     # 0xf3ffc
callq 0x9090
testq %rax, %rax
je 0x91258
leaq 0x2c592a(%rip), %rdi    # 0x356b40
leaq 0x8c13d(%rip), %rsi     # 0x11d35a
callq 0x9090
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
leaq 0x173deb(%rip), %rax    # 0x20501c
movl %ecx, (%rax)
movl $0x2, 0x2c8da7(%rip)    # 0x359fe4
leaq 0x17168c(%rip), %rax    # 0x2028d0
cmpq $0x8, (%rax)
jne 0x9119d
callq 0x56b1c
jmp 0x91194
leaq 0x2c58e1(%rip), %rdi    # 0x356b40
leaq 0x7e29c(%rip), %rsi     # 0x10f502
callq 0x9090
testq %rax, %rax
je 0x91194
leaq 0x2c58c5(%rip), %rdi    # 0x356b40
leaq 0x7bbc6(%rip), %rsi     # 0x10ce48
callq 0x9090
testq %rax, %rax
je 0x91194
movl $0x4, 0x2c8d4a(%rip)    # 0x359fe4
jmp 0x911a2
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0xa
popq %rdi
callq 0xb771
pushq $0xa
popq %rdi
testl %eax, %eax
je 0x912d5
callq 0x1d93f
callq 0x51891
cmpl $0x0, 0x2c8d1f(%rip)    # 0x359fe4
je 0x912e0
movzbl %al, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9114c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d61b
leaq 0x266ff9(%rip), %rcx    # 0x2f82e0
cmpb $0x0, 0x17a12(%rcx)
je 0x912f7
movb $0x0, 0x17a12(%rcx)
leaq 0x290f58(%rip), %rbx    # 0x322256
movzwl (%rbx), %ecx
cmpw $0x1, %cx
je 0x91335
movzwl %cx, %ecx
testl %ecx, %ecx
jne 0x9136e
cmpl $0x3e, %eax
jne 0x9131d
movw $0x1, (%rbx)
callq 0x51a2f
leaq 0x290f2e(%rip), %rax    # 0x322252
andw $0x0, (%rax)
leaq 0x290f25(%rip), %rax    # 0x322254
andw $0x0, (%rax)
jmp 0x91381
cmpb $0xa, %al
je 0x9136e
movzbl %al, %ecx
cmpl $0xd, %ecx
je 0x9136e
cmpl $0x3e, %ecx
jne 0x91388
callq 0x90823
movl $0x1, 0x2c493f(%rip)    # 0x355c94
movw $0x1, (%rbx)
leaq 0x290ef3(%rip), %rax    # 0x322254
andw $0x0, (%rax)
leaq 0x290ee6(%rip), %rax    # 0x322252
jmp 0x9132f
callq 0x90823
movl $0x1, 0x2c4917(%rip)    # 0x355c94
andw $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x290ec3(%rip), %rdx    # 0x322252
movzwl (%rdx), %ecx
cmpq $0xfff, %rcx            # imm = 0xFFF
ja 0x913ad
leal 0x1(%rcx), %esi
movw %si, (%rdx)
leaq 0x28fea8(%rip), %rdx    # 0x321250
movb %al, (%rdx,%rcx)
jmp 0x91381
andw $0x0, (%rbx)
jmp 0x9131d
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7e146(%rip), %rdi     # 0x10f507
callq 0x520bf
movl $0x1, 0x2c8c1c(%rip)    # 0x359fec
andl $0x0, 0x2c8c19(%rip)    # 0x359ff0
andl $0x0, 0x2c57e6(%rip)    # 0x356bc4
movb $0x0, 0x2c575b(%rip)    # 0x356b40
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7def9(%rip), %rdi     # 0x10f579
callq 0x520bf
leaq 0x2941a4(%rip), %rdi    # 0x325830
leaq 0x7def0(%rip), %rsi     # 0x10f583
callq 0x9090
testq %rax, %rax
je 0x916de
addq $0x7, %rax
movq %rax, %rdi
callq 0x9470
leaq 0x265368(%rip), %rax    # 0x2f6a18
movsd %xmm0, (%rax)
leaq 0x2667a7(%rip), %rax    # 0x2f7e62
cmpb $0x0, (%rax)
jne 0x916d1
leaq 0xb6669(%rip), %rax     # 0x147d30
movl $0x1, 0x2d0(%rax)
leaq 0x265b74(%rip), %rax    # 0x2f724c
movl $0x70, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x2c5457(%rip)   # 0x356b40
jne 0x91732
cmpb $0x35, 0x2c544f(%rip)   # 0x356b41
jne 0x91732
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x29412d(%rip), %rdi    # 0x325830
leaq 0x2c5436(%rip), %rsi    # 0x356b40
callq 0x9330
movl %ebx, %edi
callq 0x913e7
andl $0x0, 0x2c54a7(%rip)    # 0x356bc4
movb $0x0, 0x2c541c(%rip)    # 0x356b40
callq 0x6680e
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x264fe7(%rip), %rax    # 0x2f724c
cmpl $0x0, (%rax)
jne 0x922d9
leaq 0x2c48cf(%rip), %rdi    # 0x356b40
pushq $0x3d
popq %rsi
callq 0x9100
testq %rax, %rax
je 0x922d9
incq %rax
movq %rax, %rdi
callq 0x9470
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd 0x7649f(%rip), %xmm0    # 0x108738
leaq 0x264778(%rip), %rax    # 0x2f6a18
movsd %xmm0, (%rax)
xorpd %xmm1, %xmm1
leaq 0x172d55(%rip), %rax    # 0x205004
ucomisd %xmm1, %xmm0
jne 0x922b7
jnp 0x922bf
movl $0x1, (%rax)
jmp 0x922c4
cmpl $0x0, (%rax)
je 0x922d9
leaq 0x622cd(%rip), %rax     # 0xf4598
leaq 0xb5a5e(%rip), %rcx     # 0x147d30
movq %rax, 0x2b8(%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c485a(%rip), %rdi    # 0x356b40
pushq $0x3d
popq %rsi
callq 0x9100
testq %rax, %rax
je 0x9231e
incq %rax
movq %rax, %rdi
callq 0x9470
mulsd 0x60e52(%rip), %xmm0    # 0xf3158
leaq 0x26471b(%rip), %rax    # 0x2f6a28
movsd %xmm0, (%rax)
leaq 0x172cf0(%rip), %rax    # 0x205008
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c4815(%rip), %rdi    # 0x356b40
pushq $0x3d
popq %rsi
callq 0x9100
testq %rax, %rax
je 0x9235b
incq %rax
movq %rax, %rdi
callq 0x9470
leaq 0x2646e6(%rip), %rax    # 0x2f6a30
movsd %xmm0, (%rax)
leaq 0x172cb7(%rip), %rax    # 0x20500c
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0xa
popq %rdi
callq 0xb771
pushq $0xa
popq %rdi
testl %eax, %eax
je 0x92b05
callq 0x1d93f
callq 0x51891
leaq 0x265824(%rip), %rcx    # 0x2f82e0
cmpb $0x0, 0x17a12(%rcx)
je 0x92acc
movb $0x0, 0x17a12(%rcx)
leaq 0x28f783(%rip), %rbx    # 0x322256
movzwl (%rbx), %ecx
cmpw $0x1, %cx
je 0x92b10
movzwl %cx, %eax
testl %eax, %eax
jne 0x92b49
movw $0x1, (%rbx)
callq 0x51a2f
leaq 0x28f75e(%rip), %rax    # 0x322252
andw $0x0, (%rax)
leaq 0x28f755(%rip), %rax    # 0x322254
andw $0x0, (%rax)
jmp 0x92b5c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d61b
cmpb $0xa, %al
je 0x92b49
movzbl %al, %ecx
cmpl $0xd, %ecx
je 0x92b49
cmpl $0x3e, %ecx
jne 0x92b63
callq 0x92b91
movl $0x1, 0x2c3164(%rip)    # 0x355c94
movw $0x1, (%rbx)
leaq 0x28f718(%rip), %rax    # 0x322254
andw $0x0, (%rax)
leaq 0x28f70b(%rip), %rax    # 0x322252
jmp 0x92aff
callq 0x92b91
movl $0x1, 0x2c313c(%rip)    # 0x355c94
andw $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x28f6e8(%rip), %rdx    # 0x322252
movzwl (%rdx), %ecx
cmpq $0xfff, %rcx            # imm = 0xFFF
ja 0x92b88
leal 0x1(%rcx), %esi
movw %si, (%rdx)
leaq 0x28e6cd(%rip), %rdx    # 0x321250
movb %al, (%rdx,%rcx)
jmp 0x92b5c
andw $0x0, (%rbx)
jmp 0x92aed
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1714b8(%rip), %rax    # 0x2048f4
movl (%rax), %edx
cmpl $0x8, %edx
jg 0x93459
leaq 0x7c2cf(%rip), %rdi     # 0x10f719
movl $0x14b, %esi            # imm = 0x14B
callq 0x64f01
jmp 0x934f4
testb $0x1, 0x2c8b90(%rip)    # 0x35bff0
jne 0x934a4
movl 0x2c8b90(%rip), %eax    # 0x35bff8
notl %eax
addl %eax, %edx
leaq 0x292dad(%rip), %rbx    # 0x326220
leaq 0x7c2b7(%rip), %rsi     # 0x10f731
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x14b, %esi            # imm = 0x14B
callq 0x64f01
movl 0x2c8b61(%rip), %eax    # 0x35bff8
incl %eax
andl $0x7, %eax
movl %eax, 0x2c8b56(%rip)    # 0x35bff8
jmp 0x934f4
movl 0x2c8b4a(%rip), %eax    # 0x35bff4
cmpl %edx, %eax
jl 0x934b7
andl $0x0, 0x2c8b3f(%rip)    # 0x35bff4
xorl %eax, %eax
leaq 0x292d62(%rip), %rbx    # 0x326220
leaq 0x7c25e(%rip), %rsi     # 0x10f723
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x14b, %esi            # imm = 0x14B
callq 0x64f01
movl 0x2c8b10(%rip), %eax    # 0x35bff4
incl %eax
movl $0xc0, %ecx
cltd
idivl %ecx
movl %edx, 0x2c8b00(%rip)    # 0x35bff4
incl 0x2c8af6(%rip)          # 0x35bff0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_cont()
void parse_cs_cont() 
{
   if(get_msg_field()) {
      if(strstr(msg_field, "OFF")) cs_cont = 0;
      else if(strstr(msg_field, "ENAB")) cs_cont = 1;
      else if(strstr(msg_field, "ON")) cs_cont = 2;
      have_cs_cont = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x75767
testl %eax, %eax
je 0x938dc
leaq 0x2921c4(%rip), %rdi    # 0x325a40
leaq 0x86664(%rip), %rsi     # 0x119ee7
callq 0x9090
xorl %ecx, %ecx
testq %rax, %rax
jne 0x938c6
leaq 0x2921aa(%rip), %rdi    # 0x325a40
leaq 0x7781c(%rip), %rsi     # 0x10b0b9
callq 0x9090
testq %rax, %rax
je 0x938ab
pushq $0x1
jmp 0x938c5
leaq 0x29218e(%rip), %rdi    # 0x325a40
leaq 0x8661e(%rip), %rsi     # 0x119ed7
callq 0x9090
testq %rax, %rax
je 0x938cf
pushq $0x2
popq %rcx
leaq 0x171103(%rip), %rax    # 0x2049d0
movl %ecx, (%rax)
leaq 0x171146(%rip), %rax    # 0x204a1c
movl $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_pump()
void parse_cs_pump() 
{
   if(get_msg_field()) {
      cs_pump = atof(msg_field) * 1.0E6; 
      have_cs_pump = 1;
      pps_offset = cs_pump;
      have_pps_offset = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x75767
testl %eax, %eax
je 0x939a0
leaq 0x2920d8(%rip), %rdi    # 0x325a40
callq 0x9470
mulsd 0x5f6db(%rip), %xmm0    # 0xf3050
leaq 0x170f94(%rip), %rax    # 0x204910
movsd %xmm0, (%rax)
leaq 0x1710a1(%rip), %rax    # 0x204a28
pushq $0x1
popq %rcx
movl %ecx, (%rax)
leaq 0x262e25(%rip), %rax    # 0x2f67b8
movsd %xmm0, (%rax)
leaq 0x26389a(%rip), %rax    # 0x2f7238
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_rfam()
void parse_cs_rfam() 
{
   if(get_msg_field()) {
      cs_rfam1 = atof(msg_field) * 100.0; 
      have_cs_rfam |= 0x01;
   }
   if(get_msg_field()) {
      cs_rfam2 = atof(msg_field) * 100.0; 
      have_cs_rfam |= 0x02;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x75767
testl %eax, %eax
je 0x93a13
leaq 0x29204f(%rip), %rdi    # 0x325a40
callq 0x9470
mulsd 0x5f662(%rip), %xmm0    # 0xf3060
leaq 0x170f1b(%rip), %rax    # 0x204920
movsd %xmm0, (%rax)
leaq 0x171020(%rip), %rax    # 0x204a30
orb $0x1, (%rax)
callq 0x75767
testl %eax, %eax
je 0x93a45
leaq 0x29201d(%rip), %rdi    # 0x325a40
callq 0x9470
mulsd 0x5f630(%rip), %xmm0    # 0xf3060
leaq 0x170ef1(%rip), %rax    # 0x204928
movsd %xmm0, (%rax)
leaq 0x170fee(%rip), %rax    # 0x204a30
orb $0x2, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_sync()
void parse_cs_sync() 
{
   if(get_msg_field()) {
      if     (strstr(msg_field, "OFF"))   cs_sync = "OFF";
      else if(strstr(msg_field, "FRON"))  cs_sync = "FRONT";
      else if(strstr(msg_field, "REAR"))  cs_sync = "REAR";
      have_cs_sync = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x75767
testl %eax, %eax
je 0x93b26
leaq 0x291f81(%rip), %rdi    # 0x325a40
leaq 0x86421(%rip), %rbx     # 0x119ee7
movq %rbx, %rsi
callq 0x9090
testq %rax, %rax
jne 0x93b0f
leaq 0x291f66(%rip), %rdi    # 0x325a40
leaq 0x6c2d9(%rip), %rsi     # 0xffdba
callq 0x9090
testq %rax, %rax
je 0x93af4
leaq 0x6f113(%rip), %rbx     # 0x102c05
jmp 0x93b0f
leaq 0x291f45(%rip), %rdi    # 0x325a40
leaq 0x73bc1(%rip), %rbx     # 0x1076c3
movq %rbx, %rsi
callq 0x9090
testq %rax, %rax
je 0x93b19
leaq 0x170ee2(%rip), %rax    # 0x2049f8
movq %rbx, (%rax)
leaq 0x170f44(%rip), %rax    # 0x204a64
movl $0x1, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_supply()
void parse_cs_supply() 
{
   if(get_msg_field()) {
      if     (strstr(msg_field, "AC"))   cs_supply = "AC";
      else if(strstr(msg_field, "DC"))   cs_supply = "DC";
      else if(strstr(msg_field, "BATT")) cs_supply = "BATT";
      else if(strstr(msg_field, "LOW"))  cs_supply = "LOW";
      else                               cs_supply = "UNKN";
      have_cs_supply = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x75767
testl %eax, %eax
je 0x93c02
leaq 0x291ec3(%rip), %rdi    # 0x325a40
leaq 0x7d977(%rip), %rbx     # 0x1114fb
movq %rbx, %rsi
callq 0x9090
testq %rax, %rax
jne 0x93beb
leaq 0x291ea8(%rip), %rdi    # 0x325a40
leaq 0x7a81a(%rip), %rbx     # 0x10e3b9
movq %rbx, %rsi
callq 0x9090
testq %rax, %rax
jne 0x93beb
leaq 0x291e8d(%rip), %rdi    # 0x325a40
leaq 0x7bcdd(%rip), %rbx     # 0x10f897
movq %rbx, %rsi
callq 0x9090
testq %rax, %rax
jne 0x93beb
leaq 0x291e72(%rip), %rdi    # 0x325a40
leaq 0x7d828(%rip), %r14     # 0x1113fd
movq %r14, %rsi
callq 0x9090
testq %rax, %rax
leaq 0x7d580(%rip), %rbx     # 0x111167
cmovneq %r14, %rbx
leaq 0x170dfe(%rip), %rax    # 0x2049f0
movq %rbx, (%rax)
leaq 0x170e3c(%rip), %rax    # 0x204a38
movl $0x1, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_temp()
void parse_cs_temp() 
{
   if(get_msg_field()) {
      cs_temp = atof(msg_field); 
      have_cs_temp = 1;

      temperature = (float) cs_temp;
      have_temperature = 113;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x75767
testl %eax, %eax
je 0x93c58
leaq 0x291e25(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x170d09(%rip), %rax    # 0x204930
movsd %xmm0, (%rax)
leaq 0x170dda(%rip), %rax    # 0x204a0c
movl $0x1, (%rax)
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x262dd1(%rip), %rax    # 0x2f6a18
movsd %xmm0, (%rax)
leaq 0x2635fa(%rip), %rax    # 0x2f724c
movl $0x71, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_emul()
void parse_cs_emul() 
{
   if(get_msg_field()) {
      cs_emul = atof(msg_field); 
      have_cs_emul = 1;
      osc_offset = cs_emul;
      have_osc_offset = 68;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x75767
testl %eax, %eax
je 0x93cd6
leaq 0x291d9f(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x170c9b(%rip), %rax    # 0x204948
movsd %xmm0, (%rax)
leaq 0x170d8c(%rip), %rax    # 0x204a44
movl $0x1, (%rax)
leaq 0x262afb(%rip), %rax    # 0x2f67c0
movsd %xmm0, (%rax)
leaq 0x263564(%rip), %rax    # 0x2f7234
movl $0x44, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_pll()
void parse_cs_pll() 
{ 
   if(get_msg_field()) {
      cs_pll_dro = atof(msg_field); 
      have_cs_pll |= 0x01;
   }
   if(get_msg_field()) {
      cs_pll_saw = atof(msg_field); 
      have_cs_pll |= 0x02;
   }
   if(get_msg_field()) {
      cs_pll_87 = atof(msg_field); 
      have_cs_pll |= 0x04;
   }
   if(get_msg_field()) {
      cs_pll_up = atof(msg_field); 
      have_cs_pll |= 0x08;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x75767
testl %eax, %eax
je 0x93d6c
leaq 0x291cee(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x170c02(%rip), %rax    # 0x204960
movsd %xmm0, (%rax)
leaq 0x170ce7(%rip), %rax    # 0x204a50
orb $0x1, (%rax)
callq 0x75767
testl %eax, %eax
je 0x93d96
leaq 0x291cc4(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x170be0(%rip), %rax    # 0x204968
movsd %xmm0, (%rax)
leaq 0x170cbd(%rip), %rax    # 0x204a50
orb $0x2, (%rax)
callq 0x75767
testl %eax, %eax
je 0x93dc0
leaq 0x291c9a(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x170bbe(%rip), %rax    # 0x204970
movsd %xmm0, (%rax)
leaq 0x170c93(%rip), %rax    # 0x204a50
orb $0x4, (%rax)
callq 0x75767
testl %eax, %eax
je 0x93dea
leaq 0x291c70(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x170b9c(%rip), %rax    # 0x204978
movsd %xmm0, (%rax)
leaq 0x170c69(%rip), %rax    # 0x204a50
orb $0x8, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_leapstat()
void parse_cs_leapstat()
{
int leap;


   if(get_msg_field()) {
      if     (strstr(msg_field, "1")) leap = 1;
      else if(strstr(msg_field, "ON")) leap = 1;
      else leap = 0;
      cs_leap_state = leap;
      have_cs_leapstate = 1;

      if(leap) {
         minor_alarms |= MINOR_LEAP_PEND;
      }
      else { 
         minor_alarms &= (~MINOR_LEAP_PEND);
      }
      have_leap_info = 33;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x75767
testl %eax, %eax
je 0x93fb5
leaq 0x291b06(%rip), %rdi    # 0x325a40
pushq $0x31
popq %rsi
callq 0x9100
testq %rax, %rax
je 0x93f5e
leaq 0x170a7e(%rip), %rax    # 0x2049cc
pushq $0x1
popq %rcx
movl %ecx, (%rax)
leaq 0x170b26(%rip), %rax    # 0x204a80
movl %ecx, (%rax)
jmp 0x93f91
leaq 0x291adb(%rip), %rdi    # 0x325a40
leaq 0x85f6b(%rip), %rsi     # 0x119ed7
callq 0x9090
leaq 0x170b08(%rip), %rcx    # 0x204a80
movl $0x1, (%rcx)
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
leaq 0x170a3f(%rip), %rax    # 0x2049cc
movl %ecx, (%rax)
je 0x93fb7
leaq 0x263240(%rip), %rcx    # 0x2f71d8
movl $0x80, %eax
orl (%rcx), %eax
leaq 0x263232(%rip), %rcx    # 0x2f71d8
movl %eax, (%rcx)
leaq 0x2632e9(%rip), %rax    # 0x2f7298
movl $0x21, (%rax)
popq %rbp
retq
leaq 0x26321a(%rip), %rcx    # 0x2f71d8
movl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
andl (%rcx), %eax
jmp 0x93f9f
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_leapmjd()
void parse_cs_leapmjd()
{
   if(get_msg_field()) {
      cs_leapmjd = atof(msg_field);
      have_cs_leapmjd = 33;
      jd_leap = (cs_leapmjd + JD_MJD) + jtime(23,59,59,0.0);
      calc_jd_leap(57);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x75767
testl %eax, %eax
je 0x9406c
leaq 0x291a2c(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x1709a0(%rip), %rax    # 0x2049c0
movsd %xmm0, (%rax)
leaq 0x170a51(%rip), %rax    # 0x204a7c
movl $0x21, (%rax)
addsd 0x74707(%rip), %xmm0    # 0x108740
movsd %xmm0, -0x8(%rbp)
pushq $0x17
popq %rdi
pushq $0x3b
popq %rdx
xorpd %xmm0, %xmm0
movl %edx, %esi
callq 0xc2faf
addsd -0x8(%rbp), %xmm0
leaq 0x263505(%rip), %rax    # 0x2f7560
movsd %xmm0, (%rax)
pushq $0x39
popq %rdi
addq $0x10, %rsp
popq %rbp
jmp 0x557cf
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_loginfo()
void parse_cs_loginfo()
{
int log_id;
int i;

   log_id = (-1);
   if(get_msg_field()) {
      have_cs_loginfo = 1;
      log_id = atoi(&msg_field[4]);
   }
   if(get_msg_field()) {
      msg_field[LOG_MSG_LEN] = 0;
      i = cs_log_count - log_id - 1;
i = log_id;
      if((log_id >= 0) && (i >= 0) && (i < MAX_CS_LOGS)) {
         sprintf(out, "%3d: %s", log_id,msg_field);
         strcpy(cs_log_msg[i], out);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x75767
testl %eax, %eax
je 0x9414a
leaq 0x1708e8(%rip), %rax    # 0x204a18
movl $0x1, (%rax)
leaq 0x291903(%rip), %rdi    # 0x325a40
addq $0x4, %rdi
callq 0x95e0
movl %eax, %ebx
jmp 0x9414d
pushq $-0x1
popq %rbx
callq 0x75767
testl %eax, %eax
je 0x941a3
leaq 0x2918e3(%rip), %rax    # 0x325a40
movb $0x0, 0x20(%rax)
cmpl $0xbf, %ebx
ja 0x941a3
leaq 0x2920b0(%rip), %r14    # 0x326220
leaq 0x7b725(%rip), %rsi     # 0x10f89c
leaq 0x2918c2(%rip), %rcx    # 0x325a40
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x9060
movl %ebx, %eax
imulq $0x22, %rax, %rdi
addq 0xa5da1(%rip), %rdi     # 0x139f38
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x9330
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_cs_volt()
void parse_cs_volt() 
{
   if(get_msg_field()) {
      cs_volt1 = atof(msg_field); 
      have_cs_volt |= 0x01;
   }
   if(get_msg_field()) {
      cs_volt2 = atof(msg_field); 
      have_cs_volt |= 0x02;
   }
   if(get_msg_field()) {
      cs_volt3 = atof(msg_field); 
      have_cs_volt |= 0x04;
   }
   cs_volt_avg = (cs_volt1 + cs_volt2 + cs_volt3) / 3.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x75767
testl %eax, %eax
je 0x941d6
leaq 0x291884(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x1707b8(%rip), %rax    # 0x204980
movsd %xmm0, (%rax)
leaq 0x170881(%rip), %rax    # 0x204a54
orb $0x1, (%rax)
callq 0x75767
testl %eax, %eax
je 0x94200
leaq 0x29185a(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x170796(%rip), %rax    # 0x204988
movsd %xmm0, (%rax)
leaq 0x170857(%rip), %rax    # 0x204a54
orb $0x2, (%rax)
callq 0x75767
testl %eax, %eax
je 0x9422c
leaq 0x291830(%rip), %rdi    # 0x325a40
callq 0x9470
leaq 0x170774(%rip), %rax    # 0x204990
movsd %xmm0, (%rax)
leaq 0x17082d(%rip), %rax    # 0x204a54
orb $0x4, (%rax)
jmp 0x94237
leaq 0x17075d(%rip), %rax    # 0x204990
movsd (%rax), %xmm0
leaq 0x170742(%rip), %rax    # 0x204980
movsd (%rax), %xmm1
leaq 0x17073f(%rip), %rax    # 0x204988
addsd (%rax), %xmm1
addsd %xmm0, %xmm1
divsd 0x61827(%rip), %xmm1    # 0xf5a80
leaq 0x170738(%rip), %rax    # 0x204998
movsd %xmm1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: set_cs_disp(int)
void set_cs_disp(int mode)
{
   if(read_only) return;

   if(rcvr_type == CS_RCVR) {
      set_cs_remote(1);
      if(mode) queue_cs_cmd("DISP:ENAB ON", CS_DISP_MSG);
      else     queue_cs_cmd("DISP:ENAB OFF", CS_DISP_MSG);
      restore_cs_remote();
      queue_cs_cmd("DISP:ENAB?", CS_DISP_MSG);
   }
}

// Assembly:
leaq 0x28cdad(%rip), %rax    # 0x32101a
cmpb $0x0, (%rax)
jne 0x942cc
leaq 0x16e657(%rip), %rax    # 0x2028d0
cmpq $0x20000, (%rax)        # imm = 0x20000
jne 0x942cc
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x1
popq %rdi
callq 0x5be9f
testl %ebx, %ebx
leaq 0x7b654(%rip), %rax     # 0x10f8ef
leaq 0x7b640(%rip), %rdi     # 0x10f8e2
cmoveq %rax, %rdi
movl $0x145, %esi            # imm = 0x145
callq 0x576d4
callq 0x5be85
leaq 0x7b483(%rip), %rdi     # 0x10f73f
movl $0x145, %esi            # imm = 0x145
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x576d4
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: set_cs_leap(double, int)
void set_cs_leap(double jd, int dur)
{
   if(read_only) return;

   if(rcvr_type == CS_RCVR) {
      set_cs_remote(1);
      if(((dur != 59) && (dur != 61)) || (jd == 0.0)) {
         queue_cs_cmd(":PTIM:LEAP:STAT OFF", CS_LEAPSTAT_MSG);
      }
      else {
         sprintf(out, ":PTIM:LEAP:MJD %d", (int) (jd + jtime(0,0,1, 0.0)));
         queue_cs_cmd(out, CS_LEAPMJD_MSG);

         sprintf(out, ":PTIM:LEAP:DUR %d", dur);  
         queue_cs_cmd(out, CS_LEAPDUR_MSG); 

         queue_cs_cmd(":PTIM:LEAP:STAT ON", CS_LEAPSTAT_MSG);
      }

      restore_cs_remote();

      queue_cs_cmd(":PTIM:LEAP:STAT?", CS_LEAPSTAT_MSG);
      queue_cs_cmd(":PTIM:LEAP:DUR?",  CS_LEAPDUR_MSG);
      queue_cs_cmd(":PTIM:LEAP:MJD?", CS_LEAPMJD_MSG);
   }
}

// Assembly:
leaq 0x28cd46(%rip), %rax    # 0x32101a
cmpb $0x0, (%rax)
jne 0x943dd
leaq 0x16e5ec(%rip), %rax    # 0x2028d0
cmpq $0x20000, (%rax)        # imm = 0x20000
jne 0x943dd
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
pushq $0x1
popq %rdi
movsd %xmm0, -0x18(%rbp)
callq 0x5be9f
leal -0x3b(%rbx), %eax
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
setne %al
xorpd %xmm0, %xmm0
movsd -0x18(%rbp), %xmm1
ucomisd %xmm0, %xmm1
leaq 0x7b5d3(%rip), %rdi     # 0x10f8fd
jne 0x9432e
jnp 0x94393
testb %al, %al
jne 0x94393
pushq $0x1
popq %rdx
xorl %edi, %edi
xorl %esi, %esi
callq 0xc2faf
addsd -0x18(%rbp), %xmm0
cvttsd2si %xmm0, %edx
leaq 0x291ed2(%rip), %r14    # 0x326220
leaq 0x7b5bc(%rip), %rsi     # 0x10f911
movq %r14, %rdi
xorl %eax, %eax
callq 0x9060
movq %r14, %rdi
movl $0x149, %esi            # imm = 0x149
callq 0x576d4
leaq 0x7b5b0(%rip), %rsi     # 0x10f923
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x9060
movq %r14, %rdi
movl $0x148, %esi            # imm = 0x148
callq 0x576d4
leaq 0x7b5a2(%rip), %rdi     # 0x10f935
movl $0x147, %esi            # imm = 0x147
callq 0x576d4
callq 0x5be85
leaq 0x7b4ae(%rip), %rdi     # 0x10f857
movl $0x147, %esi            # imm = 0x147
callq 0x576d4
leaq 0x7b4ae(%rip), %rdi     # 0x10f868
movl $0x148, %esi            # imm = 0x148
callq 0x576d4
leaq 0x7b4ad(%rip), %rdi     # 0x10f878
movl $0x149, %esi            # imm = 0x149
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x576d4
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: set_cs_slew(double)
void set_cs_slew(double val)
{
   if(read_only) return;

   if(rcvr_type == CS_RCVR) {
      set_cs_remote(1);
      sprintf(out, ":PTIM:SLEW %g", val);
      queue_cs_cmd(out, CS_SLEW_MSG);
      restore_cs_remote();
   }
}

// Assembly:
leaq 0x28cc35(%rip), %rax    # 0x32101a
cmpb $0x0, (%rax)
jne 0x94442
leaq 0x16e4df(%rip), %rax    # 0x2028d0
cmpq $0x20000, (%rax)        # imm = 0x20000
jne 0x94442
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $0x1
popq %rdi
movsd %xmm0, -0x10(%rbp)
callq 0x5be9f
leaq 0x291e0c(%rip), %rbx    # 0x326220
leaq 0x7b564(%rip), %rsi     # 0x10f97f
movq %rbx, %rdi
movsd -0x10(%rbp), %xmm0
movb $0x1, %al
callq 0x9060
movq %rbx, %rdi
movl $0x144, %esi            # imm = 0x144
callq 0x576d4
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5be85
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: set_cs_standby(int)
void set_cs_standby(int mode)
{
   if(read_only) return;

   if(rcvr_type == CS_RCVR) {
      set_cs_remote(1);
      if(mode) queue_cs_cmd(":PTIM:STAN 1", CS_STANDBY_MSG);
      else     queue_cs_cmd(":PTIM:STAN 0", CS_STANDBY_MSG);
      restore_cs_remote();
   }
}

// Assembly:
leaq 0x28cbd0(%rip), %rax    # 0x32101a
cmpb $0x0, (%rax)
jne 0x94498
leaq 0x16e47a(%rip), %rax    # 0x2028d0
cmpq $0x20000, (%rax)        # imm = 0x20000
jne 0x94498
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x1
popq %rdi
callq 0x5be9f
testl %ebx, %ebx
leaq 0x76f20(%rip), %rax     # 0x10b398
leaq 0x763c1(%rip), %rdi     # 0x10a840
cmoveq %rax, %rdi
movl $0x143, %esi            # imm = 0x143
callq 0x576d4
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5be85
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: set_cs_ster(double)
void set_cs_ster(double offset)
{
   if(read_only) return;

   if(rcvr_type == CS_RCVR) {
      set_cs_remote(1);
      sprintf(out, ":ROSC:STE %g", offset);
      queue_cs_cmd(out, CS_STER_MSG);
      queue_cs_cmd("ROSC:STE?", CS_STER_MSG);
      restore_cs_remote();
   }
}

// Assembly:
leaq 0x28cb7a(%rip), %rax    # 0x32101a
cmpb $0x0, (%rax)
jne 0x9450e
leaq 0x16e424(%rip), %rax    # 0x2028d0
cmpq $0x20000, (%rax)        # imm = 0x20000
jne 0x9450e
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $0x1
popq %rdi
movsd %xmm0, -0x10(%rbp)
callq 0x5be9f
leaq 0x291d51(%rip), %rbx    # 0x326220
leaq 0x7b4b7(%rip), %rsi     # 0x10f98d
movq %rbx, %rdi
movsd -0x10(%rbp), %xmm0
movb $0x1, %al
callq 0x9060
movq %rbx, %rdi
movl $0x141, %esi            # imm = 0x141
callq 0x576d4
leaq 0x7b348(%rip), %rdi     # 0x10f841
movl $0x141, %esi            # imm = 0x141
callq 0x576d4
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5be85
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: set_cs_sync(char*)
void set_cs_sync(char *s)
{
   // OFF FRONT REAR
   if(read_only) return;

   if(s == 0) return;

   if(rcvr_type == CS_RCVR) {
      set_cs_remote(1);
      sprintf(out, ":PTIM:SYNC %s", s);
      queue_cs_cmd(out, CS_SYNC_MSG);
      restore_cs_remote();
      queue_cs_cmd(":PTIM:SYNC?", CS_SYNC_MSG);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x28cafd(%rip), %rax    # 0x32101a
cmpb $0x0, (%rax)
je 0x94527
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rbx
testq %rdi, %rdi
je 0x94522
leaq 0x16e39a(%rip), %rax    # 0x2028d0
cmpq $0x20000, (%rax)        # imm = 0x20000
jne 0x94522
pushq $0x1
popq %rdi
callq 0x5be9f
leaq 0x291cd2(%rip), %r14    # 0x326220
leaq 0x7b445(%rip), %rsi     # 0x10f99a
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9060
movq %r14, %rdi
movl $0x142, %esi            # imm = 0x142
callq 0x576d4
callq 0x5be85
leaq 0x7b2d0(%rip), %rdi     # 0x10f84b
movl $0x142, %esi            # imm = 0x142
popq %rbx
popq %r14
popq %rbp
jmp 0x576d4
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: clear_cs_log()
void clear_cs_log()
{
int i;

   if(read_only) return;

   if(rcvr_type == CS_RCVR) {
      set_cs_remote(1);
      queue_cs_cmd("DIAG:LOG:CLE", CS_CLEARLOG_MSG);
      restore_cs_remote();

      queue_cs_cmd("DIAG:LOG:COUN?", CS_LOGCOUNT_MSG);
      cs_log_count = 0;
      for(i=0; i<MAX_CS_LOGS; i++) {
         cs_log_msg[i][0] = 0;
      }
      need_redraw = 7865;
   }
}

// Assembly:
leaq 0x28ca8a(%rip), %rax    # 0x32101a
cmpb $0x0, (%rax)
jne 0x9460b
leaq 0x16e334(%rip), %rax    # 0x2028d0
cmpq $0x20000, (%rax)        # imm = 0x20000
jne 0x9460b
pushq %rbp
movq %rsp, %rbp
pushq $0x1
popq %rdi
callq 0x5be9f
leaq 0x7b40f(%rip), %rdi     # 0x10f9c7
movl $0x14c, %esi            # imm = 0x14C
callq 0x576d4
callq 0x5be85
leaq 0x7b2ba(%rip), %rdi     # 0x10f888
movl $0x14a, %esi            # imm = 0x14A
callq 0x576d4
leaq 0x170315(%rip), %rax    # 0x2048f4
andl $0x0, (%rax)
xorl %eax, %eax
leaq 0x16e965(%rip), %rcx    # 0x202f50
cmpq $0x1980, %rax           # imm = 0x1980
je 0x945fd
movb $0x0, (%rcx,%rax)
addq $0x22, %rax
jmp 0x945eb
leaq 0x16e240(%rip), %rax    # 0x202844
movl $0x1eb9, (%rax)         # imm = 0x1EB9
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: send_taip_start(char*)
void send_taip_start(char *cmd)
{
   // start a TAIP message
   if(log_file && (log_stream & LOG_PACKET_START)) {
      if(cmd) fprintf(log_file, "\nSend taip start: %s\n", cmd);
      else    fprintf(log_file, "\nSend taip start: >\n");
   }

   eom_flag = 0;
   nmea_tx_cksum = 0;
   send_byte('>');
   if(cmd) send_nmea_string(cmd, 0);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x193d44(%rip), %rax    # 0x228360
movq (%rax), %rcx
testq %rcx, %rcx
je 0x9465d
leaq 0x193de5(%rip), %rax    # 0x228410
testb $0x4, (%rax)
je 0x9465d
testq %rbx, %rbx
je 0x9464b
leaq 0x7b398(%rip), %rsi     # 0x10f9d4
movq %rcx, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9560
jmp 0x9465d
leaq 0x7b398(%rip), %rdi     # 0x10f9ea
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x9750
andl $0x0, 0x2c17ac(%rip)    # 0x355e10
movb $0x0, 0x2c244b(%rip)    # 0x356ab6
pushq $0x3e
popq %rdi
callq 0x523f2
testq %rbx, %rbx
je 0x94688
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5724b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: send_taip_end(int)
void send_taip_end(int do_cksum)
{
char cksum[10];

   // end a TAIP message

   if(do_cksum) {
      send_byte(';');
      send_byte('*');

      sprintf(cksum, "%02X", (nmea_tx_cksum & 0xFF));
      sendout(RCVR_PORT, cksum[0], ADD_CHAR);
      sendout(RCVR_PORT, cksum[1], ADD_CHAR);
   }
   sendout(RCVR_PORT, '<',  ADD_CHAR);
   sendout(RCVR_PORT, 0x0D, ADD_CHAR);
   sendout(RCVR_PORT, 0x0A, EOM);
   if(sim_file == 0) Sleep(50);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testl %edi, %edi
je 0x946e9
pushq $0x3b
popq %rdi
callq 0x523f2
pushq $0x2a
popq %rdi
callq 0x523f2
movzbl 0x2c2401(%rip), %edx    # 0x356ab6
leaq 0x80304(%rip), %rsi     # 0x1149c0
leaq -0x1a(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movzbl (%rbx), %esi
pushq $0xa
popq %r14
movl %r14d, %edi
xorl %edx, %edx
callq 0xba3b
movzbl 0x1(%rbx), %esi
movl %r14d, %edi
xorl %edx, %edx
callq 0xba3b
pushq $0xa
popq %rbx
pushq $0x3c
popq %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0xba3b
pushq $0xd
popq %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0xba3b
pushq $0x1
popq %rdx
movl %ebx, %edi
movl %ebx, %esi
callq 0xba3b
leaq 0x193ca9(%rip), %rax    # 0x2283c0
cmpq $0x0, (%rax)
je 0x94726
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x32
popq %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xae83
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathgps.cpp
// Function: send_taip_id(int)
void send_taip_id(int id)
{
char s[32];

   // send a TAIP device id

   if(id < 0) id = 0-id;
   id = (id % 10000);

   sprintf(s, ";ID=%04d", id);
   send_nmea_string(s, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movl %edi, %eax
negl %eax
cmovsl %edi, %eax
movl $0x2710, %ecx           # imm = 0x2710
xorl %edx, %edx
divl %ecx
leaq 0x7b2a9(%rip), %rsi     # 0x10f9ff
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5724b
addq $0x28, %rsp
popq %rbx
popq %rbp
retq