void do_rotate(float a[128][128], float v[128][128], float s, float tau, int ip,
               int iq) {
  float h, g;
  int j;
  for (j = 1; j <= ip - 1; j++) {
    {
      g = a[j][ip];
      h = a[j][iq];
      a[j][ip] = g - s * (h + g * tau);
      a[j][iq] = h + s * (g - h * tau);
    }
  }
  for (j = ip + 1; j <= iq - 1; j++) {
    {
      g = a[ip][j];
      h = a[j][iq];
      a[ip][j] = g - s * (h + g * tau);
      a[j][iq] = h + s * (g - h * tau);
    }
  }
  for (j = iq + 1; j <= 128; j++) {
    {
      g = a[ip][j];
      h = a[iq][j];
      a[ip][j] = g - s * (h + g * tau);
      a[iq][j] = h + s * (g - h * tau);
    }
  }
  for (j = 1; j <= 128; j++) {
    {
      g = v[j][ip];
      h = v[j][iq];
      v[j][ip] = g - s * (h + g * tau);
      v[j][iq] = h + s * (g - h * tau);
    }
  }
}


x86 assembly (clang, -O0):
<do_rotate>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1218 <do_rotate+0x118>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x28(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x24(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
movss  -0x18(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x28(%rbp),%xmm3
movss  -0x24(%rbp),%xmm2
movss  -0x18(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1123 <do_rotate+0x23>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1316 <do_rotate+0x216>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x28(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x24(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
movss  -0x18(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x28(%rbp),%xmm3
movss  -0x24(%rbp),%xmm2
movss  -0x18(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1221 <do_rotate+0x121>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x80,-0x2c(%rbp)
jg     1410 <do_rotate+0x310>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x28(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x24(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
movss  -0x18(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x28(%rbp),%xmm3
movss  -0x24(%rbp),%xmm2
movss  -0x18(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    131f <do_rotate+0x21f>
movl   $0x1,-0x2c(%rbp)
cmpl   $0x80,-0x2c(%rbp)
jg     1508 <do_rotate+0x408>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x28(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x24(%rbp),%xmm3
movss  -0x28(%rbp),%xmm2
movss  -0x18(%rbp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x28(%rbp),%xmm3
movss  -0x24(%rbp),%xmm2
movss  -0x18(%rbp),%xmm4
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1417 <do_rotate+0x317>
pop    %rbp
ret

x86 assembly (clang, -O2):
<do_rotate>:
push   %r15
push   %r14
push   %rbx
mov    %edx,%r8d
cmp    $0x2,%edx
jl     133b <do_rotate+0x23b>
movslq %ecx,%r9
movaps 0xee5(%rip),%xmm2
xorps  %xmm0,%xmm2
mov    %r8d,%r10d
lea    -0x1(%r10),%r15
mov    $0x1,%r11d
cmp    $0x4,%r15
jb     12dc <do_rotate+0x1dc>
lea    -0x2(%r10),%rax
lea    (%rdi,%r9,4),%r14
add    $0x200,%r14
mov    $0x200,%edx
mul    %rdx
lea    (%rdi,%r9,4),%rbx
seto   %dl
add    %rbx,%rax
add    $0x200,%rax
cmp    %r14,%rax
jb     12dc <do_rotate+0x1dc>
test   %dl,%dl
jne    12dc <do_rotate+0x1dc>
lea    (%rdi,%r10,4),%rdx
add    $0x200,%rdx
mov    %r10,%rax
shl    $0x9,%rax
lea    (%rdi,%rax,1),%rbx
lea    (%rbx,%r9,4),%rbx
add    $0xfffffffffffffe04,%rbx
cmp    %rbx,%rdx
jae    11a9 <do_rotate+0xa9>
lea    (%rax,%r10,4),%rax
add    %rdi,%rax
add    $0xfffffffffffffe04,%rax
cmp    %rax,%r14
jb     12dc <do_rotate+0x1dc>
mov    %r15,%r14
and    $0xfffffffffffffffc,%r14
lea    0x1(%r14),%r11
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
movaps %xmm2,%xmm8
shufps $0x0,%xmm2,%xmm8
movaps %xmm0,%xmm9
shufps $0x0,%xmm0,%xmm9
lea    0x800(%rdi),%rdx
mov    %r14,%rax
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%r10,4),%xmm6
movss  -0x200(%rdx,%r10,4),%xmm7
fe ff ff
unpcklps %xmm6,%xmm7
movss  -0x600(%rdx,%r10,4),%xmm6
fa ff ff
movss  -0x400(%rdx,%r10,4),%xmm4
fc ff ff
unpcklps %xmm4,%xmm6
movlhps %xmm7,%xmm6
movss  (%rdx,%r9,4),%xmm4
movss  -0x200(%rdx,%r9,4),%xmm5
fe ff ff
unpcklps %xmm4,%xmm5
movss  -0x600(%rdx,%r9,4),%xmm7
fa ff ff
movss  -0x400(%rdx,%r9,4),%xmm4
fc ff ff
unpcklps %xmm4,%xmm7
movlhps %xmm5,%xmm7
movaps %xmm6,%xmm4
mulps  %xmm3,%xmm4
addps  %xmm7,%xmm4
mulps  %xmm8,%xmm4
addps  %xmm6,%xmm4
movss  %xmm4,-0x600(%rdx,%r10,4)
fa ff ff
movaps %xmm4,%xmm5
shufps $0x55,%xmm4,%xmm5
movss  %xmm5,-0x400(%rdx,%r10,4)
fc ff ff
movaps %xmm4,%xmm5
unpckhpd %xmm4,%xmm5
movss  %xmm5,-0x200(%rdx,%r10,4)
fe ff ff
shufps $0xff,%xmm4,%xmm4
movss  %xmm4,(%rdx,%r10,4)
movaps %xmm7,%xmm4
mulps  %xmm3,%xmm4
subps  %xmm4,%xmm6
mulps  %xmm9,%xmm6
addps  %xmm7,%xmm6
movss  %xmm6,-0x600(%rdx,%r9,4)
fa ff ff
movaps %xmm6,%xmm4
shufps $0x55,%xmm6,%xmm4
movss  %xmm4,-0x400(%rdx,%r9,4)
fc ff ff
movaps %xmm6,%xmm4
unpckhpd %xmm6,%xmm4
movss  %xmm4,-0x200(%rdx,%r9,4)
fe ff ff
shufps $0xff,%xmm6,%xmm6
movss  %xmm6,(%rdx,%r9,4)
add    $0x800,%rdx
add    $0xfffffffffffffffc,%rax
jne    11e0 <do_rotate+0xe0>
cmp    %r14,%r15
je     133b <do_rotate+0x23b>
mov    %r10,%rax
sub    %r11,%rax
shl    $0x9,%r11
add    %rdi,%r11
nopl   0x0(%rax)
movss  (%r11,%r10,4),%xmm3
movss  (%r11,%r9,4),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,(%r11,%r10,4)
movaps %xmm4,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm5,%xmm3
mulss  %xmm0,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,(%r11,%r9,4)
add    $0x200,%r11
add    $0xffffffffffffffff,%rax
jne    12f0 <do_rotate+0x1f0>
lea    -0x1(%rcx),%eax
movslq %r8d,%r9
cmp    %r8d,%eax
jle    13c8 <do_rotate+0x2c8>
movslq %ecx,%rbx
movaps 0xcac(%rip),%xmm2
xorps  %xmm0,%xmm2
movslq %eax,%r8
sub    %r9,%r8
mov    %r9,%rax
shl    $0x9,%rax
lea    (%rax,%r9,4),%rdx
add    %rdi,%rdx
add    $0x4,%rdx
add    %rdi,%rax
lea    (%rax,%rbx,4),%rbx
add    $0x200,%rbx
xor    %eax,%eax
nop
movss  (%rdx,%rax,4),%xmm3
movss  (%rbx),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,(%rdx,%rax,4)
movaps %xmm4,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm5,%xmm3
mulss  %xmm0,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,(%rbx)
add    $0x1,%rax
add    $0x200,%rbx
cmp    %rax,%r8
jne    1380 <do_rotate+0x280>
cmp    $0x80,%ecx
jge    151c <do_rotate+0x41c>
movslq %ecx,%r10
movaps 0xc22(%rip),%xmm2
xorps  %xmm0,%xmm2
mov    $0x80,%r8d
sub    %r10,%r8
mov    %r10,%rdx
cmp    $0x4,%r8
jb     14ad <do_rotate+0x3ad>
lea    0x1(%r10),%rdx
mov    %r9,%rcx
shl    $0x9,%rcx
lea    (%rdi,%rcx,1),%rax
lea    (%rax,%r10,4),%rax
add    $0x4,%rax
mov    %r10,%rbx
shl    $0x9,%rbx
lea    (%rbx,%r10,4),%rbx
add    %rdi,%rbx
add    $0x4,%rbx
shl    $0x9,%rdx
add    %rdi,%rdx
add    $0x4,%rdx
cmp    %rdx,%rax
jae    1442 <do_rotate+0x342>
add    %rdi,%rcx
add    $0x204,%rcx
mov    %r10,%rdx
cmp    %rcx,%rbx
jb     14ad <do_rotate+0x3ad>
mov    %r8,%r11
and    $0xfffffffffffffffc,%r11
lea    (%r11,%r10,1),%rdx
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
movaps %xmm2,%xmm8
shufps $0x0,%xmm2,%xmm8
movaps %xmm0,%xmm5
shufps $0x0,%xmm0,%xmm5
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movups (%rax,%rcx,4),%xmm4
movups (%rbx,%rcx,4),%xmm7
movaps %xmm4,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm7,%xmm6
mulps  %xmm8,%xmm6
addps  %xmm4,%xmm6
movups %xmm6,(%rax,%rcx,4)
movaps %xmm7,%xmm6
mulps  %xmm3,%xmm6
subps  %xmm6,%xmm4
mulps  %xmm5,%xmm4
addps  %xmm7,%xmm4
movups %xmm4,(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    1470 <do_rotate+0x370>
cmp    %r11,%r8
je     1529 <do_rotate+0x429>
mov    %r9,%rax
shl    $0x9,%rax
add    %rdi,%rax
add    $0x4,%rax
mov    %r10,%rcx
shl    $0x9,%rcx
add    %rdi,%rcx
add    $0x4,%rcx
nopl   0x0(%rax)
movss  (%rax,%rdx,4),%xmm3
movss  (%rcx,%rdx,4),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,(%rax,%rdx,4)
movaps %xmm4,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm5,%xmm3
mulss  %xmm0,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,(%rcx,%rdx,4)
lea    0x1(%rdx),%rdi
mov    %rdi,%rdx
cmp    $0x80,%rdi
jne    14d0 <do_rotate+0x3d0>
jmp    1529 <do_rotate+0x429>
mov    %ecx,%r10d
movaps 0xada(%rip),%xmm2
xorps  %xmm0,%xmm2
lea    (%rsi,%r9,4),%rax
add    $0x200,%rax
lea    (%rsi,%r9,4),%rcx
add    $0x10000,%rcx
lea    (%rsi,%r10,4),%rdx
add    $0x200,%rdx
cmp    %rax,%rcx
jb     157e <do_rotate+0x47e>
lea    (%rsi,%r10,4),%rcx
add    $0x10000,%rcx
cmp    %rdx,%rcx
jb     157e <do_rotate+0x47e>
lea    (%rsi,%r10,4),%rcx
add    $0x10004,%rcx
cmp    %rcx,%rax
jae    15cf <do_rotate+0x4cf>
lea    (%rsi,%r9,4),%rcx
add    $0x10004,%rcx
cmp    %rcx,%rdx
jae    15cf <do_rotate+0x4cf>
xor    %ecx,%ecx
movss  (%rax,%rcx,1),%xmm3
movss  (%rdx,%rcx,1),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,(%rax,%rcx,1)
movaps %xmm4,%xmm5
mulss  %xmm1,%xmm5
subss  %xmm5,%xmm3
mulss  %xmm0,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,(%rdx,%rcx,1)
add    $0x200,%rcx
cmp    $0x10000,%rcx
jne    1580 <do_rotate+0x480>
jmp    16e8 <do_rotate+0x5e8>
shufps $0x0,%xmm1,%xmm1
shufps $0x0,%xmm2,%xmm2
shufps $0x0,%xmm0,%xmm0
lea    (%rsi,%r9,4),%rax
add    $0x800,%rax
lea    (%rsi,%r10,4),%rcx
add    $0x800,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rax,%rdx,1),%xmm3
movss  -0x200(%rax,%rdx,1),%xmm4
ff ff
unpcklps %xmm3,%xmm4
movss  -0x600(%rax,%rdx,1),%xmm3
ff ff
movss  -0x400(%rax,%rdx,1),%xmm5
ff ff
unpcklps %xmm5,%xmm3
movlhps %xmm4,%xmm3
movss  (%rcx,%rdx,1),%xmm4
movss  -0x200(%rcx,%rdx,1),%xmm5
ff ff
unpcklps %xmm4,%xmm5
movss  -0x600(%rcx,%rdx,1),%xmm4
ff ff
movss  -0x400(%rcx,%rdx,1),%xmm6
ff ff
unpcklps %xmm6,%xmm4
movlhps %xmm5,%xmm4
movaps %xmm3,%xmm5
mulps  %xmm1,%xmm5
addps  %xmm4,%xmm5
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
movss  %xmm5,-0x600(%rax,%rdx,1)
ff ff
movaps %xmm5,%xmm6
shufps $0x55,%xmm5,%xmm6
movss  %xmm6,-0x400(%rax,%rdx,1)
ff ff
movaps %xmm5,%xmm6
unpckhpd %xmm5,%xmm6
movss  %xmm6,-0x200(%rax,%rdx,1)
ff ff
shufps $0xff,%xmm5,%xmm5
movss  %xmm5,(%rax,%rdx,1)
movaps %xmm4,%xmm5
mulps  %xmm1,%xmm5
subps  %xmm5,%xmm3
mulps  %xmm0,%xmm3
addps  %xmm4,%xmm3
movss  %xmm3,-0x600(%rcx,%rdx,1)
ff ff
movaps %xmm3,%xmm4
shufps $0x55,%xmm3,%xmm4
movss  %xmm4,-0x400(%rcx,%rdx,1)
ff ff
movaps %xmm3,%xmm4
unpckhpd %xmm3,%xmm4
movss  %xmm4,-0x200(%rcx,%rdx,1)
ff ff
shufps $0xff,%xmm3,%xmm3
movss  %xmm3,(%rcx,%rdx,1)
add    $0x800,%rdx
cmp    $0x10000,%rdx
jne    1600 <do_rotate+0x500>
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @do_rotate([128 x float]* %0, [128 x float]* %1, float %2, float %3, i32 %4, i32 %5) {
%7 = alloca [128 x float]*
%8 = alloca [128 x float]*
%9 = alloca float
%10 = alloca float
%11 = alloca i32
%12 = alloca i32
%13 = alloca float
%14 = alloca float
%15 = alloca i32
store [128 x float]* %0, [128 x float]** %7
store [128 x float]* %1, [128 x float]** %8
store float %2, float* %9
store float %3, float* %10
store i32 %4, i32* %11
store i32 %5, i32* %12
store i32 1, i32* %15
br label %16
16: ; preds = %68, %6
%17 = load i32, i32* %15
%18 = load i32, i32* %11
%19 = sub nsw i32 %18, 1
%20 = icmp sle i32 %17, %19
br i1 %20, label %21, label %71
21: ; preds = %16
%22 = load [128 x float]*, [128 x float]** %7
%23 = load i32, i32* %15
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [128 x float], [128 x float]* %22, i64 %24
%26 = load i32, i32* %11
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [128 x float], [128 x float]* %25, i64 0, i64 %27
%29 = load float, float* %28
store float %29, float* %14
%30 = load [128 x float]*, [128 x float]** %7
%31 = load i32, i32* %15
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [128 x float], [128 x float]* %30, i64 %32
%34 = load i32, i32* %12
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [128 x float], [128 x float]* %33, i64 0, i64 %35
%37 = load float, float* %36
store float %37, float* %13
%38 = load float, float* %14
%39 = load float, float* %9
%40 = load float, float* %13
%41 = load float, float* %14
%42 = load float, float* %10
%43 = call float @llvm.fmuladd.f32(float %41, float %42, float %40)
%44 = fneg float %39
%45 = call float @llvm.fmuladd.f32(float %44, float %43, float %38)
%46 = load [128 x float]*, [128 x float]** %7
%47 = load i32, i32* %15
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [128 x float], [128 x float]* %46, i64 %48
%50 = load i32, i32* %11
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [128 x float], [128 x float]* %49, i64 0, i64 %51
store float %45, float* %52
%53 = load float, float* %13
%54 = load float, float* %9
%55 = load float, float* %14
%56 = load float, float* %13
%57 = load float, float* %10
%58 = fneg float %56
%59 = call float @llvm.fmuladd.f32(float %58, float %57, float %55)
%60 = call float @llvm.fmuladd.f32(float %54, float %59, float %53)
%61 = load [128 x float]*, [128 x float]** %7
%62 = load i32, i32* %15
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [128 x float], [128 x float]* %61, i64 %63
%65 = load i32, i32* %12
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [128 x float], [128 x float]* %64, i64 0, i64 %66
store float %60, float* %67
br label %68
68: ; preds = %21
%69 = load i32, i32* %15
%70 = add nsw i32 %69, 1
store i32 %70, i32* %15
br label %16
71: ; preds = %16
%72 = load i32, i32* %11
%73 = add nsw i32 %72, 1
store i32 %73, i32* %15
br label %74
74: ; preds = %126, %71
%75 = load i32, i32* %15
%76 = load i32, i32* %12
%77 = sub nsw i32 %76, 1
%78 = icmp sle i32 %75, %77
br i1 %78, label %79, label %129
79: ; preds = %74
%80 = load [128 x float]*, [128 x float]** %7
%81 = load i32, i32* %11
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [128 x float], [128 x float]* %80, i64 %82
%84 = load i32, i32* %15
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [128 x float], [128 x float]* %83, i64 0, i64 %85
%87 = load float, float* %86
store float %87, float* %14
%88 = load [128 x float]*, [128 x float]** %7
%89 = load i32, i32* %15
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [128 x float], [128 x float]* %88, i64 %90
%92 = load i32, i32* %12
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [128 x float], [128 x float]* %91, i64 0, i64 %93
%95 = load float, float* %94
store float %95, float* %13
%96 = load float, float* %14
%97 = load float, float* %9
%98 = load float, float* %13
%99 = load float, float* %14
%100 = load float, float* %10
%101 = call float @llvm.fmuladd.f32(float %99, float %100, float %98)
%102 = fneg float %97
%103 = call float @llvm.fmuladd.f32(float %102, float %101, float %96)
%104 = load [128 x float]*, [128 x float]** %7
%105 = load i32, i32* %11
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [128 x float], [128 x float]* %104, i64 %106
%108 = load i32, i32* %15
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [128 x float], [128 x float]* %107, i64 0, i64 %109
store float %103, float* %110
%111 = load float, float* %13
%112 = load float, float* %9
%113 = load float, float* %14
%114 = load float, float* %13
%115 = load float, float* %10
%116 = fneg float %114
%117 = call float @llvm.fmuladd.f32(float %116, float %115, float %113)
%118 = call float @llvm.fmuladd.f32(float %112, float %117, float %111)
%119 = load [128 x float]*, [128 x float]** %7
%120 = load i32, i32* %15
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [128 x float], [128 x float]* %119, i64 %121
%123 = load i32, i32* %12
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [128 x float], [128 x float]* %122, i64 0, i64 %124
store float %118, float* %125
br label %126
126: ; preds = %79
%127 = load i32, i32* %15
%128 = add nsw i32 %127, 1
store i32 %128, i32* %15
br label %74
129: ; preds = %74
%130 = load i32, i32* %12
%131 = add nsw i32 %130, 1
store i32 %131, i32* %15
br label %132
132: ; preds = %182, %129
%133 = load i32, i32* %15
%134 = icmp sle i32 %133, 128
br i1 %134, label %135, label %185
135: ; preds = %132
%136 = load [128 x float]*, [128 x float]** %7
%137 = load i32, i32* %11
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [128 x float], [128 x float]* %136, i64 %138
%140 = load i32, i32* %15
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [128 x float], [128 x float]* %139, i64 0, i64 %141
%143 = load float, float* %142
store float %143, float* %14
%144 = load [128 x float]*, [128 x float]** %7
%145 = load i32, i32* %12
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [128 x float], [128 x float]* %144, i64 %146
%148 = load i32, i32* %15
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [128 x float], [128 x float]* %147, i64 0, i64 %149
%151 = load float, float* %150
store float %151, float* %13
%152 = load float, float* %14
%153 = load float, float* %9
%154 = load float, float* %13
%155 = load float, float* %14
%156 = load float, float* %10
%157 = call float @llvm.fmuladd.f32(float %155, float %156, float %154)
%158 = fneg float %153
%159 = call float @llvm.fmuladd.f32(float %158, float %157, float %152)
%160 = load [128 x float]*, [128 x float]** %7
%161 = load i32, i32* %11
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds [128 x float], [128 x float]* %160, i64 %162
%164 = load i32, i32* %15
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [128 x float], [128 x float]* %163, i64 0, i64 %165
store float %159, float* %166
%167 = load float, float* %13
%168 = load float, float* %9
%169 = load float, float* %14
%170 = load float, float* %13
%171 = load float, float* %10
%172 = fneg float %170
%173 = call float @llvm.fmuladd.f32(float %172, float %171, float %169)
%174 = call float @llvm.fmuladd.f32(float %168, float %173, float %167)
%175 = load [128 x float]*, [128 x float]** %7
%176 = load i32, i32* %12
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds [128 x float], [128 x float]* %175, i64 %177
%179 = load i32, i32* %15
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [128 x float], [128 x float]* %178, i64 0, i64 %180
store float %174, float* %181
br label %182
182: ; preds = %135
%183 = load i32, i32* %15
%184 = add nsw i32 %183, 1
store i32 %184, i32* %15
br label %132
185: ; preds = %132
store i32 1, i32* %15
br label %186
186: ; preds = %236, %185
%187 = load i32, i32* %15
%188 = icmp sle i32 %187, 128
br i1 %188, label %189, label %239
189: ; preds = %186
%190 = load [128 x float]*, [128 x float]** %8
%191 = load i32, i32* %15
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds [128 x float], [128 x float]* %190, i64 %192
%194 = load i32, i32* %11
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [128 x float], [128 x float]* %193, i64 0, i64 %195
%197 = load float, float* %196
store float %197, float* %14
%198 = load [128 x float]*, [128 x float]** %8
%199 = load i32, i32* %15
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [128 x float], [128 x float]* %198, i64 %200
%202 = load i32, i32* %12
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds [128 x float], [128 x float]* %201, i64 0, i64 %203
%205 = load float, float* %204
store float %205, float* %13
%206 = load float, float* %14
%207 = load float, float* %9
%208 = load float, float* %13
%209 = load float, float* %14
%210 = load float, float* %10
%211 = call float @llvm.fmuladd.f32(float %209, float %210, float %208)
%212 = fneg float %207
%213 = call float @llvm.fmuladd.f32(float %212, float %211, float %206)
%214 = load [128 x float]*, [128 x float]** %8
%215 = load i32, i32* %15
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [128 x float], [128 x float]* %214, i64 %216
%218 = load i32, i32* %11
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds [128 x float], [128 x float]* %217, i64 0, i64 %219
store float %213, float* %220
%221 = load float, float* %13
%222 = load float, float* %9
%223 = load float, float* %14
%224 = load float, float* %13
%225 = load float, float* %10
%226 = fneg float %224
%227 = call float @llvm.fmuladd.f32(float %226, float %225, float %223)
%228 = call float @llvm.fmuladd.f32(float %222, float %227, float %221)
%229 = load [128 x float]*, [128 x float]** %8
%230 = load i32, i32* %15
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds [128 x float], [128 x float]* %229, i64 %231
%233 = load i32, i32* %12
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [128 x float], [128 x float]* %232, i64 0, i64 %234
store float %228, float* %235
br label %236
236: ; preds = %189
%237 = load i32, i32* %15
%238 = add nsw i32 %237, 1
store i32 %238, i32* %15
br label %186
239: ; preds = %186
ret void
}

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