#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 */
double sqrt(int);
void c_legendre_poly(int nmu, int m, int maxmu, int twonm1, double *mu,
                     double *ylm) {
  register int i, l;
  register double tmp1, tmp2;
  if (m == 0) {
    for (i = 1; i <= nmu; i++) {
      ylm[0 + (i - 1) * (maxmu + 1)] = 1.;
      ylm[1 + (i - 1) * (maxmu + 1)] = mu[i - 1];
    }
    for (l = 2; l <= twonm1; l++) {
      for (i = 1; i <= nmu; i++) {
        ylm[l + (i - 1) * (maxmu + 1)] =
            ((double)(2 * l - 1) * mu[i - 1] *
                 ylm[l - 1 + (i - 1) * (maxmu + 1)] -
             (double)(l - 1) * ylm[l - 2 + (i - 1) * (maxmu + 1)]) /
            l;
      }
    }
  } else {
    for (i = 1; i <= nmu; i++) {
      ylm[m + (i - 1) * (maxmu + 1)] =
          -sqrt((1. - 1. / (2 * m)) * (1. - ({
                                         const double _x = (double)(mu[i - 1]);
                                         _x *_x;
                                       }))) *
          ylm[m - 1 + (i - 1) * (maxmu + 1)];
      ylm[m + 1 + (i - 1) * (maxmu + 1)] =
          sqrt(2. * m + 1.) * mu[i - 1] * ylm[m + (i - 1) * (maxmu + 1)];
    }
    for (l = m + 2; l <= twonm1; l++) {
      tmp1 = sqrt((l - m) * (l + m));
      tmp2 = sqrt((l - m - 1) * (l + m - 1));
      for (i = 1; i <= nmu; i++) {
        ylm[l + (i - 1) * (maxmu + 1)] =
            ((double)(2 * l - 1) * mu[i - 1] *
                 ylm[l - 1 + (i - 1) * (maxmu + 1)] -
             tmp2 * ylm[l - 2 + (i - 1) * (maxmu + 1)]) /
            tmp1;
      }
    }
  }
  return;
}


x86 assembly (clang, -O0):
<c_legendre_poly>:
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    %r8,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
cmpl   $0x0,-0x8(%rbp)
jne    12b0 <c_legendre_poly+0x1a0>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     11ad <c_legendre_poly+0x9d>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  0xe96(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    113d <c_legendre_poly+0x2d>
movl   $0x2,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     12ab <c_legendre_poly+0x19b>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1298 <c_legendre_poly+0x188>
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    -0xc(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    -0xc(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsi2sdl -0x28(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    -0xc(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11c7 <c_legendre_poly+0xb7>
jmp    129d <c_legendre_poly+0x18d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11b4 <c_legendre_poly+0xa4>
jmp    1534 <c_legendre_poly+0x424>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1400 <c_legendre_poly+0x2f0>
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  0xd2b(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  0xd1f(%rip),%xmm0
subsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
movsd  %xmm1,-0x48(%rbp)
movsd  0xced(%rip),%xmm1
subsd  -0x48(%rbp),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1030 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    -0xc(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    -0xc(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cvtsi2sdl -0x8(%rbp),%xmm0
addsd  %xmm0,%xmm0
movsd  0xc70(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1030 <sqrt@plt>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    -0xc(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    -0xc(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12b7 <c_legendre_poly+0x1a7>
mov    -0x8(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     152f <c_legendre_poly+0x41f>
mov    -0x28(%rbp),%edi
sub    -0x8(%rbp),%edi
mov    -0x28(%rbp),%eax
add    -0x8(%rbp),%eax
imul   %eax,%edi
call   1030 <sqrt@plt>
movsd  %xmm0,-0x30(%rbp)
mov    -0x28(%rbp),%edi
sub    -0x8(%rbp),%edi
sub    $0x1,%edi
mov    -0x28(%rbp),%eax
add    -0x8(%rbp),%eax
sub    $0x1,%eax
imul   %eax,%edi
call   1030 <sqrt@plt>
movsd  %xmm0,-0x38(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     151c <c_legendre_poly+0x40c>
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    -0xc(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x2,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    -0xc(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x30(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    -0xc(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1454 <c_legendre_poly+0x344>
jmp    1521 <c_legendre_poly+0x411>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1409 <c_legendre_poly+0x2f9>
jmp    1534 <c_legendre_poly+0x424>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<c_legendre_poly>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,%rbx
mov    %r8,%r14
mov    %rcx,(%rsp)
mov    %rsi,%rax
mov    %rsi,0x8(%rsp)
test   %esi,%esi
je     13b9 <c_legendre_poly+0x2a9>
mov    %rdx,0x10(%rsp)
mov    %rdi,0x20(%rsp)
test   %edi,%edi
jle    122f <c_legendre_poly+0x11f>
mov    0x8(%rsp),%rcx
lea    (%rcx,%rcx,1),%eax
cvtsi2sd %eax,%xmm0
movsd  0xea2(%rip),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm0,%xmm1
movapd %xmm2,%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rsp)
mov    0x10(%rsp),%rax
add    $0x1,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm2,%xmm0
cvttsd2si %xmm0,%edx
mov    %edx,0x30(%rsp)
mov    %eax,0x38(%rsp)
movslq %eax,%rbp
movslq %ecx,%rax
mov    0x20(%rsp),%edx
mov    %rdx,0x28(%rsp)
lea    0x1(%rcx),%r15d
lea    (%rbx,%rax,8),%r12
shl    $0x3,%rbp
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r14,%r13,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0xe2e(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x18(%rsp),%xmm1
cvttsd2si %xmm1,%edi
call   1030 <sqrt@plt>
xorpd  0xe23(%rip),%xmm0
lea    -0x2(%r15),%eax
cltq
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12)
mov    0x30(%rsp),%edi
call   1030 <sqrt@plt>
mulsd  (%r14,%r13,8),%xmm0
mulsd  (%r12),%xmm0
movslq %r15d,%r15
movsd  %xmm0,(%rbx,%r15,8)
add    $0x1,%r13
add    0x38(%rsp),%r15d
add    %rbp,%r12
cmp    %r13,0x28(%rsp)
jne    11c0 <c_legendre_poly+0xb0>
mov    0x8(%rsp),%rax
add    $0x2,%eax
cmp    (%rsp),%eax
mov    0x10(%rsp),%rcx
jg     143d <c_legendre_poly+0x32d>
movslq %ecx,%rcx
lea    0x1(%rcx),%r12
mov    0x20(%rsp),%rdx
lea    0x1(%rdx),%r13d
movslq %eax,%r8
mov    0x8(%rsp),%eax
mov    %rax,0x40(%rsp)
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,(%rsp)
mov    %r8,%rax
shl    $0x20,%rax
movabs $0xfffffffe00000000,%r9
ff ff ff
add    %rax,%r9
shl    $0x20,%r12
movabs $0xffffffff00000000,%r10
ff ff ff
add    %rax,%r10
lea    (%rbx,%r8,8),%r11
lea    0x8(,%rcx,8),%r15
add    $0xffffffffffffffff,%r13
jmp    12d2 <c_legendre_poly+0x1c2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r8
movabs $0x100000000,%rax
add    %rax,%r9
add    %rax,%r10
add    $0x8,%r11
cmp    %r8d,(%rsp)
je     143d <c_legendre_poly+0x32d>
mov    %r11,0x28(%rsp)
mov    %r10,0x30(%rsp)
mov    %r9,0x38(%rsp)
mov    %r8,0x18(%rsp)
mov    %r8d,%ebp
mov    0x40(%rsp),%rax
sub    %eax,%ebp
lea    (%r8,%rax,1),%edi
imul   %ebp,%edi
call   1030 <sqrt@plt>
movsd  %xmm0,0x10(%rsp)
mov    0x8(%rsp),%rax
mov    0x18(%rsp),%rcx
add    %ecx,%eax
add    $0xffffffff,%eax
add    $0xffffffff,%ebp
imul   %eax,%ebp
mov    %ebp,%edi
call   1030 <sqrt@plt>
movsd  0x10(%rsp),%xmm4
mov    0x28(%rsp),%r11
mov    0x30(%rsp),%r10
mov    0x38(%rsp),%r9
mov    0x18(%rsp),%r8
cmpl   $0x0,0x20(%rsp)
jle    12b0 <c_legendre_poly+0x1a0>
lea    (%r8,%r8,1),%eax
add    $0xffffffff,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
xorpd  0xcb7(%rip),%xmm0
mov    %r11,%rax
mov    %r10,%rcx
mov    %r9,%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r14,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
mov    %rcx,%rdi
sar    $0x1d,%rdi
mov    %rbp,%rdx
sar    $0x1d,%rdx
movsd  (%rbx,%rdx,1),%xmm3
mulsd  %xmm0,%xmm3
mulsd  (%rbx,%rdi,1),%xmm2
addsd  %xmm3,%xmm2
divsd  %xmm4,%xmm2
movsd  %xmm2,(%rax)
add    $0x1,%rsi
add    %r12,%rbp
add    %r12,%rcx
add    %r15,%rax
cmp    %rsi,%r13
jne    1370 <c_legendre_poly+0x260>
jmp    12b0 <c_legendre_poly+0x1a0>
test   %edi,%edi
jle    1437 <c_legendre_poly+0x327>
lea    0x1(%rdx),%eax
cltq
mov    %edi,%r8d
movabs $0x3ff0000000000000,%r9
cmp    $0x1,%edi
jne    13d8 <c_legendre_poly+0x2c8>
xor    %esi,%esi
jmp    141d <c_legendre_poly+0x30d>
mov    %r8d,%r10d
and    $0xfffffffe,%r10d
lea    0x8(%rbx),%rbp
mov    %rax,%rcx
shl    $0x4,%rcx
xor    %esi,%esi
nopl   0x0(%rax)
mov    %r9,-0x8(%rbp)
movsd  (%r14,%rsi,8),%xmm0
movsd  %xmm0,0x0(%rbp)
mov    %r9,-0x8(%rbp,%rax,8)
movsd  0x8(%r14,%rsi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x2,%rsi
add    %rcx,%rbp
cmp    %rsi,%r10
jne    13f0 <c_legendre_poly+0x2e0>
test   $0x1,%r8b
je     1437 <c_legendre_poly+0x327>
imul   %rsi,%rax
mov    %r9,(%rbx,%rax,8)
movsd  (%r14,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rax,8)
cmpl   $0x2,(%rsp)
jge    144c <c_legendre_poly+0x33c>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rdi,%r12
movabs $0x100000000,%r8
movslq %edx,%rax
lea    0x1(%rax),%r15
lea    0x1(%rdi),%edx
mov    (%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,(%rsp)
shl    $0x20,%r15
lea    0x10(%rbx),%r9
lea    0x8(,%rax,8),%rdi
add    $0xffffffffffffffff,%rdx
mov    $0x2,%r11d
xor    %r10d,%r10d
jmp    14a1 <c_legendre_poly+0x391>
nopl   (%rax)
add    $0x1,%r11
add    %r8,%r10
add    $0x8,%r9
cmp    (%rsp),%r11
je     143d <c_legendre_poly+0x32d>
test   %r12d,%r12d
jle    1490 <c_legendre_poly+0x380>
lea    (%r11,%r11,1),%eax
add    $0xffffffff,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
lea    -0x1(%r11),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
xorps  %xmm2,%xmm2
cvtsi2sd %r11d,%xmm2
mov    %r9,%rsi
mov    %r10,%rcx
xor    %ebp,%ebp
nop
movsd  (%r14,%rbp,8),%xmm3
mulsd  %xmm0,%xmm3
mov    %rcx,%rax
sar    $0x1d,%rax
movsd  (%rbx,%rax,1),%xmm4
mulsd  -0x8(%rsi),%xmm3
mulsd  %xmm1,%xmm4
subsd  %xmm4,%xmm3
divsd  %xmm2,%xmm3
movsd  %xmm3,(%rsi)
add    $0x1,%rbp
add    %r15,%rcx
add    %rdi,%rsi
cmp    %rbp,%rdx
jne    14d0 <c_legendre_poly+0x3c0>
jmp    1490 <c_legendre_poly+0x380>

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

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