#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
float atan2(float, float);
float cos(float);
float fabs(float);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/ *);
float sin(float);
float sqrt(float);
int /*<<< orphan*/ sscanf(char *, char *, ...);
int strcmp(char *, char *);
int E0000(FILE *wmmdat, int IENTRY, int *maxdeg, float alt, float glat,
          float glon, float t, float *dec, float *mdp, float *ti, float *gv) {
  static int maxord, i, icomp, n, m, j, D1, D2, D3, D4;
  static float c[13][13], cd[13][13], tc[13][13], dp[13][13], snorm[169],
      sp[13], cp[13], fn[13], fm[13], pp[13], k[13][13], pi, dtr, a, b, re, a2,
      b2, c2, a4, b4, c4, epoc, gnm, hnm, dgnm, dhnm, flnmj, otime, oalt, olat,
      olon, dt, rlon, rlat, srlon, srlat, crlon, crlat, srlat2, crlat2, q, q1,
      q2, ct, st, r2, r, d, ca, sa, aor, ar, br, bt, bp, bpp, par, temp1, temp2,
      parp, bx, by, bz, bh;
  static char model[20], c_str[81], c_new[5];
  static float *p = snorm;
  switch (IENTRY) {
  case 0:
    goto GEOMAG;
  case 1:
    goto GEOMG1;
  }
GEOMAG:
  maxord = *maxdeg;
  sp[0] = 0.0;
  cp[0] = *p = pp[0] = 1.0;
  dp[0][0] = 0.0;
  a = 6378.137;
  b = 6356.7523142;
  re = 6371.2;
  a2 = a * a;
  b2 = b * b;
  c2 = a2 - b2;
  a4 = a2 * a2;
  b4 = b2 * b2;
  c4 = a4 - b4;
  c[0][0] = 0.0;
  cd[0][0] = 0.0;
  fgets(c_str, 80, wmmdat);
  sscanf(c_str, "%f%s", &epoc, model);
S3:
  fgets(c_str, 80, wmmdat);
  for (i = 0; i < 4 && (c_str[i] != '\0'); i++) {
    c_new[i] = c_str[i];
    c_new[i + 1] = '\0';
  }
  icomp = strcmp("9999", c_new);
  if (icomp == 0)
    goto S4;
  sscanf(c_str, "%d%d%f%f%f%f", &n, &m, &gnm, &hnm, &dgnm, &dhnm);
  if (m <= n) {
    c[m][n] = gnm;
    cd[m][n] = dgnm;
    if (m != 0) {
      c[n][m - 1] = hnm;
      cd[n][m - 1] = dhnm;
    }
  }
  goto S3;
S4:
  *snorm = 1.0;
  for (n = 1; n <= maxord; n++) {
    *(snorm + n) = *(snorm + n - 1) * (float)(2 * n - 1) / (float)n;
    j = 2;
    for (m = 0, D1 = 1, D2 = (n - m + D1) / D1; D2 > 0; D2--, m += D1) {
      k[m][n] = (float)(((n - 1) * (n - 1)) - (m * m)) /
                (float)((2 * n - 1) * (2 * n - 3));
      if (m > 0) {
        flnmj = (float)((n - m + 1) * j) / (float)(n + m);
        *(snorm + n + m * 13) = *(snorm + n + (m - 1) * 13) * sqrt(flnmj);
        j = 1;
        c[n][m - 1] = *(snorm + n + m * 13) * c[n][m - 1];
        cd[n][m - 1] = *(snorm + n + m * 13) * cd[n][m - 1];
      }
      c[m][n] = *(snorm + n + m * 13) * c[m][n];
      cd[m][n] = *(snorm + n + m * 13) * cd[m][n];
    }
    fn[n] = (float)(n + 1);
    fm[n] = (float)n;
  }
  k[1][1] = 0.0;
  otime = oalt = olat = olon = -1000.0;
  return (0);
GEOMG1:
  dt = t - epoc;
  if (otime < 0.0 && (dt < 0.0 || dt > 5.0)) {
    *ti = epoc;
    return (-1);
  }
  pi = 3.14159265359;
  dtr = pi / 180.0;
  rlon = glon * dtr;
  rlat = glat * dtr;
  srlon = sin(rlon);
  srlat = sin(rlat);
  crlon = cos(rlon);
  crlat = cos(rlat);
  srlat2 = srlat * srlat;
  crlat2 = crlat * crlat;
  sp[1] = srlon;
  cp[1] = crlon;
  if (alt != oalt || glat != olat) {
    q = sqrt(a2 - c2 * srlat2);
    q1 = alt * q;
    q2 = ((q1 + a2) / (q1 + b2)) * ((q1 + a2) / (q1 + b2));
    ct = srlat / sqrt(q2 * crlat2 + srlat2);
    st = sqrt(1.0 - (ct * ct));
    r2 = (alt * alt) + 2.0 * q1 + (a4 - c4 * srlat2) / (q * q);
    r = sqrt(r2);
    d = sqrt(a2 * crlat2 + b2 * srlat2);
    ca = (alt + d) / r;
    sa = c2 * crlat * srlat / (r * d);
  }
  if (glon != olon) {
    for (m = 2; m <= maxord; m++) {
      sp[m] = sp[1] * cp[m - 1] + cp[1] * sp[m - 1];
      cp[m] = cp[1] * cp[m - 1] - sp[1] * sp[m - 1];
    }
  }
  aor = re / r;
  ar = aor * aor;
  br = bt = bp = bpp = 0.0;
  for (n = 1; n <= maxord; n++) {
    ar = ar * aor;
    for (m = 0, D3 = 1, D4 = (n + m + D3) / D3; D4 > 0; D4--, m += D3) {
      if (alt != oalt || glat != olat) {
        if (n == m) {
          *(p + n + m * 13) = st * *(p + n - 1 + (m - 1) * 13);
          dp[m][n] = st * dp[m - 1][n - 1] + ct * *(p + n - 1 + (m - 1) * 13);
          goto S50;
        }
        if (n == 1 && m == 0) {
          *(p + n + m * 13) = ct * *(p + n - 1 + m * 13);
          dp[m][n] = ct * dp[m][n - 1] - st * *(p + n - 1 + m * 13);
          goto S50;
        }
        if (n > 1 && n != m) {
          if (m > n - 2)
            *(p + n - 2 + m * 13) = 0.0;
          if (m > n - 2)
            dp[m][n - 2] = 0.0;
          *(p + n + m * 13) =
              ct * *(p + n - 1 + m * 13) - k[m][n] * *(p + n - 2 + m * 13);
          dp[m][n] = ct * dp[m][n - 1] - st * *(p + n - 1 + m * 13) -
                     k[m][n] * dp[m][n - 2];
        }
      }
    S50:
      if (t != otime) {
        tc[m][n] = c[m][n] + dt * cd[m][n];
        if (m != 0)
          tc[n][m - 1] = c[n][m - 1] + dt * cd[n][m - 1];
      }
      par = ar * *(p + n + m * 13);
      if (m == 0) {
        temp1 = tc[m][n] * cp[m];
        temp2 = tc[m][n] * sp[m];
      } else {
        temp1 = tc[m][n] * cp[m] + tc[n][m - 1] * sp[m];
        temp2 = tc[m][n] * sp[m] - tc[n][m - 1] * cp[m];
      }
      bt = bt - ar * temp1 * dp[m][n];
      bp += (fm[m] * temp2 * par);
      br += (fn[n] * temp1 * par);
      if (st == 0.0 && m == 1) {
        if (n == 1)
          pp[n] = pp[n - 1];
        else
          pp[n] = ct * pp[n - 1] - k[m][n] * pp[n - 2];
        parp = ar * pp[n];
        bpp += (fm[m] * temp2 * parp);
      }
    }
  }
  if (st == 0.0)
    bp = bpp;
  else
    bp /= st;
  bx = -bt * ca - br * sa;
  by = bp;
  bz = bt * sa - br * ca;
  bh = sqrt((bx * bx) + (by * by));
  *ti = sqrt((bh * bh) + (bz * bz));
  *dec = atan2(by, bx) / dtr;
  *mdp = atan2(bz, bh) / dtr;
  *gv = -999.0;
  if (fabs(glat) >= 55.) {
    if (glat > 0.0 && glon >= 0.0)
      *gv = *dec - glon;
    if (glat > 0.0 && glon < 0.0)
      *gv = *dec + fabs(glon);
    if (glat < 0.0 && glon >= 0.0)
      *gv = *dec + glon;
    if (glat < 0.0 && glon < 0.0)
      *gv = *dec - fabs(glon);
    if (*gv > +180.0)
      *gv -= 360.0;
    if (*gv < -180.0)
      *gv += 360.0;
  }
  otime = t;
  oalt = alt;
  olat = glat;
  olon = glon;
  return (0);
}


x86 assembly (clang, -O0):
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
movss  %xmm1,-0x28(%rbp)
movss  %xmm2,-0x2c(%rbp)
movss  %xmm3,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x4c(%rbp)
test   %eax,%eax
je     11db <E0000+0x5b>
jmp    11ca <E0000+0x4a>
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
je     11e0 <E0000+0x60>
jmp    11e5 <E0000+0x65>
jmp    11ea <E0000+0x6a>
jmp    1999 <E0000+0x819>
jmp    11ea <E0000+0x6a>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x3e8a(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x4c1f(%rip)
movss  0x1e3b(%rip),%xmm0
movss  %xmm0,0x4d0f(%rip)
mov    0x3e48(%rip),%rax
movss  0x1e24(%rip),%xmm0
movss  %xmm0,(%rax)
movss  0x1e18(%rip),%xmm0
movss  %xmm0,0x4c2c(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x4681(%rip)
movss  0x1df9(%rip),%xmm0
movss  %xmm0,0x4fbd(%rip)
movss  0x1de5(%rip),%xmm0
movss  %xmm0,0x4fb1(%rip)
movss  0x1dd1(%rip),%xmm0
movss  %xmm0,0x4fa5(%rip)
movss  0x4f95(%rip),%xmm0
mulss  0x4f8d(%rip),%xmm0
movss  %xmm0,0x4f91(%rip)
movss  0x4f81(%rip),%xmm0
mulss  0x4f79(%rip),%xmm0
movss  %xmm0,0x4f7d(%rip)
movss  0x4f71(%rip),%xmm0
subss  0x4f6d(%rip),%xmm0
movss  %xmm0,0x4f69(%rip)
movss  0x4f59(%rip),%xmm0
mulss  0x4f51(%rip),%xmm0
movss  %xmm0,0x4f55(%rip)
movss  0x4f45(%rip),%xmm0
mulss  0x4f3d(%rip),%xmm0
movss  %xmm0,0x4f41(%rip)
movss  0x4f35(%rip),%xmm0
subss  0x4f31(%rip),%xmm0
movss  %xmm0,0x4f2d(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x3da6(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x404b(%rip)
mov    -0x10(%rbp),%rdx
lea    0x4fe0(%rip),%rdi
mov    $0x50,%esi
call   1040 <fgets@plt>
lea    0x4fcf(%rip),%rdi
lea    0x1d14(%rip),%rsi
lea    0x4ef1(%rip),%rdx
lea    0x4f9a(%rip),%rcx
mov    $0x0,%al
call   1080 <sscanf@plt>
mov    -0x10(%rbp),%rdx
lea    0x4fa8(%rip),%rdi
mov    $0x50,%esi
call   1040 <fgets@plt>
movl   $0x0,0x3d18(%rip)
xor    %eax,%eax
cmpl   $0x4,0x3d0f(%rip)
mov    %al,-0x4d(%rbp)
jge    1399 <E0000+0x219>
movslq 0x3cff(%rip),%rcx
lea    0x4f74(%rip),%rax
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x4d(%rbp)
mov    -0x4d(%rbp),%al
test   $0x1,%al
jne    13a9 <E0000+0x229>
jmp    13f6 <E0000+0x276>
movslq 0x3cd4(%rip),%rcx
lea    0x4f49(%rip),%rax
mov    (%rax,%rcx,1),%dl
movslq 0x3cc3(%rip),%rcx
lea    0x4f89(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    0x3cb3(%rip),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    0x4f73(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
mov    0x3c9c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3c93(%rip)
jmp    136c <E0000+0x1ec>
lea    0x1c54(%rip),%rdi
lea    0x4f4d(%rip),%rsi
call   1060 <strcmp@plt>
mov    %eax,0x3c79(%rip)
cmpl   $0x0,0x3c72(%rip)
jne    1421 <E0000+0x2a1>
jmp    1540 <E0000+0x3c0>
lea    0x4ed8(%rip),%rdi
lea    0x1c27(%rip),%rsi
lea    0x3c56(%rip),%rdx
lea    0x3c53(%rip),%rcx
lea    0x4df0(%rip),%r8
lea    0x4ded(%rip),%r9
lea    0x4dea(%rip),%r10
lea    0x4de7(%rip),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1080 <sscanf@plt>
mov    0x3c21(%rip),%eax
cmp    0x3c17(%rip),%eax
jg     153b <E0000+0x3bb>
movss  0x4db1(%rip),%xmm0
movslq 0x3c06(%rip),%rcx
lea    0x3c1f(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x3bed(%rip),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x4d90(%rip),%xmm0
movslq 0x3bdd(%rip),%rcx
lea    0x3ea6(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x3bc4(%rip),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,0x3bbc(%rip)
je     1536 <E0000+0x3b6>
movss  0x4d56(%rip),%xmm0
movslq 0x3ba3(%rip),%rcx
lea    0x3bc0(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x3b93(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x4d30(%rip),%xmm0
movslq 0x3b75(%rip),%rcx
lea    0x3e42(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x3b65(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    153b <E0000+0x3bb>
jmp    134d <E0000+0x1cd>
movss  0x1afc(%rip),%xmm0
movss  %xmm0,0x4620(%rip)
movl   $0x1,0x3b32(%rip)
mov    0x3b2c(%rip),%eax
cmp    0x3b1a(%rip),%eax
jg     1942 <E0000+0x7c2>
movslq 0x3b19(%rip),%rcx
lea    0x45f6(%rip),%rax
movss  -0x4(%rax,%rcx,4),%xmm0
mov    0x3b06(%rip),%eax
shl    $0x1,%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
mulss  %xmm1,%xmm0
cvtsi2ssl 0x3af0(%rip),%xmm1
divss  %xmm1,%xmm0
movslq 0x3ae5(%rip),%rcx
lea    0x45c2(%rip),%rax
movss  %xmm0,(%rax,%rcx,4)
movl   $0x2,0x3ad7(%rip)
movl   $0x0,0x3ac9(%rip)
movl   $0x1,0x3ac7(%rip)
mov    0x3ab5(%rip),%eax
sub    0x3ab3(%rip),%eax
add    0x3ab5(%rip),%eax
cltd
idivl  0x3aae(%rip)
mov    %eax,0x3aac(%rip)
cmpl   $0x0,0x3aa5(%rip)
jle    18f3 <E0000+0x773>
mov    0x3a89(%rip),%eax
sub    $0x1,%eax
mov    0x3a80(%rip),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    0x3a78(%rip),%ecx
imul   0x3a71(%rip),%ecx
sub    %ecx,%eax
cvtsi2ss %eax,%xmm0
mov    0x3a61(%rip),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    0x3a55(%rip),%ecx
shl    $0x1,%ecx
sub    $0x3,%ecx
imul   %ecx,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
movslq 0x3a41(%rip),%rcx
lea    0x490a(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x3a28(%rip),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,0x3a20(%rip)
jle    1801 <E0000+0x681>
mov    0x3a10(%rip),%eax
sub    0x3a0e(%rip),%eax
add    $0x1,%eax
imul   0x3a08(%rip),%eax
cvtsi2ss %eax,%xmm0
mov    0x39f6(%rip),%eax
add    0x39f4(%rip),%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,0x4b98(%rip)
movslq 0x39d9(%rip),%rcx
lea    0x44b6(%rip),%rax
shl    $0x2,%rcx
add    %rcx,%rax
mov    0x39c9(%rip),%ecx
sub    $0x1,%ecx
imul   $0xd,%ecx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  0x4b62(%rip),%xmm0
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mulss  %xmm1,%xmm0
movslq 0x3992(%rip),%rcx
lea    0x446f(%rip),%rax
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x3981(%rip),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,0x3973(%rip)
movslq 0x3964(%rip),%rcx
lea    0x4441(%rip),%rax
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x3953(%rip),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3940(%rip),%rcx
lea    0x395d(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x3930(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movslq 0x391a(%rip),%rcx
lea    0x3937(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x390a(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq 0x38f4(%rip),%rcx
lea    0x43d1(%rip),%rax
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x38e3(%rip),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x38d0(%rip),%rcx
lea    0x3b9d(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x38c0(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movslq 0x38aa(%rip),%rcx
lea    0x3b77(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x389a(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq 0x3884(%rip),%rcx
lea    0x4361(%rip),%rax
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x3873(%rip),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x3864(%rip),%rcx
lea    0x387d(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x384b(%rip),%rcx
mulss  (%rax,%rcx,4),%xmm0
movslq 0x3843(%rip),%rcx
lea    0x385c(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x382a(%rip),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq 0x381e(%rip),%rcx
lea    0x42fb(%rip),%rax
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x380d(%rip),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x37fe(%rip),%rcx
lea    0x3ac7(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x37e5(%rip),%rcx
mulss  (%rax,%rcx,4),%xmm0
movslq 0x37dd(%rip),%rcx
lea    0x3aa6(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x37c4(%rip),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x37c9(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x37c0(%rip)
mov    0x37b6(%rip),%eax
add    0x37a8(%rip),%eax
mov    %eax,0x37a2(%rip)
jmp    15f0 <E0000+0x470>
mov    0x3793(%rip),%eax
add    $0x1,%eax
cvtsi2ss %eax,%xmm0
movslq 0x3785(%rip),%rcx
lea    0x4592(%rip),%rax
movss  %xmm0,(%rax,%rcx,4)
cvtsi2ssl 0x3771(%rip),%xmm0
movslq 0x376a(%rip),%rcx
lea    0x45b7(%rip),%rax
movss  %xmm0,(%rax,%rcx,4)
mov    0x3758(%rip),%eax
add    $0x1,%eax
mov    %eax,0x374f(%rip)
jmp    155a <E0000+0x3da>
xorps  %xmm0,%xmm0
movss  %xmm0,0x464b(%rip)
movss  0x16f3(%rip),%xmm0
movss  %xmm0,0x48f7(%rip)
movss  0x16e3(%rip),%xmm0
movss  %xmm0,0x48e3(%rip)
movss  0x16d3(%rip),%xmm0
movss  %xmm0,0x48cf(%rip)
movss  0x16c3(%rip),%xmm0
movss  %xmm0,0x48bb(%rip)
movl   $0x0,-0x4(%rbp)
jmp    2ccc <E0000+0x1b4c>
movss  -0x30(%rbp),%xmm0
subss  0x488a(%rip),%xmm0
movss  %xmm0,0x48aa(%rip)
movss  0x4892(%rip),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1a1a <E0000+0x89a>
movss  0x4889(%rip),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
ja     19fe <E0000+0x87e>
movss  0x4870(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x160c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1a1a <E0000+0x89a>
movss  0x482a(%rip),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0xffffffff,-0x4(%rbp)
jmp    2ccc <E0000+0x1b4c>
movss  0x160e(%rip),%xmm0
movss  %xmm0,0x47da(%rip)
movss  0x47d2(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x15ca(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x47ba(%rip)
movss  -0x2c(%rbp),%xmm0
mulss  0x47ad(%rip),%xmm0
movss  %xmm0,0x47f9(%rip)
movss  -0x28(%rbp),%xmm0
mulss  0x4798(%rip),%xmm0
movss  %xmm0,0x47e8(%rip)
movss  0x47dc(%rip),%xmm0
call   1070 <sin@plt>
movss  %xmm0,0x47d7(%rip)
movss  0x47cb(%rip),%xmm0
call   1070 <sin@plt>
movss  %xmm0,0x47c6(%rip)
movss  0x47b2(%rip),%xmm0
call   1090 <cos@plt>
movss  %xmm0,0x47b5(%rip)
movss  0x47a1(%rip),%xmm0
call   1090 <cos@plt>
movss  %xmm0,0x47a4(%rip)
movss  0x4794(%rip),%xmm0
mulss  0x478c(%rip),%xmm0
movss  %xmm0,0x4790(%rip)
movss  0x4784(%rip),%xmm0
mulss  0x477c(%rip),%xmm0
movss  %xmm0,0x477c(%rip)
movss  0x4760(%rip),%xmm0
movss  %xmm0,0x4318(%rip)
movss  0x4758(%rip),%xmm0
movss  %xmm0,0x4348(%rip)
movss  -0x24(%rbp),%xmm0
ucomiss 0x4724(%rip),%xmm0
jne    1b51 <E0000+0x9d1>
jp     1b51 <E0000+0x9d1>
movss  -0x28(%rbp),%xmm0
ucomiss 0x4710(%rip),%xmm0
jne    1b51 <E0000+0x9d1>
jp     1b51 <E0000+0x9d1>
jmp    1d7d <E0000+0xbfd>
movss  0x46bf(%rip),%xmm1
movss  0x46bf(%rip),%xmm0
movss  0x470b(%rip),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movss  %xmm0,0x46f1(%rip)
movss  -0x24(%rbp),%xmm0
mulss  0x46e4(%rip),%xmm0
movss  %xmm0,0x46e0(%rip)
movss  0x46d8(%rip),%xmm0
addss  0x4668(%rip),%xmm0
movss  0x46c8(%rip),%xmm1
addss  0x465c(%rip),%xmm1
divss  %xmm1,%xmm0
movss  0x46b4(%rip),%xmm1
addss  0x4644(%rip),%xmm1
movss  0x46a4(%rip),%xmm2
addss  0x4638(%rip),%xmm2
divss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,0x4690(%rip)
movss  0x466c(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0x467b(%rip),%xmm0
movss  0x4667(%rip),%xmm2
movss  0x465b(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x464e(%rip)
movss  0x4646(%rip),%xmm0
mulss  0x463e(%rip),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x13ba(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   10a0 <sqrt@plt>
movss  %xmm0,0x4621(%rip)
movss  -0x24(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  0x45ff(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movss  0x458f(%rip),%xmm2
movss  0x458f(%rip),%xmm1
movss  0x45cf(%rip),%xmm3
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  0x45ba(%rip),%xmm2
mulss  0x45b2(%rip),%xmm2
divss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x45ae(%rip)
movss  0x45a6(%rip),%xmm0
call   10a0 <sqrt@plt>
movss  %xmm0,0x459d(%rip)
movss  0x4519(%rip),%xmm0
movss  0x4571(%rip),%xmm2
movss  0x450d(%rip),%xmm1
mulss  0x455d(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movss  %xmm0,0x456c(%rip)
movss  -0x24(%rbp),%xmm0
addss  0x455f(%rip),%xmm0
divss  0x4553(%rip),%xmm0
movss  %xmm0,0x4553(%rip)
movss  0x44cf(%rip),%xmm0
mulss  0x4517(%rip),%xmm0
mulss  0x4507(%rip),%xmm0
movss  0x452b(%rip),%xmm1
mulss  0x4527(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,0x4523(%rip)
movss  -0x2c(%rbp),%xmm0
ucomiss 0x44cb(%rip),%xmm0
jne    1d9a <E0000+0xc1a>
jp     1d9a <E0000+0xc1a>
jmp    1e92 <E0000+0xd12>
movl   $0x2,0x32ec(%rip)
mov    0x32e6(%rip),%eax
cmp    0x32d0(%rip),%eax
jg     1e8d <E0000+0xd0d>
movss  0x4066(%rip),%xmm0
mov    0x32cc(%rip),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x408f(%rip),%rax
movss  (%rax,%rcx,4),%xmm2
movss  0x4086(%rip),%xmm1
mov    0x32ac(%rip),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x402f(%rip),%rax
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq 0x328b(%rip),%rcx
lea    0x4014(%rip),%rax
movss  %xmm0,(%rax,%rcx,4)
movss  0x404b(%rip),%xmm0
mov    0x3271(%rip),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x4034(%rip),%rax
movss  (%rax,%rcx,4),%xmm2
movss  0x3feb(%rip),%xmm1
mov    0x3251(%rip),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x3fd4(%rip),%rax
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq 0x3223(%rip),%rcx
lea    0x3fec(%rip),%rax
movss  %xmm0,(%rax,%rcx,4)
mov    0x3211(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3208(%rip)
jmp    1da4 <E0000+0xc24>
jmp    1e92 <E0000+0xd12>
movss  0x437a(%rip),%xmm0
divss  0x43f2(%rip),%xmm0
movss  %xmm0,0x43fa(%rip)
movss  0x43f2(%rip),%xmm0
mulss  0x43ea(%rip),%xmm0
movss  %xmm0,0x43e6(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x43eb(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x43dc(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x43cd(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,0x43be(%rip)
movl   $0x1,0x3194(%rip)
mov    0x318e(%rip),%eax
cmp    0x317c(%rip),%eax
jg     2915 <E0000+0x1795>
movss  0x4396(%rip),%xmm0
mulss  0x438a(%rip),%xmm0
movss  %xmm0,0x4386(%rip)
movl   $0x0,0x3164(%rip)
movl   $0x1,0x316a(%rip)
mov    0x3150(%rip),%eax
add    0x314e(%rip),%eax
add    0x3158(%rip),%eax
cltd
idivl  0x3151(%rip)
mov    %eax,0x314f(%rip)
cmpl   $0x0,0x3148(%rip)
jle    28fc <E0000+0x177c>
movss  -0x24(%rbp),%xmm0
ucomiss 0x42de(%rip),%xmm0
jne    1f97 <E0000+0xe17>
jp     1f97 <E0000+0xe17>
movss  -0x28(%rbp),%xmm0
ucomiss 0x42ca(%rip),%xmm0
jne    1f97 <E0000+0xe17>
jp     1f97 <E0000+0xe17>
jmp    23cf <E0000+0x124f>
mov    0x30ef(%rip),%eax
cmp    0x30ed(%rip),%eax
jne    2092 <E0000+0xf12>
movss  0x42db(%rip),%xmm0
mov    0x30a8(%rip),%rax
movslq 0x30cd(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    0x30c4(%rip),%ecx
sub    $0x1,%ecx
imul   $0xd,%ecx,%ecx
movslq %ecx,%rcx
mulss  -0x4(%rax,%rcx,4),%xmm0
mov    0x307e(%rip),%rax
movslq 0x30a3(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x3099(%rip),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x4285(%rip),%xmm0
mov    0x3083(%rip),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x38a6(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x3065(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  0x424e(%rip),%xmm1
mov    0x301f(%rip),%rax
movslq 0x3044(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    0x303b(%rip),%ecx
sub    $0x1,%ecx
imul   $0xd,%ecx,%ecx
movslq %ecx,%rcx
mulss  -0x4(%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq 0x301d(%rip),%rcx
lea    0x3846(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x3004(%rip),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    23d4 <E0000+0x1254>
cmpl   $0x1,0x2ff3(%rip)
jne    2193 <E0000+0x1013>
cmpl   $0x0,0x2fea(%rip)
jne    2193 <E0000+0x1013>
movss  0x41d4(%rip),%xmm0
mov    0x2fa5(%rip),%rax
movslq 0x2fca(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x2fc0(%rip),%ecx
movslq %ecx,%rcx
mulss  -0x4(%rax,%rcx,4),%xmm0
mov    0x2f80(%rip),%rax
movslq 0x2fa5(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x2f9b(%rip),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x4183(%rip),%xmm0
movslq 0x2f84(%rip),%rcx
lea    0x37ad(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x2f6c(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  0x4159(%rip),%xmm1
mov    0x2f26(%rip),%rax
movslq 0x2f4b(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x2f41(%rip),%ecx
movslq %ecx,%rcx
mulss  -0x4(%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq 0x2f1c(%rip),%rcx
lea    0x3745(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x2f03(%rip),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    23d4 <E0000+0x1254>
cmpl   $0x1,0x2ef2(%rip)
jle    23ca <E0000+0x124a>
mov    0x2ee6(%rip),%eax
cmp    0x2ee4(%rip),%eax
je     23ca <E0000+0x124a>
mov    0x2ed8(%rip),%eax
mov    0x2ece(%rip),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jle    21f1 <E0000+0x1071>
mov    0x2e90(%rip),%rax
movslq 0x2eb5(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x2eab(%rip),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8(%rax,%rcx,4)
mov    0x2e99(%rip),%eax
mov    0x2e8f(%rip),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jle    2231 <E0000+0x10b1>
movslq 0x2e81(%rip),%rcx
lea    0x36aa(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x2e69(%rip),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x404f(%rip),%xmm0
mov    0x2e20(%rip),%rax
movslq 0x2e45(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x2e3b(%rip),%ecx
movslq %ecx,%rcx
movss  -0x4(%rax,%rcx,4),%xmm2
movslq 0x2e2b(%rip),%rcx
lea    0x3cf4(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x2e12(%rip),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x2dda(%rip),%rax
movslq 0x2dff(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x2df5(%rip),%ecx
movslq %ecx,%rcx
mulss  -0x8(%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x2da0(%rip),%rax
movslq 0x2dc5(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x2dbb(%rip),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  0x3fa3(%rip),%xmm1
movslq 0x2da4(%rip),%rcx
lea    0x35cd(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x2d8c(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  0x3f79(%rip),%xmm0
mov    0x2d46(%rip),%rax
movslq 0x2d6b(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x2d61(%rip),%ecx
movslq %ecx,%rcx
mulss  -0x4(%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movslq 0x2d3c(%rip),%rcx
lea    0x3c05(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x2d23(%rip),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x2d1b(%rip),%rcx
lea    0x3544(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x2d03(%rip),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq 0x2ce0(%rip),%rcx
lea    0x3509(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x2cc7(%rip),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    23cf <E0000+0x124f>
jmp    23d4 <E0000+0x1254>
movss  -0x30(%rbp),%xmm0
ucomiss 0x3e68(%rip),%xmm0
jne    23f1 <E0000+0x1271>
jp     23f1 <E0000+0x1271>
jmp    24f8 <E0000+0x1378>
movslq 0x2c98(%rip),%rcx
lea    0x2cb1(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x2c7f(%rip),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x3e3e(%rip),%xmm0
movslq 0x2c6f(%rip),%rcx
lea    0x2f38(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x2c56(%rip),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq 0x2c46(%rip),%rcx
lea    0x31bf(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x2c2d(%rip),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,0x2c25(%rip)
je     24f3 <E0000+0x1373>
movslq 0x2c14(%rip),%rcx
lea    0x2c31(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x2c04(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x3db9(%rip),%xmm0
movslq 0x2be6(%rip),%rcx
lea    0x2eb3(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x2bd6(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq 0x2bb8(%rip),%rcx
lea    0x3135(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x2ba8(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    24f8 <E0000+0x1378>
movss  0x3da8(%rip),%xmm0
mov    0x2b59(%rip),%rax
movslq 0x2b7e(%rip),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
imul   $0xd,0x2b74(%rip),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x3d90(%rip)
cmpl   $0x0,0x2b5d(%rip)
jne    25b6 <E0000+0x1436>
movslq 0x2b50(%rip),%rcx
lea    0x30c9(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x2b37(%rip),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x2b2f(%rip),%rcx
lea    0x38f8(%rip),%rax
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x3d4b(%rip)
movslq 0x2b14(%rip),%rcx
lea    0x308d(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x2afb(%rip),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x2af3(%rip),%rcx
lea    0x387c(%rip),%rax
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x3d13(%rip)
jmp    26bd <E0000+0x153d>
movslq 0x2ad3(%rip),%rcx
lea    0x304c(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x2aba(%rip),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x2ab2(%rip),%rcx
lea    0x387b(%rip),%rax
movss  (%rax,%rcx,4),%xmm2
movslq 0x2a9b(%rip),%rcx
lea    0x3018(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x2a8b(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movslq 0x2a79(%rip),%rcx
lea    0x3802(%rip),%rax
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x3c8d(%rip)
movslq 0x2a56(%rip),%rcx
lea    0x2fcf(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x2a3d(%rip),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq 0x2a35(%rip),%rcx
lea    0x37be(%rip),%rax
movss  (%rax,%rcx,4),%xmm2
movslq 0x2a1e(%rip),%rcx
lea    0x2f9b(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
mov    0x2a0e(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movslq 0x29fc(%rip),%rcx
lea    0x37c5(%rip),%rax
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x3c07(%rip)
movss  0x3beb(%rip),%xmm1
movss  0x3bdb(%rip),%xmm0
mulss  0x3beb(%rip),%xmm0
movslq 0x29b4(%rip),%rcx
lea    0x31dd(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x299b(%rip),%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x3b9d(%rip)
movslq 0x2976(%rip),%rcx
lea    0x37bf(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
mulss  0x3b96(%rip),%xmm0
movss  0x3b86(%rip),%xmm2
movss  0x3b76(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x3b66(%rip)
movslq 0x2937(%rip),%rcx
lea    0x3744(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
mulss  0x3b57(%rip),%xmm0
movss  0x3b4b(%rip),%xmm2
movss  0x3b33(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x3b23(%rip)
movss  0x3afb(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    28d1 <E0000+0x1751>
jp     28d1 <E0000+0x1751>
cmpl   $0x1,0x28e1(%rip)
jne    28d1 <E0000+0x1751>
cmpl   $0x1,0x28d0(%rip)
jne    27f2 <E0000+0x1672>
mov    0x28c4(%rip),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x374b(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
movslq 0x28ab(%rip),%rcx
lea    0x3738(%rip),%rax
movss  %xmm0,(%rax,%rcx,4)
jmp    2873 <E0000+0x16f3>
movss  0x3a8e(%rip),%xmm0
mov    0x288c(%rip),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x3713(%rip),%rax
movss  (%rax,%rcx,4),%xmm2
movslq 0x2877(%rip),%rcx
lea    0x3740(%rip),%rax
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq 0x285e(%rip),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x2853(%rip),%eax
sub    $0x2,%eax
movslq %eax,%rcx
lea    0x36da(%rip),%rax
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq 0x2825(%rip),%rcx
lea    0x36b2(%rip),%rax
movss  %xmm0,(%rax,%rcx,4)
movss  0x3a2d(%rip),%xmm0
movslq 0x280a(%rip),%rcx
lea    0x3697(%rip),%rax
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,0x3a32(%rip)
movslq 0x27f3(%rip),%rcx
lea    0x363c(%rip),%rax
movss  (%rax,%rcx,4),%xmm0
mulss  0x3a13(%rip),%xmm0
movss  0x3a0f(%rip),%xmm2
movss  0x39f7(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x39e7(%rip)
jmp    28d6 <E0000+0x1756>
mov    0x27c8(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x27bf(%rip)
mov    0x27b5(%rip),%eax
add    0x279f(%rip),%eax
mov    %eax,0x2799(%rip)
jmp    1f55 <E0000+0xdd5>
jmp    2901 <E0000+0x1781>
mov    0x2785(%rip),%eax
add    $0x1,%eax
mov    %eax,0x277c(%rip)
jmp    1ef8 <E0000+0xd78>
movss  0x396f(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2949 <E0000+0x17c9>
jp     2949 <E0000+0x17c9>
movss  0x397c(%rip),%xmm0
movss  %xmm0,0x3970(%rip)
jmp    2965 <E0000+0x17e5>
movss  0x393b(%rip),%xmm1
movss  0x395b(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x394f(%rip)
movss  0x3943(%rip),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  0x391a(%rip),%xmm2
movss  0x3922(%rip),%xmm1
mulss  0x390e(%rip),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x391d(%rip)
movss  0x38fd(%rip),%xmm0
movss  %xmm0,0x3911(%rip)
movss  0x38e9(%rip),%xmm0
movss  0x38d1(%rip),%xmm2
movss  0x38d5(%rip),%xmm1
mulss  0x38bd(%rip),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x38d8(%rip)
movss  0x38c8(%rip),%xmm0
movss  0x38c0(%rip),%xmm2
movss  0x38bc(%rip),%xmm1
mulss  0x38b4(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movss  %xmm0,0x38a7(%rip)
movss  0x389f(%rip),%xmm0
movss  0x3897(%rip),%xmm2
movss  0x388b(%rip),%xmm1
mulss  0x3883(%rip),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  0x3862(%rip),%xmm0
movss  0x3856(%rip),%xmm1
call   1030 <atan2@plt>
divss  0x3785(%rip),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movss  0x3841(%rip),%xmm0
movss  0x383d(%rip),%xmm1
call   1030 <atan2@plt>
divss  0x3760(%rip),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movss  0x578(%rip),%xmm0
movss  %xmm0,(%rax)
movss  -0x28(%rbp),%xmm0
call   1050 <fabs@plt>
cvtss2sd %xmm0,%xmm0
movsd  0x542(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     2c91 <E0000+0x1b11>
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2b21 <E0000+0x19a1>
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2b21 <E0000+0x19a1>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
subss  -0x2c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2b78 <E0000+0x19f8>
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    2b78 <E0000+0x19f8>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x2c(%rbp),%xmm0
call   1050 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
addss  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    2bb9 <E0000+0x1a39>
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2bb9 <E0000+0x1a39>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x2c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    2c10 <E0000+0x1a90>
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    2c10 <E0000+0x1a90>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x2c(%rbp),%xmm0
call   1050 <fabs@plt>
movaps %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
subss  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3e4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    2c4e <E0000+0x1ace>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3de(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x3c6(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    2c8c <E0000+0x1b0c>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3a0(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
jmp    2c91 <E0000+0x1b11>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,0x35aa(%rip)
movss  -0x24(%rbp),%xmm0
movss  %xmm0,0x35a1(%rip)
movss  -0x28(%rbp),%xmm0
movss  %xmm0,0x3598(%rip)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,0x358f(%rip)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
cmp    $0x1,%esi
jne    12ec <E0000+0x18c>
mov    %r9,%rbx
mov    %r8,%r15
mov    %rcx,%r12
movaps %xmm0,%xmm6
movss  0x5062(%rip),%xmm0
movaps %xmm3,%xmm4
subss  %xmm0,%xmm4
movss  %xmm4,0x5077(%rip)
xorps  %xmm5,%xmm5
ucomiss 0x505d(%rip),%xmm5
jbe    11bf <E0000+0x5f>
ucomiss %xmm4,%xmm5
ja     17b4 <E0000+0x654>
ucomiss 0x1e4b(%rip),%xmm4
ja     17b4 <E0000+0x654>
movss  %xmm3,0x10(%rsp)
movl   $0x3c8efa35,0x5005(%rip)
fa 8e 3c
movss  0x1e31(%rip),%xmm3
movaps %xmm2,0xc0(%rsp)
movaps %xmm2,%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,0x502a(%rip)
mulss  %xmm1,%xmm3
movss  %xmm3,0x5022(%rip)
movaps %xmm1,0x60(%rsp)
movss  %xmm6,0x4(%rsp)
call   1050 <sin@plt>
movss  %xmm0,0x500e(%rip)
movss  0x5002(%rip),%xmm0
call   1050 <sin@plt>
movss  %xmm0,0x4ffd(%rip)
movss  0x4fe9(%rip),%xmm0
call   1070 <cos@plt>
movss  %xmm0,0x4fec(%rip)
movss  0x4fd8(%rip),%xmm0
call   1070 <cos@plt>
movss  0x4(%rsp),%xmm6
movaps 0x60(%rsp),%xmm8
movss  %xmm0,0x4fcf(%rip)
movss  0x4fbf(%rip),%xmm1
mulss  %xmm1,%xmm1
movss  %xmm1,0x4fbf(%rip)
mulss  %xmm0,%xmm0
movss  %xmm0,0x4fb7(%rip)
movss  0x4f9b(%rip),%xmm0
movss  %xmm0,0x4b67(%rip)
movss  0x4f93(%rip),%xmm0
movss  %xmm0,0x4b97(%rip)
movss  0x4f63(%rip),%xmm0
ucomiss %xmm6,%xmm0
jne    12c0 <E0000+0x160>
jp     12c0 <E0000+0x160>
movss  0x4f58(%rip),%xmm0
ucomiss %xmm8,%xmm0
jne    12c0 <E0000+0x160>
jnp    196c <E0000+0x80c>
movss  0x4f14(%rip),%xmm0
mulss  0x4f14(%rip),%xmm1
subss  %xmm1,%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm0
jb     17c2 <E0000+0x662>
xorps  %xmm1,%xmm1
sqrtss %xmm0,%xmm1
jmp    17d3 <E0000+0x673>
mov    %rdi,%r13
mov    (%rdx),%eax
mov    %eax,0x3d69(%rip)
movl   $0x0,0x4aef(%rip)
movl   $0x3f800000,0x4be5(%rip)
movl   $0x3f800000,0x482b(%rip)
movl   $0x3f800000,0x4b11(%rip)
movl   $0x0,0x4567(%rip)
movl   $0x45c7199a,0x4ea5(%rip)
19 c7 45
movl   $0x4c1b2f2f,0x4e9f(%rip)
2f 1b 4c
movl   $0x4c1a253b,0x4e99(%rip)
25 1a 4c
movl   $0x4884fa00,0x4e93(%rip)
fa 84 48
movl   $0x58bc2457,0x4e8d(%rip)
24 bc 58
movl   $0x55a0ad80,0x4e87(%rip)
ad a0 55
movl   $0x0,0x3d11(%rip)
movl   $0x0,0x3fb7(%rip)
lea    0x4f10(%rip),%rbx
mov    %rbx,%rdi
mov    $0x50,%esi
mov    %r13,%rdx
call   1040 <fgets@plt>
lea    0x1cb9(%rip),%rsi
lea    0x4e52(%rip),%rdx
lea    0x4ecb(%rip),%rcx
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <sscanf@plt>
lea    0x4e42(%rip),%r14
lea    0x3cc3(%rip),%r15
lea    0x3f6c(%rip),%r12
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdi
mov    $0x50,%esi
mov    %r13,%rdx
call   1040 <fgets@plt>
movzbl 0x4ea9(%rip),%eax
test   %al,%al
je     1440 <E0000+0x2e0>
mov    %al,0x4ef0(%rip)
movb   $0x0,0x4eea(%rip)
movzbl 0x4e92(%rip),%eax
test   %al,%al
je     1440 <E0000+0x2e0>
mov    %al,0x4ed9(%rip)
movb   $0x0,0x4ed3(%rip)
movzbl 0x4e7b(%rip),%eax
test   %al,%al
je     1440 <E0000+0x2e0>
mov    %al,0x4ec2(%rip)
movb   $0x0,0x4ebc(%rip)
movzbl 0x4e64(%rip),%eax
test   %al,%al
je     1440 <E0000+0x2e0>
mov    %al,0x4eab(%rip)
movb   $0x0,0x4ea5(%rip)
mov    0x4e9b(%rip),%eax
mov    $0x39393939,%ecx
xor    %ecx,%eax
movzbl 0x4e91(%rip),%ecx
or     %eax,%ecx
je     1508 <E0000+0x3a8>
mov    %rbx,%rdi
lea    0x1bf4(%rip),%rsi
lea    0x3bf7(%rip),%rdx
lea    0x3bf4(%rip),%rcx
lea    0x4d79(%rip),%r8
mov    %r14,%r9
xor    %eax,%eax
lea    0x4d79(%rip),%rbp
push   %rbp
lea    0x4d6d(%rip),%rbp
push   %rbp
call   1060 <sscanf@plt>
add    $0x10,%rsp
movslq 0x3bc8(%rip),%rax
movslq 0x3bbd(%rip),%rcx
cmp    %ecx,%eax
jg     13d0 <E0000+0x270>
movss  0x4d3d(%rip),%xmm0
imul   $0x34,%rax,%rdx
lea    (%r15,%rdx,1),%rsi
movss  %xmm0,(%rsi,%rcx,4)
movss  0x4d30(%rip),%xmm0
add    %r12,%rdx
movss  %xmm0,(%rdx,%rcx,4)
test   %eax,%eax
je     13d0 <E0000+0x270>
movss  0x4d14(%rip),%xmm0
imul   $0x34,%rcx,%rcx
lea    (%r15,%rcx,1),%rdx
movss  %xmm0,-0x4(%rdx,%rax,4)
movss  0x4d06(%rip),%xmm0
add    %r12,%rcx
movss  %xmm0,-0x4(%rcx,%rax,4)
jmp    13d0 <E0000+0x270>
movl   $0x3f800000,0x462e(%rip)
movl   $0x1,0x3b48(%rip)
mov    0x3b3e(%rip),%edx
test   %edx,%edx
jle    177d <E0000+0x61d>
mov    $0x1,%eax
movss  0x1ac9(%rip),%xmm1
lea    0x4602(%rip),%r14
lea    0x49eb(%rip),%r13
xorps  %xmm3,%xmm3
nopl   0x0(%rax,%rax,1)
movslq %eax,%rsi
lea    (%rsi,%rsi,1),%ecx
add    $0xffffffff,%ecx
xorps  %xmm2,%xmm2
cvtsi2ss %ecx,%xmm2
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
mulss  %xmm1,%xmm2
divss  %xmm0,%xmm2
movss  %xmm2,(%r14,%rsi,4)
movl   $0x0,0x3ae9(%rip)
movb   $0x1,0x3ae6(%rip)
lea    0x1(%rsi),%ecx
mov    %ecx,0x3ae1(%rip)
test   %esi,%esi
js     1743 <E0000+0x5e3>
xor    %edx,%edx
mov    $0x2,%r9d
mov    $0x1,%r8b
jmp    160a <E0000+0x4aa>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rdx,%rdx,2),%ebx
lea    (%rdx,%rbx,4),%ebx
movslq %ebx,%rbx
lea    (%r14,%rdi,4),%rsi
movss  (%rsi,%rbx,4),%xmm0
imul   $0x34,%rbp,%rsi
lea    (%r15,%rsi,1),%rbp
movss  0x0(%rbp,%rdi,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rdi,4)
add    %r12,%rsi
mulss  (%rsi,%rdi,4),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
lea    -0x1(%rcx),%esi
mov    %esi,0x3a80(%rip)
movzbl %r8b,%edi
and    $0x1,%edi
add    %edi,%edx
mov    %edx,0x3a69(%rip)
cmp    $0x1,%ecx
mov    %esi,%ecx
jle    1730 <E0000+0x5d0>
lea    -0x1(%rax),%edi
imul   %edi,%edi
mov    %edx,%ebp
imul   %edx,%ebp
sub    %ebp,%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
lea    (%rax,%rax,1),%edi
add    $0xffffffff,%edi
lea    (%rax,%rax,1),%ebp
add    $0xfffffffd,%ebp
imul   %edi,%ebp
xorps  %xmm1,%xmm1
cvtsi2ss %ebp,%xmm1
divss  %xmm1,%xmm0
movslq %edx,%rbp
movslq %eax,%rdi
imul   $0x34,%rbp,%rbx
add    %r13,%rbx
movss  %xmm0,(%rbx,%rdi,4)
test   %ebp,%ebp
jle    15b0 <E0000+0x450>
mov    %edi,%eax
sub    %edx,%eax
add    $0x1,%eax
imul   %eax,%r9d
xorps  %xmm0,%xmm0
cvtsi2ss %r9d,%xmm0
lea    (%rdx,%rdi,1),%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
lea    (%r14,%rdi,4),%rax
lea    (%rdx,%rdx,2),%ecx
lea    (%rdx,%rcx,4),%ecx
add    $0xfffffff3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
ucomiss %xmm3,%xmm0
jb     16a0 <E0000+0x540>
sqrtss %xmm0,%xmm0
jmp    16b4 <E0000+0x554>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  %xmm1,0x8(%rsp)
call   1080 <sqrt@plt>
movss  0x8(%rsp),%xmm1
xorps  %xmm3,%xmm3
mulss  %xmm0,%xmm1
mov    0x39a6(%rip),%eax
movslq %eax,%rdi
lea    (%r14,%rdi,4),%rcx
mov    0x399d(%rip),%edx
movslq %edx,%rbp
lea    0x0(,%rbp,2),%rsi
add    %rbp,%rsi
lea    0x0(,%rsi,4),%rbx
add    %rbp,%rbx
movss  %xmm1,(%rcx,%rbx,4)
imul   $0x34,%rdi,%rcx
lea    (%r15,%rcx,1),%rsi
movss  -0x4(%rsi,%rbp,4),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rsi,%rbp,4)
add    %r12,%rcx
mulss  -0x4(%rcx,%rbp,4),%xmm1
movss  %xmm1,-0x4(%rcx,%rbp,4)
mov    0x395a(%rip),%ecx
mov    $0x1,%r9d
movzbl 0x3948(%rip),%r8d
jmp    15b9 <E0000+0x459>
nopl   0x0(%rax)
mov    0x392a(%rip),%edx
lea    0x1(%rax),%ecx
movslq %eax,%rsi
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
lea    0x471f(%rip),%rdi
movss  %xmm1,(%rdi,%rsi,4)
lea    0x4753(%rip),%rdi
movss  %xmm0,(%rdi,%rsi,4)
mov    %ecx,0x38fc(%rip)
cmp    %edx,%eax
jge    177d <E0000+0x61d>
movslq %ecx,%rax
movss  -0x4(%r14,%rax,4),%xmm1
mov    %ecx,%eax
jmp    1550 <E0000+0x3f0>
movl   $0x0,0x47e1(%rip)
movl   $0xc47a0000,0x4a7f(%rip)
movl   $0xc47a0000,0x4a71(%rip)
movl   $0xc47a0000,0x4a63(%rip)
movl   $0xc47a0000,0x4a55(%rip)
jmp    2235 <E0000+0x10d5>
movss  %xmm0,(%rbx)
mov    $0xffffffff,%eax
jmp    2237 <E0000+0x10d7>
call   1080 <sqrt@plt>
xorps  %xmm2,%xmm2
movss  0x4(%rsp),%xmm6
movaps %xmm0,%xmm1
movss  %xmm1,0x4a5d(%rip)
mulss  %xmm6,%xmm1
movss  %xmm1,0x4a55(%rip)
movss  0x49ed(%rip),%xmm0
addss  %xmm1,%xmm0
addss  0x49e5(%rip),%xmm1
divss  %xmm1,%xmm0
mulss  %xmm0,%xmm0
movss  0x4a19(%rip),%xmm1
mulss  0x4a21(%rip),%xmm0
addss  0x4a15(%rip),%xmm0
ucomiss %xmm2,%xmm0
jb     1826 <E0000+0x6c6>
sqrtss %xmm0,%xmm0
jmp    1837 <E0000+0x6d7>
movss  %xmm1,0x8(%rsp)
call   1080 <sqrt@plt>
movss  0x8(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x49fd(%rip)
mulss  %xmm1,%xmm1
movss  0x17b1(%rip),%xmm0
subss  %xmm1,%xmm0
xorps  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
jb     1861 <E0000+0x701>
sqrtss %xmm0,%xmm0
jmp    1869 <E0000+0x709>
call   1080 <sqrt@plt>
xorps  %xmm3,%xmm3
movss  0x4(%rsp),%xmm1
movss  %xmm0,0x49cd(%rip)
movaps %xmm1,%xmm0
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x49b2(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movss  0x494a(%rip),%xmm0
movss  0x4946(%rip),%xmm2
mulss  0x4982(%rip),%xmm2
subss  %xmm2,%xmm0
movss  0x497e(%rip),%xmm2
mulss  %xmm2,%xmm2
divss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
ucomiss %xmm3,%xmm0
jb     18d9 <E0000+0x779>
sqrtss %xmm0,%xmm0
jmp    18de <E0000+0x77e>
call   1080 <sqrt@plt>
movss  %xmm0,0x4962(%rip)
movss  0x48ee(%rip),%xmm0
movss  0x48ea(%rip),%xmm1
mulss  0x4932(%rip),%xmm1
mulss  0x492e(%rip),%xmm0
addss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1918 <E0000+0x7b8>
sqrtss %xmm0,%xmm0
jmp    191d <E0000+0x7bd>
call   1080 <sqrt@plt>
movaps 0x60(%rsp),%xmm8
movss  0x4(%rsp),%xmm6
movaps %xmm0,%xmm1
addss  %xmm6,%xmm1
movss  0x4910(%rip),%xmm2
divss  %xmm2,%xmm1
movss  0x48a0(%rip),%xmm3
mulss  0x48e0(%rip),%xmm3
mulss  0x48d0(%rip),%xmm3
movss  %xmm1,0x48f0(%rip)
mulss  %xmm2,%xmm0
divss  %xmm0,%xmm3
movss  %xmm3,0x48e4(%rip)
movss  0x489c(%rip),%xmm0
ucomiss 0xc0(%rsp),%xmm0
mov    0x36dd(%rip),%r8d
movss  0x10(%rsp),%xmm7
jne    198d <E0000+0x82d>
jnp    19a2 <E0000+0x842>
mov    $0x2,%ebp
cmp    $0x2,%r8d
jge    2249 <E0000+0x10e9>
mov    %ebp,0x36c6(%rip)
test   %r8d,%r8d
jle    1fdc <E0000+0xe7c>
mov    %rbx,0x70(%rsp)
mov    %r15,0x78(%rsp)
mov    %r12,0x80(%rsp)
movss  0x4812(%rip),%xmm15
ucomiss 0x483b(%rip),%xmm6
divss  0x4872(%rip),%xmm15
movss  %xmm15,0x14(%rsp)
setp   %cl
setne  %dl
or     %cl,%dl
ucomiss 0x481f(%rip),%xmm8
mulss  %xmm15,%xmm15
setp   %bl
setne  %r14b
or     %bl,%r14b
or     %dl,%r14b
movss  0x47fc(%rip),%xmm13
movss  0x4834(%rip),%xmm5
movss  0x4828(%rip),%xmm0
movss  %xmm0,0xc(%rsp)
movaps 0x160b(%rip),%xmm0
xorps  %xmm5,%xmm0
movaps %xmm0,0xd0(%rsp)
movss  0x47dc(%rip),%xmm0
movss  %xmm0,0x8(%rsp)
movaps 0x43eb(%rip),%xmm1
movss  0x44a3(%rip),%xmm0
movss  %xmm0,0x20(%rsp)
add    $0x1,%r8d
movss  0x4391(%rip),%xmm0
movlhps %xmm1,%xmm0
shufps $0xe2,%xmm1,%xmm0
movaps %xmm0,0xe0(%rsp)
xorps  %xmm1,%xmm1
mov    $0x1,%r12d
lea    0x40c6(%rip),%rcx
mov    $0xffffffff,%eax
lea    0x3e0a(%rip),%rdi
lea    0x44a3(%rip),%rsi
mov    %rsi,0x38(%rsp)
lea    0x3b47(%rip),%rbx
lea    0x3890(%rip),%rdx
mov    %rdx,0x28(%rsp)
lea    0x35d4(%rip),%r11
lea    0x3b59(%rip),%rbp
lea    0x35f2(%rip),%rdx
mov    %rdx,0x50(%rsp)
lea    0x3896(%rip),%rdx
mov    $0xd,%esi
mov    %rsi,0x58(%rsp)
mov    $0x3,%esi
xorps  %xmm3,%xmm3
xorps  %xmm8,%xmm8
movss  %xmm13,0x24(%rsp)
movaps %xmm5,0xf0(%rsp)
mov    %r8,0x88(%rsp)
jmp    1b62 <E0000+0xa02>
nopl   0x0(%rax)
mov    %rcx,%rsi
mov    0x48(%rsp),%rcx
add    $0x4,%rcx
mov    0x1c(%rsp),%eax
add    $0x1,%eax
add    $0x4,%rdi
addq   $0x4,0x38(%rsp)
add    $0x4,%rbx
add    $0x4,%rsi
mov    %rsi,0x28(%rsp)
add    $0x4,%r11
add    $0x34,%rbp
addq   $0x34,0x50(%rsp)
add    $0x34,%rdx
addq   $0xd,0x58(%rsp)
mov    0x18(%rsp),%esi
add    $0x1,%esi
mov    0x88(%rsp),%r8
mov    0x90(%rsp),%r12
cmp    %r8,%r12
je     1fbd <E0000+0xe5d>
mov    %rdx,0x40(%rsp)
mov    %rcx,0x48(%rsp)
mov    %eax,0x1c(%rsp)
mov    %eax,%edx
lea    0x3d17(%rip),%r8
lea    (%r8,%rdx,4),%rax
mov    %rax,0x30(%rsp)
mulss  0x14(%rsp),%xmm15
lea    0x1(%r12),%rax
mov    %rax,0x90(%rsp)
lea    0x3fa3(%rip),%rax
lea    (%rax,%r12,4),%r15
movaps %xmm15,%xmm2
xorps  0x1484(%rip),%xmm2
lea    0x42bd(%rip),%rax
movss  (%rax,%r12,4),%xmm14
lea    -0x2(%r12),%rax
mov    %rax,0x98(%rsp)
lea    (%r12,%r12,2),%edx
lea    (%r12,%rdx,4),%eax
lea    -0xd(%r12,%rdx,4),%edx
movslq %edx,%rcx
mov    %rcx,0xb8(%rsp)
mov    0x40(%rsp),%rdx
cltq
mov    %rax,0xb0(%rsp)
imul   $0x34,%r12,%rax
add    %r8,%rax
lea    (%rax,%r12,4),%rax
add    $0xffffffffffffffc8,%rax
mov    %rax,0xa8(%rsp)
lea    -0x3(%r12,%r12,2),%rax
lea    -0x1(%r12,%rax,4),%rax
mov    %rax,0xa0(%rsp)
mov    %esi,0x18(%rsp)
mov    %esi,%r8d
xor    %r9d,%r9d
xor    %r13d,%r13d
xor    %r10d,%r10d
movaps %xmm8,%xmm9
lea    0x41ff(%rip),%rsi
mov    0x28(%rsp),%rcx
jmp    1cde <E0000+0xb7e>
nopl   0x0(%rax,%rax,1)
lea    0x42a9(%rip),%rax
movss  -0x8(%rax,%r12,4),%xmm0
lea    0x42db(%rip),%rsi
mulss  0x34(%rsi,%r12,4),%xmm0
lea    0x41cd(%rip),%rsi
movss  -0x4(%rax,%r12,4),%xmm13
mulss  0xc(%rsp),%xmm13
subss  %xmm0,%xmm13
movss  %xmm13,(%rax,%r12,4)
mulss  %xmm15,%xmm13
movaps %xmm6,%xmm8
shufps $0x55,%xmm6,%xmm8
mulss  %xmm13,%xmm8
addss  %xmm9,%xmm8
movaps %xmm8,%xmm9
movss  0x24(%rsp),%xmm13
movaps 0xf0(%rsp),%xmm5
unpcklps %xmm12,%xmm1
mulps  %xmm1,%xmm6
movaps %xmm6,%xmm1
addps  %xmm10,%xmm1
mulss  %xmm14,%xmm11
mulss  %xmm12,%xmm11
addss  %xmm11,%xmm3
add    $0x1,%r10
add    $0xd,%r13
add    $0x4,%r9
add    $0xffffffff,%r8d
cmp    $0x1,%r8d
jle    1b00 <E0000+0x9a0>
movaps %xmm1,%xmm10
test   %r14b,%r14b
je     1d41 <E0000+0xbe1>
cmp    %r13,0x58(%rsp)
jne    1e00 <E0000+0xca0>
mov    0xb8(%rsp),%rax
movss  -0x4(%r15,%rax,4),%xmm1
mulss  %xmm5,%xmm1
mov    0xb0(%rsp),%rax
movss  %xmm1,(%r15,%rax,4)
mov    0xa0(%rsp),%rax
movss  -0x4(%r15,%rax,4),%xmm1
mulss  0xc(%rsp),%xmm1
mov    0xa8(%rsp),%rax
movss  (%rax),%xmm6
mulss  %xmm5,%xmm6
addss  %xmm1,%xmm6
movss  %xmm6,0x38(%rax)
ucomiss %xmm7,%xmm13
jne    1d49 <E0000+0xbe9>
jnp    1da0 <E0000+0xc40>
movss  (%rcx,%r13,4),%xmm0
mulss  0x8(%rsp),%xmm0
addss  (%r11,%r13,4),%xmm0
movss  %xmm0,(%rbx,%r13,4)
test   %r13,%r13
je     1e80 <E0000+0xd20>
movss  (%rdx,%r9,1),%xmm0
mulss  0x8(%rsp),%xmm0
mov    0x50(%rsp),%rax
addss  (%rax,%r9,1),%xmm0
movss  %xmm0,0x0(%rbp,%r9,1)
mov    %r13d,%eax
movss  (%r15,%rax,4),%xmm12
mulss  %xmm15,%xmm12
jmp    1db7 <E0000+0xc57>
nopl   0x0(%rax,%rax,1)
mov    %r13d,%eax
movss  (%r15,%rax,4),%xmm12
mulss  %xmm15,%xmm12
test   %r13,%r13
je     1e90 <E0000+0xd30>
movss  0x0(%rbp,%r9,1),%xmm0
movaps %xmm0,%xmm1
xorps  0x1268(%rip),%xmm1
movss  (%r9,%rsi,1),%xmm11
unpcklps %xmm11,%xmm0
lea    0x4017(%rip),%rax
movss  (%r9,%rax,1),%xmm4
unpcklps %xmm4,%xmm11
unpcklps %xmm1,%xmm4
mulps  %xmm0,%xmm4
movss  (%rbx,%r13,4),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm11
addps  %xmm4,%xmm11
jmp    1eab <E0000+0xd4b>
cmp    $0x1,%r12
jne    1f10 <E0000+0xdb0>
test   %r13,%r13
jne    1f10 <E0000+0xdb0>
ucomiss %xmm7,%xmm13
movss  0x3d21(%rip),%xmm0
movss  0xc(%rsp),%xmm4
mulss  %xmm4,%xmm0
movss  %xmm0,0x3d13(%rip)
lea    0x3d08(%rip),%rax
movss  -0x4(%rax,%r12,4),%xmm0
mulss  0xd0(%rsp),%xmm0
lea    0x3a41(%rip),%rax
movss  -0x4(%rax,%r12,4),%xmm1
mulss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x3a2e(%rip)
jne    1d49 <E0000+0xbe9>
jp     1d49 <E0000+0xbe9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x48(%rsp),%rax
movss  (%rax,%r13,4),%xmm12
mulss  %xmm15,%xmm12
lea    0x3749(%rip),%rax
movss  (%rax,%r12,4),%xmm11
shufps $0x0,%xmm11,%xmm11
mulps  0xe0(%rsp),%xmm11
ucomiss 0x1172(%rip),%xmm5
lea    0x3ff7(%rip),%rax
movss  (%r9,%rax,1),%xmm6
movlhps %xmm2,%xmm6
shufps $0xe2,%xmm2,%xmm6
mulps  %xmm11,%xmm6
movss  (%rdi,%r13,4),%xmm1
jne    1ca7 <E0000+0xb47>
jp     1ca7 <E0000+0xb47>
cmp    $0xd,%r13
jne    1ca7 <E0000+0xb47>
cmp    $0x1,%r12
jne    1c40 <E0000+0xae0>
movss  0x20(%rsp),%xmm0
movss  %xmm0,0x3ff6(%rip)
lea    0x3feb(%rip),%rax
movss  (%rax,%r12,4),%xmm13
jmp    1c7c <E0000+0xb1c>
cmp    $0x2,%r12
jb     1d41 <E0000+0xbe1>
cmp    0x98(%rsp),%r10
jle    1f43 <E0000+0xde3>
mov    %r13d,%edx
movl   $0x0,-0x8(%r15,%rdx,4)
mov    0x30(%rsp),%rax
movl   $0x0,(%rax,%r13,4)
xorps  %xmm11,%xmm11
jmp    1f51 <E0000+0xdf1>
mov    0x30(%rsp),%rax
movss  (%rax,%r13,4),%xmm11
mov    %r13d,%edx
movss  -0x4(%r15,%rdx,4),%xmm6
mov    0x38(%rsp),%rax
movss  (%rax,%r13,4),%xmm7
movss  -0x8(%r15,%rdx,4),%xmm0
mulss  %xmm7,%xmm0
movss  0xc(%rsp),%xmm1
movaps %xmm1,%xmm4
mulss  %xmm6,%xmm4
subss  %xmm0,%xmm4
movss  %xmm4,(%r15,%rdx,4)
mulss  0xd0(%rsp),%xmm6
movss  -0x4(%rdi,%r13,4),%xmm0
mulss  %xmm1,%xmm0
addss  %xmm6,%xmm0
mulss  %xmm7,%xmm11
subss  %xmm11,%xmm0
movss  %xmm0,(%rdi,%r13,4)
movss  0x10(%rsp),%xmm7
mov    0x40(%rsp),%rdx
jmp    1d41 <E0000+0xbe1>
addps  %xmm10,%xmm6
mov    %r10d,0x30a0(%rip)
mov    0x80(%rsp),%r12
mov    0x78(%rsp),%r15
mov    0x70(%rsp),%rbx
jmp    1ff4 <E0000+0xe94>
xorps  %xmm6,%xmm6
mov    $0x1,%r8d
xorps  %xmm3,%xmm3
movss  0x4254(%rip),%xmm5
xorps  %xmm8,%xmm8
mov    %r8d,0x3069(%rip)
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm5
jne    2005 <E0000+0xea5>
jnp    2013 <E0000+0xeb3>
movaps %xmm6,%xmm8
shufps $0x55,%xmm6,%xmm8
divss  %xmm5,%xmm8
movaps 0x1016(%rip),%xmm0
xorps  %xmm6,%xmm0
movss  0x4227(%rip),%xmm2
movss  0x4223(%rip),%xmm4
mulss  %xmm4,%xmm6
mulss  %xmm3,%xmm4
mulss  %xmm2,%xmm0
subss  %xmm4,%xmm0
movss  %xmm0,0x420f(%rip)
movss  %xmm8,0x420a(%rip)
mulss  %xmm3,%xmm2
subss  %xmm2,%xmm6
movss  %xmm6,0x41fe(%rip)
mulss  %xmm8,%xmm8
mulss  %xmm0,%xmm0
addss  %xmm8,%xmm0
ucomiss %xmm1,%xmm0
jb     2077 <E0000+0xf17>
sqrtss %xmm0,%xmm0
jmp    207c <E0000+0xf1c>
call   1080 <sqrt@plt>
mov    0x140(%rsp),%r14
movss  %xmm0,0x41d4(%rip)
movss  0x41c8(%rip),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     20ae <E0000+0xf4e>
sqrtss %xmm0,%xmm0
jmp    20b3 <E0000+0xf53>
call   1080 <sqrt@plt>
movss  %xmm0,(%rbx)
movss  0x4199(%rip),%xmm0
movss  0x418d(%rip),%xmm1
call   1030 <atan2@plt>
divss  0x4100(%rip),%xmm0
movss  %xmm0,(%r12)
movss  0x417a(%rip),%xmm0
movss  0x4176(%rip),%xmm1
call   1030 <atan2@plt>
divss  0x40dd(%rip),%xmm0
movss  %xmm0,(%r15)
movl   $0xc479c000,(%r14)
movaps 0xf36(%rip),%xmm0
movaps 0x60(%rsp),%xmm4
andps  %xmm4,%xmm0
ucomiss 0xef3(%rip),%xmm0
movaps 0xc0(%rsp),%xmm3
movss  0x10(%rsp),%xmm5
movss  0x4(%rsp),%xmm6
jb     2215 <E0000+0x10b5>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm3
movss  0xecf(%rip),%xmm0
jb     2157 <E0000+0xff7>
ucomiss %xmm1,%xmm4
jbe    2157 <E0000+0xff7>
movss  (%r12),%xmm0
subss  %xmm3,%xmm0
movss  %xmm0,(%r14)
ucomiss %xmm1,%xmm4
jbe    2179 <E0000+0x1019>
xorps  %xmm1,%xmm1
ucomiss %xmm3,%xmm1
jbe    2179 <E0000+0x1019>
movaps 0xed5(%rip),%xmm0
andps  %xmm3,%xmm0
addss  (%r12),%xmm0
movss  %xmm0,(%r14)
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm3
jb     2195 <E0000+0x1035>
ucomiss %xmm4,%xmm1
jbe    2195 <E0000+0x1035>
movss  (%r12),%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,(%r14)
ucomiss %xmm4,%xmm1
jbe    21bb <E0000+0x105b>
xorps  %xmm1,%xmm1
ucomiss %xmm3,%xmm1
jbe    21bb <E0000+0x105b>
movss  (%r12),%xmm0
movaps 0xe91(%rip),%xmm1
andps  %xmm3,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r14)
movss  0xe51(%rip),%xmm1
ucomiss %xmm1,%xmm0
movss  0xe4a(%rip),%xmm2
addss  %xmm0,%xmm2
cmpltss %xmm0,%xmm1
andps  %xmm1,%xmm2
andnps %xmm0,%xmm1
orps   %xmm2,%xmm1
ja     21ef <E0000+0x108f>
movss  0xe32(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    2215 <E0000+0x10b5>
movss  0xe29(%rip),%xmm0
addss  %xmm1,%xmm0
movaps %xmm1,%xmm2
cmpltss 0xe15(%rip),%xmm2
andps  %xmm2,%xmm0
andnps %xmm1,%xmm2
orps   %xmm0,%xmm2
movss  %xmm2,(%r14)
movss  %xmm5,0x3fe7(%rip)
movss  %xmm6,0x3fe3(%rip)
movss  %xmm4,0x3fdf(%rip)
movss  %xmm3,0x3fdb(%rip)
xor    %eax,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x1(%r8),%ebp
movss  0x3b9f(%rip),%xmm0
movss  0x3bd7(%rip),%xmm1
lea    -0x2(%r8),%rcx
xor    %edx,%edx
lea    0x3b86(%rip),%rsi
lea    0x3bbf(%rip),%rdi
movaps %xmm1,%xmm2
movaps %xmm0,%xmm3
nopw   0x0(%rax,%rax,1)
movaps %xmm0,%xmm4
movaps %xmm1,%xmm5
mulss  %xmm0,%xmm5
mulss  %xmm2,%xmm3
movaps %xmm3,%xmm0
addss  %xmm5,%xmm0
movss  %xmm0,0x8(%rsi,%rdx,4)
movss  0x3b51(%rip),%xmm3
mulss  %xmm3,%xmm4
mulss  %xmm1,%xmm2
subss  %xmm4,%xmm2
movss  %xmm2,0x8(%rdi,%rdx,4)
cmp    %rdx,%rcx
je     199c <E0000+0x83c>
movss  0x3b6e(%rip),%xmm1
add    $0x1,%rdx
jmp    2280 <E0000+0x1120>

LLVM IR (-O0):
@E0000.maxord = internal global i32 0
@E0000.i = internal global i32 0
@E0000.icomp = internal global i32 0
@E0000.n = internal global i32 0
@E0000.m = internal global i32 0
@E0000.j = internal global i32 0
@E0000.D1 = internal global i32 0
@E0000.D2 = internal global i32 0
@E0000.D3 = internal global i32 0
@E0000.D4 = internal global i32 0
@E0000.c = internal global [13 x [13 x float]] zeroinitializer
@E0000.cd = internal global [13 x [13 x float]] zeroinitializer
@E0000.tc = internal global [13 x [13 x float]] zeroinitializer
@E0000.dp = internal global [13 x [13 x float]] zeroinitializer
@E0000.snorm = internal global [169 x float] zeroinitializer
@E0000.sp = internal global [13 x float] zeroinitializer
@E0000.cp = internal global [13 x float] zeroinitializer
@E0000.fn = internal global [13 x float] zeroinitializer
@E0000.fm = internal global [13 x float] zeroinitializer
@E0000.pp = internal global [13 x float] zeroinitializer
@E0000.k = internal global [13 x [13 x float]] zeroinitializer
@E0000.pi = internal global float 0.000000e+00
@E0000.dtr = internal global float 0.000000e+00
@E0000.a = internal global float 0.000000e+00
@E0000.b = internal global float 0.000000e+00
@E0000.re = internal global float 0.000000e+00
@E0000.a2 = internal global float 0.000000e+00
@E0000.b2 = internal global float 0.000000e+00
@E0000.c2 = internal global float 0.000000e+00
@E0000.a4 = internal global float 0.000000e+00
@E0000.b4 = internal global float 0.000000e+00
@E0000.c4 = internal global float 0.000000e+00
@E0000.epoc = internal global float 0.000000e+00
@E0000.gnm = internal global float 0.000000e+00
@E0000.hnm = internal global float 0.000000e+00
@E0000.dgnm = internal global float 0.000000e+00
@E0000.dhnm = internal global float 0.000000e+00
@E0000.flnmj = internal global float 0.000000e+00
@E0000.otime = internal global float 0.000000e+00
@E0000.oalt = internal global float 0.000000e+00
@E0000.olat = internal global float 0.000000e+00
@E0000.olon = internal global float 0.000000e+00
@E0000.dt = internal global float 0.000000e+00
@E0000.rlon = internal global float 0.000000e+00
@E0000.rlat = internal global float 0.000000e+00
@E0000.srlon = internal global float 0.000000e+00
@E0000.srlat = internal global float 0.000000e+00
@E0000.crlon = internal global float 0.000000e+00
@E0000.crlat = internal global float 0.000000e+00
@E0000.srlat2 = internal global float 0.000000e+00
@E0000.crlat2 = internal global float 0.000000e+00
@E0000.q = internal global float 0.000000e+00
@E0000.q1 = internal global float 0.000000e+00
@E0000.q2 = internal global float 0.000000e+00
@E0000.ct = internal global float 0.000000e+00
@E0000.st = internal global float 0.000000e+00
@E0000.r2 = internal global float 0.000000e+00
@E0000.r = internal global float 0.000000e+00
@E0000.d = internal global float 0.000000e+00
@E0000.ca = internal global float 0.000000e+00
@E0000.sa = internal global float 0.000000e+00
@E0000.aor = internal global float 0.000000e+00
@E0000.ar = internal global float 0.000000e+00
@E0000.br = internal global float 0.000000e+00
@E0000.bt = internal global float 0.000000e+00
@E0000.bp = internal global float 0.000000e+00
@E0000.bpp = internal global float 0.000000e+00
@E0000.par = internal global float 0.000000e+00
@E0000.temp1 = internal global float 0.000000e+00
@E0000.temp2 = internal global float 0.000000e+00
@E0000.parp = internal global float 0.000000e+00
@E0000.bx = internal global float 0.000000e+00
@E0000.by = internal global float 0.000000e+00
@E0000.bz = internal global float 0.000000e+00
@E0000.bh = internal global float 0.000000e+00
@E0000.model = internal global [20 x i8] zeroinitializer
@E0000.c_str = internal global [81 x i8] zeroinitializer
@E0000.c_new = internal global [5 x i8] zeroinitializer
@E0000.p = internal global float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i32 0, i32 0)
@.str = [5 x i8] c"%f%s\00"
@.str.1 = [5 x i8] c"9999\00"
@.str.2 = [13 x i8] c"%d%d%f%f%f%f\00"
define i32 @E0000(i32* %0, i32 %1, i32* %2, float %3, float %4, float %5, float %6, float* %7, float* %8, float* %9, float* %10) {
%12 = alloca i32
%13 = alloca i32*
%14 = alloca i32
%15 = alloca i32*
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float*
%21 = alloca float*
%22 = alloca float*
%23 = alloca float*
store i32* %0, i32** %13
store i32 %1, i32* %14
store i32* %2, i32** %15
store float %3, float* %16
store float %4, float* %17
store float %5, float* %18
store float %6, float* %19
store float* %7, float** %20
store float* %8, float** %21
store float* %9, float** %22
store float* %10, float** %23
%24 = load i32, i32* %14
switch i32 %24, label %27 [
i32 0, label %25
i32 1, label %26
]
25: ; preds = %11
br label %28
26: ; preds = %11
br label %336
27: ; preds = %11
br label %28
28: ; preds = %27, %25
%29 = load i32*, i32** %15
%30 = load i32, i32* %29
store i32 %30, i32* @E0000.maxord
store float 0.000000e+00, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.sp, i64 0, i64 0)
store float 1.000000e+00, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.pp, i64 0, i64 0)
%31 = load float*, float** @E0000.p
store float 1.000000e+00, float* %31
store float 1.000000e+00, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.cp, i64 0, i64 0)
store float 0.000000e+00, float* getelementptr inbounds ([13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 0, i64 0)
store float 0x40B8EA2320000000, float* @E0000.a
store float 0x40B8D4C0A0000000, float* @E0000.b
store float 0x40B8E33340000000, float* @E0000.re
%32 = load float, float* @E0000.a
%33 = load float, float* @E0000.a
%34 = fmul float %32, %33
store float %34, float* @E0000.a2
%35 = load float, float* @E0000.b
%36 = load float, float* @E0000.b
%37 = fmul float %35, %36
store float %37, float* @E0000.b2
%38 = load float, float* @E0000.a2
%39 = load float, float* @E0000.b2
%40 = fsub float %38, %39
store float %40, float* @E0000.c2
%41 = load float, float* @E0000.a2
%42 = load float, float* @E0000.a2
%43 = fmul float %41, %42
store float %43, float* @E0000.a4
%44 = load float, float* @E0000.b2
%45 = load float, float* @E0000.b2
%46 = fmul float %44, %45
store float %46, float* @E0000.b4
%47 = load float, float* @E0000.a4
%48 = load float, float* @E0000.b4
%49 = fsub float %47, %48
store float %49, float* @E0000.c4
store float 0.000000e+00, float* getelementptr inbounds ([13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 0, i64 0)
store float 0.000000e+00, float* getelementptr inbounds ([13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 0, i64 0)
%50 = load i32*, i32** %13
%51 = call i32 @fgets(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 0), i32 80, i32* %50)
%52 = call i32 (i8*, i8*, ...) @sscanf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), float* @E0000.epoc, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @E0000.model, i64 0, i64 0))
br label %53
53: ; preds = %128, %28
%54 = load i32*, i32** %13
%55 = call i32 @fgets(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 0), i32 80, i32* %54)
store i32 0, i32* @E0000.i
br label %56
56: ; preds = %80, %53
%57 = load i32, i32* @E0000.i
%58 = icmp slt i32 %57, 4
br i1 %58, label %59, label %66
59: ; preds = %56
%60 = load i32, i32* @E0000.i
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds [81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 %61
%63 = load i8, i8* %62
%64 = sext i8 %63 to i32
%65 = icmp ne i32 %64, 0
br label %66
66: ; preds = %59, %56
%67 = phi i1 [ false, %56 ], [ %65, %59 ]
br i1 %67, label %68, label %83
68: ; preds = %66
%69 = load i32, i32* @E0000.i
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 %70
%72 = load i8, i8* %71
%73 = load i32, i32* @E0000.i
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 %74
store i8 %72, i8* %75
%76 = load i32, i32* @E0000.i
%77 = add nsw i32 %76, 1
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 %78
store i8 0, i8* %79
br label %80
80: ; preds = %68
%81 = load i32, i32* @E0000.i
%82 = add nsw i32 %81, 1
store i32 %82, i32* @E0000.i
br label %56
83: ; preds = %66
%84 = call i32 @strcmp(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 0))
store i32 %84, i32* @E0000.icomp
%85 = load i32, i32* @E0000.icomp
%86 = icmp eq i32 %85, 0
br i1 %86, label %87, label %88
87: ; preds = %83
br label %129
88: ; preds = %83
%89 = call i32 (i8*, i8*, ...) @sscanf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32* @E0000.n, i32* @E0000.m, float* @E0000.gnm, float* @E0000.hnm, float* @E0000.dgnm, float* @E0000.dhnm)
%90 = load i32, i32* @E0000.m
%91 = load i32, i32* @E0000.n
%92 = icmp sle i32 %90, %91
br i1 %92, label %93, label %128
93: ; preds = %88
%94 = load float, float* @E0000.gnm
%95 = load i32, i32* @E0000.m
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %96
%98 = load i32, i32* @E0000.n
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [13 x float], [13 x float]* %97, i64 0, i64 %99
store float %94, float* %100
%101 = load float, float* @E0000.dgnm
%102 = load i32, i32* @E0000.m
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %103
%105 = load i32, i32* @E0000.n
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [13 x float], [13 x float]* %104, i64 0, i64 %106
store float %101, float* %107
%108 = load i32, i32* @E0000.m
%109 = icmp ne i32 %108, 0
br i1 %109, label %110, label %127
110: ; preds = %93
%111 = load float, float* @E0000.hnm
%112 = load i32, i32* @E0000.n
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %113
%115 = load i32, i32* @E0000.m
%116 = sub nsw i32 %115, 1
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [13 x float], [13 x float]* %114, i64 0, i64 %117
store float %111, float* %118
%119 = load float, float* @E0000.dhnm
%120 = load i32, i32* @E0000.n
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %121
%123 = load i32, i32* @E0000.m
%124 = sub nsw i32 %123, 1
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [13 x float], [13 x float]* %122, i64 0, i64 %125
store float %119, float* %126
br label %127
127: ; preds = %110, %93
br label %128
128: ; preds = %127, %88
br label %53
129: ; preds = %87
store float 1.000000e+00, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0)
store i32 1, i32* @E0000.n
br label %130
130: ; preds = %332, %129
%131 = load i32, i32* @E0000.n
%132 = load i32, i32* @E0000.maxord
%133 = icmp sle i32 %131, %132
br i1 %133, label %134, label %335
134: ; preds = %130
%135 = load i32, i32* @E0000.n
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds float, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0), i64 %136
%138 = getelementptr inbounds float, float* %137, i64 -1
%139 = load float, float* %138
%140 = load i32, i32* @E0000.n
%141 = mul nsw i32 2, %140
%142 = sub nsw i32 %141, 1
%143 = sitofp i32 %142 to float
%144 = fmul float %139, %143
%145 = load i32, i32* @E0000.n
%146 = sitofp i32 %145 to float
%147 = fdiv float %144, %146
%148 = load i32, i32* @E0000.n
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0), i64 %149
store float %147, float* %150
store i32 2, i32* @E0000.j
store i32 0, i32* @E0000.m
store i32 1, i32* @E0000.D1
%151 = load i32, i32* @E0000.n
%152 = load i32, i32* @E0000.m
%153 = sub nsw i32 %151, %152
%154 = load i32, i32* @E0000.D1
%155 = add nsw i32 %153, %154
%156 = load i32, i32* @E0000.D1
%157 = sdiv i32 %155, %156
store i32 %157, i32* @E0000.D2
br label %158
158: ; preds = %314, %134
%159 = load i32, i32* @E0000.D2
%160 = icmp sgt i32 %159, 0
br i1 %160, label %161, label %320
161: ; preds = %158
%162 = load i32, i32* @E0000.n
%163 = sub nsw i32 %162, 1
%164 = load i32, i32* @E0000.n
%165 = sub nsw i32 %164, 1
%166 = mul nsw i32 %163, %165
%167 = load i32, i32* @E0000.m
%168 = load i32, i32* @E0000.m
%169 = mul nsw i32 %167, %168
%170 = sub nsw i32 %166, %169
%171 = sitofp i32 %170 to float
%172 = load i32, i32* @E0000.n
%173 = mul nsw i32 2, %172
%174 = sub nsw i32 %173, 1
%175 = load i32, i32* @E0000.n
%176 = mul nsw i32 2, %175
%177 = sub nsw i32 %176, 3
%178 = mul nsw i32 %174, %177
%179 = sitofp i32 %178 to float
%180 = fdiv float %171, %179
%181 = load i32, i32* @E0000.m
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.k, i64 0, i64 %182
%184 = load i32, i32* @E0000.n
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [13 x float], [13 x float]* %183, i64 0, i64 %185
store float %180, float* %186
%187 = load i32, i32* @E0000.m
%188 = icmp sgt i32 %187, 0
br i1 %188, label %189, label %269
189: ; preds = %161
%190 = load i32, i32* @E0000.n
%191 = load i32, i32* @E0000.m
%192 = sub nsw i32 %190, %191
%193 = add nsw i32 %192, 1
%194 = load i32, i32* @E0000.j
%195 = mul nsw i32 %193, %194
%196 = sitofp i32 %195 to float
%197 = load i32, i32* @E0000.n
%198 = load i32, i32* @E0000.m
%199 = add nsw i32 %197, %198
%200 = sitofp i32 %199 to float
%201 = fdiv float %196, %200
store float %201, float* @E0000.flnmj
%202 = load i32, i32* @E0000.n
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0), i64 %203
%205 = load i32, i32* @E0000.m
%206 = sub nsw i32 %205, 1
%207 = mul nsw i32 %206, 13
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds float, float* %204, i64 %208
%210 = load float, float* %209
%211 = load float, float* @E0000.flnmj
%212 = call float @sqrt(float %211)
%213 = fmul float %210, %212
%214 = load i32, i32* @E0000.n
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds float, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0), i64 %215
%217 = load i32, i32* @E0000.m
%218 = mul nsw i32 %217, 13
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float, float* %216, i64 %219
store float %213, float* %220
store i32 1, i32* @E0000.j
%221 = load i32, i32* @E0000.n
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds float, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0), i64 %222
%224 = load i32, i32* @E0000.m
%225 = mul nsw i32 %224, 13
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds float, float* %223, i64 %226
%228 = load float, float* %227
%229 = load i32, i32* @E0000.n
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %230
%232 = load i32, i32* @E0000.m
%233 = sub nsw i32 %232, 1
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [13 x float], [13 x float]* %231, i64 0, i64 %234
%236 = load float, float* %235
%237 = fmul float %228, %236
%238 = load i32, i32* @E0000.n
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %239
%241 = load i32, i32* @E0000.m
%242 = sub nsw i32 %241, 1
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [13 x float], [13 x float]* %240, i64 0, i64 %243
store float %237, float* %244
%245 = load i32, i32* @E0000.n
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds float, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0), i64 %246
%248 = load i32, i32* @E0000.m
%249 = mul nsw i32 %248, 13
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds float, float* %247, i64 %250
%252 = load float, float* %251
%253 = load i32, i32* @E0000.n
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %254
%256 = load i32, i32* @E0000.m
%257 = sub nsw i32 %256, 1
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [13 x float], [13 x float]* %255, i64 0, i64 %258
%260 = load float, float* %259
%261 = fmul float %252, %260
%262 = load i32, i32* @E0000.n
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %263
%265 = load i32, i32* @E0000.m
%266 = sub nsw i32 %265, 1
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds [13 x float], [13 x float]* %264, i64 0, i64 %267
store float %261, float* %268
br label %269
269: ; preds = %189, %161
%270 = load i32, i32* @E0000.n
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds float, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0), i64 %271
%273 = load i32, i32* @E0000.m
%274 = mul nsw i32 %273, 13
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds float, float* %272, i64 %275
%277 = load float, float* %276
%278 = load i32, i32* @E0000.m
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %279
%281 = load i32, i32* @E0000.n
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds [13 x float], [13 x float]* %280, i64 0, i64 %282
%284 = load float, float* %283
%285 = fmul float %277, %284
%286 = load i32, i32* @E0000.m
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %287
%289 = load i32, i32* @E0000.n
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds [13 x float], [13 x float]* %288, i64 0, i64 %290
store float %285, float* %291
%292 = load i32, i32* @E0000.n
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds float, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0), i64 %293
%295 = load i32, i32* @E0000.m
%296 = mul nsw i32 %295, 13
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds float, float* %294, i64 %297
%299 = load float, float* %298
%300 = load i32, i32* @E0000.m
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %301
%303 = load i32, i32* @E0000.n
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [13 x float], [13 x float]* %302, i64 0, i64 %304
%306 = load float, float* %305
%307 = fmul float %299, %306
%308 = load i32, i32* @E0000.m
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %309
%311 = load i32, i32* @E0000.n
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds [13 x float], [13 x float]* %310, i64 0, i64 %312
store float %307, float* %313
br label %314
314: ; preds = %269
%315 = load i32, i32* @E0000.D2
%316 = add nsw i32 %315, -1
store i32 %316, i32* @E0000.D2
%317 = load i32, i32* @E0000.D1
%318 = load i32, i32* @E0000.m
%319 = add nsw i32 %318, %317
store i32 %319, i32* @E0000.m
br label %158
320: ; preds = %158
%321 = load i32, i32* @E0000.n
%322 = add nsw i32 %321, 1
%323 = sitofp i32 %322 to float
%324 = load i32, i32* @E0000.n
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds [13 x float], [13 x float]* @E0000.fn, i64 0, i64 %325
store float %323, float* %326
%327 = load i32, i32* @E0000.n
%328 = sitofp i32 %327 to float
%329 = load i32, i32* @E0000.n
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds [13 x float], [13 x float]* @E0000.fm, i64 0, i64 %330
store float %328, float* %331
br label %332
332: ; preds = %320
%333 = load i32, i32* @E0000.n
%334 = add nsw i32 %333, 1
store i32 %334, i32* @E0000.n
br label %130
335: ; preds = %130
store float 0.000000e+00, float* getelementptr inbounds ([13 x [13 x float]], [13 x [13 x float]]* @E0000.k, i64 0, i64 1, i64 1)
store float -1.000000e+03, float* @E0000.olon
store float -1.000000e+03, float* @E0000.olat
store float -1.000000e+03, float* @E0000.oalt
store float -1.000000e+03, float* @E0000.otime
store i32 0, i32* %12
br label %1180
336: ; preds = %26
%337 = load float, float* %19
%338 = load float, float* @E0000.epoc
%339 = fsub float %337, %338
store float %339, float* @E0000.dt
%340 = load float, float* @E0000.otime
%341 = fpext float %340 to double
%342 = fcmp olt double %341, 0.000000e+00
br i1 %342, label %343, label %354
343: ; preds = %336
%344 = load float, float* @E0000.dt
%345 = fpext float %344 to double
%346 = fcmp olt double %345, 0.000000e+00
br i1 %346, label %351, label %347
347: ; preds = %343
%348 = load float, float* @E0000.dt
%349 = fpext float %348 to double
%350 = fcmp ogt double %349, 5.000000e+00
br i1 %350, label %351, label %354
351: ; preds = %347, %343
%352 = load float, float* @E0000.epoc
%353 = load float*, float** %22
store float %352, float* %353
store i32 -1, i32* %12
br label %1180
354: ; preds = %347, %336
store float 0x400921FB60000000, float* @E0000.pi
%355 = load float, float* @E0000.pi
%356 = fpext float %355 to double
%357 = fdiv double %356, 1.800000e+02
%358 = fptrunc double %357 to float
store float %358, float* @E0000.dtr
%359 = load float, float* %18
%360 = load float, float* @E0000.dtr
%361 = fmul float %359, %360
store float %361, float* @E0000.rlon
%362 = load float, float* %17
%363 = load float, float* @E0000.dtr
%364 = fmul float %362, %363
store float %364, float* @E0000.rlat
%365 = load float, float* @E0000.rlon
%366 = call float @sin(float %365)
store float %366, float* @E0000.srlon
%367 = load float, float* @E0000.rlat
%368 = call float @sin(float %367)
store float %368, float* @E0000.srlat
%369 = load float, float* @E0000.rlon
%370 = call float @cos(float %369)
store float %370, float* @E0000.crlon
%371 = load float, float* @E0000.rlat
%372 = call float @cos(float %371)
store float %372, float* @E0000.crlat
%373 = load float, float* @E0000.srlat
%374 = load float, float* @E0000.srlat
%375 = fmul float %373, %374
store float %375, float* @E0000.srlat2
%376 = load float, float* @E0000.crlat
%377 = load float, float* @E0000.crlat
%378 = fmul float %376, %377
store float %378, float* @E0000.crlat2
%379 = load float, float* @E0000.srlon
store float %379, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.sp, i64 0, i64 1)
%380 = load float, float* @E0000.crlon
store float %380, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.cp, i64 0, i64 1)
%381 = load float, float* %16
%382 = load float, float* @E0000.oalt
%383 = fcmp une float %381, %382
br i1 %383, label %388, label %384
384: ; preds = %354
%385 = load float, float* %17
%386 = load float, float* @E0000.olat
%387 = fcmp une float %385, %386
br i1 %387, label %388, label %469
388: ; preds = %384, %354
%389 = load float, float* @E0000.a2
%390 = load float, float* @E0000.c2
%391 = load float, float* @E0000.srlat2
%392 = fneg float %390
%393 = call float @llvm.fmuladd.f32(float %392, float %391, float %389)
%394 = call float @sqrt(float %393)
store float %394, float* @E0000.q
%395 = load float, float* %16
%396 = load float, float* @E0000.q
%397 = fmul float %395, %396
store float %397, float* @E0000.q1
%398 = load float, float* @E0000.q1
%399 = load float, float* @E0000.a2
%400 = fadd float %398, %399
%401 = load float, float* @E0000.q1
%402 = load float, float* @E0000.b2
%403 = fadd float %401, %402
%404 = fdiv float %400, %403
%405 = load float, float* @E0000.q1
%406 = load float, float* @E0000.a2
%407 = fadd float %405, %406
%408 = load float, float* @E0000.q1
%409 = load float, float* @E0000.b2
%410 = fadd float %408, %409
%411 = fdiv float %407, %410
%412 = fmul float %404, %411
store float %412, float* @E0000.q2
%413 = load float, float* @E0000.srlat
%414 = load float, float* @E0000.q2
%415 = load float, float* @E0000.crlat2
%416 = load float, float* @E0000.srlat2
%417 = call float @llvm.fmuladd.f32(float %414, float %415, float %416)
%418 = call float @sqrt(float %417)
%419 = fdiv float %413, %418
store float %419, float* @E0000.ct
%420 = load float, float* @E0000.ct
%421 = load float, float* @E0000.ct
%422 = fmul float %420, %421
%423 = fpext float %422 to double
%424 = fsub double 1.000000e+00, %423
%425 = fptrunc double %424 to float
%426 = call float @sqrt(float %425)
store float %426, float* @E0000.st
%427 = load float, float* %16
%428 = load float, float* %16
%429 = fmul float %427, %428
%430 = fpext float %429 to double
%431 = load float, float* @E0000.q1
%432 = fpext float %431 to double
%433 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %432, double %430)
%434 = load float, float* @E0000.a4
%435 = load float, float* @E0000.c4
%436 = load float, float* @E0000.srlat2
%437 = fneg float %435
%438 = call float @llvm.fmuladd.f32(float %437, float %436, float %434)
%439 = load float, float* @E0000.q
%440 = load float, float* @E0000.q
%441 = fmul float %439, %440
%442 = fdiv float %438, %441
%443 = fpext float %442 to double
%444 = fadd double %433, %443
%445 = fptrunc double %444 to float
store float %445, float* @E0000.r2
%446 = load float, float* @E0000.r2
%447 = call float @sqrt(float %446)
store float %447, float* @E0000.r
%448 = load float, float* @E0000.a2
%449 = load float, float* @E0000.crlat2
%450 = load float, float* @E0000.b2
%451 = load float, float* @E0000.srlat2
%452 = fmul float %450, %451
%453 = call float @llvm.fmuladd.f32(float %448, float %449, float %452)
%454 = call float @sqrt(float %453)
store float %454, float* @E0000.d
%455 = load float, float* %16
%456 = load float, float* @E0000.d
%457 = fadd float %455, %456
%458 = load float, float* @E0000.r
%459 = fdiv float %457, %458
store float %459, float* @E0000.ca
%460 = load float, float* @E0000.c2
%461 = load float, float* @E0000.crlat
%462 = fmul float %460, %461
%463 = load float, float* @E0000.srlat
%464 = fmul float %462, %463
%465 = load float, float* @E0000.r
%466 = load float, float* @E0000.d
%467 = fmul float %465, %466
%468 = fdiv float %464, %467
store float %468, float* @E0000.sa
br label %469
469: ; preds = %388, %384
%470 = load float, float* %18
%471 = load float, float* @E0000.olon
%472 = fcmp une float %470, %471
br i1 %472, label %473, label %518
473: ; preds = %469
store i32 2, i32* @E0000.m
br label %474
474: ; preds = %514, %473
%475 = load i32, i32* @E0000.m
%476 = load i32, i32* @E0000.maxord
%477 = icmp sle i32 %475, %476
br i1 %477, label %478, label %517
478: ; preds = %474
%479 = load float, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.sp, i64 0, i64 1)
%480 = load i32, i32* @E0000.m
%481 = sub nsw i32 %480, 1
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds [13 x float], [13 x float]* @E0000.cp, i64 0, i64 %482
%484 = load float, float* %483
%485 = load float, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.cp, i64 0, i64 1)
%486 = load i32, i32* @E0000.m
%487 = sub nsw i32 %486, 1
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds [13 x float], [13 x float]* @E0000.sp, i64 0, i64 %488
%490 = load float, float* %489
%491 = fmul float %485, %490
%492 = call float @llvm.fmuladd.f32(float %479, float %484, float %491)
%493 = load i32, i32* @E0000.m
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds [13 x float], [13 x float]* @E0000.sp, i64 0, i64 %494
store float %492, float* %495
%496 = load float, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.cp, i64 0, i64 1)
%497 = load i32, i32* @E0000.m
%498 = sub nsw i32 %497, 1
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds [13 x float], [13 x float]* @E0000.cp, i64 0, i64 %499
%501 = load float, float* %500
%502 = load float, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.sp, i64 0, i64 1)
%503 = load i32, i32* @E0000.m
%504 = sub nsw i32 %503, 1
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds [13 x float], [13 x float]* @E0000.sp, i64 0, i64 %505
%507 = load float, float* %506
%508 = fmul float %502, %507
%509 = fneg float %508
%510 = call float @llvm.fmuladd.f32(float %496, float %501, float %509)
%511 = load i32, i32* @E0000.m
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds [13 x float], [13 x float]* @E0000.cp, i64 0, i64 %512
store float %510, float* %513
br label %514
514: ; preds = %478
%515 = load i32, i32* @E0000.m
%516 = add nsw i32 %515, 1
store i32 %516, i32* @E0000.m
br label %474
517: ; preds = %474
br label %518
518: ; preds = %517, %469
%519 = load float, float* @E0000.re
%520 = load float, float* @E0000.r
%521 = fdiv float %519, %520
store float %521, float* @E0000.aor
%522 = load float, float* @E0000.aor
%523 = load float, float* @E0000.aor
%524 = fmul float %522, %523
store float %524, float* @E0000.ar
store float 0.000000e+00, float* @E0000.bpp
store float 0.000000e+00, float* @E0000.bp
store float 0.000000e+00, float* @E0000.bt
store float 0.000000e+00, float* @E0000.br
store i32 1, i32* @E0000.n
br label %525
525: ; preds = %1032, %518
%526 = load i32, i32* @E0000.n
%527 = load i32, i32* @E0000.maxord
%528 = icmp sle i32 %526, %527
br i1 %528, label %529, label %1035
529: ; preds = %525
%530 = load float, float* @E0000.ar
%531 = load float, float* @E0000.aor
%532 = fmul float %530, %531
store float %532, float* @E0000.ar
store i32 0, i32* @E0000.m
store i32 1, i32* @E0000.D3
%533 = load i32, i32* @E0000.n
%534 = load i32, i32* @E0000.m
%535 = add nsw i32 %533, %534
%536 = load i32, i32* @E0000.D3
%537 = add nsw i32 %535, %536
%538 = load i32, i32* @E0000.D3
%539 = sdiv i32 %537, %538
store i32 %539, i32* @E0000.D4
br label %540
540: ; preds = %1025, %529
%541 = load i32, i32* @E0000.D4
%542 = icmp sgt i32 %541, 0
br i1 %542, label %543, label %1031
543: ; preds = %540
%544 = load float, float* %16
%545 = load float, float* @E0000.oalt
%546 = fcmp une float %544, %545
br i1 %546, label %551, label %547
547: ; preds = %543
%548 = load float, float* %17
%549 = load float, float* @E0000.olat
%550 = fcmp une float %548, %549
br i1 %550, label %551, label %785
551: ; preds = %547, %543
%552 = load i32, i32* @E0000.n
%553 = load i32, i32* @E0000.m
%554 = icmp eq i32 %552, %553
br i1 %554, label %555, label %607
555: ; preds = %551
%556 = load float, float* @E0000.st
%557 = load float*, float** @E0000.p
%558 = load i32, i32* @E0000.n
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds float, float* %557, i64 %559
%561 = getelementptr inbounds float, float* %560, i64 -1
%562 = load i32, i32* @E0000.m
%563 = sub nsw i32 %562, 1
%564 = mul nsw i32 %563, 13
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds float, float* %561, i64 %565
%567 = load float, float* %566
%568 = fmul float %556, %567
%569 = load float*, float** @E0000.p
%570 = load i32, i32* @E0000.n
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds float, float* %569, i64 %571
%573 = load i32, i32* @E0000.m
%574 = mul nsw i32 %573, 13
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds float, float* %572, i64 %575
store float %568, float* %576
%577 = load float, float* @E0000.st
%578 = load i32, i32* @E0000.m
%579 = sub nsw i32 %578, 1
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %580
%582 = load i32, i32* @E0000.n
%583 = sub nsw i32 %582, 1
%584 = sext i32 %583 to i64
%585 = getelementptr inbounds [13 x float], [13 x float]* %581, i64 0, i64 %584
%586 = load float, float* %585
%587 = load float, float* @E0000.ct
%588 = load float*, float** @E0000.p
%589 = load i32, i32* @E0000.n
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds float, float* %588, i64 %590
%592 = getelementptr inbounds float, float* %591, i64 -1
%593 = load i32, i32* @E0000.m
%594 = sub nsw i32 %593, 1
%595 = mul nsw i32 %594, 13
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds float, float* %592, i64 %596
%598 = load float, float* %597
%599 = fmul float %587, %598
%600 = call float @llvm.fmuladd.f32(float %577, float %586, float %599)
%601 = load i32, i32* @E0000.m
%602 = sext i32 %601 to i64
%603 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %602
%604 = load i32, i32* @E0000.n
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds [13 x float], [13 x float]* %603, i64 0, i64 %605
store float %600, float* %606
br label %786
607: ; preds = %551
%608 = load i32, i32* @E0000.n
%609 = icmp eq i32 %608, 1
br i1 %609, label %610, label %663
610: ; preds = %607
%611 = load i32, i32* @E0000.m
%612 = icmp eq i32 %611, 0
br i1 %612, label %613, label %663
613: ; preds = %610
%614 = load float, float* @E0000.ct
%615 = load float*, float** @E0000.p
%616 = load i32, i32* @E0000.n
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds float, float* %615, i64 %617
%619 = getelementptr inbounds float, float* %618, i64 -1
%620 = load i32, i32* @E0000.m
%621 = mul nsw i32 %620, 13
%622 = sext i32 %621 to i64
%623 = getelementptr inbounds float, float* %619, i64 %622
%624 = load float, float* %623
%625 = fmul float %614, %624
%626 = load float*, float** @E0000.p
%627 = load i32, i32* @E0000.n
%628 = sext i32 %627 to i64
%629 = getelementptr inbounds float, float* %626, i64 %628
%630 = load i32, i32* @E0000.m
%631 = mul nsw i32 %630, 13
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds float, float* %629, i64 %632
store float %625, float* %633
%634 = load float, float* @E0000.ct
%635 = load i32, i32* @E0000.m
%636 = sext i32 %635 to i64
%637 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %636
%638 = load i32, i32* @E0000.n
%639 = sub nsw i32 %638, 1
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds [13 x float], [13 x float]* %637, i64 0, i64 %640
%642 = load float, float* %641
%643 = load float, float* @E0000.st
%644 = load float*, float** @E0000.p
%645 = load i32, i32* @E0000.n
%646 = sext i32 %645 to i64
%647 = getelementptr inbounds float, float* %644, i64 %646
%648 = getelementptr inbounds float, float* %647, i64 -1
%649 = load i32, i32* @E0000.m
%650 = mul nsw i32 %649, 13
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds float, float* %648, i64 %651
%653 = load float, float* %652
%654 = fmul float %643, %653
%655 = fneg float %654
%656 = call float @llvm.fmuladd.f32(float %634, float %642, float %655)
%657 = load i32, i32* @E0000.m
%658 = sext i32 %657 to i64
%659 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %658
%660 = load i32, i32* @E0000.n
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds [13 x float], [13 x float]* %659, i64 0, i64 %661
store float %656, float* %662
br label %786
663: ; preds = %610, %607
%664 = load i32, i32* @E0000.n
%665 = icmp sgt i32 %664, 1
br i1 %665, label %666, label %784
666: ; preds = %663
%667 = load i32, i32* @E0000.n
%668 = load i32, i32* @E0000.m
%669 = icmp ne i32 %667, %668
br i1 %669, label %670, label %784
670: ; preds = %666
%671 = load i32, i32* @E0000.m
%672 = load i32, i32* @E0000.n
%673 = sub nsw i32 %672, 2
%674 = icmp sgt i32 %671, %673
br i1 %674, label %675, label %685
675: ; preds = %670
%676 = load float*, float** @E0000.p
%677 = load i32, i32* @E0000.n
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds float, float* %676, i64 %678
%680 = getelementptr inbounds float, float* %679, i64 -2
%681 = load i32, i32* @E0000.m
%682 = mul nsw i32 %681, 13
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds float, float* %680, i64 %683
store float 0.000000e+00, float* %684
br label %685
685: ; preds = %675, %670
%686 = load i32, i32* @E0000.m
%687 = load i32, i32* @E0000.n
%688 = sub nsw i32 %687, 2
%689 = icmp sgt i32 %686, %688
br i1 %689, label %690, label %698
690: ; preds = %685
%691 = load i32, i32* @E0000.m
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %692
%694 = load i32, i32* @E0000.n
%695 = sub nsw i32 %694, 2
%696 = sext i32 %695 to i64
%697 = getelementptr inbounds [13 x float], [13 x float]* %693, i64 0, i64 %696
store float 0.000000e+00, float* %697
br label %698
698: ; preds = %690, %685
%699 = load float, float* @E0000.ct
%700 = load float*, float** @E0000.p
%701 = load i32, i32* @E0000.n
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds float, float* %700, i64 %702
%704 = getelementptr inbounds float, float* %703, i64 -1
%705 = load i32, i32* @E0000.m
%706 = mul nsw i32 %705, 13
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds float, float* %704, i64 %707
%709 = load float, float* %708
%710 = load i32, i32* @E0000.m
%711 = sext i32 %710 to i64
%712 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.k, i64 0, i64 %711
%713 = load i32, i32* @E0000.n
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds [13 x float], [13 x float]* %712, i64 0, i64 %714
%716 = load float, float* %715
%717 = load float*, float** @E0000.p
%718 = load i32, i32* @E0000.n
%719 = sext i32 %718 to i64
%720 = getelementptr inbounds float, float* %717, i64 %719
%721 = getelementptr inbounds float, float* %720, i64 -2
%722 = load i32, i32* @E0000.m
%723 = mul nsw i32 %722, 13
%724 = sext i32 %723 to i64
%725 = getelementptr inbounds float, float* %721, i64 %724
%726 = load float, float* %725
%727 = fmul float %716, %726
%728 = fneg float %727
%729 = call float @llvm.fmuladd.f32(float %699, float %709, float %728)
%730 = load float*, float** @E0000.p
%731 = load i32, i32* @E0000.n
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds float, float* %730, i64 %732
%734 = load i32, i32* @E0000.m
%735 = mul nsw i32 %734, 13
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds float, float* %733, i64 %736
store float %729, float* %737
%738 = load float, float* @E0000.ct
%739 = load i32, i32* @E0000.m
%740 = sext i32 %739 to i64
%741 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %740
%742 = load i32, i32* @E0000.n
%743 = sub nsw i32 %742, 1
%744 = sext i32 %743 to i64
%745 = getelementptr inbounds [13 x float], [13 x float]* %741, i64 0, i64 %744
%746 = load float, float* %745
%747 = load float, float* @E0000.st
%748 = load float*, float** @E0000.p
%749 = load i32, i32* @E0000.n
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds float, float* %748, i64 %750
%752 = getelementptr inbounds float, float* %751, i64 -1
%753 = load i32, i32* @E0000.m
%754 = mul nsw i32 %753, 13
%755 = sext i32 %754 to i64
%756 = getelementptr inbounds float, float* %752, i64 %755
%757 = load float, float* %756
%758 = fmul float %747, %757
%759 = fneg float %758
%760 = call float @llvm.fmuladd.f32(float %738, float %746, float %759)
%761 = load i32, i32* @E0000.m
%762 = sext i32 %761 to i64
%763 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.k, i64 0, i64 %762
%764 = load i32, i32* @E0000.n
%765 = sext i32 %764 to i64
%766 = getelementptr inbounds [13 x float], [13 x float]* %763, i64 0, i64 %765
%767 = load float, float* %766
%768 = load i32, i32* @E0000.m
%769 = sext i32 %768 to i64
%770 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %769
%771 = load i32, i32* @E0000.n
%772 = sub nsw i32 %771, 2
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds [13 x float], [13 x float]* %770, i64 0, i64 %773
%775 = load float, float* %774
%776 = fneg float %767
%777 = call float @llvm.fmuladd.f32(float %776, float %775, float %760)
%778 = load i32, i32* @E0000.m
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %779
%781 = load i32, i32* @E0000.n
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds [13 x float], [13 x float]* %780, i64 0, i64 %782
store float %777, float* %783
br label %784
784: ; preds = %698, %666, %663
br label %785
785: ; preds = %784, %547
br label %786
786: ; preds = %785, %613, %555
%787 = load float, float* %19
%788 = load float, float* @E0000.otime
%789 = fcmp une float %787, %788
br i1 %789, label %790, label %842
790: ; preds = %786
%791 = load i32, i32* @E0000.m
%792 = sext i32 %791 to i64
%793 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %792
%794 = load i32, i32* @E0000.n
%795 = sext i32 %794 to i64
%796 = getelementptr inbounds [13 x float], [13 x float]* %793, i64 0, i64 %795
%797 = load float, float* %796
%798 = load float, float* @E0000.dt
%799 = load i32, i32* @E0000.m
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %800
%802 = load i32, i32* @E0000.n
%803 = sext i32 %802 to i64
%804 = getelementptr inbounds [13 x float], [13 x float]* %801, i64 0, i64 %803
%805 = load float, float* %804
%806 = call float @llvm.fmuladd.f32(float %798, float %805, float %797)
%807 = load i32, i32* @E0000.m
%808 = sext i32 %807 to i64
%809 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %808
%810 = load i32, i32* @E0000.n
%811 = sext i32 %810 to i64
%812 = getelementptr inbounds [13 x float], [13 x float]* %809, i64 0, i64 %811
store float %806, float* %812
%813 = load i32, i32* @E0000.m
%814 = icmp ne i32 %813, 0
br i1 %814, label %815, label %841
815: ; preds = %790
%816 = load i32, i32* @E0000.n
%817 = sext i32 %816 to i64
%818 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %817
%819 = load i32, i32* @E0000.m
%820 = sub nsw i32 %819, 1
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds [13 x float], [13 x float]* %818, i64 0, i64 %821
%823 = load float, float* %822
%824 = load float, float* @E0000.dt
%825 = load i32, i32* @E0000.n
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %826
%828 = load i32, i32* @E0000.m
%829 = sub nsw i32 %828, 1
%830 = sext i32 %829 to i64
%831 = getelementptr inbounds [13 x float], [13 x float]* %827, i64 0, i64 %830
%832 = load float, float* %831
%833 = call float @llvm.fmuladd.f32(float %824, float %832, float %823)
%834 = load i32, i32* @E0000.n
%835 = sext i32 %834 to i64
%836 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %835
%837 = load i32, i32* @E0000.m
%838 = sub nsw i32 %837, 1
%839 = sext i32 %838 to i64
%840 = getelementptr inbounds [13 x float], [13 x float]* %836, i64 0, i64 %839
store float %833, float* %840
br label %841
841: ; preds = %815, %790
br label %842
842: ; preds = %841, %786
%843 = load float, float* @E0000.ar
%844 = load float*, float** @E0000.p
%845 = load i32, i32* @E0000.n
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds float, float* %844, i64 %846
%848 = load i32, i32* @E0000.m
%849 = mul nsw i32 %848, 13
%850 = sext i32 %849 to i64
%851 = getelementptr inbounds float, float* %847, i64 %850
%852 = load float, float* %851
%853 = fmul float %843, %852
store float %853, float* @E0000.par
%854 = load i32, i32* @E0000.m
%855 = icmp eq i32 %854, 0
br i1 %855, label %856, label %881
856: ; preds = %842
%857 = load i32, i32* @E0000.m
%858 = sext i32 %857 to i64
%859 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %858
%860 = load i32, i32* @E0000.n
%861 = sext i32 %860 to i64
%862 = getelementptr inbounds [13 x float], [13 x float]* %859, i64 0, i64 %861
%863 = load float, float* %862
%864 = load i32, i32* @E0000.m
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds [13 x float], [13 x float]* @E0000.cp, i64 0, i64 %865
%867 = load float, float* %866
%868 = fmul float %863, %867
store float %868, float* @E0000.temp1
%869 = load i32, i32* @E0000.m
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %870
%872 = load i32, i32* @E0000.n
%873 = sext i32 %872 to i64
%874 = getelementptr inbounds [13 x float], [13 x float]* %871, i64 0, i64 %873
%875 = load float, float* %874
%876 = load i32, i32* @E0000.m
%877 = sext i32 %876 to i64
%878 = getelementptr inbounds [13 x float], [13 x float]* @E0000.sp, i64 0, i64 %877
%879 = load float, float* %878
%880 = fmul float %875, %879
store float %880, float* @E0000.temp2
br label %933
881: ; preds = %842
%882 = load i32, i32* @E0000.m
%883 = sext i32 %882 to i64
%884 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %883
%885 = load i32, i32* @E0000.n
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds [13 x float], [13 x float]* %884, i64 0, i64 %886
%888 = load float, float* %887
%889 = load i32, i32* @E0000.m
%890 = sext i32 %889 to i64
%891 = getelementptr inbounds [13 x float], [13 x float]* @E0000.cp, i64 0, i64 %890
%892 = load float, float* %891
%893 = load i32, i32* @E0000.n
%894 = sext i32 %893 to i64
%895 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %894
%896 = load i32, i32* @E0000.m
%897 = sub nsw i32 %896, 1
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds [13 x float], [13 x float]* %895, i64 0, i64 %898
%900 = load float, float* %899
%901 = load i32, i32* @E0000.m
%902 = sext i32 %901 to i64
%903 = getelementptr inbounds [13 x float], [13 x float]* @E0000.sp, i64 0, i64 %902
%904 = load float, float* %903
%905 = fmul float %900, %904
%906 = call float @llvm.fmuladd.f32(float %888, float %892, float %905)
store float %906, float* @E0000.temp1
%907 = load i32, i32* @E0000.m
%908 = sext i32 %907 to i64
%909 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %908
%910 = load i32, i32* @E0000.n
%911 = sext i32 %910 to i64
%912 = getelementptr inbounds [13 x float], [13 x float]* %909, i64 0, i64 %911
%913 = load float, float* %912
%914 = load i32, i32* @E0000.m
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds [13 x float], [13 x float]* @E0000.sp, i64 0, i64 %915
%917 = load float, float* %916
%918 = load i32, i32* @E0000.n
%919 = sext i32 %918 to i64
%920 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %919
%921 = load i32, i32* @E0000.m
%922 = sub nsw i32 %921, 1
%923 = sext i32 %922 to i64
%924 = getelementptr inbounds [13 x float], [13 x float]* %920, i64 0, i64 %923
%925 = load float, float* %924
%926 = load i32, i32* @E0000.m
%927 = sext i32 %926 to i64
%928 = getelementptr inbounds [13 x float], [13 x float]* @E0000.cp, i64 0, i64 %927
%929 = load float, float* %928
%930 = fmul float %925, %929
%931 = fneg float %930
%932 = call float @llvm.fmuladd.f32(float %913, float %917, float %931)
store float %932, float* @E0000.temp2
br label %933
933: ; preds = %881, %856
%934 = load float, float* @E0000.bt
%935 = load float, float* @E0000.ar
%936 = load float, float* @E0000.temp1
%937 = fmul float %935, %936
%938 = load i32, i32* @E0000.m
%939 = sext i32 %938 to i64
%940 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %939
%941 = load i32, i32* @E0000.n
%942 = sext i32 %941 to i64
%943 = getelementptr inbounds [13 x float], [13 x float]* %940, i64 0, i64 %942
%944 = load float, float* %943
%945 = fneg float %937
%946 = call float @llvm.fmuladd.f32(float %945, float %944, float %934)
store float %946, float* @E0000.bt
%947 = load i32, i32* @E0000.m
%948 = sext i32 %947 to i64
%949 = getelementptr inbounds [13 x float], [13 x float]* @E0000.fm, i64 0, i64 %948
%950 = load float, float* %949
%951 = load float, float* @E0000.temp2
%952 = fmul float %950, %951
%953 = load float, float* @E0000.par
%954 = load float, float* @E0000.bp
%955 = call float @llvm.fmuladd.f32(float %952, float %953, float %954)
store float %955, float* @E0000.bp
%956 = load i32, i32* @E0000.n
%957 = sext i32 %956 to i64
%958 = getelementptr inbounds [13 x float], [13 x float]* @E0000.fn, i64 0, i64 %957
%959 = load float, float* %958
%960 = load float, float* @E0000.temp1
%961 = fmul float %959, %960
%962 = load float, float* @E0000.par
%963 = load float, float* @E0000.br
%964 = call float @llvm.fmuladd.f32(float %961, float %962, float %963)
store float %964, float* @E0000.br
%965 = load float, float* @E0000.st
%966 = fpext float %965 to double
%967 = fcmp oeq double %966, 0.000000e+00
br i1 %967, label %968, label %1024
968: ; preds = %933
%969 = load i32, i32* @E0000.m
%970 = icmp eq i32 %969, 1
br i1 %970, label %971, label %1024
971: ; preds = %968
%972 = load i32, i32* @E0000.n
%973 = icmp eq i32 %972, 1
br i1 %973, label %974, label %983
974: ; preds = %971
%975 = load i32, i32* @E0000.n
%976 = sub nsw i32 %975, 1
%977 = sext i32 %976 to i64
%978 = getelementptr inbounds [13 x float], [13 x float]* @E0000.pp, i64 0, i64 %977
%979 = load float, float* %978
%980 = load i32, i32* @E0000.n
%981 = sext i32 %980 to i64
%982 = getelementptr inbounds [13 x float], [13 x float]* @E0000.pp, i64 0, i64 %981
store float %979, float* %982
br label %1008
983: ; preds = %971
%984 = load float, float* @E0000.ct
%985 = load i32, i32* @E0000.n
%986 = sub nsw i32 %985, 1
%987 = sext i32 %986 to i64
%988 = getelementptr inbounds [13 x float], [13 x float]* @E0000.pp, i64 0, i64 %987
%989 = load float, float* %988
%990 = load i32, i32* @E0000.m
%991 = sext i32 %990 to i64
%992 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.k, i64 0, i64 %991
%993 = load i32, i32* @E0000.n
%994 = sext i32 %993 to i64
%995 = getelementptr inbounds [13 x float], [13 x float]* %992, i64 0, i64 %994
%996 = load float, float* %995
%997 = load i32, i32* @E0000.n
%998 = sub nsw i32 %997, 2
%999 = sext i32 %998 to i64
%1000 = getelementptr inbounds [13 x float], [13 x float]* @E0000.pp, i64 0, i64 %999
%1001 = load float, float* %1000
%1002 = fmul float %996, %1001
%1003 = fneg float %1002
%1004 = call float @llvm.fmuladd.f32(float %984, float %989, float %1003)
%1005 = load i32, i32* @E0000.n
%1006 = sext i32 %1005 to i64
%1007 = getelementptr inbounds [13 x float], [13 x float]* @E0000.pp, i64 0, i64 %1006
store float %1004, float* %1007
br label %1008
1008: ; preds = %983, %974
%1009 = load float, float* @E0000.ar
%1010 = load i32, i32* @E0000.n
%1011 = sext i32 %1010 to i64
%1012 = getelementptr inbounds [13 x float], [13 x float]* @E0000.pp, i64 0, i64 %1011
%1013 = load float, float* %1012
%1014 = fmul float %1009, %1013
store float %1014, float* @E0000.parp
%1015 = load i32, i32* @E0000.m
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds [13 x float], [13 x float]* @E0000.fm, i64 0, i64 %1016
%1018 = load float, float* %1017
%1019 = load float, float* @E0000.temp2
%1020 = fmul float %1018, %1019
%1021 = load float, float* @E0000.parp
%1022 = load float, float* @E0000.bpp
%1023 = call float @llvm.fmuladd.f32(float %1020, float %1021, float %1022)
store float %1023, float* @E0000.bpp
br label %1024
1024: ; preds = %1008, %968, %933
br label %1025
1025: ; preds = %1024
%1026 = load i32, i32* @E0000.D4
%1027 = add nsw i32 %1026, -1
store i32 %1027, i32* @E0000.D4
%1028 = load i32, i32* @E0000.D3
%1029 = load i32, i32* @E0000.m
%1030 = add nsw i32 %1029, %1028
store i32 %1030, i32* @E0000.m
br label %540
1031: ; preds = %540
br label %1032
1032: ; preds = %1031
%1033 = load i32, i32* @E0000.n
%1034 = add nsw i32 %1033, 1
store i32 %1034, i32* @E0000.n
br label %525
1035: ; preds = %525
%1036 = load float, float* @E0000.st
%1037 = fpext float %1036 to double
%1038 = fcmp oeq double %1037, 0.000000e+00
br i1 %1038, label %1039, label %1041
1039: ; preds = %1035
%1040 = load float, float* @E0000.bpp
store float %1040, float* @E0000.bp
br label %1045
1041: ; preds = %1035
%1042 = load float, float* @E0000.st
%1043 = load float, float* @E0000.bp
%1044 = fdiv float %1043, %1042
store float %1044, float* @E0000.bp
br label %1045
1045: ; preds = %1041, %1039
%1046 = load float, float* @E0000.bt
%1047 = fneg float %1046
%1048 = load float, float* @E0000.ca
%1049 = load float, float* @E0000.br
%1050 = load float, float* @E0000.sa
%1051 = fmul float %1049, %1050
%1052 = fneg float %1051
%1053 = call float @llvm.fmuladd.f32(float %1047, float %1048, float %1052)
store float %1053, float* @E0000.bx
%1054 = load float, float* @E0000.bp
store float %1054, float* @E0000.by
%1055 = load float, float* @E0000.bt
%1056 = load float, float* @E0000.sa
%1057 = load float, float* @E0000.br
%1058 = load float, float* @E0000.ca
%1059 = fmul float %1057, %1058
%1060 = fneg float %1059
%1061 = call float @llvm.fmuladd.f32(float %1055, float %1056, float %1060)
store float %1061, float* @E0000.bz
%1062 = load float, float* @E0000.bx
%1063 = load float, float* @E0000.bx
%1064 = load float, float* @E0000.by
%1065 = load float, float* @E0000.by
%1066 = fmul float %1064, %1065
%1067 = call float @llvm.fmuladd.f32(float %1062, float %1063, float %1066)
%1068 = call float @sqrt(float %1067)
store float %1068, float* @E0000.bh
%1069 = load float, float* @E0000.bh
%1070 = load float, float* @E0000.bh
%1071 = load float, float* @E0000.bz
%1072 = load float, float* @E0000.bz
%1073 = fmul float %1071, %1072
%1074 = call float @llvm.fmuladd.f32(float %1069, float %1070, float %1073)
%1075 = call float @sqrt(float %1074)
%1076 = load float*, float** %22
store float %1075, float* %1076
%1077 = load float, float* @E0000.by
%1078 = load float, float* @E0000.bx
%1079 = call float @atan2(float %1077, float %1078)
%1080 = load float, float* @E0000.dtr
%1081 = fdiv float %1079, %1080
%1082 = load float*, float** %20
store float %1081, float* %1082
%1083 = load float, float* @E0000.bz
%1084 = load float, float* @E0000.bh
%1085 = call float @atan2(float %1083, float %1084)
%1086 = load float, float* @E0000.dtr
%1087 = fdiv float %1085, %1086
%1088 = load float*, float** %21
store float %1087, float* %1088
%1089 = load float*, float** %23
store float -9.990000e+02, float* %1089
%1090 = load float, float* %17
%1091 = call float @fabs(float %1090)
%1092 = fpext float %1091 to double
%1093 = fcmp oge double %1092, 5.500000e+01
br i1 %1093, label %1094, label %1175
1094: ; preds = %1045
%1095 = load float, float* %17
%1096 = fpext float %1095 to double
%1097 = fcmp ogt double %1096, 0.000000e+00
br i1 %1097, label %1098, label %1108
1098: ; preds = %1094
%1099 = load float, float* %18
%1100 = fpext float %1099 to double
%1101 = fcmp oge double %1100, 0.000000e+00
br i1 %1101, label %1102, label %1108
1102: ; preds = %1098
%1103 = load float*, float** %20
%1104 = load float, float* %1103
%1105 = load float, float* %18
%1106 = fsub float %1104, %1105
%1107 = load float*, float** %23
store float %1106, float* %1107
br label %1108
1108: ; preds = %1102, %1098, %1094
%1109 = load float, float* %17
%1110 = fpext float %1109 to double
%1111 = fcmp ogt double %1110, 0.000000e+00
br i1 %1111, label %1112, label %1123
1112: ; preds = %1108
%1113 = load float, float* %18
%1114 = fpext float %1113 to double
%1115 = fcmp olt double %1114, 0.000000e+00
br i1 %1115, label %1116, label %1123
1116: ; preds = %1112
%1117 = load float*, float** %20
%1118 = load float, float* %1117
%1119 = load float, float* %18
%1120 = call float @fabs(float %1119)
%1121 = fadd float %1118, %1120
%1122 = load float*, float** %23
store float %1121, float* %1122
br label %1123
1123: ; preds = %1116, %1112, %1108
%1124 = load float, float* %17
%1125 = fpext float %1124 to double
%1126 = fcmp olt double %1125, 0.000000e+00
br i1 %1126, label %1127, label %1137
1127: ; preds = %1123
%1128 = load float, float* %18
%1129 = fpext float %1128 to double
%1130 = fcmp oge double %1129, 0.000000e+00
br i1 %1130, label %1131, label %1137
1131: ; preds = %1127
%1132 = load float*, float** %20
%1133 = load float, float* %1132
%1134 = load float, float* %18
%1135 = fadd float %1133, %1134
%1136 = load float*, float** %23
store float %1135, float* %1136
br label %1137
1137: ; preds = %1131, %1127, %1123
%1138 = load float, float* %17
%1139 = fpext float %1138 to double
%1140 = fcmp olt double %1139, 0.000000e+00
br i1 %1140, label %1141, label %1152
1141: ; preds = %1137
%1142 = load float, float* %18
%1143 = fpext float %1142 to double
%1144 = fcmp olt double %1143, 0.000000e+00
br i1 %1144, label %1145, label %1152
1145: ; preds = %1141
%1146 = load float*, float** %20
%1147 = load float, float* %1146
%1148 = load float, float* %18
%1149 = call float @fabs(float %1148)
%1150 = fsub float %1147, %1149
%1151 = load float*, float** %23
store float %1150, float* %1151
br label %1152
1152: ; preds = %1145, %1141, %1137
%1153 = load float*, float** %23
%1154 = load float, float* %1153
%1155 = fpext float %1154 to double
%1156 = fcmp ogt double %1155, 1.800000e+02
br i1 %1156, label %1157, label %1163
1157: ; preds = %1152
%1158 = load float*, float** %23
%1159 = load float, float* %1158
%1160 = fpext float %1159 to double
%1161 = fsub double %1160, 3.600000e+02
%1162 = fptrunc double %1161 to float
store float %1162, float* %1158
br label %1163
1163: ; preds = %1157, %1152
%1164 = load float*, float** %23
%1165 = load float, float* %1164
%1166 = fpext float %1165 to double
%1167 = fcmp olt double %1166, -1.800000e+02
br i1 %1167, label %1168, label %1174
1168: ; preds = %1163
%1169 = load float*, float** %23
%1170 = load float, float* %1169
%1171 = fpext float %1170 to double
%1172 = fadd double %1171, 3.600000e+02
%1173 = fptrunc double %1172 to float
store float %1173, float* %1169
br label %1174
1174: ; preds = %1168, %1163
br label %1175
1175: ; preds = %1174, %1045
%1176 = load float, float* %19
store float %1176, float* @E0000.otime
%1177 = load float, float* %16
store float %1177, float* @E0000.oalt
%1178 = load float, float* %17
store float %1178, float* @E0000.olat
%1179 = load float, float* %18
store float %1179, float* @E0000.olon
store i32 0, i32* %12
br label %1180
1180: ; preds = %1175, %351, %335
%1181 = load i32, i32* %12
ret i32 %1181
}

LLVM IR (-O2):
@E0000.maxord = internal unnamed_addr global i32 0
@E0000.n = internal global i32 0
@E0000.m = internal global i32 0
@E0000.D1 = internal unnamed_addr global i1 false
@E0000.D2 = internal unnamed_addr global i32 0
@E0000.c = internal unnamed_addr global [13 x [13 x float]] zeroinitializer
@E0000.cd = internal unnamed_addr global [13 x [13 x float]] zeroinitializer
@E0000.tc = internal unnamed_addr global [13 x [13 x float]] zeroinitializer
@E0000.dp = internal unnamed_addr global [13 x [13 x float]] zeroinitializer
@E0000.snorm = internal unnamed_addr global [169 x float] zeroinitializer
@E0000.sp = internal unnamed_addr global [13 x float] zeroinitializer
@E0000.cp = internal unnamed_addr global [13 x float] zeroinitializer
@E0000.fn = internal unnamed_addr global [13 x float] zeroinitializer
@E0000.fm = internal unnamed_addr global [13 x float] zeroinitializer
@E0000.pp = internal unnamed_addr global [13 x float] zeroinitializer
@E0000.k = internal unnamed_addr global [13 x [13 x float]] zeroinitializer
@E0000.dtr = internal unnamed_addr global float 0.000000e+00
@E0000.re = internal unnamed_addr global float 0.000000e+00
@E0000.a2 = internal unnamed_addr global float 0.000000e+00
@E0000.b2 = internal unnamed_addr global float 0.000000e+00
@E0000.c2 = internal unnamed_addr global float 0.000000e+00
@E0000.a4 = internal unnamed_addr global float 0.000000e+00
@E0000.c4 = internal unnamed_addr global float 0.000000e+00
@E0000.epoc = internal global float 0.000000e+00
@E0000.gnm = internal global float 0.000000e+00
@E0000.hnm = internal global float 0.000000e+00
@E0000.dgnm = internal global float 0.000000e+00
@E0000.dhnm = internal global float 0.000000e+00
@E0000.otime = internal unnamed_addr global float 0.000000e+00
@E0000.oalt = internal unnamed_addr global float 0.000000e+00
@E0000.olat = internal unnamed_addr global float 0.000000e+00
@E0000.olon = internal unnamed_addr global float 0.000000e+00
@E0000.dt = internal unnamed_addr global float 0.000000e+00
@E0000.rlon = internal unnamed_addr global float 0.000000e+00
@E0000.rlat = internal unnamed_addr global float 0.000000e+00
@E0000.srlon = internal unnamed_addr global float 0.000000e+00
@E0000.srlat = internal unnamed_addr global float 0.000000e+00
@E0000.crlon = internal unnamed_addr global float 0.000000e+00
@E0000.crlat = internal unnamed_addr global float 0.000000e+00
@E0000.srlat2 = internal unnamed_addr global float 0.000000e+00
@E0000.crlat2 = internal unnamed_addr global float 0.000000e+00
@E0000.q = internal unnamed_addr global float 0.000000e+00
@E0000.q1 = internal unnamed_addr global float 0.000000e+00
@E0000.ct = internal unnamed_addr global float 0.000000e+00
@E0000.st = internal unnamed_addr global float 0.000000e+00
@E0000.r = internal unnamed_addr global float 0.000000e+00
@E0000.ca = internal unnamed_addr global float 0.000000e+00
@E0000.sa = internal unnamed_addr global float 0.000000e+00
@E0000.bx = internal unnamed_addr global float 0.000000e+00
@E0000.by = internal unnamed_addr global float 0.000000e+00
@E0000.bz = internal unnamed_addr global float 0.000000e+00
@E0000.bh = internal unnamed_addr global float 0.000000e+00
@E0000.model = internal global [20 x i8] zeroinitializer
@E0000.c_str = internal global [81 x i8] zeroinitializer
@E0000.c_new = internal global [5 x i8] zeroinitializer
@.str = [5 x i8] c"%f%s\00"
@.str.1 = [5 x i8] c"9999\00"
@.str.2 = [13 x i8] c"%d%d%f%f%f%f\00"
define i32 @E0000(i32* nocapture %0, i32 %1, i32* nocapture %2, float %3, float %4, float %5, float %6, float* nocapture %7, float* nocapture writeonly %8, float* nocapture writeonly %9, float* nocapture %10) {
%12 = icmp eq i32 %1, 1
br i1 %12, label %173, label %13
13: ; preds = %11
%14 = load i32, i32* %2
store i32 %14, i32* @E0000.maxord
store float 0.000000e+00, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.sp, i64 0, i64 0)
store float 1.000000e+00, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.pp, i64 0, i64 0)
store float 1.000000e+00, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0)
store float 1.000000e+00, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.cp, i64 0, i64 0)
store float 0.000000e+00, float* getelementptr inbounds ([13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 0, i64 0)
store float 0x40B8E33340000000, float* @E0000.re
store float 0x418365E5E0000000, float* @E0000.a2
store float 4.040830e+07, float* @E0000.b2
store float 2.723360e+05, float* @E0000.c2
store float 0x4317848AE0000000, float* @E0000.a4
store float 0x42B415B000000000, float* @E0000.c4
store float 0.000000e+00, float* getelementptr inbounds ([13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 0, i64 0)
store float 0.000000e+00, float* getelementptr inbounds ([13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 0, i64 0)
%15 = tail call i32 @fgets(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 0), i32 80, i32* %0)
%16 = tail call i32 (i8*, i8*, ...) @sscanf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), float* @E0000.epoc, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @E0000.model, i64 0, i64 0))
br label %17
17: ; preds = %47, %13
%18 = tail call i32 @fgets(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 0), i32 80, i32* %0)
%19 = load i8, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 0)
%20 = icmp eq i8 %19, 0
br i1 %20, label %31, label %21
21: ; preds = %17
store i8 %19, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 0)
store i8 0, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 1)
%22 = load i8, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 1)
%23 = icmp eq i8 %22, 0
br i1 %23, label %31, label %24
24: ; preds = %21
store i8 %22, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 1)
store i8 0, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 2)
%25 = load i8, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 2)
%26 = icmp eq i8 %25, 0
br i1 %26, label %31, label %27
27: ; preds = %24
store i8 %25, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 2)
store i8 0, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 3)
%28 = load i8, i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 3)
%29 = icmp eq i8 %28, 0
br i1 %29, label %31, label %30
30: ; preds = %27
store i8 %28, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 3)
store i8 0, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 4)
br label %31
31: ; preds = %30, %27, %24, %21, %17
%32 = tail call i32 @bcmp(i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @E0000.c_new, i64 0, i64 0), i64 5)
%33 = icmp eq i32 %32, 0
br i1 %33, label %55, label %34
34: ; preds = %31
%35 = tail call i32 (i8*, i8*, ...) @sscanf(i8* getelementptr inbounds ([81 x i8], [81 x i8]* @E0000.c_str, i64 0, i64 0), i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.2, i64 0, i64 0), i32* @E0000.n, i32* @E0000.m, float* @E0000.gnm, float* @E0000.hnm, float* @E0000.dgnm, float* @E0000.dhnm)
%36 = load i32, i32* @E0000.m
%37 = load i32, i32* @E0000.n
%38 = icmp sgt i32 %36, %37
br i1 %38, label %47, label %39
39: ; preds = %34
%40 = load float, float* @E0000.gnm
%41 = sext i32 %36 to i64
%42 = sext i32 %37 to i64
%43 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %41, i64 %42
store float %40, float* %43
%44 = load float, float* @E0000.dgnm
%45 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %41, i64 %42
store float %44, float* %45
%46 = icmp eq i32 %36, 0
br i1 %46, label %47, label %48
47: ; preds = %39, %48, %34
br label %17
48: ; preds = %39
%49 = load float, float* @E0000.hnm
%50 = add nsw i32 %36, -1
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %42, i64 %51
store float %49, float* %52
%53 = load float, float* @E0000.dhnm
%54 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %42, i64 %51
store float %53, float* %54
br label %47
55: ; preds = %31
store float 1.000000e+00, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0)
store i32 1, i32* @E0000.n
%56 = load i32, i32* @E0000.maxord
%57 = icmp slt i32 %56, 1
br i1 %57, label %172, label %58
58: ; preds = %55, %167
%59 = phi i32 [ %161, %167 ], [ %56, %55 ]
%60 = phi float [ %171, %167 ], [ 1.000000e+00, %55 ]
%61 = phi i32 [ %160, %167 ], [ 1, %55 ]
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [169 x float], [169 x float]* @E0000.snorm, i64 0, i64 %62
%64 = shl nsw i32 %61, 1
%65 = add nsw i32 %64, -1
%66 = sitofp i32 %65 to float
%67 = fmul float %60, %66
%68 = sitofp i32 %61 to float
%69 = fdiv float %67, %68
store float %69, float* %63
store i32 0, i32* @E0000.m
store i1 true, i1* @E0000.D1
%70 = add nsw i32 %61, 1
store i32 %70, i32* @E0000.D2
%71 = icmp sgt i32 %61, -1
br i1 %71, label %72, label %157
72: ; preds = %58, %130
%73 = phi i1 [ %133, %130 ], [ true, %58 ]
%74 = phi i32 [ %148, %130 ], [ %70, %58 ]
%75 = phi i32 [ %137, %130 ], [ %61, %58 ]
%76 = phi i32 [ %138, %130 ], [ 2, %58 ]
%77 = phi i32 [ %150, %130 ], [ 0, %58 ]
%78 = add nsw i32 %75, -1
%79 = mul nsw i32 %78, %78
%80 = mul nsw i32 %77, %77
%81 = sub nsw i32 %79, %80
%82 = sitofp i32 %81 to float
%83 = shl nsw i32 %75, 1
%84 = add nsw i32 %83, -1
%85 = add nsw i32 %83, -3
%86 = mul nsw i32 %84, %85
%87 = sitofp i32 %86 to float
%88 = fdiv float %82, %87
%89 = sext i32 %77 to i64
%90 = sext i32 %75 to i64
%91 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.k, i64 0, i64 %89, i64 %90
store float %88, float* %91
%92 = icmp sgt i32 %77, 0
br i1 %92, label %96, label %93
93: ; preds = %72
%94 = mul nsw i32 %77, 13
%95 = sext i32 %94 to i64
br label %130
96: ; preds = %72
%97 = add i32 %75, 1
%98 = sub i32 %97, %77
%99 = mul nsw i32 %76, %98
%100 = sitofp i32 %99 to float
%101 = add nsw i32 %77, %75
%102 = sitofp i32 %101 to float
%103 = fdiv float %100, %102
%104 = getelementptr inbounds [169 x float], [169 x float]* @E0000.snorm, i64 0, i64 %90
%105 = mul i32 %77, 13
%106 = add i32 %105, -13
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float, float* %104, i64 %107
%109 = load float, float* %108
%110 = tail call float @sqrt(float %103)
%111 = fmul float %109, %110
%112 = load i32, i32* @E0000.n
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [169 x float], [169 x float]* @E0000.snorm, i64 0, i64 %113
%115 = load i32, i32* @E0000.m
%116 = mul nsw i32 %115, 13
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %114, i64 %117
store float %111, float* %118
%119 = add nsw i32 %115, -1
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %113, i64 %120
%122 = load float, float* %121
%123 = fmul float %111, %122
store float %123, float* %121
%124 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %113, i64 %120
%125 = load float, float* %124
%126 = fmul float %111, %125
store float %126, float* %124
%127 = sext i32 %115 to i64
%128 = load i32, i32* @E0000.D2
%129 = load i1, i1* @E0000.D1
br label %130
130: ; preds = %93, %96
%131 = phi i64 [ %95, %93 ], [ %117, %96 ]
%132 = phi i64 [ %90, %93 ], [ %113, %96 ]
%133 = phi i1 [ %73, %93 ], [ %129, %96 ]
%134 = phi i32 [ %74, %93 ], [ %128, %96 ]
%135 = phi i64 [ %89, %93 ], [ %127, %96 ]
%136 = phi i32 [ %77, %93 ], [ %115, %96 ]
%137 = phi i32 [ %75, %93 ], [ %112, %96 ]
%138 = phi i32 [ %76, %93 ], [ 1, %96 ]
%139 = getelementptr inbounds [169 x float], [169 x float]* @E0000.snorm, i64 0, i64 %132
%140 = getelementptr inbounds float, float* %139, i64 %131
%141 = load float, float* %140
%142 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %135, i64 %132
%143 = load float, float* %142
%144 = fmul float %141, %143
store float %144, float* %142
%145 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %135, i64 %132
%146 = load float, float* %145
%147 = fmul float %141, %146
store float %147, float* %145
%148 = add nsw i32 %134, -1
store i32 %148, i32* @E0000.D2
%149 = zext i1 %133 to i32
%150 = add nsw i32 %136, %149
store i32 %150, i32* @E0000.m
%151 = icmp sgt i32 %134, 1
br i1 %151, label %72, label %152
152: ; preds = %130
%153 = load i32, i32* @E0000.maxord
%154 = add nsw i32 %137, 1
%155 = sext i32 %137 to i64
%156 = sitofp i32 %137 to float
br label %157
157: ; preds = %152, %58
%158 = phi float [ %156, %152 ], [ %68, %58 ]
%159 = phi i64 [ %155, %152 ], [ %62, %58 ]
%160 = phi i32 [ %154, %152 ], [ %70, %58 ]
%161 = phi i32 [ %153, %152 ], [ %59, %58 ]
%162 = phi i32 [ %137, %152 ], [ %61, %58 ]
%163 = sitofp i32 %160 to float
%164 = getelementptr inbounds [13 x float], [13 x float]* @E0000.fn, i64 0, i64 %159
store float %163, float* %164
%165 = getelementptr inbounds [13 x float], [13 x float]* @E0000.fm, i64 0, i64 %159
store float %158, float* %165
store i32 %160, i32* @E0000.n
%166 = icmp slt i32 %162, %161
br i1 %166, label %167, label %172
167: ; preds = %157
%168 = sext i32 %160 to i64
%169 = getelementptr inbounds [169 x float], [169 x float]* @E0000.snorm, i64 0, i64 %168
%170 = getelementptr inbounds float, float* %169, i64 -1
%171 = load float, float* %170
br label %58
172: ; preds = %157, %55
store float 0.000000e+00, float* getelementptr inbounds ([13 x [13 x float]], [13 x [13 x float]]* @E0000.k, i64 0, i64 1, i64 1)
store float -1.000000e+03, float* @E0000.olon
store float -1.000000e+03, float* @E0000.olat
store float -1.000000e+03, float* @E0000.oalt
store float -1.000000e+03, float* @E0000.otime
br label %599
173: ; preds = %11
%174 = load float, float* @E0000.epoc
%175 = fsub float %6, %174
store float %175, float* @E0000.dt
%176 = load float, float* @E0000.otime
%177 = fcmp olt float %176, 0.000000e+00
br i1 %177, label %178, label %183
178: ; preds = %173
%179 = fcmp olt float %175, 0.000000e+00
%180 = fcmp ogt float %175, 5.000000e+00
%181 = or i1 %179, %180
br i1 %181, label %182, label %183
182: ; preds = %178
store float %174, float* %9
br label %599
183: ; preds = %178, %173
store float 0x3F91DF46A0000000, float* @E0000.dtr
%184 = fmul float %5, 0x3F91DF46A0000000
store float %184, float* @E0000.rlon
%185 = fmul float %4, 0x3F91DF46A0000000
store float %185, float* @E0000.rlat
%186 = tail call float @sin(float %184)
store float %186, float* @E0000.srlon
%187 = load float, float* @E0000.rlat
%188 = tail call float @sin(float %187)
store float %188, float* @E0000.srlat
%189 = load float, float* @E0000.rlon
%190 = tail call float @cos(float %189)
store float %190, float* @E0000.crlon
%191 = load float, float* @E0000.rlat
%192 = tail call float @cos(float %191)
store float %192, float* @E0000.crlat
%193 = load float, float* @E0000.srlat
%194 = fmul float %193, %193
store float %194, float* @E0000.srlat2
%195 = fmul float %192, %192
store float %195, float* @E0000.crlat2
%196 = load float, float* @E0000.srlon
store float %196, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.sp, i64 0, i64 1)
%197 = load float, float* @E0000.crlon
store float %197, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.cp, i64 0, i64 1)
%198 = load float, float* @E0000.oalt
%199 = fcmp une float %198, %3
%200 = load float, float* @E0000.olat
%201 = fcmp une float %200, %4
%202 = select i1 %199, i1 true, i1 %201
br i1 %202, label %203, label %259
203: ; preds = %183
%204 = load float, float* @E0000.a2
%205 = load float, float* @E0000.c2
%206 = fneg float %205
%207 = tail call float @llvm.fmuladd.f32(float %206, float %194, float %204)
%208 = tail call float @sqrt(float %207)
store float %208, float* @E0000.q
%209 = fmul float %208, %3
store float %209, float* @E0000.q1
%210 = load float, float* @E0000.a2
%211 = fadd float %209, %210
%212 = load float, float* @E0000.b2
%213 = fadd float %209, %212
%214 = fdiv float %211, %213
%215 = fmul float %214, %214
%216 = load float, float* @E0000.srlat
%217 = load float, float* @E0000.crlat2
%218 = load float, float* @E0000.srlat2
%219 = tail call float @llvm.fmuladd.f32(float %215, float %217, float %218)
%220 = tail call float @sqrt(float %219)
%221 = fdiv float %216, %220
store float %221, float* @E0000.ct
%222 = fmul float %221, %221
%223 = fsub float 1.000000e+00, %222
%224 = tail call float @sqrt(float %223)
store float %224, float* @E0000.st
%225 = fmul float %3, %3
%226 = fpext float %225 to double
%227 = load float, float* @E0000.q1
%228 = fpext float %227 to double
%229 = tail call double @llvm.fmuladd.f64(double %228, double 2.000000e+00, double %226)
%230 = load float, float* @E0000.a4
%231 = load float, float* @E0000.c4
%232 = load float, float* @E0000.srlat2
%233 = fneg float %231
%234 = tail call float @llvm.fmuladd.f32(float %233, float %232, float %230)
%235 = load float, float* @E0000.q
%236 = fmul float %235, %235
%237 = fdiv float %234, %236
%238 = fpext float %237 to double
%239 = fadd double %229, %238
%240 = fptrunc double %239 to float
%241 = tail call float @sqrt(float %240)
store float %241, float* @E0000.r
%242 = load float, float* @E0000.a2
%243 = load float, float* @E0000.crlat2
%244 = load float, float* @E0000.b2
%245 = load float, float* @E0000.srlat2
%246 = fmul float %244, %245
%247 = tail call float @llvm.fmuladd.f32(float %242, float %243, float %246)
%248 = tail call float @sqrt(float %247)
%249 = fadd float %248, %3
%250 = load float, float* @E0000.r
%251 = fdiv float %249, %250
store float %251, float* @E0000.ca
%252 = load float, float* @E0000.c2
%253 = load float, float* @E0000.crlat
%254 = fmul float %252, %253
%255 = load float, float* @E0000.srlat
%256 = fmul float %254, %255
%257 = fmul float %248, %250
%258 = fdiv float %256, %257
store float %258, float* @E0000.sa
br label %259
259: ; preds = %183, %203
%260 = load float, float* @E0000.olon
%261 = fcmp une float %260, %5
%262 = load i32, i32* @E0000.maxord
br i1 %261, label %263, label %290
263: ; preds = %259
%264 = icmp slt i32 %262, 2
br i1 %264, label %288, label %265
265: ; preds = %263
%266 = add nuw i32 %262, 1
%267 = zext i32 %266 to i64
%268 = load float, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.sp, i64 0, i64 1)
%269 = load float, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.cp, i64 0, i64 1)
br label %270
270: ; preds = %286, %265
%271 = phi float [ %268, %265 ], [ %277, %286 ]
%272 = phi float [ %269, %265 ], [ %287, %286 ]
%273 = phi float [ %269, %265 ], [ %282, %286 ]
%274 = phi float [ %268, %265 ], [ %279, %286 ]
%275 = phi i64 [ 2, %265 ], [ %284, %286 ]
%276 = fmul float %272, %271
%277 = tail call float @llvm.fmuladd.f32(float %274, float %273, float %276)
%278 = getelementptr inbounds [13 x float], [13 x float]* @E0000.sp, i64 0, i64 %275
store float %277, float* %278
%279 = load float, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.sp, i64 0, i64 1)
%280 = fneg float %279
%281 = fmul float %271, %280
%282 = tail call float @llvm.fmuladd.f32(float %272, float %273, float %281)
%283 = getelementptr inbounds [13 x float], [13 x float]* @E0000.cp, i64 0, i64 %275
store float %282, float* %283
%284 = add nuw nsw i64 %275, 1
%285 = icmp eq i64 %284, %267
br i1 %285, label %288, label %286
286: ; preds = %270
%287 = load float, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.cp, i64 0, i64 1)
br label %270
288: ; preds = %270, %263
%289 = phi i32 [ 2, %263 ], [ %266, %270 ]
store i32 %289, i32* @E0000.m
br label %290
290: ; preds = %259, %288
%291 = load float, float* @E0000.re
%292 = load float, float* @E0000.r
%293 = fdiv float %291, %292
%294 = icmp slt i32 %262, 1
br i1 %294, label %295, label %297
295: ; preds = %290
%296 = load float, float* @E0000.st
br label %519
297: ; preds = %290
%298 = fmul float %293, %293
%299 = load float, float* @E0000.oalt
%300 = fcmp une float %299, %3
%301 = load float, float* @E0000.olat
%302 = fcmp une float %301, %4
%303 = select i1 %300, i1 true, i1 %302
%304 = load float, float* @E0000.otime
%305 = fcmp une float %304, %6
%306 = load float, float* @E0000.st
%307 = fcmp oeq float %306, 0.000000e+00
%308 = load float, float* @E0000.ct
%309 = fneg float %306
%310 = load float, float* @E0000.dt
%311 = load <4 x float>, <4 x float>* bitcast ([13 x float]* @E0000.cp to <4 x float>*)
%312 = shufflevector <4 x float> %311, <4 x float> poison, <2 x i32> <i32 0, i32 undef>
%313 = load float, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.pp, i64 0, i64 0)
%314 = add nuw i32 %262, 1
%315 = zext i32 %314 to i64
%316 = load float, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.sp, i64 0, i64 0)
%317 = insertelement <2 x float> %312, float %316, i64 1
br label %320
318: ; preds = %510
%319 = icmp eq i64 %327, %315
br i1 %319, label %516, label %320
320: ; preds = %297, %318
%321 = phi i64 [ 1, %297 ], [ %327, %318 ]
%322 = phi float [ %298, %297 ], [ %326, %318 ]
%323 = phi float [ 0.000000e+00, %297 ], [ %492, %318 ]
%324 = phi float [ 0.000000e+00, %297 ], [ %511, %318 ]
%325 = phi <2 x float> [ zeroinitializer, %297 ], [ %489, %318 ]
%326 = fmul float %293, %322
%327 = add nuw nsw i64 %321, 1
%328 = getelementptr inbounds [169 x float], [169 x float]* @E0000.snorm, i64 0, i64 %321
%329 = fneg float %326
%330 = getelementptr inbounds [13 x float], [13 x float]* @E0000.fn, i64 0, i64 %321
%331 = load float, float* %330
%332 = icmp eq i64 %321, 1
%333 = icmp ult i64 %321, 2
%334 = add nsw i64 %321, -2
%335 = getelementptr inbounds float, float* %328, i64 -2
%336 = and i64 %334, 4294967295
%337 = getelementptr inbounds float, float* %328, i64 -1
%338 = add nsw i64 %321, -1
%339 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 0, i64 %321
%340 = getelementptr inbounds [13 x float], [13 x float]* @E0000.pp, i64 0, i64 %338
%341 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.k, i64 0, i64 1, i64 %321
%342 = getelementptr inbounds [13 x float], [13 x float]* @E0000.pp, i64 0, i64 %334
%343 = getelementptr inbounds [13 x float], [13 x float]* @E0000.pp, i64 0, i64 %321
%344 = trunc i64 %327 to i32
%345 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 0, i64 %338
%346 = trunc i64 %321 to i32
%347 = mul i32 %346, 13
%348 = add i32 %347, -13
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds float, float* %337, i64 %349
%351 = sext i32 %347 to i64
%352 = getelementptr inbounds float, float* %328, i64 %351
%353 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %338, i64 %338
%354 = mul nsw i64 %338, 13
%355 = getelementptr inbounds float, float* %337, i64 %354
%356 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %321, i64 %321
%357 = insertelement <2 x float> poison, float %329, i64 0
br label %358
358: ; preds = %320, %510
%359 = phi i64 [ 0, %320 ], [ %514, %510 ]
%360 = phi float [ %324, %320 ], [ %511, %510 ]
%361 = phi i32 [ %344, %320 ], [ %513, %510 ]
%362 = phi float [ %323, %320 ], [ %492, %510 ]
%363 = phi float [ %324, %320 ], [ %512, %510 ]
%364 = phi <2 x float> [ %325, %320 ], [ %489, %510 ]
br i1 %303, label %365, label %409
365: ; preds = %358
%366 = icmp eq i64 %321, %359
br i1 %366, label %367, label %374
367: ; preds = %365
%368 = load float, float* %350
%369 = fmul float %306, %368
store float %369, float* %352
%370 = load float, float* %353
%371 = load float, float* %355
%372 = fmul float %308, %371
%373 = tail call float @llvm.fmuladd.f32(float %306, float %370, float %372)
store float %373, float* %356
br label %409
374: ; preds = %365
%375 = icmp eq i64 %359, 0
%376 = select i1 %332, i1 %375, i1 false
br i1 %376, label %410, label %377
377: ; preds = %374
br i1 %333, label %409, label %378
378: ; preds = %377
%379 = icmp sgt i64 %359, %334
br i1 %379, label %385, label %380
380: ; preds = %378
%381 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %359, i64 %336
%382 = load float, float* %381
%383 = mul i64 %359, 13
%384 = and i64 %383, 4294967295
br label %390
385: ; preds = %378
%386 = mul i64 %359, 13
%387 = and i64 %386, 4294967295
%388 = getelementptr inbounds float, float* %335, i64 %387
store float 0.000000e+00, float* %388
%389 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %359, i64 %336
store float 0.000000e+00, float* %389
br label %390
390: ; preds = %380, %385
%391 = phi i64 [ %384, %380 ], [ %387, %385 ]
%392 = phi float [ %382, %380 ], [ 0.000000e+00, %385 ]
%393 = getelementptr inbounds float, float* %337, i64 %391
%394 = load float, float* %393
%395 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.k, i64 0, i64 %359, i64 %321
%396 = load float, float* %395
%397 = getelementptr inbounds float, float* %335, i64 %391
%398 = load float, float* %397
%399 = fneg float %396
%400 = fmul float %398, %399
%401 = tail call float @llvm.fmuladd.f32(float %308, float %394, float %400)
%402 = getelementptr inbounds float, float* %328, i64 %391
store float %401, float* %402
%403 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %359, i64 %338
%404 = load float, float* %403
%405 = fmul float %394, %309
%406 = tail call float @llvm.fmuladd.f32(float %308, float %404, float %405)
%407 = tail call float @llvm.fmuladd.f32(float %399, float %392, float %406)
%408 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %359, i64 %321
store float %407, float* %408
br label %409
409: ; preds = %358, %390, %377, %367
br i1 %305, label %417, label %438
410: ; preds = %374
%411 = load float, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 0)
%412 = fmul float %308, %411
store float %412, float* getelementptr inbounds ([169 x float], [169 x float]* @E0000.snorm, i64 0, i64 1)
%413 = load float, float* %345
%414 = load float, float* %337
%415 = fmul float %414, %309
%416 = tail call float @llvm.fmuladd.f32(float %308, float %413, float %415)
store float %416, float* getelementptr inbounds ([13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 0, i64 1)
br i1 %305, label %417, label %445
417: ; preds = %410, %409
%418 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %359, i64 %321
%419 = load float, float* %418
%420 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %359, i64 %321
%421 = load float, float* %420
%422 = tail call float @llvm.fmuladd.f32(float %310, float %421, float %419)
%423 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %359, i64 %321
store float %422, float* %423
%424 = icmp eq i64 %359, 0
br i1 %424, label %445, label %425
425: ; preds = %417
%426 = add nsw i64 %359, -1
%427 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.c, i64 0, i64 %321, i64 %426
%428 = load float, float* %427
%429 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.cd, i64 0, i64 %321, i64 %426
%430 = load float, float* %429
%431 = tail call float @llvm.fmuladd.f32(float %310, float %430, float %428)
%432 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %321, i64 %426
store float %431, float* %432
%433 = mul i64 %359, 13
%434 = and i64 %433, 4294967295
%435 = getelementptr inbounds float, float* %328, i64 %434
%436 = load float, float* %435
%437 = fmul float %326, %436
br label %456
438: ; preds = %409
%439 = mul i64 %359, 13
%440 = and i64 %439, 4294967295
%441 = getelementptr inbounds float, float* %328, i64 %440
%442 = load float, float* %441
%443 = fmul float %326, %442
%444 = icmp eq i64 %359, 0
br i1 %444, label %450, label %456
445: ; preds = %417, %410
%446 = mul nuw nsw i64 %359, 13
%447 = getelementptr inbounds float, float* %328, i64 %446
%448 = load float, float* %447
%449 = fmul float %326, %448
br label %450
450: ; preds = %445, %438
%451 = phi float [ %443, %438 ], [ %449, %445 ]
%452 = load float, float* %339
%453 = insertelement <2 x float> poison, float %452, i64 0
%454 = shufflevector <2 x float> %453, <2 x float> poison, <2 x i32> zeroinitializer
%455 = fmul <2 x float> %454, %317
br label %478
456: ; preds = %425, %438
%457 = phi float [ %437, %425 ], [ %443, %438 ]
%458 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %359, i64 %321
%459 = load float, float* %458
%460 = getelementptr inbounds [13 x float], [13 x float]* @E0000.cp, i64 0, i64 %359
%461 = load float, float* %460
%462 = add nsw i64 %359, -1
%463 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.tc, i64 0, i64 %321, i64 %462
%464 = load float, float* %463
%465 = getelementptr inbounds [13 x float], [13 x float]* @E0000.sp, i64 0, i64 %359
%466 = load float, float* %465
%467 = fneg float %464
%468 = insertelement <2 x float> poison, float %464, i64 0
%469 = insertelement <2 x float> %468, float %461, i64 1
%470 = insertelement <2 x float> poison, float %466, i64 0
%471 = insertelement <2 x float> %470, float %467, i64 1
%472 = fmul <2 x float> %469, %471
%473 = insertelement <2 x float> poison, float %459, i64 0
%474 = shufflevector <2 x float> %473, <2 x float> poison, <2 x i32> zeroinitializer
%475 = insertelement <2 x float> poison, float %461, i64 0
%476 = insertelement <2 x float> %475, float %466, i64 1
%477 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %474, <2 x float> %476, <2 x float> %472)
br label %478
478: ; preds = %456, %450
%479 = phi float [ %457, %456 ], [ %451, %450 ]
%480 = phi <2 x float> [ %477, %456 ], [ %455, %450 ]
%481 = getelementptr inbounds [13 x [13 x float]], [13 x [13 x float]]* @E0000.dp, i64 0, i64 %359, i64 %321
%482 = load float, float* %481
%483 = getelementptr inbounds [13 x float], [13 x float]* @E0000.fm, i64 0, i64 %359
%484 = load float, float* %483
%485 = insertelement <2 x float> %357, float %484, i64 1
%486 = fmul <2 x float> %480, %485
%487 = insertelement <2 x float> poison, float %482, i64 0
%488 = insertelement <2 x float> %487, float %479, i64 1
%489 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %486, <2 x float> %488, <2 x float> %364)
%490 = extractelement <2 x float> %480, i64 0
%491 = fmul float %490, %331
%492 = tail call float @llvm.fmuladd.f32(float %491, float %479, float %362)
%493 = icmp eq i64 %359, 1
%494 = select i1 %307, i1 %493, i1 false
br i1 %494, label %495, label %510
495: ; preds = %478
br i1 %332, label %496, label %498
496: ; preds = %495
store float %313, float* getelementptr inbounds ([13 x float], [13 x float]* @E0000.pp, i64 0, i64 1)
%497 = load float, float* %343
br label %505
498: ; preds = %495
%499 = load float, float* %340
%500 = load float, float* %341
%501 = load float, float* %342
%502 = fneg float %500
%503 = fmul float %501, %502
%504 = tail call float @llvm.fmuladd.f32(float %308, float %499, float %503)
store float %504, float* %343
br label %505
505: ; preds = %498, %496
%506 = phi float [ %504, %498 ], [ %497, %496 ]
%507 = fmul float %326, %506
%508 = extractelement <2 x float> %486, i64 1
%509 = tail call float @llvm.fmuladd.f32(float %508, float %507, float %363)
br label %510
510: ; preds = %478, %505
%511 = phi float [ %360, %478 ], [ %509, %505 ]
%512 = phi float [ %363, %478 ], [ %509, %505 ]
%513 = add nsw i32 %361, -1
%514 = add nuw nsw i64 %359, 1
%515 = icmp sgt i32 %361, 1
br i1 %515, label %358, label %318
516: ; preds = %318
%517 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %486, <2 x float> %488, <2 x float> %364)
%518 = trunc i64 %514 to i32
store i32 %518, i32* @E0000.m
br label %519
519: ; preds = %295, %516
%520 = phi float [ %492, %516 ], [ 0.000000e+00, %295 ]
%521 = phi float [ %511, %516 ], [ 0.000000e+00, %295 ]
%522 = phi float [ %306, %516 ], [ %296, %295 ]
%523 = phi i32 [ %314, %516 ], [ 1, %295 ]
%524 = phi <2 x float> [ %517, %516 ], [ zeroinitializer, %295 ]
store i32 %523, i32* @E0000.n
%525 = fcmp oeq float %522, 0.000000e+00
%526 = extractelement <2 x float> %524, i64 1
%527 = fdiv float %526, %522
%528 = select i1 %525, float %521, float %527
%529 = extractelement <2 x float> %524, i64 0
%530 = fneg float %529
%531 = load float, float* @E0000.ca
%532 = load float, float* @E0000.sa
%533 = fneg float %520
%534 = fmul float %532, %533
%535 = tail call float @llvm.fmuladd.f32(float %530, float %531, float %534)
store float %535, float* @E0000.bx
store float %528, float* @E0000.by
%536 = fmul float %531, %533
%537 = tail call float @llvm.fmuladd.f32(float %529, float %532, float %536)
store float %537, float* @E0000.bz
%538 = fmul float %528, %528
%539 = tail call float @llvm.fmuladd.f32(float %535, float %535, float %538)
%540 = tail call float @sqrt(float %539)
store float %540, float* @E0000.bh
%541 = load float, float* @E0000.bz
%542 = fmul float %541, %541
%543 = tail call float @llvm.fmuladd.f32(float %540, float %540, float %542)
%544 = tail call float @sqrt(float %543)
store float %544, float* %9
%545 = load float, float* @E0000.by
%546 = load float, float* @E0000.bx
%547 = tail call float @atan2(float %545, float %546)
%548 = load float, float* @E0000.dtr
%549 = fdiv float %547, %548
store float %549, float* %7
%550 = load float, float* @E0000.bz
%551 = load float, float* @E0000.bh
%552 = tail call float @atan2(float %550, float %551)
%553 = load float, float* @E0000.dtr
%554 = fdiv float %552, %553
store float %554, float* %8
store float -9.990000e+02, float* %10
%555 = tail call float @llvm.fabs.f32(float %4)
%556 = fcmp ult float %555, 5.500000e+01
br i1 %556, label %598, label %557
557: ; preds = %519
%558 = fcmp ogt float %4, 0.000000e+00
%559 = xor i1 %558, true
%560 = fcmp ult float %5, 0.000000e+00
%561 = or i1 %560, %559
br i1 %561, label %565, label %562
562: ; preds = %557
%563 = load float, float* %7
%564 = fsub float %563, %5
store float %564, float* %10
br label %565
565: ; preds = %562, %557
%566 = phi float [ %564, %562 ], [ -9.990000e+02, %557 ]
%567 = fcmp olt float %5, 0.000000e+00
%568 = and i1 %558, %567
br i1 %568, label %569, label %573
569: ; preds = %565
%570 = load float, float* %7
%571 = tail call float @llvm.fabs.f32(float %5)
%572 = fadd float %571, %570
store float %572, float* %10
br label %573
573: ; preds = %569, %565
%574 = phi float [ %572, %569 ], [ %566, %565 ]
%575 = fcmp olt float %4, 0.000000e+00
%576 = xor i1 %575, true
%577 = or i1 %560, %576
br i1 %577, label %581, label %578
578: ; preds = %573
%579 = load float, float* %7
%580 = fadd float %579, %5
store float %580, float* %10
br label %581
581: ; preds = %578, %573
%582 = phi float [ %580, %578 ], [ %574, %573 ]
%583 = and i1 %575, %567
br i1 %583, label %584, label %588
584: ; preds = %581
%585 = load float, float* %7
%586 = tail call float @llvm.fabs.f32(float %5)
%587 = fsub float %585, %586
store float %587, float* %10
br label %588
588: ; preds = %581, %584
%589 = phi float [ %587, %584 ], [ %582, %581 ]
%590 = fcmp ogt float %589, 1.800000e+02
%591 = fadd float %589, -3.600000e+02
%592 = select i1 %590, float %591, float %589
%593 = fcmp olt float %592, -1.800000e+02
%594 = or i1 %590, %593
br i1 %594, label %595, label %598
595: ; preds = %588
%596 = fadd float %592, 3.600000e+02
%597 = select i1 %593, float %596, float %592
store float %597, float* %10
br label %598
598: ; preds = %595, %588, %519
store float %6, float* @E0000.otime
store float %3, float* @E0000.oalt
store float %4, float* @E0000.olat
store float %5, float* @E0000.olon
br label %599
599: ; preds = %598, %182, %172
%600 = phi i32 [ -1, %182 ], [ 0, %598 ], [ 0, %172 ]
ret i32 %600
}