void cfr4tr(long off, long nn, float *b0, float *b1, float *b2, float *b3,
            float *b4, float *b5, float *b6, float *b7) {
  extern double pii, p7;
  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];
  float piovn, arg, c1, c2, c3, s1, s2, s3, r1, r5, pr, pi, t0, t1, t2, t3, t4,
      t5, t6, t7;
  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) {
                                for (i = 0; i < off; i++) {
                                  t0 = b0[i] + b2[i];
                                  t1 = b1[i] + b3[i];
                                  b2[i] = b0[i] - b2[i];
                                  b3[i] = b1[i] - b3[i];
                                  b0[i] = t0 + t1;
                                  b1[i] = t0 - t1;
                                }
                                if (nn > 4) {
                                  k0 = 4 * off;
                                  kl = k0 + off;
                                  for (i = k0; i < kl; i++) {
                                    pr = p7 * (b1[i] - b3[i]);
                                    pi = p7 * (b1[i] + b3[i]);
                                    b3[i] = b2[i] + pi;
                                    b1[i] = pi - b2[i];
                                    b2[i] = b0[i] - pr;
                                    b0[i] = b0[i] + pr;
                                  }
                                }
                              } else {
                                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;
                                  r1 = b1[j] * c1 - b5[k] * s1;
                                  r5 = b1[j] * s1 + b5[k] * c1;
                                  t2 = b2[j] * c2 - b6[k] * s2;
                                  t6 = b2[j] * s2 + b6[k] * c2;
                                  t3 = b3[j] * c3 - b7[k] * s3;
                                  t7 = b3[j] * s3 + b7[k] * c3;
                                  t0 = b0[j] + t2;
                                  t4 = b4[k] + t6;
                                  t2 = b0[j] - t2;
                                  t6 = b4[k] - t6;
                                  t1 = r1 + t3;
                                  t5 = r5 + t7;
                                  t3 = r1 - t3;
                                  t7 = r5 - t7;
                                  b0[j] = t0 + t1;
                                  b7[k] = t4 + t5;
                                  b6[k] = t0 - t1;
                                  b1[j] = t5 - t4;
                                  b2[j] = t2 - t7;
                                  b5[k] = t6 + t3;
                                  b4[k] = t2 + t7;
                                  b3[j] = t3 - t6;
                                }
                                jr += 2;
                                ji -= 2;
                                if (ji <= jl) {
                                  ji = 2 * jr - 1;
                                  jl = jr;
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  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):
<cfr4tr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2b0,%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,-0x260(%rbp)
movq   $0x1,-0x38(%rbp)
cmpq   $0x13,-0x38(%rbp)
jge    1216 <cfr4tr+0xf6>
mov    -0x38(%rbp),%rax
sub    $0x1,%rax
cmpq   $0x2,-0x260(%rbp,%rax,8)
ff 02
jge    11ab <cfr4tr+0x8b>
mov    -0x38(%rbp),%rax
sub    $0x1,%rax
movq   $0x2,-0x260(%rbp,%rax,8)
jmp    11f5 <cfr4tr+0xd5>
mov    -0x38(%rbp),%rax
sub    $0x1,%rax
cmpq   $0x2,-0x260(%rbp,%rax,8)
ff 02
je     11f0 <cfr4tr+0xd0>
mov    -0x38(%rbp),%rax
sub    $0x1,%rax
mov    -0x260(%rbp,%rax,8),%rax
ff
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,-0x260(%rbp,%rax,8)
ff
jmp    1205 <cfr4tr+0xe5>
jmp    11f5 <cfr4tr+0xd5>
mov    -0x38(%rbp),%rax
movq   $0x2,-0x260(%rbp,%rax,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1170 <cfr4tr+0x50>
mov    -0x1d0(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x1d8(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x1e0(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x1e8(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x1f0(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x1f8(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x200(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x208(%rbp),%rax
mov    %rax,-0x168(%rbp)
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    0x2cb1(%rip),%rax
movsd  (%rax),%xmm0
cvtsi2sdq -0x10(%rbp),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x264(%rbp)
ff
movq   $0x3,-0x68(%rbp)
movq   $0x2,-0x70(%rbp)
movq   $0x2,-0x78(%rbp)
movq   $0x2,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
cmp    -0x158(%rbp),%rax
jg     1eca <cfr4tr+0xdaa>
mov    -0xb8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
cmp    -0x160(%rbp),%rax
jg     1eab <cfr4tr+0xd8b>
mov    -0xc0(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rax
cmp    -0x168(%rbp),%rax
jg     1e8c <cfr4tr+0xd6c>
mov    -0xc8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
cmp    -0x170(%rbp),%rax
jg     1e6d <cfr4tr+0xd4d>
mov    -0xd0(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
cmp    -0x178(%rbp),%rax
jg     1e4e <cfr4tr+0xd2e>
mov    -0xd8(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rax
cmp    -0x180(%rbp),%rax
jg     1e2f <cfr4tr+0xd0f>
mov    -0xe0(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rax
cmp    -0x188(%rbp),%rax
jg     1e10 <cfr4tr+0xcf0>
mov    -0xe8(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf0(%rbp),%rax
cmp    -0x190(%rbp),%rax
jg     1df1 <cfr4tr+0xcd1>
mov    -0xf0(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0xf8(%rbp),%rax
cmp    -0x198(%rbp),%rax
jg     1dd2 <cfr4tr+0xcb2>
mov    -0xf8(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x100(%rbp),%rax
cmp    -0x1a0(%rbp),%rax
jg     1db3 <cfr4tr+0xc93>
mov    -0x100(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x108(%rbp),%rax
cmp    -0x1a8(%rbp),%rax
jg     1d94 <cfr4tr+0xc74>
mov    -0x108(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x110(%rbp),%rax
cmp    -0x1b0(%rbp),%rax
jg     1d75 <cfr4tr+0xc55>
mov    -0x110(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x118(%rbp),%rax
cmp    -0x1b8(%rbp),%rax
jg     1d56 <cfr4tr+0xc36>
mov    -0x118(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x120(%rbp),%rax
cmp    -0x1c0(%rbp),%rax
jg     1d37 <cfr4tr+0xc17>
mov    -0x120(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0x128(%rbp)
cmpq   $0x0,-0x128(%rbp)
jg     17d9 <cfr4tr+0x6b9>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    168b <cfr4tr+0x56b>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x294(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x298(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x294(%rbp),%xmm0
ff
addss  -0x298(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x294(%rbp),%xmm0
ff
subss  -0x298(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    15a0 <cfr4tr+0x480>
cmpq   $0x4,-0x10(%rbp)
jle    17d4 <cfr4tr+0x6b4>
mov    -0x8(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
add    -0x8(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x60(%rbp),%rax
jge    17cf <cfr4tr+0x6af>
mov    0x291d(%rip),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28c(%rbp)
ff
mov    0x28e4(%rip),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x290(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x290(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x290(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x28c(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x28c(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    16b6 <cfr4tr+0x596>
jmp    17d4 <cfr4tr+0x6b4>
jmp    1d18 <cfr4tr+0xbf8>
cvtsi2ssq -0x128(%rbp),%xmm0
ff ff
mulss  -0x264(%rbp),%xmm0
ff
movss  %xmm0,-0x268(%rbp)
ff
movss  -0x268(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1040 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x26c(%rbp)
ff
movss  -0x268(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x278(%rbp)
ff
movss  -0x26c(%rbp),%xmm0
ff
movss  -0x26c(%rbp),%xmm2
ff
movss  -0x278(%rbp),%xmm1
ff
mulss  -0x278(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x270(%rbp)
ff
movss  -0x26c(%rbp),%xmm0
ff
movss  -0x278(%rbp),%xmm2
ff
movss  -0x26c(%rbp),%xmm1
ff
mulss  -0x278(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x27c(%rbp)
ff
movss  -0x26c(%rbp),%xmm0
ff
movss  -0x270(%rbp),%xmm2
ff
movss  -0x278(%rbp),%xmm1
ff
mulss  -0x27c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x274(%rbp)
ff
movss  -0x270(%rbp),%xmm0
ff
movss  -0x278(%rbp),%xmm2
ff
movss  -0x27c(%rbp),%xmm1
ff
mulss  -0x26c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x280(%rbp)
ff
mov    -0x8(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x40(%rbp)
mov    -0x78(%rbp),%rax
imul   -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x68(%rbp),%rax
imul   -0x40(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rax
add    -0x8(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
cmp    -0x50(%rbp),%rax
jge    1cd5 <cfr4tr+0xbb5>
mov    -0x58(%rbp),%rax
add    -0x80(%rbp),%rax
sub    -0x48(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x26c(%rbp),%xmm2
ff
mov    0x18(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x278(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x284(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x278(%rbp),%xmm2
ff
mov    0x18(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x26c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x288(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x270(%rbp),%xmm2
ff
mov    0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x27c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x29c(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x27c(%rbp),%xmm2
ff
mov    0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x270(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2ac(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x274(%rbp),%xmm2
ff
mov    0x28(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x280(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2a0(%rbp)
ff
mov    -0x30(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x280(%rbp),%xmm2
ff
mov    0x28(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x274(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2b0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x29c(%rbp),%xmm0
ff
movss  %xmm0,-0x294(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x2ac(%rbp),%xmm0
ff
movss  %xmm0,-0x2a4(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x29c(%rbp),%xmm0
ff
movss  %xmm0,-0x29c(%rbp)
ff
mov    0x10(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x2ac(%rbp),%xmm0
ff
movss  %xmm0,-0x2ac(%rbp)
ff
movss  -0x284(%rbp),%xmm0
ff
addss  -0x2a0(%rbp),%xmm0
ff
movss  %xmm0,-0x298(%rbp)
ff
movss  -0x288(%rbp),%xmm0
ff
addss  -0x2b0(%rbp),%xmm0
ff
movss  %xmm0,-0x2a8(%rbp)
ff
movss  -0x284(%rbp),%xmm0
ff
subss  -0x2a0(%rbp),%xmm0
ff
movss  %xmm0,-0x2a0(%rbp)
ff
movss  -0x288(%rbp),%xmm0
ff
subss  -0x2b0(%rbp),%xmm0
ff
movss  %xmm0,-0x2b0(%rbp)
ff
movss  -0x294(%rbp),%xmm0
ff
addss  -0x298(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2a4(%rbp),%xmm0
ff
addss  -0x2a8(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x294(%rbp),%xmm0
ff
subss  -0x298(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2a8(%rbp),%xmm0
ff
subss  -0x2a4(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x29c(%rbp),%xmm0
ff
subss  -0x2b0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2ac(%rbp),%xmm0
ff
addss  -0x2a0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x29c(%rbp),%xmm0
ff
addss  -0x2b0(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
mov    -0x88(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2a0(%rbp),%xmm0
ff
subss  -0x2ac(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
mov    -0x80(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
jmp    1940 <cfr4tr+0x820>
mov    -0x78(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x78(%rbp)
mov    -0x68(%rbp),%rax
sub    $0x2,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x70(%rbp),%rax
jg     1d13 <cfr4tr+0xbf3>
mov    -0x78(%rbp),%rax
shl    $0x1,%rax
sub    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0x70(%rbp)
jmp    1d18 <cfr4tr+0xbf8>
jmp    1d1d <cfr4tr+0xbfd>
mov    -0x1b8(%rbp),%rax
add    -0x120(%rbp),%rax
mov    %rax,-0x120(%rbp)
jmp    1564 <cfr4tr+0x444>
jmp    1d3c <cfr4tr+0xc1c>
mov    -0x1b0(%rbp),%rax
add    -0x118(%rbp),%rax
mov    %rax,-0x118(%rbp)
jmp    1542 <cfr4tr+0x422>
jmp    1d5b <cfr4tr+0xc3b>
mov    -0x1a8(%rbp),%rax
add    -0x110(%rbp),%rax
mov    %rax,-0x110(%rbp)
jmp    1520 <cfr4tr+0x400>
jmp    1d7a <cfr4tr+0xc5a>
mov    -0x1a0(%rbp),%rax
add    -0x108(%rbp),%rax
mov    %rax,-0x108(%rbp)
jmp    14fe <cfr4tr+0x3de>
jmp    1d99 <cfr4tr+0xc79>
mov    -0x198(%rbp),%rax
add    -0x100(%rbp),%rax
mov    %rax,-0x100(%rbp)
jmp    14dc <cfr4tr+0x3bc>
jmp    1db8 <cfr4tr+0xc98>
mov    -0x190(%rbp),%rax
add    -0xf8(%rbp),%rax
mov    %rax,-0xf8(%rbp)
jmp    14ba <cfr4tr+0x39a>
jmp    1dd7 <cfr4tr+0xcb7>
mov    -0x188(%rbp),%rax
add    -0xf0(%rbp),%rax
mov    %rax,-0xf0(%rbp)
jmp    1498 <cfr4tr+0x378>
jmp    1df6 <cfr4tr+0xcd6>
mov    -0x180(%rbp),%rax
add    -0xe8(%rbp),%rax
mov    %rax,-0xe8(%rbp)
jmp    1476 <cfr4tr+0x356>
jmp    1e15 <cfr4tr+0xcf5>
mov    -0x178(%rbp),%rax
add    -0xe0(%rbp),%rax
mov    %rax,-0xe0(%rbp)
jmp    1454 <cfr4tr+0x334>
jmp    1e34 <cfr4tr+0xd14>
mov    -0x170(%rbp),%rax
add    -0xd8(%rbp),%rax
mov    %rax,-0xd8(%rbp)
jmp    1432 <cfr4tr+0x312>
jmp    1e53 <cfr4tr+0xd33>
mov    -0x168(%rbp),%rax
add    -0xd0(%rbp),%rax
mov    %rax,-0xd0(%rbp)
jmp    1410 <cfr4tr+0x2f0>
jmp    1e72 <cfr4tr+0xd52>
mov    -0x160(%rbp),%rax
add    -0xc8(%rbp),%rax
mov    %rax,-0xc8(%rbp)
jmp    13ee <cfr4tr+0x2ce>
jmp    1e91 <cfr4tr+0xd71>
mov    -0x158(%rbp),%rax
add    -0xc0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
jmp    13cc <cfr4tr+0x2ac>
jmp    1eb0 <cfr4tr+0xd90>
mov    -0x150(%rbp),%rax
add    -0xb8(%rbp),%rax
mov    %rax,-0xb8(%rbp)
jmp    13aa <cfr4tr+0x28a>
mov    -0x148(%rbp),%rax
add    -0xb0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
cmp    -0x150(%rbp),%rax
jg     1ef8 <cfr4tr+0xdd8>
jmp    139c <cfr4tr+0x27c>
mov    -0x140(%rbp),%rax
add    -0xa8(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
cmp    -0x148(%rbp),%rax
jg     1f26 <cfr4tr+0xe06>
jmp    138e <cfr4tr+0x26e>
mov    -0x138(%rbp),%rax
add    -0xa0(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
cmp    -0x140(%rbp),%rax
jg     1f54 <cfr4tr+0xe34>
jmp    1380 <cfr4tr+0x260>
mov    -0x130(%rbp),%rax
add    -0x98(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
cmp    -0x138(%rbp),%rax
jg     1f82 <cfr4tr+0xe62>
jmp    1372 <cfr4tr+0x252>
mov    -0x90(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
cmp    -0x130(%rbp),%rax
jg     1fad <cfr4tr+0xe8d>
jmp    1364 <cfr4tr+0x244>
add    $0x2b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cfr4tr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x258,%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,0x1c0(%rsp)
mov    $0x2,%eax
cmp    $0x1,%rcx
jg     1180 <cfr4tr+0x60>
nop
movq   $0x2,0x1b0(%rsp,%rax,8)
mov    $0x2,%edx
jmp    118e <cfr4tr+0x6e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rcx,%rdx
shr    %rdx
cmp    $0x2,%rcx
cmove  %rcx,%rdx
mov    %rdx,0x1b8(%rsp,%rax,8)
cmp    $0x2,%rdx
jge    11c0 <cfr4tr+0xa0>
nopl   0x0(%rax)
movq   $0x2,0x1b8(%rsp,%rax,8)
mov    $0x2,%ecx
jmp    11ce <cfr4tr+0xae>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdx,%rcx
shr    %rcx
cmp    $0x2,%rdx
cmove  %rdx,%rcx
mov    %rcx,0x1c0(%rsp,%rax,8)
add    $0x2,%rax
cmp    $0x14,%rax
jne    1159 <cfr4tr+0x39>
mov    0x250(%rsp),%rax
mov    %rax,0xe0(%rsp)
mov    0x248(%rsp),%rax
mov    %rax,0xd8(%rsp)
mov    0x2dcd(%rip),%r10
cvtsi2sd %rsi,%xmm0
lea    0x0(,%r14,4),%rax
cmp    $0x5,%rsi
setl   %cl
lea    (%r14,%r14,4),%rdi
mov    %rax,0x100(%rsp)
cmp    %rdi,%rax
setge  %al
or     %cl,%al
mov    %al,0xf(%rsp)
mov    %r14,%rcx
shl    $0x4,%rcx
lea    (%r15,%rcx,1),%rax
mov    %rax,0xb0(%rsp)
lea    (%rcx,%r13,1),%rax
mov    %rax,0xa8(%rsp)
lea    (%r8,%rcx,1),%rax
mov    %rax,0xa0(%rsp)
add    %r12,%rcx
mov    %rcx,0x30(%rsp)
lea    (%r8,%r14,4),%rdx
lea    (%r15,%r14,4),%r11
lea    (%r12,%r14,4),%rbp
cmp    %r8,%r11
seta   %bl
lea    0x0(,%r14,4),%r9
add    %r13,%r9
cmp    %r15,%rdx
seta   %al
and    %bl,%al
cmp    %r8,%rbp
seta   %bl
cmp    %r12,%rdx
seta   %cl
and    %bl,%cl
or     %al,%cl
cmp    %r8,%r9
seta   %al
movsd  (%r10),%xmm1
cmp    %r13,%rdx
seta   %bl
and    %al,%bl
cmp    %r15,%rbp
seta   %al
lea    (%r15,%rdi,4),%r10
cmp    %r12,%r11
seta   %dl
and    %al,%dl
lea    0x0(,%rdi,4),%rsi
add    %r13,%rsi
or     %bl,%dl
or     %cl,%dl
cmp    %r15,%r9
seta   %bl
cmp    %r13,%r11
lea    (%r8,%rdi,4),%rax
mov    %rax,0x18(%rsp)
seta   %al
and    %bl,%al
cmp    %r12,%r9
mov    %rdi,%r11
seta   %dil
cmp    %r13,%rbp
mov    0xb0(%rsp),%r9
seta   %cl
and    %dil,%cl
or     %al,%cl
or     %dl,%cl
mov    %cl,0xe(%rsp)
mov    %r14,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x98(%rsp)
mov    %rsi,%rbx
mov    %rsi,0x10(%rsp)
cmp    %rsi,%r9
setb   %al
mov    0xa8(%rsp),%rdi
cmp    %r10,%rdi
setb   %dl
and    %al,%dl
mov    0x18(%rsp),%rsi
cmp    %rsi,%r9
setb   %cl
mov    0xa0(%rsp),%rbp
cmp    %r10,%rbp
setb   %al
and    %cl,%al
lea    (%r12,%r11,4),%rcx
mov    %rcx,0x28(%rsp)
or     %dl,%al
cmp    %rcx,%r9
setb   %dl
cmp    %r10,0x30(%rsp)
setb   %r10b
and    %dl,%r10b
cmp    %rsi,%rdi
setb   %dl
cmp    %rbx,%rbp
setb   %cl
and    %dl,%cl
mov    %rdi,%rdx
mov    0x30(%rsp),%rsi
or     %r10b,%cl
mov    %rbp,%rdi
mov    0x240(%rsp),%rbp
mov    %rbp,0xd0(%rsp)
or     %al,%cl
mov    0x28(%rsp),%rbx
cmp    %rbx,%rdx
setb   %r10b
cmp    0x10(%rsp),%rsi
setb   %al
and    %r10b,%al
mov    0x238(%rsp),%rbp
mov    %rbp,0xe8(%rsp)
cmp    %rbx,%rdi
setb   %bl
cmp    0x18(%rsp),%rsi
mov    0x230(%rsp),%rbp
mov    %rbp,0xf0(%rsp)
setb   %r10b
and    %bl,%r10b
mov    0x98(%rsp),%rbp
or     %al,%r10b
mov    0x228(%rsp),%rax
mov    %rax,0x38(%rsp)
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0xcc(%rsp)
or     %cl,%r10b
mov    %r10b,0xd(%rsp)
mov    0x220(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0x218(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0x210(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x208(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0x200(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x1f8(%rsp),%rax
mov    %rax,0x68(%rsp)
mov    0x1f0(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    0x1e8(%rsp),%rax
mov    %rax,0x78(%rsp)
mov    0x1e0(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0x1d8(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    0x1d0(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    0x1c0(%rsp),%rax
mov    %rax,0xb8(%rsp)
mov    0x1c8(%rsp),%r10
lea    0x0(%rbp,%r14,4),%rax
mov    %rax,0x1a0(%rsp)
mov    $0x3,%eax
mov    %rax,0x18(%rsp)
mov    $0x2,%ecx
mov    $0x2,%eax
mov    %rax,0x28(%rsp)
mov    $0x2,%eax
mov    %rax,0x108(%rsp)
mov    %rcx,%rax
mov    %rcx,0x180(%rsp)
mov    %rax,%rbx
mov    %rbx,0x120(%rsp)
mov    %rbx,0x118(%rsp)
mov    %r8,0xc0(%rsp)
mov    %r14,0x20(%rsp)
mov    %r11,0xf8(%rsp)
mov    %r10,0x1a8(%rsp)
mov    %rax,0x10(%rsp)
jmp    155e <cfr4tr+0x43e>
nop
mov    0x128(%rsp),%rbx
add    0xe8(%rsp),%rbx
cmp    0xf0(%rsp),%rbx
jg     1d90 <cfr4tr+0xc70>
cmp    0x38(%rsp),%rbx
mov    %rbx,0x128(%rsp)
jle    1587 <cfr4tr+0x467>
jmp    1540 <cfr4tr+0x420>
nop
mov    0x130(%rsp),%rbx
add    0xf0(%rsp),%rbx
cmp    0x38(%rsp),%rbx
jg     1540 <cfr4tr+0x420>
cmp    0x40(%rsp),%rbx
mov    %rbx,0x130(%rsp)
jle    15b4 <cfr4tr+0x494>
jmp    1570 <cfr4tr+0x450>
nopl   0x0(%rax,%rax,1)
mov    0x138(%rsp),%rbx
add    0x38(%rsp),%rbx
cmp    0x40(%rsp),%rbx
jg     1570 <cfr4tr+0x450>
cmp    0x48(%rsp),%rbx
mov    %rbx,0x138(%rsp)
jle    15e4 <cfr4tr+0x4c4>
jmp    15a0 <cfr4tr+0x480>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x140(%rsp),%rbx
add    0x40(%rsp),%rbx
cmp    0x48(%rsp),%rbx
jg     15a0 <cfr4tr+0x480>
cmp    0x50(%rsp),%rbx
mov    %rbx,0x140(%rsp)
jle    1614 <cfr4tr+0x4f4>
jmp    15d0 <cfr4tr+0x4b0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x148(%rsp),%rbx
add    0x48(%rsp),%rbx
cmp    0x50(%rsp),%rbx
jg     15d0 <cfr4tr+0x4b0>
cmp    0x58(%rsp),%rbx
mov    %rbx,0x148(%rsp)
jle    1644 <cfr4tr+0x524>
jmp    1600 <cfr4tr+0x4e0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x150(%rsp),%rbx
add    0x50(%rsp),%rbx
cmp    0x58(%rsp),%rbx
jg     1600 <cfr4tr+0x4e0>
cmp    0x60(%rsp),%rbx
mov    %rbx,0x150(%rsp)
jle    1674 <cfr4tr+0x554>
jmp    1630 <cfr4tr+0x510>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x158(%rsp),%rbx
add    0x58(%rsp),%rbx
cmp    0x60(%rsp),%rbx
jg     1630 <cfr4tr+0x510>
cmp    0x68(%rsp),%rbx
mov    %rbx,0x158(%rsp)
jle    16a4 <cfr4tr+0x584>
jmp    1660 <cfr4tr+0x540>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x160(%rsp),%rbx
add    0x60(%rsp),%rbx
cmp    0x68(%rsp),%rbx
jg     1660 <cfr4tr+0x540>
cmp    0x70(%rsp),%rbx
mov    %rbx,0x160(%rsp)
jle    16d4 <cfr4tr+0x5b4>
jmp    1690 <cfr4tr+0x570>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x168(%rsp),%rbx
add    0x68(%rsp),%rbx
cmp    0x70(%rsp),%rbx
jg     1690 <cfr4tr+0x570>
cmp    0x78(%rsp),%rbx
mov    %rbx,0x168(%rsp)
jle    1704 <cfr4tr+0x5e4>
jmp    16c0 <cfr4tr+0x5a0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x170(%rsp),%rbx
add    0x70(%rsp),%rbx
cmp    0x78(%rsp),%rbx
jg     16c0 <cfr4tr+0x5a0>
cmp    0x80(%rsp),%rbx
mov    %rbx,0x170(%rsp)
jle    1737 <cfr4tr+0x617>
jmp    16f0 <cfr4tr+0x5d0>
nopl   0x0(%rax,%rax,1)
mov    0x178(%rsp),%rbx
add    0x78(%rsp),%rbx
cmp    0x80(%rsp),%rbx
jg     16f0 <cfr4tr+0x5d0>
cmp    0x88(%rsp),%rbx
mov    %rbx,0x178(%rsp)
jle    1772 <cfr4tr+0x652>
jmp    1720 <cfr4tr+0x600>
nopl   0x0(%rax,%rax,1)
mov    0x188(%rsp),%rbx
add    0x80(%rsp),%rbx
cmp    0x88(%rsp),%rbx
mov    0x180(%rsp),%rcx
jg     1720 <cfr4tr+0x600>
cmp    0x90(%rsp),%rbx
mov    %rbx,0x188(%rsp)
jg     1750 <cfr4tr+0x630>
mov    %rbx,%rcx
jmp    17aa <cfr4tr+0x68a>
nopl   0x0(%rax)
mov    0x190(%rsp),%rcx
add    0x88(%rsp),%rcx
cmp    0x90(%rsp),%rcx
jg     1750 <cfr4tr+0x630>
cmp    %r10,%rcx
mov    %rcx,0x190(%rsp)
jle    17d5 <cfr4tr+0x6b5>
jmp    1790 <cfr4tr+0x670>
nopl   0x0(%rax)
mov    0x198(%rsp),%rcx
add    0x90(%rsp),%rcx
cmp    %r10,%rcx
jg     1790 <cfr4tr+0x670>
cmp    0xb8(%rsp),%rcx
mov    %rcx,0x198(%rsp)
jg     17c0 <cfr4tr+0x6a0>
mov    %rcx,%rbx
mov    0xb8(%rsp),%rcx
jmp    1859 <cfr4tr+0x739>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xc0(%rsp),%r8
mov    0x20(%rsp),%r14
mov    0xf8(%rsp),%r11
mov    0x30(%rsp),%rsi
mov    0xb0(%rsp),%r9
mov    0xa8(%rsp),%rdx
mov    0xa0(%rsp),%rdi
mov    0x98(%rsp),%rbp
mov    0x10(%rsp),%rax
mov    %r10,%rcx
mov    %rbx,%r10
mov    0x110(%rsp),%rbx
add    %r10,%rbx
cmp    %rcx,%rbx
jg     17c0 <cfr4tr+0x6a0>
cmp    $0x2,%rbx
jg     1890 <cfr4tr+0x770>
test   %r14,%r14
jle    1c0e <cfr4tr+0xaee>
cmp    $0x4,%r14
setb   %al
or     0xe(%rsp),%al
test   $0x1,%al
je     1b47 <cfr4tr+0xa27>
xor    %eax,%eax
jmp    1bb0 <cfr4tr+0xa90>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,0x110(%rsp)
lea    -0x2(%rbx),%rax
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mulss  0xcc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x1b8(%rsp)
call   1040 <cos@plt>
movsd  %xmm0,0x1b0(%rsp)
movsd  0x1b8(%rsp),%xmm0
call   1030 <sin@plt>
test   %r14,%r14
jle    1af3 <cfr4tr+0x9d3>
mov    0x28(%rsp),%r9
mov    0x100(%rsp),%rcx
imul   %rcx,%r9
movsd  0x1b0(%rsp),%xmm1
cvtsd2ss %xmm1,%xmm8
mov    0x20(%rsp),%rax
lea    (%r9,%rax,1),%r8
cvtsd2ss %xmm0,%xmm9
movaps %xmm9,%xmm0
mulss  %xmm9,%xmm0
movaps %xmm8,%xmm10
mulss  %xmm8,%xmm10
subss  %xmm0,%xmm10
movaps %xmm8,%xmm11
mulss  %xmm9,%xmm11
addss  %xmm11,%xmm11
movaps %xmm9,%xmm0
mulss  %xmm11,%xmm0
movaps %xmm8,%xmm12
mulss  %xmm10,%xmm12
subss  %xmm0,%xmm12
movaps %xmm11,%xmm0
mulss  %xmm8,%xmm0
movaps %xmm10,%xmm13
mulss  %xmm9,%xmm13
addss  %xmm0,%xmm13
mov    0x18(%rsp),%rdx
imul   %rcx,%rdx
lea    (%r12,%r9,4),%r10
lea    (%r15,%r9,4),%r11
mov    0xc0(%rsp),%rax
lea    (%rax,%r9,4),%rdi
lea    0x0(%r13,%r9,4),%rbp
mov    0x290(%rsp),%rax
lea    (%rax,%rdx,4),%rbx
mov    0x2a8(%rsp),%rax
lea    (%rax,%rdx,4),%rcx
mov    0x2a0(%rsp),%rax
lea    (%rax,%rdx,4),%rax
mov    0x298(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x0(%rbp,%rsi,4),%xmm6
movss  (%rdx,%rsi,4),%xmm0
movaps %xmm9,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm6,%xmm14
mulss  %xmm8,%xmm14
subss  %xmm1,%xmm14
mulss  %xmm8,%xmm0
mulss  %xmm9,%xmm6
addss  %xmm0,%xmm6
movss  (%rdi,%rsi,4),%xmm1
movss  (%rax,%rsi,4),%xmm0
movaps %xmm11,%xmm2
mulss  %xmm0,%xmm2
movaps %xmm1,%xmm7
mulss  %xmm10,%xmm7
subss  %xmm2,%xmm7
mulss  %xmm10,%xmm0
mulss  %xmm11,%xmm1
addss  %xmm0,%xmm1
movss  (%r11,%rsi,4),%xmm4
movss  (%rcx,%rsi,4),%xmm0
movaps %xmm13,%xmm2
mulss  %xmm0,%xmm2
movaps %xmm4,%xmm5
mulss  %xmm12,%xmm5
subss  %xmm2,%xmm5
mulss  %xmm12,%xmm0
mulss  %xmm13,%xmm4
addss  %xmm0,%xmm4
movss  (%r10,%rsi,4),%xmm15
movaps %xmm7,%xmm3
addss  %xmm15,%xmm3
movss  (%rbx,%rsi,4),%xmm2
movaps %xmm1,%xmm0
addss  %xmm2,%xmm0
subss  %xmm7,%xmm15
subss  %xmm1,%xmm2
movaps %xmm14,%xmm1
addss  %xmm5,%xmm1
movaps %xmm6,%xmm7
addss  %xmm4,%xmm7
subss  %xmm5,%xmm14
subss  %xmm4,%xmm6
movaps %xmm3,%xmm4
addss  %xmm1,%xmm4
movss  %xmm4,(%r10,%rsi,4)
movaps %xmm0,%xmm4
addss  %xmm7,%xmm4
movss  %xmm4,(%rcx,%rsi,4)
subss  %xmm1,%xmm3
movss  %xmm3,(%rax,%rsi,4)
subss  %xmm0,%xmm7
movss  %xmm7,0x0(%rbp,%rsi,4)
movaps %xmm15,%xmm0
subss  %xmm6,%xmm0
movss  %xmm0,(%rdi,%rsi,4)
movaps %xmm2,%xmm0
addss  %xmm14,%xmm0
movss  %xmm0,(%rdx,%rsi,4)
addss  %xmm15,%xmm6
movss  %xmm6,(%rbx,%rsi,4)
subss  %xmm2,%xmm14
movss  %xmm14,(%r11,%rsi,4)
lea    (%r9,%rsi,1),%r14
add    $0x1,%r14
add    $0x1,%rsi
cmp    %r8,%r14
jl     19c0 <cfr4tr+0x8a0>
mov    0x28(%rsp),%rcx
add    $0x2,%rcx
mov    0x18(%rsp),%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,0x18(%rsp)
cmp    0x108(%rsp),%rax
mov    0xb8(%rsp),%r10
mov    0x1a8(%rsp),%rbx
mov    %rcx,0x28(%rsp)
jg     1800 <cfr4tr+0x6e0>
lea    (%rcx,%rcx,1),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x18(%rsp)
mov    %rcx,0x108(%rsp)
jmp    1800 <cfr4tr+0x6e0>
xor    %eax,%eax
nopl   0x0(%rax)
movups (%r12,%rax,4),%xmm0
movups (%r8,%rax,4),%xmm1
movaps %xmm0,%xmm2
addps  %xmm1,%xmm2
movups 0x0(%r13,%rax,4),%xmm3
movups (%r15,%rax,4),%xmm4
addps  %xmm3,%xmm4
subps  %xmm1,%xmm0
movups %xmm0,(%r8,%rax,4)
movups 0x0(%r13,%rax,4),%xmm0
movups (%r15,%rax,4),%xmm1
subps  %xmm1,%xmm0
movups %xmm0,(%r15,%rax,4)
movaps %xmm2,%xmm0
addps  %xmm4,%xmm0
movups %xmm0,(%r12,%rax,4)
subps  %xmm4,%xmm2
movups %xmm2,0x0(%r13,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1b50 <cfr4tr+0xa30>
mov    %rbp,%rax
cmp    %r14,%rbp
je     1c0e <cfr4tr+0xaee>
xchg   %ax,%ax
movss  (%r12,%rax,4),%xmm0
movss  (%r8,%rax,4),%xmm1
movaps %xmm0,%xmm2
movss  0x0(%r13,%rax,4),%xmm3
addss  (%r15,%rax,4),%xmm3
subss  %xmm1,%xmm0
movss  %xmm0,(%r8,%rax,4)
movss  0x0(%r13,%rax,4),%xmm0
subss  (%r15,%rax,4),%xmm0
addss  %xmm1,%xmm2
movss  %xmm0,(%r15,%rax,4)
movaps %xmm2,%xmm0
addss  %xmm3,%xmm0
movss  %xmm0,(%r12,%rax,4)
subss  %xmm3,%xmm2
movss  %xmm2,0x0(%r13,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    1bb0 <cfr4tr+0xa90>
cmpb   $0x0,0xf(%rsp)
je     1c20 <cfr4tr+0xb00>
mov    0x10(%rsp),%rax
jmp    184d <cfr4tr+0x72d>
nop
cmp    $0x4,%r14
mov    %r11,%r14
mov    %r10,%r11
mov    %rbx,%r10
mov    %rcx,%rbx
setb   %cl
mov    0x23ae(%rip),%rax
movsd  (%rax),%xmm0
or     0xd(%rsp),%cl
mov    0x100(%rsp),%rax
test   $0x1,%cl
mov    %rbx,%rcx
mov    %r10,%rbx
mov    %r11,%r10
mov    %r14,%r11
jne    1d00 <cfr4tr+0xbe0>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rdx,%rax,4),%xmm2
movups (%r9,%rax,4),%xmm3
movaps %xmm2,%xmm4
subps  %xmm3,%xmm4
cvtps2pd %xmm4,%xmm5
movhlps %xmm4,%xmm4
cvtps2pd %xmm4,%xmm4
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
cvtpd2ps %xmm5,%xmm5
cvtpd2ps %xmm4,%xmm4
addps  %xmm3,%xmm2
cvtps2pd %xmm2,%xmm3
movhlps %xmm2,%xmm2
cvtps2pd %xmm2,%xmm2
unpcklpd %xmm4,%xmm5
mulpd  %xmm1,%xmm3
cvtpd2ps %xmm3,%xmm3
mulpd  %xmm1,%xmm2
cvtpd2ps %xmm2,%xmm2
unpcklpd %xmm2,%xmm3
movups (%rdi,%rax,4),%xmm2
movaps %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm4,(%r9,%rax,4)
subps  %xmm2,%xmm3
movups %xmm3,(%rdx,%rax,4)
movups (%rsi,%rax,4),%xmm2
movaps %xmm2,%xmm3
subps  %xmm5,%xmm3
movups %xmm3,(%rdi,%rax,4)
addps  %xmm2,%xmm5
movups %xmm5,(%rsi,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1c70 <cfr4tr+0xb50>
mov    0x1a0(%rsp),%rax
cmp    0x20(%rsp),%rbp
je     1d72 <cfr4tr+0xc52>
nop
movss  0x0(%r13,%rax,4),%xmm1
movss  (%r15,%rax,4),%xmm2
movaps %xmm1,%xmm3
subss  %xmm2,%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm0,%xmm3
cvtsd2ss %xmm3,%xmm3
addss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  (%r8,%rax,4),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%r15,%rax,4)
subss  (%r8,%rax,4),%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
movss  (%r12,%rax,4),%xmm1
subss  %xmm3,%xmm1
movss  %xmm1,(%r8,%rax,4)
addss  (%r12,%rax,4),%xmm3
movss  %xmm3,(%r12,%rax,4)
add    $0x1,%rax
cmp    %rax,%r11
jne    1d00 <cfr4tr+0xbe0>
mov    0x10(%rsp),%rax
mov    0x20(%rsp),%r14
jmp    184d <cfr4tr+0x72d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x118(%rsp),%rbx
add    0xd0(%rsp),%rbx
cmp    0xe8(%rsp),%rbx
jle    1513 <cfr4tr+0x3f3>
xchg   %ax,%ax
mov    0x120(%rsp),%rbx
add    0xd8(%rsp),%rbx
cmp    0xd0(%rsp),%rbx
jle    150b <cfr4tr+0x3eb>
xchg   %ax,%ax
add    0xe0(%rsp),%rax
cmp    0xd8(%rsp),%rax
jle    1508 <cfr4tr+0x3e8>
cs nopw 0x0(%rax,%rax,1)
add    $0x2,%rcx
cmp    0xe0(%rsp),%rcx
jle    14fd <cfr4tr+0x3dd>
add    $0x258,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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