void __attribute__((no)) h264(float (*X)[28], float (*H)[28], float (*K)[16],
                              float (*Y)[16], float (*output)[16]) {
  int i, j;
  for (i = 0; i <= 24; i++) {
#pragma omp simd
    for (j = 0; j <= 24; j++) {
      X[i][j] = 3.141592653589793238462643f * j;
    }
  }
  for (i = 0; i <= 14; i++) {
#pragma omp simd
    for (j = 0; j <= 24; j++) {
      H[i][j] = (X[i][j] + 2.0f * X[i + 1][j] + 4.0f * X[i + 2][j] +
                 4.0f * X[i + 3][j] + 2.0f * X[i + 4][j] + X[i + 5][j]) /
                14.0f;
    }
  }
  for (i = 0; i <= 14; i++) {
    for (j = 0; j <= 14; j++) {
      K[i][j] = (H[i][j] + 2.0f * H[i][j + 1] + 4.0f * H[i][j + 2] +
                 4.0f * H[i][j + 3] + 2.0f * H[i][j + 4] + H[i][j + 5]) /
                14.0f;
    }
  }
  for (i = 0; i <= 14; i++) {
#pragma omp simd
    for (j = 0; j <= 14; j++) {
      Y[i][j] = K[i][j] + H[i][j];
    }
  }
  for (i = 0; i <= 14; i++) {
#pragma omp simd
    for (j = 0; j <= 14; j++) {
      output[i][j] = Y[i][j];
    }
  }
}


x86 assembly (clang, -O0):
<h264>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x18,-0x2c(%rbp)
jg     1184 <h264+0x84>
movl   $0x0,-0x30(%rbp)
cmpl   $0x18,-0x30(%rbp)
jg     1171 <h264+0x71>
cvtsi2ssl -0x30(%rbp),%xmm1
movss  0xec1(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1130 <h264+0x30>
jmp    1176 <h264+0x76>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    111f <h264+0x1f>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xe,-0x2c(%rbp)
jg     12c4 <h264+0x1c4>
movl   $0x0,-0x30(%rbp)
cmpl   $0x18,-0x30(%rbp)
jg     12b1 <h264+0x1b1>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
addss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0xdfc(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0xdcf(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  0xd79(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    119c <h264+0x9c>
jmp    12b6 <h264+0x1b6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    118b <h264+0x8b>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xe,-0x2c(%rbp)
jg     1404 <h264+0x304>
movl   $0x0,-0x30(%rbp)
cmpl   $0xe,-0x30(%rbp)
jg     13f1 <h264+0x2f1>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
addss  %xmm1,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  0xcbc(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0xc8f(%rip),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  0xc39(%rip),%xmm1
divss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12dc <h264+0x1dc>
jmp    13f6 <h264+0x2f6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12cb <h264+0x1cb>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xe,-0x2c(%rbp)
jg     148f <h264+0x38f>
movl   $0x0,-0x30(%rbp)
cmpl   $0xe,-0x30(%rbp)
jg     147c <h264+0x37c>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    141c <h264+0x31c>
jmp    1481 <h264+0x381>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    140b <h264+0x30b>
movl   $0x0,-0x2c(%rbp)
cmpl   $0xe,-0x2c(%rbp)
jg     1502 <h264+0x402>
movl   $0x0,-0x30(%rbp)
cmpl   $0xe,-0x30(%rbp)
jg     14ef <h264+0x3ef>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14a7 <h264+0x3a7>
jmp    14f4 <h264+0x3f4>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1496 <h264+0x396>
pop    %rbp
ret

x86 assembly (clang, -O2):
<h264>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    $0x60,%eax
movaps 0xeea(%rip),%xmm0
movaps 0xef3(%rip),%xmm1
movaps 0xefc(%rip),%xmm2
movaps 0xf05(%rip),%xmm3
movaps 0xf0e(%rip),%xmm4
movaps 0xf17(%rip),%xmm5
nopl   0x0(%rax)
movups %xmm0,-0x60(%rdi,%rax,1)
movups %xmm1,-0x50(%rdi,%rax,1)
movups %xmm2,-0x40(%rdi,%rax,1)
movups %xmm3,-0x30(%rdi,%rax,1)
movups %xmm4,-0x20(%rdi,%rax,1)
movups %xmm5,-0x10(%rdi,%rax,1)
movl   $0x4296cbe4,(%rdi,%rax,1)
add    $0x70,%rax
cmp    $0xb50,%rax
jne    1140 <h264+0x40>
lea    0x150(%rdi),%rax
xor    %ebp,%ebp
movss  0xefe(%rip),%xmm0
movss  0xefa(%rip),%xmm1
movaps 0xecf(%rip),%xmm2
movaps 0xed8(%rip),%xmm3
mov    %rsi,%r9
nopl   0x0(%rax,%rax,1)
lea    0x1(%rbp),%r10
imul   $0x70,%rbp,%r11
lea    (%rdi,%r11,1),%r14
add    $0x294,%r14
lea    (%rsi,%r11,1),%rbx
cmp    %r14,%rbx
jae    11e0 <h264+0xe0>
lea    (%rdi,%r11,1),%r14
lea    (%rsi,%r11,1),%rbx
add    $0x64,%rbx
cmp    %rbx,%r14
jae    11e0 <h264+0xe0>
xor    %ebx,%ebx
jmp    13b0 <h264+0x2b0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x2(%rbp),%rbx
lea    0x3(%rbp),%r12
lea    0x4(%rbp),%r13
add    $0x5,%rbp
movups (%rdi,%r11,1),%xmm4
imul   $0x70,%r10,%r14
movups (%rdi,%r14,1),%xmm5
addps  %xmm5,%xmm5
addps  %xmm4,%xmm5
imul   $0x70,%rbx,%r15
movups (%rdi,%r15,1),%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
imul   $0x70,%r12,%r12
movups (%rdi,%r12,1),%xmm5
mulps  %xmm2,%xmm5
addps  %xmm4,%xmm5
imul   $0x70,%r13,%r13
movups (%rdi,%r13,1),%xmm4
addps  %xmm4,%xmm4
addps  %xmm5,%xmm4
imul   $0x70,%rbp,%rbx
movups (%rdi,%rbx,1),%xmm5
addps  %xmm4,%xmm5
divps  %xmm3,%xmm5
movups %xmm5,(%rsi,%r11,1)
movups 0x10(%rdi,%r11,1),%xmm4
movups 0x10(%rdi,%r14,1),%xmm5
addps  %xmm5,%xmm5
addps  %xmm4,%xmm5
movups 0x10(%rdi,%r15,1),%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
movups 0x10(%rdi,%r12,1),%xmm5
mulps  %xmm2,%xmm5
addps  %xmm4,%xmm5
movups 0x10(%rdi,%r13,1),%xmm4
addps  %xmm4,%xmm4
addps  %xmm5,%xmm4
movups 0x10(%rdi,%rbx,1),%xmm5
addps  %xmm4,%xmm5
divps  %xmm3,%xmm5
movups %xmm5,0x10(%rsi,%r11,1)
movups 0x20(%rdi,%r11,1),%xmm4
movups 0x20(%rdi,%r14,1),%xmm5
addps  %xmm5,%xmm5
addps  %xmm4,%xmm5
movups 0x20(%rdi,%r15,1),%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
movups 0x20(%rdi,%r12,1),%xmm5
mulps  %xmm2,%xmm5
addps  %xmm4,%xmm5
movups 0x20(%rdi,%r13,1),%xmm4
addps  %xmm4,%xmm4
addps  %xmm5,%xmm4
movups 0x20(%rdi,%rbx,1),%xmm5
addps  %xmm4,%xmm5
divps  %xmm3,%xmm5
movups %xmm5,0x20(%rsi,%r11,1)
movups 0x30(%rdi,%r11,1),%xmm4
movups 0x30(%rdi,%r14,1),%xmm5
addps  %xmm5,%xmm5
addps  %xmm4,%xmm5
movups 0x30(%rdi,%r15,1),%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
movups 0x30(%rdi,%r12,1),%xmm5
mulps  %xmm2,%xmm5
addps  %xmm4,%xmm5
movups 0x30(%rdi,%r13,1),%xmm4
addps  %xmm4,%xmm4
addps  %xmm5,%xmm4
movups 0x30(%rdi,%rbx,1),%xmm5
addps  %xmm4,%xmm5
divps  %xmm3,%xmm5
movups %xmm5,0x30(%rsi,%r11,1)
movups 0x40(%rdi,%r11,1),%xmm4
movups 0x40(%rdi,%r14,1),%xmm5
addps  %xmm5,%xmm5
addps  %xmm4,%xmm5
movups 0x40(%rdi,%r15,1),%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
movups 0x40(%rdi,%r12,1),%xmm5
mulps  %xmm2,%xmm5
addps  %xmm4,%xmm5
movups 0x40(%rdi,%r13,1),%xmm4
addps  %xmm4,%xmm4
addps  %xmm5,%xmm4
movups 0x40(%rdi,%rbx,1),%xmm5
addps  %xmm4,%xmm5
divps  %xmm3,%xmm5
movups %xmm5,0x40(%rsi,%r11,1)
movups 0x50(%rdi,%r11,1),%xmm4
movups 0x50(%rdi,%r14,1),%xmm5
addps  %xmm5,%xmm5
addps  %xmm4,%xmm5
movups 0x50(%rdi,%r15,1),%xmm4
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
movups 0x50(%rdi,%r12,1),%xmm5
mulps  %xmm2,%xmm5
addps  %xmm4,%xmm5
movups 0x50(%rdi,%r13,1),%xmm4
addps  %xmm4,%xmm4
addps  %xmm5,%xmm4
movups 0x50(%rdi,%rbx,1),%xmm5
addps  %xmm4,%xmm5
divps  %xmm3,%xmm5
movups %xmm5,0x50(%rsi,%r11,1)
mov    $0x18,%ebx
nopl   0x0(%rax)
movss  -0xe0(%rax,%rbx,4),%xmm4
ff ff
movss  0x70(%rax,%rbx,4),%xmm5
addss  %xmm4,%xmm4
addss  -0x150(%rax,%rbx,4),%xmm4
ff ff
movss  -0x70(%rax,%rbx,4),%xmm6
mulss  %xmm0,%xmm6
addss  %xmm4,%xmm6
movss  (%rax,%rbx,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm6,%xmm4
addss  %xmm5,%xmm5
addss  %xmm4,%xmm5
addss  0xe0(%rax,%rbx,4),%xmm5
divss  %xmm1,%xmm5
movss  %xmm5,(%r9,%rbx,4)
add    $0x1,%rbx
cmp    $0x19,%rbx
jne    13b0 <h264+0x2b0>
add    $0x70,%r9
add    $0x70,%rax
mov    %r10,%rbp
cmp    $0xf,%r10
jne    11a0 <h264+0xa0>
lea    0x14(%rsi),%rax
xor    %r9d,%r9d
mov    %rdx,%rbx
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x10(%rax,%rdi,4),%xmm2
movss  -0x4(%rax,%rdi,4),%xmm3
addss  %xmm2,%xmm2
addss  -0x14(%rax,%rdi,4),%xmm2
movss  -0xc(%rax,%rdi,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm2,%xmm4
movss  -0x8(%rax,%rdi,4),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm4,%xmm2
addss  %xmm3,%xmm3
addss  %xmm2,%xmm3
addss  (%rax,%rdi,4),%xmm3
divss  %xmm1,%xmm3
movss  %xmm3,(%rbx,%rdi,4)
lea    0x1(%rdi),%rbp
mov    %rbp,%rdi
cmp    $0xf,%rbp
jne    1440 <h264+0x340>
add    $0x1,%r9
add    $0x70,%rax
add    $0x40,%rbx
cmp    $0xf,%r9
jne    1430 <h264+0x330>
add    $0x38,%rsi
mov    $0x38,%eax
movss  -0x38(%rdx,%rax,1),%xmm0
addss  -0x38(%rsi),%xmm0
movss  %xmm0,-0x38(%rcx,%rax,1)
movss  -0x34(%rdx,%rax,1),%xmm0
addss  -0x34(%rsi),%xmm0
movss  %xmm0,-0x34(%rcx,%rax,1)
movss  -0x30(%rdx,%rax,1),%xmm0
addss  -0x30(%rsi),%xmm0
movss  %xmm0,-0x30(%rcx,%rax,1)
movss  -0x2c(%rdx,%rax,1),%xmm0
addss  -0x2c(%rsi),%xmm0
movss  %xmm0,-0x2c(%rcx,%rax,1)
movss  -0x28(%rdx,%rax,1),%xmm0
addss  -0x28(%rsi),%xmm0
movss  %xmm0,-0x28(%rcx,%rax,1)
movss  -0x24(%rdx,%rax,1),%xmm0
addss  -0x24(%rsi),%xmm0
movss  %xmm0,-0x24(%rcx,%rax,1)
movss  -0x20(%rdx,%rax,1),%xmm0
addss  -0x20(%rsi),%xmm0
movss  %xmm0,-0x20(%rcx,%rax,1)
movss  -0x1c(%rdx,%rax,1),%xmm0
addss  -0x1c(%rsi),%xmm0
movss  %xmm0,-0x1c(%rcx,%rax,1)
movss  -0x18(%rdx,%rax,1),%xmm0
addss  -0x18(%rsi),%xmm0
movss  %xmm0,-0x18(%rcx,%rax,1)
movss  -0x14(%rdx,%rax,1),%xmm0
addss  -0x14(%rsi),%xmm0
movss  %xmm0,-0x14(%rcx,%rax,1)
movss  -0x10(%rdx,%rax,1),%xmm0
addss  -0x10(%rsi),%xmm0
movss  %xmm0,-0x10(%rcx,%rax,1)
movss  -0xc(%rdx,%rax,1),%xmm0
addss  -0xc(%rsi),%xmm0
movss  %xmm0,-0xc(%rcx,%rax,1)
movss  -0x8(%rdx,%rax,1),%xmm0
addss  -0x8(%rsi),%xmm0
movss  %xmm0,-0x8(%rcx,%rax,1)
movss  -0x4(%rdx,%rax,1),%xmm0
addss  -0x4(%rsi),%xmm0
movss  %xmm0,-0x4(%rcx,%rax,1)
movss  (%rdx,%rax,1),%xmm0
addss  (%rsi),%xmm0
movss  %xmm0,(%rcx,%rax,1)
add    $0x40,%rax
add    $0x70,%rsi
cmp    $0x3f8,%rax
jne    14b0 <h264+0x3b0>
mov    $0x38,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x38(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x38(%r8,%rax,1)
movss  -0x34(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x34(%r8,%rax,1)
movss  -0x30(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x30(%r8,%rax,1)
movss  -0x2c(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x2c(%r8,%rax,1)
movss  -0x28(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x28(%r8,%rax,1)
movss  -0x24(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x24(%r8,%rax,1)
movss  -0x20(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x20(%r8,%rax,1)
movss  -0x1c(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x1c(%r8,%rax,1)
movss  -0x18(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x18(%r8,%rax,1)
movss  -0x14(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x14(%r8,%rax,1)
movss  -0x10(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x10(%r8,%rax,1)
movss  -0xc(%rcx,%rax,1),%xmm0
movss  %xmm0,-0xc(%r8,%rax,1)
movss  -0x8(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x8(%r8,%rax,1)
movss  -0x4(%rcx,%rax,1),%xmm0
movss  %xmm0,-0x4(%r8,%rax,1)
movss  (%rcx,%rax,1),%xmm0
movss  %xmm0,(%r8,%rax,1)
add    $0x40,%rax
cmp    $0x3f8,%rax
jne    15d0 <h264+0x4d0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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