#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 */
double Fabs(float);
int /*<<< orphan*/ do_rotate(float **, float **, float, float, int, int);
double sqrt(int);
void jacob(float a[128][128], float d[128], float v[128][128], int *nrot) {
  int iq, ip, i;
  float tresh, theta, tau, t, sm, s, h, g, c;
  float b[128];
  float z[128];
  for (ip = 1; ip <= 128; ++ip) {
    for (iq = 1; iq <= 128; iq++) {
      v[ip][iq] = 0.;
    }
    v[ip][iq] = 1.0;
  }
  for (ip = 1; ip <= 128; ip++) {
    b[ip] = d[ip] = a[ip][ip];
    z[ip] = 0.;
  }
  *nrot = 0;
  for (i = 1; i <= 50; ++i) {
    sm = 0.;
    for (ip = 1; ip <= 128 - 1; ip++)
      for (iq = ip + 1; iq <= 128; iq++)
        sm += Fabs(a[ip][iq]);
    if (sm == 0.0)
      return;
    if (i < 4)
      tresh = 0.2 * sm / (128 * 128);
    else
      tresh = 0.;
    for (ip = 1; ip <= 128 - 1; ip++) {
      for (iq = ip + 1; iq < 128; iq++) {
        g = 100.0 * Fabs(a[ip][iq]);
        if (i > 4 && (float)(Fabs(d[ip]) + g) == (float)Fabs(d[ip]) &&
            (float)(Fabs(d[iq]) + g) == (float)Fabs(d[iq]))
          a[ip][iq] = 0.0;
        else if (Fabs(a[ip][iq]) > tresh) {
          h = d[iq] - d[ip];
          if ((float)(Fabs(h) + g) == (float)Fabs(h))
            t = (a[ip][iq]) / h;
          else {
            theta = 0.5 * h / (a[ip][iq]);
            t = 1.0 / (Fabs(theta) + sqrt(1.0 + theta * theta));
            if (theta < 0.0)
              t = -t;
          }
          c = 1.0 / sqrt(1 + t * t);
          s = t * c;
          tau = s / (1.0 + c);
          h = t * a[ip][iq];
          z[ip] -= h;
          z[iq] += h;
          d[ip] -= h;
          d[iq] += h;
          a[ip][iq] = 0.;
          do_rotate(a, v, s, tau, ip, iq);
          ++(*nrot);
        }
      }
    }
    for (ip = 1; ip <= 128; ip++) {
      b[ip] += z[ip];
      d[ip] = b[ip];
      z[ip] = 0.0;
    }
  }
}


x86 assembly (clang, -O0):
<jacob>:
push   %rbp
mov    %rsp,%rbp
sub    $0x470,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x1,-0x28(%rbp)
cmpl   $0x80,-0x28(%rbp)
jg     11ca <jacob+0x9a>
movl   $0x1,-0x24(%rbp)
cmpl   $0x80,-0x24(%rbp)
jg     119c <jacob+0x6c>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1166 <jacob+0x36>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  0xe71(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1152 <jacob+0x22>
movl   $0x1,-0x28(%rbp)
cmpl   $0x80,-0x28(%rbp)
jg     122e <jacob+0xfe>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x28(%rbp),%rax
movss  %xmm0,-0x250(%rbp,%rax,4)
ff ff
movslq -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11d1 <jacob+0xa1>
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x2c(%rbp)
cmpl   $0x32,-0x2c(%rbp)
jg     17e7 <jacob+0x6b7>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x1,-0x28(%rbp)
cmpl   $0x7f,-0x28(%rbp)
jg     12cf <jacob+0x19f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x80,-0x24(%rbp)
jg     12bc <jacob+0x18c>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <Fabs@plt>
movaps %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    126b <jacob+0x13b>
jmp    12c1 <jacob+0x191>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1258 <jacob+0x128>
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12f0 <jacob+0x1c0>
jp     12f0 <jacob+0x1c0>
jmp    17e7 <jacob+0x6b7>
cmpl   $0x4,-0x2c(%rbp)
jge    1329 <jacob+0x1f9>
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xcfd(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0xce9(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
jmp    1331 <jacob+0x201>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x1,-0x28(%rbp)
cmpl   $0x7f,-0x28(%rbp)
jg     1765 <jacob+0x635>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x80,-0x24(%rbp)
jge    1752 <jacob+0x622>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <Fabs@plt>
movaps %xmm0,%xmm1
movsd  0xc90(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jle    146d <jacob+0x33d>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <Fabs@plt>
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x454(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <Fabs@plt>
movaps %xmm0,%xmm1
movss  -0x454(%rbp),%xmm0
ff
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    146d <jacob+0x33d>
jp     146d <jacob+0x33d>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <Fabs@plt>
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x458(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <Fabs@plt>
movaps %xmm0,%xmm1
movss  -0x458(%rbp),%xmm0
ff
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    146d <jacob+0x33d>
jp     146d <jacob+0x33d>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    173f <jacob+0x60f>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <Fabs@plt>
movss  -0x30(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    173a <jacob+0x60a>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
call   1050 <Fabs@plt>
movss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x45c(%rbp)
ff
movss  -0x48(%rbp),%xmm0
call   1050 <Fabs@plt>
movaps %xmm0,%xmm1
movss  -0x45c(%rbp),%xmm0
ff
cvtsd2ss %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    152e <jacob+0x3fe>
jp     152e <jacob+0x3fe>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    15f4 <jacob+0x4c4>
movss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xae1(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
call   1050 <Fabs@plt>
movsd  %xmm0,-0x468(%rbp)
ff
movss  -0x34(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa84(%rip),%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1040 <sqrt@plt>
movsd  -0x468(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  0xa63(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    15ef <jacob+0x4bf>
movss  -0x3c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    15f4 <jacob+0x4c4>
movss  -0x3c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  0xa1e(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x9f6(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x50(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x9c0(%rip),%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm1
movslq -0x28(%rbp),%rax
movss  -0x450(%rbp,%rax,4),%xmm0
ff ff
subss  %xmm1,%xmm0
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
movss  -0x48(%rbp),%xmm0
movslq -0x24(%rbp),%rax
addss  -0x450(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
movss  -0x48(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
movss  -0x44(%rbp),%xmm0
movss  -0x38(%rbp),%xmm1
mov    -0x28(%rbp),%edx
mov    -0x24(%rbp),%ecx
call   1030 <do_rotate@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    173f <jacob+0x60f>
jmp    1744 <jacob+0x614>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    134b <jacob+0x21b>
jmp    1757 <jacob+0x627>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1338 <jacob+0x208>
movl   $0x1,-0x28(%rbp)
cmpl   $0x80,-0x28(%rbp)
jg     17d4 <jacob+0x6a4>
movslq -0x28(%rbp),%rax
movss  -0x450(%rbp,%rax,4),%xmm0
ff ff
movslq -0x28(%rbp),%rax
addss  -0x250(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x250(%rbp,%rax,4)
ff ff
movslq -0x28(%rbp),%rax
movss  -0x250(%rbp,%rax,4),%xmm0
ff ff
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x450(%rbp,%rax,4)
ff ff
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    176c <jacob+0x63c>
jmp    17d9 <jacob+0x6a9>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    123f <jacob+0x10f>
add    $0x470,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jacob>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x478,%rsp
mov    %rcx,0x30(%rsp)
mov    %rsi,%r13
mov    %rdi,0x28(%rsp)
mov    %rdx,0x60(%rsp)
lea    0x604(%rdx),%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
lea    (%rbx,%rbp,1),%rdi
add    $0xfffffffffffffc00,%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1030 <memset@plt>
lea    (%rbx,%rbp,1),%rdi
add    $0xfffffffffffffe00,%rdi
movl   $0x3f800000,-0x200(%rbx,%rbp,1)
mov    $0x200,%edx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x3f800000,(%rbx,%rbp,1)
add    $0x400,%rbp
cmp    $0x10000,%rbp
jne    1170 <jacob+0x30>
lea    0x74(%rsp),%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1030 <memset@plt>
lea    0x4(%r13),%rcx
mov    0x28(%rsp),%rdx
lea    0x204(%rdx),%rax
add    $0x10204,%rdx
cmp    %rdx,%rcx
jae    1254 <jacob+0x114>
lea    0x204(%r13),%rcx
cmp    %rcx,%rax
jae    1254 <jacob+0x114>
mov    0x28(%rsp),%rax
add    $0x204,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movss  (%rax),%xmm0
movss  %xmm0,0x4(%r13,%rcx,4)
movss  %xmm0,0x274(%rsp,%rcx,4)
movss  0x204(%rax),%xmm0
movss  %xmm0,0x8(%r13,%rcx,4)
movss  %xmm0,0x278(%rsp,%rcx,4)
add    $0x2,%rcx
add    $0x408,%rax
cmp    $0x80,%rcx
jne    1210 <jacob+0xd0>
jmp    12dd <jacob+0x19d>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movss  0x60c(%rax),%xmm0
movss  0x408(%rax),%xmm1
unpcklps %xmm0,%xmm1
movss  (%rax),%xmm0
movss  0x204(%rax),%xmm2
unpcklps %xmm2,%xmm0
movlhps %xmm1,%xmm0
movss  0xe1c(%rax),%xmm1
movss  0xc18(%rax),%xmm2
unpcklps %xmm1,%xmm2
movss  0xa14(%rax),%xmm1
movss  0x810(%rax),%xmm3
unpcklps %xmm1,%xmm3
movlhps %xmm2,%xmm3
movups %xmm0,0x4(%r13,%rcx,4)
movups %xmm3,0x14(%r13,%rcx,4)
movups %xmm0,0x274(%rsp,%rcx,4)
movups %xmm3,0x284(%rsp,%rcx,4)
add    $0x8,%rcx
add    $0x1020,%rax
cmp    $0x80,%rcx
jne    1260 <jacob+0x120>
mov    0x30(%rsp),%rax
movl   $0x0,(%rax)
mov    0x28(%rsp),%rax
lea    0x208(%rax),%r12
lea    0x8(%r13),%rax
mov    %rax,0x48(%rsp)
movl   $0x1,0xc(%rsp)
mov    %r12,0x50(%rsp)
nopw   0x0(%rax,%rax,1)
mov    $0x1,%r14d
mov    $0x1fc,%r15d
mov    %r12,%rbx
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r14
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movss  %xmm0,0x10(%rsp)
movss  (%rbx,%rbp,1),%xmm0
call   1060 <Fabs@plt>
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
add    $0x4,%rbp
cmp    %rbp,%r15
jne    1340 <jacob+0x200>
add    $0x204,%rbx
add    $0xfffffffffffffffc,%r15
cmp    $0x80,%r14
jne    1330 <jacob+0x1f0>
ucomiss 0xcbb(%rip),%xmm0
jne    1391 <jacob+0x251>
jnp    1741 <jacob+0x601>
cvtss2sd %xmm0,%xmm0
mulsd  0xc63(%rip),%xmm0
mulsd  0xc63(%rip),%xmm0
cmpl   $0x4,0xc(%rsp)
jb     13c0 <jacob+0x280>
xorps  %xmm0,%xmm0
jmp    13c8 <jacob+0x288>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x40(%rsp)
mov    $0x1,%ebx
mov    %r12,%r14
mov    0x48(%rsp),%r15
lea    0x78(%rsp),%rax
mov    %rax,0x38(%rsp)
xor    %ebp,%ebp
jmp    1417 <jacob+0x2d7>
nopl   0x0(%rax)
add    $0x1,%rbp
addq   $0x4,0x38(%rsp)
add    $0x4,%r15
add    $0x204,%r14
mov    0x58(%rsp),%rbx
cmp    $0x80,%rbx
je     16c0 <jacob+0x580>
lea    0x1(%rbx),%rax
mov    %rax,0x58(%rsp)
cmp    $0x7e,%rbx
ja     13f0 <jacob+0x2b0>
xor    %r12d,%r12d
jmp    1517 <jacob+0x3d7>
xchg   %ax,%ax
movss  (%r14,%r12,4),%xmm1
divss  (%rsp),%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm1,%xmm0
mulss  %xmm1,%xmm0
addss  0xbf1(%rip),%xmm0
cvttss2si %xmm0,%edi
call   1050 <sqrt@plt>
movsd  0xbc0(%rip),%xmm3
movapd %xmm3,%xmm1
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movaps 0x10(%rsp),%xmm4
movaps %xmm4,%xmm0
mulss  %xmm1,%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
cvtss2sd %xmm1,%xmm1
addsd  %xmm3,%xmm1
divsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
mulss  (%r14,%r12,4),%xmm4
movss  0x70(%rsp,%rbx,4),%xmm2
subss  %xmm4,%xmm2
movss  %xmm2,0x70(%rsp,%rbx,4)
mov    0x38(%rsp),%rax
movss  (%rax,%r12,4),%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,(%rax,%r12,4)
movss  0x0(%r13,%rbx,4),%xmm2
subss  %xmm4,%xmm2
movss  %xmm2,0x0(%r13,%rbx,4)
addss  (%r15,%r12,4),%xmm4
movss  %xmm4,(%r15,%r12,4)
movl   $0x0,(%r14,%r12,4)
lea    0x2(%rbp,%r12,1),%ecx
mov    0x28(%rsp),%rdi
mov    0x60(%rsp),%rsi
mov    %ebx,%edx
call   1040 <do_rotate@plt>
mov    0x30(%rsp),%rax
addl   $0x1,(%rax)
lea    (%r12,%rbp,1),%rax
add    $0x1,%rax
add    $0x1,%r12
cmp    $0x7e,%rax
je     13f0 <jacob+0x2b0>
movss  (%r14,%r12,4),%xmm0
call   1060 <Fabs@plt>
mulsd  0xae6(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
cmpl   $0x5,0xc(%rsp)
jb     15d0 <jacob+0x490>
movss  0x0(%r13,%rbx,4),%xmm0
call   1060 <Fabs@plt>
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,0x68(%rsp)
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rsp)
movss  0x0(%r13,%rbx,4),%xmm0
call   1060 <Fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  (%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    15d0 <jacob+0x490>
jp     15d0 <jacob+0x490>
movss  (%r15,%r12,4),%xmm0
call   1060 <Fabs@plt>
addsd  0x68(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rsp)
movss  (%r15,%r12,4),%xmm0
call   1060 <Fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  (%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    15d0 <jacob+0x490>
jp     15d0 <jacob+0x490>
movl   $0x0,(%r14,%r12,4)
jmp    1501 <jacob+0x3c1>
cs nopw 0x0(%rax,%rax,1)
movss  (%r14,%r12,4),%xmm0
call   1060 <Fabs@plt>
ucomisd 0x40(%rsp),%xmm0
jbe    1501 <jacob+0x3c1>
movss  (%r15,%r12,4),%xmm0
subss  0x0(%r13,%rbx,4),%xmm0
movss  %xmm0,(%rsp)
call   1060 <Fabs@plt>
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x10(%rsp)
movss  (%rsp),%xmm0
call   1060 <Fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  0x10(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    1638 <jacob+0x4f8>
jnp    1430 <jacob+0x2f0>
movss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0x9cf(%rip),%xmm0
movss  (%r14,%r12,4),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
call   1060 <Fabs@plt>
movsd  %xmm0,(%rsp)
movss  0x10(%rsp),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x99f(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1050 <sqrt@plt>
addsd  (%rsp),%xmm0
movsd  0x985(%rip),%xmm1
divsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
xorpd  %xmm0,%xmm0
ucomiss 0x10(%rsp),%xmm0
jbe    143b <jacob+0x2fb>
xorps  0x977(%rip),%xmm1
jmp    143b <jacob+0x2fb>
xchg   %ax,%ax
xor    %eax,%eax
xorps  %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x74(%rsp,%rax,4),%xmm0
movups 0x84(%rsp,%rax,4),%xmm1
movups 0x274(%rsp,%rax,4),%xmm2
addps  %xmm0,%xmm2
movups 0x284(%rsp,%rax,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0x274(%rsp,%rax,4)
movups %xmm0,0x284(%rsp,%rax,4)
movups %xmm2,0x4(%r13,%rax,4)
movups %xmm0,0x14(%r13,%rax,4)
movups %xmm3,0x74(%rsp,%rax,4)
movups %xmm3,0x84(%rsp,%rax,4)
add    $0x8,%rax
cmp    $0x80,%rax
jne    16d0 <jacob+0x590>
mov    0xc(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xc(%rsp)
cmp    $0x33,%eax
mov    0x50(%rsp),%r12
jne    1310 <jacob+0x1d0>
add    $0x478,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @jacob([128 x float]* %0, float* %1, [128 x float]* %2, i32* %3) {
%5 = alloca [128 x float]*
%6 = alloca float*
%7 = alloca [128 x float]*
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca float
%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 [128 x float]
%22 = alloca [128 x float]
store [128 x float]* %0, [128 x float]** %5
store float* %1, float** %6
store [128 x float]* %2, [128 x float]** %7
store i32* %3, i32** %8
store i32 1, i32* %10
br label %23
23: ; preds = %49, %4
%24 = load i32, i32* %10
%25 = icmp sle i32 %24, 128
br i1 %25, label %26, label %52
26: ; preds = %23
store i32 1, i32* %9
br label %27
27: ; preds = %38, %26
%28 = load i32, i32* %9
%29 = icmp sle i32 %28, 128
br i1 %29, label %30, label %41
30: ; preds = %27
%31 = load [128 x float]*, [128 x float]** %7
%32 = load i32, i32* %10
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [128 x float], [128 x float]* %31, i64 %33
%35 = load i32, i32* %9
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [128 x float], [128 x float]* %34, i64 0, i64 %36
store float 0.000000e+00, float* %37
br label %38
38: ; preds = %30
%39 = load i32, i32* %9
%40 = add nsw i32 %39, 1
store i32 %40, i32* %9
br label %27
41: ; preds = %27
%42 = load [128 x float]*, [128 x float]** %7
%43 = load i32, i32* %10
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [128 x float], [128 x float]* %42, i64 %44
%46 = load i32, i32* %9
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [128 x float], [128 x float]* %45, i64 0, i64 %47
store float 1.000000e+00, float* %48
br label %49
49: ; preds = %41
%50 = load i32, i32* %10
%51 = add nsw i32 %50, 1
store i32 %51, i32* %10
br label %23
52: ; preds = %23
store i32 1, i32* %10
br label %53
53: ; preds = %75, %52
%54 = load i32, i32* %10
%55 = icmp sle i32 %54, 128
br i1 %55, label %56, label %78
56: ; preds = %53
%57 = load [128 x float]*, [128 x float]** %5
%58 = load i32, i32* %10
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [128 x float], [128 x float]* %57, i64 %59
%61 = load i32, i32* %10
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [128 x float], [128 x float]* %60, i64 0, i64 %62
%64 = load float, float* %63
%65 = load float*, float** %6
%66 = load i32, i32* %10
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %65, i64 %67
store float %64, float* %68
%69 = load i32, i32* %10
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [128 x float], [128 x float]* %21, i64 0, i64 %70
store float %64, float* %71
%72 = load i32, i32* %10
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [128 x float], [128 x float]* %22, i64 0, i64 %73
store float 0.000000e+00, float* %74
br label %75
75: ; preds = %56
%76 = load i32, i32* %10
%77 = add nsw i32 %76, 1
store i32 %77, i32* %10
br label %53
78: ; preds = %53
%79 = load i32*, i32** %8
store i32 0, i32* %79
store i32 1, i32* %11
br label %80
80: ; preds = %390, %78
%81 = load i32, i32* %11
%82 = icmp sle i32 %81, 50
br i1 %82, label %83, label %393
83: ; preds = %80
store float 0.000000e+00, float* %16
store i32 1, i32* %10
br label %84
84: ; preds = %111, %83
%85 = load i32, i32* %10
%86 = icmp sle i32 %85, 127
br i1 %86, label %87, label %114
87: ; preds = %84
%88 = load i32, i32* %10
%89 = add nsw i32 %88, 1
store i32 %89, i32* %9
br label %90
90: ; preds = %107, %87
%91 = load i32, i32* %9
%92 = icmp sle i32 %91, 128
br i1 %92, label %93, label %110
93: ; preds = %90
%94 = load [128 x float]*, [128 x float]** %5
%95 = load i32, i32* %10
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [128 x float], [128 x float]* %94, i64 %96
%98 = load i32, i32* %9
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [128 x float], [128 x float]* %97, i64 0, i64 %99
%101 = load float, float* %100
%102 = call double @Fabs(float %101)
%103 = load float, float* %16
%104 = fpext float %103 to double
%105 = fadd double %104, %102
%106 = fptrunc double %105 to float
store float %106, float* %16
br label %107
107: ; preds = %93
%108 = load i32, i32* %9
%109 = add nsw i32 %108, 1
store i32 %109, i32* %9
br label %90
110: ; preds = %90
br label %111
111: ; preds = %110
%112 = load i32, i32* %10
%113 = add nsw i32 %112, 1
store i32 %113, i32* %10
br label %84
114: ; preds = %84
%115 = load float, float* %16
%116 = fpext float %115 to double
%117 = fcmp oeq double %116, 0.000000e+00
br i1 %117, label %118, label %119
118: ; preds = %114
br label %393
119: ; preds = %114
%120 = load i32, i32* %11
%121 = icmp slt i32 %120, 4
br i1 %121, label %122, label %128
122: ; preds = %119
%123 = load float, float* %16
%124 = fpext float %123 to double
%125 = fmul double 2.000000e-01, %124
%126 = fdiv double %125, 1.638400e+04
%127 = fptrunc double %126 to float
store float %127, float* %12
br label %129
128: ; preds = %119
store float 0.000000e+00, float* %12
br label %129
129: ; preds = %128, %122
store i32 1, i32* %10
br label %130
130: ; preds = %358, %129
%131 = load i32, i32* %10
%132 = icmp sle i32 %131, 127
br i1 %132, label %133, label %361
133: ; preds = %130
%134 = load i32, i32* %10
%135 = add nsw i32 %134, 1
store i32 %135, i32* %9
br label %136
136: ; preds = %354, %133
%137 = load i32, i32* %9
%138 = icmp slt i32 %137, 128
br i1 %138, label %139, label %357
139: ; preds = %136
%140 = load [128 x float]*, [128 x float]** %5
%141 = load i32, i32* %10
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds [128 x float], [128 x float]* %140, i64 %142
%144 = load i32, i32* %9
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [128 x float], [128 x float]* %143, i64 0, i64 %145
%147 = load float, float* %146
%148 = call double @Fabs(float %147)
%149 = fmul double 1.000000e+02, %148
%150 = fptrunc double %149 to float
store float %150, float* %19
%151 = load i32, i32* %11
%152 = icmp sgt i32 %151, 4
br i1 %152, label %153, label %199
153: ; preds = %139
%154 = load float*, float** %6
%155 = load i32, i32* %10
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds float, float* %154, i64 %156
%158 = load float, float* %157
%159 = call double @Fabs(float %158)
%160 = load float, float* %19
%161 = fpext float %160 to double
%162 = fadd double %159, %161
%163 = fptrunc double %162 to float
%164 = load float*, float** %6
%165 = load i32, i32* %10
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds float, float* %164, i64 %166
%168 = load float, float* %167
%169 = call double @Fabs(float %168)
%170 = fptrunc double %169 to float
%171 = fcmp oeq float %163, %170
br i1 %171, label %172, label %199
172: ; preds = %153
%173 = load float*, float** %6
%174 = load i32, i32* %9
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds float, float* %173, i64 %175
%177 = load float, float* %176
%178 = call double @Fabs(float %177)
%179 = load float, float* %19
%180 = fpext float %179 to double
%181 = fadd double %178, %180
%182 = fptrunc double %181 to float
%183 = load float*, float** %6
%184 = load i32, i32* %9
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float, float* %183, i64 %185
%187 = load float, float* %186
%188 = call double @Fabs(float %187)
%189 = fptrunc double %188 to float
%190 = fcmp oeq float %182, %189
br i1 %190, label %191, label %199
191: ; preds = %172
%192 = load [128 x float]*, [128 x float]** %5
%193 = load i32, i32* %10
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [128 x float], [128 x float]* %192, i64 %194
%196 = load i32, i32* %9
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [128 x float], [128 x float]* %195, i64 0, i64 %197
store float 0.000000e+00, float* %198
br label %353
199: ; preds = %172, %153, %139
%200 = load [128 x float]*, [128 x float]** %5
%201 = load i32, i32* %10
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [128 x float], [128 x float]* %200, i64 %202
%204 = load i32, i32* %9
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [128 x float], [128 x float]* %203, i64 0, i64 %205
%207 = load float, float* %206
%208 = call double @Fabs(float %207)
%209 = load float, float* %12
%210 = fpext float %209 to double
%211 = fcmp ogt double %208, %210
br i1 %211, label %212, label %352
212: ; preds = %199
%213 = load float*, float** %6
%214 = load i32, i32* %9
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds float, float* %213, i64 %215
%217 = load float, float* %216
%218 = load float*, float** %6
%219 = load i32, i32* %10
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds float, float* %218, i64 %220
%222 = load float, float* %221
%223 = fsub float %217, %222
store float %223, float* %18
%224 = load float, float* %18
%225 = call double @Fabs(float %224)
%226 = load float, float* %19
%227 = fpext float %226 to double
%228 = fadd double %225, %227
%229 = fptrunc double %228 to float
%230 = load float, float* %18
%231 = call double @Fabs(float %230)
%232 = fptrunc double %231 to float
%233 = fcmp oeq float %229, %232
br i1 %233, label %234, label %245
234: ; preds = %212
%235 = load [128 x float]*, [128 x float]** %5
%236 = load i32, i32* %10
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds [128 x float], [128 x float]* %235, i64 %237
%239 = load i32, i32* %9
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [128 x float], [128 x float]* %238, i64 0, i64 %240
%242 = load float, float* %241
%243 = load float, float* %18
%244 = fdiv float %242, %243
store float %244, float* %15
br label %279
245: ; preds = %212
%246 = load float, float* %18
%247 = fpext float %246 to double
%248 = fmul double 5.000000e-01, %247
%249 = load [128 x float]*, [128 x float]** %5
%250 = load i32, i32* %10
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [128 x float], [128 x float]* %249, i64 %251
%253 = load i32, i32* %9
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds [128 x float], [128 x float]* %252, i64 0, i64 %254
%256 = load float, float* %255
%257 = fpext float %256 to double
%258 = fdiv double %248, %257
%259 = fptrunc double %258 to float
store float %259, float* %13
%260 = load float, float* %13
%261 = call double @Fabs(float %260)
%262 = load float, float* %13
%263 = load float, float* %13
%264 = fmul float %262, %263
%265 = fpext float %264 to double
%266 = fadd double 1.000000e+00, %265
%267 = fptosi double %266 to i32
%268 = call double @sqrt(i32 %267)
%269 = fadd double %261, %268
%270 = fdiv double 1.000000e+00, %269
%271 = fptrunc double %270 to float
store float %271, float* %15
%272 = load float, float* %13
%273 = fpext float %272 to double
%274 = fcmp olt double %273, 0.000000e+00
br i1 %274, label %275, label %278
275: ; preds = %245
%276 = load float, float* %15
%277 = fneg float %276
store float %277, float* %15
br label %278
278: ; preds = %275, %245
br label %279
279: ; preds = %278, %234
%280 = load float, float* %15
%281 = load float, float* %15
%282 = call float @llvm.fmuladd.f32(float %280, float %281, float 1.000000e+00)
%283 = fptosi float %282 to i32
%284 = call double @sqrt(i32 %283)
%285 = fdiv double 1.000000e+00, %284
%286 = fptrunc double %285 to float
store float %286, float* %20
%287 = load float, float* %15
%288 = load float, float* %20
%289 = fmul float %287, %288
store float %289, float* %17
%290 = load float, float* %17
%291 = fpext float %290 to double
%292 = load float, float* %20
%293 = fpext float %292 to double
%294 = fadd double 1.000000e+00, %293
%295 = fdiv double %291, %294
%296 = fptrunc double %295 to float
store float %296, float* %14
%297 = load float, float* %15
%298 = load [128 x float]*, [128 x float]** %5
%299 = load i32, i32* %10
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds [128 x float], [128 x float]* %298, i64 %300
%302 = load i32, i32* %9
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds [128 x float], [128 x float]* %301, i64 0, i64 %303
%305 = load float, float* %304
%306 = fmul float %297, %305
store float %306, float* %18
%307 = load float, float* %18
%308 = load i32, i32* %10
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds [128 x float], [128 x float]* %22, i64 0, i64 %309
%311 = load float, float* %310
%312 = fsub float %311, %307
store float %312, float* %310
%313 = load float, float* %18
%314 = load i32, i32* %9
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds [128 x float], [128 x float]* %22, i64 0, i64 %315
%317 = load float, float* %316
%318 = fadd float %317, %313
store float %318, float* %316
%319 = load float, float* %18
%320 = load float*, float** %6
%321 = load i32, i32* %10
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds float, float* %320, i64 %322
%324 = load float, float* %323
%325 = fsub float %324, %319
store float %325, float* %323
%326 = load float, float* %18
%327 = load float*, float** %6
%328 = load i32, i32* %9
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds float, float* %327, i64 %329
%331 = load float, float* %330
%332 = fadd float %331, %326
store float %332, float* %330
%333 = load [128 x float]*, [128 x float]** %5
%334 = load i32, i32* %10
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds [128 x float], [128 x float]* %333, i64 %335
%337 = load i32, i32* %9
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds [128 x float], [128 x float]* %336, i64 0, i64 %338
store float 0.000000e+00, float* %339
%340 = load [128 x float]*, [128 x float]** %5
%341 = bitcast [128 x float]* %340 to float**
%342 = load [128 x float]*, [128 x float]** %7
%343 = bitcast [128 x float]* %342 to float**
%344 = load float, float* %17
%345 = load float, float* %14
%346 = load i32, i32* %10
%347 = load i32, i32* %9
%348 = call i32 @do_rotate(float** %341, float** %343, float %344, float %345, i32 %346, i32 %347)
%349 = load i32*, i32** %8
%350 = load i32, i32* %349
%351 = add nsw i32 %350, 1
store i32 %351, i32* %349
br label %352
352: ; preds = %279, %199
br label %353
353: ; preds = %352, %191
br label %354
354: ; preds = %353
%355 = load i32, i32* %9
%356 = add nsw i32 %355, 1
store i32 %356, i32* %9
br label %136
357: ; preds = %136
br label %358
358: ; preds = %357
%359 = load i32, i32* %10
%360 = add nsw i32 %359, 1
store i32 %360, i32* %10
br label %130
361: ; preds = %130
store i32 1, i32* %10
br label %362
362: ; preds = %386, %361
%363 = load i32, i32* %10
%364 = icmp sle i32 %363, 128
br i1 %364, label %365, label %389
365: ; preds = %362
%366 = load i32, i32* %10
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds [128 x float], [128 x float]* %22, i64 0, i64 %367
%369 = load float, float* %368
%370 = load i32, i32* %10
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds [128 x float], [128 x float]* %21, i64 0, i64 %371
%373 = load float, float* %372
%374 = fadd float %373, %369
store float %374, float* %372
%375 = load i32, i32* %10
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds [128 x float], [128 x float]* %21, i64 0, i64 %376
%378 = load float, float* %377
%379 = load float*, float** %6
%380 = load i32, i32* %10
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds float, float* %379, i64 %381
store float %378, float* %382
%383 = load i32, i32* %10
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds [128 x float], [128 x float]* %22, i64 0, i64 %384
store float 0.000000e+00, float* %385
br label %386
386: ; preds = %365
%387 = load i32, i32* %10
%388 = add nsw i32 %387, 1
store i32 %388, i32* %10
br label %362
389: ; preds = %362
br label %390
390: ; preds = %389
%391 = load i32, i32* %11
%392 = add nsw i32 %391, 1
store i32 %392, i32* %11
br label %80
393: ; preds = %118, %80
ret void
}

LLVM IR (-O2):
define void @jacob([128 x float]* %0, float* nocapture %1, [128 x float]* %2, i32* nocapture %3) {
%5 = alloca [128 x float]
%6 = alloca [128 x float]
%7 = bitcast [128 x float]* %5 to i8*
%8 = bitcast [128 x float]* %6 to i8*
br label %9
9: ; preds = %9, %4
%10 = phi i64 [ 1, %4 ], [ %21, %9 ]
%11 = phi i64 [ 0, %4 ], [ %17, %9 ]
%12 = or i64 %11, 1
%13 = getelementptr [128 x float], [128 x float]* %2, i64 %12, i64 1
%14 = bitcast float* %13 to i8*
%15 = getelementptr inbounds [128 x float], [128 x float]* %2, i64 %10, i64 129
store float 1.000000e+00, float* %15
%16 = add nuw nsw i64 %10, 1
%17 = add nuw nsw i64 %11, 2
%18 = getelementptr [128 x float], [128 x float]* %2, i64 %17, i64 1
%19 = bitcast float* %18 to i8*
%20 = getelementptr inbounds [128 x float], [128 x float]* %2, i64 %16, i64 129
store float 1.000000e+00, float* %20
%21 = add nuw nsw i64 %10, 2
%22 = icmp eq i64 %17, 128
br i1 %22, label %23, label %9
23: ; preds = %9
%24 = getelementptr inbounds [128 x float], [128 x float]* %6, i64 0, i64 1
%25 = bitcast float* %24 to i8*
%26 = getelementptr float, float* %1, i64 1
%27 = getelementptr float, float* %1, i64 129
%28 = getelementptr [128 x float], [128 x float]* %0, i64 1, i64 1
%29 = getelementptr [128 x float], [128 x float]* %0, i64 129, i64 1
%30 = icmp ult float* %26, %29
%31 = icmp ult float* %28, %27
%32 = and i1 %30, %31
br i1 %32, label %77, label %33
33: ; preds = %23, %33
%34 = phi i64 [ %75, %33 ], [ 0, %23 ]
%35 = or i64 %34, 1
%36 = or i64 %34, 2
%37 = or i64 %34, 3
%38 = or i64 %34, 4
%39 = or i64 %34, 5
%40 = or i64 %34, 6
%41 = or i64 %34, 7
%42 = add i64 %34, 8
%43 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %35, i64 %35
%44 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %36, i64 %36
%45 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %37, i64 %37
%46 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %38, i64 %38
%47 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %39, i64 %39
%48 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %40, i64 %40
%49 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %41, i64 %41
%50 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %42, i64 %42
%51 = load float, float* %43
%52 = load float, float* %44
%53 = load float, float* %45
%54 = load float, float* %46
%55 = insertelement <4 x float> poison, float %51, i64 0
%56 = insertelement <4 x float> %55, float %52, i64 1
%57 = insertelement <4 x float> %56, float %53, i64 2
%58 = insertelement <4 x float> %57, float %54, i64 3
%59 = load float, float* %47
%60 = load float, float* %48
%61 = load float, float* %49
%62 = load float, float* %50
%63 = insertelement <4 x float> poison, float %59, i64 0
%64 = insertelement <4 x float> %63, float %60, i64 1
%65 = insertelement <4 x float> %64, float %61, i64 2
%66 = insertelement <4 x float> %65, float %62, i64 3
%67 = getelementptr inbounds float, float* %1, i64 %35
%68 = bitcast float* %67 to <4 x float>*
store <4 x float> %58, <4 x float>* %68
%69 = getelementptr inbounds float, float* %67, i64 4
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> %66, <4 x float>* %70
%71 = getelementptr inbounds [128 x float], [128 x float]* %5, i64 0, i64 %35
%72 = bitcast float* %71 to <4 x float>*
store <4 x float> %58, <4 x float>* %72
%73 = getelementptr inbounds float, float* %71, i64 4
%74 = bitcast float* %73 to <4 x float>*
store <4 x float> %66, <4 x float>* %74
%75 = add nuw i64 %34, 8
%76 = icmp eq i64 %75, 128
br i1 %76, label %90, label %33
77: ; preds = %23, %77
%78 = phi i64 [ %88, %77 ], [ 1, %23 ]
%79 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %78, i64 %78
%80 = load float, float* %79
%81 = getelementptr inbounds float, float* %1, i64 %78
store float %80, float* %81
%82 = getelementptr inbounds [128 x float], [128 x float]* %5, i64 0, i64 %78
store float %80, float* %82
%83 = add nuw nsw i64 %78, 1
%84 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %83, i64 %83
%85 = load float, float* %84
%86 = getelementptr inbounds float, float* %1, i64 %83
store float %85, float* %86
%87 = getelementptr inbounds [128 x float], [128 x float]* %5, i64 0, i64 %83
store float %85, float* %87
%88 = add nuw nsw i64 %78, 2
%89 = icmp eq i64 %88, 129
br i1 %89, label %90, label %77
90: ; preds = %33, %77
store i32 0, i32* %3
%91 = bitcast [128 x float]* %0 to float**
%92 = bitcast [128 x float]* %2 to float**
br label %93
93: ; preds = %90, %261
%94 = phi i32 [ 1, %90 ], [ %262, %261 ]
br label %98
95: ; preds = %103
%96 = add nuw nsw i64 %100, 1
%97 = icmp eq i64 %102, 128
br i1 %97, label %114, label %98
98: ; preds = %95, %93
%99 = phi i64 [ 1, %93 ], [ %102, %95 ]
%100 = phi i64 [ 2, %93 ], [ %96, %95 ]
%101 = phi float [ 0.000000e+00, %93 ], [ %111, %95 ]
%102 = add nuw nsw i64 %99, 1
br label %103
103: ; preds = %98, %103
%104 = phi i64 [ %100, %98 ], [ %112, %103 ]
%105 = phi float [ %101, %98 ], [ %111, %103 ]
%106 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %99, i64 %104
%107 = load float, float* %106
%108 = tail call double @Fabs(float %107)
%109 = fpext float %105 to double
%110 = fadd double %108, %109
%111 = fptrunc double %110 to float
%112 = add nuw nsw i64 %104, 1
%113 = icmp eq i64 %112, 129
br i1 %113, label %95, label %103
114: ; preds = %95
%115 = fcmp oeq float %111, 0.000000e+00
br i1 %115, label %264, label %116
116: ; preds = %114
%117 = fpext float %111 to double
%118 = icmp ult i32 %94, 4
%119 = fmul double %117, 2.000000e-01
%120 = fmul double %119, 0x3F10000000000000
%121 = fptrunc double %120 to float
%122 = icmp ugt i32 %94, 4
%123 = fpext float %121 to double
%124 = select i1 %118, double %123, double 0.000000e+00
br label %155
125: ; preds = %258, %155
%126 = add nuw nsw i64 %157, 1
%127 = icmp eq i64 %158, 128
br i1 %127, label %128, label %155
128: ; preds = %125, %128
%129 = phi i64 [ %153, %128 ], [ 0, %125 ]
%130 = or i64 %129, 1
%131 = getelementptr inbounds [128 x float], [128 x float]* %6, i64 0, i64 %130
%132 = bitcast float* %131 to <4 x float>*
%133 = load <4 x float>, <4 x float>* %132
%134 = getelementptr inbounds float, float* %131, i64 4
%135 = bitcast float* %134 to <4 x float>*
%136 = load <4 x float>, <4 x float>* %135
%137 = getelementptr inbounds [128 x float], [128 x float]* %5, i64 0, i64 %130
%138 = bitcast float* %137 to <4 x float>*
%139 = load <4 x float>, <4 x float>* %138
%140 = getelementptr inbounds float, float* %137, i64 4
%141 = bitcast float* %140 to <4 x float>*
%142 = load <4 x float>, <4 x float>* %141
%143 = fadd <4 x float> %133, %139
%144 = fadd <4 x float> %136, %142
%145 = bitcast float* %137 to <4 x float>*
store <4 x float> %143, <4 x float>* %145
%146 = bitcast float* %140 to <4 x float>*
store <4 x float> %144, <4 x float>* %146
%147 = getelementptr inbounds float, float* %1, i64 %130
%148 = bitcast float* %147 to <4 x float>*
store <4 x float> %143, <4 x float>* %148
%149 = getelementptr inbounds float, float* %147, i64 4
%150 = bitcast float* %149 to <4 x float>*
store <4 x float> %144, <4 x float>* %150
%151 = bitcast float* %131 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %151
%152 = bitcast float* %134 to <4 x float>*
store <4 x float> zeroinitializer, <4 x float>* %152
%153 = add nuw i64 %129, 8
%154 = icmp eq i64 %153, 128
br i1 %154, label %261, label %128
155: ; preds = %116, %125
%156 = phi i64 [ 1, %116 ], [ %158, %125 ]
%157 = phi i64 [ 2, %116 ], [ %126, %125 ]
%158 = add nuw nsw i64 %156, 1
%159 = icmp ult i64 %156, 127
br i1 %159, label %160, label %125
160: ; preds = %155
%161 = getelementptr inbounds float, float* %1, i64 %156
%162 = getelementptr inbounds [128 x float], [128 x float]* %6, i64 0, i64 %156
%163 = trunc i64 %156 to i32
br label %164
164: ; preds = %160, %258
%165 = phi i64 [ %157, %160 ], [ %259, %258 ]
%166 = getelementptr inbounds [128 x float], [128 x float]* %0, i64 %156, i64 %165
%167 = load float, float* %166
%168 = tail call double @Fabs(float %167)
%169 = fmul double %168, 1.000000e+02
%170 = fptrunc double %169 to float
br i1 %122, label %171, label %192
171: ; preds = %164
%172 = load float, float* %161
%173 = tail call double @Fabs(float %172)
%174 = fpext float %170 to double
%175 = fadd double %173, %174
%176 = fptrunc double %175 to float
%177 = load float, float* %161
%178 = tail call double @Fabs(float %177)
%179 = fptrunc double %178 to float
%180 = fcmp oeq float %176, %179
br i1 %180, label %181, label %192
181: ; preds = %171
%182 = getelementptr inbounds float, float* %1, i64 %165
%183 = load float, float* %182
%184 = tail call double @Fabs(float %183)
%185 = fadd double %184, %174
%186 = fptrunc double %185 to float
%187 = load float, float* %182
%188 = tail call double @Fabs(float %187)
%189 = fptrunc double %188 to float
%190 = fcmp oeq float %186, %189
br i1 %190, label %191, label %192
191: ; preds = %181
store float 0.000000e+00, float* %166
br label %258
192: ; preds = %181, %171, %164
%193 = load float, float* %166
%194 = tail call double @Fabs(float %193)
%195 = fcmp ogt double %194, %124
br i1 %195, label %196, label %258
196: ; preds = %192
%197 = getelementptr inbounds float, float* %1, i64 %165
%198 = load float, float* %197
%199 = load float, float* %161
%200 = fsub float %198, %199
%201 = tail call double @Fabs(float %200)
%202 = fpext float %170 to double
%203 = fadd double %201, %202
%204 = fptrunc double %203 to float
%205 = tail call double @Fabs(float %200)
%206 = fptrunc double %205 to float
%207 = fcmp oeq float %204, %206
br i1 %207, label %208, label %211
208: ; preds = %196
%209 = load float, float* %166
%210 = fdiv float %209, %200
br label %230
211: ; preds = %196
%212 = fpext float %200 to double
%213 = fmul double %212, 5.000000e-01
%214 = load float, float* %166
%215 = fpext float %214 to double
%216 = fdiv double %213, %215
%217 = fptrunc double %216 to float
%218 = tail call double @Fabs(float %217)
%219 = fmul float %217, %217
%220 = fpext float %219 to double
%221 = fadd double %220, 1.000000e+00
%222 = fptosi double %221 to i32
%223 = tail call double @sqrt(i32 %222)
%224 = fadd double %218, %223
%225 = fdiv double 1.000000e+00, %224
%226 = fptrunc double %225 to float
%227 = fcmp olt float %217, 0.000000e+00
br i1 %227, label %228, label %230
228: ; preds = %211
%229 = fneg float %226
br label %230
230: ; preds = %211, %228, %208
%231 = phi float [ %210, %208 ], [ %229, %228 ], [ %226, %211 ]
%232 = tail call float @llvm.fmuladd.f32(float %231, float %231, float 1.000000e+00)
%233 = fptosi float %232 to i32
%234 = tail call double @sqrt(i32 %233)
%235 = fdiv double 1.000000e+00, %234
%236 = fptrunc double %235 to float
%237 = fmul float %231, %236
%238 = fpext float %237 to double
%239 = fpext float %236 to double
%240 = fadd double %239, 1.000000e+00
%241 = fdiv double %238, %240
%242 = fptrunc double %241 to float
%243 = load float, float* %166
%244 = fmul float %231, %243
%245 = load float, float* %162
%246 = fsub float %245, %244
store float %246, float* %162
%247 = getelementptr inbounds [128 x float], [128 x float]* %6, i64 0, i64 %165
%248 = load float, float* %247
%249 = fadd float %244, %248
store float %249, float* %247
%250 = load float, float* %161
%251 = fsub float %250, %244
store float %251, float* %161
%252 = load float, float* %197
%253 = fadd float %244, %252
store float %253, float* %197
store float 0.000000e+00, float* %166
%254 = trunc i64 %165 to i32
%255 = tail call i32 @do_rotate(float** %91, float** %92, float %237, float %242, i32 %163, i32 %254)
%256 = load i32, i32* %3
%257 = add nsw i32 %256, 1
store i32 %257, i32* %3
br label %258
258: ; preds = %191, %230, %192
%259 = add nuw nsw i64 %165, 1
%260 = icmp eq i64 %259, 128
br i1 %260, label %125, label %164
261: ; preds = %128
%262 = add nuw nsw i32 %94, 1
%263 = icmp eq i32 %262, 51
br i1 %263, label %264, label %93
264: ; preds = %261, %114
ret void
}