#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);
int /*<<< orphan*/ printf(char *, int, double);
double sqrt(double);
double find_Emin(int n, double **a, double **s) {
  static int i, j, k, k1, k2, po, num;
  static double *v1, *v2;
  static double tmp, e0, e1;
  static double diff = 1.0e-10;
  static int nummax = 10000;
  v1 = (double *)malloc(sizeof(double) * (n + 3));
  v2 = (double *)malloc(sizeof(double) * (n + 3));
  tmp = 1.0 / sqrt((double)n);
  for (i = 1; i <= n; i++)
    v1[i] = tmp;
  for (i = 1; i <= n; i++) {
    tmp = 0.0;
    for (j = 1; j <= n; j++)
      tmp += s[i][j] * v1[j];
    v2[i] = tmp;
  }
  tmp = 0.0;
  for (i = 1; i <= n; i++)
    tmp += v1[i] * v2[i];
  tmp = 1.0 / sqrt(fabs(tmp));
  for (i = 1; i <= n; i++)
    v1[i] = v1[i] * tmp;
  e0 = 1.0e+100;
  e1 = 0.0;
  po = 0;
  num = 0;
  do {
    num++;
    for (i = 1; i <= n; i++) {
      tmp = 0.0;
      for (j = 1; j <= n; j++)
        tmp += (a[i][j] - e1 * s[i][j]) * v1[j];
      v2[i] = tmp;
    }
    for (i = 1; i <= n; i++)
      v1[i] -= 0.05 * v2[i];
    for (i = 1; i <= n; i++) {
      tmp = 0.0;
      for (j = 1; j <= n; j++)
        tmp += s[i][j] * v1[j];
      v2[i] = tmp;
    }
    tmp = 0.0;
    for (i = 1; i <= n; i++)
      tmp += v1[i] * v2[i];
    tmp = 1.0 / sqrt(fabs(tmp));
    for (i = 1; i <= n; i++)
      v1[i] = v1[i] * tmp;
    for (i = 1; i <= n; i++) {
      tmp = 0.0;
      for (j = 1; j <= n; j++)
        tmp += a[i][j] * v1[j];
      v2[i] = tmp;
    }
    tmp = 0.0;
    for (i = 1; i <= n; i++)
      tmp += v1[i] * v2[i];
    e1 = tmp;
    if (fabs(e1 - e0) < diff)
      po = 1;
    else
      e0 = e1;
    printf("num=%5d  e1=%18.15f\n", num, e1);
  } while (po == 0 && num < nummax);
  free(v1);
  free(v2);
  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    %rdx,-0x18(%rbp)
mov    -0x4(%rbp),%eax
add    $0x3,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,0x2f0b(%rip)
mov    -0x4(%rbp),%eax
add    $0x3,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,0x2ef9(%rip)
cvtsi2sdl -0x4(%rbp),%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xe64(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2ee0(%rip)
movl   $0x1,0x2ea6(%rip)
mov    0x2ea0(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     11f0 <find_Emin+0xb0>
movsd  0x2ebf(%rip),%xmm0
mov    0x2ea8(%rip),%rax
movslq 0x2e81(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2e76(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2e6d(%rip)
jmp    11b2 <find_Emin+0x72>
movl   $0x1,0x2e5e(%rip)
mov    0x2e58(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     12b6 <find_Emin+0x176>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2e74(%rip)
movl   $0x1,0x2e3e(%rip)
mov    0x2e38(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1287 <find_Emin+0x147>
mov    -0x18(%rbp),%rax
movslq 0x2e20(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x2e19(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2e29(%rip),%rax
movslq 0x2e06(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2e25(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2e15(%rip)
mov    0x2de3(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2dda(%rip)
jmp    121e <find_Emin+0xde>
movsd  0x2df9(%rip),%xmm0
mov    0x2dea(%rip),%rax
movslq 0x2dbb(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2db0(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2da7(%rip)
jmp    11fa <find_Emin+0xba>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2dc7(%rip)
movl   $0x1,0x2d8d(%rip)
mov    0x2d87(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     132c <find_Emin+0x1ec>
mov    0x2d97(%rip),%rax
movslq 0x2d70(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2d8c(%rip),%rax
movslq 0x2d5d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2d80(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2d70(%rip)
mov    0x2d3a(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2d31(%rip)
jmp    12cb <find_Emin+0x18b>
movsd  0x2d54(%rip),%xmm0
movaps 0xce5(%rip),%xmm1
pand   %xmm1,%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xcb1(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2d2d(%rip)
movl   $0x1,0x2cf3(%rip)
mov    0x2ced(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     13b6 <find_Emin+0x276>
mov    0x2cfd(%rip),%rax
movslq 0x2cd6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x2cf9(%rip),%xmm0
mov    0x2ce2(%rip),%rax
movslq 0x2cbb(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2cb0(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2ca7(%rip)
jmp    1365 <find_Emin+0x225>
movsd  0xc4a(%rip),%xmm0
movsd  %xmm0,0x2cca(%rip)
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2cc7(%rip)
movl   $0x0,0x2c91(%rip)
movl   $0x0,0x2c8b(%rip)
mov    0x2c85(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2c7c(%rip)
movl   $0x1,0x2c5a(%rip)
mov    0x2c54(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     14fc <find_Emin+0x3bc>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2c70(%rip)
movl   $0x1,0x2c3a(%rip)
mov    0x2c34(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     14cd <find_Emin+0x38d>
mov    -0x10(%rbp),%rax
movslq 0x2c1c(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x2c15(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x2c44(%rip),%xmm0
mov    -0x18(%rbp),%rax
movslq 0x2bf9(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x2bf2(%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    0x2be3(%rip),%rax
movslq 0x2bc0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2bdf(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2bcf(%rip)
mov    0x2b9d(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2b94(%rip)
jmp    1422 <find_Emin+0x2e2>
movsd  0x2bb3(%rip),%xmm0
mov    0x2ba4(%rip),%rax
movslq 0x2b75(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2b6a(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2b61(%rip)
jmp    13fe <find_Emin+0x2be>
movl   $0x1,0x2b52(%rip)
mov    0x2b4c(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1564 <find_Emin+0x424>
mov    0x2b64(%rip),%rax
movslq 0x2b35(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2b49(%rip),%rax
movslq 0x2b22(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xacd(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2b02(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2af9(%rip)
jmp    1506 <find_Emin+0x3c6>
movl   $0x1,0x2aea(%rip)
mov    0x2ae4(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     162a <find_Emin+0x4ea>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2b00(%rip)
movl   $0x1,0x2aca(%rip)
mov    0x2ac4(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     15fb <find_Emin+0x4bb>
mov    -0x18(%rbp),%rax
movslq 0x2aac(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x2aa5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2ab5(%rip),%rax
movslq 0x2a92(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2ab1(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2aa1(%rip)
mov    0x2a6f(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2a66(%rip)
jmp    1592 <find_Emin+0x452>
movsd  0x2a85(%rip),%xmm0
mov    0x2a76(%rip),%rax
movslq 0x2a47(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2a3c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2a33(%rip)
jmp    156e <find_Emin+0x42e>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2a53(%rip)
movl   $0x1,0x2a19(%rip)
mov    0x2a13(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     16a0 <find_Emin+0x560>
mov    0x2a23(%rip),%rax
movslq 0x29fc(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2a18(%rip),%rax
movslq 0x29e9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2a0c(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x29fc(%rip)
mov    0x29c6(%rip),%eax
add    $0x1,%eax
mov    %eax,0x29bd(%rip)
jmp    163f <find_Emin+0x4ff>
movsd  0x29e0(%rip),%xmm0
movaps 0x971(%rip),%xmm1
pand   %xmm1,%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x93d(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x29b9(%rip)
movl   $0x1,0x297f(%rip)
mov    0x2979(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     172a <find_Emin+0x5ea>
mov    0x2989(%rip),%rax
movslq 0x2962(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x2985(%rip),%xmm0
mov    0x296e(%rip),%rax
movslq 0x2947(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x293c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2933(%rip)
jmp    16d9 <find_Emin+0x599>
movl   $0x1,0x2924(%rip)
mov    0x291e(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     17f0 <find_Emin+0x6b0>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x293a(%rip)
movl   $0x1,0x2904(%rip)
mov    0x28fe(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     17c1 <find_Emin+0x681>
mov    -0x10(%rbp),%rax
movslq 0x28e6(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x28df(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28ef(%rip),%rax
movslq 0x28cc(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x28eb(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28db(%rip)
mov    0x28a9(%rip),%eax
add    $0x1,%eax
mov    %eax,0x28a0(%rip)
jmp    1758 <find_Emin+0x618>
movsd  0x28bf(%rip),%xmm0
mov    0x28b0(%rip),%rax
movslq 0x2881(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2876(%rip),%eax
add    $0x1,%eax
mov    %eax,0x286d(%rip)
jmp    1734 <find_Emin+0x5f4>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x288d(%rip)
movl   $0x1,0x2853(%rip)
mov    0x284d(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1866 <find_Emin+0x726>
mov    0x285d(%rip),%rax
movslq 0x2836(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2852(%rip),%rax
movslq 0x2823(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2846(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2836(%rip)
mov    0x2800(%rip),%eax
add    $0x1,%eax
mov    %eax,0x27f7(%rip)
jmp    1805 <find_Emin+0x6c5>
movsd  0x281a(%rip),%xmm0
movsd  %xmm0,0x2822(%rip)
movsd  0x281a(%rip),%xmm1
subsd  0x280a(%rip),%xmm1
movaps 0x793(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x27a7(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    18b2 <find_Emin+0x772>
movl   $0x1,0x27bf(%rip)
jmp    18c2 <find_Emin+0x782>
movsd  0x27de(%rip),%xmm0
movsd  %xmm0,0x27ce(%rip)
mov    0x27a8(%rip),%esi
movsd  0x27c8(%rip),%xmm0
lea    0x759(%rip),%rdi
call   1040 <printf@plt>
xor    %eax,%eax
cmpl   $0x0,0x2787(%rip)
mov    %al,-0x19(%rbp)
jne    1900 <find_Emin+0x7c0>
mov    0x277c(%rip),%eax
cmp    0x274e(%rip),%eax
setl   %al
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%al
test   $0x1,%al
jne    13e5 <find_Emin+0x2a5>
mov    0x2766(%rip),%rdi
call   1030 <free@plt>
mov    0x2762(%rip),%rdi
call   1030 <free@plt>
movsd  0x276d(%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    $0x48,%rsp
mov    %rdx,0x28(%rsp)
mov    %rsi,0x38(%rsp)
mov    %edi,%ebx
lea    0x18(,%rbx,8),%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x2ee1(%rip)
mov    %ebp,%edi
call   1050 <malloc@plt>
cvtsi2sd %ebx,%xmm0
mov    %rax,0x2ed7(%rip)
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm0
mov    %rbx,(%rsp)
jb     1195 <find_Emin+0x55>
sqrtsd %xmm0,%xmm0
jmp    11a2 <find_Emin+0x62>
call   1060 <sqrt@plt>
xorpd  %xmm3,%xmm3
mov    (%rsp),%rbx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x8(%rsp)
movsd  0xe47(%rip),%xmm1
mov    %ebx,%r14d
test   %ebx,%ebx
mov    0x28(%rsp),%r11
jle    1477 <find_Emin+0x337>
divsd  %xmm0,%xmm1
mov    0x2e7c(%rip),%rcx
lea    0x1(%r14),%r10
mov    $0x1,%edx
cmp    $0x4,%ebx
jb     12a0 <find_Emin+0x160>
mov    %r14d,%edx
and    $0xfffffffc,%edx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rdx),%rax
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0xc,%rax
jae    1212 <find_Emin+0xd2>
xor    %edi,%edi
jmp    126a <find_Emin+0x12a>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
add    $0xfffffffffffffffe,%rax
and    %rax,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movupd %xmm0,0x8(%rcx,%rdi,8)
movupd %xmm0,0x18(%rcx,%rdi,8)
movupd %xmm0,0x28(%rcx,%rdi,8)
movupd %xmm0,0x38(%rcx,%rdi,8)
movupd %xmm0,0x48(%rcx,%rdi,8)
movupd %xmm0,0x58(%rcx,%rdi,8)
movupd %xmm0,0x68(%rcx,%rdi,8)
movupd %xmm0,0x78(%rcx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1230 <find_Emin+0xf0>
test   %rbp,%rbp
je     1291 <find_Emin+0x151>
nop
lea    0x0(,%rdi,8),%rax
or     $0x8,%rax
movupd %xmm0,(%rcx,%rax,1)
movupd %xmm0,0x10(%rcx,%rax,1)
add    $0x4,%rdi
add    $0xffffffffffffffff,%rbp
jne    1270 <find_Emin+0x130>
cmp    %rdx,%r14
je     12ae <find_Emin+0x16e>
or     $0x1,%rdx
nopw   0x0(%rax,%rax,1)
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r10
jne    12a0 <find_Emin+0x160>
cmpl   $0x0,(%rsp)
movsd  0xd46(%rip),%xmm1
jle    1477 <find_Emin+0x337>
mov    0x2d89(%rip),%rcx
mov    0x2d8a(%rip),%r8
mov    (%rsp),%rax
lea    0x1(%rax),%r9d
add    $0xfffffffffffffffe,%r10
mov    %r14d,%edi
and    $0x3,%edi
mov    %r14d,%ebx
and    $0xfffffffc,%ebx
mov    $0x1,%ebp
jmp    1303 <find_Emin+0x1c3>
nopl   (%rax)
movsd  %xmm0,(%r8,%rbp,8)
add    $0x1,%rbp
cmp    %r9,%rbp
je     139c <find_Emin+0x25c>
mov    (%r11,%rbp,8),%rdx
xorpd  %xmm0,%xmm0
mov    $0x1,%esi
cmp    $0x3,%r10
jb     136d <find_Emin+0x22d>
xorpd  %xmm0,%xmm0
xor    %esi,%esi
nopl   0x0(%rax)
movsd  0x8(%rdx,%rsi,8),%xmm1
movsd  0x10(%rdx,%rsi,8),%xmm2
mulsd  0x8(%rcx,%rsi,8),%xmm1
mulsd  0x10(%rcx,%rsi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%rdx,%rsi,8),%xmm3
mulsd  0x18(%rcx,%rsi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x20(%rdx,%rsi,8),%xmm0
mulsd  0x20(%rcx,%rsi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rsi
cmp    %rsi,%rbx
jne    1320 <find_Emin+0x1e0>
add    $0x1,%rsi
test   %rdi,%rdi
je     12f0 <find_Emin+0x1b0>
lea    (%rcx,%rsi,8),%rax
lea    (%rdx,%rsi,8),%rdx
xor    %esi,%esi
movsd  (%rdx,%rsi,8),%xmm1
mulsd  (%rax,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    1380 <find_Emin+0x240>
jmp    12f0 <find_Emin+0x1b0>
cmpl   $0x0,(%rsp)
jle    13c7 <find_Emin+0x287>
mov    0x2ca7(%rip),%rdx
mov    0x2ca8(%rip),%rsi
mov    %r14d,%ecx
and    $0x3,%ecx
cmp    $0x3,%r10
jae    13d8 <find_Emin+0x298>
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
jmp    143d <find_Emin+0x2fd>
xorpd  %xmm3,%xmm3
movsd  0xc2d(%rip),%xmm1
jmp    1477 <find_Emin+0x337>
mov    %r14d,%edi
and    $0xfffffffc,%edi
xorpd  %xmm3,%xmm3
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  0x10(%rdx,%rax,8),%xmm1
mulsd  0x8(%rsi,%rax,8),%xmm0
mulsd  0x10(%rsi,%rax,8),%xmm1
addsd  %xmm3,%xmm0
movsd  0x18(%rdx,%rax,8),%xmm2
mulsd  0x18(%rsi,%rax,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x20(%rdx,%rax,8),%xmm3
mulsd  0x20(%rsi,%rax,8),%xmm3
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm3
add    $0x4,%rax
cmp    %rax,%rdi
jne    13f0 <find_Emin+0x2b0>
add    $0x1,%rax
test   %rcx,%rcx
movsd  0xbb8(%rip),%xmm1
je     1477 <find_Emin+0x337>
lea    (%rsi,%rax,8),%rsi
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm0
mulsd  (%rsi,%rdx,8),%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1460 <find_Emin+0x320>
andpd  0xba1(%rip),%xmm3
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm3
jb     1492 <find_Emin+0x352>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    14a3 <find_Emin+0x363>
movapd %xmm3,%xmm0
call   1060 <sqrt@plt>
movsd  0xb5d(%rip),%xmm1
mov    (%rsp),%r10
test   %r10d,%r10d
jle    15a9 <find_Emin+0x469>
divsd  %xmm0,%xmm1
mov    0x2b95(%rip),%rcx
lea    0x1(%r10),%eax
mov    $0x1,%edx
cmp    $0x4,%r10d
jb     1585 <find_Emin+0x445>
mov    %r14d,%edx
and    $0xfffffffc,%edx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1dec <find_Emin+0xcac>
mov    %rbp,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
mov    $0x1,%esi
nopl   0x0(%rax)
movupd (%rcx,%rsi,8),%xmm2
movupd 0x10(%rcx,%rsi,8),%xmm3
movupd 0x20(%rcx,%rsi,8),%xmm4
movupd 0x30(%rcx,%rsi,8),%xmm5
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rcx,%rsi,8)
movupd %xmm3,0x10(%rcx,%rsi,8)
mulpd  %xmm0,%xmm4
mulpd  %xmm0,%xmm5
movupd %xmm4,0x20(%rcx,%rsi,8)
movupd %xmm5,0x30(%rcx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1510 <find_Emin+0x3d0>
test   $0x1,%bpl
je     157c <find_Emin+0x43c>
movupd (%rcx,%rsi,8),%xmm2
movupd 0x10(%rcx,%rsi,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%rcx,%rsi,8)
movupd %xmm3,0x10(%rcx,%rsi,8)
cmp    %rdx,%r14
je     15ad <find_Emin+0x46d>
or     $0x1,%rdx
add    $0x1,%r14
nopl   0x0(%rax)
movsd  (%rcx,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r14
jne    1590 <find_Emin+0x450>
jmp    15ad <find_Emin+0x46d>
lea    0x1(%r10),%eax
movabs $0x54b249ad2594c37d,%rcx
49 b2 54
mov    %rcx,0x2aa2(%rip)
movq   $0x0,0x2a9f(%rip)
movb   $0x0,0x2a78(%rip)
mov    %eax,%r12d
lea    -0x1(%r12),%r11
lea    -0x2(%r12),%rbp
lea    -0x5(%r12),%rax
mov    %rax,0x20(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %r11,%r13
and    $0xfffffffffffffffc,%r13
lea    0x1(%r13),%rcx
mov    %rcx,0x10(%rsp)
mov    %rax,%rcx
mov    %rax,0x18(%rsp)
and    %rax,0x8(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0x40(%rsp)
mov    %r11d,%r15d
and    $0x3,%r15d
mov    %r11,%r14
and    $0xfffffffffffffffe,%r14
neg    %r14
xor    %eax,%eax
movsd  0x9d6(%rip),%xmm6
movapd 0xa06(%rip),%xmm7
mov    %r11,0x30(%rsp)
nop
add    $0x1,%eax
mov    %eax,0x2a03(%rip)
xorpd  %xmm0,%xmm0
test   %r10d,%r10d
mov    0x28(%rsp),%r8
mov    0x38(%rsp),%r9
jle    1a50 <find_Emin+0x910>
movsd  0x2a00(%rip),%xmm0
xorpd  0x9c0(%rip),%xmm0
mov    0x29d9(%rip),%rax
mov    $0x1,%ecx
mov    0x29d5(%rip),%rdx
jmp    16a5 <find_Emin+0x565>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %r12,%rcx
mov    %r10,%rbp
je     1730 <find_Emin+0x5f0>
mov    (%r9,%rcx,8),%rsi
mov    (%r8,%rcx,8),%rdi
mov    %rbp,%r10
xorpd  %xmm1,%xmm1
mov    $0x1,%ebx
test   %rbp,%rbp
je     1703 <find_Emin+0x5c3>
xchg   %ax,%ax
movsd  (%rdi,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rsi,%rbx,8),%xmm2
mulsd  (%rax,%rbx,8),%xmm2
addsd  %xmm1,%xmm2
movsd  0x8(%rdi,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rsi,%rbx,8),%xmm1
mulsd  0x8(%rax,%rbx,8),%xmm1
addsd  %xmm2,%xmm1
lea    (%r14,%rbx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rbx
cmp    $0x1,%rbp
jne    16c0 <find_Emin+0x580>
test   $0x1,%r11b
je     1690 <find_Emin+0x550>
movsd  (%rdi,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rsi,%rbx,8),%xmm2
mulsd  (%rax,%rbx,8),%xmm2
addsd  %xmm2,%xmm1
jmp    1690 <find_Emin+0x550>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm0,%xmm0
mov    (%rsp),%r10
test   %r10d,%r10d
jle    1a50 <find_Emin+0x910>
mov    0x2910(%rip),%rax
mov    $0x1,%edx
mov    0x28fc(%rip),%rcx
cmp    $0x4,%r11
jb     1860 <find_Emin+0x720>
lea    0x8(%rcx),%rsi
lea    (%rax,%r12,8),%rdi
cmp    %rdi,%rsi
jae    177c <find_Emin+0x63c>
lea    (%rcx,%r12,8),%rsi
lea    0x8(%rax),%rdi
cmp    %rsi,%rdi
jb     1860 <find_Emin+0x720>
cmpq   $0x4,0x20(%rsp)
jae    178b <find_Emin+0x64b>
xor    %edx,%edx
jmp    1812 <find_Emin+0x6d2>
mov    0x8(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd 0x8(%rax,%rdx,8),%xmm1
movupd 0x18(%rax,%rdx,8),%xmm2
mulpd  %xmm7,%xmm1
movupd 0x8(%rcx,%rdx,8),%xmm3
addpd  %xmm1,%xmm3
movupd 0x18(%rcx,%rdx,8),%xmm1
movupd 0x28(%rcx,%rdx,8),%xmm4
movupd 0x38(%rcx,%rdx,8),%xmm5
mulpd  %xmm7,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm3,0x8(%rcx,%rdx,8)
movupd %xmm2,0x18(%rcx,%rdx,8)
movupd 0x28(%rax,%rdx,8),%xmm1
movupd 0x38(%rax,%rdx,8),%xmm2
mulpd  %xmm7,%xmm1
addpd  %xmm4,%xmm1
mulpd  %xmm7,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm1,0x28(%rcx,%rdx,8)
movupd %xmm2,0x38(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    17a0 <find_Emin+0x660>
testb  $0x1,0x18(%rsp)
je     1852 <find_Emin+0x712>
shl    $0x3,%rdx
or     $0x8,%rdx
movupd (%rax,%rdx,1),%xmm1
movupd 0x10(%rax,%rdx,1),%xmm2
movupd (%rcx,%rdx,1),%xmm3
movupd 0x10(%rcx,%rdx,1),%xmm4
mulpd  %xmm7,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm7,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%rcx,%rdx,1)
movupd %xmm2,0x10(%rcx,%rdx,1)
mov    0x10(%rsp),%rdx
cmp    %r13,%r11
je     18c2 <find_Emin+0x782>
nopl   0x0(%rax)
mov    %rdx,%rsi
test   $0x1,%r12b
jne    1880 <find_Emin+0x740>
movsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rcx,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
lea    0x1(%rdx),%rsi
not    %rdx
cmp    0x40(%rsp),%rdx
je     18c2 <find_Emin+0x782>
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rcx,%rsi,8),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
movsd  0x8(%rax,%rsi,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  0x8(%rcx,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r12
jne    1890 <find_Emin+0x750>
test   %r10d,%r10d
jle    1a50 <find_Emin+0x910>
mov    0x277e(%rip),%rax
mov    $0x1,%ecx
mov    0x277a(%rip),%rdx
jmp    18f2 <find_Emin+0x7b2>
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %r12,%rcx
je     1990 <find_Emin+0x850>
mov    (%r8,%rcx,8),%rsi
xorpd  %xmm0,%xmm0
mov    $0x1,%edi
cmp    $0x3,%rbp
jb     195d <find_Emin+0x81d>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rsi,%rdi,8),%xmm1
movsd  0x10(%rsi,%rdi,8),%xmm2
mulsd  0x8(%rax,%rdi,8),%xmm1
mulsd  0x10(%rax,%rdi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%rsi,%rdi,8),%xmm3
mulsd  0x18(%rax,%rdi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x20(%rsi,%rdi,8),%xmm0
mulsd  0x20(%rax,%rdi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdi
cmp    %rdi,%r13
jne    1910 <find_Emin+0x7d0>
add    $0x1,%rdi
test   %r15,%r15
je     18e0 <find_Emin+0x7a0>
lea    (%rax,%rdi,8),%rbx
lea    (%rsi,%rdi,8),%rsi
xor    %edi,%edi
movsd  (%rsi,%rdi,8),%xmm1
mulsd  (%rbx,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%r15
jne    1970 <find_Emin+0x830>
jmp    18e0 <find_Emin+0x7a0>
nopl   0x0(%rax)
test   %r10d,%r10d
jle    19bd <find_Emin+0x87d>
mov    0x26b4(%rip),%rax
mov    0x26b5(%rip),%rcx
xorpd  %xmm0,%xmm0
cmp    $0x3,%rbp
jae    19c6 <find_Emin+0x886>
mov    $0x1,%edx
test   $0x3,%r11b
jne    1a23 <find_Emin+0x8e3>
jmp    1a50 <find_Emin+0x910>
xorpd  %xmm0,%xmm0
jmp    1a50 <find_Emin+0x910>
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,%r13
jne    19d0 <find_Emin+0x890>
add    $0x1,%rdx
test   $0x3,%r11b
je     1a50 <find_Emin+0x910>
lea    (%rcx,%rdx,8),%rcx
lea    (%rax,%rdx,8),%rax
xor    %edx,%edx
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm1
mulsd  (%rcx,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%r15
jne    1a30 <find_Emin+0x8f0>
nopw   0x0(%rax,%rax,1)
andpd  0x5c8(%rip),%xmm0
ucomisd 0x5b8(%rip),%xmm0
jb     1a70 <find_Emin+0x930>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    1a87 <find_Emin+0x947>
nopl   0x0(%rax,%rax,1)
call   1060 <sqrt@plt>
mov    0x30(%rsp),%r11
mov    (%rsp),%r10
mov    0x38(%rsp),%r9
movapd %xmm0,%xmm1
xorpd  %xmm0,%xmm0
test   %r10d,%r10d
jle    1d30 <find_Emin+0xbf0>
movsd  0x564(%rip),%xmm2
divsd  %xmm1,%xmm2
mov    $0x1,%ecx
mov    0x25a4(%rip),%rax
cmp    $0x4,%r11
jb     1b70 <find_Emin+0xa30>
movapd %xmm2,%xmm1
unpcklpd %xmm2,%xmm1
cmpq   $0x4,0x20(%rsp)
jae    1aca <find_Emin+0x98a>
xor    %ecx,%ecx
jmp    1b2a <find_Emin+0x9ea>
mov    0x8(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x8(%rax,%rcx,8),%xmm3
movupd 0x18(%rax,%rcx,8),%xmm4
movupd 0x28(%rax,%rcx,8),%xmm5
movupd 0x38(%rax,%rcx,8),%xmm6
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm4
movupd %xmm3,0x8(%rax,%rcx,8)
movupd %xmm4,0x18(%rax,%rcx,8)
mulpd  %xmm1,%xmm5
mulpd  %xmm1,%xmm6
movupd %xmm5,0x28(%rax,%rcx,8)
movupd %xmm6,0x38(%rax,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1ae0 <find_Emin+0x9a0>
testb  $0x1,0x18(%rsp)
je     1b57 <find_Emin+0xa17>
shl    $0x3,%rcx
or     $0x8,%rcx
movupd (%rax,%rcx,1),%xmm3
movupd 0x10(%rax,%rcx,1),%xmm4
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm4
movupd %xmm3,(%rax,%rcx,1)
movupd %xmm4,0x10(%rax,%rcx,1)
mov    0x10(%rsp),%rcx
cmp    %r13,%r11
je     1b87 <find_Emin+0xa47>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1b70 <find_Emin+0xa30>
test   %r10d,%r10d
jle    1d30 <find_Emin+0xbf0>
mov    0x24b9(%rip),%rax
mov    $0x1,%ecx
mov    0x24b5(%rip),%rdx
jmp    1bc2 <find_Emin+0xa82>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %r12,%rcx
je     1c70 <find_Emin+0xb30>
mov    (%r9,%rcx,8),%rsi
xorpd  %xmm0,%xmm0
mov    $0x1,%edi
cmp    $0x3,%rbp
jb     1c2d <find_Emin+0xaed>
xorpd  %xmm0,%xmm0
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rsi,%rdi,8),%xmm1
movsd  0x10(%rsi,%rdi,8),%xmm2
mulsd  0x8(%rax,%rdi,8),%xmm1
mulsd  0x10(%rax,%rdi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x18(%rsi,%rdi,8),%xmm3
mulsd  0x18(%rax,%rdi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x20(%rsi,%rdi,8),%xmm0
mulsd  0x20(%rax,%rdi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdi
cmp    %rdi,%r13
jne    1be0 <find_Emin+0xaa0>
add    $0x1,%rdi
test   $0x3,%r11b
je     1bb0 <find_Emin+0xa70>
lea    (%rax,%rdi,8),%rbx
lea    (%rsi,%rdi,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rdi,8),%xmm1
mulsd  (%rbx,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%r15
jne    1c50 <find_Emin+0xb10>
jmp    1bb0 <find_Emin+0xa70>
nopl   0x0(%rax)
test   %r10d,%r10d
jle    1c9d <find_Emin+0xb5d>
mov    0x23d4(%rip),%rax
mov    0x23d5(%rip),%rcx
xorpd  %xmm0,%xmm0
cmp    $0x3,%rbp
jae    1ca6 <find_Emin+0xb66>
mov    $0x1,%edx
test   $0x3,%r11b
jne    1d03 <find_Emin+0xbc3>
jmp    1d30 <find_Emin+0xbf0>
xorpd  %xmm0,%xmm0
jmp    1d30 <find_Emin+0xbf0>
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,%r13
jne    1cb0 <find_Emin+0xb70>
add    $0x1,%rdx
test   $0x3,%r11b
je     1d30 <find_Emin+0xbf0>
lea    (%rcx,%rdx,8),%rcx
lea    (%rax,%rdx,8),%rax
xor    %edx,%edx
nopl   (%rax)
movsd  (%rax,%rdx,8),%xmm1
mulsd  (%rcx,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%r15
jne    1d10 <find_Emin+0xbd0>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
subsd  0x2324(%rip),%xmm1
movsd  %xmm0,0x2324(%rip)
andpd  0x2d4(%rip),%xmm1
movsd  0x2bc(%rip),%xmm2
ucomisd %xmm1,%xmm2
jbe    1d70 <find_Emin+0xc30>
movb   $0x1,0x22e7(%rip)
jmp    1d78 <find_Emin+0xc38>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm0,0x22e8(%rip)
mov    0x22ce(%rip),%esi
lea    0x2cb(%rip),%rdi
call   1040 <printf@plt>
cmpb   $0x1,0x22b7(%rip)
mov    (%rsp),%r10
mov    0x30(%rsp),%r11
movsd  0x266(%rip),%xmm6
movapd 0x296(%rip),%xmm7
je     1dbd <find_Emin+0xc7d>
mov    0x229a(%rip),%eax
cmp    $0x2710,%eax
jl     1640 <find_Emin+0x500>
mov    0x228c(%rip),%rdi
call   1030 <free@plt>
mov    0x2288(%rip),%rdi
call   1030 <free@plt>
movsd  0x228b(%rip),%xmm0
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%esi
test   $0x1,%bpl
jne    155e <find_Emin+0x41e>
jmp    157c <find_Emin+0x43c>

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

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