#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 */
scalar_t__ Get2DMem(long, long, int, int);
float **MirrorPad(float **array1, long nrow, long ncol, long krow, long kcol) {
  long row, col;
  float **array2;
  array2 = (float **)Get2DMem(nrow + 2 * krow, ncol + 2 * kcol, sizeof(float *),
                              sizeof(float));
  for (row = 0; row < nrow; row++) {
    for (col = 0; col < ncol; col++) {
      array2[row + krow][col + kcol] = array1[row][col];
    }
  }
  if (krow > nrow || kcol > ncol) {
    return (array1);
  }
  for (row = 0; row < krow; row++) {
    for (col = 0; col < kcol; col++) {
      array2[row][col] = array2[2 * krow - row][2 * kcol - col];
      array2[row][ncol + kcol + col] =
          array2[2 * krow - row][ncol + kcol - 2 - col];
      array2[nrow + krow + row][col] =
          array2[nrow + krow - 2 - row][2 * kcol - col];
      array2[nrow + krow + row][ncol + kcol + col] =
          array2[nrow + krow - 2 - row][ncol + kcol - 2 - col];
    }
  }
  for (row = krow; row < nrow + krow; row++) {
    for (col = 0; col < kcol; col++) {
      array2[row][col] = array2[row][2 * kcol - col];
      array2[row][ncol + kcol + col] = array2[row][ncol + kcol - 2 - col];
    }
  }
  for (col = kcol; col < ncol + kcol; col++) {
    for (row = 0; row < krow; row++) {
      array2[row][col] = array2[2 * krow - row][col];
      array2[nrow + krow + row][col] = array2[nrow + krow - 2 - row][col];
    }
  }
  return (array2);
}


x86 assembly (clang, -O0):
<MirrorPad>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x28(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    $0x8,%edx
mov    $0x4,%ecx
call   1030 <Get2DMem@plt>
mov    %rax,-0x48(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    11e2 <MirrorPad+0xd2>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    11cc <MirrorPad+0xbc>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
add    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
add    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    117b <MirrorPad+0x6b>
jmp    11d1 <MirrorPad+0xc1>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1165 <MirrorPad+0x55>
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jg     11fe <MirrorPad+0xee>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jle    120b <MirrorPad+0xfb>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1512 <MirrorPad+0x402>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1376 <MirrorPad+0x266>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    1360 <MirrorPad+0x250>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x1,%rcx
sub    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
shl    $0x1,%rcx
sub    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x1,%rcx
sub    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
add    -0x30(%rbp),%rcx
sub    $0x2,%rcx
sub    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
add    -0x30(%rbp),%rcx
add    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    -0x28(%rbp),%rcx
sub    $0x2,%rcx
sub    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
shl    $0x1,%rcx
sub    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    -0x28(%rbp),%rcx
add    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    -0x28(%rbp),%rcx
sub    $0x2,%rcx
sub    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
add    -0x30(%rbp),%rcx
sub    $0x2,%rcx
sub    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    -0x28(%rbp),%rcx
add    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
add    -0x30(%rbp),%rcx
add    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1229 <MirrorPad+0x119>
jmp    1365 <MirrorPad+0x255>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1213 <MirrorPad+0x103>
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    -0x28(%rbp),%rcx
cmp    %rcx,%rax
jge    1440 <MirrorPad+0x330>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    142a <MirrorPad+0x31a>
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%rcx
shl    $0x1,%rcx
sub    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
add    -0x30(%rbp),%rcx
sub    $0x2,%rcx
sub    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
add    -0x30(%rbp),%rcx
add    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    139b <MirrorPad+0x28b>
jmp    142f <MirrorPad+0x31f>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    137e <MirrorPad+0x26e>
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%rcx
add    -0x30(%rbp),%rcx
cmp    %rcx,%rax
jge    150a <MirrorPad+0x3fa>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    14f4 <MirrorPad+0x3e4>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x1,%rcx
sub    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    -0x28(%rbp),%rcx
sub    $0x2,%rcx
sub    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x18(%rbp),%rcx
add    -0x28(%rbp),%rcx
add    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1465 <MirrorPad+0x355>
jmp    14f9 <MirrorPad+0x3e9>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1448 <MirrorPad+0x338>
mov    -0x48(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MirrorPad>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r8,%r12
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%r13
mov    %rcx,0x30(%rsp)
lea    (%rsi,%rcx,2),%rdi
lea    (%rdx,%r8,2),%rsi
mov    $0x8,%edx
mov    $0x4,%ecx
call   1030 <Get2DMem@plt>
mov    %rax,0x10(%rsp)
test   %r14,%r14
jle    135c <MirrorPad+0x24c>
lea    (%r12,%r15,1),%rax
mov    %rax,0x8(%rsp)
lea    -0x8(%r15),%rax
mov    %rax,0x38(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %r15,%r11
and    $0xfffffffffffffff8,%r11
mov    %eax,%edx
and    $0x3,%edx
and    $0xfffffffffffffffc,%rax
mov    %rax,0x48(%rsp)
mov    %r15d,%ecx
and    $0x3,%ecx
lea    0x1c(%r12),%rax
mov    %rax,0x40(%rsp)
mov    %rdx,0x28(%rsp)
shl    $0x5,%rdx
lea    0x3(%r12),%rsi
xor    %r10d,%r10d
jmp    11bd <MirrorPad+0xad>
nopl   0x0(%rax)
add    $0x1,%r10
cmp    %r14,%r10
je     135c <MirrorPad+0x24c>
test   %r15,%r15
jle    11b0 <MirrorPad+0xa0>
mov    0x30(%rsp),%rax
add    %r10,%rax
mov    0x0(%r13,%r10,8),%r8
mov    0x10(%rsp),%rdi
mov    (%rdi,%rax,8),%r9
cmp    $0x8,%r15
jb     1201 <MirrorPad+0xf1>
lea    (%r9,%r12,4),%rax
lea    (%r8,%r15,4),%rdi
cmp    %rdi,%rax
jae    1291 <MirrorPad+0x181>
mov    0x8(%rsp),%rax
lea    (%r9,%rax,4),%rax
cmp    %rax,%r8
jae    1291 <MirrorPad+0x181>
xor    %edi,%edi
mov    %rdi,%rbx
not    %rbx
add    %r15,%rbx
test   %rcx,%rcx
je     1236 <MirrorPad+0x126>
lea    (%r9,%r12,4),%rbp
mov    %rcx,%rax
nopl   0x0(%rax,%rax,1)
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,0x0(%rbp,%rdi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rax
jne    1220 <MirrorPad+0x110>
cmp    $0x3,%rbx
jb     11b0 <MirrorPad+0xa0>
lea    (%r9,%rsi,4),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r8,%rdi,4),%xmm0
movss  %xmm0,-0xc(%rbp,%rdi,4)
movss  0x4(%r8,%rdi,4),%xmm0
movss  %xmm0,-0x8(%rbp,%rdi,4)
movss  0x8(%r8,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rbp,%rdi,4)
movss  0xc(%r8,%rdi,4),%xmm0
movss  %xmm0,0x0(%rbp,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%r15
jne    1250 <MirrorPad+0x140>
jmp    11b0 <MirrorPad+0xa0>
cmpq   $0x18,0x38(%rsp)
jae    129d <MirrorPad+0x18d>
xor    %edi,%edi
jmp    1310 <MirrorPad+0x200>
mov    0x40(%rsp),%rax
lea    (%r9,%rax,4),%rbx
mov    0x48(%rsp),%rbp
xor    %edi,%edi
nopl   (%rax)
movups (%r8,%rdi,4),%xmm0
movups 0x10(%r8,%rdi,4),%xmm1
movups %xmm0,-0x70(%rbx,%rdi,4)
movups %xmm1,-0x60(%rbx,%rdi,4)
movups 0x20(%r8,%rdi,4),%xmm0
movups 0x30(%r8,%rdi,4),%xmm1
movups %xmm0,-0x50(%rbx,%rdi,4)
movups %xmm1,-0x40(%rbx,%rdi,4)
movups 0x40(%r8,%rdi,4),%xmm0
movups 0x50(%r8,%rdi,4),%xmm1
movups %xmm0,-0x30(%rbx,%rdi,4)
movups %xmm1,-0x20(%rbx,%rdi,4)
movups 0x60(%r8,%rdi,4),%xmm0
movups 0x70(%r8,%rdi,4),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,4)
movups %xmm1,(%rbx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rbp
jne    12b0 <MirrorPad+0x1a0>
cmpq   $0x0,0x28(%rsp)
je     134b <MirrorPad+0x23b>
lea    (%r12,%rdi,1),%rax
lea    (%r9,%rax,4),%rbx
add    $0x10,%rbx
lea    (%r8,%rdi,4),%rax
add    $0x10,%rax
xor    %edi,%edi
xchg   %ax,%ax
movups -0x10(%rax,%rdi,1),%xmm0
movups (%rax,%rdi,1),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,1)
movups %xmm1,(%rbx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1330 <MirrorPad+0x220>
mov    %r11,%rdi
cmp    %r15,%r11
je     11b0 <MirrorPad+0xa0>
jmp    1203 <MirrorPad+0xf3>
mov    0x30(%rsp),%rbx
cmp    %r14,%rbx
jg     188f <MirrorPad+0x77f>
cmp    %r15,%r12
jg     188f <MirrorPad+0x77f>
lea    (%rbx,%rbx,1),%rax
mov    %rax,0x38(%rsp)
lea    (%r12,%r12,1),%rax
mov    %rax,0x8(%rsp)
test   %rbx,%rbx
jle    1468 <MirrorPad+0x358>
lea    (%r12,%r15,1),%rax
lea    (%r12,%r15,1),%r8
add    $0xfffffffffffffffe,%r8
lea    (%rbx,%r14,1),%r9
lea    (%rbx,%r14,1),%rcx
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x28(%rsp)
mov    %r12,%r13
neg    %r13
xor    %r11d,%r11d
jmp    13cf <MirrorPad+0x2bf>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r11
cmp    0x30(%rsp),%r11
je     1461 <MirrorPad+0x351>
test   %r12,%r12
jle    13c0 <MirrorPad+0x2b0>
mov    0x38(%rsp),%rcx
sub    %r11,%rcx
mov    0x10(%rsp),%rsi
mov    (%rsi,%rcx,8),%r10
mov    (%rsi,%r11,8),%rcx
mov    0x28(%rsp),%rdx
sub    %r11,%rdx
mov    (%rsi,%rdx,8),%rbp
lea    (%r11,%r9,1),%rdx
mov    (%rsi,%rdx,8),%rdx
lea    0x0(,%r8,4),%rsi
add    %rbp,%rsi
lea    (%r10,%r8,4),%rdi
mov    0x8(%rsp),%rbx
lea    0x0(%rbp,%rbx,4),%rbp
lea    (%r10,%rbx,4),%rbx
xor    %r10d,%r10d
nopl   (%rax)
movss  (%rbx,%r10,4),%xmm0
movss  %xmm0,(%rcx)
movss  (%rdi,%r10,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
movss  0x0(%rbp,%r10,4),%xmm0
movss  %xmm0,(%rdx)
movss  (%rsi,%r10,4),%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0xffffffffffffffff,%r10
add    $0x4,%rdx
add    $0x4,%rcx
cmp    %r10,%r13
jne    1420 <MirrorPad+0x310>
jmp    13c0 <MirrorPad+0x2b0>
mov    0x30(%rsp),%rbx
jmp    146c <MirrorPad+0x35c>
lea    (%rbx,%r14,1),%r9
lea    (%r12,%r15,1),%r10
test   %r14,%r14
jle    17fc <MirrorPad+0x6ec>
lea    (%r12,%r15,1),%rsi
add    $0xfffffffffffffffe,%rsi
lea    -0x1(%r12),%rax
mov    0x8(%rsp),%rcx
lea    (%rcx,%r15,1),%rdx
mov    %rdx,0x90(%rsp)
lea    0x1(%r12),%rdx
mov    %rdx,0x88(%rsp)
or     $0x1,%rcx
mov    %rcx,0x80(%rsp)
lea    -0x1(%r15),%rcx
mov    %rcx,0x78(%rsp)
lea    -0x4(%r12),%rcx
mov    %rcx,0x68(%rsp)
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    $0x4,%ecx
mul    %rcx
mov    %rax,%rbp
lea    -0x1(%r12,%r15,1),%rax
mov    %rax,0x70(%rsp)
seto   0x48(%rsp)
neg    %rbp
mov    %r12,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x58(%rsp)
mov    %rdi,%rax
mov    %rdi,0x60(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x50(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0x28(%rsp)
lea    0x0(,%r12,8),%r13
lea    (%r12,%r15,1),%rax
add    $0x1,%rax
mov    %rax,0x40(%rsp)
mov    %rbx,%r14
mov    %rsi,0x20(%rsp)
mov    %rbp,0x18(%rsp)
jmp    154d <MirrorPad+0x43d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    %r9,%r14
jge    17f7 <MirrorPad+0x6e7>
test   %r12,%r12
jle    1540 <MirrorPad+0x430>
mov    0x10(%rsp),%rax
mov    (%rax,%r14,8),%r11
cmp    $0x4,%r12
jb     1680 <MirrorPad+0x570>
mov    0x8(%rsp),%rax
lea    (%r11,%rax,4),%rax
lea    (%rax,%rbp,1),%rcx
cmp    %rax,%rcx
seta   %cl
mov    0x48(%rsp),%bl
or     %bl,%cl
lea    (%r11,%rsi,4),%rax
lea    (%rax,%rbp,1),%rdx
cmp    %rax,%rdx
seta   %al
test   %cl,%cl
jne    1680 <MirrorPad+0x570>
or     %bl,%al
mov    $0x0,%r8d
jne    1683 <MirrorPad+0x573>
lea    (%r11,%r12,4),%rax
lea    (%r11,%r10,4),%rsi
mov    0x90(%rsp),%rcx
lea    (%r11,%rcx,4),%rdi
mov    0x88(%rsp),%rcx
lea    (%r11,%rcx,4),%rbp
mov    0x80(%rsp),%rcx
lea    (%r11,%rcx,4),%rcx
mov    0x78(%rsp),%rdx
lea    (%r11,%rdx,4),%r8
mov    0x70(%rsp),%rdx
lea    (%r11,%rdx,4),%rbx
cmp    %rdi,%r11
setb   0x7(%rsp)
cmp    %rax,%rsi
setb   0x6(%rsp)
cmp    %rcx,%r11
setb   %dl
cmp    %rax,%rbp
setb   0x5(%rsp)
cmp    %rbx,%r11
setb   0x4(%rsp)
cmp    %rax,%r8
setb   %al
cmp    %rcx,%rsi
setb   %cl
cmp    %rdi,%rbp
setb   %bpl
cmp    %rbx,%rsi
setb   %sil
cmp    %rdi,%r8
setb   %dil
mov    0x6(%rsp),%bl
test   %bl,0x7(%rsp)
jne    173e <MirrorPad+0x62e>
and    0x5(%rsp),%dl
jne    173e <MirrorPad+0x62e>
and    %al,0x4(%rsp)
jne    173e <MirrorPad+0x62e>
and    %bpl,%cl
jne    173e <MirrorPad+0x62e>
mov    $0x0,%r8d
and    %dil,%sil
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%rbp
jne    1683 <MirrorPad+0x573>
cmpq   $0x4,0x68(%rsp)
jae    1750 <MirrorPad+0x640>
xor    %ebx,%ebx
jmp    17ab <MirrorPad+0x69b>
nopw   0x0(%rax,%rax,1)
xor    %r8d,%r8d
mov    %r8,%rbx
test   $0x1,%r12b
je     16bd <MirrorPad+0x5ad>
mov    0x8(%rsp),%rax
sub    %r8,%rax
movss  (%r11,%rax,4),%xmm0
movss  %xmm0,(%r11,%r8,4)
mov    %rsi,%rax
sub    %r8,%rax
movss  (%r11,%rax,4),%xmm0
lea    (%r8,%r10,1),%rax
movss  %xmm0,(%r11,%rax,4)
mov    %r8,%rbx
or     $0x1,%rbx
not    %r8
cmp    0x28(%rsp),%r8
je     1540 <MirrorPad+0x430>
mov    %rsi,%rcx
sub    %rbx,%rcx
mov    0x40(%rsp),%rax
lea    (%rax,%rbx,1),%rdx
lea    0x0(,%rbx,4),%rax
mov    %r13,%rdi
sub    %rax,%rdi
nopl   0x0(%rax,%rax,1)
movss  (%r11,%rdi,1),%xmm0
movss  %xmm0,(%r11,%rbx,4)
movss  (%r11,%rcx,4),%xmm0
movss  %xmm0,-0x4(%r11,%rdx,4)
movss  -0x4(%r11,%rdi,1),%xmm0
movss  %xmm0,0x4(%r11,%rbx,4)
movss  -0x4(%r11,%rcx,4),%xmm0
movss  %xmm0,(%r11,%rdx,4)
add    $0x2,%rbx
add    $0xfffffffffffffffe,%rcx
add    $0x2,%rdx
add    $0xfffffffffffffff8,%rdi
cmp    %rbx,%r12
jne    16f0 <MirrorPad+0x5e0>
jmp    1540 <MirrorPad+0x430>
xor    %r8d,%r8d
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%rbp
jmp    1683 <MirrorPad+0x573>
lea    -0xc(%r11),%rdx
lea    0x10(%r11),%rcx
mov    0x50(%rsp),%rdi
xor    %ebx,%ebx
nop
movups (%rdx,%r13,1),%xmm0
shufps $0x1b,%xmm0,%xmm0
movups %xmm0,-0x10(%rcx)
movups -0x8(%rdx,%r10,4),%xmm0
shufps $0x1b,%xmm0,%xmm0
movups %xmm0,-0x10(%rcx,%r10,4)
movups -0x10(%rdx,%r13,1),%xmm0
shufps $0x1b,%xmm0,%xmm0
movups %xmm0,(%rcx)
movups -0x18(%rdx,%r10,4),%xmm0
shufps $0x1b,%xmm0,%xmm0
movups %xmm0,(%rcx,%r10,4)
add    $0x8,%rbx
add    $0xffffffffffffffe0,%rdx
add    $0x20,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1760 <MirrorPad+0x650>
testb  $0x1,0x60(%rsp)
je     17e1 <MirrorPad+0x6d1>
mov    0x8(%rsp),%rax
sub    %rbx,%rax
movups -0xc(%r11,%rax,4),%xmm0
shufps $0x1b,%xmm0,%xmm0
movups %xmm0,(%r11,%rbx,4)
mov    %rsi,%rax
sub    %rbx,%rax
movups -0xc(%r11,%rax,4),%xmm0
shufps $0x1b,%xmm0,%xmm0
add    %r10,%rbx
movups %xmm0,(%r11,%rbx,4)
mov    0x58(%rsp),%rax
mov    %rax,%r8
cmp    %r12,%rax
je     1540 <MirrorPad+0x430>
jmp    1683 <MirrorPad+0x573>
mov    0x30(%rsp),%rbx
test   %r15,%r15
jle    188a <MirrorPad+0x77a>
mov    0x10(%rsp),%rcx
lea    (%rcx,%r9,8),%rax
add    $0xfffffffffffffff0,%rax
mov    %rbx,%rdx
neg    %rdx
mov    0x38(%rsp),%rsi
lea    (%rcx,%rsi,8),%rcx
jmp    1839 <MirrorPad+0x729>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12
cmp    %r10,%r12
jge    188a <MirrorPad+0x77a>
test   %rbx,%rbx
jle    1830 <MirrorPad+0x720>
mov    0x10(%rsp),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rcx,%rdi,8),%rbp
movss  0x0(%rbp,%r12,4),%xmm0
mov    (%rsi),%rbp
movss  %xmm0,0x0(%rbp,%r12,4)
mov    (%rax,%rdi,8),%rbp
movss  0x0(%rbp,%r12,4),%xmm0
mov    (%rsi,%r9,8),%rbp
movss  %xmm0,0x0(%rbp,%r12,4)
add    $0xffffffffffffffff,%rdi
add    $0x8,%rsi
cmp    %rdi,%rdx
jne    1850 <MirrorPad+0x740>
jmp    1830 <MirrorPad+0x720>
mov    0x10(%rsp),%r13
mov    %r13,%rax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define float** @MirrorPad(float** %0, i64 %1, i64 %2, i64 %3, i64 %4) {
%6 = alloca float**
%7 = alloca float**
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca float**
store float** %0, float*** %7
store i64 %1, i64* %8
store i64 %2, i64* %9
store i64 %3, i64* %10
store i64 %4, i64* %11
%15 = load i64, i64* %8
%16 = load i64, i64* %10
%17 = mul nsw i64 2, %16
%18 = add nsw i64 %15, %17
%19 = load i64, i64* %9
%20 = load i64, i64* %11
%21 = mul nsw i64 2, %20
%22 = add nsw i64 %19, %21
%23 = call i64 @Get2DMem(i64 %18, i64 %22, i32 8, i32 4)
%24 = inttoptr i64 %23 to float**
store float** %24, float*** %14
store i64 0, i64* %12
br label %25
25: ; preds = %56, %5
%26 = load i64, i64* %12
%27 = load i64, i64* %8
%28 = icmp slt i64 %26, %27
br i1 %28, label %29, label %59
29: ; preds = %25
store i64 0, i64* %13
br label %30
30: ; preds = %52, %29
%31 = load i64, i64* %13
%32 = load i64, i64* %9
%33 = icmp slt i64 %31, %32
br i1 %33, label %34, label %55
34: ; preds = %30
%35 = load float**, float*** %7
%36 = load i64, i64* %12
%37 = getelementptr inbounds float*, float** %35, i64 %36
%38 = load float*, float** %37
%39 = load i64, i64* %13
%40 = getelementptr inbounds float, float* %38, i64 %39
%41 = load float, float* %40
%42 = load float**, float*** %14
%43 = load i64, i64* %12
%44 = load i64, i64* %10
%45 = add nsw i64 %43, %44
%46 = getelementptr inbounds float*, float** %42, i64 %45
%47 = load float*, float** %46
%48 = load i64, i64* %13
%49 = load i64, i64* %11
%50 = add nsw i64 %48, %49
%51 = getelementptr inbounds float, float* %47, i64 %50
store float %41, float* %51
br label %52
52: ; preds = %34
%53 = load i64, i64* %13
%54 = add nsw i64 %53, 1
store i64 %54, i64* %13
br label %30
55: ; preds = %30
br label %56
56: ; preds = %55
%57 = load i64, i64* %12
%58 = add nsw i64 %57, 1
store i64 %58, i64* %12
br label %25
59: ; preds = %25
%60 = load i64, i64* %10
%61 = load i64, i64* %8
%62 = icmp sgt i64 %60, %61
br i1 %62, label %67, label %63
63: ; preds = %59
%64 = load i64, i64* %11
%65 = load i64, i64* %9
%66 = icmp sgt i64 %64, %65
br i1 %66, label %67, label %69
67: ; preds = %63, %59
%68 = load float**, float*** %7
store float** %68, float*** %6
br label %307
69: ; preds = %63
store i64 0, i64* %12
br label %70
70: ; preds = %184, %69
%71 = load i64, i64* %12
%72 = load i64, i64* %10
%73 = icmp slt i64 %71, %72
br i1 %73, label %74, label %187
74: ; preds = %70
store i64 0, i64* %13
br label %75
75: ; preds = %180, %74
%76 = load i64, i64* %13
%77 = load i64, i64* %11
%78 = icmp slt i64 %76, %77
br i1 %78, label %79, label %183
79: ; preds = %75
%80 = load float**, float*** %14
%81 = load i64, i64* %10
%82 = mul nsw i64 2, %81
%83 = load i64, i64* %12
%84 = sub nsw i64 %82, %83
%85 = getelementptr inbounds float*, float** %80, i64 %84
%86 = load float*, float** %85
%87 = load i64, i64* %11
%88 = mul nsw i64 2, %87
%89 = load i64, i64* %13
%90 = sub nsw i64 %88, %89
%91 = getelementptr inbounds float, float* %86, i64 %90
%92 = load float, float* %91
%93 = load float**, float*** %14
%94 = load i64, i64* %12
%95 = getelementptr inbounds float*, float** %93, i64 %94
%96 = load float*, float** %95
%97 = load i64, i64* %13
%98 = getelementptr inbounds float, float* %96, i64 %97
store float %92, float* %98
%99 = load float**, float*** %14
%100 = load i64, i64* %10
%101 = mul nsw i64 2, %100
%102 = load i64, i64* %12
%103 = sub nsw i64 %101, %102
%104 = getelementptr inbounds float*, float** %99, i64 %103
%105 = load float*, float** %104
%106 = load i64, i64* %9
%107 = load i64, i64* %11
%108 = add nsw i64 %106, %107
%109 = sub nsw i64 %108, 2
%110 = load i64, i64* %13
%111 = sub nsw i64 %109, %110
%112 = getelementptr inbounds float, float* %105, i64 %111
%113 = load float, float* %112
%114 = load float**, float*** %14
%115 = load i64, i64* %12
%116 = getelementptr inbounds float*, float** %114, i64 %115
%117 = load float*, float** %116
%118 = load i64, i64* %9
%119 = load i64, i64* %11
%120 = add nsw i64 %118, %119
%121 = load i64, i64* %13
%122 = add nsw i64 %120, %121
%123 = getelementptr inbounds float, float* %117, i64 %122
store float %113, float* %123
%124 = load float**, float*** %14
%125 = load i64, i64* %8
%126 = load i64, i64* %10
%127 = add nsw i64 %125, %126
%128 = sub nsw i64 %127, 2
%129 = load i64, i64* %12
%130 = sub nsw i64 %128, %129
%131 = getelementptr inbounds float*, float** %124, i64 %130
%132 = load float*, float** %131
%133 = load i64, i64* %11
%134 = mul nsw i64 2, %133
%135 = load i64, i64* %13
%136 = sub nsw i64 %134, %135
%137 = getelementptr inbounds float, float* %132, i64 %136
%138 = load float, float* %137
%139 = load float**, float*** %14
%140 = load i64, i64* %8
%141 = load i64, i64* %10
%142 = add nsw i64 %140, %141
%143 = load i64, i64* %12
%144 = add nsw i64 %142, %143
%145 = getelementptr inbounds float*, float** %139, i64 %144
%146 = load float*, float** %145
%147 = load i64, i64* %13
%148 = getelementptr inbounds float, float* %146, i64 %147
store float %138, float* %148
%149 = load float**, float*** %14
%150 = load i64, i64* %8
%151 = load i64, i64* %10
%152 = add nsw i64 %150, %151
%153 = sub nsw i64 %152, 2
%154 = load i64, i64* %12
%155 = sub nsw i64 %153, %154
%156 = getelementptr inbounds float*, float** %149, i64 %155
%157 = load float*, float** %156
%158 = load i64, i64* %9
%159 = load i64, i64* %11
%160 = add nsw i64 %158, %159
%161 = sub nsw i64 %160, 2
%162 = load i64, i64* %13
%163 = sub nsw i64 %161, %162
%164 = getelementptr inbounds float, float* %157, i64 %163
%165 = load float, float* %164
%166 = load float**, float*** %14
%167 = load i64, i64* %8
%168 = load i64, i64* %10
%169 = add nsw i64 %167, %168
%170 = load i64, i64* %12
%171 = add nsw i64 %169, %170
%172 = getelementptr inbounds float*, float** %166, i64 %171
%173 = load float*, float** %172
%174 = load i64, i64* %9
%175 = load i64, i64* %11
%176 = add nsw i64 %174, %175
%177 = load i64, i64* %13
%178 = add nsw i64 %176, %177
%179 = getelementptr inbounds float, float* %173, i64 %178
store float %165, float* %179
br label %180
180: ; preds = %79
%181 = load i64, i64* %13
%182 = add nsw i64 %181, 1
store i64 %182, i64* %13
br label %75
183: ; preds = %75
br label %184
184: ; preds = %183
%185 = load i64, i64* %12
%186 = add nsw i64 %185, 1
store i64 %186, i64* %12
br label %70
187: ; preds = %70
%188 = load i64, i64* %10
store i64 %188, i64* %12
br label %189
189: ; preds = %243, %187
%190 = load i64, i64* %12
%191 = load i64, i64* %8
%192 = load i64, i64* %10
%193 = add nsw i64 %191, %192
%194 = icmp slt i64 %190, %193
br i1 %194, label %195, label %246
195: ; preds = %189
store i64 0, i64* %13
br label %196
196: ; preds = %239, %195
%197 = load i64, i64* %13
%198 = load i64, i64* %11
%199 = icmp slt i64 %197, %198
br i1 %199, label %200, label %242
200: ; preds = %196
%201 = load float**, float*** %14
%202 = load i64, i64* %12
%203 = getelementptr inbounds float*, float** %201, i64 %202
%204 = load float*, float** %203
%205 = load i64, i64* %11
%206 = mul nsw i64 2, %205
%207 = load i64, i64* %13
%208 = sub nsw i64 %206, %207
%209 = getelementptr inbounds float, float* %204, i64 %208
%210 = load float, float* %209
%211 = load float**, float*** %14
%212 = load i64, i64* %12
%213 = getelementptr inbounds float*, float** %211, i64 %212
%214 = load float*, float** %213
%215 = load i64, i64* %13
%216 = getelementptr inbounds float, float* %214, i64 %215
store float %210, float* %216
%217 = load float**, float*** %14
%218 = load i64, i64* %12
%219 = getelementptr inbounds float*, float** %217, i64 %218
%220 = load float*, float** %219
%221 = load i64, i64* %9
%222 = load i64, i64* %11
%223 = add nsw i64 %221, %222
%224 = sub nsw i64 %223, 2
%225 = load i64, i64* %13
%226 = sub nsw i64 %224, %225
%227 = getelementptr inbounds float, float* %220, i64 %226
%228 = load float, float* %227
%229 = load float**, float*** %14
%230 = load i64, i64* %12
%231 = getelementptr inbounds float*, float** %229, i64 %230
%232 = load float*, float** %231
%233 = load i64, i64* %9
%234 = load i64, i64* %11
%235 = add nsw i64 %233, %234
%236 = load i64, i64* %13
%237 = add nsw i64 %235, %236
%238 = getelementptr inbounds float, float* %232, i64 %237
store float %228, float* %238
br label %239
239: ; preds = %200
%240 = load i64, i64* %13
%241 = add nsw i64 %240, 1
store i64 %241, i64* %13
br label %196
242: ; preds = %196
br label %243
243: ; preds = %242
%244 = load i64, i64* %12
%245 = add nsw i64 %244, 1
store i64 %245, i64* %12
br label %189
246: ; preds = %189
%247 = load i64, i64* %11
store i64 %247, i64* %13
br label %248
248: ; preds = %302, %246
%249 = load i64, i64* %13
%250 = load i64, i64* %9
%251 = load i64, i64* %11
%252 = add nsw i64 %250, %251
%253 = icmp slt i64 %249, %252
br i1 %253, label %254, label %305
254: ; preds = %248
store i64 0, i64* %12
br label %255
255: ; preds = %298, %254
%256 = load i64, i64* %12
%257 = load i64, i64* %10
%258 = icmp slt i64 %256, %257
br i1 %258, label %259, label %301
259: ; preds = %255
%260 = load float**, float*** %14
%261 = load i64, i64* %10
%262 = mul nsw i64 2, %261
%263 = load i64, i64* %12
%264 = sub nsw i64 %262, %263
%265 = getelementptr inbounds float*, float** %260, i64 %264
%266 = load float*, float** %265
%267 = load i64, i64* %13
%268 = getelementptr inbounds float, float* %266, i64 %267
%269 = load float, float* %268
%270 = load float**, float*** %14
%271 = load i64, i64* %12
%272 = getelementptr inbounds float*, float** %270, i64 %271
%273 = load float*, float** %272
%274 = load i64, i64* %13
%275 = getelementptr inbounds float, float* %273, i64 %274
store float %269, float* %275
%276 = load float**, float*** %14
%277 = load i64, i64* %8
%278 = load i64, i64* %10
%279 = add nsw i64 %277, %278
%280 = sub nsw i64 %279, 2
%281 = load i64, i64* %12
%282 = sub nsw i64 %280, %281
%283 = getelementptr inbounds float*, float** %276, i64 %282
%284 = load float*, float** %283
%285 = load i64, i64* %13
%286 = getelementptr inbounds float, float* %284, i64 %285
%287 = load float, float* %286
%288 = load float**, float*** %14
%289 = load i64, i64* %8
%290 = load i64, i64* %10
%291 = add nsw i64 %289, %290
%292 = load i64, i64* %12
%293 = add nsw i64 %291, %292
%294 = getelementptr inbounds float*, float** %288, i64 %293
%295 = load float*, float** %294
%296 = load i64, i64* %13
%297 = getelementptr inbounds float, float* %295, i64 %296
store float %287, float* %297
br label %298
298: ; preds = %259
%299 = load i64, i64* %12
%300 = add nsw i64 %299, 1
store i64 %300, i64* %12
br label %255
301: ; preds = %255
br label %302
302: ; preds = %301
%303 = load i64, i64* %13
%304 = add nsw i64 %303, 1
store i64 %304, i64* %13
br label %248
305: ; preds = %248
%306 = load float**, float*** %14
store float** %306, float*** %6
br label %307
307: ; preds = %305, %67
%308 = load float**, float*** %6
ret float** %308
}

LLVM IR (-O2):
define float** @MirrorPad(float** %0, i64 %1, i64 %2, i64 %3, i64 %4) {
%6 = shl nsw i64 %3, 1
%7 = add nsw i64 %6, %1
%8 = shl nsw i64 %4, 1
%9 = add nsw i64 %8, %2
%10 = tail call i64 @Get2DMem(i64 %7, i64 %9, i32 8, i32 4)
%11 = inttoptr i64 %10 to float**
%12 = icmp sgt i64 %1, 0
br i1 %12, label %13, label %160
13: ; preds = %5
%14 = icmp sgt i64 %2, 0
%15 = add i64 %4, %2
%16 = add i64 %2, -8
%17 = lshr i64 %16, 3
%18 = add nuw nsw i64 %17, 1
%19 = icmp ult i64 %2, 8
%20 = and i64 %2, -8
%21 = and i64 %18, 3
%22 = icmp ult i64 %16, 24
%23 = and i64 %18, 4611686018427387900
%24 = icmp eq i64 %21, 0
%25 = icmp eq i64 %20, %2
%26 = and i64 %2, 3
%27 = icmp eq i64 %26, 0
br label %28
28: ; preds = %13, %157
%29 = phi i64 [ 0, %13 ], [ %158, %157 ]
br i1 %14, label %30, label %157
30: ; preds = %28
%31 = getelementptr inbounds float*, float** %0, i64 %29
%32 = load float*, float** %31
%33 = add nsw i64 %29, %3
%34 = getelementptr inbounds float*, float** %11, i64 %33
%35 = load float*, float** %34
br i1 %19, label %117, label %36
36: ; preds = %30
%37 = getelementptr float, float* %35, i64 %4
%38 = getelementptr float, float* %35, i64 %15
%39 = getelementptr float, float* %32, i64 %2
%40 = icmp ult float* %37, %39
%41 = icmp ult float* %32, %38
%42 = and i1 %40, %41
br i1 %42, label %117, label %43
43: ; preds = %36
br i1 %22, label %97, label %44
44: ; preds = %43, %44
%45 = phi i64 [ %94, %44 ], [ 0, %43 ]
%46 = phi i64 [ %95, %44 ], [ 0, %43 ]
%47 = getelementptr inbounds float, float* %32, i64 %45
%48 = bitcast float* %47 to <4 x float>*
%49 = load <4 x float>, <4 x float>* %48
%50 = getelementptr inbounds float, float* %47, i64 4
%51 = bitcast float* %50 to <4 x float>*
%52 = load <4 x float>, <4 x float>* %51
%53 = add nsw i64 %45, %4
%54 = getelementptr inbounds float, float* %35, i64 %53
%55 = bitcast float* %54 to <4 x float>*
store <4 x float> %49, <4 x float>* %55
%56 = getelementptr inbounds float, float* %54, i64 4
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %52, <4 x float>* %57
%58 = or i64 %45, 8
%59 = getelementptr inbounds float, float* %32, i64 %58
%60 = bitcast float* %59 to <4 x float>*
%61 = load <4 x float>, <4 x float>* %60
%62 = getelementptr inbounds float, float* %59, i64 4
%63 = bitcast float* %62 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = add nsw i64 %58, %4
%66 = getelementptr inbounds float, float* %35, i64 %65
%67 = bitcast float* %66 to <4 x float>*
store <4 x float> %61, <4 x float>* %67
%68 = getelementptr inbounds float, float* %66, i64 4
%69 = bitcast float* %68 to <4 x float>*
store <4 x float> %64, <4 x float>* %69
%70 = or i64 %45, 16
%71 = getelementptr inbounds float, float* %32, i64 %70
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = getelementptr inbounds float, float* %71, i64 4
%75 = bitcast float* %74 to <4 x float>*
%76 = load <4 x float>, <4 x float>* %75
%77 = add nsw i64 %70, %4
%78 = getelementptr inbounds float, float* %35, i64 %77
%79 = bitcast float* %78 to <4 x float>*
store <4 x float> %73, <4 x float>* %79
%80 = getelementptr inbounds float, float* %78, i64 4
%81 = bitcast float* %80 to <4 x float>*
store <4 x float> %76, <4 x float>* %81
%82 = or i64 %45, 24
%83 = getelementptr inbounds float, float* %32, i64 %82
%84 = bitcast float* %83 to <4 x float>*
%85 = load <4 x float>, <4 x float>* %84
%86 = getelementptr inbounds float, float* %83, i64 4
%87 = bitcast float* %86 to <4 x float>*
%88 = load <4 x float>, <4 x float>* %87
%89 = add nsw i64 %82, %4
%90 = getelementptr inbounds float, float* %35, i64 %89
%91 = bitcast float* %90 to <4 x float>*
store <4 x float> %85, <4 x float>* %91
%92 = getelementptr inbounds float, float* %90, i64 4
%93 = bitcast float* %92 to <4 x float>*
store <4 x float> %88, <4 x float>* %93
%94 = add nuw i64 %45, 32
%95 = add i64 %46, 4
%96 = icmp eq i64 %95, %23
br i1 %96, label %97, label %44
97: ; preds = %44, %43
%98 = phi i64 [ 0, %43 ], [ %94, %44 ]
br i1 %24, label %116, label %99
99: ; preds = %97, %99
%100 = phi i64 [ %113, %99 ], [ %98, %97 ]
%101 = phi i64 [ %114, %99 ], [ 0, %97 ]
%102 = getelementptr inbounds float, float* %32, i64 %100
%103 = bitcast float* %102 to <4 x float>*
%104 = load <4 x float>, <4 x float>* %103
%105 = getelementptr inbounds float, float* %102, i64 4
%106 = bitcast float* %105 to <4 x float>*
%107 = load <4 x float>, <4 x float>* %106
%108 = add nsw i64 %100, %4
%109 = getelementptr inbounds float, float* %35, i64 %108
%110 = bitcast float* %109 to <4 x float>*
store <4 x float> %104, <4 x float>* %110
%111 = getelementptr inbounds float, float* %109, i64 4
%112 = bitcast float* %111 to <4 x float>*
store <4 x float> %107, <4 x float>* %112
%113 = add nuw i64 %100, 8
%114 = add i64 %101, 1
%115 = icmp eq i64 %114, %21
br i1 %115, label %116, label %99
116: ; preds = %99, %97
br i1 %25, label %157, label %117
117: ; preds = %36, %30, %116
%118 = phi i64 [ 0, %36 ], [ 0, %30 ], [ %20, %116 ]
%119 = xor i64 %118, -1
%120 = add i64 %119, %2
br i1 %27, label %131, label %121
121: ; preds = %117, %121
%122 = phi i64 [ %128, %121 ], [ %118, %117 ]
%123 = phi i64 [ %129, %121 ], [ 0, %117 ]
%124 = getelementptr inbounds float, float* %32, i64 %122
%125 = load float, float* %124
%126 = add nsw i64 %122, %4
%127 = getelementptr inbounds float, float* %35, i64 %126
store float %125, float* %127
%128 = add nuw nsw i64 %122, 1
%129 = add i64 %123, 1
%130 = icmp eq i64 %129, %26
br i1 %130, label %131, label %121
131: ; preds = %121, %117
%132 = phi i64 [ %118, %117 ], [ %128, %121 ]
%133 = icmp ult i64 %120, 3
br i1 %133, label %157, label %134
134: ; preds = %131, %134
%135 = phi i64 [ %155, %134 ], [ %132, %131 ]
%136 = getelementptr inbounds float, float* %32, i64 %135
%137 = load float, float* %136
%138 = add nsw i64 %135, %4
%139 = getelementptr inbounds float, float* %35, i64 %138
store float %137, float* %139
%140 = add nuw nsw i64 %135, 1
%141 = getelementptr inbounds float, float* %32, i64 %140
%142 = load float, float* %141
%143 = add nsw i64 %140, %4
%144 = getelementptr inbounds float, float* %35, i64 %143
store float %142, float* %144
%145 = add nuw nsw i64 %135, 2
%146 = getelementptr inbounds float, float* %32, i64 %145
%147 = load float, float* %146
%148 = add nsw i64 %145, %4
%149 = getelementptr inbounds float, float* %35, i64 %148
store float %147, float* %149
%150 = add nuw nsw i64 %135, 3
%151 = getelementptr inbounds float, float* %32, i64 %150
%152 = load float, float* %151
%153 = add nsw i64 %150, %4
%154 = getelementptr inbounds float, float* %35, i64 %153
store float %152, float* %154
%155 = add nuw nsw i64 %135, 4
%156 = icmp eq i64 %155, %2
br i1 %156, label %157, label %134
157: ; preds = %131, %134, %116, %28
%158 = add nuw nsw i64 %29, 1
%159 = icmp eq i64 %158, %1
br i1 %159, label %160, label %28
160: ; preds = %157, %5
%161 = icmp sgt i64 %3, %1
%162 = icmp sgt i64 %4, %2
%163 = or i1 %161, %162
br i1 %163, label %428, label %164
164: ; preds = %160
%165 = icmp sgt i64 %3, 0
br i1 %165, label %168, label %166
166: ; preds = %164
%167 = add nsw i64 %3, %1
br label %188
168: ; preds = %164
%169 = icmp sgt i64 %4, 0
%170 = add nsw i64 %4, %2
%171 = add nsw i64 %170, -2
%172 = add nsw i64 %3, %1
%173 = add nsw i64 %172, -2
br label %174
174: ; preds = %168, %243
%175 = phi i64 [ 0, %168 ], [ %244, %243 ]
br i1 %169, label %176, label %243
176: ; preds = %174
%177 = sub nsw i64 %6, %175
%178 = getelementptr inbounds float*, float** %11, i64 %177
%179 = load float*, float** %178
%180 = getelementptr inbounds float*, float** %11, i64 %175
%181 = load float*, float** %180
%182 = sub i64 %173, %175
%183 = getelementptr inbounds float*, float** %11, i64 %182
%184 = load float*, float** %183
%185 = add nsw i64 %175, %172
%186 = getelementptr inbounds float*, float** %11, i64 %185
%187 = load float*, float** %186
br label %224
188: ; preds = %243, %166
%189 = phi i64 [ %167, %166 ], [ %172, %243 ]
br i1 %12, label %192, label %190
190: ; preds = %188
%191 = add nsw i64 %4, %2
br label %371
192: ; preds = %188
%193 = icmp sgt i64 %4, 0
%194 = add i64 %4, %2
%195 = add i64 %194, -2
%196 = add i64 %4, -1
%197 = add i64 %8, %2
%198 = add i64 %4, 1
%199 = or i64 %8, 1
%200 = add i64 %2, -1
%201 = add i64 %4, %2
%202 = add i64 %201, -1
%203 = add i64 %4, -4
%204 = lshr i64 %203, 2
%205 = add nuw nsw i64 %204, 1
%206 = icmp ult i64 %4, 4
%207 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %196, i64 4)
%208 = extractvalue { i64, i1 } %207, 0
%209 = extractvalue { i64, i1 } %207, 1
%210 = sub i64 0, %208
%211 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %196, i64 4)
%212 = extractvalue { i64, i1 } %211, 0
%213 = extractvalue { i64, i1 } %211, 1
%214 = sub i64 0, %212
%215 = and i64 %4, -4
%216 = and i64 %205, 1
%217 = icmp ult i64 %203, 4
%218 = and i64 %205, 9223372036854775806
%219 = icmp eq i64 %216, 0
%220 = icmp eq i64 %215, %4
%221 = and i64 %4, 1
%222 = icmp eq i64 %221, 0
%223 = sub i64 0, %4
br label %246
224: ; preds = %176, %224
%225 = phi i64 [ 0, %176 ], [ %241, %224 ]
%226 = sub nsw i64 %8, %225
%227 = getelementptr inbounds float, float* %179, i64 %226
%228 = load float, float* %227
%229 = getelementptr inbounds float, float* %181, i64 %225
store float %228, float* %229
%230 = sub i64 %171, %225
%231 = getelementptr inbounds float, float* %179, i64 %230
%232 = load float, float* %231
%233 = add nsw i64 %225, %170
%234 = getelementptr inbounds float, float* %181, i64 %233
store float %232, float* %234
%235 = getelementptr inbounds float, float* %184, i64 %226
%236 = load float, float* %235
%237 = getelementptr inbounds float, float* %187, i64 %225
store float %236, float* %237
%238 = getelementptr inbounds float, float* %184, i64 %230
%239 = load float, float* %238
%240 = getelementptr inbounds float, float* %187, i64 %233
store float %239, float* %240
%241 = add nuw nsw i64 %225, 1
%242 = icmp eq i64 %241, %4
br i1 %242, label %243, label %224
243: ; preds = %224, %174
%244 = add nuw nsw i64 %175, 1
%245 = icmp eq i64 %244, %3
br i1 %245, label %188, label %174
246: ; preds = %192, %399
%247 = phi i64 [ %3, %192 ], [ %400, %399 ]
br i1 %193, label %248, label %399
248: ; preds = %246
%249 = getelementptr inbounds float*, float** %11, i64 %247
%250 = load float*, float** %249
br i1 %206, label %354, label %251
251: ; preds = %248
%252 = getelementptr float, float* %250, i64 %8
%253 = bitcast float* %252 to i8*
%254 = getelementptr i8, i8* %253, i64 %210
%255 = icmp ugt i8* %254, %253
%256 = or i1 %255, %209
%257 = getelementptr float, float* %250, i64 %195
%258 = bitcast float* %257 to i8*
%259 = getelementptr i8, i8* %258, i64 %214
%260 = icmp ugt i8* %259, %258
%261 = or i1 %260, %213
%262 = or i1 %256, %261
br i1 %262, label %354, label %263
263: ; preds = %251
%264 = getelementptr float, float* %250, i64 %4
%265 = getelementptr float, float* %250, i64 %194
%266 = getelementptr float, float* %250, i64 %197
%267 = getelementptr float, float* %250, i64 %198
%268 = getelementptr float, float* %250, i64 %199
%269 = getelementptr float, float* %250, i64 %200
%270 = getelementptr float, float* %250, i64 %202
%271 = icmp ult float* %250, %266
%272 = icmp ult float* %265, %264
%273 = and i1 %271, %272
%274 = icmp ult float* %250, %268
%275 = icmp ult float* %267, %264
%276 = and i1 %274, %275
%277 = or i1 %273, %276
%278 = icmp ult float* %250, %270
%279 = icmp ult float* %269, %264
%280 = and i1 %278, %279
%281 = or i1 %277, %280
%282 = icmp ult float* %265, %268
%283 = icmp ult float* %267, %266
%284 = and i1 %282, %283
%285 = or i1 %281, %284
%286 = icmp ult float* %265, %270
%287 = icmp ult float* %269, %266
%288 = and i1 %286, %287
%289 = or i1 %285, %288
br i1 %289, label %354, label %290
290: ; preds = %263
br i1 %217, label %333, label %291
291: ; preds = %290
%292 = getelementptr inbounds float, float* %250, i64 -3
%293 = getelementptr inbounds float, float* %250, i64 -3
%294 = getelementptr inbounds float, float* %250, i64 -3
%295 = getelementptr inbounds float, float* %250, i64 -3
br label %296
296: ; preds = %296, %291
%297 = phi i64 [ 0, %291 ], [ %330, %296 ]
%298 = phi i64 [ 0, %291 ], [ %331, %296 ]
%299 = sub nsw i64 %8, %297
%300 = getelementptr inbounds float, float* %292, i64 %299
%301 = bitcast float* %300 to <4 x float>*
%302 = load <4 x float>, <4 x float>* %301
%303 = shufflevector <4 x float> %302, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%304 = getelementptr inbounds float, float* %250, i64 %297
%305 = bitcast float* %304 to <4 x float>*
store <4 x float> %303, <4 x float>* %305
%306 = sub i64 %195, %297
%307 = getelementptr inbounds float, float* %293, i64 %306
%308 = bitcast float* %307 to <4 x float>*
%309 = load <4 x float>, <4 x float>* %308
%310 = shufflevector <4 x float> %309, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%311 = add nsw i64 %297, %194
%312 = getelementptr inbounds float, float* %250, i64 %311
%313 = bitcast float* %312 to <4 x float>*
store <4 x float> %310, <4 x float>* %313
%314 = or i64 %297, 4
%315 = sub nsw i64 %8, %314
%316 = getelementptr inbounds float, float* %294, i64 %315
%317 = bitcast float* %316 to <4 x float>*
%318 = load <4 x float>, <4 x float>* %317
%319 = shufflevector <4 x float> %318, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%320 = getelementptr inbounds float, float* %250, i64 %314
%321 = bitcast float* %320 to <4 x float>*
store <4 x float> %319, <4 x float>* %321
%322 = sub i64 %195, %314
%323 = getelementptr inbounds float, float* %295, i64 %322
%324 = bitcast float* %323 to <4 x float>*
%325 = load <4 x float>, <4 x float>* %324
%326 = shufflevector <4 x float> %325, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%327 = add nsw i64 %314, %194
%328 = getelementptr inbounds float, float* %250, i64 %327
%329 = bitcast float* %328 to <4 x float>*
store <4 x float> %326, <4 x float>* %329
%330 = add nuw i64 %297, 8
%331 = add i64 %298, 2
%332 = icmp eq i64 %331, %218
br i1 %332, label %333, label %296
333: ; preds = %296, %290
%334 = phi i64 [ 0, %290 ], [ %330, %296 ]
br i1 %219, label %353, label %335
335: ; preds = %333
%336 = sub nsw i64 %8, %334
%337 = getelementptr inbounds float, float* %250, i64 -3
%338 = getelementptr inbounds float, float* %337, i64 %336
%339 = bitcast float* %338 to <4 x float>*
%340 = load <4 x float>, <4 x float>* %339
%341 = shufflevector <4 x float> %340, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%342 = getelementptr inbounds float, float* %250, i64 %334
%343 = bitcast float* %342 to <4 x float>*
store <4 x float> %341, <4 x float>* %343
%344 = sub i64 %195, %334
%345 = getelementptr inbounds float, float* %250, i64 -3
%346 = getelementptr inbounds float, float* %345, i64 %344
%347 = bitcast float* %346 to <4 x float>*
%348 = load <4 x float>, <4 x float>* %347
%349 = shufflevector <4 x float> %348, <4 x float> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%350 = add nsw i64 %334, %194
%351 = getelementptr inbounds float, float* %250, i64 %350
%352 = bitcast float* %351 to <4 x float>*
store <4 x float> %349, <4 x float>* %352
br label %353
353: ; preds = %333, %335
br i1 %220, label %399, label %354
354: ; preds = %263, %251, %248, %353
%355 = phi i64 [ 0, %263 ], [ 0, %251 ], [ 0, %248 ], [ %215, %353 ]
%356 = xor i64 %355, -1
br i1 %222, label %368, label %357
357: ; preds = %354
%358 = sub nsw i64 %8, %355
%359 = getelementptr inbounds float, float* %250, i64 %358
%360 = load float, float* %359
%361 = getelementptr inbounds float, float* %250, i64 %355
store float %360, float* %361
%362 = sub i64 %195, %355
%363 = getelementptr inbounds float, float* %250, i64 %362
%364 = load float, float* %363
%365 = add nsw i64 %355, %194
%366 = getelementptr inbounds float, float* %250, i64 %365
store float %364, float* %366
%367 = or i64 %355, 1
br label %368
368: ; preds = %357, %354
%369 = phi i64 [ %355, %354 ], [ %367, %357 ]
%370 = icmp eq i64 %356, %223
br i1 %370, label %399, label %376
371: ; preds = %399, %190
%372 = phi i64 [ %191, %190 ], [ %194, %399 ]
%373 = icmp sgt i64 %2, 0
br i1 %373, label %374, label %428
374: ; preds = %371
%375 = add nsw i64 %189, -2
br label %402
376: ; preds = %368, %376
%377 = phi i64 [ %397, %376 ], [ %369, %368 ]
%378 = sub nsw i64 %8, %377
%379 = getelementptr inbounds float, float* %250, i64 %378
%380 = load float, float* %379
%381 = getelementptr inbounds float, float* %250, i64 %377
store float %380, float* %381
%382 = sub i64 %195, %377
%383 = getelementptr inbounds float, float* %250, i64 %382
%384 = load float, float* %383
%385 = add nsw i64 %377, %194
%386 = getelementptr inbounds float, float* %250, i64 %385
store float %384, float* %386
%387 = add nuw nsw i64 %377, 1
%388 = sub nsw i64 %8, %387
%389 = getelementptr inbounds float, float* %250, i64 %388
%390 = load float, float* %389
%391 = getelementptr inbounds float, float* %250, i64 %387
store float %390, float* %391
%392 = sub i64 %195, %387
%393 = getelementptr inbounds float, float* %250, i64 %392
%394 = load float, float* %393
%395 = add nsw i64 %387, %194
%396 = getelementptr inbounds float, float* %250, i64 %395
store float %394, float* %396
%397 = add nuw nsw i64 %377, 2
%398 = icmp eq i64 %397, %4
br i1 %398, label %399, label %376
399: ; preds = %368, %376, %353, %246
%400 = add nsw i64 %247, 1
%401 = icmp slt i64 %400, %189
br i1 %401, label %246, label %371
402: ; preds = %374, %425
%403 = phi i64 [ %4, %374 ], [ %426, %425 ]
br i1 %165, label %404, label %425
404: ; preds = %402, %404
%405 = phi i64 [ %423, %404 ], [ 0, %402 ]
%406 = sub nsw i64 %6, %405
%407 = getelementptr inbounds float*, float** %11, i64 %406
%408 = load float*, float** %407
%409 = getelementptr inbounds float, float* %408, i64 %403
%410 = load float, float* %409
%411 = getelementptr inbounds float*, float** %11, i64 %405
%412 = load float*, float** %411
%413 = getelementptr inbounds float, float* %412, i64 %403
store float %410, float* %413
%414 = sub i64 %375, %405
%415 = getelementptr inbounds float*, float** %11, i64 %414
%416 = load float*, float** %415
%417 = getelementptr inbounds float, float* %416, i64 %403
%418 = load float, float* %417
%419 = add nsw i64 %405, %189
%420 = getelementptr inbounds float*, float** %11, i64 %419
%421 = load float*, float** %420
%422 = getelementptr inbounds float, float* %421, i64 %403
store float %418, float* %422
%423 = add nuw nsw i64 %405, 1
%424 = icmp eq i64 %423, %3
br i1 %424, label %425, label %404
425: ; preds = %404, %402
%426 = add nsw i64 %403, 1
%427 = icmp slt i64 %426, %372
br i1 %427, label %402, label %428
428: ; preds = %425, %371, %160
%429 = phi float** [ %0, %160 ], [ %11, %371 ], [ %11, %425 ]
ret float** %429
}