LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x60, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movl %edi, -0x24(%rbp)
movsd -0x10(%rbp), %xmm0
movl -0x24(%rbp), %edi
callq 0x13cd20
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
movl -0x24(%rbp), %edi
callq 0x13cd20
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x13dd4a
jp 0x13dd4a
movsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd 0x31411(%rip), %xmm1    # 0x16f150
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x13dd89
movsd -0x20(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
divsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x134200
movsd %xmm0, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x1340f0
movaps %xmm0, %xmm1
movsd 0x4fd97(%rip), %xmm0    # 0x18eb18
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x302b1(%rip), %xmm1    # 0x16f068
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x96f0
movsd -0x30(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
mulsd %xmm2, %xmm1
movsd 0x3027b(%rip), %xmm2    # 0x16f068
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x4fd0e(%rip), %xmm0    # 0x18eb10
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
xorl %edi, %edi
callq 0x11dd00
leaq 0x22d674(%rip), %rax    # 0x36c884
cmpl $0x7e0, (%rax)          # imm = 0x7E0
jl 0x13f285
leaq 0x22d665(%rip), %rax    # 0x36c884
cmpl $0x834, (%rax)          # imm = 0x834
jge 0x13f285
leaq 0x22d656(%rip), %rax    # 0x36c884
movl (%rax), %eax
subl $0x7e0, %eax            # imm = 0x7E0
imull $0xc, %eax, %eax
movl %eax, -0x1c(%rbp)
movl $0x41b, -0x18(%rbp)     # imm = 0x41B
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x13f283
movsd -0x10(%rbp), %xmm1
movslq -0x14(%rbp), %rcx
leaq 0x8d720(%rip), %rax     # 0x1cc980
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x13f276
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x13f28c
jmp 0x13f278
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13f248
jmp 0x13f285
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 $0x50, %rsp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x13f1f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x13f34a
jmp 0x13f2c6
movsd -0x10(%rbp), %xmm0
movsd 0x4f0b5(%rip), %xmm1    # 0x18e388
subsd %xmm1, %xmm0
movsd 0x4f0a1(%rip), %xmm1    # 0x18e380
divsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm1
movsd 0x4f893(%rip), %xmm0    # 0x18eb88
mulsd %xmm0, %xmm1
movsd 0x4f88f(%rip), %xmm0    # 0x18eb90
addsd %xmm0, %xmm1
movsd 0x4f873(%rip), %xmm0    # 0x18eb80
mulsd -0x50(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x13f434
movl -0x14(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rcx
leaq 0x8d626(%rip), %rax     # 0x1cc980
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x8d60c(%rip), %rax     # 0x1cc980
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x14(%rbp), %eax
addl $0x0, %eax
movslq %eax, %rcx
leaq 0x8d5f2(%rip), %rax     # 0x1cc980
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x13f3da
jp 0x13f3da
jmp 0x13f2c6
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x13f3ef
jp 0x13f3ef
jmp 0x13f2c6
movsd -0x10(%rbp), %xmm0
movslq -0x14(%rbp), %rcx
leaq 0x8d581(%rip), %rax     # 0x1cc980
subsd (%rax,%rcx,8), %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
leaq 0x22c949(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
leaq 0x22c94e(%rip), %rax    # 0x36c1c0
movsd (%rax), %xmm1
callq 0x13cab0
movsd %xmm0, -0x40(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x96f0
movsd %xmm0, -0x60(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x96f0
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
callq 0x96f0
movsd %xmm0, -0x50(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x9080
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x9080
movsd -0x58(%rbp), %xmm1
movsd -0x50(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x48(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x9360
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq 0x15dc5e(%rip), %rax    # 0x29d570
cmpq $0x0, (%rax)
je 0x13f964
leaq 0x138185(%rip), %rax    # 0x277aa4
cmpb $0x0, (%rax)
je 0x13f964
leaq 0x15dc45(%rip), %rax    # 0x29d570
movq (%rax), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm3
movsd -0x28(%rbp), %xmm4
leaq 0x57e89(%rip), %rsi     # 0x1977d7
movb $0x5, %al
callq 0x9550
leaq 0x15dc14(%rip), %rax    # 0x29d570
movq (%rax), %rdi
callq 0x9430
movsd -0x28(%rbp), %xmm0
callq 0x7a910
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: 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 $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
callq 0x9080
movsd %xmm0, -0x60(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x96f0
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x96f0
movsd %xmm0, -0x40(%rbp)
leaq 0x22c7cf(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
callq 0x9080
movsd %xmm0, -0x48(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x9080
movsd %xmm0, -0x58(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x96f0
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
callq 0x96f0
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x40(%rbp), %xmm0
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x9050
movsd 0x2f5ff(%rip), %xmm1    # 0x16f078
mulsd %xmm1, %xmm0
movsd 0x31b43(%rip), %xmm1    # 0x1715c8
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x4309a(%rip), %xmm0    # 0x182b30
addsd -0x38(%rbp), %xmm0
movsd 0x4308d(%rip), %xmm1    # 0x182b30
callq 0x94d0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: propdelay(double, double, int)
static double propdelay(double dg, double h, int n)
{
double phi;
double theta;
double td;

     theta = dg / (earth_radius(lat,alt) * (double)(2 * n));
     phi = (PI/2.0) - atan((h / (earth_radius(lat,alt) * sin(theta))) + tan(theta/2));
     td = dg / (LIGHTSPEED * sin(phi));
     if(debug_file) {
         fprintf(debug_file, "propdelay dist %.9f height %.9f hops %d time %.9f\n",
                dg, h, n, td);
         fflush(debug_file);
     }
     return td;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movl %edi, -0x14(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
leaq 0x22c42a(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
leaq 0x22c42f(%rip), %rax    # 0x36c1c0
movsd (%rax), %xmm1
callq 0x13cab0
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
movl -0x14(%rbp), %eax
shll %eax
cvtsi2sd %eax, %xmm2
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
leaq 0x22c3e7(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
leaq 0x22c3ec(%rip), %rax    # 0x36c1c0
movsd (%rax), %xmm1
callq 0x13cab0
movsd %xmm0, -0x50(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x9080
movsd -0x50(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x48(%rbp), %xmm0
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x2f33d(%rip), %xmm1    # 0x16f150
divsd %xmm1, %xmm0
callq 0x91b0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x92e0
movaps %xmm0, %xmm1
movsd 0x4e478(%rip), %xmm0    # 0x18e2b0
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x9080
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
movsd 0x42dcb(%rip), %xmm1    # 0x182c30
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq 0x15d6f7(%rip), %rax    # 0x29d570
cmpq $0x0, (%rax)
je 0x13feb8
leaq 0x15d6ea(%rip), %rax    # 0x29d570
movq (%rax), %rdi
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movl -0x14(%rbp), %edx
movsd -0x30(%rbp), %xmm2
leaq 0x5900a(%rip), %rsi     # 0x198eac
movb $0x3, %al
callq 0x9550
leaq 0x15d6c0(%rip), %rax    # 0x29d570
movq (%rax), %rdi
callq 0x9430
movsd -0x30(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x9080
movsd %xmm0, 0x299e63(%rip)   # 0x3dade8
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x96f0
movsd %xmm0, 0x299e46(%rip)   # 0x3dade0
movsd 0x41bae(%rip), %xmm0    # 0x182b50
mulsd 0x299e3e(%rip), %xmm0   # 0x3dade8
movsd 0x299e36(%rip), %xmm1   # 0x3dade8
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm1, %xmm0
movsd 0x2e093(%rip), %xmm1    # 0x16f068
addsd %xmm1, %xmm0
movsd %xmm0, 0x299def(%rip)   # 0x3dadd0
movsd 0x299de7(%rip), %xmm0   # 0x3dadd0
callq 0x9280
movsd %xmm0, 0x299dd2(%rip)   # 0x3dadc8
movsd 0x41b4a(%rip), %xmm0    # 0x182b48
divsd 0x299dc2(%rip), %xmm0   # 0x3dadc8
movsd %xmm0, 0x299dca(%rip)   # 0x3dadd8
movsd 0x299dc2(%rip), %xmm0   # 0x3dadd8
movq -0x18(%rbp), %rax
addsd (%rax), %xmm0
mulsd 0x299dba(%rip), %xmm0   # 0x3dade0
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x96f0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd 0x299d84(%rip), %xmm0   # 0x3dadd8
movq -0x18(%rbp), %rax
addsd (%rax), %xmm0
mulsd 0x299d7c(%rip), %xmm0   # 0x3dade0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x9080
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd 0x299d46(%rip), %xmm0   # 0x3dadd8
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movsd 0x41a9e(%rip), %xmm2    # 0x182b40
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
mulsd 0x299d36(%rip), %xmm0   # 0x3dade8
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x9080
movsd %xmm0, 0x297d13(%rip)   # 0x3dae00
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x96f0
movsd %xmm0, 0x297cee(%rip)   # 0x3dadf0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x9080
movsd %xmm0, 0x297cf1(%rip)   # 0x3dae08
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x96f0
movsd %xmm0, 0x297ccc(%rip)   # 0x3dadf8
movsd 0x297ccc(%rip), %xmm0   # 0x3dae00
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd 0x297ca5(%rip), %xmm1   # 0x3dadf8
movq -0x30(%rbp), %rax
movsd (%rax), %xmm2
movsd 0x297c9d(%rip), %xmm0   # 0x3dae00
mulsd 0x297c9d(%rip), %xmm0   # 0x3dae08
movq 0x10(%rbp), %rax
mulsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x297c56(%rip), %xmm0   # 0x3dadf0
movq 0x18(%rbp), %rax
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd 0x297c4e(%rip), %xmm0   # 0x3dae08
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x30(%rbp), %rax
movsd (%rax), %xmm2
movsd 0x297c17(%rip), %xmm1   # 0x3dadf8
movq 0x10(%rbp), %rax
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd 0x297bef(%rip), %xmm1   # 0x3dadf0
mulsd 0x297bef(%rip), %xmm1   # 0x3dadf8
movq -0x30(%rbp), %rax
movsd (%rax), %xmm2
movsd 0x297bd7(%rip), %xmm0   # 0x3dadf0
mulsd 0x297be7(%rip), %xmm0   # 0x3dae08
movq 0x10(%rbp), %rax
mulsd (%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x297bc7(%rip), %xmm0   # 0x3dae00
movq 0x18(%rbp), %rax
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1432df
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x143420
cmpq $0x0, -0x18(%rbp)
jne 0x1432f2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x143420
cmpq $0x0, -0x20(%rbp)
jne 0x143305
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x143420
cmpq $0x0, -0x28(%rbp)
jne 0x143318
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x143420
cmpq $0x0, -0x30(%rbp)
jne 0x14332b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x143420
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
movsd (%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x9280
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x9280
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm2
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
mulsd 0x8(%rax), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: zero_vec8__(double*)
int zero_vec8__(double *v)
{
    /* initialize a vector (of length 3) to zero */
    /* Function Body */
    if(v == 0) return (-1); 

    v[0] = 0.;
    v[1] = 0.;
    v[2] = 0.;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x143448
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x143472
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x9080
movsd %xmm0, 0x29450f(%rip)   # 0x3dae18
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x96f0
movsd %xmm0, 0x2944f2(%rip)   # 0x3dae10
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd 0x2944da(%rip), %xmm0   # 0x3dae10
movq -0x18(%rbp), %rax
movsd (%rax), %xmm2
movsd 0x2944d2(%rip), %xmm1   # 0x3dae18
movq -0x20(%rbp), %rax
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movsd 0x2944aa(%rip), %xmm0   # 0x3dae10
movq -0x20(%rbp), %rax
movsd (%rax), %xmm2
movsd 0x2944a2(%rip), %xmm1   # 0x3dae18
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x9080
movsd %xmm0, 0x29427f(%rip)   # 0x3dae28
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x96f0
movsd %xmm0, 0x294262(%rip)   # 0x3dae20
movsd 0x29425a(%rip), %xmm0   # 0x3dae20
movq -0x10(%rbp), %rax
movsd (%rax), %xmm2
movsd 0x294252(%rip), %xmm1   # 0x3dae28
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd 0x29422a(%rip), %xmm0   # 0x3dae20
movq -0x18(%rbp), %rax
movsd (%rax), %xmm2
movsd 0x294222(%rip), %xmm1   # 0x3dae28
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x146cd3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x146df5
cmpq $0x0, -0x18(%rbp)
jne 0x146ce6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x146df5
cmpq $0x0, -0x20(%rbp)
jne 0x146cf9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x146df5
cmpq $0x0, -0x28(%rbp)
jne 0x146d0c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x146df5
cmpq $0x0, -0x30(%rbp)
jne 0x146d1f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x146df5
cmpq $0x0, -0x38(%rbp)
jne 0x146d32
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x146df5
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm2
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x29405e(%rip)   # 0x3dadc0
movsd 0x294056(%rip), %xmm1   # 0x3dadc0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x29402e(%rip)   # 0x3dadb8
movsd 0x29402e(%rip), %xmm0   # 0x3dadc0
callq 0x9280
movsd %xmm0, 0x294011(%rip)   # 0x3dadb0
movsd 0x294011(%rip), %xmm0   # 0x3dadb8
callq 0x9280
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
callq 0x9050
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x293fcf(%rip), %xmm1   # 0x3dadb0
callq 0x9050
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq 0x225394(%rip), %rax    # 0x36c1b0
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x146e30
jp 0x146e30
jmp 0x146ee3
leaq 0x225381(%rip), %rax    # 0x36c1b8
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x146e4b
jp 0x146e4b
jmp 0x146ee3
movsd -0x8(%rbp), %xmm0
movsd 0x28220(%rip), %xmm1    # 0x16f078
leaq 0x225351(%rip), %rax    # 0x36c1b0
mulsd (%rax), %xmm1
movsd 0x2a75d(%rip), %xmm2    # 0x1715c8
divsd %xmm2, %xmm1
movsd 0x28201(%rip), %xmm2    # 0x16f078
leaq 0x22533a(%rip), %rax    # 0x36c1b8
mulsd (%rax), %xmm2
movsd 0x2a73e(%rip), %xmm3    # 0x1715c8
divsd %xmm3, %xmm2
leaq 0x22532b(%rip), %rax    # 0x36c1c0
movsd (%rax), %xmm3
callq 0x13fed0
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
leaq 0x225a54(%rip), %rax    # 0x36c908
movl (%rax), %edx
xorl %esi, %esi
xorps %xmm0, %xmm0
movl %esi, %edi
callq 0x122210
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x140c60
leaq 0x22535e(%rip), %rax    # 0x36c238
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %edi
subl $0x244, %edi            # imm = 0x244
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x147700
leaq 0x224dc8(%rip), %rax    # 0x36c884
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x147acc
movl $0x244, -0x4(%rbp)      # imm = 0x244
jmp 0x147b29
movl -0x8(%rbp), %edi
subl $0x243, %edi            # imm = 0x243
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x147700
leaq 0x224d9d(%rip), %rax    # 0x36c884
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x147af7
movl $0x243, -0x4(%rbp)      # imm = 0x243
jmp 0x147b29
movl -0x8(%rbp), %edi
subl $0x242, %edi            # imm = 0x242
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x147700
leaq 0x224d72(%rip), %rax    # 0x36c884
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x147b22
movl $0x242, -0x4(%rbp)      # imm = 0x242
jmp 0x147b29
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jkingan[P]ladyheather/heathmsc.cpp
// Function: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
subl $0x242, %eax            # imm = 0x242
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x147bbc
movl -0xc(%rbp), %edi
movl $0x1, %edx
movl %edx, %esi
callq 0x147700
leaq 0x224d12(%rip), %rax    # 0x36c884
movl (%rax), %eax
leaq 0x224b85(%rip), %rcx    # 0x36c700
cmpl (%rcx), %eax
jge 0x147b81
jmp 0x147bbc
leaq 0x224cfc(%rip), %rax    # 0x36c884
movl (%rax), %eax
leaq 0x224b6f(%rip), %rcx    # 0x36c700
cmpl (%rcx), %eax
jne 0x147baf
leaq 0x224ce0(%rip), %rax    # 0x36c87c
cmpl $0x1, (%rax)
jne 0x147baf
leaq 0x224cd8(%rip), %rax    # 0x36c880
cmpl $0x1, (%rax)
jne 0x147baf
jmp 0x147bbc
jmp 0x147bb1
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x147b56
movl $0x0, -0x8(%rbp)
cmpl $0x23, -0x8(%rbp)
jg 0x147c59
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %eax
movl $0xc, %ecx
cltd
idivl %ecx
addl %eax, %edi
movl -0x8(%rbp), %eax
movl $0xc, %ecx
cltd
idivl %ecx
movl %edx, %esi
addl $0x1, %esi
movl $0x1, %edx
callq 0x147700
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl $0xc, %ecx
cltd
idivl %ecx
movl -0x10(%rbp), %edx
addl %eax, %edx
movslq -0x8(%rbp), %rcx
leaq 0x292728(%rip), %rax    # 0x3da340
movl %edx, (%rax,%rcx,4)
leaq 0x224c62(%rip), %rax    # 0x36c884
movl (%rax), %edi
leaq 0x224c51(%rip), %rax    # 0x36c87c
movl (%rax), %esi
leaq 0x224c4c(%rip), %rax    # 0x36c880
movl (%rax), %edx
callq 0x122140
movslq -0x8(%rbp), %rcx
leaq 0x2925ca(%rip), %rax    # 0x3da210
movsd %xmm0, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x147bc3
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
subl $0x1, %edi
movl $0xc, %esi
movl $0x18, %edx
callq 0x122140
movsd %xmm0, -0x10(%rbp)
leaq 0x1329a4(%rip), %rax    # 0x27a630
cvtsi2sdq (%rax), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xd, -0x14(%rbp)
jg 0x147ceb
movl -0x4(%rbp), %edx
movslq -0x14(%rbp), %rcx
leaq 0x29299a(%rip), %rax    # 0x3da650
movl %edx, (%rax,%rcx,4)
movsd -0x10(%rbp), %xmm0
movslq -0x14(%rbp), %rcx
leaq 0x2928e7(%rip), %rax    # 0x3da5b0
movsd %xmm0, (%rax,%rcx,8)
movsd 0x47382(%rip), %xmm0    # 0x18f058
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x147ca2
movl -0x4(%rbp), %edi
movl $0xc, %esi
movl $0x18, %edx
callq 0x122140
movsd %xmm0, 0x29291b(%rip)   # 0x3da620
leaq 0x132924(%rip), %rax    # 0x27a630
cvtsi2sdq (%rax), %xmm0
addsd 0x292907(%rip), %xmm0   # 0x3da620
movsd %xmm0, 0x2928ff(%rip)   # 0x3da620
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x29295b(%rip)    # 0x3da688
movsd 0x47323(%rip), %xmm0    # 0x18f058
addsd 0x2928e3(%rip), %xmm0   # 0x3da620
movsd %xmm0, 0x2928e3(%rip)   # 0x3da628
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, 0x29293b(%rip)    # 0x3da68c
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
subl $0x1, %edi
movl $0xc, %esi
movl $0x16, %edx
callq 0x122140
movsd %xmm0, 0x2921e8(%rip)   # 0x3da1a0
movsd 0x296c0(%rip), %xmm0    # 0x171680
addsd 0x2921d8(%rip), %xmm0   # 0x3da1a0
movsd %xmm0, 0x2921d8(%rip)   # 0x3da1a8
movsd 0x296a8(%rip), %xmm0    # 0x171680
addsd 0x2921c8(%rip), %xmm0   # 0x3da1a8
movsd %xmm0, 0x2921c8(%rip)   # 0x3da1b0
movsd 0x29690(%rip), %xmm0    # 0x171680
addsd 0x2921b8(%rip), %xmm0   # 0x3da1b0
movsd %xmm0, 0x2921b8(%rip)   # 0x3da1b8
movl -0x4(%rbp), %edi
subl $0x4f, %edi
addl $0x4e, %edi
callq 0x1328d0
cmpl $0x0, %eax
je 0x14802f
movsd 0x29219d(%rip), %xmm0   # 0x3da1b8
movsd 0x27045(%rip), %xmm1    # 0x16f068
subsd %xmm1, %xmm0
movsd %xmm0, 0x292189(%rip)   # 0x3da1b8
movsd 0x46791(%rip), %xmm0    # 0x18e7c8
addsd 0x292179(%rip), %xmm0   # 0x3da1b8
movsd %xmm0, 0x292179(%rip)   # 0x3da1c0
movsd 0x46779(%rip), %xmm0    # 0x18e7c8
addsd 0x292169(%rip), %xmm0   # 0x3da1c0
movsd %xmm0, 0x292169(%rip)   # 0x3da1c8
movsd 0x46761(%rip), %xmm0    # 0x18e7c8
addsd 0x292159(%rip), %xmm0   # 0x3da1c8
movsd %xmm0, 0x292159(%rip)   # 0x3da1d0
movsd 0x46749(%rip), %xmm0    # 0x18e7c8
addsd 0x292149(%rip), %xmm0   # 0x3da1d0
movsd %xmm0, 0x292149(%rip)   # 0x3da1d8
movsd 0x46731(%rip), %xmm0    # 0x18e7c8
addsd 0x292139(%rip), %xmm0   # 0x3da1d8
movsd %xmm0, 0x292139(%rip)   # 0x3da1e0
movsd 0x46719(%rip), %xmm0    # 0x18e7c8
addsd 0x292129(%rip), %xmm0   # 0x3da1e0
movsd %xmm0, 0x292129(%rip)   # 0x3da1e8
movsd 0x295b9(%rip), %xmm0    # 0x171680
addsd 0x292119(%rip), %xmm0   # 0x3da1e8
movsd %xmm0, 0x292119(%rip)   # 0x3da1f0
movsd 0x295a1(%rip), %xmm0    # 0x171680
addsd 0x292109(%rip), %xmm0   # 0x3da1f0
movsd %xmm0, 0x292109(%rip)   # 0x3da1f8
movsd 0x29589(%rip), %xmm0    # 0x171680
addsd 0x2920f9(%rip), %xmm0   # 0x3da1f8
movsd %xmm0, 0x2920f9(%rip)   # 0x3da200
movsd 0x29571(%rip), %xmm0    # 0x171680
addsd 0x2920e9(%rip), %xmm0   # 0x3da200
movsd %xmm0, 0x2920e9(%rip)   # 0x3da208
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x7da, -0x4(%rbp)      # imm = 0x7DA
jl 0x1482fd
cmpl $0x834, -0x4(%rbp)      # imm = 0x834
jle 0x1482ff
jmp 0x148342
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %edi
subl $0x1, %edi
movl -0x8(%rbp), %esi
callq 0x148130
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
addl $0x0, %edi
movl -0x8(%rbp), %esi
callq 0x148130
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
movl -0x8(%rbp), %esi
callq 0x148130
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0x132a50
movzbl %al, %eax
cmpl $0x6, %eax
jne 0x148388
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x1483a9
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0x132a50
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1483a7
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1483a9
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x45fae(%rip), %xmm1    # 0x18e388
subsd %xmm1, %xmm0
movsd 0x45f9a(%rip), %xmm1    # 0x18e380
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x17, -0xc(%rbp)
jg 0x148495
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x87133(%rip), %rax     # 0x1cf550
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x87118(%rip), %rax     # 0x1cf550
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm1
movslq -0xc(%rbp), %rcx
leaq 0x87101(%rip), %rax     # 0x1cf550
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x96f0
movsd -0x48(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1483fe
movsd -0x18(%rbp), %xmm0
movsd 0x46bce(%rip), %xmm1    # 0x18f070
mulsd %xmm1, %xmm0
movsd 0x46bca(%rip), %xmm1    # 0x18f078
addsd %xmm1, %xmm0
movsd 0x291d6(%rip), %xmm1    # 0x171690
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x96f0
movsd 0x46b93(%rip), %xmm1    # 0x18f068
mulsd %xmm1, %xmm0
movsd 0x26b87(%rip), %xmm1    # 0x16f068
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x26c5e(%rip), %xmm0    # 0x16f150
mulsd -0x28(%rbp), %xmm0
callq 0x96f0
movsd -0x50(%rbp), %xmm1
movsd 0x46b57(%rip), %xmm2    # 0x18f060
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x290fd(%rip), %xmm1    # 0x171620
mulsd -0x20(%rbp), %xmm1
divsd -0x38(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x131d53(%rip), %rax    # 0x27a5fb
cmpb $0x0, (%rax)
je 0x1488b9
movl $0x0, -0x4(%rbp)
jmp 0x1489eb
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x12f106(%rip), %rcx    # 0x2779d0
cmpl (%rcx), %eax
jge 0x1489e4
movslq -0x14(%rbp), %rcx
leaq 0x81583(%rip), %rax     # 0x1c9e60
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0x1488ef
jmp 0x1489d6
movslq -0x14(%rbp), %rcx
leaq 0x81566(%rip), %rax     # 0x1c9e60
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x14890f
jmp 0x148930
movl -0xc(%rbp), %eax
movslq -0x14(%rbp), %rdx
leaq 0x81543(%rip), %rcx     # 0x1c9e60
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
je 0x14892e
jmp 0x1489d6
jmp 0x148930
movslq -0x14(%rbp), %rcx
leaq 0x81525(%rip), %rax     # 0x1c9e60
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0x148983
movslq -0x14(%rbp), %rcx
leaq 0x8150e(%rip), %rax     # 0x1c9e60
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x64, (%rax)
jge 0x148983
movslq -0x14(%rbp), %rcx
leaq 0x814f7(%rip), %rax     # 0x1c9e60
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %edi
movl -0x1c(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x8(%rbp), %ecx
callq 0x132ae0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x1489c3
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x132a50
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movslq -0x14(%rbp), %rdx
leaq 0x814ad(%rip), %rcx     # 0x1c9e60
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
je 0x1489c1
jmp 0x1489d6
jmp 0x1489c3
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x1489cd
jmp 0x1489d6
movl $0x1, -0x4(%rbp)
jmp 0x1489eb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1488c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)