#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_RelHamann(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, itmp;
  int i, l, lmax, ss, js;
  int Nc, Nv, n;
  double rcmax, emax;
  Nc = Ncore_Atom();
  Nv = Nvalence_Atom();
  lmax = lmax_Atom();
  npsps = 2 * lmax + 2;
  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);
    ss = s_Atom(i);
    js = l + l + ((1 + ss) / 2);
    if (n == (l + 1))
      rcut_psp[js] = 4.0 * peak_Atom(i);
    else
      rcut_psp[js] = 1.9 * peak_Atom(i);
    if (rcmax < rcut_psp[js])
      rcmax = rcut_psp[js];
    if (n_psp[js] < n)
      n_psp[js] = n;
    e_psp[js] = 0.0;
  }
  if (Nv > 0) {
    rcmax = 0.0;
    emax = -10000.0;
    for (i = Nc; i < (Nc + Nv); ++i) {
      n = n_Atom(i);
      l = l_Atom(i);
      ss = s_Atom(i);
      js = l + l + ((1 + ss) / 2);
      if (n == (l + 1))
        rcut_psp[js] = 0.4 * peak_Atom(i);
      else
        rcut_psp[js] = 0.6 * 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) {
      if (rcmax > rcut_psp[p])
        rcut_psp[p] = rcmax;
      e_psp[p] = emax;
    }
  }
  *num_states_psp = npsps;
}


x86 assembly (clang, -O0):
<Suggested_Param_RelHamann>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%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,-0x54(%rbp)
mov    $0x0,%al
call   1060 <Nvalence_Atom@plt>
mov    %eax,-0x58(%rbp)
mov    $0x0,%al
call   1080 <lmax_Atom@plt>
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
shl    $0x1,%eax
add    $0x2,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1271 <Suggested_Param_RelHamann+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_RelHamann+0x58>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    13a2 <Suggested_Param_RelHamann+0x212>
mov    -0x40(%rbp),%edi
call   10a0 <n_Atom@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%edi
call   1040 <l_Atom@plt>
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%edi
call   10b0 <s_Atom@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x44(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x74(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1310 <Suggested_Param_RelHamann+0x180>
mov    -0x40(%rbp),%edi
call   1050 <peak_Atom@plt>
movaps %xmm0,%xmm1
movsd  0xd26(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1334 <Suggested_Param_RelHamann+0x1a4>
mov    -0x40(%rbp),%edi
call   1050 <peak_Atom@plt>
movaps %xmm0,%xmm1
movsd  0xcf5(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm1
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1362 <Suggested_Param_RelHamann+0x1d2>
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x5c(%rbp),%eax
jge    1384 <Suggested_Param_RelHamann+0x1f4>
mov    -0x5c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1288 <Suggested_Param_RelHamann+0xf8>
cmpl   $0x0,-0x58(%rbp)
jle    1552 <Suggested_Param_RelHamann+0x3c2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0xc44(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x54(%rbp),%ecx
add    -0x58(%rbp),%ecx
cmp    %ecx,%eax
jge    154d <Suggested_Param_RelHamann+0x3bd>
mov    -0x40(%rbp),%edi
call   10a0 <n_Atom@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x40(%rbp),%edi
call   1040 <l_Atom@plt>
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%edi
call   10b0 <s_Atom@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x44(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x78(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1454 <Suggested_Param_RelHamann+0x2c4>
mov    -0x40(%rbp),%edi
call   1050 <peak_Atom@plt>
movaps %xmm0,%xmm1
movsd  0xbd2(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1478 <Suggested_Param_RelHamann+0x2e8>
mov    -0x40(%rbp),%edi
call   1050 <peak_Atom@plt>
movaps %xmm0,%xmm1
movsd  0xba1(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%edi
call   1030 <fill_Atom@plt>
mov    -0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%edi
call   1090 <eigenvalue_Atom@plt>
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    14d7 <Suggested_Param_RelHamann+0x347>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    14e9 <Suggested_Param_RelHamann+0x359>
mov    -0x28(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    151d <Suggested_Param_RelHamann+0x38d>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1532 <Suggested_Param_RelHamann+0x3a2>
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13c7 <Suggested_Param_RelHamann+0x237>
jmp    1552 <Suggested_Param_RelHamann+0x3c2>
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    161a <Suggested_Param_RelHamann+0x48a>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1607 <Suggested_Param_RelHamann+0x477>
jp     1607 <Suggested_Param_RelHamann+0x477>
movsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    15f5 <Suggested_Param_RelHamann+0x465>
movsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    160c <Suggested_Param_RelHamann+0x47c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    159f <Suggested_Param_RelHamann+0x40f>
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Suggested_Param_RelHamann>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,0x10(%rsp)
mov    %r8,%r15
mov    %rcx,%rbp
mov    %rdx,%rbx
mov    %rsi,%r12
mov    %rdi,0x50(%rsp)
mov    0x90(%rsp),%r13
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    $0x2,%eax
mov    %eax,0x24(%rsp)
mov    %rcx,0x40(%rsp)
test   %ecx,%ecx
mov    %r15,0x8(%rsp)
mov    %rbx,0x28(%rsp)
js     13cf <Suggested_Param_RelHamann+0x23f>
mov    0x24(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%r8d
cmovge %eax,%r8d
cmp    $0x4,%r8d
jae    121a <Suggested_Param_RelHamann+0x8a>
xor    %r9d,%r9d
jmp    1361 <Suggested_Param_RelHamann+0x1d1>
mov    0x10(%rsp),%rcx
lea    (%rcx,%r8,8),%rax
cmp    %r13,%rax
seta   %r10b
lea    0x0(,%r8,8),%rax
add    %r13,%rax
cmp    %rcx,%rax
seta   %r15b
lea    (%rbx,%r8,4),%rdi
cmp    %r12,%rdi
seta   %al
lea    (%r12,%r8,4),%rdx
cmp    %rbx,%rdx
seta   %r11b
lea    0x0(,%r8,4),%rsi
add    %rbp,%rsi
cmp    %r12,%rsi
seta   %cl
cmp    %rbp,%rdx
seta   0x18(%rsp)
cmp    %rbx,%rsi
seta   %dl
cmp    %rbp,%rdi
seta   %dil
xor    %r9d,%r9d
test   %r15b,%r10b
jne    1350 <Suggested_Param_RelHamann+0x1c0>
and    %r11b,%al
jne    1350 <Suggested_Param_RelHamann+0x1c0>
and    0x18(%rsp),%cl
mov    0x28(%rsp),%rbx
jne    135c <Suggested_Param_RelHamann+0x1cc>
and    %dil,%dl
mov    0x8(%rsp),%r15
jne    1361 <Suggested_Param_RelHamann+0x1d1>
mov    %r8d,%r9d
and    $0x7ffffffc,%r9d
movdqa 0xd45(%rip),%xmm0
xor    %edx,%edx
movdqa 0xd4b(%rip),%xmm1
pxor   %xmm2,%xmm2
movdqa 0xd4f(%rip),%xmm3
movdqa 0xd57(%rip),%xmm4
mov    0x10(%rsp),%rax
xchg   %ax,%ax
movdqa %xmm0,%xmm5
paddd  %xmm1,%xmm5
movdqu %xmm2,0x0(%r13,%rdx,8)
movdqu %xmm2,0x10(%r13,%rdx,8)
movdqu %xmm2,(%rax,%rdx,8)
movdqu %xmm2,0x10(%rax,%rdx,8)
movdqu %xmm2,(%r12,%rdx,4)
movdqa %xmm0,%xmm6
psrld  $0x1,%xmm6
psrld  $0x1,%xmm5
punpcklqdq %xmm5,%xmm6
movdqu %xmm6,(%rbx,%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    12e0 <Suggested_Param_RelHamann+0x150>
cmp    %r8,%r9
jne    1361 <Suggested_Param_RelHamann+0x1d1>
jmp    13cf <Suggested_Param_RelHamann+0x23f>
mov    0x8(%rsp),%r15
mov    0x28(%rsp),%rbx
jmp    1361 <Suggested_Param_RelHamann+0x1d1>
mov    0x8(%rsp),%r15
lea    0x0(,%r9,4),%r10
add    %rbp,%r10
lea    (%rbx,%r9,4),%r11
lea    (%r12,%r9,4),%rdi
mov    0x10(%rsp),%rax
lea    (%rax,%r9,8),%rbp
lea    0x0(,%r9,8),%rbx
add    %r13,%rbx
mov    %r9,%rax
sub    %r8,%rax
xor    %ecx,%ecx
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    1390 <Suggested_Param_RelHamann+0x200>
pxor   %xmm3,%xmm3
test   %r14d,%r14d
jle    1489 <Suggested_Param_RelHamann+0x2f9>
xor    %ebp,%ebp
pxor   %xmm0,%xmm0
jmp    140f <Suggested_Param_RelHamann+0x27f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
maxsd  0x18(%rsp),%xmm3
mov    0x8(%rsp),%r15
movq   $0x0,(%r15,%rax,8)
add    $0x1,%ebp
movapd %xmm3,%xmm0
cmp    %ebp,%r14d
je     1489 <Suggested_Param_RelHamann+0x2f9>
movq   %xmm0,0x18(%rsp)
mov    %ebp,%edi
call   10a0 <n_Atom@plt>
mov    %eax,%r13d
mov    %ebp,%edi
call   1040 <l_Atom@plt>
mov    %eax,%r15d
lea    0x1(%r15),%eax
xor    %ebx,%ebx
cmp    %eax,%r13d
sete   %bl
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),%r15d
mov    %ebp,%edi
call   1050 <peak_Atom@plt>
movdqa %xmm0,%xmm3
lea    0xbdf(%rip),%rax
mulsd  (%rax,%rbx,8),%xmm3
movslq %r15d,%rax
mov    0x90(%rsp),%rcx
movsd  %xmm3,(%rcx,%rax,8)
cmp    %r13d,(%r12,%rax,4)
jge    13f0 <Suggested_Param_RelHamann+0x260>
mov    %r13d,(%r12,%rax,4)
jmp    13f0 <Suggested_Param_RelHamann+0x260>
mov    0x40(%rsp),%rax
add    %eax,%eax
mov    %eax,0x3c(%rsp)
mov    0x30(%rsp),%eax
test   %eax,%eax
mov    0x90(%rsp),%r13
mov    %r12,0x48(%rsp)
pxor   %xmm2,%xmm2
jle    157c <Suggested_Param_RelHamann+0x3ec>
add    %r14d,%eax
pxor   %xmm3,%xmm3
movsd  0xba0(%rip),%xmm2
movq   %xmm3,0x30(%rsp)
movsd  %xmm2,0x18(%rsp)
mov    %r14d,%edi
mov    %eax,%r12d
call   10a0 <n_Atom@plt>
mov    %eax,%ebp
mov    %r14d,%edi
call   1040 <l_Atom@plt>
mov    %eax,%ebx
lea    0x1(%rbx),%eax
xor    %r15d,%r15d
cmp    %eax,%ebp
sete   %r15b
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>
lea    0xb38(%rip),%rax
mulsd  (%rax,%r15,8),%xmm0
mov    0x8(%rsp),%r15
movslq %ebx,%rbx
movsd  %xmm0,0x0(%r13,%rbx,8)
mov    0x48(%rsp),%rax
mov    %ebp,(%rax,%rbx,4)
mov    %r14d,%edi
call   1030 <fill_Atom@plt>
mov    0x10(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
mov    %r14d,%edi
call   1090 <eigenvalue_Atom@plt>
movsd  0x30(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
mov    %r12d,%eax
movsd  %xmm0,(%r15,%rbx,8)
maxsd  %xmm0,%xmm2
maxsd  0x0(%r13,%rbx,8),%xmm3
add    $0x1,%r14d
cmp    %r12d,%r14d
jl     14c0 <Suggested_Param_RelHamann+0x330>
mov    0x3c(%rsp),%ebp
mov    %ebp,%eax
or     $0x1,%eax
cltq
mov    0x28(%rsp),%rdx
mov    (%rdx,%rax,4),%ecx
add    $0x1,%ecx
mov    0x48(%rsp),%rsi
mov    %ecx,(%rsi,%rax,4)
movslq %ebp,%rax
mov    (%rdx,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,(%rsi,%rax,4)
cmpl   $0x0,0x40(%rsp)
mov    0x10(%rsp),%r12
mov    0x24(%rsp),%esi
js     15f8 <Suggested_Param_RelHamann+0x468>
cmp    $0x2,%esi
mov    $0x1,%ecx
cmovge %esi,%ecx
cmp    $0x7ffffffd,%ebp
jbe    160e <Suggested_Param_RelHamann+0x47e>
xor    %eax,%eax
test   $0x1,%cl
je     15f8 <Suggested_Param_RelHamann+0x468>
movsd  (%r12,%rax,8),%xmm0
pxor   %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15f8 <Suggested_Param_RelHamann+0x468>
jp     15f8 <Suggested_Param_RelHamann+0x468>
ucomisd 0x0(%r13,%rax,8),%xmm3
jbe    15f2 <Suggested_Param_RelHamann+0x462>
movsd  %xmm3,0x0(%r13,%rax,8)
movq   %xmm2,(%r15,%rax,8)
mov    0x50(%rsp),%rax
mov    %esi,(%rax)
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ecx,%edx
and    $0x7ffffffe,%edx
xor    %eax,%eax
xorpd  %xmm0,%xmm0
jmp    1630 <Suggested_Param_RelHamann+0x4a0>
xchg   %ax,%ax
movq   %xmm2,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
je     15cb <Suggested_Param_RelHamann+0x43b>
movsd  (%r12,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1654 <Suggested_Param_RelHamann+0x4c4>
jp     1654 <Suggested_Param_RelHamann+0x4c4>
ucomisd 0x0(%r13,%rax,8),%xmm3
jbe    164e <Suggested_Param_RelHamann+0x4be>
movsd  %xmm3,0x0(%r13,%rax,8)
movq   %xmm2,(%r15,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jne    1627 <Suggested_Param_RelHamann+0x497>
jp     1627 <Suggested_Param_RelHamann+0x497>
ucomisd 0x8(%r13,%rax,8),%xmm3
jbe    1620 <Suggested_Param_RelHamann+0x490>
movsd  %xmm3,0x8(%r13,%rax,8)
jmp    1620 <Suggested_Param_RelHamann+0x490>

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

LLVM IR (-O2):
define void @Suggested_Param_RelHamann(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, 2
%13 = icmp sgt i32 %10, -1
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 %123
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, %119
%97 = phi double [ %114, %119 ], [ 0.000000e+00, %80 ]
%98 = phi i32 [ %121, %119 ], [ 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 = add nsw i32 %100, 1
%107 = icmp eq i32 %99, %106
%108 = tail call double @peak_Atom(i32 %98)
%109 = select i1 %107, double 4.000000e+00, double 1.900000e+00
%110 = fmul double %108, %109
%111 = sext i32 %105 to i64
%112 = getelementptr inbounds double, double* %6, i64 %111
store double %110, double* %112
%113 = fcmp olt double %97, %110
%114 = select i1 %113, double %110, double %97
%115 = getelementptr inbounds i32, i32* %1, i64 %111
%116 = load i32, i32* %115
%117 = icmp slt i32 %116, %99
br i1 %117, label %118, label %119
118: ; preds = %96
store i32 %99, i32* %115
br label %119
119: ; preds = %118, %96
%120 = getelementptr inbounds double, double* %4, i64 %111
store double 0.000000e+00, double* %120
%121 = add nuw nsw i32 %98, 1
%122 = icmp eq i32 %121, %8
br i1 %122, label %123, label %96
123: ; preds = %119, %80
%124 = phi double [ 0.000000e+00, %80 ], [ %114, %119 ]
%125 = icmp sgt i32 %9, 0
br i1 %125, label %126, label %159
126: ; preds = %123
%127 = add nsw i32 %9, %8
br label %128
128: ; preds = %126, %128
%129 = phi double [ %152, %128 ], [ -1.000000e+04, %126 ]
%130 = phi double [ %156, %128 ], [ 0.000000e+00, %126 ]
%131 = phi i32 [ %157, %128 ], [ %8, %126 ]
%132 = tail call i32 @n_Atom(i32 %131)
%133 = tail call i32 @l_Atom(i32 %131)
%134 = tail call i32 @s_Atom(i32 %131)
%135 = shl nsw i32 %133, 1
%136 = add nsw i32 %134, 1
%137 = sdiv i32 %136, 2
%138 = add nsw i32 %137, %135
%139 = add nsw i32 %133, 1
%140 = icmp eq i32 %132, %139
%141 = tail call double @peak_Atom(i32 %131)
%142 = select i1 %140, double 4.000000e-01, double 6.000000e-01
%143 = fmul double %141, %142
%144 = sext i32 %138 to i64
%145 = getelementptr inbounds double, double* %6, i64 %144
store double %143, double* %145
%146 = getelementptr inbounds i32, i32* %1, i64 %144
store i32 %132, i32* %146
%147 = tail call double @fill_Atom(i32 %131)
%148 = getelementptr inbounds double, double* %5, i64 %144
store double %147, double* %148
%149 = tail call double @eigenvalue_Atom(i32 %131)
%150 = getelementptr inbounds double, double* %4, i64 %144
store double %149, double* %150
%151 = fcmp ogt double %129, %149
%152 = select i1 %151, double %129, double %149
%153 = getelementptr inbounds double, double* %6, i64 %144
%154 = load double, double* %153
%155 = fcmp ogt double %130, %154
%156 = select i1 %155, double %130, double %154
%157 = add nsw i32 %131, 1
%158 = icmp slt i32 %157, %127
br i1 %158, label %128, label %159
159: ; preds = %128, %123
%160 = phi double [ %124, %123 ], [ %156, %128 ]
%161 = phi double [ 0.000000e+00, %123 ], [ %152, %128 ]
%162 = or i32 %11, 1
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i32, i32* %2, i64 %163
%165 = load i32, i32* %164
%166 = add nsw i32 %165, 1
%167 = getelementptr inbounds i32, i32* %1, i64 %163
store i32 %166, i32* %167
%168 = sext i32 %11 to i64
%169 = getelementptr inbounds i32, i32* %2, i64 %168
%170 = load i32, i32* %169
%171 = add nsw i32 %170, 1
%172 = getelementptr inbounds i32, i32* %1, i64 %168
store i32 %171, i32* %172
br i1 %13, label %173, label %223
173: ; preds = %159
%174 = call i32 @llvm.smax.i32(i32 %12, i32 1)
%175 = zext i32 %174 to i64
%176 = and i64 %175, 1
%177 = icmp ugt i32 %11, 2147483645
br i1 %177, label %209, label %178
178: ; preds = %173
%179 = and i64 %175, 2147483646
br label %180
180: ; preds = %205, %178
%181 = phi i64 [ 0, %178 ], [ %206, %205 ]
%182 = phi i64 [ 0, %178 ], [ %207, %205 ]
%183 = getelementptr inbounds double, double* %5, i64 %181
%184 = load double, double* %183
%185 = fcmp oeq double %184, 0.000000e+00
br i1 %185, label %186, label %193
186: ; preds = %180
%187 = getelementptr inbounds double, double* %6, i64 %181
%188 = load double, double* %187
%189 = fcmp ogt double %160, %188
br i1 %189, label %190, label %191
190: ; preds = %186
store double %160, double* %187
br label %191
191: ; preds = %190, %186
%192 = getelementptr inbounds double, double* %4, i64 %181
store double %161, double* %192
br label %193
193: ; preds = %180, %191
%194 = or i64 %181, 1
%195 = getelementptr inbounds double, double* %5, i64 %194
%196 = load double, double* %195
%197 = fcmp oeq double %196, 0.000000e+00
br i1 %197, label %198, label %205
198: ; preds = %193
%199 = getelementptr inbounds double, double* %6, i64 %194
%200 = load double, double* %199
%201 = fcmp ogt double %160, %200
br i1 %201, label %202, label %203
202: ; preds = %198
store double %160, double* %199
br label %203
203: ; preds = %202, %198
%204 = getelementptr inbounds double, double* %4, i64 %194
store double %161, double* %204
br label %205
205: ; preds = %203, %193
%206 = add nuw nsw i64 %181, 2
%207 = add i64 %182, 2
%208 = icmp eq i64 %207, %179
br i1 %208, label %209, label %180
209: ; preds = %205, %173
%210 = phi i64 [ 0, %173 ], [ %206, %205 ]
%211 = icmp eq i64 %176, 0
br i1 %211, label %223, label %212
212: ; preds = %209
%213 = getelementptr inbounds double, double* %5, i64 %210
%214 = load double, double* %213
%215 = fcmp oeq double %214, 0.000000e+00
br i1 %215, label %216, label %223
216: ; preds = %212
%217 = getelementptr inbounds double, double* %6, i64 %210
%218 = load double, double* %217
%219 = fcmp ogt double %160, %218
br i1 %219, label %220, label %221
220: ; preds = %216
store double %160, double* %217
br label %221
221: ; preds = %220, %216
%222 = getelementptr inbounds double, double* %4, i64 %210
store double %161, double* %222
br label %223
223: ; preds = %209, %221, %212, %159
store i32 %12, i32* %0
ret void
}