#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 */
scalar_t__ EOF;
float fmod(float, float);
int /*<<< orphan*/ printf(char *, float);
scalar_t__ scanf(char *, float *);
int main() {
  float x, arr[64], sum, numbers, a;
  int i, k, count, help;
  scanf("%f", &x);
  arr[0] = x;
  numbers = 1;
  sum = 0;
  help = 0;
  for (i = 1; scanf("%f", &x) != EOF; i++) {
    if (i == 64)
      break;
    count = 0;
    for (k = help; k >= 0; k--) {
      if (x != arr[k]) {
        count++;
      }
    }
    if (count == help + 1) {
      arr[help + 1] = x;
      numbers++;
      help++;
    }
  }
  printf("%.0f\n", numbers);
  for (i = 0; i < numbers; i++) {
    a = fmod(arr[i], numbers);
    sum = sum + a;
  }
  printf("%.3f", sum);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xebb(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1050 <scanf@plt>
movss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  0xe99(%rip),%xmm0
movss  %xmm0,-0x118(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x114(%rbp)
ff
movl   $0x0,-0x12c(%rbp)
movl   $0x1,-0x120(%rbp)
lea    0xe6f(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1050 <scanf@plt>
mov    0x2e43(%rip),%rcx
cmp    (%rcx),%rax
je     12a0 <main+0x170>
cmpl   $0x40,-0x120(%rbp)
jne    11c0 <main+0x90>
jmp    12a0 <main+0x170>
movl   $0x0,-0x128(%rbp)
mov    -0x12c(%rbp),%eax
mov    %eax,-0x124(%rbp)
cmpl   $0x0,-0x124(%rbp)
jl     1230 <main+0x100>
movss  -0x8(%rbp),%xmm0
movslq -0x124(%rbp),%rax
ucomiss -0x110(%rbp,%rax,4),%xmm0
ff
jne    1208 <main+0xd8>
jp     1208 <main+0xd8>
jmp    1217 <main+0xe7>
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    121c <main+0xec>
mov    -0x124(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x124(%rbp)
jmp    11d6 <main+0xa6>
mov    -0x128(%rbp),%eax
mov    -0x12c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1287 <main+0x157>
movss  -0x8(%rbp),%xmm0
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
cltq
movss  %xmm0,-0x110(%rbp,%rax,4)
ff ff
movss  0xd98(%rip),%xmm0
addss  -0x118(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
jmp    128c <main+0x15c>
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    118e <main+0x5e>
movss  -0x118(%rbp),%xmm0
ff
lea    0xd58(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x120(%rbp)
cvtsi2ssl -0x120(%rbp),%xmm1
ff
movss  -0x118(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1328 <main+0x1f8>
movslq -0x120(%rbp),%rax
movss  -0x110(%rbp,%rax,4),%xmm0
ff ff
movss  -0x118(%rbp),%xmm1
ff
call   1040 <fmod@plt>
movss  %xmm0,-0x11c(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
addss  -0x11c(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    12be <main+0x18e>
movss  -0x114(%rbp),%xmm0
ff
lea    0xcd6(%rip),%rdi
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
lea    0xebc(%rip),%rbx
lea    0x8(%rsp),%r14
mov    %rbx,%rdi
mov    %r14,%rsi
call   1050 <scanf@plt>
movss  0x8(%rsp),%xmm0
movss  %xmm0,0x10(%rsp)
mov    %rbx,%rdi
mov    %r14,%rsi
call   1050 <scanf@plt>
mov    0x2e72(%rip),%r13
cmp    0x0(%r13),%rax
jne    119d <main+0x6d>
lea    0xe84(%rip),%rdi
movss  0xe75(%rip),%xmm0
call   1030 <printf@plt>
movss  0xe68(%rip),%xmm0
jmp    136b <main+0x23b>
movss  0xe5b(%rip),%xmm0
mov    $0x1,%ebp
xor    %ebx,%ebx
lea    0x4(%rsp),%r12
lea    0xe4c(%rip),%r14
lea    0x8(%rsp),%r15
movss  %xmm0,0x4(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x0,%esi
test   %ebx,%ebx
js     12e7 <main+0x1b7>
movss  0x8(%rsp),%xmm0
mov    %ebx,%eax
xor    %esi,%esi
cmp    $0x7,%ebx
jb     12d0 <main+0x1a0>
lea    0x1(%rax),%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%r9),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1332 <main+0x202>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r12,%rax,4),%rcx
pxor   %xmm2,%xmm2
xor    %edi,%edi
pxor   %xmm3,%xmm3
nop
movups -0x30(%rcx,%rdi,4),%xmm4
movups -0x20(%rcx,%rdi,4),%xmm5
movups -0x10(%rcx,%rdi,4),%xmm6
movups (%rcx,%rdi,4),%xmm7
shufps $0x1b,%xmm7,%xmm7
shufps $0x1b,%xmm6,%xmm6
cmpneqps %xmm1,%xmm7
psubd  %xmm7,%xmm2
cmpneqps %xmm1,%xmm6
psubd  %xmm6,%xmm3
shufps $0x1b,%xmm5,%xmm5
shufps $0x1b,%xmm4,%xmm4
cmpneqps %xmm1,%xmm5
psubd  %xmm5,%xmm2
cmpneqps %xmm1,%xmm4
psubd  %xmm4,%xmm3
add    $0xfffffffffffffff0,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1230 <main+0x100>
neg    %rdi
test   $0x1,%dl
je     12ad <main+0x17d>
mov    %rax,%rcx
sub    %rdi,%rcx
movups -0xc(%rsp,%rcx,4),%xmm4
movups 0x4(%rsp,%rcx,4),%xmm5
shufps $0x1b,%xmm5,%xmm5
shufps $0x1b,%xmm4,%xmm4
cmpneqps %xmm1,%xmm5
psubd  %xmm5,%xmm2
cmpneqps %xmm1,%xmm4
psubd  %xmm4,%xmm3
paddd  %xmm3,%xmm2
pshufd $0xee,%xmm2,%xmm1
paddd  %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm2
paddd  %xmm1,%xmm2
movd   %xmm2,%esi
cmp    %r9,%r8
je     12e7 <main+0x1b7>
sub    %r9,%rax
nop
movss  0x10(%rsp,%rax,4),%xmm1
cmpneqss %xmm0,%xmm1
movd   %xmm1,%ecx
sub    %ecx,%esi
add    $0xffffffffffffffff,%rax
jb     12d0 <main+0x1a0>
lea    0x1(%rbx),%eax
cmp    %eax,%esi
jne    1313 <main+0x1e3>
movss  0x8(%rsp),%xmm0
movslq %esi,%rax
movss  %xmm0,0x10(%rsp,%rax,4)
movss  0x4(%rsp),%xmm0
addss  0xcf5(%rip),%xmm0
movss  %xmm0,0x4(%rsp)
mov    %esi,%ebx
mov    %r14,%rdi
mov    %r15,%rsi
call   1050 <scanf@plt>
cmp    0x0(%r13),%rax
je     134a <main+0x21a>
add    $0x1,%ebp
cmp    $0x40,%ebp
jne    11d0 <main+0xa0>
jmp    134a <main+0x21a>
pxor   %xmm2,%xmm2
xor    %edi,%edi
pxor   %xmm3,%xmm3
test   $0x1,%dl
jne    1285 <main+0x155>
jmp    12ad <main+0x17d>
lea    0xcb6(%rip),%rdi
movss  0x4(%rsp),%xmm0
call   1030 <printf@plt>
movss  0x4(%rsp),%xmm0
pxor   %xmm2,%xmm2
ucomiss %xmm2,%xmm0
jbe    13b7 <main+0x287>
xorps  %xmm2,%xmm2
xor    %ebx,%ebx
movss  %xmm0,0x4(%rsp)
cs nopw 0x0(%rax,%rax,1)
movss  %xmm2,0xc(%rsp)
movss  0x10(%rsp,%rbx,4),%xmm0
movss  0x4(%rsp),%xmm1
call   1040 <fmod@plt>
movss  0xc(%rsp),%xmm2
add    $0x1,%rbx
xorps  %xmm1,%xmm1
cvtsi2ss %ebx,%xmm1
addss  %xmm0,%xmm2
movss  0x4(%rsp),%xmm0
ucomiss %xmm1,%xmm0
ja     1380 <main+0x250>
lea    0xc4f(%rip),%rdi
movaps %xmm2,%xmm0
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%f\00"
@EOF = global i64 0
@.str.1 = [6 x i8] c"%.0f\0A\00"
@.str.2 = [5 x i8] c"%.3f\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca float
%3 = alloca [64 x float]
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i32 0, i32* %1
%11 = call i64 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), float* %2)
%12 = load float, float* %2
%13 = getelementptr inbounds [64 x float], [64 x float]* %3, i64 0, i64 0
store float %12, float* %13
store float 1.000000e+00, float* %5
store float 0.000000e+00, float* %4
store i32 0, i32* %10
store i32 1, i32* %7
br label %14
14: ; preds = %57, %0
%15 = call i64 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), float* %2)
%16 = load i64, i64* @EOF
%17 = icmp ne i64 %15, %16
br i1 %17, label %18, label %60
18: ; preds = %14
%19 = load i32, i32* %7
%20 = icmp eq i32 %19, 64
br i1 %20, label %21, label %22
21: ; preds = %18
br label %60
22: ; preds = %18
store i32 0, i32* %9
%23 = load i32, i32* %10
store i32 %23, i32* %8
br label %24
24: ; preds = %38, %22
%25 = load i32, i32* %8
%26 = icmp sge i32 %25, 0
br i1 %26, label %27, label %41
27: ; preds = %24
%28 = load float, float* %2
%29 = load i32, i32* %8
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [64 x float], [64 x float]* %3, i64 0, i64 %30
%32 = load float, float* %31
%33 = fcmp une float %28, %32
br i1 %33, label %34, label %37
34: ; preds = %27
%35 = load i32, i32* %9
%36 = add nsw i32 %35, 1
store i32 %36, i32* %9
br label %37
37: ; preds = %34, %27
br label %38
38: ; preds = %37
%39 = load i32, i32* %8
%40 = add nsw i32 %39, -1
store i32 %40, i32* %8
br label %24
41: ; preds = %24
%42 = load i32, i32* %9
%43 = load i32, i32* %10
%44 = add nsw i32 %43, 1
%45 = icmp eq i32 %42, %44
br i1 %45, label %46, label %56
46: ; preds = %41
%47 = load float, float* %2
%48 = load i32, i32* %10
%49 = add nsw i32 %48, 1
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [64 x float], [64 x float]* %3, i64 0, i64 %50
store float %47, float* %51
%52 = load float, float* %5
%53 = fadd float %52, 1.000000e+00
store float %53, float* %5
%54 = load i32, i32* %10
%55 = add nsw i32 %54, 1
store i32 %55, i32* %10
br label %56
56: ; preds = %46, %41
br label %57
57: ; preds = %56
%58 = load i32, i32* %7
%59 = add nsw i32 %58, 1
store i32 %59, i32* %7
br label %14
60: ; preds = %21, %14
%61 = load float, float* %5
%62 = call i32 @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), float %61)
store i32 0, i32* %7
br label %63
63: ; preds = %78, %60
%64 = load i32, i32* %7
%65 = sitofp i32 %64 to float
%66 = load float, float* %5
%67 = fcmp olt float %65, %66
br i1 %67, label %68, label %81
68: ; preds = %63
%69 = load i32, i32* %7
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [64 x float], [64 x float]* %3, i64 0, i64 %70
%72 = load float, float* %71
%73 = load float, float* %5
%74 = call float @fmod(float %72, float %73)
store float %74, float* %6
%75 = load float, float* %4
%76 = load float, float* %6
%77 = fadd float %75, %76
store float %77, float* %4
br label %78
78: ; preds = %68
%79 = load i32, i32* %7
%80 = add nsw i32 %79, 1
store i32 %80, i32* %7
br label %63
81: ; preds = %63
%82 = load float, float* %4
%83 = call i32 @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), float %82)
%84 = load i32, i32* %1
ret i32 %84
}

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