LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: calc_moon_posn(int)
void calc_moon_posn(int watch)
{
double maz,mel;
int r;

   if(map_and_watch && (watch == 0)) {
      r = AZEL_RADIUS;
      moon_size = (AZEL_RADIUS/4);
   }
   else {
      r = ACLOCK_R;
      moon_size = (ACLOCK_R/4);
   }

   mel = moon_el;
   if(mel < 0.0) {
      mel = 0.0 - mel;
      moon_color = GREY;
   }
   mel = (mel - 90.0F) / 90.0F;

   maz = moon_az;
   maz += 90.0F;
   if(maz >= 360.0) maz -= 360.0;
   if(maz <= 360.0) maz += 360.0;
   moon_x = (int) (mel * cos360((int)maz) * r);
   moon_y = (int) (mel * sin360((int)maz) * r);
//sprintf(plot_title, "ACLOCK:%d  AZEL:%d  maw:%d", ACLOCK_R,AZEL_RADIUS, map_and_watch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq 0x12a304(%rip), %rax    # 0x21b410
cmpb $0x0, (%rax)
setne %al
testl %edi, %edi
sete %cl
leaq 0x24a252(%rip), %rdx    # 0x33b370
testb %al, %cl
cmovneq 0x5ed80(%rip), %rdx     # 0x14fea8
leaq 0x1276e1(%rip), %rax    # 0x218810
cmovneq 0x5ee31(%rip), %rax     # 0x14ff68
movl (%rdx), %ecx
movl %ecx, %ebx
shrl $0x1f, %ebx
addl %ecx, %ebx
sarl %ebx
subl (%rax), %ebx
leal 0x3(%rbx), %eax
testl %ebx, %ebx
cmovnsl %ebx, %eax
sarl $0x2, %eax
movl %eax, 0x288c03(%rip)    # 0x379d58
leaq 0x21c694(%rip), %rax    # 0x30d7f0
movsd (%rax), %xmm4
xorpd %xmm0, %xmm0
ucomisd %xmm4, %xmm0
jbe 0xf117c
subsd %xmm4, %xmm0
movl $0x8, 0x794c8(%rip)     # 0x16a640
movapd %xmm0, %xmm4
leaq 0x21c665(%rip), %rax    # 0x30d7e8
movsd 0x1a785(%rip), %xmm0    # 0x10b910
movsd (%rax), %xmm1
addsd %xmm0, %xmm1
movsd 0x3a84d(%rip), %xmm2    # 0x12b9e8
addsd %xmm1, %xmm2
movsd 0x2cee9(%rip), %xmm5    # 0x11e090
movapd %xmm5, %xmm3
cmpnlesd %xmm1, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm3
orpd %xmm1, %xmm3
movapd %xmm3, %xmm1
cmpnlesd %xmm5, %xmm1
movapd %xmm1, %xmm2
andpd %xmm3, %xmm2
addsd %xmm5, %xmm3
andnpd %xmm3, %xmm1
orpd %xmm2, %xmm1
addsd 0x1a7af(%rip), %xmm4    # 0x10b990
divsd %xmm0, %xmm4
movsd %xmm4, -0x10(%rbp)
cvttpd2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
movapd %xmm0, -0x30(%rbp)
movapd %xmm5, %xmm1
callq 0x94d0
divsd 0x17f50(%rip), %xmm0    # 0x109158
callq 0x9710
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
movsd %xmm1, -0x18(%rbp)
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x288b1c(%rip)    # 0x379d50
movapd -0x30(%rbp), %xmm0
movsd 0x2ce4f(%rip), %xmm1    # 0x11e090
callq 0x94d0
divsd 0x17f0a(%rip), %xmm0    # 0x109158
callq 0x9080
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd -0x10(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x288ae5(%rip)    # 0x379d54
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x3e9, %edi            # imm = 0x3E9
jbe 0xf2e2a
xorl %eax, %eax
jmp 0xf2ec7
movl %edi, %eax
imulq $0x348, %rax, %rax      # imm = 0x348
leaq 0x14c176(%rip), %rcx    # 0x23efb0
cvttss2si 0x20(%rcx,%rax), %eax
cmpl $0x3e8, %edi            # imm = 0x3E8
je 0xf2e6d
leaq 0x125a81(%rip), %rcx    # 0x2188d0
cmpq $0x4, (%rcx)
jne 0xf2e6d
cltq
imulq $0x55555556, %rax, %rcx # imm = 0x55555556
movq %rcx, %rdx
shrq $0x3f, %rdx
shrq $0x20, %rcx
addl %edx, %ecx
addl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
leaq 0x14c075(%rip), %rax    # 0x23eef0
leal -0x1e(%rcx), %edx
cmpb $0x0, (%rax)
cmovnel %ecx, %edx
cmpl $0x4, %edx
movl $0x3, %eax
cmovll %eax, %edx
cmpl $0xe, %edx
movl $0xe, %ecx
cmovll %edx, %ecx
cvtsi2ss %ecx, %xmm0
divss 0x3984a(%rip), %xmm0    # 0x12c6f0
leaq 0x2484df(%rip), %rcx    # 0x33b38c
cvtsi2ssl (%rcx), %xmm1
mulss %xmm0, %xmm1
divss 0x2bae3(%rip), %xmm1    # 0x11e9a0
cvttss2si %xmm1, %ecx
cmpl $0x4, %ecx
cmovgel %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: tick_radial(int, int, int, int, int)
void tick_radial(int grid_x,int grid_y, int grid_r, int max_el, int az)
{
int x0,y0;
int x1,y1;
int x2,y2;
int el;
double len;
double r;

   x0 = grid_x;
   y0 = grid_y;
   r = (double) grid_r;
   if(plot_signals == 3) {
      x0 -= grid_r;
      y0 += grid_r;
      r *= 2.0F;
   }

   for(el=0; el<max_el; el+=5) {
      len = (r * ((double)(max_el-el)/(double) max_el));
      x1 = (int) (len * cos360(az-2));
      y1 = (int) (len * sin360(az-2));

      x2 = (int) (len * cos360(az+2));
      y2 = (int) (len * sin360(az+2));

      line(x0+x1,y0+y1, x0+x2,y0+y2, azel_grid_color);
   }
}

// Assembly:
cvtsi2sd %edx, %xmm0
leaq 0x1275d0(%rip), %r9     # 0x21b415
xorl %eax, %eax
cmpb $0x3, (%r9)
cmovel %edx, %eax
jne 0xf3e54
addsd %xmm0, %xmm0
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edi, -0x2c(%rbp)
movl %esi, -0x30(%rbp)
testl %ecx, %ecx
jle 0xf3fce
addl %eax, -0x30(%rbp)
cvtsi2sd %ecx, %xmm1
movsd %xmm1, -0x58(%rbp)
subl %eax, -0x2c(%rbp)
leal -0x2(%r8), %eax
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
movsd %xmm1, -0x50(%rbp)
addl $0x2, %r8d
xorps %xmm1, %xmm1
cvtsi2sd %r8d, %xmm1
movsd %xmm1, -0x48(%rbp)
xorl %r14d, %r14d
movl %ecx, %r15d
movl %ecx, -0x3c(%rbp)
movsd %xmm0, -0x60(%rbp)
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
divsd -0x58(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x38(%rbp)
movsd -0x50(%rbp), %xmm0
movsd 0x2a1bc(%rip), %xmm1    # 0x11e090
callq 0x94d0
movsd 0x15277(%rip), %xmm1    # 0x109158
divsd %xmm1, %xmm0
callq 0x9710
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd -0x38(%rbp), %xmm0
cvttsd2si %xmm0, %r12d
movsd -0x50(%rbp), %xmm0
movsd 0x2a187(%rip), %xmm1    # 0x11e090
callq 0x94d0
divsd 0x15242(%rip), %xmm0    # 0x109158
callq 0x9080
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd -0x38(%rbp), %xmm0
cvttsd2si %xmm0, %r13d
movsd -0x48(%rbp), %xmm0
movsd 0x2a156(%rip), %xmm1    # 0x11e090
callq 0x94d0
divsd 0x15211(%rip), %xmm0    # 0x109158
callq 0x9710
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd -0x38(%rbp), %xmm0
cvttsd2si %xmm0, %ebx
movsd -0x48(%rbp), %xmm0
movsd 0x2a126(%rip), %xmm1    # 0x11e090
callq 0x94d0
divsd 0x151e1(%rip), %xmm0    # 0x109158
callq 0x9080
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
mulsd -0x38(%rbp), %xmm0
cvttsd2si %xmm0, %ecx
movl -0x2c(%rbp), %edx
addl %edx, %r12d
movl -0x30(%rbp), %eax
addl %eax, %r13d
addl %edx, %ebx
addl %eax, %ecx
leaq 0x247404(%rip), %rax    # 0x33b3a8
movzbl (%rax), %r8d
movl %r12d, %edi
movl %r13d, %esi
movl %ebx, %edx
callq 0xe3c3
movsd -0x60(%rbp), %xmm0
movl -0x3c(%rbp), %ecx
addl $0x5, %r14d
addl $-0x5, %r15d
cmpl %ecx, %r14d
jl 0xf3eb1
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x2877a8(%rip), %rax    # 0x37bb98
xorl %ecx, %ecx
xorl %edx, %edx
movq $-0x48, %rsi
movl %ecx, -0x128(%rax,%rsi,4)
movl %ecx, -0x4(%rax,%rsi,4)
movl %ecx, 0x120(%rax,%rsi,4)
incq %rsi
jne 0xf43fb
incq %rdx
addq $0x36c, %rax            # imm = 0x36C
cmpq $0x3ea, %rdx            # imm = 0x3EA
jne 0xf43f4
movl $0x0, 0x287512(%rip)    # 0x37b940
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movaps %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0xf7358
ucomiss 0x35409(%rip), %xmm1    # 0x12c710
jae 0xf732c
leaq 0x79530(%rip), %rcx     # 0x170840
xorl %eax, %eax
movss (%rcx), %xmm2
ucomiss %xmm1, %xmm2
ja 0xf7349
incq %rax
addq $0x4, %rcx
cmpq $0x100, %rax            # imm = 0x100
jne 0xf7312
jmp 0xf7358
addss 0x353e0(%rip), %xmm1    # 0x12c714
mulss 0x15c88(%rip), %xmm1    # 0x10cfc4
addss 0x353c4(%rip), %xmm1    # 0x12c708
movaps %xmm1, %xmm0
jmp 0xf7358
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss 0x15c88(%rip), %xmm0    # 0x10cfe0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: small_screen_watch()
void small_screen_watch()
{
int medium_touch;  // for 1024x600 touch screen

if(plot_lla && lla_showing) return;

   medium_touch = ((SCREEN_WIDTH > MEDIUM_WIDTH) && (SCREEN_WIDTH <= (MEDIUM_WIDTH+X11_MARGIN)) && (SCREEN_HEIGHT <= SHORT_SCREEN) && (all_adevs == SINGLE_ADEVS));

   if(medium_touch || (SMALL_SCREEN && (SCREEN_WIDTH > NARROW_SCREEN) && (all_adevs == SINGLE_ADEVS))) {
      if(rcvr_type == NO_RCVR) {
         aclock_y = WATCH_ROW + ACLOCK_R + TEXT_WIDTH;
         aclock_x = WATCH_COL + TEXT_WIDTH;
      }
      else {
         ACLOCK_SIZE = WATCH_SIZE;
         aclock_y = WATCH_ROW + ACLOCK_R + TEXT_WIDTH;
         aclock_x = WATCH_COL + ACLOCK_R + TEXT_WIDTH;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x243f4b(%rip), %rax    # 0x33b2b0
cmpb $0x0, (%rax)
je 0xf737a
leaq 0x243f4f(%rip), %rax    # 0x33b2c0
cmpl $0x0, (%rax)
jne 0xf7484
leaq 0x12147f(%rip), %rax    # 0x218800
movl (%rax), %eax
leal -0x3e3(%rax), %ecx
cmpl $0x6, %ecx
setb %dl
leaq 0x12146e(%rip), %rcx    # 0x218804
movl (%rcx), %ecx
cmpl $0x259, %ecx            # imm = 0x259
setl %sil
andb %dl, %sil
leaq 0x145992(%rip), %rdx    # 0x23cd3e
movb (%rdx), %dl
testb %dl, %dl
sete %dil
testb %dil, %sil
jne 0xf73fd
testb %dl, %dl
sete %dl
leaq 0x12c17f(%rip), %rsi    # 0x223544
imull $0x31a, (%rsi), %esi    # imm = 0x31A
movslq %esi, %rsi
imulq $0x51eb851f, %rsi, %rsi # imm = 0x51EB851F
movq %rsi, %rdi
shrq $0x3f, %rdi
sarq $0x25, %rsi
addl %edi, %esi
cmpl $0x258, %ecx            # imm = 0x258
setl %cl
cmpl %esi, %eax
setg %al
andb %dl, %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xf7484
leaq 0x1214cc(%rip), %rax    # 0x2188d0
cmpq $0x400, (%rax)          # imm = 0x400
jne 0xf7443
leaq 0x243f50(%rip), %rax    # 0x33b364
leaq 0x243f55(%rip), %rcx    # 0x33b370
movl (%rcx), %ecx
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
addl (%rax), %edx
leaq 0x243f49(%rip), %rax    # 0x33b378
movl %edx, (%rax)
leaq 0x243f30(%rip), %rax    # 0x33b368
movl (%rax), %eax
leaq 0x1213cf(%rip), %rcx    # 0x218810
jmp 0xf7479
leaq 0x243f22(%rip), %rax    # 0x33b36c
movl (%rax), %ecx
leaq 0x243f1d(%rip), %rax    # 0x33b370
movl %ecx, (%rax)
leaq 0x243f08(%rip), %rdx    # 0x33b364
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
movl (%rdx), %ecx
addl %eax, %ecx
leaq 0x243f08(%rip), %rdx    # 0x33b378
movl %ecx, (%rdx)
leaq 0x243eef(%rip), %rcx    # 0x33b368
addl (%rcx), %eax
leaq 0x243ef2(%rip), %rcx    # 0x33b374
movl %eax, (%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: zoom_all_signals()
void zoom_all_signals()
{
int old_sigs;
int old_row, old_col;
int old_size;
int w;

   old_sigs = plot_signals;
   old_row = AZEL_ROW;
   old_col = AZEL_COL;
   old_size = AZEL_SIZE;

   if((SCREEN_WIDTH < TINY_TINY_WIDTH) || (SCREEN_WIDTH < SCREEN_HEIGHT)) {
      w = SCREEN_WIDTH;
   }
   else {
      w = SCREEN_HEIGHT;
   }
   AZEL_SIZE = ((w / 2) * 8) / 10;

   plot_signals = 1;
   AZEL_COL = 0 + TEXT_WIDTH*8;
   AZEL_ROW = TEXT_HEIGHT*2;
   erase_azel(2);
   draw_signal_map(3);

   plot_signals = 2;
   AZEL_COL = SCREEN_WIDTH/2;
   erase_azel(3);
   draw_signal_map(4);

   plot_signals = 3;
   AZEL_COL = 0 + TEXT_WIDTH*8;
   AZEL_ROW = (SCREEN_HEIGHT/2) + (TEXT_HEIGHT/2);
   erase_azel(4);
   draw_signal_map(5);

   plot_signals = 4;
   AZEL_COL = SCREEN_WIDTH/2;
   erase_azel(5);
   draw_signal_map(6);

   AZEL_COL = old_col;
   AZEL_ROW = old_row;
   AZEL_SIZE = old_size;
   plot_signals = old_sigs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x1237b3(%rip), %rbx    # 0x21b415
movb (%rbx), %al
movb %al, -0x29(%rbp)
leaq 0x243722(%rip), %r15    # 0x33b390
movl (%r15), %eax
movl %eax, -0x38(%rbp)
leaq 0x243719(%rip), %r13    # 0x33b394
movl (%r13), %eax
movl %eax, -0x34(%rbp)
leaq 0x243703(%rip), %rax    # 0x33b38c
movl (%rax), %ecx
movl %ecx, -0x30(%rbp)
movq %rax, %rdx
leaq 0x120b68(%rip), %rax    # 0x218800
movl (%rax), %eax
leaq 0x120b63(%rip), %rcx    # 0x218804
movl (%rcx), %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
cmpl $0x1c2, %eax            # imm = 0x1C2
cmovll %eax, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
shll $0x2, %eax
andl $-0x8, %eax
cltq
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x22, %rax
addl %ecx, %eax
movl %eax, (%rdx)
movb $0x1, (%rbx)
leaq 0x120b31(%rip), %r14    # 0x218810
movl (%r14), %eax
shll $0x3, %eax
movl %eax, (%r13)
leaq 0x120b24(%rip), %r12    # 0x218814
movl (%r12), %eax
addl %eax, %eax
movl %eax, (%r15)
movl $0x2, %edi
callq 0xee11
callq 0xf86eb
movb $0x2, (%rbx)
leaq 0x120aee(%rip), %rax    # 0x218800
movl (%rax), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, (%r13)
movl $0x3, %edi
callq 0xee11
callq 0xf86eb
movb $0x3, (%rbx)
movl (%r14), %eax
shll $0x3, %eax
movl %eax, (%r13)
leaq 0x120ac0(%rip), %rax    # 0x218804
movl (%rax), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl (%r12), %eax
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
addl %ecx, %edx
movl %edx, (%r15)
movl $0x4, %edi
callq 0xee11
callq 0xf86eb
movb $0x4, (%rbx)
leaq 0x120a86(%rip), %rax    # 0x218800
movl (%rax), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, (%r13)
movl $0x5, %edi
callq 0xee11
callq 0xf86eb
movl -0x34(%rbp), %eax
movl %eax, (%r13)
movl -0x38(%rbp), %eax
movl %eax, (%r15)
movl -0x30(%rbp), %eax
leaq 0x2435dd(%rip), %rcx    # 0x33b38c
movl %eax, (%rcx)
movb -0x29(%rbp), %al
movb %al, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
leaq 0x7a2c3(%rip), %rdi     # 0x173020
xorl %ebx, %ebx
movl $0x2014c, %edx          # imm = 0x2014C
xorl %esi, %esi
callq 0x91a0
leaq 0x9a3fe(%rip), %rax     # 0x193170
leaq 0x78eb7(%rip), %rcx     # 0x171c30
leaq 0x79460(%rip), %rdx     # 0x1721e0
leaq 0x79a09(%rip), %rsi     # 0x172790
leaq 0x788f2(%rip), %rdi     # 0x171680
leaq 0x7833b(%rip), %r8      # 0x1710d0
xorl %r9d, %r9d
movl %ebx, (%rcx,%r9,4)
movl %ebx, (%rdx,%r9,4)
movl %ebx, (%rsi,%r9,4)
movl %ebx, (%rdi,%r9,4)
movl $0x5a, (%r8,%r9,4)
xorl %r10d, %r10d
movl $0xbf800000, (%rax,%r10,4) # imm = 0xBF800000
incq %r10
cmpq $0x5b, %r10
jne 0xf8db3
incq %r9
addq $0x16c, %rax            # imm = 0x16C
cmpq $0x169, %r9             # imm = 0x169
jne 0xf8d98
leaq 0x79f63(%rip), %rdi     # 0x172d40
xorl %ebx, %ebx
movl $0x16c, %edx            # imm = 0x16C
xorl %esi, %esi
callq 0x91a0
leaq 0x7a0be(%rip), %rdi     # 0x172eb0
movl $0x16c, %edx            # imm = 0x16C
xorl %esi, %esi
callq 0x91a0
leaq 0xbb463(%rip), %rax     # 0x1b4268
movl %ebx, (%rax)
leaq 0xbb45e(%rip), %rax     # 0x1b426c
movl $0x4479c000, (%rax)     # imm = 0x4479C000
leaq 0xbb455(%rip), %rax     # 0x1b4270
movq %rbx, (%rax)
leaq 0xbb453(%rip), %rax     # 0x1b4278
movq %rbx, (%rax)
leaq 0x78299(%rip), %rax     # 0x1710c8
movl %ebx, (%rax)
leaq 0xba488(%rip), %rdi     # 0x1b32c0
movl $0x84, %edx
xorl %esi, %esi
callq 0x91a0
leaq 0x24248d(%rip), %rax    # 0x33b2d8
movb $0x0, (%rax)
leaq 0x242487(%rip), %rax    # 0x33b2dc
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
leaq 0x79929(%rip), %rcx     # 0x172790
xorps %xmm0, %xmm0
leaq 0x7936f(%rip), %rdx     # 0x1721e0
leaq 0x78db8(%rip), %rsi     # 0x171c30
movss (%rcx,%rax,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0xf8e84
jnp 0xf8ea7
movss (%rdx,%rax,4), %xmm2
divss %xmm1, %xmm2
movss %xmm2, (%rdx,%rax,4)
movss (%rsi,%rax,4), %xmm2
divss %xmm1, %xmm2
movss %xmm2, (%rsi,%rax,4)
movl $0x3f800000, (%rcx,%rax,4) # imm = 0x3F800000
incq %rax
cmpq $0x169, %rax            # imm = 0x169
jne 0xf8e78
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x79ff1(%rip), %rcx     # 0x172eb0
xorps %xmm0, %xmm0
leaq 0x79e77(%rip), %rdx     # 0x172d40
popq %rbp
movss (%rcx,%rax,4), %xmm1
ucomiss %xmm0, %xmm1
jne 0xf8ed6
jnp 0xf8eeb
movss (%rdx,%rax,4), %xmm2
divss %xmm1, %xmm2
movss %xmm2, (%rdx,%rax,4)
movl $0x3f800000, (%rcx,%rax,4) # imm = 0x3F800000
incq %rax
cmpq $0x5b, %rax
jne 0xf8eca
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: dump_signals(char*)
void dump_signals(char *fn)
{
FILE *f;
int az, el;

   // write signal strength data to a log file

   if(!strstr(fn, ".")) {
      strcat(fn, ".sig");
   }
   f = topen(fn, "w");
   if(f == 0) return;

   write_log_header(f, 3);
   month = fix_month(month);
   fprintf(f,"#   %02d:%02d:%02d %s   %02d %s %04d\n", 
      hours,minutes,seconds, (time_flags & TFLAGS_UTC)?"UTC":"GPS", day,months[month],year);
   fprintf(f, "#\n");
   fprintf(f, "#az el dBc\n");

   for(el=0; el<=90; el++) {
      for(az=0; az<=360; az++) {
         if(db_3d_count[az][el] > 0.0F) {
            fprintf(f, "%03d %02d %5.2f\n", az, el, db_3d_sum[az][el]/db_3d_count[az][el]);
         }
      }
   }

   fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2e, %esi
callq 0x9100
testq %rax, %rax
jne 0xf90ce
movq %rbx, %rdi
callq 0x9120
movl $0x6769732e, (%rbx,%rax) # imm = 0x6769732E
movb $0x0, 0x4(%rbx,%rax)
leaq 0x28206(%rip), %rsi     # 0x1212db
movq %rbx, %rdi
callq 0x9a4d
testq %rax, %rax
je 0xf923a
movq %rax, %r12
movq %rax, %rdi
callq 0xc6146
leaq 0x2143e0(%rip), %rbx    # 0x30d4d8
movl (%rbx), %edi
callq 0x724e5
movl %eax, (%rbx)
leaq 0x2143c8(%rip), %rcx    # 0x30d4d0
movl (%rcx), %edx
leaq 0x2143bb(%rip), %rcx    # 0x30d4cc
movl (%rcx), %ecx
leaq 0x2143ae(%rip), %rsi    # 0x30d4c8
movl (%rsi), %r8d
leaq 0x214380(%rip), %rsi    # 0x30d4a4
testb $0x1, (%rsi)
leaq 0x3a6d3(%rip), %rsi     # 0x133801
leaq 0x3bc89(%rip), %r9      # 0x134dbe
cmoveq %rsi, %r9
leaq 0x214394(%rip), %rsi    # 0x30d4d4
movl (%rsi), %r10d
movslq %eax, %r11
leaq 0x715f3(%rip), %rbx     # 0x16a740
leaq 0x214388(%rip), %rax    # 0x30d4dc
movl (%rax), %r15d
subq $0x8, %rsp
leaq 0x3bf13(%rip), %rsi     # 0x135075
xorl %r14d, %r14d
movq %r12, %rdi
xorl %eax, %eax
pushq %r15
pushq (%rbx,%r11,8)
pushq %r10
callq 0x9560
addq $0x20, %rsp
leaq 0x386fb(%rip), %rdi     # 0x13187d
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x9750
leaq 0x3bf00(%rip), %rdi     # 0x13509b
movl $0xb, %esi
movl $0x1, %edx
movq %r12, -0x30(%rbp)
movq %r12, %rcx
callq 0x9750
leaq 0x99fb8(%rip), %r13     # 0x193170
leaq 0x79e61(%rip), %r15     # 0x173020
xorps %xmm1, %xmm1
xorl %ebx, %ebx
xorl %r12d, %r12d
movss (%r13,%rbx), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xf91ff
movss (%r15,%rbx), %xmm1
divss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movq -0x30(%rbp), %rdi
leaq 0x3beb8(%rip), %rsi     # 0x1350a7
movl %r12d, %edx
movl %r14d, %ecx
movb $0x1, %al
callq 0x9560
xorps %xmm1, %xmm1
incq %r12
addq $0x16c, %rbx            # imm = 0x16C
cmpq $0x169, %r12            # imm = 0x169
jne 0xf91c7
incq %r14
addq $0x4, %r13
addq $0x4, %r15
cmpq $0x5b, %r14
jne 0xf91c2
movq -0x30(%rbp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9370
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl $0x168, %eax            # imm = 0x168
cmpl $0x167, %edi            # imm = 0x167
jg 0xf96cf
jne 0xf96d0
incl %edi
movl %edi, %eax
retq
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rdx
leaq 0x2138f2(%rip), %rcx    # 0x30cfd0
movsd (%rcx), %xmm0
movsd 0xfa6e(%rip), %xmm3     # 0x109158
mulsd %xmm0, %xmm3
xorpd %xmm1, %xmm1
xorpd %xmm4, %xmm4
subsd %xmm3, %xmm4
movapd %xmm3, %xmm2
cmpltsd %xmm1, %xmm2
andpd %xmm2, %xmm4
andnpd %xmm3, %xmm2
orpd %xmm4, %xmm2
movslq %edi, %rcx
incl %edi
imulq $0x16c, %rcx, %rsi      # imm = 0x16C
leaq (%rsi,%rdx,4), %rdx
addq 0x5678a(%rip), %rdx     # 0x14feb0
addq $0x2, %rcx
addq $0x16c, %rdx            # imm = 0x16C
xorpd %xmm3, %xmm3
movsd 0x25213(%rip), %xmm4    # 0x11e950
movss (%rdx), %xmm5
ucomiss %xmm3, %xmm5
ja 0xf978b
ucomisd %xmm0, %xmm1
jbe 0xf9757
cmpq $0xb5, %rcx
jne 0xf976f
jmp 0xf978b
cmpq $0xb5, %rcx
sete %sil
ucomisd %xmm4, %xmm2
seta %r8b
testb %sil, %r8b
jne 0xf978b
incl %edi
movq %rcx, %rsi
incq %rsi
addq $0x16c, %rdx            # imm = 0x16C
cmpl $0x168, %ecx            # imm = 0x168
movq %rsi, %rcx
jne 0xf973d
jmp 0xf978d
movl %edi, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl $0x0, 0x358fa2(%rip)    # 0x452964
xorl %ebx, %ebx
leaq 0x121a4a(%rip), %r14    # 0x21b415
cmpb $0x5, (%r14)
jb 0xf99da
movl %ebx, %edi
callq 0xf9249
jmp 0xf99e1
movl %ebx, %edi
callq 0xf978f
incl %ebx
cmpl $0x5a, %ebx
jne 0xf99cb
leaq 0x2419b9(%rip), %rax    # 0x33b3a8
movl $0xf, (%rax)
leaq 0x2419a4(%rip), %rax    # 0x33b3a0
movl (%rax), %esi
leaq 0x24199f(%rip), %rax    # 0x33b3a4
movl (%rax), %edx
leaq 0x24197e(%rip), %rax    # 0x33b38c
movl (%rax), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
leaq 0x241978(%rip), %rax    # 0x33b398
subl (%rax), %ecx
movl $0x1, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xf3fdd
// File: /workspace/github_cpp_makefile_star2_O1/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 0x78bc6(%rip), %rcx     # 0x172eb0
leaq 0x78a4f(%rip), %rdx     # 0x172d40
xorps %xmm0, %xmm0
movss (%rcx,%rax,4), %xmm3
ucomiss %xmm1, %xmm3
jne 0xfa300
jnp 0xfa311
movss (%rdx,%rax,4), %xmm2
divss %xmm3, %xmm2
ucomiss %xmm0, %xmm2
jbe 0xfa311
movaps %xmm2, %xmm0
incq %rax
cmpq $0x4c, %rax
jne 0xfa2f4
movl $0x1e, %eax
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xfa32a
jp 0xfa32a
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x11e5cf(%rip), %rsi    # 0x218904
xorl %edi, %edi
cmpb $0x2, (%rsi)
setae %dil
leaq 0x32333(%rip), %rsi     # 0x12c678
movss (%rsi,%rdi,4), %xmm2
xorl %esi, %esi
popq %rbp
movss (%rcx,%rsi,4), %xmm3
ucomiss %xmm1, %xmm3
jne 0xfa359
jnp 0xfa372
movss (%rdx,%rsi,4), %xmm4
ucomiss %xmm1, %xmm4
jne 0xfa365
jnp 0xfa372
divss %xmm3, %xmm4
divss %xmm0, %xmm4
ucomiss %xmm2, %xmm4
ja 0xfa37d
incq %rsi
cmpq $0x4c, %rsi
jne 0xfa34d
jmp 0xfa329
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %xmm1, %xmm1
movl $0x1, %eax
leaq 0xb8f31(%rip), %rcx     # 0x1b32c0
movss 0x12c3d(%rip), %xmm2    # 0x10cfd4
xorps %xmm0, %xmm0
xorps %xmm3, %xmm3
movaps %xmm3, %xmm5
movaps %xmm0, %xmm4
movss (%rcx,%rax,4), %xmm0
ucomiss %xmm0, %xmm1
addss %xmm2, %xmm3
jne 0xfa3b6
jp 0xfa3b6
movaps %xmm5, %xmm3
addss %xmm4, %xmm0
jne 0xfa3c1
jp 0xfa3c1
movaps %xmm4, %xmm0
incq %rax
cmpq $0x3e8, %rax            # imm = 0x3E8
jne 0xfa39d
pushq %rbp
movq %rsp, %rbp
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm3
divss %xmm3, %xmm0
mulss 0x3233a(%rip), %xmm0    # 0x12c71c
addss 0x12bfa(%rip), %xmm0    # 0x10cfe4
cvttss2si %xmm0, %ecx
movl $0x14, %eax
cmovnel %ecx, %eax
cmovpl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: clear_maps()
void clear_maps()
{
   // clear the signal level at sat position data

#ifdef SAT_TRAILS
   clear_sat_trails();
   need_redraw = 1101;
#endif

#ifdef SIG_LEVELS
   clear_signals();
   need_redraw = 1102;
#endif

   need_posns = 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r15d, %r15d
leaq 0x281540(%rip), %r12    # 0x37b950
leaq (%r12,%r15), %rdi
leaq (%r15,%r12), %rbx
addq $0x248, %rbx            # imm = 0x248
leaq (%r15,%r12), %r14
addq $0x124, %r14            # imm = 0x124
movl $0x120, %edx            # imm = 0x120
xorl %esi, %esi
callq 0x91a0
movl $0x120, %edx            # imm = 0x120
movq %r14, %rdi
xorl %esi, %esi
callq 0x91a0
movl $0x120, %edx            # imm = 0x120
movq %rbx, %rdi
xorl %esi, %esi
callq 0x91a0
addq $0x36c, %r15            # imm = 0x36C
cmpq $0xd64b8, %r15          # imm = 0xD64B8
jne 0xfa410
movl $0x0, 0x2814d2(%rip)    # 0x37b940
callq 0xf8d50
leaq 0x11e3ca(%rip), %rax    # 0x218844
movl $0x44e, (%rax)          # imm = 0x44E
leaq 0x120f59(%rip), %rax    # 0x21b3e0
movb $0x2, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cvtsd2ss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
subsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
movapd %xmm0, %xmm1
cmpltsd %xmm2, %xmm1
subsd %xmm0, %xmm2
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
movapd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x143ec9(%rip), %r14    # 0x23e3a0
cmpq $0x0, (%r14)
jne 0xfa511
leaq 0x767a4(%rip), %rax     # 0x170c88
movq (%rax), %rdx
leaq 0x241d32(%rip), %rbx    # 0x33c220
leaq 0x3abd3(%rip), %rsi     # 0x1350c8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9060
leaq 0x26dd5(%rip), %rsi     # 0x1212db
movq %rbx, %rdi
callq 0x9a4d
movq %rax, (%r14)
cmpq $0x0, (%r14)
je 0xfa5de
leaq 0x212fb6(%rip), %rbx    # 0x30d4d8
movl (%rbx), %edi
callq 0x724e5
movl %eax, (%rbx)
movq (%r14), %rdi
leaq 0x212f9f(%rip), %rcx    # 0x30d4d4
movl (%rcx), %ecx
cltq
leaq 0x70200(%rip), %rdx     # 0x16a740
movq (%rdx,%rax,8), %r8
leaq 0x212f91(%rip), %rax    # 0x30d4dc
movl (%rax), %r9d
leaq 0x212f7b(%rip), %rax    # 0x30d4d0
movl (%rax), %r10d
leaq 0x212f6d(%rip), %rax    # 0x30d4cc
movl (%rax), %r11d
leaq 0x212f5f(%rip), %rax    # 0x30d4c8
movl (%rax), %ebx
leaq 0x212b5e(%rip), %rax    # 0x30d0d0
movzbl (%rax), %r15d
leaq 0x3ab52(%rip), %rsi     # 0x1350cf
leaq 0x241c9c(%rip), %rdx    # 0x33c220
xorl %eax, %eax
pushq %r15
pushq %rbx
pushq %r11
pushq %r10
callq 0x9560
addq $0x20, %rsp
movq (%r14), %rdi
leaq 0x240d50(%rip), %rax    # 0x33b2f0
movsd 0xebb0(%rip), %xmm1     # 0x109158
movsd (%rax), %xmm0
mulsd %xmm1, %xmm0
leaq 0x240d41(%rip), %rax    # 0x33b2f8
mulsd (%rax), %xmm1
leaq 0x240d3e(%rip), %rax    # 0x33b300
movsd (%rax), %xmm2
leaq 0x3ab47(%rip), %rsi     # 0x135114
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_O1/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 0xfa647
xorl %edi, %edi
callq 0xfa6ba
movzbl %bl, %edi
movss 0x129a1(%rip), %xmm0    # 0x10cfd0
movl $0xff, %esi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
movaps %xmm0, %xmm3
movl $0xff, %edx
callq 0x5d081
callq 0x6627a
leaq 0x240c5d(%rip), %rax    # 0x33b2b0
movb $0x2, (%rax)
leaq 0x120db6(%rip), %rax    # 0x21b413
movb $0x1, %cl
movb %cl, (%rax)
leaq 0x120dac(%rip), %rax    # 0x21b414
movb %cl, (%rax)
leaq 0x11e18f(%rip), %rax    # 0x218800
cmpl $0x68f, (%rax)          # imm = 0x68F
jg 0xfa6a2
leaq 0x240d68(%rip), %rax    # 0x33b3e8
movb $0x1, (%rax)
leaq 0x11e246(%rip), %rax    # 0x2188d0
xorl %ecx, %ecx
cmpq $0x10000, (%rax)        # imm = 0x10000
sete %cl
leal (%rcx,%rcx,4), %eax
leaq 0x14269e(%rip), %rcx    # 0x23cd3e
movb %al, (%rcx)
testl %ebx, %ebx
js 0xfa6b3
leaq 0x240c37(%rip), %rax    # 0x33b2e4
movl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfa6cb
leaq 0x2120e3(%rip), %rax    # 0x30c7a8
cmpb $0x4c, (%rax)
jne 0xfa6cb
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
leaq 0xb9bb5(%rip), %r14     # 0x1b4290
leaq (%rbx,%r14), %rdi
movl $0x280, %edx            # imm = 0x280
xorl %esi, %esi
callq 0x91a0
addq $0x281, %rbx            # imm = 0x281
cmpq $0x64280, %rbx          # imm = 0x64280
jne 0xfa6db
leaq 0x240c3e(%rip), %rax    # 0x33b340
cmpl $0x0, (%rax)
jne 0xfa749
leaq 0x2128c2(%rip), %rax    # 0x30cfd0
movsd (%rax), %xmm0
leaq 0x240bf7(%rip), %rax    # 0x33b310
movsd %xmm0, (%rax)
leaq 0x2128b4(%rip), %rax    # 0x30cfd8
movsd (%rax), %xmm0
leaq 0x240be9(%rip), %rax    # 0x33b318
movsd %xmm0, (%rax)
leaq 0x2128a6(%rip), %rax    # 0x30cfe0
movsd (%rax), %xmm0
leaq 0x240bdb(%rip), %rax    # 0x33b320
movsd %xmm0, (%rax)
leaq 0x240bc0(%rip), %rax    # 0x33b310
movsd (%rax), %xmm0
callq 0x9710
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movsd 0x111be(%rip), %xmm2    # 0x10b928
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
leaq 0x21284b(%rip), %rax    # 0x30cfc8
movlpd %xmm1, (%rax)
leaq 0x240b60(%rip), %rax    # 0x33b2e8
movl $0x0, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2133aa(%rip), %rax    # 0x30de98
cmpb $0x0, (%rax)
je 0xfabc9
movl %edi, %edx
xorl %ebx, %ebx
movb %bl, (%rax)
leaq 0x142e5c(%rip), %rdi    # 0x23d960
leaq 0x3a7a8(%rip), %rsi     # 0x1352b3
xorl %eax, %eax
callq 0x9060
movl $0x1, %edi
callq 0xc3105
leaq 0x2407b1(%rip), %rax    # 0x33b2d4
movb %bl, (%rax)
xorl %edi, %edi
callq 0x3aabf
movss 0x1249c(%rip), %xmm0    # 0x10cfd0
movl $0x7, %edi
movl $0xff, %esi
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
movaps %xmm0, %xmm3
movl $0xff, %edx
callq 0x5d081
leaq 0x143848(%rip), %rbx    # 0x23e3a0
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xfabc9
leaq 0x3a770(%rip), %rdi     # 0x1352d7
movl $0x15, %esi
movl $0x1, %edx
callq 0x9750
movq (%rbx), %rdi
leaq 0x212bbc(%rip), %rax    # 0x30d73c
movl (%rax), %edx
leaq 0x212447(%rip), %rax    # 0x30cfd0
movsd 0xe5c7(%rip), %xmm1     # 0x109158
movsd (%rax), %xmm0
mulsd %xmm1, %xmm0
leaq 0x212438(%rip), %rax    # 0x30cfd8
mulsd (%rax), %xmm1
addq $0x3c, %rdx
leaq 0x212431(%rip), %rax    # 0x30cfe0
movsd (%rax), %xmm2
leaq 0x3a733(%rip), %rsi     # 0x1352ed
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_O1/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 0x11da2f(%rip), %rax    # 0x2187d8
cmpl $0x0, (%rax)
je 0xfadc4
leaq 0x11d9f3(%rip), %rax    # 0x2187a8
movl (%rax), %edi
decl %edi
leaq 0x11d9ec(%rip), %rax    # 0x2187ac
movl (%rax), %ecx
jmp 0xfae31
leaq 0x2404e1(%rip), %rax    # 0x33b2ac
movl (%rax), %eax
leaq 0x11da3c(%rip), %rcx    # 0x218810
cltd
idivl (%rcx)
movl %eax, %ecx
leaq 0x2404c8(%rip), %rdx    # 0x33b2a8
leaq 0x2404b1(%rip), %rax    # 0x33b298
movl (%rax), %eax
addl (%rdx), %eax
leaq 0x11da22(%rip), %rdi    # 0x218814
cltd
idivl (%rdi)
movl %eax, %edi
leaq 0x11da02(%rip), %rax    # 0x218800
leaq 0x12873f(%rip), %rdx    # 0x223544
imull $0x31a, (%rdx), %edx    # imm = 0x31A
movslq %edx, %rdx
imulq $0x51eb851f, %rdx, %rdx # imm = 0x51EB851F
movq %rdx, %r8
sarq $0x25, %r8
shrq $0x3f, %rdx
addl %r8d, %edx
addl $0x6, %edx
cmpl %edx, (%rax)
jle 0xfae2f
addl $0x6, %ecx
jmp 0xfae31
decl %ecx
movzbl %sil, %edx
movl %ecx, %esi
movq %rbx, %rcx
callq 0xe7d0
leaq 0x27f56a(%rip), %rdi    # 0x37a3b0
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9340
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %eax, %eax
movq %rax, 0x358bcc(%rip)    # 0x453f78
movq %rax, 0x358bbd(%rip)    # 0x453f70
leaq 0x23fefa(%rip), %rcx    # 0x33b2b4
cmpl $0x0, (%rcx)
je 0xfb4f2
leaq 0x211efa(%rip), %rcx    # 0x30d2c4
cmpl $0x0, (%rcx)
je 0xfb4f2
leaq 0x23febe(%rip), %rcx    # 0x33b298
movl (%rcx), %edx
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
leaq 0x11fe54(%rip), %rcx    # 0x21b240
movl (%rcx), %ecx
leaq 0x23feb7(%rip), %rdi    # 0x33b2ac
movl (%rdi), %r8d
leal (%r8,%rsi), %edi
decl %edi
decl %r8d
cmpl %r8d, %ecx
setl %r8b
leal (%rdi,%rsi), %r9d
cmpl %r9d, %ecx
setg %r9b
orb %r8b, %r9b
jne 0xfb4f2
leaq 0x11fe21(%rip), %r8     # 0x21b244
movl (%r8), %r9d
leaq 0x23fe7b(%rip), %r8     # 0x33b2a8
movl (%r8), %r10d
leal (%r10,%rsi), %r8d
decl %r8d
decl %r10d
cmpl %r10d, %r9d
setl %r10b
addl %r8d, %esi
cmpl %esi, %r9d
setg %sil
orb %r10b, %sil
jne 0xfb4f2
subl %edi, %ecx
subl %r9d, %r8d
leaq 0x211b68(%rip), %rax    # 0x30cfc8
movsd (%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xfb47d
jp 0xfb47d
movabsq $0x3f50624dd2f1a9fc, %rsi # imm = 0x3F50624DD2F1A9FC
movq %rsi, (%rax)
xorps %xmm0, %xmm0
cvtsi2sd %r8d, %xmm0
leaq 0x23fe84(%rip), %rsi    # 0x33b310
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
mulsd 0x358ae1(%rip), %xmm0   # 0x453f80
movsd 0xdcb1(%rip), %xmm2     # 0x109158
movsd (%rsi), %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
movsd %xmm3, 0x358ab5(%rip)   # 0x453f70
leaq 0x23fe56(%rip), %rdx    # 0x33b318
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd %xmm1, %xmm0
movsd 0x358ab3(%rip), %xmm1   # 0x453f88
divsd (%rax), %xmm1
mulsd (%rdx), %xmm2
mulsd %xmm0, %xmm1
addsd %xmm1, %xmm2
movsd %xmm2, 0x358a8b(%rip)   # 0x453f78
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11cf6e(%rip), %rax    # 0x2187d8
cmpl $0x0, (%rax)
setne %al
leaq 0x1436e1(%rip), %rcx    # 0x23ef58
cmpl $0x0, (%rcx)
setne %cl
testb %cl, %al
jne 0xfb910
leaq 0x23fa24(%rip), %rax    # 0x33b2b0
cmpb $0x0, (%rax)
je 0xfb910
leaq 0x23fa14(%rip), %rax    # 0x33b2ac
movl (%rax), %eax
leaq 0x11cf6f(%rip), %rcx    # 0x218810
cltd
idivl (%rcx)
leaq 0x11cf55(%rip), %rcx    # 0x218800
leaq 0x127c92(%rip), %rdx    # 0x223544
imull $0x31a, (%rdx), %edx    # imm = 0x31A
movslq %edx, %rdx
imulq $0x51eb851f, %rdx, %rdx # imm = 0x51EB851F
movq %rdx, %rsi
sarq $0x25, %rsi
shrq $0x3f, %rdx
addl %esi, %edx
addl $0x6, %edx
xorl %ebx, %ebx
cmpl %edx, (%rcx)
setle %bl
negl %ebx
orl $0x6, %ebx
addl %eax, %ebx
callq 0xfb39f
movl %eax, %r14d
callq 0xfb4f4
testl %r14d, %r14d
je 0xfb915
movsd 0x1000e(%rip), %xmm1    # 0x10b908
movsd 0x35866e(%rip), %xmm0   # 0x453f70
mulsd %xmm1, %xmm0
mulsd 0x35866a(%rip), %xmm1   # 0x453f78
jmp 0xfb92b
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x23f9f4(%rip), %rax    # 0x33b310
movsd (%rax), %xmm0
leaq 0x23f9f1(%rip), %rax    # 0x33b318
movsd (%rax), %xmm1
leaq 0x23f9ee(%rip), %rax    # 0x33b320
movsd (%rax), %xmm2
leaq 0x23f96b(%rip), %rcx    # 0x33b2a8
leaq 0x23f954(%rip), %rax    # 0x33b298
movl (%rax), %eax
addl (%rcx), %eax
leaq 0x11cec5(%rip), %rcx    # 0x218814
cltd
idivl (%rcx)
leal 0x1(%rax), %edi
movl %ebx, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xb24b9
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb830f(%rip), %rbx     # 0x1b4290
xorl %eax, %eax
leaq 0x23f31a(%rip), %r12    # 0x33b2a4
movss 0x3078e(%rip), %xmm2    # 0x12c720
leaq 0x23f313(%rip), %r9     # 0x33b2ac
leaq 0x23f2f8(%rip), %r15    # 0x33b298
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl (%r12), %xmm1
mulss %xmm0, %xmm1
divss %xmm2, %xmm1
cvttss2si %xmm1, %r14d
cmpl $0x27f, %r14d           # imm = 0x27F
ja 0xfc08a
decl %r14d
xorl %r13d, %r13d
movq %rbx, -0x38(%rbp)
xorps %xmm0, %xmm0
cvtsi2ss %r13d, %xmm0
movl (%r12), %edx
xorps %xmm1, %xmm1
cvtsi2ss %edx, %xmm1
mulss %xmm0, %xmm1
divss %xmm2, %xmm1
cvttss2si %xmm1, %ecx
cmpl $0x27f, %ecx            # imm = 0x27F
ja 0xfc07a
movb (%rbx,%r13), %al
testb %al, %al
je 0xfc07a
movl (%r15), %edi
movl %edi, %esi
shrl $0x1f, %esi
addl %edi, %esi
sarl %esi
movl %edx, %r8d
shrl $0x1f, %r8d
addl %edx, %r8d
sarl %r8d
movl %r14d, %edi
subl %r8d, %edi
addl (%r9), %edi
addl %esi, %edi
js 0xfc07a
subl %r8d, %ecx
addl %esi, %ecx
leaq 0x23f26f(%rip), %rdx    # 0x33b2a8
movl (%rdx), %edx
leal (%rdx,%rcx), %esi
decl %esi
testl %esi, %esi
js 0xfc07a
leaq 0x11c7b5(%rip), %rcx    # 0x218800
cmpl (%rcx), %edi
jge 0xfc07a
leaq 0x11c7ae(%rip), %rcx    # 0x218804
cmpl (%rcx), %esi
jge 0xfc07a
movzbl %al, %edx
movl %r14d, %ebx
movq %r9, %r14
callq 0xe6a0
movq %r14, %r9
movl %ebx, %r14d
movq -0x38(%rbp), %rbx
movss 0x306a6(%rip), %xmm2    # 0x12c720
incq %r13
cmpq $0x280, %r13            # imm = 0x280
jne 0xfbfd8
movq -0x30(%rbp), %rax
incq %rax
addq $0x281, %rbx            # imm = 0x281
cmpq $0x280, %rax            # imm = 0x280
jne 0xfbfa0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfc6db
movslq %eax, %rcx
movsd %xmm0, (%rdi,%rcx,8)
testl %eax, %eax
jle 0xfc6d9
movl %eax, %ecx
incq %rcx
movsd -0x10(%rdi,%rcx,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xfc6d9
movsd %xmm1, -0x8(%rdi,%rcx,8)
movsd %xmm0, -0x10(%rdi,%rcx,8)
decq %rcx
cmpq $0x1, %rcx
jg 0xfc6b8
incl %eax
popq %rbp
retq