LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe77bd
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movl %ebx, %edi
callq 0xe77bd
movsd -0x28(%rbp), %xmm3
subsd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe8270
jp 0xe8270
movsd -0x18(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
mulsd 0x20dfa(%rip), %xmm0    # 0x109068
jmp 0xe8293
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_O1/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 0x42850(%rip), %xmm1    # 0x12b750
addsd %xmm0, %xmm1
divsd 0x42a1c(%rip), %xmm1    # 0x12b928
movsd 0x42a1c(%rip), %xmm2    # 0x12b930
mulsd %xmm1, %xmm2
addsd 0x42a18(%rip), %xmm2    # 0x12b938
movsd 0x42a18(%rip), %xmm3    # 0x12b940
mulsd %xmm1, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd 0x42a0c(%rip), %xmm2    # 0x12b948
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
movsd 0x429fc(%rip), %xmm3    # 0x12b950
mulsd %xmm1, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd 0x429e8(%rip), %xmm2    # 0x12b958
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm3, %xmm2
movsd %xmm2, -0x8(%rbp)
callq 0xe0d30
mulsd 0x42ff6(%rip), %xmm0    # 0x12bf90
movsd -0x8(%rbp), %xmm1
mulsd %xmm1, %xmm1
movsd 0x200c5(%rip), %xmm2    # 0x109070
subsd %xmm1, %xmm2
movsd %xmm2, -0x10(%rbp)
callq 0x9710
mulsd -0x8(%rbp), %xmm0
addsd 0x200aa(%rip), %xmm0    # 0x109070
movsd -0x10(%rbp), %xmm1
divsd %xmm0, %xmm1
mulsd 0x42fc1(%rip), %xmm1    # 0x12bf98
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x42faf(%rip), %xmm0    # 0x12bfa0
jae 0xe9105
ucomisd 0x20139(%rip), %xmm0    # 0x109138
jae 0xe903d
ucomisd 0x42fb7(%rip), %xmm0    # 0x12bfc0
jae 0xe906b
mulsd 0x22805(%rip), %xmm0    # 0x10b818
divsd 0x22805(%rip), %xmm0    # 0x10b820
callq 0x91b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe902c
jnp 0xe905e
movsd 0x42fbc(%rip), %xmm1    # 0x12bff0
divsd %xmm0, %xmm1
jmp 0xe9105
mulsd 0x227d3(%rip), %xmm0    # 0x10b818
divsd 0x227d3(%rip), %xmm0    # 0x10b820
callq 0x91b0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe90c5
jp 0xe90c5
movsd 0x20092(%rip), %xmm1    # 0x1090f8
jmp 0xe910d
movsd 0x42f55(%rip), %xmm1    # 0x12bfc8
mulsd %xmm0, %xmm1
addsd 0x42f51(%rip), %xmm1    # 0x12bfd0
movsd 0x42f51(%rip), %xmm2    # 0x12bfd8
mulsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
movsd 0x42f45(%rip), %xmm3    # 0x12bfe0
mulsd %xmm0, %xmm3
mulsd %xmm0, %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movsd 0x42f35(%rip), %xmm1    # 0x12bfe8
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
jmp 0xe9101
movsd 0x42edb(%rip), %xmm1    # 0x12bfa8
divsd %xmm0, %xmm1
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movsd 0x42ecb(%rip), %xmm3    # 0x12bfb0
divsd %xmm2, %xmm3
addsd %xmm1, %xmm3
mulsd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movsd 0x42ebb(%rip), %xmm1    # 0x12bfb8
divsd %xmm2, %xmm1
addsd %xmm3, %xmm1
divsd 0x1ff03(%rip), %xmm1    # 0x109010
movapd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe8ef0
movsd %xmm0, -0x8(%rbp)
leaq 0x223ea4(%rip), %rax    # 0x30cfd0
movsd (%rax), %xmm0
leaq 0x223ea9(%rip), %rax    # 0x30cfe0
movsd (%rax), %xmm1
callq 0xe765f
movsd -0x8(%rbp), %xmm1
subsd %xmm0, %xmm1
addsd %xmm1, %xmm1
movsd 0x42ea3(%rip), %xmm0    # 0x12bff8
divsd %xmm1, %xmm0
callq 0x9660
addsd %xmm0, %xmm0
mulsd 0x226b6(%rip), %xmm0    # 0x10b820
divsd 0x226a6(%rip), %xmm0    # 0x10b818
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd0c46
leaq 0x2244ab(%rip), %rax    # 0x30d6a4
movl (%rax), %ecx
leal -0x7e0(%rcx), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x53, %edx
ja 0xe925b
shll $0x2, %ecx
leal (%rcx,%rcx,2), %edx
addl $0xffffa180, %edx       # imm = 0xFFFFA180
movslq %edx, %rdx
leal (%rcx,%rcx,2), %ecx
addl $0xffffa17f, %ecx       # imm = 0xFFFFA17F
leaq 0x84746(%rip), %rsi     # 0x16d970
leaq (%rsi,%rdx,8), %rsi
incq %rdx
movsd -0x8(%rbp), %xmm1
movsd (%rsi), %xmm0
ucomisd %xmm1, %xmm0
jae 0xe9259
incl %ecx
addq $0x8, %rsi
movq %rdx, %rdi
incq %rdi
cmpl $0x41b, %edx            # imm = 0x41B
movq %rdi, %rdx
jne 0xe9236
jmp 0xe925b
movl %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe91de
testl %eax, %eax
js 0xe92c8
leaq 0x846f2(%rip), %rcx     # 0x16d970
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 0xe929f
jnp 0xe92c8
movsd 0x10(%rcx,%rax,8), %xmm0
subsd %xmm3, %xmm0
subsd %xmm1, %xmm0
ucomisd %xmm4, %xmm0
jne 0xe92b5
jnp 0xe92c8
movsd -0x8(%rbp), %xmm3
subsd %xmm2, %xmm3
divsd %xmm1, %xmm3
mulsd %xmm3, %xmm0
jmp 0xe9301
movsd -0x8(%rbp), %xmm2
addsd 0x4247b(%rip), %xmm2    # 0x12b750
divsd 0x4247b(%rip), %xmm2    # 0x12b758
movsd 0x42d23(%rip), %xmm1    # 0x12c008
mulsd %xmm2, %xmm1
addsd 0x42d1f(%rip), %xmm1    # 0x12c010
movsd 0x42d1f(%rip), %xmm0    # 0x12c018
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x223a3d(%rip), %rax    # 0x30cfd0
movsd (%rax), %xmm0
leaq 0x223a42(%rip), %rax    # 0x30cfe0
movsd (%rax), %xmm1
callq 0xe765f
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 0x9350
movapd %xmm0, %xmm4
mulsd -0x48(%rbp), %xmm4
leaq 0x154d6c(%rip), %rbx    # 0x23e390
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xe9671
leaq 0x12f291(%rip), %rax    # 0x2188c4
cmpb $0x0, (%rax)
je 0xe9671
leaq 0x4b516(%rip), %rsi     # 0x134b55
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 0x58b41
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2238fd(%rip), %rax    # 0x30cfd0
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 0x220e5(%rip), %xmm0    # 0x10b820
divsd 0x220d5(%rip), %xmm0    # 0x10b818
movsd 0x34945(%rip), %xmm1    # 0x11e090
addsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
jmp 0x94d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x223857(%rip), %r14    # 0x30cfd0
movsd (%r14), %xmm0
leaq 0x22385b(%rip), %r15    # 0x30cfe0
movsd (%r15), %xmm1
callq 0xe765f
addl %ebx, %ebx
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
mulsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd (%r14), %xmm0
movsd (%r15), %xmm1
callq 0xe765f
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 0x1f885(%rip), %xmm0    # 0x109068
mulsd -0x20(%rbp), %xmm0
callq 0x91b0
addsd -0x28(%rbp), %xmm0
callq 0x92d0
subsd -0x20(%rbp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x29135a(%rip)   # 0x37b8e8
movsd (%rbx), %xmm0
callq 0x9710
movapd %xmm0, %xmm1
movsd 0x291345(%rip), %xmm2   # 0x37b8e8
movsd 0x33af5(%rip), %xmm0    # 0x11e0a0
mulsd %xmm2, %xmm0
mulsd %xmm2, %xmm0
addsd 0x1eab5(%rip), %xmm0    # 0x109070
movsd %xmm1, 0x29131d(%rip)   # 0x37b8e0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xea5d3
sqrtsd %xmm0, %xmm0
jmp 0xea5d8
callq 0x9270
movsd 0x33ac8(%rip), %xmm1    # 0x11e0a8
divsd %xmm0, %xmm1
movsd %xmm1, 0x2912ec(%rip)   # 0x37b8d8
addsd (%r14), %xmm1
mulsd 0x2912e7(%rip), %xmm1   # 0x37b8e0
movsd %xmm1, -0x30(%rbp)
movsd (%r12), %xmm0
callq 0x9710
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, (%r13)
movsd 0x2912bc(%rip), %xmm0   # 0x37b8d8
addsd (%r14), %xmm0
mulsd 0x2912b7(%rip), %xmm0   # 0x37b8e0
movsd %xmm0, -0x30(%rbp)
movsd (%r12), %xmm0
callq 0x9080
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, (%r15)
movsd 0x29128d(%rip), %xmm0   # 0x37b8d8
mulsd 0x33a5d(%rip), %xmm0    # 0x11e0b0
addsd (%r14), %xmm0
mulsd 0x291288(%rip), %xmm0   # 0x37b8e8
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_O1/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, 0x28fe68(%rip)   # 0x37b8f8
movsd (%rbx), %xmm0
callq 0x9710
movsd %xmm0, 0x28fe4f(%rip)   # 0x37b8f0
movsd (%r13), %xmm0
callq 0x9080
movsd %xmm0, 0x28fe4c(%rip)   # 0x37b900
movsd (%r13), %xmm0
callq 0x9710
movsd 0x28fe31(%rip), %xmm1   # 0x37b8f8
movapd 0x1d6d1(%rip), %xmm3    # 0x1091a0
xorpd %xmm1, %xmm3
mulsd %xmm0, %xmm3
movsd 0x28fe21(%rip), %xmm2   # 0x37b900
movapd %xmm2, %xmm4
mulsd %xmm1, %xmm4
movq 0x10(%rbp), %rcx
mulsd (%rcx), %xmm4
mulsd (%r14), %xmm3
subsd %xmm4, %xmm3
movsd 0x28fdf0(%rip), %xmm4   # 0x37b8f0
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_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movq %rdx, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
testq %r13, %r13
sete %dl
orb %al, %dl
orb %cl, %dl
testq %r8, %r8
sete %al
orb %dl, %al
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0xebc82
movq %r8, %r12
movq %rsi, %r14
movq %rdi, %r15
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rdi), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0xebc07
sqrtsd %xmm0, %xmm0
jmp 0xebc10
callq 0x9270
xorpd %xmm2, %xmm2
movsd %xmm0, (%r13)
movsd (%r14), %xmm1
movsd 0x8(%r14), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%r14), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jb 0xebc47
sqrtsd %xmm0, %xmm0
jmp 0xebc4c
callq 0x9270
movsd %xmm0, (%r12)
movsd (%r15), %xmm0
movsd 0x8(%r15), %xmm1
mulsd 0x8(%r14), %xmm1
mulsd (%r14), %xmm0
movsd 0x10(%r15), %xmm2
mulsd 0x10(%r14), %xmm2
addsd %xmm1, %xmm0
addsd %xmm0, %xmm2
movsd %xmm2, (%rbx)
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_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: enorm8_(double*)
double enorm8_(double *a)
{
    /* F2C generated locals */
    double ret_val;
    if(a == 0) return 0.0;  // !!!!!!

    /* compute euclidian norm of a vector (of length 3) */

    /* Function Body */
    ret_val = sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
    return ret_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xed7c5
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm0
mulsd %xmm0, %xmm0
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd 0x10(%rdi), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xed7cb
sqrtsd %xmm0, %xmm0
jmp 0xed7c9
xorpd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x9270
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x28e105(%rip)   # 0x37b908
movsd (%r14), %xmm0
callq 0x9710
movsd (%r13), %xmm1
movsd %xmm1, (%r12)
movsd 0x28e0e7(%rip), %xmm1   # 0x37b908
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_O1/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
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0xed935
pushq %rbp
movq %rsp, %rbp
movsd 0x1b787(%rip), %xmm1    # 0x109018
movsd (%rsi), %xmm0
mulsd %xmm1, %xmm0
leaq 0x21fe88(%rip), %rax    # 0x30d728
cvtsi2sdl (%rax), %xmm2
subsd %xmm2, %xmm0
movl $0xffff36a8, %eax       # imm = 0xFFFF36A8
addl (%rdi), %eax
xorps %xmm2, %xmm2
cvtsi2sd %eax, %xmm2
divsd %xmm1, %xmm0
addsd 0x1e0be(%rip), %xmm0    # 0x10b980
addsd %xmm2, %xmm0
mulsd 0x3ebfa(%rip), %xmm0    # 0x12c4c8
addsd 0x3ebfa(%rip), %xmm0    # 0x12c4d0
movsd 0x307b2(%rip), %xmm1    # 0x11e090
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cvttpd2dq %xmm2, %xmm2
cvtdq2pd %xmm2, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
divsd 0x28db72(%rip), %xmm0   # 0x37b470
movsd %xmm0, (%rdx)
movsd 0x28db76(%rip), %xmm1   # 0x37b480
ucomisd %xmm1, %xmm0
jbe 0xed916
subsd %xmm1, %xmm0
jmp 0xed8fe
movsd (%rdx), %xmm0
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0xed934
addsd 0x28db52(%rip), %xmm0   # 0x37b480
movsd %xmm0, (%rdx)
jmp 0xed920
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x28dfa8(%rip)   # 0x37b910
movsd (%rbx), %xmm0
callq 0x9710
movsd 0x28df97(%rip), %xmm1   # 0x37b910
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_O1/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
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0xedae6
movq %r8, %r14
movq %rsi, %rbx
movq %rdi, %r13
movsd (%rdi), %xmm0
movsd (%rsi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd (%r15), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x28de5e(%rip)   # 0x37b8d0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq %r9, -0x30(%rbp)
jb 0xeda86
sqrtsd %xmm0, %xmm0
jmp 0xeda8f
callq 0x9270
xorpd %xmm1, %xmm1
movsd %xmm0, 0x28de31(%rip)   # 0x37b8c8
movsd 0x28de31(%rip), %xmm0   # 0x37b8d0
ucomisd %xmm1, %xmm0
jb 0xedaab
sqrtsd %xmm0, %xmm0
jmp 0xedab0
callq 0x9270
movsd %xmm0, (%r12)
movsd (%rbx), %xmm0
movsd (%r13), %xmm1
callq 0x9050
movsd %xmm0, (%r14)
movsd (%r15), %xmm0
movsd 0x28ddf1(%rip), %xmm1   # 0x37b8c8
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_O1/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 0x21f4d0(%rip), %rax    # 0x30cfd0
movsd (%rax), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0xedb14
jnp 0xedbb0
leaq 0x21f4bd(%rip), %rax    # 0x30cfd8
movsd (%rax), %xmm2
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jne 0xedb2f
jnp 0xedbb0
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd 0x1dce1(%rip), %xmm0    # 0x10b820
mulsd %xmm0, %xmm1
movsd 0x1dccd(%rip), %xmm3    # 0x10b818
divsd %xmm3, %xmm1
mulsd %xmm0, %xmm2
divsd %xmm3, %xmm2
leaq 0x21f482(%rip), %rax    # 0x30cfe0
movsd (%rax), %xmm3
movapd %xmm4, %xmm0
movsd %xmm4, -0x8(%rbp)
callq 0xe9a28
leaq 0x21fbb1(%rip), %rax    # 0x30d728
xorps %xmm0, %xmm0
cvtsi2sdl (%rax), %xmm0
divsd 0x1b48a(%rip), %xmm0    # 0x109010
addsd 0x1b58a(%rip), %xmm0    # 0x109118
divsd 0x1b4aa(%rip), %xmm0    # 0x109040
addsd -0x8(%rbp), %xmm0
callq 0xea2df
leaq 0x21f4b1(%rip), %rax    # 0x30d058
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: get_islam_day(int, int, int)
int get_islam_day(int yy, int mm, int dd)
{
// islam_to_greg(yy-581, mm, dd);
// if(g_year == yy) return 581;

   islam_to_greg(yy-580, mm, dd);
   if(g_year == yy) return 580;

   islam_to_greg(yy-579, mm, dd);
   if(g_year == yy) return 579; // not in this year, try next year

   islam_to_greg(yy-578, mm, dd);
   if(g_year == yy) return 578; // not in this year, try next year

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %r15d
movl %edi, %ebx
leal -0x244(%rbx), %edi
callq 0xee2cc
leaq 0x21f137(%rip), %r12    # 0x30d6a4
movl $0x244, %eax            # imm = 0x244
cmpl %ebx, (%r12)
je 0xee5b3
leal -0x243(%rbx), %edi
movl %r15d, %esi
movl %r14d, %edx
callq 0xee2cc
movl $0x243, %eax            # imm = 0x243
cmpl %ebx, (%r12)
je 0xee5b3
leal -0x242(%rbx), %edi
movl %r15d, %esi
movl %r14d, %edx
callq 0xee2cc
xorl %ecx, %ecx
cmpl %ebx, (%r12)
movl $0x242, %eax            # imm = 0x242
cmovnel %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: init_islamic(int)
void init_islamic(int year)
{
int mm;
int iyear;

   // calculate start of each Islamic month
   iyear = year - 578;
   while(iyear > 0) {  // find Islamic year that starts on or before this gregorian year
      islam_to_greg(iyear, 1, 1);
      if(g_year < this_year) break;
      else if((g_year == this_year) && (g_month == 1) && (g_day == 1)) break;
      --iyear;
   }

   for(mm=0; mm<=35; mm++) {  // find start of the next 36 islam months
      islam_to_greg(iyear+(mm/12), (mm%12)+1, 1);
      myears[mm] = iyear+(mm/12);
      mtimes[mm] = jdate(g_year, g_month, g_day);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leal -0x242(%rdi), %ebx
cmpl $0x243, %edi            # imm = 0x243
jl 0xee629
leaq 0x21f0c5(%rip), %r14    # 0x30d6a4
leaq 0x21ef3a(%rip), %r15    # 0x30d520
leaq 0x21f0af(%rip), %r12    # 0x30d69c
leaq 0x21f0ac(%rip), %r13    # 0x30d6a0
movl %ebx, %edi
movl $0x1, %esi
movl $0x1, %edx
callq 0xee2cc
movl (%r15), %eax
cmpl %eax, (%r14)
jl 0xee629
jne 0xee61d
cmpl $0x1, (%r12)
jne 0xee61d
cmpl $0x1, (%r13)
je 0xee629
leal -0x1(%rbx), %eax
cmpl $0x1, %ebx
movl %eax, %ebx
jg 0xee5f4
xorl %ebx, %ebx
leaq 0x28c980(%rip), %r15    # 0x37afb0
leaq 0x28caa9(%rip), %r12    # 0x37b0e0
xorl %r13d, %r13d
movl %r13d, %r14d
movl $0xaaaaaaab, %eax       # imm = 0xAAAAAAAB
imulq %rax, %r14
shrq $0x23, %r14
leal (,%r14,4), %eax
leal (%rax,%rax,2), %eax
addl %ebx, %r14d
movl %r13d, %esi
subl %eax, %esi
incl %esi
movl %r14d, %edi
movl $0x1, %edx
callq 0xee2cc
movl %r14d, (%r12)
leaq 0x21f02d(%rip), %rax    # 0x30d6a4
movl (%rax), %edi
leaq 0x21f01c(%rip), %rax    # 0x30d69c
movl (%rax), %esi
leaq 0x21f017(%rip), %rax    # 0x30d6a0
movl (%rax), %edx
callq 0xd4110
movsd %xmm0, (%r15)
incq %r13
addq $0x8, %r15
addq $0x4, %r12
cmpq $0x24, %r13
jne 0xee63a
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: init_druid(int)
void init_druid(int year)
{
double jd;
int mm;

   jd = jdate(year-1, 12, 24);  // Druid year starts on 24 Dec
   jd += (double) druid_epoch;  // kludge to allow tweak to start of calendar
   for(mm=0; mm<=13; mm++) {    // the Juilan time of the start of each month
      dyears[mm] = year;        // assume druid year is the Gregorian year
      dtimes[mm] = jd;          // ... that holds most of the Druid year
      jd += 28.0;               // Druid months are 28 days long
   }

   dtimes[14] = jdate(year, 12, 24);
   dtimes[14] += (double) druid_epoch; 
   dyears[14] = year+1;
   dtimes[15] = dtimes[14]+28.0;
   dyears[15] = year+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rcx
leaq -0x1(%rcx), %rax
movabsq $-0x5c28f5c28f5c28f5, %r8 # imm = 0xA3D70A3D70A3D70B
imulq %r8
leaq (%rdx,%rcx), %rax
decq %rax
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x6, %rax
addq %rdx, %rax
imulq $-0x64, %rax, %rdx
addq %rcx, %rdx
decq %rdx
imulq $0x23ab1, %rax, %rax    # imm = 0x23AB1
leaq 0x3(%rax), %r9
testq %rax, %rax
cmovnsq %rax, %r9
sarq $0x2, %r9
imulq $0x8ead, %rdx, %rsi     # imm = 0x8EAD
movq %rsi, %rax
imulq %r8
addq %rsi, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x6, %rdx
cvtsi2sd %r9, %xmm0
addsd 0x3cfde(%rip), %xmm0    # 0x12b708
addq %rax, %rdx
cvtsi2sd %rdx, %xmm1
addsd %xmm0, %xmm1
addsd 0x3de0a(%rip), %xmm1    # 0x12c548
addsd 0x1a8fa(%rip), %xmm1    # 0x109040
leaq 0x12cd03(%rip), %rax    # 0x21b450
xorps %xmm0, %xmm0
cvtsi2sdq (%rax), %xmm0
addsd %xmm0, %xmm1
leaq 0x28cbf0(%rip), %rax    # 0x37b350
xorl %edx, %edx
leaq 0x28cc87(%rip), %rsi    # 0x37b3f0
movsd 0x3dddf(%rip), %xmm2    # 0x12c550
movl %edi, (%rdx,%rsi)
movsd %xmm1, (%rax)
addsd %xmm2, %xmm1
addq $0x8, %rax
addq $0x4, %rdx
cmpq $0x38, %rdx
jne 0xee771
movq %rcx, %rax
imulq %r8
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x6, %rdx
addq %rax, %rdx
imulq $-0x64, %rdx, %rax
addq %rcx, %rax
imulq $0x23ab1, %rdx, %rcx    # imm = 0x23AB1
leaq 0x3(%rcx), %rsi
testq %rcx, %rcx
cmovnsq %rcx, %rsi
sarq $0x2, %rsi
imulq $0x8ead, %rax, %rcx     # imm = 0x8EAD
movq %rcx, %rax
imulq %r8
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x6, %rdx
xorps %xmm1, %xmm1
cvtsi2sd %rsi, %xmm1
addsd 0x3cf1f(%rip), %xmm1    # 0x12b708
addq %rax, %rdx
xorps %xmm2, %xmm2
cvtsi2sd %rdx, %xmm2
addsd %xmm1, %xmm2
addsd 0x3dd48(%rip), %xmm2    # 0x12c548
addsd 0x1a838(%rip), %xmm2    # 0x109040
addsd %xmm0, %xmm2
movsd %xmm2, 0x28cbac(%rip)   # 0x37b3c0
incl %edi
movl %edi, 0x28cc0c(%rip)    # 0x37b428
addsd 0x3dd2c(%rip), %xmm2    # 0x12c550
movsd %xmm2, 0x28cb9c(%rip)   # 0x37b3c8
movl %edi, 0x28cbfa(%rip)    # 0x37b42c
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: init_indian(int)
void init_indian(int year)
{
   // India civil calendar
   itimes[0] = jdate(year-1, 12, 22);  // start of Pau the year before
   itimes[1] = itimes[0] + 30.0;           // Mag
   itimes[2] = itimes[1] + 30.0;           // Pha
   itimes[3] = itimes[2] + 30.0;           // start of Cai
   if(leap_year(year-79+78)) itimes[3] -= 1.0;  // adjust for leap years
   itimes[4] = itimes[3] + 31.0;           // Vai
   itimes[5] = itimes[4] + 31.0;           // Jya
   itimes[6] = itimes[5] + 31.0;           // Asa
   itimes[7] = itimes[6] + 31.0;           // Sra
   itimes[8] = itimes[7] + 31.0;           // Bha
   itimes[9] = itimes[8] + 31.0;           // Asv

   itimes[10] = itimes[9]  + 30.0;         // Kar
   itimes[11] = itimes[10] + 30.0;         // Agr
   itimes[12] = itimes[11] + 30.0;         // Pau
   itimes[13] = itimes[12] + 30.0;         // Mag
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rcx
decl %edi
leaq -0x1(%rcx), %rax
movabsq $-0x5c28f5c28f5c28f5, %rsi # imm = 0xA3D70A3D70A3D70B
imulq %rsi
leaq (%rdx,%rcx), %rax
decq %rax
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x6, %rax
addq %rdx, %rax
imulq $-0x64, %rax, %rdx
addq %rdx, %rcx
decq %rcx
imulq $0x23ab1, %rax, %rax    # imm = 0x23AB1
leaq 0x3(%rax), %r8
testq %rax, %rax
cmovnsq %rax, %r8
sarq $0x2, %r8
imulq $0x8ead, %rcx, %rcx     # imm = 0x8EAD
movq %rcx, %rax
imulq %rsi
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x6, %rdx
addq %rax, %rdx
cvtsi2sd %r8, %xmm0
addsd 0x3cccc(%rip), %xmm0    # 0x12b708
cvtsi2sd %rdx, %xmm1
addsd %xmm0, %xmm1
addsd 0x3dafb(%rip), %xmm1    # 0x12c548
addsd 0x3db03(%rip), %xmm1    # 0x12c558
movsd %xmm1, 0x28c4e3(%rip)   # 0x37af40
movsd 0x1ce93(%rip), %xmm0    # 0x10b8f8
addsd %xmm0, %xmm1
movsd %xmm1, 0x28c4d7(%rip)   # 0x37af48
addsd %xmm0, %xmm1
movsd %xmm1, 0x28c4d3(%rip)   # 0x37af50
addsd %xmm0, %xmm1
movsd %xmm1, 0x28c4cf(%rip)   # 0x37af58
testb $0x3, %dil
jne 0xeead5
imull $0xc28f5c29, %edi, %eax # imm = 0xC28F5C29
addl $0x51eb850, %eax        # imm = 0x51EB850
rorl $0x2, %eax
cmpl $0x28f5c28, %eax        # imm = 0x28F5C28
ja 0xeeac5
movslq %edi, %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x27, %rax
addl %ecx, %eax
imull $0x190, %eax, %eax      # imm = 0x190
subl %eax, %edi
jne 0xeead5
addsd 0x1a62b(%rip), %xmm1    # 0x1090f8
movsd %xmm1, 0x28c483(%rip)   # 0x37af58
movsd 0x3d123(%rip), %xmm1    # 0x12bc00
movsd 0x28c473(%rip), %xmm2   # 0x37af58
addsd %xmm1, %xmm2
movsd %xmm2, 0x28c46f(%rip)   # 0x37af60
addsd %xmm1, %xmm2
movsd %xmm2, 0x28c46b(%rip)   # 0x37af68
addsd %xmm1, %xmm2
movsd %xmm2, 0x28c467(%rip)   # 0x37af70
addsd %xmm1, %xmm2
movsd %xmm2, 0x28c463(%rip)   # 0x37af78
addsd %xmm1, %xmm2
movsd %xmm2, 0x28c45f(%rip)   # 0x37af80
addsd %xmm1, %xmm2
movsd %xmm2, 0x28c45b(%rip)   # 0x37af88
addsd %xmm0, %xmm2
movsd %xmm2, 0x28c457(%rip)   # 0x37af90
addsd %xmm0, %xmm2
movsd %xmm2, 0x28c453(%rip)   # 0x37af98
addsd %xmm0, %xmm2
movsd %xmm2, 0x28c44f(%rip)   # 0x37afa0
addsd %xmm0, %xmm2
movsd %xmm2, 0x28c44b(%rip)   # 0x37afa8
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: load_china_year(int, int)
int load_china_year(int year, int mm)
{
int i;
int index;
int month, months;
double days;

   index = year - 2009;
   if(china_data[index].leap_month) months = 13;
   else                             months = 12;
   year = year + 4635 - 1998 + 60;  // note +60 years is common in the US

   ctimes[mm] = china_data[index].jd;
   month = 1;
   for(i=mm; i<mm+months; i++) {
      cyear[i]  = year;
      cmonth[i] = month;
      if(china_data[index].leap_month) {  // this year has a leap month
         if((i-mm+1) != china_data[index].leap_month) ++month;
      }
      else {
         ++month;
      }

      if(china_data[index].month_mask & (1 << (i-mm))) days = 30.0;
      else                                             days = 29.0;
      ctimes[i+1] = ctimes[i] + days;
   }
   if(china_data[index].leap_month) {
      cmonth[china_data[index].leap_month] *= (-1);
   }

   return months;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq %edi, %r8
leaq 0x7bfaa(%rip), %r9      # 0x16ab20
movzbl -0x3ec6(%r9,%r8,8), %ecx
cmpq $0x1, %rcx
movl $0xd, %eax
sbbl $0x0, %eax
leal 0xa89(%r8), %edx
cvtss2sd -0x3ec4(%r9,%r8,8), %xmm0
movslq %esi, %rsi
leaq 0x28bf0a(%rip), %rdi    # 0x37aab0
leaq 0x8(%rdi,%rsi,8), %rdi
movsd %xmm0, -0x8(%rdi)
movq %rax, -0x30(%rbp)
leal (%rsi,%rax), %r10d
movzwl -0x3ec8(%r9,%r8,8), %r8d
movslq %r10d, %r9
leaq -0x1(%rcx), %r10
leaq (,%rsi,4), %rbx
movl $0x1, %r14d
xorl %r15d, %r15d
leaq 0x28c0b0(%rip), %rax    # 0x37ac90
leaq 0x3dc69(%rip), %r13     # 0x12c850
testq %rcx, %rcx
leaq (%rbx,%r15,4), %r11
leaq 0x28bffb(%rip), %r12    # 0x37abf0
movl %edx, (%r12,%r11)
movl %r14d, (%rax,%r11)
sete %r11b
cmpl %r15d, %r10d
movq %rax, %r12
setne %al
orb %r11b, %al
movzbl %al, %eax
addl %eax, %r14d
xorl %eax, %eax
btl %r15d, %r8d
setae %al
movsd -0x8(%rdi,%r15,8), %xmm0
addsd (%r13,%rax,8), %xmm0
movsd %xmm0, (%rdi,%r15,8)
leaq (%rsi,%r15), %rax
incq %rax
incq %r15
cmpq %r9, %rax
movq %r12, %rax
jl 0xeebe7
testq %rcx, %rcx
je 0xeec4a
negl (%rax,%rcx,4)
movq -0x30(%rbp), %rax
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: init_chinese(int)
void init_chinese(int year)
{
int month;

   if((year < 2010) || (year > 2100)) return;
   month = 0;
   month += load_china_year(year-1, month);
   month += load_china_year(year+0, month);
   month += load_china_year(year+1, month);
//FILE *f;
//int i;
//f = topen("abcd", "w");
//for(i=0; i<40; i++) {
//   fprintf(f, "%.1f %d %d\n", ctimes[i], cyear[i], cmonth[i]);
//}
//fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leal -0x835(%rbx), %eax
cmpl $-0x5b, %eax
jae 0xeec72
popq %rbx
popq %r14
popq %rbp
retq
leal -0x1(%rbx), %edi
xorl %esi, %esi
callq 0xeeb5f
movl %eax, %r14d
movl %ebx, %edi
movl %eax, %esi
callq 0xeeb5f
addl %eax, %r14d
incl %ebx
movl %ebx, %edi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xeeb5f
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: tax_day(int, int, int)
int tax_day(int year, int month, int day)
{
int gd;

   // return next tax due day - first weekday on or after the 15th of a month
   gd = day;
   if     (day_of_week(day, month, year) == 6) gd += 2;  // the 15th is on Sat
   else if(day_of_week(day, month, year) == 0) gd += 1;  // the 15th is on Sun
   return gd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpl $0x3, %esi
setl %al
subl %eax, %edi
leal 0x3(%rdi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
sarl $0x2, %eax
movslq %edi, %rcx
imulq $-0x51eb851f, %rcx, %rdi # imm = 0xAE147AE1
movq %rdi, %r8
shrq $0x3f, %r8
shrq $0x20, %rdi
sarl $0x5, %edi
addl %r8d, %edi
imulq $0x51eb851f, %rcx, %r8  # imm = 0x51EB851F
movq %r8, %r9
shrq $0x3f, %r9
shrq $0x20, %r8
sarl $0x7, %r8d
addl %r9d, %r8d
movslq %esi, %rsi
leaq 0x3c7ce(%rip), %r9      # 0x12b4c0
movzbl -0x1(%rsi,%r9), %esi
addl %r8d, %esi
addl %edx, %ecx
addl %eax, %ecx
addl %edi, %ecx
addl %esi, %ecx
movslq %ecx, %rax
imulq $-0x6db6db6d, %rax, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %esi
shrl $0x1f, %esi
sarl $0x2, %ecx
addl %esi, %ecx
leal (,%rcx,8), %esi
subl %esi, %ecx
xorl %esi, %esi
addl %eax, %ecx
sete %sil
cmpl $0x6, %ecx
movl $0x2, %eax
cmovnel %esi, %eax
addl %edx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: calc_vs(double)
double calc_vs(double jdme)
{
int i;
double t;
double s;
double w, jd, l;

   t = (jdme - JD2000) / 36525.0;    // Julian centuries from 2000 (of equ/sol).

   s = 0.0;
   for(i=0; i<=23; i++) {
      s = s + sol[i].a*cos(sol[i].b + sol[i].c*t);
   }

   w = (35999.373*t - 2.47)*DEG_TO_RAD; // radians
   l = 1.0 + 0.0334*cos(w) + 0.0007*cos(2.0*w);
   jd = jdme + (0.00001*s/l);           // the final result in Julian Dynamical Days.
   return jd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd 0x3ca00(%rip), %xmm1    # 0x12b750
movsd %xmm0, -0x30(%rbp)
addsd %xmm0, %xmm1
divsd 0x3c9f7(%rip), %xmm1    # 0x12b758
movsd %xmm1, -0x18(%rbp)
xorpd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x10, %ebx
leaq 0x815f5(%rip), %r14     # 0x170370
movsd -0x10(%rbx,%r14), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd (%rbx,%r14), %xmm0
mulsd -0x18(%rbp), %xmm0
addsd -0x8(%rbx,%r14), %xmm0
callq 0x9710
mulsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rbp)
addq $0x18, %rbx
cmpq $0x250, %rbx            # imm = 0x250
jne 0xeed7b
movsd -0x18(%rbp), %xmm0
mulsd 0x3d795(%rip), %xmm0    # 0x12c560
addsd 0x3d795(%rip), %xmm0    # 0x12c568
mulsd 0x1cb2d(%rip), %xmm0    # 0x10b908
movsd %xmm0, -0x18(%rbp)
callq 0x9710
mulsd 0x3d783(%rip), %xmm0    # 0x12c570
addsd 0x1a27b(%rip), %xmm0    # 0x109070
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
addsd %xmm0, %xmm0
callq 0x9710
mulsd 0x3d768(%rip), %xmm0    # 0x12c578
movsd -0x28(%rbp), %xmm1
mulsd 0x1ca5b(%rip), %xmm1    # 0x10b878
addsd -0x20(%rbp), %xmm0
divsd %xmm0, %xmm1
addsd -0x30(%rbp), %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jkingan[P]ladyheather/heathmsc.cpp
// Function: is_holiday(int, int, int)
int is_holiday(int pri_year,int pri_month,int pri_day)
{
int i;
int dow;
int day;

   if(no_greetings) return 0;

   for(i=0; i<calendar_entries; i++) { // is it a special day?
      if(holiday[i].month == 0) continue;

      day = holiday[i].day;
      if(day < 0) ;   // day number for dates like Friday the 13th (would be -13)
      else if(pri_month != holiday[i].month) continue;

      if((holiday[i].nth != 0) && (holiday[i].nth < 100)) {
         day = nth_dow_in(holiday[i].nth, day, pri_month, pri_year);
      }
      if(day < 0) {
         day = 0 - day;
         dow = day_of_week(pri_day,pri_month,pri_year);
         if(dow != holiday[i].month) continue;
      }
      if(day != pri_day) continue;
      return 1;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, -0x2c(%rbp)
leaq 0x12c39f(%rip), %rcx    # 0x21b41b
xorl %eax, %eax
cmpb $0x0, (%rcx)
jne 0xef1a1
leaq 0x129762(%rip), %r13    # 0x2187f0
cmpl $0x0, (%r13)
jle 0xef1a1
movl %edx, %r12d
movl %esi, %r14d
xorl %eax, %eax
cmpl $0x3, %esi
setl %al
movl -0x2c(%rbp), %ecx
subl %eax, %ecx
leal 0x3(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x2, %eax
movslq %ecx, %rdi
imulq $-0x51eb851f, %rdi, %rcx # imm = 0xAE147AE1
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imulq $0x51eb851f, %rdi, %rdx # imm = 0x51EB851F
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x27, %rdx
addl %esi, %edx
movslq %r14d, %rsi
movq %rsi, -0x38(%rbp)
addl %r12d, %edi
addl %eax, %edi
addl %ecx, %edi
addl %edx, %edi
movq %rdi, -0x40(%rbp)
leaq 0x7bd5b(%rip), %r15     # 0x16ae58
xorl %ebx, %ebx
movl (%r15), %ecx
testl %ecx, %ecx
je 0xef184
movl -0x4(%r15), %eax
testl %eax, %eax
setns %dl
cmpl %r14d, %ecx
setne %cl
testb %dl, %cl
jne 0xef184
movl -0x8(%r15), %edi
testl %edi, %edi
sete %cl
cmpl $0x64, %edi
setge %dl
orb %cl, %dl
jne 0xef139
movl %eax, %esi
movl %r14d, %edx
movl -0x2c(%rbp), %ecx
callq 0xdfd9e
testl %eax, %eax
jns 0xef17f
movq -0x38(%rbp), %rcx
leaq 0x3c378(%rip), %rdx     # 0x12b4c0
movzbl -0x1(%rcx,%rdx), %ecx
addl -0x40(%rbp), %ecx
movslq %ecx, %rcx
imulq $-0x6db6db6d, %rcx, %rdx # imm = 0x92492493
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %esi
shrl $0x1f, %esi
sarl $0x2, %edx
addl %esi, %edx
leal (,%rdx,8), %esi
subl %esi, %edx
addl %ecx, %edx
movzbl %dl, %ecx
cmpl %ecx, (%r15)
jne 0xef184
negl %eax
cmpl %r12d, %eax
je 0xef19c
incq %rbx
movslq (%r13), %rax
addq $0x18, %r15
cmpq %rax, %rbx
jl 0xef0ff
xorl %eax, %eax
jmp 0xef1a1
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq