#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 /*<<< orphan*/ abort();
int abs(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *, int);
double sqrt(double);
int /*<<< orphan*/ stderr;
double CG(int j1, int m1, int j2, int m2, int j, int m) {
  int kmin, kmax, k;
  double sgn, cg;
  const int fmax = 3 * 30;
  double f[3 * 30];
  if (j1 > 30 || j2 > 30 || j > 30) {
    fprintf(stderr, "*** out of bound (%s, %d)\n",
            "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
            "2022-01-22/02-19-57/repos/RafaelDexter/OpenMX/refs/heads/master/"
            "source/liberi-091216/source/eri_sf.c",
            604);
    abort();
  }
  f[0] = f[1] = 1.0;
  for (k = 2; k < fmax; k++) {
    f[k] = f[k - 1] * (double)k;
  }
  if (m != m1 + m2)
    return 0.0;
  if (j1 + j2 < j || j2 + j < j1 || j + j1 < j2)
    return 0.0;
  if (abs(m1) > j1 || abs(m2) > j2 || abs(m) > j)
    return 0.0;
  kmin = 0;
  if (kmin < -j + j2 - m1)
    kmin = -j + j2 - m1;
  if (kmin < -j + j1 + m2)
    kmin = -j + j1 + m2;
  kmax = j1 + j2 - j;
  if (kmax > j1 - m1)
    kmax = j1 - m1;
  if (kmax > j2 + m2)
    kmax = j2 + m2;
  if (kmin > kmax)
    return 0.0;
  cg = 0.0;
  sgn = kmin % 2 == 0 ? 1.0 : -1.0;
  for (k = kmin; k <= kmax; k++) {
    cg += sgn / (f[k] * f[j1 + j2 - j - k] * f[j1 - m1 - k] * f[j2 + m2 - k] *
                 f[j - j2 + m1 + k] * f[j - j1 - m2 + k]);
    sgn = -sgn;
  }
  cg *= sqrt((double)(2 * j + 1) * f[j1 + j2 - j] * f[j + j1 - j2] *
             f[j + j2 - j1] * f[j1 + m1] * f[j1 - m1] * f[j2 + m2] *
             f[j2 - m2] * f[j + m] * f[j - m] / f[j + j1 + j2 + 1]);
  return cg;
}


x86 assembly (clang, -O0):
<CG>:
push   %rbp
mov    %rsp,%rbp
sub    $0x330,%rsp
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movl   $0x5a,-0x44(%rbp)
cmpl   $0x1e,-0xc(%rbp)
jg     1184 <CG+0x44>
cmpl   $0x1e,-0x14(%rbp)
jg     1184 <CG+0x44>
cmpl   $0x1e,-0x1c(%rbp)
jle    11ac <CG+0x6c>
mov    0x2e55(%rip),%rax
mov    (%rax),%edi
lea    0xe7c(%rip),%rsi
lea    0xe90(%rip),%rdx
mov    $0x25c,%ecx
call   1050 <fprintf@plt>
mov    $0x0,%al
call   1030 <abort@plt>
movsd  0xe4c(%rip),%xmm0
movsd  %xmm0,-0x318(%rbp)
ff
movsd  0xe3c(%rip),%xmm0
movsd  %xmm0,-0x320(%rbp)
ff
movl   $0x2,-0x2c(%rbp)
cmpl   $0x5a,-0x2c(%rbp)
jge    1212 <CG+0xd2>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
cltq
movsd  -0x320(%rbp,%rax,8),%xmm0
ff ff
cvtsi2sdl -0x2c(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movsd  %xmm0,-0x320(%rbp,%rax,8)
ff ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d3 <CG+0x93>
mov    -0x20(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
je     1230 <CG+0xf0>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1558 <CG+0x418>
mov    -0xc(%rbp),%eax
add    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jl     125d <CG+0x11d>
mov    -0x14(%rbp),%eax
add    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     125d <CG+0x11d>
mov    -0x1c(%rbp),%eax
add    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    126a <CG+0x12a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1558 <CG+0x418>
mov    -0x10(%rbp),%edi
call   1040 <abs@plt>
cmp    -0xc(%rbp),%eax
jg     129d <CG+0x15d>
mov    -0x18(%rbp),%edi
call   1040 <abs@plt>
cmp    -0x14(%rbp),%eax
jg     129d <CG+0x15d>
mov    -0x20(%rbp),%edi
call   1040 <abs@plt>
cmp    -0x1c(%rbp),%eax
jle    12aa <CG+0x16a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1558 <CG+0x418>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
xor    %ecx,%ecx
sub    -0x1c(%rbp),%ecx
add    -0x14(%rbp),%ecx
sub    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    12d5 <CG+0x195>
xor    %eax,%eax
sub    -0x1c(%rbp),%eax
add    -0x14(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
xor    %ecx,%ecx
sub    -0x1c(%rbp),%ecx
add    -0xc(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    12f9 <CG+0x1b9>
xor    %eax,%eax
sub    -0x1c(%rbp),%eax
add    -0xc(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0xc(%rbp),%eax
add    -0x14(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jle    131f <CG+0x1df>
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jle    1339 <CG+0x1f9>
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jle    1352 <CG+0x212>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1558 <CG+0x418>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
movsd  0xc93(%rip),%xmm0
movsd  0xc93(%rip),%xmm1
movsd  %xmm1,-0x330(%rbp)
ff
cmp    $0x0,%edx
movsd  %xmm0,-0x328(%rbp)
ff
je     139e <CG+0x25e>
movsd  -0x330(%rbp),%xmm0
ff
movsd  %xmm0,-0x328(%rbp)
ff
movsd  -0x328(%rbp),%xmm0
ff
movsd  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1479 <CG+0x339>
movsd  -0x38(%rbp),%xmm0
movslq -0x2c(%rbp),%rax
movsd  -0x320(%rbp,%rax,8),%xmm1
ff ff
mov    -0xc(%rbp),%eax
add    -0x14(%rbp),%eax
sub    -0x1c(%rbp),%eax
sub    -0x2c(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm1
ff ff
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
sub    -0x2c(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm1
ff ff
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
sub    -0x2c(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm1
ff ff
mov    -0x1c(%rbp),%eax
sub    -0x14(%rbp),%eax
add    -0x10(%rbp),%eax
add    -0x2c(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm1
ff ff
mov    -0x1c(%rbp),%eax
sub    -0xc(%rbp),%eax
sub    -0x18(%rbp),%eax
add    -0x2c(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm1
ff ff
divsd  %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13b1 <CG+0x271>
mov    -0x1c(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0xc(%rbp),%eax
add    -0x14(%rbp),%eax
sub    -0x1c(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm0
ff ff
mov    -0x1c(%rbp),%eax
add    -0xc(%rbp),%eax
sub    -0x14(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm0
ff ff
mov    -0x1c(%rbp),%eax
add    -0x14(%rbp),%eax
sub    -0xc(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm0
ff ff
mov    -0xc(%rbp),%eax
add    -0x10(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm0
ff ff
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm0
ff ff
mov    -0x14(%rbp),%eax
add    -0x18(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm0
ff ff
mov    -0x14(%rbp),%eax
sub    -0x18(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm0
ff ff
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm0
ff ff
mov    -0x1c(%rbp),%eax
sub    -0x20(%rbp),%eax
cltq
mulsd  -0x320(%rbp,%rax,8),%xmm0
ff ff
mov    -0x1c(%rbp),%eax
add    -0xc(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
divsd  -0x320(%rbp,%rax,8),%xmm0
ff ff
call   1060 <sqrt@plt>
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x330,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CG>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x308,%rsp
cmp    $0x1e,%edi
jg     1414 <CG+0x2e4>
cmp    $0x1e,%edx
jg     1414 <CG+0x2e4>
cmp    $0x1f,%r8d
jge    1414 <CG+0x2e4>
movaps 0xe9c(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
mov    $0x2,%eax
movsd  0xeba(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rsp,%rax,8)
lea    0x1(%rax),%ebp
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x38(%rsp,%rax,8)
lea    0x2(%rax),%ebp
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rsp,%rax,8)
lea    0x3(%rax),%ebp
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x48(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x5a,%rax
jne    1180 <CG+0x50>
lea    (%rcx,%rsi,1),%eax
xorpd  %xmm4,%xmm4
cmp    %r9d,%eax
jne    1201 <CG+0xd1>
lea    (%rdx,%rdi,1),%r13d
sub    %r8d,%r13d
jl     1201 <CG+0xd1>
lea    (%r8,%rdx,1),%r15d
sub    %edi,%r15d
jl     1201 <CG+0xd1>
lea    (%r8,%rdi,1),%r14d
mov    %r14d,%r12d
sub    %edx,%r12d
jge    1217 <CG+0xe7>
movapd %xmm4,%xmm0
add    $0x308,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %esi,%eax
neg    %eax
cmovs  %esi,%eax
mov    %ecx,%ebp
neg    %ebp
cmovs  %ecx,%ebp
mov    %r9d,%ebx
neg    %ebx
cmovs  %r9d,%ebx
cmp    %edi,%eax
jg     1201 <CG+0xd1>
cmp    %edx,%ebp
jg     1201 <CG+0xd1>
cmp    %r8d,%ebx
jg     1201 <CG+0xd1>
lea    (%rsi,%r8,1),%eax
xor    %ebp,%ebp
mov    %edx,%ebx
mov    %rax,0x8(%rsp)
sub    %eax,%ebx
cmovs  %ebp,%ebx
mov    %edi,%r10d
sub    %r8d,%r10d
add    %ecx,%r10d
cmp    %r10d,%ebx
cmovge %ebx,%r10d
mov    %edi,%eax
sub    %esi,%eax
cmp    %eax,%r13d
mov    %r13d,%r11d
cmovg  %eax,%r11d
lea    (%rcx,%rdx,1),%ebp
cmp    %ebp,%r11d
cmovg  %ebp,%r11d
cmp    %r11d,%r10d
jg     1201 <CG+0xd1>
mov    %r12d,0x18(%rsp)
mov    %r15d,0x1c(%rsp)
mov    %r14,0x28(%rsp)
xor    %r14d,%r14d
test   $0x1,%r10b
sete   %r14b
lea    0xd75(%rip),%rbx
movsd  (%rbx,%r14,8),%xmm0
mov    %r8d,%r14d
sub    %ecx,%r14d
sub    %edi,%r14d
mov    %r10d,%ebx
movslq %ebp,%r12
movslq %r14d,%r14
add    $0x1,%r11d
mov    0x8(%rsp),%rbp
sub    %edx,%ebp
mov    %rbp,0x8(%rsp)
mov    %r13d,%ebp
sub    %r10d,%ebp
mov    %eax,0x14(%rsp)
mov    %eax,%r15d
sub    %r10d,%r15d
lea    (%rsp,%r14,8),%r14
add    $0x30,%r14
mov    %r12,%rax
mov    %r12,0x20(%rsp)
sub    %rbx,%rax
lea    (%rsp,%rax,8),%r10
add    $0x30,%r10
mov    %rbx,%r12
sub    %r11,%r12
xorpd  %xmm4,%xmm4
xor    %r11d,%r11d
movapd 0xd1d(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x30(%rsp,%rbx,8),%xmm2
lea    (%r11,%rbp,1),%eax
cltq
mulsd  0x30(%rsp,%rax,8),%xmm2
lea    (%r15,%r11,1),%eax
cltq
mulsd  0x30(%rsp,%rax,8),%xmm2
mulsd  (%r10,%r11,8),%xmm2
mov    0x8(%rsp),%rax
add    %ebx,%eax
cltq
mulsd  0x30(%rsp,%rax,8),%xmm2
mulsd  (%r14,%rbx,8),%xmm2
movapd %xmm0,%xmm3
divsd  %xmm2,%xmm3
addsd  %xmm3,%xmm4
xorpd  %xmm1,%xmm0
add    $0x1,%rbx
add    $0xffffffffffffffff,%r11
cmp    %r11,%r12
jne    1310 <CG+0x1e0>
lea    (%r8,%r8,1),%eax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movslq %r13d,%rax
mulsd  0x30(%rsp,%rax,8),%xmm0
movslq 0x18(%rsp),%rax
mulsd  0x30(%rsp,%rax,8),%xmm0
movslq 0x1c(%rsp),%rax
mulsd  0x30(%rsp,%rax,8),%xmm0
add    %edi,%esi
movslq %esi,%rax
mulsd  0x30(%rsp,%rax,8),%xmm0
movslq 0x14(%rsp),%rax
mulsd  0x30(%rsp,%rax,8),%xmm0
mov    0x20(%rsp),%rax
mulsd  0x30(%rsp,%rax,8),%xmm0
mov    %edx,%eax
sub    %ecx,%eax
cltq
mulsd  0x30(%rsp,%rax,8),%xmm0
lea    (%r9,%r8,1),%eax
cltq
mulsd  0x30(%rsp,%rax,8),%xmm0
sub    %r9d,%r8d
movslq %r8d,%rax
mulsd  0x30(%rsp,%rax,8),%xmm0
mov    0x28(%rsp),%rax
add    %edx,%eax
add    $0x1,%eax
cltq
divsd  0x30(%rsp,%rax,8),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     13fa <CG+0x2ca>
sqrtsd %xmm0,%xmm0
jmp    140b <CG+0x2db>
movsd  %xmm4,0x8(%rsp)
call   1050 <sqrt@plt>
movsd  0x8(%rsp),%xmm4
mulsd  %xmm0,%xmm4
jmp    1201 <CG+0xd1>
mov    0x2bc5(%rip),%rax
mov    (%rax),%edi
lea    0xc14(%rip),%rsi
lea    0xc28(%rip),%rdx
mov    $0x25c,%ecx
call   1040 <fprintf@plt>
xor    %eax,%eax
call   1030 <abort@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [27 x i8] c"*** out of bound (%s, %d)\0A\00"
@.str.1 = [165 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/RafaelDexter/OpenMX/refs/heads/master/source/liberi-091216/source/eri_sf.c\00"
define double @CG(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca double
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca double
%18 = alloca double
%19 = alloca i32
%20 = alloca [90 x double]
store i32 %0, i32* %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store i32 90, i32* %19
%21 = load i32, i32* %8
%22 = icmp sgt i32 %21, 30
br i1 %22, label %29, label %23
23: ; preds = %6
%24 = load i32, i32* %10
%25 = icmp sgt i32 %24, 30
br i1 %25, label %29, label %26
26: ; preds = %23
%27 = load i32, i32* %12
%28 = icmp sgt i32 %27, 30
br i1 %28, label %29, label %33
29: ; preds = %26, %23, %6
%30 = load i32, i32* @stderr
%31 = call i32 @fprintf(i32 %30, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.1, i64 0, i64 0), i32 604)
%32 = call i32 (...) @abort()
unreachable
33: ; preds = %26
%34 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 1
store double 1.000000e+00, double* %34
%35 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 0
store double 1.000000e+00, double* %35
store i32 2, i32* %16
br label %36
36: ; preds = %51, %33
%37 = load i32, i32* %16
%38 = icmp slt i32 %37, 90
br i1 %38, label %39, label %54
39: ; preds = %36
%40 = load i32, i32* %16
%41 = sub nsw i32 %40, 1
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %42
%44 = load double, double* %43
%45 = load i32, i32* %16
%46 = sitofp i32 %45 to double
%47 = fmul double %44, %46
%48 = load i32, i32* %16
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %49
store double %47, double* %50
br label %51
51: ; preds = %39
%52 = load i32, i32* %16
%53 = add nsw i32 %52, 1
store i32 %53, i32* %16
br label %36
54: ; preds = %36
%55 = load i32, i32* %13
%56 = load i32, i32* %9
%57 = load i32, i32* %11
%58 = add nsw i32 %56, %57
%59 = icmp ne i32 %55, %58
br i1 %59, label %60, label %61
60: ; preds = %54
store double 0.000000e+00, double* %7
br label %322
61: ; preds = %54
%62 = load i32, i32* %8
%63 = load i32, i32* %10
%64 = add nsw i32 %62, %63
%65 = load i32, i32* %12
%66 = icmp slt i32 %64, %65
br i1 %66, label %79, label %67
67: ; preds = %61
%68 = load i32, i32* %10
%69 = load i32, i32* %12
%70 = add nsw i32 %68, %69
%71 = load i32, i32* %8
%72 = icmp slt i32 %70, %71
br i1 %72, label %79, label %73
73: ; preds = %67
%74 = load i32, i32* %12
%75 = load i32, i32* %8
%76 = add nsw i32 %74, %75
%77 = load i32, i32* %10
%78 = icmp slt i32 %76, %77
br i1 %78, label %79, label %80
79: ; preds = %73, %67, %61
store double 0.000000e+00, double* %7
br label %322
80: ; preds = %73
%81 = load i32, i32* %9
%82 = call i32 @abs(i32 %81)
%83 = load i32, i32* %8
%84 = icmp sgt i32 %82, %83
br i1 %84, label %95, label %85
85: ; preds = %80
%86 = load i32, i32* %11
%87 = call i32 @abs(i32 %86)
%88 = load i32, i32* %10
%89 = icmp sgt i32 %87, %88
br i1 %89, label %95, label %90
90: ; preds = %85
%91 = load i32, i32* %13
%92 = call i32 @abs(i32 %91)
%93 = load i32, i32* %12
%94 = icmp sgt i32 %92, %93
br i1 %94, label %95, label %96
95: ; preds = %90, %85, %80
store double 0.000000e+00, double* %7
br label %322
96: ; preds = %90
store i32 0, i32* %14
%97 = load i32, i32* %14
%98 = load i32, i32* %12
%99 = sub nsw i32 0, %98
%100 = load i32, i32* %10
%101 = add nsw i32 %99, %100
%102 = load i32, i32* %9
%103 = sub nsw i32 %101, %102
%104 = icmp slt i32 %97, %103
br i1 %104, label %105, label %112
105: ; preds = %96
%106 = load i32, i32* %12
%107 = sub nsw i32 0, %106
%108 = load i32, i32* %10
%109 = add nsw i32 %107, %108
%110 = load i32, i32* %9
%111 = sub nsw i32 %109, %110
store i32 %111, i32* %14
br label %112
112: ; preds = %105, %96
%113 = load i32, i32* %14
%114 = load i32, i32* %12
%115 = sub nsw i32 0, %114
%116 = load i32, i32* %8
%117 = add nsw i32 %115, %116
%118 = load i32, i32* %11
%119 = add nsw i32 %117, %118
%120 = icmp slt i32 %113, %119
br i1 %120, label %121, label %128
121: ; preds = %112
%122 = load i32, i32* %12
%123 = sub nsw i32 0, %122
%124 = load i32, i32* %8
%125 = add nsw i32 %123, %124
%126 = load i32, i32* %11
%127 = add nsw i32 %125, %126
store i32 %127, i32* %14
br label %128
128: ; preds = %121, %112
%129 = load i32, i32* %8
%130 = load i32, i32* %10
%131 = add nsw i32 %129, %130
%132 = load i32, i32* %12
%133 = sub nsw i32 %131, %132
store i32 %133, i32* %15
%134 = load i32, i32* %15
%135 = load i32, i32* %8
%136 = load i32, i32* %9
%137 = sub nsw i32 %135, %136
%138 = icmp sgt i32 %134, %137
br i1 %138, label %139, label %143
139: ; preds = %128
%140 = load i32, i32* %8
%141 = load i32, i32* %9
%142 = sub nsw i32 %140, %141
store i32 %142, i32* %15
br label %143
143: ; preds = %139, %128
%144 = load i32, i32* %15
%145 = load i32, i32* %10
%146 = load i32, i32* %11
%147 = add nsw i32 %145, %146
%148 = icmp sgt i32 %144, %147
br i1 %148, label %149, label %153
149: ; preds = %143
%150 = load i32, i32* %10
%151 = load i32, i32* %11
%152 = add nsw i32 %150, %151
store i32 %152, i32* %15
br label %153
153: ; preds = %149, %143
%154 = load i32, i32* %14
%155 = load i32, i32* %15
%156 = icmp sgt i32 %154, %155
br i1 %156, label %157, label %158
157: ; preds = %153
store double 0.000000e+00, double* %7
br label %322
158: ; preds = %153
store double 0.000000e+00, double* %18
%159 = load i32, i32* %14
%160 = srem i32 %159, 2
%161 = icmp eq i32 %160, 0
%162 = zext i1 %161 to i64
%163 = select i1 %161, double 1.000000e+00, double -1.000000e+00
store double %163, double* %17
%164 = load i32, i32* %14
store i32 %164, i32* %16
br label %165
165: ; preds = %231, %158
%166 = load i32, i32* %16
%167 = load i32, i32* %15
%168 = icmp sle i32 %166, %167
br i1 %168, label %169, label %234
169: ; preds = %165
%170 = load double, double* %17
%171 = load i32, i32* %16
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %172
%174 = load double, double* %173
%175 = load i32, i32* %8
%176 = load i32, i32* %10
%177 = add nsw i32 %175, %176
%178 = load i32, i32* %12
%179 = sub nsw i32 %177, %178
%180 = load i32, i32* %16
%181 = sub nsw i32 %179, %180
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %182
%184 = load double, double* %183
%185 = fmul double %174, %184
%186 = load i32, i32* %8
%187 = load i32, i32* %9
%188 = sub nsw i32 %186, %187
%189 = load i32, i32* %16
%190 = sub nsw i32 %188, %189
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %191
%193 = load double, double* %192
%194 = fmul double %185, %193
%195 = load i32, i32* %10
%196 = load i32, i32* %11
%197 = add nsw i32 %195, %196
%198 = load i32, i32* %16
%199 = sub nsw i32 %197, %198
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %200
%202 = load double, double* %201
%203 = fmul double %194, %202
%204 = load i32, i32* %12
%205 = load i32, i32* %10
%206 = sub nsw i32 %204, %205
%207 = load i32, i32* %9
%208 = add nsw i32 %206, %207
%209 = load i32, i32* %16
%210 = add nsw i32 %208, %209
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %211
%213 = load double, double* %212
%214 = fmul double %203, %213
%215 = load i32, i32* %12
%216 = load i32, i32* %8
%217 = sub nsw i32 %215, %216
%218 = load i32, i32* %11
%219 = sub nsw i32 %217, %218
%220 = load i32, i32* %16
%221 = add nsw i32 %219, %220
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %222
%224 = load double, double* %223
%225 = fmul double %214, %224
%226 = fdiv double %170, %225
%227 = load double, double* %18
%228 = fadd double %227, %226
store double %228, double* %18
%229 = load double, double* %17
%230 = fneg double %229
store double %230, double* %17
br label %231
231: ; preds = %169
%232 = load i32, i32* %16
%233 = add nsw i32 %232, 1
store i32 %233, i32* %16
br label %165
234: ; preds = %165
%235 = load i32, i32* %12
%236 = mul nsw i32 2, %235
%237 = add nsw i32 %236, 1
%238 = sitofp i32 %237 to double
%239 = load i32, i32* %8
%240 = load i32, i32* %10
%241 = add nsw i32 %239, %240
%242 = load i32, i32* %12
%243 = sub nsw i32 %241, %242
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %244
%246 = load double, double* %245
%247 = fmul double %238, %246
%248 = load i32, i32* %12
%249 = load i32, i32* %8
%250 = add nsw i32 %248, %249
%251 = load i32, i32* %10
%252 = sub nsw i32 %250, %251
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %253
%255 = load double, double* %254
%256 = fmul double %247, %255
%257 = load i32, i32* %12
%258 = load i32, i32* %10
%259 = add nsw i32 %257, %258
%260 = load i32, i32* %8
%261 = sub nsw i32 %259, %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %262
%264 = load double, double* %263
%265 = fmul double %256, %264
%266 = load i32, i32* %8
%267 = load i32, i32* %9
%268 = add nsw i32 %266, %267
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %269
%271 = load double, double* %270
%272 = fmul double %265, %271
%273 = load i32, i32* %8
%274 = load i32, i32* %9
%275 = sub nsw i32 %273, %274
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %276
%278 = load double, double* %277
%279 = fmul double %272, %278
%280 = load i32, i32* %10
%281 = load i32, i32* %11
%282 = add nsw i32 %280, %281
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %283
%285 = load double, double* %284
%286 = fmul double %279, %285
%287 = load i32, i32* %10
%288 = load i32, i32* %11
%289 = sub nsw i32 %287, %288
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %290
%292 = load double, double* %291
%293 = fmul double %286, %292
%294 = load i32, i32* %12
%295 = load i32, i32* %13
%296 = add nsw i32 %294, %295
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %297
%299 = load double, double* %298
%300 = fmul double %293, %299
%301 = load i32, i32* %12
%302 = load i32, i32* %13
%303 = sub nsw i32 %301, %302
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %304
%306 = load double, double* %305
%307 = fmul double %300, %306
%308 = load i32, i32* %12
%309 = load i32, i32* %8
%310 = add nsw i32 %308, %309
%311 = load i32, i32* %10
%312 = add nsw i32 %310, %311
%313 = add nsw i32 %312, 1
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds [90 x double], [90 x double]* %20, i64 0, i64 %314
%316 = load double, double* %315
%317 = fdiv double %307, %316
%318 = call double @sqrt(double %317)
%319 = load double, double* %18
%320 = fmul double %319, %318
store double %320, double* %18
%321 = load double, double* %18
store double %321, double* %7
br label %322
322: ; preds = %234, %157, %95, %79, %60
%323 = load double, double* %7
ret double %323
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [27 x i8] c"*** out of bound (%s, %d)\0A\00"
@.str.1 = [165 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/RafaelDexter/OpenMX/refs/heads/master/source/liberi-091216/source/eri_sf.c\00"
define double @CG(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca [90 x double]
%8 = bitcast [90 x double]* %7 to i8*
%9 = icmp sgt i32 %0, 30
%10 = icmp sgt i32 %2, 30
%11 = or i1 %9, %10
%12 = icmp sgt i32 %4, 30
%13 = or i1 %11, %12
br i1 %13, label %14, label %18
14: ; preds = %6
%15 = load i32, i32* @stderr
%16 = tail call i32 @fprintf(i32 %15, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([165 x i8], [165 x i8]* @.str.1, i64 0, i64 0), i32 604)
%17 = tail call i32 (...) @abort()
unreachable
18: ; preds = %6
%19 = bitcast [90 x double]* %7 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %19
br label %20
20: ; preds = %20, %18
%21 = phi double [ 1.000000e+00, %18 ], [ %40, %20 ]
%22 = phi i64 [ 2, %18 ], [ %42, %20 ]
%23 = trunc i64 %22 to i32
%24 = sitofp i32 %23 to double
%25 = fmul double %21, %24
%26 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %22
store double %25, double* %26
%27 = or i64 %22, 1
%28 = trunc i64 %27 to i32
%29 = sitofp i32 %28 to double
%30 = fmul double %25, %29
%31 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %27
store double %30, double* %31
%32 = add nuw nsw i64 %22, 2
%33 = trunc i64 %32 to i32
%34 = sitofp i32 %33 to double
%35 = fmul double %30, %34
%36 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %32
store double %35, double* %36
%37 = add nuw nsw i64 %22, 3
%38 = trunc i64 %37 to i32
%39 = sitofp i32 %38 to double
%40 = fmul double %35, %39
%41 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %37
store double %40, double* %41
%42 = add nuw nsw i64 %22, 4
%43 = icmp eq i64 %42, 90
br i1 %43, label %44, label %20
44: ; preds = %20
%45 = add nsw i32 %3, %1
%46 = icmp eq i32 %45, %5
br i1 %46, label %47, label %183
47: ; preds = %44
%48 = add nsw i32 %2, %0
%49 = icmp slt i32 %48, %4
br i1 %49, label %183, label %50
50: ; preds = %47
%51 = add nsw i32 %4, %2
%52 = icmp slt i32 %51, %0
br i1 %52, label %183, label %53
53: ; preds = %50
%54 = add nsw i32 %4, %0
%55 = icmp slt i32 %54, %2
br i1 %55, label %183, label %56
56: ; preds = %53
%57 = tail call i32 @llvm.abs.i32(i32 %1, i1 true)
%58 = icmp sgt i32 %57, %0
%59 = tail call i32 @llvm.abs.i32(i32 %3, i1 true)
%60 = icmp sgt i32 %59, %2
%61 = select i1 %58, i1 true, i1 %60
%62 = tail call i32 @llvm.abs.i32(i32 %5, i1 true)
%63 = icmp sgt i32 %62, %4
%64 = select i1 %61, i1 true, i1 %63
br i1 %64, label %183, label %65
65: ; preds = %56
%66 = add i32 %1, %4
%67 = sub i32 %2, %66
%68 = icmp sgt i32 %67, 0
%69 = select i1 %68, i32 %67, i32 0
%70 = sub i32 %0, %4
%71 = add nsw i32 %70, %3
%72 = icmp slt i32 %69, %71
%73 = select i1 %72, i32 %71, i32 %69
%74 = sub nsw i32 %48, %4
%75 = sub nsw i32 %0, %1
%76 = icmp sgt i32 %74, %75
%77 = select i1 %76, i32 %75, i32 %74
%78 = add nsw i32 %3, %2
%79 = icmp sgt i32 %77, %78
%80 = select i1 %79, i32 %78, i32 %77
%81 = icmp sgt i32 %73, %80
br i1 %81, label %183, label %82
82: ; preds = %65
%83 = and i32 %73, 1
%84 = icmp eq i32 %83, 0
%85 = select i1 %84, double 1.000000e+00, double -1.000000e+00
%86 = sub i32 %1, %2
%87 = add i32 %86, %4
%88 = add i32 %3, %0
%89 = sub i32 %4, %88
%90 = zext i32 %73 to i64
%91 = sext i32 %78 to i64
%92 = sext i32 %89 to i64
%93 = add i32 %80, 1
%94 = zext i32 %93 to i64
br label %95
95: ; preds = %82, %95
%96 = phi i64 [ %90, %82 ], [ %128, %95 ]
%97 = phi double [ 0.000000e+00, %82 ], [ %126, %95 ]
%98 = phi double [ %85, %82 ], [ %127, %95 ]
%99 = trunc i64 %96 to i32
%100 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %96
%101 = load double, double* %100
%102 = sub nsw i32 %74, %99
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %103
%105 = load double, double* %104
%106 = fmul double %101, %105
%107 = sub nsw i32 %75, %99
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %108
%110 = load double, double* %109
%111 = fmul double %106, %110
%112 = sub nsw i64 %91, %96
%113 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %112
%114 = load double, double* %113
%115 = fmul double %111, %114
%116 = add i32 %87, %99
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %117
%119 = load double, double* %118
%120 = fmul double %115, %119
%121 = add nsw i64 %96, %92
%122 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %121
%123 = load double, double* %122
%124 = fmul double %120, %123
%125 = fdiv double %98, %124
%126 = fadd double %97, %125
%127 = fneg double %98
%128 = add nuw nsw i64 %96, 1
%129 = icmp eq i64 %128, %94
br i1 %129, label %130, label %95
130: ; preds = %95
%131 = shl nsw i32 %4, 1
%132 = or i32 %131, 1
%133 = sitofp i32 %132 to double
%134 = sext i32 %74 to i64
%135 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %134
%136 = load double, double* %135
%137 = fmul double %136, %133
%138 = sub nsw i32 %54, %2
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %139
%141 = load double, double* %140
%142 = fmul double %137, %141
%143 = sub nsw i32 %51, %0
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %144
%146 = load double, double* %145
%147 = fmul double %142, %146
%148 = add nsw i32 %1, %0
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %149
%151 = load double, double* %150
%152 = fmul double %147, %151
%153 = sext i32 %75 to i64
%154 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %153
%155 = load double, double* %154
%156 = fmul double %152, %155
%157 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %91
%158 = load double, double* %157
%159 = fmul double %156, %158
%160 = sub nsw i32 %2, %3
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %161
%163 = load double, double* %162
%164 = fmul double %159, %163
%165 = add nsw i32 %5, %4
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %166
%168 = load double, double* %167
%169 = fmul double %164, %168
%170 = sub nsw i32 %4, %5
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %171
%173 = load double, double* %172
%174 = fmul double %169, %173
%175 = add i32 %2, 1
%176 = add i32 %175, %54
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds [90 x double], [90 x double]* %7, i64 0, i64 %177
%179 = load double, double* %178
%180 = fdiv double %174, %179
%181 = tail call double @sqrt(double %180)
%182 = fmul double %126, %181
br label %183
183: ; preds = %65, %56, %47, %50, %53, %44, %130
%184 = phi double [ %182, %130 ], [ 0.000000e+00, %44 ], [ 0.000000e+00, %53 ], [ 0.000000e+00, %50 ], [ 0.000000e+00, %47 ], [ 0.000000e+00, %56 ], [ 0.000000e+00, %65 ]
ret double %184
}