LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_gprmc(int)
void parse_gprmc(int system)
{
   if((system & system_mask) == 0) return;

   last_was_gsv = 0;
   have_gprmc = system;

   if(TIME_FILTER && have_gpzda) get_msg_field();
   else                          get_nmea_time();

   get_msg_field();  // active flag A=good  V=invalid fix

   if(msg_field[0] == 'A') {
      get_nmea_lat();
      get_nmea_lon();

      if(get_msg_field()) {  // speed (km/hr)
         speed = atof(msg_field) * 0.514444;
         have_speed = 4;
      }
      if(get_msg_field()) {  // course angle
         heading = atof(msg_field);
         have_heading = 4;
      }

      if(rcvr_type == BRANDY_RCVR) return;  // Brandywine gets date/time from a different message

      if(TIME_FILTER && have_gpzda && (have_nmea_date == 0x07)) get_msg_field();
      else get_nmea_date();
   }

   check_nmea_date();

   if(TIME_FILTER && have_gpzda) ;
   else drive_nmea_screen(system, NMEA_RMC);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x11dd9b(%rip), %rcx    # 0x1cfe50
andl (%rcx), %eax
cmpl $0x0, %eax
jne 0xb20c1
jmp 0xb21d1
movl $0x0, 0x31ef29(%rip)    # 0x3d0ff4
movl -0x4(%rbp), %ecx
leaq 0x1c81e3(%rip), %rax    # 0x27a2b8
movl %ecx, (%rax)
leaq 0x1c81e2(%rip), %rax    # 0x27a2c0
cmpl $0x0, (%rax)
je 0xb20ea
callq 0xb0bd0
jmp 0xb20ef
callq 0xb1730
callq 0xb0bd0
leaq 0x2e8b25(%rip), %rax    # 0x39ac20
movsbl (%rax), %eax
cmpl $0x41, %eax
jne 0xb21b1
callq 0xb14a0
callq 0xb15b0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb214b
leaq 0x2e8afe(%rip), %rdi    # 0x39ac20
callq 0x9480
movsd 0xd09f9(%rip), %xmm1    # 0x182b28
mulsd %xmm1, %xmm0
leaq 0x2ba0c6(%rip), %rax    # 0x36c200
movsd %xmm0, (%rax)
leaq 0x2ba3d3(%rip), %rax    # 0x36c518
movl $0x4, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb2179
leaq 0x2e8ac4(%rip), %rdi    # 0x39ac20
callq 0x9480
leaq 0x2ba0a0(%rip), %rax    # 0x36c208
movsd %xmm0, (%rax)
leaq 0x2ba3a1(%rip), %rax    # 0x36c514
movl $0x4, (%rax)
leaq 0x1c5930(%rip), %rax    # 0x277ab0
cmpq $0x40000, (%rax)        # imm = 0x40000
jne 0xb218b
jmp 0xb21d1
leaq 0x1c812e(%rip), %rax    # 0x27a2c0
cmpl $0x0, (%rax)
je 0xb21aa
leaq 0x1c812a(%rip), %rax    # 0x27a2c8
cmpl $0x7, (%rax)
jne 0xb21aa
callq 0xb0bd0
jmp 0xb21af
callq 0xb18d0
jmp 0xb21b1
callq 0xb19e0
leaq 0x1c8103(%rip), %rax    # 0x27a2c0
cmpl $0x0, (%rax)
je 0xb21c4
jmp 0xb21d1
movl -0x4(%rbp), %edi
movl $0x2, %esi
callq 0xb1ef0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: config_venus_timing()
void config_venus_timing()
{
   if((saw_timing_msg == 0) || (have_sawtooth == 0)) {
      if(rcvr_type != VENUS_RCVR) {
         rcvr_type = VENUS_RCVR;
         config_rcvr_type(0);
         need_msg_init = 2004;
      }
      else {
         config_rcvr_plots();
         config_msg_ofs();
      }

      plot[ONE].show_plot = 0;
      plot[TWO].show_plot = 0;
      plot[THREE].show_plot = 0;
      plot[SIX].show_plot = 0;
      if(user_set_dac_plot == 0) plot[DAC].show_plot = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2b96cd(%rip), %rax    # 0x36c608
cmpl $0x0, (%rax)
je 0xb2f50
leaq 0x2b965d(%rip), %rax    # 0x36c5a4
cmpl $0x0, (%rax)
jne 0xb2ff4
leaq 0x1c4b59(%rip), %rax    # 0x277ab0
cmpq $0x80, (%rax)
je 0xb2f84
leaq 0x1c4b49(%rip), %rax    # 0x277ab0
movq $0x80, (%rax)
xorl %edi, %edi
callq 0x6a330
leaq 0x1c7294(%rip), %rax    # 0x27a210
movl $0x7d4, (%rax)          # imm = 0x7D4
jmp 0xb2f8e
callq 0x64540
callq 0x63c20
leaq 0x109d8b(%rip), %rax    # 0x1bcd20
movl $0x0, 0x3b8(%rax)
leaq 0x109d7a(%rip), %rax    # 0x1bcd20
movl $0x0, 0x4a0(%rax)
leaq 0x109d69(%rip), %rax    # 0x1bcd20
movl $0x0, 0x588(%rax)
leaq 0x109d58(%rip), %rax    # 0x1bcd20
movl $0x0, 0x840(%rax)
leaq 0x2ba068(%rip), %rax    # 0x36d041
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0xb2ff2
leaq 0x109d38(%rip), %rax    # 0x1bcd20
movl $0x1, 0x1e8(%rax)
jmp 0xb2ff4
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_psti(int)
void parse_psti(int system)
{
int id;

   // handle the Venus proprietary NMEA messages
   // !!!!!! should we set rcvr_type to VENUS_RCVR?

   nmea_type = VENUS_NMEA;
   if((system & system_mask) == 0) return;

   if(get_msg_field()) {
      id = atoi(msg_field);

      if(id == 0) {  // sawtooth correction
         parse_venus_sawtooth();
      }
   }

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x1c7012(%rip), %rax    # 0x27a1c4
movl $0x56, (%rax)
movl -0x4(%rbp), %eax
leaq 0x11cc8e(%rip), %rcx    # 0x1cfe50
andl (%rcx), %eax
cmpl $0x0, %eax
jne 0xb31cb
jmp 0xb31f3
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb31f1
leaq 0x2e7a44(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0xb31ef
callq 0xb3000
jmp 0xb31f1
jmp 0xb31f3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_gpacc()
void parse_gpacc()
{
int prn;
int acc;
char c[2];

   if(get_msg_field()) {
      for(prn=1; prn<=32; prn++) {
         c[0] = msg_field[prn-1];
         c[1] = 0;
         if(c[0] == 0) break;

         if(c[0] == 'X') acc = (-1);
         else            acc = atohex(c);
         sat[prn].sv_accuracy = ura_to_dist(prn, acc);

         if(have_accu == 0) need_redraw = 2344;
         have_accu = 1;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb3628
movl $0x1, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jg 0xb3626
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x2e7689(%rip), %rax    # 0x39ac20
movb (%rax,%rcx), %al
movb %al, -0xa(%rbp)
movb $0x0, -0x9(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $0x0, %eax
jne 0xb35ac
jmp 0xb3626
movsbl -0xa(%rbp), %eax
cmpl $0x58, %eax
jne 0xb35be
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
jmp 0xb35ca
leaq -0xa(%rbp), %rdi
callq 0x98d0
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0xb3220
movslq -0x4(%rbp), %rcx
leaq 0x1eabb0(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movss %xmm0, 0x1fc(%rax)
leaq 0x2b8fa7(%rip), %rax    # 0x36c5a0
cmpl $0x0, (%rax)
jne 0xb360b
leaq 0x1c441f(%rip), %rax    # 0x277a24
movl $0x928, (%rax)          # imm = 0x928
leaq 0x2b8f8e(%rip), %rax    # 0x36c5a0
movl $0x1, (%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb357d
jmp 0xb3628
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_gpanc()
void parse_gpanc()
{
int i;
char c;

   get_msg_field();  // eat the almanac time string

   if(get_msg_field()) {
      reset_sat_health();
      for(i=0; i<32; i++) {
         c = msg_field[i];
         if(c == 0) break;
         else if(c == '0') sat[i+1].health_flag = 0;  // no sat
         else if(c == '1') sat[i+1].health_flag = 1;  // unhealthy
         else if(c == '2') sat[i+1].health_flag = 2;  // good
      }
   }
   else return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb0bd0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb370e
callq 0x81c70
movl $0x0, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jge 0xb370c
movslq -0x4(%rbp), %rcx
leaq 0x2e75b4(%rip), %rax    # 0x39ac20
movb (%rax,%rcx), %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x0, %eax
jne 0xb3680
jmp 0xb370c
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jne 0xb36a8
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x1eaaf7(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movb $0x0, (%rax)
jmp 0xb36fa
movsbl -0x5(%rbp), %eax
cmpl $0x31, %eax
jne 0xb36d0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x1eaacf(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movb $0x1, (%rax)
jmp 0xb36f8
movsbl -0x5(%rbp), %eax
cmpl $0x32, %eax
jne 0xb36f6
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x1eaaa7(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movb $0x2, (%rax)
jmp 0xb36f8
jmp 0xb36fa
jmp 0xb36fc
jmp 0xb36fe
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb3657
jmp 0xb3710
jmp 0xb3710
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_gpgpt()
void parse_gpgpt()
{
int val;
int i;

   if(get_msg_field()) {  // gps time valid
      val = atoi(msg_field);
      if(val) time_flags &= (~TFLAGS_INVALID);
      else    time_flags |= (TFLAGS_INVALID);
   }

   if(get_msg_field()) {  // gps week
      gps_week = atoi(msg_field);
      faked_tow = 0;
      have_week = 1;
   }

   if(get_msg_field()) {  // GPS TOW
      pri_tow = atoi(msg_field);
      tow = pri_tow;  
      this_tow = tow;
      survey_tow = tow;

      if(have_tow == 0) need_redraw = 3029;
      have_tow = 55;
   }

   if(get_msg_field()) {  // leap second count
      i = atoi(msg_field);
      time_flags |= TFLAGS_NO_UTC_OFS;
      if(i) {
         time_flags &= (~TFLAGS_NO_UTC_OFS);
         if(!user_set_utc_ofs) utc_offset = i;
         check_utc_ofs(334);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb3775
leaq 0x2e74e7(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xb375e
leaq 0x2b8f36(%rip), %rax    # 0x36c684
movl (%rax), %ecx
andl $-0x5, %ecx
leaq 0x2b8f2a(%rip), %rax    # 0x36c684
movl %ecx, (%rax)
jmp 0xb3773
leaq 0x2b8f1f(%rip), %rax    # 0x36c684
movl (%rax), %ecx
orl $0x4, %ecx
leaq 0x2b8f13(%rip), %rax    # 0x36c684
movl %ecx, (%rax)
jmp 0xb3775
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb37b2
leaq 0x2e749a(%rip), %rdi    # 0x39ac20
callq 0x95c0
movw %ax, %cx
leaq 0x2b9183(%rip), %rax    # 0x36c918
movw %cx, (%rax)
leaq 0x2b9189(%rip), %rax    # 0x36c928
movl $0x0, (%rax)
leaq 0x2b8d60(%rip), %rax    # 0x36c50c
movl $0x1, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb3832
leaq 0x2e745d(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x2b9153(%rip), %rax    # 0x36c924
movl %ecx, (%rax)
leaq 0x2b914a(%rip), %rax    # 0x36c924
movl (%rax), %ecx
leaq 0x2b9139(%rip), %rax    # 0x36c91c
movl %ecx, (%rax)
leaq 0x2b9130(%rip), %rax    # 0x36c91c
movl (%rax), %ecx
leaq 0x2b912b(%rip), %rax    # 0x36c920
movl %ecx, (%rax)
leaq 0x2b911e(%rip), %rax    # 0x36c91c
movl (%rax), %eax
movl %eax, %ecx
leaq 0x2b9127(%rip), %rax    # 0x36c930
movq %rcx, (%rax)
leaq 0x2b8cf5(%rip), %rax    # 0x36c508
cmpl $0x0, (%rax)
jne 0xb3825
leaq 0x1c4205(%rip), %rax    # 0x277a24
movl $0xbd5, (%rax)          # imm = 0xBD5
leaq 0x2b8cdc(%rip), %rax    # 0x36c508
movl $0x37, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb389f
leaq 0x2e73dd(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x8(%rbp)
leaq 0x2b8e32(%rip), %rax    # 0x36c684
movl (%rax), %ecx
orl $0x8, %ecx
leaq 0x2b8e26(%rip), %rax    # 0x36c684
movl %ecx, (%rax)
cmpl $0x0, -0x8(%rbp)
je 0xb389d
leaq 0x2b8e17(%rip), %rax    # 0x36c684
movl (%rax), %ecx
andl $-0x9, %ecx
leaq 0x2b8e0b(%rip), %rax    # 0x36c684
movl %ecx, (%rax)
leaq 0x2b9092(%rip), %rax    # 0x36c914
cmpl $0x0, (%rax)
jne 0xb3893
movl -0x8(%rbp), %ecx
leaq 0x2b9077(%rip), %rax    # 0x36c908
movl %ecx, (%rax)
movl $0x14e, %edi            # imm = 0x14E
callq 0x7a270
jmp 0xb389f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_gpmge()
void parse_gpmge()
{
int i;
int prn;

   // get prohibited SBAS sats bitmask (answer from gpmgq query)

   for(i=0; i<32; i++) {
      prn = i+120;
      sat[prn].disabled = 0;
   }

   if(get_msg_field()) {  // gps week
      excluded_sbas = (u32) atohex(msg_field);
      for(i=0; i<32; i++) {
         prn = i+120;
         if(excluded_sbas & (1 << i)) sat[prn].disabled = 1;
      }
   }
   else return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jge 0xb38f2
movl -0x4(%rbp), %eax
addl $0x78, %eax
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x1ea8b7(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movb $0x0, 0x1(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb38bf
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb396d
leaq 0x2e731d(%rip), %rdi    # 0x39ac20
callq 0x98d0
movl %eax, %ecx
leaq 0x2b89b7(%rip), %rax    # 0x36c2c8
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jge 0xb396b
movl -0x4(%rbp), %eax
addl $0x78, %eax
movl %eax, -0x8(%rbp)
leaq 0x2b8998(%rip), %rax    # 0x36c2c8
movl (%rax), %eax
movl -0x4(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xb395e
movslq -0x8(%rbp), %rcx
leaq 0x1ea840(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movb $0x1, 0x1(%rax)
jmp 0xb3960
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb391a
jmp 0xb396f
jmp 0xb396f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_gppri()
void parse_gppri()
{
int i;
char c;

   // position fix of sats - from PFEC,GPprq

   if(get_msg_field()) {
     for(i=0; i<32; i++) {
        c = msg_field[i];
        if(c == 0) break;
        // !!!! do something with the data: '1'=no fix  '2'=GPS only   3=DGPS+RTCM  4=DGPS+SBAS
     }
   }
   else return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb39ca
movl $0x0, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jge 0xb39c8
movslq -0x4(%rbp), %rcx
leaq 0x2e7276(%rip), %rax    # 0x39ac20
movb (%rax,%rcx), %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x0, %eax
jne 0xb39bb
jmp 0xb39c8
jmp 0xb39bd
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb3999
jmp 0xb39cc
jmp 0xb39cc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_gprrm()
void parse_gprrm()
{
int traim_offset;

   // traim status

   traim_alarm = traim_status = traim_deleted = traim_offset = 0;

   if(get_msg_field()) {
      traim_alarm = atoi(msg_field);
   }

   if(get_msg_field()) {
      traim_status = atoi(msg_field);
   }

   if(get_msg_field()) {
      traim_deleted = atoi(msg_field);
   }

   get_msg_field();  // reserved
   get_msg_field();  // reserved
   get_msg_field();  // reserved
   get_msg_field();  // reserved

   if(get_msg_field()) {
      traim_offset = atoi(msg_field);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x2e8a62(%rip), %rax    # 0x39c488
movl $0x0, (%rax)
leaq 0x1c6875(%rip), %rax    # 0x27a2a8
movl $0x0, (%rax)
leaq 0x2e8a4c(%rip), %rax    # 0x39c48c
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb3a67
leaq 0x2e71c9(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x2e8a27(%rip), %rax    # 0x39c48c
movl %ecx, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb3a88
leaq 0x2e71a8(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1c6822(%rip), %rax    # 0x27a2a8
movl %ecx, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb3aa9
leaq 0x2e7187(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x2e89e1(%rip), %rax    # 0x39c488
movl %ecx, (%rax)
callq 0xb0bd0
callq 0xb0bd0
callq 0xb0bd0
callq 0xb0bd0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb3ad6
leaq 0x2e7152(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_gprsd()
void parse_gprsd()
{
int furuno_traim;
int pps_mode;

   // pps/traim config

   if(get_msg_field()) {
      traim_mode = atoi(msg_field);
      have_traim = 1;
   }

   if(get_msg_field()) {
      furuno_traim = atoi(msg_field);
   }

   if(get_msg_field()) {
      pps_mode = atoi(msg_field);
      if(pps_mode) pps_enabled = 1;
      else         pps_enabled = 0;
      have_pps_enable = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb3b16
leaq 0x2e7127(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x1c6799(%rip), %rax    # 0x27a2a0
movl %ecx, (%rax)
leaq 0x2b8a98(%rip), %rax    # 0x36c5a8
movl $0x1, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb3b2f
leaq 0x2e70f9(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb3b71
leaq 0x2e70e0(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xb3b5a
leaq 0x2b93ab(%rip), %rax    # 0x36cf00
movb $0x1, (%rax)
jmp 0xb3b64
leaq 0x2b939f(%rip), %rax    # 0x36cf00
movb $0x0, (%rax)
leaq 0x2b8951(%rip), %rax    # 0x36c4bc
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_gptmd()
void parse_gptmd()
{
   minor_alarms &= (~MINOR_SURVEY);
   survey_secs = 0;
   survey_length = 0;

   if(get_msg_field()) {   // samples remaining
      if(msg_field[0]) {
         survey_secs = atoi(msg_field);
         if(survey_secs) minor_alarms |= MINOR_SURVEY;
         survey_length = survey_secs;
      }
   }
   else return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2b847d(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $-0x21, %ecx
leaq 0x2b8471(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
leaq 0x2b9124(%rip), %rax    # 0x36d074
movl $0x0, (%rax)
leaq 0x2b90f3(%rip), %rax    # 0x36d050
movl $0x0, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb3fc5
leaq 0x2e6cac(%rip), %rax    # 0x39ac20
cmpb $0x0, (%rax)
je 0xb3fc3
leaq 0x2e6ca0(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, %ecx
leaq 0x2b90e6(%rip), %rax    # 0x36d074
movl %ecx, (%rax)
leaq 0x2b90dd(%rip), %rax    # 0x36d074
cmpl $0x0, (%rax)
je 0xb3fb1
leaq 0x2b8415(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x20, %ecx
leaq 0x2b8409(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
leaq 0x2b90bc(%rip), %rax    # 0x36d074
movl (%rax), %ecx
leaq 0x2b908f(%rip), %rax    # 0x36d050
movl %ecx, (%rax)
jmp 0xb3fc7
jmp 0xb3fc7
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_gpwas()
void parse_gpwas()
{
int setting;
int state;

   // SBAS position fix params (answer from gpwaq)

   if(get_msg_field()) {
      setting = atoi(&msg_field[1]);
   }
   else return;

   if(get_msg_field()) {
      state = atohex(&msg_field[1]);
   }
   else return;
//sprintf(debug_text, "waq setting:%d  state:%d", setting,state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb4507
leaq 0x2e6727(%rip), %rdi    # 0x39ac20
addq $0x1, %rdi
callq 0x95c0
movl %eax, -0x4(%rbp)
jmp 0xb4509
jmp 0xb452a
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb4528
leaq 0x2e6706(%rip), %rdi    # 0x39ac20
addq $0x1, %rdi
callq 0x98d0
movl %eax, -0x8(%rbp)
jmp 0xb452a
jmp 0xb452a
addq $0x10, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_fixed_field(int)
int get_fixed_field(int width)
{
char c;
int i;

   // get a fixed with field from a message

   msg_field[0] = 0;
   if(width <= 0) return 0;
   if(nmea_msg[msg_col] == 0) return 0;  // at end-of-message

   i = 0;
   while(width--) {   // get next field from the nmea message
      c = nmea_msg[msg_col];
      if(c == 0) {  // reached end-of-message
         break;
      }

      if(i < ((int)sizeof(msg_field)-2)) {
         msg_field[i++] = c;
         msg_field[i] = 0;
         ++msg_col;
      }
   }

   return msg_field[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
leaq 0x2e5eb2(%rip), %rax    # 0x39ac20
movb $0x0, (%rax)
cmpl $0x0, -0x8(%rbp)
jg 0xb4d83
movl $0x0, -0x4(%rbp)
jmp 0xb4e39
leaq 0x2e609a(%rip), %rax    # 0x39ae24
movslq (%rax), %rcx
leaq 0x2e5c7c(%rip), %rax    # 0x39aa10
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xb4da9
movl $0x0, -0x4(%rbp)
jmp 0xb4e39
movl $0x0, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
je 0xb4e2c
leaq 0x2e605d(%rip), %rax    # 0x39ae24
movslq (%rax), %rcx
leaq 0x2e5c3f(%rip), %rax    # 0x39aa10
movb (%rax,%rcx), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
jne 0xb4de2
jmp 0xb4e2c
cmpl $0x1ff, -0x10(%rbp)     # imm = 0x1FF
jge 0xb4e2a
movb -0x9(%rbp), %dl
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movslq %eax, %rcx
leaq 0x2e5e1d(%rip), %rax    # 0x39ac20
movb %dl, (%rax,%rcx)
movslq -0x10(%rbp), %rcx
leaq 0x2e5e0f(%rip), %rax    # 0x39ac20
movb $0x0, (%rax,%rcx)
leaq 0x2e6008(%rip), %rax    # 0x39ae24
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x2e5ffc(%rip), %rax    # 0x39ae24
movl %ecx, (%rax)
jmp 0xb4db0
leaq 0x2e5ded(%rip), %rax    # 0x39ac20
movsbl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_perdack()
void parse_perdack()
{
int flag;

   // command acknowledgement

   flag = 256;
   if(get_msg_field()) {  // command being acked
   }

   if(get_msg_field()) {  // ack(0..255) / nak(-1)
      flag = atoi(msg_field);
   }

   if(get_msg_field()) {  // first param of command
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x100, -0x4(%rbp)      # imm = 0x100
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb4e5b
jmp 0xb4e5b
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb4e74
leaq 0x2e5db4(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb4e80
jmp 0xb4e80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_crz()
void parse_crz()
{
int i;

   get_msg_field();  // eat the TPS4

   if(get_msg_field()) {  // freq mode
      i = atoi(msg_field);
      esip_status = i;
      have_esip_status = 87;
   }

   if(get_msg_field()) {  // freq status
      i = atoi(msg_field);
   }

   if(get_msg_field()) {  // gclk accuracy
      i = atoi(msg_field);
   }

   if(get_msg_field()) {  // delay between legacy and gclk PPS
      i = atoi(msg_field);
   }

   if(get_msg_field()) {  // amount of change of phase delay
      i = atoi(msg_field);
   }

   if(get_msg_field()) {  // duration of lock (secs)
      i = atoi(msg_field);
   }

   if(get_msg_field()) {  // holdover duration
      i = atoi(msg_field);
   }

   if(get_msg_field()) {  // reserved
      i = atohex(msg_field);
   }

   if(get_msg_field()) {  // id tag
      i = atoi(msg_field);
   }

   if(get_msg_field()) {  // reserved
      i = atohex(msg_field);
   }

   if(get_msg_field()) {  // reserved
      i = atoi(msg_field);
   }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb0bd0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb52ef
leaq 0x2e5952(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
leaq 0x2b7c7c(%rip), %rax    # 0x36cf5c
movl %ecx, (%rax)
leaq 0x2b7c77(%rip), %rax    # 0x36cf60
movl $0x57, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb5308
leaq 0x2e5920(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb5321
leaq 0x2e5907(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb533a
leaq 0x2e58ee(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb5353
leaq 0x2e58d5(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb536c
leaq 0x2e58bc(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb5385
leaq 0x2e58a3(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb539e
leaq 0x2e588a(%rip), %rdi    # 0x39ac20
callq 0x98d0
movl %eax, -0x4(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb53b7
leaq 0x2e5871(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb53d0
leaq 0x2e5858(%rip), %rdi    # 0x39ac20
callq 0x98d0
movl %eax, -0x4(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb53e9
leaq 0x2e583f(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x4(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_crn()
void parse_crn()
{
int i;
int system;
int prn;
int frame[MAX_PRN+1][10];

   // GPS navigation subframe

   system = (-1);
   prn = 0;

   if(get_msg_field()) {
      system = atoi(msg_field);
      if(system != 1) return;  // system 1 is GPS
   }

   if(get_msg_field()) {
      prn = atoi(msg_field);
      if(prn <= 0) return;
      if(prn >= MAX_PRN) return;
   }

   for(i=0; i<10; i++) {
      if(get_fixed_field(6)) {
         if(msg_field[0] == '-') frame[prn][i] = 0;
         else frame[prn][i] = atohex(msg_field);
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x9c50, %rsp           # imm = 0x9C50
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb578f
leaq 0x2e54a6(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
je 0xb578d
jmp 0xb5843
jmp 0xb578f
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb57c3
leaq 0x2e5480(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0xb57b3
jmp 0xb5843
cmpl $0x3e7, -0xc(%rbp)      # imm = 0x3E7
jl 0xb57c1
jmp 0xb5843
jmp 0xb57c3
movl $0x0, -0x4(%rbp)
cmpl $0xa, -0x4(%rbp)
jge 0xb5843
movl $0x6, %edi
callq 0xb4d60
cmpl $0x0, %eax
je 0xb5836
leaq 0x2e543a(%rip), %rax    # 0x39ac20
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xb580d
movslq -0xc(%rbp), %rcx
leaq -0x9c50(%rbp), %rax
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0xb5834
leaq 0x2e540c(%rip), %rdi    # 0x39ac20
callq 0x98d0
movl %eax, %edx
movslq -0xc(%rbp), %rcx
leaq -0x9c50(%rbp), %rax
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xb5836
jmp 0xb5838
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xb57ca
addq $0x9c50, %rsp           # imm = 0x9C50
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: esip_disable(int, int, unsigned int)
void esip_disable(int prn, int count, u32 mask)
{
int i;

   // flag excluded sats

   for(i=0; i<count; i++) {
      if(mask & (1U << i)) sat[prn].disabled = 1;
      else                 sat[prn].disabled = 0;
      ++prn;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0xb58ca
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xb589d
movslq -0x4(%rbp), %rcx
leaq 0x1e8903(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movb $0x1, 0x1(%rax)
jmp 0xb58b6
movslq -0x4(%rbp), %rcx
leaq 0x1e88e8(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movb $0x0, 0x1(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb5864
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_z12_pps()
void parse_z12_pps()
{
double period;
double ofs;

   // PPS output control
   log_packet_id("z12_pps");

   if(get_msg_field()) {  // period (0.5 .. 59.5 secs)
      period = atof(msg_field);
      if     (period == 1.0) pps_rate = RATE_1PPS;
      else if(period == 2.0) pps_rate = RATE_PP2S;
      else                   pps_rate = RATE_USER;

      if(period == 0.0) pps_enabled = 0;
      else              pps_enabled = 1;

      have_pps_rate = 12;
   }

   if(get_msg_field()) {  // offset (in msecs)
      ofs = atof(msg_field);
      pps1_delay = ofs;
      have_pps_delay |= 0x01;
   }

   get_msg_field();  // PPS enabled on port A
   get_msg_field();  // PPS enabled on port B 
   get_msg_field();  // PPS enabled on port C 
   get_msg_field();  // PPS enabled on port D 

   have_z12_pps = 12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xce340(%rip), %rdi     # 0x18647f
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb81e4
leaq 0x2e2ac7(%rip), %rdi    # 0x39ac20
callq 0x9480
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xb6ef8(%rip), %xmm1    # 0x16f068
ucomisd %xmm1, %xmm0
jne 0xb8184
jp 0xb8184
leaq 0x2b4d84(%rip), %rax    # 0x36cf03
movb $0x2, (%rax)
jmp 0xb81b1
movsd -0x8(%rbp), %xmm0
movsd 0xb6fbf(%rip), %xmm1    # 0x16f150
ucomisd %xmm1, %xmm0
jne 0xb81a5
jp 0xb81a5
leaq 0x2b4d63(%rip), %rax    # 0x36cf03
movb $-0x7e, (%rax)
jmp 0xb81af
leaq 0x2b4d57(%rip), %rax    # 0x36cf03
movb $0x0, (%rax)
jmp 0xb81b1
movsd -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb81cd
jp 0xb81cd
leaq 0x2b4d38(%rip), %rax    # 0x36cf00
movb $0x0, (%rax)
jmp 0xb81d7
leaq 0x2b4d2c(%rip), %rax    # 0x36cf00
movb $0x1, (%rax)
leaq 0x2b42d2(%rip), %rax    # 0x36c4b0
movl $0xc, (%rax)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb8224
leaq 0x2e2a2b(%rip), %rdi    # 0x39ac20
callq 0x9480
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
leaq 0x2b4dad(%rip), %rax    # 0x36cfb8
movsd %xmm0, (%rax)
leaq 0x2b4282(%rip), %rax    # 0x36c498
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x2b4276(%rip), %rax    # 0x36c498
movl %ecx, (%rax)
callq 0xb0bd0
callq 0xb0bd0
callq 0xb0bd0
callq 0xb0bd0
leaq 0x2b4275(%rip), %rax    # 0x36c4b4
movl $0xc, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_z12_ext()
void parse_z12_ext()
{
double freq;
int mode;
int lock;

   // External freq control
   log_packet_id("z12_ext");

   if(get_msg_field()) {  // freq
      freq = atof(msg_field);
   }

   if(get_msg_field()) {  // switch mode
      mode = atoi(msg_field);
   }

   if(get_msg_field()) {  // locked
      lock = atoi(msg_field);  // 'L' or 'U'
   }

   have_z12_ext = 12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xce228(%rip), %rdi     # 0x186487
callq 0x7add0
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb827f
leaq 0x2e29ab(%rip), %rdi    # 0x39ac20
callq 0x9480
movsd %xmm0, -0x8(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb8298
leaq 0x2e2990(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0xc(%rbp)
callq 0xb0bd0
cmpl $0x0, %eax
je 0xb82b1
leaq 0x2e2977(%rip), %rdi    # 0x39ac20
callq 0x95c0
movl %eax, -0x10(%rbp)
leaq 0x2b4200(%rip), %rax    # 0x36c4b8
movl $0xc, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_pashr()
void parse_pashr()
{
   if(get_msg_field() == 0) return;
if(debug_file) fprintf(debug_file, "Parsing Z12: %s\n", msg_field);

   if     (strstr(msg_field, "PBN")) parse_z12_pbn();  // binary messages
   else if(strstr(msg_field, "ALM")) parse_z12_alm();
   else if(strstr(msg_field, "EPB")) parse_z12_epb();
   else if(strstr(msg_field, "MPC")) parse_z12_mpc();
   else if(strstr(msg_field, "RPC")) parse_z12_rpc();
   else if(strstr(msg_field, "SNV")) parse_z12_snv();

   else if(strstr(msg_field, "RID")) parse_z12_rid();
   else if(strstr(msg_field, "POS")) parse_z12_pos();
   else if(strstr(msg_field, "EXT")) parse_z12_ext();
   else if(strstr(msg_field, "PPS")) parse_z12_pps();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0xb0bd0
cmpl $0x0, %eax
jne 0xb82e3
jmp 0xb8471
leaq 0x1e5286(%rip), %rax    # 0x29d570
cmpq $0x0, (%rax)
je 0xb830f
leaq 0x1e5279(%rip), %rax    # 0x29d570
movq (%rax), %rdi
leaq 0xce18e(%rip), %rsi     # 0x18648f
leaq 0x2e2918(%rip), %rdx    # 0x39ac20
movb $0x0, %al
callq 0x9550
leaq 0x2e290a(%rip), %rdi    # 0x39ac20
leaq 0xce183(%rip), %rsi     # 0x1864a0
callq 0x9090
cmpq $0x0, %rax
je 0xb8332
callq 0xb7ba0
jmp 0xb8471
leaq 0x2e28e7(%rip), %rdi    # 0x39ac20
leaq 0xce164(%rip), %rsi     # 0x1864a4
callq 0x9090
cmpq $0x0, %rax
je 0xb8355
callq 0xb8090
jmp 0xb846f
leaq 0x2e28c4(%rip), %rdi    # 0x39ac20
leaq 0xce145(%rip), %rsi     # 0x1864a8
callq 0x9090
cmpq $0x0, %rax
je 0xb8378
callq 0xb80d0
jmp 0xb846d
leaq 0x2e28a1(%rip), %rdi    # 0x39ac20
leaq 0xce126(%rip), %rsi     # 0x1864ac
callq 0x9090
cmpq $0x0, %rax
je 0xb839b
callq 0xb7190
jmp 0xb846b
leaq 0x2e287e(%rip), %rdi    # 0x39ac20
leaq 0xce107(%rip), %rsi     # 0x1864b0
callq 0x9090
cmpq $0x0, %rax
je 0xb83be
callq 0xb80f0
jmp 0xb8469
leaq 0x2e285b(%rip), %rdi    # 0x39ac20
leaq 0xce0e8(%rip), %rsi     # 0x1864b4
callq 0x9090
cmpq $0x0, %rax
je 0xb83e1
callq 0xb80b0
jmp 0xb8467
leaq 0x2e2838(%rip), %rdi    # 0x39ac20
leaq 0xcb76d(%rip), %rsi     # 0x183b5c
callq 0x9090
cmpq $0x0, %rax
je 0xb8401
callq 0xb7f10
jmp 0xb8465
leaq 0x2e2818(%rip), %rdi    # 0x39ac20
leaq 0xd112b(%rip), %rsi     # 0x18953a
callq 0x9090
cmpq $0x0, %rax
je 0xb8421
callq 0xb8110
jmp 0xb8463
leaq 0x2e27f8(%rip), %rdi    # 0x39ac20
leaq 0xcc667(%rip), %rsi     # 0x184a96
callq 0x9090
cmpq $0x0, %rax
je 0xb8441
callq 0xb8250
jmp 0xb8461
leaq 0x2e27d8(%rip), %rdi    # 0x39ac20
leaq 0xd12c3(%rip), %rsi     # 0x189712
callq 0x9090
cmpq $0x0, %rax
je 0xb845f
callq 0xb8130
jmp 0xb8461
jmp 0xb8463
jmp 0xb8465
jmp 0xb8467
jmp 0xb8469
jmp 0xb846b
jmp 0xb846d
jmp 0xb846f
jmp 0xb8471
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_ss_config()
void parse_ss_config()
{
int ss_config;
int ss_antenna;

   log_packet_id("Receiver config");

   ss_config = tsip_byte() & 0x0F;

   nav_rate = (DATA_SIZE) (tsip_byte() & 0x03);
   if     (nav_rate == 0) nav_rate = 1;
   else if(nav_rate == 1) nav_rate = 2;
   else if(nav_rate == 2) nav_rate = 5;
   else                   nav_rate = 1;  // unknown rate

   ss_antenna = tsip_byte() & 0x03;  // antenna type (0=auto  1=active  2=passive)

   tsip_byte();  // rsvd
   tsip_word();  // max speed
   tsip_byte();  // max acceleration (bits 0..5)
   tsip_byte();  // statistical threshold
   tsip_byte();  // dead reconning threshold

   tsip_byte();  // rsvd
   tsip_byte();  // rsvd
   tsip_byte();  // rsvd
   tsip_byte();  // rsvd
   tsip_byte();  // rsvd
   tsip_byte();  // rsvd
   tsip_byte();  // rsvd
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xccfdf(%rip), %rdi     # 0x18663e
callq 0x7add0
callq 0x7a510
movzbl %al, %eax
andl $0xf, %eax
movl %eax, -0x4(%rbp)
callq 0x7a510
movzbl %al, %eax
andl $0x3, %eax
cvtsi2sd %eax, %xmm0
leaq 0x1c0eb0(%rip), %rax    # 0x27a538
movsd %xmm0, (%rax)
leaq 0x1c0ea5(%rip), %rax    # 0x27a538
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb96b7
jp 0xb96b7
leaq 0x1c0e8f(%rip), %rax    # 0x27a538
movsd 0xb59b7(%rip), %xmm0    # 0x16f068
movsd %xmm0, (%rax)
jmp 0xb972e
leaq 0x1c0e7a(%rip), %rax    # 0x27a538
movsd (%rax), %xmm0
movsd 0xb599e(%rip), %xmm1    # 0x16f068
ucomisd %xmm1, %xmm0
jne 0xb96e7
jp 0xb96e7
leaq 0x1c0e5f(%rip), %rax    # 0x27a538
movsd 0xb5a6f(%rip), %xmm0    # 0x16f150
movsd %xmm0, (%rax)
jmp 0xb972c
leaq 0x1c0e4a(%rip), %rax    # 0x27a538
movsd (%rax), %xmm0
movsd 0xb5a56(%rip), %xmm1    # 0x16f150
ucomisd %xmm1, %xmm0
jne 0xb9717
jp 0xb9717
leaq 0x1c0e2f(%rip), %rax    # 0x27a538
movsd 0xb5a4f(%rip), %xmm0    # 0x16f160
movsd %xmm0, (%rax)
jmp 0xb972a
leaq 0x1c0e1a(%rip), %rax    # 0x27a538
movsd 0xb5942(%rip), %xmm0    # 0x16f068
movsd %xmm0, (%rax)
jmp 0xb972c
jmp 0xb972e
callq 0x7a510
movzbl %al, %eax
andl $0x3, %eax
movl %eax, -0x8(%rbp)
callq 0x7a510
callq 0x7a560
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_ss_string(char*, int)
void get_ss_string(char *s, int len)
{
int i;

   for(i=0; i<len; i++) {
      if(s) {
         s[i] = tsip_byte();
         s[i+1] = 0;
      }
      else tsip_byte();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb999c
cmpq $0x0, -0x8(%rbp)
je 0xb998a
callq 0x7a510
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0xb998f
callq 0x7a510
jmp 0xb9991
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb9956
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_ss_id()
void parse_ss_id()
{
   log_packet_id("Version info");

   get_ss_string(ss_sw_pn, 14);
   get_ss_string(ss_model, 14);
   get_ss_string(ss_model_cksum, 4);
   get_ss_string(ss_boot_pn, 14);
   get_ss_string(ss_rsvd, 22);
   get_ss_string(ss_psn, 13);
   get_ss_string(ss_rsvd2, 4);
   ss_boot_cksum = tsip_word();
   ss_op_cksum = tsip_word();
   ss_type = tsip_byte();

   have_info |= ALL_ID_INFO;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xccca2(%rip), %rdi     # 0x18665d
callq 0x7add0
leaq 0x2e2929(%rip), %rdi    # 0x39c2f0
movl $0xe, %esi
callq 0xb9940
leaq 0x2e2948(%rip), %rdi    # 0x39c320
movl $0xe, %esi
callq 0xb9940
leaq 0x2e2967(%rip), %rdi    # 0x39c350
movl $0x4, %esi
callq 0xb9940
leaq 0x2e2986(%rip), %rdi    # 0x39c380
movl $0xe, %esi
callq 0xb9940
leaq 0x2e29a5(%rip), %rdi    # 0x39c3b0
movl $0x16, %esi
callq 0xb9940
leaq 0x2e29c4(%rip), %rdi    # 0x39c3e0
movl $0xd, %esi
callq 0xb9940
leaq 0x2e29e3(%rip), %rdi    # 0x39c410
movl $0x4, %esi
callq 0xb9940
callq 0x7a560
movzwl %ax, %ecx
leaq 0x2e29ee(%rip), %rax    # 0x39c434
movl %ecx, (%rax)
callq 0x7a560
movzwl %ax, %ecx
leaq 0x2e29e1(%rip), %rax    # 0x39c438
movl %ecx, (%rax)
callq 0x7a510
movzbl %al, %ecx
leaq 0x2e29d4(%rip), %rax    # 0x39c43c
movl %ecx, (%rax)
leaq 0x2b30e3(%rip), %rax    # 0x36cb54
movl (%rax), %ecx
orl $0xf, %ecx
leaq 0x2b30d7(%rip), %rax    # 0x36cb54
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_ss_status()
void parse_ss_status()
{
int sys_flag;
int nav_flag;

   log_packet_id("Receiver status");

   sys_flag = tsip_byte(); // system mode
   tsip_byte();
   tsip_word();            // almanac week

   gps_week = tsip_word(); // gps week
   have_week = 333;

   ss_deleted_gps = tsip_dword();       // GPS sat disable bitmask
   sats_enabled = (~ss_deleted_gps);
   update_disable_list(sats_enabled);

   tsip_byte();        // rsvd

   ss_deleted_sbas = tsip_dword();      // !!!! needs work SBAS sat disabled bitmask

   tsip_byte();        // min idle time
   tsip_byte();        // idle time

   el_mask = ((float) tsip_word()) / 100.0F;

   tsip_byte();        // discretes

   tsip_byte();        // rsvd
   tsip_byte();        // rsvd
   tsip_byte();        // rsvd
   tsip_byte();        // rsvd
   tsip_byte();        // rsvd
   tsip_byte();        // rsvd
   tsip_byte();        // rsvd

   // sys_flag 0: self test
   // sys_flag 1: initializing
   // sys_flag 2: acquisition
   // sys_flag 3: navigation
   // sys_flag 4: fault

   // nav_flag 0: init required
   // nav_flag 1: initialized
   // nav_flag 2: nav 3d
   // nav_flag 3: nav 2d
   // nav_flag 4: differential 3d
   // nav_flag 5: differential 2d
   // nav_flag 6: dead reconing
   // nav_flag 7: reserved
   // nav_flag 8: base station
   nav_flag = tsip_byte(); // nav mode

   tsip_byte();        // rsvd
   tsip_byte();        // rsvd
   tsip_byte();        // rsvd
   tsip_byte();        // rsvd
   tsip_byte();        // rsvd
   tsip_byte();        // rsvd

   tsip_word();        // differential word count
   tsip_word();        // parity error count
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xccbcb(%rip), %rdi     # 0x18666a
callq 0x7add0
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x4(%rbp)
callq 0x7a510
callq 0x7a560
callq 0x7a560
movw %ax, %cx
leaq 0x2b2e50(%rip), %rax    # 0x36c918
movw %cx, (%rax)
leaq 0x2b2a3a(%rip), %rax    # 0x36c50c
movl $0x14d, (%rax)          # imm = 0x14D
callq 0x7a680
movl %eax, %ecx
leaq 0x2b34aa(%rip), %rax    # 0x36cf90
movl %ecx, (%rax)
movl (%rax), %ecx
notl %ecx
leaq 0x2b27d1(%rip), %rax    # 0x36c2c4
movl %ecx, (%rax)
movl (%rax), %edi
callq 0x81cb0
callq 0x7a510
callq 0x7a680
movl %eax, %ecx
leaq 0x2b3485(%rip), %rax    # 0x36cf94
movl %ecx, (%rax)
callq 0x7a510
callq 0x7a510
callq 0x7a560
movzwl %ax, %eax
cvtsi2ss %eax, %xmm0
movss 0xc97f5(%rip), %xmm1    # 0x183324
divss %xmm1, %xmm0
leaq 0x2b275a(%rip), %rax    # 0x36c294
movss %xmm0, (%rax)
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x8(%rbp)
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a560
callq 0x7a560
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_ss_health()
void parse_ss_health()
{
int prn;
int i;

   log_packet_id("Satellie health");

   reset_sat_health();
   for(prn=1; prn<=32; prn+=4) {
      i = tsip_byte();
      if(i & 0x03) sat[prn+0].health_flag = 1;
      if(i & 0x0C) sat[prn+1].health_flag = 1;
      if(i & 0x30) sat[prn+2].health_flag = 1;
      if(i & 0xC0) sat[prn+3].health_flag = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xccacb(%rip), %rdi     # 0x18667a
callq 0x7add0
callq 0x81c70
movl $0x1, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jg 0xb9c87
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xb9bfd
movl -0x4(%rbp), %eax
addl $0x0, %eax
movslq %eax, %rcx
leaq 0x1e45a0(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movb $0x1, (%rax)
movl -0x8(%rbp), %eax
andl $0xc, %eax
cmpl $0x0, %eax
je 0xb9c25
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x1e4578(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movb $0x1, (%rax)
movl -0x8(%rbp), %eax
andl $0x30, %eax
cmpl $0x0, %eax
je 0xb9c4d
movl -0x4(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rcx
leaq 0x1e4550(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movb $0x1, (%rax)
movl -0x8(%rbp), %eax
andl $0xc0, %eax
cmpl $0x0, %eax
je 0xb9c77
movl -0x4(%rbp), %eax
addl $0x3, %eax
movslq %eax, %rcx
leaq 0x1e4526(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movb $0x1, (%rax)
jmp 0xb9c79
movl -0x4(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x4(%rbp)
jmp 0xb9bc0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_ss_utc()
void parse_ss_utc()
{
int wn_lsf;
int dn;
int valid;

   log_packet_id("UTC and ionosphere data");

   tsip_byte();
   tsip_byte();
   tsip_byte();
   tsip_byte();
   tsip_byte();
   tsip_byte();
   tsip_byte();
   tsip_byte();
   tsip_byte();
   tsip_dword();
   tsip_dword();
   tsip_byte();
   tsip_byte();
   tsip_byte();

   wn_lsf = tsip_byte();   // !!!! we need a 16 bit value here
   dn = tsip_byte();
   tsip_byte();
   valid = tsip_byte();

   tsip_dword();  // reserved
   tsip_dword();
   tsip_dword();
   tsip_dword();

   if(0 && valid) {
      calc_leap_days(wn_lsf, dn, 765);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xcc6ad(%rip), %rdi     # 0x18669c
callq 0x7add0
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a680
callq 0x7a680
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x4(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x8(%rbp)
callq 0x7a510
callq 0x7a510
movzbl %al, %eax
movl %eax, -0xc(%rbp)
callq 0x7a680
callq 0x7a680
callq 0x7a680
callq 0x7a680
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_ss_timing()
void parse_ss_timing()
{
int i;

   log_packet_id("Timing status");

   cable_delay = ((double) tsip_dword()) * 1.0E9;
   have_cable_delay = 333;

   pps1_delay = ((double) tsip_dword()) * 1.0E9;
   have_pps_delay |= 0x01;

   ss_pps_width = ((double) tsip_dword()) * 100.0;  // in ns (100 ns granularity)
   have_pps_duty = 1;

   tsip_byte();  // number of observations
   el_mask = ((float) tsip_word()) / 100.0F;

   tsip_byte();  // leap second change (-1, 0, 1)
   i = tsip_byte();
   if(i) {
      if(!user_set_utc_ofs) utc_offset = i;
      check_utc_ofs(33);
   }

   pps_offset = (DATA_SIZE) tsip_double();  // bias
   have_pps_offset = 333;
   osc_offset = (DATA_SIZE) tsip_double();  // drift
   have_osc_offset = 333;

   tsip_byte();    // date of PPS
   tsip_byte();  
   tsip_word();  

   tsip_byte();    // time of PPS
   tsip_byte();
   tsip_double();

   tsip_dword();   // pps residual in ns

   tsip_byte();    // timing operation mode, etc
   tsip_dword();   // TFOM clock bias in ns
   tsip_byte();    // rsvd
   ss_intrinsic_delay = tsip_word();    // intrinsic delay
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xcc625(%rip), %rdi     # 0x1866b4
callq 0x7add0
callq 0x7a680
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd 0xb4f80(%rip), %xmm1    # 0x16f028
movsd %xmm1, -0x10(%rbp)
mulsd %xmm1, %xmm0
leaq 0x2b2ef0(%rip), %rax    # 0x36cfa8
movsd %xmm0, (%rax)
leaq 0x2b23d1(%rip), %rax    # 0x36c494
movl $0x14d, (%rax)          # imm = 0x14D
callq 0x7a680
movsd -0x10(%rbp), %xmm1
movl %eax, %eax
cvtsi2sd %rax, %xmm0
mulsd %xmm1, %xmm0
leaq 0x2b2ed3(%rip), %rax    # 0x36cfb8
movsd %xmm0, (%rax)
leaq 0x2b23a8(%rip), %rax    # 0x36c498
movb (%rax), %cl
orb $0x1, %cl
movb %cl, (%rax)
callq 0x7a680
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd 0xb4f45(%rip), %xmm1    # 0x16f050
mulsd %xmm1, %xmm0
leaq 0x2b2e72(%rip), %rax    # 0x36cf88
movsd %xmm0, (%rax)
leaq 0x2b2e23(%rip), %rax    # 0x36cf44
movl $0x1, (%rax)
callq 0x7a510
callq 0x7a560
movzwl %ax, %eax
cvtsi2ss %eax, %xmm0
movss 0xc91e4(%rip), %xmm1    # 0x183324
divss %xmm1, %xmm0
leaq 0x2b2149(%rip), %rax    # 0x36c294
movss %xmm0, (%rax)
callq 0x7a510
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xba187
leaq 0x2b27a8(%rip), %rax    # 0x36c914
cmpl $0x0, (%rax)
jne 0xba17d
movl -0x4(%rbp), %ecx
leaq 0x2b278d(%rip), %rax    # 0x36c908
movl %ecx, (%rax)
movl $0x21, %edi
callq 0x7a270
callq 0x7a9d0
leaq 0x2b1805(%rip), %rax    # 0x36b998
movsd %xmm0, (%rax)
leaq 0x2b227a(%rip), %rax    # 0x36c418
movl $0x14d, (%rax)          # imm = 0x14D
callq 0x7a9d0
leaq 0x2b17f0(%rip), %rax    # 0x36b9a0
movsd %xmm0, (%rax)
leaq 0x2b2259(%rip), %rax    # 0x36c414
movl $0x14d, (%rax)          # imm = 0x14D
callq 0x7a510
callq 0x7a510
callq 0x7a560
callq 0x7a510
callq 0x7a510
callq 0x7a9d0
callq 0x7a680
callq 0x7a510
callq 0x7a680
callq 0x7a510
callq 0x7a560
movzwl %ax, %ecx
leaq 0x2b2d96(%rip), %rax    # 0x36cf98
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_rftg_21()
void parse_rftg_21()
{
   log_packet_id("Packet 0x21 (unknown)");

   tsip_byte();  // 0x00
   tsip_byte();  // 01=OK 02=when not tracking
   tsip_byte();  // 0x74  0x16 when normal
   tsip_byte();  // 0x00
   tsip_byte();  // 40=antenna open
   tsip_byte();  // 0x15=ok 0x06=ok 0x01=ok 00=no signal
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xcbda0(%rip), %rdi     # 0x1867bb
callq 0x7add0
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
callq 0x7a510
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_rftg_phase()
void parse_rftg_phase()
{
   log_packet_id("Packet 0x22 (phase)");

   rftg_phase_err = (double) tsip_single();     // phase err ns
   rftg_phase_ref = (double) tsip_single();     // ref ns
   rftg_avg_phase = (double) tsip_single();     // avg phase?
   rftg_delta_ape_10m = (double) tsip_single(); // 10 min delta ape

   pps_offset = (OFS_SIZE) (double) rftg_avg_phase * 1.0E9;  // average phase
   have_pps_offset = 1;
//sprintf(debug_text, "phase: %g %g %g %g", v1,v2,v3,v4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xcbd86(%rip), %rdi     # 0x1867d1
callq 0x7add0
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x2b2168(%rip), %rax    # 0x36cbc8
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x2b215c(%rip), %rax    # 0x36cbd0
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x2b2150(%rip), %rax    # 0x36cbd8
movsd %xmm0, (%rax)
callq 0x7a860
cvtss2sd %xmm0, %xmm0
leaq 0x2b2154(%rip), %rax    # 0x36cbf0
movsd %xmm0, (%rax)
movsd 0xb4580(%rip), %xmm0    # 0x16f028
leaq 0x2b2129(%rip), %rax    # 0x36cbd8
mulsd (%rax), %xmm0
leaq 0x2b0ede(%rip), %rax    # 0x36b998
movsd %xmm0, (%rax)
leaq 0x2b1953(%rip), %rax    # 0x36c418
movl $0x1, (%rax)
popq %rbp
retq
nopl (%rax)