void update_map1(map, a, coords, data, win_list, sigmax, dim, ivars,
                 total_units, samples) float **map,
    **data, **a, sigmax;
int **coords, *win_list;
int dim, ivars, total_units, samples;
{
  int i, j, k, winner, dist, diff, time_count;
  float factorx, c, distf, sum, ypred, d, weight_sumx;
  float weightx, tot_error, tot_error2, rms_error, rms_data_weights();
  factorx = -.5 / (sigmax * sigmax);
  for (i = 1; i <= samples; i++)
    win_list[i] = find_winner_pe2(map, a, coords, data, i, ivars, win_list[i],
                                  total_units, dim);
  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);
      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):
<update_map1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%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)
mov    %r8,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
mov    %r9d,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe95(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     11e5 <update_map1+0xc5>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x34(%rbp),%r8d
mov    0x10(%rbp),%r9d
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%r10
mov    (%rax,%r10,4),%r11d
mov    0x18(%rbp),%r10d
mov    -0x30(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1030 <find_winner_pe2@plt>
mov    %eax,%edx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    117f <update_map1+0x5f>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     13d6 <update_map1+0x2b6>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1231 <update_map1+0x111>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11ff <update_map1+0xdf>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     1355 <update_map1+0x235>
movl   $0x0,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     12ba <update_map1+0x19a>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x3c(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x48(%rbp),%ecx
imul   -0x48(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1268 <update_map1+0x148>
cvtsi2ssl -0x44(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <exp@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x6c(%rbp),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1342 <update_map1+0x222>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x6c(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12ec <update_map1+0x1cc>
jmp    1347 <update_map1+0x227>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1240 <update_map1+0x120>
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xca2(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     13c3 <update_map1+0x2a3>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    137a <update_map1+0x25a>
jmp    13c8 <update_map1+0x2a8>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11ec <update_map1+0xcc>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<update_map1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9d,%r10d
movsd  %xmm0,0x10(%rsp)
mov    %r8,%r11
mov    %rcx,%r13
mov    %rdx,%r14
mov    0x100(%rsp),%eax
mov    0xf8(%rsp),%r15d
mov    0xf0(%rsp),%ebx
test   %eax,%eax
mov    %rdi,0x8(%rsp)
jle    11f1 <update_map1+0xc1>
mov    %rsi,%r12
mov    0x100(%rsp),%eax
add    $0x1,%eax
mov    %rax,0x18(%rsp)
mov    $0x1,%ebp
mov    %r14,0x60(%rsp)
xchg   %ax,%ax
mov    (%r11,%rbp,4),%ebx
sub    $0x8,%rsp
mov    %r12,%rsi
mov    %r14,%rdx
mov    %r13,%rcx
mov    %ebp,%r8d
mov    0xf8(%rsp),%r9d
xor    %eax,%eax
push   %r10
push   %r15
push   %rbx
mov    %r10,%rbx
mov    %r15,%r14
mov    %r11,%r15
call   1040 <find_winner_pe2@plt>
mov    %r15,%r11
mov    %r14,%r15
mov    0x80(%rsp),%r14
mov    %rbx,%r10
mov    0x110(%rsp),%ebx
mov    0x28(%rsp),%rdi
add    $0x20,%rsp
mov    %eax,(%r11,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,0x18(%rsp)
jne    1190 <update_map1+0x60>
mov    %r13,0xa8(%rsp)
mov    %r10,0x50(%rsp)
test   %r15d,%r15d
jle    182c <update_map1+0x6fc>
mov    %r15,%rax
movsd  0x10(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mulss  %xmm0,%xmm0
movss  0xde0(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x10(%rsp)
mov    %ebx,%ecx
shl    $0x2,%rcx
mov    %rcx,0x58(%rsp)
mov    %r15,%rcx
mov    0x50(%rsp),%rax
lea    0x1(%rax),%ebp
lea    0x1(%rbx),%r15d
mov    0x100(%rsp),%eax
add    $0x1,%eax
mov    %rax,0xb0(%rsp)
mov    %rcx,%rax
add    $0x1,%eax
lea    -0x1(%r15),%r8
lea    -0x1(%rbp),%rdx
lea    -0x9(%rbp),%rsi
mov    %rsi,0x90(%rsp)
shr    $0x3,%rsi
add    $0x1,%rsi
lea    -0x9(%r15),%rcx
mov    %rcx,0x40(%rsp)
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
mov    %rdx,0x48(%rsp)
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
mov    %rsi,%rdx
mov    %rsi,0x88(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x70(%rsp)
mov    %r8,(%rsp)
and    $0xfffffffffffffff8,%r8
mov    %r9,%rcx
mov    %r9,0x38(%rsp)
and    $0xfffffffffffffffe,%r9
mov    %r9,0x20(%rsp)
mov    %r15,%rcx
neg    %rcx
mov    %rcx,0x98(%rsp)
mov    %r10,0x80(%rsp)
lea    0x1(%r10),%rcx
mov    %rcx,0x78(%rsp)
mov    %r8,0x30(%rsp)
lea    0x1(%r8),%rcx
mov    %rcx,0x28(%rsp)
mov    $0x1,%r12d
mov    %r11,0xa0(%rsp)
mov    %rax,0x68(%rsp)
jmp    1322 <update_map1+0x1f2>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    0x68(%rsp),%rax
cmp    %rax,%r12
je     182c <update_map1+0x6fc>
test   %ebx,%ebx
jle    1341 <update_map1+0x211>
mov    (%rdi,%r12,8),%rdi
add    $0x4,%rdi
xor    %esi,%esi
mov    0x58(%rsp),%rdx
call   1030 <memset@plt>
mov    0xf0(%rsp),%ebx
mov    0x100(%rsp),%eax
xorps  %xmm1,%xmm1
test   %eax,%eax
jle    1740 <update_map1+0x610>
mov    $0x1,%r13d
jmp    137c <update_map1+0x24c>
nopl   0x0(%rax,%rax,1)
movss  0x18(%rsp),%xmm1
addss  %xmm0,%xmm1
add    $0x1,%r13
cmp    0xb0(%rsp),%r13
je     1740 <update_map1+0x610>
cmpl   $0x0,0x50(%rsp)
movss  %xmm1,0x18(%rsp)
jle    13c0 <update_map1+0x290>
mov    0xa0(%rsp),%rax
movslq (%rax,%r13,4),%rax
mov    (%r14,%rax,8),%rax
mov    (%r14,%r12,8),%rcx
cmpq   $0x8,0x48(%rsp)
jae    13d0 <update_map1+0x2a0>
xor    %edx,%edx
mov    $0x1,%esi
jmp    1570 <update_map1+0x440>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
jmp    1584 <update_map1+0x454>
nopw   0x0(%rax,%rax,1)
cmpq   $0x8,0x90(%rsp)
jae    13e8 <update_map1+0x2b8>
xorps  %xmm0,%xmm0
xor    %edx,%edx
xorps  %xmm1,%xmm1
jmp    14ca <update_map1+0x39a>
xorps  %xmm0,%xmm0
mov    0x70(%rsp),%rsi
xor    %edx,%edx
xorps  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
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    1400 <update_map1+0x2d0>
testb  $0x1,0x88(%rsp)
01
je     1538 <update_map1+0x408>
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    0x78(%rsp),%rsi
mov    0x80(%rsp),%rdi
cmp    %rdi,0x48(%rsp)
je     1584 <update_map1+0x454>
cs nopw 0x0(%rax,%rax,1)
mov    (%rax,%rsi,4),%edi
sub    (%rcx,%rsi,4),%edi
imul   %edi,%edi
add    %edi,%edx
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1570 <update_map1+0x440>
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <exp@plt>
cvtsd2ss %xmm0,%xmm0
mov    0xf0(%rsp),%ebx
test   %ebx,%ebx
jle    1360 <update_map1+0x230>
mov    0xa8(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    0x8(%rsp),%rcx
mov    (%rcx,%r12,8),%rcx
mov    $0x1,%edx
cmpq   $0x8,(%rsp)
jb     16c0 <update_map1+0x590>
lea    0x4(%rcx),%rsi
lea    (%rax,%r15,4),%rdi
cmp    %rdi,%rsi
jae    15f0 <update_map1+0x4c0>
lea    (%rcx,%r15,4),%rsi
lea    0x4(%rax),%rdi
cmp    %rsi,%rdi
jb     16c0 <update_map1+0x590>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x8,0x40(%rsp)
jae    1603 <update_map1+0x4d3>
xor    %edx,%edx
jmp    166e <update_map1+0x53e>
mov    0x20(%rsp),%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
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    1610 <update_map1+0x4e0>
testb  $0x1,0x38(%rsp)
je     16a4 <update_map1+0x574>
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    0x28(%rsp),%rdx
mov    0x30(%rsp),%rsi
cmp    %rsi,(%rsp)
je     1360 <update_map1+0x230>
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rsi
test   $0x1,%r15b
jne    16e0 <update_map1+0x5b0>
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    0x98(%rsp),%rdx
je     1360 <update_map1+0x230>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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,%r15
jne    1700 <update_map1+0x5d0>
jmp    1360 <update_map1+0x230>
nopw   0x0(%rax,%rax,1)
test   %ebx,%ebx
mov    0x8(%rsp),%rdi
jle    1310 <update_map1+0x1e0>
movss  0x8af(%rip),%xmm0
divss  %xmm1,%xmm0
mov    (%rdi,%r12,8),%rax
mov    $0x1,%ecx
cmpq   $0x8,(%rsp)
jb     1810 <update_map1+0x6e0>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x8,0x40(%rsp)
jae    1780 <update_map1+0x650>
xor    %ecx,%ecx
jmp    17ce <update_map1+0x69e>
mov    0x20(%rsp),%rdx
xor    %ecx,%ecx
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    1790 <update_map1+0x660>
testb  $0x1,0x38(%rsp)
je     17f5 <update_map1+0x6c5>
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    0x28(%rsp),%rcx
mov    0x30(%rsp),%rdx
cmp    %rdx,(%rsp)
je     1310 <update_map1+0x1e0>
nopl   0x0(%rax)
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1810 <update_map1+0x6e0>
jmp    1310 <update_map1+0x1e0>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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