#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, ...);
main() {
  double n, x, p, r, s, temp, u, k;
  int t, m, q = 0, d = 0;
  long long int j, k1, i;
  scanf("%d", &t);
  for (m = 0; m < t; m++) {
    scanf("%lf%lf", &x, &k);
    k1 = k / 1;
    float a[k1 + 3];
    a[0] = 0.00;
    a[1] = x / 2.0;
    a[2] = x;
    if (k1 == 1) {
      printf("%lf", a[1]);
      goto retry;
    }
    for (i = 2; i <= k1; i++) {
      for (j = 2; j <= i; j++) {
        if ((a[j] - a[j - 1]) > (a[j - 1] - a[j - 2])) {
          r = a[j];
          s = a[j - 1];
          q = 1;
        }
      }
      if (q != 1) {
        p = (a[0] + a[1]) / 2.0;
        u = p;
      } else {
        p = (r + s) / 2.0;
        u = p;
      }
      for (j = i; p < a[j]; j--) {
        a[j + 1] = a[j];
      }
      a[j + 1] = p;
      q = 0;
    }
    printf("%lf", u);
  retry:
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
lea    0xec1(%rip),%rdi
lea    -0x4c(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    13ed <main+0x2cd>
lea    0xe9f(%rip),%rdi
xor    %eax,%eax
lea    -0x18(%rbp),%rsi
lea    -0x48(%rbp),%rdx
call   1040 <scanf@plt>
cvttsd2si -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x3,%rcx
mov    %rsp,%rdx
mov    %rdx,-0x78(%rbp)
lea    0x1b(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rax
sub    %rdx,%rax
mov    %rax,-0x88(%rbp)
mov    %rax,%rsp
mov    %rcx,-0x80(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movsd  -0x18(%rbp),%xmm0
movsd  0xe35(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
movsd  -0x18(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x8(%rax)
cmpq   $0x1,-0x68(%rbp)
jne    1214 <main+0xf4>
mov    -0x88(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe06(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    13ca <main+0x2aa>
movq   $0x2,-0x70(%rbp)
mov    -0x70(%rbp),%rax
cmp    -0x68(%rbp),%rax
jg     13b7 <main+0x297>
movq   $0x2,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x70(%rbp),%rax
jg     12cc <main+0x1ac>
mov    -0x88(%rbp),%rax
mov    -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rcx
sub    $0x1,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x60(%rbp),%rcx
sub    $0x2,%rcx
subss  (%rax,%rcx,4),%xmm1
ucomiss %xmm1,%xmm0
jbe    12b6 <main+0x196>
mov    -0x88(%rbp),%rax
mov    -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x60(%rbp),%rcx
sub    $0x1,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x1,-0x54(%rbp)
jmp    12bb <main+0x19b>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1232 <main+0x112>
cmpl   $0x1,-0x54(%rbp)
je     130a <main+0x1ea>
mov    -0x88(%rbp),%rax
movss  (%rax),%xmm0
addss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd0e(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    132f <main+0x20f>
movsd  -0x28(%rbp),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  0xce4(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x88(%rbp),%rax
movsd  -0x20(%rbp),%xmm1
mov    -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1385 <main+0x265>
mov    -0x88(%rbp),%rax
mov    -0x60(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x60(%rbp)
jmp    1337 <main+0x217>
mov    -0x88(%rbp),%rax
movsd  -0x20(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x60(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movl   $0x0,-0x54(%rbp)
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    121c <main+0xfc>
movsd  -0x40(%rbp),%xmm0
lea    0xc4b(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
lea    0xc41(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x78(%rbp),%rax
mov    %rax,%rsp
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1159 <main+0x39>
xor    %eax,%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
lea    0xec0(%rip),%rdi
lea    -0x2c(%rbp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
cmpl   $0x0,-0x2c(%rbp)
jle    13f4 <main+0x2c4>
mov    $0x1,%ebx
xor    %r14d,%r14d
jmp    11bb <main+0x8b>
nopw   0x0(%rax,%rax,1)
cvtss2sd %xmm0,%xmm0
movsd  -0x40(%rbp),%xmm6
movsd  -0x38(%rbp),%xmm4
movsd  -0x48(%rbp),%xmm1
movsd  %xmm1,-0x48(%rbp)
movsd  %xmm4,-0x38(%rbp)
movsd  %xmm6,-0x40(%rbp)
lea    0xe75(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r15,%rsp
add    $0x1,%r14d
cmp    -0x2c(%rbp),%r14d
jge    13f4 <main+0x2c4>
lea    0xe49(%rip),%rdi
lea    -0x58(%rbp),%rsi
lea    -0x50(%rbp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    %rsp,%r15
cvttsd2si -0x50(%rbp),%r8
mov    %rsp,%rax
lea    0x1b(,%r8,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rax,%rcx
sub    %rdx,%rcx
mov    %rcx,%rsp
movsd  -0x58(%rbp),%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
movl   $0x0,(%rcx)
movsd  0xdf4(%rip),%xmm5
mulsd  %xmm5,%xmm0
cvtsd2ss %xmm0,%xmm0
neg    %rdx
movss  %xmm0,0x4(%rax,%rdx,1)
movss  %xmm1,0x8(%rcx)
cmp    $0x1,%r8
je     1170 <main+0x40>
jg     1250 <main+0x120>
movsd  -0x48(%rbp),%xmm1
movaps %xmm1,%xmm0
movsd  -0x40(%rbp),%xmm6
movsd  -0x38(%rbp),%xmm4
jmp    1183 <main+0x53>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r8
lea    0xc(%rcx),%rdx
mov    $0x2,%esi
mov    $0x3,%r10d
mov    $0x1,%r12d
xor    %r9d,%r9d
movsd  -0x40(%rbp),%xmm6
movsd  -0x38(%rbp),%xmm4
jmp    12ac <main+0x17c>
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
movss  %xmm1,0x4(%rcx,%rax,4)
add    $0x1,%rsi
lea    0x1(%r10),%rax
add    $0x1,%r12
add    $0x4,%rdx
movaps %xmm0,%xmm1
cmp    %r8,%r10
mov    %rax,%r10
je     1183 <main+0x53>
mov    %r9,%rax
add    $0x1,%r9
movss  0x4(%rcx),%xmm0
test   %rax,%rax
je     1350 <main+0x220>
mov    %r12,%r11
and    $0xfffffffffffffffe,%r11
neg    %r11
xor    %edi,%edi
mov    $0x2,%eax
movaps %xmm4,%xmm1
jmp    12f5 <main+0x1c5>
nopw   0x0(%rax,%rax,1)
movaps %xmm1,%xmm4
lea    (%r11,%rax,1),%r13
add    $0x2,%r13
add    $0x2,%rax
cmp    $0x2,%r13
je     1357 <main+0x227>
movss  (%rcx,%rax,4),%xmm2
movaps %xmm2,%xmm3
movaps %xmm0,%xmm4
subss  -0x8(%rcx,%rax,4),%xmm4
subss  %xmm0,%xmm3
ucomiss %xmm4,%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm2,%xmm4
jbe    1320 <main+0x1f0>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movaps %xmm4,%xmm6
movss  0x4(%rcx,%rax,4),%xmm0
movaps %xmm0,%xmm3
subss  %xmm2,%xmm3
cmova  %ebx,%edi
subss  -0x4(%rcx,%rax,4),%xmm2
ucomiss %xmm2,%xmm3
cmova  %ebx,%edi
jbe    12e0 <main+0x1b0>
xorps  %xmm6,%xmm6
cvtss2sd %xmm0,%xmm6
movaps %xmm4,%xmm1
jmp    12e3 <main+0x1b3>
nopw   0x0(%rax,%rax,1)
xor    %edi,%edi
mov    $0x2,%eax
test   $0x1,%r9b
je     1388 <main+0x258>
movss  (%rcx,%rax,4),%xmm1
movaps %xmm1,%xmm2
subss  %xmm0,%xmm2
movaps %xmm0,%xmm3
subss  -0x8(%rcx,%rax,4),%xmm3
ucomiss %xmm3,%xmm2
cmova  %ebx,%edi
jbe    1388 <main+0x258>
xorps  %xmm6,%xmm6
cvtss2sd %xmm1,%xmm6
xorps  %xmm4,%xmm4
cvtss2sd %xmm0,%xmm4
cmp    $0x1,%edi
jne    13a0 <main+0x270>
movaps %xmm4,%xmm0
addsd  %xmm6,%xmm0
jmp    13ad <main+0x27d>
cs nopw 0x0(%rax,%rax,1)
movss  (%rcx),%xmm0
addss  0x4(%rcx),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm5,%xmm0
movss  (%rcx,%rsi,4),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
ucomisd %xmm0,%xmm2
mov    %rsi,%rax
jbe    1280 <main+0x150>
xor    %eax,%eax
nopl   0x0(%rax)
movss  %xmm1,(%rdx,%rax,4)
movss  -0x8(%rdx,%rax,4),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
add    $0xffffffffffffffff,%rax
ucomisd %xmm0,%xmm2
ja     13d0 <main+0x2a0>
add    %rsi,%rax
jmp    1280 <main+0x150>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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