float update_fit4(map, a, coords, data, win_list, weight_list, sigmay, dim,
                  ivars, total_units, samples, u, b, dd, diag, workspace, atb)
float **map, **data, **a, *b, **u, **dd, *diag, *workspace, *atb, *weight_list,
    sigmay;
int **coords, *win_list;
int dim, ivars, total_units, samples;
{
  int i, j, k, p, winner, dist, diff, s_count;
  float factory, c, distf, sum, d;
  int d_count;
  float weight, rms_error, error_weight();
  float wmax, thresh, press;
  int ma = ivars + 1;
  factory = -.5 / (sigmay * sigmay);
  for (i = 1; i <= samples; i++)
    win_list[i] = winner =
        find_winnerw(map, data, weight_list, i, ivars, total_units);
  press = 0;
  s_count = 0;
  for (j = 1; j <= total_units; j++) {
    p = 1;
    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;
      }
      weight = exp(dist * factory);
      if (weight > .01) {
        u[p][1] = weight;
        for (k = 1; k <= ivars; k++)
          u[p][k + 1] = data[i][k] * weight;
        b[p] = data[i][ivars + 1] * weight;
        p++;
      }
    }
    if (p > ivars + 1)
      regress_ch2(u, b, a[j], p - 1, ivars, dd, diag, atb);
    sum = 0;
    k = 0;
    for (i = 1; i <= samples; i++) {
      if (win_list[i] == j) {
        distf = error_weight(data, i, ivars, a, j, dd, diag, atb, workspace);
        if (distf >= 0.0) {
          sum += distf * distf;
          k++;
        }
      }
    }
    press += sum;
    s_count += k;
  }
  if (s_count * 4 > samples)
    press = sqrt(press / ((float)s_count));
  else
    press = -1.0;
  return (press);
}


x86 assembly (clang, -O0):
<update_fit4>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
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)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
mov    0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe3e(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x28(%rbp),%eax
jg     121e <update_fit4+0xce>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%ecx
mov    0x18(%rbp),%r8d
mov    0x20(%rbp),%r9d
mov    $0x0,%al
call   1050 <find_winnerw@plt>
mov    %eax,%edx
mov    %edx,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11d6 <update_fit4+0x86>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     14e8 <update_fit4+0x398>
movl   $0x1,-0x44(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x28(%rbp),%eax
jg     13b2 <update_fit4+0x262>
movl   $0x0,-0x4c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     12c8 <update_fit4+0x178>
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x40(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x50(%rbp),%ecx
imul   -0x50(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1276 <update_fit4+0x126>
cvtsi2ssl -0x4c(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <exp@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd13(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    139f <update_fit4+0x24f>
movss  -0x70(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     136a <update_fit4+0x21a>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x70(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    131c <update_fit4+0x1cc>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x70(%rbp),%xmm0
mov    0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13a4 <update_fit4+0x254>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    124e <update_fit4+0xfe>
mov    -0x44(%rbp),%eax
mov    0x18(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    13fd <update_fit4+0x2ad>
mov    0x30(%rbp),%rdi
mov    0x38(%rbp),%rsi
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    0x18(%rbp),%r8d
mov    0x40(%rbp),%r9
mov    0x48(%rbp),%r10
mov    0x58(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <regress_ch2@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x28(%rbp),%eax
jg     14c2 <update_fit4+0x372>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
jne    14af <update_fit4+0x35f>
mov    -0x20(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    0x18(%rbp),%edx
mov    -0x10(%rbp),%rcx
mov    -0x3c(%rbp),%r8d
mov    0x40(%rbp),%r9
mov    0x48(%rbp),%r11
mov    0x58(%rbp),%r10
mov    0x50(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1060 <error_weight@plt>
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     14aa <update_fit4+0x35a>
movss  -0x60(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14af <update_fit4+0x35f>
jmp    14b4 <update_fit4+0x364>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1413 <update_fit4+0x2c3>
movss  -0x64(%rbp),%xmm0
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x40(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1234 <update_fit4+0xe4>
mov    -0x54(%rbp),%eax
shl    $0x2,%eax
cmp    0x28(%rbp),%eax
jle    151c <update_fit4+0x3cc>
movss  -0x80(%rbp),%xmm0
cvtsi2ssl -0x54(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1070 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
jmp    1529 <update_fit4+0x3d9>
movss  0xaec(%rip),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm0
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<update_fit4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
movsd  %xmm0,0x8(%rsp)
mov    %rcx,%rbp
mov    %rdx,0x100(%rsp)
mov    %rsi,0x68(%rsp)
mov    0x188(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x180(%rsp),%rax
mov    %rax,0xf8(%rsp)
mov    0x178(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0x170(%rsp),%rax
mov    %rax,0x50(%rsp)
mov    0x168(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0x160(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0x158(%rsp),%eax
mov    0x150(%rsp),%r15d
mov    0x148(%rsp),%r13d
mov    0x140(%rsp),%ecx
mov    %rcx,0x78(%rsp)
mov    %rax,0x10(%rsp)
test   %eax,%eax
mov    %rbp,0x28(%rsp)
jle    1252 <update_fit4+0x102>
mov    %r9,%r14
mov    %rdi,%r12
mov    0x10(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r12,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    %ebx,%ecx
mov    %r8,%rbp
mov    %r13d,%r8d
mov    %r15d,%r9d
xor    %eax,%eax
call   1060 <find_winnerw@plt>
mov    %rbp,%r8
mov    0x28(%rsp),%rbp
mov    %eax,(%r8,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,0x20(%rsp)
jne    1220 <update_fit4+0xd0>
mov    %r13,0x18(%rsp)
mov    %r8,0x80(%rsp)
test   %r15d,%r15d
jle    18de <update_fit4+0x78e>
mov    %r15,%rax
movsd  0x8(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
mulss  %xmm0,%xmm0
movss  0xd7f(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x34(%rsp)
mov    0x18(%rsp),%rcx
lea    0x1(%rcx),%r13d
movslq %r13d,%rcx
mov    %rcx,0xf0(%rsp)
mov    0x78(%rsp),%rcx
lea    0x1(%rcx),%r15d
mov    0x10(%rsp),%r12
lea    0x1(%r12),%ecx
mov    %rcx,0x20(%rsp)
add    $0x1,%eax
mov    %rax,0x90(%rsp)
lea    0x1(%r13),%rax
mov    %rax,0xc0(%rsp)
lea    -0x1(%r13),%rax
lea    -0x1(%r15),%rcx
lea    -0x9(%r15),%rdx
mov    %rdx,0xe8(%rsp)
shr    $0x3,%rdx
add    $0x1,%rdx
lea    -0x9(%r13),%rsi
mov    %rsi,0xb0(%rsp)
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rcx,0x70(%rsp)
mov    %rcx,%rdi
and    $0xfffffffffffffff8,%rdi
mov    %rdx,%rcx
mov    %rdx,0xe0(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xc8(%rsp)
mov    %rax,0x38(%rsp)
mov    %rax,%rcx
and    $0xfffffffffffffff8,%rcx
mov    %rsi,%rax
mov    %rsi,0xa8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x88(%rsp)
xorps  %xmm0,%xmm0
mov    %rdi,0xd8(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0xd0(%rsp)
mov    %rcx,0xa0(%rsp)
lea    0x1(%rcx),%rax
mov    %rax,0x98(%rsp)
mov    $0x1,%r14d
xor    %ecx,%ecx
jmp    13ad <update_fit4+0x25d>
nopl   0x0(%rax)
xor    %ebp,%ebp
xorps  %xmm1,%xmm1
movss  %xmm1,0x4(%rsp)
mov    0xb8(%rsp),%rcx
add    %ebp,%ecx
addss  0x4(%rsp),%xmm0
add    $0x1,%r14
cmp    0x90(%rsp),%r14
je     18e8 <update_fit4+0x798>
test   %r12d,%r12d
mov    0x80(%rsp),%rbp
movss  %xmm0,0x8(%rsp)
mov    %rcx,0xb8(%rsp)
mov    $0x1,%r12d
jle    17f0 <update_fit4+0x6a0>
mov    $0x1,%ebx
jmp    1411 <update_fit4+0x2c1>
nopl   0x0(%rax)
mov    0xf0(%rsp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x48(%rsp),%rax
movss  %xmm0,(%rax,%r12,4)
add    $0x1,%r12d
movss  0x8(%rsp),%xmm0
add    $0x1,%rbx
cmp    0x20(%rsp),%rbx
je     17f0 <update_fit4+0x6a0>
cmpl   $0x0,0x78(%rsp)
jle    1450 <update_fit4+0x300>
movslq 0x0(%rbp,%rbx,4),%rax
mov    0x100(%rsp),%rcx
mov    (%rcx,%rax,8),%rax
mov    (%rcx,%r14,8),%rcx
cmpq   $0x8,0x70(%rsp)
jae    1460 <update_fit4+0x310>
xor    %edx,%edx
mov    $0x1,%esi
jmp    1600 <update_fit4+0x4b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
jmp    1614 <update_fit4+0x4c4>
nopw   0x0(%rax,%rax,1)
cmpq   $0x8,0xe8(%rsp)
jae    1478 <update_fit4+0x328>
xorps  %xmm0,%xmm0
xor    %edx,%edx
xorps  %xmm1,%xmm1
jmp    155a <update_fit4+0x40a>
xorps  %xmm0,%xmm0
mov    0xc8(%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    1490 <update_fit4+0x340>
testb  $0x1,0xe0(%rsp)
01
je     15c8 <update_fit4+0x478>
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    0xd0(%rsp),%rsi
mov    0xd8(%rsp),%rdi
cmp    %rdi,0x70(%rsp)
je     1614 <update_fit4+0x4c4>
nopl   0x0(%rax)
mov    (%rax,%rsi,4),%edi
sub    (%rcx,%rsi,4),%edi
imul   %edi,%edi
add    %edi,%edx
add    $0x1,%rsi
cmp    %rsi,%r15
jne    1600 <update_fit4+0x4b0>
xorps  %xmm0,%xmm0
cvtsi2ss %edx,%xmm0
mulss  0x34(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <exp@plt>
cvtsd2ss %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
ucomisd 0x9d3(%rip),%xmm1
jbe    13fc <update_fit4+0x2ac>
movslq %r12d,%r12
mov    0x40(%rsp),%rax
mov    (%rax,%r12,8),%rcx
movss  %xmm0,0x4(%rcx)
mov    0x28(%rsp),%rax
mov    (%rax,%rbx,8),%rax
cmpl   $0x0,0x18(%rsp)
jle    13e0 <update_fit4+0x290>
mov    $0x1,%edx
cmpq   $0x8,0x38(%rsp)
jb     1750 <update_fit4+0x600>
lea    0x8(%rcx),%rsi
lea    (%rax,%r13,4),%rdi
cmp    %rdi,%rsi
jae    169f <update_fit4+0x54f>
mov    0xc0(%rsp),%rsi
lea    (%rcx,%rsi,4),%rsi
lea    0x4(%rax),%rdi
cmp    %rsi,%rdi
jb     1750 <update_fit4+0x600>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x8,0xb0(%rsp)
jae    16b5 <update_fit4+0x565>
xor    %edx,%edx
jmp    16fe <update_fit4+0x5ae>
mov    0x88(%rsp),%rsi
xor    %edx,%edx
nop
movups 0x4(%rax,%rdx,4),%xmm2
movups 0x14(%rax,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x8(%rcx,%rdx,4)
movups %xmm3,0x18(%rcx,%rdx,4)
movups 0x24(%rax,%rdx,4),%xmm2
movups 0x34(%rax,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x28(%rcx,%rdx,4)
movups %xmm3,0x38(%rcx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    16c0 <update_fit4+0x570>
testb  $0x1,0xa8(%rsp)
01
je     172f <update_fit4+0x5df>
shl    $0x2,%rdx
mov    %rdx,%rsi
or     $0x4,%rsi
movups (%rax,%rsi,1),%xmm2
movups 0x10(%rax,%rsi,1),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
or     $0x8,%rdx
movups %xmm2,(%rcx,%rdx,1)
movups %xmm3,0x10(%rcx,%rdx,1)
mov    0x98(%rsp),%rdx
mov    0xa0(%rsp),%rsi
cmp    %rsi,0x38(%rsp)
je     13e0 <update_fit4+0x290>
nopw   0x0(%rax,%rax,1)
mov    %r13d,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %r13,%rsi
and    $0x3,%rdi
je     1789 <update_fit4+0x639>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rax,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rcx,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1770 <update_fit4+0x620>
cmp    $0x3,%rsi
jb     13e0 <update_fit4+0x290>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rax,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rcx,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x8(%rcx,%rdx,4)
movss  0x8(%rax,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0xc(%rcx,%rdx,4)
movss  0xc(%rax,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x10(%rcx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r13
jne    17a0 <update_fit4+0x650>
jmp    13e0 <update_fit4+0x290>
nopl   (%rax)
cmp    %r13d,%r12d
mov    0x18(%rsp),%r8
jle    1832 <update_fit4+0x6e2>
mov    0x68(%rsp),%rax
mov    (%rax,%r14,8),%rdx
add    $0xffffffff,%r12d
mov    0x40(%rsp),%rdi
mov    0x48(%rsp),%rsi
mov    %r12d,%ecx
mov    0x50(%rsp),%r9
xor    %eax,%eax
push   0x60(%rsp)
push   0x60(%rsp)
call   1030 <regress_ch2@plt>
movss  0x18(%rsp),%xmm0
add    $0x10,%rsp
mov    0x10(%rsp),%r12
test   %r12d,%r12d
jle    1380 <update_fit4+0x230>
xorps  %xmm1,%xmm1
movss  %xmm1,0x4(%rsp)
xor    %ebp,%ebp
mov    $0x1,%ebx
jmp    1875 <update_fit4+0x725>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x8(%rsp),%xmm0
add    $0x1,%rbx
cmp    %rbx,0x20(%rsp)
je     138b <update_fit4+0x23b>
mov    0x80(%rsp),%rax
mov    (%rax,%rbx,4),%eax
cmp    %rax,%r14
jne    1866 <update_fit4+0x716>
sub    $0x8,%rsp
mov    0x30(%rsp),%rdi
mov    %ebx,%esi
mov    0x20(%rsp),%rdx
mov    0x70(%rsp),%rcx
mov    %r14d,%r8d
mov    0x58(%rsp),%r9
xor    %eax,%eax
push   0x100(%rsp)
push   0x70(%rsp)
push   0x70(%rsp)
call   1070 <error_weight@plt>
add    $0x20,%rsp
ucomiss 0x745(%rip),%xmm0
jb     1860 <update_fit4+0x710>
mulss  %xmm0,%xmm0
movss  0x4(%rsp),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x4(%rsp)
add    $0x1,%ebp
jmp    1860 <update_fit4+0x710>
xorps  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0x10(%rsp),%r12
lea    0x0(,%rcx,4),%eax
cmp    %r12d,%eax
jle    190d <update_fit4+0x7bd>
xorps  %xmm1,%xmm1
cvtsi2ss %ecx,%xmm1
divss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1927 <update_fit4+0x7d7>
sqrtss %xmm0,%xmm0
jmp    1915 <update_fit4+0x7c5>
movss  0x6ef(%rip),%xmm0
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <sqrtf@plt>

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

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