#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 */
int Ncore_Atom();
int Nvalence_Atom();
double eigenvalue_Atom(int);
double fill_Atom(int);
int l_Atom(int);
int lmax_Atom();
int n_Atom(int);
double peak_Atom(int);
int s_Atom(int);
void Suggested_Param_RelTroullier(int *num_states_psp, int *n_psp, int *l_psp,
                                  int *s_psp, double *e_psp, double *fill_psp,
                                  double *rcut_psp) {
  int p, npsps;
  int i, l, lmax;
  int Nc, Nv, n, s2, js;
  double rcmax, emax;
  Nc = Ncore_Atom();
  Nv = Nvalence_Atom();
  lmax = lmax_Atom();
  npsps = 2 * lmax + 4;
  for (p = 0; p < npsps; ++p) {
    rcut_psp[p] = 0.0;
    fill_psp[p] = 0.0;
    n_psp[p] = 0;
    l_psp[p] = p / 2;
    s_psp[p] = (p % 2) ? 1 : -1;
  }
  emax = 0.0;
  rcmax = 0.0;
  for (i = 0; i < Nc; ++i) {
    n = n_Atom(i);
    l = l_Atom(i);
    s2 = s_Atom(i);
    js = l + l + ((1 + s2) / 2);
    rcut_psp[js] = peak_Atom(i);
    rcmax = ((rcmax > rcut_psp[js]) ? rcmax : rcut_psp[js]);
    fill_psp[js] = 0.0;
    n_psp[js] = ((n_psp[l] > n) ? n_psp[l] : n);
    e_psp[js] = 0.0;
  }
  if (Nv > 0) {
    rcmax = 0.0;
    emax = -100000.0;
    for (i = Nc; i < (Nc + Nv); ++i) {
      n = n_Atom(i);
      l = l_Atom(i);
      s2 = s_Atom(i);
      js = l + l + ((1 + s2) / 2);
      rcut_psp[js] = peak_Atom(i);
      n_psp[js] = n;
      fill_psp[js] = fill_Atom(i);
      e_psp[js] = eigenvalue_Atom(i);
      emax = ((emax > e_psp[js]) ? emax : e_psp[js]);
      rcmax = ((rcmax > rcut_psp[js]) ? rcmax : rcut_psp[js]);
    }
  }
  n_psp[npsps - 1] = l_psp[npsps - 1] + 1;
  n_psp[npsps - 2] = l_psp[npsps - 2] + 1;
  for (p = 0; p < npsps; ++p) {
    if (fill_psp[p] == 0.0) {
      rcut_psp[p] = ((rcut_psp[p] > rcmax) ? rcut_psp[p] : rcmax);
      e_psp[p] = emax;
    }
  }
  *num_states_psp = npsps;
}


x86 assembly (clang, -O0):
<Suggested_Param_RelTroullier>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    $0x0,%al
call   1070 <Ncore_Atom@plt>
mov    %eax,-0x48(%rbp)
mov    $0x0,%al
call   1060 <Nvalence_Atom@plt>
mov    %eax,-0x4c(%rbp)
mov    $0x0,%al
call   1080 <lmax_Atom@plt>
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x4,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1271 <Suggested_Param_RelTroullier+0xe1>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
mov    $0xffffffff,%edx
mov    $0x1,%eax
cmp    $0x0,%ecx
cmovne %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11e8 <Suggested_Param_RelTroullier+0x58>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1397 <Suggested_Param_RelTroullier+0x207>
mov    -0x3c(%rbp),%edi
call   10a0 <n_Atom@plt>
mov    %eax,-0x50(%rbp)
mov    -0x3c(%rbp),%edi
call   1040 <l_Atom@plt>
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%edi
call   10b0 <s_Atom@plt>
mov    %eax,-0x54(%rbp)
mov    -0x40(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x6c(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x3c(%rbp),%edi
call   1050 <peak_Atom@plt>
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1312 <Suggested_Param_RelTroullier+0x182>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1324 <Suggested_Param_RelTroullier+0x194>
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x50(%rbp),%eax
jle    1365 <Suggested_Param_RelTroullier+0x1d5>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
jmp    136b <Suggested_Param_RelTroullier+0x1db>
mov    -0x50(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1288 <Suggested_Param_RelTroullier+0xf8>
cmpl   $0x0,-0x4c(%rbp)
jle    1507 <Suggested_Param_RelTroullier+0x377>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xc4f(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x48(%rbp),%ecx
add    -0x4c(%rbp),%ecx
cmp    %ecx,%eax
jge    1502 <Suggested_Param_RelTroullier+0x372>
mov    -0x3c(%rbp),%edi
call   10a0 <n_Atom@plt>
mov    %eax,-0x50(%rbp)
mov    -0x3c(%rbp),%edi
call   1040 <l_Atom@plt>
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%edi
call   10b0 <s_Atom@plt>
mov    %eax,-0x54(%rbp)
mov    -0x40(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x80(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x3c(%rbp),%edi
call   1050 <peak_Atom@plt>
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edi
call   1030 <fill_Atom@plt>
mov    -0x30(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%edi
call   1090 <eigenvalue_Atom@plt>
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1486 <Suggested_Param_RelTroullier+0x2f6>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    149b <Suggested_Param_RelTroullier+0x30b>
mov    -0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    14d2 <Suggested_Param_RelTroullier+0x342>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    14e7 <Suggested_Param_RelTroullier+0x357>
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13bc <Suggested_Param_RelTroullier+0x22c>
jmp    1507 <Suggested_Param_RelTroullier+0x377>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    15f9 <Suggested_Param_RelTroullier+0x469>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15e6 <Suggested_Param_RelTroullier+0x456>
jp     15e6 <Suggested_Param_RelTroullier+0x456>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    15b2 <Suggested_Param_RelTroullier+0x422>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
jmp    15bf <Suggested_Param_RelTroullier+0x42f>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    15eb <Suggested_Param_RelTroullier+0x45b>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1554 <Suggested_Param_RelTroullier+0x3c4>
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Suggested_Param_RelTroullier>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,%r15
mov    %r8,%r13
mov    %rcx,%rbp
mov    %rdx,0x28(%rsp)
mov    %rsi,0x10(%rsp)
mov    %rdi,0x48(%rsp)
mov    0x90(%rsp),%r12
xor    %eax,%eax
call   1070 <Ncore_Atom@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   1060 <Nvalence_Atom@plt>
mov    %eax,0x30(%rsp)
xor    %eax,%eax
call   1080 <lmax_Atom@plt>
mov    %eax,%ecx
lea    (%rcx,%rcx,1),%eax
add    $0x4,%eax
mov    %eax,0x24(%rsp)
mov    %rcx,0x40(%rsp)
cmp    $0xffffffff,%ecx
mov    %r15,0x8(%rsp)
jl     128f <Suggested_Param_RelTroullier+0xff>
mov    0x24(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%r8d
cmovge %eax,%r8d
cmp    $0x4,%r8d
jae    1492 <Suggested_Param_RelTroullier+0x302>
xor    %r9d,%r9d
lea    0x0(,%r9,4),%r10
add    %rbp,%r10
mov    0x28(%rsp),%rax
lea    (%rax,%r9,4),%r11
mov    0x10(%rsp),%rax
lea    (%rax,%r9,4),%rdi
lea    (%r15,%r9,8),%rbp
lea    (%r12,%r9,8),%rbx
mov    %r9,%rax
sub    %r8,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%rbx,%rcx,8)
movq   $0x0,0x0(%rbp,%rcx,8)
movl   $0x0,(%rdi,%rcx,4)
lea    (%r9,%rcx,1),%esi
mov    %esi,%edx
shr    %edx
mov    %edx,(%r11,%rcx,4)
and    $0x1,%esi
cmp    $0x1,%esi
sbb    %edx,%edx
or     $0x1,%edx
mov    %edx,(%r10,%rcx,4)
add    $0x1,%rcx
mov    %rax,%rdx
add    %rcx,%rdx
jne    1250 <Suggested_Param_RelTroullier+0xc0>
pxor   %xmm3,%xmm3
test   %r14d,%r14d
jle    133b <Suggested_Param_RelTroullier+0x1ab>
xor    %ebp,%ebp
pxor   %xmm3,%xmm3
mov    %r13,0x50(%rsp)
nopw   0x0(%rax,%rax,1)
movq   %xmm3,0x18(%rsp)
mov    %ebp,%edi
call   10a0 <n_Atom@plt>
mov    %eax,%r13d
mov    %ebp,%edi
call   1040 <l_Atom@plt>
mov    %eax,%r15d
mov    %ebp,%edi
call   10b0 <s_Atom@plt>
mov    %eax,%ecx
add    $0x1,%ecx
shr    $0x1f,%ecx
add    %ecx,%eax
add    $0x1,%eax
sar    %eax
lea    (%rax,%r15,2),%ebx
mov    %ebp,%edi
call   1050 <peak_Atom@plt>
movsd  0x18(%rsp),%xmm3
movslq %ebx,%rax
movq   %xmm0,(%r12,%rax,8)
maxsd  %xmm0,%xmm3
mov    0x8(%rsp),%rcx
movq   $0x0,(%rcx,%rax,8)
movslq %r15d,%rcx
mov    0x10(%rsp),%rdx
mov    (%rdx,%rcx,4),%ecx
cmp    %r13d,%ecx
cmovg  %ecx,%r13d
mov    %r13d,(%rdx,%rax,4)
mov    0x50(%rsp),%r13
movq   $0x0,0x0(%r13,%rax,8)
add    $0x1,%ebp
cmp    %ebp,%r14d
jne    12b0 <Suggested_Param_RelTroullier+0x120>
mov    0x40(%rsp),%rax
add    %eax,%eax
mov    %eax,0x3c(%rsp)
mov    0x30(%rsp),%r15d
test   %r15d,%r15d
pxor   %xmm2,%xmm2
jle    1407 <Suggested_Param_RelTroullier+0x277>
add    %r14d,%r15d
pxor   %xmm3,%xmm3
movsd  0xcd9(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
movq   %xmm3,0x18(%rsp)
movsd  %xmm2,0x30(%rsp)
mov    %r14d,%edi
call   10a0 <n_Atom@plt>
mov    %eax,%ebp
mov    %r14d,%edi
call   1040 <l_Atom@plt>
mov    %eax,%ebx
mov    %r14d,%edi
call   10b0 <s_Atom@plt>
mov    %eax,%ecx
add    $0x1,%ecx
shr    $0x1f,%ecx
add    %ecx,%eax
add    $0x1,%eax
sar    %eax
lea    (%rax,%rbx,2),%ebx
mov    %r14d,%edi
call   1050 <peak_Atom@plt>
movslq %ebx,%rbx
movsd  %xmm0,(%r12,%rbx,8)
mov    0x10(%rsp),%rax
mov    %ebp,(%rax,%rbx,4)
mov    %r14d,%edi
call   1030 <fill_Atom@plt>
mov    0x8(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
mov    %r14d,%edi
call   1090 <eigenvalue_Atom@plt>
movsd  0x18(%rsp),%xmm3
movsd  0x30(%rsp),%xmm2
movsd  %xmm0,0x0(%r13,%rbx,8)
maxsd  %xmm0,%xmm2
maxsd  (%r12,%rbx,8),%xmm3
add    $0x1,%r14d
cmp    %r15d,%r14d
jl     1370 <Suggested_Param_RelTroullier+0x1e0>
movslq 0x3c(%rsp),%rax
mov    0x28(%rsp),%rdx
mov    0xc(%rdx,%rax,4),%ecx
add    $0x1,%ecx
mov    0x10(%rsp),%rsi
mov    %ecx,0xc(%rsi,%rax,4)
mov    0x8(%rdx,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,0x8(%rsi,%rax,4)
cmpl   $0xffffffff,0x40(%rsp)
mov    0x8(%rsp),%rsi
mov    0x24(%rsp),%edi
jl     147c <Suggested_Param_RelTroullier+0x2ec>
mov    $0x1,%ecx
cmp    $0x2,%edi
cmovge %edi,%ecx
jge    15d4 <Suggested_Param_RelTroullier+0x444>
xor    %eax,%eax
test   $0x1,%cl
je     147c <Suggested_Param_RelTroullier+0x2ec>
movsd  (%rsi,%rax,8),%xmm0
pxor   %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    147c <Suggested_Param_RelTroullier+0x2ec>
jp     147c <Suggested_Param_RelTroullier+0x2ec>
movsd  (%r12,%rax,8),%xmm0
maxsd  %xmm3,%xmm0
movsd  %xmm0,(%r12,%rax,8)
movq   %xmm2,0x0(%r13,%rax,8)
mov    0x48(%rsp),%rax
mov    %edi,(%rax)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%r15,%r8,8),%rax
cmp    %r12,%rax
seta   %r10b
lea    (%r12,%r8,8),%rax
cmp    %r15,%rax
seta   %bl
mov    0x28(%rsp),%rax
lea    (%rax,%r8,4),%rdi
mov    0x10(%rsp),%rcx
cmp    %rcx,%rdi
seta   %r15b
lea    (%rcx,%r8,4),%rdx
cmp    %rax,%rdx
seta   %r11b
lea    0x0(,%r8,4),%rsi
add    %rbp,%rsi
cmp    %rcx,%rsi
seta   %cl
cmp    %rbp,%rdx
seta   0x18(%rsp)
cmp    %rax,%rsi
seta   %dl
cmp    %rbp,%rdi
seta   %dil
xor    %r9d,%r9d
test   %bl,%r10b
jne    164a <Suggested_Param_RelTroullier+0x4ba>
and    %r11b,%r15b
jne    164a <Suggested_Param_RelTroullier+0x4ba>
and    0x18(%rsp),%cl
jne    164a <Suggested_Param_RelTroullier+0x4ba>
and    %dil,%dl
mov    0x8(%rsp),%r15
jne    1217 <Suggested_Param_RelTroullier+0x87>
mov    %r8d,%r9d
and    $0x7ffffffc,%r9d
movdqa 0xad4(%rip),%xmm0
xor    %edx,%edx
movdqa 0xada(%rip),%xmm1
pxor   %xmm2,%xmm2
movdqa 0xade(%rip),%xmm3
movdqa 0xae6(%rip),%xmm4
mov    0x10(%rsp),%rax
mov    0x28(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm0,%xmm5
paddd  %xmm1,%xmm5
movdqu %xmm2,(%r12,%rdx,8)
movdqu %xmm2,0x10(%r12,%rdx,8)
movdqu %xmm2,(%r15,%rdx,8)
movdqu %xmm2,0x10(%r15,%rdx,8)
movdqu %xmm2,(%rax,%rdx,4)
movdqa %xmm0,%xmm6
psrld  $0x1,%xmm6
psrld  $0x1,%xmm5
punpcklqdq %xmm5,%xmm6
movdqu %xmm6,(%rcx,%rdx,4)
movdqa %xmm0,%xmm5
pand   %xmm3,%xmm5
pcmpeqd %xmm2,%xmm5
por    %xmm3,%xmm5
pshufd $0x44,%xmm5,%xmm5
movdqu %xmm5,0x0(%rbp,%rdx,4)
add    $0x4,%rdx
paddd  %xmm4,%xmm0
cmp    %rdx,%r9
jne    1560 <Suggested_Param_RelTroullier+0x3d0>
cmp    %r8,%r9
jne    1217 <Suggested_Param_RelTroullier+0x87>
jmp    128f <Suggested_Param_RelTroullier+0xff>
mov    %ecx,%edx
and    $0x7ffffffe,%edx
xor    %eax,%eax
xorpd  %xmm0,%xmm0
jmp    15fd <Suggested_Param_RelTroullier+0x46d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%rax
cmp    %rax,%rdx
je     144f <Suggested_Param_RelTroullier+0x2bf>
movsd  (%rsi,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1621 <Suggested_Param_RelTroullier+0x491>
jp     1621 <Suggested_Param_RelTroullier+0x491>
movsd  (%r12,%rax,8),%xmm1
maxsd  %xmm3,%xmm1
movsd  %xmm1,(%r12,%rax,8)
movq   %xmm2,0x0(%r13,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jne    15f0 <Suggested_Param_RelTroullier+0x460>
jp     15f0 <Suggested_Param_RelTroullier+0x460>
movsd  0x8(%r12,%rax,8),%xmm1
maxsd  %xmm3,%xmm1
movsd  %xmm1,0x8(%r12,%rax,8)
movq   %xmm2,0x8(%r13,%rax,8)
jmp    15f0 <Suggested_Param_RelTroullier+0x460>
mov    0x8(%rsp),%r15
jmp    1217 <Suggested_Param_RelTroullier+0x87>

LLVM IR (-O0):
define void @Suggested_Param_RelTroullier(i32* %0, i32* %1, i32* %2, i32* %3, double* %4, double* %5, double* %6) {
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca i32*
%11 = alloca i32*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca double
%26 = alloca double
store i32* %0, i32** %8
store i32* %1, i32** %9
store i32* %2, i32** %10
store i32* %3, i32** %11
store double* %4, double** %12
store double* %5, double** %13
store double* %6, double** %14
%27 = call i32 (...) @Ncore_Atom()
store i32 %27, i32* %20
%28 = call i32 (...) @Nvalence_Atom()
store i32 %28, i32* %21
%29 = call i32 (...) @lmax_Atom()
store i32 %29, i32* %19
%30 = load i32, i32* %19
%31 = mul nsw i32 2, %30
%32 = add nsw i32 %31, 4
store i32 %32, i32* %16
store i32 0, i32* %15
br label %33
33: ; preds = %65, %7
%34 = load i32, i32* %15
%35 = load i32, i32* %16
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %68
37: ; preds = %33
%38 = load double*, double** %14
%39 = load i32, i32* %15
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds double, double* %38, i64 %40
store double 0.000000e+00, double* %41
%42 = load double*, double** %13
%43 = load i32, i32* %15
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds double, double* %42, i64 %44
store double 0.000000e+00, double* %45
%46 = load i32*, i32** %9
%47 = load i32, i32* %15
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i32, i32* %46, i64 %48
store i32 0, i32* %49
%50 = load i32, i32* %15
%51 = sdiv i32 %50, 2
%52 = load i32*, i32** %10
%53 = load i32, i32* %15
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i32, i32* %52, i64 %54
store i32 %51, i32* %55
%56 = load i32, i32* %15
%57 = srem i32 %56, 2
%58 = icmp ne i32 %57, 0
%59 = zext i1 %58 to i64
%60 = select i1 %58, i32 1, i32 -1
%61 = load i32*, i32** %11
%62 = load i32, i32* %15
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %61, i64 %63
store i32 %60, i32* %64
br label %65
65: ; preds = %37
%66 = load i32, i32* %15
%67 = add nsw i32 %66, 1
store i32 %67, i32* %15
br label %33
68: ; preds = %33
store double 0.000000e+00, double* %26
store double 0.000000e+00, double* %25
store i32 0, i32* %17
br label %69
69: ; preds = %139, %68
%70 = load i32, i32* %17
%71 = load i32, i32* %20
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %142
73: ; preds = %69
%74 = load i32, i32* %17
%75 = call i32 @n_Atom(i32 %74)
store i32 %75, i32* %22
%76 = load i32, i32* %17
%77 = call i32 @l_Atom(i32 %76)
store i32 %77, i32* %18
%78 = load i32, i32* %17
%79 = call i32 @s_Atom(i32 %78)
store i32 %79, i32* %23
%80 = load i32, i32* %18
%81 = load i32, i32* %18
%82 = add nsw i32 %80, %81
%83 = load i32, i32* %23
%84 = add nsw i32 1, %83
%85 = sdiv i32 %84, 2
%86 = add nsw i32 %82, %85
store i32 %86, i32* %24
%87 = load i32, i32* %17
%88 = call double @peak_Atom(i32 %87)
%89 = load double*, double** %14
%90 = load i32, i32* %24
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds double, double* %89, i64 %91
store double %88, double* %92
%93 = load double, double* %25
%94 = load double*, double** %14
%95 = load i32, i32* %24
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double, double* %94, i64 %96
%98 = load double, double* %97
%99 = fcmp ogt double %93, %98
br i1 %99, label %100, label %102
100: ; preds = %73
%101 = load double, double* %25
br label %108
102: ; preds = %73
%103 = load double*, double** %14
%104 = load i32, i32* %24
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %103, i64 %105
%107 = load double, double* %106
br label %108
108: ; preds = %102, %100
%109 = phi double [ %101, %100 ], [ %107, %102 ]
store double %109, double* %25
%110 = load double*, double** %13
%111 = load i32, i32* %24
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %110, i64 %112
store double 0.000000e+00, double* %113
%114 = load i32*, i32** %9
%115 = load i32, i32* %18
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i32, i32* %114, i64 %116
%118 = load i32, i32* %117
%119 = load i32, i32* %22
%120 = icmp sgt i32 %118, %119
br i1 %120, label %121, label %127
121: ; preds = %108
%122 = load i32*, i32** %9
%123 = load i32, i32* %18
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i32, i32* %122, i64 %124
%126 = load i32, i32* %125
br label %129
127: ; preds = %108
%128 = load i32, i32* %22
br label %129
129: ; preds = %127, %121
%130 = phi i32 [ %126, %121 ], [ %128, %127 ]
%131 = load i32*, i32** %9
%132 = load i32, i32* %24
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i32, i32* %131, i64 %133
store i32 %130, i32* %134
%135 = load double*, double** %12
%136 = load i32, i32* %24
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds double, double* %135, i64 %137
store double 0.000000e+00, double* %138
br label %139
139: ; preds = %129
%140 = load i32, i32* %17
%141 = add nsw i32 %140, 1
store i32 %141, i32* %17
br label %69
142: ; preds = %69
%143 = load i32, i32* %21
%144 = icmp sgt i32 %143, 0
br i1 %144, label %145, label %228
145: ; preds = %142
store double 0.000000e+00, double* %25
store double -1.000000e+05, double* %26
%146 = load i32, i32* %20
store i32 %146, i32* %17
br label %147
147: ; preds = %224, %145
%148 = load i32, i32* %17
%149 = load i32, i32* %20
%150 = load i32, i32* %21
%151 = add nsw i32 %149, %150
%152 = icmp slt i32 %148, %151
br i1 %152, label %153, label %227
153: ; preds = %147
%154 = load i32, i32* %17
%155 = call i32 @n_Atom(i32 %154)
store i32 %155, i32* %22
%156 = load i32, i32* %17
%157 = call i32 @l_Atom(i32 %156)
store i32 %157, i32* %18
%158 = load i32, i32* %17
%159 = call i32 @s_Atom(i32 %158)
store i32 %159, i32* %23
%160 = load i32, i32* %18
%161 = load i32, i32* %18
%162 = add nsw i32 %160, %161
%163 = load i32, i32* %23
%164 = add nsw i32 1, %163
%165 = sdiv i32 %164, 2
%166 = add nsw i32 %162, %165
store i32 %166, i32* %24
%167 = load i32, i32* %17
%168 = call double @peak_Atom(i32 %167)
%169 = load double*, double** %14
%170 = load i32, i32* %24
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %169, i64 %171
store double %168, double* %172
%173 = load i32, i32* %22
%174 = load i32*, i32** %9
%175 = load i32, i32* %24
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i32, i32* %174, i64 %176
store i32 %173, i32* %177
%178 = load i32, i32* %17
%179 = call double @fill_Atom(i32 %178)
%180 = load double*, double** %13
%181 = load i32, i32* %24
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds double, double* %180, i64 %182
store double %179, double* %183
%184 = load i32, i32* %17
%185 = call double @eigenvalue_Atom(i32 %184)
%186 = load double*, double** %12
%187 = load i32, i32* %24
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double, double* %186, i64 %188
store double %185, double* %189
%190 = load double, double* %26
%191 = load double*, double** %12
%192 = load i32, i32* %24
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %191, i64 %193
%195 = load double, double* %194
%196 = fcmp ogt double %190, %195
br i1 %196, label %197, label %199
197: ; preds = %153
%198 = load double, double* %26
br label %205
199: ; preds = %153
%200 = load double*, double** %12
%201 = load i32, i32* %24
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %200, i64 %202
%204 = load double, double* %203
br label %205
205: ; preds = %199, %197
%206 = phi double [ %198, %197 ], [ %204, %199 ]
store double %206, double* %26
%207 = load double, double* %25
%208 = load double*, double** %14
%209 = load i32, i32* %24
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds double, double* %208, i64 %210
%212 = load double, double* %211
%213 = fcmp ogt double %207, %212
br i1 %213, label %214, label %216
214: ; preds = %205
%215 = load double, double* %25
br label %222
216: ; preds = %205
%217 = load double*, double** %14
%218 = load i32, i32* %24
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %217, i64 %219
%221 = load double, double* %220
br label %222
222: ; preds = %216, %214
%223 = phi double [ %215, %214 ], [ %221, %216 ]
store double %223, double* %25
br label %224
224: ; preds = %222
%225 = load i32, i32* %17
%226 = add nsw i32 %225, 1
store i32 %226, i32* %17
br label %147
227: ; preds = %147
br label %228
228: ; preds = %227, %142
%229 = load i32*, i32** %10
%230 = load i32, i32* %16
%231 = sub nsw i32 %230, 1
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i32, i32* %229, i64 %232
%234 = load i32, i32* %233
%235 = add nsw i32 %234, 1
%236 = load i32*, i32** %9
%237 = load i32, i32* %16
%238 = sub nsw i32 %237, 1
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds i32, i32* %236, i64 %239
store i32 %235, i32* %240
%241 = load i32*, i32** %10
%242 = load i32, i32* %16
%243 = sub nsw i32 %242, 2
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds i32, i32* %241, i64 %244
%246 = load i32, i32* %245
%247 = add nsw i32 %246, 1
%248 = load i32*, i32** %9
%249 = load i32, i32* %16
%250 = sub nsw i32 %249, 2
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i32, i32* %248, i64 %251
store i32 %247, i32* %252
store i32 0, i32* %15
br label %253
253: ; preds = %292, %228
%254 = load i32, i32* %15
%255 = load i32, i32* %16
%256 = icmp slt i32 %254, %255
br i1 %256, label %257, label %295
257: ; preds = %253
%258 = load double*, double** %13
%259 = load i32, i32* %15
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double, double* %258, i64 %260
%262 = load double, double* %261
%263 = fcmp oeq double %262, 0.000000e+00
br i1 %263, label %264, label %291
264: ; preds = %257
%265 = load double*, double** %14
%266 = load i32, i32* %15
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %265, i64 %267
%269 = load double, double* %268
%270 = load double, double* %25
%271 = fcmp ogt double %269, %270
br i1 %271, label %272, label %278
272: ; preds = %264
%273 = load double*, double** %14
%274 = load i32, i32* %15
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %273, i64 %275
%277 = load double, double* %276
br label %280
278: ; preds = %264
%279 = load double, double* %25
br label %280
280: ; preds = %278, %272
%281 = phi double [ %277, %272 ], [ %279, %278 ]
%282 = load double*, double** %14
%283 = load i32, i32* %15
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds double, double* %282, i64 %284
store double %281, double* %285
%286 = load double, double* %26
%287 = load double*, double** %12
%288 = load i32, i32* %15
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %287, i64 %289
store double %286, double* %290
br label %291
291: ; preds = %280, %257
br label %292
292: ; preds = %291
%293 = load i32, i32* %15
%294 = add nsw i32 %293, 1
store i32 %294, i32* %15
br label %253
295: ; preds = %253
%296 = load i32, i32* %16
%297 = load i32*, i32** %8
store i32 %296, i32* %297
ret void
}

LLVM IR (-O2):
define void @Suggested_Param_RelTroullier(i32* nocapture writeonly %0, i32* nocapture %1, i32* nocapture %2, i32* nocapture writeonly %3, double* nocapture writeonly %4, double* nocapture %5, double* nocapture %6) {
%8 = tail call i32 (...) @Ncore_Atom()
%9 = tail call i32 (...) @Nvalence_Atom()
%10 = tail call i32 (...) @lmax_Atom()
%11 = shl nsw i32 %10, 1
%12 = add i32 %11, 4
%13 = icmp sgt i32 %10, -2
br i1 %13, label %14, label %80
14: ; preds = %7
%15 = call i32 @llvm.smax.i32(i32 %12, i32 1)
%16 = zext i32 %15 to i64
%17 = icmp ult i32 %15, 4
br i1 %17, label %78, label %18
18: ; preds = %14
%19 = getelementptr double, double* %6, i64 %16
%20 = getelementptr double, double* %5, i64 %16
%21 = getelementptr i32, i32* %1, i64 %16
%22 = getelementptr i32, i32* %2, i64 %16
%23 = getelementptr i32, i32* %3, i64 %16
%24 = icmp ugt double* %20, %6
%25 = icmp ugt double* %19, %5
%26 = and i1 %24, %25
%27 = icmp ugt i32* %22, %1
%28 = icmp ugt i32* %21, %2
%29 = and i1 %27, %28
%30 = or i1 %26, %29
%31 = icmp ugt i32* %23, %1
%32 = icmp ugt i32* %21, %3
%33 = and i1 %31, %32
%34 = or i1 %30, %33
%35 = icmp ugt i32* %23, %2
%36 = icmp ugt i32* %22, %3
%37 = and i1 %35, %36
%38 = or i1 %34, %37
br i1 %38, label %78, label %39
39: ; preds = %18
%40 = and i64 %16, 2147483644
br label %41
41: ; preds = %41, %39
%42 = phi i64 [ 0, %39 ], [ %73, %41 ]
%43 = phi <2 x i32> [ <i32 0, i32 1>, %39 ], [ %74, %41 ]
%44 = add <2 x i32> %43, <i32 2, i32 2>
%45 = getelementptr inbounds double, double* %6, i64 %42
%46 = bitcast double* %45 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %46
%47 = getelementptr inbounds double, double* %45, i64 2
%48 = bitcast double* %47 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %48
%49 = getelementptr inbounds double, double* %5, i64 %42
%50 = bitcast double* %49 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %50
%51 = getelementptr inbounds double, double* %49, i64 2
%52 = bitcast double* %51 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %52
%53 = getelementptr inbounds i32, i32* %1, i64 %42
%54 = bitcast i32* %53 to <2 x i32>*
store <2 x i32> zeroinitializer, <2 x i32>* %54
%55 = getelementptr inbounds i32, i32* %53, i64 2
%56 = bitcast i32* %55 to <2 x i32>*
store <2 x i32> zeroinitializer, <2 x i32>* %56
%57 = lshr <2 x i32> %43, <i32 1, i32 1>
%58 = lshr <2 x i32> %44, <i32 1, i32 1>
%59 = getelementptr inbounds i32, i32* %2, i64 %42
%60 = bitcast i32* %59 to <2 x i32>*
store <2 x i32> %57, <2 x i32>* %60
%61 = getelementptr inbounds i32, i32* %59, i64 2
%62 = bitcast i32* %61 to <2 x i32>*
store <2 x i32> %58, <2 x i32>* %62
%63 = and <2 x i32> %43, <i32 1, i32 1>
%64 = and <2 x i32> %43, <i32 1, i32 1>
%65 = icmp eq <2 x i32> %63, zeroinitializer
%66 = icmp eq <2 x i32> %64, zeroinitializer
%67 = select <2 x i1> %65, <2 x i32> <i32 -1, i32 -1>, <2 x i32> <i32 1, i32 1>
%68 = select <2 x i1> %66, <2 x i32> <i32 -1, i32 -1>, <2 x i32> <i32 1, i32 1>
%69 = getelementptr inbounds i32, i32* %3, i64 %42
%70 = bitcast i32* %69 to <2 x i32>*
store <2 x i32> %67, <2 x i32>* %70
%71 = getelementptr inbounds i32, i32* %69, i64 2
%72 = bitcast i32* %71 to <2 x i32>*
store <2 x i32> %68, <2 x i32>* %72
%73 = add nuw i64 %42, 4
%74 = add <2 x i32> %43, <i32 4, i32 4>
%75 = icmp eq i64 %73, %40
br i1 %75, label %76, label %41
76: ; preds = %41
%77 = icmp eq i64 %40, %16
br i1 %77, label %80, label %78
78: ; preds = %18, %14, %76
%79 = phi i64 [ 0, %18 ], [ 0, %14 ], [ %40, %76 ]
br label %82
80: ; preds = %82, %76, %7
%81 = icmp sgt i32 %8, 0
br i1 %81, label %96, label %121
82: ; preds = %78, %82
%83 = phi i64 [ %94, %82 ], [ %79, %78 ]
%84 = getelementptr inbounds double, double* %6, i64 %83
store double 0.000000e+00, double* %84
%85 = getelementptr inbounds double, double* %5, i64 %83
store double 0.000000e+00, double* %85
%86 = getelementptr inbounds i32, i32* %1, i64 %83
store i32 0, i32* %86
%87 = trunc i64 %83 to i32
%88 = lshr i32 %87, 1
%89 = getelementptr inbounds i32, i32* %2, i64 %83
store i32 %88, i32* %89
%90 = and i32 %87, 1
%91 = icmp eq i32 %90, 0
%92 = select i1 %91, i32 -1, i32 1
%93 = getelementptr inbounds i32, i32* %3, i64 %83
store i32 %92, i32* %93
%94 = add nuw nsw i64 %83, 1
%95 = icmp eq i64 %94, %16
br i1 %95, label %80, label %82
96: ; preds = %80, %96
%97 = phi double [ %110, %96 ], [ 0.000000e+00, %80 ]
%98 = phi i32 [ %119, %96 ], [ 0, %80 ]
%99 = tail call i32 @n_Atom(i32 %98)
%100 = tail call i32 @l_Atom(i32 %98)
%101 = tail call i32 @s_Atom(i32 %98)
%102 = shl nsw i32 %100, 1
%103 = add nsw i32 %101, 1
%104 = sdiv i32 %103, 2
%105 = add nsw i32 %104, %102
%106 = tail call double @peak_Atom(i32 %98)
%107 = sext i32 %105 to i64
%108 = getelementptr inbounds double, double* %6, i64 %107
store double %106, double* %108
%109 = fcmp ogt double %97, %106
%110 = select i1 %109, double %97, double %106
%111 = getelementptr inbounds double, double* %5, i64 %107
store double 0.000000e+00, double* %111
%112 = sext i32 %100 to i64
%113 = getelementptr inbounds i32, i32* %1, i64 %112
%114 = load i32, i32* %113
%115 = icmp sgt i32 %114, %99
%116 = select i1 %115, i32 %114, i32 %99
%117 = getelementptr inbounds i32, i32* %1, i64 %107
store i32 %116, i32* %117
%118 = getelementptr inbounds double, double* %4, i64 %107
store double 0.000000e+00, double* %118
%119 = add nuw nsw i32 %98, 1
%120 = icmp eq i32 %119, %8
br i1 %120, label %121, label %96
121: ; preds = %96, %80
%122 = phi double [ 0.000000e+00, %80 ], [ %110, %96 ]
%123 = icmp sgt i32 %9, 0
br i1 %123, label %124, label %152
124: ; preds = %121
%125 = add nsw i32 %9, %8
br label %126
126: ; preds = %124, %126
%127 = phi double [ %146, %126 ], [ -1.000000e+05, %124 ]
%128 = phi double [ %149, %126 ], [ 0.000000e+00, %124 ]
%129 = phi i32 [ %150, %126 ], [ %8, %124 ]
%130 = tail call i32 @n_Atom(i32 %129)
%131 = tail call i32 @l_Atom(i32 %129)
%132 = tail call i32 @s_Atom(i32 %129)
%133 = shl nsw i32 %131, 1
%134 = add nsw i32 %132, 1
%135 = sdiv i32 %134, 2
%136 = add nsw i32 %135, %133
%137 = tail call double @peak_Atom(i32 %129)
%138 = sext i32 %136 to i64
%139 = getelementptr inbounds double, double* %6, i64 %138
store double %137, double* %139
%140 = getelementptr inbounds i32, i32* %1, i64 %138
store i32 %130, i32* %140
%141 = tail call double @fill_Atom(i32 %129)
%142 = getelementptr inbounds double, double* %5, i64 %138
store double %141, double* %142
%143 = tail call double @eigenvalue_Atom(i32 %129)
%144 = getelementptr inbounds double, double* %4, i64 %138
store double %143, double* %144
%145 = fcmp ogt double %127, %143
%146 = select i1 %145, double %127, double %143
%147 = load double, double* %139
%148 = fcmp ogt double %128, %147
%149 = select i1 %148, double %128, double %147
%150 = add nsw i32 %129, 1
%151 = icmp slt i32 %150, %125
br i1 %151, label %126, label %152
152: ; preds = %126, %121
%153 = phi double [ %122, %121 ], [ %149, %126 ]
%154 = phi double [ 0.000000e+00, %121 ], [ %146, %126 ]
%155 = add nsw i32 %11, 3
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i32, i32* %2, i64 %156
%158 = load i32, i32* %157
%159 = add nsw i32 %158, 1
%160 = getelementptr inbounds i32, i32* %1, i64 %156
store i32 %159, i32* %160
%161 = add nsw i32 %11, 2
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i32, i32* %2, i64 %162
%164 = load i32, i32* %163
%165 = add nsw i32 %164, 1
%166 = getelementptr inbounds i32, i32* %1, i64 %162
store i32 %165, i32* %166
br i1 %13, label %167, label %214
167: ; preds = %152
%168 = call i32 @llvm.smax.i32(i32 %12, i32 1)
%169 = zext i32 %168 to i64
%170 = and i64 %169, 1
%171 = icmp slt i32 %12, 2
br i1 %171, label %201, label %172
172: ; preds = %167
%173 = and i64 %169, 2147483646
br label %174
174: ; preds = %197, %172
%175 = phi i64 [ 0, %172 ], [ %198, %197 ]
%176 = phi i64 [ 0, %172 ], [ %199, %197 ]
%177 = getelementptr inbounds double, double* %5, i64 %175
%178 = load double, double* %177
%179 = fcmp oeq double %178, 0.000000e+00
br i1 %179, label %180, label %186
180: ; preds = %174
%181 = getelementptr inbounds double, double* %6, i64 %175
%182 = load double, double* %181
%183 = fcmp ogt double %182, %153
%184 = select i1 %183, double %182, double %153
store double %184, double* %181
%185 = getelementptr inbounds double, double* %4, i64 %175
store double %154, double* %185
br label %186
186: ; preds = %174, %180
%187 = or i64 %175, 1
%188 = getelementptr inbounds double, double* %5, i64 %187
%189 = load double, double* %188
%190 = fcmp oeq double %189, 0.000000e+00
br i1 %190, label %191, label %197
191: ; preds = %186
%192 = getelementptr inbounds double, double* %6, i64 %187
%193 = load double, double* %192
%194 = fcmp ogt double %193, %153
%195 = select i1 %194, double %193, double %153
store double %195, double* %192
%196 = getelementptr inbounds double, double* %4, i64 %187
store double %154, double* %196
br label %197
197: ; preds = %191, %186
%198 = add nuw nsw i64 %175, 2
%199 = add i64 %176, 2
%200 = icmp eq i64 %199, %173
br i1 %200, label %201, label %174
201: ; preds = %197, %167
%202 = phi i64 [ 0, %167 ], [ %198, %197 ]
%203 = icmp eq i64 %170, 0
br i1 %203, label %214, label %204
204: ; preds = %201
%205 = getelementptr inbounds double, double* %5, i64 %202
%206 = load double, double* %205
%207 = fcmp oeq double %206, 0.000000e+00
br i1 %207, label %208, label %214
208: ; preds = %204
%209 = getelementptr inbounds double, double* %6, i64 %202
%210 = load double, double* %209
%211 = fcmp ogt double %210, %153
%212 = select i1 %211, double %210, double %153
store double %212, double* %209
%213 = getelementptr inbounds double, double* %4, i64 %202
store double %154, double* %213
br label %214
214: ; preds = %201, %208, %204, %152
store i32 %12, i32* %0
ret void
}