LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_rftg_correction()
void parse_rftg_correction()
{
unsigned v2, v4;

   log_packet_id("Packet 0x24 (time/freq corrections)");

   rftg_time_corr = (double) tsip_single();             // time correction
   v2 = (unsigned) tsip_dword();   // age counter

   rftg_freq_corr = (double) tsip_single();             // freq correction
   v4 = (unsigned) tsip_dword();   // age counter

// sprintf(plot_title, "rftg24: %g %d %g %g", rftg_time_corr,v2,rftg_freq_corr,v4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xcba73(%rip), %rdi     # 0x186802
callq 0x7add0
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x2b1e84(%rip), %rax    # 0x36cc28
movsd %xmm0, (%rax)
callq 0x7a680
movl %eax, -0x4(%rbp)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x2b1e70(%rip), %rax    # 0x36cc30
movsd %xmm0, (%rax)
callq 0x7a680
movl %eax, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_rftg_sigs()
void parse_rftg_sigs()
{
int i;
int num_vis;
int num_tracked;
int prn;
float az;
int tracked;
int snr;
int chan;

   // satellite status
   log_packet_id("Packet 0x25 (satellite signals)");

   reset_sat_tracking();
   level_type = "SNR";

   num_vis = tsip_byte();
   num_tracked = tsip_byte();

   for(i=0; i<6; i++) {
      prn = tsip_byte();
      tracked = tsip_byte(); // 08=tracked   0=not tracked
      snr = tsip_byte();
      chan = tsip_byte();    // channel status: A2=tracked and used  01=not tracked
      if((prn >= 1) && (prn <= 32)) {
         az = (float) (prn*10);   // fake the az/el so sat sig levels show in the sat map
         set_sat_azel(prn, az, 20.0F);

         sat[prn].sig_level = (float) snr;
         sat[prn].level_msg = 0x25;
         have_snr |= rinex_gnss(prn);
         if(tracked & 0x08) {
            sat[prn].tracking = prn;
         }
         record_sig_levels(prn);
      }
   }

   tsip_byte();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xcba37(%rip), %rdi     # 0x186826
callq 0x7add0
callq 0x81c10
leaq 0x1e32d8(%rip), %rax    # 0x29e0d8
leaq 0xc7c0f(%rip), %rcx     # 0x182a16
movq %rcx, (%rax)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x8(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x6, -0x4(%rbp)
jge 0xbaf2b
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x10(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x18(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x20(%rbp)
cmpl $0x1, -0x10(%rbp)
jl 0xbaf1b
cmpl $0x20, -0x10(%rbp)
jg 0xbaf1b
imull $0xa, -0x10(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x14(%rbp)
movl -0x10(%rbp), %edi
movss -0x14(%rbp), %xmm0
movss 0xc850e(%rip), %xmm1    # 0x18339c
callq 0x7d450
cvtsi2ssl -0x1c(%rbp), %xmm0
movslq -0x10(%rbp), %rcx
leaq 0x1e32ed(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movss %xmm0, 0x20(%rax)
movslq -0x10(%rbp), %rcx
leaq 0x1e32d3(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movl $0x25, 0x1c(%rax)
movl -0x10(%rbp), %edi
callq 0x12d280
movl %eax, %ecx
leaq 0x2b164d(%rip), %rax    # 0x36c52c
orl (%rax), %ecx
leaq 0x2b1644(%rip), %rax    # 0x36c52c
movl %ecx, (%rax)
movl -0x18(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xbaf13
movl -0x10(%rbp), %ecx
movslq -0x10(%rbp), %rdx
leaq 0x1e328d(%rip), %rax    # 0x29e190
imulq $0x348, %rdx, %rdx      # imm = 0x348
addq %rdx, %rax
movl %ecx, 0x218(%rax)
movl -0x10(%rbp), %edi
callq 0x80340
jmp 0xbaf1d
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xbae27
callq 0x7a510
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_rftg_posn()
void parse_rftg_posn()
{
int i;
double v1,v2,v3;

   // rcvr posn
   log_packet_id("Packet 0x26 (position)");

   for(i=0; i<5; i++) {  // 5 sets of values RCVR, AVG. NVM0, NVM1, NVM2
       v1 = (double) (s32) tsip_dword();
       v2 = (double) (s32) tsip_dword();
       v3 = (double) (s32) tsip_dword();
       if(i == 0) {
          lat = (v1 / 3600000.0) * PI / 180.0;
          lon = (v2 / 3600000.0) * PI / 180.0;
          alt = (v3 / 100.0);
          have_rftg_lla = 1;
       }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xcb8f7(%rip), %rdi     # 0x186846
callq 0x7add0
movl $0x0, -0x4(%rbp)
cmpl $0x5, -0x4(%rbp)
jge 0xbb03a
callq 0x7a680
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x10(%rbp)
callq 0x7a680
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x7a680
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xbb02a
movsd -0x10(%rbp), %xmm0
movsd 0xc7c22(%rip), %xmm1    # 0x182bc8
divsd %xmm1, %xmm0
movsd 0xb6616(%rip), %xmm1    # 0x1715c8
mulsd %xmm1, %xmm0
movsd 0xb40ba(%rip), %xmm1    # 0x16f078
divsd %xmm1, %xmm0
leaq 0x2b11e7(%rip), %rax    # 0x36c1b0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movsd 0xc7bee(%rip), %xmm1    # 0x182bc8
divsd %xmm1, %xmm0
movsd 0xb65e2(%rip), %xmm1    # 0x1715c8
mulsd %xmm1, %xmm0
movsd 0xb4086(%rip), %xmm1    # 0x16f078
divsd %xmm1, %xmm0
leaq 0x2b11bb(%rip), %rax    # 0x36c1b8
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd 0xb4042(%rip), %xmm1    # 0x16f050
divsd %xmm1, %xmm0
leaq 0x2b11a7(%rip), %rax    # 0x36c1c0
movsd %xmm0, (%rax)
leaq 0x2b1c5c(%rip), %rax    # 0x36cc80
movl $0x1, (%rax)
jmp 0xbb02c
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xbaf5b
addq $0x20, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_rftg_additional_status()
void parse_rftg_additional_status()
{
int fw;

   log_packet_id("Packet 0x27 (additional status)");

   fw = tsip_word();  // fw version

   tsip_byte();  //
   tsip_byte();  //
   tsip_byte();  //
// maybe valid float seen here
   tsip_byte();  //
   tsip_byte();  //
// valid float seen here
   tsip_byte();  //
   tsip_byte();  //
   tsip_byte();  //
   tsip_byte();  //
   tsip_byte();  //

   rftg_sensitivity = (double) tsip_single(); // sensitivity
   rftg_pll_port = tsip_byte();   // pll status port
   rftg_pld_port = tsip_byte();   // pld status port
   tsip_byte();  //

// sprintf(debug_text, "adds:%g  pll:%02x pld:%02x", rftg_sensitivity, rftg_pll_port,rftg_pld_port);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xcb80e(%rip), %rdi     # 0x18685d
callq 0x7add0
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x2b1b6f(%rip), %rax    # 0x36cc10
movsd %xmm0, (%rax)
callq 0x7a510
movzbl %al, %ecx
leaq 0x2b1bc4(%rip), %rax    # 0x36cc78
movl %ecx, (%rax)
callq 0x7a510
movzbl %al, %ecx
leaq 0x2b1bb7(%rip), %rax    # 0x36cc7c
movl %ecx, (%rax)
callq 0x7a510
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_rftg_cable()
void parse_rftg_cable()
{
float val;

   // cable delay in feet
   log_packet_id("Packet 0x55 (cable delay)");

   val = tsip_single();
   cable_delay = (double) val;  // cable delay in feet
   cable_delay = cable_delay / 1.0E9;
   cable_delay /= VELOCITY_FACTOR;  // cable delay in nanoseconds
   have_cable_delay = 1;
//sprintf(debug_text3, "rftg55: %f  %f", val, cable_delay);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xcb785(%rip), %rdi     # 0x1868b4
callq 0x7add0
callq 0x7a860
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x2b1e5a(%rip), %rax    # 0x36cfa8
movsd %xmm0, (%rax)
leaq 0x2b1e4f(%rip), %rax    # 0x36cfa8
movsd (%rax), %xmm0
movsd 0xb3ec3(%rip), %xmm1    # 0x16f028
divsd %xmm1, %xmm0
leaq 0x2b1e38(%rip), %rax    # 0x36cfa8
movsd %xmm0, (%rax)
leaq 0x2b1e2d(%rip), %rax    # 0x36cfa8
movsd (%rax), %xmm0
movsd 0xb6551(%rip), %xmm1    # 0x1716d8
divsd %xmm1, %xmm0
leaq 0x2b1e16(%rip), %rax    # 0x36cfa8
movsd %xmm0, (%rax)
leaq 0x2b12f7(%rip), %rax    # 0x36c494
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 0xcb70b(%rip), %rdi     # 0x1868e6
callq 0x7add0
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2dade8(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbb419
jmp 0xbb43a
xorl %edi, %edi
callq 0x8af90
movl $0x31, %edi
callq 0x824f0
movl -0x4(%rbp), %eax
movzbl %al, %edi
callq 0x7b210
callq 0x82590
addq $0x10, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x4(%rbp)
leaq 0x2dada6(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbb45b
jmp 0xbb485
xorl %edi, %edi
callq 0x8af90
movl $0x30, %edi
callq 0x824f0
movl $0x1, %edi
callq 0x7b210
movss -0x4(%rbp), %xmm0
callq 0x7b600
callq 0x82590
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x4(%rbp)
leaq 0x2dad56(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbb4ab
jmp 0xbb4d5
xorl %edi, %edi
callq 0x8af90
movl $0x30, %edi
callq 0x824f0
movl $0x2, %edi
callq 0x7b210
movss -0x4(%rbp), %xmm0
callq 0x7b600
callq 0x82590
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
leaq 0x2dad0f(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbb4f2
jmp 0xbb51e
xorl %edi, %edi
callq 0x8af90
movl $0x30, %edi
callq 0x824f0
movl $0x4, %edi
callq 0x7b210
xorl %edi, %edi
callq 0x7b520
callq 0x82590
callq 0x8b030
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
leaq 0x2daccf(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbb532
jmp 0xbb55e
xorl %edi, %edi
callq 0x8af90
movl $0x30, %edi
callq 0x824f0
movl $0x5, %edi
callq 0x7b210
xorl %edi, %edi
callq 0x7b520
callq 0x82590
callq 0x8b030
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbc398
jmp 0xbc3df
movq -0x8(%rbp), %rdi
callq 0x9120
movl %eax, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xbc3cf
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %edi
callq 0x96330
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbc3ab
cmpl $0x0, -0xc(%rbp)
je 0xbc3df
movl $0x2c, %edi
callq 0x96330
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq -0xe(%rbp), %rdi
movzbl 0x30f890(%rip), %edx    # 0x3cbc96
andl $0xff, %edx
leaq 0xd1a73(%rip), %rsi     # 0x18de86
movb $0x0, %al
callq 0x9060
cmpl $0x0, -0x4(%rbp)
je 0xbc43c
movl $0x2a, %edi
callq 0x96330
movzbl -0xe(%rbp), %edi
callq 0x96330
movzbl -0xd(%rbp), %edi
callq 0x96330
movl $0xd, %edi
callq 0x96330
movl $0xa, %edi
callq 0x96330
leaq 0x1e1149(%rip), %rax    # 0x29d5a0
cmpq $0x0, (%rax)
jne 0xbc467
movl $0x32, %edi
callq 0xb8b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbc485
jmp 0xbc4f6
leaq 0x1e10b4(%rip), %rax    # 0x29d540
cmpq $0x0, (%rax)
je 0xbc4bf
leaq 0x1e1157(%rip), %rax    # 0x29d5f0
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xbc4bf
leaq 0x1e1096(%rip), %rax    # 0x29d540
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xca567(%rip), %rsi     # 0x186a1f
movb $0x0, %al
callq 0x9550
callq 0xbc360
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xbc380
movq -0x8(%rbp), %rdi
movl $0x2a, %esi
callq 0x9100
cmpq $0x0, %rax
je 0xbc4ec
xorl %edi, %edi
callq 0xbc3f0
jmp 0xbc4f6
movl $0x1, %edi
callq 0xbc3f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
leaq 0xc9e5d(%rip), %rdi     # 0x186a48
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xbcc76
leaq 0x2de01f(%rip), %rdi    # 0x39ac20
callq 0x9890
leaq 0x2de013(%rip), %rax    # 0x39ac20
movsbl (%rax), %eax
cmpl $0x50, %eax
jne 0xbcc32
leaq 0x2de004(%rip), %rdi    # 0x39ac20
addq $0x1, %rdi
callq 0x95c0
movl %eax, %ecx
leaq 0x2de402(%rip), %rax    # 0x39b030
movl %ecx, (%rax)
jmp 0xbcc69
leaq 0x2ddfe7(%rip), %rdi    # 0x39ac20
leaq 0xc9e15(%rip), %rsi     # 0x186a55
callq 0x9090
cmpq $0x0, %rax
je 0xbcc5a
leaq 0x2de3de(%rip), %rax    # 0x39b030
movl $0x3e8, (%rax)          # imm = 0x3E8
jmp 0xbcc67
leaq 0x2de3cf(%rip), %rax    # 0x39b030
movl $0x0, (%rax)
jmp 0xbcc69
leaq 0x2de3c4(%rip), %rax    # 0x39b034
movl $0x1, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xbccd9
leaq 0x2ddf99(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x2de3a3(%rip), %rax    # 0x39b038
movl %ecx, (%rax)
leaq 0x2de39a(%rip), %rax    # 0x39b038
cmpl $0x0, (%rax)
jge 0xbccb2
leaq 0x2b024e(%rip), %rax    # 0x36cef8
movl $0x1, (%rax)
jmp 0xbccbf
leaq 0x2b023f(%rip), %rax    # 0x36cef8
movl $0x0, (%rax)
leaq 0x2af7fa(%rip), %rax    # 0x36c4c0
movl $0x16, (%rax)
leaq 0x2de369(%rip), %rax    # 0x39b03c
movl $0x1, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 0xc9d72(%rip), %rdi     # 0x186a5d
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xbcd21
leaq 0x2ddf1f(%rip), %rax    # 0x39ac20
movb (%rax), %cl
leaq 0x2de336(%rip), %rax    # 0x39b040
movb %cl, (%rax)
leaq 0x2de331(%rip), %rax    # 0x39b044
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x2de325(%rip), %rax    # 0x39b044
movl %ecx, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xbcdfa
leaq 0x2ddeea(%rip), %rax    # 0x39ac20
movb (%rax), %cl
leaq 0x2de302(%rip), %rax    # 0x39b041
movb %cl, (%rax)
leaq 0x2de2f9(%rip), %rax    # 0x39b041
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0xbcd69
leaq 0x2b01a9(%rip), %rax    # 0x36cf00
movb $0x0, (%rax)
leaq 0x2af75b(%rip), %rax    # 0x36c4bc
movl $0x1e, (%rax)
jmp 0xbcde5
leaq 0x2de2d1(%rip), %rax    # 0x39b041
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0xbcd91
leaq 0x2b0181(%rip), %rax    # 0x36cf00
movb $0x0, (%rax)
leaq 0x2af733(%rip), %rax    # 0x36c4bc
movl $0x1f, (%rax)
jmp 0xbcde3
leaq 0x2de2a9(%rip), %rax    # 0x39b041
movsbl (%rax), %eax
cmpl $0x32, %eax
jne 0xbcdb9
leaq 0x2b0159(%rip), %rax    # 0x36cf00
movb $0x1, (%rax)
leaq 0x2af70b(%rip), %rax    # 0x36c4bc
movl $0x1f, (%rax)
jmp 0xbcde1
leaq 0x2de281(%rip), %rax    # 0x39b041
movsbl (%rax), %eax
cmpl $0x33, %eax
jne 0xbcddf
leaq 0x2b0131(%rip), %rax    # 0x36cf00
movb $0x1, (%rax)
leaq 0x2af6e3(%rip), %rax    # 0x36c4bc
movl $0x20, (%rax)
jmp 0xbcde1
jmp 0xbcde3
jmp 0xbcde5
leaq 0x2de258(%rip), %rax    # 0x39b044
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x2de24c(%rip), %rax    # 0x39b044
movl %ecx, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xbce2b
leaq 0x2dde15(%rip), %rax    # 0x39ac20
movb (%rax), %cl
leaq 0x2de22e(%rip), %rax    # 0x39b042
movb %cl, (%rax)
leaq 0x2de227(%rip), %rax    # 0x39b044
movl (%rax), %ecx
orl $0x4, %ecx
leaq 0x2de21b(%rip), %rax    # 0x39b044
movl %ecx, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xbce5c
leaq 0x2ddde4(%rip), %rax    # 0x39ac20
movb (%rax), %cl
leaq 0x2de1fe(%rip), %rax    # 0x39b043
movb %cl, (%rax)
leaq 0x2de1f6(%rip), %rax    # 0x39b044
movl (%rax), %ecx
orl $0x8, %ecx
leaq 0x2de1ea(%rip), %rax    # 0x39b044
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: 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 0xc969e(%rip), %rdi     # 0x186a89
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xbd418
leaq 0x2dd81f(%rip), %rax    # 0x39ac20
movb $0x0, 0x20(%rax)
leaq 0x2dda24(%rip), %rdi    # 0x39ae30
leaq 0x2dd80d(%rip), %rsi    # 0x39ac20
callq 0x9350
callq 0xb0bd0
cmpl $0x0, %eax
je 0xbd440
leaq 0x2dd7f7(%rip), %rax    # 0x39ac20
movb $0x0, 0x20(%rax)
leaq 0x2dda7c(%rip), %rdi    # 0x39aeb0
leaq 0x2dd7e5(%rip), %rsi    # 0x39ac20
callq 0x9350
callq 0xb0bd0
cmpl $0x0, %eax
je 0xbd468
leaq 0x2dd7cf(%rip), %rax    # 0x39ac20
movb $0x0, 0x20(%rax)
leaq 0x2ddad4(%rip), %rdi    # 0x39af30
leaq 0x2dd7bd(%rip), %rsi    # 0x39ac20
callq 0x9350
leaq 0x2af6e5(%rip), %rax    # 0x36cb54
movl (%rax), %ecx
orl $0x6, %ecx
leaq 0x2af6d9(%rip), %rax    # 0x36cb54
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
callq 0xb0bd0
cmpl $0x0, %eax
jne 0xbd4d7
jmp 0xbd55d
leaq 0x2dd742(%rip), %rax    # 0x39ac20
movsbl (%rax), %edi
callq 0x96e0
movl %eax, -0x4(%rbp)
cmpl $0x41, -0x4(%rbp)
jne 0xbd4f6
callq 0xbc750
jmp 0xbd55d
cmpl $0x43, -0x4(%rbp)
jne 0xbd503
callq 0xbcbe0
jmp 0xbd55b
cmpl $0x45, -0x4(%rbp)
jne 0xbd510
callq 0xbcce0
jmp 0xbd559
cmpl $0x46, -0x4(%rbp)
jne 0xbd51d
callq 0xbce60
jmp 0xbd557
cmpl $0x4a, -0x4(%rbp)
jne 0xbd52a
callq 0xbd190
jmp 0xbd555
cmpl $0x4e, -0x4(%rbp)
jne 0xbd537
callq 0xbd3e0
jmp 0xbd553
cmpl $0x4f, -0x4(%rbp)
jne 0xbd544
callq 0xbd480
jmp 0xbd551
cmpl $0x5a, -0x4(%rbp)
jne 0xbd54f
callq 0xbd4a0
jmp 0xbd551
jmp 0xbd553
jmp 0xbd555
jmp 0xbd557
jmp 0xbd559
jmp 0xbd55b
jmp 0xbd55d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: valid_sro_status()
int valid_sro_status()
{
int hh;
int gg;
int ff;
int ee;
int dd;
int cc;
int bb;
int aa;
int i;

   // return true if nmea_msg scans 8 hex values

   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?
      return 0;
   }

   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
leaq 0x2dcb00(%rip), %rdi    # 0x39aa10
leaq 0xc8c15(%rip), %rsi     # 0x186b2c
leaq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rcx
leaq -0x18(%rbp), %r8
leaq -0x1c(%rbp), %r9
leaq -0x20(%rbp), %rbx
leaq -0x24(%rbp), %r11
leaq -0x28(%rbp), %r10
leaq -0x2c(%rbp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x9370
movl %eax, -0x30(%rbp)
cmpl $0x8, -0x30(%rbp)
je 0xbdf63
movl $0x0, -0xc(%rbp)
jmp 0xbdf6a
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbx
subq $0x48, %rsp
leaq 0xc8bb4(%rip), %rdi     # 0x186b44
callq 0x7add0
leaq 0x2dca74(%rip), %rdi    # 0x39aa10
leaq 0xc8b89(%rip), %rsi     # 0x186b2c
leaq -0xc(%rbp), %rdx
leaq -0x10(%rbp), %rcx
leaq -0x14(%rbp), %r8
leaq -0x18(%rbp), %r9
leaq -0x1c(%rbp), %rbx
leaq -0x20(%rbp), %r11
leaq -0x24(%rbp), %r10
leaq -0x28(%rbp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x9370
movl %eax, -0x2c(%rbp)
cmpl $0x8, -0x2c(%rbp)
je 0xbdff0
callq 0xbe120
jmp 0xbe115
cvtsi2sdl -0xc(%rbp), %xmm0
movsd 0xc5023(%rip), %xmm1    # 0x183020
divsd %xmm1, %xmm0
movsd 0xb1157(%rip), %xmm1    # 0x16f160
mulsd %xmm1, %xmm0
leaq 0x2aed34(%rip), %rax    # 0x36cd48
movsd %xmm0, (%rax)
cvtsi2sdl -0x10(%rbp), %xmm0
leaq 0x2aed2c(%rip), %rax    # 0x36cd50
movsd %xmm0, (%rax)
cvtsi2sdl -0x14(%rbp), %xmm0
movsd 0xc4feb(%rip), %xmm1    # 0x183020
divsd %xmm1, %xmm0
movsd 0xb111f(%rip), %xmm1    # 0x16f160
mulsd %xmm1, %xmm0
leaq 0x2aed0c(%rip), %rax    # 0x36cd58
movsd %xmm0, (%rax)
movl $0xff, %eax
subl -0x18(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd 0xc4fbc(%rip), %xmm1    # 0x183020
divsd %xmm1, %xmm0
movsd 0xb10f0(%rip), %xmm1    # 0x16f160
mulsd %xmm1, %xmm0
leaq 0x2aece5(%rip), %rax    # 0x36cd60
movsd %xmm0, (%rax)
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd 0xc4f94(%rip), %xmm1    # 0x183020
divsd %xmm1, %xmm0
movsd 0xb10c8(%rip), %xmm1    # 0x16f160
mulsd %xmm1, %xmm0
leaq 0x2aecc5(%rip), %rax    # 0x36cd68
movsd %xmm0, (%rax)
movl $0xff, %eax
subl -0x20(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd 0xc4f65(%rip), %xmm1    # 0x183020
divsd %xmm1, %xmm0
movsd 0xb0f89(%rip), %xmm1    # 0x16f050
mulsd %xmm1, %xmm0
leaq 0x2aec9e(%rip), %rax    # 0x36cd70
movsd %xmm0, (%rax)
movl $0xff, %eax
subl -0x24(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd 0xc4f36(%rip), %xmm1    # 0x183020
divsd %xmm1, %xmm0
movsd 0xb0f5a(%rip), %xmm1    # 0x16f050
mulsd %xmm1, %xmm0
leaq 0x2aec77(%rip), %rax    # 0x36cd78
movsd %xmm0, (%rax)
cvtsi2sdl -0x28(%rbp), %xmm0
leaq 0x2aec6f(%rip), %rax    # 0x36cd80
movsd %xmm0, (%rax)
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: 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
movl $0x0, 0x31107e(%rip)    # 0x3cf1ac
movl $0xa, %edi
callq 0x79900
movl $0x0, 0x311062(%rip)    # 0x3cf1a4
movl $0x0, 0x311054(%rip)    # 0x3cf1a0
movl $0x0, 0x311052(%rip)    # 0x3cf1a8
movl $0x0, 0x30dc70(%rip)    # 0x3cbdd0
movl $0x0, 0x30dc72(%rip)    # 0x3cbddc
movl $0x0, 0x30dc64(%rip)    # 0x3cbdd8
movl $0x0, 0x30dc32(%rip)    # 0x3cbdb0
movl $0x0, 0x30dc58(%rip)    # 0x3cbde0
movl $0x0, 0x30dc52(%rip)    # 0x3cbde4
movl $0x0, 0x30dc38(%rip)    # 0x3cbdd4
leaq 0x1bc065(%rip), %rax    # 0x27a208
movl $0x0, (%rax)
leaq 0x2d9286(%rip), %rax    # 0x397436
movw $0x0, (%rax)
leaq 0x2d9276(%rip), %rax    # 0x397432
movw $0x0, (%rax)
leaq 0x2d926c(%rip), %rax    # 0x397434
movw $0x0, (%rax)
leaq 0x2d801c(%rip), %rax    # 0x3961f0
movl $0x0, (%rax)
popq %rbp
retq
nopl (%rax)
// File: 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 0xc8962(%rip), %rdi     # 0x186b4d
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe201
callq 0xbe120
jmp 0xbe23d
leaq 0x2dc808(%rip), %rax    # 0x39aa10
movb $0x0, 0x15(%rax)
leaq 0x2aeadd(%rip), %rdi    # 0x36ccf0
leaq 0x2dc7f6(%rip), %rsi    # 0x39aa10
callq 0x9350
cmpl $0x0, 0x30cd82(%rip)    # 0x3cafa8
je 0xbe23d
leaq 0x2ae925(%rip), %rax    # 0x36cb54
movl (%rax), %ecx
orl $0x6, %ecx
leaq 0x2ae919(%rip), %rax    # 0x36cb54
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: 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 0xc890a(%rip), %rdi     # 0x186b55
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe261
callq 0xbe120
jmp 0xbe29d
leaq 0x2dc7a8(%rip), %rax    # 0x39aa10
movb $0x0, 0x12(%rax)
leaq 0x2aeaad(%rip), %rdi    # 0x36cd20
leaq 0x2dc796(%rip), %rsi    # 0x39aa10
callq 0x9350
cmpl $0x0, 0x30cd22(%rip)    # 0x3cafa8
je 0xbe29d
leaq 0x2ae8c5(%rip), %rax    # 0x36cb54
movl (%rax), %ecx
orl $0x3, %ecx
leaq 0x2ae8b9(%rip), %rax    # 0x36cb54
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: 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 0xcab9a(%rip), %rdi     # 0x188e45
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe2c1
callq 0xbe120
jmp 0xbe32c
leaq 0x2dc748(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2aea6e(%rip), %rax    # 0x36cd44
movl %ecx, (%rax)
leaq 0x2ae398(%rip), %rax    # 0x36c677
movb $0x0, (%rax)
leaq 0x2aea5b(%rip), %rax    # 0x36cd44
cmpl $0x0, (%rax)
jne 0xbe2fa
leaq 0x2ae382(%rip), %rax    # 0x36c677
movb $0xa, (%rax)
jmp 0xbe32c
leaq 0x2aea43(%rip), %rax    # 0x36cd44
cmpl $0x1, (%rax)
jne 0xbe312
leaq 0x2ae36a(%rip), %rax    # 0x36c677
movb $0x14, (%rax)
jmp 0xbe32a
leaq 0x2aea2b(%rip), %rax    # 0x36cd44
cmpl $0x9, (%rax)
jne 0xbe328
leaq 0x2ae352(%rip), %rax    # 0x36c677
movb $0x19, (%rax)
jmp 0xbe32a
jmp 0xbe32c
popq %rbp
retq
nop
// File: 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 0xc8828(%rip), %rdi     # 0x186b63
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe351
callq 0xbe120
jmp 0xbe368
leaq 0x2dc6b8(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2aea22(%rip), %rax    # 0x36cd88
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 0xc87f1(%rip), %rdi     # 0x186b6c
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe391
callq 0xbe120
jmp 0xbe3a8
leaq 0x2dc678(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae9e6(%rip), %rax    # 0x36cd8c
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 0xbb6e5(%rip), %rdi     # 0x179aa0
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe3d1
callq 0xbe120
jmp 0xbe3e8
leaq 0x2dc638(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae9aa(%rip), %rax    # 0x36cd90
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 0xc877a(%rip), %rdi     # 0x186b75
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe411
callq 0xbe120
jmp 0xbe44a
leaq 0x2dc5f8(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae96e(%rip), %rax    # 0x36cd94
movl %ecx, (%rax)
leaq 0x2ae965(%rip), %rax    # 0x36cd94
cmpl $0x0, (%rax)
je 0xbe440
leaq 0x2aeac5(%rip), %rax    # 0x36cf00
movb $0x1, (%rax)
jmp 0xbe44a
leaq 0x2aeab9(%rip), %rax    # 0x36cf00
movb $0x0, (%rax)
popq %rbp
retq
nopl (%rax)
// File: 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 0xc8725(%rip), %rdi     # 0x186b80
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe471
callq 0xbe120
jmp 0xbe4cf
leaq 0x2dc598(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae912(%rip), %rax    # 0x36cd98
movl %ecx, (%rax)
leaq 0x2ae909(%rip), %rax    # 0x36cd98
cvtsi2sdl (%rax), %xmm0
movsd 0xb0cdd(%rip), %xmm1    # 0x16f178
mulsd %xmm1, %xmm0
movsd 0xb0cc9(%rip), %xmm1    # 0x16f170
mulsd %xmm1, %xmm0
movsd 0xb0b7d(%rip), %xmm1    # 0x16f030
divsd %xmm1, %xmm0
leaq 0x2ad4e2(%rip), %rax    # 0x36b9a0
movsd %xmm0, (%rax)
leaq 0x2adf4b(%rip), %rax    # 0x36c414
movl $0x4d, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc86a8(%rip), %rdi     # 0x186b93
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe501
callq 0xbe120
jmp 0xbe518
leaq 0x2dc508(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae886(%rip), %rax    # 0x36cd9c
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 0xc8671(%rip), %rdi     # 0x186b9c
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe541
callq 0xbe120
jmp 0xbe558
leaq 0x2dc4c8(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae84a(%rip), %rax    # 0x36cda0
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 0xc863a(%rip), %rdi     # 0x186ba5
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe581
callq 0xbe120
jmp 0xbe598
leaq 0x2dc488(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae80e(%rip), %rax    # 0x36cda4
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 0xc899b(%rip), %rdi     # 0x186f46
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe5c1
callq 0xbe120
jmp 0xbe603
leaq 0x2dc448(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae7d2(%rip), %rax    # 0x36cda8
movl %ecx, (%rax)
leaq 0x2ae7c9(%rip), %rax    # 0x36cda8
cvtsi2sdl (%rax), %xmm0
leaq 0x2adce6(%rip), %rax    # 0x36c2d0
movsd %xmm0, (%rax)
leaq 0x2ae9e7(%rip), %rax    # 0x36cfdc
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x2ae9db(%rip), %rax    # 0x36cfdc
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc8593(%rip), %rdi     # 0x186bae
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe631
callq 0xbe120
jmp 0xbe648
leaq 0x2dc3d8(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae766(%rip), %rax    # 0x36cdac
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 0xc855c(%rip), %rdi     # 0x186bb7
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe671
callq 0xbe120
jmp 0xbe688
leaq 0x2dc398(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae732(%rip), %rax    # 0x36cdb8
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 0xc8525(%rip), %rdi     # 0x186bc0
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe6b1
callq 0xbe120
jmp 0xbe6eb
leaq 0x2dc358(%rip), %rdi    # 0x39aa10
callq 0x9480
leaq 0x2ae6ec(%rip), %rax    # 0x36cdb0
movsd %xmm0, (%rax)
leaq 0x2ae6e1(%rip), %rax    # 0x36cdb0
movsd (%rax), %xmm0
leaq 0x2ad2be(%rip), %rax    # 0x36b998
movsd %xmm0, (%rax)
leaq 0x2add33(%rip), %rax    # 0x36c418
movl $0x4d, (%rax)
popq %rbp
retq
nopl (%rax)
// File: 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 0xc84d0(%rip), %rdi     # 0x186bcb
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe711
callq 0xbe120
jmp 0xbe728
leaq 0x2dc2f8(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae69a(%rip), %rax    # 0x36cdc0
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 0xc8499(%rip), %rdi     # 0x186bd4
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe751
callq 0xbe120
jmp 0xbe768
leaq 0x2dc2b8(%rip), %rdi    # 0x39aa10
callq 0x95c0
movl %eax, %ecx
leaq 0x2ae656(%rip), %rax    # 0x36cdbc
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 0xc846b(%rip), %rdi     # 0x186be6
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe791
callq 0xbe120
jmp 0xbe7a8
leaq 0x2dc278(%rip), %rdi    # 0x39aa10
callq 0x98d0
movl %eax, %ecx
leaq 0x2ae61e(%rip), %rax    # 0x36cdc4
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
leaq 0xc8439(%rip), %rdi     # 0x186bf8
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe7d5
callq 0xbe120
jmp 0xbe83e
leaq 0x2dc234(%rip), %rdi    # 0x39aa10
callq 0x98d0
movl %eax, %ecx
leaq 0x2ae5de(%rip), %rax    # 0x36cdc8
movl %ecx, (%rax)
leaq 0x2ae5d1(%rip), %rax    # 0x36cdc4
movl (%rax), %eax
shll $0x8, %eax
leaq 0x2ae5c9(%rip), %rcx    # 0x36cdc8
addl (%rcx), %eax
movl %eax, -0x4(%rbp)
leaq 0x2ae5b9(%rip), %rax    # 0x36cdc4
movl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xbe822
movl $0x7fff, %eax           # imm = 0x7FFF
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0xb0949(%rip), %xmm0    # 0x16f178
mulsd %xmm1, %xmm0
leaq 0x2ae5c6(%rip), %rax    # 0x36ce00
movsd %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc8386(%rip), %rdi     # 0x186be1
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe871
callq 0xbe120
jmp 0xbe888
leaq 0x2dc198(%rip), %rdi    # 0x39aa10
callq 0x98d0
movl %eax, %ecx
leaq 0x2ae546(%rip), %rax    # 0x36cdcc
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
leaq 0xc8354(%rip), %rdi     # 0x186bf3
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe8b5
callq 0xbe120
jmp 0xbe91e
leaq 0x2dc154(%rip), %rdi    # 0x39aa10
callq 0x98d0
movl %eax, %ecx
leaq 0x2ae506(%rip), %rax    # 0x36cdd0
movl %ecx, (%rax)
leaq 0x2ae4f9(%rip), %rax    # 0x36cdcc
movl (%rax), %eax
shll $0x8, %eax
leaq 0x2ae4f1(%rip), %rcx    # 0x36cdd0
addl (%rcx), %eax
movl %eax, -0x4(%rbp)
leaq 0x2ae4e1(%rip), %rax    # 0x36cdcc
movl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xbe902
movl $0x7fff, %eax           # imm = 0x7FFF
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0xb0869(%rip), %xmm0    # 0x16f178
mulsd %xmm1, %xmm0
leaq 0x2ae4d6(%rip), %rax    # 0x36cdf0
movsd %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc82c9(%rip), %rdi     # 0x186c04
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe951
callq 0xbe120
jmp 0xbe968
leaq 0x2dc0b8(%rip), %rdi    # 0x39aa10
callq 0x98d0
movl %eax, %ecx
leaq 0x2ae46e(%rip), %rax    # 0x36cdd4
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
leaq 0xc829a(%rip), %rdi     # 0x186c19
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbe995
callq 0xbe120
jmp 0xbe9fe
leaq 0x2dc074(%rip), %rdi    # 0x39aa10
callq 0x98d0
movl %eax, %ecx
leaq 0x2ae42e(%rip), %rax    # 0x36cdd8
movl %ecx, (%rax)
leaq 0x2ae421(%rip), %rax    # 0x36cdd4
movl (%rax), %eax
shll $0x8, %eax
leaq 0x2ae419(%rip), %rcx    # 0x36cdd8
addl (%rcx), %eax
movl %eax, -0x4(%rbp)
leaq 0x2ae409(%rip), %rax    # 0x36cdd4
movl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xbe9e2
movl $0x7fff, %eax           # imm = 0x7FFF
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm1
movsd 0xb0789(%rip), %xmm0    # 0x16f178
mulsd %xmm1, %xmm0
leaq 0x2ae3fe(%rip), %rax    # 0x36cdf8
movsd %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc8212(%rip), %rdi     # 0x186c2d
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbea31
callq 0xbe120
jmp 0xbea48
leaq 0x2dbfd8(%rip), %rdi    # 0x39aa10
callq 0x98d0
movl %eax, %ecx
leaq 0x2ae396(%rip), %rax    # 0x36cddc
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
leaq 0xc81e2(%rip), %rdi     # 0x186c41
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbea75
callq 0xbe120
jmp 0xbeab0
leaq 0x2dbf94(%rip), %rdi    # 0x39aa10
callq 0x98d0
movl %eax, %ecx
leaq 0x2ae356(%rip), %rax    # 0x36cde0
movl %ecx, (%rax)
leaq 0x2ae349(%rip), %rax    # 0x36cddc
movl (%rax), %eax
shll $0x8, %eax
leaq 0x2ae341(%rip), %rcx    # 0x36cde0
addl (%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
leaq 0x2ae33a(%rip), %rax    # 0x36cde8
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0xc8189(%rip), %rdi     # 0x186c54
callq 0x7add0
callq 0xbdf00
cmpl $0x0, %eax
je 0xbeae1
callq 0xbe120
jmp 0xbeaf8
leaq 0x2dbf28(%rip), %rdi    # 0x39aa10
callq 0x98d0
movl %eax, %ecx
leaq 0x2ae2ee(%rip), %rax    # 0x36cde4
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2d7648(%rip), %rax    # 0x3961fa
cmpb $0x0, (%rax)
je 0xbebb9
jmp 0xbec23
cmpl $0x0, -0x4(%rbp)
jge 0xbebc6
movl $0x0, -0x4(%rbp)
cmpl $0x3, -0x4(%rbp)
jle 0xbebd3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %edx
leaq 0x2dc823(%rip), %rdi    # 0x39b400
leaq 0xc8092(%rip), %rsi     # 0x186c76
movb $0x0, %al
callq 0x9060
leaq 0x2dc80e(%rip), %rdi    # 0x39b400
movl $0x32a, %esi            # imm = 0x32A
callq 0x82fd0
leaq 0xc5dde(%rip), %rdi     # 0x1849e1
movl $0x33e, %esi            # imm = 0x33E
callq 0x82fd0
leaq 0xc5dd1(%rip), %rdi     # 0x1849e5
movl $0x33f, %esi            # imm = 0x33F
callq 0x82fd0
callq 0xbeb90
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)