LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_sv6_config()
void get_sv6_config()
{
float el_val;
float amu_val;

   log_packet_id("Packet 0x4C (SV6_FAMILY receiver config)");

   dynamics_code = tsip_byte();
   el_val = tsip_single();
   amu_val = tsip_single();
   pdop_mask = tsip_single();
   have_pdop_mask |= 0x01;
   pdop_switch = tsip_single();
   have_pdop_mask |= 0x02;
   check_tsip_end(1);
   if(tsip_error) return;
//sprintf(debug_text, "got dyn:%d el:%f amu:%f pmask:%f sw:%f  aflag:%d  amode:%d", dynamics_code,el_val,amu_val,pdop_mask,pdop_switch, amu_flag, amu_mode);

   // stupid filtering required for STARLOC II devices
   el_val = (float) (int) ((el_val*RAD_TO_DEG) + 0.50F);
   if((el_val >= 0.0) && (el_val <= 90.0)) {
      el_mask = el_val;
      have_el_mask = 1;
   }

   if((amu_val >= 0.0) && (amu_val < 60.0)) {
      amu_mask = amu_val;
      have_amu = 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe7bce(%rip), %rdi     # 0x184e9d
callq 0x7add0
callq 0x7a510
movb %al, %cl
leaq 0x2cefc3(%rip), %rax    # 0x36c2a5
movb %cl, (%rax)
callq 0x7a860
movss %xmm0, -0x4(%rbp)
callq 0x7a860
movss %xmm0, -0x8(%rbp)
callq 0x7a860
leaq 0x2cef98(%rip), %rax    # 0x36c29c
movss %xmm0, (%rax)
leaq 0x2cef9d(%rip), %rax    # 0x36c2ac
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x2cef91(%rip), %rax    # 0x36c2ac
movl %ecx, (%rax)
callq 0x7a860
leaq 0x2cef77(%rip), %rax    # 0x36c2a0
movss %xmm0, (%rax)
leaq 0x2cef78(%rip), %rax    # 0x36c2ac
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x2cef6c(%rip), %rax    # 0x36c2ac
movl %ecx, (%rax)
movl $0x1, %edi
callq 0x7aee0
leaq 0x200dfd(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0x9d35d
jmp 0x9d417
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xd1e12(%rip), %xmm1    # 0x16f180
mulsd %xmm1, %xmm0
movsd 0xd1d16(%rip), %xmm1    # 0x16f090
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x9d3d1
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xd1cda(%rip), %xmm0    # 0x16f088
ucomisd %xmm1, %xmm0
jb 0x9d3d1
movss -0x4(%rbp), %xmm0
leaq 0x2ceed4(%rip), %rax    # 0x36c294
movss %xmm0, (%rax)
leaq 0x2cf211(%rip), %rax    # 0x36c5dc
movl $0x1, (%rax)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x9d417
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xd1c24(%rip), %xmm0    # 0x16f018
ucomisd %xmm1, %xmm0
jbe 0x9d417
movss -0x8(%rbp), %xmm0
leaq 0x2cee92(%rip), %rax    # 0x36c298
movss %xmm0, (%rax)
leaq 0x2cf1c7(%rip), %rax    # 0x36c5d8
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_sv6_osc_offset()
void get_sv6_osc_offset()
{
float ofs;

   log_packet_id("Packet 0x4D (SV6_FAMILY osc offset)");
   ofs = tsip_single();
   check_tsip_end(1);

   osc_offset = (double)ofs/1000.0;
   have_osc_offset = 666;
   have_rcvr_osc = 666;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe7a97(%rip), %rdi     # 0x184ec6
callq 0x7add0
callq 0x7a860
movss %xmm0, -0x4(%rbp)
movl $0x1, %edi
callq 0x7aee0
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xd1bd7(%rip), %xmm1    # 0x16f030
divsd %xmm1, %xmm0
leaq 0x2ce53c(%rip), %rax    # 0x36b9a0
movsd %xmm0, (%rax)
leaq 0x2cefa5(%rip), %rax    # 0x36c414
movl $0x29a, (%rax)          # imm = 0x29A
leaq 0x2cefac(%rip), %rax    # 0x36c428
movl $0x29a, (%rax)          # imm = 0x29A
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_sv6_utc_info()
void get_sv6_utc_info()
{
double a0;
float a1;
short delta_ls;
float tot;
double wn_lsf;
unsigned short wnt;
unsigned short dn;
short delta_lsf;
int wraps;

   log_packet_id("Packet 0x4F (UTC leapsecond info)");

   a0 = tsip_double();
   a1 = tsip_single();
   delta_ls = tsip_word();
   tot = tsip_single();
   wnt = tsip_word();
   wn_lsf = (double) (short) tsip_word();
   wraps = gps_week / 1024;
   wn_lsf += (wraps * 1024);
// while(wn_lsf < (double) gps_week) {  // adjust for week rollovers
//    wn_lsf += 1024.0;
// }
   dn = tsip_word();
   delta_lsf = tsip_word();

   minor_alarms &= (~MINOR_LEAP_PEND);
   if(delta_ls != delta_lsf) {
      minor_alarms |= MINOR_LEAP_PEND;
   }
   calc_leap_days(wn_lsf, dn, 10);
   have_leap_info = 33;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xe7a3b(%rip), %rdi     # 0x184f0a
callq 0x7add0
callq 0x7a9d0
movsd %xmm0, -0x8(%rbp)
callq 0x7a860
movss %xmm0, -0xc(%rbp)
callq 0x7a560
movw %ax, -0xe(%rbp)
callq 0x7a860
movss %xmm0, -0x14(%rbp)
callq 0x7a560
movw %ax, -0x22(%rbp)
callq 0x7a560
cwtl
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x20(%rbp)
leaq 0x2cf3fe(%rip), %rax    # 0x36c918
movzwl (%rax), %eax
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
shll $0xa, %eax
cvtsi2sd %eax, %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x7a560
movw %ax, -0x24(%rbp)
callq 0x7a560
movw %ax, -0x26(%rbp)
leaq 0x2cee63(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
leaq 0x2cee54(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
movswl -0xe(%rbp), %eax
movswl -0x26(%rbp), %ecx
cmpl %ecx, %eax
je 0x9d58a
leaq 0x2cee3f(%rip), %rax    # 0x36c3b8
movl (%rax), %ecx
orl $0x80, %ecx
leaq 0x2cee30(%rip), %rax    # 0x36c3b8
movl %ecx, (%rax)
movsd -0x20(%rbp), %xmm0
movl $0xa, %esi
movzwl -0x24(%rbp), %edi
callq 0x80110
leaq 0x2ceed4(%rip), %rax    # 0x36c478
movl $0x21, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_clock_bias()
void get_clock_bias()
{
float bias;
float bias_rate;
float time_of_fix;
static int last_tof = (-1);

   log_packet_id("Packet 0x54 (single sat clock bias)");

   bias = tsip_single();
   bias_rate = tsip_single();
   time_of_fix = tsip_single();
   check_tsip_end(1);
   if(tsip_error) return;

   if(last_tof != (int) time_of_fix) {
      if(SV6_FAMILY || PALISADE || (have_pri_time == 0)) {
         sv6_time_code(time_of_fix);
         sat_count = 1;
      }
      last_tof = (int) time_of_fix;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe755d(%rip), %rdi     # 0x184f2c
callq 0x7add0
callq 0x7a860
movss %xmm0, -0x4(%rbp)
callq 0x7a860
movss %xmm0, -0x8(%rbp)
callq 0x7a860
movss %xmm0, -0xc(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x20074d(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0x9da0d
jmp 0x9daa4
movl 0x12bb61(%rip), %eax    # 0x1c9574
cvttss2si -0xc(%rbp), %ecx
cmpl %ecx, %eax
je 0x9daa4
leaq 0x1da089(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
jne 0x9da5d
leaq 0x1dc780(%rip), %rax    # 0x27a1b4
cmpl $0x36, (%rax)
je 0x9da82
leaq 0x1dc774(%rip), %rax    # 0x27a1b4
cmpl $0x33, (%rax)
je 0x9da82
leaq 0x1dc768(%rip), %rax    # 0x27a1b4
cmpl $0x50, (%rax)
je 0x9da82
leaq 0x1dc75c(%rip), %rax    # 0x27a1b4
cmpl $0x41, (%rax)
je 0x9da82
leaq 0x1da04c(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
jne 0x9da76
leaq 0x1dc743(%rip), %rax    # 0x27a1b4
cmpl $0x50, (%rax)
je 0x9da82
leaq 0x20063b(%rip), %rax    # 0x29e0b8
cmpl $0x0, (%rax)
jne 0x9da99
movss -0xc(%rbp), %xmm0
callq 0x9d5b0
leaq 0x200659(%rip), %rax    # 0x29e0ec
movl $0x1, (%rax)
cvttss2si -0xc(%rbp), %eax
movl %eax, 0x12bad0(%rip)    # 0x1c9574
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_enu_velocity_fix()
void get_enu_velocity_fix()
{
float x_vel,y_vel,z_vel;
float bias_rate;
float time_of_fix;

   log_packet_id("Packet 0x56 (ENU velocity)");

   x_vel = tsip_single();
   y_vel = tsip_single();
   z_vel = tsip_single();
   bias_rate = tsip_single();
   time_of_fix = tsip_single();
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xe7273(%rip), %rdi     # 0x184f72
callq 0x7add0
callq 0x7a860
movss %xmm0, -0x4(%rbp)
callq 0x7a860
movss %xmm0, -0x8(%rbp)
callq 0x7a860
movss %xmm0, -0xc(%rbp)
callq 0x7a860
movss %xmm0, -0x10(%rbp)
callq 0x7a860
movss %xmm0, -0x14(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x200409(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0x9dd4e
jmp 0x9dd4e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_last_fix_info()
void get_last_fix_info()
{
u08 source_of_fix;
u08 tracking_mode;
float time_of_fix;
u16 week_of_fix;

   log_packet_id("Packet 0x57 (last fix info)");

   source_of_fix = tsip_byte();
   tracking_mode = tsip_byte();
   time_of_fix = tsip_single();
   week_of_fix = tsip_word();
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe721e(%rip), %rdi     # 0x184f8d
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
callq 0x7a510
movb %al, -0x2(%rbp)
callq 0x7a860
movss %xmm0, -0x8(%rbp)
callq 0x7a560
movw %ax, -0xa(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x2003a8(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0x9ddaf
jmp 0x9ddaf
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: parse_tsip_utc(int, int)
void parse_tsip_utc(int prn, int len)
{
int i;
double a0;
float a1;
short delta_ls;
float tot;
double wn_lsf;
unsigned short wnt;
unsigned short dn;
short delta_lsf;
int wraps;

   for(i=4; i<=16; i++) {
      tsip_byte();
   }                      
   a0 = tsip_double();
   a1 = tsip_single();
   delta_ls = tsip_word();
   tot = tsip_single();
   wnt = tsip_word();
   wn_lsf = (double) (short) tsip_word();
   wraps = gps_week / 1024;
   wn_lsf += (wraps * 1024);
//      while(wn_lsf < (double) gps_week) {  // adjust for week rollovers
//         wn_lsf += 1024.0;
//      }
   dn = tsip_word();
   delta_lsf = tsip_word();

   calc_leap_days(wn_lsf, dn, 10);

//sprintf(plot_title, "dls:%d  wnlsf:%g  dn:%d  dlsf:%d   wks:%d  days:%d  %d/%d/%d", 
//delta_ls, wn_lsf, dn, delta_lsf, (int) wn_lsf-gps_week, leap_days, g_year,g_month,g_day);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x4, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jg 0x9f4fb
callq 0x7a510
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9f4e5
callq 0x7a9d0
movsd %xmm0, -0x18(%rbp)
callq 0x7a860
movss %xmm0, -0x1c(%rbp)
callq 0x7a560
movw %ax, -0x1e(%rbp)
callq 0x7a860
movss %xmm0, -0x24(%rbp)
callq 0x7a560
movw %ax, -0x32(%rbp)
callq 0x7a560
cwtl
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq 0x2cd3d7(%rip), %rax    # 0x36c918
movzwl (%rax), %eax
movl $0x400, %ecx            # imm = 0x400
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
shll $0xa, %eax
cvtsi2sd %eax, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x7a560
movw %ax, -0x34(%rbp)
callq 0x7a560
movw %ax, -0x36(%rbp)
movsd -0x30(%rbp), %xmm0
movl $0xa, %esi
movzwl -0x34(%rbp), %edi
callq 0x80110
addq $0x40, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_packet_58()
void get_packet_58()
{
int i;
u08 op;
u08 mode;
int prn;
u08 len;

   log_packet_id("Packet 0x58 (GPS system data)");
   op = tsip_byte();
   mode = tsip_byte();
   prn = tsip_byte();
   len = tsip_byte();

   // mode 2: almanac
   // mode 3: health page
   // mode 4: ionosphere
   // mode 5: UTC params
   // mode 6: ephemeris

   if(mode == 0x05) {  // UTC data
      parse_tsip_utc(prn, len);
   }
   else if(mode == 0x06) { // ephemeris
// if(debug_file) fprintf(debug_file, "get pkt 0x58: op:%d  mode:%d  prn:%d  len:%d\n", op,mode,prn,len);
      parse_tsip_ephem(prn, len);  // prn gotten from message contents
   }
   else {  // unsupported RAW data
      for(i=0; i<len; i++) {   //!!! we should probably process this data
         tsip_byte();
      }
   }

   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe5a0a(%rip), %rdi     # 0x184fa9
callq 0x7add0
callq 0x7a510
movb %al, -0x5(%rbp)
callq 0x7a510
movb %al, -0x6(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0xc(%rbp)
callq 0x7a510
movb %al, -0xd(%rbp)
movzbl -0x6(%rbp), %eax
cmpl $0x5, %eax
jne 0x9f5de
movl -0xc(%rbp), %edi
movzbl -0xd(%rbp), %esi
callq 0x9f4d0
jmp 0x9f61b
movzbl -0x6(%rbp), %eax
cmpl $0x6, %eax
jne 0x9f5f5
movl -0xc(%rbp), %edi
movzbl -0xd(%rbp), %esi
callq 0x9ddd0
jmp 0x9f619
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movzbl -0xd(%rbp), %ecx
cmpl %ecx, %eax
jge 0x9f617
callq 0x7a510
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9f5fc
jmp 0x9f619
jmp 0x9f61b
movl $0x1, %edi
callq 0x7aee0
leaq 0x1feb24(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0x9f633
jmp 0x9f633
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_sat_health()
void get_sat_health()
{
u08 op;
u08 vals[1+32];
u08 i;
u32 val;

   log_packet_id("Packet 0x59 (Sat disable/health)");

   op = tsip_byte();
   if(op == 3) {  // sat selection enabled / disabled
      val = 0;
      for(i=1; i<=32; i++) {
         sat[i].disabled = tsip_byte();
         if(!sat[i].disabled) val |= 1 << (i-1);
      }
      sats_enabled = val;
   }
   else if(op == 6) {  // sat health enabled / disabled
      for(i=1; i<=32; i++) sat[i].forced_healthy = tsip_byte();
   }
   else if((op == 0) && (tsip_type == STARLOC_TYPE)) { // bogus packet!
      for(i=1; i<=31; i++) vals[i] = tsip_byte();  // note: 00 op plus 31 bytes of zeroes
   }
   else {  // unknown type field
      for(i=1; i<=32; i++) vals[i] = tsip_byte();
   }
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0xe5978(%rip), %rdi     # 0x184fc7
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x3, %eax
jne 0x9f6ec
movl $0x0, -0x38(%rbp)
movb $0x1, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x20, %eax
jg 0x9f6db
callq 0x7a510
movb %al, %cl
movzbl -0x31(%rbp), %eax
movl %eax, %edx
leaq 0x1feaff(%rip), %rax    # 0x29e190
imulq $0x348, %rdx, %rdx      # imm = 0x348
addq %rdx, %rax
movb %cl, 0x1(%rax)
movzbl -0x31(%rbp), %eax
movl %eax, %ecx
leaq 0x1feae5(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
cmpb $0x0, 0x1(%rax)
jne 0x9f6cf
movzbl -0x31(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
orl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x9f6d1
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x9f674
movl -0x38(%rbp), %ecx
leaq 0x2ccbdf(%rip), %rax    # 0x36c2c4
movl %ecx, (%rax)
jmp 0x9f798
movzbl -0x1(%rbp), %eax
cmpl $0x6, %eax
jne 0x9f72f
movb $0x1, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x20, %eax
jg 0x9f72d
callq 0x7a510
movb %al, %cl
movzbl -0x31(%rbp), %eax
movl %eax, %edx
leaq 0x1fea7a(%rip), %rax    # 0x29e190
imulq $0x348, %rdx, %rdx      # imm = 0x348
addq %rdx, %rax
movb %cl, 0x2(%rax)
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x9f6f9
jmp 0x9f796
movzbl -0x1(%rbp), %eax
cmpl $0x0, %eax
jne 0x9f76c
leaq 0x1daa75(%rip), %rax    # 0x27a1b4
cmpl $0x53, (%rax)
jne 0x9f76c
movb $0x1, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x1f, %eax
jg 0x9f76a
callq 0x7a510
movb %al, %cl
movzbl -0x31(%rbp), %eax
movb %cl, -0x30(%rbp,%rax)
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x9f748
jmp 0x9f794
movb $0x1, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
cmpl $0x20, %eax
jg 0x9f792
callq 0x7a510
movb %al, %cl
movzbl -0x31(%rbp), %eax
movb %cl, -0x30(%rbp,%rax)
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x9f770
jmp 0x9f794
jmp 0x9f796
jmp 0x9f798
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fe9a7(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0x9f7b0
jmp 0x9f7b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_eph_status()
void get_eph_status()
{
int prn;

   log_packet_id("Packet 0x5B (Sat ephemeris status)");

   prn = tsip_byte();
if(0 && debug_file) fprintf(debug_file, "\neph status %02d\n", prn);  //rnx3
   if((prn == 0) && (tsip_type == STARLOC_TYPE)) {  // bogus message
      for(prn=1; prn<=15; prn++) tsip_byte();
   }
   else {
      if(prn > MAX_PRN) prn = 0;  // !!!! max_sat_check - put any bogus data in unused entry in array
      if(prn < 1) prn = 0;  // !!!! max_sat_check - put any bogus data in unused entry in array

      sat[prn].eph_time = tsip_single();
      sat[prn].eph_health = tsip_byte();
      sat[prn].iode = (u08) tsip_byte();
      sat[prn].toe = tsip_single();
      sat[prn].fit_flag = tsip_byte();
      sat[prn].sv_accuracy = tsip_single();
      check_tsip_end(1);

      if(have_accu == 0) need_redraw = 2004;
      have_accu = 1;
if(0 && debug_file) {
   gregorian(0, jd_utc);
   fprintf(debug_file, "got eph status %d: %02d/%02d/%02d\n", prn, g_hours,g_minutes,g_seconds);
}
   }
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe555c(%rip), %rdi     # 0x18500b
callq 0x7add0
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x9faf3
leaq 0x1da6e8(%rip), %rax    # 0x27a1b4
cmpl $0x53, (%rax)
jne 0x9faf3
movl $0x1, -0x4(%rbp)
cmpl $0xf, -0x4(%rbp)
jg 0x9faee
callq 0x7a510
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9fad8
jmp 0x9fc0c
cmpl $0x3e7, -0x4(%rbp)      # imm = 0x3E7
jle 0x9fb03
movl $0x0, -0x4(%rbp)
cmpl $0x1, -0x4(%rbp)
jge 0x9fb10
movl $0x0, -0x4(%rbp)
callq 0x7a860
movslq -0x4(%rbp), %rcx
leaq 0x1fe670(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movss %xmm0, 0x1ec(%rax)
callq 0x7a510
movb %al, %cl
movslq -0x4(%rbp), %rdx
leaq 0x1fe64c(%rip), %rax    # 0x29e190
imulq $0x348, %rdx, %rdx      # imm = 0x348
addq %rdx, %rax
movb %cl, 0x1f0(%rax)
callq 0x7a510
movb %al, %cl
movslq -0x4(%rbp), %rdx
leaq 0x1fe62a(%rip), %rax    # 0x29e190
imulq $0x348, %rdx, %rdx      # imm = 0x348
addq %rdx, %rax
movb %cl, 0x1f1(%rax)
callq 0x7a860
movslq -0x4(%rbp), %rcx
leaq 0x1fe60a(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movss %xmm0, 0x1f4(%rax)
callq 0x7a510
movb %al, %cl
movslq -0x4(%rbp), %rdx
leaq 0x1fe5e6(%rip), %rax    # 0x29e190
imulq $0x348, %rdx, %rdx      # imm = 0x348
addq %rdx, %rax
movb %cl, 0x1f8(%rax)
callq 0x7a860
movslq -0x4(%rbp), %rcx
leaq 0x1fe5c6(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
movss %xmm0, 0x1fc(%rax)
movl $0x1, %edi
callq 0x7aee0
leaq 0x2cc9b3(%rip), %rax    # 0x36c5a0
cmpl $0x0, (%rax)
jne 0x9fbff
leaq 0x1d7e2b(%rip), %rax    # 0x277a24
movl $0x7d4, (%rax)          # imm = 0x7D4
leaq 0x2cc99a(%rip), %rax    # 0x36c5a0
movl $0x1, (%rax)
leaq 0x1fe53d(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0x9fc1a
jmp 0x9fc1a
addq $0x10, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_fix_status()
void get_fix_status()
{
int fix_status;
int meas;

   log_packet_id("Packet 0x5E (Additional fix status)");

   fix_status = tsip_byte();
   meas = tsip_byte();
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe50da(%rip), %rdi     # 0x185049
callq 0x7add0
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x4(%rbp)
callq 0x7a510
movzbl %al, %eax
movl %eax, -0x8(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fe1b5(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0x9ffa2
jmp 0x9ffa2
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_eeprom_status()
void get_eeprom_status()
{
u08 flag;
u16 ee_status;

   log_packet_id("Packet 0x5F (EEPROM status)");

   flag = tsip_byte();
   if(flag == 0x11) {
      ee_status = tsip_word();
   }

   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe50ae(%rip), %rdi     # 0x18506d
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x11, %eax
jne 0x9ffde
callq 0x7a560
movw %ax, -0x4(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fe161(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0x9fff6
jmp 0x9fff6
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_filter_config()
void get_filter_config()
{
   log_packet_id("Packet 0x70 (Filter config)");

   pv_filter = tsip_byte();
   static_filter = tsip_byte();
   alt_filter = tsip_byte();
   kalman_filter = tsip_byte();
   have_filter = (PV_FILTER | STATIC_FILTER | ALT_FILTER | KALMAN_FILTER);
   // Note: the ACUTIME and PALISADE return this value, but is not
   //       documented.  Can we set the filters?  !!!!!
   check_tsip_end(1);
   if(tsip_error) return;

   saw_version |= 0x80;
if(just_read) return;

   saw_kalman_on |= kalman_filter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe4c7d(%rip), %rdi     # 0x1850c8
callq 0x7add0
callq 0x7a510
movb %al, %cl
leaq 0x2cbe1a(%rip), %rax    # 0x36c278
movb %cl, (%rax)
callq 0x7a510
movb %al, %cl
leaq 0x2cbe0b(%rip), %rax    # 0x36c279
movb %cl, (%rax)
callq 0x7a510
movb %al, %cl
leaq 0x2cbdfc(%rip), %rax    # 0x36c27a
movb %cl, (%rax)
callq 0x7a510
movb %al, %cl
leaq 0x2cbded(%rip), %rax    # 0x36c27b
movb %cl, (%rax)
leaq 0x2cbdd9(%rip), %rax    # 0x36c270
movl $0xf, (%rax)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fdca2(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa04b5
jmp 0xa04fc
leaq 0x2cc12c(%rip), %rax    # 0x36c5e8
movl (%rax), %ecx
orl $0x80, %ecx
leaq 0x2cc11d(%rip), %rax    # 0x36c5e8
movl %ecx, (%rax)
leaq 0x2f5d24(%rip), %rax    # 0x3961f8
cmpb $0x0, (%rax)
je 0xa04db
jmp 0xa04fc
leaq 0x2cbd99(%rip), %rax    # 0x36c27b
movzbl (%rax), %ecx
leaq 0x2cc118(%rip), %rax    # 0x36c604
movzbl (%rax), %eax
orl %ecx, %eax
movb %al, %cl
leaq 0x2cc10a(%rip), %rax    # 0x36c604
movb %cl, (%rax)
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_posn_filter()
void get_posn_filter()
{
int mode;
float f1,f2,f3,f4,f5;
int i1,i2,i3,i4,i5;

   log_packet_id("Packet 0x72 (SV6_FAMILY position filter)");

   mode = tsip_word();
   f1 = tsip_single();
   i1 = tsip_word();
   i2 = tsip_word();
   i3 = tsip_word();
   i4 = tsip_word();
   f2 = tsip_single();
   f3 = tsip_single();
   f4 = tsip_single();
   f5 = tsip_single();
   i5 = tsip_word();
   check_tsip_end(1);
//sprintf(debug_text3, "i: %f %f %f %f %f", f1,f2,f3,f4,f5);
//sprintf(debug_text2, "i: %d %d %d %d %d", i1,i2,i3,i4,i5);
//sprintf(debug_text, "posn:%d  err:%04X", mode, tsip_error);
   if(i5 == 65535) static_filter = 0;
   else            static_filter = 1;
   have_filter |= STATIC_FILTER;

   if(f1 == 1.0) pv_filter = 0;
   else          pv_filter = 1;
   have_filter |= PV_FILTER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xe4bd5(%rip), %rdi     # 0x1850e4
callq 0x7add0
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
callq 0x7a860
movss %xmm0, -0x8(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x1c(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x20(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x28(%rbp)
callq 0x7a860
movss %xmm0, -0xc(%rbp)
callq 0x7a860
movss %xmm0, -0x10(%rbp)
callq 0x7a860
movss %xmm0, -0x14(%rbp)
callq 0x7a860
movss %xmm0, -0x18(%rbp)
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x2c(%rbp)
movl $0x1, %edi
callq 0x7aee0
cmpl $0xffff, -0x2c(%rbp)    # imm = 0xFFFF
jne 0xa05a7
leaq 0x2cbcd7(%rip), %rax    # 0x36c279
movb $0x0, (%rax)
jmp 0xa05b1
leaq 0x2cbccb(%rip), %rax    # 0x36c279
movb $0x1, (%rax)
leaq 0x2cbcb8(%rip), %rax    # 0x36c270
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x2cbcac(%rip), %rax    # 0x36c270
movl %ecx, (%rax)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xcea91(%rip), %xmm1    # 0x16f068
ucomisd %xmm1, %xmm0
jne 0xa05eb
jp 0xa05eb
leaq 0x2cbc92(%rip), %rax    # 0x36c278
movb $0x0, (%rax)
jmp 0xa05f5
leaq 0x2cbc86(%rip), %rax    # 0x36c278
movb $0x1, (%rax)
leaq 0x2cbc74(%rip), %rax    # 0x36c270
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x2cbc68(%rip), %rax    # 0x36c270
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_alt_filter()
void get_alt_filter()
{
float mode;

   log_packet_id("Packet 0x74 (High-8 mode)");

   mode = tsip_single();
   check_tsip_end(1);

   if(tsip_error) return;
   if(mode > 1) alt_filter = 1;
   else         alt_filter = 0;
   have_filter |= ALT_FILTER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe4aee(%rip), %rdi     # 0x18510d
callq 0x7add0
callq 0x7a860
movss %xmm0, -0x4(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fdb11(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa0646
jmp 0xa0683
movss -0x4(%rbp), %xmm0
movss 0xd12e9(%rip), %xmm1    # 0x17193c
ucomiss %xmm1, %xmm0
jbe 0xa0664
leaq 0x2cbc1b(%rip), %rax    # 0x36c27a
movb $0x1, (%rax)
jmp 0xa066e
leaq 0x2cbc0f(%rip), %rax    # 0x36c27a
movb $0x0, (%rax)
leaq 0x2cbbfb(%rip), %rax    # 0x36c270
movl (%rax), %ecx
orl $0x4, %ecx
leaq 0x2cbbef(%rip), %rax    # 0x36c270
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_ecef_fix()
void get_ecef_fix()
{
double clock_bias;
double fix_x,fix_y,fix_z;
float time_of_fix;

   log_packet_id("Packet 0x83 (XYZ ECEF)");

   fix_x = tsip_double();
   fix_y = tsip_double();
   fix_z = tsip_double();
   clock_bias = tsip_double();
   time_of_fix = tsip_single();
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xe4a59(%rip), %rdi     # 0x1851b8
callq 0x7add0
callq 0x7a9d0
movsd %xmm0, -0x10(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x18(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x20(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x8(%rbp)
callq 0x7a860
movss %xmm0, -0x24(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fd9a9(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa07ae
jmp 0xa07ae
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_lla_fix()
void get_lla_fix()
{
double xlat, xlon, xalt;
double clock_bias;
float time_of_fix;

   log_packet_id("Packet 0x84 (LLA fix)");

   xlat = tsip_double();
   xlon = tsip_double();
   xalt = tsip_double();
   clock_bias = tsip_double();
   time_of_fix = tsip_single();
   check_tsip_end(1);
   if(tsip_error) return;

   if(SV6_FAMILY || PALISADE || (have_pri_time == 0)) {
      sv6_time_code(time_of_fix);

      lat = xlat;
      lon = xlon;
      alt = xalt;
      #ifdef PRECISE_STUFF
         precise_check();
      #endif
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xe4a00(%rip), %rdi     # 0x1851cf
callq 0x7add0
callq 0x7a9d0
movsd %xmm0, -0x8(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x10(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x18(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x20(%rbp)
callq 0x7a860
movss %xmm0, -0x24(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fd939(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa0821
jmp 0xa08c2
leaq 0x1d7288(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
jne 0xa085e
leaq 0x1d997f(%rip), %rax    # 0x27a1b4
cmpl $0x36, (%rax)
je 0xa0883
leaq 0x1d9973(%rip), %rax    # 0x27a1b4
cmpl $0x33, (%rax)
je 0xa0883
leaq 0x1d9967(%rip), %rax    # 0x27a1b4
cmpl $0x50, (%rax)
je 0xa0883
leaq 0x1d995b(%rip), %rax    # 0x27a1b4
cmpl $0x41, (%rax)
je 0xa0883
leaq 0x1d724b(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
jne 0xa0877
leaq 0x1d9942(%rip), %rax    # 0x27a1b4
cmpl $0x50, (%rax)
je 0xa0883
leaq 0x1fd83a(%rip), %rax    # 0x29e0b8
cmpl $0x0, (%rax)
jne 0xa08c2
movss -0x24(%rbp), %xmm0
callq 0x9d5b0
movsd -0x8(%rbp), %xmm0
leaq 0x2cb917(%rip), %rax    # 0x36c1b0
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
leaq 0x2cb90f(%rip), %rax    # 0x36c1b8
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
leaq 0x2cb907(%rip), %rax    # 0x36c1c0
movsd %xmm0, (%rax)
callq 0x15a160
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_datums()
void get_datums()
{
int index;
double dx;
double dy;
double dz;
double a_axis;
double ecc;

   log_packet_id("Packet 0x8F.15 (Datums)");

   index = tsip_word();
   dx = tsip_double();
   dy = tsip_double();
   dz = tsip_double();
   a_axis = tsip_double();
   ecc = tsip_double();
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0xe4906(%rip), %rdi     # 0x1851e5
callq 0x7add0
callq 0x7a560
movzwl %ax, %eax
movl %eax, -0x4(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x10(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x18(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x20(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x28(%rbp)
callq 0x7a9d0
movsd %xmm0, -0x30(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fd81e(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa0939
jmp 0xa0939
addq $0x30, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: fix_manuf_params()
void fix_manuf_params()
{
   if(luxor) return;
   if(rcvr_type != TSIP_RCVR) return;
   if(SV6_FAMILY) return;

   send_tsip_start(0x8E);
   send_byte(0x41);
   send_word(0x1234);           //prefix
   send_dword(0x56789ABCL);     // sn
   send_byte(10);               // yr
   send_byte(1);    // mo
   send_byte(2);    //day
   send_byte(3);    // hr
   send_single(0.0F);    // build offset
   send_word(0);    // test code
   send_tsip_end();

   save_segment(0xFF, 27);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1fd7d3(%rip), %rax    # 0x29e11e
cmpb $0x0, (%rax)
je 0xa0955
jmp 0xa0a19
leaq 0x1d7154(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
je 0xa0967
jmp 0xa0a19
leaq 0x1d7142(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
jne 0xa09a6
leaq 0x1d9839(%rip), %rax    # 0x27a1b4
cmpl $0x36, (%rax)
je 0xa09a4
leaq 0x1d982d(%rip), %rax    # 0x27a1b4
cmpl $0x33, (%rax)
je 0xa09a4
leaq 0x1d9821(%rip), %rax    # 0x27a1b4
cmpl $0x50, (%rax)
je 0xa09a4
leaq 0x1d9815(%rip), %rax    # 0x27a1b4
cmpl $0x41, (%rax)
jne 0xa09a6
jmp 0xa0a19
movl $0x8e, %edi
callq 0x824f0
movl $0x41, %edi
callq 0x7b210
movl $0x1234, %edi           # imm = 0x1234
callq 0x7b4b0
movl $0x56789abc, %edi       # imm = 0x56789ABC
callq 0x7b520
movl $0xa, %edi
callq 0x7b210
movl $0x1, %edi
callq 0x7b210
movl $0x2, %edi
callq 0x7b210
movl $0x3, %edi
callq 0x7b210
xorps %xmm0, %xmm0
callq 0x7b600
xorl %edi, %edi
callq 0x7b4b0
callq 0x82590
movl $0xff, %edi
movl $0x1b, %esi
callq 0x90d70
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: show_manuf_params()
void show_manuf_params()
{
   if(rcvr_type != TSIP_RCVR) return;

   have_info |= MANUF_PARAMS;

   if(text_mode && first_key) return;
   if(zoom_screen) return;
   if(luxor) return;
   if(just_read) return;

   show_build_info(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1d6dd5(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
je 0xa0ce3
jmp 0xa0d43
leaq 0x2cbe6a(%rip), %rax    # 0x36cb54
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x2cbe5e(%rip), %rax    # 0x36cb54
movl %ecx, (%rax)
leaq 0x1d6cb9(%rip), %rax    # 0x2779b8
cmpl $0x0, (%rax)
je 0xa0d12
leaq 0x1fd42d(%rip), %rax    # 0x29e138
cmpl $0x0, (%rax)
je 0xa0d12
jmp 0xa0d43
leaq 0x2cac6f(%rip), %rax    # 0x36b988
cmpb $0x0, (%rax)
je 0xa0d20
jmp 0xa0d43
leaq 0x1fd3f7(%rip), %rax    # 0x29e11e
cmpb $0x0, (%rax)
je 0xa0d2e
jmp 0xa0d43
leaq 0x2f54c3(%rip), %rax    # 0x3961f8
cmpb $0x0, (%rax)
je 0xa0d3c
jmp 0xa0d43
xorl %edi, %edi
callq 0xfd130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_prodn_params()
void get_prodn_params()
{
u16 rsvd2;
u16 rsvd1;

   log_packet_id("Packet 0x8F.42 (Production Params)");

   prodn_options = tsip_byte();
   prodn_extn = tsip_byte();
   case_prefix = tsip_word();
   case_sn = tsip_dword();
   prodn_num = tsip_dword();
   rsvd1 = tsip_word();
   machine_id = tsip_word();
   rsvd2 = tsip_word();
   check_tsip_end(1);
   if(tsip_error) return;

   have_info |= PRODN_PARAMS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe44de(%rip), %rdi     # 0x18523d
callq 0x7add0
callq 0x7a510
movb %al, %cl
leaq 0x2cbe02(%rip), %rax    # 0x36cb74
movb %cl, (%rax)
callq 0x7a510
movb %al, %cl
leaq 0x2cbdf3(%rip), %rax    # 0x36cb75
movb %cl, (%rax)
callq 0x7a560
movw %ax, %cx
leaq 0x2cbde3(%rip), %rax    # 0x36cb76
movw %cx, (%rax)
callq 0x7a680
movl %eax, %ecx
leaq 0x2cbdd4(%rip), %rax    # 0x36cb78
movl %ecx, (%rax)
callq 0x7a680
movl %eax, %ecx
leaq 0x2cbdc8(%rip), %rax    # 0x36cb7c
movl %ecx, (%rax)
callq 0x7a560
movw %ax, -0x4(%rbp)
callq 0x7a560
movw %ax, %cx
leaq 0x2cbdb2(%rip), %rax    # 0x36cb80
movw %cx, (%rax)
callq 0x7a560
movw %ax, -0x2(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fd365(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa0df2
jmp 0xa0e07
leaq 0x2cbd5b(%rip), %rax    # 0x36cb54
movl (%rax), %ecx
orl $0x2, %ecx
leaq 0x2cbd4f(%rip), %rax    # 0x36cb54
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_segment_info()
void get_segment_info()
{
u08 seg_info;

   log_packet_id("Packet 0x8F.45 (EEPROM Segment Info)");

   seg_info = tsip_byte();
   check_tsip_end(1);
   if(tsip_error) return;
   have_seg_info = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe4441(%rip), %rdi     # 0x185260
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fd313(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa0e44
jmp 0xa0e51
leaq 0x2cbd11(%rip), %rax    # 0x36cb5c
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_pps_settings()
void get_pps_settings()
{
u08 pps_rsvd;
float bias_threshold;

   log_packet_id("Packet 0x8F.4A (PPS settings)");

   pps_enabled = tsip_byte();
   have_pps_enable = 1;
   pps_rsvd = tsip_byte();
   pps_polarity = tsip_byte();
   have_pps_polarity = 1;
   cable_delay = tsip_double();
   bias_threshold = tsip_single();
   check_tsip_end(1);

// if(have_cable_delay == 0) need_redraw = 2005;
   have_cable_delay = 1;
   if(tsip_error) return;

   if(text_mode && first_key) return;
   if(zoom_screen) return;
   if(luxor) return;
if(just_read) return;

   saw_version |= 0x40;
   show_cable_delay();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe4416(%rip), %rdi     # 0x185285
callq 0x7add0
callq 0x7a510
movb %al, %cl
leaq 0x2cc07e(%rip), %rax    # 0x36cf00
movb %cl, (%rax)
leaq 0x2cb631(%rip), %rax    # 0x36c4bc
movl $0x1, (%rax)
callq 0x7a510
movb %al, -0x1(%rbp)
callq 0x7a510
movzbl %al, %ecx
leaq 0x2cc050(%rip), %rax    # 0x36cef8
movl %ecx, (%rax)
leaq 0x2cb60f(%rip), %rax    # 0x36c4c0
movl $0x1, (%rax)
callq 0x7a9d0
leaq 0x2cc0e5(%rip), %rax    # 0x36cfa8
movsd %xmm0, (%rax)
callq 0x7a860
movss %xmm0, -0x8(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x2cb5b2(%rip), %rax    # 0x36c494
movl $0x1, (%rax)
leaq 0x1fd261(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa0ef6
jmp 0xa0f54
leaq 0x1d6abb(%rip), %rax    # 0x2779b8
cmpl $0x0, (%rax)
je 0xa0f10
leaq 0x1fd22f(%rip), %rax    # 0x29e138
cmpl $0x0, (%rax)
je 0xa0f10
jmp 0xa0f54
leaq 0x2caa71(%rip), %rax    # 0x36b988
cmpb $0x0, (%rax)
je 0xa0f1e
jmp 0xa0f54
leaq 0x1fd1f9(%rip), %rax    # 0x29e11e
cmpb $0x0, (%rax)
je 0xa0f2c
jmp 0xa0f54
leaq 0x2f52c5(%rip), %rax    # 0x3961f8
cmpb $0x0, (%rax)
je 0xa0f3a
jmp 0xa0f54
leaq 0x2cb6a7(%rip), %rax    # 0x36c5e8
movl (%rax), %ecx
orl $0x40, %ecx
leaq 0x2cb69b(%rip), %rax    # 0x36c5e8
movl %ecx, (%rax)
callq 0xa0f60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_pps_mode()
void get_pps_mode()
{
   log_packet_id("Packet 0x8F.4E (pps rate)");

   pps_rate = tsip_byte();
   have_pps_rate = 2;
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe4148(%rip), %rdi     # 0x1852a3
callq 0x7add0
callq 0x7a510
movb %al, %cl
leaq 0x2cbd95(%rip), %rax    # 0x36cf03
movb %cl, (%rax)
leaq 0x2cb339(%rip), %rax    # 0x36c4b0
movl $0x2, (%rax)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fcfc2(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa1195
jmp 0xa1195
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_dac_values()
void get_dac_values()
{
u32 dac_value;
float dac_voltage;
u08 dac_res;
u08 dac_format;
float dac_min, dac_max;

   log_packet_id("Packet 0x8F.A0 (DAC values)");

   dac_value = tsip_dword();
   dac_voltage = tsip_single();
   dac_res = tsip_byte();
   dac_format = tsip_byte();
   dac_min = tsip_single();
   dac_max = tsip_single();
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0xe410e(%rip), %rdi     # 0x1852bd
callq 0x7add0
callq 0x7a680
movl %eax, -0x4(%rbp)
callq 0x7a860
movss %xmm0, -0x8(%rbp)
callq 0x7a510
movb %al, -0x9(%rbp)
callq 0x7a510
movb %al, -0xa(%rbp)
callq 0x7a860
movss %xmm0, -0x10(%rbp)
callq 0x7a860
movss %xmm0, -0x14(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fcf55(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa1202
jmp 0xa1202
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_osc_sense()
void get_osc_sense()
{
   log_packet_id("Packet 0x8F.A1 (10 MHz sense)");
// not avilable on ThunderBolt-E or early ThunderBolts

   osc_polarity = tsip_byte();
   have_osc_polarity = 1;
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe40be(%rip), %rdi     # 0x1852d9
callq 0x7add0
callq 0x7a510
movb %al, %cl
leaq 0x2cbcc4(%rip), %rax    # 0x36cef2
movb %cl, (%rax)
leaq 0x2cb291(%rip), %rax    # 0x36c4c8
movl $0x1, (%rax)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fcf02(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa1255
jmp 0xa1255
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_timing_mode()
void get_timing_mode()
{
   log_packet_id("Packet 0x8F.A2 (Timing mode)");
   if(STARLOC) { // receiver randomly changes reported timing mode
      return;
   }

   timing_mode = tsip_byte();
timing_mode &= (TMODE_UTC);
if(timing_mode != TMODE_GPS) timing_mode = TMODE_UTC;
   have_rcvr_tmode = 1;
   have_timing_mode = 1;
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe408c(%rip), %rdi     # 0x1852f7
callq 0x7add0
leaq 0x1d6839(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
jne 0xa128b
leaq 0x1d8f30(%rip), %rax    # 0x27a1b4
cmpl $0x53, (%rax)
jne 0xa128b
jmp 0xa12fe
callq 0x7a510
movb %al, %cl
leaq 0x2cb404(%rip), %rax    # 0x36c69d
movb %cl, (%rax)
leaq 0x2cb3fb(%rip), %rax    # 0x36c69d
movzbl (%rax), %eax
andl $0x3, %eax
movb %al, %cl
leaq 0x2cb3ec(%rip), %rax    # 0x36c69d
movb %cl, (%rax)
leaq 0x2cb3e3(%rip), %rax    # 0x36c69d
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0xa12cc
leaq 0x2cb3d4(%rip), %rax    # 0x36c69d
movb $0x3, (%rax)
leaq 0x2cb2dd(%rip), %rax    # 0x36c5b0
movl $0x1, (%rax)
leaq 0x2cb2cc(%rip), %rax    # 0x36c5ac
movl $0x1, (%rax)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fce59(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa12fe
jmp 0xa12fe
popq %rbp
retq
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_packet_mask()
void get_packet_mask()
{
u16 mask1;
u16 mask2;

   log_packet_id("Packet 0x8F.A5 (Packet mask)");

   mask1 = tsip_word();
   mask2 = tsip_word();
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe4005(%rip), %rdi     # 0x185314
callq 0x7add0
callq 0x7a560
movw %ax, -0x2(%rbp)
callq 0x7a560
movw %ax, -0x4(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fce19(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa133e
jmp 0xa133e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_survey_params()
void get_survey_params()
{
u08 survey_flag;
u32 rsvd;

   log_packet_id("Packet 0x8F.A9 (Survey params)");

   survey_flag = tsip_byte();
   survey_save = tsip_byte();
   survey_length = tsip_dword();
   rsvd = tsip_dword();
   check_tsip_end(1);
   if(tsip_error) return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe367a(%rip), %rdi     # 0x185379
callq 0x7add0
callq 0x7a510
movb %al, -0x1(%rbp)
callq 0x7a510
movb %al, %cl
leaq 0x2cb33a(%rip), %rax    # 0x36d054
movb %cl, (%rax)
callq 0x7a680
movl %eax, %ecx
leaq 0x2cb326(%rip), %rax    # 0x36d050
movl %ecx, (%rax)
callq 0x7a680
movl %eax, -0x8(%rbp)
movl $0x1, %edi
callq 0x7aee0
leaq 0x1fc40b(%rip), %rax    # 0x29e150
cmpl $0x0, (%rax)
je 0xa1d4c
jmp 0xa1d4c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: get_comp_time()
void get_comp_time()
{
int i;
char sat_id[8];

   log_packet_id("Packet 0x8F.0B (Comprehensive timing)");

   tsip_word();   // event count
   tsip_dword();  // time of week
   tsip_byte();   // day
   tsip_byte();   // month
   tsip_word();   // year
   tsip_byte();   // receiver mode
   tsip_word();   // utc offset
   tsip_double(); // osc bias  (meters)
   tsip_double(); // osc drift (meters/sec)
   tsip_single(); // osc bias uncertainty (meters)
   tsip_single(); // osc drift uncertainty (meters/sec)
   tsip_double(); // lat
   tsip_double(); // lon
   tsip_double(); // alt

   for(i=0; i<8; i++) { // id of tracking/usable sats
      sat_id[i] = tsip_byte();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xe3469(%rip), %rdi     # 0x185398
callq 0x7add0
callq 0x7a560
callq 0x7a680
callq 0x7a510
callq 0x7a510
callq 0x7a560
callq 0x7a510
callq 0x7a560
callq 0x7a9d0
callq 0x7a9d0
callq 0x7a860
callq 0x7a860
callq 0x7a9d0
callq 0x7a9d0
callq 0x7a9d0
movl $0x0, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jge 0xa1fa1
callq 0x7a510
movb %al, %cl
movslq -0x4(%rbp), %rax
movb %cl, -0xc(%rbp,%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa1f81
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: do_pps_adev(double)
void do_pps_adev(double val)
{
   // perform adev calc on a receiver PPS value

   if(pps_adevs_cleared) ; // skip the first point after clearing adevs
   else if(pps_adev_period > 0.0) {  // using receiver data
     if(++pps_adev_time >= pps_adev_period) {   // add this data point to adev data queues  aaaahhhh assumes 1Hz
        add_pps_adev_point(val, 0);
        pps_adev_time = 0.0;
     }
   }
   pps_adevs_cleared = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x1f74a4(%rip), %rax    # 0x29be48
cmpl $0x0, (%rax)
je 0xa49ab
jmp 0xa4a08
leaq 0x1f752e(%rip), %rax    # 0x29bee0
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa4a06
movsd 0xca6a1(%rip), %xmm0    # 0x16f068
leaq 0x1f735a(%rip), %rax    # 0x29bd28
addsd (%rax), %xmm0
leaq 0x1f734f(%rip), %rax    # 0x29bd28
movsd %xmm0, (%rax)
leaq 0x1f74fc(%rip), %rax    # 0x29bee0
ucomisd (%rax), %xmm0
jb 0xa4a04
movsd -0x8(%rbp), %xmm0
xorl %edi, %edi
callq 0x161540
leaq 0x1f732b(%rip), %rax    # 0x29bd28
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0xa4a06
jmp 0xa4a08
leaq 0x1f7439(%rip), %rax    # 0x29be48
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: do_osc_adev(double)
void do_osc_adev(double val)
{
   // perform adev calc on a receiver OSC value

   if(osc_adevs_cleared) ; // skip the first point after clearing adevs
   else if(osc_adev_period > 0.0) {  // using receiver data
     if(++osc_adev_time >= osc_adev_period) {   // add this data point to adev data queues  aaaahhhh assumes 1Hz
        add_osc_adev_point(val, 0);
        osc_adev_time = 0.0;
     }
   }
   osc_adevs_cleared = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
leaq 0x1f7418(%rip), %rax    # 0x29be4c
cmpl $0x0, (%rax)
je 0xa4a3b
jmp 0xa4a98
leaq 0x1f74a6(%rip), %rax    # 0x29bee8
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa4a96
movsd 0xca611(%rip), %xmm0    # 0x16f068
leaq 0x1f731a(%rip), %rax    # 0x29bd78
addsd (%rax), %xmm0
leaq 0x1f730f(%rip), %rax    # 0x29bd78
movsd %xmm0, (%rax)
leaq 0x1f7474(%rip), %rax    # 0x29bee8
ucomisd (%rax), %xmm0
jb 0xa4a94
movsd -0x8(%rbp), %xmm0
xorl %edi, %edi
callq 0x161c60
leaq 0x1f72eb(%rip), %rax    # 0x29bd78
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0xa4a96
jmp 0xa4a98
leaq 0x1f73ad(%rip), %rax    # 0x29be4c
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: build_vis_table()
void build_vis_table()
{
int prn;
int i, j;

   // Build a list of sat PRNs with the tracked sats at the start.
   // This is used to speed up getting ephermeris data from tracked sats first.

   for(prn=1; prn<=32; prn++) {  // init the table
      vis_table[prn] = prn;
   }

   i = 1;
   vis_sat_count = 0;
   for(prn=1; prn<=32; prn++) {
      if(sat[prn].tracking) {
         j =  vis_table[prn];
         vis_table[prn] = vis_table[i];
         vis_table[i] = j;

         ++vis_sat_count;
         ++i;
      }
   }

   if(0 && log_file) {
      --i;
      fprintf(log_file, "#vis %d:", i);
      for(prn=1; prn<=32; prn++) {
         fprintf(log_file, " %02X", vis_table[prn]);
         if(prn == i) fprintf(log_file, " - ");
      }
      fprintf(log_file, "\n");
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jg 0xa4f0d
movl -0x4(%rbp), %edx
movslq -0x4(%rbp), %rcx
leaq 0x32b001(%rip), %rax    # 0x3cff00
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa4eeb
movl $0x1, -0x8(%rbp)
movl $0x0, 0x32b06a(%rip)    # 0x3cff88
movl $0x1, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jg 0xa4fb3
movslq -0x4(%rbp), %rcx
leaq 0x1f9256(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
cmpl $0x0, 0x218(%rax)
je 0xa4fa3
movslq -0x4(%rbp), %rcx
leaq 0x32afa8(%rip), %rax    # 0x3cff00
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x32af97(%rip), %rax    # 0x3cff00
movl (%rax,%rcx,4), %edx
movslq -0x4(%rbp), %rcx
leaq 0x32af89(%rip), %rax    # 0x3cff00
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %edx
movslq -0x8(%rbp), %rcx
leaq 0x32af78(%rip), %rax    # 0x3cff00
movl %edx, (%rax,%rcx,4)
movl 0x32aff7(%rip), %eax    # 0x3cff88
addl $0x1, %eax
movl %eax, 0x32afee(%rip)    # 0x3cff88
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa4fa5
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa4f25
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: poll_raw_data()
void poll_raw_data()
{
int i;
static int vis_seq = 0;

   // ask for raw observation data

   if(rcvr_type != TSIP_RCVR) return;
   if(raw_msg_rate == 0) return;

   build_vis_table();   // get list of visible sats
   if(vis_sat_count) {  // poll for a different visible sat ephemeris once a second
      request_system_data(6, vis_table[vis_seq+1]);
      request_eph_status(vis_table[vis_seq+1]);
      if(++vis_seq > 32) vis_seq = 0;
      if(vis_seq > vis_sat_count) vis_seq = 0;
   }

   if((0 && ACU_360)) {  // poll for sats raw data individually  rnx
      for(i=1; i<=vis_sat_count; i++) {  
         if(vis_table[i]) {
            request_last_raw(vis_table[i]);
         }
      }
   }
   else {  // get all sats raw data
      request_last_raw(0x00);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1d2ae1(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
je 0xa4fda
jmp 0xa5073
leaq 0x1d5577(%rip), %rax    # 0x27a558
cmpl $0x0, (%rax)
jne 0xa4feb
jmp 0xa5073
callq 0xa4ee0
cmpl $0x0, 0x32af91(%rip)    # 0x3cff88
je 0xa506c
movl 0x32af8d(%rip), %eax    # 0x3cff8c
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x32aef4(%rip), %rax    # 0x3cff00
movl (%rax,%rcx,4), %esi
movl $0x6, %edi
callq 0x8e8b0
movl 0x32af6d(%rip), %eax    # 0x3cff8c
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x32aed4(%rip), %rax    # 0x3cff00
movl (%rax,%rcx,4), %edi
callq 0x8fe80
movl 0x32af52(%rip), %eax    # 0x3cff8c
addl $0x1, %eax
movl %eax, 0x32af49(%rip)    # 0x3cff8c
cmpl $0x20, %eax
jle 0xa5052
movl $0x0, 0x32af3a(%rip)    # 0x3cff8c
movl 0x32af34(%rip), %eax    # 0x3cff8c
cmpl 0x32af2a(%rip), %eax    # 0x3cff88
jle 0xa506a
movl $0x0, 0x32af22(%rip)    # 0x3cff8c
jmp 0xa506c
xorl %edi, %edi
callq 0x8fef0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)