#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*/ MAX(int, int const);
int const MIN(int const, int /*<<< orphan*/);
void dt_masks_extend_border(float *mask, const int width, const int height,
                            const int border) {
  if (border <= 0)
    return;
  for (int row = border; row < height - border; row++) {
    const int idx = row * width;
    for (int i = 0; i < border; i++) {
      mask[idx + i] = mask[idx + border];
      mask[idx + width - i - 1] = mask[idx + width - border - 1];
    }
  }
  for (int col = 0; col < width; col++) {
    const float top =
        mask[border * width + MIN(width - border - 1, MAX(col, border))];
    const float bot = mask[(height - border - 1) * width +
                           MIN(width - border - 1, MAX(col, border))];
    for (int i = 0; i < border; i++) {
      mask[col + i * width] = top;
      mask[col + (height - i - 1) * width] = bot;
    }
  }
}


x86 assembly (clang, -O0):
<dt_masks_extend_border>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jg     1144 <dt_masks_extend_border+0x24>
jmp    1310 <dt_masks_extend_border+0x1f0>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    11ed <dt_masks_extend_border+0xcd>
mov    -0x18(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11da <dt_masks_extend_border+0xba>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0xc(%rbp),%ecx
sub    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0xc(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    116c <dt_masks_extend_border+0x4c>
jmp    11df <dt_masks_extend_border+0xbf>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    114a <dt_masks_extend_border+0x2a>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1310 <dt_masks_extend_border+0x1f0>
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x24(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1040 <MAX@plt>
mov    -0x50(%rbp),%edi
mov    %eax,%esi
call   1030 <MIN@plt>
mov    -0x4c(%rbp),%ecx
mov    %eax,%edx
mov    -0x48(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%eax
sub    -0x14(%rbp),%eax
sub    $0x1,%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x24(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1040 <MAX@plt>
mov    -0x40(%rbp),%edi
mov    %eax,%esi
call   1030 <MIN@plt>
mov    -0x3c(%rbp),%ecx
mov    %eax,%edx
mov    -0x38(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12fd <dt_masks_extend_border+0x1dd>
movss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0xc(%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    12a3 <dt_masks_extend_border+0x183>
jmp    1302 <dt_masks_extend_border+0x1e2>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11f4 <dt_masks_extend_border+0xd4>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dt_masks_extend_border>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rdx,0x38(%rsp)
mov    %rsi,0x28(%rsp)
mov    %rcx,0x10(%rsp)
test   %ecx,%ecx
jle    141e <dt_masks_extend_border+0x2fe>
mov    %rdi,%rbx
mov    0x38(%rsp),%rax
mov    %eax,%ecx
mov    0x10(%rsp),%rax
sub    %eax,%ecx
mov    %eax,%edx
not    %edx
mov    %rdx,0x30(%rsp)
mov    %eax,%edx
mov    %rdx,0x18(%rsp)
mov    %ecx,0xc(%rsp)
cmp    %eax,%ecx
mov    0x28(%rsp),%rcx
jle    128e <dt_masks_extend_border+0x16e>
movslq %ecx,%r9
movslq 0xc(%rsp),%r8
mov    0x18(%rsp),%r15
mov    %r15d,%r13d
and    $0xfffffffe,%r13d
mov    %r9,%rax
imul   %r15,%rax
lea    (%rbx,%rax,4),%rsi
add    $0x4,%rsi
lea    0x0(,%r9,4),%r10
mov    0x10(%rsp),%rax
lea    0x1(%rax),%r14d
imul   %ecx,%r14d
add    $0xfffffffe,%r14d
jmp    11d8 <dt_masks_extend_border+0xb8>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r15
add    %r10,%rsi
mov    0x28(%rsp),%rcx
add    %ecx,%r14d
cmp    %r8,%r15
je     128e <dt_masks_extend_border+0x16e>
mov    %r15,%r12
imul   %r9,%r12
mov    0x18(%rsp),%rax
add    %r12,%rax
lea    (%r12,%rcx,1),%r11d
mov    0x30(%rsp),%rcx
add    %r11d,%ecx
movslq %ecx,%rbp
cmpl   $0x1,0x10(%rsp)
jne    1210 <dt_masks_extend_border+0xf0>
xor    %edi,%edi
jmp    125e <dt_masks_extend_border+0x13e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14d,%ecx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rdi,4)
movss  (%rbx,%rbp,4),%xmm0
lea    0x1(%rcx),%edx
movslq %edx,%rdx
movss  %xmm0,(%rbx,%rdx,4)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
movss  (%rbx,%rbp,4),%xmm0
movslq %ecx,%rcx
movss  %xmm0,(%rbx,%rcx,4)
add    $0x2,%rdi
add    $0xfffffffe,%ecx
cmp    %rdi,%r13
jne    1220 <dt_masks_extend_border+0x100>
testb  $0x1,0x18(%rsp)
je     11c0 <dt_masks_extend_border+0xa0>
movss  (%rbx,%rax,4),%xmm0
add    %rdi,%r12
movss  %xmm0,(%rbx,%r12,4)
movss  (%rbx,%rbp,4),%xmm0
not    %edi
add    %edi,%r11d
movslq %r11d,%rax
movss  %xmm0,(%rbx,%rax,4)
jmp    11c0 <dt_masks_extend_border+0xa0>
test   %ecx,%ecx
jle    141e <dt_masks_extend_border+0x2fe>
mov    0x10(%rsp),%rax
mov    0x28(%rsp),%rcx
imul   %ecx,%eax
mov    %eax,0x4c(%rsp)
mov    0x30(%rsp),%rax
add    %ecx,%eax
mov    %rax,0x30(%rsp)
mov    0xc(%rsp),%eax
add    $0xffffffff,%eax
imul   %ecx,%eax
mov    %eax,0xc(%rsp)
mov    %ecx,%r15d
mov    0x18(%rsp),%rax
mov    %eax,%r8d
and    $0xfffffffe,%r8d
lea    0x0(,%r15,8),%r9
mov    0x38(%rsp),%rax
lea    -0x2(%rax),%edx
imul   %ecx,%edx
mov    %edx,0x48(%rsp)
lea    (%rcx,%rcx,1),%r12d
add    $0xffffffff,%eax
imul   %ecx,%eax
mov    %eax,0x44(%rsp)
xor    %ebp,%ebp
mov    %rbx,%r10
mov    %r8,0x58(%rsp)
mov    %r9,0x50(%rsp)
mov    0x10(%rsp),%r14
mov    0x30(%rsp),%r13
jmp    1321 <dt_masks_extend_border+0x201>
add    $0x1,%rbp
add    $0x4,%r10
cmp    %r15,%rbp
je     141e <dt_masks_extend_border+0x2fe>
mov    %r10,0x60(%rsp)
mov    %ebp,%edi
mov    %r14d,%esi
call   1040 <MAX@plt>
mov    %r13d,%edi
mov    %eax,%esi
call   1030 <MIN@plt>
add    0x4c(%rsp),%eax
cltq
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,0x24(%rsp)
mov    %ebp,%edi
mov    %r14d,%esi
call   1040 <MAX@plt>
mov    %r13d,%edi
mov    %eax,%esi
call   1030 <MIN@plt>
mov    0x60(%rsp),%r10
mov    0x50(%rsp),%r9
mov    0x58(%rsp),%r8
test   %r14d,%r14d
jle    1310 <dt_masks_extend_border+0x1f0>
add    0xc(%rsp),%eax
cltq
movss  (%rbx,%rax,4),%xmm0
cmpl   $0x1,0x10(%rsp)
jne    1390 <dt_masks_extend_border+0x270>
xor    %eax,%eax
jmp    13e4 <dt_masks_extend_border+0x2c4>
nopl   0x0(%rax)
mov    0x44(%rsp),%eax
mov    %eax,%ecx
mov    0x48(%rsp),%eax
mov    %eax,%edx
mov    %r10,%rsi
xor    %eax,%eax
movss  0x24(%rsp),%xmm1
nopw   0x0(%rax,%rax,1)
movss  %xmm1,(%rsi)
movslq %ecx,%rcx
lea    (%rcx,%rbp,1),%rdi
movss  %xmm0,(%rbx,%rdi,4)
movss  %xmm1,(%rsi,%r15,4)
movslq %edx,%rdx
lea    (%rdx,%rbp,1),%rdi
movss  %xmm0,(%rbx,%rdi,4)
add    $0x2,%rax
add    %r9,%rsi
sub    %r12d,%edx
sub    %r12d,%ecx
cmp    %rax,%r8
jne    13b0 <dt_masks_extend_border+0x290>
testb  $0x1,0x18(%rsp)
je     1310 <dt_masks_extend_border+0x1f0>
mov    %rax,%rcx
imul   %r15,%rcx
add    %rbp,%rcx
movss  0x24(%rsp),%xmm1
movss  %xmm1,(%rbx,%rcx,4)
not    %eax
add    0x38(%rsp),%eax
imul   0x28(%rsp),%eax
cltq
add    %rbp,%rax
movss  %xmm0,(%rbx,%rax,4)
jmp    1310 <dt_masks_extend_border+0x1f0>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @dt_masks_extend_border(float* %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca float*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca float
%14 = alloca float
%15 = alloca i32
store float* %0, float** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%16 = load i32, i32* %8
%17 = icmp sle i32 %16, 0
br i1 %17, label %18, label %19
18: ; preds = %4
br label %149
19: ; preds = %4
%20 = load i32, i32* %8
store i32 %20, i32* %9
br label %21
21: ; preds = %72, %19
%22 = load i32, i32* %9
%23 = load i32, i32* %7
%24 = load i32, i32* %8
%25 = sub nsw i32 %23, %24
%26 = icmp slt i32 %22, %25
br i1 %26, label %27, label %75
27: ; preds = %21
%28 = load i32, i32* %9
%29 = load i32, i32* %6
%30 = mul nsw i32 %28, %29
store i32 %30, i32* %10
store i32 0, i32* %11
br label %31
31: ; preds = %68, %27
%32 = load i32, i32* %11
%33 = load i32, i32* %8
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %71
35: ; preds = %31
%36 = load float*, float** %5
%37 = load i32, i32* %10
%38 = load i32, i32* %8
%39 = add nsw i32 %37, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds float, float* %36, i64 %40
%42 = load float, float* %41
%43 = load float*, float** %5
%44 = load i32, i32* %10
%45 = load i32, i32* %11
%46 = add nsw i32 %44, %45
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %43, i64 %47
store float %42, float* %48
%49 = load float*, float** %5
%50 = load i32, i32* %10
%51 = load i32, i32* %6
%52 = add nsw i32 %50, %51
%53 = load i32, i32* %8
%54 = sub nsw i32 %52, %53
%55 = sub nsw i32 %54, 1
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds float, float* %49, i64 %56
%58 = load float, float* %57
%59 = load float*, float** %5
%60 = load i32, i32* %10
%61 = load i32, i32* %6
%62 = add nsw i32 %60, %61
%63 = load i32, i32* %11
%64 = sub nsw i32 %62, %63
%65 = sub nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %59, i64 %66
store float %58, float* %67
br label %68
68: ; preds = %35
%69 = load i32, i32* %11
%70 = add nsw i32 %69, 1
store i32 %70, i32* %11
br label %31
71: ; preds = %31
br label %72
72: ; preds = %71
%73 = load i32, i32* %9
%74 = add nsw i32 %73, 1
store i32 %74, i32* %9
br label %21
75: ; preds = %21
store i32 0, i32* %12
br label %76
76: ; preds = %146, %75
%77 = load i32, i32* %12
%78 = load i32, i32* %6
%79 = icmp slt i32 %77, %78
br i1 %79, label %80, label %149
80: ; preds = %76
%81 = load float*, float** %5
%82 = load i32, i32* %8
%83 = load i32, i32* %6
%84 = mul nsw i32 %82, %83
%85 = load i32, i32* %6
%86 = load i32, i32* %8
%87 = sub nsw i32 %85, %86
%88 = sub nsw i32 %87, 1
%89 = load i32, i32* %12
%90 = load i32, i32* %8
%91 = call i32 @MAX(i32 %89, i32 %90)
%92 = call i32 @MIN(i32 %88, i32 %91)
%93 = add nsw i32 %84, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float, float* %81, i64 %94
%96 = load float, float* %95
store float %96, float* %13
%97 = load float*, float** %5
%98 = load i32, i32* %7
%99 = load i32, i32* %8
%100 = sub nsw i32 %98, %99
%101 = sub nsw i32 %100, 1
%102 = load i32, i32* %6
%103 = mul nsw i32 %101, %102
%104 = load i32, i32* %6
%105 = load i32, i32* %8
%106 = sub nsw i32 %104, %105
%107 = sub nsw i32 %106, 1
%108 = load i32, i32* %12
%109 = load i32, i32* %8
%110 = call i32 @MAX(i32 %108, i32 %109)
%111 = call i32 @MIN(i32 %107, i32 %110)
%112 = add nsw i32 %103, %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %97, i64 %113
%115 = load float, float* %114
store float %115, float* %14
store i32 0, i32* %15
br label %116
116: ; preds = %142, %80
%117 = load i32, i32* %15
%118 = load i32, i32* %8
%119 = icmp slt i32 %117, %118
br i1 %119, label %120, label %145
120: ; preds = %116
%121 = load float, float* %13
%122 = load float*, float** %5
%123 = load i32, i32* %12
%124 = load i32, i32* %15
%125 = load i32, i32* %6
%126 = mul nsw i32 %124, %125
%127 = add nsw i32 %123, %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds float, float* %122, i64 %128
store float %121, float* %129
%130 = load float, float* %14
%131 = load float*, float** %5
%132 = load i32, i32* %12
%133 = load i32, i32* %7
%134 = load i32, i32* %15
%135 = sub nsw i32 %133, %134
%136 = sub nsw i32 %135, 1
%137 = load i32, i32* %6
%138 = mul nsw i32 %136, %137
%139 = add nsw i32 %132, %138
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %131, i64 %140
store float %130, float* %141
br label %142
142: ; preds = %120
%143 = load i32, i32* %15
%144 = add nsw i32 %143, 1
store i32 %144, i32* %15
br label %116
145: ; preds = %116
br label %146
146: ; preds = %145
%147 = load i32, i32* %12
%148 = add nsw i32 %147, 1
store i32 %148, i32* %12
br label %76
149: ; preds = %18, %76
ret void
}

LLVM IR (-O2):
define void @dt_masks_extend_border(float* nocapture %0, i32 %1, i32 %2, i32 %3) {
%5 = icmp slt i32 %3, 1
br i1 %5, label %143, label %6
6: ; preds = %4
%7 = sub i32 %2, %3
%8 = icmp sgt i32 %7, %3
br i1 %8, label %9, label %18
9: ; preds = %6
%10 = xor i32 %3, -1
%11 = zext i32 %3 to i64
%12 = sext i32 %1 to i64
%13 = sext i32 %7 to i64
%14 = and i64 %11, 1
%15 = icmp eq i32 %3, 1
%16 = and i64 %11, 4294967294
%17 = icmp eq i64 %14, 0
br label %34
18: ; preds = %56, %6
%19 = icmp sgt i32 %1, 0
br i1 %19, label %20, label %143
20: ; preds = %18
%21 = mul nsw i32 %3, %1
%22 = xor i32 %3, -1
%23 = add i32 %22, %1
%24 = add nsw i32 %7, -1
%25 = mul nsw i32 %24, %1
%26 = icmp sgt i32 %3, 0
%27 = zext i32 %1 to i64
%28 = zext i32 %1 to i64
%29 = zext i32 %3 to i64
%30 = and i64 %29, 1
%31 = icmp eq i32 %3, 1
%32 = and i64 %29, 4294967294
%33 = icmp eq i64 %30, 0
br label %84
34: ; preds = %9, %56
%35 = phi i64 [ %11, %9 ], [ %57, %56 ]
%36 = mul nsw i64 %35, %12
%37 = add nsw i64 %36, %11
%38 = getelementptr inbounds float, float* %0, i64 %37
%39 = trunc i64 %36 to i32
%40 = add i32 %39, %1
%41 = add i32 %40, %10
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %0, i64 %42
br i1 %15, label %44, label %59
44: ; preds = %59, %34
%45 = phi i64 [ 0, %34 ], [ %81, %59 ]
br i1 %17, label %56, label %46
46: ; preds = %44
%47 = load float, float* %38
%48 = add nsw i64 %45, %36
%49 = getelementptr inbounds float, float* %0, i64 %48
store float %47, float* %49
%50 = load float, float* %43
%51 = trunc i64 %45 to i32
%52 = xor i32 %51, -1
%53 = add i32 %40, %52
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float, float* %0, i64 %54
store float %50, float* %55
br label %56
56: ; preds = %44, %46
%57 = add nuw nsw i64 %35, 1
%58 = icmp eq i64 %57, %13
br i1 %58, label %18, label %34
59: ; preds = %34, %59
%60 = phi i64 [ %81, %59 ], [ 0, %34 ]
%61 = phi i64 [ %82, %59 ], [ 0, %34 ]
%62 = load float, float* %38
%63 = add nsw i64 %60, %36
%64 = getelementptr inbounds float, float* %0, i64 %63
store float %62, float* %64
%65 = load float, float* %43
%66 = trunc i64 %60 to i32
%67 = xor i32 %66, -1
%68 = add i32 %40, %67
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float, float* %0, i64 %69
store float %65, float* %70
%71 = or i64 %60, 1
%72 = load float, float* %38
%73 = add nsw i64 %71, %36
%74 = getelementptr inbounds float, float* %0, i64 %73
store float %72, float* %74
%75 = load float, float* %43
%76 = trunc i64 %71 to i32
%77 = xor i32 %76, -1
%78 = add i32 %40, %77
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float, float* %0, i64 %79
store float %75, float* %80
%81 = add nuw nsw i64 %60, 2
%82 = add i64 %61, 2
%83 = icmp eq i64 %82, %16
br i1 %83, label %44, label %59
84: ; preds = %20, %113
%85 = phi i64 [ 0, %20 ], [ %114, %113 ]
%86 = trunc i64 %85 to i32
%87 = tail call i32 @MAX(i32 %86, i32 %3)
%88 = tail call i32 @MIN(i32 %23, i32 %87)
%89 = add nsw i32 %88, %21
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds float, float* %0, i64 %90
%92 = load float, float* %91
%93 = tail call i32 @MAX(i32 %86, i32 %3)
%94 = tail call i32 @MIN(i32 %23, i32 %93)
%95 = add nsw i32 %94, %25
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float, float* %0, i64 %96
%98 = load float, float* %97
br i1 %26, label %99, label %113
99: ; preds = %84
br i1 %31, label %100, label %116
100: ; preds = %116, %99
%101 = phi i64 [ 0, %99 ], [ %140, %116 ]
br i1 %33, label %113, label %102
102: ; preds = %100
%103 = mul nsw i64 %101, %27
%104 = add nuw nsw i64 %103, %85
%105 = getelementptr inbounds float, float* %0, i64 %104
store float %92, float* %105
%106 = trunc i64 %101 to i32
%107 = xor i32 %106, -1
%108 = add i32 %107, %2
%109 = mul nsw i32 %108, %1
%110 = sext i32 %109 to i64
%111 = add nsw i64 %85, %110
%112 = getelementptr inbounds float, float* %0, i64 %111
store float %98, float* %112
br label %113
113: ; preds = %102, %100, %84
%114 = add nuw nsw i64 %85, 1
%115 = icmp eq i64 %114, %28
br i1 %115, label %143, label %84
116: ; preds = %99, %116
%117 = phi i64 [ %140, %116 ], [ 0, %99 ]
%118 = phi i64 [ %141, %116 ], [ 0, %99 ]
%119 = mul nsw i64 %117, %27
%120 = add nuw nsw i64 %119, %85
%121 = getelementptr inbounds float, float* %0, i64 %120
store float %92, float* %121
%122 = trunc i64 %117 to i32
%123 = xor i32 %122, -1
%124 = add i32 %123, %2
%125 = mul nsw i32 %124, %1
%126 = sext i32 %125 to i64
%127 = add nsw i64 %85, %126
%128 = getelementptr inbounds float, float* %0, i64 %127
store float %98, float* %128
%129 = or i64 %117, 1
%130 = mul nsw i64 %129, %27
%131 = add nuw nsw i64 %130, %85
%132 = getelementptr inbounds float, float* %0, i64 %131
store float %92, float* %132
%133 = trunc i64 %129 to i32
%134 = xor i32 %133, -1
%135 = add i32 %134, %2
%136 = mul nsw i32 %135, %1
%137 = sext i32 %136 to i64
%138 = add nsw i64 %85, %137
%139 = getelementptr inbounds float, float* %0, i64 %138
store float %98, float* %139
%140 = add nuw nsw i64 %117, 2
%141 = add i64 %118, 2
%142 = icmp eq i64 %141, %32
br i1 %142, label %100, label %116
143: ; preds = %113, %18, %4
ret void
}