#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__ malloc(int);
void phaseEncodeScales(float fieldOfView, float spatialResolution,
                       float **scales, float direction, int fullPhaseEncoding,
                       int *numPhaseEncodes) {
  *numPhaseEncodes = fieldOfView * 10 / spatialResolution;
  if (!fullPhaseEncoding)
    *numPhaseEncodes /= 2;
  *scales = (float *)malloc(*numPhaseEncodes * sizeof(float));
  int p;
  if (fullPhaseEncoding) {
    for (p = 0; p < *numPhaseEncodes; p++)
      if (*numPhaseEncodes % 2)
        (*scales)[p] = direction * 2.0f * (p - *numPhaseEncodes / 2) /
                       (float)*numPhaseEncodes;
      else
        (*scales)[p] =
            direction * (2.0f * p - *numPhaseEncodes) / (*numPhaseEncodes);
  } else {
    for (p = 0; p < *numPhaseEncodes; p++)
      if (direction > 0)
        (*scales)[p] = p / (float)*numPhaseEncodes;
      else
        (*scales)[p] = (*numPhaseEncodes - p - 1) / (float)*numPhaseEncodes;
  }
  return;
}


x86 assembly (clang, -O0):
<phaseEncodeScales>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
movss  %xmm2,-0x14(%rbp)
mov    %esi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movss  0xec6(%rip),%xmm0
mulss  -0x4(%rbp),%xmm0
divss  -0x8(%rbp),%xmm0
cvttss2si %xmm0,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
cmpl   $0x0,-0x18(%rbp)
jne    1172 <phaseEncodeScales+0x62>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
cmpl   $0x0,-0x18(%rbp)
je     1275 <phaseEncodeScales+0x165>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    1270 <phaseEncodeScales+0x160>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     1216 <phaseEncodeScales+0x106>
movss  0xe37(%rip),%xmm0
mulss  -0x14(%rbp),%xmm0
mov    -0x24(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x34(%rbp),%eax
sub    %ecx,%eax
cvtsi2ss %eax,%xmm1
mulss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
cvtsi2ssl (%rax),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    125d <phaseEncodeScales+0x14d>
movss  -0x14(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm1
mov    -0x20(%rbp),%rax
cvtsi2ssl (%rax),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
addss  %xmm1,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
cvtsi2ssl (%rax),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1262 <phaseEncodeScales+0x152>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    119f <phaseEncodeScales+0x8f>
jmp    1306 <phaseEncodeScales+0x1f6>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    1301 <phaseEncodeScales+0x1f1>
movss  -0x14(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    12c2 <phaseEncodeScales+0x1b2>
cvtsi2ssl -0x24(%rbp),%xmm0
mov    -0x20(%rbp),%rax
cvtsi2ssl (%rax),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    12ee <phaseEncodeScales+0x1de>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
sub    -0x24(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
mov    -0x20(%rbp),%rax
cvtsi2ssl (%rax),%xmm1
divss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    12f3 <phaseEncodeScales+0x1e3>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    127c <phaseEncodeScales+0x16c>
jmp    1306 <phaseEncodeScales+0x1f6>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<phaseEncodeScales>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
mulss  0xee0(%rip),%xmm0
mov    %rdx,%rbx
mov    %esi,%ebp
movaps %xmm2,(%rsp)
mov    %rdi,%r14
divss  %xmm1,%xmm0
cvttss2si %xmm0,%eax
mov    %eax,%edi
shr    $0x1f,%edi
add    %eax,%edi
sar    %edi
test   %esi,%esi
cmovne %eax,%edi
mov    %edi,(%rdx)
shl    $0x2,%edi
call   1030 <malloc@plt>
mov    %rax,(%r14)
mov    (%rbx),%ecx
test   %ebp,%ebp
je     118c <phaseEncodeScales+0x7c>
test   %ecx,%ecx
movaps (%rsp),%xmm14
jle    13d4 <phaseEncodeScales+0x2c4>
movaps %xmm14,%xmm8
addss  %xmm14,%xmm8
mov    %ecx,%edx
cvtsi2ss %ecx,%xmm11
shr    %edx
movaps 0xe94(%rip),%xmm9
xorps  %xmm11,%xmm9
cmp    $0x4,%ecx
jae    11af <phaseEncodeScales+0x9f>
xor    %esi,%esi
jmp    1266 <phaseEncodeScales+0x156>
test   %ecx,%ecx
movaps (%rsp),%xmm7
jle    13d4 <phaseEncodeScales+0x2c4>
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
cmp    $0x4,%ecx
jae    12b2 <phaseEncodeScales+0x1a2>
xor    %edx,%edx
jmp    13a5 <phaseEncodeScales+0x295>
mov    %ecx,%esi
and    $0xfffffffc,%esi
movd   %edx,%xmm0
pshufd $0x0,%xmm0,%xmm12
movaps %xmm8,%xmm13
shufps $0x0,%xmm8,%xmm13
movaps %xmm9,%xmm5
shufps $0x0,%xmm9,%xmm5
movaps %xmm14,%xmm6
shufps $0x0,%xmm14,%xmm6
movaps %xmm11,%xmm7
shufps $0x0,%xmm11,%xmm7
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm4
lea    0x0(,%rcx,4),%rdi
and    $0xfffffffffffffff0,%rdi
movdqa 0xe21(%rip),%xmm1
xor    %ebp,%ebp
pslld  $0x1f,%xmm4
psrad  $0x1f,%xmm4
movdqa 0xe1c(%rip),%xmm10
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm1,%xmm2
psubd  %xmm12,%xmm2
cvtdq2ps %xmm2,%xmm2
mulps  %xmm13,%xmm2
cvtdq2ps %xmm1,%xmm3
addps  %xmm3,%xmm3
addps  %xmm5,%xmm3
mulps  %xmm6,%xmm3
andps  %xmm4,%xmm2
movaps %xmm4,%xmm0
andnps %xmm3,%xmm0
orps   %xmm2,%xmm0
divps  %xmm7,%xmm0
movups %xmm0,(%rax,%rbp,1)
paddd  %xmm10,%xmm1
add    $0x10,%rbp
cmp    %rbp,%rdi
jne    1220 <phaseEncodeScales+0x110>
cmp    %rcx,%rsi
je     13d4 <phaseEncodeScales+0x2c4>
neg    %edx
jmp    129c <phaseEncodeScales+0x18c>
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
addss  %xmm0,%xmm0
addss  %xmm9,%xmm0
mulss  %xmm14,%xmm0
divss  %xmm11,%xmm0
movss  %xmm0,(%rax,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
je     13d4 <phaseEncodeScales+0x2c4>
test   $0x1,%cl
je     1270 <phaseEncodeScales+0x160>
lea    (%rdx,%rsi,1),%edi
xorps  %xmm0,%xmm0
cvtsi2ss %edi,%xmm0
mulss  %xmm8,%xmm0
jmp    1285 <phaseEncodeScales+0x175>
mov    %ecx,%edx
and    $0xfffffffc,%edx
movd   %ecx,%xmm1
pshufd $0x0,%xmm1,%xmm6
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1373 <phaseEncodeScales+0x263>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
movdqa 0xd32(%rip),%xmm3
xor    %esi,%esi
xorps  %xmm4,%xmm4
pcmpeqd %xmm8,%xmm8
movdqa 0xd2f(%rip),%xmm9
movdqa 0xd36(%rip),%xmm10
movdqa 0xd3e(%rip),%xmm5
jmp    1346 <phaseEncodeScales+0x236>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm6,%xmm2
psubd  %xmm3,%xmm2
paddd  %xmm10,%xmm2
cvtdq2ps %xmm2,%xmm2
divps  %xmm1,%xmm2
movups %xmm2,0x10(%rax,%rsi,4)
add    $0x8,%rsi
paddd  %xmm5,%xmm3
add    $0xfffffffffffffffe,%rdi
je     137c <phaseEncodeScales+0x26c>
ucomiss %xmm4,%xmm7
movdqa %xmm3,%xmm2
ja     135c <phaseEncodeScales+0x24c>
movdqa %xmm3,%xmm2
pxor   %xmm8,%xmm2
paddd  %xmm6,%xmm2
cvtdq2ps %xmm2,%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rax,%rsi,4)
jbe    1320 <phaseEncodeScales+0x210>
movdqa %xmm3,%xmm2
paddd  %xmm9,%xmm2
jmp    132d <phaseEncodeScales+0x21d>
movaps 0xca6(%rip),%xmm3
xor    %esi,%esi
test   $0x1,%bpl
je     13a0 <phaseEncodeScales+0x290>
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm7
ja     1396 <phaseEncodeScales+0x286>
pcmpeqd %xmm2,%xmm2
pxor   %xmm2,%xmm3
paddd  %xmm6,%xmm3
cvtdq2ps %xmm3,%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rax,%rsi,4)
cmp    %rcx,%rdx
je     13d4 <phaseEncodeScales+0x2c4>
mov    %edx,%esi
not    %esi
add    %ecx,%esi
xorps  %xmm1,%xmm1
xchg   %ax,%ax
ucomiss %xmm1,%xmm7
mov    %edx,%edi
cmovbe %esi,%edi
xorps  %xmm2,%xmm2
cvtsi2ss %edi,%xmm2
divss  %xmm0,%xmm2
movss  %xmm2,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0xffffffff,%esi
cmp    %rdx,%rcx
jne    13b0 <phaseEncodeScales+0x2a0>
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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