#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);
scalar_t__ malloc(short const);
short max_array(short const *, unsigned int const);
short min_array(short const *, unsigned int const);
int /*<<< orphan*/ printf(char *);
void dlsch_LLR_quant(const short *llr, const unsigned int arraySize,
                     const short Mlevel, short *llr_quant) {
  unsigned int i, j;
  short max_llr, min_llr;
  short llr_interval;
  float quant_step;
  float *transLevelArray;
  min_llr = min_array(llr, arraySize);
  max_llr = max_array(llr, arraySize);
  llr_interval = (max_llr - min_llr);
  quant_step = (float)llr_interval / Mlevel;
  if ((Mlevel % 2) != 0) {
    printf("Mlevel should be mutiple of 2...\n");
    exit(-1);
  }
  transLevelArray = (float *)malloc((Mlevel + 1) * sizeof(float));
  if (!transLevelArray) {
    printf("Cannot allocate memory for transLevelArray...!\n");
    exit(-1);
  }
  for (j = 0; j < Mlevel + 1; j++) {
    transLevelArray[j] = min_llr + j * quant_step;
  }
  for (i = 0; i < arraySize; i++) {
    for (j = 0; j < Mlevel; j++) {
      if ((transLevelArray[j] <= llr[i]) &&
          (llr[i] <= transLevelArray[j + 1])) {
        llr_quant[i] = (short)(transLevelArray[j] + quant_step / 2);
        break;
      }
      if (transLevelArray[j + 1] <= llr[i]) {
        llr_quant[i] = (short)(transLevelArray[j] + quant_step / 2);
      }
    }
  }
}


x86 assembly (clang, -O0):
<dlsch_LLR_quant>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %dx,%ax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %ax,-0xe(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1030 <min_array@plt>
mov    %ax,-0x24(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1070 <max_array@plt>
mov    %ax,-0x22(%rbp)
movzwl -0x22(%rbp),%eax
movzwl -0x24(%rbp),%ecx
sub    %ecx,%eax
mov    %ax,-0x26(%rbp)
movswl -0x26(%rbp),%eax
cvtsi2ss %eax,%xmm0
movswl -0xe(%rbp),%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
movswl -0xe(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     11dc <dlsch_LLR_quant+0x8c>
lea    0xe37(%rip),%rdi
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   1060 <exit@plt>
movswl -0xe(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
movswl %ax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    1216 <dlsch_LLR_quant+0xc6>
lea    0xe1f(%rip),%rdi
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   1060 <exit@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
movswl -0xe(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jae    1266 <dlsch_LLR_quant+0x116>
movswl -0x24(%rbp),%eax
cvtsi2ss %eax,%xmm1
mov    -0x20(%rbp),%eax
cvtsi2ss %rax,%xmm0
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    121d <dlsch_LLR_quant+0xcd>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    1396 <dlsch_LLR_quant+0x246>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
movswl -0xe(%rbp),%ecx
cmp    %ecx,%eax
jae    1383 <dlsch_LLR_quant+0x233>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movswl (%rax,%rcx,2),%eax
cvtsi2ss %eax,%xmm0
ucomiss %xmm1,%xmm0
jb     1314 <dlsch_LLR_quant+0x1c4>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movswl (%rax,%rcx,2),%eax
cvtsi2ss %eax,%xmm1
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jb     1314 <dlsch_LLR_quant+0x1c4>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xd0b(%rip),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %dx,(%rax,%rcx,2)
jmp    1383 <dlsch_LLR_quant+0x233>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movswl (%rax,%rcx,2),%eax
cvtsi2ss %eax,%xmm0
ucomiss %xmm1,%xmm0
jb     1370 <dlsch_LLR_quant+0x220>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
movss  -0x2c(%rbp),%xmm1
movss  0xcaa(%rip),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %ax,%dx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %dx,(%rax,%rcx,2)
jmp    1375 <dlsch_LLR_quant+0x225>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1280 <dlsch_LLR_quant+0x130>
jmp    1388 <dlsch_LLR_quant+0x238>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    126d <dlsch_LLR_quant+0x11d>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dlsch_LLR_quant>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r15
mov    %edx,%r14d
mov    %esi,%r12d
mov    %rdi,%rbx
call   1040 <min_array@plt>
mov    %eax,%r13d
mov    %rbx,%rdi
mov    %r12d,%esi
call   1070 <max_array@plt>
test   $0x1,%r14b
jne    14a3 <dlsch_LLR_quant+0x353>
mov    %eax,%ebp
lea    0x4(,%r14,4),%eax
movswl %ax,%edi
call   1050 <malloc@plt>
test   %rax,%rax
je     14ac <dlsch_LLR_quant+0x35c>
sub    %r13d,%ebp
movswl %bp,%ecx
cvtsi2ss %ecx,%xmm0
cvtsi2ss %r14d,%xmm1
divss  %xmm1,%xmm0
mov    %r14d,%edx
add    $0x1,%edx
je     13e1 <dlsch_LLR_quant+0x291>
movswl %r13w,%ecx
cvtsi2ss %ecx,%xmm9
mov    %edx,%ecx
cmp    $0x8,%edx
jae    11d5 <dlsch_LLR_quant+0x85>
xor    %edx,%edx
jmp    13c0 <dlsch_LLR_quant+0x270>
mov    %ecx,%edx
and    $0xfffffff8,%edx
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
movaps %xmm9,%xmm3
shufps $0x0,%xmm9,%xmm3
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     148a <dlsch_LLR_quant+0x33a>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xdef(%rip),%xmm5
xor    %esi,%esi
movdqa 0xdf4(%rip),%xmm8
movdqa 0xdfb(%rip),%xmm13
movdqa 0xe02(%rip),%xmm14
movdqa 0xe09(%rip),%xmm15
movaps 0xe12(%rip),%xmm1
movdqa 0xe19(%rip),%xmm10
movdqa 0xe20(%rip),%xmm11
movdqa 0xe27(%rip),%xmm12
nopl   0x0(%rax)
movdqa %xmm5,%xmm4
paddd  %xmm8,%xmm4
movdqa %xmm5,%xmm6
pand   %xmm13,%xmm6
por    %xmm14,%xmm6
movdqa %xmm5,%xmm7
psrld  $0x10,%xmm7
por    %xmm15,%xmm7
subps  %xmm1,%xmm7
addps  %xmm6,%xmm7
movdqa %xmm4,%xmm6
pand   %xmm13,%xmm6
por    %xmm14,%xmm6
psrld  $0x10,%xmm4
por    %xmm15,%xmm4
subps  %xmm1,%xmm4
addps  %xmm6,%xmm4
mulps  %xmm2,%xmm7
addps  %xmm3,%xmm7
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm7,(%rax,%rsi,4)
movups %xmm4,0x10(%rax,%rsi,4)
movdqa %xmm5,%xmm4
paddd  %xmm10,%xmm4
movdqa %xmm5,%xmm6
paddd  %xmm11,%xmm6
movdqa %xmm4,%xmm7
pand   %xmm13,%xmm7
por    %xmm14,%xmm7
psrld  $0x10,%xmm4
por    %xmm15,%xmm4
subps  %xmm1,%xmm4
addps  %xmm7,%xmm4
movdqa %xmm6,%xmm7
pand   %xmm13,%xmm7
por    %xmm14,%xmm7
psrld  $0x10,%xmm6
por    %xmm15,%xmm6
subps  %xmm1,%xmm6
addps  %xmm7,%xmm6
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm2,%xmm6
addps  %xmm3,%xmm6
movups %xmm4,0x20(%rax,%rsi,4)
movups %xmm6,0x30(%rax,%rsi,4)
add    $0x10,%rsi
paddd  %xmm12,%xmm5
add    $0xfffffffffffffffe,%rdi
jne    1260 <dlsch_LLR_quant+0x110>
test   $0x1,%bpl
je     13b3 <dlsch_LLR_quant+0x263>
movdqa 0xccd(%rip),%xmm1
paddd  %xmm5,%xmm1
movdqa 0xcd1(%rip),%xmm4
movdqa %xmm5,%xmm6
pand   %xmm4,%xmm6
movdqa 0xcd0(%rip),%xmm8
por    %xmm8,%xmm6
psrld  $0x10,%xmm5
movdqa 0xccd(%rip),%xmm10
por    %xmm10,%xmm5
movaps 0xcd1(%rip),%xmm7
subps  %xmm7,%xmm5
addps  %xmm6,%xmm5
pand   %xmm1,%xmm4
por    %xmm8,%xmm4
psrld  $0x10,%xmm1
por    %xmm10,%xmm1
subps  %xmm7,%xmm1
addps  %xmm4,%xmm1
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
mulps  %xmm2,%xmm1
addps  %xmm3,%xmm1
movups %xmm5,(%rax,%rsi,4)
movups %xmm1,0x10(%rax,%rsi,4)
cmp    %rcx,%rdx
je     13e1 <dlsch_LLR_quant+0x291>
nopl   0x0(%rax,%rax,1)
mov    %edx,%esi
xorps  %xmm1,%xmm1
cvtsi2ss %rsi,%xmm1
mulss  %xmm0,%xmm1
addss  %xmm9,%xmm1
movss  %xmm1,(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    13c0 <dlsch_LLR_quant+0x270>
test   %r12d,%r12d
je     147b <dlsch_LLR_quant+0x32b>
mulss  0xc9e(%rip),%xmm0
cmp    $0x2,%r14d
mov    $0x1,%ecx
cmovae %r14d,%ecx
mov    %r12d,%edx
xor    %esi,%esi
jmp    1426 <dlsch_LLR_quant+0x2d6>
cs nopw 0x0(%rax,%rax,1)
addss  %xmm0,%xmm1
cvttss2si %xmm1,%edi
mov    %di,(%r15,%rsi,2)
add    $0x1,%rsi
cmp    %rdx,%rsi
je     147b <dlsch_LLR_quant+0x32b>
test   %r14w,%r14w
je     141d <dlsch_LLR_quant+0x2cd>
movss  (%rax),%xmm1
xor    %edi,%edi
jmp    1448 <dlsch_LLR_quant+0x2f8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm2,%xmm1
cmp    %rdi,%rcx
je     141d <dlsch_LLR_quant+0x2cd>
movswl (%rbx,%rsi,2),%ebp
xorps  %xmm3,%xmm3
cvtsi2ss %ebp,%xmm3
ucomiss %xmm1,%xmm3
movss  0x4(%rax,%rdi,4),%xmm2
jb     1463 <dlsch_LLR_quant+0x313>
ucomiss %xmm3,%xmm2
jae    1410 <dlsch_LLR_quant+0x2c0>
add    $0x1,%rdi
ucomiss %xmm2,%xmm3
jb     1440 <dlsch_LLR_quant+0x2f0>
addss  %xmm0,%xmm1
cvttss2si %xmm1,%ebp
mov    %bp,(%r15,%rsi,2)
jmp    1440 <dlsch_LLR_quant+0x2f0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movdqa 0xb6e(%rip),%xmm5
xor    %esi,%esi
test   $0x1,%bpl
jne    133b <dlsch_LLR_quant+0x1eb>
jmp    13b3 <dlsch_LLR_quant+0x263>
lea    0xc19(%rip),%rdi
jmp    14b3 <dlsch_LLR_quant+0x363>
lea    0xbe1(%rip),%rdi
call   1030 <puts@plt>
mov    $0xffffffff,%edi
call   1060 <exit@plt>

LLVM IR (-O0):
@.str = [34 x i8] c"Mlevel should be mutiple of 2...\0A\00"
@.str.1 = [48 x i8] c"Cannot allocate memory for transLevelArray...!\0A\00"
define void @dlsch_LLR_quant(i16* %0, i32 %1, i16 signext %2, i16* %3) {
%5 = alloca i16*
%6 = alloca i32
%7 = alloca i16
%8 = alloca i16*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i16
%12 = alloca i16
%13 = alloca i16
%14 = alloca float
%15 = alloca float*
store i16* %0, i16** %5
store i32 %1, i32* %6
store i16 %2, i16* %7
store i16* %3, i16** %8
%16 = load i16*, i16** %5
%17 = load i32, i32* %6
%18 = call signext i16 @min_array(i16* %16, i32 %17)
store i16 %18, i16* %12
%19 = load i16*, i16** %5
%20 = load i32, i32* %6
%21 = call signext i16 @max_array(i16* %19, i32 %20)
store i16 %21, i16* %11
%22 = load i16, i16* %11
%23 = sext i16 %22 to i32
%24 = load i16, i16* %12
%25 = sext i16 %24 to i32
%26 = sub nsw i32 %23, %25
%27 = trunc i32 %26 to i16
store i16 %27, i16* %13
%28 = load i16, i16* %13
%29 = sitofp i16 %28 to float
%30 = load i16, i16* %7
%31 = sext i16 %30 to i32
%32 = sitofp i32 %31 to float
%33 = fdiv float %29, %32
store float %33, float* %14
%34 = load i16, i16* %7
%35 = sext i16 %34 to i32
%36 = srem i32 %35, 2
%37 = icmp ne i32 %36, 0
br i1 %37, label %38, label %41
38: ; preds = %4
%39 = call i32 @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0))
%40 = call i32 @exit(i32 -1)
unreachable
41: ; preds = %4
%42 = load i16, i16* %7
%43 = sext i16 %42 to i32
%44 = add nsw i32 %43, 1
%45 = sext i32 %44 to i64
%46 = mul i64 %45, 4
%47 = trunc i64 %46 to i16
%48 = call i64 @malloc(i16 signext %47)
%49 = inttoptr i64 %48 to float*
store float* %49, float** %15
%50 = load float*, float** %15
%51 = icmp ne float* %50, null
br i1 %51, label %55, label %52
52: ; preds = %41
%53 = call i32 @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.1, i64 0, i64 0))
%54 = call i32 @exit(i32 -1)
unreachable
55: ; preds = %41
store i32 0, i32* %10
br label %56
56: ; preds = %74, %55
%57 = load i32, i32* %10
%58 = load i16, i16* %7
%59 = sext i16 %58 to i32
%60 = add nsw i32 %59, 1
%61 = icmp ult i32 %57, %60
br i1 %61, label %62, label %77
62: ; preds = %56
%63 = load i16, i16* %12
%64 = sext i16 %63 to i32
%65 = sitofp i32 %64 to float
%66 = load i32, i32* %10
%67 = uitofp i32 %66 to float
%68 = load float, float* %14
%69 = call float @llvm.fmuladd.f32(float %67, float %68, float %65)
%70 = load float*, float** %15
%71 = load i32, i32* %10
%72 = zext 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* %10
%76 = add i32 %75, 1
store i32 %76, i32* %10
br label %56
77: ; preds = %56
store i32 0, i32* %9
br label %78
78: ; preds = %165, %77
%79 = load i32, i32* %9
%80 = load i32, i32* %6
%81 = icmp ult i32 %79, %80
br i1 %81, label %82, label %168
82: ; preds = %78
store i32 0, i32* %10
br label %83
83: ; preds = %161, %82
%84 = load i32, i32* %10
%85 = load i16, i16* %7
%86 = sext i16 %85 to i32
%87 = icmp ult i32 %84, %86
br i1 %87, label %88, label %164
88: ; preds = %83
%89 = load float*, float** %15
%90 = load i32, i32* %10
%91 = zext i32 %90 to i64
%92 = getelementptr inbounds float, float* %89, i64 %91
%93 = load float, float* %92
%94 = load i16*, i16** %5
%95 = load i32, i32* %9
%96 = zext i32 %95 to i64
%97 = getelementptr inbounds i16, i16* %94, i64 %96
%98 = load i16, i16* %97
%99 = sext i16 %98 to i32
%100 = sitofp i32 %99 to float
%101 = fcmp ole float %93, %100
br i1 %101, label %102, label %131
102: ; preds = %88
%103 = load i16*, i16** %5
%104 = load i32, i32* %9
%105 = zext i32 %104 to i64
%106 = getelementptr inbounds i16, i16* %103, i64 %105
%107 = load i16, i16* %106
%108 = sext i16 %107 to i32
%109 = sitofp i32 %108 to float
%110 = load float*, float** %15
%111 = load i32, i32* %10
%112 = add i32 %111, 1
%113 = zext i32 %112 to i64
%114 = getelementptr inbounds float, float* %110, i64 %113
%115 = load float, float* %114
%116 = fcmp ole float %109, %115
br i1 %116, label %117, label %131
117: ; preds = %102
%118 = load float*, float** %15
%119 = load i32, i32* %10
%120 = zext i32 %119 to i64
%121 = getelementptr inbounds float, float* %118, i64 %120
%122 = load float, float* %121
%123 = load float, float* %14
%124 = fdiv float %123, 2.000000e+00
%125 = fadd float %122, %124
%126 = fptosi float %125 to i16
%127 = load i16*, i16** %8
%128 = load i32, i32* %9
%129 = zext i32 %128 to i64
%130 = getelementptr inbounds i16, i16* %127, i64 %129
store i16 %126, i16* %130
br label %164
131: ; preds = %102, %88
%132 = load float*, float** %15
%133 = load i32, i32* %10
%134 = add i32 %133, 1
%135 = zext i32 %134 to i64
%136 = getelementptr inbounds float, float* %132, i64 %135
%137 = load float, float* %136
%138 = load i16*, i16** %5
%139 = load i32, i32* %9
%140 = zext i32 %139 to i64
%141 = getelementptr inbounds i16, i16* %138, i64 %140
%142 = load i16, i16* %141
%143 = sext i16 %142 to i32
%144 = sitofp i32 %143 to float
%145 = fcmp ole float %137, %144
br i1 %145, label %146, label %160
146: ; preds = %131
%147 = load float*, float** %15
%148 = load i32, i32* %10
%149 = zext i32 %148 to i64
%150 = getelementptr inbounds float, float* %147, i64 %149
%151 = load float, float* %150
%152 = load float, float* %14
%153 = fdiv float %152, 2.000000e+00
%154 = fadd float %151, %153
%155 = fptosi float %154 to i16
%156 = load i16*, i16** %8
%157 = load i32, i32* %9
%158 = zext i32 %157 to i64
%159 = getelementptr inbounds i16, i16* %156, i64 %158
store i16 %155, i16* %159
br label %160
160: ; preds = %146, %131
br label %161
161: ; preds = %160
%162 = load i32, i32* %10
%163 = add i32 %162, 1
store i32 %163, i32* %10
br label %83
164: ; preds = %117, %83
br label %165
165: ; preds = %164
%166 = load i32, i32* %9
%167 = add i32 %166, 1
store i32 %167, i32* %9
br label %78
168: ; preds = %78
ret void
}

LLVM IR (-O2):
@str = [47 x i8] c"Cannot allocate memory for transLevelArray...!\00"
@str.2 = [33 x i8] c"Mlevel should be mutiple of 2...\00"
define void @dlsch_LLR_quant(i16* %0, i32 %1, i16 signext %2, i16* nocapture writeonly %3) {
%5 = tail call signext i16 @min_array(i16* %0, i32 %1)
%6 = tail call signext i16 @max_array(i16* %0, i32 %1)
%7 = sub i16 %6, %5
%8 = sitofp i16 %7 to float
%9 = sext i16 %2 to i32
%10 = sitofp i16 %2 to float
%11 = fdiv float %8, %10
%12 = and i32 %9, 1
%13 = icmp eq i32 %12, 0
br i1 %13, label %17, label %14
14: ; preds = %4
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str.2, i64 0, i64 0))
%16 = tail call i32 @exit(i32 -1)
unreachable
17: ; preds = %4
%18 = add nsw i32 %9, 1
%19 = trunc i32 %18 to i16
%20 = shl i16 %19, 2
%21 = tail call i64 @malloc(i16 signext %20)
%22 = inttoptr i64 %21 to float*
%23 = icmp eq i64 %21, 0
br i1 %23, label %93, label %24
24: ; preds = %17
%25 = icmp eq i32 %18, 0
br i1 %25, label %96, label %26
26: ; preds = %24
%27 = sitofp i16 %5 to float
%28 = zext i32 %18 to i64
%29 = icmp ult i32 %18, 8
br i1 %29, label %91, label %30
30: ; preds = %26
%31 = and i64 %28, 4294967288
%32 = insertelement <4 x float> poison, float %11, i64 0
%33 = shufflevector <4 x float> %32, <4 x float> poison, <4 x i32> zeroinitializer
%34 = insertelement <4 x float> poison, float %27, i64 0
%35 = shufflevector <4 x float> %34, <4 x float> poison, <4 x i32> zeroinitializer
%36 = insertelement <4 x float> poison, float %11, i64 0
%37 = shufflevector <4 x float> %36, <4 x float> poison, <4 x i32> zeroinitializer
%38 = insertelement <4 x float> poison, float %27, i64 0
%39 = shufflevector <4 x float> %38, <4 x float> poison, <4 x i32> zeroinitializer
%40 = add nsw i64 %31, -8
%41 = lshr exact i64 %40, 3
%42 = add nuw nsw i64 %41, 1
%43 = and i64 %42, 1
%44 = icmp eq i64 %40, 0
br i1 %44, label %75, label %45
45: ; preds = %30
%46 = and i64 %42, 4611686018427387902
br label %47
47: ; preds = %47, %45
%48 = phi i64 [ 0, %45 ], [ %71, %47 ]
%49 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %45 ], [ %72, %47 ]
%50 = phi i64 [ 0, %45 ], [ %73, %47 ]
%51 = add <4 x i32> %49, <i32 4, i32 4, i32 4, i32 4>
%52 = uitofp <4 x i32> %49 to <4 x float>
%53 = uitofp <4 x i32> %51 to <4 x float>
%54 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %52, <4 x float> %33, <4 x float> %35)
%55 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %53, <4 x float> %37, <4 x float> %39)
%56 = getelementptr inbounds float, float* %22, i64 %48
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %54, <4 x float>* %57
%58 = getelementptr inbounds float, float* %56, i64 4
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> %55, <4 x float>* %59
%60 = or i64 %48, 8
%61 = add <4 x i32> %49, <i32 8, i32 8, i32 8, i32 8>
%62 = add <4 x i32> %49, <i32 12, i32 12, i32 12, i32 12>
%63 = uitofp <4 x i32> %61 to <4 x float>
%64 = uitofp <4 x i32> %62 to <4 x float>
%65 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %63, <4 x float> %33, <4 x float> %35)
%66 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %64, <4 x float> %37, <4 x float> %39)
%67 = getelementptr inbounds float, float* %22, i64 %60
%68 = bitcast float* %67 to <4 x float>*
store <4 x float> %65, <4 x float>* %68
%69 = getelementptr inbounds float, float* %67, i64 4
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> %66, <4 x float>* %70
%71 = add nuw i64 %48, 16
%72 = add <4 x i32> %49, <i32 16, i32 16, i32 16, i32 16>
%73 = add i64 %50, 2
%74 = icmp eq i64 %73, %46
br i1 %74, label %75, label %47
75: ; preds = %47, %30
%76 = phi i64 [ 0, %30 ], [ %71, %47 ]
%77 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %30 ], [ %72, %47 ]
%78 = icmp eq i64 %43, 0
br i1 %78, label %89, label %79
79: ; preds = %75
%80 = add <4 x i32> %77, <i32 4, i32 4, i32 4, i32 4>
%81 = uitofp <4 x i32> %77 to <4 x float>
%82 = uitofp <4 x i32> %80 to <4 x float>
%83 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %81, <4 x float> %33, <4 x float> %35)
%84 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %82, <4 x float> %37, <4 x float> %39)
%85 = getelementptr inbounds float, float* %22, i64 %76
%86 = bitcast float* %85 to <4 x float>*
store <4 x float> %83, <4 x float>* %86
%87 = getelementptr inbounds float, float* %85, i64 4
%88 = bitcast float* %87 to <4 x float>*
store <4 x float> %84, <4 x float>* %88
br label %89
89: ; preds = %75, %79
%90 = icmp eq i64 %31, %28
br i1 %90, label %96, label %91
91: ; preds = %26, %89
%92 = phi i64 [ 0, %26 ], [ %31, %89 ]
br label %104
93: ; preds = %17
%94 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str, i64 0, i64 0))
%95 = tail call i32 @exit(i32 -1)
unreachable
96: ; preds = %104, %89, %24
%97 = icmp eq i32 %1, 0
br i1 %97, label %142, label %98
98: ; preds = %96
%99 = icmp eq i16 %2, 0
%100 = fmul float %11, 5.000000e-01
%101 = call i32 @llvm.umax.i32(i32 %9, i32 1)
%102 = zext i32 %1 to i64
%103 = zext i32 %101 to i64
br label %112
104: ; preds = %91, %104
%105 = phi i64 [ %110, %104 ], [ %92, %91 ]
%106 = trunc i64 %105 to i32
%107 = uitofp i32 %106 to float
%108 = tail call float @llvm.fmuladd.f32(float %107, float %11, float %27)
%109 = getelementptr inbounds float, float* %22, i64 %105
store float %108, float* %109
%110 = add nuw nsw i64 %105, 1
%111 = icmp eq i64 %110, %28
br i1 %111, label %96, label %104
112: ; preds = %98, %139
%113 = phi i64 [ 0, %98 ], [ %140, %139 ]
br i1 %99, label %139, label %114
114: ; preds = %112
%115 = getelementptr inbounds i16, i16* %0, i64 %113
%116 = getelementptr inbounds i16, i16* %3, i64 %113
%117 = load float, float* %22
br label %118
118: ; preds = %114, %137
%119 = phi float [ %117, %114 ], [ %126, %137 ]
%120 = phi i64 [ 0, %114 ], [ %124, %137 ]
%121 = load i16, i16* %115
%122 = sitofp i16 %121 to float
%123 = fcmp ugt float %119, %122
%124 = add nuw nsw i64 %120, 1
%125 = getelementptr inbounds float, float* %22, i64 %124
%126 = load float, float* %125
%127 = fcmp ult float %126, %122
%128 = select i1 %123, i1 true, i1 %127
br i1 %128, label %132, label %129
129: ; preds = %118
%130 = fadd float %100, %119
%131 = fptosi float %130 to i16
store i16 %131, i16* %116
br label %139
132: ; preds = %118
%133 = fcmp ugt float %126, %122
br i1 %133, label %137, label %134
134: ; preds = %132
%135 = fadd float %100, %119
%136 = fptosi float %135 to i16
store i16 %136, i16* %116
br label %137
137: ; preds = %132, %134
%138 = icmp eq i64 %124, %103
br i1 %138, label %139, label %118
139: ; preds = %137, %112, %129
%140 = add nuw nsw i64 %113, 1
%141 = icmp eq i64 %140, %102
br i1 %141, label %142, label %112
142: ; preds = %139, %96
ret void
}