#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 abs(int);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ printf(char *, ...);
double sqrt(double);
double rad_int_lambda(int n_1, int l_1, int n_2, int l_2, int lambda) {
  register int nn_1, nn_2, sigma, low, high;
  double sum;
  static double factor[7] = {1.0,   3.16227766,   10.0,  31.62277660,
                             100.0, 316.22776602, 1000.0};
  static double fct[51] = {
      0.0,           5.60499122,    1.0,           2.80249561e-1, 1.0e-1,
      4.20374341e-2, 2.0e-2,        1.05093585e-2, 6.0e-3,        3.67827549e-3,
      2.40e-3,       1.65522397e-3, 1.20e-3,       9.10373183e-4, 7.2e-4,
      5.91742569e-4, 5.04e-4,       4.43806927e-4, 4.032e-4,      3.77235888e-4,
      3.6288e-4,     3.58374093e-4, 3.6288e-4,     3.76292798e-4, 3.99168e-4,
      4.32736718e-4, 4.790016e-4,   5.40920897e-4, 6.2270208e-4,  7.30243211e-4,
      8.71782912e-4, 1.05885266e-3, 1.30767437e-3, 1.64122162e-3, 2.09227899e-3,
      2.70801567e-3, 3.55687428e-3, 4.73902742e-3, 6.40237371e-3, 8.76720072e-3,
      1.21645100e-2, 1.70960414e-2, 2.43290201e-2, 3.50468849e-2, 5.10909422e-2,
      7.53508025e-2, 1.12400073e-1, 1.69539306e-1, 2.58520167e-1, 3.98417368e-1,
      6.20448402e-1};
  if (lambda > 6) {
    printf("\n\nError in function rad_int_lambda():");
    printf("  Not allowed lambda-value!!! lambda  = %d\n", lambda);
    exit(1);
  }
  if ((l_2 > (l_1 + lambda)) || (l_2 < abs(l_1 - lambda))) {
    printf("\n\nError in function rad_int_lambda():");
    printf(" Not allowed angular momentum relation");
    printf("\n<n_2 = %d, l_2 = %d | r**%d | n_1 = %d, l_1 = %d >\n", n_2, l_2,
           lambda, n_1, l_1);
    exit(1);
  }
  nn_1 = 2 * n_1;
  nn_2 = 2 * n_2;
  low = ((((((nn_1 - l_2 + l_1 - lambda) > (nn_2 - l_1 + l_2 - lambda))
                ? (nn_1 - l_2 + l_1 - lambda)
                : (nn_2 - l_1 + l_2 - lambda))) > (0))
             ? ((((nn_1 - l_2 + l_1 - lambda) > (nn_2 - l_1 + l_2 - lambda))
                     ? (nn_1 - l_2 + l_1 - lambda)
                     : (nn_2 - l_1 + l_2 - lambda)))
             : (0));
  high = (((nn_1) < (nn_2)) ? (nn_1) : (nn_2));
  for (sum = 0.0, sigma = low; sigma <= high; sigma += 2) {
    sum += fct[l_1 + l_2 + lambda + 3 + sigma] /
           (fct[2 + sigma] * fct[nn_1 + 2 - sigma] * fct[nn_2 + 2 - sigma] *
            fct[l_2 - l_1 + lambda + 2 - nn_1 + sigma] *
            fct[l_1 - l_2 + lambda + 2 - nn_2 + sigma]);
  }
  sum *= sqrt((fct[nn_1 + 2] * fct[nn_2 + 2]) /
              (fct[nn_1 + 3 + 2 * l_1] * fct[nn_2 + 3 + 2 * l_2])) *
         fct[l_2 - l_1 + lambda + 2] * fct[l_1 - l_2 + lambda + 2] *
         factor[lambda];
  return sum;
}


x86 assembly (clang, -O0):
<rad_int_lambda>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
cmpl   $0x6,-0x14(%rbp)
jle    118b <rad_int_lambda+0x4b>
lea    0xe97(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%esi
lea    0xeac(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   1060 <exit@plt>
mov    -0x10(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    -0x14(%rbp),%ecx
cmp    %ecx,%eax
jg     11ba <rad_int_lambda+0x7a>
mov    -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%edi
sub    -0x14(%rbp),%edi
call   1030 <abs@plt>
mov    %eax,%ecx
mov    -0x34(%rbp),%eax
cmp    %ecx,%eax
jge    11ff <rad_int_lambda+0xbf>
lea    0xe3f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe83(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
mov    -0x4(%rbp),%r8d
mov    -0x8(%rbp),%r9d
lea    0xe8b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   1060 <exit@plt>
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
sub    -0x10(%rbp),%eax
add    -0x8(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x8(%rbp),%ecx
add    -0x10(%rbp),%ecx
sub    -0x14(%rbp),%ecx
cmp    %ecx,%eax
jle    1245 <rad_int_lambda+0x105>
mov    -0x18(%rbp),%eax
sub    -0x10(%rbp),%eax
add    -0x8(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1254 <rad_int_lambda+0x114>
mov    -0x1c(%rbp),%eax
sub    -0x8(%rbp),%eax
add    -0x10(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    $0x0,%eax
jle    12ae <rad_int_lambda+0x16e>
mov    -0x18(%rbp),%eax
sub    -0x10(%rbp),%eax
add    -0x8(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x8(%rbp),%ecx
add    -0x10(%rbp),%ecx
sub    -0x14(%rbp),%ecx
cmp    %ecx,%eax
jle    1294 <rad_int_lambda+0x154>
mov    -0x18(%rbp),%eax
sub    -0x10(%rbp),%eax
add    -0x8(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    12a3 <rad_int_lambda+0x163>
mov    -0x1c(%rbp),%eax
sub    -0x8(%rbp),%eax
add    -0x10(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    12b8 <rad_int_lambda+0x178>
xor    %eax,%eax
mov    %eax,-0x40(%rbp)
jmp    12b8 <rad_int_lambda+0x178>
mov    -0x40(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12d5 <rad_int_lambda+0x195>
mov    -0x18(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    12db <rad_int_lambda+0x19b>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     13bc <rad_int_lambda+0x27c>
mov    -0x8(%rbp),%eax
add    -0x10(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x3,%eax
add    -0x20(%rbp),%eax
movslq %eax,%rcx
lea    0x2d7c(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    0x2d67(%rip),%rax
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%eax
add    $0x2,%eax
sub    -0x20(%rbp),%eax
movslq %eax,%rcx
lea    0x2d4f(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
sub    -0x20(%rbp),%eax
movslq %eax,%rcx
lea    0x2d37(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%eax
sub    -0x8(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x2,%eax
sub    -0x18(%rbp),%eax
add    -0x20(%rbp),%eax
movslq %eax,%rcx
lea    0x2d16(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%eax
sub    -0x10(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x2,%eax
sub    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
movslq %eax,%rcx
lea    0x2cf5(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    12ef <rad_int_lambda+0x1af>
mov    -0x18(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    0x2cc4(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    0x2caf(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%eax
add    $0x3,%eax
mov    -0x8(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
movslq %eax,%rcx
lea    0x2c92(%rip),%rax
movsd  (%rax,%rcx,8),%xmm1
mov    -0x1c(%rbp),%eax
add    $0x3,%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
movslq %eax,%rcx
lea    0x2c75(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
mov    -0x10(%rbp),%eax
sub    -0x8(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    0x2c51(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%eax
sub    -0x10(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    0x2c36(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm0
movslq -0x14(%rbp),%rcx
lea    0x2be6(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rad_int_lambda>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8d,%r12d
cmp    $0x7,%r8d
jge    1390 <rad_int_lambda+0x260>
mov    %ecx,%ebp
mov    %edx,%r13d
mov    %edi,%r15d
lea    (%r12,%rsi,1),%r10d
cmp    %ecx,%r10d
jl     134b <rad_int_lambda+0x21b>
mov    %esi,%eax
sub    %r12d,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
cmp    %ebp,%ecx
jg     134b <rad_int_lambda+0x21b>
mov    %r15d,%eax
add    %r15d,%r15d
lea    (%rsi,%rax,2),%eax
lea    (%r12,%rbp,1),%ebx
sub    %ebx,%eax
mov    %r13d,%ecx
add    %r13d,%r13d
lea    0x0(%rbp,%rcx,2),%ecx
sub    %r10d,%ecx
cmp    %ecx,%eax
cmovg  %eax,%ecx
xor    %eax,%eax
test   %ecx,%ecx
cmovns %ecx,%eax
cmp    %r13d,%r15d
mov    %r13d,%ecx
cmovl  %r15d,%ecx
cmp    %ecx,%eax
jle    11cb <rad_int_lambda+0x9b>
lea    0x2(%r15),%ecx
lea    0x2(%r13),%edx
lea    0x2(%r12),%r14d
lea    (%r12,%rsi,1),%eax
add    $0x2,%eax
mov    %eax,0x4(%rsp)
xorpd  %xmm2,%xmm2
jmp    12b0 <rad_int_lambda+0x180>
lea    0x2(%r15),%r8d
lea    0x2(%r13),%edi
lea    0x2(%r12),%r14d
mov    %r12,0x8(%rsp)
lea    (%r12,%rsi,1),%edx
add    $0x2,%edx
mov    %edx,0x4(%rsp)
mov    %eax,%r12d
movslq %ecx,%r11
add    %eax,%r10d
mov    %rbp,0x20(%rsp)
sub    %ebp,%r10d
sub    %r13d,%r10d
add    $0x2,%r10d
lea    (%rbx,%rax,1),%ecx
sub    %esi,%ecx
sub    %r15d,%ecx
add    $0x2,%ecx
mov    %edi,0x10(%rsp)
mov    %edi,%edx
sub    %eax,%edx
mov    %r8d,0x14(%rsp)
mov    %r8d,%ebp
sub    %eax,%ebp
mov    %rsi,0x18(%rsp)
add    %esi,%ebx
add    %eax,%ebx
add    $0x3,%ebx
lea    0xe10(%rip),%rax
lea    (%rax,%r12,8),%rdi
add    $0x10,%rdi
xorpd  %xmm2,%xmm2
xor    %r8d,%r8d
nop
movsd  (%rdi,%r8,8),%xmm0
movslq %ebp,%rbp
mulsd  (%rax,%rbp,8),%xmm0
movslq %edx,%rdx
mulsd  (%rax,%rdx,8),%xmm0
lea    (%rcx,%r8,1),%r9d
movslq %r9d,%rsi
mulsd  (%rax,%rsi,8),%xmm0
lea    (%r10,%r8,1),%esi
movslq %esi,%rsi
mulsd  (%rax,%rsi,8),%xmm0
lea    (%rbx,%r8,1),%esi
movslq %esi,%rsi
movsd  (%rax,%rsi,8),%xmm1
divsd  %xmm0,%xmm1
addsd  %xmm1,%xmm2
add    $0xfffffffe,%edx
add    $0xfffffffe,%ebp
lea    (%r12,%r8,1),%rsi
add    $0x2,%rsi
add    $0x2,%r8
cmp    %r11,%rsi
jle    1240 <rad_int_lambda+0x110>
mov    0x8(%rsp),%r12
mov    0x20(%rsp),%rbp
mov    0x18(%rsp),%rsi
mov    0x14(%rsp),%ecx
mov    0x10(%rsp),%edx
movslq %ecx,%rax
lea    0xd86(%rip),%rbx
movsd  (%rbx,%rax,8),%xmm0
movslq %edx,%rax
mulsd  (%rbx,%rax,8),%xmm0
lea    0x3(%r15,%rsi,2),%eax
cltq
movsd  (%rbx,%rax,8),%xmm1
lea    0x3(%r13,%rbp,2),%eax
cltq
mulsd  (%rbx,%rax,8),%xmm1
divsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     12f3 <rad_int_lambda+0x1c3>
sqrtsd %xmm0,%xmm0
jmp    130a <rad_int_lambda+0x1da>
mov    %rsi,%r15
movsd  %xmm2,0x8(%rsp)
call   1040 <sqrt@plt>
movsd  0x8(%rsp),%xmm2
mov    %r15,%rsi
sub    %esi,%r14d
add    %ebp,%r14d
movslq %r14d,%rax
mulsd  (%rbx,%rax,8),%xmm0
mov    0x4(%rsp),%eax
sub    %ebp,%eax
cltq
mulsd  (%rbx,%rax,8),%xmm0
movslq %r12d,%rax
lea    0xcd1(%rip),%rcx
mulsd  (%rcx,%rax,8),%xmm0
mulsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xe86(%rip),%rdi
xor    %eax,%eax
mov    %rsi,%rbx
call   1030 <printf@plt>
lea    0xec7(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
lea    0xee0(%rip),%rdi
mov    %r13d,%esi
mov    %ebp,%edx
mov    %r12d,%ecx
mov    %r15d,%r8d
mov    %ebx,%r9d
xor    %eax,%eax
call   1030 <printf@plt>
mov    $0x1,%edi
call   1050 <exit@plt>
lea    0xe41(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
lea    0xe59(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1030 <printf@plt>
mov    $0x1,%edi
call   1050 <exit@plt>

LLVM IR (-O0):
@rad_int_lambda.factor = internal global [7 x double] [double 1.000000e+00, double 0x40094C583AD4923E, double 1.000000e+01, double 0x403F9F6E4989B6CE, double 1.000000e+02, double 0x4073C3A4EDFB70A4, double 1.000000e+03]
@rad_int_lambda.fct = internal global [51 x double] [double 0.000000e+00, double 0x40166B82D181118D, double 1.000000e+00, double 0x3FD1EF9BDACDA7A4, double 1.000000e-01, double 0x3FA585EE3955A279, double 2.000000e-02, double 0x3F8585EE3879BB7A, double 6.000000e-03, double 0x3F6E21E71DED640F, double 2.400000e-03, double 0x3F5B1E833465AADA, double 1.200000e-03, double 0x3F4DD4C386297724, double 7.200000e-04, double 0x3F4363E57DA1FD48, double 5.040000e-04, double 0x3F3D15D83CB95A52, double 4.032000e-04, double 0x3F38B8F7CD453940, double 3.628800e-04, double 0x3F377C850258E0A2, double 3.628800e-04, double 0x3F38A92542D97005, double 3.991680e-04, double 0x3F3C5C1E0D34E54D, double 0x3F3F645034EC5DF1, double 0x3F41B992C7FAB0EA, double 0x3F44679A88CCD6AA, double 0x3F47EDB95ACCAB7A, double 0x3F4C910B8C51F954, double 0x3F51592662F16109, double 0x3F556CC8A9CA37CB, double 0x3F5AE3C84BBCA19B, double 0x3F6123D3BAC1CE3C, double 0x3F662F1ED7ABAAEE, double 0x3F6D234E56ACB767, double 0x3F73693AFC8A3A90, double 0x3F7A39601B3832A9, double 0x3F81F489C2F57D2C, double 0x3F88E9B4E4F99456, double 0x3F91819FEAD0F5A5, double 0x3F98E9B4E6B16254, double 0x3FA1F1AA50F1C115, double 0x3FAA28978BBDDCF2, double 0x3FB34A30B07700BD, double 0x3FBCC6404D9A5F09, double 0x3FC5B376C7540964, double 0x3FD08B982BA7C5FA, double 0x3FD97FAB8F6DFA37, double 0x3FE3DAB69B6E4137]
@.str = [38 x i8] c"\0A\0AError in function rad_int_lambda():\00"
@.str.1 = [44 x i8] c" Not allowed lambda-value!!! lambda = %d\0A\00"
@.str.2 = [39 x i8] c" Not allowed angular momentum relation\00"
@.str.3 = [53 x i8] c"\0A<n_2 = %d, l_2 = %d | r**%d | n_1 = %d, l_1 = %d >\0A\00"
define double @rad_int_lambda(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i32
%7 = alloca i32
%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 double
store i32 %0, i32* %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
%17 = load i32, i32* %10
%18 = icmp sgt i32 %17, 6
br i1 %18, label %19, label %24
19: ; preds = %5
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0))
%21 = load i32, i32* %10
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.1, i64 0, i64 0), i32 %21)
%23 = call i32 @exit(i32 1)
unreachable
24: ; preds = %5
%25 = load i32, i32* %9
%26 = load i32, i32* %7
%27 = load i32, i32* %10
%28 = add nsw i32 %26, %27
%29 = icmp sgt i32 %25, %28
br i1 %29, label %37, label %30
30: ; preds = %24
%31 = load i32, i32* %9
%32 = load i32, i32* %7
%33 = load i32, i32* %10
%34 = sub nsw i32 %32, %33
%35 = call i32 @abs(i32 %34)
%36 = icmp slt i32 %31, %35
br i1 %36, label %37, label %47
37: ; preds = %30, %24
%38 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0))
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.2, i64 0, i64 0))
%40 = load i32, i32* %8
%41 = load i32, i32* %9
%42 = load i32, i32* %10
%43 = load i32, i32* %6
%44 = load i32, i32* %7
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.3, i64 0, i64 0), i32 %40, i32 %41, i32 %42, i32 %43, i32 %44)
%46 = call i32 @exit(i32 1)
unreachable
47: ; preds = %30
%48 = load i32, i32* %6
%49 = mul nsw i32 2, %48
store i32 %49, i32* %11
%50 = load i32, i32* %8
%51 = mul nsw i32 2, %50
store i32 %51, i32* %12
%52 = load i32, i32* %11
%53 = load i32, i32* %9
%54 = sub nsw i32 %52, %53
%55 = load i32, i32* %7
%56 = add nsw i32 %54, %55
%57 = load i32, i32* %10
%58 = sub nsw i32 %56, %57
%59 = load i32, i32* %12
%60 = load i32, i32* %7
%61 = sub nsw i32 %59, %60
%62 = load i32, i32* %9
%63 = add nsw i32 %61, %62
%64 = load i32, i32* %10
%65 = sub nsw i32 %63, %64
%66 = icmp sgt i32 %58, %65
br i1 %66, label %67, label %75
67: ; preds = %47
%68 = load i32, i32* %11
%69 = load i32, i32* %9
%70 = sub nsw i32 %68, %69
%71 = load i32, i32* %7
%72 = add nsw i32 %70, %71
%73 = load i32, i32* %10
%74 = sub nsw i32 %72, %73
br label %83
75: ; preds = %47
%76 = load i32, i32* %12
%77 = load i32, i32* %7
%78 = sub nsw i32 %76, %77
%79 = load i32, i32* %9
%80 = add nsw i32 %78, %79
%81 = load i32, i32* %10
%82 = sub nsw i32 %80, %81
br label %83
83: ; preds = %75, %67
%84 = phi i32 [ %74, %67 ], [ %82, %75 ]
%85 = icmp sgt i32 %84, 0
br i1 %85, label %86, label %120
86: ; preds = %83
%87 = load i32, i32* %11
%88 = load i32, i32* %9
%89 = sub nsw i32 %87, %88
%90 = load i32, i32* %7
%91 = add nsw i32 %89, %90
%92 = load i32, i32* %10
%93 = sub nsw i32 %91, %92
%94 = load i32, i32* %12
%95 = load i32, i32* %7
%96 = sub nsw i32 %94, %95
%97 = load i32, i32* %9
%98 = add nsw i32 %96, %97
%99 = load i32, i32* %10
%100 = sub nsw i32 %98, %99
%101 = icmp sgt i32 %93, %100
br i1 %101, label %102, label %110
102: ; preds = %86
%103 = load i32, i32* %11
%104 = load i32, i32* %9
%105 = sub nsw i32 %103, %104
%106 = load i32, i32* %7
%107 = add nsw i32 %105, %106
%108 = load i32, i32* %10
%109 = sub nsw i32 %107, %108
br label %118
110: ; preds = %86
%111 = load i32, i32* %12
%112 = load i32, i32* %7
%113 = sub nsw i32 %111, %112
%114 = load i32, i32* %9
%115 = add nsw i32 %113, %114
%116 = load i32, i32* %10
%117 = sub nsw i32 %115, %116
br label %118
118: ; preds = %110, %102
%119 = phi i32 [ %109, %102 ], [ %117, %110 ]
br label %121
120: ; preds = %83
br label %121
121: ; preds = %120, %118
%122 = phi i32 [ %119, %118 ], [ 0, %120 ]
store i32 %122, i32* %14
%123 = load i32, i32* %11
%124 = load i32, i32* %12
%125 = icmp slt i32 %123, %124
br i1 %125, label %126, label %128
126: ; preds = %121
%127 = load i32, i32* %11
br label %130
128: ; preds = %121
%129 = load i32, i32* %12
br label %130
130: ; preds = %128, %126
%131 = phi i32 [ %127, %126 ], [ %129, %128 ]
store i32 %131, i32* %15
store double 0.000000e+00, double* %16
%132 = load i32, i32* %14
store i32 %132, i32* %13
br label %133
133: ; preds = %201, %130
%134 = load i32, i32* %13
%135 = load i32, i32* %15
%136 = icmp sle i32 %134, %135
br i1 %136, label %137, label %204
137: ; preds = %133
%138 = load i32, i32* %7
%139 = load i32, i32* %9
%140 = add nsw i32 %138, %139
%141 = load i32, i32* %10
%142 = add nsw i32 %140, %141
%143 = add nsw i32 %142, 3
%144 = load i32, i32* %13
%145 = add nsw i32 %143, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %146
%148 = load double, double* %147
%149 = load i32, i32* %13
%150 = add nsw i32 2, %149
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %151
%153 = load double, double* %152
%154 = load i32, i32* %11
%155 = add nsw i32 %154, 2
%156 = load i32, i32* %13
%157 = sub nsw i32 %155, %156
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %158
%160 = load double, double* %159
%161 = fmul double %153, %160
%162 = load i32, i32* %12
%163 = add nsw i32 %162, 2
%164 = load i32, i32* %13
%165 = sub nsw i32 %163, %164
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %166
%168 = load double, double* %167
%169 = fmul double %161, %168
%170 = load i32, i32* %9
%171 = load i32, i32* %7
%172 = sub nsw i32 %170, %171
%173 = load i32, i32* %10
%174 = add nsw i32 %172, %173
%175 = add nsw i32 %174, 2
%176 = load i32, i32* %11
%177 = sub nsw i32 %175, %176
%178 = load i32, i32* %13
%179 = add nsw i32 %177, %178
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %180
%182 = load double, double* %181
%183 = fmul double %169, %182
%184 = load i32, i32* %7
%185 = load i32, i32* %9
%186 = sub nsw i32 %184, %185
%187 = load i32, i32* %10
%188 = add nsw i32 %186, %187
%189 = add nsw i32 %188, 2
%190 = load i32, i32* %12
%191 = sub nsw i32 %189, %190
%192 = load i32, i32* %13
%193 = add nsw i32 %191, %192
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %194
%196 = load double, double* %195
%197 = fmul double %183, %196
%198 = fdiv double %148, %197
%199 = load double, double* %16
%200 = fadd double %199, %198
store double %200, double* %16
br label %201
201: ; preds = %137
%202 = load i32, i32* %13
%203 = add nsw i32 %202, 2
store i32 %203, i32* %13
br label %133
204: ; preds = %133
%205 = load i32, i32* %11
%206 = add nsw i32 %205, 2
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %207
%209 = load double, double* %208
%210 = load i32, i32* %12
%211 = add nsw i32 %210, 2
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %212
%214 = load double, double* %213
%215 = fmul double %209, %214
%216 = load i32, i32* %11
%217 = add nsw i32 %216, 3
%218 = load i32, i32* %7
%219 = mul nsw i32 2, %218
%220 = add nsw i32 %217, %219
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %221
%223 = load double, double* %222
%224 = load i32, i32* %12
%225 = add nsw i32 %224, 3
%226 = load i32, i32* %9
%227 = mul nsw i32 2, %226
%228 = add nsw i32 %225, %227
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %229
%231 = load double, double* %230
%232 = fmul double %223, %231
%233 = fdiv double %215, %232
%234 = call double @sqrt(double %233)
%235 = load i32, i32* %9
%236 = load i32, i32* %7
%237 = sub nsw i32 %235, %236
%238 = load i32, i32* %10
%239 = add nsw i32 %237, %238
%240 = add nsw i32 %239, 2
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %241
%243 = load double, double* %242
%244 = fmul double %234, %243
%245 = load i32, i32* %7
%246 = load i32, i32* %9
%247 = sub nsw i32 %245, %246
%248 = load i32, i32* %10
%249 = add nsw i32 %247, %248
%250 = add nsw i32 %249, 2
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %251
%253 = load double, double* %252
%254 = fmul double %244, %253
%255 = load i32, i32* %10
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds [7 x double], [7 x double]* @rad_int_lambda.factor, i64 0, i64 %256
%258 = load double, double* %257
%259 = fmul double %254, %258
%260 = load double, double* %16
%261 = fmul double %260, %259
store double %261, double* %16
%262 = load double, double* %16
ret double %262
}

LLVM IR (-O2):
@rad_int_lambda.factor = internal unnamed_addr constant [7 x double] [double 1.000000e+00, double 0x40094C583AD4923E, double 1.000000e+01, double 0x403F9F6E4989B6CE, double 1.000000e+02, double 0x4073C3A4EDFB70A4, double 1.000000e+03]
@rad_int_lambda.fct = internal unnamed_addr constant [51 x double] [double 0.000000e+00, double 0x40166B82D181118D, double 1.000000e+00, double 0x3FD1EF9BDACDA7A4, double 1.000000e-01, double 0x3FA585EE3955A279, double 2.000000e-02, double 0x3F8585EE3879BB7A, double 6.000000e-03, double 0x3F6E21E71DED640F, double 2.400000e-03, double 0x3F5B1E833465AADA, double 1.200000e-03, double 0x3F4DD4C386297724, double 7.200000e-04, double 0x3F4363E57DA1FD48, double 5.040000e-04, double 0x3F3D15D83CB95A52, double 4.032000e-04, double 0x3F38B8F7CD453940, double 3.628800e-04, double 0x3F377C850258E0A2, double 3.628800e-04, double 0x3F38A92542D97005, double 3.991680e-04, double 0x3F3C5C1E0D34E54D, double 0x3F3F645034EC5DF1, double 0x3F41B992C7FAB0EA, double 0x3F44679A88CCD6AA, double 0x3F47EDB95ACCAB7A, double 0x3F4C910B8C51F954, double 0x3F51592662F16109, double 0x3F556CC8A9CA37CB, double 0x3F5AE3C84BBCA19B, double 0x3F6123D3BAC1CE3C, double 0x3F662F1ED7ABAAEE, double 0x3F6D234E56ACB767, double 0x3F73693AFC8A3A90, double 0x3F7A39601B3832A9, double 0x3F81F489C2F57D2C, double 0x3F88E9B4E4F99456, double 0x3F91819FEAD0F5A5, double 0x3F98E9B4E6B16254, double 0x3FA1F1AA50F1C115, double 0x3FAA28978BBDDCF2, double 0x3FB34A30B07700BD, double 0x3FBCC6404D9A5F09, double 0x3FC5B376C7540964, double 0x3FD08B982BA7C5FA, double 0x3FD97FAB8F6DFA37, double 0x3FE3DAB69B6E4137]
@.str = [38 x i8] c"\0A\0AError in function rad_int_lambda():\00"
@.str.1 = [44 x i8] c" Not allowed lambda-value!!! lambda = %d\0A\00"
@.str.2 = [39 x i8] c" Not allowed angular momentum relation\00"
@.str.3 = [53 x i8] c"\0A<n_2 = %d, l_2 = %d | r**%d | n_1 = %d, l_1 = %d >\0A\00"
define double @rad_int_lambda(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = icmp sgt i32 %4, 6
br i1 %6, label %7, label %11
7: ; preds = %5
%8 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0))
%9 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str.1, i64 0, i64 0), i32 %4)
%10 = tail call i32 @exit(i32 1)
unreachable
11: ; preds = %5
%12 = add i32 %4, %1
%13 = icmp slt i32 %12, %3
br i1 %13, label %18, label %14
14: ; preds = %11
%15 = sub nsw i32 %1, %4
%16 = tail call i32 @llvm.abs.i32(i32 %15, i1 true)
%17 = icmp sgt i32 %16, %3
br i1 %17, label %18, label %23
18: ; preds = %14, %11
%19 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0))
%20 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.2, i64 0, i64 0))
%21 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @.str.3, i64 0, i64 0), i32 %2, i32 %3, i32 %4, i32 %0, i32 %1)
%22 = tail call i32 @exit(i32 1)
unreachable
23: ; preds = %14
%24 = shl nsw i32 %0, 1
%25 = shl nsw i32 %2, 1
%26 = add i32 %24, %1
%27 = add i32 %3, %4
%28 = sub i32 %26, %27
%29 = add i32 %25, %3
%30 = sub i32 %29, %12
%31 = icmp sgt i32 %28, %30
%32 = select i1 %31, i32 %28, i32 %30
%33 = icmp sgt i32 %32, 0
%34 = select i1 %33, i32 %32, i32 0
%35 = icmp slt i32 %24, %25
%36 = select i1 %35, i32 %24, i32 %25
%37 = icmp sgt i32 %34, %36
br i1 %37, label %38, label %43
38: ; preds = %23
%39 = add nsw i32 %24, 2
%40 = add nsw i32 %25, 2
%41 = add nsw i32 %4, 2
%42 = add i32 %41, %1
br label %90
43: ; preds = %23
%44 = add i32 %27, 3
%45 = add i32 %44, %1
%46 = add nsw i32 %24, 2
%47 = add nsw i32 %25, 2
%48 = add nsw i32 %4, 2
%49 = sub i32 %48, %26
%50 = add i32 %49, %3
%51 = add i32 %48, %1
%52 = sub i32 %51, %29
%53 = zext i32 %34 to i64
%54 = sext i32 %36 to i64
br label %55
55: ; preds = %43, %55
%56 = phi i64 [ %53, %43 ], [ %63, %55 ]
%57 = phi double [ 0.000000e+00, %43 ], [ %88, %55 ]
%58 = trunc i64 %56 to i32
%59 = add i32 %45, %58
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %60
%62 = load double, double* %61
%63 = add nuw nsw i64 %56, 2
%64 = and i64 %63, 4294967295
%65 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %64
%66 = load double, double* %65
%67 = sub i32 %46, %58
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %68
%70 = load double, double* %69
%71 = fmul double %66, %70
%72 = sub i32 %47, %58
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %73
%75 = load double, double* %74
%76 = fmul double %71, %75
%77 = add i32 %50, %58
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %78
%80 = load double, double* %79
%81 = fmul double %76, %80
%82 = add i32 %52, %58
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %83
%85 = load double, double* %84
%86 = fmul double %81, %85
%87 = fdiv double %62, %86
%88 = fadd double %57, %87
%89 = icmp sgt i64 %63, %54
br i1 %89, label %90, label %55
90: ; preds = %55, %38
%91 = phi i32 [ %42, %38 ], [ %51, %55 ]
%92 = phi i32 [ %41, %38 ], [ %48, %55 ]
%93 = phi i32 [ %40, %38 ], [ %47, %55 ]
%94 = phi i32 [ %39, %38 ], [ %46, %55 ]
%95 = phi double [ 0.000000e+00, %38 ], [ %88, %55 ]
%96 = sext i32 %94 to i64
%97 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %96
%98 = load double, double* %97
%99 = sext i32 %93 to i64
%100 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %99
%101 = load double, double* %100
%102 = fmul double %98, %101
%103 = add nsw i32 %24, 3
%104 = shl nsw i32 %1, 1
%105 = add nsw i32 %103, %104
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %106
%108 = load double, double* %107
%109 = add nsw i32 %25, 3
%110 = shl nsw i32 %3, 1
%111 = add nsw i32 %109, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %112
%114 = load double, double* %113
%115 = fmul double %108, %114
%116 = fdiv double %102, %115
%117 = tail call double @sqrt(double %116)
%118 = sub i32 %92, %1
%119 = add i32 %118, %3
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %120
%122 = load double, double* %121
%123 = fmul double %117, %122
%124 = sub i32 %91, %3
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [51 x double], [51 x double]* @rad_int_lambda.fct, i64 0, i64 %125
%127 = load double, double* %126
%128 = fmul double %123, %127
%129 = sext i32 %4 to i64
%130 = getelementptr inbounds [7 x double], [7 x double]* @rad_int_lambda.factor, i64 0, i64 %129
%131 = load double, double* %130
%132 = fmul double %128, %131
%133 = fmul double %95, %132
ret double %133
}