LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: show_sun_moon(int, int)
void show_sun_moon(int row, int col)
{
   sun_moon_shown = 0;
   if(all_adevs) return;

//sprintf(plot_title, "zoom: %c   params:%d", zoom_screen, osc_params);
   sun_moon_shown = col;
   if(luxor) {
      sun_el = sun_posn(jd_utc, 0);
      have_sun_el = 1;
      log_sun_posn();

      if(do_moonrise) calc_moonrise();
      else            calc_sunrise(0.0, 21);
      --row;
   }
   else if(rcvr_type == NO_RCVR) ++row;
   else if(1 && (rcvr_type == RFTG_RCVR) && osc_params) {
      if(zoom_screen == 'C') return;
      if(zoom_screen == 'L') return;
   }
// else if(SCREEN_HEIGHT >= SHORT_SCREEN) ; // ++row;
// if(rcvr_type == TSIP_RCVR) col += 42;  // gggg

   show_sun_azel(row+1, col);
   if(text_mode || (SCREEN_HEIGHT >= MEDIUM_HEIGHT)) {
      show_moon_azel(row+4-1, col);
      show_sun_rise_set(row+3+3, col);
   }
   else if(1 || luxor || (SCREEN_HEIGHT >= SHORT_SCREEN) || (rcvr_type == NO_RCVR)) {
      show_moon_azel(row+3, col);
      show_sun_rise_set(row+3+3, col);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0xe2eb7(%rip), %rax     # 0x1cfe4c
movl $0x0, (%rax)
leaq 0x1aef7c(%rip), %rax    # 0x29bf1e
cmpb $0x0, (%rax)
je 0xecfac
jmp 0xed0ec
movl -0x8(%rbp), %ecx
leaq 0xe2e96(%rip), %rax     # 0x1cfe4c
movl %ecx, (%rax)
leaq 0x1b115f(%rip), %rax    # 0x29e11e
cmpb $0x0, (%rax)
je 0xed01e
leaq 0x27f745(%rip), %rax    # 0x36c710
movsd (%rax), %xmm0
xorl %edi, %edi
callq 0x13cd20
leaq 0x27f9bb(%rip), %rax    # 0x36c998
movsd %xmm0, (%rax)
leaq 0x27f9c0(%rip), %rax    # 0x36c9a8
movl $0x1, (%rax)
callq 0x151220
leaq 0x27f866(%rip), %rax    # 0x36c860
cmpl $0x0, (%rax)
je 0xed006
callq 0x13ddb0
jmp 0xed013
xorps %xmm0, %xmm0
movl $0x15, %edi
callq 0x13e3b0
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xed080
leaq 0x18aa8b(%rip), %rax    # 0x277ab0
cmpq $0x400, (%rax)          # imm = 0x400
jne 0xed039
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xed07e
leaq 0x18aa70(%rip), %rax    # 0x277ab0
cmpq $0x400000, (%rax)       # imm = 0x400000
jne 0xed07c
leaq 0x27f27c(%rip), %rax    # 0x36c2cc
cmpb $0x0, (%rax)
je 0xed07c
leaq 0x27e92c(%rip), %rax    # 0x36b988
movzbl (%rax), %eax
cmpl $0x43, %eax
jne 0xed069
jmp 0xed0ec
leaq 0x27e918(%rip), %rax    # 0x36b988
movzbl (%rax), %eax
cmpl $0x4c, %eax
jne 0xed07a
jmp 0xed0ec
jmp 0xed07c
jmp 0xed07e
jmp 0xed080
movl -0x4(%rbp), %edi
addl $0x1, %edi
movl -0x8(%rbp), %esi
callq 0xec420
leaq 0x18a923(%rip), %rax    # 0x2779b8
cmpl $0x0, (%rax)
jne 0xed0a9
leaq 0x18a943(%rip), %rax    # 0x2779e4
cmpl $0x2c6, (%rax)          # imm = 0x2C6
jl 0xed0cd
movl -0x4(%rbp), %edi
addl $0x4, %edi
subl $0x1, %edi
movl -0x8(%rbp), %esi
callq 0xec6a0
movl -0x4(%rbp), %edi
addl $0x3, %edi
addl $0x3, %edi
movl -0x8(%rbp), %esi
callq 0xec9f0
jmp 0xed0ec
movl -0x4(%rbp), %edi
addl $0x3, %edi
movl -0x8(%rbp), %esi
callq 0xec6a0
movl -0x4(%rbp), %edi
addl $0x3, %edi
addl $0x3, %edi
movl -0x8(%rbp), %esi
callq 0xec9f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: warn_info_needed()
void warn_info_needed()
{
int i;

   // warn the user we need location and/or UTC offset

   i = 0;
   if((lat != 0.0) || (lon != 0.0)) ;
   else {
      vidstr(VAL_ROW+i,VAL_COL, RED, "No location set.  ");
      ++i;
      vidstr(VAL_ROW+i,VAL_COL, RED, "Use the SL command");
      ++i;
      vidstr(VAL_ROW+i,VAL_COL, RED, "to set it.        ");
      ++i;
      if(rcvr_type == NO_RCVR) ++i;
   }

   if(have_utc_ofs < 0) {    // using estimated value
      vidstr(VAL_ROW+i,VAL_COL, RED, "UTC leapsecond   ");
      ++i;
      vidstr(VAL_ROW+i,VAL_COL, RED, "offset guessed.  ");
      ++i;
      vidstr(VAL_ROW+i,VAL_COL, RED, "Use the /uo=#    ");
      ++i;
      vidstr(VAL_ROW+i,VAL_COL, RED, "command to set it");
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x27c4ba(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xefd1d
jp 0xefd1d
leaq 0x27c4ac(%rip), %rax    # 0x36c1b8
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xefd1d
jp 0xefd1d
jmp 0xefd22
jmp 0xefdac
movl -0x4(%rbp), %edi
addl $0x0, %edi
movl $0xf, %esi
movl $0xc, %edx
leaq 0x9a555(%rip), %rcx     # 0x18a28e
callq 0x10ee0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
addl $0x0, %edi
movl $0xf, %esi
movl $0xc, %edx
leaq 0x9a543(%rip), %rcx     # 0x18a2a1
callq 0x10ee0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
addl $0x0, %edi
movl $0xf, %esi
movl $0xc, %edx
leaq 0x9a531(%rip), %rcx     # 0x18a2b4
callq 0x10ee0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
leaq 0x187d18(%rip), %rax    # 0x277ab0
cmpq $0x400, (%rax)          # imm = 0x400
jne 0xefdaa
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xefdac
leaq 0x27c749(%rip), %rax    # 0x36c4fc
cmpl $0x0, (%rax)
jge 0xefe47
movl -0x4(%rbp), %edi
addl $0x0, %edi
movl $0xf, %esi
movl $0xc, %edx
leaq 0x9a4f4(%rip), %rcx     # 0x18a2c7
callq 0x10ee0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
addl $0x0, %edi
movl $0xf, %esi
movl $0xc, %edx
leaq 0x9a4e1(%rip), %rcx     # 0x18a2d9
callq 0x10ee0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
addl $0x0, %edi
movl $0xf, %esi
movl $0xc, %edx
leaq 0x9a4ce(%rip), %rcx     # 0x18a2eb
callq 0x10ee0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
addl $0x0, %edi
movl $0xf, %esi
movl $0xc, %edx
leaq 0x9a4bb(%rip), %rcx     # 0x18a2fd
callq 0x10ee0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: utm_lon_zone(double, double)
int utm_lon_zone(double dLat, double dLon)
{
int zone;

   // longitude must be between -180.00 .. 179.9
   if((dLon < -180.0) || (dLon > 180.0)) return (0); // implies failure: 0 is an invalid utm zone

   zone = (int)((180.0 + dLon) / 6.0 + 1.0);

   if((dLat >= 56.0) && (dLat < 64.0)) { // sw Norge (ie, zone 32V)
     if((dLon >= 3.0) && (dLon < 12.0)) zone = 32;
   }
   else if((dLat >= 72.0 && dLat < 84.0)) {  // special zones for Svalbard
     if     ((dLon >= 0.0)  && (dLon < 9.0))  zone = 31;
     else if((dLon >= 9.0)  && (dLon < 21.0)) zone = 33;
     else if((dLon >= 21.0) && (dLon < 33.0)) zone = 35;
     else if((dLon >= 33.0) && (dLon < 42.0)) zone = 37;
   }

   return zone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd 0x7b2da(%rip), %xmm0    # 0x16f070
ucomisd -0x18(%rbp), %xmm0
ja 0xf3db0
movsd -0x18(%rbp), %xmm0
movsd 0x7b2ce(%rip), %xmm1    # 0x16f078
ucomisd %xmm1, %xmm0
jbe 0xf3dbc
movl $0x0, -0x4(%rbp)
jmp 0xf3f1a
movsd 0x7b2b4(%rip), %xmm0    # 0x16f078
addsd -0x18(%rbp), %xmm0
movsd 0x8f29f(%rip), %xmm1    # 0x183070
divsd %xmm1, %xmm0
movsd 0x7b28b(%rip), %xmm1    # 0x16f068
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x8f393(%rip), %xmm1    # 0x183188
ucomisd %xmm1, %xmm0
jb 0xf3e38
movsd 0x8f1cd(%rip), %xmm0    # 0x182fd0
ucomisd -0x10(%rbp), %xmm0
jbe 0xf3e38
movsd -0x18(%rbp), %xmm0
movsd 0x7b3c9(%rip), %xmm1    # 0x16f1e0
ucomisd %xmm1, %xmm0
jb 0xf3e33
movsd 0x8f32b(%rip), %xmm0    # 0x183150
ucomisd -0x18(%rbp), %xmm0
jbe 0xf3e33
movl $0x20, -0x1c(%rbp)
jmp 0xf3f14
movsd -0x10(%rbp), %xmm0
movsd 0x8f34b(%rip), %xmm1    # 0x183190
ucomisd %xmm1, %xmm0
jb 0xf3f12
movsd 0x8f341(%rip), %xmm0    # 0x183198
ucomisd -0x10(%rbp), %xmm0
jbe 0xf3f12
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xf3e8b
movsd 0x8edd8(%rip), %xmm0    # 0x182c50
ucomisd -0x18(%rbp), %xmm0
jbe 0xf3e8b
movl $0x1f, -0x1c(%rbp)
jmp 0xf3f10
movsd -0x18(%rbp), %xmm0
movsd 0x8edb8(%rip), %xmm1    # 0x182c50
ucomisd %xmm1, %xmm0
jb 0xf3eb6
movsd 0x8f2fa(%rip), %xmm0    # 0x1831a0
ucomisd -0x18(%rbp), %xmm0
jbe 0xf3eb6
movl $0x21, -0x1c(%rbp)
jmp 0xf3f0e
movsd -0x18(%rbp), %xmm0
movsd 0x8f2dd(%rip), %xmm1    # 0x1831a0
ucomisd %xmm1, %xmm0
jb 0xf3ee1
movsd 0x8f2d7(%rip), %xmm0    # 0x1831a8
ucomisd -0x18(%rbp), %xmm0
jbe 0xf3ee1
movl $0x23, -0x1c(%rbp)
jmp 0xf3f0c
movsd -0x18(%rbp), %xmm0
movsd 0x8f2ba(%rip), %xmm1    # 0x1831a8
ucomisd %xmm1, %xmm0
jb 0xf3f0a
movsd 0x8f2b4(%rip), %xmm0    # 0x1831b0
ucomisd -0x18(%rbp), %xmm0
jbe 0xf3f0a
movl $0x25, -0x1c(%rbp)
jmp 0xf3f0c
jmp 0xf3f0e
jmp 0xf3f10
jmp 0xf3f12
jmp 0xf3f14
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: dms_fmt(double)
char *dms_fmt(double x)
{
int deg, min;
double sec;
static char s[128+1];
char sign;

   if(x < 0.0) {
      x = 0.0-x;
      sign = '-';
   }
   else sign = '+';

   deg = (int) x;
   min = (int) (60.0 * ((double) x - (double) deg));
   sec = ((x - (double) deg) - ((double) min / 60.0)) * 3600.0;
   sprintf(s, "%c%2dd %02dm %9.6fs", sign, deg, min, sec);
   return &s[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0xf4d6a
xorps %xmm0, %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movb $0x2d, -0x19(%rbp)
jmp 0xf4d6e
movb $0x2b, -0x19(%rbp)
cvttsd2si -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movsd -0x8(%rbp), %xmm1
cvtsi2sdl -0xc(%rbp), %xmm0
subsd %xmm0, %xmm1
movsd 0x7a28c(%rip), %xmm0    # 0x16f018
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
subsd %xmm1, %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
movsd 0x7a266(%rip), %xmm2    # 0x16f018
divsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd 0x7a24e(%rip), %xmm1    # 0x16f010
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsbl -0x19(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
movsd -0x18(%rbp), %xmm0
leaq 0x2e09ce(%rip), %rdi    # 0x3d57b0
leaq 0x95889(%rip), %rsi     # 0x18a672
movb $0x1, %al
callq 0x9060
leaq 0x2e09b9(%rip), %rax    # 0x3d57b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: show_build_info(int)
void show_build_info(int force)
{
   if(rcvr_type != TSIP_RCVR) return;

   if(build_month > 12) build_month = 0;
   if(build_ok || force) {
      sprintf(out, "Mfg: %02d:00  %02d %s %04d", 
         build_hour, build_day, months[build_month], build_year);
      vidstr(VER_ROW+3, VER_COL, WHITE, out);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x17a96e(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
je 0xfd14d
jmp 0xfd1e9
leaq 0x26fa16(%rip), %rax    # 0x36cb6a
movzbl (%rax), %eax
cmpl $0xc, %eax
jle 0xfd166
leaq 0x26fa07(%rip), %rax    # 0x36cb6a
movb $0x0, (%rax)
leaq 0x26f467(%rip), %rax    # 0x36c5d4
cmpl $0x0, (%rax)
jne 0xfd178
cmpl $0x0, -0x4(%rbp)
je 0xfd1e9
leaq 0x26f9ed(%rip), %rax    # 0x36cb6c
movzbl (%rax), %edx
leaq 0x26f9e2(%rip), %rax    # 0x36cb6b
movzbl (%rax), %ecx
leaq 0x26f9d7(%rip), %rax    # 0x36cb6a
movzbl (%rax), %eax
movl %eax, %esi
leaq 0xcc5a1(%rip), %rax     # 0x1c9740
movq (%rax,%rsi,8), %r8
leaq 0x26f9be(%rip), %rax    # 0x36cb68
movzwl (%rax), %r9d
leaq 0x29e24b(%rip), %rdi    # 0x39b400
leaq 0x8e1e5(%rip), %rsi     # 0x18b3a1
movb $0x0, %al
callq 0x9060
leaq 0x17a7aa(%rip), %rax    # 0x277974
movl (%rax), %edi
addl $0x3, %edi
leaq 0x17a7a2(%rip), %rax    # 0x277978
movl (%rax), %esi
movl $0xf, %edx
leaq 0x29e21c(%rip), %rcx    # 0x39b400
callq 0x10ee0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: show_unit_info()
void show_unit_info()
{
   if(rcvr_type != TSIP_RCVR) return;
   if(ap_month > 12) ap_month = 0;
   if(core_month > 12) core_month = 0;

   if(have_info & VERSION_INFO) {
      if(unit_name[0] == 0) {
         sprintf(out, "App: %2d.%-2d  %02d %s %02d", 
            ap_major, ap_minor,  ap_day, months[ap_month], ap_year);   //!!! docs say 1900
         vidstr(VER_ROW+1, VER_COL, WHITE, out);
      }

      sprintf(out, "GPS: %2d.%-2d  %02d %s %02d", 
         core_major, core_minor,  core_day, months[core_month], core_year);  //!!! docs say 1900
      vidstr(VER_ROW+2, VER_COL, WHITE, out);
   }

   show_build_info(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x17a8b1(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
je 0xfd20a
jmp 0xfd363
leaq 0x26f975(%rip), %rax    # 0x36cb86
movzbl (%rax), %eax
cmpl $0xc, %eax
jle 0xfd223
leaq 0x26f966(%rip), %rax    # 0x36cb86
movb $0x0, (%rax)
leaq 0x26f962(%rip), %rax    # 0x36cb8c
movzbl (%rax), %eax
cmpl $0xc, %eax
jle 0xfd23c
leaq 0x26f953(%rip), %rax    # 0x36cb8c
movb $0x0, (%rax)
leaq 0x26f911(%rip), %rax    # 0x36cb54
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xfd35c
leaq 0x29e5c8(%rip), %rax    # 0x39b820
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xfd2de
leaq 0x26f91d(%rip), %rax    # 0x36cb84
movzbl (%rax), %edx
leaq 0x26f914(%rip), %rax    # 0x36cb85
movzbl (%rax), %ecx
leaq 0x26f90c(%rip), %rax    # 0x36cb87
movzbl (%rax), %r8d
leaq 0x26f900(%rip), %rax    # 0x36cb86
movzbl (%rax), %eax
movl %eax, %esi
leaq 0xcc4ae(%rip), %rax     # 0x1c9740
movq (%rax,%rsi,8), %r9
leaq 0x26f8eb(%rip), %rax    # 0x36cb88
movzwl (%rax), %eax
leaq 0x29e159(%rip), %rdi    # 0x39b400
leaq 0x8e10e(%rip), %rsi     # 0x18b3bc
movl %eax, (%rsp)
movb $0x0, %al
callq 0x9060
leaq 0x17a6b5(%rip), %rax    # 0x277974
movl (%rax), %edi
addl $0x1, %edi
leaq 0x17a6ad(%rip), %rax    # 0x277978
movl (%rax), %esi
movl $0xf, %edx
leaq 0x29e127(%rip), %rcx    # 0x39b400
callq 0x10ee0
leaq 0x26f8a5(%rip), %rax    # 0x36cb8a
movzbl (%rax), %edx
leaq 0x26f89c(%rip), %rax    # 0x36cb8b
movzbl (%rax), %ecx
leaq 0x26f894(%rip), %rax    # 0x36cb8d
movzbl (%rax), %r8d
leaq 0x26f888(%rip), %rax    # 0x36cb8c
movzbl (%rax), %eax
movl %eax, %esi
leaq 0xcc430(%rip), %rax     # 0x1c9740
movq (%rax,%rsi,8), %r9
leaq 0x26f873(%rip), %rax    # 0x36cb8e
movzwl (%rax), %eax
leaq 0x29e0db(%rip), %rdi    # 0x39b400
leaq 0x8e0ac(%rip), %rsi     # 0x18b3d8
movl %eax, (%rsp)
movb $0x0, %al
callq 0x9060
leaq 0x17a637(%rip), %rax    # 0x277974
movl (%rax), %edi
addl $0x2, %edi
leaq 0x17a62f(%rip), %rax    # 0x277978
movl (%rax), %esi
movl $0xf, %edx
leaq 0x29e0a9(%rip), %rcx    # 0x39b400
callq 0x10ee0
xorl %edi, %edi
callq 0xfd130
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: show_single_sat()
void show_single_sat()
{
   
   if(have_single_prn == 0) {
      vidstr(POSN_ROW+0+eofs,POSN_COL, YELLOW, "Single satellite         ");
   }
   else if(single_sat_prn) {
      sprintf(out, "Single sat: %02d           ", single_sat_prn);
      vidstr(POSN_ROW+0+eofs,POSN_COL, YELLOW, out);
   }
   else {
      vidstr(POSN_ROW+0+eofs,POSN_COL, YELLOW, "Highest satellite        ");
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x26c445(%rip), %rax    # 0x36c2c0
cmpl $0x0, (%rax)
jne 0xffea1
leaq 0x19e299(%rip), %rax    # 0x29e120
movl (%rax), %edi
addl $0x6, %edi
xorl %esi, %esi
movl $0xe, %edx
leaq 0x8c494(%rip), %rcx     # 0x18c32e
callq 0x10ee0
jmp 0xfff0d
leaq 0x26c414(%rip), %rax    # 0x36c2bc
cmpl $0x0, (%rax)
je 0xffeec
leaq 0x26c408(%rip), %rax    # 0x36c2bc
movl (%rax), %edx
leaq 0x29b543(%rip), %rdi    # 0x39b400
leaq 0x8c484(%rip), %rsi     # 0x18c348
movb $0x0, %al
callq 0x9060
leaq 0x19e24e(%rip), %rax    # 0x29e120
movl (%rax), %edi
addl $0x6, %edi
xorl %esi, %esi
movl $0xe, %edx
leaq 0x29b51b(%rip), %rcx    # 0x39b400
callq 0x10ee0
jmp 0xfff0b
leaq 0x19e22d(%rip), %rax    # 0x29e120
movl (%rax), %edi
addl $0x6, %edi
xorl %esi, %esi
movl $0xe, %edx
leaq 0x8c45e(%rip), %rcx     # 0x18c364
callq 0x10ee0
jmp 0xfff0d
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: erase_info_col()
void erase_info_col()
{
int i;
int row;

   // erase the INFO_COL column from the top of the screen to the "VIEW:" line

   row = queue_row;
   if(all_adevs && (SCREEN_WIDTH < WIDE_WIDTH)) return;
   if(rcvr_type == NO_RCVR) return;

   for(i=0; i<=queue_row; i++) {  // erase old info
      if((i < 5) && (SCREEN_WIDTH < MEDIUM_WIDTH)) {  // don't overwrite possible sat prn values  pretty printing
         vidstr(i,INFO_COL, WHITE, "            ");
      }
      else {
         vidstr(i,INFO_COL, WHITE, "              ");
      }
   }

   info_row = 0;
   info_avail = queue_row+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x16e751(%rip), %rax    # 0x2779b0
movl (%rax), %eax
movl %eax, -0x8(%rbp)
leaq 0x192cb3(%rip), %rax    # 0x29bf1e
cmpb $0x0, (%rax)
je 0x109284
leaq 0x16e769(%rip), %rax    # 0x2779e0
cmpl $0x4fa, (%rax)          # imm = 0x4FA
jge 0x109284
jmp 0x109328
leaq 0x16e825(%rip), %rax    # 0x277ab0
cmpq $0x400, (%rax)          # imm = 0x400
jne 0x109299
jmp 0x109328
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x16e706(%rip), %rcx    # 0x2779b0
cmpl (%rcx), %eax
jg 0x10930c
cmpl $0x5, -0x4(%rbp)
jge 0x1092e2
leaq 0x16e725(%rip), %rax    # 0x2779e0
cmpl $0x3e2, (%rax)          # imm = 0x3E2
jge 0x1092e2
movl -0x4(%rbp), %edi
leaq 0x16e6af(%rip), %rax    # 0x27797c
movl (%rax), %esi
movl $0xf, %edx
leaq 0x8d3e6(%rip), %rcx     # 0x1966c1
callq 0x10ee0
jmp 0x1092ff
movl -0x4(%rbp), %edi
leaq 0x16e690(%rip), %rax    # 0x27797c
movl (%rax), %esi
movl $0xf, %edx
leaq 0x8d3c5(%rip), %rcx     # 0x1966bf
callq 0x10ee0
jmp 0x109301
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1092a0
movl $0x0, 0x2c1c66(%rip)    # 0x3caf7c
leaq 0x16e693(%rip), %rax    # 0x2779b0
movl (%rax), %eax
addl $0x1, %eax
movl %eax, 0x2c1c58(%rip)    # 0x3caf80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: request_rcvr_info(int)
void request_rcvr_info(int why)
{
   // NEW_RCVR
   if(no_poll) return;
//wwwww if(SV6_FAMILY) return;  // prevent rcvr buffer overlow ttttt wwwww
if((rcvr_type == TSIP_RCVR) && (tsip_type == STARLOC_TYPE)) return;  // prevent rcvr buffer overlow ttttt wwwww
if(rcvr_type == BRANDY_RCVR) return;  // prevent receiver buffer overflow and time skips
if(rcvr_type == LPFRS_RCVR) return;   // speed up polling loop
if(rcvr_type == PRS_RCVR) return;     // speed up polling loop
if(rcvr_type == SA35_RCVR) return;    // speed up polling loop
if(rcvr_type == SRO_RCVR) return;     // speed up polling loop
if(rcvr_type == RFTG_RCVR) return;    // prevent receiver buffer overflow and time skips
if(rcvr_type == THERMO_RCVR) return;

   request_version();
   request_luxor_ver();        // no SV6
   if(luxor_time_set == 0) {   // no SV6
      set_luxor_time();
   }

   request_utc_info();

   request_pps_info();         // no SV6
   if(rcvr_type != BRANDY_RCVR) {  // request_pps_info does the same thing
      request_pps_mode();      
   }
   request_timing_mode();      // no SV6

   request_filter_config();
   request_rcvr_config(why);
   request_survey_params();    // no SV6

   if(rcvr_type != STAR_RCVR) {  // request_rcvr_config() did this
      request_all_dis_params();  // no SV6
   }

   request_sat_list();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x28cebe(%rip), %rax    # 0x396200
cmpb $0x0, (%rax)
je 0x10934c
jmp 0x109468
leaq 0x16e75d(%rip), %rax    # 0x277ab0
cmpq $0x1, (%rax)
jne 0x10936a
leaq 0x170e54(%rip), %rax    # 0x27a1b4
cmpl $0x53, (%rax)
jne 0x10936a
jmp 0x109468
leaq 0x16e73f(%rip), %rax    # 0x277ab0
cmpq $0x40000, (%rax)        # imm = 0x40000
jne 0x10937f
jmp 0x109468
leaq 0x16e72a(%rip), %rax    # 0x277ab0
cmpq $0x10000000, (%rax)     # imm = 0x10000000
jne 0x109394
jmp 0x109468
leaq 0x16e715(%rip), %rax    # 0x277ab0
cmpq $0x1000000, (%rax)      # imm = 0x1000000
jne 0x1093a9
jmp 0x109468
movabsq $0x1000000000, %rcx     # imm = 0x1000000000
leaq 0x16e6f6(%rip), %rax    # 0x277ab0
cmpq %rcx, (%rax)
jne 0x1093c4
jmp 0x109468
leaq 0x16e6e5(%rip), %rax    # 0x277ab0
cmpq $0x8000000, (%rax)      # imm = 0x8000000
jne 0x1093d9
jmp 0x109468
leaq 0x16e6d0(%rip), %rax    # 0x277ab0
cmpq $0x400000, (%rax)       # imm = 0x400000
jne 0x1093eb
jmp 0x109468
leaq 0x16e6be(%rip), %rax    # 0x277ab0
cmpq $0x80000, (%rax)        # imm = 0x80000
jne 0x1093fd
jmp 0x109468
callq 0x8b430
callq 0xaae30
movzbl 0x2c1bf0(%rip), %eax    # 0x3caffe
cmpl $0x0, %eax
jne 0x109418
callq 0x898d0
callq 0x85b00
callq 0x91720
leaq 0x16e687(%rip), %rax    # 0x277ab0
cmpq $0x40000, (%rax)        # imm = 0x40000
je 0x109437
callq 0x93230
callq 0x94c50
callq 0x902f0
movl -0x4(%rbp), %edi
callq 0x8c270
callq 0x9a9e0
leaq 0x16e65b(%rip), %rax    # 0x277ab0
cmpq $0x1000, (%rax)         # imm = 0x1000
je 0x109463
callq 0x99cb0
callq 0x8bdd0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: nvs_pkt(int)
int nvs_pkt(int id)
{
   // return true if id is a NVS receiver specific TSIP packet
   if     (id == 0x51) return 0;
   else if(id == 0x52) return 0;                 
   else if(id == 0x60) return 1;                 
   else if(id == 0x61) return 1;  //             
   else if(id == 0x72) return 1;  // every second  (!!!!! this could be a SV6 packet)
   else if(id == 0x73) return 0;                 
   else if(id == 0x74) return 0;                 
   else if(id == 0x88) return 1;  // every nav solution
   else if(id == 0x93) return 0;                 
   else if(id == 0xE7) return 0;                 
   else if(id == 0xF5) return 1;  // every second
   else if(id == 0xF7) return 0;                 

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x51, -0x8(%rbp)
jne 0x109a99
movl $0x0, -0x4(%rbp)
jmp 0x109b79
cmpl $0x52, -0x8(%rbp)
jne 0x109aab
movl $0x0, -0x4(%rbp)
jmp 0x109b79
cmpl $0x60, -0x8(%rbp)
jne 0x109abd
movl $0x1, -0x4(%rbp)
jmp 0x109b79
cmpl $0x61, -0x8(%rbp)
jne 0x109acf
movl $0x1, -0x4(%rbp)
jmp 0x109b79
cmpl $0x72, -0x8(%rbp)
jne 0x109ae1
movl $0x1, -0x4(%rbp)
jmp 0x109b79
cmpl $0x73, -0x8(%rbp)
jne 0x109af3
movl $0x0, -0x4(%rbp)
jmp 0x109b79
cmpl $0x74, -0x8(%rbp)
jne 0x109b02
movl $0x0, -0x4(%rbp)
jmp 0x109b79
cmpl $0x88, -0x8(%rbp)
jne 0x109b14
movl $0x1, -0x4(%rbp)
jmp 0x109b79
cmpl $0x93, -0x8(%rbp)
jne 0x109b26
movl $0x0, -0x4(%rbp)
jmp 0x109b79
cmpl $0xe7, -0x8(%rbp)
jne 0x109b38
movl $0x0, -0x4(%rbp)
jmp 0x109b79
cmpl $0xf5, -0x8(%rbp)
jne 0x109b4a
movl $0x1, -0x4(%rbp)
jmp 0x109b79
cmpl $0xf7, -0x8(%rbp)
jne 0x109b5c
movl $0x0, -0x4(%rbp)
jmp 0x109b79
jmp 0x109b5e
jmp 0x109b60
jmp 0x109b62
jmp 0x109b64
jmp 0x109b66
jmp 0x109b68
jmp 0x109b6a
jmp 0x109b6c
jmp 0x109b6e
jmp 0x109b70
jmp 0x109b72
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: ts_data(int)
int ts_data(int k)
{
   if(tsip_buf[k+0] != 0x01) return 0;
   if(tsip_buf[k+4] != ':') return 0;
   if(tsip_buf[k+7] != ':') return 0;
   if(tsip_buf[k+10] != ':') return 0;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $0x0, %eax
movslq %eax, %rcx
leaq 0x28c899(%rip), %rax    # 0x396430
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
je 0x109ba9
movl $0x0, -0x4(%rbp)
jmp 0x109c16
movl -0x8(%rbp), %eax
addl $0x4, %eax
movslq %eax, %rcx
leaq 0x28c877(%rip), %rax    # 0x396430
movzbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
je 0x109bcb
movl $0x0, -0x4(%rbp)
jmp 0x109c16
movl -0x8(%rbp), %eax
addl $0x7, %eax
movslq %eax, %rcx
leaq 0x28c855(%rip), %rax    # 0x396430
movzbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
je 0x109bed
movl $0x0, -0x4(%rbp)
jmp 0x109c16
movl -0x8(%rbp), %eax
addl $0xa, %eax
movslq %eax, %rcx
leaq 0x28c833(%rip), %rax    # 0x396430
movzbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
je 0x109c0f
movl $0x0, -0x4(%rbp)
jmp 0x109c16
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: x72_xxx_dds(double)
double x72_xxx_dds(double dds)
{
int depth;

   // add the current DDS setting to the dds value averaging queue
#define MIN_DEPTH 20  // was *10

   depth = (x72_tc_val / PID_RATE) + 1;
   if(depth < MIN_DEPTH) depth = MIN_DEPTH;

//if(x72_dds_count > x72_tc_val) {  // queue is full, remove oldest entry
//if(x72_dds_count > 120) {  // queue is full, remove oldest entry
//if(x72_dds_count > (x72_tc_val-2)) {  // queue is full, remove oldest entry
   if(x72_dds_count > depth) {  // queue is full, remove oldest entry
      --x72_dds_count;
      x72_dds_sum -= x72_dds_list[x72_dds_out];
      ++x72_dds_out;
      if(x72_dds_out >= depth) x72_dds_out = 0;
   }

   ++x72_dds_count;    // put new entry into the queue
   x72_dds_sum += dds;
   x72_dds_list[x72_dds_in] = dds;
   ++x72_dds_in;
   if(x72_dds_in >= depth) x72_dds_in = 0;

   if(x72_dds_count) dds = x72_dds_sum / (double) x72_dds_count;
   else dds = last_x72_dds;
   filtered_dds = dds;

   return dds;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
leaq 0x1700d4(%rip), %rax    # 0x279fe4
movl (%rax), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x109f2d
movl $0x14, -0xc(%rbp)
leaq 0x1701d4(%rip), %rax    # 0x27a108
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x109f9d
leaq 0x1701c6(%rip), %rax    # 0x27a108
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x1701ba(%rip), %rax    # 0x27a108
movl %ecx, (%rax)
movslq 0x2cf009(%rip), %rcx    # 0x3d8f60
leaq 0x2cba02(%rip), %rax    # 0x3d5960
movsd (%rax,%rcx,8), %xmm1
movsd 0x2cefed(%rip), %xmm0   # 0x3d8f58
subsd %xmm1, %xmm0
movsd %xmm0, 0x2cefe1(%rip)   # 0x3d8f58
movl 0x2cefe3(%rip), %eax    # 0x3d8f60
addl $0x1, %eax
movl %eax, 0x2cefda(%rip)    # 0x3d8f60
movl 0x2cefd4(%rip), %eax    # 0x3d8f60
cmpl -0xc(%rbp), %eax
jl 0x109f9b
movl $0x0, 0x2cefc5(%rip)    # 0x3d8f60
jmp 0x109f9d
leaq 0x170164(%rip), %rax    # 0x27a108
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x170158(%rip), %rax    # 0x27a108
movl %ecx, (%rax)
movsd -0x8(%rbp), %xmm0
addsd 0x2cef99(%rip), %xmm0   # 0x3d8f58
movsd %xmm0, 0x2cef91(%rip)   # 0x3d8f58
movsd -0x8(%rbp), %xmm0
movslq 0x2cef91(%rip), %rcx    # 0x3d8f64
leaq 0x2cb986(%rip), %rax    # 0x3d5960
movsd %xmm0, (%rax,%rcx,8)
movl 0x2cef7f(%rip), %eax    # 0x3d8f64
addl $0x1, %eax
movl %eax, 0x2cef76(%rip)    # 0x3d8f64
movl 0x2cef70(%rip), %eax    # 0x3d8f64
cmpl -0xc(%rbp), %eax
jl 0x10a003
movl $0x0, 0x2cef61(%rip)    # 0x3d8f64
leaq 0x1700fe(%rip), %rax    # 0x27a108
cmpl $0x0, (%rax)
je 0x10a02d
movsd 0x2cef41(%rip), %xmm0   # 0x3d8f58
leaq 0x1700ea(%rip), %rax    # 0x27a108
cvtsi2sdl (%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x10a03d
leaq 0x17008c(%rip), %rax    # 0x27a0c0
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x2cef1e(%rip)   # 0x3d8f68
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: new_x72_interval(int)
void new_x72_interval(int why)
{
unsigned i;

   // start accumulating a new pps interval

   x72_pps_interval = 0;
   x72_dis_sum = 0;
   x72_sum_sum = 0;

   for(i=0; i<X72_PPS_BINS; i++) {
      x72_pps_list[i] = 0;
   }

   x72_sum_y = 0.0;
   x72_sum_x = 0.0; 
   x72_sum_xx = 0.0; 
   x72_sum_yy = 0.0; 
   x72_sum_xy = 0.0; 

   x72_pps_avg = 0.0;
   x72_pps_trend = 0.0;
if(debug_file) fprintf(debug_file, "Clear pps list!  why:%d\n", why);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x170062(%rip), %rax    # 0x27a104
movl $0x0, (%rax)
movl $0x0, 0x2cb7b2(%rip)    # 0x3d5864
movl $0x0, 0x2cb7ac(%rip)    # 0x3d5868
movl $0x0, -0x8(%rbp)
cmpl $0x29, -0x8(%rbp)
jae 0x10a0e7
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x2cb7bb(%rip), %rax    # 0x3d5890
movl $0x0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x10a0c3
xorps %xmm0, %xmm0
movsd %xmm0, 0x2cb846(%rip)   # 0x3d5938
xorps %xmm0, %xmm0
movsd %xmm0, 0x2cb85b(%rip)   # 0x3d5958
xorps %xmm0, %xmm0
movsd %xmm0, 0x2cb848(%rip)   # 0x3d5950
xorps %xmm0, %xmm0
movsd %xmm0, 0x2cb82d(%rip)   # 0x3d5940
xorps %xmm0, %xmm0
movsd %xmm0, 0x2cb82a(%rip)   # 0x3d5948
xorps %xmm0, %xmm0
movsd %xmm0, 0x2cb747(%rip)   # 0x3d5870
leaq 0x16ffe0(%rip), %rax    # 0x27a110
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
leaq 0x193432(%rip), %rax    # 0x29d570
cmpq $0x0, (%rax)
je 0x10a15f
leaq 0x193425(%rip), %rax    # 0x29d570
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x83f3f(%rip), %rsi     # 0x18e097
movb $0x0, %al
callq 0x9550
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: x72_update_pps_list(int)
void x72_update_pps_list(int val)
{
double x;
double y;

   // add a new point to the pps list
   if(dac_dac == 0) {
      if(val < (-X72_PPS_SPREAD)) return;
      if(val > X72_PPS_SPREAD) return;
      ++x72_pps_list[val+X72_PPS_SPREAD];
   }

   x = (double) x72_pps_interval;
   y = (double) val;

   x72_sum_x  += x;      // update trend line data
   x72_sum_y  += y;
   x72_sum_xx += (x * x);
   x72_sum_yy += (y * y);
   x72_sum_xy += (x * y);

   ++x72_pps_interval;   // how many points we have so far for this interval

if(show_debug_info && (last_x72_dmode > 2)) sprintf(debug_text3, "add pps %g: %g  ival:%d  tavg:%g  pid_time:%d   dds_count:%d  in:%d  out:%d  filtered_dds:%g", x, y, x72_ival, x72_sum_y/x, pid_time, x72_dds_count, x72_dds_in, x72_dds_out, filtered_dds);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x29087a(%rip), %rax    # 0x39a9fc
cmpl $0x0, (%rax)
jne 0x10a1bd
cmpl $-0x14, -0x4(%rbp)
jge 0x10a192
jmp 0x10a2f1
cmpl $0x14, -0x4(%rbp)
jle 0x10a19d
jmp 0x10a2f1
movl -0x4(%rbp), %eax
addl $0x14, %eax
movslq %eax, %rcx
leaq 0x2cb6e3(%rip), %rax    # 0x3d5890
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x2cb6d6(%rip), %rax    # 0x3d5890
movl %edx, (%rax,%rcx,4)
leaq 0x16ff40(%rip), %rax    # 0x27a104
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
addsd 0x2cb774(%rip), %xmm0   # 0x3d5958
movsd %xmm0, 0x2cb76c(%rip)   # 0x3d5958
movsd -0x18(%rbp), %xmm0
addsd 0x2cb73f(%rip), %xmm0   # 0x3d5938
movsd %xmm0, 0x2cb737(%rip)   # 0x3d5938
movsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movsd 0x2cb73d(%rip), %xmm1   # 0x3d5950
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x2cb72d(%rip)   # 0x3d5950
movsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movsd 0x2cb70b(%rip), %xmm1   # 0x3d5940
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x2cb6fb(%rip)   # 0x3d5940
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movsd 0x2cb6f1(%rip), %xmm1   # 0x3d5948
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x2cb6e1(%rip)   # 0x3d5948
leaq 0x16fe96(%rip), %rax    # 0x27a104
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x16fe8a(%rip), %rax    # 0x27a104
movl %ecx, (%rax)
leaq 0x16d821(%rip), %rax    # 0x277aa4
cmpb $0x0, (%rax)
je 0x10a2f1
leaq 0x16fe71(%rip), %rax    # 0x27a100
cmpl $0x2, (%rax)
jle 0x10a2f1
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
leaq 0x16fe77(%rip), %rax    # 0x27a11c
movl (%rax), %edx
movsd 0x2cb689(%rip), %xmm2   # 0x3d5938
divsd -0x10(%rbp), %xmm2
movl 0x2cb5d2(%rip), %ecx    # 0x3d588c
leaq 0x16fe47(%rip), %rax    # 0x27a108
movl (%rax), %r8d
movl 0x2cec99(%rip), %r9d    # 0x3d8f64
movl 0x2cec8f(%rip), %eax    # 0x3d8f60
movsd 0x2cec8f(%rip), %xmm3   # 0x3d8f68
leaq 0x293b40(%rip), %rdi    # 0x39de20
leaq 0x83dc9(%rip), %rsi     # 0x18e0b0
movl %eax, (%rsp)
movb $0x4, %al
callq 0x9060
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: x72_init_state0()
void x72_init_state0()
{
   // startup the discipline algorithm

   if(pps_enabled == 0) {  // should never happen
      x72_start_discipline();
      return;
   }

   x72_startup_flag = 1;
   x72_holdover_points = 0;
   x72_idif_sum = 0;
   new_x72_interval(1);
   x72_initial_pps = x72_pps;
   x72_jamsync_ticks = 0;
   if(x72_start_timer < 0) x72_start_timer = 0;

   if(x72_start_timer < 6) {  // wait for 6 seconds to make sure we have TICs
      ++x72_start_timer;
      return;
   }

   if(have_x72_pps) {  // we have a PPS value, now jamsync the PPS out to PPS in
      update_x72_tic(x72_pps, 1);
      x72_idif = x72_pps_diff;
      init_x72_pid();
//x72_user_state = X72_STATE_START1;
x72_user_state = X72_STATE_JAM2;   // we no longer do the holdover stuff
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x262bf5(%rip), %rax    # 0x36cf00
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x10a31d
callq 0xc4ec0
jmp 0x10a3c5
movl $0x1, 0xbf309(%rip)     # 0x1c9630
movl $0x0, 0x2cb51f(%rip)    # 0x3d5850
movl $0x0, 0x2cb509(%rip)    # 0x3d5844
movl $0x1, %edi
callq 0x10a090
leaq 0x16fc90(%rip), %rax    # 0x279fdc
movl (%rax), %eax
movl %eax, 0x2cb500(%rip)    # 0x3d5854
movl $0x0, 0x2cb4fe(%rip)    # 0x3d585c
cmpl $0x0, 0x2cb523(%rip)    # 0x3d5888
jge 0x10a371
movl $0x0, 0x2cb517(%rip)    # 0x3d5888
cmpl $0x6, 0x2cb510(%rip)    # 0x3d5888
jge 0x10a38b
movl 0x2cb508(%rip), %eax    # 0x3d5888
addl $0x1, %eax
movl %eax, 0x2cb4ff(%rip)    # 0x3d5888
jmp 0x10a3c5
leaq 0x16fb1e(%rip), %rax    # 0x279eb0
cmpl $0x0, (%rax)
je 0x10a3c5
leaq 0x16fc3e(%rip), %rax    # 0x279fdc
movl (%rax), %edi
movl $0x1, %esi
callq 0x95a50
movl 0x2c1a0c(%rip), %eax    # 0x3cbdbc
movl %eax, 0x2cb48a(%rip)    # 0x3d5840
callq 0x109ef0
movl $0x5, 0x2c19ef(%rip)    # 0x3cbdb4
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: x72_init_state1()
void x72_init_state1()
{
   // wait for initial 1PPS jamsync to complete
   if(pps_enabled == 0) {  // should never happen
      x72_start_discipline();
      return;
   }

   if(++x72_jamsync_ticks >= 6) {
      x72_jamsync_ticks = 0;
      x72_user_state = X72_STATE_HOLDOVER; // do holdover analysis
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x262b25(%rip), %rax    # 0x36cf00
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x10a3ea
callq 0xc4ec0
jmp 0x10a412
movl 0x2cb46c(%rip), %eax    # 0x3d585c
addl $0x1, %eax
movl %eax, 0x2cb463(%rip)    # 0x3d585c
cmpl $0x6, %eax
jl 0x10a412
movl $0x0, 0x2cb454(%rip)    # 0x3d585c
movl $0x3, 0x2c19a2(%rip)    # 0x3cbdb4
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: x72_holdover_state()
void x72_holdover_state()
{
   // collect a few minutes of data to see how the frequency is drifting
   if(pps_enabled == 0) {  // should never happen
      x72_start_discipline();
      return;
   }
   if(x72_holdover_val <= X72_HOLDOVER_SIZE) x72_holdover_val = X72_HOLDOVER_SIZE;


   x72_idif_sum += x72_pps_diff;
   if(x72_holdover_points == 0) x72_idif_sum = 0;
   ++x72_holdover_points;
   holdover = x72_holdover_points;
if(show_debug_info) sprintf(debug_text6, "holdover state: points:%d  idif:%d  sum:%d  mcv:%g  ival:%d", x72_holdover_points, x72_pps_diff, x72_idif_sum, x72_pps_stats(0), x72_ival);

   if(x72_holdover_points >= x72_holdover_val) {  // now go calculate the drift slope and adjust the DDS
      x72_user_state = X72_STATE_SLOPECALC;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x262ad1(%rip), %rax    # 0x36cf00
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x10a441
callq 0xc4ec0
jmp 0x10a50f
leaq 0x16fba0(%rip), %rax    # 0x279fe8
cmpl $0x78, (%rax)
jg 0x10a45a
leaq 0x16fb94(%rip), %rax    # 0x279fe8
movl $0x78, (%rax)
movl 0x2c195c(%rip), %eax    # 0x3cbdbc
addl 0x2cb3de(%rip), %eax    # 0x3d5844
movl %eax, 0x2cb3d8(%rip)    # 0x3d5844
cmpl $0x0, 0x2cb3dd(%rip)    # 0x3d5850
jne 0x10a47f
movl $0x0, 0x2cb3c5(%rip)    # 0x3d5844
movl 0x2cb3cb(%rip), %eax    # 0x3d5850
addl $0x1, %eax
movl %eax, 0x2cb3c2(%rip)    # 0x3d5850
movl 0x2cb3bc(%rip), %ecx    # 0x3d5850
leaq 0x26219d(%rip), %rax    # 0x36c638
movl %ecx, (%rax)
leaq 0x16d600(%rip), %rax    # 0x277aa4
cmpb $0x0, (%rax)
je 0x10a4f4
movl 0x2cb3a1(%rip), %eax    # 0x3d5850
movl %eax, -0xc(%rbp)
movl 0x2c1904(%rip), %eax    # 0x3cbdbc
movl %eax, -0x8(%rbp)
movl 0x2cb383(%rip), %eax    # 0x3d5844
movl %eax, -0x4(%rbp)
xorl %edi, %edi
callq 0x109c20
movl -0xc(%rbp), %edx
movl -0x8(%rbp), %ecx
movl -0x4(%rbp), %r8d
leaq 0x16fc40(%rip), %rax    # 0x27a11c
movl (%rax), %r9d
leaq 0x293d2a(%rip), %rdi    # 0x39e210
leaq 0x83c20(%rip), %rsi     # 0x18e10d
movb $0x1, %al
callq 0x9060
movl 0x2cb356(%rip), %eax    # 0x3d5850
leaq 0x16fae7(%rip), %rcx    # 0x279fe8
cmpl (%rcx), %eax
jl 0x10a50f
movl $0x9, 0x2c18a5(%rip)    # 0x3cbdb4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: x72_jam1_state()
void x72_jam1_state()
{
static int count = 0;

   // adjust the TIC offset register to align the 1PPS in and 1PPS out

   if(pps_enabled == 0) {  // should never happen
      x72_start_discipline();
      return;
   }

//sprintf(debug_text3, "jamsync pass:%d  flag:%d  pulses:%d", x72_jamsync_pass, x72_jamsync_flag, x72_jamsync_ticks);
   if(x72_jamsync_flag) {
      if(1 || (x72_jamsync_pass == 2)) {
          ++count;
         init_x72_pid();
         update_x72_tic(x72_pps, 2);
         x72_jamsync_ticks = 0;      // we just changed the TIC register to move the PPS output
         x72_jamsync_flag = 0;       // now wait for the change to take effect
      }
   }

   x72_user_state = X72_STATE_JAM2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x262825(%rip), %rax    # 0x36cf00
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x10a6ea
callq 0xc4ec0
jmp 0x10a738
cmpl $0x0, 0x2cb167(%rip)    # 0x3d5858
je 0x10a72e
movl 0x2ce88b(%rip), %eax    # 0x3d8f84
addl $0x1, %eax
movl %eax, 0x2ce882(%rip)    # 0x3d8f84
callq 0x109ef0
leaq 0x16f8ce(%rip), %rax    # 0x279fdc
movl (%rax), %edi
movl $0x2, %esi
callq 0x95a50
movl $0x0, 0x2cb138(%rip)    # 0x3d585c
movl $0x0, 0x2cb12a(%rip)    # 0x3d5858
movl $0x5, 0x2c167c(%rip)    # 0x3cbdb4
popq %rbp
retq
nopw (%rax,%rax)
// File: jkingan[P]ladyheather/heathgps.cpp
// Function: x72_jam2_state()
void x72_jam2_state()
{
   // wait for change in TIC register to complete

   if(pps_enabled == 0) {  // should never happen
      x72_start_discipline();
      return;
   }

   if(++x72_jamsync_ticks >= 6) {  // allow 6 seconds for a TIC change to take effect
      x72_jamsync_ticks = 0;
      new_x72_interval(2);
      x72_user_state = X72_STATE_DISCIPLINE;  // start the disciplining
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2627b5(%rip), %rax    # 0x36cf00
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x10a75a
callq 0xc4ec0
jmp 0x10a78c
movl 0x2cb0fc(%rip), %eax    # 0x3d585c
addl $0x1, %eax
movl %eax, 0x2cb0f3(%rip)    # 0x3d585c
cmpl $0x6, %eax
jl 0x10a78c
movl $0x0, 0x2cb0e4(%rip)    # 0x3d585c
movl $0x2, %edi
callq 0x10a090
movl $0x6, 0x2c1628(%rip)    # 0x3cbdb4
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: end_log_track()
void end_log_track()
{
   if(log_file == 0) return;

   if((log_fmt == GPX) || (log_fmt == XML)) {
      fprintf(log_file, "    </trkseg>\n");
      fprintf(log_file, "  </trk>\n\n");
   }
   else if(log_fmt == KML) {
      fprintf(log_file, "          </coordinates>\n");
      fprintf(log_file, "        </LineString>\n");
      fprintf(log_file, "      </Placemark>\n");
      fprintf(log_file, "    </Folder>\n");
   }
   if(log_flush_mode && log_file) fflush(log_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x191425(%rip), %rax    # 0x29d540
cmpq $0x0, (%rax)
jne 0x10c126
jmp 0x10c206
leaq 0x1914fb(%rip), %rax    # 0x29d628
cmpl $0x14, (%rax)
je 0x10c13e
leaq 0x1914ef(%rip), %rax    # 0x29d628
cmpl $0xa, (%rax)
jne 0x10c170
leaq 0x1913fb(%rip), %rax    # 0x29d540
movq (%rax), %rdi
leaq 0x83754(%rip), %rsi     # 0x18f8a3
movb $0x0, %al
callq 0x9550
leaq 0x1913e3(%rip), %rax    # 0x29d540
movq (%rax), %rdi
leaq 0x8374b(%rip), %rsi     # 0x18f8b2
movb $0x0, %al
callq 0x9550
jmp 0x10c1de
leaq 0x1914b1(%rip), %rax    # 0x29d628
cmpl $0x1e, (%rax)
jne 0x10c1dc
leaq 0x1913bd(%rip), %rax    # 0x29d540
movq (%rax), %rdi
leaq 0x83730(%rip), %rsi     # 0x18f8bd
movb $0x0, %al
callq 0x9550
leaq 0x1913a5(%rip), %rax    # 0x29d540
movq (%rax), %rdi
leaq 0x83732(%rip), %rsi     # 0x18f8d7
movb $0x0, %al
callq 0x9550
leaq 0x19138d(%rip), %rax    # 0x29d540
movq (%rax), %rdi
leaq 0x83731(%rip), %rsi     # 0x18f8ee
movb $0x0, %al
callq 0x9550
leaq 0x191375(%rip), %rax    # 0x29d540
movq (%rax), %rdi
leaq 0x8372d(%rip), %rsi     # 0x18f902
movb $0x0, %al
callq 0x9550
jmp 0x10c1de
leaq 0x19141b(%rip), %rax    # 0x29d600
cmpl $0x0, (%rax)
je 0x10c206
leaq 0x19134f(%rip), %rax    # 0x29d540
cmpq $0x0, (%rax)
je 0x10c206
leaq 0x191342(%rip), %rax    # 0x29d540
movq (%rax), %rdi
callq 0x9430
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: sync_log_file()
void sync_log_file()
{
   if(log_file == 0) return;

   if(log_fmt != HEATHER) {
      end_log_track();
      sync_file(log_file);
      start_log_track();
   }
   else {
      sync_file(log_file);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x18ff05(%rip), %rax    # 0x29d540
cmpq $0x0, (%rax)
jne 0x10d643
jmp 0x10d679
leaq 0x18ffde(%rip), %rax    # 0x29d628
cmpl $0x0, (%rax)
je 0x10d66a
callq 0x10c110
leaq 0x18fee5(%rip), %rax    # 0x29d540
movq (%rax), %rdi
callq 0xaba0
callq 0x10bde0
jmp 0x10d679
leaq 0x18fecf(%rip), %rax    # 0x29d540
movq (%rax), %rdi
callq 0xaba0
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: filter_log_text()
int filter_log_text()
{
char *s;

   // remove potentially corrupting chars from log_text lines
   // returns 0 if resulting line is blank, 1 otherwise

   s = strchr(log_text, '!');
   while(s) {
      *s = ' ';
      s = strchr(s+1, '!');
   }

   s = strchr(log_text, '#');
   while(s) {
      *s = ' ';
      s = strchr(s+1, '#');
   }

   if(log_text[0] == 0) return 0;  // empty line
   if((log_text[0] == ' ') && (log_text[1] == 0)) return 0;  // blank line
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x18f4b1(%rip), %rdi    # 0x29cb40
movl $0x21, %esi
callq 0x9100
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10d6c3
movq -0x10(%rbp), %rax
movb $0x20, (%rax)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl $0x21, %esi
callq 0x9100
movq %rax, -0x10(%rbp)
jmp 0x10d69d
leaq 0x18f476(%rip), %rdi    # 0x29cb40
movl $0x23, %esi
callq 0x9100
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10d6fe
movq -0x10(%rbp), %rax
movb $0x20, (%rax)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl $0x23, %esi
callq 0x9100
movq %rax, -0x10(%rbp)
jmp 0x10d6d8
leaq 0x18f43b(%rip), %rax    # 0x29cb40
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x10d716
movl $0x0, -0x4(%rbp)
jmp 0x10d745
leaq 0x18f423(%rip), %rax    # 0x29cb40
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x10d73e
leaq 0x18f414(%rip), %rax    # 0x29cb40
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x10d73e
movl $0x0, -0x4(%rbp)
jmp 0x10d745
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: write_rinex_line(_IO_FILE*, char*, char*)
void write_rinex_line(FILE *file, char *s, char *type)
{
char buf[SLEN+1];

   // output a 60:20 character line to a RINEX file

   if(file == 0) return;
   if(s == 0) return;
   if(type == 0) return;

   sprintf(buf, "%-60.60s%-20.20s", s,type);
   buf[80] = 0;
   fprintf(file, "%s\n", buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x10d770
jmp 0x10d7bf
cmpq $0x0, -0x10(%rbp)
jne 0x10d779
jmp 0x10d7bf
cmpq $0x0, -0x18(%rbp)
jne 0x10d782
jmp 0x10d7bf
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x82af7(%rip), %rsi     # 0x19028f
movb $0x0, %al
callq 0x9060
movb $0x0, -0xd0(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x120(%rbp), %rdx
leaq 0x7b647(%rip), %rsi     # 0x188dff
movb $0x0, %al
callq 0x9550
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: log_enviro_info()
void log_enviro_info()
{
   strcpy(log_text, "#");
   write_log_comment(1);

   if(enviro_type == HEATHER_ENVIRO) {
      sprintf(log_text, "#   Enviro type:   Heather Environmental Sensor");
   }
   else if(enviro_type == DOG_ENVIRO) {
      if(enviro_dev[0]) sprintf(log_text, "#   Enviro type:   %s", enviro_dev);
      else              sprintf(log_text, "#   Envito type:   Dogratian USB");
   }
   else if(enviro_type == LFS_ENVIRO) {
      if(enviro_dev[0]) sprintf(log_text, "#   Enviro type:   %s", enviro_dev);
      else              sprintf(log_text, "#   Enviro type:   LFS10xx");
   }
   else {
      sprintf(log_text, "#   Enviro type:   Environmental sensor");
   }
   write_log_comment(1);

   if(enviro_sn[0]) {
      sprintf(log_text, "#   Enviro serial: %s", enviro_sn);
      write_log_comment(1);
   }

   strcpy(log_text, "#");
   write_log_comment(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x18f365(%rip), %rdi    # 0x29cb40
leaq 0x645ba(%rip), %rsi     # 0x171d9c
callq 0x9350
movl $0x1, %edi
callq 0x10cbe0
leaq 0x16a2fc(%rip), %rax    # 0x277af4
cmpl $0x2, (%rax)
jne 0x10d817
leaq 0x18f33c(%rip), %rdi    # 0x29cb40
leaq 0x82ab4(%rip), %rsi     # 0x1902bf
movb $0x0, %al
callq 0x9060
jmp 0x10d8ca
leaq 0x16a2d6(%rip), %rax    # 0x277af4
cmpl $0x1, (%rax)
jne 0x10d864
leaq 0x28ec16(%rip), %rax    # 0x39c440
cmpb $0x0, (%rax)
je 0x10d84d
leaq 0x18f30a(%rip), %rdi    # 0x29cb40
leaq 0x82ab2(%rip), %rsi     # 0x1902ef
leaq 0x28ebfc(%rip), %rdx    # 0x39c440
movb $0x0, %al
callq 0x9060
jmp 0x10d862
leaq 0x18f2ec(%rip), %rdi    # 0x29cb40
leaq 0x82aaa(%rip), %rsi     # 0x190305
movb $0x0, %al
callq 0x9060
jmp 0x10d8c8
leaq 0x16a289(%rip), %rax    # 0x277af4
cmpl $0x3, (%rax)
jne 0x10d8b1
leaq 0x28ebc9(%rip), %rax    # 0x39c440
cmpb $0x0, (%rax)
je 0x10d89a
leaq 0x18f2bd(%rip), %rdi    # 0x29cb40
leaq 0x82a65(%rip), %rsi     # 0x1902ef
leaq 0x28ebaf(%rip), %rdx    # 0x39c440
movb $0x0, %al
callq 0x9060
jmp 0x10d8af
leaq 0x18f29f(%rip), %rdi    # 0x29cb40
leaq 0x82a7e(%rip), %rsi     # 0x190326
movb $0x0, %al
callq 0x9060
jmp 0x10d8c6
leaq 0x18f288(%rip), %rdi    # 0x29cb40
leaq 0x82a82(%rip), %rsi     # 0x190341
movb $0x0, %al
callq 0x9060
jmp 0x10d8c8
jmp 0x10d8ca
movl $0x1, %edi
callq 0x10cbe0
leaq 0x28eb85(%rip), %rax    # 0x39c460
cmpb $0x0, (%rax)
je 0x10d906
leaq 0x18f259(%rip), %rdi    # 0x29cb40
leaq 0x82a7b(%rip), %rsi     # 0x190369
leaq 0x28eb6b(%rip), %rdx    # 0x39c460
movb $0x0, %al
callq 0x9060
movl $0x1, %edi
callq 0x10cbe0
leaq 0x18f233(%rip), %rdi    # 0x29cb40
leaq 0x64488(%rip), %rsi     # 0x171d9c
callq 0x9350
movl $0x1, %edi
callq 0x10cbe0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: show_cs_log(int, int, int)
void show_cs_log(int row,int col, int extended)
{
int i;
int count;

   vidstr(row,col, GREEN, "Log: Message");
   ++row;
   count = 0;
   for(i=cs_log_count-1; i>=0; i--) {
      if(cs_log_msg[i][0]) {
         vidstr(row,col, WHITE, &blanks[TEXT_COLS-LOG_MSG_LEN]);
         vidstr(row,col, WHITE, cs_log_msg[i]);
         ++row;
         ++count;
         if(count >= CS_LOG_SHOW) break;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl $0xa, %edx
leaq 0x7d242(%rip), %rcx     # 0x192975
callq 0x10ee0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x164385(%rip), %rax    # 0x279ad4
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x1157ee
movslq -0x10(%rbp), %rcx
leaq 0x1629c4(%rip), %rax    # 0x278130
imulq $0x22, %rcx, %rcx
addq %rcx, %rax
cmpb $0x0, (%rax)
je 0x1157de
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
leaq 0x162263(%rip), %rax    # 0x2779e8
movl (%rax), %eax
subl $0x20, %eax
cltq
leaq 0x285a5d(%rip), %rcx    # 0x39b1f0
addq %rax, %rcx
movl $0xf, %edx
callq 0x10ee0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movslq -0x10(%rbp), %rax
leaq 0x16297f(%rip), %rcx    # 0x278130
imulq $0x22, %rax, %rax
addq %rax, %rcx
movl $0xf, %edx
callq 0x10ee0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jl 0x1157dc
jmp 0x1157ee
jmp 0x1157de
jmp 0x1157e0
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x115757
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)