int eigen_value_convergence(int num_eigenstates, double *delta_eigen, int h_dim,
                            double *h_matrix) {
  char *func = {"eigen_value_convergence(): "};
  register int loop, num;
  static int delta_num = -1;
  double *list_eigenvalue;
  list_eigenvalue =
      (double *)mem_alloc((h_dim) * sizeof(double), func, "list_eigenvalue[]");
  eigenvalues(h_dim, h_matrix, list_eigenvalue);
  if (delta_num < 0) {
    for (loop = 0; loop < num_eigenstates; loop++) {
      delta_eigen[4 * num_eigenstates + loop] = list_eigenvalue[loop];
    }
    delta_num++;
    free(list_eigenvalue);
    return 0;
  }
  for (loop = 0, num = delta_num * num_eigenstates; loop < num_eigenstates;
       loop++, num++) {
    delta_eigen[num] =
        fabs(delta_eigen[4 * num_eigenstates + loop] - list_eigenvalue[loop]);
  }
  delta_num = (3 & (++delta_num));
  for (loop = 0; loop < num_eigenstates; loop++) {
    delta_eigen[4 * num_eigenstates + loop] = list_eigenvalue[loop];
  }
  if ((h_dim - num_eigenstates) < 4) {
    free(list_eigenvalue);
    return 0;
  }
  for (loop = 0; loop < 4 * num_eigenstates; loop++) {
    if (delta_eigen[loop] > 1.0E-05) {
      free(list_eigenvalue);
      return 0;
    }
  }
  free(list_eigenvalue);
  return 1;
}


x86 assembly (clang, -O0):
<eigen_value_convergence>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
lea    0xed3(%rip),%rax
mov    %rax,-0x28(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
mov    -0x28(%rbp),%rsi
lea    0xed8(%rip),%rdx
mov    $0x0,%al
call   1040 <mem_alloc@plt>
cltq
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    $0x0,%al
call   1050 <eigenvalues@plt>
cmpl   $0x0,0x2eae(%rip)
jge    11f7 <eigen_value_convergence+0xc7>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11d3 <eigen_value_convergence+0xa3>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
shl    $0x2,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1197 <eigen_value_convergence+0x67>
mov    0x2e5f(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2e56(%rip)
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
jmp    1356 <eigen_value_convergence+0x226>
movl   $0x0,-0x2c(%rbp)
mov    0x2e34(%rip),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1268 <eigen_value_convergence+0x138>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
shl    $0x2,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0xdd0(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    120b <eigen_value_convergence+0xdb>
mov    0x2dca(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2dc1(%rip)
and    $0x3,%eax
mov    %eax,0x2db8(%rip)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12c3 <eigen_value_convergence+0x193>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
shl    $0x2,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1287 <eigen_value_convergence+0x157>
mov    -0x14(%rbp),%eax
sub    -0x8(%rbp),%eax
cmp    $0x4,%eax
jge    12e7 <eigen_value_convergence+0x1b7>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
jmp    1356 <eigen_value_convergence+0x226>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x8(%rbp),%ecx
shl    $0x2,%ecx
cmp    %ecx,%eax
jge    1346 <eigen_value_convergence+0x216>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xcec(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1333 <eigen_value_convergence+0x203>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
jmp    1356 <eigen_value_convergence+0x226>
jmp    1338 <eigen_value_convergence+0x208>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12ee <eigen_value_convergence+0x1be>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eigen_value_convergence>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r13
mov    %edx,%r12d
mov    %rsi,%r14
mov    %edi,%r15d
movslq %edx,%rbp
lea    0x0(,%rbp,8),%rdi
lea    0xebf(%rip),%rsi
lea    0xed4(%rip),%rdx
xor    %eax,%eax
call   1040 <mem_alloc@plt>
movslq %eax,%rbx
mov    %ebp,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1050 <eigenvalues@plt>
mov    0x2eb8(%rip),%r10d
test   %r10d,%r10d
js     11b7 <eigen_value_convergence+0x87>
test   %r15d,%r15d
jle    127c <eigen_value_convergence+0x14c>
mov    %r10d,%eax
imul   %r15d,%eax
lea    0x0(,%r15,4),%ecx
movslq %eax,%rdi
movslq %ecx,%r8
mov    %r15d,%ecx
cmp    $0x4,%r15d
jae    1290 <eigen_value_convergence+0x160>
xor    %esi,%esi
jmp    1345 <eigen_value_convergence+0x215>
test   %r15d,%r15d
jle    16e8 <eigen_value_convergence+0x5b8>
lea    0x0(,%r15,4),%eax
movslq %eax,%r8
mov    %r15d,%ecx
cmp    $0x4,%r15d
jb     11f6 <eigen_value_convergence+0xc6>
lea    (%r14,%r8,8),%rax
lea    (%rbx,%rcx,8),%rdx
cmp    %rdx,%rax
jae    14d2 <eigen_value_convergence+0x3a2>
lea    (%r8,%rcx,1),%rax
lea    (%r14,%rax,8),%rax
cmp    %rax,%rbx
jae    14d2 <eigen_value_convergence+0x3a2>
xor    %esi,%esi
mov    %rsi,%rdx
not    %rdx
add    %rcx,%rdx
mov    %rcx,%rax
and    $0x3,%rax
je     1224 <eigen_value_convergence+0xf4>
lea    (%r14,%r8,8),%rdi
xchg   %ax,%ax
movsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rdi,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1210 <eigen_value_convergence+0xe0>
cmp    $0x3,%rdx
jb     16e8 <eigen_value_convergence+0x5b8>
lea    (%r14,%r8,8),%rax
add    $0x18,%rax
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,-0x18(%rax,%rsi,8)
movsd  0x8(%rbx,%rsi,8),%xmm0
movsd  %xmm0,-0x10(%rax,%rsi,8)
movsd  0x10(%rbx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rsi,8)
movsd  0x18(%rbx,%rsi,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    1240 <eigen_value_convergence+0x110>
jmp    16e8 <eigen_value_convergence+0x5b8>
add    $0x1,%r10d
and    $0x3,%r10d
mov    %r10d,0x2dad(%rip)
jmp    15b8 <eigen_value_convergence+0x488>
lea    (%r14,%rdi,8),%rax
lea    (%rdi,%rcx,1),%rdx
lea    (%r14,%rdx,8),%rdx
lea    (%r14,%r8,8),%r9
lea    (%r8,%rcx,1),%rbp
lea    (%r14,%rbp,8),%rbp
lea    (%rbx,%rcx,8),%rsi
cmp    %rbp,%rax
setb   %r11b
cmp    %rdx,%r9
setb   %r9b
cmp    %rsi,%rax
setb   %al
cmp    %rdx,%rbx
setb   %dl
xor    %esi,%esi
test   %r9b,%r11b
jne    1345 <eigen_value_convergence+0x215>
and    %dl,%al
jne    1345 <eigen_value_convergence+0x215>
mov    %ecx,%esi
and    $0xfffffffc,%esi
lea    (%rsi,%rdi,1),%r9
lea    (%r14,%r8,8),%rdx
add    $0x10,%rdx
lea    0x0(,%rcx,8),%rbp
and    $0xffffffffffffffe0,%rbp
lea    (%r14,%rdi,8),%rdi
add    $0x10,%rdi
xor    %eax,%eax
movapd 0xd00(%rip),%xmm0
movupd -0x10(%rdx,%rax,1),%xmm1
movupd (%rdx,%rax,1),%xmm2
movupd (%rbx,%rax,1),%xmm3
subpd  %xmm3,%xmm1
movupd 0x10(%rbx,%rax,1),%xmm3
subpd  %xmm3,%xmm2
andpd  %xmm0,%xmm1
andpd  %xmm0,%xmm2
movupd %xmm1,-0x10(%rdi,%rax,1)
movupd %xmm2,(%rdi,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbp
jne    1300 <eigen_value_convergence+0x1d0>
cmp    %rcx,%rsi
je     13e2 <eigen_value_convergence+0x2b2>
jmp    1348 <eigen_value_convergence+0x218>
mov    %rdi,%r9
mov    %rsi,%rdx
not    %rdx
test   $0x1,%cl
je     1378 <eigen_value_convergence+0x248>
lea    (%rsi,%r8,1),%rax
movsd  (%r14,%rax,8),%xmm0
subsd  (%rbx,%rsi,8),%xmm0
andpd  0xc96(%rip),%xmm0
movlpd %xmm0,(%r14,%r9,8)
or     $0x1,%rsi
add    $0x1,%r9
add    %rcx,%rdx
je     13e2 <eigen_value_convergence+0x2b2>
mov    %rcx,%rdx
sub    %rsi,%rdx
lea    (%rsi,%r8,1),%rax
lea    (%r14,%rax,8),%rdi
add    $0x8,%rdi
lea    (%rbx,%rsi,8),%rsi
add    $0x8,%rsi
lea    (%r14,%r9,8),%rax
add    $0x8,%rax
xor    %ebp,%ebp
movapd 0xc57(%rip),%xmm0
nopl   0x0(%rax)
movsd  -0x8(%rdi,%rbp,8),%xmm1
subsd  -0x8(%rsi,%rbp,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,-0x8(%rax,%rbp,8)
movsd  (%rdi,%rbp,8),%xmm1
subsd  (%rsi,%rbp,8),%xmm1
andpd  %xmm0,%xmm1
movlpd %xmm1,(%rax,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rdx
jne    13b0 <eigen_value_convergence+0x280>
add    $0x1,%r10d
and    $0x3,%r10d
mov    %r10d,0x2c47(%rip)
test   %r15d,%r15d
jle    15b8 <eigen_value_convergence+0x488>
cmp    $0x4,%r15d
jb     1422 <eigen_value_convergence+0x2f2>
lea    (%r14,%r8,8),%rax
lea    (%rbx,%rcx,8),%rdx
cmp    %rdx,%rax
jae    14ac <eigen_value_convergence+0x37c>
lea    (%r8,%rcx,1),%rax
lea    (%r14,%rax,8),%rax
cmp    %rax,%rbx
jae    14ac <eigen_value_convergence+0x37c>
xor    %eax,%eax
mov    %rax,%rdx
not    %rdx
add    %rcx,%rdx
mov    %rcx,%rsi
and    $0x3,%rsi
je     1454 <eigen_value_convergence+0x324>
lea    (%r14,%r8,8),%rdi
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1440 <eigen_value_convergence+0x310>
cmp    $0x3,%rdx
jb     15b8 <eigen_value_convergence+0x488>
lea    (%r14,%r8,8),%rdx
add    $0x18,%rdx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x18(%rdx,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%rdx,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1470 <eigen_value_convergence+0x340>
jmp    15b8 <eigen_value_convergence+0x488>
mov    %ecx,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rdx
jae    14fe <eigen_value_convergence+0x3ce>
xor    %ebp,%ebp
jmp    156c <eigen_value_convergence+0x43c>
mov    %ecx,%esi
and    $0xfffffffc,%esi
lea    -0x4(%rsi),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0xc,%rax
jae    1623 <eigen_value_convergence+0x4f3>
xor    %edx,%edx
jmp    169d <eigen_value_convergence+0x56d>
and    $0xfffffffffffffffc,%rdi
lea    (%r14,%r8,8),%rdx
add    $0x70,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups (%rbx,%rbp,8),%xmm0
movups 0x10(%rbx,%rbp,8),%xmm1
movups %xmm0,-0x70(%rdx,%rbp,8)
movups %xmm1,-0x60(%rdx,%rbp,8)
movups 0x20(%rbx,%rbp,8),%xmm0
movups 0x30(%rbx,%rbp,8),%xmm1
movups %xmm0,-0x50(%rdx,%rbp,8)
movups %xmm1,-0x40(%rdx,%rbp,8)
movups 0x40(%rbx,%rbp,8),%xmm0
movups 0x50(%rbx,%rbp,8),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,8)
movups %xmm1,-0x20(%rdx,%rbp,8)
movupd 0x60(%rbx,%rbp,8),%xmm0
movupd 0x70(%rbx,%rbp,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rbp,8)
movupd %xmm1,(%rdx,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1510 <eigen_value_convergence+0x3e0>
test   %rsi,%rsi
je     15af <eigen_value_convergence+0x47f>
lea    (%r8,%rbp,1),%rdx
lea    (%r14,%rdx,8),%rdx
add    $0x10,%rdx
lea    (%rbx,%rbp,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rbp,1),%xmm0
movupd (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rbp,1)
movupd %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1590 <eigen_value_convergence+0x460>
cmp    %rcx,%rax
jne    1424 <eigen_value_convergence+0x2f4>
sub    %r15d,%r12d
xor    %ebp,%ebp
cmp    $0x4,%r12d
setge  %bpl
jl     16f5 <eigen_value_convergence+0x5c5>
test   %r15d,%r15d
jle    16f5 <eigen_value_convergence+0x5c5>
shl    $0x2,%r15d
cmp    $0x2,%r15d
mov    $0x1,%eax
cmovge %r15d,%eax
xor    %ebp,%ebp
movsd  0xa21(%rip),%xmm0
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm1
ucomisd %xmm0,%xmm1
ja     16f5 <eigen_value_convergence+0x5c5>
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1600 <eigen_value_convergence+0x4d0>
mov    $0x1,%ebp
jmp    16f5 <eigen_value_convergence+0x5c5>
and    $0xfffffffffffffffc,%rdi
lea    (%r14,%r8,8),%rbp
add    $0x70,%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rdx,8),%xmm0
movups 0x10(%rbx,%rdx,8),%xmm1
movups %xmm0,-0x70(%rbp,%rdx,8)
movups %xmm1,-0x60(%rbp,%rdx,8)
movups 0x20(%rbx,%rdx,8),%xmm0
movups 0x30(%rbx,%rdx,8),%xmm1
movups %xmm0,-0x50(%rbp,%rdx,8)
movups %xmm1,-0x40(%rbp,%rdx,8)
movups 0x40(%rbx,%rdx,8),%xmm0
movups 0x50(%rbx,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbp,%rdx,8)
movups %xmm1,-0x20(%rbp,%rdx,8)
movupd 0x60(%rbx,%rdx,8),%xmm0
movupd 0x70(%rbx,%rdx,8),%xmm1
movupd %xmm0,-0x10(%rbp,%rdx,8)
movupd %xmm1,0x0(%rbp,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1640 <eigen_value_convergence+0x510>
test   %r9,%r9
je     16df <eigen_value_convergence+0x5af>
lea    (%rdx,%r8,1),%rax
lea    (%r14,%rax,8),%rax
add    $0x10,%rax
lea    (%rbx,%rdx,8),%rdx
add    $0x10,%rdx
shl    $0x5,%r9
xor    %edi,%edi
nopl   0x0(%rax)
movupd -0x10(%rdx,%rdi,1),%xmm0
movupd (%rdx,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rax,%rdi,1)
movupd %xmm1,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    16c0 <eigen_value_convergence+0x590>
cmp    %rcx,%rsi
jne    11f8 <eigen_value_convergence+0xc8>
add    $0x1,%r10d
mov    %r10d,0x2945(%rip)
xor    %ebp,%ebp
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [28 x i8] c"eigen_value_convergence(): \00"
@eigen_value_convergence.delta_num = internal global i32 -1
@.str.1 = [18 x i8] c"list_eigenvalue[]\00"
define i32 @eigen_value_convergence(i32 %0, double* %1, i32 %2, double* %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca double*
%8 = alloca i32
%9 = alloca double*
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
%13 = alloca double*
store i32 %0, i32* %6
store double* %1, double** %7
store i32 %2, i32* %8
store double* %3, double** %9
store i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0), i8** %10
%14 = load i32, i32* %8
%15 = sext i32 %14 to i64
%16 = mul i64 %15, 8
%17 = load i8*, i8** %10
%18 = call i32 (i64, i8*, i8*, ...) bitcast (i32 (...)* @mem_alloc to i32 (i64, i8*, i8*, ...)*)(i64 %16, i8* %17, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0))
%19 = sext i32 %18 to i64
%20 = inttoptr i64 %19 to double*
store double* %20, double** %13
%21 = load i32, i32* %8
%22 = load double*, double** %9
%23 = load double*, double** %13
%24 = call i32 (i32, double*, double*, ...) bitcast (i32 (...)* @eigenvalues to i32 (i32, double*, double*, ...)*)(i32 %21, double* %22, double* %23)
%25 = load i32, i32* @eigen_value_convergence.delta_num
%26 = icmp slt i32 %25, 0
br i1 %26, label %27, label %53
27: ; preds = %4
store i32 0, i32* %11
br label %28
28: ; preds = %45, %27
%29 = load i32, i32* %11
%30 = load i32, i32* %6
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %48
32: ; preds = %28
%33 = load double*, double** %13
%34 = load i32, i32* %11
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds double, double* %33, i64 %35
%37 = load double, double* %36
%38 = load double*, double** %7
%39 = load i32, i32* %6
%40 = mul nsw i32 4, %39
%41 = load i32, i32* %11
%42 = add nsw i32 %40, %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %38, i64 %43
store double %37, double* %44
br label %45
45: ; preds = %32
%46 = load i32, i32* %11
%47 = add nsw i32 %46, 1
store i32 %47, i32* %11
br label %28
48: ; preds = %28
%49 = load i32, i32* @eigen_value_convergence.delta_num
%50 = add nsw i32 %49, 1
store i32 %50, i32* @eigen_value_convergence.delta_num
%51 = load double*, double** %13
%52 = bitcast double* %51 to i8*
store i32 0, i32* %5
br label %141
53: ; preds = %4
store i32 0, i32* %11
%54 = load i32, i32* @eigen_value_convergence.delta_num
%55 = load i32, i32* %6
%56 = mul nsw i32 %54, %55
store i32 %56, i32* %12
br label %57
57: ; preds = %81, %53
%58 = load i32, i32* %11
%59 = load i32, i32* %6
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %86
61: ; preds = %57
%62 = load double*, double** %7
%63 = load i32, i32* %6
%64 = mul nsw i32 4, %63
%65 = load i32, i32* %11
%66 = add nsw i32 %64, %65
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %62, i64 %67
%69 = load double, double* %68
%70 = load double*, double** %13
%71 = load i32, i32* %11
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double, double* %70, i64 %72
%74 = load double, double* %73
%75 = fsub double %69, %74
%76 = call double @llvm.fabs.f64(double %75)
%77 = load double*, double** %7
%78 = load i32, i32* %12
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %77, i64 %79
store double %76, double* %80
br label %81
81: ; preds = %61
%82 = load i32, i32* %11
%83 = add nsw i32 %82, 1
store i32 %83, i32* %11
%84 = load i32, i32* %12
%85 = add nsw i32 %84, 1
store i32 %85, i32* %12
br label %57
86: ; preds = %57
%87 = load i32, i32* @eigen_value_convergence.delta_num
%88 = add nsw i32 %87, 1
store i32 %88, i32* @eigen_value_convergence.delta_num
%89 = and i32 3, %88
store i32 %89, i32* @eigen_value_convergence.delta_num
store i32 0, i32* %11
br label %90
90: ; preds = %107, %86
%91 = load i32, i32* %11
%92 = load i32, i32* %6
%93 = icmp slt i32 %91, %92
br i1 %93, label %94, label %110
94: ; preds = %90
%95 = load double*, double** %13
%96 = load i32, i32* %11
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %95, i64 %97
%99 = load double, double* %98
%100 = load double*, double** %7
%101 = load i32, i32* %6
%102 = mul nsw i32 4, %101
%103 = load i32, i32* %11
%104 = add nsw i32 %102, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %100, i64 %105
store double %99, double* %106
br label %107
107: ; preds = %94
%108 = load i32, i32* %11
%109 = add nsw i32 %108, 1
store i32 %109, i32* %11
br label %90
110: ; preds = %90
%111 = load i32, i32* %8
%112 = load i32, i32* %6
%113 = sub nsw i32 %111, %112
%114 = icmp slt i32 %113, 4
br i1 %114, label %115, label %118
115: ; preds = %110
%116 = load double*, double** %13
%117 = bitcast double* %116 to i8*
store i32 0, i32* %5
br label %141
118: ; preds = %110
store i32 0, i32* %11
br label %119
119: ; preds = %135, %118
%120 = load i32, i32* %11
%121 = load i32, i32* %6
%122 = mul nsw i32 4, %121
%123 = icmp slt i32 %120, %122
br i1 %123, label %124, label %138
124: ; preds = %119
%125 = load double*, double** %7
%126 = load i32, i32* %11
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds double, double* %125, i64 %127
%129 = load double, double* %128
%130 = fcmp ogt double %129, 1.000000e-05
br i1 %130, label %131, label %134
131: ; preds = %124
%132 = load double*, double** %13
%133 = bitcast double* %132 to i8*
store i32 0, i32* %5
br label %141
134: ; preds = %124
br label %135
135: ; preds = %134
%136 = load i32, i32* %11
%137 = add nsw i32 %136, 1
store i32 %137, i32* %11
br label %119
138: ; preds = %119
%139 = load double*, double** %13
%140 = bitcast double* %139 to i8*
store i32 1, i32* %5
br label %141
141: ; preds = %138, %131, %115, %48
%142 = load i32, i32* %5
ret i32 %142
}

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