#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 fabs(float);
float sqrt(float);
void kendl2(float **tab, int i, int j, float *tau, float *z, float *prob) {
  float erfcc(float x);
  long nn, mm, m2, m1, lj, li, l, kj, ki, k;
  float svar, s = 0.0, points, pairs, en2 = 0.0, en1 = 0.0;
  nn = i * j;
  points = tab[i][j];
  for (k = 0; k <= nn - 2; k++) {
    ki = (k / j);
    kj = k - j * ki;
    points += tab[ki + 1][kj + 1];
    for (l = k + 1; l <= nn - 1; l++) {
      li = l / j;
      lj = l - j * li;
      mm = (m1 = li - ki) * (m2 = lj - kj);
      pairs = tab[ki + 1][kj + 1] * tab[li + 1][lj + 1];
      if (mm) {
        en1 += pairs;
        en2 += pairs;
        s += (mm > 0 ? pairs : -pairs);
      } else {
        if (m1)
          en1 += pairs;
        if (m2)
          en2 += pairs;
      }
    }
  }
  *tau = s / sqrt(en1 * en2);
  svar = (4.0 * points + 10.0) / (9.0 * points * (points - 1.0));
  *z = (*tau) / sqrt(svar);
  *prob = erfcc(fabs(*z) / 1.4142136);
}


x86 assembly (clang, -O0):
<kendl2>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
cltq
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movq   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jg     13a4 <kendl2+0x274>
mov    -0x78(%rbp),%rax
movslq -0x10(%rbp),%rcx
cqto
idiv   %rcx
mov    %rax,-0x70(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x10(%rbp),%rcx
imul   -0x70(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    -0x68(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jg     138e <kendl2+0x25e>
mov    -0x60(%rbp),%rax
movslq -0x10(%rbp),%rcx
cqto
idiv   %rcx
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x10(%rbp),%rcx
imul   -0x58(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
sub    -0x70(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rcx
sub    -0x68(%rbp),%rcx
mov    %rcx,-0x40(%rbp)
imul   %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    -0x68(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    -0x50(%rbp),%rcx
mulss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
cmpq   $0x0,-0x38(%rbp)
je     132d <kendl2+0x1fd>
movss  -0x88(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
cmpq   $0x0,-0x38(%rbp)
jle    12f9 <kendl2+0x1c9>
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x94(%rbp)
ff
jmp    1316 <kendl2+0x1e6>
movss  -0x88(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
jmp    1378 <kendl2+0x248>
cmpq   $0x0,-0x48(%rbp)
je     1350 <kendl2+0x220>
movss  -0x88(%rbp),%xmm0
ff
addss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
cmpq   $0x0,-0x40(%rbp)
je     1373 <kendl2+0x243>
movss  -0x88(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
jmp    1378 <kendl2+0x248>
jmp    137d <kendl2+0x24d>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    120e <kendl2+0xde>
jmp    1393 <kendl2+0x263>
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x78(%rbp)
jmp    11a1 <kendl2+0x71>
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
mulss  -0x8c(%rbp),%xmm0
ff
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x9c(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0xc27(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc23(%rip),%xmm1
addsd  %xmm1,%xmm0
movss  -0x84(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm2
movsd  0xbfb(%rip),%xmm1
mulsd  %xmm2,%xmm1
movss  -0x84(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
movsd  0xbdb(%rip),%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x98(%rbp),%xmm0
ff
divss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
call   1030 <fabs@plt>
movsd  0xb78(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1040 <erfcc@plt>
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kendl2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r9,%r14
mov    %r8,%r15
mov    %rcx,%rbp
mov    %edx,%eax
imul   %esi,%eax
movslq %esi,%rcx
mov    (%rdi,%rcx,8),%rcx
movslq %edx,%rbx
movss  (%rcx,%rbx,4),%xmm10
xorps  %xmm8,%xmm8
cmp    $0x2,%eax
jge    1197 <kendl2+0x67>
xorps  %xmm4,%xmm4
xorps  %xmm0,%xmm0
ucomiss %xmm8,%xmm0
jae    12fa <kendl2+0x1ca>
movss  %xmm4,(%rsp)
movss  %xmm10,0x8(%rsp)
call   1050 <sqrt@plt>
movss  0x8(%rsp),%xmm10
movss  (%rsp),%xmm4
jmp    12fe <kendl2+0x1ce>
mov    %edx,%r9d
mov    %rbp,0x10(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14,(%rsp)
movslq %eax,%r11
lea    -0x1(%r11),%r13
xorps  %xmm2,%xmm2
xor    %r8d,%r8d
movss  0xe53(%rip),%xmm1
movaps 0xe3b(%rip),%xmm9
xorps  %xmm0,%xmm0
xorps  %xmm4,%xmm4
jmp    11d9 <kendl2+0xa9>
nopl   (%rax)
cmp    %r13,%r8
je     12de <kendl2+0x1ae>
mov    %r8,%rax
or     %rbx,%rax
shr    $0x20,%rax
je     1200 <kendl2+0xd0>
mov    %r8,%rax
cqto
idiv   %rbx
mov    %rdx,%r10
mov    %rax,%r12
jmp    120e <kendl2+0xde>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r8d,%eax
xor    %edx,%edx
div    %r9d
mov    %edx,%r10d
mov    %eax,%r12d
mov    0x8(%rdi,%r12,8),%rax
movss  0x4(%rax,%r10,4),%xmm5
addss  %xmm5,%xmm10
add    $0x1,%r8
mov    %r8,%rcx
jmp    1248 <kendl2+0x118>
nopl   0x0(%rax,%rax,1)
addss  %xmm7,%xmm4
movaps %xmm6,%xmm7
addss  %xmm7,%xmm2
addss  %xmm6,%xmm0
add    $0x1,%rcx
cmp    %r11,%rcx
jge    11d0 <kendl2+0xa0>
mov    %rcx,%rax
or     %rbx,%rax
shr    $0x20,%rax
je     1270 <kendl2+0x140>
mov    %rcx,%rax
cqto
idiv   %rbx
mov    %rdx,%r15
mov    %rax,%r14
jmp    127d <kendl2+0x14d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ecx,%eax
xor    %edx,%edx
div    %r9d
mov    %edx,%r15d
mov    %eax,%r14d
mov    %r14,%rax
sub    %r12,%rax
mov    %r15,%rdx
sub    %r10,%rdx
mov    %rdx,%rbp
imul   %rax,%rbp
mov    0x8(%rdi,%r14,8),%rsi
movss  0x4(%rsi,%r15,4),%xmm6
mulss  %xmm5,%xmm6
test   %rbp,%rbp
je     12c0 <kendl2+0x190>
movaps %xmm6,%xmm7
jg     1230 <kendl2+0x100>
movaps %xmm6,%xmm7
xorps  %xmm9,%xmm7
jmp    1230 <kendl2+0x100>
cs nopw 0x0(%rax,%rax,1)
movaps %xmm1,%xmm7
test   %rax,%rax
je     12cb <kendl2+0x19b>
movaps %xmm6,%xmm7
movaps %xmm1,%xmm3
test   %rdx,%rdx
je     12d6 <kendl2+0x1a6>
movaps %xmm6,%xmm3
movaps %xmm3,%xmm6
jmp    1237 <kendl2+0x107>
mulss  %xmm2,%xmm0
mov    (%rsp),%r14
mov    0x8(%rsp),%r15
mov    0x10(%rsp),%rbp
ucomiss %xmm8,%xmm0
jb     1175 <kendl2+0x45>
sqrtss %xmm0,%xmm0
divss  %xmm0,%xmm4
xorps  %xmm0,%xmm0
cvtss2sd %xmm10,%xmm0
movsd  0xd06(%rip),%xmm1
mulsd  %xmm0,%xmm1
addsd  0xd02(%rip),%xmm1
movsd  0xd02(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  0xcfe(%rip),%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm4,0x0(%rbp)
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1354 <kendl2+0x224>
sqrtss %xmm0,%xmm0
jmp    1363 <kendl2+0x233>
movss  %xmm4,(%rsp)
call   1050 <sqrt@plt>
movss  (%rsp),%xmm4
divss  %xmm0,%xmm4
movss  %xmm4,(%r15)
movaps %xmm4,%xmm0
call   1030 <fabs@plt>
divsd  0xcbc(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
call   1040 <erfcc@plt>
movss  %xmm0,(%r14)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @kendl2(float** nocapture %0, i32 %1, i32 %2, float* nocapture writeonly %3, float* nocapture writeonly %4, float* nocapture writeonly %5) {
%7 = mul nsw i32 %2, %1
%8 = sext i32 %7 to i64
%9 = sext i32 %1 to i64
%10 = getelementptr inbounds float*, float** %0, i64 %9
%11 = load float*, float** %10
%12 = sext i32 %2 to i64
%13 = getelementptr inbounds float, float* %11, i64 %12
%14 = load float, float* %13
%15 = icmp slt i32 %7, 2
br i1 %15, label %76, label %16
16: ; preds = %6
%17 = add nsw i64 %8, -1
br label %20
18: ; preds = %66
%19 = icmp eq i64 %36, %17
br i1 %19, label %74, label %20
20: ; preds = %18, %16
%21 = phi float [ %71, %18 ], [ 0.000000e+00, %16 ]
%22 = phi float [ %70, %18 ], [ 0.000000e+00, %16 ]
%23 = phi float [ %35, %18 ], [ %14, %16 ]
%24 = phi float [ %67, %18 ], [ 0.000000e+00, %16 ]
%25 = phi i64 [ %36, %18 ], [ 0, %16 ]
%26 = sdiv i64 %25, %12
%27 = mul nsw i64 %26, %12
%28 = srem i64 %25, %12
%29 = add nsw i64 %26, 1
%30 = getelementptr inbounds float*, float** %0, i64 %29
%31 = load float*, float** %30
%32 = add nsw i64 %28, 1
%33 = getelementptr inbounds float, float* %31, i64 %32
%34 = load float, float* %33
%35 = fadd float %23, %34
%36 = add nuw nsw i64 %25, 1
br label %37
37: ; preds = %20, %66
%38 = phi float [ %71, %66 ], [ %21, %20 ]
%39 = phi float [ %70, %66 ], [ %22, %20 ]
%40 = phi i64 [ %72, %66 ], [ %36, %20 ]
%41 = phi float [ %67, %66 ], [ %24, %20 ]
%42 = sdiv i64 %40, %12
%43 = mul nsw i64 %42, %12
%44 = srem i64 %40, %12
%45 = sub nsw i64 %42, %26
%46 = sub nsw i64 %44, %28
%47 = mul nsw i64 %46, %45
%48 = add nsw i64 %42, 1
%49 = getelementptr inbounds float*, float** %0, i64 %48
%50 = load float*, float** %49
%51 = add nsw i64 %44, 1
%52 = getelementptr inbounds float, float* %50, i64 %51
%53 = load float, float* %52
%54 = fmul float %34, %53
%55 = icmp eq i64 %47, 0
br i1 %55, label %61, label %56
56: ; preds = %37
%57 = icmp sgt i64 %47, 0
%58 = fneg float %54
%59 = select i1 %57, float %54, float %58
%60 = fadd float %41, %59
br label %66
61: ; preds = %37
%62 = icmp eq i64 %45, 0
%63 = select i1 %62, float -0.000000e+00, float %54
%64 = icmp eq i64 %46, 0
%65 = select i1 %64, float -0.000000e+00, float %54
br label %66
66: ; preds = %61, %56
%67 = phi float [ %60, %56 ], [ %41, %61 ]
%68 = phi float [ %54, %56 ], [ %65, %61 ]
%69 = phi float [ %54, %56 ], [ %63, %61 ]
%70 = fadd float %39, %68
%71 = fadd float %38, %69
%72 = add nuw nsw i64 %40, 1
%73 = icmp slt i64 %72, %8
br i1 %73, label %37, label %18
74: ; preds = %18
%75 = fmul float %70, %71
br label %76
76: ; preds = %74, %6
%77 = phi float [ 0.000000e+00, %6 ], [ %67, %74 ]
%78 = phi float [ %14, %6 ], [ %35, %74 ]
%79 = phi float [ 0.000000e+00, %6 ], [ %75, %74 ]
%80 = tail call float @sqrt(float %79)
%81 = fdiv float %77, %80
store float %81, float* %3
%82 = fpext float %78 to double
%83 = tail call double @llvm.fmuladd.f64(double %82, double 4.000000e+00, double 1.000000e+01)
%84 = fmul double %82, 9.000000e+00
%85 = fadd double %82, -1.000000e+00
%86 = fmul double %84, %85
%87 = fdiv double %83, %86
%88 = fptrunc double %87 to float
%89 = tail call float @sqrt(float %88)
%90 = fdiv float %81, %89
store float %90, float* %4
%91 = tail call double @fabs(float %90)
%92 = fdiv double %91, 0x3FF6A09E7098EF50
%93 = fptrunc double %92 to float
%94 = tail call float @erfcc(float %93)
store float %94, float* %5
ret void
}