LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: get_mayan_date()
void get_mayan_date()
{
long mayan;

   gregorian(0, jd_local);
   mayan = (long) (jdate(g_year,g_month,g_day)-jdate(1618,9,18));
   mayan = adjust_mayan(mayan);

   kin = (int) (mayan % 20L);  mayan /= 20L;
   uinal = (int) (mayan % 18L);  mayan /= 18L;
   tun = (int) (mayan % 20L);  mayan /= 20L;
   katun = (int) (mayan % 20L);  mayan /= 20L;
   baktun = (int) ((mayan % 20L)+12L);  mayan /= 20L;  // Baktun 12 started in 1618, 13 started in 2012
   pictun = (int) (mayan % 20L);  mayan /= 20L;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2253ca(%rip), %rax    # 0x2f7548
movsd (%rax), %xmm0
xorl %edi, %edi
callq 0xbfac2
leaq 0x225514(%rip), %rax    # 0x2f76a4
movl (%rax), %edi
leaq 0x225503(%rip), %rax    # 0x2f769c
movl (%rax), %esi
leaq 0x2254fe(%rip), %rax    # 0x2f76a0
movl (%rax), %edx
callq 0xc2f07
addsd 0x439d7(%rip), %xmm0    # 0x115b88
cvttsd2si %xmm0, %rdi
callq 0xd2115
movq %rax, %rcx
pushq $0x14
popq %rsi
xorl %edx, %edx
divq %rsi
movl %edx, 0x293270(%rip)    # 0x36543c
pushq $0x12
popq %rdi
xorl %edx, %edx
divq %rdi
movl %edx, 0x293266(%rip)    # 0x365440
movl $0x168, %edi            # imm = 0x168
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
xorl %edx, %edx
divq %rsi
movl %edx, 0x293252(%rip)    # 0x365444
movl $0x1c20, %edi           # imm = 0x1C20
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
xorl %edx, %edx
divq %rsi
movl %edx, 0x29323e(%rip)    # 0x365448
movl $0x23280, %edi          # imm = 0x23280
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
xorl %edx, %edx
divq %rsi
addl $0xc, %edx
movl %edx, 0x293227(%rip)    # 0x36544c
movl $0x2bf200, %edi         # imm = 0x2BF200
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
xorl %edx, %edx
divq %rsi
movl %edx, 0x293213(%rip)    # 0x365450
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: sun_position(double)
double sun_position(double jd)
{
double n,x,e,l,dl,v;
int i;
double ecc;

//  ecc = 0.016718;
    ecc = orbit_eccentricity(jd);
    jd -= 2444238.5;

    n = (360.0/SOLAR_YEAR) * jd;
    i = (int) (n / 360.0);
    n = n - 360.0 * (double) i;
    x = n - 3.762863;
    if(x < 0.0) x += 360.0;
    x *= DEG_TO_RAD;
    e = x;

    i = 0;
    do {  // solve Keppler's equation
        dl = e - (ecc*sin(e)) - x;
        e  = e - (dl / (1.0 - (ecc*cos(e))));
        if(++i > 10) break;
    } while (fabs(dl) >= SMALL_FLOAT);

    v = (360.0 / PI) * atan(1.01686011182*tan(e/2));
    l = v + 282.596403;
    i = (int) (l / 360.0);
    l = l - 360.0 * (double) i;
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, -0x10(%rbp)
callq 0xce799
movsd -0x10(%rbp), %xmm3
addsd 0x4370b(%rip), %xmm3    # 0x115b90
mulsd 0x4370b(%rip), %xmm3    # 0x115b98
movsd 0x35d1b(%rip), %xmm1    # 0x1081b0
movapd %xmm3, %xmm2
divsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd 0x4355b(%rip), %xmm2    # 0x115a08
addsd %xmm3, %xmm2
addsd 0x436e7(%rip), %xmm2    # 0x115ba0
addsd %xmm2, %xmm1
xorpd %xmm3, %xmm3
movapd %xmm2, %xmm4
cmpltsd %xmm3, %xmm4
andpd %xmm4, %xmm1
andnpd %xmm2, %xmm4
orpd %xmm1, %xmm4
mulsd 0x234aa(%rip), %xmm4    # 0xf5988
xorps 0x20ccb(%rip), %xmm0    # 0xf31b0
movaps %xmm0, -0x20(%rbp)
pushq $0xb
popq %rbx
movapd %xmm4, -0x30(%rbp)
movapd %xmm4, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x9080
mulsd -0x20(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movapd %xmm0, -0x40(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x9710
movapd -0x40(%rbp), %xmm2
mulsd -0x20(%rbp), %xmm0
addsd 0x20b3c(%rip), %xmm0    # 0xf3070
movapd %xmm2, %xmm1
divsd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
subsd %xmm1, %xmm0
decl %ebx
je 0xd255b
andpd 0x20c3f(%rip), %xmm2    # 0xf3190
ucomisd 0x35d17(%rip), %xmm2    # 0x108270
jae 0xd24f5
mulsd 0x20b05(%rip), %xmm0    # 0xf3068
callq 0x91a0
mulsd 0x43638(%rip), %xmm0    # 0x115ba8
callq 0x92c0
mulsd 0x434ab(%rip), %xmm0    # 0x115a28
addsd 0x4362b(%rip), %xmm0    # 0x115bb0
movapd %xmm0, %xmm1
divsd 0x35c1f(%rip), %xmm1    # 0x1081b0
cvttpd2dq %xmm1, %xmm1
cvtdq2pd %xmm1, %xmm1
mulsd 0x43467(%rip), %xmm1    # 0x115a08
addsd %xmm1, %xmm0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: moon_position(double, double)
double moon_position(double jd, double ls)
{
double ms,l,mm,n,ev,sms,ae,ec;
int i;

    jd -= 2444238.5;

    /* ls = sun_position(jd) */
    ms = 0.985647332099*jd - 3.762863;
    if(ms < 0) ms += 360.0;
    l = 13.176396*jd + 64.975464;
    i = (int) (l / 360.0);
    l = l - (360.0*(double) i);
    if(l < 0) l += 360.0;
    mm = l - 0.1114041*jd - 349.383063;
    i = (int) (mm / 360.0);
    mm -= 360.0 * (double) i;
    n = 151.950429 - 0.0529539*jd;
    i = (int) (n / 360.0);
    n -= 360.0 * (double) i;
    ev = 1.2739 * sin((2*(l-ls)-mm)*DEG_TO_RAD);
    sms = sin(ms*DEG_TO_RAD);
    ae = 0.1858 * sms;
    mm += ev - ae - 0.37*sms;
    ec = 6.2886 * sin(mm*DEG_TO_RAD);
    l += ev + ec - ae + 0.214*sin(2.0*mm*DEG_TO_RAD);
    l= 0.6583 * sin(2*(l-ls)*DEG_TO_RAD)+l;

    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm1, -0x28(%rbp)
addsd 0x435cf(%rip), %xmm0    # 0x115b90
movsd 0x435ef(%rip), %xmm4    # 0x115bb8
mulsd %xmm0, %xmm4
addsd 0x435cb(%rip), %xmm4    # 0x115ba0
movsd 0x35bd3(%rip), %xmm6    # 0x1081b0
movapd %xmm4, %xmm2
addsd %xmm6, %xmm2
xorpd %xmm3, %xmm3
movapd %xmm4, %xmm5
cmpltsd %xmm3, %xmm5
andpd %xmm5, %xmm2
andnpd %xmm4, %xmm5
movapd %xmm5, %xmm7
movsd 0x435ba(%rip), %xmm5    # 0x115bc0
mulsd %xmm0, %xmm5
addsd 0x435b6(%rip), %xmm5    # 0x115bc8
movapd %xmm5, %xmm4
divsd %xmm6, %xmm4
cvttpd2dq %xmm4, %xmm4
orpd %xmm2, %xmm7
movapd %xmm7, -0x20(%rbp)
cvtdq2pd %xmm4, %xmm2
movsd 0x433d5(%rip), %xmm4    # 0x115a08
mulsd %xmm4, %xmm2
addsd %xmm5, %xmm2
movapd %xmm2, %xmm5
addsd %xmm6, %xmm5
movapd %xmm2, %xmm7
cmpltsd %xmm3, %xmm7
andpd %xmm7, %xmm5
andnpd %xmm2, %xmm7
orpd %xmm5, %xmm7
mulsd 0x43570(%rip), %xmm0    # 0x115bd0
addsd %xmm7, %xmm0
movapd %xmm7, -0x40(%rbp)
addsd 0x43567(%rip), %xmm0    # 0x115bd8
movapd %xmm0, %xmm2
movapd %xmm0, %xmm3
divsd %xmm6, %xmm2
cvttpd2dq %xmm2, %xmm0
cvtdq2pd %xmm0, %xmm0
mulsd %xmm4, %xmm0
addsd %xmm0, %xmm3
movsd %xmm3, -0x10(%rbp)
movapd %xmm7, %xmm0
subsd %xmm1, %xmm0
addsd %xmm0, %xmm0
subsd %xmm3, %xmm0
mulsd 0x232de(%rip), %xmm0    # 0xf5988
callq 0x9080
mulsd 0x43529(%rip), %xmm0    # 0x115be0
movsd %xmm0, -0x8(%rbp)
movapd -0x20(%rbp), %xmm0
mulsd 0x232bf(%rip), %xmm0    # 0xf5988
callq 0x9080
movsd 0x43512(%rip), %xmm2    # 0x115be8
mulsd %xmm0, %xmm2
movsd %xmm2, -0x20(%rbp)
movsd -0x8(%rbp), %xmm1
subsd %xmm2, %xmm1
mulsd 0x43500(%rip), %xmm0    # 0x115bf0
addsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
mulsd 0x23282(%rip), %xmm0    # 0xf5988
callq 0x9080
mulsd 0x434e5(%rip), %xmm0    # 0x115bf8
addsd -0x8(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
addsd %xmm0, %xmm0
mulsd 0x23255(%rip), %xmm0    # 0xf5988
callq 0x9080
mulsd 0x434c0(%rip), %xmm0    # 0x115c00
addsd -0x8(%rbp), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
subsd -0x28(%rbp), %xmm0
addsd %xmm0, %xmm0
mulsd 0x23228(%rip), %xmm0    # 0xf5988
callq 0x9080
mulsd 0x4349b(%rip), %xmm0    # 0x115c08
addsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: xmoon_info(double)
double xmoon_info(double jd)
{
double jd_new, jd_next;

   ++sp_count;

   jd_new = new_moon(jd);
   jd_next = new_moon(jd+31.0);
   MoonSynod = (jd_next-jd_new);
   if(MoonSynod == 0.0) MoonSynod = synmonth;

   MoonAge = ((jd - jd_new) / MoonSynod) * 360.0; // in degrees
   MoonAge = fmod(MoonAge, 360.0);
   MoonPhase = (1.0 - cos(MoonAge*PI/180.0)) / 2.0;

   MoonAge = MoonSynod * (MoonAge / 360.0);  // in days

   lunation = (long) floor(((jd_new + 7.0) - lunatbase) / MoonSynod) + 1;
//sprintf(debug_text, "jd:%f  jd_new:%f  next:%f  synod:%f  age:%f  lunat:%d  phase:%f", 
//jd,jd_new, jd_next, MoonSynod, MoonAge, lunation, MoonPhase);
   return MoonPhase;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x18(%rbp)
incl 0x291e26(%rip)          # 0x3645b4
callq 0xd289a
movsd %xmm0, -0x20(%rbp)
movsd 0x43470(%rip), %xmm0    # 0x115c10
addsd -0x18(%rbp), %xmm0
callq 0xd289a
movsd -0x20(%rbp), %xmm3
subsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movsd 0x43454(%rip), %xmm2    # 0x115c18
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm1, %xmm2
leaq 0x225071(%rip), %rbx    # 0x2f7848
movlpd %xmm2, (%rbx)
movsd -0x18(%rbp), %xmm0
subsd %xmm3, %xmm0
divsd %xmm2, %xmm0
movsd 0x359c0(%rip), %xmm1    # 0x1081b0
mulsd %xmm1, %xmm0
callq 0x94d0
leaq 0x225038(%rip), %r14    # 0x2f7838
movsd %xmm0, (%r14)
mulsd 0x23093(%rip), %xmm0    # 0xf58a0
divsd 0x23093(%rip), %xmm0    # 0xf58a8
callq 0x9710
movsd 0x2084e(%rip), %xmm1    # 0xf3070
subsd %xmm0, %xmm1
mulsd 0x2083a(%rip), %xmm1    # 0xf3068
movsd %xmm1, -0x18(%rbp)
leaq 0x225006(%rip), %rax    # 0x2f7840
movsd %xmm1, (%rax)
movsd (%rbx), %xmm0
movsd (%r14), %xmm1
divsd 0x35961(%rip), %xmm1    # 0x1081b0
mulsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm2
addsd 0x23120(%rip), %xmm2    # 0xf5980
movsd %xmm1, (%r14)
addsd 0x433b3(%rip), %xmm2    # 0x115c20
divsd %xmm0, %xmm2
movapd %xmm2, %xmm0
callq 0x9680
cvttsd2si %xmm0, %rax
incq %rax
leaq 0x224fef(%rip), %rcx    # 0x2f7878
movq %rax, (%rcx)
movsd -0x18(%rbp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: FNrange(double)
double FNrange(double x)
{
double a, b;

    b = x / (PI+PI);
    a = (PI+PI) * (b - FNipart(b));
    if(a < 0) a = (PI+PI) + a;
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd 0x350d0(%rip), %xmm1    # 0x1081f8
divsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm0
setae %al
movapd 0x2004f(%rip), %xmm3    # 0xf3190
andpd %xmm0, %xmm3
cvttpd2dq %xmm3, %xmm3
cvtdq2pd %xmm3, %xmm3
leaq 0x23e1c(%rip), %rcx     # 0xf6f70
mulsd (%rcx,%rax,8), %xmm3
addsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm3, %xmm1
movapd %xmm3, %xmm0
cmpltsd %xmm2, %xmm0
andpd %xmm0, %xmm1
andnpd %xmm3, %xmm0
orpd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: FNatn2(double, double)
double FNatn2(double y, double x)
{
double a;

    a = atan(y/x);
    if(x < 0.0) a = a + PI;
    if((y < 0.0) && (x > 0.0)) a = a + PI + PI;
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movapd %xmm1, -0x10(%rbp)
movapd %xmm0, -0x20(%rbp)
divsd %xmm1, %xmm0
callq 0x92c0
movsd 0x22701(%rip), %xmm2    # 0xf58a0
xorpd %xmm3, %xmm3
xorpd %xmm4, %xmm4
movapd -0x10(%rbp), %xmm5
cmpltsd %xmm5, %xmm4
cmpltsd %xmm3, %xmm5
movapd %xmm5, %xmm1
andnpd %xmm0, %xmm1
addsd %xmm2, %xmm0
andpd %xmm5, %xmm0
orpd %xmm1, %xmm0
movapd %xmm0, %xmm1
addsd %xmm2, %xmm1
addsd %xmm2, %xmm1
andpd %xmm4, %xmm1
andnpd %xmm0, %xmm4
orpd %xmm4, %xmm1
movapd -0x20(%rbp), %xmm2
cmpltsd %xmm3, %xmm2
andpd %xmm2, %xmm1
andnpd %xmm0, %xmm2
orpd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: earth_radius(double, double)
double earth_radius(double lat, double alt)
{
double r1,r2,r3,r4;
double r;

   // return earth radius in km at latitude, alt (in meters)

   r1 = (EQU_RADIUS*EQU_RADIUS) * cos(lat);
   r2 = (POLE_RADIUS*POLE_RADIUS) * sin(lat);
   r3 = EQU_RADIUS * cos(lat);
   r4 = POLE_RADIUS * sin(lat);

   r = (r3*r3) + (r4*r4);
   if(r == 0.0) r = dEarthMeanRadius;
   else {
      r = ((r1*r1) + (r2*r2)) / r;
      if(r > 0.0) r = sqrt(r);
      else r = dEarthMeanRadius;
   }

   return r + (alt / 1000.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x8(%rbp)
callq 0x9710
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x9080
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x9710
mulsd 0x42136(%rip), %xmm0    # 0x115dd8
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x9080
movsd -0x20(%rbp), %xmm4
mulsd 0x42122(%rip), %xmm0    # 0x115de0
mulsd %xmm0, %xmm0
mulsd %xmm4, %xmm4
addsd %xmm0, %xmm4
movsd 0x42116(%rip), %xmm2    # 0x115de8
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm4
jne 0xd3cde
jnp 0xd3d12
movsd -0x10(%rbp), %xmm3
mulsd 0x42105(%rip), %xmm3    # 0x115df0
movsd -0x18(%rbp), %xmm0
mulsd 0x42100(%rip), %xmm0    # 0x115df8
mulsd %xmm3, %xmm3
mulsd %xmm0, %xmm0
addsd %xmm3, %xmm0
divsd %xmm4, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd3d12
sqrtsd %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
divsd 0x1f319(%rip), %xmm0    # 0xf3038
addsd %xmm2, %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: sun_peak(double, int)
double sun_peak(double jd, int do_moon)
{
double peak;
#define PEAK_THRESH1 (5.0*PI/180.0)  // prevents search instability near the equator
#define PEAK_THRESH2 (80.0*PI/180.0) // longitude/azimuth gets ambiguous near the poles 

   // used to find the "peak" solar position.  Near the equator and poles this is
   // the actual solar elevation angle.  Otherwise it is where the sun crosses
   // crosses 180.0 degrees azimuth (northern hemisphere) or 0 degrees (southern)

   peak = sun_posn(jd, do_moon);

   // looking for peak in sun elevation
   if(0 && do_moon) return peak;
   else if((lat > (0.0-PEAK_THRESH1)) && (lat < PEAK_THRESH1)) return peak;
   else if(lat > PEAK_THRESH2) return peak;
   else if(lat < (0.0-PEAK_THRESH2)) return peak;
// else return peak;  // always use sun elevation

   // look for sun azimuth nearest 180.0 (or 0.0 below the equator)
   peak = sun_az;
   if(lat < 0.0) peak = fmod(peak+180.0, 360.0);
   if(peak > 180.0) return 360.0-peak;
   else return peak;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0xd3da7
leaq 0x223297(%rip), %rax    # 0x2f6fd0
movsd (%rax), %xmm1
movapd 0x1f44b(%rip), %xmm2    # 0xf3190
andpd %xmm1, %xmm2
movsd 0x420af(%rip), %xmm3    # 0x115e00
ucomisd %xmm2, %xmm3
ja 0xd3da5
ucomisd 0x420a9(%rip), %xmm2    # 0x115e08
ja 0xd3da5
leaq 0x223a68(%rip), %rax    # 0x2f77d0
movsd (%rax), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
jbe 0xd3d8b
addsd 0x21b2a(%rip), %xmm0    # 0xf58a8
movsd 0x3442a(%rip), %xmm1    # 0x1081b0
callq 0x94d0
ucomisd 0x21b15(%rip), %xmm0    # 0xf58a8
jbe 0xd3da5
movsd 0x34413(%rip), %xmm1    # 0x1081b0
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: interp_solar_noon(double, double, int)
double interp_solar_noon(double start, double end, int do_moon)
{
double start_el, mid_el, end_el;
double mid;
double pct, delta;

// return (start+end) / 2.0;

   if((lat > (0.0-PEAK_THRESH1)) && (lat < PEAK_THRESH1)) return (start+end)/2.0;
   else if(lat > PEAK_THRESH2) return (start+end)/2.0; 
   else if(lat < (0.0-PEAK_THRESH2)) return (start+end)/2.0; 

   start_el = sun_peak(start, do_moon);
   end_el = 360.0 - sun_peak(end, do_moon);
   delta = end_el - start_el;
   if(delta == 0.0) return (start+end) / 2.0;

   pct = (180.0 - start_el) / delta;
   mid = start + (end-start) * pct;


if(0 && debug_file) {
   mid_el = sun_peak(mid, do_moon);
   fprintf(debug_file, "\ninterp noon: start:%f mid:%f end:%f\n", start,mid,end);
   fprintf(debug_file, "start_el:%f mid_el:%f end_el:%f  pct:%f\n", start_el,mid_el,end_el, pct);
   gregorian(0, mid+time_zone());
   fprintf(debug_file, "noon (utc): %02d:%02d:%02d %f  %04d/%02d/%02d  tz:%f\n\n", g_hours,g_minutes,g_seconds,g_frac, g_year,g_month,g_day, time_zone());
}
   return mid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq 0x222b01(%rip), %rax    # 0x2f6fd0
movsd (%rax), %xmm3
movapd 0x1ecb5(%rip), %xmm4    # 0xf3190
andpd %xmm3, %xmm4
movsd 0x41919(%rip), %xmm2    # 0x115e00
ucomisd %xmm4, %xmm2
ja 0xd4505
ucomisd 0x41913(%rip), %xmm3    # 0x115e08
ja 0xd4505
movsd 0x342d1(%rip), %xmm2    # 0x1087d0
ucomisd %xmm3, %xmm2
jbe 0xd4518
addsd %xmm1, %xmm0
mulsd 0x1eb57(%rip), %xmm0    # 0xf3068
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movl %edi, %ebx
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
callq 0xd3d29
movsd %xmm0, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movl %ebx, %edi
callq 0xd3d29
movsd -0x20(%rbp), %xmm3
movsd 0x33c69(%rip), %xmm1    # 0x1081b0
subsd %xmm0, %xmm1
subsd %xmm3, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0xd4567
jp 0xd4567
movsd -0x18(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
jmp 0xd4509
movsd 0x21339(%rip), %xmm2    # 0xf58a8
subsd %xmm3, %xmm2
divsd %xmm1, %xmm2
movsd -0x18(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
subsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
jmp 0xd4511
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: interp_sun_posn(double, double, double, int)
double interp_sun_posn(double start, double end, double zenith, int do_moon)
{
double start_el, mid_el, end_el;
double mid;
double pct, delta;

//   return (start+end) / 2.0;

   start_el = sun_posn(start, do_moon);
   end_el = sun_posn(end, do_moon);
   delta = (end_el - start_el);
   if(delta == 0.0) return ((start+end) / 2.0);

   pct = (zenith - start_el) / delta;
   mid = start + (end-start) * pct;

if(0 && debug_file) {
   mid_el = sun_posn(mid, do_moon);
   fprintf(debug_file, "interp: start:%f mid:%f end:%f\n", start,mid,end);
   fprintf(debug_file, "start_el:%f mid_el:%f end_el:%f  pct:%f\n", start_el,mid_el,end_el, pct);
   gregorian(0, mid+time_zone());
   fprintf(debug_file, "time (utc): %02d:%02d:%02d %f  %04d/%02d/%02d  tz:%f\n\n", g_hours,g_minutes,g_seconds,g_frac, g_year,g_month,g_day, time_zone());
}
   return mid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
movsd %xmm2, -0x20(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
callq 0xd3da7
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movl %ebx, %edi
callq 0xd3da7
movsd -0x28(%rbp), %xmm3
subsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xd482d
jp 0xd482d
movsd -0x18(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
mulsd 0x1e83d(%rip), %xmm0    # 0xf3068
jmp 0xd4850
movsd -0x20(%rbp), %xmm2
subsd %xmm3, %xmm2
divsd %xmm0, %xmm2
movsd -0x18(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
subsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: earth_sun_dist(double)
double earth_sun_dist(double jd)
{
double d;
double e;
double theta;

   // in km

   e = orbit_eccentricity(jd);
   theta = ((PI*2.0)/365.2563630) * time_since_perihelion(jd);

   d = (1.0-e*e) / (1.0 + (e*cos(theta)));

   d = d*dAstronomicalUnit;
   return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0xce799
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0xce727
mulsd 0x40b72(%rip), %xmm0    # 0x115fa0
movsd -0x10(%rbp), %xmm1
mulsd %xmm1, %xmm1
movsd 0x1dc31(%rip), %xmm2    # 0xf3070
subsd %xmm1, %xmm2
movsd %xmm2, -0x8(%rbp)
callq 0x9710
mulsd -0x10(%rbp), %xmm0
addsd 0x1dc16(%rip), %xmm0    # 0xf3070
movsd -0x8(%rbp), %xmm1
divsd %xmm0, %xmm1
mulsd 0x40b3d(%rip), %xmm1    # 0x115fa8
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: sun_refraction(double)
double sun_refraction(double el)
{
double r;
double htan;
double r2;

   // calculation sun refraction angle (in degrees) given its 
   // elevation "el" in degrees

   r = r2 = (-1.0);
   if(0) {
      htan = el + 5.11;
      if(htan == 0.0) return (-1.0);
      htan = el + (10.3 / htan);
      htan = tan(htan*PI/180.0);
      if(htan == 0.0) return (-1.0);
      r2 = 1.02 / htan; // refraction in minutes
      r2 /= 60.0;       // refraction in degrees
      r = r2;
   }
   else {
      if(el >= 85.0) r = 0.0;
      else if(el >= 5.0) {
         htan = tan(el*PI/180.0);
         if(htan == 0.0) return (-1.0);
         r = (58.1 / htan) - (0.07 / (htan*htan*htan)) + (0.000086 / (htan*htan*htan*htan*htan));
      }
      else if(el >= (-0.575)) {
         r = 1735.0;
         r -= (518.2*el);
         r += (103.4*el*el);
         r -= (12.79*el*el*el);
         r += (0.711*el*el*el*el);
      }
      else {
         htan = tan(el*PI/180.0);
         if(htan == 0.0) return (-1.0);
         r = (-20.774/htan);
      }
      r /= 3600.0;
   }
   return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorpd %xmm1, %xmm1
ucomisd 0x40b2b(%rip), %xmm0    # 0x115fb0
jae 0xd5599
ucomisd 0x1dcad(%rip), %xmm0    # 0xf3140
jae 0xd54d1
ucomisd 0x40b33(%rip), %xmm0    # 0x115fd0
jae 0xd54ff
mulsd 0x203f9(%rip), %xmm0    # 0xf58a0
divsd 0x203f9(%rip), %xmm0    # 0xf58a8
callq 0x91a0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xd54c0
jnp 0xd54f2
movsd 0x40b38(%rip), %xmm1    # 0x116000
divsd %xmm0, %xmm1
jmp 0xd5599
mulsd 0x203c7(%rip), %xmm0    # 0xf58a0
divsd 0x203c7(%rip), %xmm0    # 0xf58a8
callq 0x91a0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xd5559
jp 0xd5559
movsd 0x1dbfe(%rip), %xmm1    # 0xf30f8
jmp 0xd55a1
movsd 0x40ad1(%rip), %xmm1    # 0x115fd8
mulsd %xmm0, %xmm1
addsd 0x40acd(%rip), %xmm1    # 0x115fe0
movsd 0x40acd(%rip), %xmm2    # 0x115fe8
mulsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd 0x40ac1(%rip), %xmm3    # 0x115ff0
mulsd %xmm0, %xmm3
mulsd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movsd 0x40ab1(%rip), %xmm1    # 0x115ff8
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
jmp 0xd5595
movsd 0x40a57(%rip), %xmm1    # 0x115fb8
divsd %xmm0, %xmm1
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movsd 0x40a47(%rip), %xmm3    # 0x115fc0
divsd %xmm2, %xmm3
addsd %xmm1, %xmm3
mulsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movsd 0x40a37(%rip), %xmm1    # 0x115fc8
divsd %xmm2, %xmm1
addsd %xmm3, %xmm1
divsd 0x1da6f(%rip), %xmm1    # 0xf3010
movapd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: sun_diam(double)
double sun_diam(double jd)
{
double diam;

   // return apparent topocentric sun disk diameter in degrees.
   // earth radius correction only valid for daylight hours

   diam = 2.0 * asin(SUN_DIAM / ((earth_sun_dist(jd)-earth_radius(lat,alt)) * 2.0)) * 180.0 / PI;
   return diam;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xd5405
movsd %xmm0, -0x8(%rbp)
leaq 0x221a10(%rip), %rax    # 0x2f6fd0
movsd (%rax), %xmm0
leaq 0x221a15(%rip), %rax    # 0x2f6fe0
movsd (%rax), %xmm1
callq 0xd3c65
movsd -0x8(%rbp), %xmm1
subsd %xmm0, %xmm1
addsd %xmm1, %xmm1
movsd 0x40a1f(%rip), %xmm0    # 0x116008
divsd %xmm1, %xmm0
callq 0x9660
addsd %xmm0, %xmm0
mulsd 0x202aa(%rip), %xmm0    # 0xf58a8
divsd 0x2029a(%rip), %xmm0    # 0xf58a0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: lookup_new_moon(double)
int lookup_new_moon(double jd)
{
int i, j;
int i0;

   gregorian(0, jd);
   if((g_year >= 2016) && (g_year < 2100)) {  // look up accurate new moon info in table
      i0 = (g_year-2016) * 12;  // approx place to start looking in the table
      j = sizeof(new_moon_table) / sizeof(new_moon_table[0]);
      for(i=i0; i<j; i++) {
         if(jd <= new_moon_table[i]) {
            return i-1;
         }
      }
   }
   return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
movsd %xmm0, -0x8(%rbp)
callq 0xbfac2
leaq 0x222017(%rip), %rax    # 0x2f76a4
movl (%rax), %ecx
leal -0x7e0(%rcx), %edx
pushq $-0x1
popq %rax
cmpl $0x53, %edx
ja 0xd56e2
imull $0xc, %ecx, %ecx
leal -0x5e80(%rcx), %edx
movl $0x41b, %esi            # imm = 0x41B
subq %rdx, %rsi
shlq $0x3, %rdx
xorl %edi, %edi
leaq 0x822b5(%rip), %r8      # 0x157970
movsd -0x8(%rbp), %xmm1
cmpq %rdi, %rsi
je 0xd56e2
leaq (%rdx,%rdi,8), %r9
movsd (%r8,%r9), %xmm0
ucomisd %xmm1, %xmm0
jae 0xd56da
incq %rdi
jmp 0xd56c0
leal (%rcx,%rdi), %eax
addl $0xffffa17f, %eax       # imm = 0xFFFFA17F
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: moon_synod(double)
double moon_synod(double jd)
{
int i;
double d1,d2,d3;
double delta;
double pct,mid;
double synod;

   // return moon synod (in days) for the month jd lies in
   // the value is linearly interpolated between the two adjacent synods.

   i = lookup_new_moon(jd);
   if(i < 0) { // jd is outside of the table range, calculate the synod
      calc_synod:
      synod = (jd - JD2000) / 36525.0;
      synod = 29.5305888531 + 0.00000021621*synod - 3.64E-10*synod*synod;  // average length of synodic month
      return synod;
   }

   d3 = new_moon_table[i+2];
   d2 = new_moon_table[i+1];
   d1 = new_moon_table[i+0];

   d1 = d2 - d1;  // this months synod
   d2 = d3 - d2;  // next months synod

   delta = (d2 - d1);
   if(delta == 0.0) goto calc_synod;
   if(d1 == 0.0) goto calc_synod;

   pct = (jd - new_moon_table[i]) / d1;
   mid = d1 + (delta * pct);

// sprintf(debug_text2, "d1:%f d2:%f pct:%f  delta:%f  mid:%f", d1,d2, pct, delta, mid);
   return mid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0xd5672
testl %eax, %eax
js 0xd574f
leaq 0x8226b(%rip), %rcx     # 0x157970
movl %eax, %eax
movsd (%rcx,%rax,8), %xmm2
movsd 0x8(%rcx,%rax,8), %xmm3
movapd %xmm3, %xmm1
subsd %xmm2, %xmm1
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm1
jne 0xd5726
jnp 0xd574f
movsd 0x10(%rcx,%rax,8), %xmm0
subsd %xmm3, %xmm0
subsd %xmm1, %xmm0
ucomisd %xmm4, %xmm0
jne 0xd573c
jnp 0xd574f
movsd -0x8(%rbp), %xmm3
subsd %xmm2, %xmm3
divsd %xmm1, %xmm3
mulsd %xmm3, %xmm0
jmp 0xd5788
movsd -0x8(%rbp), %xmm2
addsd 0x40014(%rip), %xmm2    # 0x115770
divsd 0x40014(%rip), %xmm2    # 0x115778
movsd 0x408ac(%rip), %xmm1    # 0x116018
mulsd %xmm2, %xmm1
addsd 0x408a8(%rip), %xmm1    # 0x116020
movsd 0x408a8(%rip), %xmm0    # 0x116028
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: greatcircle(double, double, double, double)
double greatcircle(double lat1,double long1, double lat2,double long2)
{
double dg;
double l1r, l2r;

   l1r = lat1;
   l2r = lat2;
   dg = earth_radius(lat,alt) * acos(
           (cos(l1r) * cos(l2r) * cos(long2-long1))
           + (sin(l1r) * sin(l2r)));
   if(debug_file && show_debug_info) {
       fprintf(debug_file,
               "greatcircle lat1 %.9f long1 %.9f lat2 %.9f long2 %.9f dist %.9f\n",
               lat1, long1, lat2, long2, dg);
       fflush(debug_file);
   }

   dg = check_double(dg);  // NAN check
   return dg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movsd %xmm3, -0x30(%rbp)
movsd %xmm2, -0x10(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x20(%rbp)
leaq 0x2215bd(%rip), %rax    # 0x2f6fd0
movsd (%rax), %xmm0
leaq 0x2215c2(%rip), %rax    # 0x2f6fe0
movsd (%rax), %xmm1
callq 0xd3c65
movsd %xmm0, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x9710
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x9710
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
callq 0x9710
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x9080
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x9080
mulsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
mulsd -0x18(%rbp), %xmm1
addsd %xmm1, %xmm0
callq 0x9340
movapd %xmm0, %xmm4
mulsd -0x48(%rbp), %xmm4
leaq 0x1528ec(%rip), %rbx    # 0x228390
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd5af1
leaq 0x12ce11(%rip), %rax    # 0x2028c4
cmpb $0x0, (%rax)
je 0xd5af1
leaq 0x490a6(%rip), %rsi     # 0x11eb65
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x10(%rbp), %xmm2
movsd -0x30(%rbp), %xmm3
movsd %xmm4, -0x10(%rbp)
movsd -0x10(%rbp), %xmm4
movb $0x5, %al
callq 0x9560
movq (%rbx), %rdi
callq 0x9420
movsd -0x10(%rbp), %xmm4
movapd %xmm4, %xmm0
addq $0x48, %rsp
popq %rbx
popq %rbp
jmp 0x51e2a
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: az_angle(double, double, double, double)
double az_angle(double lat1,double lon1, double lat2,double lon2)
{
double x,y;
double az;

   y = sin(lon2-lon1) * cos(lat2);
   x = cos(lat1)*sin(lat) - sin(lat1)*cos(lat2)*cos(lon2-lon1);
   az = atan2(y, x) * 180.0/PI;
   az = fmod(az + 360.0, 360.0);
   return az;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm2, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movapd %xmm3, %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x9080
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x9710
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x9710
movsd %xmm0, -0x28(%rbp)
leaq 0x22147d(%rip), %rax    # 0x2f6fd0
movsd (%rax), %xmm0
callq 0x9080
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x9080
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x9710
movsd %xmm0, -0x10(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x9710
movsd -0x10(%rbp), %xmm1
mulsd -0x8(%rbp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
mulsd -0x28(%rbp), %xmm1
subsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
callq 0x9050
mulsd 0x1fced(%rip), %xmm0    # 0xf58a8
divsd 0x1fcdd(%rip), %xmm0    # 0xf58a0
movsd 0x325e5(%rip), %xmm1    # 0x1081b0
addsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
jmp 0x94d0
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: waveangle(double, double, int)
double waveangle(double dg, double h, int n)
{
double theta;
double delta;

   theta = dg / (earth_radius(lat,alt) * (double)(2 * n));
   delta = atan((h / (earth_radius(lat,alt) * sin(theta))) + tan(theta/2)) - theta;
   if(0 && debug_file) {
       fprintf(debug_file, "waveangle dist %g height %g hops %d angle %g\n",
              dg, h, n, delta / RADPERDEG);
       fflush(debug_file);
   }
   return delta;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x20(%rbp)
leaq 0x2213d7(%rip), %r14    # 0x2f6fd0
movsd (%r14), %xmm0
leaq 0x2213db(%rip), %r15    # 0x2f6fe0
movsd (%r15), %xmm1
callq 0xd3c65
addl %ebx, %ebx
cvtsi2sd %ebx, %xmm1
mulsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd (%r14), %xmm0
movsd (%r15), %xmm1
callq 0xd3c65
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x9080
mulsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
movsd 0x1d408(%rip), %xmm0    # 0xf3068
mulsd -0x20(%rbp), %xmm0
callq 0x91a0
addsd -0x28(%rbp), %xmm0
callq 0x92c0
subsd -0x20(%rbp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: geoxyz_(double*, double*, double*, double*, double*, double*)
int geoxyz_(double *gla, double *glo, double *eht, double *x, double *y, double *z)
{
    /* Local variables */
    static double w, w2, en, cla, sla;

    /* convert geodetic lat, long, ellip ht. to x,y,z */
    sla = sin(*gla);
    cla = cos(*gla);
    w2 = 1. - eccSquared * sla * sla;
    w = sqrt(w2);
    en = WGS84_A / w;
    *x = (en + *eht) * cla * cos(*glo);
    *y = (en + *eht) * cla * sin(*glo);
    *z = (en * (1. - eccSquared) + *eht) * sla;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x38(%rbp)
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movsd (%rdi), %xmm0
callq 0x9080
movsd %xmm0, 0x28ee0c(%rip)   # 0x365810
movsd (%rbx), %xmm0
callq 0x9710
movapd %xmm0, %xmm1
movsd 0x28edf7(%rip), %xmm2   # 0x365810
movsd 0x3179f(%rip), %xmm0    # 0x1081c0
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd 0x1c63f(%rip), %xmm0    # 0xf3070
movsd %xmm1, 0x28edcf(%rip)   # 0x365808
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xd6a49
sqrtsd %xmm0, %xmm0
jmp 0xd6a4e
callq 0x9260
movsd 0x31772(%rip), %xmm1    # 0x1081c8
divsd %xmm0, %xmm1
movsd %xmm1, 0x28ed9e(%rip)   # 0x365800
addsd (%r14), %xmm1
mulsd 0x28ed99(%rip), %xmm1   # 0x365808
movsd %xmm1, -0x30(%rbp)
movsd (%r12), %xmm0
callq 0x9710
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, (%r13)
movsd 0x28ed6e(%rip), %xmm0   # 0x365800
addsd (%r14), %xmm0
mulsd 0x28ed69(%rip), %xmm0   # 0x365808
movsd %xmm0, -0x30(%rbp)
movsd (%r12), %xmm0
callq 0x9080
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, (%r15)
movsd 0x28ed3f(%rip), %xmm0   # 0x365800
mulsd 0x31707(%rip), %xmm0    # 0x1081d0
addsd (%r14), %xmm0
mulsd 0x28ed3a(%rip), %xmm0   # 0x365810
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: rge_(double*, double*, double*, double*, double*, double*, double*, double*)
int rge_(double *gla, double *glo, double *u, 
        double *v, double *w, double *x, double *y, double *z)
{
    /* Local variables */
    static double cb, cl, sb, sl;

    /* given a rectangular cartesian system (x,y,z) */
    /* compute a geodetic h cartesian sys   (u,v,w) */
    sb = sin(*gla);
    cb = cos(*gla);
    sl = sin(*glo);
    cl = cos(*glo);
    *u = -sb * cl * *x - sb * sl * *y + cb * *z;
    *v = -sl * *x + cl * *y;
    *w = cb * cl * *x + cb * sl * *y + sb * *z;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, -0x30(%rbp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movsd (%rdi), %xmm0
callq 0x9080
movsd %xmm0, 0x28da12(%rip)   # 0x365820
movsd (%rbx), %xmm0
callq 0x9710
movsd %xmm0, 0x28d9f9(%rip)   # 0x365818
movsd (%r13), %xmm0
callq 0x9080
movsd %xmm0, 0x28d9f6(%rip)   # 0x365828
movsd (%r13), %xmm0
callq 0x9710
movsd 0x28d9db(%rip), %xmm1   # 0x365820
movapd 0x1b363(%rip), %xmm3    # 0xf31b0
xorpd %xmm1, %xmm3
mulsd %xmm0, %xmm3
movsd 0x28d9cb(%rip), %xmm2   # 0x365828
movapd %xmm2, %xmm4
mulsd %xmm1, %xmm4
movq 0x10(%rbp), %rcx
mulsd (%rcx), %xmm4
mulsd (%r14), %xmm3
subsd %xmm4, %xmm3
movsd 0x28d99a(%rip), %xmm4   # 0x365818
movq 0x18(%rbp), %rax
movsd (%rax), %xmm5
mulsd %xmm4, %xmm5
addsd %xmm3, %xmm5
movsd %xmm5, (%r12)
movsd (%rcx), %xmm3
mulsd %xmm0, %xmm3
movsd (%r14), %xmm5
mulsd %xmm2, %xmm5
subsd %xmm5, %xmm3
movsd %xmm3, (%r15)
mulsd %xmm4, %xmm0
mulsd %xmm4, %xmm2
mulsd (%rcx), %xmm2
mulsd (%r14), %xmm0
mulsd (%rax), %xmm1
addsd %xmm2, %xmm0
addsd %xmm0, %xmm1
movq -0x30(%rbp), %rax
movsd %xmm1, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: sprod_(double*, double*, double*, double*, double*)
int sprod_(double *x, double *y, double *scal, double *r1, double *r2)
{

   if(x == 0) return (-1); 
   if(y == 0) return (-1); 
   if(scal == 0) return (-1); 
   if(r1 == 0) return (-1); 
   if(r2 == 0) return (-1); 

/*  computation of the scalar-product of two vectors and their norms */

/*  input:   x(i),i=1,2,3  -- components of vector x */
/*           y(i),i=1,2,3  -- components of vector y */
/*  output:  scal          -- scalar product of x and y */
/*           r1,r2         -- lengths of the two vectors x and y */

    /* Function Body */
    *r1 = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
    *r2 = sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
    *scal = x[0] * y[0] + x[1] * y[1] + x[2] * y[2];
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %r9b
orb %al, %r9b
testq %rdx, %rdx
sete %al
testq %rcx, %rcx
sete %r10b
orb %al, %r10b
orb %r9b, %r10b
testq %r8, %r8
sete %al
orb %r10b, %al
je 0xd7f3e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xd7fbd
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rdi), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
movsd (%rsi), %xmm0
movsd 0x8(%rsi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd 0x10(%rsi), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
sqrtsd %xmm1, %xmm0
movsd %xmm0, (%r8)
movsd (%rdi), %xmm0
movsd 0x8(%rdi), %xmm1
mulsd 0x8(%rsi), %xmm1
mulsd (%rsi), %xmm0
movsd 0x10(%rdi), %xmm2
mulsd 0x10(%rsi), %xmm2
addsd %xmm1, %xmm0
addsd %xmm0, %xmm2
movsd %xmm2, (%rdx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: rot1_(double*, double*, double*, double*, double*, double*, double*)
int rot1_(double *theta, double *x, double *y, 
        double *z, double *u, double *v, double *w)
{
    /* Local variables */
    static double c, s;

    /* rotate coordinate axes about 1 axis by angle of theta radians */
    /* x,y,z transformed into u,v,w */
    s = sin(*theta);
    c = cos(*theta);
    *u = *x;
    *v = c * *y + s * *z;
    *w = c * *z - s * *y;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
movsd (%rdi), %xmm0
callq 0x9080
movsd %xmm0, 0x28c0bb(%rip)   # 0x365830
movsd (%r14), %xmm0
callq 0x9710
movsd (%r13), %xmm1
movsd %xmm1, (%r12)
movsd 0x28c09d(%rip), %xmm1   # 0x365830
movsd (%rbx), %xmm2
mulsd %xmm1, %xmm2
movsd (%r15), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movq -0x30(%rbp), %rax
movsd %xmm3, (%rax)
mulsd (%r15), %xmm1
mulsd (%rbx), %xmm0
subsd %xmm1, %xmm0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: getghar_(int*, double*, double*)
int getghar_(int *mjd, double *fmjd, double *ghar)
{
    static double ghad, d;
    static int i;
    static double fmjdutc, tsecgps, tsecutc;

    if(mjd == 0) return (-1); 
    if(fmjd == 0) return (-1); 
    if(ghar == 0) return (-1); 

/* convert mjd/fmjd in GPS time to Greenwich hour angle (in radians) */

/*** "satellite orbits: models, methods, applications" montenbruck & gill(2000) */
/* section 2.3.1, pg. 33 */
/*** need UT to get sidereal time  ("astronomy on the personal computer", 4th ed) 2005) */
    tsecgps = *fmjd * 86400.;
/* *** GPS time (sec of */
    tsecutc = gps2utc_(&tsecgps);
/* *** UTC time (sec of */
    fmjdutc = tsecutc / 86400.;
/* **** d = MJD - 51544.5d0                               !*** footnote */

/* *** UTC time (fract. */
    d = *mjd - 51544 + (fmjdutc - .5);
/* greenwich hour angle for J2000  (12:00:00 on 1 Jan 2000) */
/***** ghad = 100.46061837504d0 + 360.9856473662862d0*d  !*** eq. 2.85 (+d
igits)*/
/* *** days since */
    ghad = d * 360.9856473662862 + 280.46061837504;
/* *** normalize to 0-360 and convert to radians */
/* *** corrn.   (+ */
    i = (int) (ghad / 360.);
    *ghar = (ghad - i * 360.) / stuff_1.rad;
    while(*ghar > stuff_1.pi2) {
       *ghar -= stuff_1.pi2;
    }
    while(*ghar < 0.) {
       *ghar += stuff_1.pi2;
    }
    return 0;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
je 0xd97f4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
pushq %rbp
movq %rsp, %rbp
movsd 0x19818(%rip), %xmm1    # 0xf3018
movsd (%rsi), %xmm0
mulsd %xmm1, %xmm0
leaq 0x21df19(%rip), %rax    # 0x2f7728
cvtsi2sdl (%rax), %xmm2
subsd %xmm2, %xmm0
movl $0xffff36a8, %eax       # imm = 0xFFFF36A8
addl (%rdi), %eax
cvtsi2sd %eax, %xmm2
divsd %xmm1, %xmm0
addsd 0x1c1d2(%rip), %xmm0    # 0xf5a00
addsd %xmm2, %xmm0
mulsd 0x3cc9e(%rip), %xmm0    # 0x1164d8
addsd 0x3cc9e(%rip), %xmm0    # 0x1164e0
movsd 0x2e966(%rip), %xmm1    # 0x1081b0
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
divsd 0x28bc06(%rip), %xmm0   # 0x365470
movsd %xmm0, (%rdx)
movsd 0x28bc0a(%rip), %xmm1   # 0x365480
ucomisd %xmm1, %xmm0
jbe 0xd9882
subsd %xmm1, %xmm0
jmp 0xd986a
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0xd989a
addsd 0x28bbec(%rip), %xmm0   # 0x365480
movsd %xmm0, (%rdx)
jmp 0xd9886
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: rot3_(double*, double*, double*, double*, double*, double*, double*)
int rot3_(double *theta, double *x, double *y, 
        double *z, double *u, double *v, double *w)
{
    /* Local variables */
    static double c, s;

    /* rotate coordinate axes about 3 axis by angle of theta radians */
    /* x,y,z transformed into u,v,w */

    s = sin(*theta);
    c = cos(*theta);
    *u = c * *x + s * *y;
    *v = c * *y - s * *x;
    *w = *z;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movsd (%rdi), %xmm0
callq 0x9080
movsd %xmm0, 0x28bf68(%rip)   # 0x365838
movsd (%rbx), %xmm0
callq 0x9710
movsd 0x28bf57(%rip), %xmm1   # 0x365838
movsd (%r15), %xmm2
mulsd %xmm1, %xmm2
movsd (%r13), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%r12)
mulsd (%r13), %xmm1
mulsd (%r15), %xmm0
subsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movsd (%r14), %xmm0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: lhsaaz_(double*, double*, double*, double*, double*, double*)
int lhsaaz_(double *u, double *v, double *w, 
        double *ra, double *az, double *va)
{
    /* Local variables */
    static double s, r2, s2;

    if(u == 0) return (-1); 
    if(v == 0) return (-1); 
    if(w == 0) return (-1); 
    if(ra == 0) return (-1); 
    if(az == 0) return (-1); 
    if(va == 0) return (-1); 

    /* determine range,azimuth,vertical angle from local horizon coord. */
    s2 = *u * *u + *v * *v;
    r2 = s2 + *w * *w;
    s = sqrt(s2);
    *ra = sqrt(r2);
    *az = atan2(*v, *u);
    *va = atan2(*w, s);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
testq %r12, %r12
sete %dl
orb %al, %dl
orb %cl, %dl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %cl
orb %al, %cl
orb %dl, %cl
je 0xd99a7
pushq $-0x1
popq %rax
jmp 0xd9a2c
movq %r8, %r14
movq %rsi, %rbx
movq %rdi, %r13
movq %r9, -0x30(%rbp)
movsd (%rdi), %xmm1
movsd (%rsi), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd (%r15), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm1, %xmm1
movsd %xmm1, 0x28be17(%rip)   # 0x3657f8
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xd99f1
sqrtsd %xmm0, %xmm0
jmp 0xd99f6
callq 0x9260
movsd %xmm0, (%r12)
movsd (%rbx), %xmm0
movsd (%r13), %xmm1
callq 0x9050
movsd %xmm0, (%r14)
movsd (%r15), %xmm0
movsd 0x28bddb(%rip), %xmm1   # 0x3657f8
callq 0x9050
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: grav_force(double)
double grav_force(double jd)
{
double d;

   // jd is utc time
   d = 0.0;
   if(lat && lon) {  // only do this if lat/lon available
      d = calc_gals(jd, lat*180.0/PI, lon*180.0/PI, alt);

      calc_earth_tide(jd + jtime(0,0,utc_offset,0.0));  // uses GPS time
      d = alt_tide;
   }

   return d;
}

// Assembly:
movapd %xmm0, %xmm4
leaq 0x21d58a(%rip), %rax    # 0x2f6fd0
movsd (%rax), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0xd9a5a
jnp 0xd9aef
leaq 0x21d577(%rip), %rax    # 0x2f6fd8
movsd (%rax), %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jne 0xd9a71
jnp 0xd9aef
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd 0x1be27(%rip), %xmm0    # 0xf58a8
mulsd %xmm0, %xmm1
movsd 0x1be13(%rip), %xmm3    # 0xf58a0
divsd %xmm3, %xmm1
mulsd %xmm0, %xmm2
divsd %xmm3, %xmm2
leaq 0x21d540(%rip), %rax    # 0x2f6fe0
movsd (%rax), %xmm3
movapd %xmm4, %xmm0
movsd %xmm4, -0x8(%rbp)
callq 0xd5ea0
leaq 0x21dc6f(%rip), %rax    # 0x2f7728
cvtsi2sdl (%rax), %xmm0
divsd 0x1954b(%rip), %xmm0    # 0xf3010
addsd 0x1964b(%rip), %xmm0    # 0xf3118
divsd 0x1956b(%rip), %xmm0    # 0xf3040
addsd -0x8(%rbp), %xmm0
callq 0xd6757
leaq 0x21d572(%rip), %rax    # 0x2f7058
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkingan[P]ladyheather/heathmsc.cpp
// Function: easter(int)
void easter(int y)
{
int g, c, d, h, k, i, j;
int m;
double jd;

    // Oudin's algorithm for calculating easter
    g = y % 19;
    c = y / 100;
    d = c - c/4;
    h = (d - ((8*c+13)/25) + (19*g) + 15) % 30;
    k = h / 28;
    i = h - k*(1 - k*(29/(h+1))*(21-g)/11);
    j = (y + y/4 + i + 2 - d) % 7;
    d = 28 + i - j;

    if(d > 31) {
       d -= 31;
       m = 4;
    }
    else m = 3;

    set_holiday(EASTER, m, d);

    // calculate Ash Wednesday
    jd = jdate(y, m, d);
    gregorian(0, jd-46.0);
    set_holiday(ASH, g_month, g_day);

    gregorian(0, jd-47.0);
    set_holiday(MARDI_GRAS, g_month, g_day);

    // calculate Palm Sunday
    gregorian(0, jd-7.0);
    set_holiday(PALM_SUNDAY, g_month, g_day);

    // calculate Good Friday
    gregorian(0, jd-2.0);
    set_holiday(GOOD_FRIDAY, g_month, g_day);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x13
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
movl %edx, %esi
pushq $0x64
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
movl %eax, %edi
movl $0xfffffe70, %ecx       # imm = 0xFFFFFE70
movl %ebx, %eax
cltd
idivl %ecx
movl %eax, %ecx
addl %edi, %ecx
leal 0xd(,%rdi,8), %eax
pushq $-0x19
popq %rdi
cltd
idivl %edi
imull $0x13, %esi, %edx
addl %ecx, %edx
addl %edx, %eax
addl $0xf, %eax
pushq $0x1e
popq %rdi
cltd
idivl %edi
movl %edx, %edi
movsbl %dil, %edx
movb $0x1c, %r8b
movl %edx, %eax
idivb %r8b
movsbl %al, %r8d
incb %dl
movb $0x1d, %al
movzbl %al, %eax
idivb %dl
movsbl %al, %edx
pushq $0x15
popq %rax
subl %esi, %eax
imull %r8d, %eax
imull %edx, %eax
movw $0xfff5, %si            # imm = 0xFFF5
cwtd
idivw %si
notl %eax
movswl %ax, %r14d
imull %r8d, %r14d
addl %edi, %r14d
pushq $0x4
popq %rsi
movl %ebx, %eax
cltd
idivl %esi
addl %ebx, %eax
subl %ecx, %eax
addl %r14d, %eax
addl $0x2, %eax
pushq $0x7
popq %rcx
cltd
idivl %ecx
subl %edx, %r14d
leal 0x1c(%r14), %eax
addl $-0x3, %r14d
xorl %r15d, %r15d
cmpl $0x20, %eax
setge %r15b
cmovll %eax, %r14d
addl $0x3, %r15d
pushq $0x6f
popq %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0xd1911
movl %ebx, %edi
movl %r15d, %esi
movl %r14d, %edx
callq 0xc2f07
movapd %xmm0, %xmm1
movsd %xmm0, -0x20(%rbp)
movsd 0x3c90c(%rip), %xmm0    # 0x1164e8
addsd %xmm1, %xmm0
xorl %edi, %edi
callq 0xbfac2
leaq 0x21daae(%rip), %rbx    # 0x2f769c
movl (%rbx), %esi
leaq 0x21daa9(%rip), %r14    # 0x2f76a0
movl (%r14), %edx
pushq $0x6c
popq %rdi
callq 0xd1911
movsd 0x3c8e6(%rip), %xmm0    # 0x1164f0
addsd -0x20(%rbp), %xmm0
xorl %edi, %edi
callq 0xbfac2
movl (%rbx), %esi
movl (%r14), %edx
pushq $0x76
popq %rdi
callq 0xd1911
movsd 0x3bc35(%rip), %xmm0    # 0x115860
addsd -0x20(%rbp), %xmm0
xorl %edi, %edi
callq 0xbfac2
movl (%rbx), %esi
movl (%r14), %edx
pushq $0x6d
popq %rdi
callq 0xd1911
movsd -0x20(%rbp), %xmm0
addsd 0x1be47(%rip), %xmm0    # 0xf5a98
xorl %edi, %edi
callq 0xbfac2
movl (%rbx), %esi
movl (%r14), %edx
pushq $0x6e
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd1911