LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: set_marker_size(int)
int set_marker_size(int prn)
{
int marker_size;

   if(prn < 0) return 0;
   if(prn > SUN_MOON_PRN) return 0;

   marker_size = (int) sat[prn].sig_level;
if((rcvr_type == UBX_RCVR) && (prn != SUN_PRN)) marker_size += (marker_size / 3);  // UBX receivers have smaller sig level values
   if(marker_size < 0) marker_size = 0 - marker_size;
   if(amu_mode == 0) {
       marker_size -= 30;  // 30 dBc represents our minimum marker size
   }

   if(marker_size > MAX_MARKER_SIZE) marker_size = MAX_MARKER_SIZE;   // and 44 dBc is our max size
   else if(marker_size < MIN_MARKER_SIZE) marker_size = MIN_MARKER_SIZE;
   marker_size = (int) (((float) marker_size) / (float) MAX_MARKER_SIZE * (float) AZEL_SIZE/20.0F);
   if(marker_size < MIN_MARKER_SIZE) marker_size = MIN_MARKER_SIZE;

   return marker_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x14ec99
movl $0x0, -0x4(%rbp)
jmp 0x14ed7c
cmpl $0x3e9, -0x8(%rbp)      # imm = 0x3E9
jle 0x14ecae
movl $0x0, -0x4(%rbp)
jmp 0x14ed7c
movslq -0x8(%rbp), %rcx
leaq 0x14f4d7(%rip), %rax    # 0x29e190
imulq $0x348, %rcx, %rcx      # imm = 0x348
addq %rcx, %rax
cvttss2si 0x20(%rax), %eax
movl %eax, -0xc(%rbp)
leaq 0x128dde(%rip), %rax    # 0x277ab0
cmpq $0x4, (%rax)
jne 0x14ecf2
cmpl $0x3e8, -0x8(%rbp)      # imm = 0x3E8
je 0x14ecf2
movl -0xc(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x14ed00
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq 0x14f3c9(%rip), %rax    # 0x29e0d0
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x14ed18
movl -0xc(%rbp), %eax
subl $0x1e, %eax
movl %eax, -0xc(%rbp)
cmpl $0xe, -0xc(%rbp)
jle 0x14ed27
movl $0xe, -0xc(%rbp)
jmp 0x14ed36
cmpl $0x3, -0xc(%rbp)
jge 0x14ed34
movl $0x3, -0xc(%rbp)
jmp 0x14ed36
cvtsi2ssl -0xc(%rbp), %xmm0
movss 0x34615(%rip), %xmm1    # 0x183358
divss %xmm1, %xmm0
leaq 0x24b81e(%rip), %rax    # 0x39a56c
cvtsi2ssl (%rax), %xmm1
mulss %xmm1, %xmm0
movss 0x3463e(%rip), %xmm1    # 0x18339c
divss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x14ed76
movl $0x3, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: clear_sat_trails()
void clear_sat_trails()
{
int i;
int prn;

   for(prn=0; prn<=MOON_PRN; prn++) {
      for(i=0; i<TRAIL_POINTS; i++) {  // clear the sat's position list
         sat_trail[prn].az[i] = 0.0F;
         sat_trail[prn].el[i] = 0.0F;
         sat_trail[prn].mins[i] = 0;
      }
   }
   trail_count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
cmpl $0x3e9, -0x8(%rbp)      # imm = 0x3E9
jg 0x1508fa
movl $0x0, -0x4(%rbp)
cmpl $0x48, -0x4(%rbp)
jge 0x1508ea
movslq -0x8(%rbp), %rcx
leaq 0x28a5e0(%rip), %rax    # 0x3dae60
imulq $0x36c, %rcx, %rcx      # imm = 0x36C
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movslq -0x8(%rbp), %rcx
leaq 0x28a5bf(%rip), %rax    # 0x3dae60
imulq $0x36c, %rcx, %rcx      # imm = 0x36C
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, 0x124(%rax,%rcx,4)
movslq -0x8(%rbp), %rcx
leaq 0x28a59a(%rip), %rax    # 0x3dae60
imulq $0x36c, %rcx, %rcx      # imm = 0x36C
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movl $0x0, 0x248(%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x15086f
jmp 0x1508ec
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x15085b
movl $0x0, 0x28a54c(%rip)    # 0x3dae50
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: blink_sat()
int blink_sat()
{
   if(blink_prn >= 0) return blink_prn;    // user specified sat
   else if(blink_prn == BLINK_HIGHEST) return highest_sat();
   else if(blink_prn == BLINK_PLOT) return plot_prn;

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x21a309(%rip), %rax    # 0x36b978
cmpl $0x0, (%rax)
jl 0x151682
leaq 0x21a2fd(%rip), %rax    # 0x36b978
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1516bd
leaq 0x21a2ef(%rip), %rax    # 0x36b978
cmpl $-0x1, (%rax)
jne 0x151698
callq 0xec370
movl %eax, -0x4(%rbp)
jmp 0x1516bd
leaq 0x21a2d9(%rip), %rax    # 0x36b978
cmpl $-0x2, (%rax)
jne 0x1516b2
leaq 0x21a2c9(%rip), %rax    # 0x36b974
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1516bd
jmp 0x1516b4
jmp 0x1516b6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: dbc_to_amu(float)
float dbc_to_amu(float sig_level)
{
int i;

   if(sig_level <= 0.0F)  return 0.0F;
   if(sig_level >= 51.0F) return 25.1F + ((sig_level - 51.0F) * 3.0F);

   for(i=0; i<256; i++) {
      if(amu_2_dbc[i] > sig_level) return ((float) i) / 10.0F;
   }
   return 0.0F;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jb 0x154c0f
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x154ca4
movss -0x8(%rbp), %xmm0
movss 0x3a5b8(%rip), %xmm1    # 0x18f1d4
ucomiss %xmm1, %xmm0
jb 0x154c51
movss -0x8(%rbp), %xmm0
movss 0x3a5a6(%rip), %xmm1    # 0x18f1d4
subss %xmm1, %xmm0
movss 0x2e6de(%rip), %xmm1    # 0x183318
mulss %xmm1, %xmm0
movss 0x3a58a(%rip), %xmm1    # 0x18f1d0
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x154ca4
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x154c9c
movslq -0xc(%rbp), %rcx
leaq 0x7adb4(%rip), %rax     # 0x1cfa20
movss (%rax,%rcx,4), %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0x154c8f
cvtsi2ssl -0xc(%rbp), %xmm0
movss 0x2e69c(%rip), %xmm1    # 0x183320
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x154ca4
jmp 0x154c91
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x154c58
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: clear_signals()
void clear_signals()
{
int x, y;

   // clear out the signal level data structures

   for(x=0; x<=360; x++) {
      db_az_sum[x] = 0.0F;
      db_weighted_az_sum[x] = 0.0F;
      db_az_count[x] = 0.0F;
      max_el[x] = 0;
      min_el[x] = 90;

      for(y=0; y<=90; y++) {
         db_3d_sum[x][y] = 0.0F;
         db_3d_count[x][y] = (-1.0F);
      }
   }

   for(y=0; y<=90; y++) {
      db_el_sum[y]= 0.0F;
      db_el_count[y] = 0.0F;
   }

   max_sig_level = 0.0F;
   min_sig_level = 999.0F;
   sig_level_sum = 0.0;
   sig_level_count = 0.0;
   max_sat_prn = 0;
   for(x=0; x<=32; x++) {
      max_sat_db[x] = 0.0F;
   }

   reading_signals = 0;  // re-enable live data recording
   signal_length = 0L;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x168, -0x4(%rbp)      # imm = 0x168
jg 0x1575f4
movslq -0x4(%rbp), %rcx
leaq 0x798dd(%rip), %rax     # 0x1d0e10
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x79e7a(%rip), %rax     # 0x1d13c0
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x7a417(%rip), %rax     # 0x1d1970
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x792f4(%rip), %rax     # 0x1d0860
movl $0x0, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x78d32(%rip), %rax     # 0x1d02b0
movl $0x5a, (%rax,%rcx,4)
movl $0x0, -0x8(%rbp)
cmpl $0x5a, -0x8(%rbp)
jg 0x1575e4
movslq -0x4(%rbp), %rcx
leaq 0x7ac63(%rip), %rax     # 0x1d2200
imulq $0x16c, %rcx, %rcx      # imm = 0x16C
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x9ad92(%rip), %rax     # 0x1f2350
imulq $0x16c, %rcx, %rcx      # imm = 0x16C
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movss 0x1a364(%rip), %xmm0    # 0x171938
movss %xmm0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x15758c
jmp 0x1575e6
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x15751b
movl $0x0, -0x8(%rbp)
cmpl $0x5a, -0x8(%rbp)
jg 0x157632
movslq -0x8(%rbp), %rcx
leaq 0x7a914(%rip), %rax     # 0x1d1f20
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movslq -0x8(%rbp), %rcx
leaq 0x7aa71(%rip), %rax     # 0x1d2090
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1575fb
leaq 0xbbe0f(%rip), %rax     # 0x213448
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
leaq 0xbbe05(%rip), %rax     # 0x21344c
movss 0x1a2e5(%rip), %xmm0    # 0x171934
movss %xmm0, (%rax)
leaq 0xbbdf6(%rip), %rax     # 0x213450
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
leaq 0xbbdf0(%rip), %rax     # 0x213458
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
leaq 0x78c32(%rip), %rax     # 0x1d02a8
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
cmpl $0x20, -0x4(%rbp)
jg 0x1576a7
movslq -0x4(%rbp), %rcx
leaq 0xbae0c(%rip), %rax     # 0x2124a0
xorps %xmm0, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x157683
leaq 0x242e0a(%rip), %rax    # 0x39a4b8
movb $0x0, (%rax)
leaq 0x242e04(%rip), %rax    # 0x39a4bc
movl $0x0, (%rax)
popq %rbp
retq
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: freshen_sig_info()
void freshen_sig_info()
{
int az, ell;

   // keep signal level maps "fresh" by periodically re-starting the averaging
   // of readings from the current avaerage.

   for(az=0; az<=360; az++) {
      if(db_az_count[az]) {
         db_weighted_az_sum[az] = (db_weighted_az_sum[az] / db_az_count[az]);
         db_az_sum[az] = (db_az_sum[az] / db_az_count[az]);
         db_az_count[az] = 1;
      }
   }

   for(ell=0; ell<=90; ell++) {
      if(db_el_count[ell]) {
         db_el_sum[ell] = (db_el_sum[ell] / db_el_count[ell]);
         db_el_count[ell] = 1;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x168, -0x4(%rbp)      # imm = 0x168
jg 0x15777c
movslq -0x4(%rbp), %rcx
leaq 0x7a28d(%rip), %rax     # 0x1d1970
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1576f4
jp 0x1576f4
jmp 0x15776c
movslq -0x4(%rbp), %rcx
leaq 0x79cc1(%rip), %rax     # 0x1d13c0
movss (%rax,%rcx,4), %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x7a261(%rip), %rax     # 0x1d1970
divss (%rax,%rcx,4), %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x79ca1(%rip), %rax     # 0x1d13c0
movss %xmm0, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x796e1(%rip), %rax     # 0x1d0e10
movss (%rax,%rcx,4), %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x7a231(%rip), %rax     # 0x1d1970
divss (%rax,%rcx,4), %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x796c1(%rip), %rax     # 0x1d0e10
movss %xmm0, (%rax,%rcx,4)
movslq -0x4(%rbp), %rcx
leaq 0x7a211(%rip), %rax     # 0x1d1970
movss 0x1a1d5(%rip), %xmm0    # 0x17193c
movss %xmm0, (%rax,%rcx,4)
jmp 0x15776e
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1576cb
movl $0x0, -0x8(%rbp)
cmpl $0x5a, -0x8(%rbp)
jg 0x1577fa
movslq -0x8(%rbp), %rcx
leaq 0x7a8fc(%rip), %rax     # 0x1d2090
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1577a5
jp 0x1577a5
jmp 0x1577ed
movslq -0x8(%rbp), %rcx
leaq 0x7a770(%rip), %rax     # 0x1d1f20
movss (%rax,%rcx,4), %xmm0
movslq -0x8(%rbp), %rcx
leaq 0x7a8d0(%rip), %rax     # 0x1d2090
divss (%rax,%rcx,4), %xmm0
movslq -0x8(%rbp), %rcx
leaq 0x7a750(%rip), %rax     # 0x1d1f20
movss %xmm0, (%rax,%rcx,4)
movslq -0x8(%rbp), %rcx
leaq 0x7a8b0(%rip), %rax     # 0x1d2090
movss 0x1a154(%rip), %xmm0    # 0x17193c
movss %xmm0, (%rax,%rcx,4)
jmp 0x1577ef
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x157783
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: next_az_point(int, int)
int next_az_point(int start_az, int el)
{
   if(start_az >= 360) return 360;
   while(++start_az < 360) {
      if(db_3d_count[start_az][el] > 0.0F) break;
      if((lat < 0.0) || (DABS(lat*RAD_TO_DEG) > HIGH_LATS)) {
         if(start_az == 180) break;
      }
   }
   return start_az;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x168, -0x8(%rbp)      # imm = 0x168
jl 0x1582cf
movl $0x168, -0x4(%rbp)      # imm = 0x168
jmp 0x1583bf
jmp 0x1582d1
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x168, %eax            # imm = 0x168
jge 0x1583b9
movslq -0x8(%rbp), %rcx
leaq 0x9a060(%rip), %rax     # 0x1f2350
imulq $0x16c, %rcx, %rcx      # imm = 0x16C
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x158310
jmp 0x1583b9
xorps %xmm0, %xmm0
leaq 0x213e96(%rip), %rax    # 0x36c1b0
ucomisd (%rax), %xmm0
ja 0x1583a7
movsd 0x16e54(%rip), %xmm1    # 0x16f180
leaq 0x213e7d(%rip), %rax    # 0x36c1b0
mulsd (%rax), %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x15837c
leaq 0x213e69(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x16e16(%rip), %xmm1    # 0x16f180
mulsd %xmm1, %xmm0
xorps %xmm1, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x158394
movsd 0x16dfc(%rip), %xmm0    # 0x16f180
leaq 0x213e25(%rip), %rax    # 0x36c1b0
mulsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x2af17(%rip), %xmm1    # 0x1832b8
ucomisd %xmm1, %xmm0
jbe 0x1583b4
cmpl $0xb4, -0x8(%rbp)
jne 0x1583b2
jmp 0x1583b9
jmp 0x1583b4
jmp 0x1582d1
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: draw_3d_signals()
void draw_3d_signals()
{
int el;

   // draw signal level map as a function of az/el
   start_color = BLACK;
   if(plot_signals == 4) {  // find min and max elevations seen at each az angle
      calc_az_clip();
   }
   else if(plot_signals) ;
   else if(zoom_screen == 'S') {
      calc_az_clip();
   }

   for(el=0; el<90; el++) {
      if(plot_signals >= 5) {  // just show raw data points
         plot_raw_signals(el);
      }
      else {                   // show fully expanded color data plot
         plot_3d_signals(el);
      }
   }

   azel_grid_color = WHITE;  // AZEL_COLOR;
   draw_azel_grid(1, AZEL_X,AZEL_Y, AZEL_RADIUS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0x359782(%rip)    # 0x4b1e74
leaq 0x121efc(%rip), %rax    # 0x27a5f5
movzbl (%rax), %eax
cmpl $0x4, %eax
jne 0x158708
callq 0x157f70
jmp 0x15872e
leaq 0x121ee6(%rip), %rax    # 0x27a5f5
cmpb $0x0, (%rax)
je 0x158716
jmp 0x15872c
leaq 0x21326b(%rip), %rax    # 0x36b988
movzbl (%rax), %eax
cmpl $0x53, %eax
jne 0x15872a
callq 0x157f70
jmp 0x15872c
jmp 0x15872e
movl $0x0, -0x4(%rbp)
cmpl $0x5a, -0x4(%rbp)
jge 0x158769
leaq 0x121eb3(%rip), %rax    # 0x27a5f5
movzbl (%rax), %eax
cmpl $0x5, %eax
jl 0x158754
movl -0x4(%rbp), %edi
callq 0x157cd0
jmp 0x15875c
movl -0x4(%rbp), %edi
callq 0x1583d0
jmp 0x15875e
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x158735
leaq 0x241e18(%rip), %rax    # 0x39a588
movl $0xf, (%rax)
leaq 0x241e03(%rip), %rax    # 0x39a580
movl (%rax), %esi
leaq 0x241dfe(%rip), %rax    # 0x39a584
movl (%rax), %eax
movl %eax, -0x8(%rbp)
leaq 0x241dda(%rip), %rax    # 0x39a56c
movl (%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x8(%rbp), %edx
movl %eax, %ecx
leaq 0x241dd0(%rip), %rax    # 0x39a578
subl (%rax), %ecx
movl $0x1, %edi
callq 0x150290
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x4b, -0x8(%rbp)
jg 0x15960e
movslq -0x8(%rbp), %rcx
leaq 0x78adc(%rip), %rax     # 0x1d2090
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1595c5
jp 0x1595c5
jmp 0x159601
movslq -0x8(%rbp), %rcx
leaq 0x78950(%rip), %rax     # 0x1d1f20
movss (%rax,%rcx,4), %xmm0
movslq -0x8(%rbp), %rcx
leaq 0x78ab0(%rip), %rax     # 0x1d2090
divss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
ucomiss -0xc(%rbp), %xmm0
jbe 0x1595ff
movss -0x10(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
jmp 0x159601
jmp 0x159603
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1595a3
movss -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x159629
jp 0x159629
movl $0x1e, -0x4(%rbp)
jmp 0x15972b
movl $0x0, -0x8(%rbp)
cmpl $0x4b, -0x8(%rbp)
jg 0x159724
movslq -0x8(%rbp), %rcx
leaq 0x78a4b(%rip), %rax     # 0x1d2090
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x159659
jp 0x159659
jmp 0x159714
movslq -0x8(%rbp), %rcx
leaq 0x788bc(%rip), %rax     # 0x1d1f20
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x159678
jp 0x159678
jmp 0x159714
movslq -0x8(%rbp), %rcx
leaq 0x7889d(%rip), %rax     # 0x1d1f20
movss (%rax,%rcx,4), %xmm0
movslq -0x8(%rbp), %rcx
leaq 0x789fd(%rip), %rax     # 0x1d2090
divss (%rax,%rcx,4), %xmm0
divss -0xc(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
xorl %eax, %eax
leaq 0x11e42f(%rip), %rcx    # 0x277ae4
cmpb $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0x1596d0
leaq 0x11e420(%rip), %rax    # 0x277ae4
movzbl (%rax), %eax
cmpl $0x1, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movss 0x15c49(%rip), %xmm0    # 0x16f324
movss 0x35af5(%rip), %xmm1    # 0x18f1d8
movss %xmm1, -0x20(%rbp)
testb $0x1, %al
movss %xmm0, -0x1c(%rbp)
jne 0x1596fb
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x1c(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x159712
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15972b
jmp 0x159714
jmp 0x159716
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x159630
movl $0x1e, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0x3e7, -0xc(%rbp)      # imm = 0x3E7
jg 0x1597a9
movslq -0xc(%rbp), %rcx
leaq 0xb8d41(%rip), %rax     # 0x2124a0
movss (%rax,%rcx,4), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x159770
jp 0x159770
jmp 0x15979c
movslq -0xc(%rbp), %rcx
leaq 0xb8d25(%rip), %rax     # 0x2124a0
movss (%rax,%rcx,4), %xmm0
addss -0x8(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss 0x181aa(%rip), %xmm0    # 0x17193c
addss -0x4(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x15979e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x15974b
movss -0x4(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x1597ba
jp 0x1597ba
jmp 0x1597e1
movss -0x4(%rbp), %xmm1
movss -0x8(%rbp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss 0x35a07(%rip), %xmm0    # 0x18f1dc
mulss -0x8(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
jmp 0x1597ee
movss 0x29bb3(%rip), %xmm0    # 0x18339c
movss %xmm0, -0x8(%rbp)
movss 0x1814a(%rip), %xmm0    # 0x171940
addss -0x8(%rbp), %xmm0
cvttss2si %xmm0, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: float_error(double)
double float_error(double val)
{
float x;

   // calculate the error between the single and double precision value
   x = (float) val;
   val = val - x;
   if(val < 0.0) val = 0.0 - val;
   return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movsd -0x8(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jbe 0x159895
xorps %xmm0, %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: 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 %rbx
subq $0x28, %rsp
movl %edi, -0xc(%rbp)
leaq 0x143ccd(%rip), %rax    # 0x29d580
cmpq $0x0, (%rax)
jne 0x1598f8
leaq 0x765a8(%rip), %rax     # 0x1cfe68
movq (%rax), %rdx
leaq 0x241b36(%rip), %rdi    # 0x39b400
leaq 0x3e479(%rip), %rsi     # 0x197d4a
movb $0x0, %al
callq 0x9060
leaq 0x241b21(%rip), %rdi    # 0x39b400
leaq 0x2ad65(%rip), %rsi     # 0x18464b
callq 0x9b20
movq %rax, %rcx
leaq 0x143c8b(%rip), %rax    # 0x29d580
movq %rcx, (%rax)
leaq 0x143c81(%rip), %rax    # 0x29d580
cmpq $0x0, (%rax)
jne 0x15990a
jmp 0x1599eb
leaq 0x212da7(%rip), %rax    # 0x36c6b8
movl (%rax), %edi
callq 0x9c2e0
movl %eax, %ecx
leaq 0x212d97(%rip), %rax    # 0x36c6b8
movl %ecx, (%rax)
leaq 0x143c56(%rip), %rax    # 0x29d580
movq (%rax), %rdi
leaq 0x212d80(%rip), %rax    # 0x36c6b4
movl (%rax), %ecx
leaq 0x212d7b(%rip), %rax    # 0x36c6b8
movslq (%rax), %rdx
leaq 0x6fdf9(%rip), %rax     # 0x1c9740
movq (%rax,%rdx,8), %r8
leaq 0x212d6a(%rip), %rax    # 0x36c6bc
movl (%rax), %r9d
leaq 0x212d54(%rip), %rax    # 0x36c6b0
movl (%rax), %ebx
leaq 0x212d47(%rip), %rax    # 0x36c6ac
movl (%rax), %r11d
leaq 0x212d39(%rip), %rax    # 0x36c6a8
movl (%rax), %r10d
leaq 0x212937(%rip), %rax    # 0x36c2b0
movzbl (%rax), %eax
leaq 0x3e3ce(%rip), %rsi     # 0x197d51
leaq 0x241a76(%rip), %rdx    # 0x39b400
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movb $0x0, %al
callq 0x9550
leaq 0x143bd7(%rip), %rax    # 0x29d580
movq (%rax), %rdi
movsd 0x157cc(%rip), %xmm0    # 0x16f180
leaq 0x240b15(%rip), %rax    # 0x39a4d0
mulsd (%rax), %xmm0
movsd 0x157b9(%rip), %xmm1    # 0x16f180
leaq 0x240b0a(%rip), %rax    # 0x39a4d8
mulsd (%rax), %xmm1
leaq 0x240b07(%rip), %rax    # 0x39a4e0
movsd (%rax), %xmm2
leaq 0x3e3b2(%rip), %rsi     # 0x197d96
movb $0x3, %al
callq 0x9550
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x159a5b
xorl %edi, %edi
callq 0x159b10
cmpl $0x0, -0x4(%rbp)
jl 0x159a84
movl -0x4(%rbp), %eax
movl $0xff, %edx
movss 0x17ec7(%rip), %xmm3    # 0x171938
movzbl %al, %edi
movl %edx, %esi
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x805d0
callq 0x8bdd0
leaq 0x240a00(%rip), %rax    # 0x39a490
movb $0x2, (%rax)
leaq 0x120b59(%rip), %rax    # 0x27a5f3
movb $0x1, (%rax)
leaq 0x120b50(%rip), %rax    # 0x27a5f4
movb $0x1, (%rax)
leaq 0x11df32(%rip), %rax    # 0x2779e0
cmpl $0x690, (%rax)          # imm = 0x690
setge %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x159af3
leaq 0x240b00(%rip), %rax    # 0x39a5c8
movb $0x1, (%rax)
leaq 0x11dfde(%rip), %rax    # 0x277ab0
cmpq $0x10000, (%rax)        # imm = 0x10000
jne 0x159ae7
leaq 0x14243c(%rip), %rax    # 0x29bf1e
movb $0x5, (%rax)
jmp 0x159af1
leaq 0x142430(%rip), %rax    # 0x29bf1e
movb $0x0, (%rax)
jmp 0x159af3
cmpl $0x0, -0x4(%rbp)
jl 0x159b06
leaq 0x2409c4(%rip), %rax    # 0x39a4c4
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x159b23
jmp 0x159b39
leaq 0x211e5e(%rip), %rax    # 0x36b988
movzbl (%rax), %eax
cmpl $0x4c, %eax
jne 0x159b37
jmp 0x159c2d
jmp 0x159b39
movl $0x0, -0x8(%rbp)
cmpl $0x280, -0x8(%rbp)      # imm = 0x280
jge 0x159b8e
movl $0x0, -0xc(%rbp)
cmpl $0x280, -0xc(%rbp)      # imm = 0x280
jge 0x159b81
movslq -0x8(%rbp), %rcx
leaq 0xb990c(%rip), %rax     # 0x213470
imulq $0x281, %rcx, %rcx      # imm = 0x281
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x159b50
jmp 0x159b83
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x159b40
leaq 0x24098b(%rip), %rax    # 0x39a520
cmpl $0x0, (%rax)
jne 0x159bdc
leaq 0x21260f(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
leaq 0x240944(%rip), %rax    # 0x39a4f0
movsd %xmm0, (%rax)
leaq 0x212601(%rip), %rax    # 0x36c1b8
movsd (%rax), %xmm0
leaq 0x240936(%rip), %rax    # 0x39a4f8
movsd %xmm0, (%rax)
leaq 0x2125f3(%rip), %rax    # 0x36c1c0
movsd (%rax), %xmm0
leaq 0x240928(%rip), %rax    # 0x39a500
movsd %xmm0, (%rax)
leaq 0x24090d(%rip), %rax    # 0x39a4f0
movsd (%rax), %xmm0
callq 0x96f0
leaq 0x2125b5(%rip), %rax    # 0x36c1a8
movsd %xmm0, (%rax)
leaq 0x2125aa(%rip), %rax    # 0x36c1a8
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x159c20
jp 0x159c20
leaq 0x212594(%rip), %rax    # 0x36c1a8
movsd 0x15574(%rip), %xmm0    # 0x16f190
movsd %xmm0, (%rax)
leaq 0x2408a1(%rip), %rax    # 0x39a4c8
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x213016(%rip), %rax    # 0x36d078
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x15a06f
jmp 0x15a155
leaq 0x213002(%rip), %rax    # 0x36d078
movb $0x0, (%rax)
movl -0x4(%rbp), %edx
leaq 0x142abd(%rip), %rdi    # 0x29cb40
leaq 0x3deab(%rip), %rsi     # 0x197f35
movb $0x0, %al
callq 0x9060
movl $0x1, %edi
callq 0x10cbe0
leaq 0x240412(%rip), %rax    # 0x39a4b4
movb $0x0, (%rax)
leaq 0x240408(%rip), %rax    # 0x39a4b4
movzbl (%rax), %edi
callq 0x52a70
movl $0x7, %edi
movl $0xff, %edx
movss 0x17872(%rip), %xmm3    # 0x171938
movl %edx, %esi
movaps %xmm3, %xmm0
movaps %xmm3, %xmm1
movaps %xmm3, %xmm2
callq 0x805d0
leaq 0x1434a3(%rip), %rax    # 0x29d580
cmpq $0x0, (%rax)
je 0x15a155
leaq 0x143496(%rip), %rax    # 0x29d580
movq (%rax), %rdi
leaq 0x3de65(%rip), %rsi     # 0x197f59
movb $0x0, %al
callq 0x9550
leaq 0x14347e(%rip), %rax    # 0x29d580
movq (%rax), %rdi
leaq 0x212810(%rip), %rax    # 0x36c91c
movl (%rax), %eax
movl %eax, %edx
addq $0x3c, %rdx
movsd 0x15064(%rip), %xmm0    # 0x16f180
leaq 0x21208d(%rip), %rax    # 0x36c1b0
mulsd (%rax), %xmm0
movsd 0x15051(%rip), %xmm1    # 0x16f180
leaq 0x212082(%rip), %rax    # 0x36c1b8
mulsd (%rax), %xmm1
leaq 0x21207f(%rip), %rax    # 0x36c1c0
movsd (%rax), %xmm2
leaq 0x3de23(%rip), %rsi     # 0x197f6f
xorl %ecx, %ecx
movb $0x3, %al
callq 0x9550
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x11d642(%rip), %rax    # 0x2779b8
cmpl $0x0, (%rax)
je 0x15a398
leaq 0x11d606(%rip), %rax    # 0x277988
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq 0x11d5fb(%rip), %rax    # 0x27798c
movl (%rax), %eax
movl %eax, -0x10(%rbp)
jmp 0x15a416
leaq 0x2400ed(%rip), %rax    # 0x39a48c
movl (%rax), %eax
leaq 0x11d648(%rip), %rcx    # 0x2779f0
cltd
idivl (%rcx)
addl $0x1, %eax
movl %eax, -0x10(%rbp)
leaq 0x2400d0(%rip), %rax    # 0x39a488
movl (%rax), %eax
leaq 0x2400b7(%rip), %rcx    # 0x39a478
addl (%rcx), %eax
leaq 0x11d62a(%rip), %rcx    # 0x2779f4
cltd
idivl (%rcx)
addl $0x0, %eax
movl %eax, -0x14(%rbp)
leaq 0x11d606(%rip), %rax    # 0x2779e0
movl (%rax), %eax
movl %eax, -0x18(%rbp)
leaq 0x12833e(%rip), %rax    # 0x282724
imull $0x31a, (%rax), %eax    # imm = 0x31A
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl $0x6, %ecx
cmpl %ecx, %eax
jle 0x15a40b
movl -0x10(%rbp), %eax
addl $0x5, %eax
movl %eax, -0x10(%rbp)
jmp 0x15a414
movl -0x10(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x15a416
movl -0x14(%rbp), %edi
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl %al, %edx
callq 0x10ee0
movq -0x8(%rbp), %rsi
leaq 0x27f1ba(%rip), %rdi    # 0x3d95f0
callq 0x9350
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
leaq 0x11c7b9(%rip), %rax    # 0x2779b8
cmpl $0x0, (%rax)
je 0x15b215
leaq 0x142f2d(%rip), %rax    # 0x29e138
cmpl $0x0, (%rax)
je 0x15b215
jmp 0x15b33b
leaq 0x23f274(%rip), %rax    # 0x39a490
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x15b229
jmp 0x15b33b
leaq 0x23f25c(%rip), %rax    # 0x39a48c
movl (%rax), %eax
leaq 0x11c7b7(%rip), %rcx    # 0x2779f0
cltd
idivl (%rcx)
addl $0x1, %eax
movl %eax, -0x4(%rbp)
leaq 0x11c797(%rip), %rax    # 0x2779e0
movl (%rax), %eax
movl %eax, -0x8(%rbp)
leaq 0x1274cf(%rip), %rax    # 0x282724
imull $0x31a, (%rax), %eax    # imm = 0x31A
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x8(%rbp), %eax
addl $0x6, %ecx
cmpl %ecx, %eax
jle 0x15b27a
movl -0x4(%rbp), %eax
addl $0x5, %eax
movl %eax, -0x4(%rbp)
jmp 0x15b283
movl -0x4(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x4(%rbp)
callq 0x15ab00
cmpl $0x0, %eax
je 0x15b2ea
callq 0x15ada0
movsd 0x163f6(%rip), %xmm0    # 0x171690
mulsd 0x3581de(%rip), %xmm0   # 0x4b3480
movsd 0x163e6(%rip), %xmm1    # 0x171690
mulsd 0x3581d6(%rip), %xmm1   # 0x4b3488
leaq 0x23f247(%rip), %rax    # 0x39a500
movsd (%rax), %xmm2
leaq 0x23f1c4(%rip), %rax    # 0x39a488
movl (%rax), %eax
leaq 0x23f1ab(%rip), %rcx    # 0x39a478
addl (%rcx), %eax
leaq 0x11c71e(%rip), %rcx    # 0x2779f4
cltd
idivl (%rcx)
movl %eax, %edi
addl $0x1, %edi
movl -0x4(%rbp), %esi
xorl %edx, %edx
callq 0xf2600
jmp 0x15b33b
callq 0x15ada0
leaq 0x23f1fa(%rip), %rax    # 0x39a4f0
movsd (%rax), %xmm0
leaq 0x23f1f7(%rip), %rax    # 0x39a4f8
movsd (%rax), %xmm1
leaq 0x23f1f4(%rip), %rax    # 0x39a500
movsd (%rax), %xmm2
leaq 0x23f171(%rip), %rax    # 0x39a488
movl (%rax), %eax
leaq 0x23f158(%rip), %rcx    # 0x39a478
addl (%rcx), %eax
leaq 0x11c6cb(%rip), %rcx    # 0x2779f4
cltd
idivl (%rcx)
movl %eax, %edi
addl $0x1, %edi
movl -0x4(%rbp), %esi
xorl %edx, %edx
callq 0xf2600
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
cmpl $0x60, -0x1c(%rbp)
jl 0x15c5a1
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15c627
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x15c618
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x15c609
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
jmp 0x15c60b
jmp 0x15c618
jmp 0x15c60d
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x15c5bc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
leaq 0x23cb5e(%rip), %rax    # 0x39a4c4
movl (%rax), %eax
movl $0xe10, %ecx            # imm = 0xE10
cqto
idivq %rcx
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0xc, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
leaq 0x20f6ee(%rip), %rax    # 0x36d078
cmpb $0x0, (%rax)
jne 0x15d9a7
leaq 0x23cb2a(%rip), %rax    # 0x39a4c0
cmpb $0x0, (%rax)
jne 0x15d9a7
leaq 0x23cb12(%rip), %rax    # 0x39a4b4
cmpb $0x0, (%rax)
je 0x15d9d8
leaq 0x20ecce(%rip), %rax    # 0x36c67c
cmpl $0x0, (%rax)
jne 0x15d9d6
leaq 0x23cad6(%rip), %rax    # 0x39a490
cmpb $0x0, (%rax)
je 0x15d9d6
movl -0x4(%rbp), %esi
addl $0x3, %esi
movl $0x1, %edi
callq 0x12c200
movl $0x1, -0x8(%rbp)
jmp 0x15d9d8
cmpl $0x0, -0x8(%rbp)
jne 0x15d9eb
movl -0x4(%rbp), %esi
addl $0x3, %esi
xorl %edi, %edi
callq 0x12c200
leaq 0x20f686(%rip), %rax    # 0x36d078
cmpb $0x0, (%rax)
je 0x15da1b
callq 0x15d760
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x15da19
movl $0x1, %edi
callq 0x15a050
callq 0x15c870
callq 0x15bd60
jmp 0x15da3e
leaq 0x23ca92(%rip), %rax    # 0x39a4b4
cmpb $0x0, (%rax)
je 0x15da3c
leaq 0x23ca96(%rip), %rax    # 0x39a4c4
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x23ca8a(%rip), %rax    # 0x39a4c4
movl %ecx, (%rax)
jmp 0x15da3e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 0x15da50
movl $0x1, %edi
callq 0x15da50
movl $0x2, %edi
callq 0x15da50
movl $0x3, %edi
callq 0x15da50
leaq 0x13de84(%rip), %rax    # 0x29bec4
movl $0x0, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: mtie_phase(int, int)
double mtie_phase(int id, int ndx)
{
   // get a value from the MTIE data buffer
   if(id < 0) return 0.0;
   if(id > MAX_MTIE_CHANS) return 0.0;

   if(ndx < 0) return 0.0;
   if(ndx >= max_mtie_samples) return 0.0;

   return mtie_buf[id][ndx];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x15e06a
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x15e0bc
cmpl $0x4, -0xc(%rbp)
jle 0x15e07a
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x15e0bc
cmpl $0x0, -0x10(%rbp)
jge 0x15e08a
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x15e0bc
movl -0x10(%rbp), %eax
cmpl 0x35694d(%rip), %eax    # 0x4b49e0
jl 0x15e09f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x15e0bc
movslq -0xc(%rbp), %rcx
leaq 0x356236(%rip), %rax    # 0x4b42e0
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x15e0e4
jmp 0x15e147
cmpl $0x4, -0x4(%rbp)
jle 0x15e0ec
jmp 0x15e147
movslq -0x4(%rbp), %rcx
leaq 0x356209(%rip), %rax    # 0x4b4300
movl (%rax,%rcx,4), %eax
cmpl 0x3568e0(%rip), %eax    # 0x4b49e0
jl 0x15e104
jmp 0x15e147
movsd -0x10(%rbp), %xmm0
movslq -0x4(%rbp), %rcx
leaq 0x3561cc(%rip), %rax    # 0x4b42e0
movq (%rax,%rcx,8), %rax
movslq -0x4(%rbp), %rdx
leaq 0x3561dd(%rip), %rcx    # 0x4b4300
movslq (%rcx,%rdx,4), %rcx
movsd %xmm0, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0x3561c9(%rip), %rax    # 0x4b4300
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x3561bc(%rip), %rax    # 0x4b4300
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x15e752
jmp 0x15e82a
cmpl $0x4, -0x4(%rbp)
jle 0x15e75d
jmp 0x15e82a
leaq 0x13d6fc(%rip), %rax    # 0x29be60
movl (%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x20, -0x8(%rbp)
jge 0x15e82a
movslq -0x4(%rbp), %rcx
leaq 0x354ec2(%rip), %rax    # 0x4b3640
imulq $0x328, %rcx, %rcx      # imm = 0x328
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x108c7(%rip), %xmm1    # 0x16f060
ucomisd %xmm1, %xmm0
jne 0x15e7a3
jp 0x15e7a3
jmp 0x15e81c
movslq -0x4(%rbp), %rcx
leaq 0x354e92(%rip), %rax    # 0x4b3640
imulq $0x328, %rcx, %rcx      # imm = 0x328
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x1085f(%rip), %xmm1    # 0x16f028
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
leaq 0x13d4ea(%rip), %rax    # 0x29bcc8
ucomisd (%rax), %xmm0
jbe 0x15e7f4
movsd -0x10(%rbp), %xmm0
leaq 0x13d4d8(%rip), %rax    # 0x29bcc8
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm1
leaq 0x13d4d0(%rip), %rax    # 0x29bcd0
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x15e81a
movsd -0x10(%rbp), %xmm0
leaq 0x13d4ba(%rip), %rax    # 0x29bcd0
movsd %xmm0, (%rax)
jmp 0x15e81c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x15e769
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: calc_adev_display_size()
void calc_adev_display_size()
{
   adev_bottom_row  = PLOT_TEXT_ROW - 1;
   adev_bottom_row -= (TEXT_Y_MARGIN+TEXT_HEIGHT-1)/TEXT_HEIGHT;
   if(extra_plots) adev_bottom_row -= 2;
   if(all_adevs && (adev_bottom_row >= MOUSE_ROW+1)) adev_bottom_row = MOUSE_ROW+1; // mmmmmm 

   if(all_adevs) adev_bottom_row = MOUSE_ROW+1;
   else          adev_bottom_row = MOUSE_ROW+2+1;  // mmmmmm
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x119235(%rip), %rax    # 0x277a70
movl (%rax), %ecx
subl $0x1, %ecx
leaq 0x119151(%rip), %rax    # 0x277998
movl %ecx, (%rax)
leaq 0x1191a4(%rip), %rax    # 0x2779f4
movl (%rax), %eax
shll $0x0, %eax
leaq 0x119198(%rip), %rcx    # 0x2779f4
addl (%rcx), %eax
subl $0x1, %eax
leaq 0x11918c(%rip), %rcx    # 0x2779f4
cltd
idivl (%rcx)
leaq 0x119126(%rip), %rcx    # 0x277998
movl (%rcx), %ecx
subl %eax, %ecx
leaq 0x11911b(%rip), %rax    # 0x277998
movl %ecx, (%rax)
leaq 0x2406ae(%rip), %rax    # 0x39ef34
cmpl $0x0, (%rax)
je 0x15e8a0
leaq 0x119106(%rip), %rax    # 0x277998
movl (%rax), %ecx
subl $0x2, %ecx
leaq 0x1190fa(%rip), %rax    # 0x277998
movl %ecx, (%rax)
leaq 0x13d677(%rip), %rax    # 0x29bf1e
cmpb $0x0, (%rax)
je 0x15e8da
leaq 0x1190e5(%rip), %rax    # 0x277998
movl (%rax), %eax
leaq 0x1190cc(%rip), %rcx    # 0x277988
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jl 0x15e8da
leaq 0x1190bc(%rip), %rax    # 0x277988
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x1190c0(%rip), %rax    # 0x277998
movl %ecx, (%rax)
leaq 0x13d63d(%rip), %rax    # 0x29bf1e
cmpb $0x0, (%rax)
je 0x15e8fd
leaq 0x11909b(%rip), %rax    # 0x277988
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x11909f(%rip), %rax    # 0x277998
movl %ecx, (%rax)
jmp 0x15e915
leaq 0x119084(%rip), %rax    # 0x277988
movl (%rax), %ecx
addl $0x2, %ecx
addl $0x1, %ecx
leaq 0x119085(%rip), %rax    # 0x277998
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x15ebad
jmp 0x15ec73
movl $0x1, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0x15ec73
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x15ebe4
jmp 0x15ec65
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
cvtsi2sdl -0x18(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x30(%rax)
movslq -0x18(%rbp), %rdi
leaq 0x13d201(%rip), %rax    # 0x29be5c
movl (%rax), %esi
callq 0x15e920
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15ebbb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
leaq 0x13d095(%rip), %rax    # 0x29bd20
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
leaq 0x13d247(%rip), %rax    # 0x29bee0
movsd (%rax), %xmm0
leaq 0x126e2c(%rip), %rdi    # 0x285ad0
callq 0x15eb90
leaq 0x13d230(%rip), %rax    # 0x29bee0
movsd (%rax), %xmm0
leaq 0x128435(%rip), %rdi    # 0x2870f0
callq 0x15eb90
leaq 0x13d219(%rip), %rax    # 0x29bee0
movsd (%rax), %xmm0
leaq 0x129a3e(%rip), %rdi    # 0x288710
callq 0x15eb90
leaq 0x13d202(%rip), %rax    # 0x29bee0
movsd (%rax), %xmm0
leaq 0x12b047(%rip), %rdi    # 0x289d30
callq 0x15eb90
popq %rbp
retq
// File: 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
leaq 0x13d075(%rip), %rax    # 0x29bd70
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
leaq 0x13d1df(%rip), %rax    # 0x29bee8
movsd (%rax), %xmm0
leaq 0x13089c(%rip), %rdi    # 0x28f5b0
callq 0x15eb90
leaq 0x13d1c8(%rip), %rax    # 0x29bee8
movsd (%rax), %xmm0
leaq 0x12c625(%rip), %rdi    # 0x28b350
callq 0x15eb90
leaq 0x13d1b1(%rip), %rax    # 0x29bee8
movsd (%rax), %xmm0
leaq 0x12dc2e(%rip), %rdi    # 0x28c970
callq 0x15eb90
leaq 0x13d19a(%rip), %rax    # 0x29bee8
movsd (%rax), %xmm0
leaq 0x12f237(%rip), %rdi    # 0x28df90
callq 0x15eb90
popq %rbp
retq
// File: 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
leaq 0x13d055(%rip), %rax    # 0x29bdc0
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
leaq 0x13d177(%rip), %rax    # 0x29bef0
movsd (%rax), %xmm0
leaq 0x131e4c(%rip), %rdi    # 0x290bd0
callq 0x15eb90
leaq 0x13d160(%rip), %rax    # 0x29bef0
movsd (%rax), %xmm0
leaq 0x133455(%rip), %rdi    # 0x2921f0
callq 0x15eb90
leaq 0x13d149(%rip), %rax    # 0x29bef0
movsd (%rax), %xmm0
leaq 0x134a5e(%rip), %rdi    # 0x293810
callq 0x15eb90
leaq 0x13d132(%rip), %rax    # 0x29bef0
movsd (%rax), %xmm0
leaq 0x136067(%rip), %rdi    # 0x294e30
callq 0x15eb90
popq %rbp
retq