LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: good_el_level()
int good_el_level()
{
int el;
float max_db;
float r;
#define MAX_GOOD_EL 75

   // find lowest EL level that has good signal
   max_db = 0.0F;
   for(el=0; el<=MAX_GOOD_EL; el++) {  // find max db value
      if(db_el_count[el]) {
         r = db_el_sum[el] / db_el_count[el];
         if(r > max_db) max_db = r;
      }
   }
   if(max_db == 0.0F) return GOOD_EL_LEVEL;

   for(el=0; el<=MAX_GOOD_EL; el++) {
      if(db_el_count[el] && db_el_sum[el]) {
         r = (db_el_sum[el] / db_el_count[el]) / max_db;
         if(r > EL_THRESHOLD) {
            return el;
         }
      }
   }

   return GOOD_EL_LEVEL;
}

// Assembly:
xorps %xmm1, %xmm1
xorl %eax, %eax
leaq 0x77e22(%rip), %rcx     # 0x15ceb0
leaq 0x77cab(%rip), %rdx     # 0x15cd40
xorps %xmm0, %xmm0
cmpq $0x4c, %rax
je 0xe50c0
movss (%rcx,%rax,4), %xmm3
ucomiss %xmm1, %xmm3
jne 0xe50aa
jnp 0xe50bb
movss (%rdx,%rax,4), %xmm2
divss %xmm3, %xmm2
ucomiss %xmm0, %xmm2
jbe 0xe50bb
movaps %xmm2, %xmm0
incq %rax
jmp 0xe5098
movl $0x1e, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xe50d0
jp 0xe50d0
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x11d829(%rip), %rsi    # 0x202904
xorl %edi, %edi
cmpb $0x2, (%rsi)
setae %dil
leaq 0x31595(%rip), %rsi     # 0x116680
movss (%rsi,%rdi,4), %xmm2
xorl %esi, %esi
popq %rbp
cmpq $0x4c, %rsi
je 0xe50cf
movss (%rcx,%rsi,4), %xmm3
ucomiss %xmm1, %xmm3
jne 0xe5105
jnp 0xe511e
movss (%rdx,%rsi,4), %xmm4
ucomiss %xmm1, %xmm4
jne 0xe5111
jnp 0xe511e
divss %xmm3, %xmm4
divss %xmm0, %xmm4
ucomiss %xmm2, %xmm4
ja 0xe5123
incq %rsi
jmp 0xe50f3
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: good_sig_level()
int good_sig_level()
{
float count, sum;
int prn;

   // find reasonable signal level mask setting (0.4 * the average max sig level)

   count = sum = 0.0;
   for(prn=1; prn<=MAX_PRN; prn++) {
      if(max_sat_db[prn]) {
         sum += max_sat_db[prn];
         ++count;
      }
   }

   if(count) {
      sum /= count;
      sum *= 0.40F;
   }
   else {
      sum = GOOD_SIG_LEVEL;
   }

   return (int) (sum+0.50F);
}

// Assembly:
xorps %xmm0, %xmm0
movabsq $0x1, %rax
leaq 0xb8186(%rip), %rcx     # 0x19d2c0
movss 0x11faa(%rip), %xmm1    # 0xf70ec
xorps %xmm5, %xmm5
xorps %xmm2, %xmm2
cmpq $0x3e8, %rax            # imm = 0x3E8
je 0xe517c
movss (%rcx,%rax,4), %xmm3
ucomiss %xmm3, %xmm0
movaps %xmm5, %xmm4
addss %xmm1, %xmm4
jne 0xe5166
jp 0xe5166
movaps %xmm5, %xmm4
addss %xmm2, %xmm3
jne 0xe5171
jp 0xe5171
movaps %xmm2, %xmm3
incq %rax
movaps %xmm4, %xmm5
movaps %xmm3, %xmm2
jmp 0xe5148
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm5
divss %xmm5, %xmm2
mulss 0x31592(%rip), %xmm2    # 0x116724
addss 0x11f5e(%rip), %xmm2    # 0xf70f8
cvttss2si %xmm2, %ecx
movl $0x14, %eax
cmovnel %ecx, %eax
cmovpl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: open_lla_file(int)
void open_lla_file(int why)
{
   if(lla_file == 0) {
//    strcpy(out, LLA_FILE);
      sprintf(out, "%s.lla", unit_file_name);
      lla_file = topen(out, "w");
   }
   if(lla_file == 0) return;
//fprintf(lla_file, "### open_lla_file(%d)\n", why);

   month = fix_month(month);
   fprintf(lla_file, "#TITLE: LLA log %s: %02d %s %04d  %02d:%02d:%02d - receiver mode %d\n", 
      out, day, months[month], year, hours,minutes,seconds, rcvr_mode);
   fprintf(lla_file, "#LLA: %.9f %.9f %.4f\n", precise_lat*RAD_TO_DEG, precise_lon*RAD_TO_DEG, precise_alt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x14318a(%rip), %r14    # 0x2283a0
cmpq $0x0, (%r14)
jne 0xe5259
leaq 0x75a65(%rip), %rax     # 0x15ac88
movq (%rax), %rdx
leaq 0x240ff3(%rip), %rbx    # 0x326220
leaq 0x39ea4(%rip), %rsi     # 0x11f0d8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
leaq 0x260be(%rip), %rsi     # 0x10b303
movq %rbx, %rdi
callq 0x9a22
movq %rax, (%r14)
testq %rax, %rax
je 0xe531c
leaq 0x212278(%rip), %rbx    # 0x2f74d8
movl (%rbx), %edi
callq 0x68914
movl %eax, (%rbx)
movq (%r14), %rdi
leaq 0x212261(%rip), %rcx    # 0x2f74d4
movl (%rcx), %ecx
cltq
leaq 0x6f4c2(%rip), %rdx     # 0x154740
movq (%rdx,%rax,8), %r8
leaq 0x212253(%rip), %rax    # 0x2f74dc
movl (%rax), %r9d
leaq 0x21223d(%rip), %rax    # 0x2f74d0
movl (%rax), %r10d
leaq 0x21222f(%rip), %rax    # 0x2f74cc
movl (%rax), %r11d
leaq 0x212221(%rip), %rax    # 0x2f74c8
movl (%rax), %ebx
leaq 0x211e20(%rip), %rax    # 0x2f70d0
movzbl (%rax), %r15d
leaq 0x39e24(%rip), %rsi     # 0x11f0df
leaq 0x240f5e(%rip), %rdx    # 0x326220
xorl %eax, %eax
pushq %r15
pushq %rbx
pushq %r11
pushq %r10
callq 0x9560
addq $0x20, %rsp
movq (%r14), %rdi
leaq 0x240012(%rip), %rax    # 0x3252f0
movsd 0xde7a(%rip), %xmm1     # 0xf3160
movsd (%rax), %xmm0
mulsd %xmm1, %xmm0
leaq 0x240003(%rip), %rax    # 0x3252f8
mulsd (%rax), %xmm1
leaq 0x240000(%rip), %rax    # 0x325300
movsd (%rax), %xmm2
leaq 0x39e19(%rip), %rsi     # 0x11f124
movb $0x3, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9560
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: start_3d_fixes(int, int)
void start_3d_fixes(int mode, int why)
{
   #ifdef BUFFER_LLA
      if(mode >= 0) clear_lla_points(0);
   #endif
// open_lla_file(1);

   if(mode >= 0) set_rcvr_mode(mode);  // 0=auto 2D/3D  or  4=3D only mode
   request_sat_list();

   plot_lla = 2;
   plot_azel = 1;
   update_azel = 1;
   if(WIDE_SCREEN == 0) {
      shared_plot = 1; 
      if(rcvr_type == TICC_RCVR) all_adevs = ALL_CHANS;
      else                       all_adevs = SINGLE_ADEVS;
   }
if(mode >= 0) precision_samples = 0L;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
js 0xe5382
xorl %edi, %edi
callq 0xe53f2
movzbl %bl, %edi
movss 0x11d7e(%rip), %xmm0    # 0xf70e8
movl $0xff, %esi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
movaps %xmm0, %xmm3
movl $0xff, %edx
callq 0x55b65
callq 0x5de9d
leaq 0x23ff22(%rip), %rax    # 0x3252b0
movb $0x2, (%rax)
leaq 0x12007b(%rip), %rax    # 0x205413
movb $0x1, %cl
movb %cl, (%rax)
leaq 0x120071(%rip), %rax    # 0x205414
movb %cl, (%rax)
leaq 0x11d454(%rip), %rax    # 0x202800
cmpl $0x68f, (%rax)          # imm = 0x68F
jg 0xe53dd
leaq 0x24002d(%rip), %rax    # 0x3253e8
movb $0x1, (%rax)
leaq 0x11d50b(%rip), %rax    # 0x2028d0
xorl %ecx, %ecx
cmpq $0x10000, (%rax)        # imm = 0x10000
sete %cl
leal (%rcx,%rcx,4), %eax
leaq 0x141963(%rip), %rcx    # 0x226d3e
movb %al, (%rcx)
testl %ebx, %ebx
js 0xe53eb
leaq 0x23fefc(%rip), %rax    # 0x3252e4
andl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: clear_lla_points(int)
void clear_lla_points(int force_clear)
{
int x, y;

   // clear splatter plot data buffer

   if(force_clear) ;    // llascale
   else if(zoom_screen == 'L') return;

   for(x=0; x<MAX_LLA_SIZE; x++) {
      for(y=0; y<MAX_LLA_SIZE; y++) {
         lla_data[x][y] = 0;
      }
   }

   if(user_set_ref_lla == 0) {
      ref_lat = lat;
      ref_lon = lon;
      ref_alt = alt;
   }
   cos_factor = cos(ref_lat);
   if(cos_factor == 0.0) cos_factor = 0.001;
   lla_points = 0;
}

// Assembly:
testl %edi, %edi
jne 0xe5403
leaq 0x2113ab(%rip), %rax    # 0x2f67a8
cmpb $0x4c, (%rax)
jne 0xe5403
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xb8e82(%rip), %rax     # 0x19e290
xorl %ecx, %ecx
cmpq $0x280, %rcx            # imm = 0x280
je 0xe5438
xorl %edx, %edx
cmpq $0x280, %rdx            # imm = 0x280
je 0xe542d
movb $0x0, (%rax,%rdx)
incq %rdx
jmp 0xe541b
incq %rcx
addq $0x281, %rax            # imm = 0x281
jmp 0xe5410
leaq 0x23ff01(%rip), %rax    # 0x325340
cmpl $0x0, (%rax)
je 0xe5451
leaq 0x23fec5(%rip), %rax    # 0x325310
movsd (%rax), %xmm0
jmp 0xe5493
leaq 0x211b78(%rip), %rax    # 0x2f6fd0
movsd (%rax), %xmm0
leaq 0x23fead(%rip), %rax    # 0x325310
movsd %xmm0, (%rax)
leaq 0x211b6a(%rip), %rax    # 0x2f6fd8
movsd (%rax), %xmm1
leaq 0x23fe9f(%rip), %rax    # 0x325318
movsd %xmm1, (%rax)
leaq 0x211b5c(%rip), %rax    # 0x2f6fe0
movsd (%rax), %xmm1
leaq 0x23fe91(%rip), %rax    # 0x325320
movsd %xmm1, (%rax)
callq 0x9710
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movsd 0x104ff(%rip), %xmm2    # 0xf59a8
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
leaq 0x211b0c(%rip), %rax    # 0x2f6fc8
movlpd %xmm1, (%rax)
leaq 0x23fe21(%rip), %rax    # 0x3252e8
andl $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: stop_precision_survey(int)
void stop_precision_survey(int why)
{
   if(precision_survey == 0) return;
   precision_survey = 0;

//if(debug_file) fprintf(debug_file, "stop precision survey:%d\n", why); //plugh
   sprintf(log_text, "# Precision survey stopped.  why:%d", why);
   write_log_comment(1);

   show_fixes = 0;
   change_fix_config(show_fixes);
   set_rcvr_mode(RCVR_MODE_HOLD);     // overdetermined clock mode
   if(lla_file) { //!!!! kludge - add a extra entry so external processor program works correctly
      fprintf(lla_file, "# time filler kludge\n");
      fprintf(lla_file, "%-6ld %d %13.8f  %13.8f  %8.3f\n", 
      tow+60L, 0, lat*RAD_TO_DEG, lon*RAD_TO_DEG, alt);
   }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x21267a(%rip), %rax    # 0x2f7e98
cmpb $0x0, (%rax)
je 0xe58f1
movl %edi, %edx
xorl %ebx, %ebx
movb %bl, (%rax)
leaq 0x14212c(%rip), %rdi    # 0x227960
leaq 0x39a88(%rip), %rsi     # 0x11f2c3
xorl %eax, %eax
callq 0x9060
pushq $0x1
popq %rdi
callq 0xb25f5
leaq 0x23fa83(%rip), %rax    # 0x3252d4
movb %bl, (%rax)
xorl %edi, %edi
callq 0x377c9
pushq $0x7
popq %rdi
movss 0x11883(%rip), %xmm0    # 0xf70e8
movl $0xff, %esi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
movaps %xmm0, %xmm3
movl $0xff, %edx
callq 0x55b65
leaq 0x142b1c(%rip), %rbx    # 0x2283a0
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xe58f1
leaq 0x39a54(%rip), %rdi     # 0x11f2e7
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x9750
movq (%rbx), %rdi
leaq 0x211e94(%rip), %rax    # 0x2f773c
movl (%rax), %edx
leaq 0x21171f(%rip), %rax    # 0x2f6fd0
movsd 0xd8a7(%rip), %xmm1     # 0xf3160
movsd (%rax), %xmm0
mulsd %xmm1, %xmm0
leaq 0x211710(%rip), %rax    # 0x2f6fd8
mulsd (%rax), %xmm1
addq $0x3c, %rdx
leaq 0x211709(%rip), %rax    # 0x2f6fe0
movsd (%rax), %xmm2
leaq 0x39a1b(%rip), %rsi     # 0x11f2fd
xorl %ecx, %ecx
movb $0x3, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9560
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: precise_check()
void precise_check()
{
double d_lat, d_lon, d_alt;

   if(surveying) return;
   if(check_precise_posn == 0) return;
   if(check_delay) {  // ignore first few survey points - they could be bogus filter remnants
      --check_delay;
      return;
   }

   d_lat = (lat-precise_lat)*RAD_TO_DEG/ANGLE_SCALE;
   d_lon = (lon-precise_lon)*RAD_TO_DEG/ANGLE_SCALE*cos_factor;
   d_alt = (alt-precise_alt);
// if((DABS(lat-precise_lat) < LAT_THRESH) && (DABS(lon-precise_lon) < LON_THRESH) && (DABS(alt-precise_alt) < ALT_THRESH)) {

   // see if surveyed position error is small enough
   if((sqrt(d_lat*d_lat + d_lon*d_lon) <= 1.0) && (DABS(d_alt) < ALT_THRESH)) {
      save_segment(7, 10);      // yes,  save the position in EEPROM
      check_precise_posn = 0;   // we are done
      log_saved_posn(-1);
      if(SCREEN_WIDTH > NARROW_SCREEN) lla_header("Precise survey complete    ", WHITE);
      else                             lla_header("Survey complete            ", WHITE);
      close_lla_file(1);
      precise_survey_done = 1;
      trimble_save = 0;
   }
   else { // try single point survey again
      start_self_survey(0x00, 2);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x21259c(%rip), %rax    # 0x2f7ea1
cmpb $0x0, (%rax)
jne 0xe5927
leaq 0x23f9cf(%rip), %rbx    # 0x3252e0
cmpb $0x0, (%rbx)
je 0xe5927
leaq 0x23f9c4(%rip), %rax    # 0x3252e1
movb (%rax), %cl
testb %cl, %cl
je 0xe592e
decb %cl
movb %cl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x21169b(%rip), %rax    # 0x2f6fd0
movsd (%rax), %xmm0
leaq 0x23f9b0(%rip), %rax    # 0x3252f0
subsd (%rax), %xmm0
movsd 0xd814(%rip), %xmm1     # 0xf3160
mulsd %xmm1, %xmm0
leaq 0x211661(%rip), %rax    # 0x2f6fb8
movsd (%rax), %xmm2
leaq 0x211676(%rip), %rax    # 0x2f6fd8
movsd (%rax), %xmm3
leaq 0x23f98b(%rip), %rax    # 0x3252f8
subsd (%rax), %xmm3
mulsd %xmm1, %xmm3
divsd %xmm2, %xmm3
leaq 0x211648(%rip), %rax    # 0x2f6fc8
mulsd (%rax), %xmm3
divsd %xmm2, %xmm0
mulsd %xmm3, %xmm3
mulsd %xmm0, %xmm0
addsd %xmm3, %xmm0
sqrtsd %xmm0, %xmm1
movsd 0xd6d0(%rip), %xmm0     # 0xf3070
ucomisd %xmm1, %xmm0
jb 0xe5a4f
leaq 0x23f94f(%rip), %rax    # 0x325300
leaq 0x211628(%rip), %rcx    # 0x2f6fe0
movsd (%rcx), %xmm1
subsd (%rax), %xmm1
xorpd %xmm2, %xmm2
movapd %xmm1, %xmm3
cmpltsd %xmm2, %xmm3
subsd %xmm1, %xmm2
andpd %xmm3, %xmm2
andnpd %xmm1, %xmm3
orpd %xmm2, %xmm3
ucomisd %xmm3, %xmm0
jbe 0xe5a4f
pushq $0x7
popq %rdi
pushq $0xa
popq %rsi
callq 0x6166c
movb $0x0, (%rbx)
pushq $-0x1
popq %rdi
callq 0xc2231
leaq 0x11ce00(%rip), %rax    # 0x202800
movl (%rax), %ecx
leaq 0x127b3b(%rip), %rax    # 0x20d544
imull $0x31a, (%rax), %eax    # imm = 0x31A
pushq $0x64
popq %rsi
cltd
idivl %esi
cmpl %eax, %ecx
leaq 0x398ff(%rip), %rax     # 0x11f31d
leaq 0x39914(%rip), %rdi     # 0x11f339
cmovgq %rax, %rdi
pushq $0xf
popq %rsi
callq 0xe5a5f
callq 0xe5327
leaq 0x21245d(%rip), %rax    # 0x2f7e9a
movb $0x1, (%rax)
leaq 0x212455(%rip), %rax    # 0x2f7e9c
andl $0x0, (%rax)
jmp 0xe5927
pushq $0x2
popq %rsi
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6355d
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: lla_header(char*, int)
void lla_header(char *s, int color)
{
int xx;
int yy;

   // label the lat/lon/alt data block

   if(text_mode) {
      yy = MOUSE_ROW-1;
      xx = MOUSE_COL;
   }
   else {
      xx = (LLA_COL/TEXT_WIDTH)+1;
      yy = (LLA_ROW+LLA_SIZE)/TEXT_HEIGHT+0;
      if(SCREEN_WIDTH > (NARROW_SCREEN+X11_MARGIN)) xx += 5;
      else                                          xx -= 2;
   }

   vidstr(yy, xx, color, s);
   strcpy(lla_msg, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11cd69(%rip), %rax    # 0x2027d8
cmpl $0x0, (%rax)
je 0xe5a8a
leaq 0x11cd2d(%rip), %rax    # 0x2027a8
movl (%rax), %edi
decl %edi
leaq 0x11cd26(%rip), %rax    # 0x2027ac
movl (%rax), %ecx
jmp 0xe5aeb
leaq 0x23f81b(%rip), %rax    # 0x3252ac
movl (%rax), %eax
leaq 0x11cd76(%rip), %rcx    # 0x202810
cltd
idivl (%rcx)
movl %eax, %ecx
leaq 0x23f802(%rip), %rdx    # 0x3252a8
leaq 0x23f7eb(%rip), %rax    # 0x325298
movl (%rax), %eax
addl (%rdx), %eax
leaq 0x11cd5c(%rip), %rdi    # 0x202814
cltd
idivl (%rdi)
movl %eax, %edi
leaq 0x11cd3c(%rip), %rax    # 0x202800
movl (%rax), %r8d
leaq 0x127a76(%rip), %rax    # 0x20d544
imull $0x31a, (%rax), %eax    # imm = 0x31A
pushq $0x64
popq %r9
cltd
idivl %r9d
addl $0x6, %eax
cmpl %eax, %r8d
jle 0xe5ae9
addl $0x6, %ecx
jmp 0xe5aeb
decl %ecx
movzbl %sil, %edx
movl %ecx, %esi
movq %rbx, %rcx
callq 0xe2d2
leaq 0x27e8b0(%rip), %rdi    # 0x3643b0
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9330
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: abort_precise_survey(int)
void abort_precise_survey(int why)
{
float flat, flon, falt;

   if(check_precise_posn) {  // precise position found
      flat = (float) precise_lat;
      flon = (float) precise_lon;
      falt = (float) precise_alt;

      lat = (double) flat;
      lon = (double) flon;
      alt = (double) falt;
      save_precise_posn(2);  // save it using low res TSIP message
   }
   else if(precision_survey) {  // precise survey is incomplete
      if(precision_samples) {   // so save the average position
         precise_lat = lat_sum / (double)precision_samples;
         precise_lon = lon_sum / (double)precision_samples;
         precise_alt = alt_sum / (double)precision_samples;
         have_precise_lla = 1;
         ref_lat = precise_lat;
         ref_lon = precise_lon;
         ref_alt = precise_alt;
         cos_factor = cos(ref_lat);
         if(cos_factor == 0.0) cos_factor = 0.001;

         flat = (float) precise_lat;
         flon = (float) precise_lon;
         falt = (float) precise_alt;

         lat = (double) flat;
         lon = (double) flon;
         alt = (double) falt;
         save_precise_posn(3);
      }
   }
//if(lla_file) {
//   fprintf(lla_file, "### abort_precise_survey(%d): cpp:%d  ps:%d  samples:%d\n", why, check_precise_posn, precision_survey, precision_samples);
//   fprintf(lla_file, "### lla:%.9f %.9f %.9f\n", lat*180.0/PI,lon*180.0/PI,alt);
//}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x23f418(%rip), %rax    # 0x3252e0
cmpb $0x0, (%rax)
je 0xe5ed4
pushq $0x2
jmp 0xe5fa3
leaq 0x211fbd(%rip), %rax    # 0x2f7e98
cmpb $0x0, (%rax)
setne %cl
leaq 0x23f3fc(%rip), %rax    # 0x3252e4
movl (%rax), %eax
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xe5ff8
movl %eax, %eax
cvtsi2sd %rax, %xmm1
movsd 0x3569b7(%rip), %xmm0   # 0x43c8c0
divsd %xmm1, %xmm0
leaq 0x23f3dc(%rip), %rax    # 0x3252f0
movsd %xmm0, (%rax)
movsd 0x3569a8(%rip), %xmm2   # 0x43c8c8
divsd %xmm1, %xmm2
leaq 0x23f3cd(%rip), %rax    # 0x3252f8
movsd %xmm2, (%rax)
movsd 0x356999(%rip), %xmm3   # 0x43c8d0
divsd %xmm1, %xmm3
leaq 0x23f3be(%rip), %rax    # 0x325300
movsd %xmm3, (%rax)
leaq 0x23f3bb(%rip), %rax    # 0x325308
movl $0x1, (%rax)
leaq 0x23f3b6(%rip), %rax    # 0x325310
movsd %xmm0, (%rax)
leaq 0x23f3b3(%rip), %rax    # 0x325318
movsd %xmm2, (%rax)
leaq 0x23f3b0(%rip), %rax    # 0x325320
movsd %xmm3, (%rax)
callq 0x9710
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movsd 0xfa1e(%rip), %xmm2     # 0xf59a8
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm1, %xmm2
leaq 0x21102b(%rip), %rax    # 0x2f6fc8
movlpd %xmm2, (%rax)
pushq $0x3
popq %rdi
leaq 0x23f345(%rip), %rax    # 0x3252f0
cvtsd2ss (%rax), %xmm0
leaq 0x23f342(%rip), %rax    # 0x3252f8
cvtsd2ss (%rax), %xmm1
leaq 0x23f33f(%rip), %rax    # 0x325300
cvtsd2ss (%rax), %xmm2
cvtss2sd %xmm0, %xmm0
leaq 0x211000(%rip), %rax    # 0x2f6fd0
movsd %xmm0, (%rax)
cvtss2sd %xmm1, %xmm0
leaq 0x210ff9(%rip), %rax    # 0x2f6fd8
movsd %xmm0, (%rax)
cvtss2sd %xmm2, %xmm0
leaq 0x210ff2(%rip), %rax    # 0x2f6fe0
movsd %xmm0, (%rax)
popq %rbp
jmp 0xe5b0e
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: find_mouse_lla()
int find_mouse_lla()
{
int map_r;
int x,y;

   // set mouse_lat and mouse_lon variables to the lat/lon in the scattergram
   // where the mouse cursor is located.  Returns true is mouse values are
   // valid.

   mouse_lat = mouse_lon = 0.0;
   if(autoscale_lla == 0) return 0;
   if(have_valid_lla == 0) return 0;
   
   map_r = LLA_SIZE / 2;
   if(mouse_x < LLA_X-map_r) return 0;
   if(mouse_x > LLA_X+map_r) return 0;
   if(mouse_y < LLA_Y-map_r) return 0;
   if(mouse_y > LLA_Y+map_r) return 0;

   x = mouse_x - LLA_X;
   y = LLA_Y - mouse_y;

   if(cos_factor == 0.0) cos_factor = 0.001;
   mouse_lat = (ref_lat*RAD_TO_DEG) + ( (((double) y) / (double) LLA_SIZE) * ref_lat_span ); 
   mouse_lon = (ref_lon*RAD_TO_DEG) + ( (((double) x) / (double) LLA_SIZE) * (ref_lon_span / cos_factor));
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $0x0, 0x357e92(%rip)    # 0x43de98
andq $0x0, 0x357e82(%rip)    # 0x43de90
leaq 0x23f29f(%rip), %rax    # 0x3252b4
xorl %esi, %esi
cmpl $0x0, (%rax)
je 0xe614a
leaq 0x21129d(%rip), %rax    # 0x2f72c4
cmpl $0x0, (%rax)
je 0xe614a
leaq 0x23f261(%rip), %rax    # 0x325298
movl (%rax), %ecx
movl $0x2, %edi
movl %ecx, %eax
cltd
idivl %edi
leaq 0x11f1f6(%rip), %rdx    # 0x205240
movl (%rdx), %edx
leaq 0x23f259(%rip), %rdi    # 0x3252ac
movl (%rdi), %edi
leal (%rax,%rdi), %r8d
decl %r8d
decl %edi
cmpl %edi, %edx
setl %dil
leal (%r8,%rax), %r9d
cmpl %r9d, %edx
setg %r9b
orb %dil, %r9b
jne 0xe614a
leal -0x1(%rax), %edi
leaq 0x11f1c2(%rip), %r9     # 0x205244
movl (%r9), %r9d
leaq 0x23f21c(%rip), %r10    # 0x3252a8
addl (%r10), %edi
movl %edi, %r10d
subl %eax, %r10d
cmpl %r10d, %r9d
setl %r10b
addl %edi, %eax
cmpl %eax, %r9d
setg %al
orb %r10b, %al
jne 0xe614a
subl %r8d, %edx
subl %r9d, %edi
leaq 0x210f0e(%rip), %rax    # 0x2f6fc8
movsd (%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe60df
jp 0xe60df
movabsq $0x3f50624dd2f1a9fc, %rsi # imm = 0x3F50624DD2F1A9FC
movq %rsi, (%rax)
movsd 0xf8c9(%rip), %xmm0     # 0xf59a8
leaq 0x23f22a(%rip), %rax    # 0x325310
cvtsi2sd %edi, %xmm1
cvtsi2sd %ecx, %xmm2
divsd %xmm2, %xmm1
mulsd 0x357da6(%rip), %xmm1   # 0x43dea0
movsd 0xd05e(%rip), %xmm3     # 0xf3160
movsd (%rax), %xmm4
mulsd %xmm3, %xmm4
addsd %xmm1, %xmm4
movsd %xmm4, 0x357d7a(%rip)   # 0x43de90
leaq 0x23f1fb(%rip), %rax    # 0x325318
cvtsi2sd %edx, %xmm1
divsd %xmm2, %xmm1
movsd 0x357d7b(%rip), %xmm2   # 0x43dea8
divsd %xmm0, %xmm2
mulsd (%rax), %xmm3
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm3
movsd %xmm3, 0x357d53(%rip)   # 0x43de98
movl $0x1, %esi
movl %esi, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: show_mouse_lla()
void show_mouse_lla()
{
int xx;

   // label the lat/lon scattergram

   if(text_mode && first_key) return;
   if(plot_lla == 0) return;

   xx = LLA_COL/TEXT_WIDTH+1;
   if(SCREEN_WIDTH > (NARROW_SCREEN+X11_MARGIN)) xx += 5;
   else                                          xx -= 2;

   if(find_mouse_lla()) {
      label_lla_header();
      format_lla(mouse_lat*DEG_TO_RAD,mouse_lon*DEG_TO_RAD,ref_alt, (LLA_ROW+LLA_SIZE)/TEXT_HEIGHT+1, xx, 0);
   }
   else {
      label_lla_header();
      format_lla(ref_lat,ref_lon,ref_alt, (LLA_ROW+LLA_SIZE)/TEXT_HEIGHT+1, xx, 0);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x11c32c(%rip), %rax    # 0x2027d8
cmpl $0x0, (%rax)
setne %al
leaq 0x142a9f(%rip), %rcx    # 0x228f58
cmpl $0x0, (%rcx)
setne %cl
testb %cl, %al
jne 0xe6541
leaq 0x23ede6(%rip), %rax    # 0x3252b0
cmpb $0x0, (%rax)
je 0xe6541
leaq 0x23edd6(%rip), %rax    # 0x3252ac
movl (%rax), %eax
leaq 0x11c331(%rip), %rcx    # 0x202810
cltd
idivl (%rcx)
movl %eax, %ecx
leaq 0x11c315(%rip), %rax    # 0x202800
movl (%rax), %esi
leaq 0x127050(%rip), %rax    # 0x20d544
imull $0x31a, (%rax), %eax    # imm = 0x31A
pushq $0x64
popq %rdi
cltd
idivl %edi
addl $0x6, %eax
xorl %ebx, %ebx
cmpl %eax, %esi
setle %bl
negl %ebx
orl $0x6, %ebx
addl %ecx, %ebx
callq 0xe5ffa
movl %eax, %r14d
callq 0xe614e
testl %r14d, %r14d
je 0xe6546
movsd 0xf45d(%rip), %xmm1     # 0xf5988
movsd 0x35795d(%rip), %xmm0   # 0x43de90
mulsd %xmm1, %xmm0
mulsd 0x357959(%rip), %xmm1   # 0x43de98
jmp 0xe655c
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x23edc3(%rip), %rax    # 0x325310
movsd (%rax), %xmm0
leaq 0x23edc0(%rip), %rax    # 0x325318
movsd (%rax), %xmm1
leaq 0x23edbd(%rip), %rax    # 0x325320
movsd (%rax), %xmm2
leaq 0x23ed3a(%rip), %rcx    # 0x3252a8
leaq 0x23ed23(%rip), %rax    # 0x325298
movl (%rax), %eax
addl (%rcx), %eax
leaq 0x11c294(%rip), %rcx    # 0x202814
cltd
idivl (%rcx)
leal 0x1(%rax), %edi
movl %ebx, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xa2476
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: redraw_lla_points()
void redraw_lla_points()
{
int x, y;
int xs, ys;
int xx,yy;

   // redraw splatter plot from the saved data points

   for(x=0; x<MAX_LLA_SIZE; x++) {
      xs = (int) ((float) x * (float) lla_width / (float) MAX_LLA_SIZE);
      if((xs < 0) || (xs >= MAX_LLA_SIZE)) continue;

      for(y=0; y<MAX_LLA_SIZE; y++) {
         ys = (int) ((float) y * (float) lla_width / (float) MAX_LLA_SIZE);
         if((ys < 0) || (ys >= MAX_LLA_SIZE)) continue;
         if(lla_data[x][y]) {
            xx = LLA_X+xs-(lla_width/2);
            yy = LLA_Y+ys-(lla_width/2);
            if(xx < 0) continue;
            if(yy < 0) continue;
            if(xx >= SCREEN_WIDTH) continue;
            if(yy >= SCREEN_HEIGHT) continue;
            dot(xx,yy, lla_data[x][y]);
         }
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0xb770d(%rip), %rbx     # 0x19e290
xorl %eax, %eax
leaq 0x23e718(%rip), %r14    # 0x3252a4
movss 0x2fb94(%rip), %xmm2    # 0x116728
leaq 0x23e711(%rip), %r10    # 0x3252ac
leaq 0x23e6f6(%rip), %r11    # 0x325298
pushq $0x2
popq %r15
pushq $-0x2
popq %r12
cmpq $0x280, %rax            # imm = 0x280
je 0xe6cb6
movq %rax, -0x38(%rbp)
cvtsi2ss %eax, %xmm0
cvtsi2ssl (%r14), %xmm1
mulss %xmm0, %xmm1
divss %xmm2, %xmm1
cvttss2si %xmm1, %eax
movq %rax, -0x30(%rbp)
cmpl $0x27f, %eax            # imm = 0x27F
jbe 0xe6bea
movq -0x38(%rbp), %rax
incq %rax
addq $0x281, %rbx            # imm = 0x281
jmp 0xe6baa
movq -0x30(%rbp), %rax
decl %eax
movq %rax, -0x30(%rbp)
xorl %r13d, %r13d
movq %rbx, -0x40(%rbp)
cmpq $0x280, %r13            # imm = 0x280
je 0xe6bda
cvtsi2ss %r13d, %xmm0
movl (%r14), %ecx
cvtsi2ss %ecx, %xmm1
mulss %xmm0, %xmm1
divss %xmm2, %xmm1
cvttss2si %xmm1, %r9d
cmpl $0x27f, %r9d            # imm = 0x27F
ja 0xe6cae
movb (%rbx,%r13), %r8b
testb %r8b, %r8b
je 0xe6cae
movl (%r11), %eax
cltd
idivl %r15d
movl %eax, %esi
movl %ecx, %eax
cltd
idivl %r12d
movq -0x30(%rbp), %rcx
leal (%rcx,%rax), %edi
addl (%r10), %edi
addl %esi, %edi
js 0xe6cae
addl %esi, %eax
addl %r9d, %eax
leaq 0x23e64c(%rip), %rcx    # 0x3252a8
movl (%rcx), %ecx
leal (%rcx,%rax), %esi
decl %esi
testl %esi, %esi
js 0xe6cae
leaq 0x11bb92(%rip), %rax    # 0x202800
cmpl (%rax), %edi
jge 0xe6cae
leaq 0x11bb8b(%rip), %rax    # 0x202804
cmpl (%rax), %esi
jge 0xe6cae
movzbl %r8b, %edx
movq %r14, %rbx
movq %r10, %r14
movl %r15d, %r12d
movq %r11, %r15
callq 0xe1a7
movq %r15, %r11
movl %r12d, %r15d
pushq $-0x2
popq %r12
movq %r14, %r10
movq %rbx, %r14
movq -0x40(%rbp), %rbx
movss 0x2fa7a(%rip), %xmm2    # 0x116728
incq %r13
jmp 0xe6bfb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: add_to_bin(double, double*, int)
int add_to_bin(double val,  double bin[],  int bins_filled)
{
int i;

   if(bins_filled >= SURVEY_BIN_COUNT) {
     return bins_filled;
   }

   bin[bins_filled] = val;
   for(i=bins_filled-1; i>=0; i--) {
      if(bin[i] > val) {
         bin[i+1] = bin[i];
         bin[i] = val;
      }
      else break;
   }

   bins_filled += 1;
   return bins_filled;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
cmpl $0x5f, %esi
jg 0xe72c8
movslq %eax, %rcx
movsd %xmm0, (%rdi,%rcx,8)
movl %eax, %ecx
testl %ecx, %ecx
jle 0xe72c6
movsd -0x8(%rdi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xe72c6
movsd %xmm1, (%rdi,%rcx,8)
movsd %xmm0, -0x8(%rdi,%rcx,8)
decq %rcx
jmp 0xe72a6
incl %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: update_precise_survey()
void update_precise_survey()
{
int color;
int plotted;
int i;

   plotted = 0;
   color = precision_samples / (60L*60L);
   color %= 12;

   if(precision_survey || check_precise_posn || show_fixes) {  // plot the points
      if((gps_status == GPS_FIXES) && plot_lla) {  // plot data
         plot_lla_point(1, color+3);
         plotted = 1;
      }
   }
   if(plotted == 0) { // just add point to lla map buffer
      plot_lla_point(0, color+3);
   }

   if(precision_survey) {
      i = add_survey_point();
      if(i) {                      // precision survey has completed
         stop_precision_survey(1); // stop doing the precison survey
         analyze_hours();          // analyze the hourly data
         calc_precise_lla();       // figure up where we are
      }
   }
   else {
      if(show_fixes) ++precision_samples;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x23d282(%rip), %rbx    # 0x3252e4
movl (%rbx), %eax
movl $0xe10, %ecx            # imm = 0xE10
xorl %edx, %edx
divl %ecx
pushq $0xc
popq %rcx
xorl %edx, %edx
divl %ecx
leaq 0x20fe1d(%rip), %r15    # 0x2f7e98
cmpb $0x0, (%r15)
leaq 0x23d24e(%rip), %r14    # 0x3252d4
jne 0xe809e
leaq 0x23d251(%rip), %rax    # 0x3252e0
cmpb $0x0, (%rax)
jne 0xe809e
cmpb $0x0, (%r14)
jne 0xe809e
xorl %edi, %edi
jmp 0xe80b9
leaq 0x20f3f7(%rip), %rax    # 0x2f749c
cmpl $0x0, (%rax)
jne 0xe809a
leaq 0x23d1ff(%rip), %rax    # 0x3252b0
cmpb $0x0, (%rax)
je 0xe809a
pushq $0x1
popq %rdi
addl $0x3, %edx
movl %edx, %esi
callq 0xc9a95
cmpb $0x0, (%r15)
je 0xe80ee
callq 0xe7ebe
testl %eax, %eax
je 0xe80f6
pushq $0x1
popq %rdi
callq 0xe5811
callq 0xe749a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe6cc5
cmpb $0x0, (%r14)
je 0xe80f6
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: free_mtie_data(int)
void free_mtie_data(int id)
{
int i;

   if(id < 0) return;
   if(id > MAX_MTIE_CHANS) return;
   if(mtie_taus[id] == 0) return;

   for(i=0; i<mtie_kmax; i++) {
      if(mtie_taus[id][i].vals) {
         if(mtie_taus[id][i].vals->min_vals) free(mtie_taus[id][i].vals->min_vals);
         if(mtie_taus[id][i].vals->max_vals) free(mtie_taus[id][i].vals->max_vals);
      }
   }

   for(i=0; i<mtie_kmax; i++) {
      if(mtie_taus[id][i].vals) {
         free(mtie_taus[id][i].vals);
      }
   }

   free(mtie_taus[id]);
   mtie_taus[id] = 0;

   if(mtie_buf[id]) {
      free(mtie_buf[id]);
      mtie_buf[id] = 0;
   }

   mtie_q_count[id] = 0;
   mtie_q_in = mtie_q_out = 0;
}

// Assembly:
cmpl $0x4, %edi
ja 0xe81d3
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x3572b3(%rip), %r14    # 0x43f3d0
cmpq $0x0, (%r14,%rbx,8)
je 0xe81c9
movl 0x3572c6(%rip), %eax    # 0x43f3f4
xorl %r15d, %r15d
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0xe816a
movq (%r14,%rbx,8), %rcx
movq (%rcx,%r15,8), %rcx
testq %rcx, %rcx
je 0xe8165
movq (%rcx), %rdi
callq 0x9440
movq (%r14,%rbx,8), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rdi
callq 0x9440
movl 0x35728f(%rip), %eax    # 0x43f3f4
incq %r15
jmp 0xe8131
xorl %r15d, %r15d
cltq
movq (%r14,%rbx,8), %rdi
cmpq %rax, %r15
jge 0xe818c
movq (%rdi,%r15,8), %rdi
callq 0x9440
incq %r15
movl 0x35726a(%rip), %eax    # 0x43f3f4
jmp 0xe816d
callq 0x9440
andq $0x0, (%r14,%rbx,8)
leaq 0x356b53(%rip), %r14    # 0x43ecf0
movq (%r14,%rbx,8), %rdi
testq %rdi, %rdi
je 0xe81b0
callq 0x9440
andq $0x0, (%r14,%rbx,8)
leaq 0x356b59(%rip), %rax    # 0x43ed10
andl $0x0, (%rax,%rbx,4)
andl $0x0, 0x35723a(%rip)    # 0x43f3fc
andl $0x0, 0x35722f(%rip)    # 0x43f3f8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: free_mtie()
void free_mtie()
{
   free_mtie_data(CHA_MTIE);
   free_mtie_data(CHB_MTIE);
   free_mtie_data(CHC_MTIE);
   free_mtie_data(CHD_MTIE);
   mtie_allocated = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0xe8101
pushq $0x1
popq %rdi
callq 0xe8101
pushq $0x2
popq %rdi
callq 0xe8101
pushq $0x3
popq %rdi
callq 0xe8101
leaq 0x13e830(%rip), %rax    # 0x226ce4
andl $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: save_mtie_phase(int, double)
void save_mtie_phase(int id, double val)
{
   // put a value into the MTIE data buffer

   if(id < 0) return;
   if(id > MAX_MTIE_CHANS) return;
   if(mtie_q_count[id] >= max_mtie_samples) return;

   mtie_buf[id][mtie_q_count[id]] = val;
   ++mtie_q_count[id];
}

// Assembly:
cmpl $0x4, %edi
ja 0xe851b
movl %edi, %eax
leaq 0x35681b(%rip), %rcx    # 0x43ed10
movslq (%rcx,%rax,4), %rdx
cmpl 0x356ef1(%rip), %edx    # 0x43f3f0
jge 0xe851b
pushq %rbp
movq %rsp, %rbp
leaq 0x3567e4(%rip), %rsi    # 0x43ecf0
movq (%rsi,%rax,8), %rsi
movsd %xmm0, (%rsi,%rdx,8)
incl %edx
movl %edx, (%rcx,%rax,4)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: scan_mtie_bins(int)
void scan_mtie_bins(int id)
{
int i;
double val;

   // find min/max values in the MTIE data

   if(id < 0) return;
   if(id > MAX_MTIE_CHANS) return;

   for(i=first_show_bin; i<32; i++) {  // !!!!! should start at
      if(mtie[id][i] == (-BIG_NUM)) continue;
      val = (mtie[id][i] / 1.0E9);

      if(val > global_adev_max) global_adev_max = val;
      if(val < global_adev_min) global_adev_min = val;
   }
}

// Assembly:
cmpl $0x4, %edi
ja 0xe88e8
pushq %rbp
movq %rsp, %rbp
leaq 0x13e41a(%rip), %rax    # 0x226c80
movslq (%rax), %rax
leaq 0x13e278(%rip), %rcx    # 0x226ae8
movsd (%rcx), %xmm0
leaq 0x13e275(%rip), %rdx    # 0x226af0
movsd (%rdx), %xmm3
movl %edi, %esi
imulq $0x328, %rsi, %rsi      # imm = 0x328
leaq (%rsi,%rax,8), %rdi
leaq 0x3557bd(%rip), %rsi    # 0x43e050
addq %rdi, %rsi
movsd 0x2ddf2(%rip), %xmm1    # 0x116690
movsd 0xa782(%rip), %xmm2     # 0xf3028
cmpq $0x1f, %rax
jg 0xe88e7
movsd (%rsi), %xmm4
ucomisd %xmm1, %xmm4
jne 0xe88b8
jnp 0xe88d6
divsd %xmm2, %xmm4
ucomisd %xmm0, %xmm4
jbe 0xe88ca
movsd %xmm4, (%rcx)
movapd %xmm4, %xmm0
ucomisd %xmm4, %xmm3
jbe 0xe88d6
movsd %xmm4, (%rdx)
jmp 0xe88da
movapd %xmm3, %xmm4
incq %rax
addq $0x8, %rsi
movapd %xmm4, %xmm3
jmp 0xe88a6
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: reset_incr_bins(BIN*, double)
void reset_incr_bins(struct BIN *bins, double period)
{
int b;
S32 m;
struct BIN *B;

   if(bins == 0) return;

   m = 1L;
   for(b=0; b<MAX_ADEV_BINS; b++) {  // flush adev bin data
      B = &bins[b];
      if(B == 0) continue;

      B->m     = m;
      B->n     = 0;
      B->sum   = 0.0;
      B->value = 0.0;
      B->tau   = ((double) m) * period;
      B->accum = 0.0;
      B->i     = 0;
      B->j     = 0;
      B->init  = 0;

      m = next_tau(m, bin_scale);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, -0x20(%rbp)
testq %rdi, %rdi
je 0xe8af6
movq %rdi, %rbx
pushq $0x1
popq %rax
pushq $0x20
popq %r14
leaq 0x13e1cf(%rip), %r15    # 0x226c7c
cmpq $0x1600, %r14           # imm = 0x1600
je 0xe8af6
movl %eax, -0x20(%rbx,%r14)
cvtsi2sd %eax, %xmm0
mulsd -0x20(%rbp), %xmm0
andl $0x0, -0xc(%rbx,%r14)
xorps %xmm1, %xmm1
movups %xmm1, -0x1c(%rbx,%r14)
movsd %xmm0, -0x8(%rbx,%r14)
movslq %eax, %rdi
movups %xmm1, (%rbx,%r14)
andl $0x0, 0x10(%rbx,%r14)
movl (%r15), %esi
callq 0xe8915
addq $0x38, %r14
jmp 0xe8aad
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: reset_pps_bins()
void reset_pps_bins()
{
   pps_adev_q_overflow = 0.0;
   reset_incr_bins(&pps_adev_bins[0], pps_adev_period);
   reset_incr_bins(&pps_hdev_bins[0], pps_adev_period);
   reset_incr_bins(&pps_mdev_bins[0], pps_adev_period);
   reset_incr_bins(&pps_tdev_bins[0], pps_adev_period);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x13e032(%rip), %rax    # 0x226b40
andq $0x0, (%rax)
leaq 0x13e1e7(%rip), %rbx    # 0x226d00
movsd (%rbx), %xmm0
leaq 0x127dcc(%rip), %rdi    # 0x2108f0
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x1293dc(%rip), %rdi    # 0x211f10
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x12a9ec(%rip), %rdi    # 0x213530
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x12bffc(%rip), %rdi    # 0x214b50
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe8a88
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: reset_osc_bins()
void reset_osc_bins()
{
   osc_adev_q_overflow = 0.0;
   reset_incr_bins(&osc_adev_bins[0], osc_adev_period);
   reset_incr_bins(&osc_hdev_bins[0], osc_adev_period);
   reset_incr_bins(&osc_mdev_bins[0], osc_adev_period);
   reset_incr_bins(&osc_tdev_bins[0], osc_adev_period);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x13e024(%rip), %rax    # 0x226b90
andq $0x0, (%rax)
leaq 0x13e191(%rip), %rbx    # 0x226d08
movsd (%rbx), %xmm0
leaq 0x13184e(%rip), %rdi    # 0x21a3d0
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x12d5de(%rip), %rdi    # 0x216170
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x12ebee(%rip), %rdi    # 0x217790
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x1301fe(%rip), %rdi    # 0x218db0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe8a88
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: reset_chc_bins()
void reset_chc_bins()
{
   chc_adev_q_overflow = 0.0;
   reset_incr_bins(&chc_adev_bins[0], chc_adev_period);
   reset_incr_bins(&chc_hdev_bins[0], chc_adev_period);
   reset_incr_bins(&chc_mdev_bins[0], chc_adev_period);
   reset_incr_bins(&chc_tdev_bins[0], chc_adev_period);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x13e016(%rip), %rax    # 0x226be0
andq $0x0, (%rax)
leaq 0x13e13b(%rip), %rbx    # 0x226d10
movsd (%rbx), %xmm0
leaq 0x132e10(%rip), %rdi    # 0x21b9f0
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x134420(%rip), %rdi    # 0x21d010
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x135a30(%rip), %rdi    # 0x21e630
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x137040(%rip), %rdi    # 0x21fc50
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe8a88
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: reset_chd_bins()
void reset_chd_bins()
{
   chd_adev_q_overflow = 0.0;
   reset_incr_bins(&chd_adev_bins[0], chd_adev_period);
   reset_incr_bins(&chd_hdev_bins[0], chd_adev_period);
   reset_incr_bins(&chd_mdev_bins[0], chd_adev_period);
   reset_incr_bins(&chd_tdev_bins[0], chd_adev_period);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x13e008(%rip), %rax    # 0x226c30
andq $0x0, (%rax)
leaq 0x13e0e5(%rip), %rbx    # 0x226d18
movsd (%rbx), %xmm0
leaq 0x138632(%rip), %rdi    # 0x221270
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x139c42(%rip), %rdi    # 0x222890
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x13b252(%rip), %rdi    # 0x223eb0
callq 0xe8a88
movsd (%rbx), %xmm0
leaq 0x13c862(%rip), %rdi    # 0x2254d0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe8a88
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: adev_mouse()
void adev_mouse()
{
u08 old_disable_kbd;

// return;    // this routine breaks "keep_adevs_fresh"  unless timer_serve is set when calling get_mouse_info()

   // keep mouse lively during long periods of thinking
   if((++adev_mouse_time & 0xFFFF) != 0x0000) return;

   update_pwm();
   if(mouse_shown == 0) return;

   old_disable_kbd = disable_kbd;
   if(kbd_flag) disable_kbd = 2; // (so that do_kbd() won't do anything when it's called by WM_CHAR during get_pending_gps())

   ++timer_serve;
   get_mouse_info();
   --timer_serve;

   disable_kbd = old_disable_kbd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x13d75f(%rip), %rax    # 0x226cb8
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
testw %cx, %cx
jne 0xe95a3
callq 0xc067d
leaq 0x11bccd(%rip), %rax    # 0x20523d
cmpb $0x0, (%rax)
je 0xe95a3
leaq 0x11bca0(%rip), %rbx    # 0x20521c
movb (%rbx), %r14b
leaq 0x11bc97(%rip), %rax    # 0x20521d
cmpb $0x0, (%rax)
je 0xe958e
movb $0x2, (%rbx)
leaq 0x11bc83(%rip), %r15    # 0x205218
incl (%r15)
callq 0x1b5eb
decl (%r15)
movb %r14b, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: do_incr_pps_adevs()
void do_incr_pps_adevs()
{
   // update each of the PPS adev bins with the latest queue data
   incr_adev(PPS_ADEV, &pps_adev_bins[0]);
   incr_hdev(PPS_HDEV, &pps_hdev_bins[0]);
   incr_mdev(PPS_MDEV, &pps_mdev_bins[0]);
   incr_tdev(PPS_TDEV, &pps_tdev_bins[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x127337(%rip), %rsi    # 0x2108f0
pushq $0x5
popq %rdi
callq 0xe95ef
leaq 0x128948(%rip), %rsi    # 0x211f10
pushq $0x6
popq %rdi
callq 0xe97b5
leaq 0x129f59(%rip), %rsi    # 0x213530
pushq $0x7
popq %rdi
callq 0xe99be
leaq 0x12b56a(%rip), %rsi    # 0x214b50
pushq $0x8
popq %rdi
popq %rbp
jmp 0xe9c94
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: do_incr_osc_adevs()
void do_incr_osc_adevs()
{
   // update each of the OSC adev bins with the latest queue data
   incr_adev(OSC_ADEV, &osc_adev_bins[0]);
   incr_hdev(OSC_HDEV, &osc_hdev_bins[0]);
   incr_mdev(OSC_MDEV, &osc_mdev_bins[0]);
   incr_tdev(OSC_TDEV, &osc_tdev_bins[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x13044d(%rip), %rsi    # 0x21a3d0
xorl %edi, %edi
callq 0xe95ef
leaq 0x12c1df(%rip), %rsi    # 0x216170
pushq $0x1
popq %rdi
callq 0xe97b5
leaq 0x12d7f0(%rip), %rsi    # 0x217790
pushq $0x2
popq %rdi
callq 0xe99be
leaq 0x12ee01(%rip), %rsi    # 0x218db0
pushq $0x3
popq %rdi
popq %rbp
jmp 0xe9c94
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: do_incr_chc_adevs()
void do_incr_chc_adevs()
{
   // update each of the CHC adev bins with the latest queue data
   incr_adev(CHC_ADEV, &chc_adev_bins[0]);
   incr_hdev(CHC_HDEV, &chc_hdev_bins[0]);
   incr_mdev(CHC_MDEV, &chc_mdev_bins[0]);
   incr_tdev(CHC_TDEV, &chc_tdev_bins[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x131a2d(%rip), %rsi    # 0x21b9f0
pushq $0xa
popq %rdi
callq 0xe95ef
leaq 0x13303e(%rip), %rsi    # 0x21d010
pushq $0xb
popq %rdi
callq 0xe97b5
leaq 0x13464f(%rip), %rsi    # 0x21e630
pushq $0xc
popq %rdi
callq 0xe99be
leaq 0x135c60(%rip), %rsi    # 0x21fc50
pushq $0xd
popq %rdi
popq %rbp
jmp 0xe9c94
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: do_incr_chd_adevs()
void do_incr_chd_adevs()
{
   // update each of the CHD adev bins with the latest queue data
   incr_adev(CHD_ADEV, &chd_adev_bins[0]);
   incr_hdev(CHD_HDEV, &chd_hdev_bins[0]);
   incr_mdev(CHD_MDEV, &chd_mdev_bins[0]);
   incr_tdev(CHD_TDEV, &chd_tdev_bins[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x13726c(%rip), %rsi    # 0x221270
pushq $0xf
popq %rdi
callq 0xe95ef
leaq 0x13887d(%rip), %rsi    # 0x222890
pushq $0x10
popq %rdi
callq 0xe97b5
leaq 0x139e8e(%rip), %rsi    # 0x223eb0
pushq $0x11
popq %rdi
callq 0xe99be
leaq 0x13b49f(%rip), %rsi    # 0x2254d0
pushq $0x12
popq %rdi
popq %rbp
jmp 0xe9c94
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: incr_pps_overflow()
void incr_pps_overflow()
{
int b;

   // tweek bin data counts when the PPS/chA adev queue is full
   pps_adev_q_overflow += 1.0;

   for(b=0; b<n_bins; b++) {  
      pps_adev_bins[b].n--; 
      pps_adev_bins[b].j--;
      pps_hdev_bins[b].n--;
      pps_hdev_bins[b].j--;
      pps_mdev_bins[b].n--;
      pps_mdev_bins[b].j--;
      pps_tdev_bins[b].n--;
      pps_tdev_bins[b].j--;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x13cac6(%rip), %rax    # 0x226b40
movsd (%rax), %xmm0
addsd 0x8fea(%rip), %xmm0     # 0xf3070
movsd %xmm0, (%rax)
leaq 0x13cc2f(%rip), %rax    # 0x226cc0
movslq (%rax), %rax
movabsq $0x2c, %rcx
xorl %edx, %edx
leaq 0x126849(%rip), %rsi    # 0x2108f0
leaq 0x127e62(%rip), %rdi    # 0x211f10
leaq 0x12947b(%rip), %r8     # 0x213530
leaq 0x12aa94(%rip), %r9     # 0x214b50
cmpq %rax, %rdx
jge 0xea0ea
decl -0x28(%rsi,%rcx)
decl (%rsi,%rcx)
decl -0x28(%rdi,%rcx)
decl (%rdi,%rcx)
decl -0x28(%r8,%rcx)
decl (%r8,%rcx)
decl -0x28(%r9,%rcx)
decl (%r9,%rcx)
incq %rdx
addq $0x38, %rcx
jmp 0xea0bc
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: incr_osc_overflow()
void incr_osc_overflow()
{
int b;

   // tweek bin data counts when the OSC/chB adev queue is full
   osc_adev_q_overflow += 1.0;

   for(b=0; b<n_bins; b++) {  
      osc_adev_bins[b].n--;
      osc_adev_bins[b].j--;
      osc_hdev_bins[b].n--;
      osc_hdev_bins[b].j--;
      osc_mdev_bins[b].n--;
      osc_mdev_bins[b].j--;
      osc_tdev_bins[b].n--;
      osc_tdev_bins[b].j--;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x13ca99(%rip), %rax    # 0x226b90
movsd (%rax), %xmm0
addsd 0x8f6d(%rip), %xmm0     # 0xf3070
movsd %xmm0, (%rax)
leaq 0x13cbb2(%rip), %rax    # 0x226cc0
movslq (%rax), %rax
movabsq $0x2c, %rcx
xorl %edx, %edx
leaq 0x1302ac(%rip), %rsi    # 0x21a3d0
leaq 0x12c045(%rip), %rdi    # 0x216170
leaq 0x12d65e(%rip), %r8     # 0x217790
leaq 0x12ec77(%rip), %r9     # 0x218db0
cmpq %rax, %rdx
jge 0xea167
decl -0x28(%rsi,%rcx)
decl (%rsi,%rcx)
decl -0x28(%rdi,%rcx)
decl (%rdi,%rcx)
decl -0x28(%r8,%rcx)
decl (%r8,%rcx)
decl -0x28(%r9,%rcx)
decl (%r9,%rcx)
incq %rdx
addq $0x38, %rcx
jmp 0xea139
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: incr_chc_overflow()
void incr_chc_overflow()
{
int b;

   // tweek bin data counts when the chC adev queue is full
   chc_adev_q_overflow += 1.0;

   for(b=0; b<n_bins; b++) {  
      chc_adev_bins[b].n--;
      chc_adev_bins[b].j--;
      chc_hdev_bins[b].n--;
      chc_hdev_bins[b].j--;
      chc_mdev_bins[b].n--;
      chc_mdev_bins[b].j--;
      chc_tdev_bins[b].n--;
      chc_tdev_bins[b].j--;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x13ca6c(%rip), %rax    # 0x226be0
movsd (%rax), %xmm0
addsd 0x8ef0(%rip), %xmm0     # 0xf3070
movsd %xmm0, (%rax)
leaq 0x13cb35(%rip), %rax    # 0x226cc0
movslq (%rax), %rax
movabsq $0x2c, %rcx
xorl %edx, %edx
leaq 0x13184f(%rip), %rsi    # 0x21b9f0
leaq 0x132e68(%rip), %rdi    # 0x21d010
leaq 0x134481(%rip), %r8     # 0x21e630
leaq 0x135a9a(%rip), %r9     # 0x21fc50
cmpq %rax, %rdx
jge 0xea1e4
decl -0x28(%rsi,%rcx)
decl (%rsi,%rcx)
decl -0x28(%rdi,%rcx)
decl (%rdi,%rcx)
decl -0x28(%r8,%rcx)
decl (%r8,%rcx)
decl -0x28(%r9,%rcx)
decl (%r9,%rcx)
incq %rdx
addq $0x38, %rcx
jmp 0xea1b6
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: incr_chd_overflow()
void incr_chd_overflow()
{
int b;

   // tweek bin data counts when the chD adev queue is full
   chd_adev_q_overflow += 1.0;

   for(b=0; b<n_bins; b++) {  
      chd_adev_bins[b].n--;
      chd_adev_bins[b].j--;
      chd_hdev_bins[b].n--;
      chd_hdev_bins[b].j--;
      chd_mdev_bins[b].n--;
      chd_mdev_bins[b].j--;
      chd_tdev_bins[b].n--;
      chd_tdev_bins[b].j--;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x13ca3f(%rip), %rax    # 0x226c30
movsd (%rax), %xmm0
addsd 0x8e73(%rip), %xmm0     # 0xf3070
movsd %xmm0, (%rax)
leaq 0x13cab8(%rip), %rax    # 0x226cc0
movslq (%rax), %rax
movabsq $0x2c, %rcx
xorl %edx, %edx
leaq 0x137052(%rip), %rsi    # 0x221270
leaq 0x13866b(%rip), %rdi    # 0x222890
leaq 0x139c84(%rip), %r8     # 0x223eb0
leaq 0x13b29d(%rip), %r9     # 0x2254d0
cmpq %rax, %rdx
jge 0xea261
decl -0x28(%rsi,%rcx)
decl (%rsi,%rcx)
decl -0x28(%rdi,%rcx)
decl (%rdi,%rcx)
decl -0x28(%r8,%rcx)
decl (%r8,%rcx)
decl -0x28(%r9,%rcx)
decl (%r9,%rcx)
incq %rdx
addq $0x38, %rcx
jmp 0xea233
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: calc_resids(int, double, double)
void calc_resids(int plot, double resid_val, double period)
{
double x,y;

   if(plot < 0) return;
   if(plot >= (NUM_PLOTS+DERIVED_PLOTS)) return;

   resid[plot].resid_count += 1.0;
   y = resid_val;
   x = resid[plot].resid_count * period;

   resid[plot].sum_x  += x;
   resid[plot].sum_y  += y;
   resid[plot].sum_xx += (x*x);
   resid[plot].sum_yy += (y*y);
   resid[plot].sum_xy += (x*y);
//   resid[plot].a0 = 
}

// Assembly:
cmpl $0x13, %edi
ja 0xea2e4
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
shlq $0x6, %rax
leaq 0x23f5d7(%rip), %rcx    # 0x329850
movsd 0x38(%rcx,%rax), %xmm2
addsd 0x8de9(%rip), %xmm2     # 0xf3070
movsd %xmm2, 0x38(%rcx,%rax)
mulsd %xmm1, %xmm2
movsd (%rcx,%rax), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%rax)
movsd 0x8(%rcx,%rax), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rcx,%rax)
movapd %xmm2, %xmm1
mulsd %xmm2, %xmm1
addsd 0x10(%rcx,%rax), %xmm1
movsd %xmm1, 0x10(%rcx,%rax)
mulsd %xmm0, %xmm2
mulsd %xmm0, %xmm0
addsd 0x18(%rcx,%rax), %xmm0
movsd %xmm0, 0x18(%rcx,%rax)
addsd 0x20(%rcx,%rax), %xmm2
movsd %xmm2, 0x20(%rcx,%rax)
popq %rbp
retq