LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yoavweiss[P]cache-digests-cuckoo/cuckoo.cpp
// Function: Cuckoo::hash(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
unsigned Cuckoo::hash(std::string key, unsigned entries) {
    // Given the following inputs:
    //
    // * `key`, an array of characters.
    // * `N`, an integer

    // 1. Let `hash-value` be the SHA-256 message digest {{RFC6234}} of `key`, truncated to 32 bits, expressed as an integer.
    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    SHA256_Update(&sha256, key.c_str(), key.size());
    SHA256_Final(hash, &sha256);
    // Truncate to 32 bits
    unsigned long hashValue = bigEndianRead((const unsigned char *)hash, SHA256_DIGEST_LENGTH - 4, 4);
    // 2. Return `hash-value` modulo N.
    return hashValue % entries;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x21a0
movq -0xb8(%rbp), %rdi
callq 0x2100
movq -0xb8(%rbp), %rdi
movq %rax, -0xb0(%rbp)
callq 0x21d0
movq -0xb0(%rbp), %rsi
movq %rax, %rdx
leaq -0xa0(%rbp), %rdi
callq 0x22f0
leaq -0x30(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2390
leaq -0x30(%rbp), %rdi
movl $0x1c, %esi
movl $0x4, %edx
callq 0x2b50
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movl -0xc(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: yoavweiss[P]cache-digests-cuckoo/cuckoo.cpp
// Function: Cuckoo::fingerprint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
unsigned long Cuckoo::fingerprint(std::string key, unsigned fingerprintSize) {
    // Given the following inputs:
    //
    // * `key`, an array of characters
    // * `f`, an integer indicating the number of output bits

    assert(fingerprintSize > 0);
    // 1. Let `hash-value` be the SHA-256 message digest {{RFC6234}} of `key`, expressed as an integer.
    unsigned char hash[SHA256_DIGEST_LENGTH];
    SHA256_CTX sha256;
    SHA256_Init(&sha256);
    SHA256_Update(&sha256, key.c_str(), key.size());
    SHA256_Final(hash, &sha256);
    unsigned long fingerprintValue;
    // Note: the implementation below diverges from the literal specified steps, but achieves the same goals.
    // 2. Let `h` be the number of bits in `hash-value`
    // 3. Let `fingerprint-value` be 0
    // 4. While `fingerprint-value` is 0 and `h` > `f`:
    for (unsigned i = SHA256_DIGEST_LENGTH * 8 - fingerprintSize; i >= fingerprintSize; i -= fingerprintSize) {
        // 1. Let `fingerprint-value` be the `f` least significant bits of `hash-value`.
        // 2. Let `hash-value` be the `h`-`f` most significant bits of `hash-value`.
        // 3. Substract `f` from `h`.
        fingerprintValue = readFingerprint(hash, i, fingerprintSize);
        if (fingerprintValue != 0)
            break;
    }
    // 5. If `fingerprint-value` is 0, let `fingerprint-value` be 1.
    if (fingerprintValue == 0)
        fingerprintValue = 1;
    // 6. Return `fingerprint-value`.
    return fingerprintValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jbe 0x2d81
jmp 0x2da0
leaq 0x3405(%rip), %rdi      # 0x618d
leaq 0x32bb(%rip), %rsi      # 0x604a
movl $0x12d, %edx            # imm = 0x12D
leaq 0x3406(%rip), %rcx      # 0x61a1
callq 0x21b0
leaq -0xa0(%rbp), %rdi
callq 0x21a0
movq -0xb8(%rbp), %rdi
callq 0x2100
movq -0xb8(%rbp), %rdi
movq %rax, -0xc0(%rbp)
callq 0x21d0
movq -0xc0(%rbp), %rsi
movq %rax, %rdx
leaq -0xa0(%rbp), %rdi
callq 0x22f0
leaq -0x30(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2390
movl $0x100, %eax            # imm = 0x100
subl -0xc(%rbp), %eax
movl %eax, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpl -0xc(%rbp), %eax
jb 0x2e44
leaq -0x30(%rbp), %rdi
movl -0xac(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x2f50
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
je 0x2e2f
jmp 0x2e44
jmp 0x2e31
movl -0xc(%rbp), %ecx
movl -0xac(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xac(%rbp)
jmp 0x2dff
cmpq $0x0, -0xa8(%rbp)
jne 0x2e59
movq $0x1, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: yoavweiss[P]cache-digests-cuckoo/cuckoo.cpp
// Function: Cuckoo::alternateHash(unsigned int, unsigned long, unsigned int)
unsigned Cuckoo::alternateHash(unsigned hash1, unsigned long fingerprintValue, unsigned entries) {
    // Given the following inputs:
    //
    // * `hash1`, an integer indicating the previous hash
    // * `fingerprint`, an integer indicating the fingerprint value
    // * `N`, an integer indicating the number of entries in the digest

    // Note: This is not thread safe (but a bit faster)!!!
    static char fingerprintString[20];
    // 1. Let `fingerprint-string` be the value of `fingerprint` in base 10, expressed as a string.
    sprintf((char*)fingerprintString, "%lu", fingerprintValue);
    // 2. Let `h2` be the return value of {{hash}} with `fingerprint-string` and `N` as inputs, XORed with `h1`.
    unsigned long hash2 = hash(std::string(fingerprintString), entries);
    hash2 ^= hash1;
    // 3. Return `hash2`.
    return hash2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x6370(%rip), %rdi      # 0x9200
movq %rdi, -0x68(%rbp)
leaq 0x3364(%rip), %rsi      # 0x61ff
xorl %eax, %eax
callq 0x2080
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2340
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x2280
jmp 0x2ec2
movl -0x14(%rbp), %esi
leaq -0x40(%rbp), %rdi
callq 0x2cc0
movl %eax, -0x6c(%rbp)
jmp 0x2ed3
movl -0x6c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2190
leaq -0x41(%rbp), %rdi
callq 0x2230
movq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %eax
xorq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2f31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2190
leaq -0x41(%rbp), %rdi
callq 0x2230
movq -0x50(%rbp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: yoavweiss[P]cache-digests-cuckoo/cuckoo.cpp
// Function: Cuckoo::readFingerprint(unsigned char const*, unsigned int, unsigned int)
unsigned long Cuckoo::readFingerprint(const unsigned char* hash, unsigned positionInBits, unsigned fingerprintSizeInBits) {
    const float Bits = 8.0;
    unsigned endPositionInBits = positionInBits + fingerprintSizeInBits;
    unsigned startPositionInBytes = floor((float)positionInBits / Bits);
    unsigned endPositionInBytes = ceil((float)endPositionInBits / Bits);
    unsigned lengthInBytes = endPositionInBytes - startPositionInBytes;
    unsigned long hashValue = bigEndianRead((const unsigned char *)(hash), startPositionInBytes, lengthInBytes);
    unsigned extraBitsAtStart = positionInBits - startPositionInBytes * Bits;
    unsigned extraBitsAtEnd = endPositionInBytes * Bits - endPositionInBits;
    unsigned extraBytes = sizeof(hashValue) - lengthInBytes;
    // TODO(yoav): There's probably a better way to do this, but I'm too jetlagged to think.
    hashValue <<= extraBytes * (unsigned)Bits + extraBitsAtStart;
    hashValue >>= extraBytes * (unsigned)Bits + extraBitsAtStart + extraBitsAtEnd;
    return hashValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x41000000, -0x14(%rbp) # imm = 0x41000000
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
cvtsi2ss %rax, %xmm0
movss 0x30ac(%rip), %xmm1     # 0x6030
movss %xmm1, -0x40(%rbp)
mulss %xmm1, %xmm0
callq 0x4360
movss -0x40(%rbp), %xmm1
cvttss2si %xmm0, %rax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cvtsi2ss %rax, %xmm0
mulss %xmm1, %xmm0
callq 0x4380
cvttss2si %xmm0, %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x2b50
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
cvtsi2ss %rax, %xmm0
movl -0x1c(%rbp), %eax
cvtsi2ss %rax, %xmm1
movss 0x3044(%rip), %xmm2     # 0x6034
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, -0x34(%rbp)
movl -0x20(%rbp), %eax
cvtsi2ss %rax, %xmm0
movl -0x18(%rbp), %eax
cvtsi2ss %rax, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
cvttss2si %xmm0, %rax
movl %eax, -0x38(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
movl $0x8, %eax
subq %rcx, %rax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %ecx
shll $0x3, %ecx
addl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movl -0x3c(%rbp), %ecx
shll $0x3, %ecx
addl -0x34(%rbp), %ecx
addl -0x38(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: yoavweiss[P]cache-digests-cuckoo/cuckoo.cpp
// Function: hex(unsigned char)
unsigned char hex(unsigned char input) {
    if (input >= '0' && input <= '9')
        return input - '0';
    if (input >= 'a' && input <= 'f') {
        return 10 + input - 'a';
    }
    if (input >= 'A' && input <= 'F') {
        return 10 + input - 'A';
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x30, %eax
jl 0x3988
movzbl -0x2(%rbp), %eax
cmpl $0x39, %eax
jg 0x3988
movzbl -0x2(%rbp), %eax
subl $0x30, %eax
movb %al, -0x1(%rbp)
jmp 0x39ce
movzbl -0x2(%rbp), %eax
cmpl $0x61, %eax
jl 0x39a9
movzbl -0x2(%rbp), %eax
cmpl $0x66, %eax
jg 0x39a9
movzbl -0x2(%rbp), %eax
addl $0xa, %eax
subl $0x61, %eax
movb %al, -0x1(%rbp)
jmp 0x39ce
movzbl -0x2(%rbp), %eax
cmpl $0x41, %eax
jl 0x39ca
movzbl -0x2(%rbp), %eax
cmpl $0x46, %eax
jg 0x39ca
movzbl -0x2(%rbp), %eax
addl $0xa, %eax
subl $0x41, %eax
movb %al, -0x1(%rbp)
jmp 0x39ce
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matthewarcus[P]mmps/./image.h
// Function: Image::GetRgb(long, Rgb&) const
inline void GetRgb(long i, Rgb& rgb) const {
#if defined UNALIGNED
    Rgb* p = reinterpret_cast<Rgb*>(data+i+i+i);
    rgb = *p;
#else
    Byte *p = reinterpret_cast<Byte*>(data+i+i+i);
    rgb.r = *p++;
    rgb.g = *p++;
    rgb.b = *p;
#endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x10(%rbp), %rax
addq -0x10(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matthewarcus[P]mmps/./image.h
// Function: Image::SetRgb(long, Rgb const&)
inline void SetRgb(long i, const Rgb& rgb) {
#if defined UNALIGNED
    Rgb* p = reinterpret_cast<Rgb *>(data+i+i+i);
    *p = rgb;
#else
    Byte *p = reinterpret_cast<Byte*>(data+i+i+i);
    *p++ = rgb.r;
    *p++ = rgb.g;
    *p = rgb.b;
#endif
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x10(%rbp), %rax
addq -0x10(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movb 0x2(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matthewarcus[P]mmps/matrix.cpp
// Function: Matrix3::Identity()
void Matrix3::Identity () {
  int i;
  for (i = 0; i < 9; i++) {
    Set(i,0.0);
  }
  for (i = 0; i < 9; i+=4){
    Set(i,1.0);
  }
  identity = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0x76fb
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
xorps %xmm0, %xmm0
callq 0x8050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x76db
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0x7727
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movsd 0xd931(%rip), %xmm0     # 0x15048
callq 0x8050
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x7702
movq -0x18(%rbp), %rax
movb $0x1, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matthewarcus[P]mmps/matrix.cpp
// Function: Matrix3::Matrix3(RotationAxis, double)
Matrix3::Matrix3(RotationAxis r, double theta)
{ 
  switch (r) {
  case XAxis: 
    {
      RotX(theta);
      break;
    }
  case YAxis: 
    {
      RotY(theta);
      break;
    }
  case ZAxis: 
    {
      RotZ(theta);
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x777c
jmp 0x7768
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x778c
jmp 0x7772
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x779c
jmp 0x77aa
movq -0x28(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x77b0
jmp 0x77aa
movq -0x28(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x78d0
jmp 0x77aa
movq -0x28(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x79f0
addq $0x30, %rsp
popq %rbp
retq
// File: matthewarcus[P]mmps/matrix.cpp
// Function: Matrix3::RotX(double)
void Matrix3::RotX (double theta) {
  if (theta == 0.0) {
    Identity();
  } else {
    Set(0, 1.0); Set(1, 0.0);        Set(2, 0.0);
    Set(3, 0.0); Set(4, cos(theta)); Set(5, -sin(theta));
    Set(6, 0.0); Set(7, sin(theta)); Set(8,  cos(theta));
    identity = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x77e7
jp 0x77e7
movq -0x18(%rbp), %rdi
callq 0x76c0
jmp 0x78bd
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movsd 0xd853(%rip), %xmm0     # 0x15048
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x1, %esi
xorps %xmm0, %xmm0
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x2, %esi
xorps %xmm0, %xmm0
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x3, %esi
xorps %xmm0, %xmm0
callq 0x8050
movsd -0x10(%rbp), %xmm0
callq 0x5470
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x8050
movsd -0x10(%rbp), %xmm0
callq 0x5080
movq -0x18(%rbp), %rdi
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movl $0x5, %esi
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x6, %esi
xorps %xmm0, %xmm0
callq 0x8050
movsd -0x10(%rbp), %xmm0
callq 0x5080
movq -0x18(%rbp), %rdi
movl $0x7, %esi
callq 0x8050
movsd -0x10(%rbp), %xmm0
callq 0x5470
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x8050
movq -0x18(%rbp), %rax
movb $0x0, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matthewarcus[P]mmps/matrix.cpp
// Function: Matrix3::RotY(double)
void Matrix3::RotY (double theta) {
  if (theta == 0.0) {
    Identity();
  } else {
    Set(0, cos(theta)); Set(1, 0.0); Set(2, -sin(theta));
    Set(3, 0.0);        Set(4, 1.0); Set(5, 0.0);
    Set(6, sin(theta)); Set(7, 0.0); Set(8, cos(theta));
    identity = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7907
jp 0x7907
movq -0x18(%rbp), %rdi
callq 0x76c0
jmp 0x79dd
movsd -0x10(%rbp), %xmm0
callq 0x5470
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x1, %esi
xorps %xmm0, %xmm0
callq 0x8050
movsd -0x10(%rbp), %xmm0
callq 0x5080
movq -0x18(%rbp), %rdi
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movl $0x2, %esi
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x3, %esi
xorps %xmm0, %xmm0
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x4, %esi
movsd 0xd6ca(%rip), %xmm0     # 0x15048
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x5, %esi
xorps %xmm0, %xmm0
callq 0x8050
movsd -0x10(%rbp), %xmm0
callq 0x5080
movq -0x18(%rbp), %rdi
movl $0x6, %esi
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x7, %esi
xorps %xmm0, %xmm0
callq 0x8050
movsd -0x10(%rbp), %xmm0
callq 0x5470
movq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x8050
movq -0x18(%rbp), %rax
movb $0x0, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matthewarcus[P]mmps/matrix.cpp
// Function: Matrix3::RotZ(double)
void Matrix3::RotZ (double theta) {
  if (theta == 0.0) {
    Identity();
  } else {
    Set(0, cos(theta)); Set(1, -sin(theta)); Set(2, 0.0);
    Set(3, sin(theta)); Set(4,  cos(theta)); Set(5, 0.0);
    Set(6, 0.0);        Set(7, 0.0);         Set(8, 1.0);
    identity = false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x7a27
jp 0x7a27
movq -0x18(%rbp), %rdi
callq 0x76c0
jmp 0x7afd
movsd -0x10(%rbp), %xmm0
callq 0x5470
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x8050
movsd -0x10(%rbp), %xmm0
callq 0x5080
movq -0x18(%rbp), %rdi
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movl $0x1, %esi
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x2, %esi
xorps %xmm0, %xmm0
callq 0x8050
movsd -0x10(%rbp), %xmm0
callq 0x5080
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x8050
movsd -0x10(%rbp), %xmm0
callq 0x5470
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x5, %esi
xorps %xmm0, %xmm0
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x6, %esi
xorps %xmm0, %xmm0
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x7, %esi
xorps %xmm0, %xmm0
callq 0x8050
movq -0x18(%rbp), %rdi
movl $0x8, %esi
movsd 0xd558(%rip), %xmm0     # 0x15048
callq 0x8050
movq -0x18(%rbp), %rax
movb $0x0, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x48(%rax)
je 0x7c4d
movq -0x18(%rbp), %rax
testb $0x1, 0x48(%rax)
je 0x7c3b
movq -0x30(%rbp), %rdi
callq 0x76c0
jmp 0x7c48
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7b40
jmp 0x7d8c
movq -0x18(%rbp), %rax
testb $0x1, 0x48(%rax)
je 0x7c69
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b40
jmp 0x7d8a
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x7d82
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x7d72
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
callq 0x80a0
movsd %xmm0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %edx
xorl %esi, %esi
callq 0x80a0
movaps %xmm0, %xmm2
movsd -0x48(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x1, %edx
callq 0x80a0
movsd %xmm0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %edx
movl $0x1, %esi
callq 0x80a0
movaps %xmm0, %xmm2
movsd -0x40(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x2, %edx
callq 0x80a0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %edx
movl $0x2, %esi
callq 0x80a0
movq -0x30(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movsd -0x28(%rbp), %xmm0
callq 0x80d0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7c81
jmp 0x7d74
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7c70
movq -0x30(%rbp), %rax
movb $0x0, 0x48(%rax)
jmp 0x7d8c
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: matthewarcus[P]mmps/matrix.cpp
// Function: Matrix3::Apply(double&, double&, double&) const
void Matrix3::Apply (double& x, double& y, double& z) const
{
  if (!identity) {
    double x1 = Get(0) * x + Get(1) * y + Get(2) * z;
    double y1 = Get(3) * x + Get(4) * y + Get(5) * z;
    double z1 = Get(6) * x + Get(7) * y + Get(8) * z;
    x = x1; y = y1; z = z1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0x48(%rax)
jne 0x7f5f
movq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x8080
movq -0x40(%rbp), %rdi
movsd %xmm0, -0x80(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movl $0x1, %esi
callq 0x8080
movsd -0x88(%rbp), %xmm2
movq -0x40(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x80(%rbp), %xmm0
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x78(%rbp)
movl $0x2, %esi
callq 0x8080
movsd -0x78(%rbp), %xmm1
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x3, %esi
callq 0x8080
movq -0x40(%rbp), %rdi
movsd %xmm0, -0x68(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movl $0x4, %esi
callq 0x8080
movsd -0x70(%rbp), %xmm2
movq -0x40(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movl $0x5, %esi
callq 0x8080
movsd -0x60(%rbp), %xmm1
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rax
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x6, %esi
callq 0x8080
movq -0x40(%rbp), %rdi
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movl $0x7, %esi
callq 0x8080
movsd -0x58(%rbp), %xmm2
movq -0x40(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
movq -0x18(%rbp), %rax
mulsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x8, %esi
callq 0x8080
movsd -0x48(%rbp), %xmm1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x48(%rax)
jne 0x8046
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x5470
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x5470
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
callq 0x5080
movsd %xmm0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x5470
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x5080
movq -0x38(%rbp), %rdi
movsd %xmm0, -0x30(%rbp)
leaq -0x20(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x7da0
movsd -0x30(%rbp), %xmm0
callq 0x53e0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x5050
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x5470
movsd %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x5470
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x5080
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x5470
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
callq 0x5080
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rdi
callq 0xddb0
testb $0x1, %al
jne 0x81ff
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x7da0
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
callq 0x53e0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x18(%rbp), %rax
movsd (%rax), %xmm1
callq 0x5050
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x5470
movsd %xmm0, -0x78(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5470
movaps %xmm0, %xmm1
movsd -0x78(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x5080
movsd %xmm0, -0x70(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5470
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5080
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x5470
movsd %xmm0, -0x68(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x5470
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x5080
movsd %xmm0, -0x60(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x5470
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x5080
movsd %xmm0, -0x50(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x40(%rbp), %xmm2
movsd -0x30(%rbp), %xmm0
mulsd -0x48(%rbp), %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
movsd -0x50(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x5280
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: matthewarcus[P]mmps/transform.cpp
// Function: Transform::CheckPoint(TransformParams const&, double, double) const
bool Transform::CheckPoint(const TransformParams &params, double phi, double lambda) const
{
  if (params.radius != 0 && 
      distance(phi,lambda,params.lat,params.lon) > params.radius) {
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsd 0x30(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x8ce0
jp 0x8ce0
jmp 0x8d12
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm3
callq 0x8210
movq -0x18(%rbp), %rax
ucomisd 0x30(%rax), %xmm0
jbe 0x8d12
movb $0x0, -0x1(%rbp)
jmp 0x8d16
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5470
movsd %xmm0, -0x50(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5080
movsd -0x58(%rbp), %xmm1
movsd -0x50(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x48(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5080
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x5470
movsd -0x40(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
movaps %xmm0, %xmm3
movsd -0x30(%rbp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movb $0x0, -0x39(%rbp)
movq -0x18(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x950f
jmp 0x9639
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x9538
jmp 0x9639
movq -0x10(%rbp), %rdi
callq 0x74e0
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7500
movq -0x68(%rbp), %rdi
movl %eax, -0x44(%rbp)
cvtsi2sdl -0x40(%rbp), %xmm1
movsd 0xbea7(%rip), %xmm0     # 0x15408
mulsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
cvtsi2sdl -0x44(%rbp), %xmm1
movsd 0xbe91(%rip), %xmm0     # 0x15408
mulsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movl -0x40(%rbp), %esi
movl -0x44(%rbp), %edx
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rax
divsd 0x28(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x95b0
jp 0x95b0
jmp 0x95c6
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x8d30
movsd -0x50(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
subsd 0xb0(%rax), %xmm1
divsd -0x60(%rbp), %xmm1
addsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x58(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
subsd 0xb8(%rax), %xmm1
movsd -0x60(%rbp), %xmm2
movq %xmm2, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x158(%rbp)
movq -0x10(%rbp), %rsi
callq 0x8500
leaq -0xb0(%rbp), %rdi
movl $0x1, %esi
movsd 0xae7d(%rip), %xmm0     # 0x15028
callq 0x7740
movq -0x158(%rbp), %rdx
addq $0x8, %rdx
leaq -0x60(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x7bb0
movq -0x158(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
movl $0x49, %edx
callq 0x5230
movq -0x158(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x160(%rbp)
leaq -0x150(%rbp), %rdi
movl $0x1, %esi
movsd 0xae16(%rip), %xmm0     # 0x15020
callq 0x7740
movq -0x160(%rbp), %rsi
leaq -0x100(%rbp), %rdi
leaq -0x150(%rbp), %rdx
callq 0x7bb0
movq -0x158(%rbp), %rdi
addq $0x58, %rdi
leaq -0x100(%rbp), %rsi
movl $0x49, %edx
callq 0x5230
movq -0x158(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0xa0(%rcx), %xmm0
movsd %xmm0, 0xc0(%rax)
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x41(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0xddd0
movsd %xmm0, -0x60(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0xddd0
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
addsd %xmm1, %xmm0
callq 0x5200
movq -0x10(%rbp), %rax
subsd 0xa8(%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movsd 0xa0(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
callq 0x5050
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x50(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa3d3
movq 0x10(%rbp), %rax
fldl (%rax)
fldl 0xace2(%rip)            # 0x15030
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jb 0xa3d3
jmp 0xa358
movq 0x10(%rbp), %rax
fldl (%rax)
fldl 0xaca4(%rip)            # 0x15008
fucompi %st(1), %st
fstp %st(0)
jb 0xa3d3
jmp 0xa36c
movq -0x68(%rbp), %rdi
movsd -0x50(%rbp), %xmm0
movq -0x40(%rbp), %rsi
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
movq -0x40(%rbp), %rax
fldl (%rax)
fldl 0xac9a(%rip)            # 0x15028
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jb 0xa3d1
jmp 0xa398
movq -0x40(%rbp), %rax
fldl (%rax)
fldl 0xac7c(%rip)            # 0x15020
fucompi %st(1), %st
fstp %st(0)
jb 0xa3d1
jmp 0xa3ac
movq -0x68(%rbp), %r9
movq -0x40(%rbp), %rdi
movq 0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
addq $0x8, %r9
callq 0x8110
movb $0x1, -0x41(%rbp)
jmp 0xa3d3
movb -0x41(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x8(%rbp), %r9
movq %r9, -0x60(%rbp)
movb $0x0, -0x31(%rbp)
addq $0x58, %r9
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
leaq -0x50(%rbp), %r8
callq 0x8110
movq -0x60(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x18(%rbp), %xmm0
movq (%rdi), %rax
leaq -0x58(%rbp), %rsi
callq *0x50(%rax)
testb $0x1, %al
jne 0xa44f
jmp 0xa4ea
movsd -0x58(%rbp), %xmm0
movq -0x10(%rbp), %rax
addsd 0xa8(%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
divsd 0xa0(%rax), %xmm0
callq 0x5080
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x58(%rbp), %xmm0
movq -0x10(%rbp), %rax
addsd 0xa8(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
divsd 0xa0(%rax), %xmm0
callq 0x5470
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movb $0x0, -0x41(%rbp)
movsd 0xc0(%rdi), %xmm0
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movq (%rdi), %rax
movq 0x58(%rax), %rax
callq *%rax
movq 0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq 0x10(%rbp), %rax
fldl (%rax)
fldl 0xaac4(%rip)            # 0x15030
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jb 0xa5d9
jmp 0xa576
movq 0x10(%rbp), %rax
fldl (%rax)
fldl 0xaa86(%rip)            # 0x15008
fucompi %st(1), %st
fstp %st(0)
jb 0xa5d9
jmp 0xa58a
movq -0x40(%rbp), %rax
fldl (%rax)
fldl 0xaa92(%rip)            # 0x15028
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jb 0xa5d9
jmp 0xa5a0
movq -0x40(%rbp), %rax
fldl (%rax)
fldl 0xaa74(%rip)            # 0x15020
fucompi %st(1), %st
fstp %st(0)
jb 0xa5d9
jmp 0xa5b4
movq -0x50(%rbp), %r9
movq -0x40(%rbp), %rdi
movq 0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
addq $0x8, %r9
callq 0x8110
movb $0x1, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movaps 0xaa43(%rip), %xmm1     # 0x154a0
pand %xmm1, %xmm0
callq 0x5450
movsd %xmm0, -0x18(%rbp)
movsd 0xa9ad(%rip), %xmm0     # 0x15420
mulsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm1
movsd 0xa5ba(%rip), %xmm2     # 0x15048
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x5280
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0xaacb
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movaps 0xa969(%rip), %xmm1     # 0x154a0
pand %xmm1, %xmm0
callq 0x5080
movaps %xmm0, %xmm1
movsd 0xa4fd(%rip), %xmm0     # 0x15048
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movaps 0xa940(%rip), %xmm1     # 0x154a0
pand %xmm1, %xmm0
callq 0x5470
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
divsd %xmm1, %xmm0
callq 0x5220
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0xabb3
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xadad
movsd -0x10(%rbp), %xmm0
callq 0x5470
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xaf85
movsd -0x10(%rbp), %xmm0
callq 0x5150
movsd 0xa4b7(%rip), %xmm1     # 0x15420
mulsd %xmm0, %xmm1
movsd 0xa0d3(%rip), %xmm0     # 0x15048
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0xddd0
movaps %xmm0, %xmm1
movsd 0xa429(%rip), %xmm0     # 0x15420
subsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0xa418(%rip), %xmm0     # 0x15420
mulsd -0x18(%rbp), %xmm0
callq 0xddd0
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x5200
movsd %xmm0, -0x40(%rbp)
movsd 0xa3e6(%rip), %xmm0     # 0x15420
mulsd -0x18(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd 0xa3d2(%rip), %xmm1     # 0x15428
ucomisd %xmm1, %xmm0
jb 0xb0e1
movsd 0x9fe0(%rip), %xmm0     # 0x15048
ucomisd -0x48(%rbp), %xmm0
jb 0xb0e1
movsd -0x48(%rbp), %xmm0
callq 0x53e0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd -0x38(%rbp), %xmm1
movsd 0xa38c(%rip), %xmm2     # 0x15428
addsd %xmm2, %xmm1
callq 0x5050
addsd %xmm0, %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
fldl (%rax)
fldl 0x9f73(%rip)            # 0x15030
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jb 0xb0df
jmp 0xb0c7
movq -0x28(%rbp), %rax
fldl (%rax)
fldl 0x9f35(%rip)            # 0x15008
fucompi %st(1), %st
fstp %st(0)
jb 0xb0df
jmp 0xb0db
movb $0x1, -0x29(%rbp)
jmp 0xb0e1
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)