#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 pow(double, int);
void lineCirc(double out[][5], double pt0[3], double norm[3], double r[],
              double z[], int ix) {
  int i;
  double eps, epst, f0r, f1r;
  f0r = pow(pt0[0], 2) + pow(pt0[1], 2);
  f1r = pow(norm[0], 2) + pow(norm[1], 2);
  eps = pt0[0] * norm[0] + pt0[1] * norm[1];
  for (i = 0; i < ix; i++) {
    epst = eps + (pt0[2] - z[i]) * norm[2];
    out[i][0] = f1r;
    out[i][1] = 2 * (eps + epst * f1r);
    out[i][2] =
        f0r + 4 * eps * epst + f1r * (pow(epst, 2) - pow(r[i], 2) * f1r);
    out[i][3] = 2 * (f0r * epst + eps * (pow(epst, 2) - pow(r[i], 2) * f1r));
    out[i][4] = f0r * pow(epst, 2) - pow(r[i], 2) * pow(eps, 2);
  }
}


x86 assembly (clang, -O0):
<lineCirc>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    148a <lineCirc+0x37a>
movsd  -0x38(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
movsd  -0x38(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xdad(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x48(%rbp),%xmm1
movsd  0xd90(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  -0xb0(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x50(%rbp),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  -0x98(%rbp),%xmm4
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x80(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm5
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xc2e(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x40(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,-0x70(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  -0x78(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movaps %xmm0,%xmm3
movsd  -0x68(%rbp),%xmm0
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11df <lineCirc+0xcf>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lineCirc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,%ebp
mov    %r8,0x38(%rsp)
mov    %rcx,%r13
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%rbx
movsd  (%rsi),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%r12),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,0x10(%rsp)
movsd  (%r15),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0x8(%r15),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
test   %ebp,%ebp
jle    1352 <lineCirc+0x242>
movsd  0x20(%rsp),%xmm1
addsd  0x10(%rsp),%xmm1
movsd  %xmm1,0x20(%rsp)
movsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  (%r12),%xmm1
movsd  0x8(%r12),%xmm0
mulsd  0x8(%r15),%xmm0
mulsd  (%r15),%xmm1
addsd  %xmm0,%xmm1
movsd  0xe30(%rip),%xmm0
movsd  %xmm1,0x10(%rsp)
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %ebp,%ebp
add    $0x20,%rbx
xor    %r14d,%r14d
nopl   0x0(%rax)
movsd  0x10(%r12),%xmm0
mov    0x38(%rsp),%rax
subsd  (%rax,%r14,8),%xmm0
mulsd  0x10(%r15),%xmm0
movsd  0x10(%rsp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rsp)
movsd  0x18(%rsp),%xmm3
movsd  %xmm3,-0x20(%rbx)
movapd %xmm0,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm2
movsd  %xmm2,-0x18(%rbx)
movsd  0x30(%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x20(%rsp),%xmm1
movsd  %xmm1,0x8(%rsp)
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,0x40(%rsp)
movsd  0x0(%r13,%r14,8),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  0x18(%rsp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x40(%rsp),%xmm2
subsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
addsd  0x8(%rsp),%xmm2
movsd  %xmm2,-0x10(%rbx)
movsd  0x28(%rsp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x0(%r13,%r14,8),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulsd  0x18(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
subsd  %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm1
movapd %xmm1,%xmm2
movsd  0x20(%rsp),%xmm1
movsd  0x28(%rsp),%xmm0
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm1
movsd  %xmm1,-0x8(%rbx)
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x0(%r13,%r14,8),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
mov    $0x2,%edi
call   1030 <pow@plt>
mulsd  0x8(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
mulsd  0x20(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx)
add    $0x1,%r14
add    $0x28,%rbx
cmp    %r14,%rbp
jne    11f0 <lineCirc+0xe0>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @lineCirc([5 x double]* %0, double* %1, double* %2, double* %3, double* %4, i32 %5) {
%7 = alloca [5 x double]*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca i32
%13 = alloca i32
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
store [5 x double]* %0, [5 x double]** %7
store double* %1, double** %8
store double* %2, double** %9
store double* %3, double** %10
store double* %4, double** %11
store i32 %5, i32* %12
%18 = load double*, double** %8
%19 = getelementptr inbounds double, double* %18, i64 0
%20 = load double, double* %19
%21 = call double @pow(double %20, i32 2)
%22 = load double*, double** %8
%23 = getelementptr inbounds double, double* %22, i64 1
%24 = load double, double* %23
%25 = call double @pow(double %24, i32 2)
%26 = fadd double %21, %25
store double %26, double* %16
%27 = load double*, double** %9
%28 = getelementptr inbounds double, double* %27, i64 0
%29 = load double, double* %28
%30 = call double @pow(double %29, i32 2)
%31 = load double*, double** %9
%32 = getelementptr inbounds double, double* %31, i64 1
%33 = load double, double* %32
%34 = call double @pow(double %33, i32 2)
%35 = fadd double %30, %34
store double %35, double* %17
%36 = load double*, double** %8
%37 = getelementptr inbounds double, double* %36, i64 0
%38 = load double, double* %37
%39 = load double*, double** %9
%40 = getelementptr inbounds double, double* %39, i64 0
%41 = load double, double* %40
%42 = load double*, double** %8
%43 = getelementptr inbounds double, double* %42, i64 1
%44 = load double, double* %43
%45 = load double*, double** %9
%46 = getelementptr inbounds double, double* %45, i64 1
%47 = load double, double* %46
%48 = fmul double %44, %47
%49 = call double @llvm.fmuladd.f64(double %38, double %41, double %48)
store double %49, double* %14
store i32 0, i32* %13
br label %50
50: ; preds = %149, %6
%51 = load i32, i32* %13
%52 = load i32, i32* %12
%53 = icmp slt i32 %51, %52
br i1 %53, label %54, label %152
54: ; preds = %50
%55 = load double, double* %14
%56 = load double*, double** %8
%57 = getelementptr inbounds double, double* %56, i64 2
%58 = load double, double* %57
%59 = load double*, double** %11
%60 = load i32, i32* %13
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %59, i64 %61
%63 = load double, double* %62
%64 = fsub double %58, %63
%65 = load double*, double** %9
%66 = getelementptr inbounds double, double* %65, i64 2
%67 = load double, double* %66
%68 = call double @llvm.fmuladd.f64(double %64, double %67, double %55)
store double %68, double* %15
%69 = load double, double* %17
%70 = load [5 x double]*, [5 x double]** %7
%71 = load i32, i32* %13
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [5 x double], [5 x double]* %70, i64 %72
%74 = getelementptr inbounds [5 x double], [5 x double]* %73, i64 0, i64 0
store double %69, double* %74
%75 = load double, double* %14
%76 = load double, double* %15
%77 = load double, double* %17
%78 = call double @llvm.fmuladd.f64(double %76, double %77, double %75)
%79 = fmul double 2.000000e+00, %78
%80 = load [5 x double]*, [5 x double]** %7
%81 = load i32, i32* %13
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [5 x double], [5 x double]* %80, i64 %82
%84 = getelementptr inbounds [5 x double], [5 x double]* %83, i64 0, i64 1
store double %79, double* %84
%85 = load double, double* %16
%86 = load double, double* %14
%87 = fmul double 4.000000e+00, %86
%88 = load double, double* %15
%89 = call double @llvm.fmuladd.f64(double %87, double %88, double %85)
%90 = load double, double* %17
%91 = load double, double* %15
%92 = call double @pow(double %91, i32 2)
%93 = load double*, double** %10
%94 = load i32, i32* %13
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %93, i64 %95
%97 = load double, double* %96
%98 = call double @pow(double %97, i32 2)
%99 = load double, double* %17
%100 = fneg double %98
%101 = call double @llvm.fmuladd.f64(double %100, double %99, double %92)
%102 = call double @llvm.fmuladd.f64(double %90, double %101, double %89)
%103 = load [5 x double]*, [5 x double]** %7
%104 = load i32, i32* %13
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [5 x double], [5 x double]* %103, i64 %105
%107 = getelementptr inbounds [5 x double], [5 x double]* %106, i64 0, i64 2
store double %102, double* %107
%108 = load double, double* %16
%109 = load double, double* %15
%110 = load double, double* %14
%111 = load double, double* %15
%112 = call double @pow(double %111, i32 2)
%113 = load double*, double** %10
%114 = load i32, i32* %13
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double, double* %113, i64 %115
%117 = load double, double* %116
%118 = call double @pow(double %117, i32 2)
%119 = load double, double* %17
%120 = fneg double %118
%121 = call double @llvm.fmuladd.f64(double %120, double %119, double %112)
%122 = fmul double %110, %121
%123 = call double @llvm.fmuladd.f64(double %108, double %109, double %122)
%124 = fmul double 2.000000e+00, %123
%125 = load [5 x double]*, [5 x double]** %7
%126 = load i32, i32* %13
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [5 x double], [5 x double]* %125, i64 %127
%129 = getelementptr inbounds [5 x double], [5 x double]* %128, i64 0, i64 3
store double %124, double* %129
%130 = load double, double* %16
%131 = load double, double* %15
%132 = call double @pow(double %131, i32 2)
%133 = load double*, double** %10
%134 = load i32, i32* %13
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %133, i64 %135
%137 = load double, double* %136
%138 = call double @pow(double %137, i32 2)
%139 = load double, double* %14
%140 = call double @pow(double %139, i32 2)
%141 = fmul double %138, %140
%142 = fneg double %141
%143 = call double @llvm.fmuladd.f64(double %130, double %132, double %142)
%144 = load [5 x double]*, [5 x double]** %7
%145 = load i32, i32* %13
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [5 x double], [5 x double]* %144, i64 %146
%148 = getelementptr inbounds [5 x double], [5 x double]* %147, i64 0, i64 4
store double %143, double* %148
br label %149
149: ; preds = %54
%150 = load i32, i32* %13
%151 = add nsw i32 %150, 1
store i32 %151, i32* %13
br label %50
152: ; preds = %50
ret void
}

LLVM IR (-O2):
define void @lineCirc([5 x double]* nocapture writeonly %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, double* nocapture %4, i32 %5) {
%7 = load double, double* %1
%8 = tail call double @pow(double %7, i32 2)
%9 = getelementptr inbounds double, double* %1, i64 1
%10 = load double, double* %9
%11 = tail call double @pow(double %10, i32 2)
%12 = fadd double %8, %11
%13 = load double, double* %2
%14 = tail call double @pow(double %13, i32 2)
%15 = getelementptr inbounds double, double* %2, i64 1
%16 = load double, double* %15
%17 = tail call double @pow(double %16, i32 2)
%18 = fadd double %14, %17
%19 = load double, double* %1
%20 = load double, double* %2
%21 = load double, double* %9
%22 = load double, double* %15
%23 = fmul double %21, %22
%24 = tail call double @llvm.fmuladd.f64(double %19, double %20, double %23)
%25 = icmp sgt i32 %5, 0
br i1 %25, label %26, label %71
26: ; preds = %6
%27 = getelementptr inbounds double, double* %1, i64 2
%28 = getelementptr inbounds double, double* %2, i64 2
%29 = fmul double %24, 4.000000e+00
%30 = zext i32 %5 to i64
br label %31
31: ; preds = %26, %31
%32 = phi i64 [ 0, %26 ], [ %69, %31 ]
%33 = load double, double* %27
%34 = getelementptr inbounds double, double* %4, i64 %32
%35 = load double, double* %34
%36 = fsub double %33, %35
%37 = load double, double* %28
%38 = tail call double @llvm.fmuladd.f64(double %36, double %37, double %24)
%39 = getelementptr inbounds [5 x double], [5 x double]* %0, i64 %32, i64 0
store double %18, double* %39
%40 = tail call double @llvm.fmuladd.f64(double %38, double %18, double %24)
%41 = fmul double %40, 2.000000e+00
%42 = getelementptr inbounds [5 x double], [5 x double]* %0, i64 %32, i64 1
store double %41, double* %42
%43 = tail call double @llvm.fmuladd.f64(double %29, double %38, double %12)
%44 = tail call double @pow(double %38, i32 2)
%45 = getelementptr inbounds double, double* %3, i64 %32
%46 = load double, double* %45
%47 = tail call double @pow(double %46, i32 2)
%48 = fneg double %47
%49 = tail call double @llvm.fmuladd.f64(double %48, double %18, double %44)
%50 = tail call double @llvm.fmuladd.f64(double %18, double %49, double %43)
%51 = getelementptr inbounds [5 x double], [5 x double]* %0, i64 %32, i64 2
store double %50, double* %51
%52 = tail call double @pow(double %38, i32 2)
%53 = load double, double* %45
%54 = tail call double @pow(double %53, i32 2)
%55 = fneg double %54
%56 = tail call double @llvm.fmuladd.f64(double %55, double %18, double %52)
%57 = fmul double %24, %56
%58 = tail call double @llvm.fmuladd.f64(double %12, double %38, double %57)
%59 = fmul double %58, 2.000000e+00
%60 = getelementptr inbounds [5 x double], [5 x double]* %0, i64 %32, i64 3
store double %59, double* %60
%61 = tail call double @pow(double %38, i32 2)
%62 = load double, double* %45
%63 = tail call double @pow(double %62, i32 2)
%64 = tail call double @pow(double %24, i32 2)
%65 = fneg double %63
%66 = fmul double %64, %65
%67 = tail call double @llvm.fmuladd.f64(double %12, double %61, double %66)
%68 = getelementptr inbounds [5 x double], [5 x double]* %0, i64 %32, i64 4
store double %67, double* %68
%69 = add nuw nsw i64 %32, 1
%70 = icmp eq i64 %69, %30
br i1 %70, label %71, label %31
71: ; preds = %31, %6
ret void
}