#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float sqrt(float);
float initialize(float data[][12 + 1], int num_frames, float *noise,
                 float tilt[], float speech_threshold, float codebook[][12 + 1],
                 float *prob, float var[][12 + 1], int ncodes) {
  float noise_ceiling, min, speech_power, codemean[12 + 1], localprob[256];
  int i, j, noise_frames, speech_frames;
  for (j = 1; j <= 12; j++)
    tilt[j] = 0.0;
  for (i = 0; i < ncodes; ++i) {
    localprob[i] = 1.0;
    for (j = 0; j <= 12; ++j)
      localprob[i] *= var[i][j];
    localprob[i] = prob[i] * sqrt(localprob[i]);
  }
  for (j = 0; j <= 12; ++j) {
    tilt[j] = 0;
    codemean[j] = 0;
    for (i = 0; i < ncodes; ++i)
      codemean[j] += localprob[i] * codebook[i][j];
  }
  for (i = 0; i < num_frames; ++i)
    for (j = 0; j <= 12; ++j)
      tilt[j] += data[i][j];
  for (j = 0; j <= 12; ++j)
    tilt[j] = tilt[j] / (float)num_frames - codemean[j];
  min = data[0][0];
  for (i = 0; i < num_frames; i++)
    if (data[i][0] < min)
      min = data[i][0];
  noise_ceiling = speech_threshold + min;
  noise_frames = 0;
  speech_frames = 0;
  speech_power = 0;
  for (j = 0; j <= 12; j++)
    noise[j] = 0.0;
  for (i = 0; i < num_frames; i++) {
    if (data[i][0] < noise_ceiling) {
      noise_frames++;
      for (j = 0; j <= 12; j++)
        noise[j] += data[i][j];
    } else {
      speech_frames++;
      speech_power += data[i][0];
    }
  }
  for (j = 0; j <= 12; j++)
    noise[j] /= noise_frames;
  speech_power /= speech_frames;
  return (speech_power);
}


x86 assembly (clang, -O0):
<initialize>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4a0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x1,-0x488(%rbp)
cmpl   $0xc,-0x488(%rbp)
jg     117c <initialize+0x6c>
mov    -0x20(%rbp),%rax
movslq -0x488(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x488(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x488(%rbp)
jmp    1148 <initialize+0x38>
movl   $0x0,-0x484(%rbp)
mov    -0x484(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    126f <initialize+0x15f>
movslq -0x484(%rbp),%rax
movss  0xe5c(%rip),%xmm0
movss  %xmm0,-0x480(%rbp,%rax,4)
ff ff
movl   $0x0,-0x488(%rbp)
cmpl   $0xc,-0x488(%rbp)
jg     120f <initialize+0xff>
mov    0x10(%rbp),%rax
movslq -0x484(%rbp),%rcx
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq -0x488(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x484(%rbp),%rax
mulss  -0x480(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x480(%rbp,%rax,4)
ff ff
mov    -0x488(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x488(%rbp)
jmp    11b7 <initialize+0xa7>
mov    -0x38(%rbp),%rax
movslq -0x484(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x494(%rbp)
ff
movslq -0x484(%rbp),%rax
movss  -0x480(%rbp,%rax,4),%xmm0
ff ff
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x494(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
movslq -0x484(%rbp),%rax
movss  %xmm0,-0x480(%rbp,%rax,4)
ff ff
mov    -0x484(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x484(%rbp)
jmp    1186 <initialize+0x76>
movl   $0x0,-0x488(%rbp)
cmpl   $0xc,-0x488(%rbp)
jg     1338 <initialize+0x228>
mov    -0x20(%rbp),%rax
movslq -0x488(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq -0x488(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp,%rax,4)
movl   $0x0,-0x484(%rbp)
mov    -0x484(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    131f <initialize+0x20f>
movslq -0x484(%rbp),%rax
movss  -0x480(%rbp,%rax,4),%xmm0
ff ff
mov    -0x30(%rbp),%rax
movslq -0x484(%rbp),%rcx
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq -0x488(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movslq -0x488(%rbp),%rax
movss  -0x80(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp,%rax,4)
mov    -0x484(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x484(%rbp)
jmp    12b3 <initialize+0x1a3>
jmp    1324 <initialize+0x214>
mov    -0x488(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x488(%rbp)
jmp    1279 <initialize+0x169>
movl   $0x0,-0x484(%rbp)
mov    -0x484(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13c8 <initialize+0x2b8>
movl   $0x0,-0x488(%rbp)
cmpl   $0xc,-0x488(%rbp)
jg     13af <initialize+0x29f>
mov    -0x8(%rbp),%rax
movslq -0x484(%rbp),%rcx
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq -0x488(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x488(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x488(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x488(%rbp)
jmp    135b <initialize+0x24b>
jmp    13b4 <initialize+0x2a4>
mov    -0x484(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x484(%rbp)
jmp    1342 <initialize+0x232>
movl   $0x0,-0x488(%rbp)
cmpl   $0xc,-0x488(%rbp)
jg     1429 <initialize+0x319>
mov    -0x20(%rbp),%rax
movslq -0x488(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0xc(%rbp),%xmm1
divss  %xmm1,%xmm0
movslq -0x488(%rbp),%rax
subss  -0x80(%rbp,%rax,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x488(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x488(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x488(%rbp)
jmp    13d2 <initialize+0x2c2>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0x484(%rbp)
mov    -0x484(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14a7 <initialize+0x397>
mov    -0x8(%rbp),%rax
movslq -0x484(%rbp),%rcx
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movss  (%rax),%xmm1
movss  -0x40(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    148e <initialize+0x37e>
mov    -0x8(%rbp),%rax
movslq -0x484(%rbp),%rcx
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
jmp    1493 <initialize+0x383>
mov    -0x484(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x484(%rbp)
jmp    1440 <initialize+0x330>
movss  -0x24(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x48c(%rbp)
movl   $0x0,-0x490(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x488(%rbp)
cmpl   $0xc,-0x488(%rbp)
jg     1510 <initialize+0x400>
mov    -0x18(%rbp),%rax
movslq -0x488(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x488(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x488(%rbp)
jmp    14dc <initialize+0x3cc>
movl   $0x0,-0x484(%rbp)
mov    -0x484(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1607 <initialize+0x4f7>
mov    -0x8(%rbp),%rax
movslq -0x484(%rbp),%rcx
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movss  (%rax),%xmm1
movss  -0x3c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    15bf <initialize+0x4af>
mov    -0x48c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48c(%rbp)
movl   $0x0,-0x488(%rbp)
cmpl   $0xc,-0x488(%rbp)
jg     15ba <initialize+0x4aa>
mov    -0x8(%rbp),%rax
movslq -0x484(%rbp),%rcx
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movslq -0x488(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x488(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x488(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x488(%rbp)
jmp    1566 <initialize+0x456>
jmp    15ee <initialize+0x4de>
mov    -0x490(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x490(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x484(%rbp),%rcx
imul   $0x34,%rcx,%rcx
add    %rcx,%rax
movss  (%rax),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
jmp    15f3 <initialize+0x4e3>
mov    -0x484(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x484(%rbp)
jmp    151a <initialize+0x40a>
movl   $0x0,-0x488(%rbp)
cmpl   $0xc,-0x488(%rbp)
jg     1653 <initialize+0x543>
cvtsi2ssl -0x48c(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x488(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x488(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x488(%rbp)
jmp    1611 <initialize+0x501>
cvtsi2ssl -0x490(%rbp),%xmm1
ff
movss  -0x44(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm0
add    $0x4a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<initialize>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x468,%rsp
mov    %r8,%rbx
movss  %xmm0,0xc(%rsp)
mov    %rcx,%rbp
mov    %rdx,(%rsp)
mov    %esi,0x10(%rsp)
mov    %rdi,0x18(%rsp)
mov    0x4a8(%rsp),%eax
xorps  %xmm0,%xmm0
movups %xmm0,0x24(%rcx)
movups %xmm0,0x14(%rcx)
movups %xmm0,0x4(%rcx)
mov    %eax,%r15d
test   %eax,%eax
jle    120e <initialize+0xfe>
mov    %r9,%r12
mov    0x4a0(%rsp),%r14
add    $0x30,%r14
xor    %r13d,%r13d
xorps  %xmm1,%xmm1
jmp    11ac <initialize+0x9c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  %xmm2,0x14(%rsp)
call   1030 <sqrt@plt>
movss  0x14(%rsp),%xmm2
xorps  %xmm1,%xmm1
mulss  %xmm0,%xmm2
movss  %xmm2,0x60(%rsp,%r13,4)
add    $0x1,%r13
add    $0x34,%r14
cmp    %r13,%r15
je     120e <initialize+0xfe>
movss  -0x2c(%r14),%xmm0
mulss  -0x30(%r14),%xmm0
mulss  -0x28(%r14),%xmm0
mulss  -0x24(%r14),%xmm0
mulss  -0x20(%r14),%xmm0
mulss  -0x1c(%r14),%xmm0
mulss  -0x18(%r14),%xmm0
mulss  -0x14(%r14),%xmm0
mulss  -0x10(%r14),%xmm0
mulss  -0xc(%r14),%xmm0
mulss  -0x8(%r14),%xmm0
mulss  -0x4(%r14),%xmm0
mulss  (%r14),%xmm0
movss  (%r12,%r13,4),%xmm2
ucomiss %xmm1,%xmm0
jb     1180 <initialize+0x70>
sqrtss %xmm0,%xmm0
jmp    1194 <initialize+0x84>
lea    -0x1(%r15),%r8
mov    %r15d,%ecx
and    $0x3,%ecx
and    $0xfffffffc,%r15d
xor    %edx,%edx
mov    0x10(%rsp),%r9d
mov    0x4a8(%rsp),%r10d
jmp    1248 <initialize+0x138>
nopl   (%rax)
movss  %xmm0,0x20(%rsp,%rdx,4)
add    $0x1,%rdx
add    $0x4,%rbx
cmp    $0xd,%rdx
je     130f <initialize+0x1ff>
movl   $0x0,0x0(%rbp,%rdx,4)
movl   $0x0,0x20(%rsp,%rdx,4)
test   %r10d,%r10d
jle    1236 <initialize+0x126>
xorps  %xmm0,%xmm0
cmp    $0x3,%r8
jae    1270 <initialize+0x160>
xor    %esi,%esi
jmp    12ce <initialize+0x1be>
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x60(%rsp,%rsi,4),%xmm1
mulss  (%rdi),%xmm1
movss  0x64(%rsp,%rsi,4),%xmm2
addss  %xmm0,%xmm1
mulss  0x34(%rdi),%xmm2
addss  %xmm1,%xmm2
movss  0x68(%rsp,%rsi,4),%xmm1
mulss  0x68(%rdi),%xmm1
addss  %xmm2,%xmm1
movss  0x6c(%rsp,%rsi,4),%xmm0
mulss  0x9c(%rdi),%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rsi
add    $0xd0,%rdi
cmp    %rsi,%r15
jne    1280 <initialize+0x170>
test   %rcx,%rcx
je     1230 <initialize+0x120>
imul   $0x34,%rsi,%rdi
add    %rbx,%rdi
lea    (%rsp,%rsi,4),%rsi
add    $0x60,%rsi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rax,4),%xmm1
mulss  (%rdi),%xmm1
addss  %xmm1,%xmm0
add    $0x1,%rax
add    $0x34,%rdi
cmp    %rax,%rcx
jne    12f0 <initialize+0x1e0>
jmp    1230 <initialize+0x120>
mov    %r9d,%r8d
test   %r9d,%r9d
jle    1438 <initialize+0x328>
movss  0x0(%rbp),%xmm9
movss  0x4(%rbp),%xmm12
movss  0x8(%rbp),%xmm4
movss  0xc(%rbp),%xmm6
movss  0x10(%rbp),%xmm10
movss  0x14(%rbp),%xmm3
movss  0x18(%rbp),%xmm7
movss  0x1c(%rbp),%xmm0
movss  0x20(%rbp),%xmm11
movss  0x24(%rbp),%xmm2
movss  0x28(%rbp),%xmm1
movss  0x2c(%rbp),%xmm5
movss  0x30(%rbp),%xmm8
imul   $0x34,%r8,%rax
xor    %edx,%edx
mov    0x18(%rsp),%rcx
nopl   0x0(%rax)
addss  (%rcx,%rdx,1),%xmm9
movss  %xmm9,0x0(%rbp)
addss  0x4(%rcx,%rdx,1),%xmm12
movss  %xmm12,0x4(%rbp)
addss  0x8(%rcx,%rdx,1),%xmm4
movss  %xmm4,0x8(%rbp)
addss  0xc(%rcx,%rdx,1),%xmm6
movss  %xmm6,0xc(%rbp)
addss  0x10(%rcx,%rdx,1),%xmm10
movss  %xmm10,0x10(%rbp)
addss  0x14(%rcx,%rdx,1),%xmm3
movss  %xmm3,0x14(%rbp)
addss  0x18(%rcx,%rdx,1),%xmm7
movss  %xmm7,0x18(%rbp)
addss  0x1c(%rcx,%rdx,1),%xmm0
movss  %xmm0,0x1c(%rbp)
addss  0x20(%rcx,%rdx,1),%xmm11
movss  %xmm11,0x20(%rbp)
addss  0x24(%rcx,%rdx,1),%xmm2
movss  %xmm2,0x24(%rbp)
addss  0x28(%rcx,%rdx,1),%xmm1
movss  %xmm1,0x28(%rbp)
addss  0x2c(%rcx,%rdx,1),%xmm5
movss  %xmm5,0x2c(%rbp)
addss  0x30(%rcx,%rdx,1),%xmm8
movss  %xmm8,0x30(%rbp)
add    $0x34,%rdx
cmp    %rdx,%rax
jne    1370 <initialize+0x260>
unpcklps %xmm5,%xmm1
unpcklps %xmm2,%xmm11
movlhps %xmm1,%xmm11
unpcklps %xmm0,%xmm7
unpcklps %xmm3,%xmm10
movlhps %xmm7,%xmm10
unpcklps %xmm6,%xmm4
unpcklps %xmm12,%xmm9
movlhps %xmm4,%xmm9
jmp    1452 <initialize+0x342>
movups 0x0(%rbp),%xmm9
movups 0x10(%rbp),%xmm10
movups 0x20(%rbp),%xmm11
movss  0x30(%rbp),%xmm8
mov    0x18(%rsp),%rcx
xorps  %xmm0,%xmm0
cvtsi2ss %r9d,%xmm0
divss  %xmm0,%xmm8
shufps $0x0,%xmm0,%xmm0
divps  %xmm0,%xmm9
subps  0x20(%rsp),%xmm9
movups %xmm9,0x0(%rbp)
divps  %xmm0,%xmm10
subps  0x30(%rsp),%xmm10
movups %xmm10,0x10(%rbp)
divps  %xmm0,%xmm11
subps  0x40(%rsp),%xmm11
movups %xmm11,0x20(%rbp)
subss  0x50(%rsp),%xmm8
xor    %eax,%eax
movss  %xmm8,0x30(%rbp)
xorps  %xmm8,%xmm8
test   %r9d,%r9d
jle    14bf <initialize+0x3af>
movss  (%rcx),%xmm0
cmp    $0x1,%r9d
jne    14d9 <initialize+0x3c9>
movaps %xmm0,%xmm10
mov    (%rsp),%rbp
jmp    1588 <initialize+0x478>
xorps  %xmm9,%xmm9
xorps  %xmm0,%xmm0
xor    %edx,%edx
xorps  %xmm12,%xmm12
xorps  %xmm11,%xmm11
mov    (%rsp),%rbp
jmp    172c <initialize+0x61c>
lea    -0x1(%r8),%rsi
lea    -0x2(%r8),%rdi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x3,%rdi
jae    14f3 <initialize+0x3e3>
mov    $0x1,%edi
jmp    1550 <initialize+0x440>
lea    0xd0(%rcx),%rbp
and    $0xfffffffffffffffc,%rsi
neg    %rsi
mov    $0x1,%edi
cs nopw 0x0(%rax,%rax,1)
movss  -0x9c(%rbp),%xmm1
ff
minss  %xmm0,%xmm1
movss  -0x68(%rbp),%xmm0
minss  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
minss  %xmm0,%xmm1
movss  0x0(%rbp),%xmm0
minss  %xmm1,%xmm0
add    $0xd0,%rbp
lea    (%rsi,%rdi,1),%rbx
add    $0x4,%rbx
add    $0x4,%rdi
cmp    $0x1,%rbx
jne    1510 <initialize+0x400>
movaps %xmm0,%xmm10
test   %rdx,%rdx
mov    (%rsp),%rbp
je     1588 <initialize+0x478>
imul   $0x34,%rdi,%rsi
add    %rcx,%rsi
imul   $0x34,%rdx,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rdi,1),%xmm10
minss  %xmm0,%xmm10
add    $0x34,%rdi
movaps %xmm10,%xmm0
cmp    %rdi,%rdx
jne    1570 <initialize+0x460>
xorps  %xmm9,%xmm9
movups %xmm9,0x20(%rbp)
movups %xmm9,0x10(%rbp)
movups %xmm9,0x0(%rbp)
movl   $0x0,0x30(%rbp)
xorps  %xmm0,%xmm0
mov    $0x0,%edx
xorps  %xmm12,%xmm12
xorps  %xmm11,%xmm11
test   %r9d,%r9d
jle    172c <initialize+0x61c>
addss  0xc(%rsp),%xmm10
imul   $0x34,%r8,%rdi
xorps  %xmm9,%xmm9
xor    %esi,%esi
xorps  %xmm8,%xmm8
xor    %edx,%edx
xor    %eax,%eax
xorps  %xmm0,%xmm0
xorps  %xmm12,%xmm12
xorps  %xmm11,%xmm11
jmp    1604 <initialize+0x4f4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%edx
addss  %xmm6,%xmm0
add    $0x34,%rsi
cmp    %rsi,%rdi
je     172c <initialize+0x61c>
movss  (%rcx,%rsi,1),%xmm6
ucomiss %xmm6,%xmm10
jbe    15f0 <initialize+0x4e0>
addss  %xmm9,%xmm6
movss  %xmm6,0x0(%rbp)
movaps %xmm9,%xmm13
shufps $0x55,%xmm9,%xmm13
addss  0x4(%rcx,%rsi,1),%xmm13
movss  %xmm13,0x4(%rbp)
movaps %xmm9,%xmm1
unpckhpd %xmm9,%xmm1
addss  0x8(%rcx,%rsi,1),%xmm1
movss  %xmm1,0x8(%rbp)
shufps $0xff,%xmm9,%xmm9
addss  0xc(%rcx,%rsi,1),%xmm9
movss  %xmm9,0xc(%rbp)
movss  0x10(%rcx,%rsi,1),%xmm7
addss  %xmm12,%xmm7
movss  %xmm7,0x10(%rbp)
movaps %xmm12,%xmm14
shufps $0x55,%xmm12,%xmm14
addss  0x14(%rcx,%rsi,1),%xmm14
movss  %xmm14,0x14(%rbp)
movaps %xmm12,%xmm2
unpckhpd %xmm12,%xmm2
addss  0x18(%rcx,%rsi,1),%xmm2
movss  %xmm2,0x18(%rbp)
shufps $0xff,%xmm12,%xmm12
addss  0x1c(%rcx,%rsi,1),%xmm12
movss  %xmm12,0x1c(%rbp)
movss  0x20(%rcx,%rsi,1),%xmm4
addss  %xmm11,%xmm4
movss  %xmm4,0x20(%rbp)
movaps %xmm11,%xmm3
shufps $0x55,%xmm11,%xmm3
addss  0x24(%rcx,%rsi,1),%xmm3
movss  %xmm3,0x24(%rbp)
movaps %xmm11,%xmm5
unpckhpd %xmm11,%xmm5
addss  0x28(%rcx,%rsi,1),%xmm5
movss  %xmm5,0x28(%rbp)
shufps $0xff,%xmm11,%xmm11
addss  0x2c(%rcx,%rsi,1),%xmm11
movss  %xmm11,0x2c(%rbp)
addss  0x30(%rcx,%rsi,1),%xmm8
movss  %xmm8,0x30(%rbp)
add    $0x1,%eax
unpcklps %xmm9,%xmm1
unpcklps %xmm13,%xmm6
movlhps %xmm1,%xmm6
unpcklps %xmm14,%xmm7
unpcklps %xmm12,%xmm2
movlhps %xmm2,%xmm7
unpcklps %xmm3,%xmm4
unpcklps %xmm11,%xmm5
movlhps %xmm5,%xmm4
movaps %xmm6,%xmm9
movaps %xmm7,%xmm12
movaps %xmm4,%xmm11
jmp    15f7 <initialize+0x4e7>
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm8
shufps $0x0,%xmm1,%xmm1
divps  %xmm1,%xmm9
movups %xmm9,0x0(%rbp)
divps  %xmm1,%xmm12
movups %xmm12,0x10(%rbp)
divps  %xmm1,%xmm11
movups %xmm11,0x20(%rbp)
movss  %xmm8,0x30(%rbp)
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
divss  %xmm1,%xmm0
add    $0x468,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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