#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*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, int, int, int);
void calcPivotPoints(float *histogram, int histosize, int listsize,
                     int divisions, float min, float max, float *pivotPoints,
                     float histo_width) {
  float elemsPerSlice = listsize / (float)divisions;
  float startsAt = min;
  float endsAt = min + histo_width;
  float we_need = elemsPerSlice;
  int p_idx = 0;
  for (int i = 0; i < histosize; i++) {
    if (i == histosize - 1) {
      if (!(p_idx < divisions)) {
        pivotPoints[p_idx++] =
            startsAt + (we_need / histogram[i]) * histo_width;
      }
      break;
    }
    while (histogram[i] > we_need) {
      if (!(p_idx < divisions)) {
        printf("i=%d, p_idx = %d, divisions = %d\n", i, p_idx, divisions);
        exit(0);
      }
      pivotPoints[p_idx++] = startsAt + (we_need / histogram[i]) * histo_width;
      startsAt += (we_need / histogram[i]) * histo_width;
      histogram[i] -= we_need;
      we_need = elemsPerSlice;
    }
    we_need -= histogram[i];
    startsAt = endsAt;
    endsAt += histo_width;
  }
  while (p_idx < divisions) {
    pivotPoints[p_idx] = pivotPoints[p_idx - 1];
    p_idx++;
  }
}


x86 assembly (clang, -O0):
<calcPivotPoints>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movss  %xmm2,-0x2c(%rbp)
cvtsi2ssl -0x10(%rbp),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x18(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1309 <calcPivotPoints+0x1e9>
mov    -0x44(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    11f5 <calcPivotPoints+0xd5>
mov    -0x40(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     11f0 <calcPivotPoints+0xd0>
movss  -0x34(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1309 <calcPivotPoints+0x1e9>
jmp    11fa <calcPivotPoints+0xda>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x3c(%rbp),%xmm0
jbe    12c7 <calcPivotPoints+0x1a7>
mov    -0x40(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1239 <calcPivotPoints+0x119>
mov    -0x44(%rbp),%esi
mov    -0x40(%rbp),%edx
mov    -0x14(%rbp),%ecx
lea    0xdd3(%rip),%rdi
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
movss  -0x34(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x3c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    11fa <calcPivotPoints+0xda>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x3c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    118c <calcPivotPoints+0x6c>
jmp    130e <calcPivotPoints+0x1ee>
mov    -0x40(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1347 <calcPivotPoints+0x227>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    130e <calcPivotPoints+0x1ee>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calcPivotPoints>:
push   %rax
test   %esi,%esi
jle    1219 <calcPivotPoints+0xf9>
cvtsi2ss %edx,%xmm1
cvtsi2ss %ecx,%xmm3
divss  %xmm3,%xmm1
xor    %edx,%edx
add    $0xffffffff,%esi
je     121d <calcPivotPoints+0xfd>
movaps %xmm1,%xmm3
xor    %eax,%eax
jmp    1168 <calcPivotPoints+0x48>
nopw   0x0(%rax,%rax,1)
movaps %xmm1,%xmm3
subss  %xmm4,%xmm3
addss  %xmm2,%xmm0
add    $0x1,%rax
cmp    %rsi,%rax
je     1220 <calcPivotPoints+0x100>
movss  (%rdi,%rax,4),%xmm4
ucomiss %xmm3,%xmm4
jbe    1153 <calcPivotPoints+0x33>
mov    %ecx,%r9d
cmp    %ecx,%edx
cmovg  %edx,%r9d
jge    12d5 <calcPivotPoints+0x1b5>
movslq %edx,%rdx
movaps %xmm3,%xmm5
divss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm0,%xmm5
movss  %xmm5,(%r8,%rdx,4)
add    $0x1,%rdx
movss  (%rdi,%rax,4),%xmm5
movaps %xmm5,%xmm4
subss  %xmm3,%xmm4
movss  %xmm4,(%rdi,%rax,4)
ucomiss %xmm1,%xmm4
jbe    1150 <calcPivotPoints+0x30>
movslq %r9d,%r10
divss  %xmm5,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm0,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %rdx,%r10
je     12d2 <calcPivotPoints+0x1b2>
movaps %xmm1,%xmm5
divss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm3,%xmm5
movss  %xmm5,(%r8,%rdx,4)
add    $0x1,%rdx
movss  (%rdi,%rax,4),%xmm4
movaps %xmm1,%xmm5
divss  %xmm4,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm5,%xmm3
subss  %xmm1,%xmm4
movss  %xmm4,(%rdi,%rax,4)
ucomiss %xmm1,%xmm4
ja     11d0 <calcPivotPoints+0xb0>
jmp    1150 <calcPivotPoints+0x30>
xor    %edx,%edx
jmp    123d <calcPivotPoints+0x11d>
movaps %xmm1,%xmm3
cmp    %ecx,%edx
jl     123d <calcPivotPoints+0x11d>
divss  (%rdi,%rsi,4),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm0,%xmm3
movslq %edx,%rax
add    $0x1,%edx
movss  %xmm3,(%r8,%rax,4)
cmp    %ecx,%edx
jge    12d0 <calcPivotPoints+0x1b0>
movslq %edx,%rax
movslq %ecx,%rsi
movss  -0x4(%r8,%rax,4),%xmm0
sub    %edx,%ecx
mov    %rax,%rdx
not    %rdx
add    %rsi,%rdx
and    $0x7,%rcx
je     1280 <calcPivotPoints+0x160>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  %xmm0,(%r8,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    1270 <calcPivotPoints+0x150>
cmp    $0x7,%rdx
jb     12d0 <calcPivotPoints+0x1b0>
cs nopw 0x0(%rax,%rax,1)
movss  %xmm0,(%r8,%rax,4)
movss  %xmm0,0x4(%r8,%rax,4)
movss  %xmm0,0x8(%r8,%rax,4)
movss  %xmm0,0xc(%r8,%rax,4)
movss  %xmm0,0x10(%r8,%rax,4)
movss  %xmm0,0x14(%r8,%rax,4)
movss  %xmm0,0x18(%r8,%rax,4)
movss  %xmm0,0x1c(%r8,%rax,4)
add    $0x8,%rax
cmp    %rax,%rsi
jne    1290 <calcPivotPoints+0x170>
pop    %rax
ret
mov    %r9d,%edx
lea    0xd24(%rip),%rdi
mov    %eax,%esi
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>

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

LLVM IR (-O2):
@.str = [34 x i8] c"i=%d, p_idx = %d, divisions = %d\0A\00"
define void @calcPivotPoints(float* nocapture %0, i32 %1, i32 %2, i32 %3, float %4, float %5, float* nocapture %6, float %7) {
%9 = sitofp i32 %2 to float
%10 = sitofp i32 %3 to float
%11 = fdiv float %9, %10
%12 = icmp sgt i32 %1, 0
br i1 %12, label %13, label %86
13: ; preds = %8
%14 = add nsw i32 %1, -1
%15 = zext i32 %14 to i64
%16 = icmp eq i32 %14, 0
br i1 %16, label %42, label %17
17: ; preds = %13, %79
%18 = phi float [ %22, %79 ], [ %4, %13 ]
%19 = phi float [ %83, %79 ], [ %11, %13 ]
%20 = phi i32 [ %81, %79 ], [ 0, %13 ]
%21 = phi i64 [ %84, %79 ], [ 0, %13 ]
%22 = fadd float %18, %7
%23 = getelementptr inbounds float, float* %0, i64 %21
%24 = load float, float* %23
%25 = fcmp ogt float %24, %19
br i1 %25, label %26, label %79
26: ; preds = %17
%27 = sext i32 %20 to i64
%28 = call i32 @llvm.smax.i32(i32 %20, i32 %3)
%29 = sext i32 %28 to i64
%30 = icmp slt i32 %20, %3
br i1 %30, label %31, label %60
31: ; preds = %26
%32 = fdiv float %19, %24
%33 = tail call float @llvm.fmuladd.f32(float %32, float %7, float %18)
%34 = add nsw i64 %27, 1
%35 = getelementptr inbounds float, float* %6, i64 %27
store float %33, float* %35
%36 = load float, float* %23
%37 = fsub float %36, %19
store float %37, float* %23
%38 = fcmp ogt float %37, %11
br i1 %38, label %39, label %75
39: ; preds = %31
%40 = fdiv float %19, %36
%41 = tail call float @llvm.fmuladd.f32(float %40, float %7, float %18)
br label %55
42: ; preds = %79, %13
%43 = phi i32 [ 0, %13 ], [ %81, %79 ]
%44 = phi float [ %11, %13 ], [ %83, %79 ]
%45 = phi float [ %4, %13 ], [ %22, %79 ]
%46 = icmp slt i32 %43, %3
br i1 %46, label %86, label %47
47: ; preds = %42
%48 = getelementptr inbounds float, float* %0, i64 %15
%49 = load float, float* %48
%50 = fdiv float %44, %49
%51 = tail call float @llvm.fmuladd.f32(float %50, float %7, float %45)
%52 = add nsw i32 %43, 1
%53 = sext i32 %43 to i64
%54 = getelementptr inbounds float, float* %6, i64 %53
store float %51, float* %54
br label %86
55: ; preds = %39, %65
%56 = phi i64 [ %34, %39 ], [ %68, %65 ]
%57 = phi float [ %37, %39 ], [ %73, %65 ]
%58 = phi float [ %41, %39 ], [ %72, %65 ]
%59 = icmp eq i64 %56, %29
br i1 %59, label %60, label %65
60: ; preds = %26, %55
%61 = phi i32 [ %28, %55 ], [ %20, %26 ]
%62 = trunc i64 %21 to i32
%63 = tail call i32 @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0), i32 %62, i32 %61, i32 %3)
%64 = tail call i32 @exit(i32 0)
unreachable
65: ; preds = %55
%66 = fdiv float %11, %57
%67 = tail call float @llvm.fmuladd.f32(float %66, float %7, float %58)
%68 = add nsw i64 %56, 1
%69 = getelementptr inbounds float, float* %6, i64 %56
store float %67, float* %69
%70 = load float, float* %23
%71 = fdiv float %11, %70
%72 = tail call float @llvm.fmuladd.f32(float %71, float %7, float %58)
%73 = fsub float %70, %11
store float %73, float* %23
%74 = fcmp ogt float %73, %11
br i1 %74, label %55, label %75
75: ; preds = %65, %31
%76 = phi i64 [ %34, %31 ], [ %68, %65 ]
%77 = phi float [ %37, %31 ], [ %73, %65 ]
%78 = trunc i64 %76 to i32
br label %79
79: ; preds = %75, %17
%80 = phi float [ %19, %17 ], [ %11, %75 ]
%81 = phi i32 [ %20, %17 ], [ %78, %75 ]
%82 = phi float [ %24, %17 ], [ %77, %75 ]
%83 = fsub float %80, %82
%84 = add nuw nsw i64 %21, 1
%85 = icmp eq i64 %84, %15
br i1 %85, label %42, label %17
86: ; preds = %8, %42, %47
%87 = phi i32 [ %43, %42 ], [ %52, %47 ], [ 0, %8 ]
%88 = icmp slt i32 %87, %3
br i1 %88, label %89, label %129
89: ; preds = %86
%90 = sext i32 %87 to i64
%91 = sext i32 %3 to i64
%92 = add nsw i64 %90, -1
%93 = getelementptr float, float* %6, i64 %92
%94 = load float, float* %93
%95 = sub nsw i64 %91, %90
%96 = xor i64 %90, -1
%97 = add nsw i64 %96, %91
%98 = and i64 %95, 7
%99 = icmp eq i64 %98, 0
br i1 %99, label %107, label %100
100: ; preds = %89, %100
%101 = phi i64 [ %104, %100 ], [ %90, %89 ]
%102 = phi i64 [ %105, %100 ], [ 0, %89 ]
%103 = getelementptr inbounds float, float* %6, i64 %101
store float %94, float* %103
%104 = add nsw i64 %101, 1
%105 = add i64 %102, 1
%106 = icmp eq i64 %105, %98
br i1 %106, label %107, label %100
107: ; preds = %100, %89
%108 = phi i64 [ %90, %89 ], [ %104, %100 ]
%109 = icmp ult i64 %97, 7
br i1 %109, label %129, label %110
110: ; preds = %107, %110
%111 = phi i64 [ %127, %110 ], [ %108, %107 ]
%112 = getelementptr inbounds float, float* %6, i64 %111
store float %94, float* %112
%113 = add nsw i64 %111, 1
%114 = getelementptr inbounds float, float* %6, i64 %113
store float %94, float* %114
%115 = add nsw i64 %111, 2
%116 = getelementptr inbounds float, float* %6, i64 %115
store float %94, float* %116
%117 = add nsw i64 %111, 3
%118 = getelementptr inbounds float, float* %6, i64 %117
store float %94, float* %118
%119 = add nsw i64 %111, 4
%120 = getelementptr inbounds float, float* %6, i64 %119
store float %94, float* %120
%121 = add nsw i64 %111, 5
%122 = getelementptr inbounds float, float* %6, i64 %121
store float %94, float* %122
%123 = add nsw i64 %111, 6
%124 = getelementptr inbounds float, float* %6, i64 %123
store float %94, float* %124
%125 = add nsw i64 %111, 7
%126 = getelementptr inbounds float, float* %6, i64 %125
store float %94, float* %126
%127 = add nsw i64 %111, 8
%128 = icmp eq i64 %127, %91
br i1 %128, label %129, label %110
129: ; preds = %107, %110, %86
ret void
}