int reflect1(filt, x_dim, y_dim, x_pos, y_pos, result, r_or_e)
register double *filt, *result;
register int x_dim;
int y_dim, x_pos, y_pos, r_or_e;
{
  int filt_sz = x_dim * y_dim;
  register int y_filt, x_filt, y_res, x_res;
  register int x_base = (x_pos > 0) ? (x_dim - 1) : 0;
  register int y_base = x_dim * ((y_pos > 0) ? (y_dim - 1) : 0);
  int x_overhang = (x_pos > 0) ? (x_pos - 1) : ((x_pos < 0) ? (x_pos + 1) : 0);
  int y_overhang =
      x_dim * ((y_pos > 0) ? (y_pos - 1) : ((y_pos < 0) ? (y_pos + 1) : 0));
  int i;
  int mx_pos = (x_pos < 0) ? (x_dim / 2) : ((x_dim - 1) / 2);
  int my_pos = x_dim * ((y_pos < 0) ? (y_dim / 2) : ((y_dim - 1) / 2));
  for (i = 0; i < filt_sz; i++)
    result[i] = 0.0;
  if (r_or_e == 0)
    for (y_filt = 0, y_res = y_overhang - y_base; y_filt < filt_sz;
         y_filt += x_dim, y_res += x_dim)
      for (x_filt = y_filt, x_res = x_overhang - x_base;
           x_filt < y_filt + x_dim; x_filt++, x_res++)
        result[(((y_base - (((y_res) >= 0) ? (y_res) : (-(y_res)))) >= 0)
                    ? (y_base - (((y_res) >= 0) ? (y_res) : (-(y_res))))
                    : (-(y_base - (((y_res) >= 0) ? (y_res) : (-(y_res)))))) +
               (((x_base - (((x_res) >= 0) ? (x_res) : (-(x_res)))) >= 0)
                    ? (x_base - (((x_res) >= 0) ? (x_res) : (-(x_res))))
                    : (-(x_base - (((x_res) >= 0) ? (x_res) : (-(x_res))))))] +=
            filt[x_filt];
  else {
    y_overhang = (((y_overhang) >= 0) ? (y_overhang) : (-(y_overhang)));
    x_overhang = (((x_overhang) >= 0) ? (x_overhang) : (-(x_overhang)));
    for (y_res = y_base, y_filt = y_base - y_overhang;
         y_filt > y_base - filt_sz; y_filt -= x_dim, y_res -= x_dim) {
      for (x_res = x_base, x_filt = x_base - x_overhang;
           x_filt > x_base - x_dim; x_res--, x_filt--)
        result[(((y_res) >= 0) ? (y_res) : (-(y_res))) +
               (((x_res) >= 0) ? (x_res) : (-(x_res)))] +=
            filt[(((y_filt) >= 0) ? (y_filt) : (-(y_filt))) +
                 (((x_filt) >= 0) ? (x_filt) : (-(x_filt)))];
      if ((x_overhang != mx_pos) && (x_pos != 0))
        for (x_res = x_base, x_filt = x_base - 2 * mx_pos + x_overhang;
             x_filt > x_base - x_dim; x_res--, x_filt--)
          result[(((y_res) >= 0) ? (y_res) : (-(y_res))) +
                 (((x_res) >= 0) ? (x_res) : (-(x_res)))] +=
              filt[(((y_filt) >= 0) ? (y_filt) : (-(y_filt))) +
                   (((x_filt) >= 0) ? (x_filt) : (-(x_filt)))];
    }
    if ((y_overhang != my_pos) && (y_pos != 0))
      for (y_res = y_base, y_filt = y_base - 2 * my_pos + y_overhang;
           y_filt > y_base - filt_sz; y_filt -= x_dim, y_res -= x_dim) {
        for (x_res = x_base, x_filt = x_base - x_overhang;
             x_filt > x_base - x_dim; x_res--, x_filt--)
          result[(((y_res) >= 0) ? (y_res) : (-(y_res))) +
                 (((x_res) >= 0) ? (x_res) : (-(x_res)))] +=
              filt[(((y_filt) >= 0) ? (y_filt) : (-(y_filt))) +
                   (((x_filt) >= 0) ? (x_filt) : (-(x_filt)))];
        if ((x_overhang != mx_pos) && (x_pos != 0))
          for (x_res = x_base, x_filt = x_base - 2 * mx_pos + x_overhang;
               x_filt > x_base - x_dim; x_res--, x_filt--)
            result[(((y_res) >= 0) ? (y_res) : (-(y_res))) +
                   (((x_res) >= 0) ? (x_res) : (-(x_res)))] +=
                filt[(((y_filt) >= 0) ? (y_filt) : (-(y_filt))) +
                     (((x_filt) >= 0) ? (x_filt) : (-(x_filt)))];
      }
  }
  return (0);
}


x86 assembly (clang, -O0):
<reflect1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    1145 <reflect1+0x45>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    114f <reflect1+0x4f>
xor    %eax,%eax
mov    %eax,-0x54(%rbp)
jmp    114f <reflect1+0x4f>
mov    -0x54(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    1173 <reflect1+0x73>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    117d <reflect1+0x7d>
xor    %eax,%eax
mov    %eax,-0x5c(%rbp)
jmp    117d <reflect1+0x7d>
mov    -0x58(%rbp),%eax
mov    -0x5c(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    11a1 <reflect1+0xa1>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    11c9 <reflect1+0xc9>
cmpl   $0x0,-0x14(%rbp)
jge    11b9 <reflect1+0xb9>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    11c3 <reflect1+0xc3>
xor    %eax,%eax
mov    %eax,-0x64(%rbp)
jmp    11c3 <reflect1+0xc3>
mov    -0x64(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    11ed <reflect1+0xed>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1215 <reflect1+0x115>
cmpl   $0x0,-0x18(%rbp)
jge    1205 <reflect1+0x105>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    120f <reflect1+0x10f>
xor    %eax,%eax
mov    %eax,-0x70(%rbp)
jmp    120f <reflect1+0x10f>
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x68(%rbp),%eax
mov    -0x6c(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x14(%rbp)
jge    123e <reflect1+0x13e>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x74(%rbp)
jmp    124f <reflect1+0x14f>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x78(%rbp)
cmpl   $0x0,-0x18(%rbp)
jge    1278 <reflect1+0x178>
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x7c(%rbp)
jmp    1289 <reflect1+0x189>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x7c(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x7c(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12c6 <reflect1+0x1c6>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    129c <reflect1+0x19c>
cmpl   $0x0,0x10(%rbp)
jne    152c <reflect1+0x42c>
movl   $0x0,-0x28(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1527 <reflect1+0x427>
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x40(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    150b <reflect1+0x40b>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x80(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     134a <reflect1+0x24a>
mov    -0x30(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    1355 <reflect1+0x255>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x80(%rbp),%eax
mov    -0x94(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jl     13ae <reflect1+0x2ae>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     138a <reflect1+0x28a>
mov    -0x30(%rbp),%eax
mov    %eax,-0x9c(%rbp)
jmp    1395 <reflect1+0x295>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x9c(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0xa0(%rbp)
jmp    13f2 <reflect1+0x2f2>
mov    -0x3c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     13cf <reflect1+0x2cf>
mov    -0x30(%rbp),%eax
mov    %eax,-0xa8(%rbp)
jmp    13da <reflect1+0x2da>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa4(%rbp),%ecx
mov    -0xa8(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0xac(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     141f <reflect1+0x31f>
mov    -0x34(%rbp),%eax
mov    %eax,-0xb4(%rbp)
jmp    142a <reflect1+0x32a>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xac(%rbp),%eax
mov    -0xb4(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jl     1486 <reflect1+0x386>
mov    -0x38(%rbp),%eax
mov    %eax,-0xb8(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1462 <reflect1+0x362>
mov    -0x34(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    146d <reflect1+0x36d>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xb8(%rbp),%eax
mov    -0xbc(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0xc0(%rbp)
jmp    14ca <reflect1+0x3ca>
mov    -0x38(%rbp),%eax
mov    %eax,-0xc4(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     14a7 <reflect1+0x3a7>
mov    -0x34(%rbp),%eax
mov    %eax,-0xc8(%rbp)
jmp    14b2 <reflect1+0x3b2>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc4(%rbp),%ecx
mov    -0xc8(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xc0(%rbp)
mov    -0x88(%rbp),%rax
movsd  -0x90(%rbp),%xmm0
ff
mov    -0xb0(%rbp),%ecx
mov    -0xc0(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12fb <reflect1+0x1fb>
jmp    1510 <reflect1+0x410>
mov    -0xc(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    12e0 <reflect1+0x1e0>
jmp    1b72 <reflect1+0xa72>
cmpl   $0x0,-0x44(%rbp)
jl     1544 <reflect1+0x444>
mov    -0x44(%rbp),%eax
mov    %eax,-0xcc(%rbp)
jmp    154f <reflect1+0x44f>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     1570 <reflect1+0x470>
mov    -0x40(%rbp),%eax
mov    %eax,-0xd0(%rbp)
jmp    157b <reflect1+0x47b>
xor    %eax,%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x3c(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jle    1867 <reflect1+0x767>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    16e4 <reflect1+0x5e4>
mov    -0x8(%rbp),%rax
mov    %rax,-0xd8(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     15e7 <reflect1+0x4e7>
mov    -0x28(%rbp),%eax
mov    %eax,-0xdc(%rbp)
jmp    15f2 <reflect1+0x4f2>
xor    %eax,%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
mov    %eax,-0xe0(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1616 <reflect1+0x516>
mov    -0x2c(%rbp),%eax
mov    %eax,-0xe4(%rbp)
jmp    1621 <reflect1+0x521>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0xe4(%rbp)
mov    -0xd8(%rbp),%rax
mov    -0xe0(%rbp),%ecx
mov    -0xe4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0xf0(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     1669 <reflect1+0x569>
mov    -0x30(%rbp),%eax
mov    %eax,-0xfc(%rbp)
jmp    1674 <reflect1+0x574>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
mov    %eax,-0x100(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1698 <reflect1+0x598>
mov    -0x34(%rbp),%eax
mov    %eax,-0x104(%rbp)
jmp    16a3 <reflect1+0x5a3>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0xf0(%rbp),%rax
movsd  -0xf8(%rbp),%xmm0
ff
mov    -0x100(%rbp),%ecx
mov    -0x104(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    15b3 <reflect1+0x4b3>
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     1847 <reflect1+0x747>
cmpl   $0x0,-0x14(%rbp)
je     1847 <reflect1+0x747>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4c(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    1842 <reflect1+0x742>
mov    -0x8(%rbp),%rax
mov    %rax,-0x110(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1745 <reflect1+0x645>
mov    -0x28(%rbp),%eax
mov    %eax,-0x114(%rbp)
jmp    1750 <reflect1+0x650>
xor    %eax,%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x114(%rbp)
mov    -0x114(%rbp),%eax
mov    %eax,-0x118(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1774 <reflect1+0x674>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x11c(%rbp)
jmp    177f <reflect1+0x67f>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x110(%rbp),%rax
mov    -0x118(%rbp),%ecx
mov    -0x11c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0x128(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     17c7 <reflect1+0x6c7>
mov    -0x30(%rbp),%eax
mov    %eax,-0x134(%rbp)
jmp    17d2 <reflect1+0x6d2>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x134(%rbp)
mov    -0x134(%rbp),%eax
mov    %eax,-0x138(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     17f6 <reflect1+0x6f6>
mov    -0x34(%rbp),%eax
mov    %eax,-0x13c(%rbp)
jmp    1801 <reflect1+0x701>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x128(%rbp),%rax
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x138(%rbp),%ecx
mov    -0x13c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1711 <reflect1+0x611>
jmp    1847 <reflect1+0x747>
jmp    184c <reflect1+0x74c>
mov    -0xc(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x30(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
jmp    1593 <reflect1+0x493>
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     1b6d <reflect1+0xa6d>
cmpl   $0x0,-0x18(%rbp)
je     1b6d <reflect1+0xa6d>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jle    1b68 <reflect1+0xa68>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    19e5 <reflect1+0x8e5>
mov    -0x8(%rbp),%rax
mov    %rax,-0x148(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     18e8 <reflect1+0x7e8>
mov    -0x28(%rbp),%eax
mov    %eax,-0x14c(%rbp)
jmp    18f3 <reflect1+0x7f3>
xor    %eax,%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
mov    %eax,-0x150(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1917 <reflect1+0x817>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x154(%rbp)
jmp    1922 <reflect1+0x822>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x154(%rbp)
mov    -0x148(%rbp),%rax
mov    -0x150(%rbp),%ecx
mov    -0x154(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0x160(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     196a <reflect1+0x86a>
mov    -0x30(%rbp),%eax
mov    %eax,-0x16c(%rbp)
jmp    1975 <reflect1+0x875>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    %eax,-0x170(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1999 <reflect1+0x899>
mov    -0x34(%rbp),%eax
mov    %eax,-0x174(%rbp)
jmp    19a4 <reflect1+0x8a4>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x174(%rbp)
mov    -0x160(%rbp),%rax
movsd  -0x168(%rbp),%xmm0
ff
mov    -0x170(%rbp),%ecx
mov    -0x174(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    18b4 <reflect1+0x7b4>
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     1b48 <reflect1+0xa48>
cmpl   $0x0,-0x14(%rbp)
je     1b48 <reflect1+0xa48>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4c(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    1b43 <reflect1+0xa43>
mov    -0x8(%rbp),%rax
mov    %rax,-0x180(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1a46 <reflect1+0x946>
mov    -0x28(%rbp),%eax
mov    %eax,-0x184(%rbp)
jmp    1a51 <reflect1+0x951>
xor    %eax,%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x184(%rbp)
mov    -0x184(%rbp),%eax
mov    %eax,-0x188(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1a75 <reflect1+0x975>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x18c(%rbp)
jmp    1a80 <reflect1+0x980>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x18c(%rbp)
mov    -0x180(%rbp),%rax
mov    -0x188(%rbp),%ecx
mov    -0x18c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0x198(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     1ac8 <reflect1+0x9c8>
mov    -0x30(%rbp),%eax
mov    %eax,-0x1a4(%rbp)
jmp    1ad3 <reflect1+0x9d3>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
mov    %eax,-0x1a8(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1af7 <reflect1+0x9f7>
mov    -0x34(%rbp),%eax
mov    %eax,-0x1ac(%rbp)
jmp    1b02 <reflect1+0xa02>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x1ac(%rbp)
mov    -0x198(%rbp),%rax
movsd  -0x1a0(%rbp),%xmm0
ff
mov    -0x1a8(%rbp),%ecx
mov    -0x1ac(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a12 <reflect1+0x912>
jmp    1b48 <reflect1+0xa48>
jmp    1b4d <reflect1+0xa4d>
mov    -0xc(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x30(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
jmp    1894 <reflect1+0x794>
jmp    1b6d <reflect1+0xa6d>
jmp    1b72 <reflect1+0xa72>
xor    %eax,%eax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reflect1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %edx,%ebx
lea    -0x1(%rbx),%r10d
lea    0x1(%r8),%r13d
test   %r8d,%r8d
mov    %r10d,%eax
cmovs  %edx,%eax
mov    %eax,0x64(%rsp)
xor    %edx,%edx
mov    %r8,0x80(%rsp)
mov    %r8d,%eax
sub    $0x1,%eax
cmovb  %edx,%r13d
cmovl  %edx,%r10d
mov    %r9,%r14
mov    %rdi,%r15
mov    %rsi,%rdi
cmovge %eax,%r13d
imul   %edi,%ebx
lea    -0x1(%rsi),%ebp
imul   %edi,%r10d
lea    0x1(%rcx),%r12d
mov    %ecx,%eax
sub    $0x1,%eax
cmovb  %edx,%r12d
imul   %edi,%r13d
mov    %rcx,0x78(%rsp)
test   %ecx,%ecx
cmovg  %ebp,%edx
mov    %rdx,0x10(%rsp)
cmovg  %eax,%r12d
cmovs  %edi,%ebp
test   %ebx,%ebx
mov    %rsi,0x30(%rsp)
mov    %r10d,0x20(%rsp)
jle    1252 <reflect1+0x142>
mov    %ebx,%edx
shl    $0x3,%rdx
mov    %r14,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x30(%rsp),%rdi
mov    0x20(%rsp),%r10d
cmpl   $0x0,0xc0(%rsp)
jne    1260 <reflect1+0x150>
sub    %r10d,%r13d
sub    0x10(%rsp),%r12d
movslq %edi,%r8
movslq %ebx,%r9
xor    %edx,%edx
mov    0x10(%rsp),%rbx
jmp    11f4 <reflect1+0xe4>
nop
mov    0x30(%rsp),%rdi
add    %edi,%r13d
mov    %rsi,%rdx
cmp    %r9,%rsi
jge    1665 <reflect1+0x555>
lea    (%rdx,%r8,1),%rsi
test   %edi,%edi
jle    11e0 <reflect1+0xd0>
mov    %r13d,%eax
neg    %eax
cmovns %r13d,%eax
add    %r10d,%eax
mov    %eax,%edi
neg    %edi
cmovs  %eax,%edi
mov    %r12d,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ecx,%eax
neg    %eax
cmovns %ecx,%eax
add    %ebx,%eax
mov    %eax,%ebp
neg    %ebp
cmovs  %eax,%ebp
movsd  (%r15,%rdx,8),%xmm0
add    %edi,%ebp
addsd  (%r14,%rbp,8),%xmm0
movsd  %xmm0,(%r14,%rbp,8)
add    $0x1,%rdx
add    $0x1,%ecx
cmp    %rsi,%rdx
jl     1220 <reflect1+0x110>
jmp    11e0 <reflect1+0xd0>
cmpl   $0x0,0xc0(%rsp)
je     1665 <reflect1+0x555>
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebp,%eax
sar    %eax
mov    %rax,0x70(%rsp)
mov    %r13d,%ecx
neg    %ecx
cmovs  %r13d,%ecx
mov    %r12d,%eax
neg    %eax
cmovs  %r12d,%eax
mov    %rax,0x28(%rsp)
sub    %ebx,%r10d
mov    %r10d,0x24(%rsp)
mov    %ecx,0x1c(%rsp)
cmp    %ecx,%ebx
jle    146a <reflect1+0x35a>
cmpl   $0x0,0x78(%rsp)
sete   %r8b
mov    0x20(%rsp),%r12d
mov    %r12d,%r9d
sub    0x1c(%rsp),%r9d
mov    0x10(%rsp),%rcx
mov    %ecx,%ebx
sub    %edi,%ebx
mov    0x28(%rsp),%rsi
mov    0x70(%rsp),%r10
cmp    %r10d,%esi
sete   %al
lea    (%rsi,%rcx,1),%ebp
sub    %r10d,%ebp
sub    %r10d,%ebp
cmp    %ebx,%ebp
setle  %dl
or     %r8b,%al
or     %dl,%al
mov    %al,0x58(%rsp)
mov    %ebp,%eax
neg    %eax
cmovs  %ebp,%eax
mov    %rax,0x40(%rsp)
lea    (%rsi,%rdi,1),%eax
mov    %eax,0xc(%rsp)
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
mov    %rax,0x38(%rsp)
lea    0x1(%r10,%r10,1),%eax
mov    %eax,0x48(%rsp)
lea    -0x1(%rcx),%eax
mov    %eax,0x6c(%rsp)
mov    %rbp,0x50(%rsp)
lea    -0x1(%rbp),%eax
mov    %eax,0x68(%rsp)
mov    %esi,%eax
neg    %eax
jmp    1331 <reflect1+0x221>
sub    %edi,%r9d
sub    %edi,%r12d
cmp    0x24(%rsp),%r9d
jle    146a <reflect1+0x35a>
cmp    %edi,0x28(%rsp)
jge    1384 <reflect1+0x274>
mov    %r9d,%edi
neg    %edi
cmovs  %r9d,%edi
mov    %r12d,%esi
neg    %esi
cmovs  %r12d,%esi
mov    0x10(%rsp),%rdx
xchg   %ax,%ax
lea    (%rax,%rdx,1),%ecx
mov    %ecx,%ebp
neg    %ebp
cmovs  %ecx,%ebp
add    %edi,%ebp
mov    %edx,%ecx
neg    %ecx
cmovs  %edx,%ecx
movsd  (%r15,%rbp,8),%xmm0
add    %esi,%ecx
addsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
lea    (%rax,%rdx,1),%ecx
add    $0xffffffff,%ecx
add    $0xffffffff,%edx
cmp    %ebx,%ecx
jg     1350 <reflect1+0x240>
cmpb   $0x0,0x58(%rsp)
mov    0x30(%rsp),%rdi
jne    1320 <reflect1+0x210>
mov    %r9d,%r10d
neg    %r10d
cmovs  %r9d,%r10d
mov    %r12d,%r8d
neg    %r8d
cmovs  %r12d,%r8d
mov    0x50(%rsp),%r11
mov    0x10(%rsp),%r13
testb  $0x1,0xc(%rsp)
je     13e5 <reflect1+0x2d5>
mov    0x40(%rsp),%rcx
add    %r10d,%ecx
movsd  (%r15,%rcx,8),%xmm0
mov    0x38(%rsp),%rcx
add    %r8d,%ecx
addsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
mov    0x68(%rsp),%ecx
mov    %ecx,%r11d
mov    0x6c(%rsp),%ecx
mov    %ecx,%r13d
mov    0x48(%rsp),%ecx
cmp    %ecx,0xc(%rsp)
je     1320 <reflect1+0x210>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r11d,%ecx
neg    %ecx
cmovs  %r11d,%ecx
add    %r10d,%ecx
movsd  (%r15,%rcx,8),%xmm0
mov    %r13d,%ecx
neg    %ecx
cmovs  %r13d,%ecx
add    %r8d,%ecx
addsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
lea    -0x1(%r13),%ecx
lea    -0x1(%r11),%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
add    %r10d,%esi
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
movsd  (%r15,%rsi,8),%xmm0
add    %r8d,%edx
addsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
add    $0xfffffffe,%r13d
add    $0xfffffffe,%r11d
cmp    %ebx,%r11d
jg     1400 <reflect1+0x2f0>
jmp    1320 <reflect1+0x210>
cmpl   $0x0,0x80(%rsp)
mov    0x20(%rsp),%r11d
je     1665 <reflect1+0x555>
mov    0x64(%rsp),%ecx
mov    %ecx,%eax
shr    $0x1f,%eax
add    %ecx,%eax
sar    %eax
imul   %edi,%eax
cmp    %eax,0x1c(%rsp)
je     1665 <reflect1+0x555>
add    %eax,%eax
mov    %r11d,%ebx
sub    %eax,%ebx
add    0x1c(%rsp),%ebx
cmp    0x24(%rsp),%ebx
jle    1665 <reflect1+0x555>
cmpl   $0x0,0x78(%rsp)
sete   %al
mov    0x10(%rsp),%rdx
mov    %edx,%r8d
sub    %edi,%r8d
mov    0x28(%rsp),%r10
mov    0x70(%rsp),%rsi
cmp    %esi,%r10d
sete   %r13b
lea    (%r10,%rdx,1),%ebp
sub    %esi,%ebp
sub    %esi,%ebp
cmp    %r8d,%ebp
setle  %cl
or     %al,%r13b
or     %cl,%r13b
mov    %ebp,%eax
neg    %eax
cmovs  %ebp,%eax
mov    %rax,0x50(%rsp)
lea    (%r10,%rdi,1),%r9d
mov    %edx,%eax
neg    %eax
cmovs  %edx,%eax
mov    %rax,0x48(%rsp)
lea    0x1(%rsi,%rsi,1),%eax
mov    %eax,0xc(%rsp)
lea    -0x1(%rdx),%eax
mov    %eax,0x40(%rsp)
mov    %rbp,0x58(%rsp)
lea    -0x1(%rbp),%eax
mov    %eax,0x38(%rsp)
neg    %r10d
jmp    1537 <reflect1+0x427>
mov    0x30(%rsp),%rdi
sub    %edi,%ebx
mov    %ebp,%r11d
sub    %edi,%r11d
cmp    0x24(%rsp),%ebx
jle    1665 <reflect1+0x555>
cmp    %edi,0x28(%rsp)
jge    1597 <reflect1+0x487>
mov    %ebx,%eax
neg    %eax
cmovs  %ebx,%eax
mov    %r11d,%ecx
neg    %ecx
cmovs  %r11d,%ecx
mov    0x10(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r10,%rsi,1),%ebp
mov    %ebp,%edi
neg    %edi
cmovs  %ebp,%edi
add    %eax,%edi
mov    %esi,%edx
neg    %edx
cmovs  %esi,%edx
movsd  (%r15,%rdi,8),%xmm0
add    %ecx,%edx
addsd  (%r14,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
lea    (%r10,%rsi,1),%edx
add    $0xffffffff,%edx
add    $0xffffffff,%esi
cmp    %r8d,%edx
jg     1560 <reflect1+0x450>
mov    %r11d,%ebp
test   %r13b,%r13b
jne    1520 <reflect1+0x410>
mov    %ebx,%eax
neg    %eax
cmovs  %ebx,%eax
mov    %ebp,%ecx
mov    %ebp,%r11d
neg    %r11d
cmovs  %ebp,%r11d
mov    0x58(%rsp),%r12
mov    0x10(%rsp),%rdx
test   $0x1,%r9b
je     15f0 <reflect1+0x4e0>
mov    0x50(%rsp),%rcx
add    %eax,%ecx
movsd  (%r15,%rcx,8),%xmm0
mov    0x48(%rsp),%rcx
add    %r11d,%ecx
addsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
mov    0x38(%rsp),%ecx
mov    %ecx,%r12d
mov    0x40(%rsp),%ecx
mov    %ecx,%edx
cmp    0xc(%rsp),%r9d
je     1520 <reflect1+0x410>
nopl   0x0(%rax,%rax,1)
mov    %r12d,%ecx
neg    %ecx
cmovs  %r12d,%ecx
add    %eax,%ecx
movsd  (%r15,%rcx,8),%xmm0
mov    %edx,%ecx
neg    %ecx
cmovs  %edx,%ecx
add    %r11d,%ecx
addsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%r14,%rcx,8)
lea    -0x1(%rdx),%ecx
lea    -0x1(%r12),%esi
mov    %esi,%edi
neg    %edi
cmovs  %esi,%edi
add    %eax,%edi
mov    %ecx,%esi
neg    %esi
cmovs  %ecx,%esi
movsd  (%r15,%rdi,8),%xmm0
add    %r11d,%esi
addsd  (%r14,%rsi,8),%xmm0
movsd  %xmm0,(%r14,%rsi,8)
add    $0xfffffffe,%edx
add    $0xfffffffe,%r12d
cmp    %r8d,%r12d
jg     1600 <reflect1+0x4f0>
jmp    1520 <reflect1+0x410>
xor    %eax,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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