#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) {
  static int i, j, po, num;
  static double *v1, *v2, tmp, e0, e1;
  static double diff = 1.0e-13;
  static double shiftE = 35.0;
  static int nummax = 31000;
  v1 = (double *)malloc(sizeof(double) * (n + 1));
  v2 = (double *)malloc(sizeof(double) * (n + 1));
  for (i = 1; i <= n; i++)
    a[i][i] -= shiftE;
  tmp = 1.0 / sqrt((double)n);
  for (i = 1; i <= n; i++)
    v1[i] = tmp;
  e0 = 1.0e+100;
  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] * v1[j];
      }
      v2[i] = tmp;
    }
    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];
    }
    printf("num=%6d e1=%18.15f\n", num, e1);
  } while (po == 0 && num < nummax);
  free(v1);
  free(v2);
  for (i = 1; i <= n; i++)
    a[i][i] += shiftE;
  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   1050 <malloc@plt>
mov    %rax,0x2f07(%rip)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,0x2ef5(%rip)
movl   $0x1,0x2ed3(%rip)
mov    0x2ecd(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     11dc <find_Emin+0x9c>
movsd  0x2ea4(%rip),%xmm1
mov    -0x10(%rbp),%rax
movslq 0x2eb1(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x2ea6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2e92(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2e89(%rip)
jmp    118d <find_Emin+0x4d>
cvtsi2sdl -0x4(%rbp),%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xe0f(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2e83(%rip)
movl   $0x1,0x2e59(%rip)
mov    0x2e53(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1245 <find_Emin+0x105>
movsd  0x2e62(%rip),%xmm0
mov    0x2e4b(%rip),%rax
movslq 0x2e34(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2e29(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2e20(%rip)
jmp    1207 <find_Emin+0xc7>
movsd  0xdbb(%rip),%xmm0
movsd  %xmm0,0x2e33(%rip)
movl   $0x0,0x2e09(%rip)
movl   $0x0,0x2e03(%rip)
mov    0x2dfd(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2df4(%rip)
movl   $0x1,0x2dde(%rip)
mov    0x2dd8(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     133e <find_Emin+0x1fe>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2de4(%rip)
movl   $0x1,0x2dbe(%rip)
mov    0x2db8(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     130f <find_Emin+0x1cf>
mov    -0x10(%rbp),%rax
movslq 0x2da0(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x2d99(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2d99(%rip),%rax
movslq 0x2d86(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2d95(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2d85(%rip)
mov    0x2d63(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2d5a(%rip)
jmp    12a6 <find_Emin+0x166>
movsd  0x2d69(%rip),%xmm0
mov    0x2d5a(%rip),%rax
movslq 0x2d3b(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2d30(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2d27(%rip)
jmp    1282 <find_Emin+0x142>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2d47(%rip)
movl   $0x1,0x2d0d(%rip)
mov    0x2d07(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     13b4 <find_Emin+0x274>
mov    0x2d07(%rip),%rax
movslq 0x2cf0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2cfc(%rip),%rax
movslq 0x2cdd(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2d00(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2cf0(%rip)
mov    0x2cba(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2cb1(%rip)
jmp    1353 <find_Emin+0x213>
movsd  0x2cd4(%rip),%xmm1
subsd  0x2cc4(%rip),%xmm1
movaps 0xc45(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x2c69(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13f0 <find_Emin+0x2b0>
movl   $0x1,0x2c7d(%rip)
jmp    1400 <find_Emin+0x2c0>
movsd  0x2c98(%rip),%xmm0
movsd  %xmm0,0x2c88(%rip)
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2c75(%rip)
movl   $0x1,0x2c4b(%rip)
mov    0x2c45(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     1476 <find_Emin+0x336>
mov    0x2c4d(%rip),%rax
movslq 0x2c2e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2c3a(%rip),%rax
movslq 0x2c1b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2c2e(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2c1e(%rip)
mov    0x2bf8(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2bef(%rip)
jmp    1415 <find_Emin+0x2d5>
movsd  0x2c02(%rip),%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xb72(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2be6(%rip)
movl   $0x1,0x2bbc(%rip)
mov    0x2bb6(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     14f5 <find_Emin+0x3b5>
movsd  0x2bc5(%rip),%xmm0
mov    0x2bb6(%rip),%rax
movslq 0x2b97(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x2b9b(%rip),%rax
movslq 0x2b84(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2b79(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2b70(%rip)
jmp    14a4 <find_Emin+0x364>
mov    0x2b71(%rip),%esi
movsd  0x2b8d(%rip),%xmm0
lea    0xb16(%rip),%rdi
call   1040 <printf@plt>
xor    %eax,%eax
cmpl   $0x0,0x2b50(%rip)
mov    %al,-0x11(%rbp)
jne    1533 <find_Emin+0x3f3>
mov    0x2b45(%rip),%eax
cmp    0x2b23(%rip),%eax
setl   %al
mov    %al,-0x11(%rbp)
mov    -0x11(%rbp),%al
test   $0x1,%al
jne    1269 <find_Emin+0x129>
mov    0x2b2b(%rip),%rdi
call   1030 <free@plt>
mov    0x2b27(%rip),%rdi
call   1030 <free@plt>
movl   $0x1,0x2b00(%rip)
mov    0x2afa(%rip),%eax
cmp    -0x4(%rbp),%eax
jg     15ab <find_Emin+0x46b>
movsd  0x2ad1(%rip),%xmm0
mov    -0x10(%rbp),%rax
movslq 0x2ade(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x2ad3(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2ac3(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2aba(%rip)
jmp    1560 <find_Emin+0x420>
movsd  0x2a95(%rip),%xmm0
addsd  0x2ad5(%rip),%xmm0
movsd  %xmm0,0x2acd(%rip)
movsd  0x2ac5(%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    $0x38,%rsp
mov    %rsi,%r14
mov    %edi,%ebx
lea    0x8(,%rbx,8),%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x2ee8(%rip)
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x2ee2(%rip)
mov    %ebx,%ebp
test   %ebx,%ebx
jle    123c <find_Emin+0xfc>
lea    -0x1(%rbp),%rdx
mov    %ebp,%eax
and    $0x3,%eax
mov    $0x1,%ecx
cmp    $0x3,%rdx
jb     1211 <find_Emin+0xd1>
mov    %ebp,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
movsd  0xe5d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x8(%r14,%rcx,8),%rsi
movsd  0x8(%rsi,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsi,%rcx,8)
mov    0x10(%r14,%rcx,8),%rsi
movsd  0x10(%rsi,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsi,%rcx,8)
mov    0x18(%r14,%rcx,8),%rsi
movsd  0x18(%rsi,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsi,%rcx,8)
mov    0x20(%r14,%rcx,8),%rsi
movsd  0x20(%rsi,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    11b0 <find_Emin+0x70>
add    $0x1,%rcx
test   %rax,%rax
je     123c <find_Emin+0xfc>
movsd  0xde2(%rip),%xmm0
xchg   %ax,%ax
mov    (%r14,%rcx,8),%rdx
movsd  (%rdx,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1220 <find_Emin+0xe0>
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %rbx,0x8(%rsp)
jb     1258 <find_Emin+0x118>
sqrtsd %xmm0,%xmm0
jmp    1262 <find_Emin+0x122>
call   1060 <sqrt@plt>
mov    0x8(%rsp),%rbx
movabs $0x7ffffffffffffffc,%r9
ff ff 7f
movsd  0xd94(%rip),%xmm1
test   %ebx,%ebx
jle    12c0 <find_Emin+0x180>
divsd  %xmm0,%xmm1
mov    0x2dcd(%rip),%rcx
lea    0x1(%rbx),%r8d
mov    $0x1,%edx
cmp    $0x4,%ebx
jb     133a <find_Emin+0x1fa>
mov    %ebp,%edx
and    $0xfffffffc,%edx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x4(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%eax
and    $0x3,%eax
cmp    $0xc,%rdi
jae    12c9 <find_Emin+0x189>
xor    %edi,%edi
jmp    130a <find_Emin+0x1ca>
lea    0x1(%rbx),%r8d
jmp    134e <find_Emin+0x20e>
and    %r9,%rsi
xor    %edi,%edi
xchg   %ax,%ax
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    12d0 <find_Emin+0x190>
test   %rax,%rax
je     1331 <find_Emin+0x1f1>
nop
lea    0x0(,%rdi,8),%rsi
or     $0x8,%rsi
movupd %xmm0,(%rcx,%rsi,1)
movupd %xmm0,0x10(%rcx,%rsi,1)
add    $0x4,%rdi
add    $0xffffffffffffffff,%rax
jne    1310 <find_Emin+0x1d0>
cmp    %rdx,%rbp
je     134e <find_Emin+0x20e>
or     $0x1,%rdx
add    $0x1,%rbp
xchg   %ax,%ax
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1340 <find_Emin+0x200>
movabs $0x54b249ad2594c37d,%rax
49 b2 54
mov    %rax,0x2d01(%rip)
movb   $0x0,0x2ce2(%rip)
mov    %r8d,%r15d
lea    -0x1(%r15),%rbp
lea    -0x2(%r15),%r12
lea    -0x5(%r15),%rax
mov    %rax,0x30(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %ebp,%r13d
and    $0x3,%r13d
mov    %rbp,0x10(%rsp)
and    $0xfffffffffffffffc,%rbp
lea    0x1(%rbp),%rcx
mov    %rcx,0x20(%rsp)
add    $0x2,%r9
mov    %rax,%rcx
mov    %rax,0x28(%rsp)
and    %rax,%r9
mov    %r9,0x18(%rsp)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%eax
mov    %eax,0x2c83(%rip)
xorpd  %xmm0,%xmm0
mov    0x8(%rsp),%r8
test   %r8d,%r8d
mov    0x10(%rsp),%r9
jle    1577 <find_Emin+0x437>
mov    0x2c69(%rip),%rax
mov    $0x1,%ecx
mov    0x2c65(%rip),%rdx
jmp    1412 <find_Emin+0x2d2>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %r15,%rcx
je     14b0 <find_Emin+0x370>
mov    (%r14,%rcx,8),%rsi
xorpd  %xmm0,%xmm0
mov    $0x1,%edi
cmp    $0x3,%r12
jb     147d <find_Emin+0x33d>
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,%rbp
jne    1430 <find_Emin+0x2f0>
add    $0x1,%rdi
test   %r13,%r13
je     1400 <find_Emin+0x2c0>
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,%r13
jne    1490 <find_Emin+0x350>
jmp    1400 <find_Emin+0x2c0>
nopl   0x0(%rax)
movq   $0x0,0x2bad(%rip)
test   %r8d,%r8d
jle    14f0 <find_Emin+0x3b0>
mov    0x2b89(%rip),%rax
mov    0x2b8a(%rip),%rcx
xorpd  %xmm0,%xmm0
cmp    $0x3,%r12
jae    14f9 <find_Emin+0x3b9>
mov    $0x1,%edx
test   $0x3,%r9b
jne    1553 <find_Emin+0x413>
jmp    1577 <find_Emin+0x437>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
jmp    157f <find_Emin+0x43f>
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,%rbp
jne    1500 <find_Emin+0x3c0>
add    $0x1,%rdx
test   $0x3,%r9b
je     1577 <find_Emin+0x437>
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,%r13
jne    1560 <find_Emin+0x420>
movsd  %xmm0,0x2ae9(%rip)
movapd %xmm0,%xmm1
subsd  0x2ad5(%rip),%xmm1
andpd  0xa9d(%rip),%xmm1
movsd  0xa75(%rip),%xmm2
ucomisd %xmm1,%xmm2
jbe    15e0 <find_Emin+0x4a0>
movb   $0x1,0x2aa0(%rip)
test   %r8d,%r8d
jle    15ed <find_Emin+0x4ad>
mov    0x2aa4(%rip),%rax
xorpd  %xmm0,%xmm0
cmp    $0x3,%r12
jae    1600 <find_Emin+0x4c0>
mov    $0x1,%ecx
test   $0x3,%r9b
jne    165b <find_Emin+0x51b>
jmp    1686 <find_Emin+0x546>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm0,0x2a78(%rip)
test   %r8d,%r8d
jg     15ad <find_Emin+0x46d>
xorpd  %xmm0,%xmm0
jmp    1686 <find_Emin+0x546>
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,%rbp
jne    1610 <find_Emin+0x4d0>
add    $0x1,%rcx
test   $0x3,%r9b
je     1686 <find_Emin+0x546>
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    1670 <find_Emin+0x530>
ucomisd 0x992(%rip),%xmm0
jb     16a0 <find_Emin+0x560>
sqrtsd %xmm0,%xmm0
test   %r8d,%r8d
jg     16b8 <find_Emin+0x578>
jmp    1837 <find_Emin+0x6f7>
xchg   %ax,%ax
call   1060 <sqrt@plt>
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%r8
test   %r8d,%r8d
jle    1837 <find_Emin+0x6f7>
movsd  0x948(%rip),%xmm1
divsd  %xmm0,%xmm1
mov    0x298d(%rip),%rax
mov    $0x1,%edx
mov    0x2979(%rip),%rcx
cmp    $0x4,%r9
jb     17b0 <find_Emin+0x670>
lea    0x8(%rcx),%rsi
lea    (%rax,%r15,8),%rdi
cmp    %rdi,%rsi
jae    16ff <find_Emin+0x5bf>
lea    (%rcx,%r15,8),%rsi
lea    0x8(%rax),%rdi
cmp    %rsi,%rdi
jb     17b0 <find_Emin+0x670>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpq   $0x4,0x30(%rsp)
jae    1713 <find_Emin+0x5d3>
xor    %edx,%edx
jmp    176a <find_Emin+0x62a>
mov    0x18(%rsp),%rsi
xor    %edx,%edx
nopw   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    1720 <find_Emin+0x5e0>
testb  $0x1,0x28(%rsp)
je     1797 <find_Emin+0x657>
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    0x20(%rsp),%rdx
cmp    %rbp,%r9
je     1837 <find_Emin+0x6f7>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15d,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %r15,%rsi
and    $0x3,%rdi
je     17e8 <find_Emin+0x6a8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    17d0 <find_Emin+0x690>
cmp    $0x3,%rsi
jb     1837 <find_Emin+0x6f7>
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,%r15
jne    17f0 <find_Emin+0x6b0>
mov    0x280f(%rip),%esi
movsd  0x2823(%rip),%xmm0
lea    0x7f4(%rip),%rdi
call   1040 <printf@plt>
cmpb   $0x1,0x27f0(%rip)
je     186b <find_Emin+0x72b>
mov    0x27ec(%rip),%eax
cmp    $0x7918,%eax
jl     13c0 <find_Emin+0x280>
mov    0x27de(%rip),%rdi
call   1030 <free@plt>
mov    0x27da(%rip),%rdi
call   1030 <free@plt>
cmpl   $0x0,0x8(%rsp)
mov    0x10(%rsp),%rdx
jle    193c <find_Emin+0x7fc>
and    $0x3,%edx
mov    $0x1,%eax
cmp    $0x3,%r12
jb     1911 <find_Emin+0x7d1>
xor    %eax,%eax
movsd  0x76d(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
mov    0x8(%r14,%rax,8),%rcx
movsd  0x8(%rcx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rcx,%rax,8)
mov    0x10(%r14,%rax,8),%rcx
movsd  0x10(%rcx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rcx,%rax,8)
mov    0x18(%r14,%rax,8),%rcx
movsd  0x18(%rcx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rcx,%rax,8)
mov    0x20(%r14,%rax,8),%rcx
movsd  0x20(%rcx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    18b0 <find_Emin+0x770>
add    $0x1,%rax
test   %rdx,%rdx
je     193c <find_Emin+0x7fc>
movsd  0x6fa(%rip),%xmm0
xchg   %ax,%ax
mov    (%r14,%rax,8),%rcx
movsd  (%rcx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1920 <find_Emin+0x7e0>
movsd  0x2724(%rip),%xmm0
addsd  0x6cc(%rip),%xmm0
movsd  %xmm0,0x2714(%rip)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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.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-13
@find_Emin.shiftE = internal global double 3.500000e+01
@find_Emin.nummax = internal global i32 31000
@.str = [20 x i8] c"num=%6d e1=%18.15f\0A\00"
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.v1
%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.v2
store i32 1, i32* @find_Emin.i
br label %19
19: ; preds = %35, %2
%20 = load i32, i32* @find_Emin.i
%21 = load i32, i32* %3
%22 = icmp sle i32 %20, %21
br i1 %22, label %23, label %38
23: ; preds = %19
%24 = load double, double* @find_Emin.shiftE
%25 = load double**, double*** %4
%26 = load i32, i32* @find_Emin.i
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds double*, double** %25, i64 %27
%29 = load double*, double** %28
%30 = load i32, i32* @find_Emin.i
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds double, double* %29, i64 %31
%33 = load double, double* %32
%34 = fsub double %33, %24
store double %34, double* %32
br label %35
35: ; preds = %23
%36 = load i32, i32* @find_Emin.i
%37 = add nsw i32 %36, 1
store i32 %37, i32* @find_Emin.i
br label %19
38: ; preds = %19
%39 = load i32, i32* %3
%40 = sitofp i32 %39 to double
%41 = call double @sqrt(double %40)
%42 = fdiv double 1.000000e+00, %41
store double %42, double* @find_Emin.tmp
store i32 1, i32* @find_Emin.i
br label %43
43: ; preds = %53, %38
%44 = load i32, i32* @find_Emin.i
%45 = load i32, i32* %3
%46 = icmp sle i32 %44, %45
br i1 %46, label %47, label %56
47: ; preds = %43
%48 = load double, double* @find_Emin.tmp
%49 = load double*, double** @find_Emin.v1
%50 = load i32, i32* @find_Emin.i
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %49, i64 %51
store double %48, double* %52
br label %53
53: ; preds = %47
%54 = load i32, i32* @find_Emin.i
%55 = add nsw i32 %54, 1
store i32 %55, i32* @find_Emin.i
br label %43
56: ; preds = %43
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 %57
57: ; preds = %184, %56
%58 = load i32, i32* @find_Emin.num
%59 = add nsw i32 %58, 1
store i32 %59, i32* @find_Emin.num
store i32 1, i32* @find_Emin.i
br label %60
60: ; preds = %95, %57
%61 = load i32, i32* @find_Emin.i
%62 = load i32, i32* %3
%63 = icmp sle i32 %61, %62
br i1 %63, label %64, label %98
64: ; preds = %60
store double 0.000000e+00, double* @find_Emin.tmp
store i32 1, i32* @find_Emin.j
br label %65
65: ; preds = %86, %64
%66 = load i32, i32* @find_Emin.j
%67 = load i32, i32* %3
%68 = icmp sle i32 %66, %67
br i1 %68, label %69, label %89
69: ; preds = %65
%70 = load double**, double*** %4
%71 = load i32, i32* @find_Emin.i
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double*, double** %70, i64 %72
%74 = load double*, double** %73
%75 = load i32, i32* @find_Emin.j
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double, double* %74, i64 %76
%78 = load double, double* %77
%79 = load double*, double** @find_Emin.v1
%80 = load i32, i32* @find_Emin.j
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %79, i64 %81
%83 = load double, double* %82
%84 = load double, double* @find_Emin.tmp
%85 = call double @llvm.fmuladd.f64(double %78, double %83, double %84)
store double %85, double* @find_Emin.tmp
br label %86
86: ; preds = %69
%87 = load i32, i32* @find_Emin.j
%88 = add nsw i32 %87, 1
store i32 %88, i32* @find_Emin.j
br label %65
89: ; preds = %65
%90 = load double, double* @find_Emin.tmp
%91 = load double*, double** @find_Emin.v2
%92 = load i32, i32* @find_Emin.i
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds double, double* %91, i64 %93
store double %90, double* %94
br label %95
95: ; preds = %89
%96 = load i32, i32* @find_Emin.i
%97 = add nsw i32 %96, 1
store i32 %97, i32* @find_Emin.i
br label %60
98: ; preds = %60
store double 0.000000e+00, double* @find_Emin.e1
store i32 1, i32* @find_Emin.i
br label %99
99: ; preds = %116, %98
%100 = load i32, i32* @find_Emin.i
%101 = load i32, i32* %3
%102 = icmp sle i32 %100, %101
br i1 %102, label %103, label %119
103: ; preds = %99
%104 = load double*, double** @find_Emin.v1
%105 = load i32, i32* @find_Emin.i
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double, double* %104, i64 %106
%108 = load double, double* %107
%109 = load double*, double** @find_Emin.v2
%110 = load i32, i32* @find_Emin.i
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds double, double* %109, i64 %111
%113 = load double, double* %112
%114 = load double, double* @find_Emin.e1
%115 = call double @llvm.fmuladd.f64(double %108, double %113, double %114)
store double %115, double* @find_Emin.e1
br label %116
116: ; preds = %103
%117 = load i32, i32* @find_Emin.i
%118 = add nsw i32 %117, 1
store i32 %118, i32* @find_Emin.i
br label %99
119: ; preds = %99
%120 = load double, double* @find_Emin.e1
%121 = load double, double* @find_Emin.e0
%122 = fsub double %120, %121
%123 = call double @llvm.fabs.f64(double %122)
%124 = load double, double* @find_Emin.diff
%125 = fcmp olt double %123, %124
br i1 %125, label %126, label %127
126: ; preds = %119
store i32 1, i32* @find_Emin.po
br label %129
127: ; preds = %119
%128 = load double, double* @find_Emin.e1
store double %128, double* @find_Emin.e0
br label %129
129: ; preds = %127, %126
store double 0.000000e+00, double* @find_Emin.tmp
store i32 1, i32* @find_Emin.i
br label %130
130: ; preds = %147, %129
%131 = load i32, i32* @find_Emin.i
%132 = load i32, i32* %3
%133 = icmp sle i32 %131, %132
br i1 %133, label %134, label %150
134: ; preds = %130
%135 = load double*, double** @find_Emin.v2
%136 = load i32, i32* @find_Emin.i
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds double, double* %135, i64 %137
%139 = load double, double* %138
%140 = load double*, double** @find_Emin.v2
%141 = load i32, i32* @find_Emin.i
%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.tmp
%146 = call double @llvm.fmuladd.f64(double %139, double %144, double %145)
store double %146, double* @find_Emin.tmp
br label %147
147: ; preds = %134
%148 = load i32, i32* @find_Emin.i
%149 = add nsw i32 %148, 1
store i32 %149, i32* @find_Emin.i
br label %130
150: ; preds = %130
%151 = load double, double* @find_Emin.tmp
%152 = call double @sqrt(double %151)
%153 = fdiv double 1.000000e+00, %152
store double %153, double* @find_Emin.tmp
store i32 1, i32* @find_Emin.i
br label %154
154: ; preds = %170, %150
%155 = load i32, i32* @find_Emin.i
%156 = load i32, i32* %3
%157 = icmp sle i32 %155, %156
br i1 %157, label %158, label %173
158: ; preds = %154
%159 = load double, double* @find_Emin.tmp
%160 = load double*, double** @find_Emin.v2
%161 = load i32, i32* @find_Emin.i
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %160, i64 %162
%164 = load double, double* %163
%165 = fmul double %159, %164
%166 = load double*, double** @find_Emin.v1
%167 = load i32, i32* @find_Emin.i
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds double, double* %166, i64 %168
store double %165, double* %169
br label %170
170: ; preds = %158
%171 = load i32, i32* @find_Emin.i
%172 = add nsw i32 %171, 1
store i32 %172, i32* @find_Emin.i
br label %154
173: ; preds = %154
%174 = load i32, i32* @find_Emin.num
%175 = load double, double* @find_Emin.e1
%176 = call i32 @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i64 0, i64 0), i32 %174, double %175)
br label %177
177: ; preds = %173
%178 = load i32, i32* @find_Emin.po
%179 = icmp eq i32 %178, 0
br i1 %179, label %180, label %184
180: ; preds = %177
%181 = load i32, i32* @find_Emin.num
%182 = load i32, i32* @find_Emin.nummax
%183 = icmp slt i32 %181, %182
br label %184
184: ; preds = %180, %177
%185 = phi i1 [ false, %177 ], [ %183, %180 ]
br i1 %185, label %57, label %186
186: ; preds = %184
%187 = load double*, double** @find_Emin.v1
%188 = call i32 @free(double* %187)
%189 = load double*, double** @find_Emin.v2
%190 = call i32 @free(double* %189)
store i32 1, i32* @find_Emin.i
br label %191
191: ; preds = %207, %186
%192 = load i32, i32* @find_Emin.i
%193 = load i32, i32* %3
%194 = icmp sle i32 %192, %193
br i1 %194, label %195, label %210
195: ; preds = %191
%196 = load double, double* @find_Emin.shiftE
%197 = load double**, double*** %4
%198 = load i32, i32* @find_Emin.i
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds double*, double** %197, i64 %199
%201 = load double*, double** %200
%202 = load i32, i32* @find_Emin.i
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %201, i64 %203
%205 = load double, double* %204
%206 = fadd double %205, %196
store double %206, double* %204
br label %207
207: ; preds = %195
%208 = load i32, i32* @find_Emin.i
%209 = add nsw i32 %208, 1
store i32 %209, i32* @find_Emin.i
br label %191
210: ; preds = %191
%211 = load double, double* @find_Emin.shiftE
%212 = load double, double* @find_Emin.e1
%213 = fadd double %212, %211
store double %213, double* @find_Emin.e1
%214 = load double, double* @find_Emin.e1
ret double %214
}

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