#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*/ FREE(float *);
scalar_t__ MALLOC(int);
float exp(double);
float hz2bark(float);
double pow(int, float);
void barkweights(int nfreqs, int Fs, float dB, float *wts, int *indices,
                 int *nbands) {
  float nyqbark = hz2bark(Fs / 2);
  float step_barks = nyqbark / (*nbands - 1);
  float *binbarks = (float *)MALLOC(nfreqs * sizeof(float));
  for (int i = 0; i < nfreqs; i++) {
    binbarks[i] = hz2bark(((float)i * (Fs / 2)) / (nfreqs - 1));
  }
  for (int i = 0; i < *nbands; i++) {
    float f_bark_mid = i * step_barks;
    for (int j = 0; j < nfreqs; j++) {
      wts[i * nfreqs + j] = exp(-0.5 * pow(binbarks[j] - f_bark_mid, 2));
    }
  }
  float lin = pow(10, -dB / 20);
  for (int i = 0; i < *nbands; i++) {
    int j = 0;
    while (wts[i * nfreqs + (j++)] < lin)
      ;
    indices[i * 2] = j - 1;
    j = nfreqs - 1;
    while (wts[i * nfreqs + (j--)] < lin)
      ;
    indices[i * 2 + 1] = j + 1;
  }
  FREE(binbarks);
}


x86 assembly (clang, -O0):
<barkweights>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cvtsi2ss %eax,%xmm0
call   1030 <hz2bark@plt>
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <MALLOC@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    120f <barkweights+0xbf>
cvtsi2ssl -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cvtsi2ss %eax,%xmm1
mulss  %xmm1,%xmm0
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
call   1030 <hz2bark@plt>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11bd <barkweights+0x6d>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    12b5 <barkweights+0x165>
cvtsi2ssl -0x40(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12a2 <barkweights+0x152>
mov    -0x38(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x44(%rbp),%xmm0
cvttss2si %xmm0,%edi
movss  0xd9f(%rip),%xmm0
call   1070 <pow@plt>
movaps %xmm0,%xmm1
movsd  0xd93(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1050 <exp@plt>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    123b <barkweights+0xeb>
jmp    12a7 <barkweights+0x157>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1216 <barkweights+0xc6>
movss  -0xc(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  0xd31(%rip),%xmm1
divss  %xmm1,%xmm0
mov    $0xa,%edi
call   1070 <pow@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    13af <barkweights+0x25f>
movl   $0x0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    %edx,%esi
add    $0x1,%esi
mov    %esi,-0x54(%rbp)
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1336 <barkweights+0x1e6>
jmp    1303 <barkweights+0x1b3>
mov    -0x54(%rbp),%edx
sub    $0x1,%edx
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0x54(%rbp),%edx
mov    %edx,%esi
add    $0xffffffff,%esi
mov    %esi,-0x54(%rbp)
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x4c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1388 <barkweights+0x238>
jmp    1355 <barkweights+0x205>
mov    -0x54(%rbp),%edx
add    $0x1,%edx
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12ed <barkweights+0x19d>
mov    -0x38(%rbp),%rdi
call   1040 <FREE@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<barkweights>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r8,%r13
mov    %rcx,0x30(%rsp)
mov    %rdx,%r15
movss  %xmm0,0x1c(%rsp)
mov    %edi,%ebp
mov    %esi,%eax
shr    $0x1f,%eax
add    %esi,%eax
sar    %eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x4(%rsp)
call   1030 <hz2bark@plt>
movss  %xmm0,(%rsp)
mov    0x0(%r13),%r12d
lea    0x0(,%rbp,4),%edi
call   1060 <MALLOC@plt>
mov    %rax,%rbx
mov    %ebp,%r14d
mov    %rbp,0x8(%rsp)
test   %ebp,%ebp
jle    11f6 <barkweights+0xa6>
mov    0x8(%rsp),%rax
add    $0xffffffff,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x10(%rsp)
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
mulss  0x4(%rsp),%xmm0
divss  0x10(%rsp),%xmm0
call   1030 <hz2bark@plt>
movss  %xmm0,(%rbx,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    11d0 <barkweights+0x80>
mov    %r13,0x28(%rsp)
mov    0x0(%r13),%eax
mov    0x8(%rsp),%rdx
movslq %edx,%rcx
mov    %rcx,0x20(%rsp)
test   %eax,%eax
jle    12cb <barkweights+0x17b>
add    $0xffffffff,%r12d
xorps  %xmm0,%xmm0
cvtsi2ss %r12d,%xmm0
movss  (%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rsp)
mov    0x20(%rsp),%rcx
lea    0x0(,%rcx,4),%rcx
mov    %rcx,0x10(%rsp)
xor    %r12d,%r12d
movss  0xdb5(%rip),%xmm1
mov    %r15,%r13
jmp    1261 <barkweights+0x111>
add    $0x1,%r12
movslq %eax,%rcx
add    0x10(%rsp),%r13
cmp    %rcx,%r12
jge    12cb <barkweights+0x17b>
test   %edx,%edx
jle    1250 <barkweights+0x100>
xorps  %xmm2,%xmm2
cvtsi2ss %r12d,%xmm2
mulss  (%rsp),%xmm2
movss  %xmm2,0x4(%rsp)
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movss  (%rbx,%rbp,4),%xmm0
subss  0x4(%rsp),%xmm0
cvttss2si %xmm0,%edi
movapd %xmm1,%xmm0
call   1070 <pow@plt>
mulsd  0xd68(%rip),%xmm0
call   1050 <exp@plt>
movss  0xd53(%rip),%xmm1
movss  %xmm0,0x0(%r13,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1280 <barkweights+0x130>
mov    0x28(%rsp),%rax
mov    (%rax),%eax
mov    0x8(%rsp),%rdx
jmp    1250 <barkweights+0x100>
movss  0x1c(%rsp),%xmm0
divss  0xd2b(%rip),%xmm0
mov    $0xa,%edi
call   1070 <pow@plt>
mov    0x8(%rsp),%r9
mov    0x28(%rsp),%r8
cmpl   $0x0,(%r8)
mov    0x30(%rsp),%r10
mov    0x20(%rsp),%rbp
jle    136a <barkweights+0x21a>
cvtsd2ss %xmm0,%xmm0
lea    (%r15,%rbp,4),%rax
add    $0xfffffffffffffffc,%rax
shl    $0x2,%rbp
xor    %ecx,%ecx
nop
mov    $0xffffffff,%esi
mov    %r15,%rdx
nopl   0x0(%rax,%rax,1)
add    $0x1,%esi
ucomiss (%rdx),%xmm0
lea    0x4(%rdx),%rdx
ja     1320 <barkweights+0x1d0>
lea    (%rcx,%rcx,1),%rdx
mov    %esi,(%r10,%rcx,8)
mov    %rax,%rdi
mov    %r9d,%esi
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%esi
ucomiss (%rdi),%xmm0
lea    -0x4(%rdi),%rdi
ja     1340 <barkweights+0x1f0>
shl    $0x2,%rdx
or     $0x4,%rdx
mov    %esi,(%r10,%rdx,1)
add    $0x1,%rcx
movslq (%r8),%rdx
add    %rbp,%r15
add    %rbp,%rax
cmp    %rdx,%rcx
jl     1310 <barkweights+0x1c0>
mov    %rbx,%rdi
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <FREE@plt>

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

LLVM IR (-O2):
define void @barkweights(i32 %0, i32 %1, float %2, float* nocapture %3, i32* nocapture writeonly %4, i32* nocapture %5) {
%7 = sdiv i32 %1, 2
%8 = sitofp i32 %7 to float
%9 = tail call float @hz2bark(float %8)
%10 = load i32, i32* %5
%11 = add nsw i32 %10, -1
%12 = sitofp i32 %11 to float
%13 = fdiv float %9, %12
%14 = shl i32 %0, 2
%15 = tail call i64 @MALLOC(i32 %14)
%16 = inttoptr i64 %15 to float*
%17 = icmp sgt i32 %0, 0
br i1 %17, label %18, label %22
18: ; preds = %6
%19 = add nsw i32 %0, -1
%20 = sitofp i32 %19 to float
%21 = zext i32 %0 to i64
br label %28
22: ; preds = %28, %6
%23 = load i32, i32* %5
%24 = icmp sgt i32 %23, 0
br i1 %24, label %25, label %38
25: ; preds = %22
%26 = sext i32 %0 to i64
%27 = zext i32 %0 to i64
br label %46
28: ; preds = %18, %28
%29 = phi i64 [ 0, %18 ], [ %36, %28 ]
%30 = trunc i64 %29 to i32
%31 = sitofp i32 %30 to float
%32 = fmul float %8, %31
%33 = fdiv float %32, %20
%34 = tail call float @hz2bark(float %33)
%35 = getelementptr inbounds float, float* %16, i64 %29
store float %34, float* %35
%36 = add nuw nsw i64 %29, 1
%37 = icmp eq i64 %36, %21
br i1 %37, label %22, label %28
38: ; preds = %56, %22
%39 = fdiv float %2, -2.000000e+01
%40 = tail call double @pow(i32 10, float %39)
%41 = fptrunc double %40 to float
%42 = load i32, i32* %5
%43 = icmp sgt i32 %42, 0
br i1 %43, label %44, label %77
44: ; preds = %38
%45 = sext i32 %0 to i64
br label %74
46: ; preds = %25, %56
%47 = phi i32 [ %23, %25 ], [ %57, %56 ]
%48 = phi i64 [ 0, %25 ], [ %58, %56 ]
%49 = trunc i64 %48 to i32
%50 = sitofp i32 %49 to float
%51 = fmul float %13, %50
br i1 %17, label %52, label %56
52: ; preds = %46
%53 = mul nsw i64 %48, %26
br label %61
54: ; preds = %61
%55 = load i32, i32* %5
br label %56
56: ; preds = %54, %46
%57 = phi i32 [ %55, %54 ], [ %47, %46 ]
%58 = add nuw nsw i64 %48, 1
%59 = sext i32 %57 to i64
%60 = icmp slt i64 %58, %59
br i1 %60, label %46, label %38
61: ; preds = %52, %61
%62 = phi i64 [ 0, %52 ], [ %72, %61 ]
%63 = getelementptr inbounds float, float* %16, i64 %62
%64 = load float, float* %63
%65 = fsub float %64, %51
%66 = fptosi float %65 to i32
%67 = tail call double @pow(i32 %66, float 2.000000e+00)
%68 = fmul double %67, -5.000000e-01
%69 = tail call float @exp(double %68)
%70 = add nsw i64 %62, %53
%71 = getelementptr inbounds float, float* %3, i64 %70
store float %69, float* %71
%72 = add nuw nsw i64 %62, 1
%73 = icmp eq i64 %72, %27
br i1 %73, label %54, label %61
74: ; preds = %44, %97
%75 = phi i64 [ 0, %44 ], [ %101, %97 ]
%76 = mul nsw i64 %75, %45
br label %79
77: ; preds = %97, %38
%78 = tail call i32 @FREE(float* %16)
ret void
79: ; preds = %74, %79
%80 = phi i64 [ 0, %74 ], [ %81, %79 ]
%81 = add nuw i64 %80, 1
%82 = add nsw i64 %80, %76
%83 = getelementptr inbounds float, float* %3, i64 %82
%84 = load float, float* %83
%85 = fcmp olt float %84, %41
br i1 %85, label %79, label %86
86: ; preds = %79
%87 = trunc i64 %80 to i32
%88 = shl nuw nsw i64 %75, 1
%89 = getelementptr inbounds i32, i32* %4, i64 %88
store i32 %87, i32* %89
br label %90
90: ; preds = %90, %86
%91 = phi i64 [ %92, %90 ], [ %45, %86 ]
%92 = add i64 %91, -1
%93 = add nsw i64 %92, %76
%94 = getelementptr inbounds float, float* %3, i64 %93
%95 = load float, float* %94
%96 = fcmp olt float %95, %41
br i1 %96, label %90, label %97
97: ; preds = %90
%98 = trunc i64 %92 to i32
%99 = or i64 %88, 1
%100 = getelementptr inbounds i32, i32* %4, i64 %99
store i32 %98, i32* %100
%101 = add nuw nsw i64 %75, 1
%102 = load i32, i32* %5
%103 = sext i32 %102 to i64
%104 = icmp slt i64 %101, %103
br i1 %104, label %74, label %77
}