LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: rftg_disable_cpu()
void rftg_disable_cpu()
{
   if(read_only) return;

   start_rftg_request2(0);

   send_rftg_start(0x30);
   send_byte(5); 
   send_dword(0);
   send_rftg_end();

   set_rftg_normal();
}

// Assembly:
leaq 0x2ade03(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8921d
retq
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x657ff
movl $0x30, %edi
callq 0x5e6be
movl $0x5, %edi
callq 0x590f7
xorl %edi, %edi
callq 0x592eb
callq 0x5e73c
xorl %edi, %edi
callq 0x65779
movl $0x45, %edi
callq 0x5e6be
popq %rbp
jmp 0x5e73c
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: send_brandy_string(char*, int)
void send_brandy_string(char *s, int comma)
{
int i, j;

   if(s == 0) return;

   j = strlen(s);
   for(i=0; i<j; i++) send_brandy_char((u08) s[i]);

   if(comma) send_brandy_char((u08) ',');
}

// Assembly:
testq %rdi, %rdi
je 0x89bf2
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x9120
movq %rax, %r15
testl %r15d, %r15d
jle 0x89bc5
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movzbl (%r14,%r13), %r12d
movl $0xa, %edi
movl %r12d, %esi
movl $0x1, %edx
callq 0xbcaa
xorb %r12b, 0x2e2ef9(%rip)   # 0x36cab6
incq %r13
cmpq %r13, %r15
jne 0x89b9f
testl %ebx, %ebx
je 0x89be4
movl $0xa, %edi
movl $0x2c, %esi
movl $0x1, %edx
callq 0xbcaa
xorb $0x2c, 0x2e2ed2(%rip)   # 0x36cab6
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: send_brandy_end(int)
void send_brandy_end(int do_cksum)
{
char cksum[10];

   sprintf(cksum, "%02X", (nmea_tx_cksum & 0xFF));

   if(do_cksum) {
      send_brandy_char('*');
      send_brandy_char(cksum[0]);
      send_brandy_char(cksum[1]);
   }
   send_brandy_char(0x0D);
   send_brandy_char(0x0A);

   if(sim_file == 0) Sleep(50);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movzbl 0x2e2eb1(%rip), %edx    # 0x36cab6
leaq 0xa0e6f(%rip), %rsi     # 0x12aa7b
leaq -0x12(%rbp), %rdi
xorl %eax, %eax
callq 0x9060
testl %ebx, %ebx
je 0x89c6c
movl $0xa, %edi
movl $0x2a, %esi
movl $0x1, %edx
callq 0xbcaa
xorb $0x2a, 0x2e2e80(%rip)   # 0x36cab6
movzbl -0x12(%rbp), %ebx
movl $0xa, %edi
movl %ebx, %esi
movl $0x1, %edx
callq 0xbcaa
xorb %bl, 0x2e2e65(%rip)     # 0x36cab6
movzbl -0x11(%rbp), %ebx
movl $0xa, %edi
movl %ebx, %esi
movl $0x1, %edx
callq 0xbcaa
xorb %bl, 0x2e2e4a(%rip)     # 0x36cab6
movl $0xa, %edi
movl $0xd, %esi
movl $0x1, %edx
callq 0xbcaa
xorb $0xd, 0x2e2e2f(%rip)    # 0x36cab6
movl $0xa, %edi
movl $0xa, %esi
movl $0x1, %edx
callq 0xbcaa
xorb $0xa, 0x2e2e14(%rip)    # 0x36cab6
leaq 0x1b4717(%rip), %rax    # 0x23e3c0
cmpq $0x0, (%rax)
je 0x89cb6
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movl $0x32, %edi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0xafe8
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: send_brandy_cmd(char*)
void send_brandy_cmd(char *s)
{
   if(s == 0) return;
   if(log_file && (log_stream & LOG_PACKET_START)) {
      fprintf(log_file, "\nSend brandy start: %s\n", s);
   }

   send_brandy_start();
   send_brandy_string(s, 0);
//send_brandy_end(0);
//return;
   if(strchr(s, '*')) send_brandy_end(0);
   else               send_brandy_end(1);
}

// Assembly:
testq %rdi, %rdi
je 0x89d46
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b4685(%rip), %rax    # 0x23e360
movq (%rax), %rdi
testq %rdi, %rdi
je 0x89d00
leaq 0x1b4726(%rip), %rax    # 0x23e410
testb $0x4, (%rax)
je 0x89d00
leaq 0x99a42(%rip), %rsi     # 0x123738
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9560
movl $0xa, %edi
movl $0x24, %esi
movl $0x1, %edx
callq 0xbcaa
movb $0x0, 0x2e2d9b(%rip)    # 0x36cab6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x89b70
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x9100
xorl %edi, %edi
testq %rax, %rax
sete %dil
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x89bf3
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_brandy_c()
void parse_brandy_c()
{

   // pulse output
   log_packet_id("pulse output");

   if(get_msg_field()) {  // pulse time should be UXXXXXX or P1000 for 1PPS
      strupr(msg_field);
      if(msg_field[0] == 'P') brandy_pps_rate = atoi(&msg_field[1]);
      else if(strstr(msg_field, "UXXXXXX")) brandy_pps_rate = 1000;
      else brandy_pps_rate = 0;
      have_brandy_rate = 1;
   }

   if(get_msg_field()) {  // pulse width in msecs
      brandy_pps_width = atoi(msg_field);
      if(brandy_pps_width < 0) pps_polarity = 1;
      else                     pps_polarity = 0;
      have_pps_polarity = 22;
      have_brandy_width = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x9952b(%rip), %rdi     # 0x123761
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0x8a29b
leaq 0x2b17f5(%rip), %rbx    # 0x33ba40
movq %rbx, %rdi
callq 0x9899
cmpb $0x50, (%rbx)
jne 0x8a265
incq %rbx
movq %rbx, %rdi
callq 0x95e0
jmp 0x8a285
leaq 0x2b17d4(%rip), %rdi    # 0x33ba40
leaq 0x994fb(%rip), %rsi     # 0x12376e
callq 0x9090
xorl %ecx, %ecx
testq %rax, %rax
movl $0x3e8, %eax            # imm = 0x3E8
cmovel %ecx, %eax
leaq 0x2b1bc4(%rip), %rcx    # 0x33be50
movl %eax, (%rcx)
leaq 0x2b1bbf(%rip), %rax    # 0x33be54
movl $0x1, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x8a2df
leaq 0x2b1795(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x2b1ba1(%rip), %rcx    # 0x33be58
movl %eax, (%rcx)
shrl $0x1f, %eax
leaq 0x283a55(%rip), %rcx    # 0x30dd18
movl %eax, (%rcx)
leaq 0x283014(%rip), %rax    # 0x30d2e0
movl $0x16, (%rax)
leaq 0x2b1b83(%rip), %rax    # 0x33be5c
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_brandy_e()
void parse_brandy_e()
{
   // code output
   log_packet_id("code output");

   if(get_msg_field()) {  // time code 1 type
      brandy_code1 = msg_field[0];
      have_brandy_code |= 0x01;
   }

   if(get_msg_field()) {  // pulse output type
      brandy_code2 = msg_field[0];
      if     (brandy_code2 == '0') { pps_enabled = 0; have_pps_enable = 30; }
      else if(brandy_code2 == '1') { pps_enabled = 0; have_pps_enable = 31; } 
      else if(brandy_code2 == '2') { pps_enabled = 1; have_pps_enable = 31; } 
      else if(brandy_code2 == '3') { pps_enabled = 1; have_pps_enable = 32; } 
      have_brandy_code |= 0x02;
   }

   if(get_msg_field()) {  // TXD1 code type (not used)
      brandy_code3 = msg_field[0];
      have_brandy_code |= 0x04;
   }

   if(get_msg_field()) {  // TXD2 code type (not used)
      brandy_code4 = msg_field[0];
      have_brandy_code |= 0x08;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x99485(%rip), %rdi     # 0x123776
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0x8a31b
leaq 0x2b173a(%rip), %rax    # 0x33ba40
movb (%rax), %al
leaq 0x2b1b51(%rip), %rcx    # 0x33be60
movb %al, (%rcx)
leaq 0x2b1b4c(%rip), %rax    # 0x33be64
orb $0x1, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x8a373
leaq 0x2b1715(%rip), %rax    # 0x33ba40
movb (%rax), %al
leaq 0x2b1b2d(%rip), %rcx    # 0x33be61
movb %al, (%rcx)
addb $-0x30, %al
cmpb $0x3, %al
ja 0x8a369
leal (,%rax,8), %ecx
movl $0x1010000, %edx        # imm = 0x1010000
shrl %cl, %edx
movzbl %al, %eax
leaq 0x947ac(%rip), %rcx     # 0x11eb00
movl (%rcx,%rax,4), %eax
leaq 0x2839c2(%rip), %rcx    # 0x30dd20
movb %dl, (%rcx)
leaq 0x282f75(%rip), %rcx    # 0x30d2dc
movl %eax, (%rcx)
leaq 0x2b1af4(%rip), %rax    # 0x33be64
orb $0x2, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x8a398
leaq 0x2b16bd(%rip), %rax    # 0x33ba40
movb (%rax), %al
leaq 0x2b1ad6(%rip), %rcx    # 0x33be62
movb %al, (%rcx)
leaq 0x2b1acf(%rip), %rax    # 0x33be64
orb $0x4, (%rax)
callq 0x810b1
testl %eax, %eax
je 0x8a3bd
leaq 0x2b1698(%rip), %rax    # 0x33ba40
movb (%rax), %al
leaq 0x2b1ab2(%rip), %rcx    # 0x33be63
movb %al, (%rcx)
leaq 0x2b1aaa(%rip), %rax    # 0x33be64
orb $0x8, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_brandy_n()
void parse_brandy_n()
{
   // receiver fw version
   log_packet_id("firmware");

   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(brandy_fw, msg_field);
   }
   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(brandy_engine, msg_field);
   }
   if(get_msg_field()) {
      msg_field[32] = 0;
      strcpy(brandy_test, msg_field);
   }

   have_info |= (VERSION_INFO | PRODN_PARAMS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98f36(%rip), %rdi     # 0x1237a2
callq 0x58dc2
callq 0x810b1
testl %eax, %eax
je 0x8a891
leaq 0x2b11bf(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x2b13c4(%rip), %rdi    # 0x33bc50
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0x8a8b1
leaq 0x2b119f(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x2b1424(%rip), %rdi    # 0x33bcd0
callq 0x9340
callq 0x810b1
testl %eax, %eax
je 0x8a8d1
leaq 0x2b117f(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x2b1484(%rip), %rdi    # 0x33bd50
callq 0x9340
leaq 0x28309c(%rip), %rax    # 0x30d974
orb $0x6, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_prccg()
void parse_prccg()
{
int cmd;

   // Brandywine query responses
   // queries D, H, L, P, S produce NMEA messages

   if(get_msg_field() == 0) return;

   cmd = toupper(msg_field[0]);

   if     (cmd == 'A') parse_brandy_a();
   else if(cmd == 'C') parse_brandy_c();
   else if(cmd == 'E') parse_brandy_e();
   else if(cmd == 'F') parse_brandy_f();
   else if(cmd == 'J') parse_brandy_j();
   else if(cmd == 'N') parse_brandy_n();
   else if(cmd == 'O') parse_brandy_o();
   else if(cmd == 'Z') parse_brandy_z();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x810b1
testl %eax, %eax
je 0x8a947
leaq 0x2b112d(%rip), %rax    # 0x33ba40
movsbl (%rax), %edi
callq 0x9700
leal -0x41(%rax), %ecx
cmpl $0xe, %ecx
ja 0x8a939
leaq 0x949be(%rip), %rax     # 0x11f2e8
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
popq %rbp
jmp 0x89f30
cmpl $0x5a, %eax
jne 0x8a947
leaq 0x98e70(%rip), %rdi     # 0x1237b5
jmp 0x8a950
popq %rbp
retq
leaq 0x98e5b(%rip), %rdi     # 0x1237ab
popq %rbp
jmp 0x58dc2
popq %rbp
jmp 0x8a2e6
popq %rbp
jmp 0x8a3bf
popq %rbp
jmp 0x8a229
popq %rbp
jmp 0x8a5f9
popq %rbp
jmp 0x8a861
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_m()
void parse_sro_m()
{
int hh;   // efc input
int gg;   // reserved
int ff;   // Rb signal peak voltage
int ee;   // photocell voltage
int dd;   // varactor voltage
int cc;   // heater current
int bb;   // cell current
int aa;   // not used
int i;

   log_packet_id("readings");
   i = sscanf(nmea_msg, "%x %x %x %x %x %x %x %x", &hh,&gg,&ff,&ee,&dd,&cc,&bb,&aa);
   if(i != 8) {  // expected 8 values.  Loss of message sync?
      restart_prs_polling();
      return;
   }

   sro_hh = ((double) hh) / 255.0 * 5.0;
   sro_gg = (double) gg;
   sro_ff = ((double) ff) / 255.0 * 5.0;
   sro_ee = ((double) (255-ee)) / 255.0 * 5.0;
   sro_dd = ((double) dd) / 255.0 * 5.0;
   sro_cc = ((double) (255-cc)) / 255.0 * 100.0;
   sro_bb = ((double) (255-bb)) / 255.0 * 100.0;
   sro_aa = (double) aa;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x987d8(%rip), %rdi     # 0x12385d
callq 0x58dc2
leaq -0x14(%rbp), %r10
leaq -0x18(%rbp), %r11
leaq -0x1c(%rbp), %rbx
leaq -0x20(%rbp), %r14
leaq 0x2b078f(%rip), %rdi    # 0x33b830
leaq 0x9879d(%rip), %rsi     # 0x123845
leaq -0x30(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x24(%rbp), %r9
xorl %eax, %eax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
callq 0x9360
addq $0x20, %rsp
cmpl $0x8, %eax
jne 0x8b1c4
cvtsi2sdl -0x30(%rbp), %xmm1
movsd 0x93660(%rip), %xmm0    # 0x11e740
divsd %xmm0, %xmm1
movsd 0x7e04c(%rip), %xmm2    # 0x109138
mulsd %xmm2, %xmm1
leaq 0x282a71(%rip), %rax    # 0x30db68
movsd %xmm1, (%rax)
xorps %xmm1, %xmm1
cvtsi2sdl -0x2c(%rbp), %xmm1
leaq 0x282a66(%rip), %rax    # 0x30db70
movsd %xmm1, (%rax)
xorps %xmm1, %xmm1
cvtsi2sdl -0x28(%rbp), %xmm1
divsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
leaq 0x282a53(%rip), %rax    # 0x30db78
movl $0xff, %ecx
subl -0x24(%rbp), %ecx
movsd %xmm1, (%rax)
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
leaq 0x282a39(%rip), %rax    # 0x30db80
cvtsi2sdl -0x20(%rbp), %xmm3
movsd %xmm1, (%rax)
divsd %xmm0, %xmm3
mulsd %xmm2, %xmm3
leaq 0x282a29(%rip), %rax    # 0x30db88
movsd %xmm3, (%rax)
movl $0xff, %eax
subl -0x1c(%rbp), %eax
movl $0xff, %ecx
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm0, %xmm1
movsd 0x7dedd(%rip), %xmm2    # 0x109060
mulsd %xmm2, %xmm1
leaq 0x282a02(%rip), %rax    # 0x30db90
movsd %xmm1, (%rax)
subl -0x18(%rbp), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
leaq 0x2829ed(%rip), %rax    # 0x30db98
movsd %xmm1, (%rax)
xorps %xmm0, %xmm0
cvtsi2sdl -0x14(%rbp), %xmm0
leaq 0x2829e2(%rip), %rax    # 0x30dba0
movsd %xmm0, (%rax)
jmp 0x8b1c9
callq 0x8b1d2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: restart_prs_polling()
void restart_prs_polling()
{
    polled_req = 0;                  // reset message queues, etc
    drain_port(RCVR_PORT);
    polled_q_in = polled_q_out = 0;
    polled_q_entries = 0;
    polled_msg_id = 0;
    scpi_msg_id = 0;
    prs_msg_id = 0;
    x72_msg_id = 0;
    sa35_msg_id = 0;
    sro_msg_id = 0;
    lpfrs_msg_id = 0;
    rcvr_reset = 0;
    tsip_sync = 0;
    tsip_wptr = 0;
    tsip_rptr = 0;
    did_init1 = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movl %ebx, 0x2e4dfc(%rip)    # 0x36ffdc
movl $0xa, %edi
callq 0x5802f
movl %ebx, 0x2e4de4(%rip)    # 0x36ffd4
movl %ebx, 0x2e4dda(%rip)    # 0x36ffd0
movl %ebx, 0x2e4ddc(%rip)    # 0x36ffd8
movl %ebx, 0x2e19fe(%rip)    # 0x36cc00
movl %ebx, 0x2e1a04(%rip)    # 0x36cc0c
movl %ebx, 0x2e19fa(%rip)    # 0x36cc08
movl %ebx, 0x2e19cc(%rip)    # 0x36cbe0
movl %ebx, 0x2e19f6(%rip)    # 0x36cc10
movl %ebx, 0x2e19f4(%rip)    # 0x36cc14
movl %ebx, 0x2e19de(%rip)    # 0x36cc04
leaq 0x18fdfb(%rip), %rax    # 0x21b028
movl %ebx, (%rax)
leaq 0x2ad020(%rip), %rax    # 0x338256
movw %bx, (%rax)
leaq 0x2ad012(%rip), %rax    # 0x338252
movw %bx, (%rax)
leaq 0x2ad00a(%rip), %rax    # 0x338254
movw %bx, (%rax)
leaq 0x2abdbc(%rip), %rax    # 0x337010
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_id()
void parse_sro_id()
{
   log_packet_id("id info");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   nmea_msg[21] = 0;
   strcpy(sro_id, nmea_msg);
   if(all_polled) have_info |= (VERSION_INFO | PRODN_PARAMS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x985fe(%rip), %rdi     # 0x123866
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b27c
popq %rbp
jmp 0x8b1d2
leaq 0x2b05ad(%rip), %rsi    # 0x33b830
movb $0x0, 0x15(%rsi)
leaq 0x282882(%rip), %rdi    # 0x30db10
callq 0x9340
cmpl $0x0, 0x2e0b2e(%rip)    # 0x36bdc8
je 0x8b2a6
leaq 0x2826d1(%rip), %rax    # 0x30d974
orb $0x6, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_sn()
void parse_sro_sn()
{
   log_packet_id("serial number");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   nmea_msg[18] = 0;
   strcpy(sro_sn, nmea_msg);
   if(all_polled) have_info |= (MANUF_PARAMS | PRODN_PARAMS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x985bb(%rip), %rdi     # 0x12386e
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b2c7
popq %rbp
jmp 0x8b1d2
leaq 0x2b0562(%rip), %rsi    # 0x33b830
movb $0x0, 0x12(%rsi)
leaq 0x282867(%rip), %rdi    # 0x30db40
callq 0x9340
cmpl $0x0, 0x2e0ae3(%rip)    # 0x36bdc8
je 0x8b2f1
leaq 0x282686(%rip), %rax    # 0x30d974
orb $0x3, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_st()
void parse_sro_st()
{
   log_packet_id("status");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_status= atoi(nmea_msg);
   discipline_mode = DIS_MODE_NORMAL;
   if     (sro_status == 0) discipline_mode = DIS_MODE_WARMUP;
   else if(sro_status == 1) discipline_mode = DIS_MODE_LEARNING;
   else if(sro_status == 9) discipline_mode = DIS_MODE_FAILED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9a81f(%rip), %rdi     # 0x125b1d
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b312
popq %rbp
jmp 0x8b1d2
leaq 0x2b0517(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x28283f(%rip), %rcx    # 0x30db64
movl %eax, (%rcx)
leaq 0x282169(%rip), %rcx    # 0x30d497
movb $0x0, (%rcx)
cmpl $0x9, %eax
je 0x8b349
cmpl $0x1, %eax
je 0x8b344
testl %eax, %eax
jne 0x8b34c
movb $0xa, (%rcx)
jmp 0x8b34c
movb $0x14, (%rcx)
jmp 0x8b34c
movb $0x19, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_tr()
void parse_sro_tr()
{
   log_packet_id("tr value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_tr = atoi(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98523(%rip), %rdi     # 0x12387c
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b36d
popq %rbp
jmp 0x8b1d2
leaq 0x2b04bc(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x282828(%rip), %rcx    # 0x30dba8
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_sy()
void parse_sro_sy()
{
   log_packet_id("sy value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_sy = atoi(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x984f6(%rip), %rdi     # 0x123885
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b3a3
popq %rbp
jmp 0x8b1d2
leaq 0x2b0486(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x2827f6(%rip), %rcx    # 0x30dbac
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_de()
void parse_sro_de()
{
   log_packet_id("de value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_de = atoi(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x89d3f(%rip), %rdi     # 0x115104
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b3d9
popq %rbp
jmp 0x8b1d2
leaq 0x2b0450(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x2827c4(%rip), %rcx    # 0x30dbb0
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_pw()
void parse_sro_pw()
{
   log_packet_id("pps enable");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_pw = atoi(nmea_msg);
   if(sro_pw) pps_enabled = 1;
   else       pps_enabled = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98493(%rip), %rdi     # 0x12388e
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b40f
popq %rbp
jmp 0x8b1d2
leaq 0x2b041a(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x282792(%rip), %rcx    # 0x30dbb4
movl %eax, (%rcx)
testl %eax, %eax
je 0x8b434
leaq 0x2828f1(%rip), %rax    # 0x30dd20
movb $0x1, (%rax)
jmp 0x8b43e
leaq 0x2828e5(%rip), %rax    # 0x30dd20
movb $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_fc()
void parse_sro_fc()
{
   log_packet_id("freq control value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_fc = atoi(nmea_msg);
   osc_offset = ((double)sro_fc)*SRO_DDS_STEP*1.0E12/1000.0;
   have_osc_offset = 77;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9844e(%rip), %rdi     # 0x123899
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b45f
popq %rbp
jmp 0x8b1d2
leaq 0x2b03ca(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x282746(%rip), %rcx    # 0x30dbb8
movl %eax, (%rcx)
cvtsi2sd %eax, %xmm0
mulsd 0x7dcd0(%rip), %xmm0    # 0x109150
mulsd 0x7dcd0(%rip), %xmm0    # 0x109158
divsd 0x7dba8(%rip), %xmm0    # 0x109038
leaq 0x281329(%rip), %rax    # 0x30c7c0
movsd %xmm0, (%rax)
leaq 0x281d92(%rip), %rax    # 0x30d234
movl $0x4d, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_fs()
void parse_sro_fs()
{
   log_packet_id("fs value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_fs = atoi(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x983f7(%rip), %rdi     # 0x1238ac
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b4c9
popq %rbp
jmp 0x8b1d2
leaq 0x2b0360(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x2826e0(%rip), %rcx    # 0x30dbbc
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_tw()
void parse_sro_tw()
{
   log_packet_id("tw value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_tw = atoi(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x983ca(%rip), %rdi     # 0x1238b5
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b4ff
popq %rbp
jmp 0x8b1d2
leaq 0x2b032a(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x2826ae(%rip), %rcx    # 0x30dbc0
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_aw()
void parse_sro_aw()
{
   log_packet_id("aw value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_aw = atoi(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9839d(%rip), %rdi     # 0x1238be
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b535
popq %rbp
jmp 0x8b1d2
leaq 0x2b02f4(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x28267c(%rip), %rcx    # 0x30dbc4
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_tc()
void parse_sro_tc()
{
   log_packet_id("time constant");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_tc = atoi(nmea_msg);
   time_constant = (DATA_SIZE) sro_tc;
   have_osc_params |= PARAM_TC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98708(%rip), %rdi     # 0x123c5f
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b56b
popq %rbp
jmp 0x8b1d2
leaq 0x2b02be(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x28264a(%rip), %rcx    # 0x30dbc8
movl %eax, (%rcx)
cvtsi2sd %eax, %xmm0
leaq 0x281b65(%rip), %rax    # 0x30d0f0
movsd %xmm0, (%rax)
leaq 0x282866(%rip), %rax    # 0x30ddfc
orb $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_co()
void parse_sro_co()
{
   log_packet_id("co value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_co = atoi(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98321(%rip), %rdi     # 0x1238c7
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b5ba
popq %rbp
jmp 0x8b1d2
leaq 0x2b026f(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x2825ff(%rip), %rcx    # 0x30dbcc
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_vt()
void parse_sro_vt()
{
   log_packet_id("vt value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_vt = atoi(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x982f4(%rip), %rdi     # 0x1238d0
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b5f0
popq %rbp
jmp 0x8b1d2
leaq 0x2b0239(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x2825d5(%rip), %rcx    # 0x30dbd8
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_vs()
void parse_sro_vs()
{
   log_packet_id("pps offset");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_vs = atof(nmea_msg);
   pps_offset = sro_vs;
   have_pps_offset = 77;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x982c7(%rip), %rdi     # 0x1238d9
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b626
popq %rbp
jmp 0x8b1d2
leaq 0x2b0203(%rip), %rdi    # 0x33b830
callq 0x9470
leaq 0x282597(%rip), %rax    # 0x30dbd0
movsd %xmm0, (%rax)
leaq 0x281174(%rip), %rax    # 0x30c7b8
movsd %xmm0, (%rax)
leaq 0x281be9(%rip), %rax    # 0x30d238
movl $0x4d, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_ra()
void parse_sro_ra()
{
   log_packet_id("ra value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_ra = atoi(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98282(%rip), %rdi     # 0x1238e4
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b676
popq %rbp
jmp 0x8b1d2
leaq 0x2b01b3(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x282557(%rip), %rcx    # 0x30dbe0
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_gf()
void parse_sro_gf()
{
   log_packet_id("gofast value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_gf = atoi(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98255(%rip), %rdi     # 0x1238ed
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b6ac
popq %rbp
jmp 0x8b1d2
leaq 0x2b017d(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x28251d(%rip), %rcx    # 0x30dbdc
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_l05()
void parse_sro_l05()
{
   log_packet_id("fc high byte");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_l05 = atohex(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98231(%rip), %rdi     # 0x1238ff
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b6e2
popq %rbp
jmp 0x8b1d2
leaq 0x2b0147(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x2824ef(%rip), %rcx    # 0x30dbe4
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_l06()
void parse_sro_l06()
{
int i;

   log_packet_id("fc low byte");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_l06 = atohex(nmea_msg);
   i = (sro_l05 * 256) + sro_l06;
   if(sro_l05 & 0x80) i = 32767-i;
   sro_poweron_fc = SRO_DDS_STEP * (double) i;
//sprintf(debug_text2, "pwronr_fc:%g %g  l05:%02X  l06:%02x", (double)sro_poweron_fc*SRO_DDS_STEP, sro_poweron_fc, sro_l05,sro_l06);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9820d(%rip), %rdi     # 0x123911
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b718
popq %rbp
jmp 0x8b1d2
leaq 0x2b0111(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x2824bd(%rip), %rcx    # 0x30dbe8
movl %eax, (%rcx)
leaq 0x2824b0(%rip), %rcx    # 0x30dbe4
movl (%rcx), %ecx
movl %ecx, %edx
shll $0x8, %edx
addl %eax, %edx
movl $0x7fff, %eax           # imm = 0x7FFF
subl %edx, %eax
testb %cl, %cl
cmovnsl %edx, %eax
cvtsi2sd %eax, %xmm0
mulsd 0x7d9fb(%rip), %xmm0    # 0x109150
leaq 0x2824c4(%rip), %rax    # 0x30dc20
movsd %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_r05()
void parse_sro_r05()
{
   log_packet_id("user fc high byte");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_r05 = atohex(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9818d(%rip), %rdi     # 0x1238fa
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b781
popq %rbp
jmp 0x8b1d2
leaq 0x2b00a8(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x282458(%rip), %rcx    # 0x30dbec
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_r06()
void parse_sro_r06()
{
int i;

   log_packet_id("user fc low byte");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_r06 = atohex(nmea_msg);
   i = (sro_r05 * 256) + sro_r06;
   if(sro_r05 & 0x80) i = 32767-i;
   sro_user_fc = SRO_DDS_STEP * (double) i;
//sprintf(debug_text2, "user_fc:%g %g  r14:%02X  r15:%02x", (double)sro_user_fc*SRO_DDS_STEP, sro_user_fc, sro_r05,sro_r06);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98169(%rip), %rdi     # 0x12390c
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b7b7
popq %rbp
jmp 0x8b1d2
leaq 0x2b0072(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x282426(%rip), %rcx    # 0x30dbf0
movl %eax, (%rcx)
leaq 0x282419(%rip), %rcx    # 0x30dbec
movl (%rcx), %ecx
movl %ecx, %edx
shll $0x8, %edx
addl %eax, %edx
movl $0x7fff, %eax           # imm = 0x7FFF
subl %edx, %eax
testb %cl, %cl
cmovnsl %edx, %eax
cvtsi2sd %eax, %xmm0
mulsd 0x7d95c(%rip), %xmm0    # 0x109150
leaq 0x282415(%rip), %rax    # 0x30dc10
movsd %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_r14()
void parse_sro_r14()
{
   log_packet_id("freq limit high byte");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_r14 = atohex(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98111(%rip), %rdi     # 0x12391d
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b820
popq %rbp
jmp 0x8b1d2
leaq 0x2b0009(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x2823c1(%rip), %rcx    # 0x30dbf4
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_r15()
void parse_sro_r15()
{
int i;

   log_packet_id("freq limit low byte");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_r15 = atohex(nmea_msg);
   i = (sro_r14 * 256) + sro_r15;
   if(sro_r14 & 0x80) i = 32767-i;
   sro_freq_lim = SRO_DDS_STEP * (double) i;
//sprintf(debug_text, "freq lim:%g  r14:%02X  r15:%02x", sro_freq_lim, sro_r14,sro_r15);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x980f0(%rip), %rdi     # 0x123932
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b856
popq %rbp
jmp 0x8b1d2
leaq 0x2affd3(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x28238f(%rip), %rcx    # 0x30dbf8
movl %eax, (%rcx)
leaq 0x282382(%rip), %rcx    # 0x30dbf4
movl (%rcx), %ecx
movl %ecx, %edx
shll $0x8, %edx
addl %eax, %edx
movl $0x7fff, %eax           # imm = 0x7FFF
subl %edx, %eax
testb %cl, %cl
cmovnsl %edx, %eax
cvtsi2sd %eax, %xmm0
mulsd 0x7d8bd(%rip), %xmm0    # 0x109150
leaq 0x28237e(%rip), %rax    # 0x30dc18
movsd %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_r48()
void parse_sro_r48()
{
   log_packet_id("countdown high byte");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_r48 = atohex(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9809b(%rip), %rdi     # 0x123946
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b8bf
popq %rbp
jmp 0x8b1d2
leaq 0x2aff6a(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x28232a(%rip), %rcx    # 0x30dbfc
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_r49()
void parse_sro_r49()
{
int i;

   log_packet_id("countdown low byte");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_r49 = atohex(nmea_msg);

   i = (sro_r48 * 256) + sro_r49;
   sro_countdown = i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98079(%rip), %rdi     # 0x12395a
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b8f5
popq %rbp
jmp 0x8b1d2
leaq 0x2aff34(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x2822f8(%rip), %rcx    # 0x30dc00
movl %eax, (%rcx)
leaq 0x2822eb(%rip), %rcx    # 0x30dbfc
movl (%rcx), %ecx
shll $0x8, %ecx
addl %eax, %ecx
leaq 0x2822e9(%rip), %rax    # 0x30dc08
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_sro_r4F()
void parse_sro_r4F()
{
   log_packet_id("4F value");
   if(valid_sro_status()) {
      restart_prs_polling();
      return;
   }
   sro_r4F = atohex(nmea_msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9803f(%rip), %rdi     # 0x12396d
callq 0x58dc2
callq 0x8b015
testl %eax, %eax
je 0x8b942
popq %rbp
jmp 0x8b1d2
leaq 0x2afee7(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x2822af(%rip), %rcx    # 0x30dc04
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_fs(int)
void set_sro_fs(int mode)
{
   if(read_only) return;

   if(mode < 0) mode = 0;
   if(mode > 3) mode = 1;
   sprintf(out, "FS%d", mode);
   queue_sro_cmd(out, SRO_FS_MSG);
   queue_sro_cmd("L05", SRO_L05_MSG); 
   queue_sro_cmd("L06", SRO_L06_MSG); 
   sro_eeprom();
}

// Assembly:
leaq 0x2ab648(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8b9d8
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %edi, %edi
movl $0x0, %eax
cmovgl %edi, %eax
cmpl $0x4, %edi
movl $0x1, %edx
cmovll %eax, %edx
leaq 0x2b0826(%rip), %rbx    # 0x33c220
leaq 0x97f8e(%rip), %rsi     # 0x12398f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x32a, %esi            # imm = 0x32A
callq 0x5edda
leaq 0x95d32(%rip), %rdi     # 0x121751
movl $0x33e, %esi            # imm = 0x33E
callq 0x5edda
leaq 0x95d25(%rip), %rdi     # 0x121755
movl $0x33f, %esi            # imm = 0x33F
callq 0x5edda
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d78
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_gf(int)
void set_sro_gf(int secs)
{
   if(read_only) return;

   if(secs < 0) secs = 0;
   if(secs > 65535) secs = 65535;
   sprintf(out, "GF%05d", secs);
   queue_sro_cmd(out, SRO_GF_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2ab5c9(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8ba57
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edx
movl $0xffff, %eax           # imm = 0xFFFF
cmpl %eax, %edx
cmovgel %eax, %edx
leaq 0x2b07a9(%rip), %rbx    # 0x33c220
leaq 0x97f16(%rip), %rsi     # 0x123994
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x332, %esi            # imm = 0x332
callq 0x5edda
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d78
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_width(double)
void set_sro_width(double usecs)
{
int val;

   if(read_only) return;

   if(usecs < 0.0) usecs = 0.0 - usecs;
   usecs *= 1000.0;
   usecs += (SRO_TICK / 2.0);
   val = (int) (usecs / SRO_TICK);
   if(val > 7499999) val = 7499999;
   sprintf(out, "PW%07d", val);
   queue_sro_cmd(out, SRO_PW_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2ab56e(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bab2
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltsd %xmm1, %xmm2
subsd %xmm0, %xmm1
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
mulsd 0x7d55b(%rip), %xmm2    # 0x109038
addsd 0x92c63(%rip), %xmm2    # 0x11e748
divsd 0x7ff23(%rip), %xmm2    # 0x10ba10
cvttsd2si %xmm2, %eax
movl $0x7270df, %edx         # imm = 0x7270DF
cmpl %edx, %eax
cmovll %eax, %edx
leaq 0x2b071e(%rip), %rbx    # 0x33c220
leaq 0x97e92(%rip), %rsi     # 0x12399b
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x328, %esi            # imm = 0x328
callq 0x5edda
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d78
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_delay(double)
void set_sro_delay(double nsecs)
{
int val;

   if(read_only) return;

   if(nsecs < 0.0) nsecs = 0.0 - nsecs;
   nsecs += (SRO_TICK / 2.0);
   val = (int) (nsecs / SRO_TICK);
   if(val > 255) val = 255;
   sprintf(out, "DE%07d", val);
   queue_sro_cmd(out, SRO_DE_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2ab4e3(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bb3d
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltsd %xmm1, %xmm2
subsd %xmm0, %xmm1
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
addsd 0x92be0(%rip), %xmm2    # 0x11e748
divsd 0x7fea0(%rip), %xmm2    # 0x10ba10
cvttsd2si %xmm2, %eax
movl $0xff, %edx
cmpl %edx, %eax
cmovll %eax, %edx
leaq 0x2b069b(%rip), %rbx    # 0x33c220
leaq 0x97e16(%rip), %rsi     # 0x1239a2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x327, %esi            # imm = 0x327
callq 0x5edda
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d78
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_raw(double)
void set_sro_raw(double nsecs)
{
int val;

   if(read_only) return;

   val = (int) (nsecs / SRO_TICK);
   if(val > 127) val = 127;
   if(val < -128) val = -128;
   if(val < 0) sprintf(out, "RA%04d", val);
   else        sprintf(out, "RA+%03d", val);
   queue_sro_cmd(out, SRO_RA_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2ab460(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bbc0
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
divsd 0x7fe42(%rip), %xmm0    # 0x10ba10
movsd 0x7fcf2(%rip), %xmm1    # 0x10b8c8
maxsd %xmm0, %xmm1
movsd 0x7fcee(%rip), %xmm2    # 0x10b8d0
minsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movsbl %al, %edx
cvttsd2si %xmm0, %eax
testl %eax, %eax
leaq 0x97daf(%rip), %rax     # 0x1239a9
leaq 0x97daf(%rip), %rsi     # 0x1239b0
cmovsq %rax, %rsi
leaq 0x2b0614(%rip), %rbx    # 0x33c220
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x331, %esi            # imm = 0x331
callq 0x5edda
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d78
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_co(double)
void set_sro_co(double nsecs)
{
int val;

   if(read_only) return;

   val = (int) (nsecs);
   if(val > 127) val = 127;
   if(val < -128) val = -128;
   if(val < 0) sprintf(out, "CO%04d", val);
   else        sprintf(out, "CO+%03d", val);
   queue_sro_cmd(out, SRO_CO_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2ab3e0(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bc40
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movsd 0x7fc7a(%rip), %xmm1    # 0x10b8c8
maxsd %xmm0, %xmm1
movsd 0x7fc76(%rip), %xmm2    # 0x10b8d0
minsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movsbl %al, %edx
cvttsd2si %xmm0, %eax
testl %eax, %eax
leaq 0x97d46(%rip), %rax     # 0x1239b8
leaq 0x97d46(%rip), %rsi     # 0x1239bf
cmovsq %rax, %rsi
leaq 0x2b059c(%rip), %rbx    # 0x33c220
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x32e, %esi            # imm = 0x32E
callq 0x5edda
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d78
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_fc(double)
void set_sro_fc(double ppb)
{
int val;

   if(read_only) return;

   val = (int) ((ppb*1.0E-12) / SRO_DDS_STEP);
   if(val > 32767) val = 32767;
   if(val < -32768) val = -32768;
   if(val < 0) sprintf(out, "FC%06d", val);
   else        sprintf(out, "FC+%05d", val);
   queue_sro_cmd(out, SRO_FC_MSG);
   queue_sro_cmd("L05", SRO_L05_MSG); 
   queue_sro_cmd("L06", SRO_L06_MSG); 
   sro_eeprom();
}

// Assembly:
leaq 0x2ab368(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bcb8
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
mulsd 0x92532(%rip), %xmm0    # 0x11e1f8
divsd 0x7d482(%rip), %xmm0    # 0x109150
movsd 0x92a7a(%rip), %xmm1    # 0x11e750
maxsd %xmm0, %xmm1
movsd 0x92a56(%rip), %xmm2    # 0x11e738
minsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movswl %ax, %edx
cvttsd2si %xmm0, %eax
testl %eax, %eax
leaq 0x97ccd(%rip), %rax     # 0x1239c7
leaq 0x97ccd(%rip), %rsi     # 0x1239ce
cmovsq %rax, %rsi
leaq 0x2b0514(%rip), %rbx    # 0x33c220
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x329, %esi            # imm = 0x329
callq 0x5edda
leaq 0x95a27(%rip), %rdi     # 0x121751
movl $0x33e, %esi            # imm = 0x33E
callq 0x5edda
leaq 0x95a1a(%rip), %rdi     # 0x121755
movl $0x33f, %esi            # imm = 0x33F
callq 0x5edda
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d78
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_alarm_window(double)
void set_sro_alarm_window(double nsecs)
{
int val;

   if(read_only) return;

   if(nsecs < 0.0) nsecs = 0.0 - nsecs;
   nsecs += (SRO_TICK / 2.0);
   val = (int) (nsecs / SRO_TICK);
   if(val > 7499999) val = 7499999;
   sprintf(out, "AW%03d", val);
   queue_sro_cmd(out, SRO_AW_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2ab2be(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bd62
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltsd %xmm1, %xmm2
subsd %xmm0, %xmm1
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
addsd 0x929bb(%rip), %xmm2    # 0x11e748
divsd 0x7fc7b(%rip), %xmm2    # 0x10ba10
cvttsd2si %xmm2, %eax
movl $0x7270df, %edx         # imm = 0x7270DF
cmpl %edx, %eax
cmovll %eax, %edx
leaq 0x2b0476(%rip), %rbx    # 0x33c220
leaq 0x97c25(%rip), %rsi     # 0x1239d6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x32c, %esi            # imm = 0x32C
callq 0x5edda
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d78
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_track_window(double)
void set_sro_track_window(double nsecs)
{
int val;

   if(read_only) return;

   if(nsecs < 0.0) nsecs = 0.0 - nsecs;
   nsecs += (SRO_TICK / 2.0);
   val = (int) (nsecs / SRO_TICK);
   if(val > 255) val = 255;
   sprintf(out, "TW%03d", val);
   queue_sro_cmd(out, SRO_TW_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2ab23b(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bde5
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorpd %xmm1, %xmm1
movapd %xmm0, %xmm2
cmpltsd %xmm1, %xmm2
subsd %xmm0, %xmm1
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
addsd 0x92938(%rip), %xmm2    # 0x11e748
divsd 0x7fbf8(%rip), %xmm2    # 0x10ba10
cvttsd2si %xmm2, %eax
movl $0xff, %edx
cmpl %edx, %eax
cmovll %eax, %edx
leaq 0x2b03f3(%rip), %rbx    # 0x33c220
leaq 0x97ba9(%rip), %rsi     # 0x1239dd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x32b, %esi            # imm = 0x32B
callq 0x5edda
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d78
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sro_clock()
void set_sro_clock()
{

   if(read_only) return;

   sprintf(out, "DT%04d-%02d-%02d", pri_year,pri_month,pri_day);
   queue_sro_cmd(out, SRO_DT_MSG);

   sprintf(out, "TD%02d:%02d:%02d", pri_hours,pri_minutes,pri_seconds);
   queue_sro_cmd(out, SRO_TD_MSG);
   sro_eeprom();
}

// Assembly:
leaq 0x2ab1b8(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8be68
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x28169f(%rip), %rax    # 0x30d514
movl (%rax), %edx
leaq 0x281692(%rip), %rax    # 0x30d510
movl (%rax), %ecx
leaq 0x281685(%rip), %rax    # 0x30d50c
movl (%rax), %r8d
leaq 0x2b038f(%rip), %rbx    # 0x33c220
leaq 0x97b4c(%rip), %rsi     # 0x1239e4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x333, %esi            # imm = 0x333
callq 0x5edda
leaq 0x281652(%rip), %rax    # 0x30d508
movl (%rax), %edx
leaq 0x281645(%rip), %rax    # 0x30d504
movl (%rax), %ecx
leaq 0x281638(%rip), %rax    # 0x30d500
movl (%rax), %r8d
leaq 0x97b23(%rip), %rsi     # 0x1239f5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x334, %esi            # imm = 0x334
callq 0x5edda
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d78
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_scpi_user()
void parse_scpi_user()
{
int i;

   log_packet_id("scpi user msg");

   i = (int) sizeof(debug_text2)-20;
   if(i < (int) sizeof(nmea_msg)) nmea_msg[i] = 0;

   sprintf(debug_text2, "response to msg %d:%s", user_msg_num, nmea_msg);
   need_redraw = 543;  // why is this needed for X11?
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x98f2b(%rip), %rdi     # 0x1250fb
callq 0x58dc2
leaq 0x2af654(%rip), %rcx    # 0x33b830
movb $0x0, 0x137(%rcx)
movl 0x2dfc2b(%rip), %edx    # 0x36be14
leaq 0x2b2900(%rip), %rdi    # 0x33eaf0
leaq 0x98f12(%rip), %rsi     # 0x125109
xorl %eax, %eax
callq 0x9060
leaq 0x18c63f(%rip), %rax    # 0x218844
movl $0x21f, (%rax)          # imm = 0x21F
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jkingan[P]ladyheather/heathgps.cpp
// Function: set_sa35_freq(double)
void set_sa35_freq(double freq)
{
double val;

   // !!!!! placeholder

   if(read_only) return;

   if(freq > 2.00E-8) freq = 2.00E-8;
   if(freq < -2.00E-8) freq = -2.00E-8;

   val = freq / 1.0E-15;
   sprintf(out, "<FG%d>", (int) val);
   queue_sa35_cmd(out, SA35_DDS_CMD);

   BEEP(505);  // signal EEPROM write  piss3
}

// Assembly:
leaq 0x2aab86(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8c49a
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movsd 0x7f540(%rip), %xmm1    # 0x10b9e8
minsd %xmm0, %xmm1
movsd 0x922a4(%rip), %xmm0    # 0x11e758
maxsd %xmm1, %xmm0
divsd 0x7cc68(%rip), %xmm0    # 0x109128
cvttsd2si %xmm0, %edx
leaq 0x2afd55(%rip), %rbx    # 0x33c220
leaq 0x9755d(%rip), %rsi     # 0x123a2f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x3eb, %esi            # imm = 0x3EB
callq 0x5edda
movl $0x1f9, %edi            # imm = 0x1F9
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d78