LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Mollweide::GetLat(double)
double Mollweide::GetLat(double y)
{
  // find t;
  double t = asin(y*a);
  m = 1/cos(t);
  return asin((t + 0.5 * sin(2 * t)) * twooverpi);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
mulsd 0xc8(%rdi), %xmm0
callq 0x42f0
movsd %xmm0, 0x18(%rsp)
callq 0x4370
movsd 0x412e(%rip), %xmm1     # 0xd048
divsd %xmm0, %xmm1
movsd %xmm1, 0xd0(%rbx)
movsd 0x18(%rsp), %xmm0
addsd %xmm0, %xmm0
callq 0x4070
mulsd 0x44eb(%rip), %xmm0     # 0xd428
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
fldt 0x45d1(%rip)            # 0xd520
fmull 0x28(%rsp)
fstpt (%rsp)
callq 0x42e0
fstpl 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Mollweide::GetXY(double, double, double&, double&) const
bool Mollweide::GetXY(double phi, double lambda, double& x, double& y) const
{
  bool result = false;
  MollweideEquation equation;
  equation.sinphi = sin(phi);
  double t = 0.0;
  if (equation.FindRoot(-pi/2, pi/2, 1e-5, t)) {
    y = sin(t)/a;
    x = lambda * cos(t);
    result = true;
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movsd %xmm1, 0x8(%rsp)
movq %rdi, %r15
leaq 0x9ad0(%rip), %rax      # 0x12a68
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
callq 0x4070
movsd %xmm0, 0x8(%r12)
movq %rsp, %rsi
movq $0x0, (%rsi)
movsd 0x4069(%rip), %xmm0     # 0xd028
movsd 0x4059(%rip), %xmm1     # 0xd020
movsd 0x44a9(%rip), %xmm2     # 0xd478
movq %r12, %rdi
callq 0xa21c
movl %eax, %ebp
testb %al, %al
je 0x9009
movsd (%rsp), %xmm0
callq 0x4070
divsd 0xc8(%r15), %xmm0
movsd %xmm0, (%r14)
movsd (%rsp), %xmm0
callq 0x4370
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Transform::AddLines(Image&, TransformParams const&) const
void Transform::AddLines (Image& image, const TransformParams& params) const
{
  CmdParams cmdparams;
  cmdparams.color = params.gridcolor;
  cmdparams.gridx = params.gridx;
  cmdparams.gridy = params.gridy;
  DrawGrid(image,params,cmdparams);
  //DrawDial(image,params,cmdparams);
}

// Assembly:
subq $0x28, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rcx
movups %xmm0, 0x10(%rcx)
movq $0x0, 0x20(%rcx)
movzwl 0xcc(%rdx), %eax
movw %ax, (%rcx)
movb 0xce(%rdx), %al
movb %al, 0x2(%rcx)
movq 0xc4(%rdx), %rax
movq %rax, 0x4(%rcx)
callq 0x9056
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Transform::DrawGrid(Image&, TransformParams const&, Transform::CmdParams const&) const
void Transform::DrawGrid (Image& image, 
			  const TransformParams& params,
			  const CmdParams &cmdparams) const
{
  int gridx = cmdparams.gridx;
  int gridy = cmdparams.gridy;
  int gridoff = cmdparams.gridoff;
  double loff = 2*pi*gridoff/360.0;
  int nx = 360/gridx;
  int ny = 180/gridy;
  for (int i = 0; i < nx; i++) {
    LatPlotter latplotter(image, params, *this);
    double lambda = (i - nx/2) * 2 * pi / nx + loff;
    latplotter.lambda = lambda;
    // Omit the last section of the lines of latitude.
    //image.PlotLine(-pi/2+radians(gridy), pi/2-radians(gridy), latplotter, cmdparams.color, 16);
    image.PlotLine(-pi/2, pi/2, latplotter, cmdparams.color, 16);
  }
  LongPlotter longplotter(image, params, *this);
  for (int i = 0; i <= ny; i++) {
    longplotter.phi = (i - ny/2) * pi / ny;
    image.PlotLine(-pi, pi, longplotter, cmdparams.color,16);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r12
movq %rsi, %r14
movl $0x168, %eax            # imm = 0x168
xorl %edx, %edx
idivl 0x4(%rcx)
movl %eax, %r15d
movq %rdi, %rbx
movl $0xb4, %eax
xorl %edx, %edx
movq %rcx, 0x8(%rsp)
idivl 0x8(%rcx)
movl %eax, %ebp
testl %r15d, %r15d
jle 0x914b
movq 0x8(%rsp), %rax
cvttsd2si 0x10(%rax), %eax
movl %eax, 0x20(%rsp)
fildl 0x20(%rsp)
fmull 0x3f8c(%rip)            # 0xd038
fdivs 0x448a(%rip)            # 0xd53c
fstpl 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
movl %r15d, 0x1c(%rsp)
fildl 0x1c(%rsp)
fstpt 0x24(%rsp)
movsd %xmm0, 0x58(%rsp)
fldl 0x58(%rsp)
fstpt 0x6c(%rsp)
movl %r15d, %r13d
andl $-0x2, %r13d
negl %r13d
movq %r14, 0x38(%rsp)
movq %r12, 0x40(%rsp)
movq %rbx, 0x48(%rsp)
leaq 0x99b1(%rip), %rax      # 0x12aa8
movq %rax, 0x30(%rsp)
movl %r13d, 0x18(%rsp)
fildl 0x18(%rsp)
fmull 0x3efd(%rip)            # 0xd008
fldt 0x24(%rsp)
fdivrp %st, %st(1)
fldt 0x6c(%rsp)
faddp %st, %st(1)
fstpl 0x50(%rsp)
movq %r14, %rdi
movsd 0x3f02(%rip), %xmm0     # 0xd028
movsd 0x3ef2(%rip), %xmm1     # 0xd020
leaq 0x30(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0x10, %ecx
callq 0xc5b8
addl $0x2, %r13d
decl %r15d
jne 0x90e1
movq %r14, 0x38(%rsp)
movq %r12, 0x40(%rsp)
movq %rbx, 0x48(%rsp)
leaq 0x99af(%rip), %rax      # 0x12b10
movq %rax, 0x30(%rsp)
testl %ebp, %ebp
movq 0x8(%rsp), %rbx
js 0x91ce
movl %ebp, %r12d
shrl %r12d
movl %ebp, 0x14(%rsp)
fildl 0x14(%rsp)
fstpt 0x24(%rsp)
incl %ebp
negl %r12d
leaq 0x30(%rsp), %r15
movl %r12d, 0x10(%rsp)
fildl 0x10(%rsp)
fmull 0x3e6e(%rip)            # 0xd008
fldt 0x24(%rsp)
fdivrp %st, %st(1)
fstpl 0x50(%rsp)
movq %r14, %rdi
movsd 0x3e81(%rip), %xmm0     # 0xd030
movsd 0x3e51(%rip), %xmm1     # 0xd008
movq %r15, %rsi
movq %rbx, %rdx
movl $0x10, %ecx
callq 0xc5b8
incl %r12d
decl %ebp
jne 0x918b
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Transform::DrawTemporaryHours(Image&, TransformParams const&, Transform::CmdParams const&) const
void Transform::DrawTemporaryHours(Image& image, 
				   const TransformParams& params,
				   const CmdParams &cmdparams) const
{
  TempPlotter tempplotter(image, params, *this);
  tempplotter.phi = cmdparams.dlat;
  tempplotter.lambda = cmdparams.dlon;
  for (int i = 6; i <= 18; i++) {
    tempplotter.time  = i;
    image.PlotLine(-inclination,+inclination,tempplotter,cmdparams.color,4);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rsi, %r14
leaq 0x10(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rdi, 0x18(%r15)
leaq 0x9566(%rip), %rax      # 0x12bd0
movq %rax, (%r15)
movups 0x18(%rcx), %xmm0
movups %xmm0, 0x28(%r15)
movsd 0x3e12(%rip), %xmm0     # 0xd490
movl $0xd, %ebp
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x30(%rsp)
movq %r14, %rdi
movsd 0x3dfe(%rip), %xmm0     # 0xd498
movsd 0x3dfe(%rip), %xmm1     # 0xd4a0
movq %r15, %rsi
movq %rbx, %rdx
movl $0x4, %ecx
callq 0xc5b8
movsd 0x8(%rsp), %xmm0
addsd 0x3988(%rip), %xmm0     # 0xd048
decl %ebp
jne 0x9683
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Transform::DrawLocalHours(Image&, TransformParams const&, Transform::CmdParams const&) const
void Transform::DrawLocalHours (Image& image, 
				const TransformParams& params,
				const CmdParams &cmdparams) const
{
  LatPlotter latplotter(image, params, *this);
  int nx = 24;
  for (int i = 0; i < nx; i++) {
    double lambda = (i - nx/2) * 2 * pi / nx + cmdparams.dlon;
    latplotter.lambda = lambda;
    // Omit the last section of the lines of latitude.
    image.PlotLine(-inclination, +inclination, latplotter, cmdparams.color, 4);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rsi, %r14
leaq 0x10(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rdi, 0x18(%r15)
leaq 0x93b0(%rip), %rax      # 0x12aa8
movq %rax, (%r15)
movl $0xffffffe8, %ebp       # imm = 0xFFFFFFE8
movl %ebp, 0xc(%rsp)
fildl 0xc(%rsp)
fmull 0x38fa(%rip)            # 0xd008
fdivs 0x3e2c(%rip)            # 0xd540
faddl 0x20(%rbx)
fstpl 0x30(%rsp)
movq %r14, %rdi
movsd 0x3d72(%rip), %xmm0     # 0xd498
movsd 0x3d72(%rip), %xmm1     # 0xd4a0
movq %r15, %rsi
movq %rbx, %rdx
movl $0x4, %ecx
callq 0xc5b8
addl $0x2, %ebp
cmpl $0x18, %ebp
jne 0x9700
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Transform::DrawAltitudes(Image&, TransformParams const&, Transform::CmdParams const&) const
void Transform::DrawAltitudes(Image& image, 
			 const TransformParams& params,
			 const CmdParams &cmdparams) const
{
  FooPlotter fooplotter(image,params,*this);
  fooplotter.lambda = cmdparams.dlon;
  fooplotter.phi = cmdparams.dlat;
  for (int i = 10; i <= 80; i += 10) {
    fooplotter.theta = radians(i);
    image.PlotLine(0,twopi,fooplotter,cmdparams.color,16);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rsi, %r14
leaq 0x10(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rdi, 0x18(%r15)
leaq 0x9416(%rip), %rax      # 0x12b90
movq %rax, (%r15)
movups 0x18(%rcx), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, 0x28(%r15)
flds 0x3db4(%rip)            # 0xd544
xorl %ebp, %ebp
fstpt 0x4(%rsp)
fldt 0x4(%rsp)
fmull 0x3868(%rip)            # 0xd008
fdivs 0x38c6(%rip)            # 0xd06c
fstpl 0x30(%rsp)
xorps %xmm0, %xmm0
movq %r14, %rdi
movsd 0x3880(%rip), %xmm1     # 0xd038
movq %r15, %rsi
movq %rbx, %rdx
movl $0x10, %ecx
callq 0xc5b8
fldt 0x4(%rsp)
fadds 0x3d72(%rip)            # 0xd544
addl $0xa, %ebp
cmpl $0x47, %ebp
jb 0x9792
fstp %st(0)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Transform::DrawAnalemma(Image&, TransformParams const&, Transform::CmdParams const&) const
void Transform::DrawAnalemma (Image& image, 
                              const TransformParams& params,
			      const CmdParams &cmdparams) const
{
  int gridx = cmdparams.gridx;
  AnalemmaPlotter analemmaplotter(image, params, *this);
  int nx = 360/gridx;
  for (int i = 0; i < nx; i++) {
    double time = 2 * pi * (i - nx/2) / nx;
    analemmaplotter.time = time;
    image.PlotLine(0, twopi, analemmaplotter, cmdparams.color,16);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %rcx
movl $0x168, %eax            # imm = 0x168
xorl %edx, %edx
idivl 0x4(%rbx)
movl %eax, %ebp
movq %rsi, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
leaq 0x9334(%rip), %rax      # 0x12b50
movq %rax, 0x18(%rsp)
testl %ebp, %ebp
jle 0x9880
movq %rsi, %r14
movl %ebp, %r12d
shrl %r12d
movl %ebp, 0x8(%rsp)
fildl 0x8(%rsp)
fstpt 0xc(%rsp)
negl %r12d
leaq 0x18(%rsp), %r15
movl %r12d, 0x4(%rsp)
fildl 0x4(%rsp)
fmull 0x37e7(%rip)            # 0xd038
fldt 0xc(%rsp)
fdivrp %st, %st(1)
fstpl 0x38(%rsp)
xorps %xmm0, %xmm0
movq %r14, %rdi
movsd 0x37cf(%rip), %xmm1     # 0xd038
movq %r15, %rsi
movq %rbx, %rdx
movl $0x10, %ecx
callq 0xc5b8
incl %r12d
decl %ebp
jne 0x9842
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Transform::DrawTropics(Image&, TransformParams const&, Transform::CmdParams const&) const
void Transform::DrawTropics(Image& image, 
			    const TransformParams& params,
			    const CmdParams &cmdparams) const
{
  LongPlotter longplotter(image, params, *this);
  longplotter.phi = inclination;
  image.PlotLine(-pi, pi, longplotter, cmdparams.color,16);
  longplotter.phi = -inclination;
  image.PlotLine(-pi, pi, longplotter, cmdparams.color,16);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rdi, 0x18(%r15)
leaq 0x925b(%rip), %rax      # 0x12b10
movq %rax, (%r15)
movabsq $0x3fda31a385e77b3a, %rax # imm = 0x3FDA31A385E77B3A
movq %rax, 0x20(%r15)
movsd 0x3762(%rip), %xmm0     # 0xd030
movsd 0x3732(%rip), %xmm1     # 0xd008
movq %rsi, %rdi
movq %r15, %rsi
movq %rcx, %rdx
movl $0x10, %ecx
callq 0xc5b8
movabsq $-0x4025ce5c7a1884c6, %rax # imm = 0xBFDA31A385E77B3A
movq %rax, 0x20(%r15)
movq %r14, %rdi
movsd 0x372e(%rip), %xmm0     # 0xd030
movsd 0x36fe(%rip), %xmm1     # 0xd008
movq %r15, %rsi
movq %rbx, %rdx
movl $0x10, %ecx
callq 0xc5b8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Transform::DrawArctics(Image&, TransformParams const&, Transform::CmdParams const&) const
void Transform::DrawArctics(Image& image, 
			    const TransformParams& params,
			    const CmdParams &cmdparams) const
{
  LongPlotter longplotter(image, params, *this);
  longplotter.phi = 0.5*pi-inclination;
  image.PlotLine(-pi, pi, longplotter, cmdparams.color,16);
  longplotter.phi = inclination-0.5*pi;
  image.PlotLine(-pi, pi, longplotter, cmdparams.color,16);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rdi, 0x18(%r15)
leaq 0x91c5(%rip), %rax      # 0x12b10
movq %rax, (%r15)
movabsq $0x3ff2959272ca4e4a, %rax # imm = 0x3FF2959272CA4E4A
movq %rax, 0x20(%r15)
movsd 0x36cc(%rip), %xmm0     # 0xd030
movsd 0x369c(%rip), %xmm1     # 0xd008
movq %rsi, %rdi
movq %r15, %rsi
movq %rcx, %rdx
movl $0x10, %ecx
callq 0xc5b8
movabsq $-0x400d6a6d8d35b1b6, %rax # imm = 0xBFF2959272CA4E4A
movq %rax, 0x20(%r15)
movq %r14, %rdi
movsd 0x3698(%rip), %xmm0     # 0xd030
movsd 0x3668(%rip), %xmm1     # 0xd008
movq %r15, %rsi
movq %rbx, %rdx
movl $0x10, %ecx
callq 0xc5b8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Transform::DrawDateline(Image&, TransformParams const&, Transform::CmdParams const&, double) const
void Transform::DrawDateline (Image& image, 
			      const TransformParams& params,
			      const CmdParams &cmdparams,
			      double day) const
{
  LongPlotter longplotter(image, params, *this);
  // Spring equinox is date 0, and is day 80 of a normal year.
  day = day - 80;
  while (day < 0) day += 365;
  while (day >= 365) day -= 365;
  double date = 2 * pi * day / 365;
  longplotter.phi = sundec(date);
  image.PlotLine(-pi, pi, longplotter, cmdparams.color,16);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x9133(%rip), %rax      # 0x12b10
addsd 0x3a2b(%rip), %xmm0     # 0xd410
movq %rax, 0x10(%rsp)
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9a06
movsd 0x3a1c(%rip), %xmm2     # 0xd418
addsd %xmm2, %xmm0
ucomisd %xmm0, %xmm1
ja 0x99fc
ucomisd 0x3a0a(%rip), %xmm0     # 0xd418
jb 0x9a2a
movsd 0x3a08(%rip), %xmm1     # 0xd420
movsd 0x39f8(%rip), %xmm2     # 0xd418
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
jae 0x9a20
movsd %xmm0, 0x8(%rsp)
fldl 0x8(%rsp)
fmull 0x35fe(%rip)            # 0xd038
fdivs 0x3af0(%rip)            # 0xd530
fstpl (%rsp)
movsd (%rsp), %xmm0
callq 0xa858
leaq 0x10(%rsp), %rsi
movsd %xmm0, 0x20(%rsi)
movsd 0x35d1(%rip), %xmm0     # 0xd030
movsd 0x35a1(%rip), %xmm1     # 0xd008
movq %r14, %rdi
movq %rbx, %rdx
movl $0x10, %ecx
callq 0xc5b8
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: Transform::DrawDatetime(Image&, TransformParams const&, Transform::CmdParams const&, double) const
void Transform::DrawDatetime (Image& image, 
			      const TransformParams& params,
			      const CmdParams &cmdparams,
			      double day) const
{
  LongPlotter longplotter(image, params, *this);
  // Spring equinox is day 0
  day = day - 80;
  while (day < 0) day += 365;
  while (day >= 365) day -= 365;
  double time = fmod(day, 1.0)-0.5; // Time relative to noon
  double date = 2 * pi * day / 365;
  double phi = sundec(date);
  double eot = equationoftime(date) / (24 * 60 * 60);
  double apparenttime = time + eot; // AT = MT + EOT
  double lambda = -(2 * pi * apparenttime);
  double x,y;
  MapXY(image, params, phi, lambda, x, y); 
  //fprintf(stderr,"%g %g %g %g %g %g\n", day, time,date,eot,phi,lambda);
  image.PlotPoint(x,y,1,cmdparams.color);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
addsd 0x3971(%rip), %xmm0     # 0xd410
movq %rdi, %r12
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x9abe
movsd 0x3964(%rip), %xmm1     # 0xd418
addsd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
ja 0x9ab4
ucomisd 0x3952(%rip), %xmm0     # 0xd418
jb 0x9ae2
movsd 0x3950(%rip), %xmm2     # 0xd420
movsd 0x3940(%rip), %xmm1     # 0xd418
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jae 0x9ad8
movsd %xmm0, (%rsp)
movsd 0x3559(%rip), %xmm1     # 0xd048
callq 0x4250
addsd 0x394c(%rip), %xmm0     # 0xd448
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
fldl 0x30(%rsp)
fmull 0x3521(%rip)            # 0xd038
fdivs 0x3a13(%rip)            # 0xd530
fstpl 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xa858
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0xa536
divsd 0x395e(%rip), %xmm0     # 0xd4a8
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
fldl 0x20(%rsp)
fmull 0x34b0(%rip)            # 0xd010
fstpl 0x18(%rsp)
movsd 0x18(%rsp), %xmm1
leaq 0x40(%rsp), %r13
leaq 0x38(%rsp), %rbp
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movsd (%rsp), %xmm0
movq %r13, %rcx
movq %rbp, %r8
callq 0x6e42
movsd (%r13), %xmm0
movsd (%rbp), %xmm1
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0xc4c4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/transform.cpp
// Function: FooPlotter::GetXY(double, double&, double&) const
bool GetXY(double t, double&x, double&y) const
  {
    // Angle up from the pole
    double x0 = cos(t)*cos(theta);
    double y0 = sin(t)*cos(theta);
    double z0 = sin(theta);
    // Now rotate about y axis
    double x1 = sin(phi)*x0 + cos(phi)*z0;
    double y1 = y0;
    double z1 = -cos(phi)*x0 + sin(phi)*z0;
    double phi0 = asin(z1);
    if (phi0 < -inclination || phi0 > inclination) {
      return false;
    } else {
      double lambda0 = atan2(y1,x1);
      return transform.MapXY(image, params, phi0, lambda0+lambda, x, y);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movsd %xmm0, 0x10(%rsp)
movq %rdi, %r15
callq 0x4370
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%r15), %xmm0
callq 0x4370
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4070
movsd %xmm0, 0x40(%rsp)
movsd 0x20(%r15), %xmm0
callq 0x4370
movsd %xmm0, 0x38(%rsp)
movsd 0x20(%r15), %xmm0
callq 0x4070
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%r15), %xmm0
callq 0x4070
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%r15), %xmm0
callq 0x4370
movsd %xmm0, 0x28(%rsp)
movsd 0x30(%r15), %xmm0
callq 0x4370
movsd %xmm0, 0x48(%rsp)
movsd 0x30(%r15), %xmm0
callq 0x4070
mulsd 0x10(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm0
callq 0x42f0
movapd 0x34a4(%rip), %xmm1     # 0xd510
andpd %xmm0, %xmm1
ucomisd 0x3428(%rip), %xmm1     # 0xd4a0
jbe 0xa086
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movsd 0x10(%rsp), %xmm2
mulsd 0x28(%rsp), %xmm2
movapd %xmm0, 0x10(%rsp)
movsd 0x30(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm2, %xmm1
movsd 0x40(%rsp), %xmm0
mulsd 0x38(%rsp), %xmm0
callq 0x4050
movapd %xmm0, %xmm1
movq 0x18(%r15), %rdi
movq 0x8(%r15), %rsi
addsd 0x28(%r15), %xmm1
movq 0x10(%r15), %rdx
movaps 0x10(%rsp), %xmm0
movq %r14, %rcx
movq %rbx, %r8
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x6e42
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/equations.cpp
// Function: Equation::FindRoot(double, double, double, double&) const
bool Equation::FindRoot (double t0, double t1, double epsilon, double& t) const
{
  bool result = false;
  double p0 = (*this)(t0);
  double p1 = (*this)(t1);
  if (p0 > p1) {
    double temp;
    temp = t0; t0 = t1; t1 = temp;
    temp = p0; p0 = p1; p1 = temp;
  };
  if (p0 > 0 || p1 < 0) {
    fprintf(stderr, "No root for %f %f %f %f\n", t0, t1, p0, p1);
  } else {
    while (t1 - t0 > epsilon) {
      double t2 = (t0 + t1) / 2.0;
      double p2 = (*this)(t2);
      if (p2 <= 0.0) {
	t0 = t2;
      } else {
	t1 = t2;
      }
    }
    t = t0;
    result = true;
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movsd %xmm2, 0x8(%rsp)
movsd %xmm1, (%rsp)
movq %rdi, %r14
movq (%rdi), %rax
movsd %xmm0, 0x10(%rsp)
callq *(%rax)
movaps %xmm0, 0x20(%rsp)
movq (%r14), %rax
movq %r14, %rdi
movsd (%rsp), %xmm0
callq *(%rax)
movapd 0x20(%rsp), %xmm3
ucomisd %xmm0, %xmm3
jbe 0xa26f
movapd %xmm0, %xmm2
movsd 0x10(%rsp), %xmm1
movsd (%rsp), %xmm5
jmp 0xa282
movapd %xmm3, %xmm2
movapd %xmm0, %xmm3
movsd (%rsp), %xmm1
movsd 0x10(%rsp), %xmm5
xorpd %xmm0, %xmm0
movapd %xmm3, %xmm4
cmpnltpd %xmm0, %xmm4
cmpnltpd %xmm2, %xmm0
andpd %xmm4, %xmm0
movd %xmm0, %ebp
testb $0x1, %bpl
je 0xa332
movapd %xmm1, %xmm0
subsd %xmm5, %xmm0
ucomisd 0x8(%rsp), %xmm0
jbe 0xa31f
movsd %xmm5, (%rsp)
movapd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
addsd %xmm5, %xmm0
mulsd 0x3157(%rip), %xmm0     # 0xd428
movapd %xmm0, 0x20(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movapd 0x20(%rsp), %xmm2
xorpd %xmm1, %xmm1
movsd (%rsp), %xmm5
ucomisd %xmm0, %xmm1
jb 0xa2f8
movapd %xmm2, %xmm5
cmpnlesd %xmm1, %xmm0
andpd %xmm0, %xmm2
andnpd 0x10(%rsp), %xmm0
orpd %xmm2, %xmm0
movapd %xmm0, %xmm1
subsd %xmm5, %xmm1
ucomisd 0x8(%rsp), %xmm1
movapd %xmm0, %xmm1
ja 0xa2b6
movsd %xmm5, (%rbx)
andb $0x1, %bpl
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8ca7(%rip), %rax      # 0x12fe0
movq (%rax), %rdi
leaq 0x3595(%rip), %rsi      # 0xd8d8
movapd %xmm5, %xmm0
movb $0x4, %al
callq 0x4280
jmp 0xa323
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/equations.cpp
// Function: perihelionangle(double)
double perihelionangle (double m)
{
  double e = eccentricity;
  double r = m + 2*e*sin(m) + 5*sqr(e)*sin(2*m)/4 + 
             cube(e)*(-sin(m)/4 + 13*sin(3*m)/12);
  return r;
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x4070
movapd %xmm0, %xmm1
mulsd 0x34a5(%rip), %xmm1     # 0xd810
movsd 0x8(%rsp), %xmm0
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
addsd %xmm0, %xmm0
callq 0x4070
mulsd 0x348d(%rip), %xmm0     # 0xd818
mulsd 0x348d(%rip), %xmm0     # 0xd820
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4070
mulsd 0x3470(%rip), %xmm0     # 0xd820
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x3464(%rip), %xmm0     # 0xd828
callq 0x4070
mulsd 0x345f(%rip), %xmm0     # 0xd830
divsd 0x345f(%rip), %xmm0     # 0xd838
subsd 0x10(%rsp), %xmm0
mulsd 0x3459(%rip), %xmm0     # 0xd840
addsd (%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/equations.cpp
// Function: getperiheliontime()
double getperiheliontime ()
{
  double theta0 = 0;
  double theta1 = 2 * pi;
  double epsilon = 1e-8;
  while (theta1 - theta0 > epsilon) {
    double theta2 = (theta0 + theta1) / 2.0;
    double p = perihelionangle(theta2) - equinoxangle;
    if (p <= 0.0) {
      theta0 = theta2;
    } else {
      theta1 = theta2;
    }
  }
  printf ("Perihelion time: %f\n", -theta1);
  return -theta1;
}

// Assembly:
subq $0x48, %rsp
movsd 0x2c3b(%rip), %xmm1     # 0xd038
xorpd %xmm2, %xmm2
movsd %xmm2, 0x28(%rsp)
movapd %xmm1, 0x30(%rsp)
movapd %xmm1, %xmm0
addsd %xmm2, %xmm0
mulsd 0x300b(%rip), %xmm0     # 0xd428
movapd %xmm0, 0x10(%rsp)
callq 0x4070
movapd %xmm0, %xmm1
mulsd 0x33dc(%rip), %xmm1     # 0xd810
movapd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
addsd %xmm0, %xmm0
callq 0x4070
movapd %xmm0, %xmm1
mulsd 0x33bf(%rip), %xmm1     # 0xd818
movsd 0x33bf(%rip), %xmm0     # 0xd820
mulsd %xmm0, %xmm1
addsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movapd 0x10(%rsp), %xmm0
callq 0x4070
mulsd 0x339c(%rip), %xmm0     # 0xd820
movsd %xmm0, 0x20(%rsp)
movapd 0x10(%rsp), %xmm0
mulsd 0x3390(%rip), %xmm0     # 0xd828
callq 0x4070
movapd 0x10(%rsp), %xmm3
movsd 0x28(%rsp), %xmm2
xorpd %xmm1, %xmm1
mulsd 0x337b(%rip), %xmm0     # 0xd830
divsd 0x337b(%rip), %xmm0     # 0xd838
subsd 0x20(%rsp), %xmm0
mulsd 0x3375(%rip), %xmm0     # 0xd840
addsd 0x8(%rsp), %xmm0
addsd 0x336f(%rip), %xmm0     # 0xd848
ucomisd %xmm0, %xmm1
jb 0xa4e3
movapd %xmm3, %xmm2
cmpnlesd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd 0x30(%rsp), %xmm0
orpd %xmm3, %xmm0
movapd %xmm0, %xmm1
subsd %xmm2, %xmm0
ucomisd 0x334a(%rip), %xmm0     # 0xd850
ja 0xa401
movapd 0x2b5c(%rip), %xmm0     # 0xd070
xorpd %xmm1, %xmm0
movapd %xmm0, 0x10(%rsp)
leaq 0x33cc(%rip), %rdi      # 0xd8f1
movb $0x1, %al
callq 0x4040
movaps 0x10(%rsp), %xmm0
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/equations.cpp
// Function: equationoftime(double)
double equationoftime(double date)
{
  double p = perihelion;
  double m = date - periheliontime;
  double s = 
    -591.7 * sin(2 * (m+p))
    -459.6 * sin(m) +
     +19.8 * sin(m + 2 * p)
     -19.8 * sin(3 * m + 2 * p)
     -12.8 * sin(4 * (m + p))
      -4.8 * sin(2 * m)
      +0.9 * sin(3 * m + 4 * p)
      -0.9 * sin(5 * m + 4 * p)
      -0.5 * sin(4 * m + 2 * p)
      -0.4 * sin(6 * (m + p));
    
  // fprintf(stderr, "EOT: %f\n", s / 60.0);
  return s; // seconds
}

// Assembly:
subq $0x28, %rsp
movapd %xmm0, %xmm1
addsd 0x3312(%rip), %xmm1     # 0xd858
movsd %xmm1, 0x10(%rsp)
movsd 0x330c(%rip), %xmm0     # 0xd860
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
addsd %xmm0, %xmm0
callq 0x4070
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4070
mulsd 0x32e8(%rip), %xmm0     # 0xd868
movsd 0x8(%rsp), %xmm1
mulsd 0x32e2(%rip), %xmm1     # 0xd870
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x32d2(%rip), %xmm0     # 0xd878
callq 0x4070
mulsd 0x32cd(%rip), %xmm0     # 0xd880
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x3261(%rip), %xmm0     # 0xd828
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
addsd 0x329d(%rip), %xmm0     # 0xd878
callq 0x4070
mulsd 0x32a0(%rip), %xmm0     # 0xd888
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
mulsd 0x2e7e(%rip), %xmm0     # 0xd480
callq 0x4070
mulsd 0x3281(%rip), %xmm0     # 0xd890
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm0
callq 0x4070
mulsd 0x3266(%rip), %xmm0     # 0xd898
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
addsd 0x3254(%rip), %xmm0     # 0xd8a0
callq 0x4070
mulsd 0x324f(%rip), %xmm0     # 0xd8a8
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x3243(%rip), %xmm0     # 0xd8b0
mulsd 0x10(%rsp), %xmm0
addsd 0x3225(%rip), %xmm0     # 0xd8a0
callq 0x4070
mulsd 0x3230(%rip), %xmm0     # 0xd8b8
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0x2dde(%rip), %xmm0     # 0xd480
addsd 0x31ce(%rip), %xmm0     # 0xd878
callq 0x4070
mulsd 0x2d91(%rip), %xmm0     # 0xd448
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
mulsd 0x2dbf(%rip), %xmm0     # 0xd490
callq 0x4070
mulsd 0x31e2(%rip), %xmm0     # 0xd8c0
addsd 0x10(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/equations.cpp
// Function: sunangle(double)
double sunangle (double date)
{
  // Date is measured from vernal equinox
  // Need time from perihelion to equinox

  // Add the time from the perihelion and equinox
  double t = date - periheliontime;
  // r is the angle of the sun, from the perihelion
  double r = perihelionangle(t);
  // So subtract the angle between perihelion and equinox
  return r - equinoxangle;
}

// Assembly:
subq $0x18, %rsp
addsd 0x3163(%rip), %xmm0     # 0xd858
movsd %xmm0, 0x8(%rsp)
callq 0x4070
movapd %xmm0, %xmm1
mulsd 0x3104(%rip), %xmm1     # 0xd810
movsd 0x8(%rsp), %xmm0
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
addsd %xmm0, %xmm0
callq 0x4070
mulsd 0x30ec(%rip), %xmm0     # 0xd818
mulsd 0x30ec(%rip), %xmm0     # 0xd820
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4070
mulsd 0x30cf(%rip), %xmm0     # 0xd820
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x30c3(%rip), %xmm0     # 0xd828
callq 0x4070
mulsd 0x30be(%rip), %xmm0     # 0xd830
divsd 0x30be(%rip), %xmm0     # 0xd838
subsd 0x10(%rsp), %xmm0
mulsd 0x30b8(%rip), %xmm0     # 0xd840
addsd (%rsp), %xmm0
addsd 0x30b3(%rip), %xmm0     # 0xd848
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/equations.cpp
// Function: sunaltitude(double, double, double)
double sunaltitude (double date, double phi, double time)
{
  // Compute altitude of sun at the given date and time,
  // on the zero meridian at latitude phi
  double delta = asin(sunheight(date)); // Declination of the sun

  // Rotate lat = phi, long = 0 round by time
  // Find x,y,z coords on the sphere - no need to use an ellipsoid, as the
  // tangents at a location are the same.
  double x = cos(time) * cos(phi);
  double y = sin(time) * cos(phi);
  double z = sin(phi);

  // The sun vector - the sun is at -x
  double sunx = -cos(delta);
  double suny = 0;
  double sunz = sin(delta);

  // Dot product to get angle to normal
  double alt = pi/2.0 - acos(x * sunx + y * suny + z * sunz);
  return alt;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm2, 0x8(%rsp)
movsd %xmm1, 0x18(%rsp)
addsd 0x2f26(%rip), %xmm0     # 0xd858
movsd %xmm0, 0x10(%rsp)
callq 0x4070
movapd %xmm0, %xmm1
mulsd 0x2ec7(%rip), %xmm1     # 0xd810
movsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
addsd %xmm0, %xmm0
callq 0x4070
mulsd 0x2eaf(%rip), %xmm0     # 0xd818
mulsd 0x2eaf(%rip), %xmm0     # 0xd820
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4070
mulsd 0x2e92(%rip), %xmm0     # 0xd820
movsd %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0x2e86(%rip), %xmm0     # 0xd828
callq 0x4070
mulsd 0x2e81(%rip), %xmm0     # 0xd830
divsd 0x2e81(%rip), %xmm0     # 0xd838
subsd 0x20(%rsp), %xmm0
mulsd 0x2e7b(%rip), %xmm0     # 0xd840
addsd (%rsp), %xmm0
addsd 0x2e76(%rip), %xmm0     # 0xd848
callq 0x4070
mulsd 0x2ee9(%rip), %xmm0     # 0xd8c8
callq 0x42f0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4370
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x4370
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4070
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x4370
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x4070
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4370
movsd %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4070
xorpd %xmm1, %xmm1
mulsd 0x8(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
mulsd (%rsp), %xmm2
subsd %xmm2, %xmm1
mulsd 0x18(%rsp), %xmm0
addsd %xmm1, %xmm0
callq 0x41e0
movsd %xmm0, 0x30(%rsp)
fldl 0x2588(%rip)            # 0xd020
fsubl 0x30(%rsp)
fstpl 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/equations.cpp
// Function: sunrise(double, double)
double sunrise (double date, double phi)
{
  double t0 = 0;
  double t1 = pi;
  double epsilon = 1e-6;
  while (t1 - t0 > epsilon) {
    double t = (t1 + t0) / 2.0;
    double h = sunaltitude(date + t/daysinyear, phi, t);
    //printf ("%f %f %f %f\n", t0, t1, t, h);
    if (h < sunriseangle) {
      t0 = t;
    } else {
      t1 = t;
    }
  }
  return t0;
}

// Assembly:
subq $0x48, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movsd 0x2545(%rip), %xmm2     # 0xd008
xorpd %xmm1, %xmm1
movapd %xmm2, 0x30(%rsp)
movsd %xmm1, 0x18(%rsp)
addsd %xmm1, %xmm2
mulsd 0x2949(%rip), %xmm2     # 0xd428
movapd %xmm2, %xmm0
movapd %xmm2, 0x20(%rsp)
divsd 0x2ddf(%rip), %xmm0     # 0xd8d0
addsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0xa91a
movapd 0x20(%rsp), %xmm3
movsd 0x2920(%rip), %xmm2     # 0xd430
movapd %xmm0, %xmm1
ucomisd %xmm0, %xmm2
movapd %xmm3, %xmm0
ja 0xab24
movsd 0x18(%rsp), %xmm0
cmpltsd %xmm2, %xmm1
movapd 0x30(%rsp), %xmm2
andpd %xmm1, %xmm2
andnpd %xmm3, %xmm1
orpd %xmm1, %xmm2
movapd %xmm2, %xmm1
subsd %xmm0, %xmm1
ucomisd 0x2925(%rip), %xmm1     # 0xd470
movapd %xmm0, %xmm1
ja 0xaac7
addq $0x48, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/utils.cpp
// Function: StringSpec::ReadOpt(int&, char**&)
int StringSpec::ReadOpt(int &argc, char** &argv) {
  if (strcmp(argv[0], optstring) != 0) {
    return 0;
  } else {
    argc--; argv++;
    if (argc == 0) {
      fprintf(stderr,"Need a parameter for %s\n", optstring);
      return -1;
    } else {
      value = argv[0];
      return 1;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %r12
movq (%r12), %rdi
movq 0x8(%rbx), %rsi
callq 0x4260
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xac8d
addq $0x8, %r12
decl (%r15)
movq %r12, (%r14)
je 0xac99
movq (%r12), %rax
movq 0x10(%rbx), %rcx
movq %rax, (%rcx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4406
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xac8d
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/utils.cpp
// Function: IntSpec::ReadOpt(int&, char**&)
int IntSpec::ReadOpt(int &argc, char** &argv) {
  if (strcmp(argv[0], optstring) != 0) {
    return 0;
  } else {
    argc--; argv++;
    if (argc == 0) {
      fprintf(stderr,"Need a parameter for %s\n", optstring);
      return -1;
    } else {
      // Should do some error checking here
      value = strtol(argv[0],NULL,0);
      return 1;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %r12
movq (%r12), %rdi
movq 0x8(%rbx), %rsi
callq 0x4260
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xad0d
addq $0x8, %r12
decl (%r15)
movq %r12, (%r14)
je 0xad19
movq (%r12), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4270
movq 0x10(%rbx), %rcx
movl %eax, (%rcx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4424
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xad0d
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/utils.cpp
// Function: DoubleSpec::ReadOpt(int&, char**&)
int DoubleSpec::ReadOpt(int &argc, char** &argv) {
  if (strcmp(argv[0], optstring) != 0) {
    return 0;
  } else {
    argc--; argv++;
    if (argc == 0) {
      fprintf(stderr,"Need a parameter for %s\n", optstring);
      return -1;
    } else {
      // Should do some error checking here
      value = conversion * strtod(argv[0], NULL);
      return 1;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %r12
movq (%r12), %rdi
movq 0x8(%rbx), %rsi
callq 0x4260
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xada0
addq $0x8, %r12
decl (%r15)
movq %r12, (%r14)
je 0xadac
movsd 0x18(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq (%r12), %rdi
xorl %esi, %esi
callq 0x4160
mulsd (%rsp), %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4442
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xada0
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/utils.cpp
// Function: CmdSpec::ReadOpt(int&, char**&)
int CmdSpec::ReadOpt(int &argc, char** &argv) {
  if (strcmp(argv[0], optstring) != 0) {
    return 0;
  } else {
    vector<string>cmd;
    // Skip the initial '-'
    assert(*argv[0] == '-');
    cmd.push_back(argv[0]+1);
    for (int i = 0; i < nargs; i++){
      argc--;argv++;
      if (argc == 0) {
	fprintf(stderr,"Need %d parameter for %s\n", nargs, optstring);
	return -1;
      } else {
	cmd.push_back(argv[0]);
      }
    }
    cmdlist.push_back(cmd);
    return 1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rax
movq (%rax), %r12
movq 0x8(%rdi), %rsi
movq %r12, %rdi
callq 0x4260
xorl %ebp, %ebp
testl %eax, %eax
jne 0xaefd
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
cmpb $0x2d, (%r12)
jne 0xaf34
leaq 0x1(%r12), %r13
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, %rdi
callq 0x40d0
leaq (%r12,%rax), %rdx
incq %rdx
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0xb38e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xb11e
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xae76
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4220
cmpl $0x0, 0x10(%rbx)
jle 0xaedd
xorl %r13d, %r13d
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %rbp
decl (%r15)
setne %cl
movq (%r14), %rax
addq $0x8, %rax
movq %rax, (%r14)
testb %cl, %cl
je 0xaf0e
movq (%rax), %rsi
movq %r12, %rdi
leaq 0xf(%rsp), %rdx
callq 0xafd8
movq %rbp, %rdi
movq %r12, %rsi
callq 0xb11e
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xaed4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4220
incl %r13d
cmpl 0x10(%rbx), %r13d
jl 0xae89
movl $0x1, %ebp
leaq 0x833f(%rip), %rdi      # 0x13228
leaq 0x30(%rsp), %rsi
callq 0xb016
leaq 0x30(%rsp), %rdi
callq 0xb042
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x80cb(%rip), %rax      # 0x12fe0
movq (%rax), %rdi
movl 0x10(%rbx), %edx
movq 0x8(%rbx), %rcx
leaq 0x2a64(%rip), %rsi      # 0xd98a
xorl %eax, %eax
callq 0x4280
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0xaef3
leaq 0x2a07(%rip), %rdi      # 0xd942
leaq 0x2a10(%rip), %rsi      # 0xd952
leaq 0x2a13(%rip), %rcx      # 0xd95c
movl $0x80, %edx
callq 0x4120
jmp 0xaf7a
jmp 0xaf59
jmp 0xaf7a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xaf7d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4220
jmp 0xaf7d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xb042
movq %rbx, %rdi
callq 0x4330
nop
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/image.cpp
// Function: RgbSpec::ReadOpt(int&, char**&)
int RgbSpec::ReadOpt(int &argc, char** &argv) {
  if (strcmp(argv[0], optstring) != 0) {
    return 0;
  } else {
    argc--; argv++;
    if (argc == 0) {
      fprintf(stderr,"Need a parameter for %s\n", optstring);
      return -1;
    } else {
      value = Rgb(argv[0]);
      return 1;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %r12
movq (%r12), %rdi
movq 0x8(%rbx), %rsi
callq 0x4260
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xb9d9
addq $0x8, %r12
decl (%r15)
movq %r12, (%r14)
je 0xb9e5
movq (%r12), %rsi
leaq 0x5(%rsp), %r14
movq %r14, %rdi
callq 0xb734
movq 0x10(%rbx), %rax
movb 0x2(%r14), %cl
movb %cl, 0x2(%rax)
movzwl (%r14), %ecx
movw %cx, (%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x448b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xb9d9
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/image.cpp
// Function: Image::Close()
void Image::Close()
{
  if (mmapdata != NULL) {
    if (munmap(mmapdata, mmapsize)) {
      syserror("Error unmapping input file");
    }
    close(mmapfd);
    mmapdata = NULL;
    mmapsize = 0;
    mmapfd = 0;
    data = NULL;
  } else if (data != NULL) {
    delete (data);
    data = NULL;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xba97
movq 0x20(%rbx), %rsi
callq 0x4110
testl %eax, %eax
je 0xba82
leaq 0x2046(%rip), %rdi      # 0xdac3
callq 0xab82
movl 0x28(%rbx), %edi
callq 0x4390
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x1c(%rbx)
jmp 0xbab2
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xbab2
movl $0x1, %esi
callq 0x4220
movq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/image.cpp
// Function: Image::Copy(Image const&)
void Image::Copy (const Image& image) {
  if (data == NULL) {
    width = image.width;
    height = image.height;
    data = new char[(long) width * height * 3];
    memcpy(data, image.data,(long) width * height * 3);
  } else {
    for (long y = 0; y < height && y < image.height; y++) {
      for (long x = 0; x < width && x < image.width; x++) {
	Rgb rgb;
	image.GetRgb(x,y,rgb);
	SetRgb(x,y,rgb);
      }
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0xbb6a
movq 0x8(%r14), %rdi
testq %rdi, %rdi
setg %al
movq 0x8(%rbx), %r8
testq %r8, %r8
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xbb64
movq (%r14), %rcx
movq (%rbx), %rsi
xorl %eax, %eax
xorl %edx, %edx
testq %rcx, %rcx
setg %r9b
testq %rsi, %rsi
setg %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0xbb53
movl $0x1, %edi
xorl %r8d, %r8d
imulq %rax, %rsi
addq 0x10(%rbx), %rsi
movzwl -0x1(%rdi,%rsi), %r9d
movb 0x1(%rdi,%rsi), %sil
imulq %rax, %rcx
addq 0x10(%r14), %rcx
movw %r9w, -0x1(%rdi,%rcx)
movb %sil, 0x1(%rdi,%rcx)
incq %r8
movq (%r14), %rcx
movq (%rbx), %rsi
cmpq %rcx, %r8
jge 0xbb4b
addq $0x3, %rdi
cmpq %rsi, %r8
jl 0xbb0e
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %r8
incq %rdx
cmpq %rdi, %rdx
jge 0xbb64
addq $0x3, %rax
cmpq %r8, %rdx
jl 0xbaef
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
imulq %rcx, %rax
leaq (%rax,%rax,2), %r15
movq %r15, %rdi
callq 0x4030
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x41a0
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/image.cpp
// Function: GetLine(char*&, char*, char*, int)
static void GetLine (char* &dataptr, char* dataend, 
	      char* linebuffer, int length)
{
  do {
    int i = 0;
    if (dataptr == dataend) {
      error("Unexpected end of file\n");
    }
    while (dataptr < dataend && i <length-1) {
      char c = *dataptr;
      dataptr++;
      if (c == '\n') {
	break;
      }
      linebuffer[i] = c;
      i++;
    }
    linebuffer[i] = 0;
  } while (linebuffer[0] == '#' || linebuffer[0] == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1e6f(%rip), %r12      # 0xdc13
movq (%r15), %rax
cmpq %r14, %rax
jne 0xbdb7
movq %r12, %rdi
callq 0xab5c
movq (%r15), %rax
cmpq %r14, %rax
jae 0xbde5
xorl %ecx, %ecx
movb (%rax), %dl
incq %rax
movq %rax, (%r15)
cmpb $0xa, %dl
je 0xbde9
movb %dl, (%rbx,%rcx)
leaq 0x1(%rcx), %rdx
movq (%r15), %rax
cmpq %r14, %rax
jae 0xbdec
cmpq $0x7e, %rcx
movq %rdx, %rcx
jb 0xbdbe
jmp 0xbdec
xorl %eax, %eax
jmp 0xbdee
movq %rcx, %rdx
movl %edx, %eax
movb $0x0, (%rbx,%rax)
movzbl (%rbx), %eax
testl %eax, %eax
je 0xbda4
cmpl $0x23, %eax
je 0xbda4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/image.cpp
// Function: Image::Write(char const*) const
void Image::Write (const char* filename) const
{
  if (mmapdata != NULL) {
    fprintf(stderr, "mmapped image - skipping WriteImage\n");
  } else {
    int fd = 1; // stdout
    char header[128];
    size_t datasize;
    if (filename != NULL) {
      fd = creat(filename, 0666);
      if (fd < 0) {
	syserror("Can't open output file");
      }
    }
#if defined O_BINARY
    // Ghastly hack to ensure CR/LF substitution not done, eg. on cygwin
    // Set the output type to binary, not text.
    setmode(fd,O_BINARY);
#endif
    sprintf(header, "P6\n%ld %ld\n255\n", width, height);
    if (write(fd, header, strlen(header)) < 0) {
      syserror("write failed");
    }
    datasize = (long) width * height * 3;
    char *dataptr = data;
    while (datasize > 0) {
      size_t MAXDATA = 64UL*1024*1024;
      ssize_t written = write(fd, dataptr, std::min(MAXDATA,datasize));
      fprintf(stderr,"%zd bytes written\n", written);
      if (written < 0) {
	syserror("write failed");
      }
      datasize -= written;
      dataptr += written;
    }
    if (filename != NULL) {
      close(fd);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
cmpq $0x0, 0x18(%rdi)
jne 0xbebf
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xbe4e
movq %rbx, %rdi
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x4130
movl %eax, %ebp
testl %eax, %eax
jns 0xbe53
leaq 0x1d47(%rip), %rdi      # 0xdb8e
callq 0xab82
jmp 0xbe53
movl $0x1, %ebp
movq (%r14), %rdx
movq 0x8(%r14), %rcx
leaq 0x1d44(%rip), %rsi      # 0xdba5
movq %rsp, %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x4060
movq %r15, %rdi
callq 0x40d0
movl %ebp, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x40a0
testq %rax, %rax
jns 0xbe94
leaq 0x1d26(%rip), %rdi      # 0xdbb5
callq 0xab82
movq (%r14), %rax
imulq 0x8(%r14), %rax
leaq (%rax,%rax,2), %rsi
testq %rsi, %rsi
jne 0xbec6
testq %rbx, %rbx
je 0xbeb1
movl %ebp, %edi
callq 0x4390
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x44a9
jmp 0xbeb1
movq %r14, %rdi
movl %ebp, %edx
callq 0x44c5
jmp 0xbea5
// File: /workspace/github_cpp_makefile_star2_O3/matthewarcus[P]mmps/image.cpp
// Function: Image::AddGrid(double, double, Rgb const&)
void Image::AddGrid(double gridx, double gridy, const Rgb& color)
{
  double ystep = gridy * height/180.0;
  double xstep = gridx * width/360.0;
  // Quicker this way around with big images
  for (long y = 0; y < height; y++) {
    for (double xgrad = 0.0; ROUND(xgrad) < width; xgrad += xstep) {
      long x = long(ROUND(xgrad));
      SetRgb((long) y * width + x, color);
    }
  }
  for (double ygrad = 0.0; ROUND(ygrad) < height; ygrad += ystep) {
    long y = long(ROUND(ygrad));
    for (long x = 0; x < width; x++) {
      SetRgb((long) y * width + x, color);
    }
  }
#if 0
  long y = long(ROUND(height/2.0 - greenwichlat * height / pi));
  for (long x = 0; x < width; x++) {
    SetRgb((long) y * width + x, red);
  }
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x8(%rdi), %r12
testq %r12, %r12
jle 0xc053
movq %rsi, %rbx
movq %rdi, %r14
cvtsi2sd %r12, %xmm2
mulsd %xmm1, %xmm2
divsd 0x1b05(%rip), %xmm2     # 0xda08
movsd %xmm2, 0x10(%rsp)
movq (%rdi), %r15
xorps %xmm2, %xmm2
cvtsi2sd %r15, %xmm2
mulsd %xmm0, %xmm2
divsd 0x1af0(%rip), %xmm2     # 0xda10
xorl %r13d, %r13d
movsd 0x14fd(%rip), %xmm1     # 0xd428
movsd %xmm2, 0x18(%rsp)
testq %r15, %r15
jle 0xbfaa
xorpd %xmm0, %xmm0
xorpd %xmm3, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rsp)
cvttsd2si %xmm0, %rax
imulq %r13, %r15
addq %rax, %r15
movq 0x10(%r14), %rax
addq %r15, %rax
addq %r15, %rax
movb (%rbx), %cl
movb %cl, (%rax,%r15)
movb 0x1(%rbx), %cl
movb %cl, 0x1(%rax,%r15)
movb 0x2(%rbx), %cl
movb %cl, 0x2(%rax,%r15)
movapd %xmm3, %xmm0
addsd %xmm1, %xmm0
callq 0x4310
movsd 0x8(%rsp), %xmm3
movsd 0x18(%rsp), %xmm2
movq (%r14), %r15
xorps %xmm1, %xmm1
cvtsi2sd %r15, %xmm1
ucomisd %xmm0, %xmm1
movsd 0x1484(%rip), %xmm1     # 0xd428
ja 0xbf3e
movq 0x8(%r14), %r12
incq %r13
cmpq %r12, %r13
jl 0xbf31
testq %r12, %r12
jle 0xc053
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
testq %r15, %r15
jle 0xc01a
cvttsd2si %xmm0, %rax
leaq (%rax,%rax,2), %rax
movl $0x2, %ecx
xorl %edx, %edx
movsd 0x1444(%rip), %xmm1     # 0xd428
imulq %rax, %r15
addq 0x10(%r14), %r15
movb (%rbx), %sil
movb %sil, -0x2(%rcx,%r15)
movb 0x1(%rbx), %sil
movb %sil, -0x1(%rcx,%r15)
movb 0x2(%rbx), %sil
movb %sil, (%rcx,%r15)
incq %rdx
movq (%r14), %r15
addq $0x3, %rcx
cmpq %r15, %rdx
jl 0xbfe4
movq 0x8(%r14), %r12
jmp 0xc022
movsd 0x1406(%rip), %xmm1     # 0xd428
addsd 0x10(%rsp), %xmm2
movapd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
addsd %xmm1, %xmm0
callq 0x4310
movsd 0x8(%rsp), %xmm2
xorps %xmm1, %xmm1
cvtsi2sd %r12, %xmm1
ucomisd %xmm0, %xmm1
ja 0xbfc7
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop