#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 floor(float);
int /*<<< orphan*/ max(int, int /*<<< orphan*/);
int min(int /*<<< orphan*/, int);
void warpAffine(float *warped, float *input, float *X, int m, int n, int o) {
  int m2 = m;
  int n2 = n;
  int o2 = o;
  for (int k = 0; k < o; k++) {
    for (int j = 0; j < n; j++) {
      for (int i = 0; i < m; i++) {
        float y1 =
            (float)i * X[0] + (float)j * X[1] + (float)k * X[2] + (float)X[3];
        float x1 =
            (float)i * X[4] + (float)j * X[5] + (float)k * X[6] + (float)X[7];
        float z1 =
            (float)i * X[8] + (float)j * X[9] + (float)k * X[10] + (float)X[11];
        int x = floor(x1);
        int y = floor(y1);
        int z = floor(z1);
        float dx = x1 - x;
        float dy = y1 - y;
        float dz = z1 - z;
        if (y < 0 | y >= m2 - 1 | x < 0 | x >= n2 - 1 | z < 0 | z >= o2 - 1) {
          warped[i + j * m + k * m * n] = 0.0;
        } else {
          warped[i + j * m + k * m * n] =
              (1.0 - dx) * (1.0 - dy) * (1.0 - dz) *
                  input[min(max(y, 0), m2 - 1) + min(max(x, 0), n2 - 1) * m2 +
                        min(max(z, 0), o2 - 1) * m2 * n2] +
              (1.0 - dx) * dy * (1.0 - dz) *
                  input[min(max(y + 1, 0), m2 - 1) +
                        min(max(x, 0), n2 - 1) * m2 +
                        min(max(z, 0), o2 - 1) * m2 * n2] +
              dx * (1.0 - dy) * (1.0 - dz) *
                  input[min(max(y, 0), m2 - 1) +
                        min(max(x + 1, 0), n2 - 1) * m2 +
                        min(max(z, 0), o2 - 1) * m2 * n2] +
              (1.0 - dx) * (1.0 - dy) * dz *
                  input[min(max(y, 0), m2 - 1) + min(max(x, 0), n2 - 1) * m2 +
                        min(max(z + 1, 0), o2 - 1) * m2 * n2] +
              dx * dy * (1.0 - dz) *
                  input[min(max(y + 1, 0), m2 - 1) +
                        min(max(x + 1, 0), n2 - 1) * m2 +
                        min(max(z, 0), o2 - 1) * m2 * n2] +
              (1.0 - dx) * dy * dz *
                  input[min(max(y + 1, 0), m2 - 1) +
                        min(max(x, 0), n2 - 1) * m2 +
                        min(max(z + 1, 0), o2 - 1) * m2 * n2] +
              dx * (1.0 - dy) * dz *
                  input[min(max(y, 0), m2 - 1) +
                        min(max(x + 1, 0), n2 - 1) * m2 +
                        min(max(z + 1, 0), o2 - 1) * m2 * n2] +
              dx * dy * dz *
                  input[min(max(y + 1, 0), m2 - 1) +
                        min(max(x + 1, 0), n2 - 1) * m2 +
                        min(max(z + 1, 0), o2 - 1) * m2 * n2];
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<warpAffine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1b0a <warpAffine+0x9da>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1af7 <warpAffine+0x9c7>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1ae4 <warpAffine+0x9b4>
cvtsi2ssl -0x3c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
cvtsi2ssl -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
cvtsi2ssl -0x34(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
addss  0xc(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
cvtsi2ssl -0x3c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm2
cvtsi2ssl -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
cvtsi2ssl -0x34(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
addss  0x1c(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
cvtsi2ssl -0x3c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
cvtsi2ssl -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
cvtsi2ssl -0x34(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
addss  0x2c(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
call   1050 <floor@plt>
mov    %eax,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm0
call   1050 <floor@plt>
mov    %eax,-0x50(%rbp)
movss  -0x48(%rbp),%xmm0
call   1050 <floor@plt>
mov    %eax,-0x54(%rbp)
movss  -0x44(%rbp),%xmm0
cvtsi2ssl -0x4c(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x40(%rbp),%xmm0
cvtsi2ssl -0x50(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
cvtsi2ssl -0x54(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
cmpl   $0x0,-0x50(%rbp)
setl   %al
and    $0x1,%al
movzbl %al,%eax
mov    -0x50(%rbp),%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
cmp    %edx,%ecx
setge  %cl
and    $0x1,%cl
movzbl %cl,%ecx
or     %ecx,%eax
cmpl   $0x0,-0x4c(%rbp)
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
or     %ecx,%eax
mov    -0x4c(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
cmp    %edx,%ecx
setge  %cl
and    $0x1,%cl
movzbl %cl,%ecx
or     %ecx,%eax
cmpl   $0x0,-0x54(%rbp)
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
or     %ecx,%eax
mov    -0x54(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
cmp    %edx,%ecx
setge  %cl
and    $0x1,%cl
movzbl %cl,%ecx
or     %ecx,%eax
cmp    $0x0,%eax
je     1376 <warpAffine+0x246>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1ad1 <warpAffine+0x9a1>
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xc79(%rip),%xmm0
subsd  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xc64(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xc4b(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x50(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x28(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,-0x158(%rbp)
mov    -0x4c(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x2c(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,%ecx
mov    -0x158(%rbp),%eax
imul   -0x28(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x154(%rbp)
mov    -0x54(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x30(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    -0x154(%rbp),%ecx
mov    %eax,%edx
mov    -0x150(%rbp),%rax
imul   -0x28(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb93(%rip),%xmm0
subsd  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xb71(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x50(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x28(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,-0x148(%rbp)
mov    -0x4c(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x2c(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,%ecx
mov    -0x148(%rbp),%eax
imul   -0x28(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x144(%rbp)
mov    -0x54(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x30(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    -0x144(%rbp),%ecx
movsd  -0x140(%rbp),%xmm1
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x130(%rbp),%xmm2
ff
mov    %eax,%edx
mov    -0x128(%rbp),%rax
imul   -0x28(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x5c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xa89(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xa70(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x50(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x28(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,-0x120(%rbp)
mov    -0x4c(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x2c(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,%ecx
mov    -0x120(%rbp),%eax
imul   -0x28(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x11c(%rbp)
mov    -0x54(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x30(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    -0x11c(%rbp),%ecx
movsd  -0x118(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
mov    %eax,%edx
mov    -0x108(%rbp),%rax
imul   -0x28(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x99d(%rip),%xmm0
subsd  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x988(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x50(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x28(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,-0x100(%rbp)
mov    -0x4c(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x2c(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,%ecx
mov    -0x100(%rbp),%eax
imul   -0x28(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xfc(%rbp)
mov    -0x54(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x30(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    -0xfc(%rbp),%ecx
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm1
ff
mov    %eax,%edx
mov    -0xe8(%rbp),%rax
imul   -0x28(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movss  -0x58(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x89a(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x50(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x28(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,-0xe0(%rbp)
mov    -0x4c(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x2c(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,%ecx
mov    -0xe0(%rbp),%eax
imul   -0x28(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xdc(%rbp)
mov    -0x54(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x30(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    -0xdc(%rbp),%ecx
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
mov    %eax,%edx
mov    -0xc8(%rbp),%rax
imul   -0x28(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x7c4(%rip),%xmm0
subsd  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x50(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x28(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,-0xc0(%rbp)
mov    -0x4c(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x2c(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,%ecx
mov    -0xc0(%rbp),%eax
imul   -0x28(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xbc(%rbp)
mov    -0x54(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x30(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    -0xbc(%rbp),%ecx
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
mov    %eax,%edx
mov    -0xa8(%rbp),%rax
imul   -0x28(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x5c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x6cf(%rip),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x50(%rbp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x28(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,-0xa0(%rbp)
mov    -0x4c(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x2c(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,%ecx
mov    -0xa0(%rbp),%eax
imul   -0x28(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x54(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x30(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    -0x9c(%rbp),%ecx
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
mov    %eax,%edx
mov    -0x88(%rbp),%rax
imul   -0x28(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movss  -0x58(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x50(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x28(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,-0x7c(%rbp)
mov    -0x4c(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x2c(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    %eax,%ecx
mov    -0x7c(%rbp),%eax
imul   -0x28(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x78(%rbp)
mov    -0x54(%rbp),%edi
add    $0x1,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    -0x30(%rbp),%esi
sub    $0x1,%esi
call   1030 <min@plt>
mov    -0x78(%rbp),%ecx
movss  -0x74(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
mov    %eax,%edx
mov    -0x68(%rbp),%rax
imul   -0x28(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x1c(%rbp),%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
imul   -0x1c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1ad6 <warpAffine+0x9a6>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1191 <warpAffine+0x61>
jmp    1ae9 <warpAffine+0x9b9>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    117e <warpAffine+0x4e>
jmp    1afc <warpAffine+0x9cc>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    116b <warpAffine+0x3b>
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<warpAffine>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %r8,0x20(%rsp)
mov    %rcx,0x28(%rsp)
mov    %rsi,0x38(%rsp)
mov    %rdi,0x118(%rsp)
mov    %r9,0xe0(%rsp)
test   %r9d,%r9d
jle    198d <warpAffine+0x85d>
mov    %rdx,%r15
mov    0x28(%rsp),%rdx
lea    -0x1(%rdx),%eax
mov    %eax,0xc(%rsp)
mov    0x20(%rsp),%rcx
lea    -0x1(%rcx),%eax
mov    %eax,0x10(%rsp)
mov    0xe0(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0x18(%rsp)
mov    %edx,%eax
mov    %rax,0xe8(%rsp)
imul   %edx,%ecx
mov    %rcx,0x108(%rsp)
xor    %eax,%eax
mov    %rax,0xb8(%rsp)
movl   $0x0,0x40(%rsp)
jmp    11f0 <warpAffine+0xc0>
nopl   0x0(%rax)
mov    0x40(%rsp),%ecx
add    $0x1,%ecx
mov    0xb8(%rsp),%rax
add    0x108(%rsp),%rax
mov    %rax,0xb8(%rsp)
mov    %ecx,0x40(%rsp)
cmp    0xe0(%rsp),%ecx
je     198d <warpAffine+0x85d>
cmpl   $0x0,0x20(%rsp)
jle    11c0 <warpAffine+0x90>
xorps  %xmm0,%xmm0
cvtsi2ssl 0x40(%rsp),%xmm0
movaps %xmm0,0x130(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x120(%rsp)
movl   $0x0,0x44(%rsp)
mov    0xb8(%rsp),%rax
mov    %rax,0xc0(%rsp)
jmp    125d <warpAffine+0x12d>
xchg   %ax,%ax
mov    0x44(%rsp),%eax
add    $0x1,%eax
mov    0xc0(%rsp),%rcx
add    0xe8(%rsp),%rcx
mov    %rcx,0xc0(%rsp)
mov    %eax,0x44(%rsp)
cmp    0x20(%rsp),%eax
je     11c0 <warpAffine+0x90>
cmpl   $0x0,0x28(%rsp)
jle    1230 <warpAffine+0x100>
xorps  %xmm0,%xmm0
cvtsi2ssl 0x44(%rsp),%xmm0
movaps %xmm0,0x150(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x140(%rsp)
xor    %ebx,%ebx
jmp    12bb <warpAffine+0x18b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0xc0(%rsp),%rax
add    %ebx,%eax
cltq
mov    0x118(%rsp),%rcx
movss  %xmm0,(%rcx,%rax,4)
add    $0x1,%rbx
cmp    %rbx,0xe8(%rsp)
je     1230 <warpAffine+0x100>
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
movss  0x14(%r15),%xmm1
movss  (%r15),%xmm2
movss  0x4(%r15),%xmm3
unpcklps %xmm3,%xmm1
mulps  0x140(%rsp),%xmm1
movss  0x8(%r15),%xmm3
movss  0xc(%r15),%xmm4
movaps %xmm0,%xmm5
shufps $0x0,%xmm0,%xmm5
movss  0x10(%r15),%xmm6
unpcklps %xmm2,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm1,%xmm6
movss  0x18(%r15),%xmm1
unpcklps %xmm3,%xmm1
mulps  0x120(%rsp),%xmm1
addps  %xmm6,%xmm1
movss  0x1c(%r15),%xmm2
unpcklps %xmm4,%xmm2
addps  %xmm1,%xmm2
movaps %xmm2,0x60(%rsp)
movss  0x24(%r15),%xmm1
mulss  0x150(%rsp),%xmm1
mulss  0x20(%r15),%xmm0
addss  %xmm1,%xmm0
movss  0x28(%r15),%xmm1
mulss  0x130(%rsp),%xmm1
addss  %xmm0,%xmm1
addss  0x2c(%r15),%xmm1
movss  %xmm1,0x1c(%rsp)
movaps %xmm2,%xmm0
call   1050 <floor@plt>
mov    %eax,%r14d
movaps 0x60(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
call   1050 <floor@plt>
mov    %eax,%r13d
movss  0x1c(%rsp),%xmm0
call   1050 <floor@plt>
xor    %ebp,%ebp
cmp    0xc(%rsp),%r13d
setge  %bpl
xor    %ecx,%ecx
cmp    0x10(%rsp),%r14d
setge  %cl
mov    %eax,%edx
shr    $0x1f,%edx
xor    %esi,%esi
cmp    0x18(%rsp),%eax
setge  %sil
mov    %r13d,%r12d
or     %r14d,%r13d
shr    $0x1f,%r13d
or     %ecx,%r13d
or     %ebp,%r13d
or     %edx,%r13d
xorps  %xmm0,%xmm0
or     %esi,%r13d
jne    1290 <warpAffine+0x160>
movd   %r14d,%xmm0
movd   %r12d,%xmm1
punpckldq %xmm1,%xmm0
cvtdq2ps %xmm0,%xmm0
movaps 0x60(%rsp),%xmm2
subps  %xmm0,%xmm2
movaps %xmm2,0x60(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  0x1c(%rsp),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x1c(%rsp)
cvtps2pd %xmm2,%xmm2
movapd %xmm2,0xd0(%rsp)
movapd 0xbf0(%rip),%xmm3
subpd  %xmm2,%xmm3
movapd %xmm3,0x90(%rsp)
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movapd %xmm0,0xa0(%rsp)
movapd %xmm3,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm2,0x80(%rsp)
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,0x50(%rsp)
movsd  0xbbf(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rsp)
mulsd  %xmm0,%xmm2
movapd %xmm2,0xf0(%rsp)
mov    %r12d,%edi
mov    %rbx,0x110(%rsp)
mov    %r12d,0x5c(%rsp)
xor    %esi,%esi
mov    %eax,%ebx
mov    %eax,0x58(%rsp)
call   1040 <max@plt>
mov    %eax,%edi
mov    0xc(%rsp),%esi
call   1030 <min@plt>
mov    %eax,%r13d
mov    %r14d,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0x10(%rsp),%esi
call   1030 <min@plt>
mov    %eax,%ebp
mov    %ebx,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0x18(%rsp),%esi
call   1030 <min@plt>
mov    0x20(%rsp),%rcx
imul   %ecx,%eax
add    %ebp,%eax
imul   0x28(%rsp),%eax
add    %r13d,%eax
cltq
mov    0x38(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0xf0(%rsp),%xmm0
movsd  %xmm0,0x48(%rsp)
movapd 0xd0(%rsp),%xmm0
unpckhpd %xmm0,%xmm0
mulsd  0x90(%rsp),%xmm0
movapd %xmm0,0x90(%rsp)
mulsd  0x30(%rsp),%xmm0
movapd %xmm0,0x70(%rsp)
add    $0x1,%r12d
mov    %r12d,0xf0(%rsp)
mov    %r12d,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0xc(%rsp),%esi
call   1030 <min@plt>
mov    %eax,0x14(%rsp)
mov    %r14d,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0x10(%rsp),%ebx
mov    %ebx,%esi
call   1030 <min@plt>
mov    %eax,%ebp
mov    0x58(%rsp),%r12d
mov    %r12d,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0x18(%rsp),%r13d
mov    %r13d,%esi
call   1030 <min@plt>
imul   0x20(%rsp),%eax
add    %ebp,%eax
imul   0x28(%rsp),%eax
add    0x14(%rsp),%eax
cltq
mov    0x38(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0x70(%rsp),%xmm0
addsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x48(%rsp)
movapd 0xa0(%rsp),%xmm0
mulsd  0xd0(%rsp),%xmm0
movapd %xmm0,0xa0(%rsp)
mulsd  0x30(%rsp),%xmm0
movapd %xmm0,0x70(%rsp)
mov    0x5c(%rsp),%ebp
mov    %ebp,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0xc(%rsp),%esi
call   1030 <min@plt>
mov    %eax,0x14(%rsp)
mov    %r14d,0xcc(%rsp)
mov    %r14d,%edi
add    $0x1,%edi
mov    %edi,0xd0(%rsp)
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    %ebx,%esi
call   1030 <min@plt>
mov    %eax,%ebx
mov    %r12d,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    %r13d,%esi
mov    %r13d,%r12d
call   1030 <min@plt>
imul   0x20(%rsp),%eax
add    %ebx,%eax
mov    0x28(%rsp),%r13
imul   %r13d,%eax
add    0x14(%rsp),%eax
cltq
mov    0x38(%rsp),%rbx
movss  (%rbx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0x70(%rsp),%xmm0
addsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x70(%rsp)
movapd 0x80(%rsp),%xmm0
mulsd  0x50(%rsp),%xmm0
movapd %xmm0,0x80(%rsp)
mov    %ebp,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0xc(%rsp),%esi
call   1030 <min@plt>
mov    %eax,0x14(%rsp)
mov    %r14d,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0x10(%rsp),%esi
call   1030 <min@plt>
mov    %eax,%ebp
mov    0x58(%rsp),%r14d
mov    %r14d,%edi
add    $0x1,%edi
mov    %edi,0x48(%rsp)
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    %r12d,%esi
call   1030 <min@plt>
mov    0x20(%rsp),%r12
imul   %r12d,%eax
add    %ebp,%eax
imul   %r13d,%eax
add    0x14(%rsp),%eax
cltq
movss  (%rbx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0x80(%rsp),%xmm0
addsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x80(%rsp)
movaps 0x60(%rsp),%xmm0
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm1,0x60(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    0xf0(%rsp),%ebx
mov    %ebx,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0xc(%rsp),%esi
call   1030 <min@plt>
mov    %eax,0x70(%rsp)
mov    0xd0(%rsp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0x10(%rsp),%r13d
mov    %r13d,%esi
call   1030 <min@plt>
mov    %eax,%ebp
mov    %r14d,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0x18(%rsp),%r14d
mov    %r14d,%esi
call   1030 <min@plt>
imul   %r12d,%eax
add    %ebp,%eax
imul   0x28(%rsp),%eax
add    0x70(%rsp),%eax
cltq
mov    0x38(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0x30(%rsp),%xmm0
addsd  0x80(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
movapd 0x90(%rsp),%xmm0
mulsd  0x50(%rsp),%xmm0
movapd %xmm0,0x90(%rsp)
mov    %ebx,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0xc(%rsp),%esi
call   1030 <min@plt>
mov    %eax,0x80(%rsp)
mov    0xcc(%rsp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    %r13d,%ebx
mov    %r13d,%esi
call   1030 <min@plt>
mov    %eax,%ebp
mov    0x48(%rsp),%r12d
mov    %r12d,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    %r14d,%esi
call   1030 <min@plt>
mov    0x20(%rsp),%r13
imul   %r13d,%eax
add    %ebp,%eax
mov    0x28(%rsp),%rbp
imul   %ebp,%eax
add    0x80(%rsp),%eax
cltq
mov    0x38(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0x90(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x90(%rsp)
movapd 0xa0(%rsp),%xmm0
mulsd  0x50(%rsp),%xmm0
movapd %xmm0,0xa0(%rsp)
mov    0x5c(%rsp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0xc(%rsp),%esi
call   1030 <min@plt>
mov    %eax,0x50(%rsp)
mov    0xd0(%rsp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    %ebx,%esi
call   1030 <min@plt>
mov    %eax,%ebx
mov    %r12d,%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    %r14d,%r12d
mov    %r14d,%esi
call   1030 <min@plt>
imul   %r13d,%eax
add    %ebx,%eax
imul   %ebp,%eax
add    0x50(%rsp),%eax
cltq
mov    0x38(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0xa0(%rsp),%xmm0
addsd  0x90(%rsp),%xmm0
movsd  %xmm0,0xa0(%rsp)
movaps 0x60(%rsp),%xmm0
mulss  0x1c(%rsp),%xmm0
movaps %xmm0,0x60(%rsp)
mov    0xf0(%rsp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0xc(%rsp),%esi
call   1030 <min@plt>
mov    %eax,%r14d
mov    0xd0(%rsp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    0x10(%rsp),%esi
mov    0x110(%rsp),%rbx
call   1030 <min@plt>
mov    %eax,%ebp
mov    0x48(%rsp),%edi
xor    %esi,%esi
call   1040 <max@plt>
mov    %eax,%edi
mov    %r12d,%esi
call   1030 <min@plt>
imul   %r13d,%eax
add    %ebp,%eax
imul   0x28(%rsp),%eax
add    %r14d,%eax
cltq
movaps 0x60(%rsp),%xmm0
mov    0x38(%rsp),%rcx
mulss  (%rcx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0xa0(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
jmp    1290 <warpAffine+0x160>
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @warpAffine(float* %0, float* %1, float* %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca float
%26 = alloca float
%27 = alloca float
store float* %0, float** %7
store float* %1, float** %8
store float* %2, float** %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%28 = load i32, i32* %10
store i32 %28, i32* %13
%29 = load i32, i32* %11
store i32 %29, i32* %14
%30 = load i32, i32* %12
store i32 %30, i32* %15
store i32 0, i32* %16
br label %31
31: ; preds = %517, %6
%32 = load i32, i32* %16
%33 = load i32, i32* %12
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %520
35: ; preds = %31
store i32 0, i32* %17
br label %36
36: ; preds = %513, %35
%37 = load i32, i32* %17
%38 = load i32, i32* %11
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %516
40: ; preds = %36
store i32 0, i32* %18
br label %41
41: ; preds = %509, %40
%42 = load i32, i32* %18
%43 = load i32, i32* %10
%44 = icmp slt i32 %42, %43
br i1 %44, label %45, label %512
45: ; preds = %41
%46 = load i32, i32* %18
%47 = sitofp i32 %46 to float
%48 = load float*, float** %9
%49 = getelementptr inbounds float, float* %48, i64 0
%50 = load float, float* %49
%51 = load i32, i32* %17
%52 = sitofp i32 %51 to float
%53 = load float*, float** %9
%54 = getelementptr inbounds float, float* %53, i64 1
%55 = load float, float* %54
%56 = fmul float %52, %55
%57 = call float @llvm.fmuladd.f32(float %47, float %50, float %56)
%58 = load i32, i32* %16
%59 = sitofp i32 %58 to float
%60 = load float*, float** %9
%61 = getelementptr inbounds float, float* %60, i64 2
%62 = load float, float* %61
%63 = call float @llvm.fmuladd.f32(float %59, float %62, float %57)
%64 = load float*, float** %9
%65 = getelementptr inbounds float, float* %64, i64 3
%66 = load float, float* %65
%67 = fadd float %63, %66
store float %67, float* %19
%68 = load i32, i32* %18
%69 = sitofp i32 %68 to float
%70 = load float*, float** %9
%71 = getelementptr inbounds float, float* %70, i64 4
%72 = load float, float* %71
%73 = load i32, i32* %17
%74 = sitofp i32 %73 to float
%75 = load float*, float** %9
%76 = getelementptr inbounds float, float* %75, i64 5
%77 = load float, float* %76
%78 = fmul float %74, %77
%79 = call float @llvm.fmuladd.f32(float %69, float %72, float %78)
%80 = load i32, i32* %16
%81 = sitofp i32 %80 to float
%82 = load float*, float** %9
%83 = getelementptr inbounds float, float* %82, i64 6
%84 = load float, float* %83
%85 = call float @llvm.fmuladd.f32(float %81, float %84, float %79)
%86 = load float*, float** %9
%87 = getelementptr inbounds float, float* %86, i64 7
%88 = load float, float* %87
%89 = fadd float %85, %88
store float %89, float* %20
%90 = load i32, i32* %18
%91 = sitofp i32 %90 to float
%92 = load float*, float** %9
%93 = getelementptr inbounds float, float* %92, i64 8
%94 = load float, float* %93
%95 = load i32, i32* %17
%96 = sitofp i32 %95 to float
%97 = load float*, float** %9
%98 = getelementptr inbounds float, float* %97, i64 9
%99 = load float, float* %98
%100 = fmul float %96, %99
%101 = call float @llvm.fmuladd.f32(float %91, float %94, float %100)
%102 = load i32, i32* %16
%103 = sitofp i32 %102 to float
%104 = load float*, float** %9
%105 = getelementptr inbounds float, float* %104, i64 10
%106 = load float, float* %105
%107 = call float @llvm.fmuladd.f32(float %103, float %106, float %101)
%108 = load float*, float** %9
%109 = getelementptr inbounds float, float* %108, i64 11
%110 = load float, float* %109
%111 = fadd float %107, %110
store float %111, float* %21
%112 = load float, float* %20
%113 = call i32 @floor(float %112)
store i32 %113, i32* %22
%114 = load float, float* %19
%115 = call i32 @floor(float %114)
store i32 %115, i32* %23
%116 = load float, float* %21
%117 = call i32 @floor(float %116)
store i32 %117, i32* %24
%118 = load float, float* %20
%119 = load i32, i32* %22
%120 = sitofp i32 %119 to float
%121 = fsub float %118, %120
store float %121, float* %25
%122 = load float, float* %19
%123 = load i32, i32* %23
%124 = sitofp i32 %123 to float
%125 = fsub float %122, %124
store float %125, float* %26
%126 = load float, float* %21
%127 = load i32, i32* %24
%128 = sitofp i32 %127 to float
%129 = fsub float %126, %128
store float %129, float* %27
%130 = load i32, i32* %23
%131 = icmp slt i32 %130, 0
%132 = zext i1 %131 to i32
%133 = load i32, i32* %23
%134 = load i32, i32* %13
%135 = sub nsw i32 %134, 1
%136 = icmp sge i32 %133, %135
%137 = zext i1 %136 to i32
%138 = or i32 %132, %137
%139 = load i32, i32* %22
%140 = icmp slt i32 %139, 0
%141 = zext i1 %140 to i32
%142 = or i32 %138, %141
%143 = load i32, i32* %22
%144 = load i32, i32* %14
%145 = sub nsw i32 %144, 1
%146 = icmp sge i32 %143, %145
%147 = zext i1 %146 to i32
%148 = or i32 %142, %147
%149 = load i32, i32* %24
%150 = icmp slt i32 %149, 0
%151 = zext i1 %150 to i32
%152 = or i32 %148, %151
%153 = load i32, i32* %24
%154 = load i32, i32* %15
%155 = sub nsw i32 %154, 1
%156 = icmp sge i32 %153, %155
%157 = zext i1 %156 to i32
%158 = or i32 %152, %157
%159 = icmp ne i32 %158, 0
br i1 %159, label %160, label %175
160: ; preds = %45
%161 = load float*, float** %7
%162 = load i32, i32* %18
%163 = load i32, i32* %17
%164 = load i32, i32* %10
%165 = mul nsw i32 %163, %164
%166 = add nsw i32 %162, %165
%167 = load i32, i32* %16
%168 = load i32, i32* %10
%169 = mul nsw i32 %167, %168
%170 = load i32, i32* %11
%171 = mul nsw i32 %169, %170
%172 = add nsw i32 %166, %171
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds float, float* %161, i64 %173
store float 0.000000e+00, float* %174
br label %508
175: ; preds = %45
%176 = load float, float* %25
%177 = fpext float %176 to double
%178 = fsub double 1.000000e+00, %177
%179 = load float, float* %26
%180 = fpext float %179 to double
%181 = fsub double 1.000000e+00, %180
%182 = fmul double %178, %181
%183 = load float, float* %27
%184 = fpext float %183 to double
%185 = fsub double 1.000000e+00, %184
%186 = fmul double %182, %185
%187 = load float*, float** %8
%188 = load i32, i32* %23
%189 = call i32 @max(i32 %188, i32 0)
%190 = load i32, i32* %13
%191 = sub nsw i32 %190, 1
%192 = call i32 @min(i32 %189, i32 %191)
%193 = load i32, i32* %22
%194 = call i32 @max(i32 %193, i32 0)
%195 = load i32, i32* %14
%196 = sub nsw i32 %195, 1
%197 = call i32 @min(i32 %194, i32 %196)
%198 = load i32, i32* %13
%199 = mul nsw i32 %197, %198
%200 = add nsw i32 %192, %199
%201 = load i32, i32* %24
%202 = call i32 @max(i32 %201, i32 0)
%203 = load i32, i32* %15
%204 = sub nsw i32 %203, 1
%205 = call i32 @min(i32 %202, i32 %204)
%206 = load i32, i32* %13
%207 = mul nsw i32 %205, %206
%208 = load i32, i32* %14
%209 = mul nsw i32 %207, %208
%210 = add nsw i32 %200, %209
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds float, float* %187, i64 %211
%213 = load float, float* %212
%214 = fpext float %213 to double
%215 = load float, float* %25
%216 = fpext float %215 to double
%217 = fsub double 1.000000e+00, %216
%218 = load float, float* %26
%219 = fpext float %218 to double
%220 = fmul double %217, %219
%221 = load float, float* %27
%222 = fpext float %221 to double
%223 = fsub double 1.000000e+00, %222
%224 = fmul double %220, %223
%225 = load float*, float** %8
%226 = load i32, i32* %23
%227 = add nsw i32 %226, 1
%228 = call i32 @max(i32 %227, i32 0)
%229 = load i32, i32* %13
%230 = sub nsw i32 %229, 1
%231 = call i32 @min(i32 %228, i32 %230)
%232 = load i32, i32* %22
%233 = call i32 @max(i32 %232, i32 0)
%234 = load i32, i32* %14
%235 = sub nsw i32 %234, 1
%236 = call i32 @min(i32 %233, i32 %235)
%237 = load i32, i32* %13
%238 = mul nsw i32 %236, %237
%239 = add nsw i32 %231, %238
%240 = load i32, i32* %24
%241 = call i32 @max(i32 %240, i32 0)
%242 = load i32, i32* %15
%243 = sub nsw i32 %242, 1
%244 = call i32 @min(i32 %241, i32 %243)
%245 = load i32, i32* %13
%246 = mul nsw i32 %244, %245
%247 = load i32, i32* %14
%248 = mul nsw i32 %246, %247
%249 = add nsw i32 %239, %248
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds float, float* %225, i64 %250
%252 = load float, float* %251
%253 = fpext float %252 to double
%254 = fmul double %224, %253
%255 = call double @llvm.fmuladd.f64(double %186, double %214, double %254)
%256 = load float, float* %25
%257 = fpext float %256 to double
%258 = load float, float* %26
%259 = fpext float %258 to double
%260 = fsub double 1.000000e+00, %259
%261 = fmul double %257, %260
%262 = load float, float* %27
%263 = fpext float %262 to double
%264 = fsub double 1.000000e+00, %263
%265 = fmul double %261, %264
%266 = load float*, float** %8
%267 = load i32, i32* %23
%268 = call i32 @max(i32 %267, i32 0)
%269 = load i32, i32* %13
%270 = sub nsw i32 %269, 1
%271 = call i32 @min(i32 %268, i32 %270)
%272 = load i32, i32* %22
%273 = add nsw i32 %272, 1
%274 = call i32 @max(i32 %273, i32 0)
%275 = load i32, i32* %14
%276 = sub nsw i32 %275, 1
%277 = call i32 @min(i32 %274, i32 %276)
%278 = load i32, i32* %13
%279 = mul nsw i32 %277, %278
%280 = add nsw i32 %271, %279
%281 = load i32, i32* %24
%282 = call i32 @max(i32 %281, i32 0)
%283 = load i32, i32* %15
%284 = sub nsw i32 %283, 1
%285 = call i32 @min(i32 %282, i32 %284)
%286 = load i32, i32* %13
%287 = mul nsw i32 %285, %286
%288 = load i32, i32* %14
%289 = mul nsw i32 %287, %288
%290 = add nsw i32 %280, %289
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds float, float* %266, i64 %291
%293 = load float, float* %292
%294 = fpext float %293 to double
%295 = call double @llvm.fmuladd.f64(double %265, double %294, double %255)
%296 = load float, float* %25
%297 = fpext float %296 to double
%298 = fsub double 1.000000e+00, %297
%299 = load float, float* %26
%300 = fpext float %299 to double
%301 = fsub double 1.000000e+00, %300
%302 = fmul double %298, %301
%303 = load float, float* %27
%304 = fpext float %303 to double
%305 = fmul double %302, %304
%306 = load float*, float** %8
%307 = load i32, i32* %23
%308 = call i32 @max(i32 %307, i32 0)
%309 = load i32, i32* %13
%310 = sub nsw i32 %309, 1
%311 = call i32 @min(i32 %308, i32 %310)
%312 = load i32, i32* %22
%313 = call i32 @max(i32 %312, i32 0)
%314 = load i32, i32* %14
%315 = sub nsw i32 %314, 1
%316 = call i32 @min(i32 %313, i32 %315)
%317 = load i32, i32* %13
%318 = mul nsw i32 %316, %317
%319 = add nsw i32 %311, %318
%320 = load i32, i32* %24
%321 = add nsw i32 %320, 1
%322 = call i32 @max(i32 %321, i32 0)
%323 = load i32, i32* %15
%324 = sub nsw i32 %323, 1
%325 = call i32 @min(i32 %322, i32 %324)
%326 = load i32, i32* %13
%327 = mul nsw i32 %325, %326
%328 = load i32, i32* %14
%329 = mul nsw i32 %327, %328
%330 = add nsw i32 %319, %329
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds float, float* %306, i64 %331
%333 = load float, float* %332
%334 = fpext float %333 to double
%335 = call double @llvm.fmuladd.f64(double %305, double %334, double %295)
%336 = load float, float* %25
%337 = load float, float* %26
%338 = fmul float %336, %337
%339 = fpext float %338 to double
%340 = load float, float* %27
%341 = fpext float %340 to double
%342 = fsub double 1.000000e+00, %341
%343 = fmul double %339, %342
%344 = load float*, float** %8
%345 = load i32, i32* %23
%346 = add nsw i32 %345, 1
%347 = call i32 @max(i32 %346, i32 0)
%348 = load i32, i32* %13
%349 = sub nsw i32 %348, 1
%350 = call i32 @min(i32 %347, i32 %349)
%351 = load i32, i32* %22
%352 = add nsw i32 %351, 1
%353 = call i32 @max(i32 %352, i32 0)
%354 = load i32, i32* %14
%355 = sub nsw i32 %354, 1
%356 = call i32 @min(i32 %353, i32 %355)
%357 = load i32, i32* %13
%358 = mul nsw i32 %356, %357
%359 = add nsw i32 %350, %358
%360 = load i32, i32* %24
%361 = call i32 @max(i32 %360, i32 0)
%362 = load i32, i32* %15
%363 = sub nsw i32 %362, 1
%364 = call i32 @min(i32 %361, i32 %363)
%365 = load i32, i32* %13
%366 = mul nsw i32 %364, %365
%367 = load i32, i32* %14
%368 = mul nsw i32 %366, %367
%369 = add nsw i32 %359, %368
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds float, float* %344, i64 %370
%372 = load float, float* %371
%373 = fpext float %372 to double
%374 = call double @llvm.fmuladd.f64(double %343, double %373, double %335)
%375 = load float, float* %25
%376 = fpext float %375 to double
%377 = fsub double 1.000000e+00, %376
%378 = load float, float* %26
%379 = fpext float %378 to double
%380 = fmul double %377, %379
%381 = load float, float* %27
%382 = fpext float %381 to double
%383 = fmul double %380, %382
%384 = load float*, float** %8
%385 = load i32, i32* %23
%386 = add nsw i32 %385, 1
%387 = call i32 @max(i32 %386, i32 0)
%388 = load i32, i32* %13
%389 = sub nsw i32 %388, 1
%390 = call i32 @min(i32 %387, i32 %389)
%391 = load i32, i32* %22
%392 = call i32 @max(i32 %391, i32 0)
%393 = load i32, i32* %14
%394 = sub nsw i32 %393, 1
%395 = call i32 @min(i32 %392, i32 %394)
%396 = load i32, i32* %13
%397 = mul nsw i32 %395, %396
%398 = add nsw i32 %390, %397
%399 = load i32, i32* %24
%400 = add nsw i32 %399, 1
%401 = call i32 @max(i32 %400, i32 0)
%402 = load i32, i32* %15
%403 = sub nsw i32 %402, 1
%404 = call i32 @min(i32 %401, i32 %403)
%405 = load i32, i32* %13
%406 = mul nsw i32 %404, %405
%407 = load i32, i32* %14
%408 = mul nsw i32 %406, %407
%409 = add nsw i32 %398, %408
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds float, float* %384, i64 %410
%412 = load float, float* %411
%413 = fpext float %412 to double
%414 = call double @llvm.fmuladd.f64(double %383, double %413, double %374)
%415 = load float, float* %25
%416 = fpext float %415 to double
%417 = load float, float* %26
%418 = fpext float %417 to double
%419 = fsub double 1.000000e+00, %418
%420 = fmul double %416, %419
%421 = load float, float* %27
%422 = fpext float %421 to double
%423 = fmul double %420, %422
%424 = load float*, float** %8
%425 = load i32, i32* %23
%426 = call i32 @max(i32 %425, i32 0)
%427 = load i32, i32* %13
%428 = sub nsw i32 %427, 1
%429 = call i32 @min(i32 %426, i32 %428)
%430 = load i32, i32* %22
%431 = add nsw i32 %430, 1
%432 = call i32 @max(i32 %431, i32 0)
%433 = load i32, i32* %14
%434 = sub nsw i32 %433, 1
%435 = call i32 @min(i32 %432, i32 %434)
%436 = load i32, i32* %13
%437 = mul nsw i32 %435, %436
%438 = add nsw i32 %429, %437
%439 = load i32, i32* %24
%440 = add nsw i32 %439, 1
%441 = call i32 @max(i32 %440, i32 0)
%442 = load i32, i32* %15
%443 = sub nsw i32 %442, 1
%444 = call i32 @min(i32 %441, i32 %443)
%445 = load i32, i32* %13
%446 = mul nsw i32 %444, %445
%447 = load i32, i32* %14
%448 = mul nsw i32 %446, %447
%449 = add nsw i32 %438, %448
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds float, float* %424, i64 %450
%452 = load float, float* %451
%453 = fpext float %452 to double
%454 = call double @llvm.fmuladd.f64(double %423, double %453, double %414)
%455 = load float, float* %25
%456 = load float, float* %26
%457 = fmul float %455, %456
%458 = load float, float* %27
%459 = fmul float %457, %458
%460 = load float*, float** %8
%461 = load i32, i32* %23
%462 = add nsw i32 %461, 1
%463 = call i32 @max(i32 %462, i32 0)
%464 = load i32, i32* %13
%465 = sub nsw i32 %464, 1
%466 = call i32 @min(i32 %463, i32 %465)
%467 = load i32, i32* %22
%468 = add nsw i32 %467, 1
%469 = call i32 @max(i32 %468, i32 0)
%470 = load i32, i32* %14
%471 = sub nsw i32 %470, 1
%472 = call i32 @min(i32 %469, i32 %471)
%473 = load i32, i32* %13
%474 = mul nsw i32 %472, %473
%475 = add nsw i32 %466, %474
%476 = load i32, i32* %24
%477 = add nsw i32 %476, 1
%478 = call i32 @max(i32 %477, i32 0)
%479 = load i32, i32* %15
%480 = sub nsw i32 %479, 1
%481 = call i32 @min(i32 %478, i32 %480)
%482 = load i32, i32* %13
%483 = mul nsw i32 %481, %482
%484 = load i32, i32* %14
%485 = mul nsw i32 %483, %484
%486 = add nsw i32 %475, %485
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds float, float* %460, i64 %487
%489 = load float, float* %488
%490 = fmul float %459, %489
%491 = fpext float %490 to double
%492 = fadd double %454, %491
%493 = fptrunc double %492 to float
%494 = load float*, float** %7
%495 = load i32, i32* %18
%496 = load i32, i32* %17
%497 = load i32, i32* %10
%498 = mul nsw i32 %496, %497
%499 = add nsw i32 %495, %498
%500 = load i32, i32* %16
%501 = load i32, i32* %10
%502 = mul nsw i32 %500, %501
%503 = load i32, i32* %11
%504 = mul nsw i32 %502, %503
%505 = add nsw i32 %499, %504
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds float, float* %494, i64 %506
store float %493, float* %507
br label %508
508: ; preds = %175, %160
br label %509
509: ; preds = %508
%510 = load i32, i32* %18
%511 = add nsw i32 %510, 1
store i32 %511, i32* %18
br label %41
512: ; preds = %41
br label %513
513: ; preds = %512
%514 = load i32, i32* %17
%515 = add nsw i32 %514, 1
store i32 %515, i32* %17
br label %36
516: ; preds = %36
br label %517
517: ; preds = %516
%518 = load i32, i32* %16
%519 = add nsw i32 %518, 1
store i32 %519, i32* %16
br label %31
520: ; preds = %31
ret void
}

LLVM IR (-O2):
define void @warpAffine(float* nocapture writeonly %0, float* nocapture %1, float* nocapture %2, i32 %3, i32 %4, i32 %5) {
%7 = icmp sgt i32 %5, 0
br i1 %7, label %8, label %33
8: ; preds = %6
%9 = icmp sgt i32 %4, 0
%10 = icmp sgt i32 %3, 0
%11 = getelementptr inbounds float, float* %2, i64 1
%12 = getelementptr inbounds float, float* %2, i64 2
%13 = getelementptr inbounds float, float* %2, i64 3
%14 = getelementptr inbounds float, float* %2, i64 4
%15 = getelementptr inbounds float, float* %2, i64 5
%16 = getelementptr inbounds float, float* %2, i64 6
%17 = getelementptr inbounds float, float* %2, i64 7
%18 = getelementptr inbounds float, float* %2, i64 8
%19 = getelementptr inbounds float, float* %2, i64 9
%20 = getelementptr inbounds float, float* %2, i64 10
%21 = getelementptr inbounds float, float* %2, i64 11
%22 = add nsw i32 %3, -1
%23 = add nsw i32 %4, -1
%24 = add nsw i32 %5, -1
%25 = zext i32 %3 to i64
br label %26
26: ; preds = %8, %42
%27 = phi i32 [ 0, %8 ], [ %43, %42 ]
br i1 %9, label %28, label %42
28: ; preds = %26
%29 = sitofp i32 %27 to float
%30 = mul i32 %27, %4
%31 = insertelement <2 x float> poison, float %29, i64 0
%32 = shufflevector <2 x float> %31, <2 x float> poison, <2 x i32> zeroinitializer
br label %34
33: ; preds = %42, %6
ret void
34: ; preds = %28, %45
%35 = phi i32 [ 0, %28 ], [ %46, %45 ]
br i1 %10, label %36, label %45
36: ; preds = %34
%37 = sitofp i32 %35 to float
%38 = add i32 %35, %30
%39 = mul i32 %38, %3
%40 = insertelement <2 x float> poison, float %37, i64 0
%41 = shufflevector <2 x float> %40, <2 x float> poison, <2 x i32> zeroinitializer
br label %48
42: ; preds = %45, %26
%43 = add nuw nsw i32 %27, 1
%44 = icmp eq i32 %43, %5
br i1 %44, label %33, label %26
45: ; preds = %257, %34
%46 = add nuw nsw i32 %35, 1
%47 = icmp eq i32 %46, %4
br i1 %47, label %42, label %34
48: ; preds = %36, %257
%49 = phi i64 [ 0, %36 ], [ %262, %257 ]
%50 = trunc i64 %49 to i32
%51 = sitofp i32 %50 to float
%52 = load float, float* %2
%53 = load float, float* %11
%54 = load float, float* %12
%55 = load float, float* %13
%56 = load float, float* %14
%57 = load float, float* %15
%58 = insertelement <2 x float> poison, float %57, i64 0
%59 = insertelement <2 x float> %58, float %53, i64 1
%60 = fmul <2 x float> %59, %41
%61 = insertelement <2 x float> poison, float %51, i64 0
%62 = shufflevector <2 x float> %61, <2 x float> poison, <2 x i32> zeroinitializer
%63 = insertelement <2 x float> poison, float %56, i64 0
%64 = insertelement <2 x float> %63, float %52, i64 1
%65 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %62, <2 x float> %64, <2 x float> %60)
%66 = load float, float* %16
%67 = insertelement <2 x float> poison, float %66, i64 0
%68 = insertelement <2 x float> %67, float %54, i64 1
%69 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %32, <2 x float> %68, <2 x float> %65)
%70 = load float, float* %17
%71 = insertelement <2 x float> poison, float %70, i64 0
%72 = insertelement <2 x float> %71, float %55, i64 1
%73 = fadd <2 x float> %72, %69
%74 = load float, float* %18
%75 = load float, float* %19
%76 = fmul float %75, %37
%77 = tail call float @llvm.fmuladd.f32(float %51, float %74, float %76)
%78 = load float, float* %20
%79 = tail call float @llvm.fmuladd.f32(float %29, float %78, float %77)
%80 = load float, float* %21
%81 = fadd float %80, %79
%82 = extractelement <2 x float> %73, i64 0
%83 = tail call i32 @floor(float %82)
%84 = extractelement <2 x float> %73, i64 1
%85 = tail call i32 @floor(float %84)
%86 = tail call i32 @floor(float %81)
%87 = insertelement <2 x i32> poison, i32 %83, i64 0
%88 = insertelement <2 x i32> %87, i32 %85, i64 1
%89 = sitofp <2 x i32> %88 to <2 x float>
%90 = fsub <2 x float> %73, %89
%91 = sitofp i32 %86 to float
%92 = fsub float %81, %91
%93 = icmp sge i32 %85, %22
%94 = zext i1 %93 to i32
%95 = icmp sge i32 %83, %23
%96 = zext i1 %95 to i32
%97 = lshr i32 %86, 31
%98 = icmp sge i32 %86, %24
%99 = zext i1 %98 to i32
%100 = or i32 %85, %83
%101 = lshr i32 %100, 31
%102 = or i32 %101, %96
%103 = or i32 %102, %94
%104 = or i32 %103, %97
%105 = or i32 %104, %99
%106 = icmp eq i32 %105, 0
br i1 %106, label %107, label %257
107: ; preds = %48
%108 = fpext <2 x float> %90 to <2 x double>
%109 = fsub <2 x double> <double 1.000000e+00, double 1.000000e+00>, %108
%110 = extractelement <2 x double> %109, i64 0
%111 = extractelement <2 x double> %109, i64 1
%112 = fmul double %110, %111
%113 = fpext float %92 to double
%114 = fsub double 1.000000e+00, %113
%115 = fmul double %112, %114
%116 = tail call i32 @max(i32 %85, i32 0)
%117 = tail call i32 @min(i32 %116, i32 %22)
%118 = tail call i32 @max(i32 %83, i32 0)
%119 = tail call i32 @min(i32 %118, i32 %23)
%120 = tail call i32 @max(i32 %86, i32 0)
%121 = tail call i32 @min(i32 %120, i32 %24)
%122 = mul i32 %121, %4
%123 = add i32 %122, %119
%124 = mul i32 %123, %3
%125 = add i32 %124, %117
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds float, float* %1, i64 %126
%128 = load float, float* %127
%129 = fpext float %128 to double
%130 = shufflevector <2 x double> %108, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%131 = fmul <2 x double> %109, %130
%132 = extractelement <2 x double> %131, i64 0
%133 = fmul double %132, %114
%134 = add nsw i32 %85, 1
%135 = tail call i32 @max(i32 %134, i32 0)
%136 = tail call i32 @min(i32 %135, i32 %22)
%137 = tail call i32 @max(i32 %83, i32 0)
%138 = tail call i32 @min(i32 %137, i32 %23)
%139 = tail call i32 @max(i32 %86, i32 0)
%140 = tail call i32 @min(i32 %139, i32 %24)
%141 = mul i32 %140, %4
%142 = add i32 %141, %138
%143 = mul i32 %142, %3
%144 = add i32 %143, %136
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds float, float* %1, i64 %145
%147 = load float, float* %146
%148 = fpext float %147 to double
%149 = fmul double %133, %148
%150 = tail call double @llvm.fmuladd.f64(double %115, double %129, double %149)
%151 = extractelement <2 x double> %108, i64 0
%152 = fmul double %111, %151
%153 = fmul double %152, %114
%154 = tail call i32 @max(i32 %85, i32 0)
%155 = tail call i32 @min(i32 %154, i32 %22)
%156 = add nsw i32 %83, 1
%157 = tail call i32 @max(i32 %156, i32 0)
%158 = tail call i32 @min(i32 %157, i32 %23)
%159 = tail call i32 @max(i32 %86, i32 0)
%160 = tail call i32 @min(i32 %159, i32 %24)
%161 = mul i32 %160, %4
%162 = add i32 %161, %158
%163 = mul i32 %162, %3
%164 = add i32 %163, %155
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %1, i64 %165
%167 = load float, float* %166
%168 = fpext float %167 to double
%169 = tail call double @llvm.fmuladd.f64(double %153, double %168, double %150)
%170 = fmul double %112, %113
%171 = tail call i32 @max(i32 %85, i32 0)
%172 = tail call i32 @min(i32 %171, i32 %22)
%173 = tail call i32 @max(i32 %83, i32 0)
%174 = tail call i32 @min(i32 %173, i32 %23)
%175 = add nsw i32 %86, 1
%176 = tail call i32 @max(i32 %175, i32 0)
%177 = tail call i32 @min(i32 %176, i32 %24)
%178 = mul i32 %177, %4
%179 = add i32 %178, %174
%180 = mul i32 %179, %3
%181 = add i32 %180, %172
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %1, i64 %182
%184 = load float, float* %183
%185 = fpext float %184 to double
%186 = tail call double @llvm.fmuladd.f64(double %170, double %185, double %169)
%187 = shufflevector <2 x float> %90, <2 x float> poison, <2 x i32> <i32 1, i32 undef>
%188 = fmul <2 x float> %90, %187
%189 = extractelement <2 x float> %188, i64 0
%190 = fpext float %189 to double
%191 = fmul double %114, %190
%192 = tail call i32 @max(i32 %134, i32 0)
%193 = tail call i32 @min(i32 %192, i32 %22)
%194 = tail call i32 @max(i32 %156, i32 0)
%195 = tail call i32 @min(i32 %194, i32 %23)
%196 = tail call i32 @max(i32 %86, i32 0)
%197 = tail call i32 @min(i32 %196, i32 %24)
%198 = mul i32 %197, %4
%199 = add i32 %198, %195
%200 = mul i32 %199, %3
%201 = add i32 %200, %193
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float, float* %1, i64 %202
%204 = load float, float* %203
%205 = fpext float %204 to double
%206 = tail call double @llvm.fmuladd.f64(double %191, double %205, double %186)
%207 = fmul double %132, %113
%208 = tail call i32 @max(i32 %134, i32 0)
%209 = tail call i32 @min(i32 %208, i32 %22)
%210 = tail call i32 @max(i32 %83, i32 0)
%211 = tail call i32 @min(i32 %210, i32 %23)
%212 = tail call i32 @max(i32 %175, i32 0)
%213 = tail call i32 @min(i32 %212, i32 %24)
%214 = mul i32 %213, %4
%215 = add i32 %214, %211
%216 = mul i32 %215, %3
%217 = add i32 %216, %209
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds float, float* %1, i64 %218
%220 = load float, float* %219
%221 = fpext float %220 to double
%222 = tail call double @llvm.fmuladd.f64(double %207, double %221, double %206)
%223 = fmul double %152, %113
%224 = tail call i32 @max(i32 %85, i32 0)
%225 = tail call i32 @min(i32 %224, i32 %22)
%226 = tail call i32 @max(i32 %156, i32 0)
%227 = tail call i32 @min(i32 %226, i32 %23)
%228 = tail call i32 @max(i32 %175, i32 0)
%229 = tail call i32 @min(i32 %228, i32 %24)
%230 = mul i32 %229, %4
%231 = add i32 %230, %227
%232 = mul i32 %231, %3
%233 = add i32 %232, %225
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds float, float* %1, i64 %234
%236 = load float, float* %235
%237 = fpext float %236 to double
%238 = tail call double @llvm.fmuladd.f64(double %223, double %237, double %222)
%239 = fmul float %189, %92
%240 = tail call i32 @max(i32 %134, i32 0)
%241 = tail call i32 @min(i32 %240, i32 %22)
%242 = tail call i32 @max(i32 %156, i32 0)
%243 = tail call i32 @min(i32 %242, i32 %23)
%244 = tail call i32 @max(i32 %175, i32 0)
%245 = tail call i32 @min(i32 %244, i32 %24)
%246 = mul i32 %245, %4
%247 = add i32 %246, %243
%248 = mul i32 %247, %3
%249 = add i32 %248, %241
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds float, float* %1, i64 %250
%252 = load float, float* %251
%253 = fmul float %239, %252
%254 = fpext float %253 to double
%255 = fadd double %238, %254
%256 = fptrunc double %255 to float
br label %257
257: ; preds = %48, %107
%258 = phi float [ %256, %107 ], [ 0.000000e+00, %48 ]
%259 = add i32 %39, %50
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds float, float* %0, i64 %260
store float %258, float* %261
%262 = add nuw nsw i64 %49, 1
%263 = icmp eq i64 %262, %25
br i1 %263, label %45, label %48
}