#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
double sqrt(double);
double find_Emin(int n, double **a) {
  static int i, j, po, num, rl, rlnum;
  static double *v0, *v1, *v2;
  static double tmp, tmp0, tmp1, e0, e1;
  static double *al, *be;
  static double shiftE = 5.0;
  static double diff = 1.0e-5;
  static int rlmax = 20;
  static int nummax = 100;
  v0 = (double *)malloc(sizeof(double) * (n + 1));
  v1 = (double *)malloc(sizeof(double) * (n + 1));
  v2 = (double *)malloc(sizeof(double) * (n + 1));
  al = (double *)malloc(sizeof(double) * (n + 1));
  be = (double *)malloc(sizeof(double) * (n + 1));
  tmp = 1.0 / sqrt((double)n);
  for (i = 0; i <= n; i++) {
    v0[i] = 0.0;
    v1[i] = tmp;
    v2[i] = 0.0;
    al[i] = 0.0;
    be[i] = 0.0;
  }
  if (n < rlmax)
    rlnum = n - 1;
  else
    rlnum = rlmax;
  for (rl = 1; rl <= rlnum; rl++) {
    for (i = 1; i <= n; i++) {
      tmp = 0.0;
      for (j = 1; j <= n; j++) {
        tmp += a[i][j] * v1[j];
      }
      v2[i] = tmp;
    }
    tmp0 = 0.0;
    for (i = 1; i <= n; i++) {
      tmp0 += v1[i] * v2[i];
    }
    al[rl] = tmp0;
    tmp0 = be[rl];
    tmp1 = al[rl];
    for (i = 1; i <= n; i++) {
      v2[i] = v2[i] - tmp0 * v0[i] - tmp1 * v1[i];
    }
    tmp0 = 0.0;
    for (i = 1; i <= n; i++) {
      tmp0 += v2[i] * v2[i];
    }
    be[rl + 1] = sqrt(tmp0);
    tmp0 = be[rl + 1];
    for (i = 1; i <= n; i++) {
      v0[i] = v1[i];
      v1[i] = v2[i] / tmp0;
    }
  }
  for (i = 1; i <= rlnum; i++)
    al[i] -= shiftE;
  for (i = 0; i <= n; i++)
    v1[i] = 0.0;
  v1[1] = 1.0;
  e0 = 1.0e+100;
  po = 0;
  num = 0;
  do {
    num++;
    for (i = 1; i <= n; i++) {
      v2[i] = be[i] * v1[i - 1] + al[i] * v1[i] + be[i + 1] * v1[i + 1];
    }
    e1 = 0.0;
    for (i = 1; i <= n; i++) {
      e1 += v1[i] * v2[i];
    }
    if (fabs(e1 - e0) < diff)
      po = 1;
    else
      e0 = e1;
    tmp = 0.0;
    for (i = 1; i <= n; i++) {
      tmp += v2[i] * v2[i];
    }
    tmp = 1.0 / sqrt(tmp);
    for (i = 1; i <= n; i++) {
      v1[i] = tmp * v2[i];
    }
  } while (po == 0 && num < nummax);
  free(v0);
  free(v1);
  free(v2);
  free(al);
  free(be);
  e1 += shiftE;
  return e1;
}


x86 assembly (clang, -O0):
<find_Emin>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,0x2f17(%rip)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,0x2f05(%rip)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,0x2ef3(%rip)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,0x2f09(%rip)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,0x2ef7(%rip)
cvtsi2sdl -0x4(%rbp),%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xe2a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2ea6(%rip)
movl   $0x0,0x2e6c(%rip)
mov    0x2e66(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1282 <find_Emin+0x152>
mov    0x2e6e(%rip),%rax
movslq 0x2e4f(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x2e6f(%rip),%xmm0
mov    0x2e58(%rip),%rax
movslq 0x2e31(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2e4d(%rip),%rax
movslq 0x2e1e(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2e67(%rip),%rax
movslq 0x2e08(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2e59(%rip),%rax
movslq 0x2df2(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2de4(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2ddb(%rip)
jmp    11ec <find_Emin+0xbc>
mov    -0x4(%rbp),%eax
cmp    0x2dbd(%rip),%eax
jge    12a2 <find_Emin+0x172>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,0x2dcf(%rip)
jmp    12ae <find_Emin+0x17e>
mov    0x2da0(%rip),%eax
mov    %eax,0x2dbe(%rip)
movl   $0x1,0x2db0(%rip)
mov    0x2daa(%rip),%eax
cmp    0x2da8(%rip),%eax
jg     1673 <find_Emin+0x543>
movl   $0x1,0x2d84(%rip)
mov    0x2d7e(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1390 <find_Emin+0x260>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2d9a(%rip)
movl   $0x1,0x2d64(%rip)
mov    0x2d5e(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1361 <find_Emin+0x231>
mov    -0x10(%rbp),%rax
movslq 0x2d46(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x2d3f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2d4f(%rip),%rax
movslq 0x2d2c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2d4b(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2d3b(%rip)
mov    0x2d09(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2d00(%rip)
jmp    12f8 <find_Emin+0x1c8>
movsd  0x2d1f(%rip),%xmm0
mov    0x2d10(%rip),%rax
movslq 0x2ce1(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2cd6(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2ccd(%rip)
jmp    12d4 <find_Emin+0x1a4>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2cf5(%rip)
movl   $0x1,0x2cb3(%rip)
mov    0x2cad(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1406 <find_Emin+0x2d6>
mov    0x2cbd(%rip),%rax
movslq 0x2c96(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2cb2(%rip),%rax
movslq 0x2c83(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2cae(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2c9e(%rip)
mov    0x2c60(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2c57(%rip)
jmp    13a5 <find_Emin+0x275>
movsd  0x2c82(%rip),%xmm0
mov    0x2c9b(%rip),%rax
movslq 0x2c4c(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2c90(%rip),%rax
movslq 0x2c39(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2c54(%rip)
mov    0x2c6d(%rip),%rax
movslq 0x2c1e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2c41(%rip)
movl   $0x1,0x2bf7(%rip)
mov    0x2bf1(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     151e <find_Emin+0x3ee>
mov    0x2c09(%rip),%rax
movslq 0x2bda(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x2c05(%rip),%xmm1
mov    0x2bde(%rip),%rax
movslq 0x2bbf(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2bd3(%rip),%xmm0
mov    0x2bac(%rip),%rax
movslq 0x2b85(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x2b82(%rip),%rax
movslq 0x2b53(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2b48(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2b3f(%rip)
jmp    1461 <find_Emin+0x331>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2b67(%rip)
movl   $0x1,0x2b25(%rip)
mov    0x2b1f(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1594 <find_Emin+0x464>
mov    0x2b37(%rip),%rax
movslq 0x2b08(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2b24(%rip),%rax
movslq 0x2af5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2b20(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2b10(%rip)
mov    0x2ad2(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2ac9(%rip)
jmp    1533 <find_Emin+0x403>
movsd  0x2af4(%rip),%xmm0
call   1050 <sqrt@plt>
mov    0x2b10(%rip),%rax
mov    0x2aba(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2af8(%rip),%rax
mov    0x2aa2(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2ab7(%rip)
movl   $0x1,0x2a75(%rip)
mov    0x2a6f(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     165a <find_Emin+0x52a>
mov    0x2a7f(%rip),%rax
movslq 0x2a58(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2a64(%rip),%rax
movslq 0x2a45(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2a61(%rip),%rax
movslq 0x2a32(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  0x2a5d(%rip),%xmm0
mov    0x2a3e(%rip),%rax
movslq 0x2a17(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2a0c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2a03(%rip)
jmp    15e3 <find_Emin+0x4b3>
jmp    165f <find_Emin+0x52f>
mov    0x2a03(%rip),%eax
add    $0x1,%eax
mov    %eax,0x29fa(%rip)
jmp    12b8 <find_Emin+0x188>
movl   $0x1,0x29db(%rip)
mov    0x29d5(%rip),%eax
cmp    0x29e3(%rip),%eax
jg     16c7 <find_Emin+0x597>
movsd  0x29a1(%rip),%xmm1
mov    0x2a12(%rip),%rax
movslq 0x29b3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x299f(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2996(%rip)
jmp    167d <find_Emin+0x54d>
movl   $0x0,0x2987(%rip)
mov    0x2981(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     170a <find_Emin+0x5da>
mov    0x2991(%rip),%rax
movslq 0x296a(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x295c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2953(%rip)
jmp    16d1 <find_Emin+0x5a1>
mov    0x2967(%rip),%rax
movsd  0x8e7(%rip),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  0x8e2(%rip),%xmm0
movsd  %xmm0,0x2972(%rip)
movl   $0x0,0x2928(%rip)
movl   $0x0,0x2922(%rip)
mov    0x291c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2913(%rip)
movl   $0x1,0x28fd(%rip)
mov    0x28f7(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1822 <find_Emin+0x6f2>
mov    0x2947(%rip),%rax
movslq 0x28e0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28f4(%rip),%rax
mov    0x28ce(%rip),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x2914(%rip),%rax
movslq 0x28b5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28c9(%rip),%rax
movslq 0x28a2(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x28ee(%rip),%rax
mov    0x2888(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2896(%rip),%rax
mov    0x2870(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x287e(%rip),%rax
movslq 0x284f(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2844(%rip),%eax
add    $0x1,%eax
mov    %eax,0x283b(%rip)
jmp    175b <find_Emin+0x62b>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x287b(%rip)
movl   $0x1,0x2821(%rip)
mov    0x281b(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1898 <find_Emin+0x768>
mov    0x282b(%rip),%rax
movslq 0x2804(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2820(%rip),%rax
movslq 0x27f1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2834(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2824(%rip)
mov    0x27ce(%rip),%eax
add    $0x1,%eax
mov    %eax,0x27c5(%rip)
jmp    1837 <find_Emin+0x707>
movsd  0x2808(%rip),%xmm1
subsd  0x27f8(%rip),%xmm1
movaps 0x761(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x2785(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    18d4 <find_Emin+0x7a4>
movl   $0x1,0x2791(%rip)
jmp    18e4 <find_Emin+0x7b4>
movsd  0x27cc(%rip),%xmm0
movsd  %xmm0,0x27bc(%rip)
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2799(%rip)
movl   $0x1,0x275f(%rip)
mov    0x2759(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     195a <find_Emin+0x82a>
mov    0x2771(%rip),%rax
movslq 0x2742(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x275e(%rip),%rax
movslq 0x272f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2752(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2742(%rip)
mov    0x270c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2703(%rip)
jmp    18f9 <find_Emin+0x7c9>
movsd  0x2726(%rip),%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x68e(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x270a(%rip)
movl   $0x1,0x26d0(%rip)
mov    0x26ca(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     19d9 <find_Emin+0x8a9>
movsd  0x26e9(%rip),%xmm0
mov    0x26da(%rip),%rax
movslq 0x26ab(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x26bf(%rip),%rax
movslq 0x2698(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x268d(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2684(%rip)
jmp    1988 <find_Emin+0x858>
jmp    19de <find_Emin+0x8ae>
xor    %eax,%eax
cmpl   $0x0,0x2679(%rip)
mov    %al,-0x11(%rbp)
jne    1a02 <find_Emin+0x8d2>
mov    0x266e(%rip),%eax
cmp    0x2650(%rip),%eax
setl   %al
mov    %al,-0x11(%rbp)
mov    -0x11(%rbp),%al
test   $0x1,%al
jne    1742 <find_Emin+0x612>
mov    0x265c(%rip),%rdi
call   1030 <free@plt>
mov    0x2658(%rip),%rdi
call   1030 <free@plt>
mov    0x2654(%rip),%rdi
call   1030 <free@plt>
mov    0x2678(%rip),%rdi
call   1030 <free@plt>
mov    0x2674(%rip),%rdi
call   1030 <free@plt>
movsd  0x25e7(%rip),%xmm0
addsd  0x264f(%rip),%xmm0
movsd  %xmm0,0x2647(%rip)
movsd  0x263f(%rip),%xmm0
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_Emin>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rsi,%r13
mov    %edi,%ebx
lea    0x8(,%rbx,8),%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x3ef0(%rip)
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x3eea(%rip)
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x3ee4(%rip)
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x3eee(%rip)
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rbx,%r8
cvtsi2sd %r8d,%xmm0
mov    %rax,0x3ee0(%rip)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %rbx,(%rsp)
jb     11c4 <find_Emin+0x84>
sqrtsd %xmm0,%xmm0
test   %r8d,%r8d
jns    11d6 <find_Emin+0x96>
jmp    12a3 <find_Emin+0x163>
call   1060 <sqrt@plt>
mov    (%rsp),%r8
test   %r8d,%r8d
js     12a3 <find_Emin+0x163>
movsd  0x1e22(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    0x3e6f(%rip),%rax
mov    0x3e70(%rip),%rcx
mov    0x3e71(%rip),%rdx
mov    0x3e82(%rip),%rsi
mov    0x3e83(%rip),%rdi
lea    0x1(%r8),%r9d
test   %r8d,%r8d
je     2112 <find_Emin+0xfd2>
mov    %r9d,%ebp
and    $0xfffffffe,%ebp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%rax,%rbx,8)
movsd  %xmm1,(%rcx,%rbx,8)
movq   $0x0,(%rdx,%rbx,8)
movq   $0x0,(%rsi,%rbx,8)
movq   $0x0,(%rdi,%rbx,8)
movq   $0x0,0x8(%rax,%rbx,8)
movsd  %xmm1,0x8(%rcx,%rbx,8)
movq   $0x0,0x8(%rdx,%rbx,8)
movq   $0x0,0x8(%rsi,%rbx,8)
movq   $0x0,0x8(%rdi,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%rbp
jne    1220 <find_Emin+0xe0>
test   $0x1,%r9b
je     12a3 <find_Emin+0x163>
movq   $0x0,(%rax,%rbx,8)
movsd  %xmm1,(%rcx,%rbx,8)
movq   $0x0,(%rdx,%rbx,8)
movq   $0x0,(%rsi,%rbx,8)
movq   $0x0,(%rdi,%rbx,8)
lea    -0x1(%r8),%eax
cmp    $0x14,%r8d
mov    $0x14,%ecx
cmovl  %eax,%ecx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x58(%rsp)
mov    %ecx,0x3d8c(%rip)
movl   $0x1,0x3d7e(%rip)
test   %ecx,%ecx
jle    1ae7 <find_Emin+0x9a7>
lea    0x1(%r8),%ebp
lea    -0x1(%rbp),%r9
lea    -0x2(%rbp),%r14
lea    -0x3(%rbp),%rax
mov    %rax,0x40(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %r9d,%r12d
and    $0x3,%r12d
mov    %r9,%r15
and    $0xfffffffffffffffc,%r15
lea    0x1(%r15),%rax
mov    %rax,0x30(%rsp)
mov    %rbp,%rax
neg    %rax
mov    %rax,0x28(%rsp)
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x70(%rsp)
mov    %r9,%rax
or     $0x1,%rax
mov    %rax,0x68(%rsp)
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x60(%rsp)
mov    $0x1,%r10d
xorpd  %xmm9,%xmm9
mov    %r9,0x8(%rsp)
jmp    1375 <find_Emin+0x235>
cs nopw 0x0(%rax,%rax,1)
mov    %r10d,0x3ce9(%rip)
mov    0x3ce7(%rip),%edx
cmp    %edx,%ebx
jge    19df <find_Emin+0x89f>
xorpd  %xmm1,%xmm1
test   %r8d,%r8d
jle    1507 <find_Emin+0x3c7>
mov    0x3cd7(%rip),%rcx
mov    $0x1,%edx
mov    0x3cd3(%rip),%rsi
jmp    13b2 <find_Emin+0x272>
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,(%rsi,%rdx,8)
add    $0x1,%rdx
cmp    %rbp,%rdx
je     1450 <find_Emin+0x310>
mov    0x0(%r13,%rdx,8),%rax
xorpd  %xmm0,%xmm0
mov    $0x1,%edi
cmp    $0x3,%r14
jb     141d <find_Emin+0x2dd>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
nopl   0x0(%rax)
movsd  0x8(%rax,%rdi,8),%xmm1
movsd  0x10(%rax,%rdi,8),%xmm2
mulsd  0x8(%rcx,%rdi,8),%xmm1
mulsd  0x10(%rcx,%rdi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%rax,%rdi,8),%xmm3
mulsd  0x18(%rcx,%rdi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x20(%rax,%rdi,8),%xmm0
mulsd  0x20(%rcx,%rdi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdi
cmp    %rdi,%r15
jne    13d0 <find_Emin+0x290>
add    $0x1,%rdi
test   %r12,%r12
je     13a0 <find_Emin+0x260>
lea    (%rcx,%rdi,8),%rbx
lea    (%rax,%rdi,8),%rax
xor    %edi,%edi
movsd  (%rax,%rdi,8),%xmm1
mulsd  (%rbx,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%r12
jne    1430 <find_Emin+0x2f0>
jmp    13a0 <find_Emin+0x260>
nopl   0x0(%rax)
test   %r8d,%r8d
jle    1480 <find_Emin+0x340>
mov    0x3c04(%rip),%rax
mov    0x3c05(%rip),%rcx
xorpd  %xmm1,%xmm1
cmp    $0x3,%r14
jae    1489 <find_Emin+0x349>
mov    $0x1,%edx
test   $0x3,%r9b
jne    14e3 <find_Emin+0x3a3>
jmp    1507 <find_Emin+0x3c7>
nopl   (%rax)
xorpd  %xmm1,%xmm1
jmp    1507 <find_Emin+0x3c7>
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rax,%rdx,8),%xmm0
movsd  0x10(%rax,%rdx,8),%xmm2
mulsd  0x8(%rcx,%rdx,8),%xmm0
mulsd  0x10(%rcx,%rdx,8),%xmm2
addsd  %xmm1,%xmm0
movsd  0x18(%rax,%rdx,8),%xmm3
mulsd  0x18(%rcx,%rdx,8),%xmm3
addsd  %xmm0,%xmm2
movsd  0x20(%rax,%rdx,8),%xmm1
mulsd  0x20(%rcx,%rdx,8),%xmm1
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
add    $0x4,%rdx
cmp    %rdx,%r15
jne    1490 <find_Emin+0x350>
add    $0x1,%rdx
test   $0x3,%r9b
je     1507 <find_Emin+0x3c7>
lea    (%rcx,%rdx,8),%rcx
lea    (%rax,%rdx,8),%rax
xor    %edx,%edx
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rdx
cmp    %rdx,%r12
jne    14f0 <find_Emin+0x3b0>
mov    0x3b72(%rip),%rax
movslq %r10d,%rdx
movsd  %xmm1,(%rax,%rdx,8)
xorpd  %xmm0,%xmm0
test   %r8d,%r8d
jle    1796 <find_Emin+0x656>
mov    0x3b5e(%rip),%rsi
mov    0x3b37(%rip),%rax
mov    0x3b20(%rip),%rcx
movsd  (%rsi,%rdx,8),%xmm8
movapd 0x1ada(%rip),%xmm2
xorpd  %xmm2,%xmm8
mov    0x3b0e(%rip),%rdx
xorpd  %xmm2,%xmm1
mov    $0x1,%esi
cmp    $0x4,%r9
jae    1610 <find_Emin+0x4d0>
mov    %rsi,%rdi
test   $0x1,%bpl
jne    1593 <find_Emin+0x453>
movsd  (%rcx,%rsi,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  (%rax,%rsi,8),%xmm2
movsd  (%rdx,%rsi,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rax,%rsi,8)
lea    0x1(%rsi),%rdi
not    %rsi
cmp    0x28(%rsp),%rsi
je     16f0 <find_Emin+0x5b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rdi,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  (%rax,%rdi,8),%xmm2
movsd  (%rdx,%rdi,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rax,%rdi,8)
movsd  0x8(%rcx,%rdi,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  0x8(%rax,%rdi,8),%xmm2
movsd  0x8(%rdx,%rdi,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x8(%rax,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rbp
jne    15b0 <find_Emin+0x470>
jmp    16f0 <find_Emin+0x5b0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x8(%rax),%rdi
lea    (%rax,%rbp,8),%r10
lea    0x8(%rcx),%r8
lea    (%rcx,%rbp,8),%r9
lea    0x8(%rdx),%rbx
mov    %rbx,0x18(%rsp)
lea    (%rdx,%rbp,8),%r11
cmp    %r9,%rdi
setb   %bl
cmp    %r10,%r8
setb   %r9b
cmp    %r11,%rdi
setb   %r8b
cmp    %r10,0x18(%rsp)
setb   %dil
test   %r9b,%bl
jne    1926 <find_Emin+0x7e6>
and    %dil,%r8b
mov    (%rsp),%r8
mov    0x8(%rsp),%r9
jne    1565 <find_Emin+0x425>
movapd %xmm8,%xmm3
unpcklpd %xmm8,%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
xor    %esi,%esi
nopl   0x0(%rax)
movupd 0x8(%rax,%rsi,8),%xmm5
movupd 0x18(%rax,%rsi,8),%xmm6
movupd 0x8(%rcx,%rsi,8),%xmm7
movupd 0x18(%rcx,%rsi,8),%xmm2
mulpd  %xmm3,%xmm7
addpd  %xmm5,%xmm7
mulpd  %xmm3,%xmm2
addpd  %xmm6,%xmm2
movupd 0x8(%rdx,%rsi,8),%xmm5
movupd 0x18(%rdx,%rsi,8),%xmm6
mulpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm2,%xmm6
movupd %xmm5,0x8(%rax,%rsi,8)
movupd %xmm6,0x18(%rax,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r15
jne    1680 <find_Emin+0x540>
mov    0x30(%rsp),%rsi
cmp    %r15,%r9
jne    1565 <find_Emin+0x425>
nopw   0x0(%rax,%rax,1)
test   %r8d,%r8d
jle    1796 <find_Emin+0x656>
mov    0x3968(%rip),%rax
xorpd  %xmm0,%xmm0
cmp    $0x3,%r14
jae    171a <find_Emin+0x5da>
mov    $0x1,%ecx
test   $0x3,%r9b
jne    176b <find_Emin+0x62b>
jmp    1796 <find_Emin+0x656>
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  0x10(%rax,%rcx,8),%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0x18(%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
movsd  0x20(%rax,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%rcx
cmp    %rcx,%r15
jne    1720 <find_Emin+0x5e0>
add    $0x1,%rcx
test   $0x3,%r9b
je     1796 <find_Emin+0x656>
lea    (%rax,%rcx,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1780 <find_Emin+0x640>
ucomisd %xmm9,%xmm0
jb     17b0 <find_Emin+0x670>
sqrtsd %xmm0,%xmm0
jmp    17c3 <find_Emin+0x683>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
call   1060 <sqrt@plt>
xorpd  %xmm9,%xmm9
mov    0x8(%rsp),%r9
mov    (%rsp),%r8
movslq 0x3886(%rip),%rbx
lea    0x1(%rbx),%r10
mov    0x38b3(%rip),%rax
movsd  %xmm0,0x8(%rax,%rbx,8)
test   %r8d,%r8d
jle    1360 <find_Emin+0x220>
mov    0x3875(%rip),%rdx
mov    0x3866(%rip),%rsi
mov    $0x1,%ecx
mov    0x386a(%rip),%rdi
cmp    $0x2,%r9
jae    1890 <find_Emin+0x750>
mov    %rcx,%rax
test   $0x1,%bpl
jne    182d <find_Emin+0x6ed>
movsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
movsd  (%rdi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
lea    0x1(%rcx),%rax
not    %rcx
cmp    0x28(%rsp),%rcx
je     1360 <find_Emin+0x220>
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rsi,%rax,8)
movsd  (%rdi,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rsi,%rax,8)
movsd  0x8(%rdi,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1840 <find_Emin+0x700>
jmp    1360 <find_Emin+0x220>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,0x10(%rsp)
mov    %r10,0x18(%rsp)
lea    0x8(%rsi),%rax
lea    (%rsi,%rbp,8),%rbx
lea    0x8(%rdx),%r11
lea    (%rdx,%rbp,8),%r8
lea    0x8(%rdi),%r10
lea    (%rdi,%rbp,8),%r9
cmp    %r8,%rax
setb   0x20(%rsp)
cmp    %rbx,%r11
setb   0x50(%rsp)
cmp    %r9,%rax
setb   %al
cmp    %rbx,%r10
setb   0x48(%rsp)
cmp    %r9,%r11
setb   %r9b
cmp    %r8,%r10
setb   %r11b
mov    0x50(%rsp),%bl
test   %bl,0x20(%rsp)
jne    19b8 <find_Emin+0x878>
and    0x48(%rsp),%al
mov    (%rsp),%r8
mov    0x18(%rsp),%r10
jne    19d0 <find_Emin+0x890>
and    %r11b,%r9b
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%rbx
jne    1808 <find_Emin+0x6c8>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x2,0x40(%rsp)
jae    1934 <find_Emin+0x7f4>
xor    %eax,%eax
jmp    197e <find_Emin+0x83e>
mov    (%rsp),%r8
mov    0x8(%rsp),%r9
jmp    1565 <find_Emin+0x425>
mov    0x60(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups 0x8(%rdx,%rax,8),%xmm2
movups %xmm2,0x8(%rsi,%rax,8)
movupd 0x8(%rdi,%rax,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,0x8(%rdx,%rax,8)
movups 0x18(%rdx,%rax,8),%xmm2
movups %xmm2,0x18(%rsi,%rax,8)
movupd 0x18(%rdi,%rax,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,0x18(%rdx,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    1940 <find_Emin+0x800>
testb  $0x1,0x38(%rsp)
je     19a3 <find_Emin+0x863>
shl    $0x3,%rax
or     $0x8,%rax
movups (%rdx,%rax,1),%xmm2
movups %xmm2,(%rsi,%rax,1)
movupd (%rdi,%rax,1),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rdx,%rax,1)
mov    0x68(%rsp),%rcx
cmp    0x70(%rsp),%r9
je     1360 <find_Emin+0x220>
jmp    1808 <find_Emin+0x6c8>
mov    (%rsp),%r8
mov    0x8(%rsp),%r9
mov    0x18(%rsp),%r10
mov    0x10(%rsp),%rbx
jmp    1808 <find_Emin+0x6c8>
mov    0x8(%rsp),%r9
mov    0x10(%rsp),%rbx
jmp    1808 <find_Emin+0x6c8>
test   %edx,%edx
jle    1ae7 <find_Emin+0x9a7>
mov    0x3692(%rip),%rax
mov    $0x1,%ecx
cmp    $0x4,%rdx
jb     1abd <find_Emin+0x97d>
mov    %edx,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     2123 <find_Emin+0xfe3>
mov    %rbp,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
mov    $0x1,%esi
movapd 0x15f9(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movupd (%rax,%rsi,8),%xmm1
movupd 0x10(%rax,%rsi,8),%xmm2
movupd 0x20(%rax,%rsi,8),%xmm3
movupd 0x30(%rax,%rsi,8),%xmm4
addpd  %xmm0,%xmm1
addpd  %xmm0,%xmm2
movupd %xmm1,(%rax,%rsi,8)
movupd %xmm2,0x10(%rax,%rsi,8)
addpd  %xmm0,%xmm3
addpd  %xmm0,%xmm4
movupd %xmm3,0x20(%rax,%rsi,8)
movupd %xmm4,0x30(%rax,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1a40 <find_Emin+0x900>
test   $0x1,%bpl
je     1ab4 <find_Emin+0x974>
movupd (%rax,%rsi,8),%xmm0
movupd 0x10(%rax,%rsi,8),%xmm1
movapd 0x158f(%rip),%xmm2
addpd  %xmm2,%xmm0
addpd  %xmm2,%xmm1
movupd %xmm0,(%rax,%rsi,8)
movupd %xmm1,0x10(%rax,%rsi,8)
cmp    %rcx,%rdx
je     1ae7 <find_Emin+0x9a7>
or     $0x1,%rcx
add    $0x1,%rdx
movsd  0x153f(%rip),%xmm0
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1ad0 <find_Emin+0x990>
mov    0x3572(%rip),%rbp
mov    %r8d,%r14d
test   %r8d,%r8d
js     1b0c <find_Emin+0x9cc>
lea    0x8(,%r14,8),%rdx
mov    %rbp,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    (%rsp),%r8
lea    0x1(%r14),%rbx
movabs $0x3ff0000000000000,%rax
mov    %rax,0x8(%rbp)
movabs $0x54b249ad2594c37d,%rax
49 b2 54
mov    %rax,0x3541(%rip)
movb   $0x0,0x3512(%rip)
lea    0x2(%r14),%rax
mov    %rax,0x18(%rsp)
lea    -0x1(%r14),%r12
lea    -0x4(%r14),%rax
mov    %rax,0x50(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %r14d,%ebp
and    $0xfffffffe,%ebp
mov    %r14,%rcx
or     $0x1,%rcx
mov    %rcx,0x38(%rsp)
mov    %r14d,%r13d
and    $0x3,%r13d
mov    %r14d,%r15d
and    $0xfffffffc,%r15d
lea    0x1(%r15),%rcx
mov    %rcx,0x30(%rsp)
mov    %rax,%rcx
mov    %rax,0x48(%rsp)
and    %rax,0x58(%rsp)
xor    %eax,%eax
movapd 0x14ac(%rip),%xmm4
movsd  0x1474(%rip),%xmm5
xorpd  %xmm6,%xmm6
mov    %r14,0x10(%rsp)
mov    %r12,0x20(%rsp)
mov    %rbp,0x40(%rsp)
nop
add    $0x1,%eax
mov    %eax,0x3493(%rip)
xorpd  %xmm0,%xmm0
test   %r8d,%r8d
jle    1dd7 <find_Emin+0xc97>
mov    0x34bb(%rip),%rax
mov    0x348c(%rip),%rcx
mov    0x34a5(%rip),%rdx
mov    $0x1,%edi
mov    0x3481(%rip),%rsi
cmp    $0x2,%r14d
jb     1cd0 <find_Emin+0xb90>
lea    0x8(%rsi),%r14
lea    (%rsi,%rbx,8),%r11
lea    0x8(%rax),%r8
mov    0x18(%rsp),%r10
lea    (%rax,%r10,8),%r9
lea    (%rcx,%r10,8),%r10
lea    0x8(%rdx),%rbp
mov    %rbp,0x8(%rsp)
lea    (%rdx,%rbx,8),%rbp
cmp    %r9,%r14
setb   0x28(%rsp)
cmp    %r11,%r8
setb   %r12b
cmp    %r10,%r14
setb   %r8b
cmp    %r11,%rcx
setb   %r10b
cmp    %rbp,%r14
setb   %r9b
cmp    %r11,0x8(%rsp)
setb   %r11b
test   %r12b,0x28(%rsp)
jne    1cc2 <find_Emin+0xb82>
and    %r10b,%r8b
jne    1cc2 <find_Emin+0xb82>
and    %r11b,%r9b
mov    (%rsp),%r8
mov    0x10(%rsp),%r14
mov    0x20(%rsp),%r12
jne    1cd0 <find_Emin+0xb90>
xor    %edi,%edi
mov    0x40(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movupd 0x8(%rdx,%rdi,8),%xmm0
movupd (%rcx,%rdi,8),%xmm1
movupd 0x8(%rcx,%rdi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rcx,%rdi,8),%xmm0
movupd 0x8(%rax,%rdi,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd 0x10(%rax,%rdi,8),%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,0x8(%rsi,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rbp
jne    1c70 <find_Emin+0xb30>
mov    0x38(%rsp),%rdi
cmp    %rbp,%r14
jne    1cd0 <find_Emin+0xb90>
jmp    1d0a <find_Emin+0xbca>
mov    (%rsp),%r8
mov    0x10(%rsp),%r14
mov    0x20(%rsp),%r12
movsd  (%rdx,%rdi,8),%xmm0
mulsd  (%rcx,%rdi,8),%xmm0
movsd  (%rax,%rdi,8),%xmm1
mulsd  -0x8(%rcx,%rdi,8),%xmm1
movsd  0x8(%rax,%rdi,8),%xmm2
addsd  %xmm0,%xmm1
mulsd  0x8(%rcx,%rdi,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rsi,%rdi,8)
lea    0x1(%rdi),%rbp
mov    %rbp,%rdi
cmp    %rbp,%rbx
jne    1cd0 <find_Emin+0xb90>
movq   $0x0,0x3363(%rip)
test   %r8d,%r8d
jle    1d50 <find_Emin+0xc10>
mov    0x333f(%rip),%rax
mov    0x3340(%rip),%rcx
xorpd  %xmm0,%xmm0
cmp    $0x3,%r12
jae    1d59 <find_Emin+0xc19>
mov    $0x1,%edx
test   %r13,%r13
jne    1db2 <find_Emin+0xc72>
jmp    1dd7 <find_Emin+0xc97>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
jmp    1ddf <find_Emin+0xc9f>
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rax,%rdx,8),%xmm1
movsd  0x10(%rax,%rdx,8),%xmm2
mulsd  0x8(%rcx,%rdx,8),%xmm1
mulsd  0x10(%rcx,%rdx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%rax,%rdx,8),%xmm3
mulsd  0x18(%rcx,%rdx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x20(%rax,%rdx,8),%xmm0
mulsd  0x20(%rcx,%rdx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdx
cmp    %rdx,%r15
jne    1d60 <find_Emin+0xc20>
add    $0x1,%rdx
test   %r13,%r13
je     1dd7 <find_Emin+0xc97>
lea    (%rcx,%rdx,8),%rcx
lea    (%rax,%rdx,8),%rax
xor    %edx,%edx
nopl   0x0(%rax)
movsd  (%rax,%rdx,8),%xmm1
mulsd  (%rcx,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%r13
jne    1dc0 <find_Emin+0xc80>
movsd  %xmm0,0x3299(%rip)
movapd %xmm0,%xmm1
subsd  0x3285(%rip),%xmm1
andpd  %xmm4,%xmm1
ucomisd %xmm1,%xmm5
jbe    1e30 <find_Emin+0xcf0>
movb   $0x1,0x324c(%rip)
test   %r8d,%r8d
jle    1e3d <find_Emin+0xcfd>
mov    0x3260(%rip),%rax
xorpd  %xmm0,%xmm0
cmp    $0x3,%r12
jae    1e50 <find_Emin+0xd10>
mov    $0x1,%ecx
test   $0x3,%r14b
jne    1eab <find_Emin+0xd6b>
jmp    1ed6 <find_Emin+0xd96>
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm0,0x3238(%rip)
test   %r8d,%r8d
jg     1e01 <find_Emin+0xcc1>
xorpd  %xmm0,%xmm0
jmp    1ed6 <find_Emin+0xd96>
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  0x10(%rax,%rcx,8),%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  0x18(%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
movsd  0x20(%rax,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x4,%rcx
cmp    %rcx,%r15
jne    1e60 <find_Emin+0xd20>
add    $0x1,%rcx
test   $0x3,%r14b
je     1ed6 <find_Emin+0xd96>
lea    (%rax,%rcx,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1ec0 <find_Emin+0xd80>
ucomisd %xmm6,%xmm0
jb     1ef0 <find_Emin+0xdb0>
sqrtsd %xmm0,%xmm0
test   %r8d,%r8d
jg     1f16 <find_Emin+0xdd6>
jmp    2097 <find_Emin+0xf57>
nopw   0x0(%rax,%rax,1)
call   1060 <sqrt@plt>
xorpd  %xmm6,%xmm6
movsd  0x110f(%rip),%xmm5
movapd 0x1137(%rip),%xmm4
mov    (%rsp),%r8
test   %r8d,%r8d
jle    2097 <find_Emin+0xf57>
movsd  0x10e2(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    0x313f(%rip),%rax
mov    $0x1,%edx
mov    0x312b(%rip),%rcx
cmp    $0x4,%r14d
jb     2010 <find_Emin+0xed0>
lea    0x8(%rcx),%rsi
lea    (%rax,%rbx,8),%rdi
cmp    %rdi,%rsi
jae    1f5d <find_Emin+0xe1d>
lea    (%rcx,%rbx,8),%rsi
lea    0x8(%rax),%rdi
cmp    %rsi,%rdi
jb     2010 <find_Emin+0xed0>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x4,0x50(%rsp)
jae    1f71 <find_Emin+0xe31>
xor    %edx,%edx
jmp    1fca <find_Emin+0xe8a>
mov    0x58(%rsp),%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd 0x8(%rax,%rdx,8),%xmm2
movupd 0x18(%rax,%rdx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x8(%rcx,%rdx,8)
movupd %xmm3,0x18(%rcx,%rdx,8)
movupd 0x28(%rax,%rdx,8),%xmm2
movupd 0x38(%rax,%rdx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,0x28(%rcx,%rdx,8)
movupd %xmm3,0x38(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1f80 <find_Emin+0xe40>
testb  $0x1,0x48(%rsp)
je     1ff7 <find_Emin+0xeb7>
shl    $0x3,%rdx
or     $0x8,%rdx
movupd (%rax,%rdx,1),%xmm2
movupd 0x10(%rax,%rdx,1),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rcx,%rdx,1)
movupd %xmm3,0x10(%rcx,%rdx,1)
mov    0x30(%rsp),%rdx
cmp    %r15,%r14
je     2097 <find_Emin+0xf57>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebx,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rbx,%rsi
and    $0x3,%rdi
je     2048 <find_Emin+0xf08>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    2030 <find_Emin+0xef0>
cmp    $0x3,%rsi
jb     2097 <find_Emin+0xf57>
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rcx,%rdx,8)
movsd  0x10(%rax,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rcx,%rdx,8)
movsd  0x18(%rax,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    2050 <find_Emin+0xf10>
cmpb   $0x1,0x2faa(%rip)
je     20af <find_Emin+0xf6f>
mov    0x2fa6(%rip),%eax
cmp    $0x64,%eax
jl     1bb0 <find_Emin+0xa70>
mov    0x2fa2(%rip),%rdi
call   1030 <free@plt>
mov    0x2f9e(%rip),%rdi
call   1030 <free@plt>
mov    0x2f9a(%rip),%rdi
call   1030 <free@plt>
mov    0x2fa6(%rip),%rdi
call   1030 <free@plt>
mov    0x2fa2(%rip),%rdi
call   1030 <free@plt>
movsd  0x2f85(%rip),%xmm0
addsd  0xf1d(%rip),%xmm0
movsd  %xmm0,0x2f75(%rip)
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebx,%ebx
test   $0x1,%r9b
jne    127e <find_Emin+0x13e>
jmp    12a3 <find_Emin+0x163>
mov    $0x1,%esi
test   $0x1,%bpl
jne    1a8e <find_Emin+0x94e>
jmp    1ab4 <find_Emin+0x974>

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

LLVM IR (-O2):
@find_Emin.po = internal unnamed_addr global i1 false
@find_Emin.num = internal unnamed_addr global i32 0
@find_Emin.rl = internal unnamed_addr global i32 0
@find_Emin.rlnum = internal unnamed_addr global i32 0
@find_Emin.v0 = internal unnamed_addr global double* null
@find_Emin.v1 = internal unnamed_addr global double* null
@find_Emin.v2 = internal unnamed_addr global double* null
@find_Emin.e0 = internal unnamed_addr global double 0.000000e+00
@find_Emin.e1 = internal unnamed_addr global double 0.000000e+00
@find_Emin.al = internal unnamed_addr global double* null
@find_Emin.be = internal unnamed_addr global double* null
define double @find_Emin(i32 %0, double** nocapture %1) {
%3 = shl i32 %0, 3
%4 = add i32 %3, 8
%5 = tail call i64 @malloc(i32 %4)
%6 = inttoptr i64 %5 to double*
store double* %6, double** @find_Emin.v0
%7 = tail call i64 @malloc(i32 %4)
%8 = inttoptr i64 %7 to double*
store double* %8, double** @find_Emin.v1
%9 = tail call i64 @malloc(i32 %4)
%10 = inttoptr i64 %9 to double*
store double* %10, double** @find_Emin.v2
%11 = tail call i64 @malloc(i32 %4)
%12 = inttoptr i64 %11 to double*
store double* %12, double** @find_Emin.al
%13 = tail call i64 @malloc(i32 %4)
%14 = inttoptr i64 %13 to double*
store double* %14, double** @find_Emin.be
%15 = sitofp i32 %0 to double
%16 = tail call double @sqrt(double %15)
%17 = fdiv double 1.000000e+00, %16
%18 = icmp slt i32 %0, 0
br i1 %18, label %57, label %19
19: ; preds = %2
%20 = load double*, double** @find_Emin.v0
%21 = load double*, double** @find_Emin.v1
%22 = load double*, double** @find_Emin.v2
%23 = load double*, double** @find_Emin.al
%24 = load double*, double** @find_Emin.be
%25 = add nuw i32 %0, 1
%26 = zext i32 %25 to i64
%27 = and i64 %26, 1
%28 = icmp eq i32 %0, 0
br i1 %28, label %48, label %29
29: ; preds = %19
%30 = and i64 %26, 4294967294
br label %31
31: ; preds = %31, %29
%32 = phi i64 [ 0, %29 ], [ %45, %31 ]
%33 = phi i64 [ 0, %29 ], [ %46, %31 ]
%34 = getelementptr inbounds double, double* %20, i64 %32
store double 0.000000e+00, double* %34
%35 = getelementptr inbounds double, double* %21, i64 %32
store double %17, double* %35
%36 = getelementptr inbounds double, double* %22, i64 %32
store double 0.000000e+00, double* %36
%37 = getelementptr inbounds double, double* %23, i64 %32
store double 0.000000e+00, double* %37
%38 = getelementptr inbounds double, double* %24, i64 %32
store double 0.000000e+00, double* %38
%39 = or i64 %32, 1
%40 = getelementptr inbounds double, double* %20, i64 %39
store double 0.000000e+00, double* %40
%41 = getelementptr inbounds double, double* %21, i64 %39
store double %17, double* %41
%42 = getelementptr inbounds double, double* %22, i64 %39
store double 0.000000e+00, double* %42
%43 = getelementptr inbounds double, double* %23, i64 %39
store double 0.000000e+00, double* %43
%44 = getelementptr inbounds double, double* %24, i64 %39
store double 0.000000e+00, double* %44
%45 = add nuw nsw i64 %32, 2
%46 = add i64 %33, 2
%47 = icmp eq i64 %46, %30
br i1 %47, label %48, label %31
48: ; preds = %31, %19
%49 = phi i64 [ 0, %19 ], [ %45, %31 ]
%50 = icmp eq i64 %27, 0
br i1 %50, label %57, label %51
51: ; preds = %48
%52 = getelementptr inbounds double, double* %20, i64 %49
store double 0.000000e+00, double* %52
%53 = getelementptr inbounds double, double* %21, i64 %49
store double %17, double* %53
%54 = getelementptr inbounds double, double* %22, i64 %49
store double 0.000000e+00, double* %54
%55 = getelementptr inbounds double, double* %23, i64 %49
store double 0.000000e+00, double* %55
%56 = getelementptr inbounds double, double* %24, i64 %49
store double 0.000000e+00, double* %56
br label %57
57: ; preds = %51, %48, %2
%58 = icmp slt i32 %0, 20
%59 = add i32 %0, -1
%60 = select i1 %58, i32 %59, i32 20
store i32 %60, i32* @find_Emin.rlnum
store i32 1, i32* @find_Emin.rl
%61 = icmp slt i32 %60, 1
br i1 %61, label %534, label %62
62: ; preds = %57
%63 = icmp slt i32 %0, 1
%64 = add i32 %0, 1
%65 = zext i32 %64 to i64
%66 = zext i32 %64 to i64
%67 = zext i32 %64 to i64
%68 = add nsw i64 %65, -1
%69 = add nsw i64 %65, -1
%70 = add nsw i64 %65, -1
%71 = add nsw i64 %65, -2
%72 = add nsw i64 %65, -3
%73 = lshr i64 %72, 1
%74 = add nuw i64 %73, 1
%75 = and i64 %70, 3
%76 = icmp ult i64 %71, 3
%77 = and i64 %70, -4
%78 = icmp eq i64 %75, 0
%79 = and i64 %70, 3
%80 = icmp ult i64 %71, 3
%81 = and i64 %70, -4
%82 = icmp eq i64 %79, 0
%83 = icmp ult i64 %69, 4
%84 = and i64 %69, -4
%85 = or i64 %84, 1
%86 = icmp eq i64 %69, %84
%87 = and i64 %65, 1
%88 = icmp eq i64 %87, 0
%89 = sub nsw i64 0, %65
%90 = and i64 %70, 3
%91 = icmp ult i64 %71, 3
%92 = and i64 %70, -4
%93 = icmp eq i64 %90, 0
%94 = icmp ult i64 %68, 2
%95 = and i64 %68, -2
%96 = or i64 %68, 1
%97 = and i64 %74, 1
%98 = icmp ult i64 %72, 2
%99 = and i64 %74, -2
%100 = icmp eq i64 %97, 0
%101 = icmp eq i64 %68, %95
%102 = and i64 %65, 1
%103 = icmp eq i64 %102, 0
%104 = sub nsw i64 0, %65
br label %108
105: ; preds = %514, %517, %502, %427
store i32 %432, i32* @find_Emin.rl
%106 = load i32, i32* @find_Emin.rlnum
%107 = icmp slt i32 %431, %106
br i1 %107, label %108, label %113
108: ; preds = %62, %105
%109 = phi i32 [ 1, %62 ], [ %432, %105 ]
br i1 %63, label %284, label %110
110: ; preds = %108
%111 = load double*, double** @find_Emin.v1
%112 = load double*, double** @find_Emin.v2
br label %179
113: ; preds = %105
%114 = icmp slt i32 %106, 1
br i1 %114, label %534, label %115
115: ; preds = %113
%116 = load double*, double** @find_Emin.al
%117 = add nuw i32 %106, 1
%118 = zext i32 %117 to i64
%119 = add nsw i64 %118, -1
%120 = icmp ult i64 %119, 4
br i1 %120, label %177, label %121
121: ; preds = %115
%122 = and i64 %119, -4
%123 = or i64 %122, 1
%124 = add nsw i64 %122, -4
%125 = lshr exact i64 %124, 2
%126 = add nuw nsw i64 %125, 1
%127 = and i64 %126, 1
%128 = icmp eq i64 %124, 0
br i1 %128, label %161, label %129
129: ; preds = %121
%130 = and i64 %126, 9223372036854775806
br label %131
131: ; preds = %131, %129
%132 = phi i64 [ 0, %129 ], [ %156, %131 ]
%133 = phi i64 [ 0, %129 ], [ %157, %131 ]
%134 = or i64 %132, 1
%135 = getelementptr inbounds double, double* %116, i64 %134
%136 = bitcast double* %135 to <2 x double>*
%137 = load <2 x double>, <2 x double>* %136
%138 = getelementptr inbounds double, double* %135, i64 2
%139 = bitcast double* %138 to <2 x double>*
%140 = load <2 x double>, <2 x double>* %139
%141 = fadd <2 x double> %137, <double -5.000000e+00, double -5.000000e+00>
%142 = fadd <2 x double> %140, <double -5.000000e+00, double -5.000000e+00>
%143 = bitcast double* %135 to <2 x double>*
store <2 x double> %141, <2 x double>* %143
%144 = bitcast double* %138 to <2 x double>*
store <2 x double> %142, <2 x double>* %144
%145 = or i64 %132, 5
%146 = getelementptr inbounds double, double* %116, i64 %145
%147 = bitcast double* %146 to <2 x double>*
%148 = load <2 x double>, <2 x double>* %147
%149 = getelementptr inbounds double, double* %146, i64 2
%150 = bitcast double* %149 to <2 x double>*
%151 = load <2 x double>, <2 x double>* %150
%152 = fadd <2 x double> %148, <double -5.000000e+00, double -5.000000e+00>
%153 = fadd <2 x double> %151, <double -5.000000e+00, double -5.000000e+00>
%154 = bitcast double* %146 to <2 x double>*
store <2 x double> %152, <2 x double>* %154
%155 = bitcast double* %149 to <2 x double>*
store <2 x double> %153, <2 x double>* %155
%156 = add nuw i64 %132, 8
%157 = add i64 %133, 2
%158 = icmp eq i64 %157, %130
br i1 %158, label %159, label %131
159: ; preds = %131
%160 = or i64 %156, 1
br label %161
161: ; preds = %159, %121
%162 = phi i64 [ 1, %121 ], [ %160, %159 ]
%163 = icmp eq i64 %127, 0
br i1 %163, label %175, label %164
164: ; preds = %161
%165 = getelementptr inbounds double, double* %116, i64 %162
%166 = bitcast double* %165 to <2 x double>*
%167 = load <2 x double>, <2 x double>* %166
%168 = getelementptr inbounds double, double* %165, i64 2
%169 = bitcast double* %168 to <2 x double>*
%170 = load <2 x double>, <2 x double>* %169
%171 = fadd <2 x double> %167, <double -5.000000e+00, double -5.000000e+00>
%172 = fadd <2 x double> %170, <double -5.000000e+00, double -5.000000e+00>
%173 = bitcast double* %165 to <2 x double>*
store <2 x double> %171, <2 x double>* %173
%174 = bitcast double* %168 to <2 x double>*
store <2 x double> %172, <2 x double>* %174
br label %175
175: ; preds = %161, %164
%176 = icmp eq i64 %119, %122
br i1 %176, label %534, label %177
177: ; preds = %115, %175
%178 = phi i64 [ 1, %115 ], [ %123, %175 ]
br label %541
179: ; preds = %229, %110
%180 = phi i64 [ 1, %110 ], [ %232, %229 ]
%181 = getelementptr inbounds double*, double** %1, i64 %180
%182 = load double*, double** %181
br i1 %76, label %213, label %183
183: ; preds = %179, %183
%184 = phi i64 [ %210, %183 ], [ 1, %179 ]
%185 = phi double [ %209, %183 ], [ 0.000000e+00, %179 ]
%186 = phi i64 [ %211, %183 ], [ 0, %179 ]
%187 = getelementptr inbounds double, double* %182, i64 %184
%188 = load double, double* %187
%189 = getelementptr inbounds double, double* %111, i64 %184
%190 = load double, double* %189
%191 = tail call double @llvm.fmuladd.f64(double %188, double %190, double %185)
%192 = add nuw nsw i64 %184, 1
%193 = getelementptr inbounds double, double* %182, i64 %192
%194 = load double, double* %193
%195 = getelementptr inbounds double, double* %111, i64 %192
%196 = load double, double* %195
%197 = tail call double @llvm.fmuladd.f64(double %194, double %196, double %191)
%198 = add nuw nsw i64 %184, 2
%199 = getelementptr inbounds double, double* %182, i64 %198
%200 = load double, double* %199
%201 = getelementptr inbounds double, double* %111, i64 %198
%202 = load double, double* %201
%203 = tail call double @llvm.fmuladd.f64(double %200, double %202, double %197)
%204 = add nuw nsw i64 %184, 3
%205 = getelementptr inbounds double, double* %182, i64 %204
%206 = load double, double* %205
%207 = getelementptr inbounds double, double* %111, i64 %204
%208 = load double, double* %207
%209 = tail call double @llvm.fmuladd.f64(double %206, double %208, double %203)
%210 = add nuw nsw i64 %184, 4
%211 = add i64 %186, 4
%212 = icmp eq i64 %211, %77
br i1 %212, label %213, label %183
213: ; preds = %183, %179
%214 = phi double [ undef, %179 ], [ %209, %183 ]
%215 = phi i64 [ 1, %179 ], [ %210, %183 ]
%216 = phi double [ 0.000000e+00, %179 ], [ %209, %183 ]
br i1 %78, label %229, label %217
217: ; preds = %213, %217
%218 = phi i64 [ %226, %217 ], [ %215, %213 ]
%219 = phi double [ %225, %217 ], [ %216, %213 ]
%220 = phi i64 [ %227, %217 ], [ 0, %213 ]
%221 = getelementptr inbounds double, double* %182, i64 %218
%222 = load double, double* %221
%223 = getelementptr inbounds double, double* %111, i64 %218
%224 = load double, double* %223
%225 = tail call double @llvm.fmuladd.f64(double %222, double %224, double %219)
%226 = add nuw nsw i64 %218, 1
%227 = add i64 %220, 1
%228 = icmp eq i64 %227, %75
br i1 %228, label %229, label %217
229: ; preds = %217, %213
%230 = phi double [ %214, %213 ], [ %225, %217 ]
%231 = getelementptr inbounds double, double* %112, i64 %180
store double %230, double* %231
%232 = add nuw nsw i64 %180, 1
%233 = icmp eq i64 %232, %65
br i1 %233, label %234, label %179
234: ; preds = %229
br i1 %63, label %284, label %235
235: ; preds = %234
%236 = load double*, double** @find_Emin.v1
%237 = load double*, double** @find_Emin.v2
br i1 %80, label %268, label %238
238: ; preds = %235, %238
%239 = phi i64 [ %265, %238 ], [ 1, %235 ]
%240 = phi double [ %264, %238 ], [ 0.000000e+00, %235 ]
%241 = phi i64 [ %266, %238 ], [ 0, %235 ]
%242 = getelementptr inbounds double, double* %236, i64 %239
%243 = load double, double* %242
%244 = getelementptr inbounds double, double* %237, i64 %239
%245 = load double, double* %244
%246 = tail call double @llvm.fmuladd.f64(double %243, double %245, double %240)
%247 = add nuw nsw i64 %239, 1
%248 = getelementptr inbounds double, double* %236, i64 %247
%249 = load double, double* %248
%250 = getelementptr inbounds double, double* %237, i64 %247
%251 = load double, double* %250
%252 = tail call double @llvm.fmuladd.f64(double %249, double %251, double %246)
%253 = add nuw nsw i64 %239, 2
%254 = getelementptr inbounds double, double* %236, i64 %253
%255 = load double, double* %254
%256 = getelementptr inbounds double, double* %237, i64 %253
%257 = load double, double* %256
%258 = tail call double @llvm.fmuladd.f64(double %255, double %257, double %252)
%259 = add nuw nsw i64 %239, 3
%260 = getelementptr inbounds double, double* %236, i64 %259
%261 = load double, double* %260
%262 = getelementptr inbounds double, double* %237, i64 %259
%263 = load double, double* %262
%264 = tail call double @llvm.fmuladd.f64(double %261, double %263, double %258)
%265 = add nuw nsw i64 %239, 4
%266 = add i64 %241, 4
%267 = icmp eq i64 %266, %81
br i1 %267, label %268, label %238
268: ; preds = %238, %235
%269 = phi double [ undef, %235 ], [ %264, %238 ]
%270 = phi i64 [ 1, %235 ], [ %265, %238 ]
%271 = phi double [ 0.000000e+00, %235 ], [ %264, %238 ]
br i1 %82, label %284, label %272
272: ; preds = %268, %272
%273 = phi i64 [ %281, %272 ], [ %270, %268 ]
%274 = phi double [ %280, %272 ], [ %271, %268 ]
%275 = phi i64 [ %282, %272 ], [ 0, %268 ]
%276 = getelementptr inbounds double, double* %236, i64 %273
%277 = load double, double* %276
%278 = getelementptr inbounds double, double* %237, i64 %273
%279 = load double, double* %278
%280 = tail call double @llvm.fmuladd.f64(double %277, double %279, double %274)
%281 = add nuw nsw i64 %273, 1
%282 = add i64 %275, 1
%283 = icmp eq i64 %282, %79
br i1 %283, label %284, label %272
284: ; preds = %268, %272, %108, %234
%285 = phi double [ 0.000000e+00, %234 ], [ 0.000000e+00, %108 ], [ %269, %268 ], [ %280, %272 ]
%286 = load double*, double** @find_Emin.al
%287 = sext i32 %109 to i64
%288 = getelementptr inbounds double, double* %286, i64 %287
store double %285, double* %288
br i1 %63, label %427, label %289
289: ; preds = %284
%290 = load double*, double** @find_Emin.be
%291 = getelementptr inbounds double, double* %290, i64 %287
%292 = load double, double* %291
%293 = load double*, double** @find_Emin.v2
%294 = load double*, double** @find_Emin.v0
%295 = fneg double %292
%296 = load double*, double** @find_Emin.v1
%297 = fneg double %285
br i1 %83, label %351, label %298
298: ; preds = %289
%299 = getelementptr double, double* %293, i64 1
%300 = getelementptr double, double* %293, i64 %65
%301 = getelementptr double, double* %294, i64 1
%302 = getelementptr double, double* %294, i64 %65
%303 = getelementptr double, double* %296, i64 1
%304 = getelementptr double, double* %296, i64 %65
%305 = icmp ult double* %299, %302
%306 = icmp ult double* %301, %300
%307 = and i1 %305, %306
%308 = icmp ult double* %299, %304
%309 = icmp ult double* %303, %300
%310 = and i1 %308, %309
%311 = or i1 %307, %310
br i1 %311, label %351, label %312
312: ; preds = %298
%313 = insertelement <2 x double> poison, double %295, i64 0
%314 = shufflevector <2 x double> %313, <2 x double> poison, <2 x i32> zeroinitializer
%315 = insertelement <2 x double> poison, double %295, i64 0
%316 = shufflevector <2 x double> %315, <2 x double> poison, <2 x i32> zeroinitializer
%317 = insertelement <2 x double> poison, double %297, i64 0
%318 = shufflevector <2 x double> %317, <2 x double> poison, <2 x i32> zeroinitializer
%319 = insertelement <2 x double> poison, double %297, i64 0
%320 = shufflevector <2 x double> %319, <2 x double> poison, <2 x i32> zeroinitializer
br label %321
321: ; preds = %321, %312
%322 = phi i64 [ 0, %312 ], [ %348, %321 ]
%323 = or i64 %322, 1
%324 = getelementptr inbounds double, double* %293, i64 %323
%325 = bitcast double* %324 to <2 x double>*
%326 = load <2 x double>, <2 x double>* %325
%327 = getelementptr inbounds double, double* %324, i64 2
%328 = bitcast double* %327 to <2 x double>*
%329 = load <2 x double>, <2 x double>* %328
%330 = getelementptr inbounds double, double* %294, i64 %323
%331 = bitcast double* %330 to <2 x double>*
%332 = load <2 x double>, <2 x double>* %331
%333 = getelementptr inbounds double, double* %330, i64 2
%334 = bitcast double* %333 to <2 x double>*
%335 = load <2 x double>, <2 x double>* %334
%336 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %314, <2 x double> %332, <2 x double> %326)
%337 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %316, <2 x double> %335, <2 x double> %329)
%338 = getelementptr inbounds double, double* %296, i64 %323
%339 = bitcast double* %338 to <2 x double>*
%340 = load <2 x double>, <2 x double>* %339
%341 = getelementptr inbounds double, double* %338, i64 2
%342 = bitcast double* %341 to <2 x double>*
%343 = load <2 x double>, <2 x double>* %342
%344 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %318, <2 x double> %340, <2 x double> %336)
%345 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %320, <2 x double> %343, <2 x double> %337)
%346 = bitcast double* %324 to <2 x double>*
store <2 x double> %344, <2 x double>* %346
%347 = bitcast double* %327 to <2 x double>*
store <2 x double> %345, <2 x double>* %347
%348 = add nuw i64 %322, 4
%349 = icmp eq i64 %348, %84
br i1 %349, label %350, label %321
350: ; preds = %321
br i1 %86, label %388, label %351
351: ; preds = %298, %289, %350
%352 = phi i64 [ 1, %298 ], [ 1, %289 ], [ %85, %350 ]
%353 = xor i64 %352, -1
br i1 %88, label %354, label %364
354: ; preds = %351
%355 = getelementptr inbounds double, double* %293, i64 %352
%356 = load double, double* %355
%357 = getelementptr inbounds double, double* %294, i64 %352
%358 = load double, double* %357
%359 = tail call double @llvm.fmuladd.f64(double %295, double %358, double %356)
%360 = getelementptr inbounds double, double* %296, i64 %352
%361 = load double, double* %360
%362 = tail call double @llvm.fmuladd.f64(double %297, double %361, double %359)
store double %362, double* %355
%363 = add nuw nsw i64 %352, 1
br label %364
364: ; preds = %354, %351
%365 = phi i64 [ %352, %351 ], [ %363, %354 ]
%366 = icmp eq i64 %353, %89
br i1 %366, label %388, label %367
367: ; preds = %364, %367
%368 = phi i64 [ %386, %367 ], [ %365, %364 ]
%369 = getelementptr inbounds double, double* %293, i64 %368
%370 = load double, double* %369
%371 = getelementptr inbounds double, double* %294, i64 %368
%372 = load double, double* %371
%373 = tail call double @llvm.fmuladd.f64(double %295, double %372, double %370)
%374 = getelementptr inbounds double, double* %296, i64 %368
%375 = load double, double* %374
%376 = tail call double @llvm.fmuladd.f64(double %297, double %375, double %373)
store double %376, double* %369
%377 = add nuw nsw i64 %368, 1
%378 = getelementptr inbounds double, double* %293, i64 %377
%379 = load double, double* %378
%380 = getelementptr inbounds double, double* %294, i64 %377
%381 = load double, double* %380
%382 = tail call double @llvm.fmuladd.f64(double %295, double %381, double %379)
%383 = getelementptr inbounds double, double* %296, i64 %377
%384 = load double, double* %383
%385 = tail call double @llvm.fmuladd.f64(double %297, double %384, double %382)
store double %385, double* %378
%386 = add nuw nsw i64 %368, 2
%387 = icmp eq i64 %386, %66
br i1 %387, label %388, label %367
388: ; preds = %364, %367, %350
br i1 %63, label %427, label %389
389: ; preds = %388
%390 = load double*, double** @find_Emin.v2
br i1 %91, label %413, label %391
391: ; preds = %389, %391
%392 = phi i64 [ %410, %391 ], [ 1, %389 ]
%393 = phi double [ %409, %391 ], [ 0.000000e+00, %389 ]
%394 = phi i64 [ %411, %391 ], [ 0, %389 ]
%395 = getelementptr inbounds double, double* %390, i64 %392
%396 = load double, double* %395
%397 = tail call double @llvm.fmuladd.f64(double %396, double %396, double %393)
%398 = add nuw nsw i64 %392, 1
%399 = getelementptr inbounds double, double* %390, i64 %398
%400 = load double, double* %399
%401 = tail call double @llvm.fmuladd.f64(double %400, double %400, double %397)
%402 = add nuw nsw i64 %392, 2
%403 = getelementptr inbounds double, double* %390, i64 %402
%404 = load double, double* %403
%405 = tail call double @llvm.fmuladd.f64(double %404, double %404, double %401)
%406 = add nuw nsw i64 %392, 3
%407 = getelementptr inbounds double, double* %390, i64 %406
%408 = load double, double* %407
%409 = tail call double @llvm.fmuladd.f64(double %408, double %408, double %405)
%410 = add nuw nsw i64 %392, 4
%411 = add i64 %394, 4
%412 = icmp eq i64 %411, %92
br i1 %412, label %413, label %391
413: ; preds = %391, %389
%414 = phi double [ undef, %389 ], [ %409, %391 ]
%415 = phi i64 [ 1, %389 ], [ %410, %391 ]
%416 = phi double [ 0.000000e+00, %389 ], [ %409, %391 ]
br i1 %93, label %427, label %417
417: ; preds = %413, %417
%418 = phi i64 [ %424, %417 ], [ %415, %413 ]
%419 = phi double [ %423, %417 ], [ %416, %413 ]
%420 = phi i64 [ %425, %417 ], [ 0, %413 ]
%421 = getelementptr inbounds double, double* %390, i64 %418
%422 = load double, double* %421
%423 = tail call double @llvm.fmuladd.f64(double %422, double %422, double %419)
%424 = add nuw nsw i64 %418, 1
%425 = add i64 %420, 1
%426 = icmp eq i64 %425, %90
br i1 %426, label %427, label %417
427: ; preds = %413, %417, %284, %388
%428 = phi double [ 0.000000e+00, %388 ], [ 0.000000e+00, %284 ], [ %414, %413 ], [ %423, %417 ]
%429 = tail call double @sqrt(double %428)
%430 = load double*, double** @find_Emin.be
%431 = load i32, i32* @find_Emin.rl
%432 = add nsw i32 %431, 1
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %430, i64 %433
store double %429, double* %434
br i1 %63, label %105, label %435
435: ; preds = %427
%436 = load double*, double** @find_Emin.v1
%437 = load double*, double** @find_Emin.v0
%438 = load double*, double** @find_Emin.v2
br i1 %94, label %503, label %439
439: ; preds = %435
%440 = getelementptr double, double* %437, i64 1
%441 = getelementptr double, double* %437, i64 %65
%442 = getelementptr double, double* %436, i64 1
%443 = getelementptr double, double* %436, i64 %65
%444 = getelementptr double, double* %438, i64 1
%445 = getelementptr double, double* %438, i64 %65
%446 = icmp ult double* %440, %443
%447 = icmp ult double* %442, %441
%448 = and i1 %446, %447
%449 = icmp ult double* %440, %445
%450 = icmp ult double* %444, %441
%451 = and i1 %449, %450
%452 = or i1 %448, %451
%453 = icmp ult double* %442, %445
%454 = icmp ult double* %444, %443
%455 = and i1 %453, %454
%456 = or i1 %452, %455
br i1 %456, label %503, label %457
457: ; preds = %439
%458 = insertelement <2 x double> poison, double %429, i64 0
%459 = shufflevector <2 x double> %458, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %98, label %488, label %460
460: ; preds = %457, %460
%461 = phi i64 [ %485, %460 ], [ 0, %457 ]
%462 = phi i64 [ %486, %460 ], [ 0, %457 ]
%463 = or i64 %461, 1
%464 = getelementptr inbounds double, double* %436, i64 %463
%465 = bitcast double* %464 to <2 x double>*
%466 = load <2 x double>, <2 x double>* %465
%467 = getelementptr inbounds double, double* %437, i64 %463
%468 = bitcast double* %467 to <2 x double>*
store <2 x double> %466, <2 x double>* %468
%469 = getelementptr inbounds double, double* %438, i64 %463
%470 = bitcast double* %469 to <2 x double>*
%471 = load <2 x double>, <2 x double>* %470
%472 = fdiv <2 x double> %471, %459
%473 = bitcast double* %464 to <2 x double>*
store <2 x double> %472, <2 x double>* %473
%474 = or i64 %461, 3
%475 = getelementptr inbounds double, double* %436, i64 %474
%476 = bitcast double* %475 to <2 x double>*
%477 = load <2 x double>, <2 x double>* %476
%478 = getelementptr inbounds double, double* %437, i64 %474
%479 = bitcast double* %478 to <2 x double>*
store <2 x double> %477, <2 x double>* %479
%480 = getelementptr inbounds double, double* %438, i64 %474
%481 = bitcast double* %480 to <2 x double>*
%482 = load <2 x double>, <2 x double>* %481
%483 = fdiv <2 x double> %482, %459
%484 = bitcast double* %475 to <2 x double>*
store <2 x double> %483, <2 x double>* %484
%485 = add nuw i64 %461, 4
%486 = add nuw i64 %462, 2
%487 = icmp eq i64 %486, %99
br i1 %487, label %488, label %460
488: ; preds = %460, %457
%489 = phi i64 [ 0, %457 ], [ %485, %460 ]
br i1 %100, label %502, label %490
490: ; preds = %488
%491 = or i64 %489, 1
%492 = getelementptr inbounds double, double* %436, i64 %491
%493 = bitcast double* %492 to <2 x double>*
%494 = load <2 x double>, <2 x double>* %493
%495 = getelementptr inbounds double, double* %437, i64 %491
%496 = bitcast double* %495 to <2 x double>*
store <2 x double> %494, <2 x double>* %496
%497 = getelementptr inbounds double, double* %438, i64 %491
%498 = bitcast double* %497 to <2 x double>*
%499 = load <2 x double>, <2 x double>* %498
%500 = fdiv <2 x double> %499, %459
%501 = bitcast double* %492 to <2 x double>*
store <2 x double> %500, <2 x double>* %501
br label %502
502: ; preds = %488, %490
br i1 %101, label %105, label %503
503: ; preds = %439, %435, %502
%504 = phi i64 [ 1, %439 ], [ 1, %435 ], [ %96, %502 ]
%505 = xor i64 %504, -1
br i1 %103, label %506, label %514
506: ; preds = %503
%507 = getelementptr inbounds double, double* %436, i64 %504
%508 = load double, double* %507
%509 = getelementptr inbounds double, double* %437, i64 %504
store double %508, double* %509
%510 = getelementptr inbounds double, double* %438, i64 %504
%511 = load double, double* %510
%512 = fdiv double %511, %429
store double %512, double* %507
%513 = add nuw nsw i64 %504, 1
br label %514
514: ; preds = %506, %503
%515 = phi i64 [ %504, %503 ], [ %513, %506 ]
%516 = icmp eq i64 %505, %104
br i1 %516, label %105, label %517
517: ; preds = %514, %517
%518 = phi i64 [ %532, %517 ], [ %515, %514 ]
%519 = getelementptr inbounds double, double* %436, i64 %518
%520 = load double, double* %519
%521 = getelementptr inbounds double, double* %437, i64 %518
store double %520, double* %521
%522 = getelementptr inbounds double, double* %438, i64 %518
%523 = load double, double* %522
%524 = fdiv double %523, %429
store double %524, double* %519
%525 = add nuw nsw i64 %518, 1
%526 = getelementptr inbounds double, double* %436, i64 %525
%527 = load double, double* %526
%528 = getelementptr inbounds double, double* %437, i64 %525
store double %527, double* %528
%529 = getelementptr inbounds double, double* %438, i64 %525
%530 = load double, double* %529
%531 = fdiv double %530, %429
store double %531, double* %526
%532 = add nuw nsw i64 %518, 2
%533 = icmp eq i64 %532, %67
br i1 %533, label %105, label %517
534: ; preds = %541, %175, %57, %113
%535 = load double*, double** @find_Emin.v1
br i1 %18, label %548, label %536
536: ; preds = %534
%537 = bitcast double* %535 to i8*
%538 = zext i32 %0 to i64
%539 = shl nuw nsw i64 %538, 3
%540 = add nuw nsw i64 %539, 8
br label %548
541: ; preds = %177, %541
%542 = phi i64 [ %546, %541 ], [ %178, %177 ]
%543 = getelementptr inbounds double, double* %116, i64 %542
%544 = load double, double* %543
%545 = fadd double %544, -5.000000e+00
store double %545, double* %543
%546 = add nuw nsw i64 %542, 1
%547 = icmp eq i64 %546, %118
br i1 %547, label %534, label %541
548: ; preds = %534, %536
%549 = add nuw i32 %0, 1
%550 = getelementptr inbounds double, double* %535, i64 1
store double 1.000000e+00, double* %550
store double 1.000000e+100, double* @find_Emin.e0
store i1 false, i1* @find_Emin.po
%551 = icmp slt i32 %0, 1
%552 = zext i32 %549 to i64
%553 = zext i32 %549 to i64
%554 = add nsw i64 %552, -1
%555 = add nuw nsw i64 %552, 1
%556 = add nsw i64 %552, -1
%557 = add nsw i64 %552, -2
%558 = add nsw i64 %552, -5
%559 = lshr i64 %558, 2
%560 = add nuw nsw i64 %559, 1
%561 = icmp ult i64 %556, 2
%562 = and i64 %556, -2
%563 = or i64 %556, 1
%564 = icmp eq i64 %556, %562
%565 = and i64 %556, 3
%566 = icmp ult i64 %557, 3
%567 = and i64 %556, -4
%568 = icmp eq i64 %565, 0
%569 = and i64 %556, 3
%570 = icmp ult i64 %557, 3
%571 = and i64 %556, -4
%572 = icmp eq i64 %569, 0
%573 = icmp ult i64 %554, 4
%574 = and i64 %554, -4
%575 = or i64 %574, 1
%576 = and i64 %560, 1
%577 = icmp ult i64 %558, 4
%578 = and i64 %560, 9223372036854775806
%579 = icmp eq i64 %576, 0
%580 = icmp eq i64 %554, %574
br label %581
581: ; preds = %872, %548
%582 = phi i32 [ %875, %872 ], [ 0, %548 ]
%583 = add nsw i32 %582, 1
store i32 %583, i32* @find_Emin.num
br i1 %551, label %711, label %584
584: ; preds = %581
%585 = load double*, double** @find_Emin.be
%586 = load double*, double** @find_Emin.v1
%587 = load double*, double** @find_Emin.al
%588 = load double*, double** @find_Emin.v2
br i1 %561, label %638, label %589
589: ; preds = %584
%590 = getelementptr double, double* %588, i64 1
%591 = getelementptr double, double* %588, i64 %552
%592 = getelementptr double, double* %585, i64 1
%593 = getelementptr double, double* %585, i64 %555
%594 = getelementptr double, double* %586, i64 %555
%595 = getelementptr double, double* %587, i64 1
%596 = getelementptr double, double* %587, i64 %552
%597 = icmp ult double* %590, %593
%598 = icmp ult double* %592, %591
%599 = and i1 %597, %598
%600 = icmp ult double* %590, %594
%601 = icmp ult double* %586, %591
%602 = and i1 %600, %601
%603 = or i1 %599, %602
%604 = icmp ult double* %590, %596
%605 = icmp ult double* %595, %591
%606 = and i1 %604, %605
%607 = or i1 %603, %606
br i1 %607, label %638, label %608
608: ; preds = %589, %608
%609 = phi i64 [ %635, %608 ], [ 0, %589 ]
%610 = or i64 %609, 1
%611 = getelementptr inbounds double, double* %585, i64 %610
%612 = bitcast double* %611 to <2 x double>*
%613 = load <2 x double>, <2 x double>* %612
%614 = getelementptr inbounds double, double* %586, i64 %609
%615 = bitcast double* %614 to <2 x double>*
%616 = load <2 x double>, <2 x double>* %615
%617 = getelementptr inbounds double, double* %587, i64 %610
%618 = bitcast double* %617 to <2 x double>*
%619 = load <2 x double>, <2 x double>* %618
%620 = getelementptr inbounds double, double* %586, i64 %610
%621 = bitcast double* %620 to <2 x double>*
%622 = load <2 x double>, <2 x double>* %621
%623 = fmul <2 x double> %619, %622
%624 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %613, <2 x double> %616, <2 x double> %623)
%625 = add i64 %609, 2
%626 = getelementptr inbounds double, double* %585, i64 %625
%627 = bitcast double* %626 to <2 x double>*
%628 = load <2 x double>, <2 x double>* %627
%629 = getelementptr inbounds double, double* %586, i64 %625
%630 = bitcast double* %629 to <2 x double>*
%631 = load <2 x double>, <2 x double>* %630
%632 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %628, <2 x double> %631, <2 x double> %624)
%633 = getelementptr inbounds double, double* %588, i64 %610
%634 = bitcast double* %633 to <2 x double>*
store <2 x double> %632, <2 x double>* %634
%635 = add nuw i64 %609, 2
%636 = icmp eq i64 %635, %562
br i1 %636, label %637, label %608
637: ; preds = %608
br i1 %564, label %661, label %638
638: ; preds = %589, %584, %637
%639 = phi i64 [ 1, %589 ], [ 1, %584 ], [ %563, %637 ]
br label %640
640: ; preds = %638, %640
%641 = phi i64 [ %653, %640 ], [ %639, %638 ]
%642 = getelementptr inbounds double, double* %585, i64 %641
%643 = load double, double* %642
%644 = add nsw i64 %641, -1
%645 = getelementptr inbounds double, double* %586, i64 %644
%646 = load double, double* %645
%647 = getelementptr inbounds double, double* %587, i64 %641
%648 = load double, double* %647
%649 = getelementptr inbounds double, double* %586, i64 %641
%650 = load double, double* %649
%651 = fmul double %648, %650
%652 = tail call double @llvm.fmuladd.f64(double %643, double %646, double %651)
%653 = add nuw nsw i64 %641, 1
%654 = getelementptr inbounds double, double* %585, i64 %653
%655 = load double, double* %654
%656 = getelementptr inbounds double, double* %586, i64 %653
%657 = load double, double* %656
%658 = tail call double @llvm.fmuladd.f64(double %655, double %657, double %652)
%659 = getelementptr inbounds double, double* %588, i64 %641
store double %658, double* %659
%660 = icmp eq i64 %653, %552
br i1 %660, label %661, label %640
661: ; preds = %640, %637
store double 0.000000e+00, double* @find_Emin.e1
br i1 %551, label %713, label %662
662: ; preds = %661
%663 = load double*, double** @find_Emin.v1
%664 = load double*, double** @find_Emin.v2
br i1 %566, label %695, label %665
665: ; preds = %662, %665
%666 = phi i64 [ %692, %665 ], [ 1, %662 ]
%667 = phi double [ %691, %665 ], [ 0.000000e+00, %662 ]
%668 = phi i64 [ %693, %665 ], [ 0, %662 ]
%669 = getelementptr inbounds double, double* %663, i64 %666
%670 = load double, double* %669
%671 = getelementptr inbounds double, double* %664, i64 %666
%672 = load double, double* %671
%673 = tail call double @llvm.fmuladd.f64(double %670, double %672, double %667)
%674 = add nuw nsw i64 %666, 1
%675 = getelementptr inbounds double, double* %663, i64 %674
%676 = load double, double* %675
%677 = getelementptr inbounds double, double* %664, i64 %674
%678 = load double, double* %677
%679 = tail call double @llvm.fmuladd.f64(double %676, double %678, double %673)
%680 = add nuw nsw i64 %666, 2
%681 = getelementptr inbounds double, double* %663, i64 %680
%682 = load double, double* %681
%683 = getelementptr inbounds double, double* %664, i64 %680
%684 = load double, double* %683
%685 = tail call double @llvm.fmuladd.f64(double %682, double %684, double %679)
%686 = add nuw nsw i64 %666, 3
%687 = getelementptr inbounds double, double* %663, i64 %686
%688 = load double, double* %687
%689 = getelementptr inbounds double, double* %664, i64 %686
%690 = load double, double* %689
%691 = tail call double @llvm.fmuladd.f64(double %688, double %690, double %685)
%692 = add nuw nsw i64 %666, 4
%693 = add i64 %668, 4
%694 = icmp eq i64 %693, %567
br i1 %694, label %695, label %665
695: ; preds = %665, %662
%696 = phi double [ undef, %662 ], [ %691, %665 ]
%697 = phi i64 [ 1, %662 ], [ %692, %665 ]
%698 = phi double [ 0.000000e+00, %662 ], [ %691, %665 ]
br i1 %568, label %711, label %699
699: ; preds = %695, %699
%700 = phi i64 [ %708, %699 ], [ %697, %695 ]
%701 = phi double [ %707, %699 ], [ %698, %695 ]
%702 = phi i64 [ %709, %699 ], [ 0, %695 ]
%703 = getelementptr inbounds double, double* %663, i64 %700
%704 = load double, double* %703
%705 = getelementptr inbounds double, double* %664, i64 %700
%706 = load double, double* %705
%707 = tail call double @llvm.fmuladd.f64(double %704, double %706, double %701)
%708 = add nuw nsw i64 %700, 1
%709 = add i64 %702, 1
%710 = icmp eq i64 %709, %565
br i1 %710, label %711, label %699
711: ; preds = %695, %699, %581
%712 = phi double [ 0.000000e+00, %581 ], [ %696, %695 ], [ %707, %699 ]
store double %712, double* @find_Emin.e1
br label %713
713: ; preds = %711, %661
%714 = phi double [ 0.000000e+00, %661 ], [ %712, %711 ]
%715 = load double, double* @find_Emin.e0
%716 = fsub double %714, %715
%717 = tail call double @llvm.fabs.f64(double %716)
%718 = fcmp olt double %717, 1.000000e-05
br i1 %718, label %719, label %720
719: ; preds = %713
store i1 true, i1* @find_Emin.po
br label %721
720: ; preds = %713
store double %714, double* @find_Emin.e0
br label %721
721: ; preds = %720, %719
br i1 %551, label %760, label %722
722: ; preds = %721
%723 = load double*, double** @find_Emin.v2
br i1 %570, label %746, label %724
724: ; preds = %722, %724
%725 = phi i64 [ %743, %724 ], [ 1, %722 ]
%726 = phi double [ %742, %724 ], [ 0.000000e+00, %722 ]
%727 = phi i64 [ %744, %724 ], [ 0, %722 ]
%728 = getelementptr inbounds double, double* %723, i64 %725
%729 = load double, double* %728
%730 = tail call double @llvm.fmuladd.f64(double %729, double %729, double %726)
%731 = add nuw nsw i64 %725, 1
%732 = getelementptr inbounds double, double* %723, i64 %731
%733 = load double, double* %732
%734 = tail call double @llvm.fmuladd.f64(double %733, double %733, double %730)
%735 = add nuw nsw i64 %725, 2
%736 = getelementptr inbounds double, double* %723, i64 %735
%737 = load double, double* %736
%738 = tail call double @llvm.fmuladd.f64(double %737, double %737, double %734)
%739 = add nuw nsw i64 %725, 3
%740 = getelementptr inbounds double, double* %723, i64 %739
%741 = load double, double* %740
%742 = tail call double @llvm.fmuladd.f64(double %741, double %741, double %738)
%743 = add nuw nsw i64 %725, 4
%744 = add i64 %727, 4
%745 = icmp eq i64 %744, %571
br i1 %745, label %746, label %724
746: ; preds = %724, %722
%747 = phi double [ undef, %722 ], [ %742, %724 ]
%748 = phi i64 [ 1, %722 ], [ %743, %724 ]
%749 = phi double [ 0.000000e+00, %722 ], [ %742, %724 ]
br i1 %572, label %760, label %750
750: ; preds = %746, %750
%751 = phi i64 [ %757, %750 ], [ %748, %746 ]
%752 = phi double [ %756, %750 ], [ %749, %746 ]
%753 = phi i64 [ %758, %750 ], [ 0, %746 ]
%754 = getelementptr inbounds double, double* %723, i64 %751
%755 = load double, double* %754
%756 = tail call double @llvm.fmuladd.f64(double %755, double %755, double %752)
%757 = add nuw nsw i64 %751, 1
%758 = add i64 %753, 1
%759 = icmp eq i64 %758, %569
br i1 %759, label %760, label %750
760: ; preds = %746, %750, %721
%761 = phi double [ 0.000000e+00, %721 ], [ %747, %746 ], [ %756, %750 ]
%762 = tail call double @sqrt(double %761)
%763 = fdiv double 1.000000e+00, %762
br i1 %551, label %872, label %764
764: ; preds = %760
%765 = load double*, double** @find_Emin.v2
%766 = load double*, double** @find_Emin.v1
br i1 %573, label %829, label %767
767: ; preds = %764
%768 = getelementptr double, double* %766, i64 1
%769 = getelementptr double, double* %766, i64 %552
%770 = getelementptr double, double* %765, i64 1
%771 = getelementptr double, double* %765, i64 %552
%772 = icmp ult double* %768, %771
%773 = icmp ult double* %770, %769
%774 = and i1 %772, %773
br i1 %774, label %829, label %775
775: ; preds = %767
%776 = insertelement <2 x double> poison, double %763, i64 0
%777 = shufflevector <2 x double> %776, <2 x double> poison, <2 x i32> zeroinitializer
%778 = insertelement <2 x double> poison, double %763, i64 0
%779 = shufflevector <2 x double> %778, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %577, label %812, label %780
780: ; preds = %775, %780
%781 = phi i64 [ %809, %780 ], [ 0, %775 ]
%782 = phi i64 [ %810, %780 ], [ 0, %775 ]
%783 = or i64 %781, 1
%784 = getelementptr inbounds double, double* %765, i64 %783
%785 = bitcast double* %784 to <2 x double>*
%786 = load <2 x double>, <2 x double>* %785
%787 = getelementptr inbounds double, double* %784, i64 2
%788 = bitcast double* %787 to <2 x double>*
%789 = load <2 x double>, <2 x double>* %788
%790 = fmul <2 x double> %777, %786
%791 = fmul <2 x double> %779, %789
%792 = getelementptr inbounds double, double* %766, i64 %783
%793 = bitcast double* %792 to <2 x double>*
store <2 x double> %790, <2 x double>* %793
%794 = getelementptr inbounds double, double* %792, i64 2
%795 = bitcast double* %794 to <2 x double>*
store <2 x double> %791, <2 x double>* %795
%796 = or i64 %781, 5
%797 = getelementptr inbounds double, double* %765, i64 %796
%798 = bitcast double* %797 to <2 x double>*
%799 = load <2 x double>, <2 x double>* %798
%800 = getelementptr inbounds double, double* %797, i64 2
%801 = bitcast double* %800 to <2 x double>*
%802 = load <2 x double>, <2 x double>* %801
%803 = fmul <2 x double> %777, %799
%804 = fmul <2 x double> %779, %802
%805 = getelementptr inbounds double, double* %766, i64 %796
%806 = bitcast double* %805 to <2 x double>*
store <2 x double> %803, <2 x double>* %806
%807 = getelementptr inbounds double, double* %805, i64 2
%808 = bitcast double* %807 to <2 x double>*
store <2 x double> %804, <2 x double>* %808
%809 = add nuw i64 %781, 8
%810 = add i64 %782, 2
%811 = icmp eq i64 %810, %578
br i1 %811, label %812, label %780
812: ; preds = %780, %775
%813 = phi i64 [ 0, %775 ], [ %809, %780 ]
br i1 %579, label %828, label %814
814: ; preds = %812
%815 = or i64 %813, 1
%816 = getelementptr inbounds double, double* %765, i64 %815
%817 = bitcast double* %816 to <2 x double>*
%818 = load <2 x double>, <2 x double>* %817
%819 = getelementptr inbounds double, double* %816, i64 2
%820 = bitcast double* %819 to <2 x double>*
%821 = load <2 x double>, <2 x double>* %820
%822 = fmul <2 x double> %777, %818
%823 = fmul <2 x double> %779, %821
%824 = getelementptr inbounds double, double* %766, i64 %815
%825 = bitcast double* %824 to <2 x double>*
store <2 x double> %822, <2 x double>* %825
%826 = getelementptr inbounds double, double* %824, i64 2
%827 = bitcast double* %826 to <2 x double>*
store <2 x double> %823, <2 x double>* %827
br label %828
828: ; preds = %812, %814
br i1 %580, label %872, label %829
829: ; preds = %767, %764, %828
%830 = phi i64 [ 1, %767 ], [ 1, %764 ], [ %575, %828 ]
%831 = sub nsw i64 %552, %830
%832 = xor i64 %830, -1
%833 = add nsw i64 %832, %552
%834 = and i64 %831, 3
%835 = icmp eq i64 %834, 0
br i1 %835, label %846, label %836
836: ; preds = %829, %836
%837 = phi i64 [ %843, %836 ], [ %830, %829 ]
%838 = phi i64 [ %844, %836 ], [ 0, %829 ]
%839 = getelementptr inbounds double, double* %765, i64 %837
%840 = load double, double* %839
%841 = fmul double %763, %840
%842 = getelementptr inbounds double, double* %766, i64 %837
store double %841, double* %842
%843 = add nuw nsw i64 %837, 1
%844 = add i64 %838, 1
%845 = icmp eq i64 %844, %834
br i1 %845, label %846, label %836
846: ; preds = %836, %829
%847 = phi i64 [ %830, %829 ], [ %843, %836 ]
%848 = icmp ult i64 %833, 3
br i1 %848, label %872, label %849
849: ; preds = %846, %849
%850 = phi i64 [ %870, %849 ], [ %847, %846 ]
%851 = getelementptr inbounds double, double* %765, i64 %850
%852 = load double, double* %851
%853 = fmul double %763, %852
%854 = getelementptr inbounds double, double* %766, i64 %850
store double %853, double* %854
%855 = add nuw nsw i64 %850, 1
%856 = getelementptr inbounds double, double* %765, i64 %855
%857 = load double, double* %856
%858 = fmul double %763, %857
%859 = getelementptr inbounds double, double* %766, i64 %855
store double %858, double* %859
%860 = add nuw nsw i64 %850, 2
%861 = getelementptr inbounds double, double* %765, i64 %860
%862 = load double, double* %861
%863 = fmul double %763, %862
%864 = getelementptr inbounds double, double* %766, i64 %860
store double %863, double* %864
%865 = add nuw nsw i64 %850, 3
%866 = getelementptr inbounds double, double* %765, i64 %865
%867 = load double, double* %866
%868 = fmul double %763, %867
%869 = getelementptr inbounds double, double* %766, i64 %865
store double %868, double* %869
%870 = add nuw nsw i64 %850, 4
%871 = icmp eq i64 %870, %553
br i1 %871, label %872, label %849
872: ; preds = %846, %849, %828, %760
%873 = load i1, i1* @find_Emin.po
%874 = xor i1 %873, true
%875 = load i32, i32* @find_Emin.num
%876 = icmp slt i32 %875, 100
%877 = select i1 %874, i1 %876, i1 false
br i1 %877, label %581, label %878
878: ; preds = %872
%879 = load double*, double** @find_Emin.v0
%880 = tail call i32 @free(double* %879)
%881 = load double*, double** @find_Emin.v1
%882 = tail call i32 @free(double* %881)
%883 = load double*, double** @find_Emin.v2
%884 = tail call i32 @free(double* %883)
%885 = load double*, double** @find_Emin.al
%886 = tail call i32 @free(double* %885)
%887 = load double*, double** @find_Emin.be
%888 = tail call i32 @free(double* %887)
%889 = load double, double* @find_Emin.e1
%890 = fadd double %889, 5.000000e+00
store double %890, double* @find_Emin.e1
ret double %890
}