#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 */

/* Variables and functions */
float cos(float);
float sin(float);
void cfr4syn(long off, long nn, float *b0, float *b1, float *b2, float *b3,
             float *b4, float *b5, float *b6, float *b7) {
  extern double pii, p7two;
  float piovn, arg, c1, c2, c3, s1, s2, s3, t0, t1, t2, t3, t4, t5, t6, t7;
  long i, off4, jj0, jlast, k0, kl, ji, jl, jr, j, k, jj1, j2, j3, j4, j5, j6,
      j7, j8, j9, j10, j11, j12, j13, j14, j15, j16, j17, j18, jthet, th2, l1,
      l2, l3, l4, l5, l6, l7, l8, l9, l10, l11, l12, l13, l14, l15, l16, l17,
      l18, l19, l[19];
  l[0] = nn / 4;
  for (i = 1; i < 19; i++) {
    if (l[i - 1] < 2)
      l[i - 1] = 2;
    else if (l[i - 1] != 2) {
      l[i] = l[i - 1] / 2;
      continue;
    }
    l[i] = 2;
  }
  l1 = l[18];
  l2 = l[17];
  l3 = l[16];
  l4 = l[15];
  l5 = l[14];
  l6 = l[13];
  l7 = l[12];
  l8 = l[11];
  l9 = l[10];
  l10 = l[9];
  l11 = l[8];
  l12 = l[7];
  l13 = l[6];
  l14 = l[5];
  l15 = l[4];
  l16 = l[3];
  l17 = l[2];
  l18 = l[1];
  l19 = l[0];
  piovn = pii / nn;
  ji = 3;
  jl = 2;
  jr = 2;
  jj1 = 2;
loop1:
  j2 = jj1;
loop2:
  j3 = j2;
loop3:
  j4 = j3;
loop4:
  j5 = j4;
loop5:
  for (j6 = j5; j6 <= l6; j6 += l5) {
    for (j7 = j6; j7 <= l7; j7 += l6) {
      for (j8 = j7; j8 <= l8; j8 += l7) {
        for (j9 = j8; j9 <= l9; j9 += l8) {
          for (j10 = j9; j10 <= l10; j10 += l9) {
            for (j11 = j10; j11 <= l11; j11 += l10) {
              for (j12 = j11; j12 <= l12; j12 += l11) {
                for (j13 = j12; j13 <= l13; j13 += l12) {
                  for (j14 = j13; j14 <= l14; j14 += l13) {
                    for (j15 = j14; j15 <= l15; j15 += l14) {
                      for (j16 = j15; j16 <= l16; j16 += l15) {
                        for (j17 = j16; j17 <= l17; j17 += l16) {
                          for (j18 = j17; j18 <= l18; j18 += l17) {
                            for (jthet = j18; jthet <= l19; jthet += l18) {
                              th2 = jthet - 2;
                              if (th2 > 0) {
                                arg = th2 * piovn;
                                c1 = cos(arg);
                                s1 = -sin(arg);
                                c2 = c1 * c1 - s1 * s1;
                                s2 = c1 * s1 + c1 * s1;
                                c3 = c1 * c2 - s1 * s2;
                                s3 = c2 * s1 + s2 * c1;
                                off4 = 4 * off;
                                jj0 = jr * off4;
                                k0 = ji * off4;
                                jlast = jj0 + off;
                                for (j = jj0; j < jlast; j++) {
                                  k = k0 + j - jj0;
                                  t0 = b0[j] + b6[k];
                                  t1 = b7[k] - b1[j];
                                  t2 = b0[j] - b6[k];
                                  t3 = b7[k] + b1[j];
                                  t4 = b2[j] + b4[k];
                                  t5 = b5[k] - b3[j];
                                  t6 = b5[k] + b3[j];
                                  t7 = b4[k] - b2[j];
                                  b0[j] = t0 + t4;
                                  b4[k] = t1 + t5;
                                  b1[j] = (t2 + t6) * c1 - (t3 + t7) * s1;
                                  b5[k] = (t2 + t6) * s1 + (t3 + t7) * c1;
                                  b2[j] = (t0 - t4) * c2 - (t1 - t5) * s2;
                                  b6[k] = (t0 - t4) * s2 + (t1 - t5) * c2;
                                  b3[j] = (t2 - t6) * c3 - (t3 - t7) * s3;
                                  b7[k] = (t2 - t6) * s3 + (t3 - t7) * c3;
                                }
                                jr = jr + 2;
                                ji = ji - 2;
                                if (ji <= jl) {
                                  ji = 2 * jr - 1;
                                  jl = jr;
                                }
                              } else {
                                for (i = 0; i < off; i++) {
                                  t0 = b0[i] + b1[i];
                                  t1 = b0[i] - b1[i];
                                  t2 = b2[i] * 2.0;
                                  t3 = b3[i] * 2.0;
                                  b0[i] = t0 + t2;
                                  b2[i] = t0 - t2;
                                  b1[i] = t1 + t3;
                                  b3[i] = t1 - t3;
                                }
                                if (nn > 4) {
                                  k0 = 4 * off;
                                  kl = k0 + off;
                                  for (i = k0; i < kl; i++) {
                                    t2 = b0[i] - b2[i];
                                    t3 = b1[i] + b3[i];
                                    b0[i] = (b0[i] + b2[i]) * 2.0;
                                    b2[i] = (b3[i] - b1[i]) * 2.0;
                                    b1[i] = (t2 + t3) * p7two;
                                    b3[i] = (t3 - t2) * p7two;
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  j5 += l4;
  if (j5 <= l5)
    goto loop5;
  j4 += l3;
  if (j4 <= l4)
    goto loop4;
  j3 += l2;
  if (j3 <= l3)
    goto loop3;
  j2 += l1;
  if (j2 <= l2)
    goto loop2;
  jj1 += 2;
  if (jj1 <= l1)
    goto loop1;
}


x86 assembly (clang, -O0):
<cfr4syn>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2a0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    $0x4,%ecx
cqto
idiv   %rcx
mov    %rax,-0x2a0(%rbp)
movq   $0x1,-0x78(%rbp)
cmpq   $0x13,-0x78(%rbp)
jge    1216 <cfr4syn+0xf6>
mov    -0x78(%rbp),%rax
sub    $0x1,%rax
cmpq   $0x2,-0x2a0(%rbp,%rax,8)
ff 02
jge    11ab <cfr4syn+0x8b>
mov    -0x78(%rbp),%rax
sub    $0x1,%rax
movq   $0x2,-0x2a0(%rbp,%rax,8)
jmp    11f5 <cfr4syn+0xd5>
mov    -0x78(%rbp),%rax
sub    $0x1,%rax
cmpq   $0x2,-0x2a0(%rbp,%rax,8)
ff 02
je     11f0 <cfr4syn+0xd0>
mov    -0x78(%rbp),%rax
sub    $0x1,%rax
mov    -0x2a0(%rbp,%rax,8),%rax
ff
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x78(%rbp),%rax
mov    %rcx,-0x2a0(%rbp,%rax,8)
ff
jmp    1205 <cfr4syn+0xe5>
jmp    11f5 <cfr4syn+0xd5>
mov    -0x78(%rbp),%rax
movq   $0x2,-0x2a0(%rbp,%rax,8)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    1170 <cfr4syn+0x50>
mov    -0x210(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x218(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x220(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    -0x228(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x230(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0x238(%rbp),%rax
mov    %rax,-0x198(%rbp)
mov    -0x240(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x248(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x250(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x258(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x260(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x268(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x270(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x278(%rbp),%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x280(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x288(%rbp),%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x290(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
mov    -0x298(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x2a0(%rbp),%rax
mov    %rax,-0x200(%rbp)
mov    0x2cb1(%rip),%rax
movsd  (%rax),%xmm0
cvtsi2sdq -0x10(%rbp),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movq   $0x3,-0xa8(%rbp)
movq   $0x2,-0xb0(%rbp)
movq   $0x2,-0xb8(%rbp)
movq   $0x2,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf0(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0xf8(%rbp),%rax
cmp    -0x198(%rbp),%rax
jg     1e65 <cfr4syn+0xd45>
mov    -0xf8(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x100(%rbp),%rax
cmp    -0x1a0(%rbp),%rax
jg     1e46 <cfr4syn+0xd26>
mov    -0x100(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x108(%rbp),%rax
cmp    -0x1a8(%rbp),%rax
jg     1e27 <cfr4syn+0xd07>
mov    -0x108(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x110(%rbp),%rax
cmp    -0x1b0(%rbp),%rax
jg     1e08 <cfr4syn+0xce8>
mov    -0x110(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x118(%rbp),%rax
cmp    -0x1b8(%rbp),%rax
jg     1de9 <cfr4syn+0xcc9>
mov    -0x118(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x120(%rbp),%rax
cmp    -0x1c0(%rbp),%rax
jg     1dca <cfr4syn+0xcaa>
mov    -0x120(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
cmp    -0x1c8(%rbp),%rax
jg     1dab <cfr4syn+0xc8b>
mov    -0x128(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x130(%rbp),%rax
cmp    -0x1d0(%rbp),%rax
jg     1d8c <cfr4syn+0xc6c>
mov    -0x130(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x138(%rbp),%rax
cmp    -0x1d8(%rbp),%rax
jg     1d6d <cfr4syn+0xc4d>
mov    -0x138(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x140(%rbp),%rax
cmp    -0x1e0(%rbp),%rax
jg     1d4e <cfr4syn+0xc2e>
mov    -0x140(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x148(%rbp),%rax
cmp    -0x1e8(%rbp),%rax
jg     1d2f <cfr4syn+0xc0f>
mov    -0x148(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x150(%rbp),%rax
cmp    -0x1f0(%rbp),%rax
jg     1d10 <cfr4syn+0xbf0>
mov    -0x150(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x158(%rbp),%rax
cmp    -0x1f8(%rbp),%rax
jg     1cf1 <cfr4syn+0xbd1>
mov    -0x158(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x160(%rbp),%rax
cmp    -0x200(%rbp),%rax
jg     1cd2 <cfr4syn+0xbb2>
mov    -0x160(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0x168(%rbp)
cmpq   $0x0,-0x168(%rbp)
jle    1a3b <cfr4syn+0x91b>
cvtsi2ssq -0x168(%rbp),%xmm0
ff ff
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
call   1040 <cos@plt>
movss  %xmm0,-0x3c(%rbp)
movss  -0x38(%rbp),%xmm0
call   1030 <sin@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x80(%rbp)
mov    -0xb8(%rbp),%rax
imul   -0x80(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0xa8(%rbp),%rax
imul   -0x80(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x88(%rbp),%rax
add    -0x8(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
cmp    -0x90(%rbp),%rax
jge    19da <cfr4syn+0x8ba>
mov    -0x98(%rbp),%rax
add    -0xc0(%rbp),%rax
sub    -0x88(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x18(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
mov    -0xc8(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x28(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0xc0(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
mov    -0xc8(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    0x28(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0xc0(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
mov    -0xc8(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    0x18(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xc0(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    0x18(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0xc0(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    0x10(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0xc0(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
addss  -0x70(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
addss  -0x70(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x18(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
subss  -0x68(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
subss  -0x64(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
subss  -0x68(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
subss  -0x70(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0xc0(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
subss  -0x70(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
mov    -0xc8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc0(%rbp)
jmp    16cc <cfr4syn+0x5ac>
mov    -0xb8(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xb8(%rbp)
mov    -0xa8(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
cmp    -0xb0(%rbp),%rax
jg     1a36 <cfr4syn+0x916>
mov    -0xb8(%rbp),%rax
shl    $0x1,%rax
sub    $0x1,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,-0xb0(%rbp)
jmp    1cb3 <cfr4syn+0xb93>
movq   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    1b48 <cfr4syn+0xa28>
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x558(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x532(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x54(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    1a43 <cfr4syn+0x923>
cmpq   $0x4,-0x10(%rbp)
jle    1cae <cfr4syn+0xb8e>
mov    -0x8(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
add    -0x8(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
cmp    -0xa0(%rbp),%rax
jge    1ca9 <cfr4syn+0xb89>
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x78(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x40c(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x3d1(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x238f(%rip),%rax
mulsd  (%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x60(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x2365(%rip),%rax
mulsd  (%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    1b7f <cfr4syn+0xa5f>
jmp    1cae <cfr4syn+0xb8e>
jmp    1cb3 <cfr4syn+0xb93>
jmp    1cb8 <cfr4syn+0xb98>
mov    -0x1f8(%rbp),%rax
add    -0x160(%rbp),%rax
mov    %rax,-0x160(%rbp)
jmp    156a <cfr4syn+0x44a>
jmp    1cd7 <cfr4syn+0xbb7>
mov    -0x1f0(%rbp),%rax
add    -0x158(%rbp),%rax
mov    %rax,-0x158(%rbp)
jmp    1548 <cfr4syn+0x428>
jmp    1cf6 <cfr4syn+0xbd6>
mov    -0x1e8(%rbp),%rax
add    -0x150(%rbp),%rax
mov    %rax,-0x150(%rbp)
jmp    1526 <cfr4syn+0x406>
jmp    1d15 <cfr4syn+0xbf5>
mov    -0x1e0(%rbp),%rax
add    -0x148(%rbp),%rax
mov    %rax,-0x148(%rbp)
jmp    1504 <cfr4syn+0x3e4>
jmp    1d34 <cfr4syn+0xc14>
mov    -0x1d8(%rbp),%rax
add    -0x140(%rbp),%rax
mov    %rax,-0x140(%rbp)
jmp    14e2 <cfr4syn+0x3c2>
jmp    1d53 <cfr4syn+0xc33>
mov    -0x1d0(%rbp),%rax
add    -0x138(%rbp),%rax
mov    %rax,-0x138(%rbp)
jmp    14c0 <cfr4syn+0x3a0>
jmp    1d72 <cfr4syn+0xc52>
mov    -0x1c8(%rbp),%rax
add    -0x130(%rbp),%rax
mov    %rax,-0x130(%rbp)
jmp    149e <cfr4syn+0x37e>
jmp    1d91 <cfr4syn+0xc71>
mov    -0x1c0(%rbp),%rax
add    -0x128(%rbp),%rax
mov    %rax,-0x128(%rbp)
jmp    147c <cfr4syn+0x35c>
jmp    1db0 <cfr4syn+0xc90>
mov    -0x1b8(%rbp),%rax
add    -0x120(%rbp),%rax
mov    %rax,-0x120(%rbp)
jmp    145a <cfr4syn+0x33a>
jmp    1dcf <cfr4syn+0xcaf>
mov    -0x1b0(%rbp),%rax
add    -0x118(%rbp),%rax
mov    %rax,-0x118(%rbp)
jmp    1438 <cfr4syn+0x318>
jmp    1dee <cfr4syn+0xcce>
mov    -0x1a8(%rbp),%rax
add    -0x110(%rbp),%rax
mov    %rax,-0x110(%rbp)
jmp    1416 <cfr4syn+0x2f6>
jmp    1e0d <cfr4syn+0xced>
mov    -0x1a0(%rbp),%rax
add    -0x108(%rbp),%rax
mov    %rax,-0x108(%rbp)
jmp    13f4 <cfr4syn+0x2d4>
jmp    1e2c <cfr4syn+0xd0c>
mov    -0x198(%rbp),%rax
add    -0x100(%rbp),%rax
mov    %rax,-0x100(%rbp)
jmp    13d2 <cfr4syn+0x2b2>
jmp    1e4b <cfr4syn+0xd2b>
mov    -0x190(%rbp),%rax
add    -0xf8(%rbp),%rax
mov    %rax,-0xf8(%rbp)
jmp    13b0 <cfr4syn+0x290>
mov    -0x188(%rbp),%rax
add    -0xf0(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf0(%rbp),%rax
cmp    -0x190(%rbp),%rax
jg     1e93 <cfr4syn+0xd73>
jmp    13a2 <cfr4syn+0x282>
mov    -0x180(%rbp),%rax
add    -0xe8(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rax
cmp    -0x188(%rbp),%rax
jg     1ec1 <cfr4syn+0xda1>
jmp    1394 <cfr4syn+0x274>
mov    -0x178(%rbp),%rax
add    -0xe0(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rax
cmp    -0x180(%rbp),%rax
jg     1eef <cfr4syn+0xdcf>
jmp    1386 <cfr4syn+0x266>
mov    -0x170(%rbp),%rax
add    -0xd8(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
cmp    -0x178(%rbp),%rax
jg     1f1d <cfr4syn+0xdfd>
jmp    1378 <cfr4syn+0x258>
mov    -0xd0(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
cmp    -0x170(%rbp),%rax
jg     1f48 <cfr4syn+0xe28>
jmp    136a <cfr4syn+0x24a>
add    $0x2a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cfr4syn>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x288,%rsp
mov    %r9,%r15
mov    %rcx,%r13
mov    %rdx,%r12
mov    %rdi,%r14
lea    0x3(%rsi),%rcx
test   %rsi,%rsi
cmovns %rsi,%rcx
sar    $0x2,%rcx
mov    %rcx,0x1d0(%rsp)
mov    $0x2,%eax
cmp    $0x1,%rcx
jg     1180 <cfr4syn+0x60>
nop
movq   $0x2,0x1c0(%rsp,%rax,8)
mov    $0x2,%edx
jmp    118e <cfr4syn+0x6e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rcx,%rdx
shr    %rdx
cmp    $0x2,%rcx
cmove  %rcx,%rdx
mov    %rdx,0x1c8(%rsp,%rax,8)
cmp    $0x2,%rdx
jge    11c0 <cfr4syn+0xa0>
nopl   0x0(%rax)
movq   $0x2,0x1c8(%rsp,%rax,8)
mov    $0x2,%ecx
jmp    11ce <cfr4syn+0xae>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdx,%rcx
shr    %rcx
cmp    $0x2,%rdx
cmove  %rdx,%rcx
mov    %rcx,0x1d0(%rsp,%rax,8)
add    $0x2,%rax
cmp    $0x14,%rax
jne    1159 <cfr4syn+0x39>
mov    0x260(%rsp),%rax
mov    %rax,0xf8(%rsp)
mov    0x258(%rsp),%rax
mov    %rax,0xf0(%rsp)
mov    0x2dcd(%rip),%rax
movsd  (%rax),%xmm0
cvtsi2sd %rsi,%xmm1
cmp    $0x5,%rsi
setl   %al
lea    0x0(,%r14,4),%rcx
lea    (%r14,%r14,4),%r10
mov    %rcx,0x120(%rsp)
cmp    %r10,%rcx
setge  %cl
or     %al,%cl
mov    %cl,0xf(%rsp)
mov    %r14,%rbp
shl    $0x4,%rbp
lea    (%r12,%rbp,1),%rax
mov    %rax,0x28(%rsp)
lea    (%r8,%rbp,1),%rax
mov    %rax,0xa8(%rsp)
mov    %r13,%rax
add    %rbp,%rax
mov    %rax,0x20(%rsp)
add    %r15,%rbp
lea    (%r12,%r14,4),%rsi
lea    (%r8,%r14,4),%rbx
lea    0x0(,%r14,4),%r9
add    %r13,%r9
cmp    %r12,%rbx
seta   %cl
lea    (%r15,%r14,4),%r11
cmp    %r8,%rsi
seta   %al
and    %cl,%al
cmp    %r12,%r9
seta   %dl
cmp    %r13,%rsi
seta   %cl
and    %dl,%cl
or     %al,%cl
cmp    %r12,%r11
seta   %dl
cmp    %r15,%rsi
seta   %al
and    %dl,%al
cmp    %r8,%r9
seta   %sil
cmp    %r13,%rbx
seta   %dl
and    %sil,%dl
or     %al,%dl
or     %cl,%dl
cmp    %r8,%r11
seta   %al
lea    (%r12,%r10,4),%rdi
cmp    %r15,%rbx
seta   %cl
and    %al,%cl
cmp    %r13,%r11
seta   %bl
lea    (%r8,%r10,4),%rsi
mov    %rsi,0x38(%rsp)
cmp    %r15,%r9
seta   %al
lea    0x0(,%r10,4),%r9
add    %r13,%r9
and    %bl,%al
or     %cl,%al
or     %dl,%al
mov    %al,0xe(%rsp)
mov    %r14,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0xa0(%rsp)
mov    0x28(%rsp),%rcx
cmp    %rsi,%rcx
setb   %al
mov    0xa8(%rsp),%r11
cmp    %rdi,%r11
setb   %dl
and    %al,%dl
cmp    %r9,%rcx
mov    %r9,%rbx
mov    %r9,0xd0(%rsp)
setb   %sil
mov    0x20(%rsp),%r9
cmp    %rdi,%r9
setb   %al
and    %sil,%al
lea    (%r15,%r10,4),%rsi
or     %dl,%al
cmp    %rsi,%rcx
setb   %dl
cmp    %rdi,%rbp
setb   %cl
and    %dl,%cl
cmp    %rbx,%r11
mov    %r11,%rdi
setb   %r11b
mov    0x38(%rsp),%rbx
cmp    %rbx,%r9
setb   %dl
and    %r11b,%dl
mov    %rdi,%r9
or     %cl,%dl
mov    0x250(%rsp),%rcx
mov    %rcx,0xe8(%rsp)
or     %al,%dl
cmp    %rsi,%rdi
setb   %cl
cmp    %rbx,%rbp
setb   %al
and    %cl,%al
mov    0x248(%rsp),%rcx
mov    %rcx,0x100(%rsp)
mov    0x20(%rsp),%rdi
cmp    %rsi,%rdi
mov    0xa0(%rsp),%rbx
setb   %sil
cmp    0xd0(%rsp),%rbp
mov    0x240(%rsp),%rcx
mov    %rcx,0x108(%rsp)
setb   %cl
and    %sil,%cl
or     %al,%cl
mov    0x238(%rsp),%rax
mov    %rax,0x40(%rsp)
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xc8(%rsp)
or     %dl,%cl
mov    %cl,0xd(%rsp)
mov    0x230(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0x228(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x220(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0x218(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x210(%rsp),%rax
mov    %rax,0x68(%rsp)
mov    0x208(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    0x200(%rsp),%rax
mov    %rax,0x78(%rsp)
mov    0x1f8(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0x1f0(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    0x1e8(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    0x1e0(%rsp),%rax
mov    %rax,0x98(%rsp)
mov    0x1d0(%rsp),%rax
mov    %rax,0xb0(%rsp)
mov    0x1d8(%rsp),%r11
lea    (%rbx,%r14,4),%rax
mov    %rax,0x1c0(%rsp)
mov    $0x3,%eax
mov    %rax,0x30(%rsp)
mov    $0x2,%eax
mov    $0x2,%ecx
mov    %rcx,0xc0(%rsp)
mov    $0x2,%ecx
mov    %rcx,0x128(%rsp)
mov    %rax,0x140(%rsp)
mov    %rax,0x138(%rsp)
mov    %rax,%rcx
mov    0x28(%rsp),%rdx
mov    %rcx,%rax
mov    %rcx,0x1a0(%rsp)
mov    %rax,%rsi
mov    %r8,0xb8(%rsp)
mov    %r14,0x10(%rsp)
mov    %r10,0x118(%rsp)
mov    %rbp,0x110(%rsp)
mov    %r11,0x1c8(%rsp)
mov    %rax,0x18(%rsp)
jmp    155e <cfr4syn+0x43e>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x148(%rsp),%rsi
add    0x100(%rsp),%rsi
cmp    0x108(%rsp),%rsi
jg     1df0 <cfr4syn+0xcd0>
cmp    0x40(%rsp),%rsi
mov    %rsi,0x148(%rsp)
jle    1587 <cfr4syn+0x467>
jmp    1540 <cfr4syn+0x420>
nop
mov    0x150(%rsp),%rsi
add    0x108(%rsp),%rsi
cmp    0x40(%rsp),%rsi
jg     1540 <cfr4syn+0x420>
cmp    0x48(%rsp),%rsi
mov    %rsi,0x150(%rsp)
jle    15b4 <cfr4syn+0x494>
jmp    1570 <cfr4syn+0x450>
nopl   0x0(%rax,%rax,1)
mov    0x158(%rsp),%rsi
add    0x40(%rsp),%rsi
cmp    0x48(%rsp),%rsi
jg     1570 <cfr4syn+0x450>
cmp    0x50(%rsp),%rsi
mov    %rsi,0x158(%rsp)
jle    15e4 <cfr4syn+0x4c4>
jmp    15a0 <cfr4syn+0x480>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x160(%rsp),%rsi
add    0x48(%rsp),%rsi
cmp    0x50(%rsp),%rsi
jg     15a0 <cfr4syn+0x480>
cmp    0x58(%rsp),%rsi
mov    %rsi,0x160(%rsp)
jle    1614 <cfr4syn+0x4f4>
jmp    15d0 <cfr4syn+0x4b0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x168(%rsp),%rsi
add    0x50(%rsp),%rsi
cmp    0x58(%rsp),%rsi
jg     15d0 <cfr4syn+0x4b0>
cmp    0x60(%rsp),%rsi
mov    %rsi,0x168(%rsp)
jle    1644 <cfr4syn+0x524>
jmp    1600 <cfr4syn+0x4e0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x170(%rsp),%rsi
add    0x58(%rsp),%rsi
cmp    0x60(%rsp),%rsi
jg     1600 <cfr4syn+0x4e0>
cmp    0x68(%rsp),%rsi
mov    %rsi,0x170(%rsp)
jle    1674 <cfr4syn+0x554>
jmp    1630 <cfr4syn+0x510>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x178(%rsp),%rsi
add    0x60(%rsp),%rsi
cmp    0x68(%rsp),%rsi
jg     1630 <cfr4syn+0x510>
cmp    0x70(%rsp),%rsi
mov    %rsi,0x178(%rsp)
jle    16a4 <cfr4syn+0x584>
jmp    1660 <cfr4syn+0x540>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x180(%rsp),%rsi
add    0x68(%rsp),%rsi
cmp    0x70(%rsp),%rsi
jg     1660 <cfr4syn+0x540>
cmp    0x78(%rsp),%rsi
mov    %rsi,0x180(%rsp)
jle    16d4 <cfr4syn+0x5b4>
jmp    1690 <cfr4syn+0x570>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x188(%rsp),%rsi
add    0x70(%rsp),%rsi
cmp    0x78(%rsp),%rsi
jg     1690 <cfr4syn+0x570>
cmp    0x80(%rsp),%rsi
mov    %rsi,0x188(%rsp)
jle    1707 <cfr4syn+0x5e7>
jmp    16c0 <cfr4syn+0x5a0>
nopl   0x0(%rax,%rax,1)
mov    0x190(%rsp),%rsi
add    0x78(%rsp),%rsi
cmp    0x80(%rsp),%rsi
jg     16c0 <cfr4syn+0x5a0>
cmp    0x88(%rsp),%rsi
mov    %rsi,0x190(%rsp)
jle    173a <cfr4syn+0x61a>
jmp    16f0 <cfr4syn+0x5d0>
nopl   0x0(%rax,%rax,1)
mov    0x198(%rsp),%rsi
add    0x80(%rsp),%rsi
cmp    0x88(%rsp),%rsi
jg     16f0 <cfr4syn+0x5d0>
cmp    0x90(%rsp),%rsi
mov    %rsi,0x198(%rsp)
jle    1772 <cfr4syn+0x652>
jmp    1720 <cfr4syn+0x600>
xchg   %ax,%ax
mov    0x1a8(%rsp),%rsi
add    0x88(%rsp),%rsi
cmp    0x90(%rsp),%rsi
mov    0x1a0(%rsp),%rcx
jg     1720 <cfr4syn+0x600>
cmp    0x98(%rsp),%rsi
mov    %rsi,0x1a8(%rsp)
jg     1750 <cfr4syn+0x630>
mov    %rsi,%rcx
jmp    17aa <cfr4syn+0x68a>
nopl   0x0(%rax)
mov    0x1b0(%rsp),%rcx
add    0x90(%rsp),%rcx
cmp    0x98(%rsp),%rcx
jg     1750 <cfr4syn+0x630>
cmp    %r11,%rcx
mov    %rcx,0x1b0(%rsp)
jle    17d5 <cfr4syn+0x6b5>
jmp    1790 <cfr4syn+0x670>
nopl   0x0(%rax)
mov    0x1b8(%rsp),%rcx
add    0x98(%rsp),%rcx
cmp    %r11,%rcx
jg     1790 <cfr4syn+0x670>
cmp    0xb0(%rsp),%rcx
mov    %rcx,0x1b8(%rsp)
jg     17c0 <cfr4syn+0x6a0>
mov    %rcx,%rsi
mov    0xb0(%rsp),%rcx
jmp    1856 <cfr4syn+0x736>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xb8(%rsp),%r8
mov    0x10(%rsp),%r14
mov    0x118(%rsp),%r10
mov    0x110(%rsp),%rbp
mov    0x28(%rsp),%rdx
mov    0xa8(%rsp),%r9
mov    0x20(%rsp),%rdi
mov    0xa0(%rsp),%rbx
mov    0x18(%rsp),%rax
mov    %r11,%rcx
mov    %rsi,%r11
mov    0x130(%rsp),%rsi
add    %r11,%rsi
cmp    %rcx,%rsi
jg     17c0 <cfr4syn+0x6a0>
cmp    $0x2,%rsi
jle    1b50 <cfr4syn+0xa30>
mov    %rsi,0x130(%rsp)
lea    -0x2(%rsi),%rax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xc8(%rsp),%xmm0
movss  %xmm0,0xd0(%rsp)
call   1040 <cos@plt>
movss  %xmm0,0x38(%rsp)
movss  0xd0(%rsp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,0xd0(%rsp)
test   %r14,%r14
jle    1af4 <cfr4syn+0x9d4>
mov    0xc0(%rsp),%r9
mov    0x120(%rsp),%rcx
imul   %rcx,%r9
mov    0x10(%rsp),%rax
lea    (%r9,%rax,1),%r8
movaps 0xd0(%rsp),%xmm0
movaps %xmm0,%xmm10
xorps  0x71f(%rip),%xmm10
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  0x38(%rsp),%xmm12
movaps %xmm12,%xmm2
mulss  %xmm12,%xmm2
subss  %xmm1,%xmm2
movaps %xmm10,0x270(%rsp)
mulss  %xmm12,%xmm10
addss  %xmm10,%xmm10
movaps %xmm0,%xmm1
mulss  %xmm10,%xmm1
movaps %xmm12,%xmm11
mulss  %xmm2,%xmm11
addss  %xmm1,%xmm11
mulss  %xmm10,%xmm12
movss  %xmm2,0xcc(%rsp)
movaps %xmm2,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm12
mov    0x30(%rsp),%rdx
imul   %rcx,%rdx
lea    (%r15,%r9,4),%r10
mov    0xb8(%rsp),%rax
lea    (%rax,%r9,4),%r11
lea    0x0(,%r9,4),%rdi
add    %r13,%rdi
lea    (%r12,%r9,4),%rbp
mov    0x2c8(%rsp),%rax
lea    (%rax,%rdx,4),%rbx
mov    0x2c0(%rsp),%rax
lea    (%rax,%rdx,4),%rcx
mov    0x2d8(%rsp),%rax
lea    (%rax,%rdx,4),%rax
mov    0x2d0(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movss  0x0(%rbp,%rsi,4),%xmm8
movss  (%rdx,%rsi,4),%xmm3
movaps %xmm8,%xmm6
addss  %xmm3,%xmm6
movss  (%rax,%rsi,4),%xmm2
movss  (%rdi,%rsi,4),%xmm4
movaps %xmm2,%xmm7
subss  %xmm4,%xmm7
subss  %xmm3,%xmm8
addss  %xmm4,%xmm2
movss  (%r11,%rsi,4),%xmm15
movss  (%rcx,%rsi,4),%xmm13
movaps %xmm15,%xmm5
addss  %xmm13,%xmm5
movss  (%rbx,%rsi,4),%xmm14
movss  (%r10,%rsi,4),%xmm3
movaps %xmm14,%xmm4
subss  %xmm3,%xmm4
addss  %xmm3,%xmm14
subss  %xmm15,%xmm13
movaps %xmm6,%xmm3
addss  %xmm5,%xmm3
movss  %xmm3,0x0(%rbp,%rsi,4)
movaps %xmm7,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,(%rcx,%rsi,4)
movaps %xmm8,%xmm1
addss  %xmm14,%xmm1
movaps %xmm2,%xmm15
addss  %xmm13,%xmm15
movaps 0xd0(%rsp),%xmm0
mulss  %xmm15,%xmm0
movaps %xmm1,%xmm3
movss  0x38(%rsp),%xmm9
mulss  %xmm9,%xmm3
addss  %xmm0,%xmm3
movss  %xmm3,(%rdi,%rsi,4)
mulss  %xmm9,%xmm15
mulss  0x270(%rsp),%xmm1
addss  %xmm15,%xmm1
movss  %xmm1,(%rbx,%rsi,4)
subss  %xmm5,%xmm6
subss  %xmm4,%xmm7
movaps %xmm10,%xmm0
mulss  %xmm7,%xmm0
movaps %xmm6,%xmm1
movss  0xcc(%rsp),%xmm3
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%r11,%rsi,4)
mulss  %xmm3,%xmm7
mulss  %xmm10,%xmm6
addss  %xmm7,%xmm6
movss  %xmm6,(%rdx,%rsi,4)
subss  %xmm14,%xmm8
subss  %xmm13,%xmm2
movaps %xmm12,%xmm0
mulss  %xmm2,%xmm0
movaps %xmm8,%xmm1
mulss  %xmm11,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%r10,%rsi,4)
mulss  %xmm11,%xmm2
mulss  %xmm12,%xmm8
addss  %xmm2,%xmm8
movss  %xmm8,(%rax,%rsi,4)
lea    (%r9,%rsi,1),%r14
add    $0x1,%r14
add    $0x1,%rsi
cmp    %r8,%r14
jl     19a0 <cfr4syn+0x880>
mov    0xc0(%rsp),%rcx
add    $0x2,%rcx
mov    0x30(%rsp),%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,0x30(%rsp)
cmp    0x128(%rsp),%rax
mov    0xb0(%rsp),%r11
mov    0x1c8(%rsp),%rsi
mov    %rcx,0xc0(%rsp)
jg     1800 <cfr4syn+0x6e0>
lea    (%rcx,%rcx,1),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x30(%rsp)
mov    %rcx,0x128(%rsp)
jmp    1800 <cfr4syn+0x6e0>
xchg   %ax,%ax
test   %r14,%r14
jle    1c34 <cfr4syn+0xb14>
cmp    $0x4,%r14
setb   %al
or     0xe(%rsp),%al
test   $0x1,%al
je     1b6c <cfr4syn+0xa4c>
xor    %eax,%eax
jmp    1bd0 <cfr4syn+0xab0>
xor    %eax,%eax
xchg   %ax,%ax
movups (%r12,%rax,4),%xmm0
movups 0x0(%r13,%rax,4),%xmm1
movaps %xmm0,%xmm2
addps  %xmm1,%xmm2
subps  %xmm1,%xmm0
movups (%r8,%rax,4),%xmm1
addps  %xmm1,%xmm1
movups (%r15,%rax,4),%xmm3
addps  %xmm3,%xmm3
movaps %xmm2,%xmm4
addps  %xmm1,%xmm4
movups %xmm4,(%r12,%rax,4)
subps  %xmm1,%xmm2
movups %xmm2,(%r8,%rax,4)
movaps %xmm0,%xmm1
addps  %xmm3,%xmm1
movups %xmm1,0x0(%r13,%rax,4)
subps  %xmm3,%xmm0
movups %xmm0,(%r15,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbx
jne    1b70 <cfr4syn+0xa50>
mov    %rbx,%rax
cmp    %r14,%rbx
je     1c34 <cfr4syn+0xb14>
nopl   0x0(%rax)
movss  (%r12,%rax,4),%xmm0
movss  0x0(%r13,%rax,4),%xmm1
movaps %xmm0,%xmm2
addss  %xmm1,%xmm2
subss  %xmm1,%xmm0
movss  (%r8,%rax,4),%xmm1
addss  %xmm1,%xmm1
movss  (%r15,%rax,4),%xmm3
addss  %xmm3,%xmm3
movaps %xmm2,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,(%r12,%rax,4)
subss  %xmm1,%xmm2
movss  %xmm2,(%r8,%rax,4)
movaps %xmm0,%xmm1
addss  %xmm3,%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
subss  %xmm3,%xmm0
movss  %xmm0,(%r15,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    1bd0 <cfr4syn+0xab0>
cmpb   $0x0,0xf(%rsp)
je     1c50 <cfr4syn+0xb30>
mov    0x18(%rsp),%rax
jmp    184a <cfr4syn+0x72a>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0x4,%r14
mov    %r10,%r14
mov    %r11,%r10
mov    %rsi,%r11
mov    %rcx,%rsi
setb   %cl
mov    0x237e(%rip),%rax
movsd  (%rax),%xmm0
or     0xd(%rsp),%cl
mov    0x120(%rsp),%rax
test   $0x1,%cl
mov    %rsi,%rcx
mov    %r11,%rsi
mov    %r10,%r11
mov    %r14,%r10
jne    1d50 <cfr4syn+0xc30>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rdx,%rax,4),%xmm4
movups (%r9,%rax,4),%xmm5
movaps %xmm4,%xmm3
subps  %xmm5,%xmm3
movups (%rdi,%rax,4),%xmm6
movups 0x0(%rbp,%rax,4),%xmm2
addps  %xmm6,%xmm2
addps  %xmm5,%xmm4
addps  %xmm4,%xmm4
movups %xmm4,(%rdx,%rax,4)
movups 0x0(%rbp,%rax,4),%xmm4
movups (%rdi,%rax,4),%xmm5
subps  %xmm5,%xmm4
addps  %xmm4,%xmm4
movaps %xmm3,%xmm5
addps  %xmm2,%xmm5
cvtps2pd %xmm5,%xmm6
movups %xmm4,(%r9,%rax,4)
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm4
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm6
cvtpd2ps %xmm6,%xmm5
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm4,%xmm5
movupd %xmm5,(%rdi,%rax,4)
subps  %xmm3,%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
movupd %xmm3,0x0(%rbp,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbx
jne    1ca0 <cfr4syn+0xb80>
mov    0x1c0(%rsp),%rax
cmp    0x10(%rsp),%rbx
je     1dd5 <cfr4syn+0xcb5>
nopw   0x0(%rax,%rax,1)
movss  (%r12,%rax,4),%xmm1
movss  (%r8,%rax,4),%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
movss  0x0(%r13,%rax,4),%xmm4
addss  (%r15,%rax,4),%xmm4
addss  %xmm2,%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,(%r12,%rax,4)
movss  (%r15,%rax,4),%xmm1
subss  0x0(%r13,%rax,4),%xmm1
addss  %xmm1,%xmm1
movss  %xmm1,(%r8,%rax,4)
movaps %xmm3,%xmm1
addss  %xmm4,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
subss  %xmm3,%xmm4
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
mulsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm1,0x0(%r13,%rax,4)
movss  %xmm2,(%r15,%rax,4)
add    $0x1,%rax
cmp    %rax,%r10
jne    1d50 <cfr4syn+0xc30>
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%r14
jmp    184a <cfr4syn+0x72a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    0xe8(%rsp),%rax
cmp    0x100(%rsp),%rax
jle    1506 <cfr4syn+0x3e6>
cs nopw 0x0(%rax,%rax,1)
add    0xf0(%rsp),%rcx
cmp    0xe8(%rsp),%rcx
jle    14fb <cfr4syn+0x3db>
cs nopw 0x0(%rax,%rax,1)
mov    0x138(%rsp),%rax
add    0xf8(%rsp),%rax
cmp    0xf0(%rsp),%rax
jle    14eb <cfr4syn+0x3cb>
xchg   %ax,%ax
mov    0x140(%rsp),%rax
add    $0x2,%rax
cmp    0xf8(%rsp),%rax
jle    14e3 <cfr4syn+0x3c3>
add    $0x288,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@pii = external global double
@p7two = external global double
define void @cfr4syn(i64 %0, i64 %1, float* %2, float* %3, float* %4, float* %5, float* %6, float* %7, float* %8, float* %9) {
%11 = alloca i64
%12 = alloca i64
%13 = alloca float*
%14 = alloca float*
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
%18 = alloca float*
%19 = alloca float*
%20 = alloca float*
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca i64
%38 = alloca i64
%39 = alloca i64
%40 = alloca i64
%41 = alloca i64
%42 = alloca i64
%43 = alloca i64
%44 = alloca i64
%45 = alloca i64
%46 = alloca i64
%47 = alloca i64
%48 = alloca i64
%49 = alloca i64
%50 = alloca i64
%51 = alloca i64
%52 = alloca i64
%53 = alloca i64
%54 = alloca i64
%55 = alloca i64
%56 = alloca i64
%57 = alloca i64
%58 = alloca i64
%59 = alloca i64
%60 = alloca i64
%61 = alloca i64
%62 = alloca i64
%63 = alloca i64
%64 = alloca i64
%65 = alloca i64
%66 = alloca i64
%67 = alloca i64
%68 = alloca i64
%69 = alloca i64
%70 = alloca i64
%71 = alloca i64
%72 = alloca i64
%73 = alloca i64
%74 = alloca i64
%75 = alloca i64
%76 = alloca i64
%77 = alloca i64
%78 = alloca i64
%79 = alloca i64
%80 = alloca i64
%81 = alloca i64
%82 = alloca i64
%83 = alloca i64
%84 = alloca i64
%85 = alloca i64
%86 = alloca i64
%87 = alloca [19 x i64]
store i64 %0, i64* %11
store i64 %1, i64* %12
store float* %2, float** %13
store float* %3, float** %14
store float* %4, float** %15
store float* %5, float** %16
store float* %6, float** %17
store float* %7, float** %18
store float* %8, float** %19
store float* %9, float** %20
%88 = load i64, i64* %12
%89 = sdiv i64 %88, 4
%90 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 0
store i64 %89, i64* %90
store i64 1, i64* %37
br label %91
91: ; preds = %122, %10
%92 = load i64, i64* %37
%93 = icmp slt i64 %92, 19
br i1 %93, label %94, label %125
94: ; preds = %91
%95 = load i64, i64* %37
%96 = sub nsw i64 %95, 1
%97 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 %96
%98 = load i64, i64* %97
%99 = icmp slt i64 %98, 2
br i1 %99, label %100, label %104
100: ; preds = %94
%101 = load i64, i64* %37
%102 = sub nsw i64 %101, 1
%103 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 %102
store i64 2, i64* %103
br label %119
104: ; preds = %94
%105 = load i64, i64* %37
%106 = sub nsw i64 %105, 1
%107 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 %106
%108 = load i64, i64* %107
%109 = icmp ne i64 %108, 2
br i1 %109, label %110, label %118
110: ; preds = %104
%111 = load i64, i64* %37
%112 = sub nsw i64 %111, 1
%113 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 %112
%114 = load i64, i64* %113
%115 = sdiv i64 %114, 2
%116 = load i64, i64* %37
%117 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 %116
store i64 %115, i64* %117
br label %122
118: ; preds = %104
br label %119
119: ; preds = %118, %100
%120 = load i64, i64* %37
%121 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 %120
store i64 2, i64* %121
br label %122
122: ; preds = %119, %110
%123 = load i64, i64* %37
%124 = add nsw i64 %123, 1
store i64 %124, i64* %37
br label %91
125: ; preds = %91
%126 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 18
%127 = load i64, i64* %126
store i64 %127, i64* %68
%128 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 17
%129 = load i64, i64* %128
store i64 %129, i64* %69
%130 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 16
%131 = load i64, i64* %130
store i64 %131, i64* %70
%132 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 15
%133 = load i64, i64* %132
store i64 %133, i64* %71
%134 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 14
%135 = load i64, i64* %134
store i64 %135, i64* %72
%136 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 13
%137 = load i64, i64* %136
store i64 %137, i64* %73
%138 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 12
%139 = load i64, i64* %138
store i64 %139, i64* %74
%140 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 11
%141 = load i64, i64* %140
store i64 %141, i64* %75
%142 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 10
%143 = load i64, i64* %142
store i64 %143, i64* %76
%144 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 9
%145 = load i64, i64* %144
store i64 %145, i64* %77
%146 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 8
%147 = load i64, i64* %146
store i64 %147, i64* %78
%148 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 7
%149 = load i64, i64* %148
store i64 %149, i64* %79
%150 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 6
%151 = load i64, i64* %150
store i64 %151, i64* %80
%152 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 5
%153 = load i64, i64* %152
store i64 %153, i64* %81
%154 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 4
%155 = load i64, i64* %154
store i64 %155, i64* %82
%156 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 3
%157 = load i64, i64* %156
store i64 %157, i64* %83
%158 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 2
%159 = load i64, i64* %158
store i64 %159, i64* %84
%160 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 1
%161 = load i64, i64* %160
store i64 %161, i64* %85
%162 = getelementptr inbounds [19 x i64], [19 x i64]* %87, i64 0, i64 0
%163 = load i64, i64* %162
store i64 %163, i64* %86
%164 = load double, double* @pii
%165 = load i64, i64* %12
%166 = sitofp i64 %165 to double
%167 = fdiv double %164, %166
%168 = fptrunc double %167 to float
store float %168, float* %21
store i64 3, i64* %43
store i64 2, i64* %44
store i64 2, i64* %45
store i64 2, i64* %48
br label %169
169: ; preds = %767, %125
%170 = load i64, i64* %48
store i64 %170, i64* %49
br label %171
171: ; preds = %760, %169
%172 = load i64, i64* %49
store i64 %172, i64* %50
br label %173
173: ; preds = %752, %171
%174 = load i64, i64* %50
store i64 %174, i64* %51
br label %175
175: ; preds = %744, %173
%176 = load i64, i64* %51
store i64 %176, i64* %52
br label %177
177: ; preds = %736, %175
%178 = load i64, i64* %52
store i64 %178, i64* %53
br label %179
179: ; preds = %725, %177
%180 = load i64, i64* %53
%181 = load i64, i64* %73
%182 = icmp sle i64 %180, %181
br i1 %182, label %183, label %729
183: ; preds = %179
%184 = load i64, i64* %53
store i64 %184, i64* %54
br label %185
185: ; preds = %720, %183
%186 = load i64, i64* %54
%187 = load i64, i64* %74
%188 = icmp sle i64 %186, %187
br i1 %188, label %189, label %724
189: ; preds = %185
%190 = load i64, i64* %54
store i64 %190, i64* %55
br label %191
191: ; preds = %715, %189
%192 = load i64, i64* %55
%193 = load i64, i64* %75
%194 = icmp sle i64 %192, %193
br i1 %194, label %195, label %719
195: ; preds = %191
%196 = load i64, i64* %55
store i64 %196, i64* %56
br label %197
197: ; preds = %710, %195
%198 = load i64, i64* %56
%199 = load i64, i64* %76
%200 = icmp sle i64 %198, %199
br i1 %200, label %201, label %714
201: ; preds = %197
%202 = load i64, i64* %56
store i64 %202, i64* %57
br label %203
203: ; preds = %705, %201
%204 = load i64, i64* %57
%205 = load i64, i64* %77
%206 = icmp sle i64 %204, %205
br i1 %206, label %207, label %709
207: ; preds = %203
%208 = load i64, i64* %57
store i64 %208, i64* %58
br label %209
209: ; preds = %700, %207
%210 = load i64, i64* %58
%211 = load i64, i64* %78
%212 = icmp sle i64 %210, %211
br i1 %212, label %213, label %704
213: ; preds = %209
%214 = load i64, i64* %58
store i64 %214, i64* %59
br label %215
215: ; preds = %695, %213
%216 = load i64, i64* %59
%217 = load i64, i64* %79
%218 = icmp sle i64 %216, %217
br i1 %218, label %219, label %699
219: ; preds = %215
%220 = load i64, i64* %59
store i64 %220, i64* %60
br label %221
221: ; preds = %690, %219
%222 = load i64, i64* %60
%223 = load i64, i64* %80
%224 = icmp sle i64 %222, %223
br i1 %224, label %225, label %694
225: ; preds = %221
%226 = load i64, i64* %60
store i64 %226, i64* %61
br label %227
227: ; preds = %685, %225
%228 = load i64, i64* %61
%229 = load i64, i64* %81
%230 = icmp sle i64 %228, %229
br i1 %230, label %231, label %689
231: ; preds = %227
%232 = load i64, i64* %61
store i64 %232, i64* %62
br label %233
233: ; preds = %680, %231
%234 = load i64, i64* %62
%235 = load i64, i64* %82
%236 = icmp sle i64 %234, %235
br i1 %236, label %237, label %684
237: ; preds = %233
%238 = load i64, i64* %62
store i64 %238, i64* %63
br label %239
239: ; preds = %675, %237
%240 = load i64, i64* %63
%241 = load i64, i64* %83
%242 = icmp sle i64 %240, %241
br i1 %242, label %243, label %679
243: ; preds = %239
%244 = load i64, i64* %63
store i64 %244, i64* %64
br label %245
245: ; preds = %670, %243
%246 = load i64, i64* %64
%247 = load i64, i64* %84
%248 = icmp sle i64 %246, %247
br i1 %248, label %249, label %674
249: ; preds = %245
%250 = load i64, i64* %64
store i64 %250, i64* %65
br label %251
251: ; preds = %665, %249
%252 = load i64, i64* %65
%253 = load i64, i64* %85
%254 = icmp sle i64 %252, %253
br i1 %254, label %255, label %669
255: ; preds = %251
%256 = load i64, i64* %65
store i64 %256, i64* %66
br label %257
257: ; preds = %660, %255
%258 = load i64, i64* %66
%259 = load i64, i64* %86
%260 = icmp sle i64 %258, %259
br i1 %260, label %261, label %664
261: ; preds = %257
%262 = load i64, i64* %66
%263 = sub nsw i64 %262, 2
store i64 %263, i64* %67
%264 = load i64, i64* %67
%265 = icmp sgt i64 %264, 0
br i1 %265, label %266, label %506
266: ; preds = %261
%267 = load i64, i64* %67
%268 = sitofp i64 %267 to float
%269 = load float, float* %21
%270 = fmul float %268, %269
store float %270, float* %22
%271 = load float, float* %22
%272 = call float @cos(float %271)
store float %272, float* %23
%273 = load float, float* %22
%274 = call float @sin(float %273)
%275 = fneg float %274
store float %275, float* %26
%276 = load float, float* %23
%277 = load float, float* %23
%278 = load float, float* %26
%279 = load float, float* %26
%280 = fmul float %278, %279
%281 = fneg float %280
%282 = call float @llvm.fmuladd.f32(float %276, float %277, float %281)
store float %282, float* %24
%283 = load float, float* %23
%284 = load float, float* %26
%285 = load float, float* %23
%286 = load float, float* %26
%287 = fmul float %285, %286
%288 = call float @llvm.fmuladd.f32(float %283, float %284, float %287)
store float %288, float* %27
%289 = load float, float* %23
%290 = load float, float* %24
%291 = load float, float* %26
%292 = load float, float* %27
%293 = fmul float %291, %292
%294 = fneg float %293
%295 = call float @llvm.fmuladd.f32(float %289, float %290, float %294)
store float %295, float* %25
%296 = load float, float* %24
%297 = load float, float* %26
%298 = load float, float* %27
%299 = load float, float* %23
%300 = fmul float %298, %299
%301 = call float @llvm.fmuladd.f32(float %296, float %297, float %300)
store float %301, float* %28
%302 = load i64, i64* %11
%303 = mul nsw i64 4, %302
store i64 %303, i64* %38
%304 = load i64, i64* %45
%305 = load i64, i64* %38
%306 = mul nsw i64 %304, %305
store i64 %306, i64* %39
%307 = load i64, i64* %43
%308 = load i64, i64* %38
%309 = mul nsw i64 %307, %308
store i64 %309, i64* %41
%310 = load i64, i64* %39
%311 = load i64, i64* %11
%312 = add nsw i64 %310, %311
store i64 %312, i64* %40
%313 = load i64, i64* %39
store i64 %313, i64* %46
br label %314
314: ; preds = %489, %266
%315 = load i64, i64* %46
%316 = load i64, i64* %40
%317 = icmp slt i64 %315, %316
br i1 %317, label %318, label %492
318: ; preds = %314
%319 = load i64, i64* %41
%320 = load i64, i64* %46
%321 = add nsw i64 %319, %320
%322 = load i64, i64* %39
%323 = sub nsw i64 %321, %322
store i64 %323, i64* %47
%324 = load float*, float** %13
%325 = load i64, i64* %46
%326 = getelementptr inbounds float, float* %324, i64 %325
%327 = load float, float* %326
%328 = load float*, float** %19
%329 = load i64, i64* %47
%330 = getelementptr inbounds float, float* %328, i64 %329
%331 = load float, float* %330
%332 = fadd float %327, %331
store float %332, float* %29
%333 = load float*, float** %20
%334 = load i64, i64* %47
%335 = getelementptr inbounds float, float* %333, i64 %334
%336 = load float, float* %335
%337 = load float*, float** %14
%338 = load i64, i64* %46
%339 = getelementptr inbounds float, float* %337, i64 %338
%340 = load float, float* %339
%341 = fsub float %336, %340
store float %341, float* %30
%342 = load float*, float** %13
%343 = load i64, i64* %46
%344 = getelementptr inbounds float, float* %342, i64 %343
%345 = load float, float* %344
%346 = load float*, float** %19
%347 = load i64, i64* %47
%348 = getelementptr inbounds float, float* %346, i64 %347
%349 = load float, float* %348
%350 = fsub float %345, %349
store float %350, float* %31
%351 = load float*, float** %20
%352 = load i64, i64* %47
%353 = getelementptr inbounds float, float* %351, i64 %352
%354 = load float, float* %353
%355 = load float*, float** %14
%356 = load i64, i64* %46
%357 = getelementptr inbounds float, float* %355, i64 %356
%358 = load float, float* %357
%359 = fadd float %354, %358
store float %359, float* %32
%360 = load float*, float** %15
%361 = load i64, i64* %46
%362 = getelementptr inbounds float, float* %360, i64 %361
%363 = load float, float* %362
%364 = load float*, float** %17
%365 = load i64, i64* %47
%366 = getelementptr inbounds float, float* %364, i64 %365
%367 = load float, float* %366
%368 = fadd float %363, %367
store float %368, float* %33
%369 = load float*, float** %18
%370 = load i64, i64* %47
%371 = getelementptr inbounds float, float* %369, i64 %370
%372 = load float, float* %371
%373 = load float*, float** %16
%374 = load i64, i64* %46
%375 = getelementptr inbounds float, float* %373, i64 %374
%376 = load float, float* %375
%377 = fsub float %372, %376
store float %377, float* %34
%378 = load float*, float** %18
%379 = load i64, i64* %47
%380 = getelementptr inbounds float, float* %378, i64 %379
%381 = load float, float* %380
%382 = load float*, float** %16
%383 = load i64, i64* %46
%384 = getelementptr inbounds float, float* %382, i64 %383
%385 = load float, float* %384
%386 = fadd float %381, %385
store float %386, float* %35
%387 = load float*, float** %17
%388 = load i64, i64* %47
%389 = getelementptr inbounds float, float* %387, i64 %388
%390 = load float, float* %389
%391 = load float*, float** %15
%392 = load i64, i64* %46
%393 = getelementptr inbounds float, float* %391, i64 %392
%394 = load float, float* %393
%395 = fsub float %390, %394
store float %395, float* %36
%396 = load float, float* %29
%397 = load float, float* %33
%398 = fadd float %396, %397
%399 = load float*, float** %13
%400 = load i64, i64* %46
%401 = getelementptr inbounds float, float* %399, i64 %400
store float %398, float* %401
%402 = load float, float* %30
%403 = load float, float* %34
%404 = fadd float %402, %403
%405 = load float*, float** %17
%406 = load i64, i64* %47
%407 = getelementptr inbounds float, float* %405, i64 %406
store float %404, float* %407
%408 = load float, float* %31
%409 = load float, float* %35
%410 = fadd float %408, %409
%411 = load float, float* %23
%412 = load float, float* %32
%413 = load float, float* %36
%414 = fadd float %412, %413
%415 = load float, float* %26
%416 = fmul float %414, %415
%417 = fneg float %416
%418 = call float @llvm.fmuladd.f32(float %410, float %411, float %417)
%419 = load float*, float** %14
%420 = load i64, i64* %46
%421 = getelementptr inbounds float, float* %419, i64 %420
store float %418, float* %421
%422 = load float, float* %31
%423 = load float, float* %35
%424 = fadd float %422, %423
%425 = load float, float* %26
%426 = load float, float* %32
%427 = load float, float* %36
%428 = fadd float %426, %427
%429 = load float, float* %23
%430 = fmul float %428, %429
%431 = call float @llvm.fmuladd.f32(float %424, float %425, float %430)
%432 = load float*, float** %18
%433 = load i64, i64* %47
%434 = getelementptr inbounds float, float* %432, i64 %433
store float %431, float* %434
%435 = load float, float* %29
%436 = load float, float* %33
%437 = fsub float %435, %436
%438 = load float, float* %24
%439 = load float, float* %30
%440 = load float, float* %34
%441 = fsub float %439, %440
%442 = load float, float* %27
%443 = fmul float %441, %442
%444 = fneg float %443
%445 = call float @llvm.fmuladd.f32(float %437, float %438, float %444)
%446 = load float*, float** %15
%447 = load i64, i64* %46
%448 = getelementptr inbounds float, float* %446, i64 %447
store float %445, float* %448
%449 = load float, float* %29
%450 = load float, float* %33
%451 = fsub float %449, %450
%452 = load float, float* %27
%453 = load float, float* %30
%454 = load float, float* %34
%455 = fsub float %453, %454
%456 = load float, float* %24
%457 = fmul float %455, %456
%458 = call float @llvm.fmuladd.f32(float %451, float %452, float %457)
%459 = load float*, float** %19
%460 = load i64, i64* %47
%461 = getelementptr inbounds float, float* %459, i64 %460
store float %458, float* %461
%462 = load float, float* %31
%463 = load float, float* %35
%464 = fsub float %462, %463
%465 = load float, float* %25
%466 = load float, float* %32
%467 = load float, float* %36
%468 = fsub float %466, %467
%469 = load float, float* %28
%470 = fmul float %468, %469
%471 = fneg float %470
%472 = call float @llvm.fmuladd.f32(float %464, float %465, float %471)
%473 = load float*, float** %16
%474 = load i64, i64* %46
%475 = getelementptr inbounds float, float* %473, i64 %474
store float %472, float* %475
%476 = load float, float* %31
%477 = load float, float* %35
%478 = fsub float %476, %477
%479 = load float, float* %28
%480 = load float, float* %32
%481 = load float, float* %36
%482 = fsub float %480, %481
%483 = load float, float* %25
%484 = fmul float %482, %483
%485 = call float @llvm.fmuladd.f32(float %478, float %479, float %484)
%486 = load float*, float** %20
%487 = load i64, i64* %47
%488 = getelementptr inbounds float, float* %486, i64 %487
store float %485, float* %488
br label %489
489: ; preds = %318
%490 = load i64, i64* %46
%491 = add nsw i64 %490, 1
store i64 %491, i64* %46
br label %314
492: ; preds = %314
%493 = load i64, i64* %45
%494 = add nsw i64 %493, 2
store i64 %494, i64* %45
%495 = load i64, i64* %43
%496 = sub nsw i64 %495, 2
store i64 %496, i64* %43
%497 = load i64, i64* %43
%498 = load i64, i64* %44
%499 = icmp sle i64 %497, %498
br i1 %499, label %500, label %505
500: ; preds = %492
%501 = load i64, i64* %45
%502 = mul nsw i64 2, %501
%503 = sub nsw i64 %502, 1
store i64 %503, i64* %43
%504 = load i64, i64* %45
store i64 %504, i64* %44
br label %505
505: ; preds = %500, %492
br label %659
506: ; preds = %261
store i64 0, i64* %37
br label %507
507: ; preds = %568, %506
%508 = load i64, i64* %37
%509 = load i64, i64* %11
%510 = icmp slt i64 %508, %509
br i1 %510, label %511, label %571
511: ; preds = %507
%512 = load float*, float** %13
%513 = load i64, i64* %37
%514 = getelementptr inbounds float, float* %512, i64 %513
%515 = load float, float* %514
%516 = load float*, float** %14
%517 = load i64, i64* %37
%518 = getelementptr inbounds float, float* %516, i64 %517
%519 = load float, float* %518
%520 = fadd float %515, %519
store float %520, float* %29
%521 = load float*, float** %13
%522 = load i64, i64* %37
%523 = getelementptr inbounds float, float* %521, i64 %522
%524 = load float, float* %523
%525 = load float*, float** %14
%526 = load i64, i64* %37
%527 = getelementptr inbounds float, float* %525, i64 %526
%528 = load float, float* %527
%529 = fsub float %524, %528
store float %529, float* %30
%530 = load float*, float** %15
%531 = load i64, i64* %37
%532 = getelementptr inbounds float, float* %530, i64 %531
%533 = load float, float* %532
%534 = fpext float %533 to double
%535 = fmul double %534, 2.000000e+00
%536 = fptrunc double %535 to float
store float %536, float* %31
%537 = load float*, float** %16
%538 = load i64, i64* %37
%539 = getelementptr inbounds float, float* %537, i64 %538
%540 = load float, float* %539
%541 = fpext float %540 to double
%542 = fmul double %541, 2.000000e+00
%543 = fptrunc double %542 to float
store float %543, float* %32
%544 = load float, float* %29
%545 = load float, float* %31
%546 = fadd float %544, %545
%547 = load float*, float** %13
%548 = load i64, i64* %37
%549 = getelementptr inbounds float, float* %547, i64 %548
store float %546, float* %549
%550 = load float, float* %29
%551 = load float, float* %31
%552 = fsub float %550, %551
%553 = load float*, float** %15
%554 = load i64, i64* %37
%555 = getelementptr inbounds float, float* %553, i64 %554
store float %552, float* %555
%556 = load float, float* %30
%557 = load float, float* %32
%558 = fadd float %556, %557
%559 = load float*, float** %14
%560 = load i64, i64* %37
%561 = getelementptr inbounds float, float* %559, i64 %560
store float %558, float* %561
%562 = load float, float* %30
%563 = load float, float* %32
%564 = fsub float %562, %563
%565 = load float*, float** %16
%566 = load i64, i64* %37
%567 = getelementptr inbounds float, float* %565, i64 %566
store float %564, float* %567
br label %568
568: ; preds = %511
%569 = load i64, i64* %37
%570 = add nsw i64 %569, 1
store i64 %570, i64* %37
br label %507
571: ; preds = %507
%572 = load i64, i64* %12
%573 = icmp sgt i64 %572, 4
br i1 %573, label %574, label %658
574: ; preds = %571
%575 = load i64, i64* %11
%576 = mul nsw i64 4, %575
store i64 %576, i64* %41
%577 = load i64, i64* %41
%578 = load i64, i64* %11
%579 = add nsw i64 %577, %578
store i64 %579, i64* %42
%580 = load i64, i64* %41
store i64 %580, i64* %37
br label %581
581: ; preds = %654, %574
%582 = load i64, i64* %37
%583 = load i64, i64* %42
%584 = icmp slt i64 %582, %583
br i1 %584, label %585, label %657
585: ; preds = %581
%586 = load float*, float** %13
%587 = load i64, i64* %37
%588 = getelementptr inbounds float, float* %586, i64 %587
%589 = load float, float* %588
%590 = load float*, float** %15
%591 = load i64, i64* %37
%592 = getelementptr inbounds float, float* %590, i64 %591
%593 = load float, float* %592
%594 = fsub float %589, %593
store float %594, float* %31
%595 = load float*, float** %14
%596 = load i64, i64* %37
%597 = getelementptr inbounds float, float* %595, i64 %596
%598 = load float, float* %597
%599 = load float*, float** %16
%600 = load i64, i64* %37
%601 = getelementptr inbounds float, float* %599, i64 %600
%602 = load float, float* %601
%603 = fadd float %598, %602
store float %603, float* %32
%604 = load float*, float** %13
%605 = load i64, i64* %37
%606 = getelementptr inbounds float, float* %604, i64 %605
%607 = load float, float* %606
%608 = load float*, float** %15
%609 = load i64, i64* %37
%610 = getelementptr inbounds float, float* %608, i64 %609
%611 = load float, float* %610
%612 = fadd float %607, %611
%613 = fpext float %612 to double
%614 = fmul double %613, 2.000000e+00
%615 = fptrunc double %614 to float
%616 = load float*, float** %13
%617 = load i64, i64* %37
%618 = getelementptr inbounds float, float* %616, i64 %617
store float %615, float* %618
%619 = load float*, float** %16
%620 = load i64, i64* %37
%621 = getelementptr inbounds float, float* %619, i64 %620
%622 = load float, float* %621
%623 = load float*, float** %14
%624 = load i64, i64* %37
%625 = getelementptr inbounds float, float* %623, i64 %624
%626 = load float, float* %625
%627 = fsub float %622, %626
%628 = fpext float %627 to double
%629 = fmul double %628, 2.000000e+00
%630 = fptrunc double %629 to float
%631 = load float*, float** %15
%632 = load i64, i64* %37
%633 = getelementptr inbounds float, float* %631, i64 %632
store float %630, float* %633
%634 = load float, float* %31
%635 = load float, float* %32
%636 = fadd float %634, %635
%637 = fpext float %636 to double
%638 = load double, double* @p7two
%639 = fmul double %637, %638
%640 = fptrunc double %639 to float
%641 = load float*, float** %14
%642 = load i64, i64* %37
%643 = getelementptr inbounds float, float* %641, i64 %642
store float %640, float* %643
%644 = load float, float* %32
%645 = load float, float* %31
%646 = fsub float %644, %645
%647 = fpext float %646 to double
%648 = load double, double* @p7two
%649 = fmul double %647, %648
%650 = fptrunc double %649 to float
%651 = load float*, float** %16
%652 = load i64, i64* %37
%653 = getelementptr inbounds float, float* %651, i64 %652
store float %650, float* %653
br label %654
654: ; preds = %585
%655 = load i64, i64* %37
%656 = add nsw i64 %655, 1
store i64 %656, i64* %37
br label %581
657: ; preds = %581
br label %658
658: ; preds = %657, %571
br label %659
659: ; preds = %658, %505
br label %660
660: ; preds = %659
%661 = load i64, i64* %85
%662 = load i64, i64* %66
%663 = add nsw i64 %662, %661
store i64 %663, i64* %66
br label %257
664: ; preds = %257
br label %665
665: ; preds = %664
%666 = load i64, i64* %84
%667 = load i64, i64* %65
%668 = add nsw i64 %667, %666
store i64 %668, i64* %65
br label %251
669: ; preds = %251
br label %670
670: ; preds = %669
%671 = load i64, i64* %83
%672 = load i64, i64* %64
%673 = add nsw i64 %672, %671
store i64 %673, i64* %64
br label %245
674: ; preds = %245
br label %675
675: ; preds = %674
%676 = load i64, i64* %82
%677 = load i64, i64* %63
%678 = add nsw i64 %677, %676
store i64 %678, i64* %63
br label %239
679: ; preds = %239
br label %680
680: ; preds = %679
%681 = load i64, i64* %81
%682 = load i64, i64* %62
%683 = add nsw i64 %682, %681
store i64 %683, i64* %62
br label %233
684: ; preds = %233
br label %685
685: ; preds = %684
%686 = load i64, i64* %80
%687 = load i64, i64* %61
%688 = add nsw i64 %687, %686
store i64 %688, i64* %61
br label %227
689: ; preds = %227
br label %690
690: ; preds = %689
%691 = load i64, i64* %79
%692 = load i64, i64* %60
%693 = add nsw i64 %692, %691
store i64 %693, i64* %60
br label %221
694: ; preds = %221
br label %695
695: ; preds = %694
%696 = load i64, i64* %78
%697 = load i64, i64* %59
%698 = add nsw i64 %697, %696
store i64 %698, i64* %59
br label %215
699: ; preds = %215
br label %700
700: ; preds = %699
%701 = load i64, i64* %77
%702 = load i64, i64* %58
%703 = add nsw i64 %702, %701
store i64 %703, i64* %58
br label %209
704: ; preds = %209
br label %705
705: ; preds = %704
%706 = load i64, i64* %76
%707 = load i64, i64* %57
%708 = add nsw i64 %707, %706
store i64 %708, i64* %57
br label %203
709: ; preds = %203
br label %710
710: ; preds = %709
%711 = load i64, i64* %75
%712 = load i64, i64* %56
%713 = add nsw i64 %712, %711
store i64 %713, i64* %56
br label %197
714: ; preds = %197
br label %715
715: ; preds = %714
%716 = load i64, i64* %74
%717 = load i64, i64* %55
%718 = add nsw i64 %717, %716
store i64 %718, i64* %55
br label %191
719: ; preds = %191
br label %720
720: ; preds = %719
%721 = load i64, i64* %73
%722 = load i64, i64* %54
%723 = add nsw i64 %722, %721
store i64 %723, i64* %54
br label %185
724: ; preds = %185
br label %725
725: ; preds = %724
%726 = load i64, i64* %72
%727 = load i64, i64* %53
%728 = add nsw i64 %727, %726
store i64 %728, i64* %53
br label %179
729: ; preds = %179
%730 = load i64, i64* %71
%731 = load i64, i64* %52
%732 = add nsw i64 %731, %730
store i64 %732, i64* %52
%733 = load i64, i64* %52
%734 = load i64, i64* %72
%735 = icmp sle i64 %733, %734
br i1 %735, label %736, label %737
736: ; preds = %729
br label %177
737: ; preds = %729
%738 = load i64, i64* %70
%739 = load i64, i64* %51
%740 = add nsw i64 %739, %738
store i64 %740, i64* %51
%741 = load i64, i64* %51
%742 = load i64, i64* %71
%743 = icmp sle i64 %741, %742
br i1 %743, label %744, label %745
744: ; preds = %737
br label %175
745: ; preds = %737
%746 = load i64, i64* %69
%747 = load i64, i64* %50
%748 = add nsw i64 %747, %746
store i64 %748, i64* %50
%749 = load i64, i64* %50
%750 = load i64, i64* %70
%751 = icmp sle i64 %749, %750
br i1 %751, label %752, label %753
752: ; preds = %745
br label %173
753: ; preds = %745
%754 = load i64, i64* %68
%755 = load i64, i64* %49
%756 = add nsw i64 %755, %754
store i64 %756, i64* %49
%757 = load i64, i64* %49
%758 = load i64, i64* %69
%759 = icmp sle i64 %757, %758
br i1 %759, label %760, label %761
760: ; preds = %753
br label %171
761: ; preds = %753
%762 = load i64, i64* %48
%763 = add nsw i64 %762, 2
store i64 %763, i64* %48
%764 = load i64, i64* %48
%765 = load i64, i64* %68
%766 = icmp sle i64 %764, %765
br i1 %766, label %767, label %768
767: ; preds = %761
br label %169
768: ; preds = %761
ret void
}

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