#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__ fabs(float);
float gaindequant(int, float, int);
int /*<<< orphan*/ getCBvec(float *, float *, int, int, int);
void iCBConstruct(float *decvector, int *index, int *gain_index, float *mem,
                  int lMem, int veclen, int nStages) {
  int j, k;
  float gain[3];
  float cbvec[40];
  gain[0] = gaindequant(gain_index[0], 1.0, 32);
  if (nStages > 1) {
    gain[1] = gaindequant(gain_index[1], (float)fabs(gain[0]), 16);
  }
  if (nStages > 2) {
    gain[2] = gaindequant(gain_index[2], (float)fabs(gain[1]), 8);
  }
  getCBvec(cbvec, mem, index[0], lMem, veclen);
  for (j = 0; j < veclen; j++) {
    decvector[j] = gain[0] * cbvec[j];
  }
  if (nStages > 1) {
    for (k = 1; k < nStages; k++) {
      getCBvec(cbvec, mem, index[k], lMem, veclen);
      for (j = 0; j < veclen; j++) {
        decvector[j] += gain[k] * cbvec[j];
      }
    }
  }
}


x86 assembly (clang, -O0):
<iCBConstruct>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%edi
movss  0xe9c(%rip),%xmm0
mov    $0x20,%esi
call   1030 <gaindequant@plt>
movss  %xmm0,-0x3c(%rbp)
cmpl   $0x1,0x10(%rbp)
jle    11ae <iCBConstruct+0x7e>
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xe4(%rbp)
movss  -0x3c(%rbp),%xmm0
call   1040 <fabs@plt>
mov    -0xe4(%rbp),%edi
cvtsi2ss %rax,%xmm0
mov    $0x10,%esi
call   1030 <gaindequant@plt>
movss  %xmm0,-0x38(%rbp)
cmpl   $0x2,0x10(%rbp)
jle    11e9 <iCBConstruct+0xb9>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0xe8(%rbp)
movss  -0x38(%rbp),%xmm0
call   1040 <fabs@plt>
mov    -0xe8(%rbp),%edi
cvtsi2ss %rax,%xmm0
mov    $0x8,%esi
call   1030 <gaindequant@plt>
movss  %xmm0,-0x34(%rbp)
lea    -0xe0(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x10(%rbp),%rax
mov    (%rax),%edx
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%r8d
call   1050 <getCBvec@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1246 <iCBConstruct+0x116>
movss  -0x3c(%rbp),%xmm0
movslq -0x2c(%rbp),%rax
mulss  -0xe0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    120d <iCBConstruct+0xdd>
cmpl   $0x1,0x10(%rbp)
jle    12ef <iCBConstruct+0x1bf>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    12ea <iCBConstruct+0x1ba>
lea    -0xe0(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%r8d
call   1050 <getCBvec@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    12d7 <iCBConstruct+0x1a7>
movslq -0x30(%rbp),%rax
movss  -0x3c(%rbp,%rax,4),%xmm0
movslq -0x2c(%rbp),%rax
movss  -0xe0(%rbp,%rax,4),%xmm2
ff ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    128c <iCBConstruct+0x15c>
jmp    12dc <iCBConstruct+0x1ac>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1257 <iCBConstruct+0x127>
jmp    12ef <iCBConstruct+0x1bf>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<iCBConstruct>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r9d,%ebx
mov    %r8d,0xc(%rsp)
mov    %rcx,0x18(%rsp)
mov    %rdx,%r13
mov    %rsi,0x10(%rsp)
mov    %rdi,%rbp
mov    0x130(%rsp),%r15d
mov    (%rdx),%edi
movss  0xe95(%rip),%xmm0
mov    $0x20,%esi
call   1030 <gaindequant@plt>
movaps %xmm0,0x20(%rsp)
cmp    $0x2,%r15d
jl     11d3 <iCBConstruct+0xa3>
mov    0x4(%r13),%r14d
movaps 0x20(%rsp),%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    %r14d,%edi
mov    $0x10,%esi
call   1030 <gaindequant@plt>
movss  %xmm0,0x48(%rsp)
cmp    $0x2,%r15d
je     11d3 <iCBConstruct+0xa3>
mov    0x8(%r13),%r13d
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
mov    %r13d,%edi
mov    $0x8,%esi
call   1030 <gaindequant@plt>
movss  %xmm0,0x4c(%rsp)
mov    0x10(%rsp),%rax
mov    (%rax),%edx
lea    0x50(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    0xc(%rsp),%ecx
mov    %ebx,%r8d
call   1050 <getCBvec@plt>
mov    %ebx,%r14d
test   %ebx,%ebx
movaps 0x20(%rsp),%xmm3
jle    12c9 <iCBConstruct+0x199>
cmp    $0x8,%ebx
jae    120c <iCBConstruct+0xdc>
xor    %eax,%eax
jmp    12b0 <iCBConstruct+0x180>
mov    %r14d,%eax
and    $0xfffffff8,%eax
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1461 <iCBConstruct+0x331>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movaps 0x50(%rsp,%rdx,4),%xmm1
mulps  %xmm0,%xmm1
movaps 0x60(%rsp,%rdx,4),%xmm2
mulps  %xmm0,%xmm2
movups %xmm1,0x0(%rbp,%rdx,4)
movups %xmm2,0x10(%rbp,%rdx,4)
movaps 0x70(%rsp,%rdx,4),%xmm1
mulps  %xmm0,%xmm1
movaps 0x80(%rsp,%rdx,4),%xmm2
mulps  %xmm0,%xmm2
movups %xmm1,0x20(%rbp,%rdx,4)
movups %xmm2,0x30(%rbp,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1240 <iCBConstruct+0x110>
test   $0x1,%cl
je     12a0 <iCBConstruct+0x170>
movaps %xmm0,%xmm1
mulps  0x50(%rsp,%rdx,4),%xmm1
movaps 0x60(%rsp,%rdx,4),%xmm2
mulps  %xmm0,%xmm2
movups %xmm1,0x0(%rbp,%rdx,4)
movups %xmm2,0x10(%rbp,%rdx,4)
cmp    %r14,%rax
je     12c9 <iCBConstruct+0x199>
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x50(%rsp,%rax,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    12b0 <iCBConstruct+0x180>
cmp    $0x2,%r15d
jl     144f <iCBConstruct+0x31f>
mov    %r15d,%r15d
mov    %r14d,%r12d
and    $0xfffffff8,%r12d
lea    -0x8(%r12),%rax
mov    %rax,0x20(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x30(%rsp)
mov    $0x1,%r13d
jmp    131d <iCBConstruct+0x1ed>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    %r15,%r13
je     144f <iCBConstruct+0x31f>
mov    0x10(%rsp),%rax
mov    (%rax,%r13,4),%edx
lea    0x50(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    0xc(%rsp),%ecx
mov    %ebx,%r8d
call   1050 <getCBvec@plt>
test   %ebx,%ebx
jle    1310 <iCBConstruct+0x1e0>
movss  0x44(%rsp,%r13,4),%xmm0
cmp    $0x8,%ebx
jae    1360 <iCBConstruct+0x230>
xor    %eax,%eax
jmp    1420 <iCBConstruct+0x2f0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0x20(%rsp)
je     1444 <iCBConstruct+0x314>
mov    0x30(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movaps 0x50(%rsp,%rax,4),%xmm2
mulps  %xmm1,%xmm2
movups 0x0(%rbp,%rax,4),%xmm3
addps  %xmm2,%xmm3
movups 0x10(%rbp,%rax,4),%xmm2
movups 0x20(%rbp,%rax,4),%xmm4
movups 0x30(%rbp,%rax,4),%xmm5
movaps 0x60(%rsp,%rax,4),%xmm6
mulps  %xmm1,%xmm6
addps  %xmm2,%xmm6
movups %xmm3,0x0(%rbp,%rax,4)
movups %xmm6,0x10(%rbp,%rax,4)
movaps 0x70(%rsp,%rax,4),%xmm2
mulps  %xmm1,%xmm2
addps  %xmm4,%xmm2
movaps 0x80(%rsp,%rax,4),%xmm3
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,0x20(%rbp,%rax,4)
movups %xmm3,0x30(%rbp,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1380 <iCBConstruct+0x250>
testb  $0x1,0x38(%rsp)
je     1412 <iCBConstruct+0x2e2>
movups 0x0(%rbp,%rax,4),%xmm2
movups 0x10(%rbp,%rax,4),%xmm3
movaps %xmm1,%xmm4
mulps  0x50(%rsp,%rax,4),%xmm4
addps  %xmm2,%xmm4
movaps 0x60(%rsp,%rax,4),%xmm2
mulps  %xmm1,%xmm2
addps  %xmm3,%xmm2
movups %xmm4,0x0(%rbp,%rax,4)
movups %xmm2,0x10(%rbp,%rax,4)
mov    %r12,%rax
cmp    %r14,%r12
je     1310 <iCBConstruct+0x1e0>
xchg   %ax,%ax
movss  0x50(%rsp,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x0(%rbp,%rax,4),%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    1420 <iCBConstruct+0x2f0>
jmp    1310 <iCBConstruct+0x1e0>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
jne    13e8 <iCBConstruct+0x2b8>
jmp    1412 <iCBConstruct+0x2e2>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%cl
jne    1286 <iCBConstruct+0x156>
jmp    12a0 <iCBConstruct+0x170>

LLVM IR (-O0):
define void @iCBConstruct(float* %0, i32* %1, i32* %2, float* %3, i32 %4, i32 %5, i32 %6) {
%8 = alloca float*
%9 = alloca i32*
%10 = alloca i32*
%11 = alloca float*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca [3 x float]
%18 = alloca [40 x float]
store float* %0, float** %8
store i32* %1, i32** %9
store i32* %2, i32** %10
store float* %3, float** %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store i32 %6, i32* %14
%19 = load i32*, i32** %10
%20 = getelementptr inbounds i32, i32* %19, i64 0
%21 = load i32, i32* %20
%22 = call float @gaindequant(i32 %21, float 1.000000e+00, i32 32)
%23 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 0
store float %22, float* %23
%24 = load i32, i32* %14
%25 = icmp sgt i32 %24, 1
br i1 %25, label %26, label %36
26: ; preds = %7
%27 = load i32*, i32** %10
%28 = getelementptr inbounds i32, i32* %27, i64 1
%29 = load i32, i32* %28
%30 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 0
%31 = load float, float* %30
%32 = call i64 @fabs(float %31)
%33 = sitofp i64 %32 to float
%34 = call float @gaindequant(i32 %29, float %33, i32 16)
%35 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
store float %34, float* %35
br label %36
36: ; preds = %26, %7
%37 = load i32, i32* %14
%38 = icmp sgt i32 %37, 2
br i1 %38, label %39, label %49
39: ; preds = %36
%40 = load i32*, i32** %10
%41 = getelementptr inbounds i32, i32* %40, i64 2
%42 = load i32, i32* %41
%43 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
%44 = load float, float* %43
%45 = call i64 @fabs(float %44)
%46 = sitofp i64 %45 to float
%47 = call float @gaindequant(i32 %42, float %46, i32 8)
%48 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 2
store float %47, float* %48
br label %49
49: ; preds = %39, %36
%50 = getelementptr inbounds [40 x float], [40 x float]* %18, i64 0, i64 0
%51 = load float*, float** %11
%52 = load i32*, i32** %9
%53 = getelementptr inbounds i32, i32* %52, i64 0
%54 = load i32, i32* %53
%55 = load i32, i32* %12
%56 = load i32, i32* %13
%57 = call i32 @getCBvec(float* %50, float* %51, i32 %54, i32 %55, i32 %56)
store i32 0, i32* %15
br label %58
58: ; preds = %74, %49
%59 = load i32, i32* %15
%60 = load i32, i32* %13
%61 = icmp slt i32 %59, %60
br i1 %61, label %62, label %77
62: ; preds = %58
%63 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 0
%64 = load float, float* %63
%65 = load i32, i32* %15
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [40 x float], [40 x float]* %18, i64 0, i64 %66
%68 = load float, float* %67
%69 = fmul float %64, %68
%70 = load float*, float** %8
%71 = load i32, i32* %15
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
store float %69, float* %73
br label %74
74: ; preds = %62
%75 = load i32, i32* %15
%76 = add nsw i32 %75, 1
store i32 %76, i32* %15
br label %58
77: ; preds = %58
%78 = load i32, i32* %14
%79 = icmp sgt i32 %78, 1
br i1 %79, label %80, label %123
80: ; preds = %77
store i32 1, i32* %16
br label %81
81: ; preds = %119, %80
%82 = load i32, i32* %16
%83 = load i32, i32* %14
%84 = icmp slt i32 %82, %83
br i1 %84, label %85, label %122
85: ; preds = %81
%86 = getelementptr inbounds [40 x float], [40 x float]* %18, i64 0, i64 0
%87 = load float*, float** %11
%88 = load i32*, i32** %9
%89 = load i32, i32* %16
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i32, i32* %88, i64 %90
%92 = load i32, i32* %91
%93 = load i32, i32* %12
%94 = load i32, i32* %13
%95 = call i32 @getCBvec(float* %86, float* %87, i32 %92, i32 %93, i32 %94)
store i32 0, i32* %15
br label %96
96: ; preds = %115, %85
%97 = load i32, i32* %15
%98 = load i32, i32* %13
%99 = icmp slt i32 %97, %98
br i1 %99, label %100, label %118
100: ; preds = %96
%101 = load i32, i32* %16
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 %102
%104 = load float, float* %103
%105 = load i32, i32* %15
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [40 x float], [40 x float]* %18, i64 0, i64 %106
%108 = load float, float* %107
%109 = load float*, float** %8
%110 = load i32, i32* %15
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %109, i64 %111
%113 = load float, float* %112
%114 = call float @llvm.fmuladd.f32(float %104, float %108, float %113)
store float %114, float* %112
br label %115
115: ; preds = %100
%116 = load i32, i32* %15
%117 = add nsw i32 %116, 1
store i32 %117, i32* %15
br label %96
118: ; preds = %96
br label %119
119: ; preds = %118
%120 = load i32, i32* %16
%121 = add nsw i32 %120, 1
store i32 %121, i32* %16
br label %81
122: ; preds = %81
br label %123
123: ; preds = %122, %77
ret void
}

LLVM IR (-O2):
define void @iCBConstruct(float* nocapture %0, i32* nocapture %1, i32* nocapture %2, float* %3, i32 %4, i32 %5, i32 %6) {
%8 = alloca [3 x float]
%9 = alloca [40 x float]
%10 = bitcast [3 x float]* %8 to i8*
%11 = bitcast [40 x float]* %9 to i8*
%12 = load i32, i32* %2
%13 = tail call float @gaindequant(i32 %12, float 1.000000e+00, i32 32)
%14 = icmp sgt i32 %6, 1
br i1 %14, label %15, label %30
15: ; preds = %7
%16 = getelementptr inbounds i32, i32* %2, i64 1
%17 = load i32, i32* %16
%18 = tail call i64 @fabs(float %13)
%19 = sitofp i64 %18 to float
%20 = tail call float @gaindequant(i32 %17, float %19, i32 16)
%21 = getelementptr inbounds [3 x float], [3 x float]* %8, i64 0, i64 1
store float %20, float* %21
%22 = icmp eq i32 %6, 2
br i1 %22, label %30, label %23
23: ; preds = %15
%24 = getelementptr inbounds i32, i32* %2, i64 2
%25 = load i32, i32* %24
%26 = tail call i64 @fabs(float %20)
%27 = sitofp i64 %26 to float
%28 = tail call float @gaindequant(i32 %25, float %27, i32 8)
%29 = getelementptr inbounds [3 x float], [3 x float]* %8, i64 0, i64 2
store float %28, float* %29
br label %30
30: ; preds = %7, %23, %15
%31 = getelementptr inbounds [40 x float], [40 x float]* %9, i64 0, i64 0
%32 = load i32, i32* %1
%33 = call i32 @getCBvec(float* %31, float* %3, i32 %32, i32 %4, i32 %5)
%34 = icmp sgt i32 %5, 0
br i1 %34, label %35, label %110
35: ; preds = %30
%36 = zext i32 %5 to i64
%37 = icmp ult i32 %5, 8
br i1 %37, label %100, label %38
38: ; preds = %35
%39 = and i64 %36, 4294967288
%40 = insertelement <4 x float> poison, float %13, i64 0
%41 = shufflevector <4 x float> %40, <4 x float> poison, <4 x i32> zeroinitializer
%42 = insertelement <4 x float> poison, float %13, i64 0
%43 = shufflevector <4 x float> %42, <4 x float> poison, <4 x i32> zeroinitializer
%44 = add nsw i64 %39, -8
%45 = lshr exact i64 %44, 3
%46 = add nuw nsw i64 %45, 1
%47 = and i64 %46, 1
%48 = icmp eq i64 %44, 0
br i1 %48, label %82, label %49
49: ; preds = %38
%50 = and i64 %46, 4611686018427387902
br label %51
51: ; preds = %51, %49
%52 = phi i64 [ 0, %49 ], [ %79, %51 ]
%53 = phi i64 [ 0, %49 ], [ %80, %51 ]
%54 = getelementptr inbounds [40 x float], [40 x float]* %9, i64 0, i64 %52
%55 = bitcast float* %54 to <4 x float>*
%56 = load <4 x float>, <4 x float>* %55
%57 = getelementptr inbounds float, float* %54, i64 4
%58 = bitcast float* %57 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = fmul <4 x float> %41, %56
%61 = fmul <4 x float> %43, %59
%62 = getelementptr inbounds float, float* %0, i64 %52
%63 = bitcast float* %62 to <4 x float>*
store <4 x float> %60, <4 x float>* %63
%64 = getelementptr inbounds float, float* %62, i64 4
%65 = bitcast float* %64 to <4 x float>*
store <4 x float> %61, <4 x float>* %65
%66 = or i64 %52, 8
%67 = getelementptr inbounds [40 x float], [40 x float]* %9, i64 0, i64 %66
%68 = bitcast float* %67 to <4 x float>*
%69 = load <4 x float>, <4 x float>* %68
%70 = getelementptr inbounds float, float* %67, i64 4
%71 = bitcast float* %70 to <4 x float>*
%72 = load <4 x float>, <4 x float>* %71
%73 = fmul <4 x float> %41, %69
%74 = fmul <4 x float> %43, %72
%75 = getelementptr inbounds float, float* %0, i64 %66
%76 = bitcast float* %75 to <4 x float>*
store <4 x float> %73, <4 x float>* %76
%77 = getelementptr inbounds float, float* %75, i64 4
%78 = bitcast float* %77 to <4 x float>*
store <4 x float> %74, <4 x float>* %78
%79 = add nuw i64 %52, 16
%80 = add i64 %53, 2
%81 = icmp eq i64 %80, %50
br i1 %81, label %82, label %51
82: ; preds = %51, %38
%83 = phi i64 [ 0, %38 ], [ %79, %51 ]
%84 = icmp eq i64 %47, 0
br i1 %84, label %98, label %85
85: ; preds = %82
%86 = getelementptr inbounds [40 x float], [40 x float]* %9, i64 0, i64 %83
%87 = bitcast float* %86 to <4 x float>*
%88 = load <4 x float>, <4 x float>* %87
%89 = getelementptr inbounds float, float* %86, i64 4
%90 = bitcast float* %89 to <4 x float>*
%91 = load <4 x float>, <4 x float>* %90
%92 = fmul <4 x float> %41, %88
%93 = fmul <4 x float> %43, %91
%94 = getelementptr inbounds float, float* %0, i64 %83
%95 = bitcast float* %94 to <4 x float>*
store <4 x float> %92, <4 x float>* %95
%96 = getelementptr inbounds float, float* %94, i64 4
%97 = bitcast float* %96 to <4 x float>*
store <4 x float> %93, <4 x float>* %97
br label %98
98: ; preds = %82, %85
%99 = icmp eq i64 %39, %36
br i1 %99, label %110, label %100
100: ; preds = %35, %98
%101 = phi i64 [ 0, %35 ], [ %39, %98 ]
br label %102
102: ; preds = %100, %102
%103 = phi i64 [ %108, %102 ], [ %101, %100 ]
%104 = getelementptr inbounds [40 x float], [40 x float]* %9, i64 0, i64 %103
%105 = load float, float* %104
%106 = fmul float %13, %105
%107 = getelementptr inbounds float, float* %0, i64 %103
store float %106, float* %107
%108 = add nuw nsw i64 %103, 1
%109 = icmp eq i64 %108, %36
br i1 %109, label %110, label %102
110: ; preds = %102, %98, %30
br i1 %14, label %111, label %211
111: ; preds = %110
%112 = zext i32 %6 to i64
%113 = zext i32 %5 to i64
%114 = and i64 %113, 4294967288
%115 = add nsw i64 %114, -8
%116 = lshr exact i64 %115, 3
%117 = add nuw nsw i64 %116, 1
%118 = icmp ult i32 %5, 8
%119 = and i64 %113, 4294967288
%120 = and i64 %117, 1
%121 = icmp eq i64 %115, 0
%122 = and i64 %117, 4611686018427387902
%123 = icmp eq i64 %120, 0
%124 = icmp eq i64 %119, %113
br label %125
125: ; preds = %111, %208
%126 = phi i64 [ 1, %111 ], [ %209, %208 ]
%127 = getelementptr inbounds i32, i32* %1, i64 %126
%128 = load i32, i32* %127
%129 = call i32 @getCBvec(float* %31, float* %3, i32 %128, i32 %4, i32 %5)
br i1 %34, label %130, label %208
130: ; preds = %125
%131 = getelementptr inbounds [3 x float], [3 x float]* %8, i64 0, i64 %126
%132 = load float, float* %131
br i1 %118, label %197, label %133
133: ; preds = %130
%134 = insertelement <4 x float> poison, float %132, i64 0
%135 = shufflevector <4 x float> %134, <4 x float> poison, <4 x i32> zeroinitializer
%136 = insertelement <4 x float> poison, float %132, i64 0
%137 = shufflevector <4 x float> %136, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %121, label %177, label %138
138: ; preds = %133, %138
%139 = phi i64 [ %174, %138 ], [ 0, %133 ]
%140 = phi i64 [ %175, %138 ], [ 0, %133 ]
%141 = getelementptr inbounds [40 x float], [40 x float]* %9, i64 0, i64 %139
%142 = bitcast float* %141 to <4 x float>*
%143 = load <4 x float>, <4 x float>* %142
%144 = getelementptr inbounds float, float* %141, i64 4
%145 = bitcast float* %144 to <4 x float>*
%146 = load <4 x float>, <4 x float>* %145
%147 = getelementptr inbounds float, float* %0, i64 %139
%148 = bitcast float* %147 to <4 x float>*
%149 = load <4 x float>, <4 x float>* %148
%150 = getelementptr inbounds float, float* %147, i64 4
%151 = bitcast float* %150 to <4 x float>*
%152 = load <4 x float>, <4 x float>* %151
%153 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %135, <4 x float> %143, <4 x float> %149)
%154 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %137, <4 x float> %146, <4 x float> %152)
%155 = bitcast float* %147 to <4 x float>*
store <4 x float> %153, <4 x float>* %155
%156 = bitcast float* %150 to <4 x float>*
store <4 x float> %154, <4 x float>* %156
%157 = or i64 %139, 8
%158 = getelementptr inbounds [40 x float], [40 x float]* %9, i64 0, i64 %157
%159 = bitcast float* %158 to <4 x float>*
%160 = load <4 x float>, <4 x float>* %159
%161 = getelementptr inbounds float, float* %158, i64 4
%162 = bitcast float* %161 to <4 x float>*
%163 = load <4 x float>, <4 x float>* %162
%164 = getelementptr inbounds float, float* %0, i64 %157
%165 = bitcast float* %164 to <4 x float>*
%166 = load <4 x float>, <4 x float>* %165
%167 = getelementptr inbounds float, float* %164, i64 4
%168 = bitcast float* %167 to <4 x float>*
%169 = load <4 x float>, <4 x float>* %168
%170 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %135, <4 x float> %160, <4 x float> %166)
%171 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %137, <4 x float> %163, <4 x float> %169)
%172 = bitcast float* %164 to <4 x float>*
store <4 x float> %170, <4 x float>* %172
%173 = bitcast float* %167 to <4 x float>*
store <4 x float> %171, <4 x float>* %173
%174 = add nuw i64 %139, 16
%175 = add i64 %140, 2
%176 = icmp eq i64 %175, %122
br i1 %176, label %177, label %138
177: ; preds = %138, %133
%178 = phi i64 [ 0, %133 ], [ %174, %138 ]
br i1 %123, label %196, label %179
179: ; preds = %177
%180 = getelementptr inbounds [40 x float], [40 x float]* %9, i64 0, i64 %178
%181 = bitcast float* %180 to <4 x float>*
%182 = load <4 x float>, <4 x float>* %181
%183 = getelementptr inbounds float, float* %180, i64 4
%184 = bitcast float* %183 to <4 x float>*
%185 = load <4 x float>, <4 x float>* %184
%186 = getelementptr inbounds float, float* %0, i64 %178
%187 = bitcast float* %186 to <4 x float>*
%188 = load <4 x float>, <4 x float>* %187
%189 = getelementptr inbounds float, float* %186, i64 4
%190 = bitcast float* %189 to <4 x float>*
%191 = load <4 x float>, <4 x float>* %190
%192 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %135, <4 x float> %182, <4 x float> %188)
%193 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %137, <4 x float> %185, <4 x float> %191)
%194 = bitcast float* %186 to <4 x float>*
store <4 x float> %192, <4 x float>* %194
%195 = bitcast float* %189 to <4 x float>*
store <4 x float> %193, <4 x float>* %195
br label %196
196: ; preds = %177, %179
br i1 %124, label %208, label %197
197: ; preds = %130, %196
%198 = phi i64 [ 0, %130 ], [ %119, %196 ]
br label %199
199: ; preds = %197, %199
%200 = phi i64 [ %206, %199 ], [ %198, %197 ]
%201 = getelementptr inbounds [40 x float], [40 x float]* %9, i64 0, i64 %200
%202 = load float, float* %201
%203 = getelementptr inbounds float, float* %0, i64 %200
%204 = load float, float* %203
%205 = call float @llvm.fmuladd.f32(float %132, float %202, float %204)
store float %205, float* %203
%206 = add nuw nsw i64 %200, 1
%207 = icmp eq i64 %206, %113
br i1 %207, label %208, label %199
208: ; preds = %199, %196, %125
%209 = add nuw nsw i64 %126, 1
%210 = icmp eq i64 %209, %112
br i1 %210, label %211, label %125
211: ; preds = %208, %110
ret void
}