double *minimize(double x[], double y[], int n, int k) {
  double **simplex = create_simplex(n);
  double *function_values = (double *)malloc((n + 1) * sizeof(double));
  function_values = call_functions(x, y, simplex, n, k);
  int worst, second_worst, best;
  double min, max;
  int i, j;
  double *centroid = (double *)malloc(n * sizeof(double));
  double alpha = 1, beta = 0.5, gamma = 2, delta = 0.5;
  double *vertex_r = (double *)malloc(n * sizeof(double));
  double f_r;
  double *vertex_e = (double *)malloc(n * sizeof(double));
  double f_e;
  double *vertex_c = (double *)malloc(n * sizeof(double));
  double f_c;
  int intterations_max = 5000;
  int itteration = 0;
  double conv_test;
  double diff = 42.0;
  do {
    worst = 0, second_worst = 0, best = 0;
    min = function_values[0], max = function_values[0];
    for (i = 1; i < (n + 1); i++) {
      if (min >= function_values[i]) {
        min = function_values[i];
        best = i;
      }
      if (max <= function_values[i]) {
        max = function_values[i];
        second_worst = worst;
        worst = i;
      }
    }
    for (i = 0; i < n; i++)
      centroid[i] = 0.0;
    for (i = 0; i < n; i++) {
      for (j = 0; j < (n + 1); j++) {
        if (j != worst) {
          centroid[i] += simplex[j][i];
        }
      }
      centroid[i] = centroid[i] / n;
    }
    for (i = 0; i < n; i++) {
      vertex_r[i] = centroid[i] + alpha * (centroid[i] - simplex[worst][i]);
    }
    f_r = objective_function(x, y, vertex_r, n, k);
    if (function_values[best] <= f_r && f_r < function_values[second_worst]) {
      for (i = 0; i < n; i++) {
        simplex[worst][i] = vertex_r[i];
      }
      function_values[worst] = f_r;
    } else if (f_r < function_values[best]) {
      for (i = 0; i < n; i++) {
        vertex_e[i] = centroid[i] + gamma * (vertex_r[i] - centroid[i]);
      }
      f_e = objective_function(x, y, vertex_e, n, k);
      if (f_e < f_r) {
        for (i = 0; i < n; i++) {
          simplex[worst][i] = vertex_e[i];
        }
        function_values[worst] = f_e;
      } else if (f_e >= f_r) {
        for (i = 0; i < n; i++) {
          simplex[worst][i] = vertex_e[i];
        }
        function_values[worst] = f_e;
      }
    } else if (f_r >= function_values[second_worst]) {
      if (function_values[second_worst] <= f_r &&
          f_r < function_values[worst]) {
        for (i = 0; i < n; i++) {
          vertex_c[i] = centroid[i] + beta * (vertex_r[i] - centroid[i]);
        }
        f_c = objective_function(x, y, vertex_c, n, k);
        if (f_c <= f_r) {
          for (i = 0; i < n; i++) {
            simplex[worst][i] = vertex_c[i];
          }
          function_values[worst] = f_c;
        }
      } else if (f_r >= function_values[worst]) {
        for (i = 0; i < n; i++) {
          vertex_c[i] = centroid[i] + beta * (simplex[worst][i] - centroid[i]);
        }
        f_c = objective_function(x, y, vertex_c, n, k);
        if (f_c < function_values[worst]) {
          for (i = 0; i < n; i++) {
            simplex[worst][i] = vertex_c[i];
          }
          function_values[worst] = f_c;
        }
      } else {
        for (i = 0; i < (n + 1); i++) {
          if (i != best) {
            for (j = 0; i < n; j++) {
              simplex[i][j] =
                  simplex[best][j] + delta * (simplex[i][j] - simplex[best][j]);
            }
          }
        }
        function_values = call_functions(x, y, simplex, n, k);
      }
    }
    if (itteration % 42 == 0) {
      if (itteration > 0) {
        diff = fabs(conv_test - function_values[best]);
      }
      conv_test = function_values[best];
    }
    itteration++;
  } while (itteration < intterations_max && diff > 0.0001);
  if (itteration == intterations_max) {
    printf("The algorithm has not converge.\n");
  }
  return simplex[best];
}


x86 assembly (clang, -O0):
<minimize>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%edi
mov    $0x0,%al
call   1030 <create_simplex@plt>
cltq
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%r8d
mov    $0x0,%al
call   1040 <call_functions@plt>
cltq
mov    %rax,-0x28(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
movsd  0xe50(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xe33(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0xe2e(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xe19(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x80(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movl   $0x1388,-0xac(%rbp)
movl   $0x0,-0xb0(%rbp)
movsd  0xdb7(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1315 <minimize+0x1c5>
movsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     12c8 <minimize+0x178>
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x34(%rbp)
movsd  -0x48(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1302 <minimize+0x1b2>
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1307 <minimize+0x1b7>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1287 <minimize+0x137>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1346 <minimize+0x1f6>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    131c <minimize+0x1cc>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13e8 <minimize+0x298>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    13b7 <minimize+0x267>
mov    -0x50(%rbp),%eax
cmp    -0x2c(%rbp),%eax
je     13a4 <minimize+0x254>
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    13a9 <minimize+0x259>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1360 <minimize+0x210>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    134d <minimize+0x1fd>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1452 <minimize+0x302>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13ef <minimize+0x29f>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x80(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%r8d
mov    $0x0,%al
call   1070 <objective_function@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1513 <minimize+0x3c3>
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1513 <minimize+0x3c3>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14f9 <minimize+0x3a9>
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14bd <minimize+0x36d>
movsd  -0x88(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a38 <minimize+0x8e8>
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    16b5 <minimize+0x565>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1597 <minimize+0x447>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1539 <minimize+0x3e9>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x90(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%r8d
mov    $0x0,%al
call   1070 <objective_function@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    163a <minimize+0x4ea>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1620 <minimize+0x4d0>
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    15e1 <minimize+0x491>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16b0 <minimize+0x560>
movsd  -0x98(%rbp),%xmm0
ff
ucomisd -0x88(%rbp),%xmm0
ff
jb     16ab <minimize+0x55b>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1696 <minimize+0x546>
mov    -0x90(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1657 <minimize+0x507>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16b0 <minimize+0x560>
jmp    1a33 <minimize+0x8e3>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1a2e <minimize+0x8de>
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1816 <minimize+0x6c6>
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1816 <minimize+0x6c6>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1773 <minimize+0x623>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1715 <minimize+0x5c5>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0xa0(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%r8d
mov    $0x0,%al
call   1070 <objective_function@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1811 <minimize+0x6c1>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17fc <minimize+0x6ac>
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    17bd <minimize+0x66d>
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a29 <minimize+0x8d9>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1946 <minimize+0x7f6>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    189e <minimize+0x74e>
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x58(%rbp),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1838 <minimize+0x6e8>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0xa0(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%r8d
mov    $0x0,%al
call   1070 <objective_function@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1941 <minimize+0x7f1>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    192c <minimize+0x7dc>
mov    -0xa0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    18ed <minimize+0x79d>
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a24 <minimize+0x8d4>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1a04 <minimize+0x8b4>
mov    -0x4c(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     19f1 <minimize+0x8a1>
movl   $0x0,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    19ec <minimize+0x89c>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1971 <minimize+0x821>
jmp    19f1 <minimize+0x8a1>
jmp    19f6 <minimize+0x8a6>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    194d <minimize+0x7fd>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%r8d
mov    $0x0,%al
call   1040 <call_functions@plt>
cltq
mov    %rax,-0x28(%rbp)
jmp    1a29 <minimize+0x8d9>
jmp    1a2e <minimize+0x8de>
jmp    1a33 <minimize+0x8e3>
jmp    1a38 <minimize+0x8e8>
mov    -0xb0(%rbp),%eax
mov    $0x2a,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1a99 <minimize+0x949>
cmpl   $0x0,-0xb0(%rbp)
jle    1a84 <minimize+0x934>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x5b8(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%ecx
xor    %eax,%eax
cmp    -0xac(%rbp),%ecx
mov    %al,-0xc1(%rbp)
jge    1adf <minimize+0x98f>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  0x54e(%rip),%xmm1
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xc1(%rbp)
mov    -0xc1(%rbp),%al
test   $0x1,%al
jne    1251 <minimize+0x101>
mov    -0xb0(%rbp),%eax
cmp    -0xac(%rbp),%eax
jne    1b0d <minimize+0x9bd>
lea    0x53a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<minimize>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %ecx,%r15d
mov    %edx,%r14d
mov    %rsi,%r12
mov    %rdi,%rbp
mov    %edx,%edi
xor    %eax,%eax
call   1030 <create_simplex@plt>
movslq %eax,%rbx
mov    %rbp,0x68(%rsp)
mov    %rbp,%rdi
mov    %r12,0x70(%rsp)
mov    %r12,%rsi
mov    %rbx,%rdx
mov    %r14d,%ecx
mov    %r15d,0x3c(%rsp)
mov    %r15d,%r8d
xor    %eax,%eax
call   1040 <call_functions@plt>
cltq
mov    %rax,0x28(%rsp)
movslq %r14d,%r15
lea    0x0(,%r15,8),%r12
mov    %r12,%rdi
call   1070 <malloc@plt>
mov    %rax,%rbp
mov    %r12,%rdi
call   1070 <malloc@plt>
mov    %rax,%r13
mov    %r12,%rdi
call   1070 <malloc@plt>
mov    %r12,%rdi
mov    %rax,%r12
call   1070 <malloc@plt>
mov    0x28(%rsp),%rdi
mov    %r13,%r9
mov    %r14d,%r8d
cvtsi2sd %r15d,%xmm0
movsd  %xmm0,0x118(%rsp)
mov    %r15d,%r10d
mov    %r10,0x40(%rsp)
mov    %r15,0x108(%rsp)
lea    0x1(%r15),%r13d
mov    %rax,%r15
lea    -0x1(%r13),%r11
mov    %r10d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x50(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x48(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %r11,%rsi
and    $0xfffffffffffffffe,%rsi
mov    %r13,0xb8(%rsp)
and    $0xfffffffe,%r13d
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
or     $0x2,%rax
and    %rdx,%rax
mov    %rax,0xa0(%rsp)
mov    %r10,%rax
neg    %rax
mov    %rax,0xe8(%rsp)
mov    %edx,%ecx
and    $0x3,%ecx
mov    %rdx,%rax
mov    %rdx,0x58(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x80(%rsp)
mov    %r10d,%eax
and    $0x3,%eax
mov    %rax,0x90(%rsp)
mov    %rcx,0x100(%rsp)
mov    %rcx,%r14
shl    $0x5,%r14
movsd  0x1d4c(%rip),%xmm0
movsd  %xmm0,0xf0(%rsp)
lea    0x0(,%r10,8),%rax
mov    %rax,0x110(%rsp)
lea    (%r12,%r10,8),%rax
mov    %rax,0xd8(%rsp)
lea    (%r15,%r10,8),%rax
mov    %rax,0xb0(%rsp)
lea    (%r9,%r10,8),%rax
mov    %rax,0xe0(%rsp)
lea    0x10(%r9),%rax
mov    %rax,0xf8(%rsp)
lea    0x10(%r15),%rax
mov    %rax,0xc8(%rsp)
lea    0x10(%r12),%rax
mov    %rax,0xd0(%rsp)
xor    %edx,%edx
mov    %r8d,0x24(%rsp)
mov    %r9,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r12,0xa8(%rsp)
mov    %r15,0x88(%rsp)
mov    %rsi,0x30(%rsp)
mov    %r14,0x60(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x0,%r12d
mov    $0x0,%r14d
mov    $0x0,%r15d
test   %r8d,%r8d
jle    147a <minimize+0x31a>
movsd  (%rdi),%xmm0
cmpl   $0x2,0xb8(%rsp)
02
jne    1390 <minimize+0x230>
xor    %r15d,%r15d
mov    $0x1,%eax
xor    %r14d,%r14d
xor    %r12d,%r12d
movapd %xmm0,%xmm1
jmp    1458 <minimize+0x2f8>
xor    %r15d,%r15d
mov    $0x1,%eax
xor    %r14d,%r14d
xor    %r12d,%r12d
movapd %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm3
movsd  0x8(%rdi,%rax,8),%xmm2
ucomisd %xmm3,%xmm0
movapd %xmm3,%xmm4
cmpnlesd %xmm0,%xmm4
movapd %xmm4,%xmm5
andnpd %xmm3,%xmm5
andpd  %xmm0,%xmm4
cmovae %eax,%r12d
orpd   %xmm5,%xmm4
ucomisd %xmm1,%xmm3
movapd %xmm1,%xmm5
cmpnlesd %xmm3,%xmm5
movapd %xmm5,%xmm0
andnpd %xmm3,%xmm0
andpd  %xmm1,%xmm5
cmovae %r15d,%r14d
orpd   %xmm0,%xmm5
cmovae %eax,%r15d
lea    0x1(%rax),%rcx
ucomisd %xmm2,%xmm4
movapd %xmm2,%xmm0
cmpnlesd %xmm4,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm4,%xmm1
andnpd %xmm2,%xmm0
orpd   %xmm1,%xmm0
cmovae %ecx,%r12d
ucomisd %xmm5,%xmm2
movapd %xmm5,%xmm1
cmpnlesd %xmm2,%xmm1
movapd %xmm1,%xmm3
andpd  %xmm5,%xmm3
andnpd %xmm2,%xmm1
orpd   %xmm3,%xmm1
cmovae %r15d,%r14d
cmovae %ecx,%r15d
add    $0x2,%rax
cmp    %rsi,%rcx
jne    13b0 <minimize+0x250>
test   $0x1,%r11b
je     147a <minimize+0x31a>
movsd  (%rdi,%rax,8),%xmm2
ucomisd %xmm2,%xmm0
cmovae %eax,%r12d
ucomisd %xmm1,%xmm2
cmovae %r15d,%r14d
cmovb  %r15d,%eax
mov    %eax,%r15d
mov    %rdx,0x18(%rsp)
mov    %rdi,0x28(%rsp)
test   %r8d,%r8d
jle    1750 <minimize+0x5f0>
mov    %rbp,%rdi
xor    %esi,%esi
mov    0x110(%rsp),%rdx
call   1060 <memset@plt>
mov    0x10(%rsp),%r11
mov    0x40(%rsp),%r10
movsd  0x118(%rsp),%xmm1
mov    0x24(%rsp),%r8d
mov    %r15d,%eax
xor    %ecx,%ecx
mov    0xb8(%rsp),%r9
jmp    14ed <minimize+0x38d>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
cmp    %r10,%rcx
je     1590 <minimize+0x430>
test   %r8d,%r8d
js     14d0 <minimize+0x370>
test   %r11,%r11
je     1560 <minimize+0x400>
xor    %esi,%esi
jmp    1509 <minimize+0x3a9>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %r13,%rsi
je     1550 <minimize+0x3f0>
mov    %rsi,%rdx
cmp    %rsi,%rax
je     1526 <minimize+0x3c6>
mov    (%rbx,%rdx,8),%rsi
movsd  (%rsi,%rcx,8),%xmm0
addsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
lea    0x1(%rdx),%rsi
cmp    %rax,%rsi
je     1500 <minimize+0x3a0>
mov    0x8(%rbx,%rdx,8),%rdi
movsd  (%rdi,%rcx,8),%xmm0
addsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
jmp    1500 <minimize+0x3a0>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rdx
test   $0x1,%r9b
jne    156c <minimize+0x40c>
jmp    14d0 <minimize+0x370>
nop
xor    %edx,%edx
test   $0x1,%r9b
je     14d0 <minimize+0x370>
cmp    %rax,%rdx
je     14d0 <minimize+0x370>
mov    (%rbx,%rdx,8),%rdx
movsd  (%rdx,%rcx,8),%xmm0
addsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
jmp    14d0 <minimize+0x370>
nop
test   %r8d,%r8d
mov    0x8(%rsp),%r9
jle    1750 <minimize+0x5f0>
movslq %r15d,%rax
mov    (%rbx,%rax,8),%rax
cmp    $0x4,%r8d
jb     15c6 <minimize+0x466>
lea    (%rax,%r10,8),%rcx
cmp    %rcx,%r9
jae    1652 <minimize+0x4f2>
cmp    %rax,0xe0(%rsp)
jbe    1652 <minimize+0x4f2>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r10b
je     15f1 <minimize+0x491>
movsd  0x0(%rbp,%rdx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0xe8(%rsp),%rdx
je     1750 <minimize+0x5f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x8(%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r9,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r10
jne    1610 <minimize+0x4b0>
jmp    1750 <minimize+0x5f0>
cmpq   $0x0,0x48(%rsp)
je     1cc7 <minimize+0xb67>
mov    0xa0(%rsp),%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
movapd %xmm0,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
addpd  %xmm0,%xmm4
addpd  %xmm1,%xmm2
movupd %xmm4,(%r9,%rcx,8)
movupd %xmm2,0x10(%r9,%rcx,8)
movupd 0x20(%rbp,%rcx,8),%xmm0
movupd 0x30(%rbp,%rcx,8),%xmm1
movupd 0x20(%rax,%rcx,8),%xmm2
movupd 0x30(%rax,%rcx,8),%xmm3
movapd %xmm0,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
addpd  %xmm0,%xmm4
addpd  %xmm1,%xmm2
movupd %xmm4,0x20(%r9,%rcx,8)
movupd %xmm2,0x30(%r9,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1670 <minimize+0x510>
testb  $0x1,0x58(%rsp)
je     173b <minimize+0x5db>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
movapd %xmm0,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
addpd  %xmm0,%xmm4
addpd  %xmm1,%xmm2
movupd %xmm4,(%r9,%rcx,8)
movupd %xmm2,0x10(%r9,%rcx,8)
mov    0x50(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r10,%rcx
jne    15c8 <minimize+0x468>
nopl   0x0(%rax)
mov    0x68(%rsp),%rdi
mov    0x70(%rsp),%rsi
mov    %r9,%rdx
mov    %r8d,%ecx
mov    0x3c(%rsp),%r8d
xor    %eax,%eax
call   1080 <objective_function@plt>
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
movslq %r12d,%rax
mov    0x28(%rsp),%rdi
mov    %rax,0xc0(%rsp)
movsd  (%rdi,%rax,8),%xmm0
ucomisd %xmm0,%xmm2
jb     1870 <minimize+0x710>
movslq %r14d,%rax
movsd  (%rdi,%rax,8),%xmm1
ucomisd %xmm2,%xmm1
jbe    1870 <minimize+0x710>
movslq %r15d,%r10
mov    0x24(%rsp),%r8d
test   %r8d,%r8d
mov    0x8(%rsp),%r9
mov    0x40(%rsp),%rax
mov    0x10(%rsp),%r11
mov    0x60(%rsp),%r14
jle    2030 <minimize+0xed0>
mov    (%rbx,%r10,8),%rcx
cmp    $0x4,%r8d
jb     17ee <minimize+0x68e>
cmp    %rcx,0xe0(%rsp)
jbe    1cb4 <minimize+0xb54>
lea    (%rcx,%rax,8),%rdx
cmp    %rdx,%r9
jae    1cb4 <minimize+0xb54>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rax,%rsi
mov    0x90(%rsp),%rdi
test   %rdi,%rdi
je     1825 <minimize+0x6c5>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r9,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1810 <minimize+0x6b0>
cmp    $0x3,%rsi
jb     2030 <minimize+0xed0>
nop
movsd  (%r9,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x8(%r9,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdx,8)
movsd  0x10(%r9,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rdx,8)
movsd  0x18(%r9,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    1830 <minimize+0x6d0>
jmp    2030 <minimize+0xed0>
ucomisd %xmm2,%xmm0
jbe    18b0 <minimize+0x750>
mov    0x24(%rsp),%ecx
test   %ecx,%ecx
mov    0x8(%rsp),%rsi
mov    0x40(%rsp),%rdi
movsd  %xmm2,0x98(%rsp)
jle    1926 <minimize+0x7c6>
cmp    $0x4,%ecx
jae    1968 <minimize+0x808>
xor    %eax,%eax
mov    0xa8(%rsp),%r12
jmp    1a70 <minimize+0x910>
nopl   (%rax)
movslq %r14d,%rax
ucomisd (%rdi,%rax,8),%xmm2
mov    0x24(%rsp),%r8d
mov    0x8(%rsp),%r9
mov    0x40(%rsp),%rsi
movsd  0x1739(%rip),%xmm4
jae    18db <minimize+0x77b>
mov    0x10(%rsp),%r11
jmp    203b <minimize+0xedb>
movslq %r15d,%r10
movsd  (%rdi,%r10,8),%xmm0
ucomisd %xmm2,%xmm0
movapd 0x1730(%rip),%xmm5
jbe    1b27 <minimize+0x9c7>
test   %r8d,%r8d
mov    %r10,0x78(%rsp)
movsd  %xmm2,0x98(%rsp)
jle    1d0a <minimize+0xbaa>
cmp    $0x4,%r8d
jae    1da0 <minimize+0xc40>
xor    %eax,%eax
mov    0x88(%rsp),%r15
jmp    1ea0 <minimize+0xd40>
mov    0x68(%rsp),%rdi
mov    0x70(%rsp),%rsi
mov    0xa8(%rsp),%rdx
mov    0x3c(%rsp),%r8d
xor    %eax,%eax
call   1080 <objective_function@plt>
movsd  0x98(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
ucomisd %xmm0,%xmm1
jbe    1b71 <minimize+0xa11>
mov    0x24(%rsp),%r8d
jmp    1b10 <minimize+0x9b0>
cmpq   $0x0,0x48(%rsp)
je     1c9a <minimize+0xb3a>
mov    0xa0(%rsp),%rdx
xor    %eax,%eax
mov    0xa8(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rax,8),%xmm0
movupd 0x10(%rbp,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
movupd 0x10(%rsi,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%r12,%rax,8)
movupd %xmm3,0x10(%r12,%rax,8)
movupd 0x20(%rbp,%rax,8),%xmm0
movupd 0x30(%rbp,%rax,8),%xmm1
movupd 0x20(%rsi,%rax,8),%xmm2
movupd 0x30(%rsi,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r12,%rax,8)
movupd %xmm3,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    1990 <minimize+0x830>
testb  $0x1,0x58(%rsp)
je     1a5b <minimize+0x8fb>
movupd 0x0(%rbp,%rax,8),%xmm0
movupd 0x10(%rbp,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
movupd 0x10(%rsi,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
addpd  %xmm2,%xmm2
addpd  %xmm0,%xmm2
addpd  %xmm3,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%r12,%rax,8)
movupd %xmm3,0x10(%r12,%rax,8)
mov    0x50(%rsp),%rdx
mov    %rdx,%rax
cmp    %rdi,%rdx
je     1a96 <minimize+0x936>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  (%rsi,%rax,8),%xmm1
subsd  %xmm0,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1a70 <minimize+0x910>
mov    0x68(%rsp),%rdi
mov    0x70(%rsp),%rsi
mov    %r12,%rdx
mov    %ecx,%r14d
mov    0x3c(%rsp),%r8d
xor    %eax,%eax
call   1080 <objective_function@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x98(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    1af7 <minimize+0x997>
test   %r14d,%r14d
mov    %r14d,%r8d
jle    1b10 <minimize+0x9b0>
movslq %r15d,%r10
mov    (%rbx,%r10,8),%rcx
cmp    $0x4,%r8d
jae    1cd9 <minimize+0xb79>
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x40(%rsp),%rax
mov    0x10(%rsp),%r11
jmp    2280 <minimize+0x1120>
ucomisd %xmm1,%xmm0
mov    0x60(%rsp),%r14
jae    1b99 <minimize+0xa39>
mov    0x24(%rsp),%r8d
jmp    1eff <minimize+0xd9f>
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
mov    0x18(%rsp),%rdx
movslq %r15d,%r10
jmp    26b0 <minimize+0x1550>
ucomisd %xmm0,%xmm2
jae    1bce <minimize+0xa6e>
test   %r8d,%r8d
mov    0xb8(%rsp),%rdx
js     1d68 <minimize+0xc08>
mov    %r12d,%eax
xor    %ecx,%ecx
jmp    1b5d <minimize+0x9fd>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    %rcx,%rdx
je     1d68 <minimize+0xc08>
cmp    %rcx,%rax
je     1b50 <minimize+0x9f0>
cmp    0x108(%rsp),%rcx
jge    1b50 <minimize+0x9f0>
jmp    2975 <minimize+0x1815>
ucomisd %xmm1,%xmm0
mov    0x24(%rsp),%r8d
mov    0x10(%rsp),%r11
mov    0x18(%rsp),%rdx
jae    1f4d <minimize+0xded>
mov    0x8(%rsp),%r9
mov    0x28(%rsp),%rdi
jmp    26bb <minimize+0x155b>
mov    0x24(%rsp),%r8d
test   %r8d,%r8d
jle    1f43 <minimize+0xde3>
movslq %r15d,%r10
mov    (%rbx,%r10,8),%rcx
cmp    $0x4,%r8d
jae    204a <minimize+0xeea>
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x40(%rsp),%rax
mov    0x10(%rsp),%r11
jmp    262c <minimize+0x14cc>
test   %r8d,%r8d
mov    0x88(%rsp),%r15
jle    23fc <minimize+0x129c>
mov    (%rbx,%r10,8),%rax
cmp    $0x4,%r8d
jb     1c04 <minimize+0xaa4>
lea    (%rax,%rsi,8),%rcx
cmp    %rcx,%r15
jae    2300 <minimize+0x11a0>
cmp    %rax,0xb0(%rsp)
jbe    2300 <minimize+0x11a0>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%sil
je     1c33 <minimize+0xad3>
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  (%rax,%rdx,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0xe8(%rsp),%rdx
je     23fc <minimize+0x129c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  (%rax,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movsd  0x8(%rax,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r15,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    1c50 <minimize+0xaf0>
jmp    23fc <minimize+0x129c>
xor    %eax,%eax
mov    0xa8(%rsp),%r12
testb  $0x1,0x58(%rsp)
jne    1a1f <minimize+0x8bf>
jmp    1a5b <minimize+0x8fb>
cmpq   $0xc,0x48(%rsp)
jae    1f5a <minimize+0xdfa>
xor    %edx,%edx
jmp    1fd4 <minimize+0xe74>
xor    %ecx,%ecx
testb  $0x1,0x58(%rsp)
jne    16ff <minimize+0x59f>
jmp    173b <minimize+0x5db>
cmp    %rcx,0xd8(%rsp)
mov    0x40(%rsp),%rax
jbe    207b <minimize+0xf1b>
lea    (%rcx,%rax,8),%rdx
cmp    %rdx,%r12
jae    207b <minimize+0xf1b>
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
jmp    2280 <minimize+0x1120>
mov    0x68(%rsp),%rdi
mov    0x70(%rsp),%rsi
mov    0x88(%rsp),%rdx
mov    %r8d,%ecx
mov    0x3c(%rsp),%r8d
xor    %eax,%eax
call   1080 <objective_function@plt>
mov    0x18(%rsp),%rdx
mov    0x30(%rsp),%rsi
mov    0x28(%rsp),%rdi
mov    0x10(%rsp),%r11
mov    0x8(%rsp),%r9
mov    0x24(%rsp),%r8d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x98(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jb     26c0 <minimize+0x1560>
jmp    284a <minimize+0x16ea>
mov    0x68(%rsp),%rdi
mov    0x70(%rsp),%rsi
mov    %rbx,%rdx
mov    %r8d,%ecx
mov    0x3c(%rsp),%r8d
xor    %eax,%eax
call   1040 <call_functions@plt>
mov    0x30(%rsp),%rsi
mov    0x10(%rsp),%r11
mov    0x8(%rsp),%r9
mov    0x24(%rsp),%r8d
movslq %eax,%rdi
jmp    2040 <minimize+0xee0>
cmpq   $0x0,0x48(%rsp)
je     209d <minimize+0xf3d>
mov    0xa0(%rsp),%rcx
xor    %eax,%eax
mov    0x88(%rsp),%r15
xchg   %ax,%ax
movupd 0x0(%rbp,%rax,8),%xmm0
movupd 0x10(%rbp,%rax,8),%xmm1
movupd (%r9,%rax,8),%xmm2
movupd 0x10(%r9,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%r15,%rax,8)
movupd %xmm3,0x10(%r15,%rax,8)
movupd 0x20(%rbp,%rax,8),%xmm0
movupd 0x30(%rbp,%rax,8),%xmm1
movupd 0x20(%r9,%rax,8),%xmm2
movupd 0x30(%r9,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r15,%rax,8)
movupd %xmm3,0x30(%r15,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1dc0 <minimize+0xc60>
testb  $0x1,0x58(%rsp)
je     1e91 <minimize+0xd31>
movupd 0x0(%rbp,%rax,8),%xmm0
movupd 0x10(%rbp,%rax,8),%xmm1
movupd (%r9,%rax,8),%xmm2
movupd 0x10(%r9,%rax,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%r15,%rax,8)
movupd %xmm3,0x10(%r15,%rax,8)
mov    0x50(%rsp),%rcx
mov    %rcx,%rax
cmp    %rsi,%rcx
je     1ec7 <minimize+0xd67>
xchg   %ax,%ax
movsd  0x0(%rbp,%rax,8),%xmm0
movsd  (%r9,%rax,8),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1ea0 <minimize+0xd40>
mov    0x68(%rsp),%rdi
mov    0x70(%rsp),%rsi
mov    %r15,%rdx
mov    %r8d,%ecx
mov    %r8d,%r14d
mov    0x3c(%rsp),%r8d
xor    %eax,%eax
call   1080 <objective_function@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x98(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jae    1f13 <minimize+0xdb3>
mov    %r14d,%r8d
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
mov    0x28(%rsp),%rdi
jmp    203b <minimize+0xedb>
test   %r14d,%r14d
mov    %r14d,%r8d
jle    20b7 <minimize+0xf57>
mov    0x78(%rsp),%rax
mov    (%rbx,%rax,8),%rax
cmp    $0x4,%r8d
jae    20cb <minimize+0xf6b>
xor    %ecx,%ecx
mov    0x8(%rsp),%r9
mov    0x40(%rsp),%r10
jmp    20f2 <minimize+0xf92>
mov    0x10(%rsp),%r11
mov    0x18(%rsp),%rdx
movslq %r15d,%r10
mov    0x8(%rsp),%r9
jmp    26b0 <minimize+0x1550>
mov    0x80(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r9,%rdx,8),%xmm0
movups 0x10(%r9,%rdx,8),%xmm1
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
movups 0x20(%r9,%rdx,8),%xmm0
movups 0x30(%r9,%rdx,8),%xmm1
movups %xmm0,0x20(%rcx,%rdx,8)
movups %xmm1,0x30(%rcx,%rdx,8)
movups 0x40(%r9,%rdx,8),%xmm0
movups 0x50(%r9,%rdx,8),%xmm1
movups %xmm0,0x40(%rcx,%rdx,8)
movups %xmm1,0x50(%rcx,%rdx,8)
movupd 0x60(%r9,%rdx,8),%xmm0
movupd 0x70(%r9,%rdx,8),%xmm1
movupd %xmm0,0x60(%rcx,%rdx,8)
movupd %xmm1,0x70(%rcx,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1f70 <minimize+0xe10>
cmpq   $0x0,0x100(%rsp)
je     201f <minimize+0xebf>
lea    (%rcx,%rdx,8),%rsi
add    $0x10,%rsi
mov    0xf8(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%rdx,%rdi,1),%xmm0
movupd (%rdx,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rdi,1)
movupd %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r14
jne    2000 <minimize+0xea0>
mov    0x50(%rsp),%rsi
mov    %rsi,%rdx
cmp    %rax,%rsi
jne    17f0 <minimize+0x690>
mov    0x28(%rsp),%rdi
movsd  %xmm2,(%rdi,%r10,8)
mov    0x30(%rsp),%rsi
mov    0x18(%rsp),%rdx
jmp    26c0 <minimize+0x1560>
cmp    %rcx,0xd8(%rsp)
mov    0x40(%rsp),%rax
jbe    2180 <minimize+0x1020>
lea    (%rcx,%rax,8),%rdx
cmp    %rdx,%r12
jae    2180 <minimize+0x1020>
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
jmp    262c <minimize+0x14cc>
cmpq   $0xc,0x48(%rsp)
jae    219d <minimize+0x103d>
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
mov    0x60(%rsp),%r14
jmp    2224 <minimize+0x10c4>
xor    %eax,%eax
mov    0x88(%rsp),%r15
testb  $0x1,0x58(%rsp)
jne    1e53 <minimize+0xcf3>
jmp    1e91 <minimize+0xd31>
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
mov    0x28(%rsp),%rdi
jmp    2840 <minimize+0x16e0>
cmp    %rax,0xb0(%rsp)
mov    0x40(%rsp),%r10
jbe    252d <minimize+0x13cd>
lea    (%rax,%r10,8),%rcx
cmp    %rcx,%r15
jae    252d <minimize+0x13cd>
xor    %ecx,%ecx
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
mov    0x28(%rsp),%rdi
mov    %rcx,%rdx
not    %rdx
add    %r10,%rdx
test   $0x3,%r10b
je     2135 <minimize+0xfd5>
mov    0x90(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    2120 <minimize+0xfc0>
cmp    $0x3,%rdx
jb     2840 <minimize+0x16e0>
nop
movsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rax,%rcx,8)
movsd  0x10(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x10(%rax,%rcx,8)
movsd  0x18(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    2140 <minimize+0xfe0>
jmp    2840 <minimize+0x16e0>
cmpq   $0xc,0x48(%rsp)
jae    2554 <minimize+0x13f4>
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
jmp    25d4 <minimize+0x1474>
mov    0x80(%rsp),%rsi
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
mov    0x60(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
movups (%r12,%rdx,8),%xmm1
movups 0x10(%r12,%rdx,8),%xmm2
movups %xmm1,(%rcx,%rdx,8)
movups %xmm2,0x10(%rcx,%rdx,8)
movups 0x20(%r12,%rdx,8),%xmm1
movups 0x30(%r12,%rdx,8),%xmm2
movups %xmm1,0x20(%rcx,%rdx,8)
movups %xmm2,0x30(%rcx,%rdx,8)
movups 0x40(%r12,%rdx,8),%xmm1
movups 0x50(%r12,%rdx,8),%xmm2
movups %xmm1,0x40(%rcx,%rdx,8)
movups %xmm2,0x50(%rcx,%rdx,8)
movupd 0x60(%r12,%rdx,8),%xmm1
movupd 0x70(%r12,%rdx,8),%xmm2
movupd %xmm1,0x60(%rcx,%rdx,8)
movupd %xmm2,0x70(%rcx,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rsi
jne    21c0 <minimize+0x1060>
testb  $0x3,0x58(%rsp)
je     226f <minimize+0x110f>
lea    (%rcx,%rdx,8),%rsi
add    $0x10,%rsi
mov    0xd0(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rdi,1),%xmm1
movupd (%rdx,%rdi,1),%xmm2
movupd %xmm1,-0x10(%rsi,%rdi,1)
movupd %xmm2,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r14
jne    2250 <minimize+0x10f0>
mov    0x50(%rsp),%rsi
mov    %rsi,%rdx
cmp    %rax,%rsi
je     26ab <minimize+0x154b>
mov    %rdx,%rsi
not    %rsi
add    %rax,%rsi
test   $0x3,%al
je     22b5 <minimize+0x1155>
mov    0x90(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    22a0 <minimize+0x1140>
cmp    $0x3,%rsi
jb     26ab <minimize+0x154b>
nop
movsd  (%r12,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
movsd  0x8(%r12,%rdx,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rdx,8)
movsd  0x10(%r12,%rdx,8),%xmm1
movsd  %xmm1,0x10(%rcx,%rdx,8)
movsd  0x18(%r12,%rdx,8),%xmm1
movsd  %xmm1,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    22c0 <minimize+0x1160>
jmp    26ab <minimize+0x154b>
cmpq   $0x0,0x48(%rsp)
je     2747 <minimize+0x15e7>
mov    0xa0(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%r15,%rcx,8)
movupd %xmm3,0x10(%r15,%rcx,8)
movupd 0x20(%rbp,%rcx,8),%xmm0
movupd 0x30(%rbp,%rcx,8),%xmm1
movupd 0x20(%rax,%rcx,8),%xmm2
movupd 0x30(%rax,%rcx,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r15,%rcx,8)
movupd %xmm3,0x30(%r15,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2320 <minimize+0x11c0>
testb  $0x1,0x58(%rsp)
je     23eb <minimize+0x128b>
movupd 0x0(%rbp,%rcx,8),%xmm0
movupd 0x10(%rbp,%rcx,8),%xmm1
movupd (%rax,%rcx,8),%xmm2
movupd 0x10(%rax,%rcx,8),%xmm3
subpd  %xmm0,%xmm2
subpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%r15,%rcx,8)
movupd %xmm3,0x10(%r15,%rcx,8)
mov    0x50(%rsp),%rcx
mov    %rcx,%rdx
cmp    %rsi,%rcx
jne    1c06 <minimize+0xaa6>
mov    0x68(%rsp),%rdi
mov    0x70(%rsp),%rsi
mov    %r15,%rdx
mov    %r8d,%ecx
mov    %r8d,%r14d
mov    0x3c(%rsp),%r8d
xor    %eax,%eax
mov    %r10,0x78(%rsp)
call   1080 <objective_function@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x28(%rsp),%rdi
mov    0x78(%rsp),%rax
movsd  (%rdi,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    2520 <minimize+0x13c0>
test   %r14d,%r14d
mov    %r14d,%r8d
mov    0x8(%rsp),%r9
mov    0x40(%rsp),%r10
mov    0x10(%rsp),%r11
mov    0x60(%rsp),%r14
mov    0x18(%rsp),%rdx
jle    2935 <minimize+0x17d5>
mov    0x78(%rsp),%rax
mov    (%rbx,%rax,8),%rax
cmp    $0x4,%r8d
jb     248f <minimize+0x132f>
cmp    %rax,0xb0(%rsp)
jbe    2734 <minimize+0x15d4>
lea    (%rax,%r10,8),%rcx
cmp    %rcx,%r15
jae    2734 <minimize+0x15d4>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r10,%rdx
test   $0x3,%r10b
je     24c5 <minimize+0x1365>
mov    0x90(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    24b0 <minimize+0x1350>
cmp    $0x3,%rdx
mov    0x18(%rsp),%rdx
jb     2935 <minimize+0x17d5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rax,%rcx,8)
movsd  0x10(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x10(%rax,%rcx,8)
movsd  0x18(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    24e0 <minimize+0x1380>
jmp    2935 <minimize+0x17d5>
mov    %r14d,%r8d
mov    0x8(%rsp),%r9
jmp    18d1 <minimize+0x771>
cmpq   $0xc,0x48(%rsp)
jae    2759 <minimize+0x15f9>
xor    %ecx,%ecx
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
mov    0x28(%rsp),%rdi
mov    0x60(%rsp),%r14
jmp    27e4 <minimize+0x1684>
mov    0x80(%rsp),%rsi
xor    %edx,%edx
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
nopl   0x0(%rax,%rax,1)
movups (%r12,%rdx,8),%xmm1
movups 0x10(%r12,%rdx,8),%xmm2
movups %xmm1,(%rcx,%rdx,8)
movups %xmm2,0x10(%rcx,%rdx,8)
movups 0x20(%r12,%rdx,8),%xmm1
movups 0x30(%r12,%rdx,8),%xmm2
movups %xmm1,0x20(%rcx,%rdx,8)
movups %xmm2,0x30(%rcx,%rdx,8)
movups 0x40(%r12,%rdx,8),%xmm1
movups 0x50(%r12,%rdx,8),%xmm2
movups %xmm1,0x40(%rcx,%rdx,8)
movups %xmm2,0x50(%rcx,%rdx,8)
movupd 0x60(%r12,%rdx,8),%xmm1
movupd 0x70(%r12,%rdx,8),%xmm2
movupd %xmm1,0x60(%rcx,%rdx,8)
movupd %xmm2,0x70(%rcx,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rsi
jne    2570 <minimize+0x1410>
testb  $0x3,0x58(%rsp)
je     261f <minimize+0x14bf>
lea    (%rcx,%rdx,8),%rsi
add    $0x10,%rsi
mov    0xd0(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rdi,1),%xmm1
movupd (%rdx,%rdi,1),%xmm2
movupd %xmm1,-0x10(%rsi,%rdi,1)
movupd %xmm2,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r14
jne    2600 <minimize+0x14a0>
mov    0x50(%rsp),%rsi
mov    %rsi,%rdx
cmp    %rax,%rsi
je     26ab <minimize+0x154b>
mov    %rdx,%rsi
not    %rsi
add    %rax,%rsi
test   $0x3,%al
je     2665 <minimize+0x1505>
mov    0x90(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    2650 <minimize+0x14f0>
cmp    $0x3,%rsi
jb     26ab <minimize+0x154b>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
movsd  0x8(%r12,%rdx,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rdx,8)
movsd  0x10(%r12,%rdx,8),%xmm1
movsd  %xmm1,0x10(%rcx,%rdx,8)
movsd  0x18(%r12,%rdx,8),%xmm1
movsd  %xmm1,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    2670 <minimize+0x1510>
mov    0x18(%rsp),%rdx
mov    0x28(%rsp),%rdi
movsd  %xmm0,(%rdi,%r10,8)
mov    0x30(%rsp),%rsi
imul   $0x3cf3cf3d,%edx,%eax
ror    %eax
cmp    $0x6186186,%eax
ja     2707 <minimize+0x15a7>
mov    0xc0(%rsp),%rax
movsd  (%rdi,%rax,8),%xmm0
test   %edx,%edx
je     26fe <minimize+0x159e>
movapd 0x120(%rsp),%xmm1
subsd  %xmm0,%xmm1
andpd  0x93b(%rip),%xmm1
movsd  %xmm1,0xf0(%rsp)
movapd %xmm0,0x120(%rsp)
lea    0x1(%rdx),%eax
cmp    $0x1386,%edx
ja     2944 <minimize+0x17e4>
movsd  0xf0(%rsp),%xmm0
ucomisd 0x8e9(%rip),%xmm0
mov    %eax,%edx
ja     1350 <minimize+0x1f0>
jmp    2944 <minimize+0x17e4>
cmpq   $0xc,0x48(%rsp)
jae    2859 <minimize+0x16f9>
xor    %ecx,%ecx
jmp    28d4 <minimize+0x1774>
xor    %ecx,%ecx
testb  $0x1,0x58(%rsp)
jne    23af <minimize+0x124f>
jmp    23eb <minimize+0x128b>
mov    0x80(%rsp),%rdx
xor    %ecx,%ecx
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%r11
mov    0x28(%rsp),%rdi
mov    0x60(%rsp),%r14
nopw   0x0(%rax,%rax,1)
movups (%r15,%rcx,8),%xmm1
movups 0x10(%r15,%rcx,8),%xmm2
movups %xmm1,(%rax,%rcx,8)
movups %xmm2,0x10(%rax,%rcx,8)
movups 0x20(%r15,%rcx,8),%xmm1
movups 0x30(%r15,%rcx,8),%xmm2
movups %xmm1,0x20(%rax,%rcx,8)
movups %xmm2,0x30(%rax,%rcx,8)
movups 0x40(%r15,%rcx,8),%xmm1
movups 0x50(%r15,%rcx,8),%xmm2
movups %xmm1,0x40(%rax,%rcx,8)
movups %xmm2,0x50(%rax,%rcx,8)
movupd 0x60(%r15,%rcx,8),%xmm1
movupd 0x70(%r15,%rcx,8),%xmm2
movupd %xmm1,0x60(%rax,%rcx,8)
movupd %xmm2,0x70(%rax,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    2780 <minimize+0x1620>
testb  $0x3,0x58(%rsp)
je     282f <minimize+0x16cf>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0xc8(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rsi,1),%xmm1
movupd (%rcx,%rsi,1),%xmm2
movupd %xmm1,-0x10(%rdx,%rsi,1)
movupd %xmm2,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r14
jne    2810 <minimize+0x16b0>
mov    0x50(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r10,%rdx
jne    20fc <minimize+0xf9c>
mov    0x30(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    0x78(%rsp),%rax
movsd  %xmm0,(%rdi,%rax,8)
jmp    26c0 <minimize+0x1560>
mov    0x80(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r15,%rcx,8),%xmm1
movups 0x10(%r15,%rcx,8),%xmm2
movups %xmm1,(%rax,%rcx,8)
movups %xmm2,0x10(%rax,%rcx,8)
movups 0x20(%r15,%rcx,8),%xmm1
movups 0x30(%r15,%rcx,8),%xmm2
movups %xmm1,0x20(%rax,%rcx,8)
movups %xmm2,0x30(%rax,%rcx,8)
movups 0x40(%r15,%rcx,8),%xmm1
movups 0x50(%r15,%rcx,8),%xmm2
movups %xmm1,0x40(%rax,%rcx,8)
movups %xmm2,0x50(%rax,%rcx,8)
movupd 0x60(%r15,%rcx,8),%xmm1
movupd 0x70(%r15,%rcx,8),%xmm2
movupd %xmm1,0x60(%rax,%rcx,8)
movupd %xmm2,0x70(%rax,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    2870 <minimize+0x1710>
testb  $0x3,0x58(%rsp)
je     291f <minimize+0x17bf>
lea    (%rax,%rcx,8),%rdx
add    $0x10,%rdx
mov    0xc8(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rsi,1),%xmm1
movupd (%rcx,%rsi,1),%xmm2
movupd %xmm1,-0x10(%rdx,%rsi,1)
movupd %xmm2,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r14
jne    2900 <minimize+0x17a0>
mov    0x50(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r10,%rdx
mov    0x18(%rsp),%rdx
jne    2491 <minimize+0x1331>
mov    0x78(%rsp),%rax
movsd  %xmm0,(%rdi,%rax,8)
jmp    26bb <minimize+0x155b>
cmp    $0x1388,%eax
jne    2957 <minimize+0x17f7>
lea    0x6ee(%rip),%rdi
call   1050 <puts@plt>
mov    0xc0(%rsp),%rax
mov    (%rbx,%rax,8),%rax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0xc0(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rbx,%rcx,8),%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,1),%xmm0
movsd  (%rcx,%rdx,1),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rdx,1)
add    $0x8,%rdx
jmp    2990 <minimize+0x1830>

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

LLVM IR (-O2):
@str = [32 x i8] c"The algorithm has not converge.\00"
define double* @minimize(double* %0, double* %1, i32 %2, i32 %3) {
%5 = tail call i32 (i32, ...) bitcast (i32 (...)* @create_simplex to i32 (i32, ...)*)(i32 %2)
%6 = sext i32 %5 to i64
%7 = inttoptr i64 %6 to double**
%8 = tail call i32 (double*, double*, double**, i32, i32, ...) bitcast (i32 (...)* @call_functions to i32 (double*, double*, double**, i32, i32, ...)*)(double* %0, double* %1, double** %7, i32 %2, i32 %3)
%9 = sext i32 %8 to i64
%10 = inttoptr i64 %9 to double*
%11 = sext i32 %2 to i64
%12 = shl nsw i64 %11, 3
%13 = tail call i8* @malloc(i64 %12)
%14 = bitcast i8* %13 to double*
%15 = tail call i8* @malloc(i64 %12)
%16 = bitcast i8* %15 to double*
%17 = tail call i8* @malloc(i64 %12)
%18 = bitcast i8* %17 to double*
%19 = tail call i8* @malloc(i64 %12)
%20 = bitcast i8* %19 to double*
%21 = icmp slt i32 %2, 1
%22 = icmp sgt i32 %2, 0
%23 = icmp slt i32 %2, 0
%24 = sitofp i32 %2 to double
%25 = add i32 %2, 1
%26 = zext i32 %2 to i64
%27 = shl nuw nsw i64 %26, 3
%28 = zext i32 %25 to i64
%29 = shl nuw nsw i64 %26, 3
%30 = getelementptr i8, i8* %17, i64 %29
%31 = shl nuw nsw i64 %26, 3
%32 = getelementptr i8, i8* %17, i64 %31
%33 = shl nuw nsw i64 %26, 3
%34 = getelementptr i8, i8* %19, i64 %33
%35 = shl nuw nsw i64 %26, 3
%36 = getelementptr i8, i8* %19, i64 %35
%37 = shl nuw nsw i64 %26, 3
%38 = getelementptr i8, i8* %19, i64 %37
%39 = shl nuw nsw i64 %26, 3
%40 = getelementptr i8, i8* %15, i64 %39
%41 = shl nuw nsw i64 %26, 3
%42 = getelementptr i8, i8* %15, i64 %41
%43 = add nsw i64 %28, -1
%44 = and i64 %26, 4294967292
%45 = add nsw i64 %44, -4
%46 = lshr exact i64 %45, 2
%47 = add nuw nsw i64 %46, 1
%48 = and i64 %43, 1
%49 = icmp eq i32 %25, 2
%50 = and i64 %43, -2
%51 = icmp eq i64 %48, 0
%52 = and i64 %28, 1
%53 = icmp eq i64 %43, 0
%54 = and i64 %28, 4294967294
%55 = icmp eq i64 %52, 0
%56 = icmp ult i32 %2, 4
%57 = and i64 %26, 4294967292
%58 = and i64 %47, 1
%59 = icmp eq i64 %45, 0
%60 = and i64 %47, 9223372036854775806
%61 = icmp eq i64 %58, 0
%62 = icmp eq i64 %57, %26
%63 = and i64 %26, 1
%64 = icmp eq i64 %63, 0
%65 = sub nsw i64 0, %26
%66 = icmp ult i32 %2, 4
%67 = and i64 %26, 4294967292
%68 = and i64 %47, 3
%69 = icmp ult i64 %45, 12
%70 = and i64 %47, 9223372036854775804
%71 = icmp eq i64 %68, 0
%72 = icmp eq i64 %67, %26
%73 = and i64 %26, 3
%74 = icmp eq i64 %73, 0
%75 = icmp ult i32 %2, 4
%76 = and i64 %26, 4294967292
%77 = and i64 %47, 1
%78 = icmp eq i64 %45, 0
%79 = and i64 %47, 9223372036854775806
%80 = icmp eq i64 %77, 0
%81 = icmp eq i64 %76, %26
%82 = and i64 %26, 1
%83 = icmp eq i64 %82, 0
%84 = sub nsw i64 0, %26
%85 = icmp ult i32 %2, 4
%86 = and i64 %26, 4294967292
%87 = and i64 %47, 3
%88 = icmp ult i64 %45, 12
%89 = and i64 %47, 9223372036854775804
%90 = icmp eq i64 %87, 0
%91 = icmp eq i64 %86, %26
%92 = and i64 %26, 3
%93 = icmp eq i64 %92, 0
%94 = icmp ult i32 %2, 4
%95 = and i64 %26, 4294967292
%96 = and i64 %47, 1
%97 = icmp eq i64 %45, 0
%98 = and i64 %47, 9223372036854775806
%99 = icmp eq i64 %96, 0
%100 = icmp eq i64 %95, %26
%101 = icmp ult i32 %2, 4
%102 = and i64 %26, 4294967292
%103 = and i64 %47, 3
%104 = icmp ult i64 %45, 12
%105 = and i64 %47, 9223372036854775804
%106 = icmp eq i64 %103, 0
%107 = icmp eq i64 %102, %26
%108 = and i64 %26, 3
%109 = icmp eq i64 %108, 0
%110 = icmp ult i32 %2, 4
%111 = and i64 %26, 4294967292
%112 = and i64 %47, 1
%113 = icmp eq i64 %45, 0
%114 = and i64 %47, 9223372036854775806
%115 = icmp eq i64 %112, 0
%116 = icmp eq i64 %111, %26
%117 = icmp ult i32 %2, 4
%118 = and i64 %26, 4294967292
%119 = and i64 %47, 3
%120 = icmp ult i64 %45, 12
%121 = and i64 %47, 9223372036854775804
%122 = icmp eq i64 %119, 0
%123 = icmp eq i64 %118, %26
%124 = and i64 %26, 3
%125 = icmp eq i64 %124, 0
%126 = icmp ult i32 %2, 4
%127 = and i64 %26, 4294967292
%128 = and i64 %47, 3
%129 = icmp ult i64 %45, 12
%130 = and i64 %47, 9223372036854775804
%131 = icmp eq i64 %128, 0
%132 = icmp eq i64 %127, %26
%133 = and i64 %26, 3
%134 = icmp eq i64 %133, 0
br label %135
135: ; preds = %1342, %4
%136 = phi double* [ %10, %4 ], [ %1332, %1342 ]
%137 = phi i32 [ 0, %4 ], [ %1345, %1342 ]
%138 = phi double [ undef, %4 ], [ %1343, %1342 ]
%139 = phi double [ 4.200000e+01, %4 ], [ %1344, %1342 ]
%140 = load double, double* %136
br i1 %21, label %161, label %141
141: ; preds = %135
br i1 %49, label %142, label %165
142: ; preds = %165, %141
%143 = phi i32 [ undef, %141 ], [ %189, %165 ]
%144 = phi i32 [ undef, %141 ], [ %192, %165 ]
%145 = phi i32 [ undef, %141 ], [ %193, %165 ]
%146 = phi i64 [ 1, %141 ], [ %194, %165 ]
%147 = phi i32 [ 0, %141 ], [ %193, %165 ]
%148 = phi i32 [ 0, %141 ], [ %192, %165 ]
%149 = phi i32 [ 0, %141 ], [ %189, %165 ]
%150 = phi double [ %140, %141 ], [ %187, %165 ]
%151 = phi double [ %140, %141 ], [ %191, %165 ]
br i1 %51, label %161, label %152
152: ; preds = %142
%153 = getelementptr inbounds double, double* %136, i64 %146
%154 = load double, double* %153
%155 = fcmp ult double %150, %154
%156 = trunc i64 %146 to i32
%157 = select i1 %155, i32 %149, i32 %156
%158 = fcmp ugt double %151, %154
%159 = select i1 %158, i32 %148, i32 %147
%160 = select i1 %158, i32 %147, i32 %156
br label %161
161: ; preds = %152, %142, %135
%162 = phi i32 [ 0, %135 ], [ %143, %142 ], [ %157, %152 ]
%163 = phi i32 [ 0, %135 ], [ %144, %142 ], [ %159, %152 ]
%164 = phi i32 [ 0, %135 ], [ %145, %142 ], [ %160, %152 ]
br i1 %22, label %197, label %363
165: ; preds = %141, %165
%166 = phi i64 [ %194, %165 ], [ 1, %141 ]
%167 = phi i32 [ %193, %165 ], [ 0, %141 ]
%168 = phi i32 [ %192, %165 ], [ 0, %141 ]
%169 = phi i32 [ %189, %165 ], [ 0, %141 ]
%170 = phi double [ %187, %165 ], [ %140, %141 ]
%171 = phi double [ %191, %165 ], [ %140, %141 ]
%172 = phi i64 [ %195, %165 ], [ 0, %141 ]
%173 = getelementptr inbounds double, double* %136, i64 %166
%174 = load double, double* %173
%175 = fcmp ult double %170, %174
%176 = select i1 %175, double %170, double %174
%177 = trunc i64 %166 to i32
%178 = select i1 %175, i32 %169, i32 %177
%179 = fcmp ugt double %171, %174
%180 = select i1 %179, double %171, double %174
%181 = select i1 %179, i32 %168, i32 %167
%182 = select i1 %179, i32 %167, i32 %177
%183 = add nuw nsw i64 %166, 1
%184 = getelementptr inbounds double, double* %136, i64 %183
%185 = load double, double* %184
%186 = fcmp ult double %176, %185
%187 = select i1 %186, double %176, double %185
%188 = trunc i64 %183 to i32
%189 = select i1 %186, i32 %178, i32 %188
%190 = fcmp ugt double %180, %185
%191 = select i1 %190, double %180, double %185
%192 = select i1 %190, i32 %181, i32 %182
%193 = select i1 %190, i32 %182, i32 %188
%194 = add nuw nsw i64 %166, 2
%195 = add i64 %172, 2
%196 = icmp eq i64 %195, %50
br i1 %196, label %142, label %165
197: ; preds = %161
%198 = zext i32 %164 to i64
br label %298
199: ; preds = %338
br i1 %22, label %200, label %363
200: ; preds = %199
%201 = sext i32 %164 to i64
%202 = getelementptr inbounds double*, double** %7, i64 %201
%203 = load double*, double** %202
br i1 %56, label %283, label %204
204: ; preds = %200
%205 = bitcast double* %203 to i8*
%206 = getelementptr double, double* %203, i64 %26
%207 = bitcast double* %206 to i8*
%208 = icmp ult i8* %15, %207
%209 = icmp ugt i8* %42, %205
%210 = and i1 %208, %209
br i1 %210, label %283, label %211
211: ; preds = %204
br i1 %59, label %259, label %212
212: ; preds = %211, %212
%213 = phi i64 [ %256, %212 ], [ 0, %211 ]
%214 = phi i64 [ %257, %212 ], [ 0, %211 ]
%215 = getelementptr inbounds double, double* %14, i64 %213
%216 = bitcast double* %215 to <2 x double>*
%217 = load <2 x double>, <2 x double>* %216
%218 = getelementptr inbounds double, double* %215, i64 2
%219 = bitcast double* %218 to <2 x double>*
%220 = load <2 x double>, <2 x double>* %219
%221 = getelementptr inbounds double, double* %203, i64 %213
%222 = bitcast double* %221 to <2 x double>*
%223 = load <2 x double>, <2 x double>* %222
%224 = getelementptr inbounds double, double* %221, i64 2
%225 = bitcast double* %224 to <2 x double>*
%226 = load <2 x double>, <2 x double>* %225
%227 = fsub <2 x double> %217, %223
%228 = fsub <2 x double> %220, %226
%229 = fadd <2 x double> %217, %227
%230 = fadd <2 x double> %220, %228
%231 = getelementptr inbounds double, double* %16, i64 %213
%232 = bitcast double* %231 to <2 x double>*
store <2 x double> %229, <2 x double>* %232
%233 = getelementptr inbounds double, double* %231, i64 2
%234 = bitcast double* %233 to <2 x double>*
store <2 x double> %230, <2 x double>* %234
%235 = or i64 %213, 4
%236 = getelementptr inbounds double, double* %14, i64 %235
%237 = bitcast double* %236 to <2 x double>*
%238 = load <2 x double>, <2 x double>* %237
%239 = getelementptr inbounds double, double* %236, i64 2
%240 = bitcast double* %239 to <2 x double>*
%241 = load <2 x double>, <2 x double>* %240
%242 = getelementptr inbounds double, double* %203, i64 %235
%243 = bitcast double* %242 to <2 x double>*
%244 = load <2 x double>, <2 x double>* %243
%245 = getelementptr inbounds double, double* %242, i64 2
%246 = bitcast double* %245 to <2 x double>*
%247 = load <2 x double>, <2 x double>* %246
%248 = fsub <2 x double> %238, %244
%249 = fsub <2 x double> %241, %247
%250 = fadd <2 x double> %238, %248
%251 = fadd <2 x double> %241, %249
%252 = getelementptr inbounds double, double* %16, i64 %235
%253 = bitcast double* %252 to <2 x double>*
store <2 x double> %250, <2 x double>* %253
%254 = getelementptr inbounds double, double* %252, i64 2
%255 = bitcast double* %254 to <2 x double>*
store <2 x double> %251, <2 x double>* %255
%256 = add nuw i64 %213, 8
%257 = add i64 %214, 2
%258 = icmp eq i64 %257, %60
br i1 %258, label %259, label %212
259: ; preds = %212, %211
%260 = phi i64 [ 0, %211 ], [ %256, %212 ]
br i1 %61, label %282, label %261
261: ; preds = %259
%262 = getelementptr inbounds double, double* %14, i64 %260
%263 = bitcast double* %262 to <2 x double>*
%264 = load <2 x double>, <2 x double>* %263
%265 = getelementptr inbounds double, double* %262, i64 2
%266 = bitcast double* %265 to <2 x double>*
%267 = load <2 x double>, <2 x double>* %266
%268 = getelementptr inbounds double, double* %203, i64 %260
%269 = bitcast double* %268 to <2 x double>*
%270 = load <2 x double>, <2 x double>* %269
%271 = getelementptr inbounds double, double* %268, i64 2
%272 = bitcast double* %271 to <2 x double>*
%273 = load <2 x double>, <2 x double>* %272
%274 = fsub <2 x double> %264, %270
%275 = fsub <2 x double> %267, %273
%276 = fadd <2 x double> %264, %274
%277 = fadd <2 x double> %267, %275
%278 = getelementptr inbounds double, double* %16, i64 %260
%279 = bitcast double* %278 to <2 x double>*
store <2 x double> %276, <2 x double>* %279
%280 = getelementptr inbounds double, double* %278, i64 2
%281 = bitcast double* %280 to <2 x double>*
store <2 x double> %277, <2 x double>* %281
br label %282
282: ; preds = %259, %261
br i1 %62, label %363, label %283
283: ; preds = %204, %200, %282
%284 = phi i64 [ 0, %204 ], [ 0, %200 ], [ %57, %282 ]
%285 = xor i64 %284, -1
br i1 %64, label %295, label %286
286: ; preds = %283
%287 = getelementptr inbounds double, double* %14, i64 %284
%288 = load double, double* %287
%289 = getelementptr inbounds double, double* %203, i64 %284
%290 = load double, double* %289
%291 = fsub double %288, %290
%292 = fadd double %288, %291
%293 = getelementptr inbounds double, double* %16, i64 %284
store double %292, double* %293
%294 = or i64 %284, 1
br label %295
295: ; preds = %286, %283
%296 = phi i64 [ %284, %283 ], [ %294, %286 ]
%297 = icmp eq i64 %285, %65
br i1 %297, label %363, label %344
298: ; preds = %197, %338
%299 = phi i64 [ 0, %197 ], [ %342, %338 ]
br i1 %23, label %338, label %300
300: ; preds = %298
%301 = getelementptr inbounds double, double* %14, i64 %299
br i1 %53, label %327, label %302
302: ; preds = %300, %323
%303 = phi i64 [ %324, %323 ], [ 0, %300 ]
%304 = phi i64 [ %325, %323 ], [ 0, %300 ]
%305 = icmp eq i64 %303, %198
br i1 %305, label %313, label %306
306: ; preds = %302
%307 = getelementptr inbounds double*, double** %7, i64 %303
%308 = load double*, double** %307
%309 = getelementptr inbounds double, double* %308, i64 %299
%310 = load double, double* %309
%311 = load double, double* %301
%312 = fadd double %310, %311
store double %312, double* %301
br label %313
313: ; preds = %302, %306
%314 = or i64 %303, 1
%315 = icmp eq i64 %314, %198
br i1 %315, label %323, label %316
316: ; preds = %313
%317 = getelementptr inbounds double*, double** %7, i64 %314
%318 = load double*, double** %317
%319 = getelementptr inbounds double, double* %318, i64 %299
%320 = load double, double* %319
%321 = load double, double* %301
%322 = fadd double %320, %321
store double %322, double* %301
br label %323
323: ; preds = %316, %313
%324 = add nuw nsw i64 %303, 2
%325 = add i64 %304, 2
%326 = icmp eq i64 %325, %54
br i1 %326, label %327, label %302
327: ; preds = %323, %300
%328 = phi i64 [ 0, %300 ], [ %324, %323 ]
%329 = icmp eq i64 %328, %198
%330 = select i1 %55, i1 true, i1 %329
br i1 %330, label %338, label %331
331: ; preds = %327
%332 = getelementptr inbounds double*, double** %7, i64 %328
%333 = load double*, double** %332
%334 = getelementptr inbounds double, double* %333, i64 %299
%335 = load double, double* %334
%336 = load double, double* %301
%337 = fadd double %335, %336
store double %337, double* %301
br label %338
338: ; preds = %327, %331, %298
%339 = getelementptr inbounds double, double* %14, i64 %299
%340 = load double, double* %339
%341 = fdiv double %340, %24
store double %341, double* %339
%342 = add nuw nsw i64 %299, 1
%343 = icmp eq i64 %342, %26
br i1 %343, label %199, label %298
344: ; preds = %295, %344
%345 = phi i64 [ %361, %344 ], [ %296, %295 ]
%346 = getelementptr inbounds double, double* %14, i64 %345
%347 = load double, double* %346
%348 = getelementptr inbounds double, double* %203, i64 %345
%349 = load double, double* %348
%350 = fsub double %347, %349
%351 = fadd double %347, %350
%352 = getelementptr inbounds double, double* %16, i64 %345
store double %351, double* %352
%353 = add nuw nsw i64 %345, 1
%354 = getelementptr inbounds double, double* %14, i64 %353
%355 = load double, double* %354
%356 = getelementptr inbounds double, double* %203, i64 %353
%357 = load double, double* %356
%358 = fsub double %355, %357
%359 = fadd double %355, %358
%360 = getelementptr inbounds double, double* %16, i64 %353
store double %359, double* %360
%361 = add nuw nsw i64 %345, 2
%362 = icmp eq i64 %361, %26
br i1 %362, label %363, label %344
363: ; preds = %295, %344, %282, %161, %199
%364 = tail call i32 (double*, double*, double*, i32, i32, ...) bitcast (i32 (...)* @objective_function to i32 (double*, double*, double*, i32, i32, ...)*)(double* %0, double* %1, double* %16, i32 %2, i32 %3)
%365 = sitofp i32 %364 to double
%366 = sext i32 %162 to i64
%367 = getelementptr inbounds double, double* %136, i64 %366
%368 = load double, double* %367
%369 = fcmp ugt double %368, %365
br i1 %369, label %493, label %370
370: ; preds = %363
%371 = sext i32 %163 to i64
%372 = getelementptr inbounds double, double* %136, i64 %371
%373 = load double, double* %372
%374 = fcmp ogt double %373, %365
br i1 %374, label %375, label %493
375: ; preds = %370
%376 = sext i32 %164 to i64
br i1 %22, label %377, label %491
377: ; preds = %375
%378 = getelementptr inbounds double*, double** %7, i64 %376
%379 = load double*, double** %378
br i1 %66, label %456, label %380
380: ; preds = %377
%381 = bitcast double* %379 to i8*
%382 = getelementptr double, double* %379, i64 %26
%383 = bitcast double* %382 to i8*
%384 = icmp ugt i8* %40, %381
%385 = icmp ult i8* %15, %383
%386 = and i1 %384, %385
br i1 %386, label %456, label %387
387: ; preds = %380
br i1 %69, label %437, label %388
388: ; preds = %387, %388
%389 = phi i64 [ %434, %388 ], [ 0, %387 ]
%390 = phi i64 [ %435, %388 ], [ 0, %387 ]
%391 = getelementptr inbounds double, double* %16, i64 %389
%392 = bitcast double* %391 to <2 x double>*
%393 = load <2 x double>, <2 x double>* %392
%394 = getelementptr inbounds double, double* %391, i64 2
%395 = bitcast double* %394 to <2 x double>*
%396 = load <2 x double>, <2 x double>* %395
%397 = getelementptr inbounds double, double* %379, i64 %389
%398 = bitcast double* %397 to <2 x double>*
store <2 x double> %393, <2 x double>* %398
%399 = getelementptr inbounds double, double* %397, i64 2
%400 = bitcast double* %399 to <2 x double>*
store <2 x double> %396, <2 x double>* %400
%401 = or i64 %389, 4
%402 = getelementptr inbounds double, double* %16, i64 %401
%403 = bitcast double* %402 to <2 x double>*
%404 = load <2 x double>, <2 x double>* %403
%405 = getelementptr inbounds double, double* %402, i64 2
%406 = bitcast double* %405 to <2 x double>*
%407 = load <2 x double>, <2 x double>* %406
%408 = getelementptr inbounds double, double* %379, i64 %401
%409 = bitcast double* %408 to <2 x double>*
store <2 x double> %404, <2 x double>* %409
%410 = getelementptr inbounds double, double* %408, i64 2
%411 = bitcast double* %410 to <2 x double>*
store <2 x double> %407, <2 x double>* %411
%412 = or i64 %389, 8
%413 = getelementptr inbounds double, double* %16, i64 %412
%414 = bitcast double* %413 to <2 x double>*
%415 = load <2 x double>, <2 x double>* %414
%416 = getelementptr inbounds double, double* %413, i64 2
%417 = bitcast double* %416 to <2 x double>*
%418 = load <2 x double>, <2 x double>* %417
%419 = getelementptr inbounds double, double* %379, i64 %412
%420 = bitcast double* %419 to <2 x double>*
store <2 x double> %415, <2 x double>* %420
%421 = getelementptr inbounds double, double* %419, i64 2
%422 = bitcast double* %421 to <2 x double>*
store <2 x double> %418, <2 x double>* %422
%423 = or i64 %389, 12
%424 = getelementptr inbounds double, double* %16, i64 %423
%425 = bitcast double* %424 to <2 x double>*
%426 = load <2 x double>, <2 x double>* %425
%427 = getelementptr inbounds double, double* %424, i64 2
%428 = bitcast double* %427 to <2 x double>*
%429 = load <2 x double>, <2 x double>* %428
%430 = getelementptr inbounds double, double* %379, i64 %423
%431 = bitcast double* %430 to <2 x double>*
store <2 x double> %426, <2 x double>* %431
%432 = getelementptr inbounds double, double* %430, i64 2
%433 = bitcast double* %432 to <2 x double>*
store <2 x double> %429, <2 x double>* %433
%434 = add nuw i64 %389, 16
%435 = add nuw i64 %390, 4
%436 = icmp eq i64 %435, %70
br i1 %436, label %437, label %388
437: ; preds = %388, %387
%438 = phi i64 [ 0, %387 ], [ %434, %388 ]
br i1 %71, label %455, label %439
439: ; preds = %437, %439
%440 = phi i64 [ %452, %439 ], [ %438, %437 ]
%441 = phi i64 [ %453, %439 ], [ 0, %437 ]
%442 = getelementptr inbounds double, double* %16, i64 %440
%443 = bitcast double* %442 to <2 x double>*
%444 = load <2 x double>, <2 x double>* %443
%445 = getelementptr inbounds double, double* %442, i64 2
%446 = bitcast double* %445 to <2 x double>*
%447 = load <2 x double>, <2 x double>* %446
%448 = getelementptr inbounds double, double* %379, i64 %440
%449 = bitcast double* %448 to <2 x double>*
store <2 x double> %444, <2 x double>* %449
%450 = getelementptr inbounds double, double* %448, i64 2
%451 = bitcast double* %450 to <2 x double>*
store <2 x double> %447, <2 x double>* %451
%452 = add nuw i64 %440, 4
%453 = add i64 %441, 1
%454 = icmp eq i64 %453, %68
br i1 %454, label %455, label %439
455: ; preds = %439, %437
br i1 %72, label %491, label %456
456: ; preds = %380, %377, %455
%457 = phi i64 [ 0, %380 ], [ 0, %377 ], [ %67, %455 ]
%458 = xor i64 %457, -1
%459 = add nsw i64 %458, %26
br i1 %74, label %469, label %460
460: ; preds = %456, %460
%461 = phi i64 [ %466, %460 ], [ %457, %456 ]
%462 = phi i64 [ %467, %460 ], [ 0, %456 ]
%463 = getelementptr inbounds double, double* %16, i64 %461
%464 = load double, double* %463
%465 = getelementptr inbounds double, double* %379, i64 %461
store double %464, double* %465
%466 = add nuw nsw i64 %461, 1
%467 = add i64 %462, 1
%468 = icmp eq i64 %467, %73
br i1 %468, label %469, label %460
469: ; preds = %460, %456
%470 = phi i64 [ %457, %456 ], [ %466, %460 ]
%471 = icmp ult i64 %459, 3
br i1 %471, label %491, label %472
472: ; preds = %469, %472
%473 = phi i64 [ %489, %472 ], [ %470, %469 ]
%474 = getelementptr inbounds double, double* %16, i64 %473
%475 = load double, double* %474
%476 = getelementptr inbounds double, double* %379, i64 %473
store double %475, double* %476
%477 = add nuw nsw i64 %473, 1
%478 = getelementptr inbounds double, double* %16, i64 %477
%479 = load double, double* %478
%480 = getelementptr inbounds double, double* %379, i64 %477
store double %479, double* %480
%481 = add nuw nsw i64 %473, 2
%482 = getelementptr inbounds double, double* %16, i64 %481
%483 = load double, double* %482
%484 = getelementptr inbounds double, double* %379, i64 %481
store double %483, double* %484
%485 = add nuw nsw i64 %473, 3
%486 = getelementptr inbounds double, double* %16, i64 %485
%487 = load double, double* %486
%488 = getelementptr inbounds double, double* %379, i64 %485
store double %487, double* %488
%489 = add nuw nsw i64 %473, 4
%490 = icmp eq i64 %489, %26
br i1 %490, label %491, label %472
491: ; preds = %469, %472, %455, %375
%492 = getelementptr inbounds double, double* %136, i64 %376
store double %365, double* %492
br label %1331
493: ; preds = %370, %363
%494 = fcmp ogt double %368, %365
br i1 %494, label %495, label %840
495: ; preds = %493
br i1 %22, label %496, label %586
496: ; preds = %495
br i1 %110, label %569, label %497
497: ; preds = %496
br i1 %113, label %545, label %498
498: ; preds = %497, %498
%499 = phi i64 [ %542, %498 ], [ 0, %497 ]
%500 = phi i64 [ %543, %498 ], [ 0, %497 ]
%501 = getelementptr inbounds double, double* %14, i64 %499
%502 = bitcast double* %501 to <2 x double>*
%503 = load <2 x double>, <2 x double>* %502
%504 = getelementptr inbounds double, double* %501, i64 2
%505 = bitcast double* %504 to <2 x double>*
%506 = load <2 x double>, <2 x double>* %505
%507 = getelementptr inbounds double, double* %16, i64 %499
%508 = bitcast double* %507 to <2 x double>*
%509 = load <2 x double>, <2 x double>* %508
%510 = getelementptr inbounds double, double* %507, i64 2
%511 = bitcast double* %510 to <2 x double>*
%512 = load <2 x double>, <2 x double>* %511
%513 = fsub <2 x double> %509, %503
%514 = fsub <2 x double> %512, %506
%515 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %513, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %503)
%516 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %514, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %506)
%517 = getelementptr inbounds double, double* %18, i64 %499
%518 = bitcast double* %517 to <2 x double>*
store <2 x double> %515, <2 x double>* %518
%519 = getelementptr inbounds double, double* %517, i64 2
%520 = bitcast double* %519 to <2 x double>*
store <2 x double> %516, <2 x double>* %520
%521 = or i64 %499, 4
%522 = getelementptr inbounds double, double* %14, i64 %521
%523 = bitcast double* %522 to <2 x double>*
%524 = load <2 x double>, <2 x double>* %523
%525 = getelementptr inbounds double, double* %522, i64 2
%526 = bitcast double* %525 to <2 x double>*
%527 = load <2 x double>, <2 x double>* %526
%528 = getelementptr inbounds double, double* %16, i64 %521
%529 = bitcast double* %528 to <2 x double>*
%530 = load <2 x double>, <2 x double>* %529
%531 = getelementptr inbounds double, double* %528, i64 2
%532 = bitcast double* %531 to <2 x double>*
%533 = load <2 x double>, <2 x double>* %532
%534 = fsub <2 x double> %530, %524
%535 = fsub <2 x double> %533, %527
%536 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %534, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %524)
%537 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %535, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %527)
%538 = getelementptr inbounds double, double* %18, i64 %521
%539 = bitcast double* %538 to <2 x double>*
store <2 x double> %536, <2 x double>* %539
%540 = getelementptr inbounds double, double* %538, i64 2
%541 = bitcast double* %540 to <2 x double>*
store <2 x double> %537, <2 x double>* %541
%542 = add nuw i64 %499, 8
%543 = add i64 %500, 2
%544 = icmp eq i64 %543, %114
br i1 %544, label %545, label %498
545: ; preds = %498, %497
%546 = phi i64 [ 0, %497 ], [ %542, %498 ]
br i1 %115, label %568, label %547
547: ; preds = %545
%548 = getelementptr inbounds double, double* %14, i64 %546
%549 = bitcast double* %548 to <2 x double>*
%550 = load <2 x double>, <2 x double>* %549
%551 = getelementptr inbounds double, double* %548, i64 2
%552 = bitcast double* %551 to <2 x double>*
%553 = load <2 x double>, <2 x double>* %552
%554 = getelementptr inbounds double, double* %16, i64 %546
%555 = bitcast double* %554 to <2 x double>*
%556 = load <2 x double>, <2 x double>* %555
%557 = getelementptr inbounds double, double* %554, i64 2
%558 = bitcast double* %557 to <2 x double>*
%559 = load <2 x double>, <2 x double>* %558
%560 = fsub <2 x double> %556, %550
%561 = fsub <2 x double> %559, %553
%562 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %560, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %550)
%563 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %561, <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> %553)
%564 = getelementptr inbounds double, double* %18, i64 %546
%565 = bitcast double* %564 to <2 x double>*
store <2 x double> %562, <2 x double>* %565
%566 = getelementptr inbounds double, double* %564, i64 2
%567 = bitcast double* %566 to <2 x double>*
store <2 x double> %563, <2 x double>* %567
br label %568
568: ; preds = %545, %547
br i1 %116, label %582, label %569
569: ; preds = %496, %568
%570 = phi i64 [ 0, %496 ], [ %111, %568 ]
br label %571
571: ; preds = %569, %571
%572 = phi i64 [ %580, %571 ], [ %570, %569 ]
%573 = getelementptr inbounds double, double* %14, i64 %572
%574 = load double, double* %573
%575 = getelementptr inbounds double, double* %16, i64 %572
%576 = load double, double* %575
%577 = fsub double %576, %574
%578 = tail call double @llvm.fmuladd.f64(double %577, double 2.000000e+00, double %574)
%579 = getelementptr inbounds double, double* %18, i64 %572
store double %578, double* %579
%580 = add nuw nsw i64 %572, 1
%581 = icmp eq i64 %580, %26
br i1 %581, label %582, label %571
582: ; preds = %571, %568
%583 = tail call i32 (double*, double*, double*, i32, i32, ...) bitcast (i32 (...)* @objective_function to i32 (double*, double*, double*, i32, i32, ...)*)(double* %0, double* %1, double* %18, i32 %2, i32 %3)
%584 = sitofp i32 %583 to double
%585 = fcmp olt double %584, %365
br i1 %585, label %590, label %713
586: ; preds = %495
%587 = tail call i32 (double*, double*, double*, i32, i32, ...) bitcast (i32 (...)* @objective_function to i32 (double*, double*, double*, i32, i32, ...)*)(double* %0, double* %1, double* %18, i32 %2, i32 %3)
%588 = sitofp i32 %587 to double
%589 = fcmp olt double %588, %365
br i1 %589, label %591, label %715
590: ; preds = %582
br i1 %22, label %594, label %591
591: ; preds = %586, %590
%592 = phi double [ %584, %590 ], [ %588, %586 ]
%593 = sext i32 %164 to i64
br label %709
594: ; preds = %590
%595 = sext i32 %164 to i64
%596 = getelementptr inbounds double*, double** %7, i64 %595
%597 = load double*, double** %596
br i1 %126, label %674, label %598
598: ; preds = %594
%599 = bitcast double* %597 to i8*
%600 = getelementptr double, double* %597, i64 %26
%601 = bitcast double* %600 to i8*
%602 = icmp ugt i8* %30, %599
%603 = icmp ult i8* %17, %601
%604 = and i1 %602, %603
br i1 %604, label %674, label %605
605: ; preds = %598
br i1 %129, label %655, label %606
606: ; preds = %605, %606
%607 = phi i64 [ %652, %606 ], [ 0, %605 ]
%608 = phi i64 [ %653, %606 ], [ 0, %605 ]
%609 = getelementptr inbounds double, double* %18, i64 %607
%610 = bitcast double* %609 to <2 x double>*
%611 = load <2 x double>, <2 x double>* %610
%612 = getelementptr inbounds double, double* %609, i64 2
%613 = bitcast double* %612 to <2 x double>*
%614 = load <2 x double>, <2 x double>* %613
%615 = getelementptr inbounds double, double* %597, i64 %607
%616 = bitcast double* %615 to <2 x double>*
store <2 x double> %611, <2 x double>* %616
%617 = getelementptr inbounds double, double* %615, i64 2
%618 = bitcast double* %617 to <2 x double>*
store <2 x double> %614, <2 x double>* %618
%619 = or i64 %607, 4
%620 = getelementptr inbounds double, double* %18, i64 %619
%621 = bitcast double* %620 to <2 x double>*
%622 = load <2 x double>, <2 x double>* %621
%623 = getelementptr inbounds double, double* %620, i64 2
%624 = bitcast double* %623 to <2 x double>*
%625 = load <2 x double>, <2 x double>* %624
%626 = getelementptr inbounds double, double* %597, i64 %619
%627 = bitcast double* %626 to <2 x double>*
store <2 x double> %622, <2 x double>* %627
%628 = getelementptr inbounds double, double* %626, i64 2
%629 = bitcast double* %628 to <2 x double>*
store <2 x double> %625, <2 x double>* %629
%630 = or i64 %607, 8
%631 = getelementptr inbounds double, double* %18, i64 %630
%632 = bitcast double* %631 to <2 x double>*
%633 = load <2 x double>, <2 x double>* %632
%634 = getelementptr inbounds double, double* %631, i64 2
%635 = bitcast double* %634 to <2 x double>*
%636 = load <2 x double>, <2 x double>* %635
%637 = getelementptr inbounds double, double* %597, i64 %630
%638 = bitcast double* %637 to <2 x double>*
store <2 x double> %633, <2 x double>* %638
%639 = getelementptr inbounds double, double* %637, i64 2
%640 = bitcast double* %639 to <2 x double>*
store <2 x double> %636, <2 x double>* %640
%641 = or i64 %607, 12
%642 = getelementptr inbounds double, double* %18, i64 %641
%643 = bitcast double* %642 to <2 x double>*
%644 = load <2 x double>, <2 x double>* %643
%645 = getelementptr inbounds double, double* %642, i64 2
%646 = bitcast double* %645 to <2 x double>*
%647 = load <2 x double>, <2 x double>* %646
%648 = getelementptr inbounds double, double* %597, i64 %641
%649 = bitcast double* %648 to <2 x double>*
store <2 x double> %644, <2 x double>* %649
%650 = getelementptr inbounds double, double* %648, i64 2
%651 = bitcast double* %650 to <2 x double>*
store <2 x double> %647, <2 x double>* %651
%652 = add nuw i64 %607, 16
%653 = add nuw i64 %608, 4
%654 = icmp eq i64 %653, %130
br i1 %654, label %655, label %606
655: ; preds = %606, %605
%656 = phi i64 [ 0, %605 ], [ %652, %606 ]
br i1 %131, label %673, label %657
657: ; preds = %655, %657
%658 = phi i64 [ %670, %657 ], [ %656, %655 ]
%659 = phi i64 [ %671, %657 ], [ 0, %655 ]
%660 = getelementptr inbounds double, double* %18, i64 %658
%661 = bitcast double* %660 to <2 x double>*
%662 = load <2 x double>, <2 x double>* %661
%663 = getelementptr inbounds double, double* %660, i64 2
%664 = bitcast double* %663 to <2 x double>*
%665 = load <2 x double>, <2 x double>* %664
%666 = getelementptr inbounds double, double* %597, i64 %658
%667 = bitcast double* %666 to <2 x double>*
store <2 x double> %662, <2 x double>* %667
%668 = getelementptr inbounds double, double* %666, i64 2
%669 = bitcast double* %668 to <2 x double>*
store <2 x double> %665, <2 x double>* %669
%670 = add nuw i64 %658, 4
%671 = add i64 %659, 1
%672 = icmp eq i64 %671, %128
br i1 %672, label %673, label %657
673: ; preds = %657, %655
br i1 %132, label %709, label %674
674: ; preds = %598, %594, %673
%675 = phi i64 [ 0, %598 ], [ 0, %594 ], [ %127, %673 ]
%676 = xor i64 %675, -1
%677 = add nsw i64 %676, %26
br i1 %134, label %687, label %678
678: ; preds = %674, %678
%679 = phi i64 [ %684, %678 ], [ %675, %674 ]
%680 = phi i64 [ %685, %678 ], [ 0, %674 ]
%681 = getelementptr inbounds double, double* %18, i64 %679
%682 = load double, double* %681
%683 = getelementptr inbounds double, double* %597, i64 %679
store double %682, double* %683
%684 = add nuw nsw i64 %679, 1
%685 = add i64 %680, 1
%686 = icmp eq i64 %685, %133
br i1 %686, label %687, label %678
687: ; preds = %678, %674
%688 = phi i64 [ %675, %674 ], [ %684, %678 ]
%689 = icmp ult i64 %677, 3
br i1 %689, label %709, label %690
690: ; preds = %687, %690
%691 = phi i64 [ %707, %690 ], [ %688, %687 ]
%692 = getelementptr inbounds double, double* %18, i64 %691
%693 = load double, double* %692
%694 = getelementptr inbounds double, double* %597, i64 %691
store double %693, double* %694
%695 = add nuw nsw i64 %691, 1
%696 = getelementptr inbounds double, double* %18, i64 %695
%697 = load double, double* %696
%698 = getelementptr inbounds double, double* %597, i64 %695
store double %697, double* %698
%699 = add nuw nsw i64 %691, 2
%700 = getelementptr inbounds double, double* %18, i64 %699
%701 = load double, double* %700
%702 = getelementptr inbounds double, double* %597, i64 %699
store double %701, double* %702
%703 = add nuw nsw i64 %691, 3
%704 = getelementptr inbounds double, double* %18, i64 %703
%705 = load double, double* %704
%706 = getelementptr inbounds double, double* %597, i64 %703
store double %705, double* %706
%707 = add nuw nsw i64 %691, 4
%708 = icmp eq i64 %707, %26
br i1 %708, label %709, label %690
709: ; preds = %687, %690, %673, %591
%710 = phi double [ %592, %591 ], [ %584, %673 ], [ %584, %690 ], [ %584, %687 ]
%711 = phi i64 [ %593, %591 ], [ %595, %673 ], [ %595, %690 ], [ %595, %687 ]
%712 = getelementptr inbounds double, double* %136, i64 %711
store double %710, double* %712
br label %1331
713: ; preds = %582
%714 = fcmp ult double %584, %365
br i1 %714, label %1331, label %717
715: ; preds = %586
%716 = fcmp ult double %588, %365
br i1 %716, label %1331, label %718
717: ; preds = %713
br i1 %22, label %721, label %718
718: ; preds = %715, %717
%719 = phi double [ %584, %717 ], [ %588, %715 ]
%720 = sext i32 %164 to i64
br label %836
721: ; preds = %717
%722 = sext i32 %164 to i64
%723 = getelementptr inbounds double*, double** %7, i64 %722
%724 = load double*, double** %723
br i1 %117, label %801, label %725
725: ; preds = %721
%726 = bitcast double* %724 to i8*
%727 = getelementptr double, double* %724, i64 %26
%728 = bitcast double* %727 to i8*
%729 = icmp ugt i8* %32, %726
%730 = icmp ult i8* %17, %728
%731 = and i1 %729, %730
br i1 %731, label %801, label %732
732: ; preds = %725
br i1 %120, label %782, label %733
733: ; preds = %732, %733
%734 = phi i64 [ %779, %733 ], [ 0, %732 ]
%735 = phi i64 [ %780, %733 ], [ 0, %732 ]
%736 = getelementptr inbounds double, double* %18, i64 %734
%737 = bitcast double* %736 to <2 x double>*
%738 = load <2 x double>, <2 x double>* %737
%739 = getelementptr inbounds double, double* %736, i64 2
%740 = bitcast double* %739 to <2 x double>*
%741 = load <2 x double>, <2 x double>* %740
%742 = getelementptr inbounds double, double* %724, i64 %734
%743 = bitcast double* %742 to <2 x double>*
store <2 x double> %738, <2 x double>* %743
%744 = getelementptr inbounds double, double* %742, i64 2
%745 = bitcast double* %744 to <2 x double>*
store <2 x double> %741, <2 x double>* %745
%746 = or i64 %734, 4
%747 = getelementptr inbounds double, double* %18, i64 %746
%748 = bitcast double* %747 to <2 x double>*
%749 = load <2 x double>, <2 x double>* %748
%750 = getelementptr inbounds double, double* %747, i64 2
%751 = bitcast double* %750 to <2 x double>*
%752 = load <2 x double>, <2 x double>* %751
%753 = getelementptr inbounds double, double* %724, i64 %746
%754 = bitcast double* %753 to <2 x double>*
store <2 x double> %749, <2 x double>* %754
%755 = getelementptr inbounds double, double* %753, i64 2
%756 = bitcast double* %755 to <2 x double>*
store <2 x double> %752, <2 x double>* %756
%757 = or i64 %734, 8
%758 = getelementptr inbounds double, double* %18, i64 %757
%759 = bitcast double* %758 to <2 x double>*
%760 = load <2 x double>, <2 x double>* %759
%761 = getelementptr inbounds double, double* %758, i64 2
%762 = bitcast double* %761 to <2 x double>*
%763 = load <2 x double>, <2 x double>* %762
%764 = getelementptr inbounds double, double* %724, i64 %757
%765 = bitcast double* %764 to <2 x double>*
store <2 x double> %760, <2 x double>* %765
%766 = getelementptr inbounds double, double* %764, i64 2
%767 = bitcast double* %766 to <2 x double>*
store <2 x double> %763, <2 x double>* %767
%768 = or i64 %734, 12
%769 = getelementptr inbounds double, double* %18, i64 %768
%770 = bitcast double* %769 to <2 x double>*
%771 = load <2 x double>, <2 x double>* %770
%772 = getelementptr inbounds double, double* %769, i64 2
%773 = bitcast double* %772 to <2 x double>*
%774 = load <2 x double>, <2 x double>* %773
%775 = getelementptr inbounds double, double* %724, i64 %768
%776 = bitcast double* %775 to <2 x double>*
store <2 x double> %771, <2 x double>* %776
%777 = getelementptr inbounds double, double* %775, i64 2
%778 = bitcast double* %777 to <2 x double>*
store <2 x double> %774, <2 x double>* %778
%779 = add nuw i64 %734, 16
%780 = add nuw i64 %735, 4
%781 = icmp eq i64 %780, %121
br i1 %781, label %782, label %733
782: ; preds = %733, %732
%783 = phi i64 [ 0, %732 ], [ %779, %733 ]
br i1 %122, label %800, label %784
784: ; preds = %782, %784
%785 = phi i64 [ %797, %784 ], [ %783, %782 ]
%786 = phi i64 [ %798, %784 ], [ 0, %782 ]
%787 = getelementptr inbounds double, double* %18, i64 %785
%788 = bitcast double* %787 to <2 x double>*
%789 = load <2 x double>, <2 x double>* %788
%790 = getelementptr inbounds double, double* %787, i64 2
%791 = bitcast double* %790 to <2 x double>*
%792 = load <2 x double>, <2 x double>* %791
%793 = getelementptr inbounds double, double* %724, i64 %785
%794 = bitcast double* %793 to <2 x double>*
store <2 x double> %789, <2 x double>* %794
%795 = getelementptr inbounds double, double* %793, i64 2
%796 = bitcast double* %795 to <2 x double>*
store <2 x double> %792, <2 x double>* %796
%797 = add nuw i64 %785, 4
%798 = add i64 %786, 1
%799 = icmp eq i64 %798, %119
br i1 %799, label %800, label %784
800: ; preds = %784, %782
br i1 %123, label %836, label %801
801: ; preds = %725, %721, %800
%802 = phi i64 [ 0, %725 ], [ 0, %721 ], [ %118, %800 ]
%803 = xor i64 %802, -1
%804 = add nsw i64 %803, %26
br i1 %125, label %814, label %805
805: ; preds = %801, %805
%806 = phi i64 [ %811, %805 ], [ %802, %801 ]
%807 = phi i64 [ %812, %805 ], [ 0, %801 ]
%808 = getelementptr inbounds double, double* %18, i64 %806
%809 = load double, double* %808
%810 = getelementptr inbounds double, double* %724, i64 %806
store double %809, double* %810
%811 = add nuw nsw i64 %806, 1
%812 = add i64 %807, 1
%813 = icmp eq i64 %812, %124
br i1 %813, label %814, label %805
814: ; preds = %805, %801
%815 = phi i64 [ %802, %801 ], [ %811, %805 ]
%816 = icmp ult i64 %804, 3
br i1 %816, label %836, label %817
817: ; preds = %814, %817
%818 = phi i64 [ %834, %817 ], [ %815, %814 ]
%819 = getelementptr inbounds double, double* %18, i64 %818
%820 = load double, double* %819
%821 = getelementptr inbounds double, double* %724, i64 %818
store double %820, double* %821
%822 = add nuw nsw i64 %818, 1
%823 = getelementptr inbounds double, double* %18, i64 %822
%824 = load double, double* %823
%825 = getelementptr inbounds double, double* %724, i64 %822
store double %824, double* %825
%826 = add nuw nsw i64 %818, 2
%827 = getelementptr inbounds double, double* %18, i64 %826
%828 = load double, double* %827
%829 = getelementptr inbounds double, double* %724, i64 %826
store double %828, double* %829
%830 = add nuw nsw i64 %818, 3
%831 = getelementptr inbounds double, double* %18, i64 %830
%832 = load double, double* %831
%833 = getelementptr inbounds double, double* %724, i64 %830
store double %832, double* %833
%834 = add nuw nsw i64 %818, 4
%835 = icmp eq i64 %834, %26
br i1 %835, label %836, label %817
836: ; preds = %814, %817, %800, %718
%837 = phi double [ %719, %718 ], [ %584, %800 ], [ %584, %817 ], [ %584, %814 ]
%838 = phi i64 [ %720, %718 ], [ %722, %800 ], [ %722, %817 ], [ %722, %814 ]
%839 = getelementptr inbounds double, double* %136, i64 %838
store double %837, double* %839
br label %1331
840: ; preds = %493
%841 = sext i32 %163 to i64
%842 = getelementptr inbounds double, double* %136, i64 %841
%843 = load double, double* %842
%844 = fcmp ugt double %843, %365
br i1 %844, label %1331, label %845
845: ; preds = %840
%846 = sext i32 %164 to i64
%847 = getelementptr inbounds double, double* %136, i64 %846
%848 = load double, double* %847
%849 = fcmp ogt double %848, %365
br i1 %849, label %850, label %1062
850: ; preds = %845
br i1 %22, label %851, label %941
851: ; preds = %850
br i1 %94, label %924, label %852
852: ; preds = %851
br i1 %97, label %900, label %853
853: ; preds = %852, %853
%854 = phi i64 [ %897, %853 ], [ 0, %852 ]
%855 = phi i64 [ %898, %853 ], [ 0, %852 ]
%856 = getelementptr inbounds double, double* %14, i64 %854
%857 = bitcast double* %856 to <2 x double>*
%858 = load <2 x double>, <2 x double>* %857
%859 = getelementptr inbounds double, double* %856, i64 2
%860 = bitcast double* %859 to <2 x double>*
%861 = load <2 x double>, <2 x double>* %860
%862 = getelementptr inbounds double, double* %16, i64 %854
%863 = bitcast double* %862 to <2 x double>*
%864 = load <2 x double>, <2 x double>* %863
%865 = getelementptr inbounds double, double* %862, i64 2
%866 = bitcast double* %865 to <2 x double>*
%867 = load <2 x double>, <2 x double>* %866
%868 = fsub <2 x double> %864, %858
%869 = fsub <2 x double> %867, %861
%870 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %868, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %858)
%871 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %869, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %861)
%872 = getelementptr inbounds double, double* %20, i64 %854
%873 = bitcast double* %872 to <2 x double>*
store <2 x double> %870, <2 x double>* %873
%874 = getelementptr inbounds double, double* %872, i64 2
%875 = bitcast double* %874 to <2 x double>*
store <2 x double> %871, <2 x double>* %875
%876 = or i64 %854, 4
%877 = getelementptr inbounds double, double* %14, i64 %876
%878 = bitcast double* %877 to <2 x double>*
%879 = load <2 x double>, <2 x double>* %878
%880 = getelementptr inbounds double, double* %877, i64 2
%881 = bitcast double* %880 to <2 x double>*
%882 = load <2 x double>, <2 x double>* %881
%883 = getelementptr inbounds double, double* %16, i64 %876
%884 = bitcast double* %883 to <2 x double>*
%885 = load <2 x double>, <2 x double>* %884
%886 = getelementptr inbounds double, double* %883, i64 2
%887 = bitcast double* %886 to <2 x double>*
%888 = load <2 x double>, <2 x double>* %887
%889 = fsub <2 x double> %885, %879
%890 = fsub <2 x double> %888, %882
%891 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %889, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %879)
%892 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %890, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %882)
%893 = getelementptr inbounds double, double* %20, i64 %876
%894 = bitcast double* %893 to <2 x double>*
store <2 x double> %891, <2 x double>* %894
%895 = getelementptr inbounds double, double* %893, i64 2
%896 = bitcast double* %895 to <2 x double>*
store <2 x double> %892, <2 x double>* %896
%897 = add nuw i64 %854, 8
%898 = add i64 %855, 2
%899 = icmp eq i64 %898, %98
br i1 %899, label %900, label %853
900: ; preds = %853, %852
%901 = phi i64 [ 0, %852 ], [ %897, %853 ]
br i1 %99, label %923, label %902
902: ; preds = %900
%903 = getelementptr inbounds double, double* %14, i64 %901
%904 = bitcast double* %903 to <2 x double>*
%905 = load <2 x double>, <2 x double>* %904
%906 = getelementptr inbounds double, double* %903, i64 2
%907 = bitcast double* %906 to <2 x double>*
%908 = load <2 x double>, <2 x double>* %907
%909 = getelementptr inbounds double, double* %16, i64 %901
%910 = bitcast double* %909 to <2 x double>*
%911 = load <2 x double>, <2 x double>* %910
%912 = getelementptr inbounds double, double* %909, i64 2
%913 = bitcast double* %912 to <2 x double>*
%914 = load <2 x double>, <2 x double>* %913
%915 = fsub <2 x double> %911, %905
%916 = fsub <2 x double> %914, %908
%917 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %915, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %905)
%918 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %916, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %908)
%919 = getelementptr inbounds double, double* %20, i64 %901
%920 = bitcast double* %919 to <2 x double>*
store <2 x double> %917, <2 x double>* %920
%921 = getelementptr inbounds double, double* %919, i64 2
%922 = bitcast double* %921 to <2 x double>*
store <2 x double> %918, <2 x double>* %922
br label %923
923: ; preds = %900, %902
br i1 %100, label %937, label %924
924: ; preds = %851, %923
%925 = phi i64 [ 0, %851 ], [ %95, %923 ]
br label %926
926: ; preds = %924, %926
%927 = phi i64 [ %935, %926 ], [ %925, %924 ]
%928 = getelementptr inbounds double, double* %14, i64 %927
%929 = load double, double* %928
%930 = getelementptr inbounds double, double* %16, i64 %927
%931 = load double, double* %930
%932 = fsub double %931, %929
%933 = tail call double @llvm.fmuladd.f64(double %932, double 5.000000e-01, double %929)
%934 = getelementptr inbounds double, double* %20, i64 %927
store double %933, double* %934
%935 = add nuw nsw i64 %927, 1
%936 = icmp eq i64 %935, %26
br i1 %936, label %937, label %926
937: ; preds = %926, %923
%938 = tail call i32 (double*, double*, double*, i32, i32, ...) bitcast (i32 (...)* @objective_function to i32 (double*, double*, double*, i32, i32, ...)*)(double* %0, double* %1, double* %20, i32 %2, i32 %3)
%939 = sitofp i32 %938 to double
%940 = fcmp ugt double %939, %365
br i1 %940, label %1331, label %945
941: ; preds = %850
%942 = tail call i32 (double*, double*, double*, i32, i32, ...) bitcast (i32 (...)* @objective_function to i32 (double*, double*, double*, i32, i32, ...)*)(double* %0, double* %1, double* %20, i32 %2, i32 %3)
%943 = sitofp i32 %942 to double
%944 = fcmp ugt double %943, %365
br i1 %944, label %1331, label %1060
945: ; preds = %937
br i1 %22, label %946, label %1060
946: ; preds = %945
%947 = getelementptr inbounds double*, double** %7, i64 %846
%948 = load double*, double** %947
br i1 %101, label %1025, label %949
949: ; preds = %946
%950 = bitcast double* %948 to i8*
%951 = getelementptr double, double* %948, i64 %26
%952 = bitcast double* %951 to i8*
%953 = icmp ugt i8* %34, %950
%954 = icmp ult i8* %19, %952
%955 = and i1 %953, %954
br i1 %955, label %1025, label %956
956: ; preds = %949
br i1 %104, label %1006, label %957
957: ; preds = %956, %957
%958 = phi i64 [ %1003, %957 ], [ 0, %956 ]
%959 = phi i64 [ %1004, %957 ], [ 0, %956 ]
%960 = getelementptr inbounds double, double* %20, i64 %958
%961 = bitcast double* %960 to <2 x double>*
%962 = load <2 x double>, <2 x double>* %961
%963 = getelementptr inbounds double, double* %960, i64 2
%964 = bitcast double* %963 to <2 x double>*
%965 = load <2 x double>, <2 x double>* %964
%966 = getelementptr inbounds double, double* %948, i64 %958
%967 = bitcast double* %966 to <2 x double>*
store <2 x double> %962, <2 x double>* %967
%968 = getelementptr inbounds double, double* %966, i64 2
%969 = bitcast double* %968 to <2 x double>*
store <2 x double> %965, <2 x double>* %969
%970 = or i64 %958, 4
%971 = getelementptr inbounds double, double* %20, i64 %970
%972 = bitcast double* %971 to <2 x double>*
%973 = load <2 x double>, <2 x double>* %972
%974 = getelementptr inbounds double, double* %971, i64 2
%975 = bitcast double* %974 to <2 x double>*
%976 = load <2 x double>, <2 x double>* %975
%977 = getelementptr inbounds double, double* %948, i64 %970
%978 = bitcast double* %977 to <2 x double>*
store <2 x double> %973, <2 x double>* %978
%979 = getelementptr inbounds double, double* %977, i64 2
%980 = bitcast double* %979 to <2 x double>*
store <2 x double> %976, <2 x double>* %980
%981 = or i64 %958, 8
%982 = getelementptr inbounds double, double* %20, i64 %981
%983 = bitcast double* %982 to <2 x double>*
%984 = load <2 x double>, <2 x double>* %983
%985 = getelementptr inbounds double, double* %982, i64 2
%986 = bitcast double* %985 to <2 x double>*
%987 = load <2 x double>, <2 x double>* %986
%988 = getelementptr inbounds double, double* %948, i64 %981
%989 = bitcast double* %988 to <2 x double>*
store <2 x double> %984, <2 x double>* %989
%990 = getelementptr inbounds double, double* %988, i64 2
%991 = bitcast double* %990 to <2 x double>*
store <2 x double> %987, <2 x double>* %991
%992 = or i64 %958, 12
%993 = getelementptr inbounds double, double* %20, i64 %992
%994 = bitcast double* %993 to <2 x double>*
%995 = load <2 x double>, <2 x double>* %994
%996 = getelementptr inbounds double, double* %993, i64 2
%997 = bitcast double* %996 to <2 x double>*
%998 = load <2 x double>, <2 x double>* %997
%999 = getelementptr inbounds double, double* %948, i64 %992
%1000 = bitcast double* %999 to <2 x double>*
store <2 x double> %995, <2 x double>* %1000
%1001 = getelementptr inbounds double, double* %999, i64 2
%1002 = bitcast double* %1001 to <2 x double>*
store <2 x double> %998, <2 x double>* %1002
%1003 = add nuw i64 %958, 16
%1004 = add nuw i64 %959, 4
%1005 = icmp eq i64 %1004, %105
br i1 %1005, label %1006, label %957
1006: ; preds = %957, %956
%1007 = phi i64 [ 0, %956 ], [ %1003, %957 ]
br i1 %106, label %1024, label %1008
1008: ; preds = %1006, %1008
%1009 = phi i64 [ %1021, %1008 ], [ %1007, %1006 ]
%1010 = phi i64 [ %1022, %1008 ], [ 0, %1006 ]
%1011 = getelementptr inbounds double, double* %20, i64 %1009
%1012 = bitcast double* %1011 to <2 x double>*
%1013 = load <2 x double>, <2 x double>* %1012
%1014 = getelementptr inbounds double, double* %1011, i64 2
%1015 = bitcast double* %1014 to <2 x double>*
%1016 = load <2 x double>, <2 x double>* %1015
%1017 = getelementptr inbounds double, double* %948, i64 %1009
%1018 = bitcast double* %1017 to <2 x double>*
store <2 x double> %1013, <2 x double>* %1018
%1019 = getelementptr inbounds double, double* %1017, i64 2
%1020 = bitcast double* %1019 to <2 x double>*
store <2 x double> %1016, <2 x double>* %1020
%1021 = add nuw i64 %1009, 4
%1022 = add i64 %1010, 1
%1023 = icmp eq i64 %1022, %103
br i1 %1023, label %1024, label %1008
1024: ; preds = %1008, %1006
br i1 %107, label %1060, label %1025
1025: ; preds = %949, %946, %1024
%1026 = phi i64 [ 0, %949 ], [ 0, %946 ], [ %102, %1024 ]
%1027 = xor i64 %1026, -1
%1028 = add nsw i64 %1027, %26
br i1 %109, label %1038, label %1029
1029: ; preds = %1025, %1029
%1030 = phi i64 [ %1035, %1029 ], [ %1026, %1025 ]
%1031 = phi i64 [ %1036, %1029 ], [ 0, %1025 ]
%1032 = getelementptr inbounds double, double* %20, i64 %1030
%1033 = load double, double* %1032
%1034 = getelementptr inbounds double, double* %948, i64 %1030
store double %1033, double* %1034
%1035 = add nuw nsw i64 %1030, 1
%1036 = add i64 %1031, 1
%1037 = icmp eq i64 %1036, %108
br i1 %1037, label %1038, label %1029
1038: ; preds = %1029, %1025
%1039 = phi i64 [ %1026, %1025 ], [ %1035, %1029 ]
%1040 = icmp ult i64 %1028, 3
br i1 %1040, label %1060, label %1041
1041: ; preds = %1038, %1041
%1042 = phi i64 [ %1058, %1041 ], [ %1039, %1038 ]
%1043 = getelementptr inbounds double, double* %20, i64 %1042
%1044 = load double, double* %1043
%1045 = getelementptr inbounds double, double* %948, i64 %1042
store double %1044, double* %1045
%1046 = add nuw nsw i64 %1042, 1
%1047 = getelementptr inbounds double, double* %20, i64 %1046
%1048 = load double, double* %1047
%1049 = getelementptr inbounds double, double* %948, i64 %1046
store double %1048, double* %1049
%1050 = add nuw nsw i64 %1042, 2
%1051 = getelementptr inbounds double, double* %20, i64 %1050
%1052 = load double, double* %1051
%1053 = getelementptr inbounds double, double* %948, i64 %1050
store double %1052, double* %1053
%1054 = add nuw nsw i64 %1042, 3
%1055 = getelementptr inbounds double, double* %20, i64 %1054
%1056 = load double, double* %1055
%1057 = getelementptr inbounds double, double* %948, i64 %1054
store double %1056, double* %1057
%1058 = add nuw nsw i64 %1042, 4
%1059 = icmp eq i64 %1058, %26
br i1 %1059, label %1060, label %1041
1060: ; preds = %1038, %1041, %1024, %941, %945
%1061 = phi double [ %939, %945 ], [ %943, %941 ], [ %939, %1024 ], [ %939, %1041 ], [ %939, %1038 ]
store double %1061, double* %847
br label %1331
1062: ; preds = %845
%1063 = fcmp ugt double %848, %365
br i1 %1063, label %1162, label %1064
1064: ; preds = %1062
br i1 %22, label %1065, label %1184
1065: ; preds = %1064
%1066 = getelementptr inbounds double*, double** %7, i64 %846
%1067 = load double*, double** %1066
br i1 %75, label %1147, label %1068
1068: ; preds = %1065
%1069 = bitcast double* %1067 to i8*
%1070 = getelementptr double, double* %1067, i64 %26
%1071 = bitcast double* %1070 to i8*
%1072 = icmp ult i8* %19, %1071
%1073 = icmp ugt i8* %38, %1069
%1074 = and i1 %1072, %1073
br i1 %1074, label %1147, label %1075
1075: ; preds = %1068
br i1 %78, label %1123, label %1076
1076: ; preds = %1075, %1076
%1077 = phi i64 [ %1120, %1076 ], [ 0, %1075 ]
%1078 = phi i64 [ %1121, %1076 ], [ 0, %1075 ]
%1079 = getelementptr inbounds double, double* %14, i64 %1077
%1080 = bitcast double* %1079 to <2 x double>*
%1081 = load <2 x double>, <2 x double>* %1080
%1082 = getelementptr inbounds double, double* %1079, i64 2
%1083 = bitcast double* %1082 to <2 x double>*
%1084 = load <2 x double>, <2 x double>* %1083
%1085 = getelementptr inbounds double, double* %1067, i64 %1077
%1086 = bitcast double* %1085 to <2 x double>*
%1087 = load <2 x double>, <2 x double>* %1086
%1088 = getelementptr inbounds double, double* %1085, i64 2
%1089 = bitcast double* %1088 to <2 x double>*
%1090 = load <2 x double>, <2 x double>* %1089
%1091 = fsub <2 x double> %1087, %1081
%1092 = fsub <2 x double> %1090, %1084
%1093 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1091, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1081)
%1094 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1092, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1084)
%1095 = getelementptr inbounds double, double* %20, i64 %1077
%1096 = bitcast double* %1095 to <2 x double>*
store <2 x double> %1093, <2 x double>* %1096
%1097 = getelementptr inbounds double, double* %1095, i64 2
%1098 = bitcast double* %1097 to <2 x double>*
store <2 x double> %1094, <2 x double>* %1098
%1099 = or i64 %1077, 4
%1100 = getelementptr inbounds double, double* %14, i64 %1099
%1101 = bitcast double* %1100 to <2 x double>*
%1102 = load <2 x double>, <2 x double>* %1101
%1103 = getelementptr inbounds double, double* %1100, i64 2
%1104 = bitcast double* %1103 to <2 x double>*
%1105 = load <2 x double>, <2 x double>* %1104
%1106 = getelementptr inbounds double, double* %1067, i64 %1099
%1107 = bitcast double* %1106 to <2 x double>*
%1108 = load <2 x double>, <2 x double>* %1107
%1109 = getelementptr inbounds double, double* %1106, i64 2
%1110 = bitcast double* %1109 to <2 x double>*
%1111 = load <2 x double>, <2 x double>* %1110
%1112 = fsub <2 x double> %1108, %1102
%1113 = fsub <2 x double> %1111, %1105
%1114 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1112, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1102)
%1115 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1113, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1105)
%1116 = getelementptr inbounds double, double* %20, i64 %1099
%1117 = bitcast double* %1116 to <2 x double>*
store <2 x double> %1114, <2 x double>* %1117
%1118 = getelementptr inbounds double, double* %1116, i64 2
%1119 = bitcast double* %1118 to <2 x double>*
store <2 x double> %1115, <2 x double>* %1119
%1120 = add nuw i64 %1077, 8
%1121 = add i64 %1078, 2
%1122 = icmp eq i64 %1121, %79
br i1 %1122, label %1123, label %1076
1123: ; preds = %1076, %1075
%1124 = phi i64 [ 0, %1075 ], [ %1120, %1076 ]
br i1 %80, label %1146, label %1125
1125: ; preds = %1123
%1126 = getelementptr inbounds double, double* %14, i64 %1124
%1127 = bitcast double* %1126 to <2 x double>*
%1128 = load <2 x double>, <2 x double>* %1127
%1129 = getelementptr inbounds double, double* %1126, i64 2
%1130 = bitcast double* %1129 to <2 x double>*
%1131 = load <2 x double>, <2 x double>* %1130
%1132 = getelementptr inbounds double, double* %1067, i64 %1124
%1133 = bitcast double* %1132 to <2 x double>*
%1134 = load <2 x double>, <2 x double>* %1133
%1135 = getelementptr inbounds double, double* %1132, i64 2
%1136 = bitcast double* %1135 to <2 x double>*
%1137 = load <2 x double>, <2 x double>* %1136
%1138 = fsub <2 x double> %1134, %1128
%1139 = fsub <2 x double> %1137, %1131
%1140 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1138, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1128)
%1141 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1139, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> %1131)
%1142 = getelementptr inbounds double, double* %20, i64 %1124
%1143 = bitcast double* %1142 to <2 x double>*
store <2 x double> %1140, <2 x double>* %1143
%1144 = getelementptr inbounds double, double* %1142, i64 2
%1145 = bitcast double* %1144 to <2 x double>*
store <2 x double> %1141, <2 x double>* %1145
br label %1146
1146: ; preds = %1123, %1125
br i1 %81, label %1184, label %1147
1147: ; preds = %1068, %1065, %1146
%1148 = phi i64 [ 0, %1068 ], [ 0, %1065 ], [ %76, %1146 ]
%1149 = xor i64 %1148, -1
br i1 %83, label %1159, label %1150
1150: ; preds = %1147
%1151 = getelementptr inbounds double, double* %14, i64 %1148
%1152 = load double, double* %1151
%1153 = getelementptr inbounds double, double* %1067, i64 %1148
%1154 = load double, double* %1153
%1155 = fsub double %1154, %1152
%1156 = tail call double @llvm.fmuladd.f64(double %1155, double 5.000000e-01, double %1152)
%1157 = getelementptr inbounds double, double* %20, i64 %1148
store double %1156, double* %1157
%1158 = or i64 %1148, 1
br label %1159
1159: ; preds = %1150, %1147
%1160 = phi i64 [ %1148, %1147 ], [ %1158, %1150 ]
%1161 = icmp eq i64 %1149, %84
br i1 %1161, label %1184, label %1165
1162: ; preds = %1062
br i1 %23, label %1327, label %1163
1163: ; preds = %1162
%1164 = zext i32 %162 to i64
br label %1305
1165: ; preds = %1159, %1165
%1166 = phi i64 [ %1182, %1165 ], [ %1160, %1159 ]
%1167 = getelementptr inbounds double, double* %14, i64 %1166
%1168 = load double, double* %1167
%1169 = getelementptr inbounds double, double* %1067, i64 %1166
%1170 = load double, double* %1169
%1171 = fsub double %1170, %1168
%1172 = tail call double @llvm.fmuladd.f64(double %1171, double 5.000000e-01, double %1168)
%1173 = getelementptr inbounds double, double* %20, i64 %1166
store double %1172, double* %1173
%1174 = add nuw nsw i64 %1166, 1
%1175 = getelementptr inbounds double, double* %14, i64 %1174
%1176 = load double, double* %1175
%1177 = getelementptr inbounds double, double* %1067, i64 %1174
%1178 = load double, double* %1177
%1179 = fsub double %1178, %1176
%1180 = tail call double @llvm.fmuladd.f64(double %1179, double 5.000000e-01, double %1176)
%1181 = getelementptr inbounds double, double* %20, i64 %1174
store double %1180, double* %1181
%1182 = add nuw nsw i64 %1166, 2
%1183 = icmp eq i64 %1182, %26
br i1 %1183, label %1184, label %1165
1184: ; preds = %1159, %1165, %1146, %1064
%1185 = tail call i32 (double*, double*, double*, i32, i32, ...) bitcast (i32 (...)* @objective_function to i32 (double*, double*, double*, i32, i32, ...)*)(double* %0, double* %1, double* %20, i32 %2, i32 %3)
%1186 = sitofp i32 %1185 to double
%1187 = load double, double* %847
%1188 = fcmp ogt double %1187, %1186
br i1 %1188, label %1189, label %1331
1189: ; preds = %1184
br i1 %22, label %1190, label %1304
1190: ; preds = %1189
%1191 = getelementptr inbounds double*, double** %7, i64 %846
%1192 = load double*, double** %1191
br i1 %85, label %1269, label %1193
1193: ; preds = %1190
%1194 = bitcast double* %1192 to i8*
%1195 = getelementptr double, double* %1192, i64 %26
%1196 = bitcast double* %1195 to i8*
%1197 = icmp ugt i8* %36, %1194
%1198 = icmp ult i8* %19, %1196
%1199 = and i1 %1197, %1198
br i1 %1199, label %1269, label %1200
1200: ; preds = %1193
br i1 %88, label %1250, label %1201
1201: ; preds = %1200, %1201
%1202 = phi i64 [ %1247, %1201 ], [ 0, %1200 ]
%1203 = phi i64 [ %1248, %1201 ], [ 0, %1200 ]
%1204 = getelementptr inbounds double, double* %20, i64 %1202
%1205 = bitcast double* %1204 to <2 x double>*
%1206 = load <2 x double>, <2 x double>* %1205
%1207 = getelementptr inbounds double, double* %1204, i64 2
%1208 = bitcast double* %1207 to <2 x double>*
%1209 = load <2 x double>, <2 x double>* %1208
%1210 = getelementptr inbounds double, double* %1192, i64 %1202
%1211 = bitcast double* %1210 to <2 x double>*
store <2 x double> %1206, <2 x double>* %1211
%1212 = getelementptr inbounds double, double* %1210, i64 2
%1213 = bitcast double* %1212 to <2 x double>*
store <2 x double> %1209, <2 x double>* %1213
%1214 = or i64 %1202, 4
%1215 = getelementptr inbounds double, double* %20, i64 %1214
%1216 = bitcast double* %1215 to <2 x double>*
%1217 = load <2 x double>, <2 x double>* %1216
%1218 = getelementptr inbounds double, double* %1215, i64 2
%1219 = bitcast double* %1218 to <2 x double>*
%1220 = load <2 x double>, <2 x double>* %1219
%1221 = getelementptr inbounds double, double* %1192, i64 %1214
%1222 = bitcast double* %1221 to <2 x double>*
store <2 x double> %1217, <2 x double>* %1222
%1223 = getelementptr inbounds double, double* %1221, i64 2
%1224 = bitcast double* %1223 to <2 x double>*
store <2 x double> %1220, <2 x double>* %1224
%1225 = or i64 %1202, 8
%1226 = getelementptr inbounds double, double* %20, i64 %1225
%1227 = bitcast double* %1226 to <2 x double>*
%1228 = load <2 x double>, <2 x double>* %1227
%1229 = getelementptr inbounds double, double* %1226, i64 2
%1230 = bitcast double* %1229 to <2 x double>*
%1231 = load <2 x double>, <2 x double>* %1230
%1232 = getelementptr inbounds double, double* %1192, i64 %1225
%1233 = bitcast double* %1232 to <2 x double>*
store <2 x double> %1228, <2 x double>* %1233
%1234 = getelementptr inbounds double, double* %1232, i64 2
%1235 = bitcast double* %1234 to <2 x double>*
store <2 x double> %1231, <2 x double>* %1235
%1236 = or i64 %1202, 12
%1237 = getelementptr inbounds double, double* %20, i64 %1236
%1238 = bitcast double* %1237 to <2 x double>*
%1239 = load <2 x double>, <2 x double>* %1238
%1240 = getelementptr inbounds double, double* %1237, i64 2
%1241 = bitcast double* %1240 to <2 x double>*
%1242 = load <2 x double>, <2 x double>* %1241
%1243 = getelementptr inbounds double, double* %1192, i64 %1236
%1244 = bitcast double* %1243 to <2 x double>*
store <2 x double> %1239, <2 x double>* %1244
%1245 = getelementptr inbounds double, double* %1243, i64 2
%1246 = bitcast double* %1245 to <2 x double>*
store <2 x double> %1242, <2 x double>* %1246
%1247 = add nuw i64 %1202, 16
%1248 = add nuw i64 %1203, 4
%1249 = icmp eq i64 %1248, %89
br i1 %1249, label %1250, label %1201
1250: ; preds = %1201, %1200
%1251 = phi i64 [ 0, %1200 ], [ %1247, %1201 ]
br i1 %90, label %1268, label %1252
1252: ; preds = %1250, %1252
%1253 = phi i64 [ %1265, %1252 ], [ %1251, %1250 ]
%1254 = phi i64 [ %1266, %1252 ], [ 0, %1250 ]
%1255 = getelementptr inbounds double, double* %20, i64 %1253
%1256 = bitcast double* %1255 to <2 x double>*
%1257 = load <2 x double>, <2 x double>* %1256
%1258 = getelementptr inbounds double, double* %1255, i64 2
%1259 = bitcast double* %1258 to <2 x double>*
%1260 = load <2 x double>, <2 x double>* %1259
%1261 = getelementptr inbounds double, double* %1192, i64 %1253
%1262 = bitcast double* %1261 to <2 x double>*
store <2 x double> %1257, <2 x double>* %1262
%1263 = getelementptr inbounds double, double* %1261, i64 2
%1264 = bitcast double* %1263 to <2 x double>*
store <2 x double> %1260, <2 x double>* %1264
%1265 = add nuw i64 %1253, 4
%1266 = add i64 %1254, 1
%1267 = icmp eq i64 %1266, %87
br i1 %1267, label %1268, label %1252
1268: ; preds = %1252, %1250
br i1 %91, label %1304, label %1269
1269: ; preds = %1193, %1190, %1268
%1270 = phi i64 [ 0, %1193 ], [ 0, %1190 ], [ %86, %1268 ]
%1271 = xor i64 %1270, -1
%1272 = add nsw i64 %1271, %26
br i1 %93, label %1282, label %1273
1273: ; preds = %1269, %1273
%1274 = phi i64 [ %1279, %1273 ], [ %1270, %1269 ]
%1275 = phi i64 [ %1280, %1273 ], [ 0, %1269 ]
%1276 = getelementptr inbounds double, double* %20, i64 %1274
%1277 = load double, double* %1276
%1278 = getelementptr inbounds double, double* %1192, i64 %1274
store double %1277, double* %1278
%1279 = add nuw nsw i64 %1274, 1
%1280 = add i64 %1275, 1
%1281 = icmp eq i64 %1280, %92
br i1 %1281, label %1282, label %1273
1282: ; preds = %1273, %1269
%1283 = phi i64 [ %1270, %1269 ], [ %1279, %1273 ]
%1284 = icmp ult i64 %1272, 3
br i1 %1284, label %1304, label %1285
1285: ; preds = %1282, %1285
%1286 = phi i64 [ %1302, %1285 ], [ %1283, %1282 ]
%1287 = getelementptr inbounds double, double* %20, i64 %1286
%1288 = load double, double* %1287
%1289 = getelementptr inbounds double, double* %1192, i64 %1286
store double %1288, double* %1289
%1290 = add nuw nsw i64 %1286, 1
%1291 = getelementptr inbounds double, double* %20, i64 %1290
%1292 = load double, double* %1291
%1293 = getelementptr inbounds double, double* %1192, i64 %1290
store double %1292, double* %1293
%1294 = add nuw nsw i64 %1286, 2
%1295 = getelementptr inbounds double, double* %20, i64 %1294
%1296 = load double, double* %1295
%1297 = getelementptr inbounds double, double* %1192, i64 %1294
store double %1296, double* %1297
%1298 = add nuw nsw i64 %1286, 3
%1299 = getelementptr inbounds double, double* %20, i64 %1298
%1300 = load double, double* %1299
%1301 = getelementptr inbounds double, double* %1192, i64 %1298
store double %1300, double* %1301
%1302 = add nuw nsw i64 %1286, 4
%1303 = icmp eq i64 %1302, %26
br i1 %1303, label %1304, label %1285
1304: ; preds = %1282, %1285, %1268, %1189
store double %1186, double* %847
br label %1331
1305: ; preds = %1163, %1324
%1306 = phi i64 [ 0, %1163 ], [ %1325, %1324 ]
%1307 = icmp ne i64 %1306, %1164
%1308 = icmp slt i64 %1306, %11
%1309 = and i1 %1307, %1308
br i1 %1309, label %1310, label %1324
1310: ; preds = %1305
%1311 = getelementptr inbounds double*, double** %7, i64 %366
%1312 = load double*, double** %1311
%1313 = getelementptr inbounds double*, double** %7, i64 %1306
%1314 = load double*, double** %1313
br label %1315
1315: ; preds = %1315, %1310
%1316 = phi i64 [ 0, %1310 ], [ %1323, %1315 ]
%1317 = getelementptr inbounds double, double* %1312, i64 %1316
%1318 = load double, double* %1317
%1319 = getelementptr inbounds double, double* %1314, i64 %1316
%1320 = load double, double* %1319
%1321 = fsub double %1320, %1318
%1322 = tail call double @llvm.fmuladd.f64(double %1321, double 5.000000e-01, double %1318)
store double %1322, double* %1319
%1323 = add nuw i64 %1316, 1
br label %1315
1324: ; preds = %1305
%1325 = add nuw nsw i64 %1306, 1
%1326 = icmp eq i64 %1325, %28
br i1 %1326, label %1327, label %1305
1327: ; preds = %1324, %1162
%1328 = tail call i32 (double*, double*, double**, i32, i32, ...) bitcast (i32 (...)* @call_functions to i32 (double*, double*, double**, i32, i32, ...)*)(double* %0, double* %1, double** %7, i32 %2, i32 %3)
%1329 = sext i32 %1328 to i64
%1330 = inttoptr i64 %1329 to double*
br label %1331
1331: ; preds = %941, %715, %713, %836, %709, %1060, %937, %1184, %1304, %1327, %840, %491
%1332 = phi double* [ %136, %491 ], [ %136, %709 ], [ %136, %836 ], [ %136, %713 ], [ %136, %1060 ], [ %136, %937 ], [ %136, %1304 ], [ %136, %1184 ], [ %1330, %1327 ], [ %136, %840 ], [ %136, %715 ], [ %136, %941 ]
%1333 = urem i32 %137, 42
%1334 = icmp eq i32 %1333, 0
br i1 %1334, label %1335, label %1342
1335: ; preds = %1331
%1336 = icmp eq i32 %137, 0
%1337 = getelementptr inbounds double, double* %1332, i64 %366
%1338 = load double, double* %1337
br i1 %1336, label %1342, label %1339
1339: ; preds = %1335
%1340 = fsub double %138, %1338
%1341 = tail call double @llvm.fabs.f64(double %1340)
br label %1342
1342: ; preds = %1335, %1339, %1331
%1343 = phi double [ %138, %1331 ], [ %1338, %1339 ], [ %1338, %1335 ]
%1344 = phi double [ %139, %1331 ], [ %1341, %1339 ], [ %139, %1335 ]
%1345 = add nuw nsw i32 %137, 1
%1346 = icmp ult i32 %137, 4999
%1347 = fcmp ogt double %1344, 1.000000e-04
%1348 = select i1 %1346, i1 %1347, i1 false
br i1 %1348, label %135, label %1349
1349: ; preds = %1342
%1350 = icmp eq i32 %1345, 5000
br i1 %1350, label %1351, label %1353
1351: ; preds = %1349
%1352 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str, i64 0, i64 0))
br label %1353
1353: ; preds = %1351, %1349
%1354 = getelementptr inbounds double*, double** %7, i64 %366
%1355 = load double*, double** %1354
ret double* %1355
}