#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 */
void cvort4(const float *u, const float *v, size_t imax, size_t jmax,
            const float *dx, float dy, float *vort) {
  size_t i;
  size_t j;
  float du_dy1;
  float dv_dx1;
  float du_dy2;
  float dv_dx2;
  float du_dy;
  float dv_dx;
  for (i = 2; i < imax - 2; ++i) {
    for (j = 2; j < jmax - 2; ++j) {
      du_dy1 = 2 * (u[(i + 1) * jmax + j] - u[(i - 1) * jmax + j]) / (3 * dy);
      du_dy2 = (u[(i + 2) * jmax + j] - u[(i - 2) * jmax + j]) / (12 * dy);
      du_dy = du_dy1 - du_dy2;
      dv_dx1 =
          2 * (v[i * jmax + (j + 1)] - v[i * jmax + (j - 1)]) / (3 * dx[i]);
      dv_dx2 = (v[i * jmax + (j + 2)] - v[i * jmax + (j - 2)]) / (12 * dx[i]);
      dv_dx = dv_dx1 - dv_dx2;
      vort[i * jmax + j] = dv_dx - du_dy;
    }
  }
}


x86 assembly (clang, -O0):
<cvort4>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
mov    %r9,-0x38(%rbp)
movq   $0x2,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jae    131c <cvort4+0x21c>
movq   $0x2,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x2,%rcx
cmp    %rcx,%rax
jae    1306 <cvort4+0x206>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
add    $0x1,%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    $0x1,%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm1
movss  0xe71(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  0xe61(%rip),%xmm1
mulss  -0x2c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
add    $0x2,%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    $0x2,%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  0xe13(%rip),%xmm1
mulss  -0x2c(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x4c(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
mov    -0x48(%rbp),%rdx
add    $0x1,%rdx
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
mov    -0x48(%rbp),%rdx
sub    $0x1,%rdx
add    %rdx,%rcx
subss  (%rax,%rcx,4),%xmm1
movss  0xdbc(%rip),%xmm0
mulss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0xda4(%rip),%xmm1
mulss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
mov    -0x48(%rbp),%rdx
add    $0x2,%rdx
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
mov    -0x48(%rbp),%rdx
sub    $0x2,%rdx
add    %rdx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  0xd48(%rip),%xmm1
mulss  (%rax,%rcx,4),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x50(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
imul   -0x20(%rbp),%rcx
add    -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1146 <cvort4+0x46>
jmp    130b <cvort4+0x20b>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1129 <cvort4+0x29>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvort4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x80,%rsp
mov    %r9,-0x60(%rsp)
mov    %rcx,-0x58(%rsp)
mov    %rsi,-0x68(%rsp)
mov    %rdi,-0x70(%rsp)
add    $0xfffffffffffffffe,%rdx
mov    %rdx,0x70(%rsp)
cmp    $0x3,%rdx
jb     15f5 <cvort4+0x4f5>
mov    -0x58(%rsp),%rcx
lea    -0x2(%rcx),%rax
mov    %rax,-0x48(%rsp)
movss  0xeb2(%rip),%xmm1
mulss  %xmm0,%xmm1
mulss  0xeaa(%rip),%xmm0
lea    (%rcx,%rcx,1),%r13
lea    0x2(%rcx,%rcx,1),%rax
mov    %rax,0x58(%rsp)
lea    (%rcx,%rcx,2),%rdi
lea    -0x2(%rcx,%rcx,2),%rax
mov    %rax,0x48(%rsp)
lea    0x0(,%rcx,4),%r9
lea    0x2(,%rcx,4),%rax
mov    %rax,0x40(%rsp)
lea    -0x2(%rcx,%rcx,4),%rax
mov    %rax,0x38(%rsp)
lea    0x2(%rcx),%rax
mov    %rax,0x30(%rsp)
lea    -0x2(%rcx,%rcx,1),%r11
lea    0x2(%rcx,%rcx,2),%rax
mov    %rax,0x20(%rsp)
lea    -0x2(,%rcx,4),%rax
ff
mov    %rax,0x18(%rsp)
lea    -0x4(%rcx),%rax
mov    %rax,-0x40(%rsp)
mov    %rax,%rbp
and    $0xfffffffffffffffc,%rbp
movaps %xmm1,%xmm9
shufps $0x0,%xmm1,%xmm9
movaps %xmm0,%xmm10
shufps $0x0,%xmm0,%xmm10
mov    %rcx,%rax
shl    $0x4,%rax
mov    -0x70(%rsp),%rdx
lea    (%rax,%rdx,1),%rbx
add    $0x8,%rbx
movss  0xe07(%rip),%xmm12
movss  0xe06(%rip),%xmm11
movss  0xdf9(%rip),%xmm8
mov    %rbp,0x10(%rsp)
lea    0x2(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0x68(%rsp),%rax
lea    0x10(%rax,%rcx,8),%r12
lea    0x8(%rdx,%rdi,4),%rbp
lea    0x8(%rdx,%rcx,4),%r10
lea    0x8(%rdx),%r15
mov    -0x60(%rsp),%rax
lea    (%rax,%r13,4),%r14
add    $0x8,%r14
mov    $0x2,%esi
xor    %eax,%eax
mov    %rax,-0x50(%rsp)
mov    %r13,0x60(%rsp)
mov    %r13,-0x10(%rsp)
mov    %rdi,0x50(%rsp)
mov    %rdi,-0x18(%rsp)
mov    %rcx,-0x20(%rsp)
mov    %r9,0x68(%rsp)
mov    %r9,-0x28(%rsp)
mov    %rdx,-0x30(%rsp)
mov    %r11,0x28(%rsp)
mov    %r11,-0x38(%rsp)
jmp    12d9 <cvort4+0x1d9>
xchg   %ax,%ax
addq   $0x1,-0x50(%rsp)
mov    0x68(%rsp),%rcx
add    %rcx,%r12
mov    -0x8(%rsp),%rbp
add    %rcx,%rbp
add    %rcx,%r10
mov    (%rsp),%rbx
add    %rcx,%rbx
add    %rcx,%r15
add    %rcx,%r14
mov    -0x58(%rsp),%rax
add    %rax,-0x38(%rsp)
add    %rcx,-0x30(%rsp)
add    %rax,-0x28(%rsp)
add    %rax,-0x20(%rsp)
add    %rax,-0x18(%rsp)
add    %rax,-0x10(%rsp)
mov    0x78(%rsp),%rsi
cmp    0x70(%rsp),%rsi
je     15f5 <cvort4+0x4f5>
mov    %rbp,-0x8(%rsp)
mov    %rbx,(%rsp)
lea    0x1(%rsi),%rax
mov    %rax,0x78(%rsp)
cmpq   $0x3,-0x48(%rsp)
jb     1280 <cvort4+0x180>
mov    %rsi,%r11
mov    $0x2,%r9d
cmpq   $0x4,-0x40(%rsp)
jae    13f0 <cvort4+0x2f0>
mov    -0x48(%rsp),%rsi
sub    %r9,%rsi
mov    -0x38(%rsp),%rax
add    %r9,%rax
mov    -0x68(%rsp),%rcx
lea    (%rcx,%rax,4),%rcx
mov    -0x30(%rsp),%rax
lea    (%rax,%r9,4),%rbx
mov    -0x28(%rsp),%rax
add    %r9,%rax
mov    -0x70(%rsp),%rdx
lea    (%rdx,%rax,4),%rdi
mov    -0x20(%rsp),%rax
add    %r9,%rax
lea    (%rdx,%rax,4),%r13
mov    -0x18(%rsp),%rax
add    %r9,%rax
lea    (%rdx,%rax,4),%rax
add    -0x10(%rsp),%r9
mov    -0x60(%rsp),%rdx
lea    (%rdx,%r9,4),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rax,%rdx,4),%xmm6
subss  0x0(%r13,%rdx,4),%xmm6
addss  %xmm6,%xmm6
movss  (%rdi,%rdx,4),%xmm2
subss  (%rbx,%rdx,4),%xmm2
divss  %xmm1,%xmm6
divss  %xmm0,%xmm2
subss  %xmm2,%xmm6
movss  0xc(%rcx,%rdx,4),%xmm2
movss  0x10(%rcx,%rdx,4),%xmm3
subss  0x4(%rcx,%rdx,4),%xmm2
addss  %xmm2,%xmm2
movss  (%r8,%r11,4),%xmm4
movaps %xmm4,%xmm5
mulss  %xmm12,%xmm5
subss  (%rcx,%rdx,4),%xmm3
divss  %xmm5,%xmm2
mulss  %xmm11,%xmm4
divss  %xmm4,%xmm3
addss  %xmm2,%xmm3
subss  %xmm6,%xmm3
movss  %xmm3,0x0(%rbp,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    1370 <cvort4+0x270>
jmp    1280 <cvort4+0x180>
nopl   0x0(%rax,%rax,1)
mov    -0x50(%rsp),%rax
imul   -0x58(%rsp),%rax
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,1),%rdx
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,1),%rsi
mov    -0x48(%rsp),%rcx
lea    (%rcx,%rax,1),%rdi
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,1),%r13
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,1),%rbp
mov    0x30(%rsp),%rcx
add    %rax,%rcx
mov    %rcx,-0x78(%rsp)
mov    -0x60(%rsp),%rcx
lea    (%rcx,%rdx,4),%rdx
lea    (%rcx,%rsi,4),%rbx
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
add    $0x8,%rsi
lea    (%rcx,%rdi,4),%rdi
cmp    %rdi,%rdx
setb   -0x79(%rsp)
cmp    %rbx,%rsi
mov    0x28(%rsp),%rsi
lea    (%rsi,%rax,1),%rsi
lea    (%rcx,%r13,4),%rdi
lea    (%rcx,%rbp,4),%rbp
setb   -0x7a(%rsp)
cmp    %rbp,%rdx
setb   -0x7b(%rsp)
cmp    %rbx,%rdi
mov    0x20(%rsp),%rdi
lea    (%rdi,%rax,1),%rdi
mov    -0x78(%rsp),%rbp
lea    (%rcx,%rbp,4),%r13
lea    (%rcx,%rsi,4),%rsi
setb   -0x78(%rsp)
cmp    %rsi,%rdx
setb   %bpl
cmp    %rbx,%r13
mov    0x18(%rsp),%rsi
lea    (%rsi,%rax,1),%rsi
lea    (%rcx,%rdi,4),%rdi
lea    (%rcx,%rsi,4),%rsi
setb   -0x7c(%rsp)
cmp    %rsi,%rdx
setb   %r13b
cmp    %rbx,%rdi
mov    0x60(%rsp),%rcx
lea    (%rcx,%rax,1),%rdi
mov    0x50(%rsp),%rcx
lea    (%rcx,%rax,1),%rax
mov    -0x68(%rsp),%rsi
lea    (%rsi,%rdi,4),%rdi
lea    (%rsi,%rax,4),%rax
setb   -0x7d(%rsp)
cmp    %rax,%rdx
setb   %al
cmp    %rbx,%rdi
mov    -0x50(%rsp),%rcx
lea    0xc(%r8,%rcx,4),%rdi
setb   %cl
cmp    %rdi,%rdx
lea    (%r8,%r11,4),%rdi
setb   %dl
cmp    %rbx,%rdi
setb   %sil
mov    -0x7a(%rsp),%bl
test   %bl,-0x79(%rsp)
jne    1308 <cvort4+0x208>
mov    -0x78(%rsp),%bl
and    %bl,-0x7b(%rsp)
jne    1308 <cvort4+0x208>
and    -0x7c(%rsp),%bpl
jne    1308 <cvort4+0x208>
and    -0x7d(%rsp),%r13b
jne    1308 <cvort4+0x208>
and    %cl,%al
jne    1308 <cvort4+0x208>
and    %sil,%dl
jne    1308 <cvort4+0x208>
movss  (%r8,%r11,4),%xmm7
movaps %xmm7,%xmm6
mulss  %xmm12,%xmm6
shufps $0x0,%xmm6,%xmm6
mulss  %xmm8,%xmm7
shufps $0x0,%xmm7,%xmm7
xor    %eax,%eax
mov    0x10(%rsp),%rcx
mov    (%rsp),%rdx
mov    -0x8(%rsp),%rsi
nopl   (%rax)
movups (%rsi,%rax,4),%xmm2
movups (%r10,%rax,4),%xmm3
subps  %xmm3,%xmm2
addps  %xmm2,%xmm2
divps  %xmm9,%xmm2
movups (%rdx,%rax,4),%xmm3
movups (%r15,%rax,4),%xmm5
subps  %xmm5,%xmm3
divps  %xmm10,%xmm3
subps  %xmm3,%xmm2
movups -0x10(%r12,%rax,4),%xmm3
movups -0xc(%r12,%rax,4),%xmm5
movups -0x4(%r12,%rax,4),%xmm4
subps  %xmm5,%xmm4
movups (%r12,%rax,4),%xmm5
subps  %xmm3,%xmm5
divps  %xmm7,%xmm5
addps  %xmm4,%xmm4
divps  %xmm6,%xmm4
subps  %xmm5,%xmm4
subps  %xmm2,%xmm4
movups %xmm4,(%r14,%rax,4)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1580 <cvort4+0x480>
mov    0x8(%rsp),%r9
cmp    %rcx,-0x40(%rsp)
je     1280 <cvort4+0x180>
jmp    1308 <cvort4+0x208>
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @cvort4(float* nocapture %0, float* nocapture %1, i64 %2, i64 %3, float* nocapture %4, float %5, float* nocapture writeonly %6) {
%8 = add i64 %2, -2
%9 = icmp ugt i64 %8, 2
br i1 %9, label %10, label %214
10: ; preds = %7
%11 = add i64 %3, -2
%12 = icmp ugt i64 %11, 2
%13 = fmul float %5, 3.000000e+00
%14 = fmul float %5, 1.200000e+01
%15 = shl i64 %3, 1
%16 = add i64 %15, 2
%17 = mul i64 %3, 3
%18 = add i64 %17, -2
%19 = shl i64 %3, 2
%20 = or i64 %19, 2
%21 = mul i64 %3, 5
%22 = add i64 %21, -2
%23 = add i64 %3, 2
%24 = add i64 %15, -2
%25 = add i64 %17, 2
%26 = add i64 %19, -2
%27 = add i64 %3, -4
%28 = icmp ult i64 %27, 4
%29 = and i64 %27, -4
%30 = or i64 %29, 2
%31 = insertelement <4 x float> poison, float %13, i64 0
%32 = shufflevector <4 x float> %31, <4 x float> poison, <4 x i32> zeroinitializer
%33 = insertelement <4 x float> poison, float %14, i64 0
%34 = shufflevector <4 x float> %33, <4 x float> poison, <4 x i32> zeroinitializer
%35 = icmp eq i64 %27, %29
br label %36
36: ; preds = %10, %211
%37 = phi i64 [ 0, %10 ], [ %213, %211 ]
%38 = phi i64 [ 2, %10 ], [ %67, %211 ]
%39 = mul i64 %37, %3
%40 = add i64 %16, %39
%41 = getelementptr float, float* %6, i64 %40
%42 = add i64 %18, %39
%43 = getelementptr float, float* %6, i64 %42
%44 = add i64 %39, 2
%45 = getelementptr float, float* %0, i64 %44
%46 = add i64 %11, %39
%47 = getelementptr float, float* %0, i64 %46
%48 = add i64 %20, %39
%49 = getelementptr float, float* %0, i64 %48
%50 = add i64 %22, %39
%51 = getelementptr float, float* %0, i64 %50
%52 = add i64 %23, %39
%53 = getelementptr float, float* %0, i64 %52
%54 = add i64 %24, %39
%55 = getelementptr float, float* %0, i64 %54
%56 = add i64 %25, %39
%57 = getelementptr float, float* %0, i64 %56
%58 = add i64 %26, %39
%59 = getelementptr float, float* %0, i64 %58
%60 = add i64 %15, %39
%61 = getelementptr float, float* %1, i64 %60
%62 = add i64 %17, %39
%63 = getelementptr float, float* %1, i64 %62
%64 = getelementptr float, float* %4, i64 %38
%65 = add i64 %37, 3
%66 = getelementptr float, float* %4, i64 %65
%67 = add nuw i64 %38, 1
br i1 %12, label %68, label %211
68: ; preds = %36
%69 = mul i64 %67, %3
%70 = add i64 %38, -1
%71 = mul i64 %70, %3
%72 = add i64 %38, 2
%73 = mul i64 %72, %3
%74 = add i64 %38, -2
%75 = mul i64 %74, %3
%76 = mul i64 %38, %3
%77 = getelementptr inbounds float, float* %4, i64 %38
br i1 %28, label %163, label %78
78: ; preds = %68
%79 = icmp ult float* %41, %47
%80 = icmp ult float* %45, %43
%81 = and i1 %79, %80
%82 = icmp ult float* %41, %51
%83 = icmp ult float* %49, %43
%84 = and i1 %82, %83
%85 = or i1 %81, %84
%86 = icmp ult float* %41, %55
%87 = icmp ult float* %53, %43
%88 = and i1 %86, %87
%89 = or i1 %85, %88
%90 = icmp ult float* %41, %59
%91 = icmp ult float* %57, %43
%92 = and i1 %90, %91
%93 = or i1 %89, %92
%94 = icmp ult float* %41, %63
%95 = icmp ult float* %61, %43
%96 = and i1 %94, %95
%97 = or i1 %93, %96
%98 = icmp ult float* %41, %66
%99 = icmp ult float* %64, %43
%100 = and i1 %98, %99
%101 = or i1 %97, %100
br i1 %101, label %163, label %102
102: ; preds = %78
%103 = load float, float* %77
%104 = insertelement <4 x float> poison, float %103, i64 0
%105 = shufflevector <4 x float> %104, <4 x float> poison, <4 x i32> zeroinitializer
%106 = fmul <4 x float> %105, <float 3.000000e+00, float 3.000000e+00, float 3.000000e+00, float 3.000000e+00>
%107 = fmul <4 x float> %105, <float 1.200000e+01, float 1.200000e+01, float 1.200000e+01, float 1.200000e+01>
br label %108
108: ; preds = %108, %102
%109 = phi i64 [ 0, %102 ], [ %160, %108 ]
%110 = or i64 %109, 2
%111 = add i64 %110, %69
%112 = getelementptr inbounds float, float* %0, i64 %111
%113 = bitcast float* %112 to <4 x float>*
%114 = load <4 x float>, <4 x float>* %113
%115 = add i64 %110, %71
%116 = getelementptr inbounds float, float* %0, i64 %115
%117 = bitcast float* %116 to <4 x float>*
%118 = load <4 x float>, <4 x float>* %117
%119 = fsub <4 x float> %114, %118
%120 = fmul <4 x float> %119, <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>
%121 = fdiv <4 x float> %120, %32
%122 = add i64 %110, %73
%123 = getelementptr inbounds float, float* %0, i64 %122
%124 = bitcast float* %123 to <4 x float>*
%125 = load <4 x float>, <4 x float>* %124
%126 = add i64 %110, %75
%127 = getelementptr inbounds float, float* %0, i64 %126
%128 = bitcast float* %127 to <4 x float>*
%129 = load <4 x float>, <4 x float>* %128
%130 = fsub <4 x float> %125, %129
%131 = fdiv <4 x float> %130, %34
%132 = fsub <4 x float> %121, %131
%133 = or i64 %109, 3
%134 = add i64 %133, %76
%135 = getelementptr inbounds float, float* %1, i64 %134
%136 = bitcast float* %135 to <4 x float>*
%137 = load <4 x float>, <4 x float>* %136
%138 = add i64 %110, %76
%139 = add i64 %138, -1
%140 = getelementptr inbounds float, float* %1, i64 %139
%141 = bitcast float* %140 to <4 x float>*
%142 = load <4 x float>, <4 x float>* %141
%143 = fsub <4 x float> %137, %142
%144 = fmul <4 x float> %143, <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>
%145 = fdiv <4 x float> %144, %106
%146 = add i64 %138, 2
%147 = getelementptr inbounds float, float* %1, i64 %146
%148 = bitcast float* %147 to <4 x float>*
%149 = load <4 x float>, <4 x float>* %148
%150 = add i64 %138, -2
%151 = getelementptr inbounds float, float* %1, i64 %150
%152 = bitcast float* %151 to <4 x float>*
%153 = load <4 x float>, <4 x float>* %152
%154 = fsub <4 x float> %149, %153
%155 = fdiv <4 x float> %154, %107
%156 = fsub <4 x float> %145, %155
%157 = fsub <4 x float> %156, %132
%158 = getelementptr inbounds float, float* %6, i64 %138
%159 = bitcast float* %158 to <4 x float>*
store <4 x float> %157, <4 x float>* %159
%160 = add nuw i64 %109, 4
%161 = icmp eq i64 %160, %29
br i1 %161, label %162, label %108
162: ; preds = %108
br i1 %35, label %211, label %163
163: ; preds = %78, %68, %162
%164 = phi i64 [ 2, %78 ], [ 2, %68 ], [ %30, %162 ]
br label %165
165: ; preds = %163, %165
%166 = phi i64 [ %185, %165 ], [ %164, %163 ]
%167 = add i64 %166, %69
%168 = getelementptr inbounds float, float* %0, i64 %167
%169 = load float, float* %168
%170 = add i64 %166, %71
%171 = getelementptr inbounds float, float* %0, i64 %170
%172 = load float, float* %171
%173 = fsub float %169, %172
%174 = fmul float %173, 2.000000e+00
%175 = fdiv float %174, %13
%176 = add i64 %166, %73
%177 = getelementptr inbounds float, float* %0, i64 %176
%178 = load float, float* %177
%179 = add i64 %166, %75
%180 = getelementptr inbounds float, float* %0, i64 %179
%181 = load float, float* %180
%182 = fsub float %178, %181
%183 = fdiv float %182, %14
%184 = fsub float %175, %183
%185 = add nuw i64 %166, 1
%186 = add i64 %185, %76
%187 = getelementptr inbounds float, float* %1, i64 %186
%188 = load float, float* %187
%189 = add i64 %166, %76
%190 = add i64 %189, -1
%191 = getelementptr inbounds float, float* %1, i64 %190
%192 = load float, float* %191
%193 = fsub float %188, %192
%194 = fmul float %193, 2.000000e+00
%195 = load float, float* %77
%196 = fmul float %195, 3.000000e+00
%197 = fdiv float %194, %196
%198 = add i64 %189, 2
%199 = getelementptr inbounds float, float* %1, i64 %198
%200 = load float, float* %199
%201 = add i64 %189, -2
%202 = getelementptr inbounds float, float* %1, i64 %201
%203 = load float, float* %202
%204 = fsub float %200, %203
%205 = fmul float %195, 1.200000e+01
%206 = fdiv float %204, %205
%207 = fsub float %197, %206
%208 = fsub float %207, %184
%209 = getelementptr inbounds float, float* %6, i64 %189
store float %208, float* %209
%210 = icmp eq i64 %185, %11
br i1 %210, label %211, label %165
211: ; preds = %165, %162, %36
%212 = icmp eq i64 %67, %8
%213 = add i64 %37, 1
br i1 %212, label %214, label %36
214: ; preds = %211, %7
ret void
}