LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/matrix.cpp
// Function: Matrix3::Mult(Matrix3 const&, Matrix3 const&)
void Matrix3::Mult (const Matrix3& m1, const Matrix3& m2) 
{ 
  if (m1.identity) {
    if (m2.identity) {
      Identity();
    } else {
      Copy(m2);
    }
  } else if (m2.identity) {
    Copy(m1);
  } else {
    for (int i = 0; i < 3; i++) {
      for (int j = 0; j < 3; j++) {
	double x = 0.0;
	x += m1.Get(i,0) * m2.Get(0,j);
	x += m1.Get(i,1) * m2.Get(1,j);
	x += m1.Get(i,2) * m2.Get(2,j);
	Set(i,j,x);
      }
    }
    identity = false; // We could check the indices at this point
  }
}

// Assembly:
movb 0x48(%rdx), %al
cmpb $0x1, 0x48(%rsi)
jne 0x552d
testb %al, %al
jne 0x52c6
movq %rdx, %rsi
jmp 0x54cc
testb %al, %al
jne 0x54cc
xorl %eax, %eax
pushq $0x1
popq %rcx
xorpd %xmm0, %xmm0
movq %rdi, %r8
cmpq $0x3, %rax
je 0x559c
xorl %r9d, %r9d
movq %rcx, %r10
cmpq $0x4, %r10
je 0x5593
movsd (%rsi,%rax,8), %xmm1
mulsd (%rdx,%r9), %xmm1
movsd 0x18(%rsi,%rax,8), %xmm2
addsd %xmm0, %xmm1
mulsd 0x8(%rdx,%r9), %xmm2
addsd %xmm1, %xmm2
movsd 0x30(%rsi,%rax,8), %xmm1
mulsd 0x10(%rdx,%r9), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, (%r8,%r9)
incq %r10
addq $0x18, %r9
jmp 0x554d
incq %rax
addq $0x8, %r8
jmp 0x5541
movb $0x0, 0x48(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/matrix.cpp
// Function: Matrix3::ApplyLatLong(double&, double&) const
void Matrix3::ApplyLatLong (double& phi, double& lambda) const
{
  if (!identity) {
    double x = cos(lambda) * cos(phi);
    double y = sin(lambda) * cos(phi);
    double z = sin(phi);
    Apply(x,y,z);
    phi = asin(z);
    lambda = atan2(y,x);
  }
}

// Assembly:
cmpb $0x0, 0x48(%rdi)
jne 0x56ea
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd (%rdx), %xmm0
callq 0x43a0
movsd %xmm0, 0x8(%rsp)
movsd (%r14), %xmm0
callq 0x43a0
mulsd 0x8(%rsp), %xmm0
leaq 0x20(%rsp), %r12
movsd %xmm0, (%r12)
movsd (%rbx), %xmm0
callq 0x4070
movsd %xmm0, 0x8(%rsp)
movsd (%r14), %xmm0
callq 0x43a0
mulsd 0x8(%rsp), %xmm0
leaq 0x18(%rsp), %r13
movsd %xmm0, (%r13)
movsd (%r14), %xmm0
callq 0x4070
leaq 0x10(%rsp), %rbp
movsd %xmm0, (%rbp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x55a2
movsd (%rbp), %xmm0
callq 0x4320
movsd %xmm0, (%r14)
movsd (%r13), %xmm0
movsd (%r12), %xmm1
callq 0x4050
movsd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: convertlatlong(double&, double&, double&, double&, double&, Matrix3 const&)
void convertlatlong(double &phi, double &lambda, 
		    double& x, double& y, double& z,
		    const Matrix3& m)
{
  x = cos(lambda) * cos(phi);
  y = sin(lambda) * cos(phi);
  z = sin(phi);
  if (!m.IsIdentity()) {
    m.Apply(x,y,z);
    phi = asin(z);
    lambda = atan2(y,x);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbp
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movsd (%rsi), %xmm0
callq 0x43a0
movsd %xmm0, (%rsp)
movsd (%r12), %xmm0
callq 0x43a0
mulsd (%rsp), %xmm0
movsd %xmm0, (%r14)
movsd (%rbx), %xmm0
callq 0x4070
movsd %xmm0, (%rsp)
movsd (%r12), %xmm0
callq 0x43a0
mulsd (%rsp), %xmm0
movsd %xmm0, (%r15)
movsd (%r12), %xmm0
callq 0x4070
movsd %xmm0, (%r13)
cmpb $0x0, 0x48(%rbp)
jne 0x579b
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x55a2
movsd (%r13), %xmm0
callq 0x4320
movsd %xmm0, (%r12)
movsd (%r15), %xmm0
movsd (%r14), %xmm1
callq 0x4050
movsd %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: distance(double, double, double, double)
double distance(double phi0, double lambda0, double phi1, double lambda1)
{
  double x0 = cos(lambda0) * cos(phi0);
  double y0 = sin(lambda0) * cos(phi0);
  double z0 = sin(phi0);
  double x1 = cos(lambda1) * cos(phi1);
  double y1 = sin(lambda1) * cos(phi1);
  double z1 = sin(phi1);
  double d = acos((x0*x1 + y0*y1 + z0*z1));
  return d;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm3, 0x8(%rsp)
movsd %xmm2, 0x28(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
movaps %xmm1, %xmm0
callq 0x43a0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x43a0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x4070
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x43a0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x4070
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x43a0
movsd %xmm0, 0x30(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x43a0
mulsd 0x30(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4070
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x43a0
mulsd 0x8(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x4070
mulsd 0x20(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
addq $0x38, %rsp
jmp 0x41f0
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: applyRotation(double, double&, double&)
void applyRotation(double r, double &x, double &y)
{
  double x1 =  x * cos(r) + y * sin(r);
  double y1 = -x * sin(r) + y * cos(r);
  //double x1 = -y;
  //double y1 = x;
  //fprintf(stderr,"%g %g:", x, y);
  x = x1;
  y = y1;
  //fprintf(stderr,"%g %g\n", x, y);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x18(%rsp)
movsd (%rdi), %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x43a0
movsd %xmm0, 0x10(%rsp)
movsd (%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x4070
mulsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x4070
movsd %xmm0, (%rsp)
movsd (%rbx), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x43a0
mulsd 0x20(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd 0x10(%rsp), %xmm1
movsd %xmm1, (%r14)
movsd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Transform::MapXY(Image const&, TransformParams const&, double, double, double&, double&) const
bool Transform::MapXY(const Image& outImage, 
		      const TransformParams& params,
		      double phi, double lambda, double& x, double& y) const
{
  bool result = false;
  // Set x and y to where phi and lambda are mapped to
  // x, y are in image coordinates
  // Get projection coordinates for x and y
  if (CheckPoint(params,phi,lambda) &&
      ProjectInv(params, phi,lambda, x, y)) {
    // Now x and y are in 2pi scale
    int ow = outImage.Width();
    int oh = outImage.Height();
    double orgx = 0.5 * ow;
    double orgy = 0.5 * oh;
    double scaleFactor = BasicScale(ow,oh) / params.scale;
    if (params.rotate != 0) {
      applyRotation(params.rotate,x,y);
    }
    x = orgx + (x - params.xoff) / scaleFactor;
    y = orgy + (y - params.yoff) / -scaleFactor;
    result = true;
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq (%rdi), %rax
movq %rdx, %rsi
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
callq *0x30(%rax)
testb %al, %al
je 0x677d
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r15, %rdx
movq %rbx, %rcx
callq *0x28(%rax)
testb %al, %al
je 0x677d
movl (%r13), %esi
movl 0x8(%r13), %edx
cvtsi2sd %esi, %xmm1
movsd 0x5d0c(%rip), %xmm0     # 0xc3f0
mulsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
cvtsi2sd %edx, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movq (%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
movapd %xmm0, %xmm2
divsd 0x28(%r14), %xmm2
movsd 0x10(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6722
jnp 0x6739
movq %r15, %rdi
movq %rbx, %rsi
movsd %xmm2, 0x18(%rsp)
callq 0x5eae
movsd 0x18(%rsp), %xmm2
movsd (%r15), %xmm0
subsd 0xb0(%r14), %xmm0
divsd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r15)
movsd (%rbx), %xmm0
subsd 0xb8(%r14), %xmm0
divsd %xmm2, %xmm0
movsd 0x10(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movb $0x1, %al
jmp 0x677f
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: PolarTransform::Init(TransformParams const&)
void PolarTransform::Init (const TransformParams& params)
{
  Transform::Init(params);

  // Polar transforms have the north pole as the centre.
  // For consistency with other transforms, we rotate to set lat = 0
  m = Matrix3(YAxis,-piovertwo) * m;
  minv = minv * Matrix3(YAxis,piovertwo);

  k = params.conic;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x596e
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rbp
movsd 0x544a(%rip), %xmm0     # 0xc028
movq %r15, %rdi
movl %ebp, %esi
callq 0x52fa
leaq 0x8(%rbx), %r12
leaq 0x58(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x54ea
pushq $0x49
popq %r15
movq %r15, %rcx
movq %r12, %rdi
movq %r13, %rsi
rep  movsb (%rsi), %es:(%rdi)
leaq 0x58(%rbx), %r12
leaq 0x8(%rsp), %r13
movsd 0x5401(%rip), %xmm0     # 0xc020
movq %r13, %rdi
movl %ebp, %esi
callq 0x52fa
leaq 0x58(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x54ea
movq %r15, %rcx
movq %r12, %rdi
movq %rbp, %rsi
rep  movsb (%rsi), %es:(%rdi)
movsd 0xa0(%r14), %xmm0
movsd %xmm0, 0xc0(%rbx)
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: PolarTransform::Project(TransformParams const&, double, double, double&, double&, double&, double&, double&) const
bool PolarTransform::Project(const TransformParams& params,
			     double x0, double y0, 
			     double& x, double& y, double& z,
			     double& phi, double& lambda) const
{
  bool result = false;
  double r = sqrt(sqr(x0) + sqr(y0)) - params.conicr;
  lambda = params.conic * atan2(x0, -y0);
  if (r > 0.0 && lambda >= -pi && lambda <= pi) {
    GetPhi(r, phi);
    if (phi >= -piovertwo && phi <= piovertwo) {
      convertlatlong(phi,lambda,x,y,z,m);
      result = true;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %r13
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movapd %xmm1, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
sqrtsd %xmm3, %xmm2
subsd 0xa8(%rsi), %xmm2
movsd %xmm2, 0x8(%rsp)
movq 0x50(%rsp), %rbp
movsd 0xa0(%rsi), %xmm2
movsd %xmm2, 0x10(%rsp)
xorpd 0x53a8(%rip), %xmm1     # 0xc070
callq 0x4050
movsd 0x8(%rsp), %xmm2
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rbp)
xorl %eax, %eax
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jbe 0x6d4d
andpd 0x57de(%rip), %xmm0     # 0xc4d0
movsd 0x530e(%rip), %xmm1     # 0xc008
ucomisd %xmm0, %xmm1
jb 0x6d4d
movq (%r13), %rax
movq %r13, %rdi
movapd %xmm2, %xmm0
movq %r15, %rsi
callq *0x48(%rax)
movsd (%r15), %xmm0
andpd 0x57b2(%rip), %xmm0     # 0xc4d0
movsd 0x52fa(%rip), %xmm1     # 0xc020
ucomisd %xmm0, %xmm1
jae 0x6d30
xorl %eax, %eax
jmp 0x6d4d
addq $0x8, %r13
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %r13, %r9
callq 0x56ec
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: PolarTransform::ProjectInv(TransformParams const&, double, double, double&, double&) const
bool PolarTransform::ProjectInv(const TransformParams& params,
				double phi, double lambda,
				double& x, double& y) const
{
  bool result = false;
  // Set x and y to where phi and lambda are mapped to
  // x, y are in image coordinates
  // Get projection coordinates for x and y
  double x0,y0,z0;
  convertlatlong(phi,lambda,x0,y0,z0,minv);
  double r = 0.0;
  if (GetR(phi, r)) {
    x = (r + params.conicr) * sin(lambda / params.conic);
    y = -(r + params.conicr) * cos(lambda / params.conic);
    result = true;
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x50(%rsp), %r13
movsd %xmm0, (%r13)
leaq 0x30(%rsp), %rsi
movsd %xmm1, (%rsi)
leaq 0x58(%rdi), %r9
leaq 0x48(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x38(%rsp), %r8
movq %r13, %rdi
callq 0x56ec
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movsd (%r13), %xmm0
movq (%r12), %rax
movq %r12, %rdi
callq *0x50(%rax)
movl %eax, %ebp
testb %al, %al
je 0x6e39
movsd 0x8(%rsp), %xmm0
addsd 0xa8(%r14), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
divsd 0xa0(%r14), %xmm0
callq 0x4070
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, (%r15)
movsd 0x8(%rsp), %xmm0
addsd 0xa8(%r14), %xmm0
xorpd 0x525b(%rip), %xmm0     # 0xc070
movapd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
divsd 0xa0(%r14), %xmm0
callq 0x43a0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rbx)
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: CylindricalTransform::Project(TransformParams const&, double, double, double&, double&, double&, double&, double&) const
bool CylindricalTransform::Project(const TransformParams& params,
				   double x0, double y0, 
				   double& x, double& y, double& z,
				   double& phi, double& lambda) const
{
  (void(params));
  (void(y0));
  bool result = false;

  phi = phi0;
  lambda = GetLong(x0);

  if (lambda >= -pi && lambda <= pi && 
      phi >= -piovertwo && phi <= piovertwo) {
    // Transform to new lat and long.
    // cartesian coords from latlong
    convertlatlong(phi,lambda,x,y,z,m);
    result = true;
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rdi, %r15
movq 0x40(%rsp), %rbp
movsd 0xc0(%rdi), %xmm1
movsd %xmm1, (%r9)
movq (%rdi), %rax
callq *0x58(%rax)
movsd %xmm0, (%rbp)
andpd 0x5647(%rip), %xmm0     # 0xc4d0
movsd 0x5177(%rip), %xmm1     # 0xc008
ucomisd %xmm0, %xmm1
jb 0x6eb3
movsd (%r12), %xmm0
andpd 0x562b(%rip), %xmm0     # 0xc4d0
movsd 0x5173(%rip), %xmm1     # 0xc020
ucomisd %xmm0, %xmm1
jae 0x6eb7
xorl %eax, %eax
jmp 0x6ed4
addq $0x8, %r15
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %r15, %r9
callq 0x56ec
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Mercator::GetLat(double)
double Mercator::GetLat(double y)
{
  double k = exp(fabs(y));
  double phi = acos(2*k/(k*k+1));
  if (y < 0) phi = -phi;
  return phi;
}

// Assembly:
subq $0x18, %rsp
movapd %xmm0, %xmm1
movapd %xmm0, (%rsp)
movapd 0x5359(%rip), %xmm0     # 0xc4d0
andpd %xmm1, %xmm0
callq 0x4380
movapd %xmm0, %xmm1
addsd %xmm0, %xmm1
mulsd %xmm0, %xmm0
addsd 0x4eb4(%rip), %xmm0     # 0xc048
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x41f0
movapd 0x4ec7(%rip), %xmm1     # 0xc070
xorpd %xmm0, %xmm1
xorpd %xmm2, %xmm2
movapd (%rsp), %xmm3
cmpltsd %xmm2, %xmm3
movapd %xmm3, %xmm2
andnpd %xmm0, %xmm2
andpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movapd %xmm3, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Mercator::GetXY(double, double, double&, double&) const
bool Mercator::GetXY(double phi, double lambda, double& x, double& y) const
{
  x = lambda;
  y = log((1 + sin(fabs(phi))) / cos(fabs(phi)));
  if (phi < 0) {
    y = -y;
  }
  return true;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movapd %xmm0, %xmm2
movapd %xmm0, 0x10(%rsp)
movsd %xmm1, (%rsi)
movapd 0x52dc(%rip), %xmm0     # 0xc4d0
andpd %xmm2, %xmm0
callq 0x4070
addsd 0x4e43(%rip), %xmm0     # 0xc048
movsd %xmm0, 0x8(%rsp)
movapd 0x10(%rsp), %xmm0
callq 0x43a0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x41a0
movapd 0x4e3f(%rip), %xmm1     # 0xc070
xorpd %xmm0, %xmm1
xorpd %xmm2, %xmm2
movapd 0x10(%rsp), %xmm3
cmpltsd %xmm2, %xmm3
movapd %xmm3, %xmm2
andnpd %xmm0, %xmm2
andpd %xmm1, %xmm3
orpd %xmm2, %xmm3
movlpd %xmm3, (%rbx)
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Rectilinear::GetR(double, double&) const
bool Rectilinear::GetR(double phi, double& r) const
{
  bool result = false;
  if (phi >= 0.0) {
    r = cos(phi);
    result = true;
  }
  return result;
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7314
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x43a0
xorpd %xmm1, %xmm1
movsd %xmm0, (%rbx)
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
ucomisd %xmm1, %xmm0
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Gnomonic::GetR(double, double&) const
bool Gnomonic::GetR(double phi, double& r) const
{
  bool result = false;
  if (phi > 0) {
    r = 1 / (2 * tan(phi));
    result = true;
  }
  return result;
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x7426
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x4110
addsd %xmm0, %xmm0
movsd 0x4c39(%rip), %xmm1     # 0xc048
divsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
movsd %xmm1, (%rbx)
xorpd %xmm1, %xmm1
addq $0x10, %rsp
popq %rbx
ucomisd %xmm1, %xmm0
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Hammer::ProjectSimple(double, double, double&, double&) const
bool Hammer::ProjectSimple(double x, double y, 
			   double& phi, double& lambda) const
{
  bool result = false;
  double z2 = 2-sqr(x)-sqr(2*y);
  double z = sqrt(z2);
  double t1 = 2*y*z;
  if (t1 >= -1.0 && t1 <= 1.0) {
    phi = asin(t1);
    lambda = 2 * atan2(x*z,z2 - 1);
    if (lambda >= -pi && lambda <= pi) {
      result = true;
    }
  }
  return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movsd %xmm0, 0x18(%rsp)
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movsd 0x4fc9(%rip), %xmm0     # 0xc420
subsd %xmm2, %xmm0
addsd %xmm1, %xmm1
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
subsd %xmm2, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movsd %xmm0, 0x20(%rsp)
jb 0x7481
sqrtsd %xmm0, %xmm3
jmp 0x7494
movapd %xmm1, (%rsp)
callq 0x4190
movapd (%rsp), %xmm1
movapd %xmm0, %xmm3
mulsd %xmm3, %xmm1
movapd 0x5030(%rip), %xmm0     # 0xc4d0
andpd %xmm1, %xmm0
movsd 0x4b9c(%rip), %xmm2     # 0xc048
ucomisd %xmm0, %xmm2
jae 0x74b6
xorl %eax, %eax
jmp 0x7506
movapd %xmm1, %xmm0
movsd %xmm3, (%rsp)
callq 0x4320
movsd %xmm0, (%r14)
movsd (%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
addsd 0x4f46(%rip), %xmm1     # 0xc428
callq 0x4050
addsd %xmm0, %xmm0
movsd %xmm0, (%rbx)
andpd 0x4fd9(%rip), %xmm0     # 0xc4d0
movsd 0x4b09(%rip), %xmm1     # 0xc008
ucomisd %xmm0, %xmm1
setae %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Hammer::ProjectInvSimple(double, double, double&, double&) const
bool Hammer::ProjectInvSimple(double phi, double lambda, double& x, double& y) const
{
  double z = sqrt(1 + cos(phi)*cos(lambda/2));
  x = cos(phi)*sin(lambda/2)/z;
  y = sin(phi)/(2 * z);
  return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x18(%rsp)
callq 0x43a0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0x4eb0(%rip), %xmm0     # 0xc3f0
movsd %xmm0, 0x10(%rsp)
callq 0x43a0
mulsd 0x8(%rsp), %xmm0
addsd 0x4aef(%rip), %xmm0     # 0xc048
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7569
sqrtsd %xmm0, %xmm0
jmp 0x756e
callq 0x4190
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x43a0
movsd %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4070
mulsd 0x20(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r14)
movsd 0x18(%rsp), %xmm0
callq 0x4070
movsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Bonne::ProjectSimple(double, double, double&, double&) const
bool Bonne::ProjectSimple(double x, double y, 
			  double& phi, double& lambda) const
{
  bool result = false;
  double rho = sqrt(sqr(x) + sqr(cotp - y));
  if (p > 0) {
    phi = cotp + p - rho;
    lambda = rho * atan2(x, cotp - y)/cos(phi);
  } else if (p < 0) {
    phi = cotp + p + rho;
    lambda = rho * atan2(x, y - cotp)/cos(phi);
  } else {
    // Degenerate case - the sinusoidal projection
    phi = y;
    lambda = x/cos(phi);
  }
  if (phi >= -piovertwo && phi <= +piovertwo &&
      lambda >= -pi && lambda <= pi) {
    result = true;
  }
  return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movapd %xmm0, %xmm3
mulsd %xmm0, %xmm3
movsd 0xc0(%rdi), %xmm5
movsd 0xc8(%rdi), %xmm2
movapd %xmm2, %xmm4
subsd %xmm1, %xmm4
mulsd %xmm4, %xmm4
addsd %xmm3, %xmm4
sqrtsd %xmm4, %xmm4
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm5
jbe 0x766b
addsd %xmm2, %xmm5
subsd %xmm4, %xmm5
movsd %xmm5, (%rbx)
movsd 0xc8(%rdi), %xmm2
subsd %xmm1, %xmm2
movapd %xmm2, %xmm1
jmp 0x7685
ucomisd %xmm5, %xmm3
jbe 0x769f
addsd %xmm2, %xmm5
addsd %xmm4, %xmm5
movsd %xmm5, (%rbx)
subsd 0xc8(%rdi), %xmm1
movsd %xmm4, (%rsp)
callq 0x4050
mulsd (%rsp), %xmm0
movapd %xmm0, (%rsp)
movsd (%rbx), %xmm1
jmp 0x76a8
movsd %xmm1, (%rbx)
movapd %xmm0, (%rsp)
movapd %xmm1, %xmm0
callq 0x43a0
movapd (%rsp), %xmm2
divsd %xmm0, %xmm2
movsd %xmm2, (%r14)
movsd (%rbx), %xmm0
movapd 0x4e05(%rip), %xmm1     # 0xc4d0
andpd %xmm1, %xmm0
andpd %xmm1, %xmm2
movsd 0x492d(%rip), %xmm1     # 0xc008
cmplepd %xmm1, %xmm2
movsd 0x4938(%rip), %xmm1     # 0xc020
cmplepd %xmm1, %xmm0
andpd %xmm2, %xmm0
movd %xmm0, %eax
andb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Bonne::ProjectInvSimple(double, double, double&, double&) const
bool Bonne::ProjectInvSimple(double phi, double lambda, double& x, double& y) const
{
  if (p == 0.0) {
    x = lambda * cos(phi);
    y = phi;
  } else {
    double rho = cotp + p - phi;
    double e = lambda * cos(phi)/rho;
    x = rho * sin(e);
    y = cotp - rho * cos(e);
  }
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movsd %xmm1, 0x8(%rsp)
movsd 0xc0(%rdi), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x7747
jp 0x7747
movsd %xmm0, 0x18(%rsp)
callq 0x43a0
movsd 0x18(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r14)
jmp 0x77ad
movq %rdi, %r15
addsd 0xc8(%rdi), %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp)
callq 0x43a0
mulsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x4070
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, (%r14)
movsd 0xc8(%r15), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x43a0
movsd 0x18(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Perspective::Init(TransformParams const&)
void Perspective::Init(const TransformParams& params) 
{
  Transform::Init(params);
  vx = params.x; vy = params.y; vz = params.z;
  rx = vx; ry = vy; rz = vz;
  m.Apply(rx,ry,rz);
  scalefactor = (vx + 1) * tan(params.aw/2);
  iscalefactor = 1/scalefactor;

  a = params.ox;
  b = params.oy;
  c = params.oz;
  a2 = sqr(a);
  b2 = sqr(b);
  c2 = sqr(c);
  ia2 = 1/a2;
  ib2 = 1/b2;
  ic2 = 1/c2;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x596e
movups 0x48(%r14), %xmm0
movups %xmm0, 0xd0(%rbx)
movsd 0x58(%r14), %xmm1
movsd %xmm1, 0xe0(%rbx)
leaq 0xe8(%rbx), %rsi
leaq 0xf0(%rbx), %rdx
movups %xmm0, 0xe8(%rbx)
leaq 0xf8(%rbx), %rcx
movsd %xmm1, 0xf8(%rbx)
leaq 0x8(%rbx), %rdi
callq 0x55a2
movsd 0xd0(%rbx), %xmm0
addsd 0x4824(%rip), %xmm0     # 0xc048
movsd %xmm0, (%rsp)
movsd 0x40(%r14), %xmm0
mulsd 0x4bb9(%rip), %xmm0     # 0xc3f0
callq 0x4110
mulsd (%rsp), %xmm0
movsd %xmm0, 0xc0(%rbx)
movsd 0x47f7(%rip), %xmm3     # 0xc048
movapd %xmm3, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0xc8(%rbx)
movsd 0x70(%r14), %xmm0
movsd %xmm0, 0x110(%rbx)
movupd 0x60(%r14), %xmm1
movupd %xmm1, 0x100(%rbx)
mulpd %xmm1, %xmm1
movupd %xmm1, 0x118(%rbx)
mulsd %xmm0, %xmm0
movsd %xmm0, 0x128(%rbx)
movapd 0x4bf3(%rip), %xmm2     # 0xc490
divpd %xmm1, %xmm2
movupd %xmm2, 0x130(%rbx)
movapd %xmm3, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x140(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: CylindricalTransform::AdjustSize(int&, int&, TransformParams&)
void CylindricalTransform::AdjustSize (int& w, int& h, 
				       TransformParams& params)
{
  if (params.scale < 1.0) {
    w = int(w * params.scale);
    params.scale = 1.0;     
  }
  // If a parallel has been given, check it's valid
  if (params.p < 0 || params.p >= piovertwo) {
    error ("Invalid parallel");
  }
  double h0 = GetMaxHeight(params);
  if (h0 > 0.0) { // Return <= 0 for don't adjust
    int newh = int(h0 * w * params.scale / pi);
    if (newh < h) { h = newh; };
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movsd 0x28(%rcx), %xmm0
movsd 0x4066(%rip), %xmm1     # 0xc048
ucomisd %xmm0, %xmm1
jbe 0x8006
cvtsi2sdl (%r15), %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, (%r15)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x28(%r14)
movsd 0x80(%r14), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x8023
ucomisd 0x3fff(%rip), %xmm0     # 0xc020
jb 0x802f
leaq 0x456d(%rip), %rdi      # 0xc597
callq 0x9e20
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x60(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x808e
cvtsi2sdl (%r15), %xmm1
mulsd %xmm1, %xmm0
mulsd 0x28(%r14), %xmm0
movsd %xmm0, 0x10(%rsp)
fldl 0x10(%rsp)
fdivl 0x3fa3(%rip)            # 0xc008
fnstcw 0x8(%rsp)
movzwl 0x8(%rsp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, 0xa(%rsp)
fldcw 0xa(%rsp)
fistpl 0xc(%rsp)
fldcw 0x8(%rsp)
movl 0xc(%rsp), %eax
cmpl %eax, (%rbx)
jle 0x808e
movl %eax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Sinusoidal2::CalcParams(double, double, double&, double&)
void Sinusoidal2::CalcParams(double a, double phi, double& k, double& b)
{
  // Find the t value for phi
  double t1 = 0;
  double t2 = pi/2.0;
  double epsilon = 1e-6;
  double k0 = 0.0, b0 = 0.0;
  while (fabs(t2 - t1) > epsilon) {
    double t0 = (t1 + t2)/2.0;
    k0 = sqr((cos(t0) + a) / ((a+1)*cos(phi)));
    b0 = (k0 * (a+1))/(1 + a * pi / 2.0);
    double p0 = b0 * sin(t0) + a * t0 - k0 * (a+1) * sin(phi);
    if (p0 <= 0.0) t1 = t0;
    else t2 = t0;
  }
  k = k0; b = b0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm1, 0x18(%rsp)
movsd 0x3f58(%rip), %xmm1     # 0xc048
addsd %xmm0, %xmm1
movsd %xmm1, 0x30(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd %xmm0, 0x58(%rsp)
fldl 0x58(%rsp)
fmull 0x3ef8(%rip)            # 0xc008
fmuls 0x43e2(%rip)            # 0xc4f8
fld1
faddp %st, %st(1)
fstpt 0x64(%rsp)
movsd 0x3efa(%rip), %xmm1     # 0xc020
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movsd %xmm0, 0x8(%rsp)
xorpd %xmm2, %xmm2
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
andpd 0x4387(%rip), %xmm0     # 0xc4d0
ucomisd 0x42e7(%rip), %xmm0     # 0xc438
jbe 0x8256
movapd %xmm1, 0x80(%rsp)
movapd %xmm1, %xmm0
addsd %xmm2, %xmm0
mulsd 0x4280(%rip), %xmm0     # 0xc3f0
movapd %xmm0, 0x20(%rsp)
movsd %xmm2, 0x40(%rsp)
callq 0x43a0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x43a0
movsd 0x30(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd (%rsp), %xmm2
divsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
movsd %xmm2, (%rsp)
mulsd %xmm2, %xmm1
movsd %xmm1, 0x38(%rsp)
movsd %xmm1, 0x50(%rsp)
fldt 0x64(%rsp)
fdivrl 0x50(%rsp)
fstpl 0x48(%rsp)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movapd 0x20(%rsp), %xmm0
callq 0x4070
movapd 0x20(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movapd %xmm0, 0x70(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x4070
movapd 0x70(%rsp), %xmm3
movsd 0x40(%rsp), %xmm2
xorpd %xmm1, %xmm1
mulsd 0x38(%rsp), %xmm0
subsd %xmm0, %xmm3
movapd 0x20(%rsp), %xmm0
ucomisd %xmm3, %xmm1
jb 0x8237
movapd %xmm0, %xmm2
cmpnlesd %xmm1, %xmm3
andpd %xmm3, %xmm0
andnpd 0x80(%rsp), %xmm3
orpd %xmm0, %xmm3
movapd %xmm3, %xmm1
jmp 0x8139
movsd (%rsp), %xmm0
movsd %xmm0, (%r14)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
addq $0x98, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Sinusoidal2::GetLat(double)
double Sinusoidal2::GetLat(double y)
{
  double t = y/b;
  double phi = asin((b * (sin(t) + a * t)) / (k * (a+1)));
  m = (a+1) / (cos(t) + a);
  return phi;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd 0xd0(%rdi), %xmm1
movsd %xmm1, 0x8(%rsp)
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x4070
movsd 0xc8(%rbx), %xmm1
movapd %xmm1, %xmm2
mulsd 0x10(%rsp), %xmm2
addsd %xmm2, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd 0x3d47(%rip), %xmm2     # 0xc048
movsd %xmm2, 0x8(%rsp)
addsd %xmm2, %xmm1
mulsd 0xd8(%rbx), %xmm1
divsd %xmm1, %xmm0
callq 0x4320
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
addsd 0xc8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x43a0
addsd 0xc8(%rbx), %xmm0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0xe0(%rbx)
movsd 0x18(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Sinusoidal2::GetXY(double, double, double&, double&) const
bool Sinusoidal2::GetXY(double phi, double lambda, double& x, double& y) const
{
  bool result = false;
  Sinusoidal2Equation equation;
  equation.b = b; equation.a = a; equation.k = k; equation.sinphi = sin(phi);
  double t = 0.0;
  if (equation.FindRoot(-pi/2, pi/2, 1e-5, t)) {
    y = b * t;
    x = lambda * (cos(t) + a) / (a+1);
    result = true;
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movsd %xmm1, 0x8(%rsp)
movq %rdi, %r14
leaq 0x9684(%rip), %rax      # 0x11a18
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movups 0xc8(%rdi), %xmm1
shufps $0x4e, %xmm1, %xmm1     # xmm1 = xmm1[2,3,0,1]
movups %xmm1, 0x8(%r12)
movsd 0xd8(%rdi), %xmm1
movsd %xmm1, 0x18(%r12)
callq 0x4070
movsd %xmm0, 0x20(%r12)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
movsd 0x3c4e(%rip), %xmm0     # 0xc028
movsd 0x3c3e(%rip), %xmm1     # 0xc020
movsd 0x4056(%rip), %xmm2     # 0xc440
movq %r12, %rdi
callq 0x9844
movl %eax, %ebp
testb %al, %al
je 0x8438
movsd 0x10(%rsp), %xmm0
movsd 0xd0(%r14), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%r15)
callq 0x43a0
movsd 0xc8(%r14), %xmm1
addsd %xmm1, %xmm0
mulsd 0x8(%rsp), %xmm0
addsd 0x3c18(%rip), %xmm1     # 0xc048
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/matthewarcus[P]mmps/transform.cpp
// Function: Mollweide::CalcParams(double, double&)
void Mollweide::CalcParams(double phi, double& a)
{
  // Now we need to find a suitable t
  // Good old binary search - note we cavalierly fail to check if there's
  // a solution in the interval. Hell, we're going to terminate with something.
  double t = 0;     // phi = 0;
  double t1 = pi/2;  // phi = pi/2;
  double b = 0.5 * pi * sin(phi);
  double epsilon = 1e-6;
  while (fabs(t1 - t) > epsilon) {
    double t2 = (t + t1)/2.0;
    double p = t2 + 0.5 * sin (2 * t2) - b;
    if (p <= 0.0) t = t2; 
    else t1 = t2;
  }
  // t is our selected value
  a = pi / (4 * sqr(cos (t)/cos(phi)));
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movsd %xmm0, 0x10(%rsp)
callq 0x4070
movsd %xmm0, 0x38(%rsp)
fldl 0x38(%rsp)
fmull 0x3b89(%rip)            # 0xc020
fstpl 0x30(%rsp)
movsd 0x3b7d(%rip), %xmm1     # 0xc020
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
xorpd %xmm2, %xmm2
movapd %xmm1, %xmm0
subsd %xmm2, %xmm0
andpd 0x400d(%rip), %xmm0     # 0xc4d0
ucomisd 0x3f6d(%rip), %xmm0     # 0xc438
jbe 0x8542
movapd %xmm1, (%rsp)
addsd %xmm2, %xmm1
movsd 0x3f12(%rip), %xmm0     # 0xc3f0
mulsd %xmm0, %xmm1
movapd %xmm1, 0x40(%rsp)
movapd %xmm1, %xmm0
addsd %xmm1, %xmm0
movsd %xmm2, 0x20(%rsp)
callq 0x4070
movapd 0x40(%rsp), %xmm3
movsd 0x20(%rsp), %xmm2
xorpd %xmm1, %xmm1
mulsd 0x3edd(%rip), %xmm0     # 0xc3f0
addsd %xmm3, %xmm0
subsd 0x18(%rsp), %xmm0
ucomisd %xmm0, %xmm1
jb 0x8527
movapd %xmm3, %xmm2
cmpnlesd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd (%rsp), %xmm0
orpd %xmm3, %xmm0
movapd %xmm0, %xmm1
jmp 0x84b3
movapd %xmm2, %xmm0
callq 0x43a0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x43a0
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
mulsd %xmm1, %xmm1
mulsd 0x3ed8(%rip), %xmm1     # 0xc448
movsd %xmm1, 0x28(%rsp)
fldl 0x3a8c(%rip)            # 0xc008
fdivl 0x28(%rsp)
fstpl (%rbx)
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4320
movsd %xmm0, 0x18(%rsp)
callq 0x43a0
movsd 0x3a76(%rip), %xmm1     # 0xc048
divsd %xmm0, %xmm1
movsd %xmm1, 0xd0(%rbx)
movsd 0x18(%rsp), %xmm0
addsd %xmm0, %xmm0
callq 0x4070
mulsd 0x3dfb(%rip), %xmm0     # 0xc3f0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
fldt 0x3ed9(%rip)            # 0xc4e0
fmull 0x28(%rsp)
fstpt (%rsp)
callq 0x4310
fstpl 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9418(%rip), %rax      # 0x11a68
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
callq 0x4070
movsd %xmm0, 0x8(%r12)
movq %rsp, %rsi
andq $0x0, (%rsi)
movsd 0x39b4(%rip), %xmm0     # 0xc028
movsd 0x39a4(%rip), %xmm1     # 0xc020
movsd 0x3dbc(%rip), %xmm2     # 0xc440
movq %r12, %rdi
callq 0x9844
movl %eax, %ebp
testb %al, %al
je 0x86be
movsd (%rsp), %xmm0
callq 0x4070
divsd 0xc8(%r15), %xmm0
movsd %xmm0, (%r14)
movsd (%rsp), %xmm0
callq 0x43a0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsp, %rcx
andq $0x0, 0x20(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%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 0x870a
addq $0x28, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
cvttsd2si 0x10(%rcx), %eax
movq %rdi, %r12
movl 0x8(%rcx), %ecx
movl %ecx, 0xc(%rsp)
movl %eax, 0x1c(%rsp)
fildl 0x1c(%rsp)
fmull 0x38fa(%rip)            # 0xc038
fdivs 0x3db8(%rip)            # 0xc4fc
fstpl 0x38(%rsp)
movsd 0x38(%rsp), %xmm0
xorl %r13d, %r13d
movl $0x168, %eax            # imm = 0x168
xorl %edx, %edx
idivl 0x4(%rbx)
movl %eax, %ecx
movw $0xfffe, %si            # imm = 0xFFFE
cwtd
idivw %si
movswl %ax, %ebp
movl %ecx, 0x20(%rsp)
fildl 0x20(%rsp)
fstpt 0x24(%rsp)
movsd %xmm0, 0x30(%rsp)
fldl 0x30(%rsp)
fstpt 0x6c(%rsp)
testl %ecx, %ecx
cmovgl %ecx, %r13d
addl %ebp, %ebp
subl $0x1, %r13d
jb 0x87f2
movq %r14, 0x48(%rsp)
movq %r15, 0x50(%rsp)
movq %r12, 0x58(%rsp)
leaq 0x9301(%rip), %rax      # 0x11aa8
movq %rax, 0x40(%rsp)
movl %ebp, 0x18(%rsp)
fildl 0x18(%rsp)
fmull 0x384e(%rip)            # 0xc008
fldt 0x24(%rsp)
fdivrp %st, %st(1)
fldt 0x6c(%rsp)
faddp %st, %st(1)
fstpl 0x60(%rsp)
movq %r14, %rdi
movsd 0x3853(%rip), %xmm0     # 0xc028
movsd 0x3843(%rip), %xmm1     # 0xc020
leaq 0x40(%rsp), %rsi
movq %rbx, %rdx
pushq $0x10
popq %rcx
callq 0xb5ca
addl $0x2, %ebp
jmp 0x878b
xorl %r13d, %r13d
movl $0xb4, %eax
xorl %edx, %edx
idivl 0xc(%rsp)
movl %eax, %ebp
leaq 0x40(%rsp), %rcx
movq %r14, 0x8(%rcx)
movq %r15, 0x10(%rcx)
movq %r12, 0x18(%rcx)
leaq 0x92f6(%rip), %rax      # 0x11b10
movq %rax, (%rcx)
movw $0xfffe, %cx            # imm = 0xFFFE
movl %ebp, %eax
cwtd
idivw %cx
movswl %ax, %r12d
movl %ebp, 0x14(%rsp)
fildl 0x14(%rsp)
fstpt 0x24(%rsp)
pushq $0x10
popq %r15
cmpl %ebp, %r13d
jg 0x8885
leal (%r12,%r13), %eax
movl %eax, 0x10(%rsp)
fildl 0x10(%rsp)
fmull 0x37b5(%rip)            # 0xc008
fldt 0x24(%rsp)
fdivrp %st, %st(1)
fstpl 0x60(%rsp)
movq %r14, %rdi
movsd 0x37c8(%rip), %xmm0     # 0xc030
movsd 0x3798(%rip), %xmm1     # 0xc008
leaq 0x40(%rsp), %rsi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0xb5ca
incl %r13d
jmp 0x883c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rdi, 0x18(%r15)
leaq 0x8f3e(%rip), %rax      # 0x11bd0
movq %rax, (%r15)
movups 0x18(%rcx), %xmm0
movups %xmm0, 0x28(%r15)
movsd 0x37b2(%rip), %xmm0     # 0xc458
pushq $0xd
popq %r12
pushq $0x4
popq %rbp
subl $0x1, %r12d
jb 0x8ced
movsd %xmm0, 0x28(%rsp)
movq %r14, %rdi
movsd %xmm0, (%rsp)
movsd 0x3797(%rip), %xmm0     # 0xc460
movsd 0x3797(%rip), %xmm1     # 0xc468
movq %r15, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xb5ca
movsd (%rsp), %xmm0
addsd 0x335d(%rip), %xmm0     # 0xc048
jmp 0x8cad
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
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 0x8d84(%rip), %rax      # 0x11aa8
movq %rax, (%r15)
pushq $-0x18
popq %r12
pushq $0x4
popq %rbp
cmpl $0x18, %r12d
je 0x8d76
movl %r12d, 0x4(%rsp)
fildl 0x4(%rsp)
fmull 0x32c5(%rip)            # 0xc008
fdivs 0x37b7(%rip)            # 0xc500
faddl 0x20(%rbx)
fstpl 0x28(%rsp)
movq %r14, %rdi
movsd 0x3705(%rip), %xmm0     # 0xc460
movsd 0x3705(%rip), %xmm1     # 0xc468
movq %r15, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xb5ca
addl $0x2, %r12d
jmp 0x8d2e
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rsi, %r14
leaq 0x18(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rdi, 0x18(%r15)
leaq 0x8de2(%rip), %rax      # 0x11b90
movq %rax, (%r15)
movups 0x18(%rcx), %xmm0
shufps $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
movups %xmm0, 0x28(%r15)
pushq $0xa
popq %r12
flds 0x373c(%rip)            # 0xc504
pushq $0x10
popq %rbp
cmpl $0x51, %r12d
jae 0x8e14
fstpt 0xc(%rsp)
fldt 0xc(%rsp)
fmull 0x3229(%rip)            # 0xc008
fdivs 0x3287(%rip)            # 0xc06c
fstpl 0x38(%rsp)
xorps %xmm0, %xmm0
movq %r14, %rdi
movsd 0x3241(%rip), %xmm1     # 0xc038
movq %r15, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xb5ca
fldt 0xc(%rsp)
fadds 0x36f6(%rip)            # 0xc504
addl $0xa, %r12d
jmp 0x8dcb
fstp %st(0)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %rcx
movq %rsi, %r14
xorl %r12d, %r12d
movl $0x168, %eax            # imm = 0x168
xorl %edx, %edx
idivl 0x4(%rbx)
movl %eax, %esi
leaq 0x20(%rsp), %r15
movq %r14, 0x8(%r15)
movq %rcx, 0x10(%r15)
movq %rdi, 0x18(%r15)
leaq 0x8cee(%rip), %rax      # 0x11b50
movq %rax, (%r15)
movw $0xfffe, %cx            # imm = 0xFFFE
movl %esi, %eax
cwtd
idivw %cx
movswl %ax, %r13d
movl %esi, 0x10(%rsp)
fildl 0x10(%rsp)
fstpt 0x14(%rsp)
testl %esi, %esi
cmovgl %esi, %r12d
pushq $0x10
popq %rbp
subl $0x1, %r12d
jb 0x8ec8
movl %r13d, 0xc(%rsp)
fildl 0xc(%rsp)
fmull 0x319a(%rip)            # 0xc038
fldt 0x14(%rsp)
fdivrp %st, %st(1)
fstpl 0x40(%rsp)
xorps %xmm0, %xmm0
movq %r14, %rdi
movsd 0x3182(%rip), %xmm1     # 0xc038
movq %r15, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xb5ca
incl %r13d
jmp 0x8e89
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rsp, %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rdi, 0x18(%r15)
leaq 0x8c12(%rip), %rax      # 0x11b10
movq %rax, (%r15)
movabsq $0x3fda31a385e77b3a, %rax # imm = 0x3FDA31A385E77B3A
movq %rax, 0x20(%r15)
movsd 0x3119(%rip), %xmm0     # 0xc030
movsd 0x30e9(%rip), %xmm1     # 0xc008
pushq $0x10
popq %rbp
movq %rsi, %rdi
movq %r15, %rsi
movq %rcx, %rdx
movl %ebp, %ecx
callq 0xb5ca
movabsq $-0x4025ce5c7a1884c6, %rax # imm = 0xBFDA31A385E77B3A
movq %rax, 0x20(%r15)
movq %r14, %rdi
movsd 0x30e5(%rip), %xmm0     # 0xc030
movsd 0x30b5(%rip), %xmm1     # 0xc008
movq %r15, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xb5ca
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rsp, %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rdi, 0x18(%r15)
leaq 0x8b7e(%rip), %rax      # 0x11b10
movq %rax, (%r15)
movabsq $0x3ff2959272ca4e4a, %rax # imm = 0x3FF2959272CA4E4A
movq %rax, 0x20(%r15)
movsd 0x3085(%rip), %xmm0     # 0xc030
movsd 0x3055(%rip), %xmm1     # 0xc008
pushq $0x10
popq %rbp
movq %rsi, %rdi
movq %r15, %rsi
movq %rcx, %rdx
movl %ebp, %ecx
callq 0xb5ca
movabsq $-0x400d6a6d8d35b1b6, %rax # imm = 0xBFF2959272CA4E4A
movq %rax, 0x20(%r15)
movq %r14, %rdi
movsd 0x3051(%rip), %xmm0     # 0xc030
movsd 0x3021(%rip), %xmm1     # 0xc008
movq %r15, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xb5ca
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop