LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: parse_rftg_traim()
void parse_rftg_traim()
{
   // !!!!! we need to decode this
   log_packet_id("Packet 0x63 (traim status)");

   tsip_byte();  // message rate
   tsip_byte();  // alarm limit us (?)
   tsip_byte();  // status (0x0D)
   tsip_byte();  // 
   tsip_byte();  // 
   tsip_byte();  // 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x9a626(%rip), %rdi     # 0x12351f
callq 0x58e77
callq 0x587d1
cmpl $0x100, %eax            # imm = 0x100
jb 0x88f14
leaq 0x1b605f(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
callq 0x587d1
cmpl $0x100, %eax            # imm = 0x100
jb 0x88f2a
leaq 0x1b6049(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
callq 0x587d1
cmpl $0x100, %eax            # imm = 0x100
jb 0x88f40
leaq 0x1b6033(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
callq 0x587d1
cmpl $0x100, %eax            # imm = 0x100
jb 0x88f56
leaq 0x1b601d(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
callq 0x587d1
cmpl $0x100, %eax            # imm = 0x100
jb 0x88f6c
leaq 0x1b6007(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
callq 0x587d1
cmpl $0x100, %eax            # imm = 0x100
jb 0x88f82
leaq 0x1b5ff1(%rip), %rax    # 0x23ef70
orb $0x8, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rftg_fix_mode(int)
void set_rftg_fix_mode(int mode)
{
   // (mode == 0) -> fix mode
   if(read_only) return;

   start_rftg_request2(0);

   send_rftg_start(0x31);
   send_byte(mode);
   send_rftg_end();
}

// Assembly:
leaq 0x2adeeb(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x89135
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %edi, %edi
callq 0x65636
movl $0x31, %edi
callq 0x5e740
movzbl %bl, %edi
callq 0x591af
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rftg_advance(float)
void set_rftg_advance(float val)
{
   // advance pps (in microseconds)
   if(read_only) return;

   start_rftg_request2(0);

   send_rftg_start(0x30);
   send_byte(1);    // advance
   send_single(val);
   send_rftg_end();
}

// Assembly:
leaq 0x2adeb2(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8916e
retq
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
movss %xmm0, -0x4(%rbp)
callq 0x65636
movl $0x30, %edi
callq 0x5e740
movl $0x1, %edi
callq 0x591af
movss -0x4(%rbp), %xmm0
callq 0x59440
addq $0x10, %rsp
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: set_rftg_delay(float)
void set_rftg_delay(float val)
{
   // delay pps (in microseconds)
   if(read_only) return;

   start_rftg_request2(0);

   send_rftg_start(0x30);
   send_byte(2);    // delay
   send_single(val);
   send_rftg_end();
}

// Assembly:
leaq 0x2ade69(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x891b7
retq
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
movss %xmm0, -0x4(%rbp)
callq 0x65636
movl $0x30, %edi
callq 0x5e740
movl $0x2, %edi
callq 0x591af
movss -0x4(%rbp), %xmm0
callq 0x59440
addq $0x10, %rsp
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: rftg_enable_cpu()
void rftg_enable_cpu()
{
   if(read_only) return;

   start_rftg_request2(0);

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

   set_rftg_normal();
}

// Assembly:
leaq 0x2ade20(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x89200
retq
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x65636
movl $0x30, %edi
callq 0x5e740
movl $0x4, %edi
callq 0x591af
xorl %edi, %edi
callq 0x593b5
callq 0x5e7c0
xorl %edi, %edi
callq 0x655b0
movl $0x45, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2addd1(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8924f
retq
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0x65636
movl $0x30, %edi
callq 0x5e740
movl $0x5, %edi
callq 0x591af
xorl %edi, %edi
callq 0x593b5
callq 0x5e7c0
xorl %edi, %edi
callq 0x655b0
movl $0x45, %edi
callq 0x5e740
popq %rbp
jmp 0x5e7c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x89c23
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 0x89bf6
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movzbl (%r14,%r13), %r12d
movl $0xa, %edi
movl %r12d, %esi
movl $0x1, %edx
callq 0xbcc0
xorb %r12b, 0x2e2ec8(%rip)   # 0x36cab6
incq %r13
cmpq %r13, %r15
jne 0x89bd0
testl %ebx, %ebx
je 0x89c15
movl $0xa, %edi
movl $0x2c, %esi
movl $0x1, %edx
callq 0xbcc0
xorb $0x2c, 0x2e2ea1(%rip)   # 0x36cab6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e2e80(%rip), %edx    # 0x36cab6
leaq 0xa0d73(%rip), %rsi     # 0x12a9b0
leaq -0x12(%rbp), %rdi
xorl %eax, %eax
callq 0x9060
testl %ebx, %ebx
je 0x89c9d
movl $0xa, %edi
movl $0x2a, %esi
movl $0x1, %edx
callq 0xbcc0
xorb $0x2a, 0x2e2e4f(%rip)   # 0x36cab6
movzbl -0x12(%rbp), %ebx
movl $0xa, %edi
movl %ebx, %esi
movl $0x1, %edx
callq 0xbcc0
xorb %bl, 0x2e2e34(%rip)     # 0x36cab6
movzbl -0x11(%rbp), %ebx
movl $0xa, %edi
movl %ebx, %esi
movl $0x1, %edx
callq 0xbcc0
xorb %bl, 0x2e2e19(%rip)     # 0x36cab6
movl $0xa, %edi
movl $0xd, %esi
movl $0x1, %edx
callq 0xbcc0
xorb $0xd, 0x2e2dfe(%rip)    # 0x36cab6
movl $0xa, %edi
movl $0xa, %esi
movl $0x1, %edx
callq 0xbcc0
xorb $0xa, 0x2e2de3(%rip)    # 0x36cab6
leaq 0x1b46e6(%rip), %rax    # 0x23e3c0
cmpq $0x0, (%rax)
je 0x89ce7
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movl $0x32, %edi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0xaff7
// File: /workspace/github_cpp_makefile_star2_O1/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 0x89d77
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b4654(%rip), %rax    # 0x23e360
movq (%rax), %rdi
testq %rdi, %rdi
je 0x89d31
leaq 0x1b46f5(%rip), %rax    # 0x23e410
testb $0x4, (%rax)
je 0x89d31
leaq 0x99931(%rip), %rsi     # 0x123658
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9560
movl $0xa, %edi
movl $0x24, %esi
movl $0x1, %edx
callq 0xbcc0
movb $0x0, 0x2e2d6a(%rip)    # 0x36cab6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x89ba1
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x9100
xorl %edi, %edi
testq %rax, %rax
sete %dil
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x89c24
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x99425(%rip), %rdi     # 0x123681
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8a2c1
leaq 0x2b17cf(%rip), %rbx    # 0x33ba40
movq %rbx, %rdi
callq 0x9899
cmpb $0x50, (%rbx)
jne 0x8a28b
incq %rbx
movq %rbx, %rdi
callq 0x95e0
jmp 0x8a2ab
leaq 0x2b17ae(%rip), %rdi    # 0x33ba40
leaq 0x993f5(%rip), %rsi     # 0x12368e
callq 0x9090
xorl %ecx, %ecx
testq %rax, %rax
movl $0x3e8, %eax            # imm = 0x3E8
cmovel %ecx, %eax
leaq 0x2b1b9e(%rip), %rcx    # 0x33be50
movl %eax, (%rcx)
leaq 0x2b1b99(%rip), %rax    # 0x33be54
movl $0x1, (%rax)
callq 0x811da
testl %eax, %eax
je 0x8a305
leaq 0x2b176f(%rip), %rdi    # 0x33ba40
callq 0x95e0
leaq 0x2b1b7b(%rip), %rcx    # 0x33be58
movl %eax, (%rcx)
shrl $0x1f, %eax
leaq 0x283a2f(%rip), %rcx    # 0x30dd18
movl %eax, (%rcx)
leaq 0x282fee(%rip), %rax    # 0x30d2e0
movl $0x16, (%rax)
leaq 0x2b1b5d(%rip), %rax    # 0x33be5c
movl $0x1, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9937f(%rip), %rdi     # 0x123696
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8a341
leaq 0x2b1714(%rip), %rax    # 0x33ba40
movb (%rax), %al
leaq 0x2b1b2b(%rip), %rcx    # 0x33be60
movb %al, (%rcx)
leaq 0x2b1b26(%rip), %rax    # 0x33be64
orb $0x1, (%rax)
callq 0x811da
testl %eax, %eax
je 0x8a399
leaq 0x2b16ef(%rip), %rax    # 0x33ba40
movb (%rax), %al
leaq 0x2b1b07(%rip), %rcx    # 0x33be61
movb %al, (%rcx)
addb $-0x30, %al
cmpb $0x3, %al
ja 0x8a38f
leal (,%rax,8), %ecx
movl $0x1010000, %edx        # imm = 0x1010000
shrl %cl, %edx
movzbl %al, %eax
leaq 0x946e6(%rip), %rcx     # 0x11ea60
movl (%rcx,%rax,4), %eax
leaq 0x28399c(%rip), %rcx    # 0x30dd20
movb %dl, (%rcx)
leaq 0x282f4f(%rip), %rcx    # 0x30d2dc
movl %eax, (%rcx)
leaq 0x2b1ace(%rip), %rax    # 0x33be64
orb $0x2, (%rax)
callq 0x811da
testl %eax, %eax
je 0x8a3be
leaq 0x2b1697(%rip), %rax    # 0x33ba40
movb (%rax), %al
leaq 0x2b1ab0(%rip), %rcx    # 0x33be62
movb %al, (%rcx)
leaq 0x2b1aa9(%rip), %rax    # 0x33be64
orb $0x4, (%rax)
callq 0x811da
testl %eax, %eax
je 0x8a3e3
leaq 0x2b1672(%rip), %rax    # 0x33ba40
movb (%rax), %al
leaq 0x2b1a8c(%rip), %rcx    # 0x33be63
movb %al, (%rcx)
leaq 0x2b1a84(%rip), %rax    # 0x33be64
orb $0x8, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98e30(%rip), %rdi     # 0x1236c2
callq 0x58e77
callq 0x811da
testl %eax, %eax
je 0x8a8b7
leaq 0x2b1199(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x2b139e(%rip), %rdi    # 0x33bc50
callq 0x9340
callq 0x811da
testl %eax, %eax
je 0x8a8d7
leaq 0x2b1179(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x2b13fe(%rip), %rdi    # 0x33bcd0
callq 0x9340
callq 0x811da
testl %eax, %eax
je 0x8a8f7
leaq 0x2b1159(%rip), %rsi    # 0x33ba40
movb $0x0, 0x20(%rsi)
leaq 0x2b145e(%rip), %rdi    # 0x33bd50
callq 0x9340
leaq 0x283076(%rip), %rax    # 0x30d974
orb $0x6, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x811da
testl %eax, %eax
je 0x8a96d
leaq 0x2b1107(%rip), %rax    # 0x33ba40
movsbl (%rax), %edi
callq 0x9700
leal -0x41(%rax), %ecx
cmpl $0xe, %ecx
ja 0x8a95f
leaq 0x948d8(%rip), %rax     # 0x11f228
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
popq %rbp
jmp 0x89f61
cmpl $0x5a, %eax
jne 0x8a96d
leaq 0x98d6a(%rip), %rdi     # 0x1236d5
jmp 0x8a976
popq %rbp
retq
leaq 0x98d55(%rip), %rdi     # 0x1236cb
popq %rbp
jmp 0x58e77
popq %rbp
jmp 0x8a30c
popq %rbp
jmp 0x8a3e5
popq %rbp
jmp 0x8a24f
popq %rbp
jmp 0x8a61f
popq %rbp
jmp 0x8a887
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathgps.cpp
// Function: send_queued_cmd(int)
int send_queued_cmd(int why)
{
int id;

   // send the next message in the request queue to the receiver

   if(polled_q_in == polled_q_out) return 0;
   id = polled_q[polled_q_out].id;

if(debug_file) fprintf(debug_file, "SEND Q %d: sqe:%d  old_id=%d: %s  why:%d\n", polled_q_out, polled_q_entries, polled_msg_id, polled_q[polled_q_out].msg, why);

   send_polled_cmd(polled_q[polled_q_out].msg, polled_q[polled_q_out].id);


   if(++polled_q_out >= POLLED_Q_SIZE) polled_q_out = 0;
   --polled_q_entries;

   if(rcvr_type == STAR_RCVR) ;
   else if(rcvr_type == BRANDY_RCVR) ;
   else if((id == SCPI_TEST_MSG) && (scpi_type != UCCMP_TYPE)) {
      if(sim_file == 0) Sleep(20000);    // wait for reset to complete

      erase_screen();
      vidstr(0,0, YELLOW, "Re-establishing communications in 30 seconds...");
      refresh_page();

      drain_com_data();      // flush com data
      reset_com_timer(RCVR_PORT);
      polled_q_in = 0;           // reset SCPI message send queue pointers
      polled_q_out = 0;
      polled_q_entries = 0;
      polled_req = 0;
      polled_seq = 0;
      need_redraw = 3487;
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movslq 0x2e54be(%rip), %rdx    # 0x36ffd4
xorl %ebx, %ebx
cmpl %edx, 0x2e54b2(%rip)    # 0x36ffd0
je 0x8ac65
movq %rdx, %rax
shlq $0x7, %rax
leaq (%rax,%rdx,4), %r9
leaq 0x2e210a(%rip), %rbx    # 0x36cc40
movl 0x80(%rbx,%r9), %r14d
leaq 0x1b384b(%rip), %rax    # 0x23e390
movq (%rax), %rax
testq %rax, %rax
je 0x8ab71
addq %rbx, %r9
movl 0x2e5482(%rip), %ecx    # 0x36ffd8
movl 0x2e20a3(%rip), %r8d    # 0x36cc00
movl %edi, (%rsp)
leaq 0x9a630(%rip), %rsi     # 0x125197
movq %rax, %rdi
xorl %eax, %eax
callq 0x9560
movslq 0x2e545c(%rip), %rax    # 0x36ffd4
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,4), %rax
leaq (%rbx,%rax), %rdi
movl 0x80(%rbx,%rax), %esi
callq 0x6e3bc
movl 0x2e543b(%rip), %eax    # 0x36ffd4
leal 0x1(%rax), %ecx
xorl %edx, %edx
cmpl $0x63, %eax
cmovll %ecx, %edx
movl %edx, 0x2e542a(%rip)    # 0x36ffd4
decl 0x2e5428(%rip)          # 0x36ffd8
leaq 0x18dd19(%rip), %rax    # 0x2188d0
movq (%rax), %rax
movl $0x1, %ebx
cmpq $0x1000, %rax           # imm = 0x1000
je 0x8ac65
cmpq $0x40000, %rax          # imm = 0x40000
je 0x8ac65
cmpl $0x19, %r14d
jne 0x8ac65
leaq 0x1903f8(%rip), %rax    # 0x21afe0
cmpl $0x50, (%rax)
je 0x8ac65
leaq 0x1b37cc(%rip), %rax    # 0x23e3c0
cmpq $0x0, (%rax)
jne 0x8ac04
movl $0x4e20, %edi           # imm = 0x4E20
callq 0xaff7
callq 0xed5e
leaq 0x9a5b1(%rip), %rcx     # 0x1251c1
xorl %r14d, %r14d
xorl %edi, %edi
xorl %esi, %esi
movl $0xe, %edx
callq 0xe7d0
callq 0xab5f
callq 0x585ff
movl $0xa, %edi
callq 0x1ea2c
movl %r14d, 0x2e5394(%rip)   # 0x36ffd0
movl %r14d, 0x2e5391(%rip)   # 0x36ffd4
movl %r14d, 0x2e538e(%rip)   # 0x36ffd8
movl %r14d, 0x2e538b(%rip)   # 0x36ffdc
movl %r14d, 0x2e5388(%rip)   # 0x36ffe0
leaq 0x18dbe5(%rip), %rax    # 0x218844
movl $0xd9f, (%rax)          # imm = 0xD9F
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x986fa(%rip), %rdi     # 0x12377d
callq 0x58e77
leaq -0x14(%rbp), %r10
leaq -0x18(%rbp), %r11
leaq -0x1c(%rbp), %rbx
leaq -0x20(%rbp), %r14
leaq 0x2b0791(%rip), %rdi    # 0x33b830
leaq 0x986bf(%rip), %rsi     # 0x123765
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 0x8b1c2
cvtsi2sdl -0x30(%rbp), %xmm1
movsd 0x935b2(%rip), %xmm0    # 0x11e690
divsd %xmm0, %xmm1
movsd 0x7e04e(%rip), %xmm2    # 0x109138
mulsd %xmm2, %xmm1
leaq 0x282a73(%rip), %rax    # 0x30db68
movsd %xmm1, (%rax)
xorps %xmm1, %xmm1
cvtsi2sdl -0x2c(%rbp), %xmm1
leaq 0x282a68(%rip), %rax    # 0x30db70
movsd %xmm1, (%rax)
xorps %xmm1, %xmm1
cvtsi2sdl -0x28(%rbp), %xmm1
divsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
leaq 0x282a55(%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 0x282a3b(%rip), %rax    # 0x30db80
cvtsi2sdl -0x20(%rbp), %xmm3
movsd %xmm1, (%rax)
divsd %xmm0, %xmm3
mulsd %xmm2, %xmm3
leaq 0x282a2b(%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 0x7dedf(%rip), %xmm2    # 0x109060
mulsd %xmm2, %xmm1
leaq 0x282a04(%rip), %rax    # 0x30db90
movsd %xmm1, (%rax)
subl -0x18(%rbp), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
divsd %xmm0, %xmm1
mulsd %xmm2, %xmm1
leaq 0x2829ef(%rip), %rax    # 0x30db98
movsd %xmm1, (%rax)
xorps %xmm0, %xmm0
cvtsi2sdl -0x14(%rbp), %xmm0
leaq 0x2829e4(%rip), %rax    # 0x30dba0
movsd %xmm0, (%rax)
jmp 0x8b1c7
callq 0x8b1d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x2e4dfe(%rip)    # 0x36ffdc
movl $0xa, %edi
callq 0x5804f
movl %ebx, 0x2e4de6(%rip)    # 0x36ffd4
movl %ebx, 0x2e4ddc(%rip)    # 0x36ffd0
movl %ebx, 0x2e4dde(%rip)    # 0x36ffd8
movl %ebx, 0x2e1a00(%rip)    # 0x36cc00
movl %ebx, 0x2e1a06(%rip)    # 0x36cc0c
movl %ebx, 0x2e19fc(%rip)    # 0x36cc08
movl %ebx, 0x2e19ce(%rip)    # 0x36cbe0
movl %ebx, 0x2e19f8(%rip)    # 0x36cc10
movl %ebx, 0x2e19f6(%rip)    # 0x36cc14
movl %ebx, 0x2e19e0(%rip)    # 0x36cc04
leaq 0x18fdfd(%rip), %rax    # 0x21b028
movl %ebx, (%rax)
leaq 0x2ad022(%rip), %rax    # 0x338256
movw %bx, (%rax)
leaq 0x2ad014(%rip), %rax    # 0x338252
movw %bx, (%rax)
leaq 0x2ad00c(%rip), %rax    # 0x338254
movw %bx, (%rax)
leaq 0x2abdbe(%rip), %rax    # 0x337010
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98520(%rip), %rdi     # 0x123786
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b27a
popq %rbp
jmp 0x8b1d0
leaq 0x2b05af(%rip), %rsi    # 0x33b830
movb $0x0, 0x15(%rsi)
leaq 0x282884(%rip), %rdi    # 0x30db10
callq 0x9340
cmpl $0x0, 0x2e0b30(%rip)    # 0x36bdc8
je 0x8b2a4
leaq 0x2826d3(%rip), %rax    # 0x30d974
orb $0x6, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x984dd(%rip), %rdi     # 0x12378e
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b2c5
popq %rbp
jmp 0x8b1d0
leaq 0x2b0564(%rip), %rsi    # 0x33b830
movb $0x0, 0x12(%rsi)
leaq 0x282869(%rip), %rdi    # 0x30db40
callq 0x9340
cmpl $0x0, 0x2e0ae5(%rip)    # 0x36bdc8
je 0x8b2ef
leaq 0x282688(%rip), %rax    # 0x30d974
orb $0x3, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9a741(%rip), %rdi     # 0x125a3d
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b310
popq %rbp
jmp 0x8b1d0
leaq 0x2b0519(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x282841(%rip), %rcx    # 0x30db64
movl %eax, (%rcx)
leaq 0x28216b(%rip), %rcx    # 0x30d497
movb $0x0, (%rcx)
cmpl $0x9, %eax
je 0x8b347
cmpl $0x1, %eax
je 0x8b342
testl %eax, %eax
jne 0x8b34a
movb $0xa, (%rcx)
jmp 0x8b34a
movb $0x14, (%rcx)
jmp 0x8b34a
movb $0x19, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98445(%rip), %rdi     # 0x12379c
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b36b
popq %rbp
jmp 0x8b1d0
leaq 0x2b04be(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x28282a(%rip), %rcx    # 0x30dba8
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98418(%rip), %rdi     # 0x1237a5
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b3a1
popq %rbp
jmp 0x8b1d0
leaq 0x2b0488(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x2827f8(%rip), %rcx    # 0x30dbac
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x89cad(%rip), %rdi     # 0x115070
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b3d7
popq %rbp
jmp 0x8b1d0
leaq 0x2b0452(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x2827c6(%rip), %rcx    # 0x30dbb0
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x983b5(%rip), %rdi     # 0x1237ae
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b40d
popq %rbp
jmp 0x8b1d0
leaq 0x2b041c(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x282794(%rip), %rcx    # 0x30dbb4
movl %eax, (%rcx)
testl %eax, %eax
je 0x8b432
leaq 0x2828f3(%rip), %rax    # 0x30dd20
movb $0x1, (%rax)
jmp 0x8b43c
leaq 0x2828e7(%rip), %rax    # 0x30dd20
movb $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98370(%rip), %rdi     # 0x1237b9
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b45d
popq %rbp
jmp 0x8b1d0
leaq 0x2b03cc(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x282748(%rip), %rcx    # 0x30dbb8
movl %eax, (%rcx)
cvtsi2sd %eax, %xmm0
mulsd 0x7dcca(%rip), %xmm0    # 0x109148
mulsd 0x7dcca(%rip), %xmm0    # 0x109150
divsd 0x7dbaa(%rip), %xmm0    # 0x109038
leaq 0x28132b(%rip), %rax    # 0x30c7c0
movsd %xmm0, (%rax)
leaq 0x281d94(%rip), %rax    # 0x30d234
movl $0x4d, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98319(%rip), %rdi     # 0x1237cc
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b4c7
popq %rbp
jmp 0x8b1d0
leaq 0x2b0362(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x2826e2(%rip), %rcx    # 0x30dbbc
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x982ec(%rip), %rdi     # 0x1237d5
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b4fd
popq %rbp
jmp 0x8b1d0
leaq 0x2b032c(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x2826b0(%rip), %rcx    # 0x30dbc0
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x982bf(%rip), %rdi     # 0x1237de
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b533
popq %rbp
jmp 0x8b1d0
leaq 0x2b02f6(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x28267e(%rip), %rcx    # 0x30dbc4
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9862a(%rip), %rdi     # 0x123b7f
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b569
popq %rbp
jmp 0x8b1d0
leaq 0x2b02c0(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x28264c(%rip), %rcx    # 0x30dbc8
movl %eax, (%rcx)
cvtsi2sd %eax, %xmm0
leaq 0x281b67(%rip), %rax    # 0x30d0f0
movsd %xmm0, (%rax)
leaq 0x282868(%rip), %rax    # 0x30ddfc
orb $0x1, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98243(%rip), %rdi     # 0x1237e7
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b5b8
popq %rbp
jmp 0x8b1d0
leaq 0x2b0271(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x282601(%rip), %rcx    # 0x30dbcc
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98216(%rip), %rdi     # 0x1237f0
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b5ee
popq %rbp
jmp 0x8b1d0
leaq 0x2b023b(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x2825d7(%rip), %rcx    # 0x30dbd8
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x981e9(%rip), %rdi     # 0x1237f9
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b624
popq %rbp
jmp 0x8b1d0
leaq 0x2b0205(%rip), %rdi    # 0x33b830
callq 0x9470
leaq 0x282599(%rip), %rax    # 0x30dbd0
movsd %xmm0, (%rax)
leaq 0x281176(%rip), %rax    # 0x30c7b8
movsd %xmm0, (%rax)
leaq 0x281beb(%rip), %rax    # 0x30d238
movl $0x4d, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x981a4(%rip), %rdi     # 0x123804
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b674
popq %rbp
jmp 0x8b1d0
leaq 0x2b01b5(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x282559(%rip), %rcx    # 0x30dbe0
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98177(%rip), %rdi     # 0x12380d
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b6aa
popq %rbp
jmp 0x8b1d0
leaq 0x2b017f(%rip), %rdi    # 0x33b830
callq 0x95e0
leaq 0x28251f(%rip), %rcx    # 0x30dbdc
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98153(%rip), %rdi     # 0x12381f
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b6e0
popq %rbp
jmp 0x8b1d0
leaq 0x2b0149(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x2824f1(%rip), %rcx    # 0x30dbe4
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9812f(%rip), %rdi     # 0x123831
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b716
popq %rbp
jmp 0x8b1d0
leaq 0x2b0113(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x2824bf(%rip), %rcx    # 0x30dbe8
movl %eax, (%rcx)
leaq 0x2824b2(%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 0x7d9f5(%rip), %xmm0    # 0x109148
leaq 0x2824c6(%rip), %rax    # 0x30dc20
movsd %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x980af(%rip), %rdi     # 0x12381a
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b77f
popq %rbp
jmp 0x8b1d0
leaq 0x2b00aa(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x28245a(%rip), %rcx    # 0x30dbec
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9808b(%rip), %rdi     # 0x12382c
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b7b5
popq %rbp
jmp 0x8b1d0
leaq 0x2b0074(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x282428(%rip), %rcx    # 0x30dbf0
movl %eax, (%rcx)
leaq 0x28241b(%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 0x7d956(%rip), %xmm0    # 0x109148
leaq 0x282417(%rip), %rax    # 0x30dc10
movsd %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98033(%rip), %rdi     # 0x12383d
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b81e
popq %rbp
jmp 0x8b1d0
leaq 0x2b000b(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x2823c3(%rip), %rcx    # 0x30dbf4
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x98012(%rip), %rdi     # 0x123852
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b854
popq %rbp
jmp 0x8b1d0
leaq 0x2affd5(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x282391(%rip), %rcx    # 0x30dbf8
movl %eax, (%rcx)
leaq 0x282384(%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 0x7d8b7(%rip), %xmm0    # 0x109148
leaq 0x282380(%rip), %rax    # 0x30dc18
movsd %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x97fbd(%rip), %rdi     # 0x123866
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b8bd
popq %rbp
jmp 0x8b1d0
leaq 0x2aff6c(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x28232c(%rip), %rcx    # 0x30dbfc
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x97f9b(%rip), %rdi     # 0x12387a
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b8f3
popq %rbp
jmp 0x8b1d0
leaq 0x2aff36(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x2822fa(%rip), %rcx    # 0x30dc00
movl %eax, (%rcx)
leaq 0x2822ed(%rip), %rcx    # 0x30dbfc
movl (%rcx), %ecx
shll $0x8, %ecx
addl %eax, %ecx
leaq 0x2822eb(%rip), %rax    # 0x30dc08
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x97f61(%rip), %rdi     # 0x12388d
callq 0x58e77
callq 0x8b013
testl %eax, %eax
je 0x8b940
popq %rbp
jmp 0x8b1d0
leaq 0x2afee9(%rip), %rdi    # 0x33b830
callq 0x98c6
leaq 0x2822b1(%rip), %rcx    # 0x30dc04
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ab64a(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8b9d6
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 0x2b0828(%rip), %rbx    # 0x33c220
leaq 0x97eb0(%rip), %rsi     # 0x1238af
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x32a, %esi            # imm = 0x32A
callq 0x5ee52
leaq 0x95c54(%rip), %rdi     # 0x121671
movl $0x33e, %esi            # imm = 0x33E
callq 0x5ee52
leaq 0x95c47(%rip), %rdi     # 0x121675
movl $0x33f, %esi            # imm = 0x33F
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ab5cb(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8ba55
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 0x2b07ab(%rip), %rbx    # 0x33c220
leaq 0x97e38(%rip), %rsi     # 0x1238b4
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x332, %esi            # imm = 0x332
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ab570(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bab0
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 0x7d55d(%rip), %xmm2    # 0x109038
addsd 0x92bb5(%rip), %xmm2    # 0x11e698
divsd 0x7ff25(%rip), %xmm2    # 0x10ba10
cvttsd2si %xmm2, %eax
movl $0x7270df, %edx         # imm = 0x7270DF
cmpl %edx, %eax
cmovll %eax, %edx
leaq 0x2b0720(%rip), %rbx    # 0x33c220
leaq 0x97db4(%rip), %rsi     # 0x1238bb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x328, %esi            # imm = 0x328
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ab4e5(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bb3b
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 0x92b32(%rip), %xmm2    # 0x11e698
divsd 0x7fea2(%rip), %xmm2    # 0x10ba10
cvttsd2si %xmm2, %eax
movl $0xff, %edx
cmpl %edx, %eax
cmovll %eax, %edx
leaq 0x2b069d(%rip), %rbx    # 0x33c220
leaq 0x97d38(%rip), %rsi     # 0x1238c2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x327, %esi            # imm = 0x327
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ab462(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bbbe
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
divsd 0x7fe44(%rip), %xmm0    # 0x10ba10
movsd 0x7fce4(%rip), %xmm1    # 0x10b8b8
maxsd %xmm0, %xmm1
movsd 0x7fce0(%rip), %xmm2    # 0x10b8c0
minsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movsbl %al, %edx
cvttsd2si %xmm0, %eax
testl %eax, %eax
leaq 0x97cd1(%rip), %rax     # 0x1238c9
leaq 0x97cd1(%rip), %rsi     # 0x1238d0
cmovsq %rax, %rsi
leaq 0x2b0616(%rip), %rbx    # 0x33c220
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x331, %esi            # imm = 0x331
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ab3e2(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bc3e
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movsd 0x7fc6c(%rip), %xmm1    # 0x10b8b8
maxsd %xmm0, %xmm1
movsd 0x7fc68(%rip), %xmm2    # 0x10b8c0
minsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movsbl %al, %edx
cvttsd2si %xmm0, %eax
testl %eax, %eax
leaq 0x97c68(%rip), %rax     # 0x1238d8
leaq 0x97c68(%rip), %rsi     # 0x1238df
cmovsq %rax, %rsi
leaq 0x2b059e(%rip), %rbx    # 0x33c220
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x32e, %esi            # imm = 0x32E
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ab36a(%rip), %rax    # 0x33701a
cmpb $0x0, (%rax)
je 0x8bcb6
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
mulsd 0x9248c(%rip), %xmm0    # 0x11e150
divsd 0x7d47c(%rip), %xmm0    # 0x109148
movsd 0x929cc(%rip), %xmm1    # 0x11e6a0
maxsd %xmm0, %xmm1
movsd 0x929a8(%rip), %xmm2    # 0x11e688
minsd %xmm1, %xmm2
cvttsd2si %xmm2, %eax
movswl %ax, %edx
cvttsd2si %xmm0, %eax
testl %eax, %eax
leaq 0x97bef(%rip), %rax     # 0x1238e7
leaq 0x97bef(%rip), %rsi     # 0x1238ee
cmovsq %rax, %rsi
leaq 0x2b0516(%rip), %rbx    # 0x33c220
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
movq %rbx, %rdi
movl $0x329, %esi            # imm = 0x329
callq 0x5ee52
leaq 0x95949(%rip), %rdi     # 0x121671
movl $0x33e, %esi            # imm = 0x33E
callq 0x5ee52
leaq 0x9593c(%rip), %rdi     # 0x121675
movl $0x33f, %esi            # imm = 0x33F
callq 0x5ee52
movl $0x1f8, %edi            # imm = 0x1F8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9d80