void get_rsegdelay(float *rspd, int nx, int ny, double *dh, int nb, float *gbnd,
                   float *gwid, float *rvf) {
  int ib, ixs, ixe, ix, iy, ip;
  for (ib = 0; ib < nb; ib++) {
    ixs = (int)(1.0 * (gbnd[ib] - 0.5 * gwid[ib]) / (*dh) + 0.5);
    ixe = (int)(1.0 * (gbnd[ib] + 0.5 * gwid[ib]) / (*dh) + 0.5);
    if (ixs < 0)
      ixs = 0;
    if (ixe > nx - 1)
      ixe = nx - 1;
    if (ixs < ixe) {
      for (iy = 0; iy < ny; iy++) {
        for (ix = ixs; ix <= ixe; ix++) {
          ip = ix + iy * nx;
          rspd[ip] = rvf[ib] * rspd[ip];
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<get_rsegdelay>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12b2 <get_rsegdelay+0x1b2>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xeb1(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe99(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
divsd  (%rax),%xmm0
movsd  0xe7d(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xe48(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xe40(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
divsd  (%rax),%xmm0
movsd  0xe24(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x30(%rbp)
jge    11f8 <get_rsegdelay+0xf8>
movl   $0x0,-0x30(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1212 <get_rsegdelay+0x112>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    129f <get_rsegdelay+0x19f>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    129a <get_rsegdelay+0x19a>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1287 <get_rsegdelay+0x187>
mov    -0x38(%rbp),%eax
mov    -0x3c(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1237 <get_rsegdelay+0x137>
jmp    128c <get_rsegdelay+0x18c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1225 <get_rsegdelay+0x125>
jmp    129f <get_rsegdelay+0x19f>
jmp    12a4 <get_rsegdelay+0x1a4>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1129 <get_rsegdelay+0x29>
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_rsegdelay>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9,-0x58(%rsp)
mov    %edx,-0x6c(%rsp)
test   %r8d,%r8d
jle    140e <get_rsegdelay+0x30e>
mov    %rdi,%rdx
mov    0x40(%rsp),%rax
movslq %esi,%r13
add    $0xffffffff,%esi
mov    %r8d,%edi
mov    %rdi,-0x60(%rsp)
mov    -0x6c(%rsp),%edi
mov    %rdi,-0x8(%rsp)
movsd  (%rcx),%xmm0
unpcklpd %xmm0,%xmm0
movd   %esi,%xmm1
pshufd $0x51,%xmm1,%xmm1
lea    0x30(%rdx),%rcx
mov    %rcx,-0x68(%rsp)
lea    0x0(,%r13,4),%r15
xor    %ecx,%ecx
movapd 0xe98(%rip),%xmm8
movapd 0xe9f(%rip),%xmm9
movd   %r13d,%xmm4
xorps  %xmm10,%xmm10
mov    %r13,-0x48(%rsp)
jmp    119f <get_rsegdelay+0x9f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    -0x60(%rsp),%rcx
je     140e <get_rsegdelay+0x30e>
mov    -0x58(%rsp),%rsi
movss  (%rsi,%rcx,4),%xmm6
cvtss2sd %xmm6,%xmm6
mov    0x38(%rsp),%rsi
movss  (%rsi,%rcx,4),%xmm7
cvtss2sd %xmm7,%xmm7
movlhps %xmm7,%xmm7
movlhps %xmm6,%xmm6
mulpd  %xmm8,%xmm7
addpd  %xmm6,%xmm7
divpd  %xmm0,%xmm7
addpd  %xmm9,%xmm7
cvttpd2dq %xmm7,%xmm2
movdqa %xmm4,%xmm7
punpcklqdq %xmm2,%xmm7
shufps $0xe2,%xmm2,%xmm7
movaps %xmm2,%xmm6
movss  %xmm10,%xmm6
pcmpgtd %xmm6,%xmm7
pand   %xmm7,%xmm2
pandn  %xmm1,%xmm7
por    %xmm2,%xmm7
movd   %xmm7,%esi
pshufd $0x55,%xmm7,%xmm2
movd   %xmm2,%r10d
cmp    %r10d,%esi
jge    1190 <get_rsegdelay+0x90>
cmpl   $0x0,-0x6c(%rsp)
jle    1190 <get_rsegdelay+0x90>
lea    (%rax,%rcx,4),%rdi
mov    %rdi,-0x20(%rsp)
lea    (%rax,%rcx,4),%rdi
add    $0x4,%rdi
mov    %rdi,-0x18(%rsp)
mov    %esi,%r11d
add    $0x1,%r10d
mov    %r10,%r9
sub    %r11,%r9
lea    -0x8(%r9),%rsi
mov    %rsi,-0x28(%rsp)
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %r9,%rsi
and    $0xfffffffffffffff8,%rsi
mov    %rsi,-0x38(%rsp)
add    %r11,%rsi
mov    %rsi,-0x40(%rsp)
mov    %rdi,%rsi
mov    %rdi,-0x30(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,-0x50(%rsp)
mov    %r10,%rsi
neg    %rsi
mov    %rsi,-0x10(%rsp)
mov    -0x68(%rsp),%rsi
lea    (%rsi,%r11,4),%r8
mov    %rdx,%rdi
xor    %r12d,%r12d
jmp    12b5 <get_rsegdelay+0x1b5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
add    %r15,%r8
add    %r15,%rdi
cmp    -0x8(%rsp),%r12
je     1190 <get_rsegdelay+0x90>
mov    %r12,%r14
imul   %r13,%r14
mov    %r11,%rsi
cmp    $0x8,%r9
jb     13a0 <get_rsegdelay+0x2a0>
lea    (%r14,%r11,1),%rsi
lea    (%rdx,%rsi,4),%rsi
cmp    -0x18(%rsp),%rsi
jae    12ee <get_rsegdelay+0x1ee>
lea    (%r14,%r10,1),%rsi
lea    (%rdx,%rsi,4),%rbp
mov    %r11,%rsi
cmp    %rbp,-0x20(%rsp)
jb     13a0 <get_rsegdelay+0x2a0>
cmpq   $0x8,-0x28(%rsp)
jae    12fb <get_rsegdelay+0x1fb>
xor    %r13d,%r13d
jmp    1354 <get_rsegdelay+0x254>
movss  (%rax,%rcx,4),%xmm6
shufps $0x0,%xmm6,%xmm6
mov    -0x50(%rsp),%rbp
xor    %r13d,%r13d
nopl   0x0(%rax)
movups -0x30(%r8,%r13,4),%xmm2
movups -0x20(%r8,%r13,4),%xmm7
movups -0x10(%r8,%r13,4),%xmm3
movups (%r8,%r13,4),%xmm5
mulps  %xmm6,%xmm2
mulps  %xmm6,%xmm7
movups %xmm2,-0x30(%r8,%r13,4)
movups %xmm7,-0x20(%r8,%r13,4)
mulps  %xmm6,%xmm3
mulps  %xmm6,%xmm5
movups %xmm3,-0x10(%r8,%r13,4)
movups %xmm5,(%r8,%r13,4)
add    $0x10,%r13
add    $0xfffffffffffffffe,%rbp
jne    1310 <get_rsegdelay+0x210>
testb  $0x1,-0x30(%rsp)
je     1386 <get_rsegdelay+0x286>
add    %r11,%r13
add    %r14,%r13
movss  (%rax,%rcx,4),%xmm2
shufps $0x0,%xmm2,%xmm2
movups (%rdx,%r13,4),%xmm3
movups 0x10(%rdx,%r13,4),%xmm5
mulps  %xmm2,%xmm3
mulps  %xmm2,%xmm5
movups %xmm3,(%rdx,%r13,4)
movups %xmm5,0x10(%rdx,%r13,4)
mov    -0x40(%rsp),%rsi
cmp    -0x38(%rsp),%r9
mov    -0x48(%rsp),%r13
je     12a0 <get_rsegdelay+0x1a0>
nopl   0x0(%rax,%rax,1)
mov    %r10d,%ebx
sub    %esi,%ebx
mov    %rsi,%rbp
test   $0x1,%bl
je     13c5 <get_rsegdelay+0x2c5>
add    %rsi,%r14
movss  (%rax,%rcx,4),%xmm2
mulss  (%rdx,%r14,4),%xmm2
movss  %xmm2,(%rdx,%r14,4)
lea    0x1(%rsi),%rbp
not    %rsi
cmp    -0x10(%rsp),%rsi
je     12a0 <get_rsegdelay+0x1a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rax,%rcx,4),%xmm2
mulss  (%rdi,%rbp,4),%xmm2
movss  %xmm2,(%rdi,%rbp,4)
movss  (%rax,%rcx,4),%xmm2
mulss  0x4(%rdi,%rbp,4),%xmm2
movss  %xmm2,0x4(%rdi,%rbp,4)
add    $0x2,%rbp
cmp    %rbp,%r10
jne    13e0 <get_rsegdelay+0x2e0>
jmp    12a0 <get_rsegdelay+0x1a0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @get_rsegdelay(float* nocapture %0, i32 %1, i32 %2, double* nocapture %3, i32 %4, float* nocapture %5, float* nocapture %6, float* nocapture %7) {
%9 = icmp sgt i32 %4, 0
br i1 %9, label %10, label %178
10: ; preds = %8
%11 = load double, double* %3
%12 = add nsw i32 %1, -1
%13 = icmp slt i32 %2, 1
%14 = sext i32 %1 to i64
%15 = zext i32 %4 to i64
%16 = zext i32 %2 to i64
%17 = insertelement <2 x double> poison, double %11, i64 0
%18 = shufflevector <2 x double> %17, <2 x double> poison, <2 x i32> zeroinitializer
%19 = insertelement <2 x i32> <i32 0, i32 poison>, i32 %12, i64 1
br label %20
20: ; preds = %10, %175
%21 = phi i64 [ 0, %10 ], [ %176, %175 ]
%22 = getelementptr float, float* %7, i64 %21
%23 = add nuw i64 %21, 1
%24 = getelementptr float, float* %7, i64 %23
%25 = getelementptr inbounds float, float* %5, i64 %21
%26 = load float, float* %25
%27 = fpext float %26 to double
%28 = getelementptr inbounds float, float* %6, i64 %21
%29 = load float, float* %28
%30 = fpext float %29 to double
%31 = insertelement <2 x double> poison, double %30, i64 0
%32 = shufflevector <2 x double> %31, <2 x double> poison, <2 x i32> zeroinitializer
%33 = insertelement <2 x double> poison, double %27, i64 0
%34 = shufflevector <2 x double> %33, <2 x double> poison, <2 x i32> zeroinitializer
%35 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %32, <2 x double> <double -5.000000e-01, double 5.000000e-01>, <2 x double> %34)
%36 = fdiv <2 x double> %35, %18
%37 = fadd <2 x double> %36, <double 5.000000e-01, double 5.000000e-01>
%38 = fptosi <2 x double> %37 to <2 x i32>
%39 = insertelement <2 x i32> %38, i32 %1, i64 1
%40 = insertelement <2 x i32> %38, i32 0, i64 0
%41 = icmp sgt <2 x i32> %39, %40
%42 = select <2 x i1> %41, <2 x i32> %38, <2 x i32> %19
%43 = extractelement <2 x i32> %42, i64 0
%44 = extractelement <2 x i32> %42, i64 1
%45 = icmp sge i32 %43, %44
%46 = or i1 %45, %13
br i1 %46, label %175, label %47
47: ; preds = %20
%48 = getelementptr inbounds float, float* %7, i64 %21
%49 = zext i32 %43 to i64
%50 = add i32 %44, 1
%51 = zext i32 %50 to i64
%52 = sub nsw i64 %51, %49
%53 = add nsw i64 %52, -8
%54 = lshr i64 %53, 3
%55 = add nuw nsw i64 %54, 1
%56 = icmp ult i64 %52, 8
%57 = and i64 %52, -8
%58 = add nsw i64 %57, %49
%59 = and i64 %55, 1
%60 = icmp ult i64 %53, 8
%61 = and i64 %55, 4611686018427387902
%62 = icmp eq i64 %59, 0
%63 = icmp eq i64 %52, %57
%64 = sub nsw i64 0, %51
br label %65
65: ; preds = %172, %47
%66 = phi i64 [ 0, %47 ], [ %173, %172 ]
%67 = mul i64 %66, %14
%68 = mul nsw i64 %66, %14
br i1 %56, label %141, label %69
69: ; preds = %65
%70 = add i64 %67, %51
%71 = getelementptr float, float* %0, i64 %70
%72 = add i64 %67, %49
%73 = getelementptr float, float* %0, i64 %72
%74 = icmp ult float* %73, %24
%75 = icmp ult float* %22, %71
%76 = and i1 %74, %75
br i1 %76, label %141, label %77
77: ; preds = %69
br i1 %60, label %120, label %78
78: ; preds = %77
%79 = load float, float* %48
%80 = insertelement <4 x float> poison, float %79, i64 0
%81 = shufflevector <4 x float> %80, <4 x float> poison, <4 x i32> zeroinitializer
%82 = insertelement <4 x float> poison, float %79, i64 0
%83 = shufflevector <4 x float> %82, <4 x float> poison, <4 x i32> zeroinitializer
%84 = load float, float* %48
%85 = insertelement <4 x float> poison, float %84, i64 0
%86 = shufflevector <4 x float> %85, <4 x float> poison, <4 x i32> zeroinitializer
%87 = insertelement <4 x float> poison, float %84, i64 0
%88 = shufflevector <4 x float> %87, <4 x float> poison, <4 x i32> zeroinitializer
br label %89
89: ; preds = %89, %78
%90 = phi i64 [ 0, %78 ], [ %117, %89 ]
%91 = phi i64 [ 0, %78 ], [ %118, %89 ]
%92 = add i64 %90, %49
%93 = add nsw i64 %92, %68
%94 = getelementptr inbounds float, float* %0, i64 %93
%95 = bitcast float* %94 to <4 x float>*
%96 = load <4 x float>, <4 x float>* %95
%97 = getelementptr inbounds float, float* %94, i64 4
%98 = bitcast float* %97 to <4 x float>*
%99 = load <4 x float>, <4 x float>* %98
%100 = fmul <4 x float> %81, %96
%101 = fmul <4 x float> %83, %99
%102 = bitcast float* %94 to <4 x float>*
store <4 x float> %100, <4 x float>* %102
%103 = bitcast float* %97 to <4 x float>*
store <4 x float> %101, <4 x float>* %103
%104 = or i64 %90, 8
%105 = add i64 %104, %49
%106 = add nsw i64 %105, %68
%107 = getelementptr inbounds float, float* %0, i64 %106
%108 = bitcast float* %107 to <4 x float>*
%109 = load <4 x float>, <4 x float>* %108
%110 = getelementptr inbounds float, float* %107, i64 4
%111 = bitcast float* %110 to <4 x float>*
%112 = load <4 x float>, <4 x float>* %111
%113 = fmul <4 x float> %86, %109
%114 = fmul <4 x float> %88, %112
%115 = bitcast float* %107 to <4 x float>*
store <4 x float> %113, <4 x float>* %115
%116 = bitcast float* %110 to <4 x float>*
store <4 x float> %114, <4 x float>* %116
%117 = add nuw i64 %90, 16
%118 = add i64 %91, 2
%119 = icmp eq i64 %118, %61
br i1 %119, label %120, label %89
120: ; preds = %89, %77
%121 = phi i64 [ 0, %77 ], [ %117, %89 ]
br i1 %62, label %140, label %122
122: ; preds = %120
%123 = add i64 %121, %49
%124 = add nsw i64 %123, %68
%125 = load float, float* %48
%126 = insertelement <4 x float> poison, float %125, i64 0
%127 = shufflevector <4 x float> %126, <4 x float> poison, <4 x i32> zeroinitializer
%128 = insertelement <4 x float> poison, float %125, i64 0
%129 = shufflevector <4 x float> %128, <4 x float> poison, <4 x i32> zeroinitializer
%130 = getelementptr inbounds float, float* %0, i64 %124
%131 = bitcast float* %130 to <4 x float>*
%132 = load <4 x float>, <4 x float>* %131
%133 = getelementptr inbounds float, float* %130, i64 4
%134 = bitcast float* %133 to <4 x float>*
%135 = load <4 x float>, <4 x float>* %134
%136 = fmul <4 x float> %127, %132
%137 = fmul <4 x float> %129, %135
%138 = bitcast float* %130 to <4 x float>*
store <4 x float> %136, <4 x float>* %138
%139 = bitcast float* %133 to <4 x float>*
store <4 x float> %137, <4 x float>* %139
br label %140
140: ; preds = %120, %122
br i1 %63, label %172, label %141
141: ; preds = %69, %65, %140
%142 = phi i64 [ %49, %69 ], [ %49, %65 ], [ %58, %140 ]
%143 = sub nsw i64 %51, %142
%144 = xor i64 %142, -1
%145 = and i64 %143, 1
%146 = icmp eq i64 %145, 0
br i1 %146, label %154, label %147
147: ; preds = %141
%148 = add nsw i64 %142, %68
%149 = load float, float* %48
%150 = getelementptr inbounds float, float* %0, i64 %148
%151 = load float, float* %150
%152 = fmul float %149, %151
store float %152, float* %150
%153 = add nuw nsw i64 %142, 1
br label %154
154: ; preds = %147, %141
%155 = phi i64 [ %142, %141 ], [ %153, %147 ]
%156 = icmp eq i64 %144, %64
br i1 %156, label %172, label %157
157: ; preds = %154, %157
%158 = phi i64 [ %170, %157 ], [ %155, %154 ]
%159 = add nsw i64 %158, %68
%160 = load float, float* %48
%161 = getelementptr inbounds float, float* %0, i64 %159
%162 = load float, float* %161
%163 = fmul float %160, %162
store float %163, float* %161
%164 = add nuw nsw i64 %158, 1
%165 = add nsw i64 %164, %68
%166 = load float, float* %48
%167 = getelementptr inbounds float, float* %0, i64 %165
%168 = load float, float* %167
%169 = fmul float %166, %168
store float %169, float* %167
%170 = add nuw nsw i64 %158, 2
%171 = icmp eq i64 %170, %51
br i1 %171, label %172, label %157
172: ; preds = %154, %157, %140
%173 = add nuw nsw i64 %66, 1
%174 = icmp eq i64 %173, %16
br i1 %174, label %175, label %65
175: ; preds = %172, %20
%176 = add nuw nsw i64 %21, 1
%177 = icmp eq i64 %176, %15
br i1 %177, label %178, label %20
178: ; preds = %175, %8
ret void
}