void find_best_candidate(double *x, int *n, int *p, int *uncens, int *uncens_n,
                         double *beta, double *risk, double *eta,
                         double *weight_at_event, int *max_nz, int *max_1,
                         double *weighted_risk, double *weighted_risk_sum,
                         int *weight_time_dependent, double *penalty,
                         int *penscore, int *candidates, int *candno,
                         int *is_01, int *warncount, int *min_index,
                         double *min_beta_delta, double *score_vec,
                         double *beta_delta_vec, double *U_vec, double *I_vec) {
  int actual_cand, actual_x, i, j;
  double x_bar, prev_x_bar_base, V;
  double U, I, beta_delta;
  double buffer1, prev_buffer1;
  double score, max_score, max_score_beta_delta;
  int max_score_index;
  const double stability_penalty = 1.0 / 0.1 - 1;
  *warncount = 0;
  for (actual_cand = 0; actual_cand < *candno; actual_cand++) {
    actual_x = candidates[actual_cand];
    U = 0;
    I = 0;
    if (*is_01) {
      prev_buffer1 = 0;
      for (i = 0; i < *uncens_n; i++) {
        if (*weight_time_dependent) {
          buffer1 = 0;
          for (j = 0; j < max_nz[i]; j++) {
            buffer1 += weighted_risk[(i * *n) + j] * x[(actual_x * *n) + j];
          }
        } else {
          buffer1 = prev_buffer1;
          for (j = max_1[i]; j < max_1[i + 1]; j++) {
            buffer1 += weighted_risk[(i * *n) + j] * x[(actual_x * *n) + j];
          }
          prev_buffer1 = buffer1;
          for (j = max_1[i + 1]; j < max_nz[i]; j++) {
            buffer1 += weighted_risk[(i * *n) + j] * x[(actual_x * *n) + j];
          }
        }
        x_bar = buffer1 / weighted_risk_sum[i];
        U += weight_at_event[i] * (x[(actual_x * *n) + uncens[i]] - x_bar);
        I += weight_at_event[i] *
             (x_bar * x_bar * (weighted_risk_sum[i] - buffer1) +
              (1 - x_bar) * (1 - x_bar) * buffer1) /
             weighted_risk_sum[i];
      }
    } else {
      prev_x_bar_base = 0;
      for (i = 0; i < *uncens_n; i++) {
        if (*weight_time_dependent) {
          x_bar = 0;
          for (j = 0; j < max_nz[i]; j++)
            x_bar += weighted_risk[(i * *n) + j] * x[(actual_x * *n) + j];
        } else {
          x_bar = prev_x_bar_base;
          for (j = max_1[i]; j < max_1[i + 1]; j++)
            x_bar += weighted_risk[(i * *n) + j] * x[(actual_x * *n) + j];
          prev_x_bar_base = x_bar;
          for (j = max_1[i + 1]; j < max_nz[i]; j++)
            x_bar += weighted_risk[(i * *n) + j] * x[(actual_x * *n) + j];
        }
        x_bar /= weighted_risk_sum[i];
        U += weight_at_event[i] * (x[(actual_x * *n) + uncens[i]] - x_bar);
        V = 0;
        for (j = 0; j < max_nz[i]; j++)
          V += weighted_risk[(i * *n) + j] * (x[(actual_x * *n) + j] - x_bar) *
               (x[(actual_x * *n) + j] - x_bar);
        V /= weighted_risk_sum[i];
        I += weight_at_event[i] * V;
      }
    }
    U_vec[actual_x] = U;
    I_vec[actual_x] = I;
    beta_delta_vec[actual_x] = beta_delta = U / (I + penalty[actual_x]);
    if (*penscore) {
      score_vec[actual_x] = score = U * U / (I + penalty[actual_x]);
    } else {
      score_vec[actual_x] = score = U * U / (I + stability_penalty);
    }
    if (actual_cand == 0 || score > max_score) {
      max_score_index = actual_x + 1;
      max_score = score;
      max_score_beta_delta = beta_delta;
    }
  }
  *min_index = max_score_index;
  *min_beta_delta = max_score_beta_delta;
}


x86 assembly (clang, -O0):
<find_best_candidate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x28,%rsp
mov    0xa8(%rbp),%rax
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
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),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  0xe76(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x78(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x68(%rbp),%rcx
cmp    (%rcx),%eax
jge    189c <find_best_candidate+0x79c>
mov    0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x70(%rbp),%rax
cmpl   $0x0,(%rax)
je     146b <find_best_candidate+0x36b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    1466 <find_best_candidate+0x366>
mov    0x48(%rbp),%rax
cmpl   $0x0,(%rax)
je     1282 <find_best_candidate+0x182>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x28(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    127d <find_best_candidate+0x17d>
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1217 <find_best_candidate+0x117>
jmp    138d <find_best_candidate+0x28d>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x30(%rbp),%rcx
mov    -0x3c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1305 <find_best_candidate+0x205>
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    129a <find_best_candidate+0x19a>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x28(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1388 <find_best_candidate+0x288>
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1322 <find_best_candidate+0x222>
jmp    138d <find_best_candidate+0x28d>
movsd  -0x78(%rbp),%xmm0
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
mov    -0x20(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x48(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
subsd  -0x78(%rbp),%xmm3
movsd  0xbee(%rip),%xmm2
subsd  -0x48(%rbp),%xmm2
movsd  0xbe1(%rip),%xmm4
subsd  -0x48(%rbp),%xmm4
mulsd  %xmm4,%xmm2
mulsd  -0x78(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11ec <find_best_candidate+0xec>
jmp    1769 <find_best_candidate+0x669>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    1764 <find_best_candidate+0x664>
mov    0x48(%rbp),%rax
cmpl   $0x0,(%rax)
je     1510 <find_best_candidate+0x410>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x28(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    150b <find_best_candidate+0x40b>
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14a5 <find_best_candidate+0x3a5>
jmp    161b <find_best_candidate+0x51b>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x30(%rbp),%rcx
mov    -0x3c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1593 <find_best_candidate+0x493>
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1528 <find_best_candidate+0x428>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x28(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1616 <find_best_candidate+0x516>
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    15b0 <find_best_candidate+0x4b0>
jmp    161b <find_best_candidate+0x51b>
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x48(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
mov    -0x20(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x48(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    0x28(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1717 <find_best_candidate+0x617>
mov    0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0x48(%rbp),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
imul   (%rdx),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x48(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    168a <find_best_candidate+0x58a>
mov    0x40(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    147a <find_best_candidate+0x37a>
jmp    1769 <find_best_candidate+0x669>
movsd  -0x60(%rbp),%xmm0
mov    0xa0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0xa8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x98(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
cmpl   $0x0,(%rax)
je     180d <find_best_candidate+0x70d>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x90(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1840 <find_best_candidate+0x740>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  0x7e1(%rip),%xmm1
addsd  -0x68(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x90(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x34(%rbp)
je     1860 <find_best_candidate+0x760>
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0x90(%rbp),%xmm0
ff
jbe    1889 <find_best_candidate+0x789>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    188e <find_best_candidate+0x78e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a3 <find_best_candidate+0xa3>
mov    -0x9c(%rbp),%ecx
mov    0x80(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x98(%rbp),%xmm0
ff
mov    0x88(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x28,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_best_candidate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8,-0x18(%rsp)
mov    %rsi,-0x30(%rsp)
mov    0x90(%rsp),%rax
mov    0xa0(%rsp),%rdx
movl   $0x0,(%rdx)
mov    (%rax),%eax
mov    %rax,-0x20(%rsp)
test   %eax,%eax
jle    184d <find_best_candidate+0x74d>
mov    0x98(%rsp),%rax
mov    0x80(%rsp),%rdx
mov    0x60(%rsp),%rsi
mov    (%rax),%eax
mov    %eax,-0x40(%rsp)
mov    (%rdx),%eax
mov    %eax,-0x44(%rsp)
lea    0x8(%rsi),%rax
mov    %rax,-0x28(%rsp)
movsd  0xe9c(%rip),%xmm8
movsd  0xe8b(%rip),%xmm11
lea    0x8(%rdi),%rax
mov    %rax,-0x38(%rsp)
xor    %ebp,%ebp
jmp    11b0 <find_best_candidate+0xb0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x3c(%rsp),%edx
cmovne %eax,%edx
add    $0x1,%rbp
movapd %xmm0,%xmm9
movapd %xmm13,%xmm10
cmp    -0x20(%rsp),%rbp
je     184d <find_best_candidate+0x74d>
mov    0x88(%rsp),%rax
movslq (%rax,%rbp,4),%rsi
mov    -0x18(%rsp),%rax
mov    (%rax),%r14d
cmpl   $0x0,-0x40(%rsp)
mov    %edx,-0x3c(%rsp)
mov    %rbp,-0x8(%rsp)
mov    %rsi,-0x10(%rsp)
je     1480 <find_best_candidate+0x380>
test   %r14d,%r14d
jle    17a0 <find_best_candidate+0x6a0>
mov    0x70(%rsp),%rax
mov    (%rax),%r8d
mov    -0x30(%rsp),%rax
mov    (%rax),%r15d
mov    %r15d,%eax
imul   %esi,%eax
movslq %eax,%r9
mov    -0x38(%rsp),%rax
lea    (%rax,%r9,8),%rsi
xorpd  %xmm6,%xmm6
xor    %r12d,%r12d
xor    %r10d,%r10d
xorpd  %xmm12,%xmm12
xorpd  %xmm13,%xmm13
jmp    12ad <find_best_candidate+0x1ad>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm7,%xmm7
mov    0x68(%rsp),%rdx
movsd  (%rdx,%r10,8),%xmm5
movapd %xmm7,%xmm1
divsd  %xmm5,%xmm1
mov    0x48(%rsp),%rax
movsd  (%rax,%r10,8),%xmm2
movslq (%rcx,%r10,4),%rdx
add    %r9,%rdx
movsd  (%rdi,%rdx,8),%xmm3
subsd  %xmm1,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm13
movapd %xmm11,%xmm3
subsd  %xmm1,%xmm3
mulsd  %xmm1,%xmm1
movapd %xmm5,%xmm0
subsd  %xmm7,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm3,%xmm3
mulsd  %xmm7,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm2,%xmm3
divsd  %xmm5,%xmm3
addsd  %xmm3,%xmm12
add    $0x1,%r10
add    %r15d,%r12d
cmp    %r14,%r10
je     17aa <find_best_candidate+0x6aa>
movslq %r12d,%rdx
mov    -0x28(%rsp),%rax
lea    (%rax,%rdx,8),%rbx
test   %r8d,%r8d
je     12e0 <find_best_candidate+0x1e0>
mov    0x50(%rsp),%rax
mov    (%rax,%r10,4),%r11d
test   %r11d,%r11d
jle    1230 <find_best_candidate+0x130>
cmp    $0x1,%r11d
jne    130a <find_best_candidate+0x20a>
xorpd  %xmm7,%xmm7
xor    %ebp,%ebp
jmp    134b <find_best_candidate+0x24b>
xchg   %ax,%ax
mov    0x58(%rsp),%rax
movslq (%rax,%r10,4),%r13
movslq 0x4(%rax,%r10,4),%r11
cmp    %r11d,%r13d
jge    13eb <find_best_candidate+0x2eb>
mov    %r11d,%edx
sub    %r13d,%edx
test   $0x1,%dl
jne    137d <find_best_candidate+0x27d>
mov    %r13,%rbp
jmp    13a6 <find_best_candidate+0x2a6>
mov    %r11d,%edx
and    $0xfffffffe,%edx
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%rbp,8),%xmm1
movsd  (%rbx,%rbp,8),%xmm7
mulsd  -0x8(%rsi,%rbp,8),%xmm1
mulsd  (%rsi,%rbp,8),%xmm7
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm7
add    $0x2,%rbp
movapd %xmm7,%xmm0
cmp    %rbp,%rdx
jne    1320 <find_best_candidate+0x220>
test   $0x1,%r11b
je     1234 <find_best_candidate+0x134>
mov    %r15d,%edx
imul   %r10d,%edx
movslq %edx,%rdx
add    %rbp,%rdx
mov    0x60(%rsp),%rbx
movsd  (%rbx,%rdx,8),%xmm0
add    %r9,%rbp
mulsd  (%rdi,%rbp,8),%xmm0
addsd  %xmm0,%xmm7
jmp    1234 <find_best_candidate+0x134>
mov    %r15d,%edx
imul   %r10d,%edx
movslq %edx,%rdx
add    %r13,%rdx
mov    0x60(%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm0
lea    (%r9,%r13,1),%rdx
mulsd  (%rdi,%rdx,8),%xmm0
addsd  %xmm0,%xmm6
lea    0x1(%r13),%rbp
movapd %xmm6,%xmm0
not    %r13
add    %r11,%r13
je     13eb <find_best_candidate+0x2eb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rbp,8),%xmm1
movsd  (%rbx,%rbp,8),%xmm6
mulsd  -0x8(%rsi,%rbp,8),%xmm1
mulsd  (%rsi,%rbp,8),%xmm6
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm6
add    $0x2,%rbp
movapd %xmm6,%xmm0
cmp    %rbp,%r11
jne    13c0 <find_best_candidate+0x2c0>
mov    0x50(%rsp),%rax
movslq (%rax,%r10,4),%rbp
cmp    %ebp,%r11d
jge    1470 <find_best_candidate+0x370>
mov    %ebp,%r13d
sub    %r11d,%r13d
mov    %r11,%rdx
movapd %xmm6,%xmm7
test   $0x1,%r13b
je     1434 <find_best_candidate+0x334>
mov    %r15d,%edx
imul   %r10d,%edx
movslq %edx,%rdx
add    %r11,%rdx
mov    0x60(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm7
lea    (%r11,%r9,1),%rdx
mulsd  (%rdi,%rdx,8),%xmm7
addsd  %xmm6,%xmm7
lea    0x1(%r11),%rdx
not    %r11
add    %rbp,%r11
je     1234 <find_best_candidate+0x134>
movsd  -0x8(%rbx,%rdx,8),%xmm0
movsd  (%rbx,%rdx,8),%xmm1
mulsd  -0x8(%rsi,%rdx,8),%xmm0
mulsd  (%rsi,%rdx,8),%xmm1
addsd  %xmm7,%xmm0
movapd %xmm1,%xmm7
addsd  %xmm0,%xmm7
add    $0x2,%rdx
cmp    %rdx,%rbp
jne    1440 <find_best_candidate+0x340>
jmp    1234 <find_best_candidate+0x134>
movapd %xmm6,%xmm7
jmp    1234 <find_best_candidate+0x134>
nopl   0x0(%rax)
test   %r14d,%r14d
jle    17a0 <find_best_candidate+0x6a0>
mov    0x70(%rsp),%rax
mov    (%rax),%r8d
mov    -0x30(%rsp),%rax
movslq (%rax),%r15
mov    %r15d,%eax
imul   %esi,%eax
movslq %eax,%r13
lea    0x0(,%r15,8),%r9
mov    -0x38(%rsp),%rax
lea    (%rax,%r13,8),%rbx
xorpd  %xmm12,%xmm12
mov    -0x28(%rsp),%r12
xor    %edx,%edx
xorpd  %xmm13,%xmm13
xorpd  %xmm6,%xmm6
jmp    14ff <find_best_candidate+0x3ff>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
subsd  %xmm7,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm13
divsd  %xmm14,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm1,%xmm12
add    $0x1,%rdx
add    %r9,%r12
cmp    %r14,%rdx
je     17aa <find_best_candidate+0x6aa>
test   %r8d,%r8d
je     1530 <find_best_candidate+0x430>
mov    0x50(%rsp),%rax
mov    (%rax,%rdx,4),%r11d
test   %r11d,%r11d
jle    1560 <find_best_candidate+0x460>
cmp    $0x1,%r11d
jne    1569 <find_best_candidate+0x469>
xorpd  %xmm7,%xmm7
xor    %ebp,%ebp
jmp    15ad <find_best_candidate+0x4ad>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x58(%rsp),%rax
movslq (%rax,%rdx,4),%r10
movslq 0x4(%rax,%rdx,4),%rbp
cmp    %ebp,%r10d
jge    163d <find_best_candidate+0x53d>
mov    %ebp,%esi
sub    %r10d,%esi
test   $0x1,%sil
jne    15dc <find_best_candidate+0x4dc>
mov    %r10,%rsi
jmp    1601 <find_best_candidate+0x501>
xchg   %ax,%ax
xorpd  %xmm7,%xmm7
jmp    16d0 <find_best_candidate+0x5d0>
mov    %r11d,%eax
and    $0xfffffffe,%eax
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%r12,%rbp,8),%xmm1
movsd  (%r12,%rbp,8),%xmm7
mulsd  -0x8(%rbx,%rbp,8),%xmm1
mulsd  (%rbx,%rbp,8),%xmm7
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm7
add    $0x2,%rbp
movapd %xmm7,%xmm0
cmp    %rbp,%rax
jne    1580 <find_best_candidate+0x480>
test   $0x1,%r11b
je     16d0 <find_best_candidate+0x5d0>
mov    %rdx,%rax
imul   %r15,%rax
add    %rbp,%rax
mov    0x60(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
add    %r13,%rbp
mulsd  (%rdi,%rbp,8),%xmm0
addsd  %xmm0,%xmm7
jmp    16d0 <find_best_candidate+0x5d0>
mov    %rdx,%rsi
imul   %r15,%rsi
add    %r10,%rsi
mov    0x60(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm0
lea    (%r10,%r13,1),%rsi
mulsd  (%rdi,%rsi,8),%xmm0
addsd  %xmm0,%xmm6
lea    0x1(%r10),%rsi
movapd %xmm6,%xmm0
not    %r10
add    %rbp,%r10
je     163d <find_best_candidate+0x53d>
nopl   (%rax)
movsd  -0x8(%r12,%rsi,8),%xmm1
movsd  (%r12,%rsi,8),%xmm6
mulsd  -0x8(%rbx,%rsi,8),%xmm1
mulsd  (%rbx,%rsi,8),%xmm6
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm6
add    $0x2,%rsi
movapd %xmm6,%xmm0
cmp    %rsi,%rbp
jne    1610 <find_best_candidate+0x510>
mov    0x50(%rsp),%rax
mov    (%rax,%rdx,4),%r11d
cmp    %r11d,%ebp
jge    16bf <find_best_candidate+0x5bf>
mov    %r11d,%esi
sub    %ebp,%esi
mov    %rbp,%rax
movapd %xmm6,%xmm7
test   $0x1,%sil
je     1684 <find_best_candidate+0x584>
mov    %rdx,%rax
imul   %r15,%rax
add    %rbp,%rax
mov    0x60(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm7
mov    %rbp,%rax
add    %r13,%rax
mulsd  (%rdi,%rax,8),%xmm7
addsd  %xmm6,%xmm7
lea    0x1(%rbp),%rax
movslq %r11d,%rsi
not    %rbp
add    %rsi,%rbp
je     16d0 <find_best_candidate+0x5d0>
nop
movsd  -0x8(%r12,%rax,8),%xmm0
movsd  (%r12,%rax,8),%xmm1
mulsd  -0x8(%rbx,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm1
addsd  %xmm7,%xmm0
movapd %xmm1,%xmm7
addsd  %xmm0,%xmm7
add    $0x2,%rax
cmp    %rax,%rsi
jne    1690 <find_best_candidate+0x590>
jmp    16d0 <find_best_candidate+0x5d0>
movapd %xmm6,%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x68(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm14
divsd  %xmm14,%xmm7
mov    0x48(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm2
movslq (%rcx,%rdx,4),%rax
add    %r13,%rax
movsd  (%rdi,%rax,8),%xmm3
test   %r11d,%r11d
jle    14d0 <find_best_candidate+0x3d0>
mov    %r11d,%ebp
cmp    $0x1,%r11d
jne    1710 <find_best_candidate+0x610>
xorpd  %xmm1,%xmm1
xor    %esi,%esi
jmp    1761 <find_best_candidate+0x661>
mov    %ebp,%eax
and    $0xfffffffe,%eax
xorpd  %xmm1,%xmm1
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%rsi,8),%xmm5
movsd  (%rbx,%rsi,8),%xmm4
subsd  %xmm7,%xmm5
movsd  -0x8(%r12,%rsi,8),%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm1,%xmm0
subsd  %xmm7,%xmm4
movsd  (%r12,%rsi,8),%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1720 <find_best_candidate+0x620>
test   $0x1,%bpl
je     14d4 <find_best_candidate+0x3d4>
mov    %rdx,%rax
imul   %r15,%rax
add    %rsi,%rax
add    %r13,%rsi
movsd  (%rdi,%rsi,8),%xmm0
subsd  %xmm7,%xmm0
mov    0x60(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm4,%xmm1
jmp    14d4 <find_best_candidate+0x3d4>
nopl   0x0(%rax)
xorpd  %xmm13,%xmm13
xorpd  %xmm12,%xmm12
mov    0xc8(%rsp),%rax
mov    -0x10(%rsp),%rbx
movsd  %xmm13,(%rax,%rbx,8)
mov    0xd0(%rsp),%rax
movsd  %xmm12,(%rax,%rbx,8)
mov    0x78(%rsp),%rdx
movsd  (%rdx,%rbx,8),%xmm1
addsd  %xmm12,%xmm1
movapd %xmm13,%xmm0
divsd  %xmm1,%xmm0
mov    0xc0(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
movapd %xmm8,%xmm1
cmpl   $0x0,-0x44(%rsp)
je     1801 <find_best_candidate+0x701>
movsd  (%rdx,%rbx,8),%xmm1
mulsd  %xmm13,%xmm13
addsd  %xmm1,%xmm12
divsd  %xmm12,%xmm13
mov    -0x8(%rsp),%rbp
test   %rbp,%rbp
sete   %al
ucomisd %xmm10,%xmm13
seta   %dl
mov    0xb8(%rsp),%rsi
movsd  %xmm13,(%rsi,%rbx,8)
or     %al,%dl
lea    0x1(%rbx),%eax
test   %dl,%dl
jne    1190 <find_best_candidate+0x90>
movapd %xmm10,%xmm13
movapd %xmm9,%xmm0
jmp    1190 <find_best_candidate+0x90>
mov    0xa8(%rsp),%rax
mov    %edx,(%rax)
mov    0xb0(%rsp),%rax
movsd  %xmm0,(%rax)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @find_best_candidate(double* %0, i32* %1, i32* %2, i32* %3, i32* %4, double* %5, double* %6, double* %7, double* %8, i32* %9, i32* %10, double* %11, double* %12, i32* %13, double* %14, i32* %15, i32* %16, i32* %17, i32* %18, i32* %19, i32* %20, double* %21, double* %22, double* %23, double* %24, double* %25) {
%27 = alloca double*
%28 = alloca i32*
%29 = alloca i32*
%30 = alloca i32*
%31 = alloca i32*
%32 = alloca double*
%33 = alloca double*
%34 = alloca double*
%35 = alloca double*
%36 = alloca i32*
%37 = alloca i32*
%38 = alloca double*
%39 = alloca double*
%40 = alloca i32*
%41 = alloca double*
%42 = alloca i32*
%43 = alloca i32*
%44 = alloca i32*
%45 = alloca i32*
%46 = alloca i32*
%47 = alloca i32*
%48 = alloca double*
%49 = alloca double*
%50 = alloca double*
%51 = alloca double*
%52 = alloca double*
%53 = alloca i32
%54 = alloca i32
%55 = alloca i32
%56 = alloca i32
%57 = alloca double
%58 = alloca double
%59 = alloca double
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca double
%65 = alloca double
%66 = alloca double
%67 = alloca double
%68 = alloca i32
%69 = alloca double
store double* %0, double** %27
store i32* %1, i32** %28
store i32* %2, i32** %29
store i32* %3, i32** %30
store i32* %4, i32** %31
store double* %5, double** %32
store double* %6, double** %33
store double* %7, double** %34
store double* %8, double** %35
store i32* %9, i32** %36
store i32* %10, i32** %37
store double* %11, double** %38
store double* %12, double** %39
store i32* %13, i32** %40
store double* %14, double** %41
store i32* %15, i32** %42
store i32* %16, i32** %43
store i32* %17, i32** %44
store i32* %18, i32** %45
store i32* %19, i32** %46
store i32* %20, i32** %47
store double* %21, double** %48
store double* %22, double** %49
store double* %23, double** %50
store double* %24, double** %51
store double* %25, double** %52
store double 9.000000e+00, double* %69
%70 = load i32*, i32** %46
store i32 0, i32* %70
store i32 0, i32* %53
br label %71
71: ; preds = %581, %26
%72 = load i32, i32* %53
%73 = load i32*, i32** %44
%74 = load i32, i32* %73
%75 = icmp slt i32 %72, %74
br i1 %75, label %76, label %584
76: ; preds = %71
%77 = load i32*, i32** %43
%78 = load i32, i32* %53
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
%81 = load i32, i32* %80
store i32 %81, i32* %54
store double 0.000000e+00, double* %60
store double 0.000000e+00, double* %61
%82 = load i32*, i32** %45
%83 = load i32, i32* %82
%84 = icmp ne i32 %83, 0
br i1 %84, label %85, label %283
85: ; preds = %76
store double 0.000000e+00, double* %64
store i32 0, i32* %55
br label %86
86: ; preds = %279, %85
%87 = load i32, i32* %55
%88 = load i32*, i32** %31
%89 = load i32, i32* %88
%90 = icmp slt i32 %87, %89
br i1 %90, label %91, label %282
91: ; preds = %86
%92 = load i32*, i32** %40
%93 = load i32, i32* %92
%94 = icmp ne i32 %93, 0
br i1 %94, label %95, label %131
95: ; preds = %91
store double 0.000000e+00, double* %63
store i32 0, i32* %56
br label %96
96: ; preds = %127, %95
%97 = load i32, i32* %56
%98 = load i32*, i32** %36
%99 = load i32, i32* %55
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i32, i32* %98, i64 %100
%102 = load i32, i32* %101
%103 = icmp slt i32 %97, %102
br i1 %103, label %104, label %130
104: ; preds = %96
%105 = load double*, double** %38
%106 = load i32, i32* %55
%107 = load i32*, i32** %28
%108 = load i32, i32* %107
%109 = mul nsw i32 %106, %108
%110 = load i32, i32* %56
%111 = add nsw i32 %109, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %105, i64 %112
%114 = load double, double* %113
%115 = load double*, double** %27
%116 = load i32, i32* %54
%117 = load i32*, i32** %28
%118 = load i32, i32* %117
%119 = mul nsw i32 %116, %118
%120 = load i32, i32* %56
%121 = add nsw i32 %119, %120
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %115, i64 %122
%124 = load double, double* %123
%125 = load double, double* %63
%126 = call double @llvm.fmuladd.f64(double %114, double %124, double %125)
store double %126, double* %63
br label %127
127: ; preds = %104
%128 = load i32, i32* %56
%129 = add nsw i32 %128, 1
store i32 %129, i32* %56
br label %96
130: ; preds = %96
br label %216
131: ; preds = %91
%132 = load double, double* %64
store double %132, double* %63
%133 = load i32*, i32** %37
%134 = load i32, i32* %55
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %133, i64 %135
%137 = load i32, i32* %136
store i32 %137, i32* %56
br label %138
138: ; preds = %170, %131
%139 = load i32, i32* %56
%140 = load i32*, i32** %37
%141 = load i32, i32* %55
%142 = add nsw i32 %141, 1
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i32, i32* %140, i64 %143
%145 = load i32, i32* %144
%146 = icmp slt i32 %139, %145
br i1 %146, label %147, label %173
147: ; preds = %138
%148 = load double*, double** %38
%149 = load i32, i32* %55
%150 = load i32*, i32** %28
%151 = load i32, i32* %150
%152 = mul nsw i32 %149, %151
%153 = load i32, i32* %56
%154 = add nsw i32 %152, %153
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %148, i64 %155
%157 = load double, double* %156
%158 = load double*, double** %27
%159 = load i32, i32* %54
%160 = load i32*, i32** %28
%161 = load i32, i32* %160
%162 = mul nsw i32 %159, %161
%163 = load i32, i32* %56
%164 = add nsw i32 %162, %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %158, i64 %165
%167 = load double, double* %166
%168 = load double, double* %63
%169 = call double @llvm.fmuladd.f64(double %157, double %167, double %168)
store double %169, double* %63
br label %170
170: ; preds = %147
%171 = load i32, i32* %56
%172 = add nsw i32 %171, 1
store i32 %172, i32* %56
br label %138
173: ; preds = %138
%174 = load double, double* %63
store double %174, double* %64
%175 = load i32*, i32** %37
%176 = load i32, i32* %55
%177 = add nsw i32 %176, 1
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds i32, i32* %175, i64 %178
%180 = load i32, i32* %179
store i32 %180, i32* %56
br label %181
181: ; preds = %212, %173
%182 = load i32, i32* %56
%183 = load i32*, i32** %36
%184 = load i32, i32* %55
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i32, i32* %183, i64 %185
%187 = load i32, i32* %186
%188 = icmp slt i32 %182, %187
br i1 %188, label %189, label %215
189: ; preds = %181
%190 = load double*, double** %38
%191 = load i32, i32* %55
%192 = load i32*, i32** %28
%193 = load i32, i32* %192
%194 = mul nsw i32 %191, %193
%195 = load i32, i32* %56
%196 = add nsw i32 %194, %195
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds double, double* %190, i64 %197
%199 = load double, double* %198
%200 = load double*, double** %27
%201 = load i32, i32* %54
%202 = load i32*, i32** %28
%203 = load i32, i32* %202
%204 = mul nsw i32 %201, %203
%205 = load i32, i32* %56
%206 = add nsw i32 %204, %205
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %200, i64 %207
%209 = load double, double* %208
%210 = load double, double* %63
%211 = call double @llvm.fmuladd.f64(double %199, double %209, double %210)
store double %211, double* %63
br label %212
212: ; preds = %189
%213 = load i32, i32* %56
%214 = add nsw i32 %213, 1
store i32 %214, i32* %56
br label %181
215: ; preds = %181
br label %216
216: ; preds = %215, %130
%217 = load double, double* %63
%218 = load double*, double** %39
%219 = load i32, i32* %55
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds double, double* %218, i64 %220
%222 = load double, double* %221
%223 = fdiv double %217, %222
store double %223, double* %57
%224 = load double*, double** %35
%225 = load i32, i32* %55
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %224, i64 %226
%228 = load double, double* %227
%229 = load double*, double** %27
%230 = load i32, i32* %54
%231 = load i32*, i32** %28
%232 = load i32, i32* %231
%233 = mul nsw i32 %230, %232
%234 = load i32*, i32** %30
%235 = load i32, i32* %55
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds i32, i32* %234, i64 %236
%238 = load i32, i32* %237
%239 = add nsw i32 %233, %238
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %229, i64 %240
%242 = load double, double* %241
%243 = load double, double* %57
%244 = fsub double %242, %243
%245 = load double, double* %60
%246 = call double @llvm.fmuladd.f64(double %228, double %244, double %245)
store double %246, double* %60
%247 = load double*, double** %35
%248 = load i32, i32* %55
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %247, i64 %249
%251 = load double, double* %250
%252 = load double, double* %57
%253 = load double, double* %57
%254 = fmul double %252, %253
%255 = load double*, double** %39
%256 = load i32, i32* %55
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double, double* %255, i64 %257
%259 = load double, double* %258
%260 = load double, double* %63
%261 = fsub double %259, %260
%262 = load double, double* %57
%263 = fsub double 1.000000e+00, %262
%264 = load double, double* %57
%265 = fsub double 1.000000e+00, %264
%266 = fmul double %263, %265
%267 = load double, double* %63
%268 = fmul double %266, %267
%269 = call double @llvm.fmuladd.f64(double %254, double %261, double %268)
%270 = fmul double %251, %269
%271 = load double*, double** %39
%272 = load i32, i32* %55
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds double, double* %271, i64 %273
%275 = load double, double* %274
%276 = fdiv double %270, %275
%277 = load double, double* %61
%278 = fadd double %277, %276
store double %278, double* %61
br label %279
279: ; preds = %216
%280 = load i32, i32* %55
%281 = add nsw i32 %280, 1
store i32 %281, i32* %55
br label %86
282: ; preds = %86
br label %514
283: ; preds = %76
store double 0.000000e+00, double* %58
store i32 0, i32* %55
br label %284
284: ; preds = %510, %283
%285 = load i32, i32* %55
%286 = load i32*, i32** %31
%287 = load i32, i32* %286
%288 = icmp slt i32 %285, %287
br i1 %288, label %289, label %513
289: ; preds = %284
%290 = load i32*, i32** %40
%291 = load i32, i32* %290
%292 = icmp ne i32 %291, 0
br i1 %292, label %293, label %329
293: ; preds = %289
store double 0.000000e+00, double* %57
store i32 0, i32* %56
br label %294
294: ; preds = %325, %293
%295 = load i32, i32* %56
%296 = load i32*, i32** %36
%297 = load i32, i32* %55
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds i32, i32* %296, i64 %298
%300 = load i32, i32* %299
%301 = icmp slt i32 %295, %300
br i1 %301, label %302, label %328
302: ; preds = %294
%303 = load double*, double** %38
%304 = load i32, i32* %55
%305 = load i32*, i32** %28
%306 = load i32, i32* %305
%307 = mul nsw i32 %304, %306
%308 = load i32, i32* %56
%309 = add nsw i32 %307, %308
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds double, double* %303, i64 %310
%312 = load double, double* %311
%313 = load double*, double** %27
%314 = load i32, i32* %54
%315 = load i32*, i32** %28
%316 = load i32, i32* %315
%317 = mul nsw i32 %314, %316
%318 = load i32, i32* %56
%319 = add nsw i32 %317, %318
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %313, i64 %320
%322 = load double, double* %321
%323 = load double, double* %57
%324 = call double @llvm.fmuladd.f64(double %312, double %322, double %323)
store double %324, double* %57
br label %325
325: ; preds = %302
%326 = load i32, i32* %56
%327 = add nsw i32 %326, 1
store i32 %327, i32* %56
br label %294
328: ; preds = %294
br label %414
329: ; preds = %289
%330 = load double, double* %58
store double %330, double* %57
%331 = load i32*, i32** %37
%332 = load i32, i32* %55
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds i32, i32* %331, i64 %333
%335 = load i32, i32* %334
store i32 %335, i32* %56
br label %336
336: ; preds = %368, %329
%337 = load i32, i32* %56
%338 = load i32*, i32** %37
%339 = load i32, i32* %55
%340 = add nsw i32 %339, 1
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i32, i32* %338, i64 %341
%343 = load i32, i32* %342
%344 = icmp slt i32 %337, %343
br i1 %344, label %345, label %371
345: ; preds = %336
%346 = load double*, double** %38
%347 = load i32, i32* %55
%348 = load i32*, i32** %28
%349 = load i32, i32* %348
%350 = mul nsw i32 %347, %349
%351 = load i32, i32* %56
%352 = add nsw i32 %350, %351
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds double, double* %346, i64 %353
%355 = load double, double* %354
%356 = load double*, double** %27
%357 = load i32, i32* %54
%358 = load i32*, i32** %28
%359 = load i32, i32* %358
%360 = mul nsw i32 %357, %359
%361 = load i32, i32* %56
%362 = add nsw i32 %360, %361
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds double, double* %356, i64 %363
%365 = load double, double* %364
%366 = load double, double* %57
%367 = call double @llvm.fmuladd.f64(double %355, double %365, double %366)
store double %367, double* %57
br label %368
368: ; preds = %345
%369 = load i32, i32* %56
%370 = add nsw i32 %369, 1
store i32 %370, i32* %56
br label %336
371: ; preds = %336
%372 = load double, double* %57
store double %372, double* %58
%373 = load i32*, i32** %37
%374 = load i32, i32* %55
%375 = add nsw i32 %374, 1
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds i32, i32* %373, i64 %376
%378 = load i32, i32* %377
store i32 %378, i32* %56
br label %379
379: ; preds = %410, %371
%380 = load i32, i32* %56
%381 = load i32*, i32** %36
%382 = load i32, i32* %55
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds i32, i32* %381, i64 %383
%385 = load i32, i32* %384
%386 = icmp slt i32 %380, %385
br i1 %386, label %387, label %413
387: ; preds = %379
%388 = load double*, double** %38
%389 = load i32, i32* %55
%390 = load i32*, i32** %28
%391 = load i32, i32* %390
%392 = mul nsw i32 %389, %391
%393 = load i32, i32* %56
%394 = add nsw i32 %392, %393
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds double, double* %388, i64 %395
%397 = load double, double* %396
%398 = load double*, double** %27
%399 = load i32, i32* %54
%400 = load i32*, i32** %28
%401 = load i32, i32* %400
%402 = mul nsw i32 %399, %401
%403 = load i32, i32* %56
%404 = add nsw i32 %402, %403
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds double, double* %398, i64 %405
%407 = load double, double* %406
%408 = load double, double* %57
%409 = call double @llvm.fmuladd.f64(double %397, double %407, double %408)
store double %409, double* %57
br label %410
410: ; preds = %387
%411 = load i32, i32* %56
%412 = add nsw i32 %411, 1
store i32 %412, i32* %56
br label %379
413: ; preds = %379
br label %414
414: ; preds = %413, %328
%415 = load double*, double** %39
%416 = load i32, i32* %55
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds double, double* %415, i64 %417
%419 = load double, double* %418
%420 = load double, double* %57
%421 = fdiv double %420, %419
store double %421, double* %57
%422 = load double*, double** %35
%423 = load i32, i32* %55
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds double, double* %422, i64 %424
%426 = load double, double* %425
%427 = load double*, double** %27
%428 = load i32, i32* %54
%429 = load i32*, i32** %28
%430 = load i32, i32* %429
%431 = mul nsw i32 %428, %430
%432 = load i32*, i32** %30
%433 = load i32, i32* %55
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds i32, i32* %432, i64 %434
%436 = load i32, i32* %435
%437 = add nsw i32 %431, %436
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds double, double* %427, i64 %438
%440 = load double, double* %439
%441 = load double, double* %57
%442 = fsub double %440, %441
%443 = load double, double* %60
%444 = call double @llvm.fmuladd.f64(double %426, double %442, double %443)
store double %444, double* %60
store double 0.000000e+00, double* %59
store i32 0, i32* %56
br label %445
445: ; preds = %491, %414
%446 = load i32, i32* %56
%447 = load i32*, i32** %36
%448 = load i32, i32* %55
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds i32, i32* %447, i64 %449
%451 = load i32, i32* %450
%452 = icmp slt i32 %446, %451
br i1 %452, label %453, label %494
453: ; preds = %445
%454 = load double*, double** %38
%455 = load i32, i32* %55
%456 = load i32*, i32** %28
%457 = load i32, i32* %456
%458 = mul nsw i32 %455, %457
%459 = load i32, i32* %56
%460 = add nsw i32 %458, %459
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double, double* %454, i64 %461
%463 = load double, double* %462
%464 = load double*, double** %27
%465 = load i32, i32* %54
%466 = load i32*, i32** %28
%467 = load i32, i32* %466
%468 = mul nsw i32 %465, %467
%469 = load i32, i32* %56
%470 = add nsw i32 %468, %469
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds double, double* %464, i64 %471
%473 = load double, double* %472
%474 = load double, double* %57
%475 = fsub double %473, %474
%476 = fmul double %463, %475
%477 = load double*, double** %27
%478 = load i32, i32* %54
%479 = load i32*, i32** %28
%480 = load i32, i32* %479
%481 = mul nsw i32 %478, %480
%482 = load i32, i32* %56
%483 = add nsw i32 %481, %482
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds double, double* %477, i64 %484
%486 = load double, double* %485
%487 = load double, double* %57
%488 = fsub double %486, %487
%489 = load double, double* %59
%490 = call double @llvm.fmuladd.f64(double %476, double %488, double %489)
store double %490, double* %59
br label %491
491: ; preds = %453
%492 = load i32, i32* %56
%493 = add nsw i32 %492, 1
store i32 %493, i32* %56
br label %445
494: ; preds = %445
%495 = load double*, double** %39
%496 = load i32, i32* %55
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds double, double* %495, i64 %497
%499 = load double, double* %498
%500 = load double, double* %59
%501 = fdiv double %500, %499
store double %501, double* %59
%502 = load double*, double** %35
%503 = load i32, i32* %55
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds double, double* %502, i64 %504
%506 = load double, double* %505
%507 = load double, double* %59
%508 = load double, double* %61
%509 = call double @llvm.fmuladd.f64(double %506, double %507, double %508)
store double %509, double* %61
br label %510
510: ; preds = %494
%511 = load i32, i32* %55
%512 = add nsw i32 %511, 1
store i32 %512, i32* %55
br label %284
513: ; preds = %284
br label %514
514: ; preds = %513, %282
%515 = load double, double* %60
%516 = load double*, double** %51
%517 = load i32, i32* %54
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds double, double* %516, i64 %518
store double %515, double* %519
%520 = load double, double* %61
%521 = load double*, double** %52
%522 = load i32, i32* %54
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds double, double* %521, i64 %523
store double %520, double* %524
%525 = load double, double* %60
%526 = load double, double* %61
%527 = load double*, double** %41
%528 = load i32, i32* %54
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds double, double* %527, i64 %529
%531 = load double, double* %530
%532 = fadd double %526, %531
%533 = fdiv double %525, %532
store double %533, double* %62
%534 = load double*, double** %50
%535 = load i32, i32* %54
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds double, double* %534, i64 %536
store double %533, double* %537
%538 = load i32*, i32** %42
%539 = load i32, i32* %538
%540 = icmp ne i32 %539, 0
br i1 %540, label %541, label %557
541: ; preds = %514
%542 = load double, double* %60
%543 = load double, double* %60
%544 = fmul double %542, %543
%545 = load double, double* %61
%546 = load double*, double** %41
%547 = load i32, i32* %54
%548 = sext i32 %547 to i64
%549 = getelementptr inbounds double, double* %546, i64 %548
%550 = load double, double* %549
%551 = fadd double %545, %550
%552 = fdiv double %544, %551
store double %552, double* %65
%553 = load double*, double** %49
%554 = load i32, i32* %54
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds double, double* %553, i64 %555
store double %552, double* %556
br label %568
557: ; preds = %514
%558 = load double, double* %60
%559 = load double, double* %60
%560 = fmul double %558, %559
%561 = load double, double* %61
%562 = fadd double %561, 9.000000e+00
%563 = fdiv double %560, %562
store double %563, double* %65
%564 = load double*, double** %49
%565 = load i32, i32* %54
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds double, double* %564, i64 %566
store double %563, double* %567
br label %568
568: ; preds = %557, %541
%569 = load i32, i32* %53
%570 = icmp eq i32 %569, 0
br i1 %570, label %575, label %571
571: ; preds = %568
%572 = load double, double* %65
%573 = load double, double* %66
%574 = fcmp ogt double %572, %573
br i1 %574, label %575, label %580
575: ; preds = %571, %568
%576 = load i32, i32* %54
%577 = add nsw i32 %576, 1
store i32 %577, i32* %68
%578 = load double, double* %65
store double %578, double* %66
%579 = load double, double* %62
store double %579, double* %67
br label %580
580: ; preds = %575, %571
br label %581
581: ; preds = %580
%582 = load i32, i32* %53
%583 = add nsw i32 %582, 1
store i32 %583, i32* %53
br label %71
584: ; preds = %71
%585 = load i32, i32* %68
%586 = load i32*, i32** %47
store i32 %585, i32* %586
%587 = load double, double* %67
%588 = load double*, double** %48
store double %587, double* %588
ret void
}

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