#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*/ set_bnd(int, int, float *);
void advect(int N, int b, float *d, float *d0, float *u, float *v, float dt) {
  int i, j, i0, j0, i1, j1;
  float x, y, s0, t0, s1, t1, dt0;
  dt0 = dt * N;
  for (i = 1; i <= N; i++) {
    for (j = 1; j <= N; j++) {
      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)
movss  -0x2c(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     13e0 <advect+0x2d0>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     13cd <advect+0x2bd>
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  0xe0e(%rip),%xmm0
ucomiss -0x48(%rbp),%xmm0
jbe    1209 <advect+0xf9>
movss  0xdfc(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
movss  0xde5(%rip),%xmm2
addss  %xmm2,%xmm1
ucomiss %xmm1,%xmm0
jbe    123e <advect+0x12e>
cvtsi2ssl -0x4(%rbp),%xmm0
movss  0xdcb(%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  0xda9(%rip),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    126e <advect+0x15e>
movss  0xd97(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
movss  0xd80(%rip),%xmm2
addss  %xmm2,%xmm1
ucomiss %xmm1,%xmm0
jbe    12a3 <advect+0x193>
cvtsi2ssl -0x4(%rbp),%xmm0
movss  0xd66(%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  0xd35(%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  0xd10(%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    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1160 <advect+0x50>
jmp    13d2 <advect+0x2c2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    114d <advect+0x3d>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <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
mov    %rdx,-0x8(%rsp)
mov    %esi,-0x14(%rsp)
mov    %rdi,-0x10(%rsp)
test   %edi,%edi
jle    129d <advect+0x18d>
mov    -0x10(%rsp),%rdx
cvtsi2ss %edx,%xmm1
lea    0x2(%rdx),%r12d
movaps 0xebc(%rip),%xmm2
xorps  %xmm1,%xmm2
mulss  %xmm0,%xmm2
addss  0xebd(%rip),%xmm1
mov    %edx,%eax
lea    0x1(%rdx),%r10d
lea    0xc(%r8,%rax,4),%r8
lea    0x8(,%rax,4),%r11
lea    0xc(%r9,%rax,4),%r9
mov    -0x8(%rsp),%rdx
lea    (%rdx,%rax,4),%r15
add    $0xc,%r15
mov    $0x1,%edi
movss  0xe8a(%rip),%xmm8
movss  0xe85(%rip),%xmm9
nop
cvtsi2ss %edi,%xmm10
xor    %ebx,%ebx
mov    $0x1,%eax
nopl   0x0(%rax)
movss  (%r8,%rbx,1),%xmm3
mulss  %xmm2,%xmm3
xorps  %xmm5,%xmm5
cvtsi2ss %eax,%xmm5
addss  %xmm10,%xmm3
movss  (%r9,%rbx,1),%xmm6
mulss  %xmm2,%xmm6
addss  %xmm5,%xmm6
movaps %xmm8,%xmm7
maxss  %xmm3,%xmm7
movaps %xmm1,%xmm5
minss  %xmm7,%xmm5
cvttss2si %xmm5,%r13d
movaps %xmm8,%xmm3
maxss  %xmm6,%xmm3
movaps %xmm1,%xmm6
minss  %xmm3,%xmm6
cvttss2si %xmm6,%ebp
cvttps2dq %xmm5,%xmm3
cvtdq2ps %xmm3,%xmm3
subss  %xmm3,%xmm5
movaps %xmm9,%xmm3
subss  %xmm5,%xmm3
cvttps2dq %xmm6,%xmm7
cvtdq2ps %xmm7,%xmm7
subss  %xmm7,%xmm6
movaps %xmm9,%xmm7
subss  %xmm6,%xmm7
mov    %r12d,%r14d
imul   %ebp,%r14d
add    $0x1,%ebp
lea    (%r14,%r13,1),%esi
movslq %esi,%rsi
imul   %r12d,%ebp
lea    0x0(%rbp,%r13,1),%edx
movslq %edx,%rdx
movss  (%rcx,%rdx,4),%xmm0
mulss  %xmm6,%xmm0
movss  (%rcx,%rsi,4),%xmm4
mulss  %xmm7,%xmm4
addss  %xmm0,%xmm4
lea    0x1(%r14,%r13,1),%edx
movslq %edx,%rdx
lea    0x1(%rbp,%r13,1),%esi
movslq %esi,%rsi
mulss  (%rcx,%rsi,4),%xmm6
mulss  (%rcx,%rdx,4),%xmm7
mulss  %xmm3,%xmm4
addss  %xmm6,%xmm7
mulss  %xmm5,%xmm7
addss  %xmm4,%xmm7
movss  %xmm7,(%r15,%rbx,1)
add    $0x1,%rax
add    %r11,%rbx
cmp    %rax,%r10
jne    11a0 <advect+0x90>
add    $0x1,%rdi
add    $0x4,%r8
add    $0x4,%r9
add    $0x4,%r15
cmp    %r10,%rdi
jne    1190 <advect+0x80>
mov    -0x10(%rsp),%rdi
mov    -0x14(%rsp),%esi
mov    -0x8(%rsp),%rdx
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <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* %14
%29 = load i32, i32* %8
%30 = sitofp i32 %29 to float
%31 = fmul float %28, %30
store float %31, float* %27
store i32 1, i32* %15
br label %32
32: ; preds = %185, %7
%33 = load i32, i32* %15
%34 = load i32, i32* %8
%35 = icmp sle i32 %33, %34
br i1 %35, label %36, label %188
36: ; preds = %32
store i32 1, i32* %16
br label %37
37: ; preds = %181, %36
%38 = load i32, i32* %16
%39 = load i32, i32* %8
%40 = icmp sle i32 %38, %39
br i1 %40, label %41, label %184
41: ; preds = %37
%42 = load i32, i32* %15
%43 = sitofp i32 %42 to float
%44 = load float, float* %27
%45 = load float*, float** %12
%46 = load i32, i32* %15
%47 = load i32, i32* %8
%48 = add nsw i32 %47, 2
%49 = load i32, i32* %16
%50 = mul nsw i32 %48, %49
%51 = add nsw i32 %46, %50
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float, float* %45, i64 %52
%54 = load float, float* %53
%55 = fneg float %44
%56 = call float @llvm.fmuladd.f32(float %55, float %54, float %43)
store float %56, float* %21
%57 = load i32, i32* %16
%58 = sitofp i32 %57 to float
%59 = load float, float* %27
%60 = load float*, float** %13
%61 = load i32, i32* %15
%62 = load i32, i32* %8
%63 = add nsw i32 %62, 2
%64 = load i32, i32* %16
%65 = mul nsw i32 %63, %64
%66 = add nsw i32 %61, %65
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %60, i64 %67
%69 = load float, float* %68
%70 = fneg float %59
%71 = call float @llvm.fmuladd.f32(float %70, float %69, float %58)
store float %71, float* %22
%72 = load float, float* %21
%73 = fcmp olt float %72, 5.000000e-01
br i1 %73, label %74, label %75
74: ; preds = %41
store float 5.000000e-01, float* %21
br label %75
75: ; preds = %74, %41
%76 = load float, float* %21
%77 = load i32, i32* %8
%78 = sitofp i32 %77 to float
%79 = fadd float %78, 5.000000e-01
%80 = fcmp ogt float %76, %79
br i1 %80, label %81, label %85
81: ; preds = %75
%82 = load i32, i32* %8
%83 = sitofp i32 %82 to float
%84 = fadd float %83, 5.000000e-01
store float %84, float* %21
br label %85
85: ; preds = %81, %75
%86 = load float, float* %21
%87 = fptosi float %86 to i32
store i32 %87, i32* %17
%88 = load i32, i32* %17
%89 = add nsw i32 %88, 1
store i32 %89, i32* %19
%90 = load float, float* %22
%91 = fcmp olt float %90, 5.000000e-01
br i1 %91, label %92, label %93
92: ; preds = %85
store float 5.000000e-01, float* %22
br label %93
93: ; preds = %92, %85
%94 = load float, float* %22
%95 = load i32, i32* %8
%96 = sitofp i32 %95 to float
%97 = fadd float %96, 5.000000e-01
%98 = fcmp ogt float %94, %97
br i1 %98, label %99, label %103
99: ; preds = %93
%100 = load i32, i32* %8
%101 = sitofp i32 %100 to float
%102 = fadd float %101, 5.000000e-01
store float %102, float* %22
br label %103
103: ; preds = %99, %93
%104 = load float, float* %22
%105 = fptosi float %104 to i32
store i32 %105, i32* %18
%106 = load i32, i32* %18
%107 = add nsw i32 %106, 1
store i32 %107, i32* %20
%108 = load float, float* %21
%109 = load i32, i32* %17
%110 = sitofp i32 %109 to float
%111 = fsub float %108, %110
store float %111, float* %25
%112 = load float, float* %25
%113 = fsub float 1.000000e+00, %112
store float %113, float* %23
%114 = load float, float* %22
%115 = load i32, i32* %18
%116 = sitofp i32 %115 to float
%117 = fsub float %114, %116
store float %117, float* %26
%118 = load float, float* %26
%119 = fsub float 1.000000e+00, %118
store float %119, float* %24
%120 = load float, float* %23
%121 = load float, float* %24
%122 = load float*, float** %11
%123 = load i32, i32* %17
%124 = load i32, i32* %8
%125 = add nsw i32 %124, 2
%126 = load i32, i32* %18
%127 = mul nsw i32 %125, %126
%128 = add nsw i32 %123, %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds float, float* %122, i64 %129
%131 = load float, float* %130
%132 = load float, float* %26
%133 = load float*, float** %11
%134 = load i32, i32* %17
%135 = load i32, i32* %8
%136 = add nsw i32 %135, 2
%137 = load i32, i32* %20
%138 = mul nsw i32 %136, %137
%139 = add nsw i32 %134, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %133, i64 %140
%142 = load float, float* %141
%143 = fmul float %132, %142
%144 = call float @llvm.fmuladd.f32(float %121, float %131, float %143)
%145 = load float, float* %25
%146 = load float, float* %24
%147 = load float*, float** %11
%148 = load i32, i32* %19
%149 = load i32, i32* %8
%150 = add nsw i32 %149, 2
%151 = load i32, i32* %18
%152 = mul nsw i32 %150, %151
%153 = add nsw i32 %148, %152
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %147, i64 %154
%156 = load float, float* %155
%157 = load float, float* %26
%158 = load float*, float** %11
%159 = load i32, i32* %19
%160 = load i32, i32* %8
%161 = add nsw i32 %160, 2
%162 = load i32, i32* %20
%163 = mul nsw i32 %161, %162
%164 = add nsw i32 %159, %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %158, i64 %165
%167 = load float, float* %166
%168 = fmul float %157, %167
%169 = call float @llvm.fmuladd.f32(float %146, float %156, float %168)
%170 = fmul float %145, %169
%171 = call float @llvm.fmuladd.f32(float %120, float %144, float %170)
%172 = load float*, float** %10
%173 = load i32, i32* %15
%174 = load i32, i32* %8
%175 = add nsw i32 %174, 2
%176 = load i32, i32* %16
%177 = mul nsw i32 %175, %176
%178 = add nsw i32 %173, %177
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds float, float* %172, i64 %179
store float %171, float* %180
br label %181
181: ; preds = %103
%182 = load i32, i32* %16
%183 = add nsw i32 %182, 1
store i32 %183, i32* %16
br label %37
184: ; preds = %37
br label %185
185: ; preds = %184
%186 = load i32, i32* %15
%187 = add nsw i32 %186, 1
store i32 %187, i32* %15
br label %32
188: ; preds = %32
%189 = load i32, i32* %8
%190 = load i32, i32* %9
%191 = load float*, float** %10
%192 = call i32 @set_bnd(i32 %189, i32 %190, float* %191)
ret void
}

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