#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 */
typedef int i1;
typedef int i0;
typedef int i;

/* Variables and functions */
int /*<<< orphan*/ assert(float *);
int /*<<< orphan*/ set_bnd(int, int, float *);
void advect(int N, int b, float *d, float *d0, float *u, float *v, float dt) {
  assert(d);
  assert(d0);
  assert(u);
  assert(v);
  int i, j, i0, j0, i1, j1;
  float x, y, s0, t0, s1, t1, dt0;
  dt0 = dt * N;
  for (j = 1; j <= N; j++)
    for (i = 1; i <= N; i++) {
      x = i - dt0 * u[((i) + (N + 2) * (j))];
      y = j - dt0 * v[((i) + (N + 2) * (j))];
      if (x < 0.5f)
        x = 0.5f;
      if (x > N + 0.5f)
        x = N + 0.5f;
      i0 = (int)x;
      i1 = i0 + 1;
      if (y < 0.5f)
        y = 0.5f;
      if (y > N + 0.5f)
        y = N + 0.5f;
      j0 = (int)y;
      j1 = j0 + 1;
      s1 = x - i0;
      s0 = 1 - s1;
      t1 = y - j0;
      t0 = 1 - t1;
      d[((i) + (N + 2) * (j))] = s0 * (t0 * d0[((i0) + (N + 2) * (j0))] +
                                       t1 * d0[((i0) + (N + 2) * (j1))]) +
                                 s1 * (t0 * d0[((i1) + (N + 2) * (j0))] +
                                       t1 * d0[((i1) + (N + 2) * (j1))]);
    }
  set_bnd(N, b, d);
}


x86 assembly (clang, -O0):
<advect>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <assert@plt>
mov    -0x18(%rbp),%rdi
call   1030 <assert@plt>
mov    -0x20(%rbp),%rdi
call   1030 <assert@plt>
mov    -0x28(%rbp),%rdi
call   1030 <assert@plt>
movss  -0x2c(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1414 <advect+0x2f4>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1401 <advect+0x2e1>
cvtsi2ssl -0x30(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
cvtsi2ssl -0x34(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  0xdda(%rip),%xmm0
ucomiss -0x48(%rbp),%xmm0
jbe    123d <advect+0x11d>
movss  0xdc8(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
movss  0xdb1(%rip),%xmm2
addss  %xmm2,%xmm1
ucomiss %xmm1,%xmm0
jbe    1272 <advect+0x152>
cvtsi2ssl -0x4(%rbp),%xmm0
movss  0xd97(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
cvttss2si -0x48(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
movss  0xd75(%rip),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    12a2 <advect+0x182>
movss  0xd63(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
movss  0xd4c(%rip),%xmm2
addss  %xmm2,%xmm1
ucomiss %xmm1,%xmm0
jbe    12d7 <advect+0x1b7>
cvtsi2ssl -0x4(%rbp),%xmm0
movss  0xd32(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
cvttss2si -0x4c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movss  -0x48(%rbp),%xmm0
cvtsi2ssl -0x38(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0xd01(%rip),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtsi2ssl -0x3c(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  0xcdc(%rip),%xmm0
subss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x5c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x58(%rbp),%xmm1
movss  -0x54(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x5c(%rbp),%xmm4
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x4(%rbp),%edx
add    $0x2,%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1194 <advect+0x74>
jmp    1406 <advect+0x2e6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1181 <advect+0x61>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1040 <set_bnd@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<advect>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
movss  %xmm0,(%rsp)
mov    %r9,%r13
mov    %r8,%r14
mov    %rcx,%rbp
mov    %esi,0xc(%rsp)
mov    %edi,%ebx
mov    %rdx,0x18(%rsp)
mov    %rdx,%rdi
call   1030 <assert@plt>
mov    %rbp,%rdi
call   1030 <assert@plt>
mov    %r14,%rdi
call   1030 <assert@plt>
mov    %r13,%rdi
call   1030 <assert@plt>
mov    %rbx,0x10(%rsp)
test   %ebx,%ebx
jle    12ff <advect+0x1df>
mov    0x10(%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
lea    0x2(%rax),%r9d
movaps 0xe75(%rip),%xmm1
xorps  %xmm0,%xmm1
mulss  (%rsp),%xmm1
addss  0xe75(%rip),%xmm0
mov    %eax,%r11d
lea    0x1(%r11),%rax
mov    %rax,(%rsp)
lea    0xc(%r14,%r11,4),%r14
lea    0x8(,%r11,4),%rax
mov    %rax,0x20(%rsp)
lea    0xc(%r13,%r11,4),%r13
mov    0x18(%rsp),%rax
lea    (%rax,%r11,4),%r8
add    $0xc,%r8
mov    $0x1,%r10d
movss  0xe37(%rip),%xmm8
movss  0xe32(%rip),%xmm9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cvtsi2ss %r10d,%xmm10
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
lea    0x1(%rdi),%rcx
xorps  %xmm5,%xmm5
cvtsi2ss %ecx,%xmm5
movss  (%r14,%rdi,4),%xmm6
mulss  %xmm1,%xmm6
addss  %xmm5,%xmm6
movss  0x0(%r13,%rdi,4),%xmm7
mulss  %xmm1,%xmm7
addss  %xmm10,%xmm7
movaps %xmm8,%xmm2
maxss  %xmm6,%xmm2
movaps %xmm0,%xmm5
minss  %xmm2,%xmm5
cvttss2si %xmm5,%esi
movaps %xmm8,%xmm2
maxss  %xmm7,%xmm2
movaps %xmm0,%xmm6
minss  %xmm2,%xmm6
cvttss2si %xmm6,%ebx
cvttps2dq %xmm5,%xmm2
cvtdq2ps %xmm2,%xmm2
subss  %xmm2,%xmm5
movaps %xmm9,%xmm2
subss  %xmm5,%xmm2
cvttps2dq %xmm6,%xmm7
cvtdq2ps %xmm7,%xmm7
subss  %xmm7,%xmm6
movaps %xmm9,%xmm7
subss  %xmm6,%xmm7
mov    %r9d,%r15d
imul   %ebx,%r15d
add    $0x1,%ebx
lea    (%r15,%rsi,1),%r12d
movslq %r12d,%rdx
imul   %r9d,%ebx
lea    (%rbx,%rsi,1),%eax
cltq
movss  0x0(%rbp,%rax,4),%xmm3
mulss  %xmm6,%xmm3
movss  0x0(%rbp,%rdx,4),%xmm4
mulss  %xmm7,%xmm4
addss  %xmm3,%xmm4
mulss  %xmm2,%xmm4
lea    0x1(%r15,%rsi,1),%eax
lea    0x1(%rbx,%rsi,1),%edx
movslq %edx,%rdx
mulss  0x0(%rbp,%rdx,4),%xmm6
cltq
mulss  0x0(%rbp,%rax,4),%xmm7
addss  %xmm6,%xmm7
mulss  %xmm5,%xmm7
addss  %xmm4,%xmm7
movss  %xmm7,(%r8,%rdi,4)
mov    %rcx,%rdi
cmp    %rcx,%r11
jne    1200 <advect+0xe0>
add    $0x1,%r10
mov    0x20(%rsp),%rax
add    %rax,%r14
add    %rax,%r13
add    %rax,%r8
cmp    (%rsp),%r10
jne    11f0 <advect+0xd0>
mov    0x10(%rsp),%rdi
mov    0xc(%rsp),%esi
mov    0x18(%rsp),%rdx
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <set_bnd@plt>

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

LLVM IR (-O2):
define void @advect(i32 %0, i32 %1, float* %2, float* %3, float* %4, float* %5, float %6) {
%8 = tail call i32 @assert(float* %2)
%9 = tail call i32 @assert(float* %3)
%10 = tail call i32 @assert(float* %4)
%11 = tail call i32 @assert(float* %5)
%12 = sitofp i32 %0 to float
%13 = icmp slt i32 %0, 1
br i1 %13, label %86, label %14
14: ; preds = %7
%15 = add nuw nsw i32 %0, 2
%16 = fneg float %12
%17 = fmul float %16, %6
%18 = fadd float %12, 5.000000e-01
%19 = add nuw i32 %0, 1
%20 = zext i32 %15 to i64
%21 = zext i32 %19 to i64
br label %22
22: ; preds = %83, %14
%23 = phi i64 [ 1, %14 ], [ %84, %83 ]
%24 = mul nsw i64 %23, %20
%25 = trunc i64 %23 to i32
%26 = sitofp i32 %25 to float
br label %27
27: ; preds = %22, %27
%28 = phi i64 [ 1, %22 ], [ %81, %27 ]
%29 = trunc i64 %28 to i32
%30 = sitofp i32 %29 to float
%31 = add nuw nsw i64 %28, %24
%32 = getelementptr inbounds float, float* %4, i64 %31
%33 = load float, float* %32
%34 = tail call float @llvm.fmuladd.f32(float %17, float %33, float %30)
%35 = getelementptr inbounds float, float* %5, i64 %31
%36 = load float, float* %35
%37 = tail call float @llvm.fmuladd.f32(float %17, float %36, float %26)
%38 = fcmp olt float %34, 5.000000e-01
%39 = select i1 %38, float 5.000000e-01, float %34
%40 = fcmp ogt float %39, %18
%41 = select i1 %40, float %18, float %39
%42 = fptosi float %41 to i32
%43 = add nsw i32 %42, 1
%44 = fcmp olt float %37, 5.000000e-01
%45 = select i1 %44, float 5.000000e-01, float %37
%46 = fcmp ogt float %45, %18
%47 = select i1 %46, float %18, float %45
%48 = fptosi float %47 to i32
%49 = add nsw i32 %48, 1
%50 = sitofp i32 %42 to float
%51 = fsub float %41, %50
%52 = fsub float 1.000000e+00, %51
%53 = sitofp i32 %48 to float
%54 = fsub float %47, %53
%55 = fsub float 1.000000e+00, %54
%56 = mul nsw i32 %15, %48
%57 = add nsw i32 %56, %42
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %3, i64 %58
%60 = load float, float* %59
%61 = mul nsw i32 %49, %15
%62 = add nsw i32 %61, %42
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds float, float* %3, i64 %63
%65 = load float, float* %64
%66 = fmul float %65, %54
%67 = tail call float @llvm.fmuladd.f32(float %55, float %60, float %66)
%68 = add nsw i32 %56, %43
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float, float* %3, i64 %69
%71 = load float, float* %70
%72 = add nsw i32 %61, %43
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %3, i64 %73
%75 = load float, float* %74
%76 = fmul float %75, %54
%77 = tail call float @llvm.fmuladd.f32(float %55, float %71, float %76)
%78 = fmul float %51, %77
%79 = tail call float @llvm.fmuladd.f32(float %52, float %67, float %78)
%80 = getelementptr inbounds float, float* %2, i64 %31
store float %79, float* %80
%81 = add nuw nsw i64 %28, 1
%82 = icmp eq i64 %81, %21
br i1 %82, label %83, label %27
83: ; preds = %27
%84 = add nuw nsw i64 %23, 1
%85 = icmp eq i64 %84, %21
br i1 %85, label %86, label %22
86: ; preds = %83, %7
%87 = tail call i32 @set_bnd(i32 %0, i32 %1, float* %2)
ret void
}