void som(map, coords, data, win_list, sigmax, dim, ivars, u_p_dim, total_units,
         samples) float **map,
    **data, sigmax;
int **coords, *win_list;
int dim, ivars, total_units, samples, u_p_dim;
{
  int k, j, i;
  int winner, dist, diff, ndist;
  float weightx, weight_sumx, factorx;
  factorx = -.5 / (sigmax * sigmax);
  ndist = 2 * sigmax * sigmax;
  if (ndist < 2)
    ndist = 2;
  if (ndist < u_p_dim)
    for (k = 1; k <= samples; k++)
      win_list[k] = find_winner2(map, coords, data, win_list[k], k, ivars,
                                 total_units, dim, ndist);
  else
    for (k = 1; k <= samples; k++)
      win_list[k] = find_winner(map, data, k, ivars, total_units);
  for (j = 1; j <= total_units; j++) {
    for (k = 1; k <= ivars; k++)
      map[j][k] = 0;
    weight_sumx = 0;
    for (i = 1; i <= samples; i++) {
      dist = 0;
      winner = win_list[i];
      for (k = 1; k <= dim; k++) {
        diff = coords[winner][k] - coords[j][k];
        dist = dist + diff * diff;
      }
      weightx = exp(dist * factorx);
      if (weightx > .01) {
        weight_sumx += weightx;
        for (k = 1; k <= ivars; k++)
          map[j][k] += data[i][k] * weightx;
      }
    }
    weight_sumx = 1.0 / weight_sumx;
    for (k = 1; k <= ivars; k++)
      map[j][k] = map[j][k] * weight_sumx;
  }
}


x86 assembly (clang, -O0):
<som>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
cvtsd2ss %xmm0,%xmm0
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe90(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  0xe73(%rip),%xmm0
mulss  -0x24(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x2,-0x48(%rbp)
jge    11af <som+0x7f>
movl   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    122c <som+0xfc>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     1227 <som+0xf7>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x30(%rbp),%r8d
mov    -0x2c(%rbp),%r9d
mov    0x18(%rbp),%r11d
mov    -0x28(%rbp),%r10d
mov    -0x48(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1030 <find_winner2@plt>
mov    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11c2 <som+0x92>
jmp    1278 <som+0x148>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     1273 <som+0x143>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x30(%rbp),%edx
mov    -0x2c(%rbp),%ecx
mov    0x18(%rbp),%r8d
mov    $0x0,%al
call   1050 <find_winner@plt>
mov    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1233 <som+0x103>
jmp    1278 <som+0x148>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1489 <som+0x359>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     12c4 <som+0x194>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1292 <som+0x162>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     1408 <som+0x2d8>
movl   $0x0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     134d <som+0x21d>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x30(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x44(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12fb <som+0x1cb>
cvtsi2ssl -0x40(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <exp@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc9e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    13f5 <som+0x2c5>
movss  -0x4c(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     13f0 <som+0x2c0>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x4c(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    139a <som+0x26a>
jmp    13f5 <som+0x2c5>
jmp    13fa <som+0x2ca>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12d3 <som+0x1a3>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xbf7(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1476 <som+0x346>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    142d <som+0x2fd>
jmp    147b <som+0x34b>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    127f <som+0x14f>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<som>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9d,%r15d
mov    %r8,0x30(%rsp)
mov    %rsi,%r14
mov    0x100(%rsp),%esi
cvtsd2ss %xmm0,%xmm1
movaps %xmm1,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
cmp    $0x3,%eax
mov    $0x2,%r10d
cmovge %eax,%r10d
cmp    0xf0(%rsp),%r10d
mov    %rcx,0x28(%rsp)
mov    %rdi,0x18(%rsp)
movss  %xmm1,0x14(%rsp)
jge    1220 <som+0xe0>
test   %esi,%esi
mov    0xf8(%rsp),%ebx
jle    127e <som+0x13e>
mov    0x100(%rsp),%eax
add    $0x1,%eax
mov    %rax,0x8(%rsp)
mov    $0x1,%r12d
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rcx,%r12,4),%ecx
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    %r14,%rsi
mov    %rdx,%rbp
mov    %r12d,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
push   %r10
push   0x40(%rsp)
push   %rbx
mov    %r15,%r13
mov    %r10,%r15
call   1030 <find_winner2@plt>
mov    %r15,%r10
mov    %r13,%r15
mov    0x48(%rsp),%rcx
mov    %rbp,%rdx
add    $0x20,%rsp
mov    %eax,(%rcx,%r12,4)
add    $0x1,%r12
cmp    %r12,0x8(%rsp)
jne    11d0 <som+0x90>
jmp    127e <som+0x13e>
test   %esi,%esi
mov    0xf8(%rsp),%ebx
jle    127e <som+0x13e>
mov    %rdi,%r13
mov    0x100(%rsp),%eax
add    $0x1,%eax
mov    %rax,0x8(%rsp)
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r13,%rdi
mov    %rdx,%rsi
mov    %rdx,%r12
mov    %ebp,%edx
mov    %r15d,%ecx
mov    %ebx,%r8d
xor    %eax,%eax
call   1060 <find_winner@plt>
mov    0x28(%rsp),%rcx
mov    %r12,%rdx
mov    %eax,(%rcx,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,0x8(%rsp)
jne    1250 <som+0x110>
mov    %rdx,0xb0(%rsp)
test   %ebx,%ebx
jle    18ac <som+0x76c>
movss  0x14(%rsp),%xmm1
mulss  %xmm1,%xmm1
movss  0xd60(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x14(%rsp)
mov    %r15d,%eax
shl    $0x2,%rax
mov    %rax,0x70(%rsp)
mov    0x30(%rsp),%rax
lea    0x1(%rax),%ebp
lea    0x1(%r15),%ebx
mov    0x100(%rsp),%eax
lea    0x1(%rax),%r12d
mov    0xf8(%rsp),%eax
add    $0x1,%eax
lea    -0x1(%rbx),%rcx
lea    -0x1(%rbp),%rdx
lea    -0x9(%rbp),%rsi
mov    %rsi,0xa8(%rsp)
shr    $0x3,%rsi
add    $0x1,%rsi
lea    -0x9(%rbx),%rdi
mov    %rdi,0x58(%rsp)
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %rdx,0x68(%rsp)
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
mov    %rsi,%rdx
mov    %rsi,0xa0(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x80(%rsp)
mov    %rcx,0x20(%rsp)
mov    %rcx,%rdx
and    $0xfffffffffffffff8,%rdx
mov    %rdi,%rcx
mov    %rdi,0x50(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x38(%rsp)
mov    %rbx,%rcx
neg    %rcx
mov    %rcx,0x88(%rsp)
mov    %r8,0x98(%rsp)
lea    0x1(%r8),%rcx
mov    %rcx,0x90(%rsp)
mov    %rdx,0x48(%rsp)
lea    0x1(%rdx),%rcx
mov    %rcx,0x40(%rsp)
mov    $0x1,%r13d
mov    %r15,0x60(%rsp)
mov    %rax,0x78(%rsp)
jmp    13a2 <som+0x262>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13
mov    0x78(%rsp),%rax
cmp    %rax,%r13
je     18ac <som+0x76c>
test   %r15d,%r15d
jle    13c0 <som+0x280>
mov    0x18(%rsp),%rax
mov    (%rax,%r13,8),%rdi
add    $0x4,%rdi
xor    %esi,%esi
mov    0x70(%rsp),%rdx
call   1040 <memset@plt>
mov    0x100(%rsp),%eax
xorps  %xmm0,%xmm0
test   %eax,%eax
jle    17b0 <som+0x670>
movss  %xmm0,0x8(%rsp)
mov    $0x1,%r15d
jmp    13ed <som+0x2ad>
add    $0x1,%r15
cmp    %r12,%r15
je     17b6 <som+0x676>
cmpl   $0x0,0x30(%rsp)
jle    1420 <som+0x2e0>
mov    0x28(%rsp),%rax
movslq (%rax,%r15,4),%rax
mov    (%r14,%rax,8),%rax
mov    (%r14,%r13,8),%rcx
cmpq   $0x8,0x68(%rsp)
jae    1430 <som+0x2f0>
xor    %edx,%edx
mov    $0x1,%esi
jmp    15d0 <som+0x490>
nopl   0x0(%rax)
xor    %edx,%edx
jmp    15e4 <som+0x4a4>
nopw   0x0(%rax,%rax,1)
cmpq   $0x8,0xa8(%rsp)
jae    1448 <som+0x308>
xorps  %xmm0,%xmm0
xor    %edx,%edx
xorps  %xmm1,%xmm1
jmp    152a <som+0x3ea>
xorps  %xmm0,%xmm0
mov    0x80(%rsp),%rsi
xor    %edx,%edx
xorps  %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu 0x4(%rax,%rdx,4),%xmm4
movdqu 0x14(%rax,%rdx,4),%xmm5
movdqu 0x24(%rax,%rdx,4),%xmm3
movdqu 0x34(%rax,%rdx,4),%xmm2
movdqu 0x4(%rcx,%rdx,4),%xmm6
psubd  %xmm6,%xmm4
movdqu 0x14(%rcx,%rdx,4),%xmm6
psubd  %xmm6,%xmm5
movdqu 0x24(%rcx,%rdx,4),%xmm6
psubd  %xmm6,%xmm3
movdqu 0x34(%rcx,%rdx,4),%xmm6
psubd  %xmm6,%xmm2
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm4,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pmuludq %xmm6,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm4
paddd  %xmm0,%xmm4
pshufd $0xf5,%xmm5,%xmm0
pmuludq %xmm5,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pmuludq %xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm5
paddd  %xmm1,%xmm5
pshufd $0xf5,%xmm3,%xmm1
pmuludq %xmm3,%xmm3
pshufd $0xe8,%xmm3,%xmm0
pmuludq %xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
paddd  %xmm4,%xmm0
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm1
pmuludq %xmm3,%xmm3
pshufd $0xe8,%xmm3,%xmm2
punpckldq %xmm2,%xmm1
paddd  %xmm5,%xmm1
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1460 <som+0x320>
testb  $0x1,0xa0(%rsp)
01
je     1598 <som+0x458>
shl    $0x2,%rdx
or     $0x4,%rdx
movdqu (%rax,%rdx,1),%xmm2
movdqu 0x10(%rax,%rdx,1),%xmm3
movdqu (%rcx,%rdx,1),%xmm4
psubd  %xmm4,%xmm2
movdqu 0x10(%rcx,%rdx,1),%xmm4
psubd  %xmm4,%xmm3
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm4,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm2
paddd  %xmm2,%xmm0
pshufd $0xf5,%xmm3,%xmm2
pmuludq %xmm3,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
mov    0x90(%rsp),%rsi
mov    0x98(%rsp),%rdi
cmp    %rdi,0x68(%rsp)
je     15e4 <som+0x4a4>
nopl   0x0(%rax)
mov    (%rax,%rsi,4),%edi
sub    (%rcx,%rsi,4),%edi
imul   %edi,%edi
add    %edi,%edx
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    15d0 <som+0x490>
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <exp@plt>
cvtsd2ss %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
ucomisd 0x9fb(%rip),%xmm1
jbe    13e0 <som+0x2a0>
movss  0x8(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x8(%rsp)
cmpl   $0x0,0x60(%rsp)
jle    13e0 <som+0x2a0>
mov    0xb0(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    0x18(%rsp),%rcx
mov    (%rcx,%r13,8),%rcx
mov    $0x1,%edx
cmpq   $0x8,0x20(%rsp)
jb     1740 <som+0x600>
lea    0x4(%rcx),%rsi
lea    (%rax,%rbx,4),%rdi
cmp    %rdi,%rsi
jae    1672 <som+0x532>
lea    (%rcx,%rbx,4),%rsi
lea    0x4(%rax),%rdi
cmp    %rsi,%rdi
jb     1740 <som+0x600>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x8,0x58(%rsp)
jae    1685 <som+0x545>
xor    %edx,%edx
jmp    16ee <som+0x5ae>
mov    0x38(%rsp),%rsi
xor    %edx,%edx
nopl   0x0(%rax)
movups 0x4(%rax,%rdx,4),%xmm2
movups 0x14(%rax,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
movups 0x4(%rcx,%rdx,4),%xmm4
addps  %xmm2,%xmm4
movups 0x14(%rcx,%rdx,4),%xmm2
movups 0x24(%rcx,%rdx,4),%xmm5
movups 0x34(%rcx,%rdx,4),%xmm6
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm4,0x4(%rcx,%rdx,4)
movups %xmm3,0x14(%rcx,%rdx,4)
movups 0x24(%rax,%rdx,4),%xmm2
movups 0x34(%rax,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm6,%xmm3
movups %xmm2,0x24(%rcx,%rdx,4)
movups %xmm3,0x34(%rcx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1690 <som+0x550>
testb  $0x1,0x50(%rsp)
je     1724 <som+0x5e4>
shl    $0x2,%rdx
or     $0x4,%rdx
movups (%rax,%rdx,1),%xmm2
movups 0x10(%rax,%rdx,1),%xmm3
movups (%rcx,%rdx,1),%xmm4
movups 0x10(%rcx,%rdx,1),%xmm5
mulps  %xmm1,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%rcx,%rdx,1)
movups %xmm3,0x10(%rcx,%rdx,1)
mov    0x40(%rsp),%rdx
mov    0x48(%rsp),%rsi
cmp    %rsi,0x20(%rsp)
je     13e0 <som+0x2a0>
nopl   0x0(%rax)
mov    %rdx,%rsi
test   $0x1,%bl
jne    175f <som+0x61f>
movss  (%rax,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%rdx,4),%xmm1
movss  %xmm1,(%rcx,%rdx,4)
lea    0x1(%rdx),%rsi
not    %rdx
cmp    0x88(%rsp),%rdx
je     13e0 <som+0x2a0>
movss  (%rax,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%rsi,4),%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%rcx,%rsi,4),%xmm1
movss  %xmm1,0x4(%rcx,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rbx
jne    1770 <som+0x630>
jmp    13e0 <som+0x2a0>
nopw   0x0(%rax,%rax,1)
movss  %xmm0,0x8(%rsp)
mov    0x60(%rsp),%r15
test   %r15d,%r15d
jle    1390 <som+0x250>
movss  0x838(%rip),%xmm0
divss  0x8(%rsp),%xmm0
mov    0x18(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    $0x1,%ecx
cmpq   $0x8,0x20(%rsp)
jb     1890 <som+0x750>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x8,0x58(%rsp)
jae    17ff <som+0x6bf>
xor    %ecx,%ecx
jmp    184e <som+0x70e>
mov    0x38(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movups 0x4(%rax,%rcx,4),%xmm2
movups 0x14(%rax,%rcx,4),%xmm3
movups 0x24(%rax,%rcx,4),%xmm4
movups 0x34(%rax,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x4(%rax,%rcx,4)
movups %xmm3,0x14(%rax,%rcx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,0x24(%rax,%rcx,4)
movups %xmm5,0x34(%rax,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1810 <som+0x6d0>
testb  $0x1,0x50(%rsp)
je     1875 <som+0x735>
shl    $0x2,%rcx
or     $0x4,%rcx
movups (%rax,%rcx,1),%xmm2
movups 0x10(%rax,%rcx,1),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rax,%rcx,1)
movups %xmm3,0x10(%rax,%rcx,1)
mov    0x40(%rsp),%rcx
mov    0x48(%rsp),%rdx
cmp    %rdx,0x20(%rsp)
je     1390 <som+0x250>
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    1890 <som+0x750>
jmp    1390 <som+0x250>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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