int Extend(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, y_tmp, x_tmp;
  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 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));
  int i;
  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_filt < filt_sz;
         y_filt += x_dim, y_res += x_dim)
      if ((y_res >= 0) && (y_res < filt_sz))
        for (x_filt = y_filt, x_res = x_overhang; x_filt < y_filt + x_dim;
             x_filt++, x_res++)
          if ((x_res >= 0) && (x_res < x_dim))
            result[y_res + x_res] += filt[x_filt];
          else {
            result[y_res + (((x_base - (((x_res - x_base) >= 0)
                                            ? (x_res - x_base)
                                            : (-(x_res - x_base)))) >= 0)
                                ? (x_base - (((x_res - x_base) >= 0)
                                                 ? (x_res - x_base)
                                                 : (-(x_res - x_base))))
                                : (-(x_base - (((x_res - x_base) >= 0)
                                                   ? (x_res - x_base)
                                                   : (-(x_res - x_base))))))] -=
                filt[x_filt];
            result[y_res + x_base] += 2 * filt[x_filt];
          }
      else
        for (x_filt = y_filt, x_res = x_overhang; x_filt < y_filt + x_dim;
             x_filt++, x_res++)
          if ((x_res >= 0) && (x_res < x_dim)) {
            result[(((y_base - (((y_res - y_base) >= 0)
                                    ? (y_res - y_base)
                                    : (-(y_res - y_base)))) >= 0)
                        ? (y_base - (((y_res - y_base) >= 0)
                                         ? (y_res - y_base)
                                         : (-(y_res - y_base))))
                        : (-(y_base - (((y_res - y_base) >= 0)
                                           ? (y_res - y_base)
                                           : (-(y_res - y_base)))))) +
                   x_res] -= filt[x_filt];
            result[y_base + x_res] += 2 * filt[x_filt];
          } else {
            result[(((y_base - (((y_res - y_base) >= 0)
                                    ? (y_res - y_base)
                                    : (-(y_res - y_base)))) >= 0)
                        ? (y_base - (((y_res - y_base) >= 0)
                                         ? (y_res - y_base)
                                         : (-(y_res - y_base))))
                        : (-(y_base - (((y_res - y_base) >= 0)
                                           ? (y_res - y_base)
                                           : (-(y_res - y_base)))))) +
                   (((x_base - (((x_res - x_base) >= 0)
                                    ? (x_res - x_base)
                                    : (-(x_res - x_base)))) >= 0)
                        ? (x_base - (((x_res - x_base) >= 0)
                                         ? (x_res - x_base)
                                         : (-(x_res - x_base))))
                        : (-(x_base - (((x_res - x_base) >= 0)
                                           ? (x_res - x_base)
                                           : (-(x_res - x_base))))))] -=
                filt[x_filt];
            result[y_base + x_base] += 2 * 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_pos != 0)
        if (x_overhang != mx_pos)
          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)))];
        else
          for (x_res = x_base, x_filt = x_base - 2 * mx_pos + x_overhang - 1;
               x_filt > x_base - x_dim; x_res--, x_filt--)
            for (x_tmp = x_filt; x_tmp > x_base - x_dim; x_tmp--)
              result[(((y_res) >= 0) ? (y_res) : (-(y_res))) +
                     (((x_res) >= 0) ? (x_res) : (-(x_res)))] +=
                  2 * filt[(((y_filt) >= 0) ? (y_filt) : (-(y_filt))) +
                           (((x_tmp) >= 0) ? (x_tmp) : (-(x_tmp)))];
    }
    if (y_pos != 0)
      if (y_overhang != my_pos)
        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_pos != 0) && (x_overhang != mx_pos))
            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)))];
        }
      else
        for (y_res = y_base, y_filt = y_base - 2 * my_pos + y_overhang - x_dim;
             y_filt > y_base - filt_sz; y_res -= x_dim, y_filt -= x_dim)
          for (y_tmp = y_filt; y_tmp > y_base - filt_sz; y_tmp -= 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)))] +=
                  2 * filt[(((y_tmp) >= 0) ? (y_tmp) : (-(y_tmp))) +
                           (((x_filt) >= 0) ? (x_filt) : (-(x_filt)))];
            if ((x_pos != 0) && (x_overhang == mx_pos))
              for (x_res = x_base,
                  x_filt = x_base - 2 * mx_pos + x_overhang - 1;
                   x_filt > x_base - x_dim; x_res--, x_filt--)
                for (x_tmp = x_filt; x_tmp > x_base - x_dim; x_tmp--)
                  result[(((y_res) >= 0) ? (y_res) : (-(y_res))) +
                         (((x_res) >= 0) ? (x_res) : (-(x_res)))] +=
                      2 * filt[(((y_tmp) >= 0) ? (y_tmp) : (-(y_tmp))) +
                               (((x_tmp) >= 0) ? (x_tmp) : (-(x_tmp)))];
          }
  }
  return (0);
}


x86 assembly (clang, -O0):
<Extend>:
push   %rbp
mov    %rsp,%rbp
sub    $0x248,%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 <Extend+0x45>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    114f <Extend+0x4f>
xor    %eax,%eax
mov    %eax,-0x5c(%rbp)
jmp    114f <Extend+0x4f>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    1173 <Extend+0x73>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    117d <Extend+0x7d>
xor    %eax,%eax
mov    %eax,-0x64(%rbp)
jmp    117d <Extend+0x7d>
mov    -0x60(%rbp),%eax
mov    -0x64(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    11a1 <Extend+0xa1>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    11c9 <Extend+0xc9>
cmpl   $0x0,-0x14(%rbp)
jge    11b9 <Extend+0xb9>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    11c3 <Extend+0xc3>
xor    %eax,%eax
mov    %eax,-0x6c(%rbp)
jmp    11c3 <Extend+0xc3>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x70(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    11ed <Extend+0xed>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1215 <Extend+0x115>
cmpl   $0x0,-0x18(%rbp)
jge    1205 <Extend+0x105>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    120f <Extend+0x10f>
xor    %eax,%eax
mov    %eax,-0x78(%rbp)
jmp    120f <Extend+0x10f>
mov    -0x78(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x74(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x14(%rbp)
jge    123e <Extend+0x13e>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x7c(%rbp)
jmp    124f <Extend+0x14f>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x80(%rbp)
cmpl   $0x0,-0x18(%rbp)
jge    127b <Extend+0x17b>
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x84(%rbp)
jmp    128f <Extend+0x18f>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x84(%rbp)
mov    -0x80(%rbp),%eax
mov    -0x84(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12cf <Extend+0x1cf>
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12a5 <Extend+0x1a5>
cmpl   $0x0,0x10(%rbp)
jne    1949 <Extend+0x849>
movl   $0x0,-0x28(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1944 <Extend+0x844>
cmpl   $0x0,-0x30(%rbp)
jl     14fb <Extend+0x3fb>
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14fb <Extend+0x3fb>
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    14f6 <Extend+0x3f6>
cmpl   $0x0,-0x34(%rbp)
jl     1364 <Extend+0x264>
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1364 <Extend+0x264>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    14da <Extend+0x3da>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
cmp    $0x0,%eax
jl     13b6 <Extend+0x2b6>
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    13c6 <Extend+0x2c6>
mov    -0x34(%rbp),%ecx
sub    -0x40(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x88(%rbp),%eax
mov    -0xa4(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jl     142f <Extend+0x32f>
mov    -0x40(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
cmp    $0x0,%eax
jl     1406 <Extend+0x306>
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0xac(%rbp)
jmp    1416 <Extend+0x316>
mov    -0x34(%rbp),%ecx
sub    -0x40(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0xa8(%rbp),%eax
mov    -0xac(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0xb0(%rbp)
jmp    1480 <Extend+0x380>
mov    -0x40(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
cmp    $0x0,%eax
jl     1458 <Extend+0x358>
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0xb8(%rbp)
jmp    1468 <Extend+0x368>
mov    -0x34(%rbp),%ecx
sub    -0x40(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb4(%rbp),%ecx
mov    -0xb8(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x98(%rbp),%rax
movsd  -0xa0(%rbp),%xmm1
ff
mov    -0x8c(%rbp),%ecx
mov    -0xb0(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    14df <Extend+0x3df>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1314 <Extend+0x214>
jmp    1928 <Extend+0x828>
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    1923 <Extend+0x823>
cmpl   $0x0,-0x34(%rbp)
jl     169b <Extend+0x59b>
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    169b <Extend+0x59b>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
cmp    $0x0,%eax
jl     1577 <Extend+0x477>
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    1587 <Extend+0x487>
mov    -0x30(%rbp),%ecx
sub    -0x44(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xd4(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0xd4(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jl     15f0 <Extend+0x4f0>
mov    -0x44(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
cmp    $0x0,%eax
jl     15c7 <Extend+0x4c7>
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0xdc(%rbp)
jmp    15d7 <Extend+0x4d7>
mov    -0x30(%rbp),%ecx
sub    -0x44(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xdc(%rbp)
mov    -0xd8(%rbp),%eax
mov    -0xdc(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0xe0(%rbp)
jmp    1641 <Extend+0x541>
mov    -0x44(%rbp),%eax
mov    %eax,-0xe4(%rbp)
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
cmp    $0x0,%eax
jl     1619 <Extend+0x519>
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0xe8(%rbp)
jmp    1629 <Extend+0x529>
mov    -0x30(%rbp),%ecx
sub    -0x44(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe4(%rbp),%ecx
mov    -0xe8(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xe0(%rbp)
mov    -0xc8(%rbp),%rax
movsd  -0xd0(%rbp),%xmm1
ff
mov    -0xe0(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1907 <Extend+0x807>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
cmp    $0x0,%eax
jl     16e4 <Extend+0x5e4>
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x104(%rbp)
jmp    16f4 <Extend+0x5f4>
mov    -0x30(%rbp),%ecx
sub    -0x44(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x104(%rbp)
mov    -0xec(%rbp),%eax
mov    -0x104(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jl     175d <Extend+0x65d>
mov    -0x44(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
cmp    $0x0,%eax
jl     1734 <Extend+0x634>
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x10c(%rbp)
jmp    1744 <Extend+0x644>
mov    -0x30(%rbp),%ecx
sub    -0x44(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x10c(%rbp)
mov    -0x108(%rbp),%eax
mov    -0x10c(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x110(%rbp)
jmp    17ae <Extend+0x6ae>
mov    -0x44(%rbp),%eax
mov    %eax,-0x114(%rbp)
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
cmp    $0x0,%eax
jl     1786 <Extend+0x686>
mov    -0x30(%rbp),%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x118(%rbp)
jmp    1796 <Extend+0x696>
mov    -0x30(%rbp),%ecx
sub    -0x44(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x118(%rbp)
mov    -0x114(%rbp),%ecx
mov    -0x118(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x110(%rbp)
mov    -0x110(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
cmp    $0x0,%eax
jl     17e3 <Extend+0x6e3>
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x124(%rbp)
jmp    17f3 <Extend+0x6f3>
mov    -0x34(%rbp),%ecx
sub    -0x40(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x124(%rbp)
mov    -0x11c(%rbp),%eax
mov    -0x124(%rbp),%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jl     185c <Extend+0x75c>
mov    -0x40(%rbp),%eax
mov    %eax,-0x128(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
cmp    $0x0,%eax
jl     1833 <Extend+0x733>
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x12c(%rbp)
jmp    1843 <Extend+0x743>
mov    -0x34(%rbp),%ecx
sub    -0x40(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x12c(%rbp)
mov    -0x128(%rbp),%eax
mov    -0x12c(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x130(%rbp)
jmp    18ad <Extend+0x7ad>
mov    -0x40(%rbp),%eax
mov    %eax,-0x134(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
cmp    $0x0,%eax
jl     1885 <Extend+0x785>
mov    -0x34(%rbp),%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x138(%rbp)
jmp    1895 <Extend+0x795>
mov    -0x34(%rbp),%ecx
sub    -0x40(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x138(%rbp)
mov    -0x134(%rbp),%ecx
mov    -0x138(%rbp),%eax
sub    %eax,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x130(%rbp)
mov    -0xf8(%rbp),%rax
movsd  -0x100(%rbp),%xmm1
ff
mov    -0x120(%rbp),%ecx
mov    -0x130(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    190c <Extend+0x80c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1507 <Extend+0x407>
jmp    1928 <Extend+0x828>
jmp    192d <Extend+0x82d>
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    12e6 <Extend+0x1e6>
jmp    2483 <Extend+0x1383>
cmpl   $0x0,-0x4c(%rbp)
jl     1961 <Extend+0x861>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x13c(%rbp)
jmp    196c <Extend+0x86c>
xor    %eax,%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x48(%rbp)
jl     198d <Extend+0x88d>
mov    -0x48(%rbp),%eax
mov    %eax,-0x140(%rbp)
jmp    1998 <Extend+0x898>
xor    %eax,%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x140(%rbp)
mov    -0x140(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jle    1e0f <Extend+0xd0f>
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    1b01 <Extend+0xa01>
mov    -0x8(%rbp),%rax
mov    %rax,-0x148(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1a04 <Extend+0x904>
mov    -0x28(%rbp),%eax
mov    %eax,-0x14c(%rbp)
jmp    1a0f <Extend+0x90f>
xor    %eax,%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
mov    %eax,-0x150(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1a33 <Extend+0x933>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x154(%rbp)
jmp    1a3e <Extend+0x93e>
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     1a86 <Extend+0x986>
mov    -0x30(%rbp),%eax
mov    %eax,-0x16c(%rbp)
jmp    1a91 <Extend+0x991>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
mov    %eax,-0x170(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1ab5 <Extend+0x9b5>
mov    -0x34(%rbp),%eax
mov    %eax,-0x174(%rbp)
jmp    1ac0 <Extend+0x9c0>
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    19d0 <Extend+0x8d0>
cmpl   $0x0,-0x14(%rbp)
je     1def <Extend+0xcef>
mov    -0x48(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     1c68 <Extend+0xb68>
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    1c63 <Extend+0xb63>
mov    -0x8(%rbp),%rax
mov    %rax,-0x180(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1b62 <Extend+0xa62>
mov    -0x28(%rbp),%eax
mov    %eax,-0x184(%rbp)
jmp    1b6d <Extend+0xa6d>
xor    %eax,%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x184(%rbp)
mov    -0x184(%rbp),%eax
mov    %eax,-0x188(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1b91 <Extend+0xa91>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x18c(%rbp)
jmp    1b9c <Extend+0xa9c>
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     1be4 <Extend+0xae4>
mov    -0x30(%rbp),%eax
mov    %eax,-0x1a4(%rbp)
jmp    1bef <Extend+0xaef>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x1a4(%rbp)
mov    -0x1a4(%rbp),%eax
mov    %eax,-0x1a8(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1c13 <Extend+0xb13>
mov    -0x34(%rbp),%eax
mov    %eax,-0x1ac(%rbp)
jmp    1c1e <Extend+0xb1e>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x1ac(%rbp)
mov    -0x198(%rbp),%rax
movsd  -0x1a0(%rbp),%xmm1
ff
mov    -0x1a8(%rbp),%ecx
mov    -0x1ac(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%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    1b2e <Extend+0xa2e>
jmp    1dea <Extend+0xcea>
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
add    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    1de5 <Extend+0xce5>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    1dc9 <Extend+0xcc9>
mov    -0x8(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1ccd <Extend+0xbcd>
mov    -0x28(%rbp),%eax
mov    %eax,-0x1bc(%rbp)
jmp    1cd8 <Extend+0xbd8>
xor    %eax,%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x1bc(%rbp)
mov    -0x1bc(%rbp),%eax
mov    %eax,-0x1c0(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     1cfc <Extend+0xbfc>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x1c4(%rbp)
jmp    1d07 <Extend+0xc07>
xor    %eax,%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x1c4(%rbp)
mov    -0x1b8(%rbp),%rax
mov    -0x1c0(%rbp),%ecx
mov    -0x1c4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     1d4f <Extend+0xc4f>
mov    -0x30(%rbp),%eax
mov    %eax,-0x1dc(%rbp)
jmp    1d5a <Extend+0xc5a>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x1dc(%rbp)
mov    -0x1dc(%rbp),%eax
mov    %eax,-0x1e0(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1d7e <Extend+0xc7e>
mov    -0x34(%rbp),%eax
mov    %eax,-0x1e4(%rbp)
jmp    1d89 <Extend+0xc89>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x1e4(%rbp)
mov    -0x1d0(%rbp),%rax
movsd  -0x1d8(%rbp),%xmm0
ff
mov    -0x1e0(%rbp),%ecx
mov    -0x1e4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1c99 <Extend+0xb99>
jmp    1dce <Extend+0xcce>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1c82 <Extend+0xb82>
jmp    1dea <Extend+0xcea>
jmp    1def <Extend+0xcef>
jmp    1df4 <Extend+0xcf4>
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    19b0 <Extend+0x8b0>
cmpl   $0x0,-0x18(%rbp)
je     247e <Extend+0x137e>
mov    -0x4c(%rbp),%eax
cmp    -0x54(%rbp),%eax
je     211d <Extend+0x101d>
mov    -0x44(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jle    2118 <Extend+0x1018>
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    1f91 <Extend+0xe91>
mov    -0x8(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1e90 <Extend+0xd90>
mov    -0x28(%rbp),%eax
mov    %eax,-0x1f4(%rbp)
jmp    1e9b <Extend+0xd9b>
xor    %eax,%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x1f4(%rbp)
mov    -0x1f4(%rbp),%eax
mov    %eax,-0x1f8(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1ebf <Extend+0xdbf>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x1fc(%rbp)
jmp    1eca <Extend+0xdca>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x1fc(%rbp)
mov    -0x1f0(%rbp),%rax
mov    -0x1f8(%rbp),%ecx
mov    -0x1fc(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0x208(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     1f12 <Extend+0xe12>
mov    -0x30(%rbp),%eax
mov    %eax,-0x214(%rbp)
jmp    1f1d <Extend+0xe1d>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x214(%rbp)
mov    -0x214(%rbp),%eax
mov    %eax,-0x218(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1f41 <Extend+0xe41>
mov    -0x34(%rbp),%eax
mov    %eax,-0x21c(%rbp)
jmp    1f4c <Extend+0xe4c>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x21c(%rbp)
mov    -0x208(%rbp),%rax
movsd  -0x210(%rbp),%xmm1
ff
mov    -0x218(%rbp),%ecx
mov    -0x21c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%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    1e5c <Extend+0xd5c>
cmpl   $0x0,-0x14(%rbp)
je     20f8 <Extend+0xff8>
mov    -0x48(%rbp),%eax
cmp    -0x50(%rbp),%eax
je     20f8 <Extend+0xff8>
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    20f3 <Extend+0xff3>
mov    -0x8(%rbp),%rax
mov    %rax,-0x228(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1ff2 <Extend+0xef2>
mov    -0x28(%rbp),%eax
mov    %eax,-0x22c(%rbp)
jmp    1ffd <Extend+0xefd>
xor    %eax,%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x22c(%rbp)
mov    -0x22c(%rbp),%eax
mov    %eax,-0x230(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     2021 <Extend+0xf21>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x234(%rbp)
jmp    202c <Extend+0xf2c>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x234(%rbp)
mov    -0x228(%rbp),%rax
mov    -0x230(%rbp),%ecx
mov    -0x234(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0x240(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     2074 <Extend+0xf74>
mov    -0x30(%rbp),%eax
mov    %eax,-0x24c(%rbp)
jmp    207f <Extend+0xf7f>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x24c(%rbp)
mov    -0x24c(%rbp),%eax
mov    %eax,-0x250(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     20a3 <Extend+0xfa3>
mov    -0x34(%rbp),%eax
mov    %eax,-0x254(%rbp)
jmp    20ae <Extend+0xfae>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x254(%rbp)
mov    -0x240(%rbp),%rax
movsd  -0x248(%rbp),%xmm1
ff
mov    -0x250(%rbp),%ecx
mov    -0x254(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%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    1fbe <Extend+0xebe>
jmp    20f8 <Extend+0xff8>
jmp    20fd <Extend+0xffd>
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    1e3c <Extend+0xd3c>
jmp    2479 <Extend+0x1379>
mov    -0x44(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
add    -0x4c(%rbp),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jle    2474 <Extend+0x1374>
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x44(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jle    2454 <Extend+0x1354>
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    22a7 <Extend+0x11a7>
mov    -0x8(%rbp),%rax
mov    %rax,-0x260(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     21a2 <Extend+0x10a2>
mov    -0x38(%rbp),%eax
mov    %eax,-0x264(%rbp)
jmp    21ad <Extend+0x10ad>
xor    %eax,%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x264(%rbp)
mov    -0x264(%rbp),%eax
mov    %eax,-0x268(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     21d1 <Extend+0x10d1>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x26c(%rbp)
jmp    21dc <Extend+0x10dc>
xor    %eax,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x26c(%rbp)
mov    -0x260(%rbp),%rax
mov    -0x268(%rbp),%ecx
mov    -0x26c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x280(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x278(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     2224 <Extend+0x1124>
mov    -0x30(%rbp),%eax
mov    %eax,-0x284(%rbp)
jmp    222f <Extend+0x112f>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x284(%rbp)
mov    -0x284(%rbp),%eax
mov    %eax,-0x288(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     2253 <Extend+0x1153>
mov    -0x34(%rbp),%eax
mov    %eax,-0x28c(%rbp)
jmp    225e <Extend+0x115e>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x28c(%rbp)
mov    -0x278(%rbp),%rax
movsd  -0x280(%rbp),%xmm0
ff
mov    -0x288(%rbp),%ecx
mov    -0x28c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%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    216e <Extend+0x106e>
cmpl   $0x0,-0x14(%rbp)
je     243f <Extend+0x133f>
mov    -0x48(%rbp),%eax
cmp    -0x50(%rbp),%eax
jne    243f <Extend+0x133f>
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x50(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
add    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    243a <Extend+0x133a>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    -0xc(%rbp),%ecx
cmp    %ecx,%eax
jle    241e <Extend+0x131e>
mov    -0x8(%rbp),%rax
mov    %rax,-0x298(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     2322 <Extend+0x1222>
mov    -0x38(%rbp),%eax
mov    %eax,-0x29c(%rbp)
jmp    232d <Extend+0x122d>
xor    %eax,%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x29c(%rbp)
mov    -0x29c(%rbp),%eax
mov    %eax,-0x2a0(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     2351 <Extend+0x1251>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x2a4(%rbp)
jmp    235c <Extend+0x125c>
xor    %eax,%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x2a4(%rbp)
mov    -0x298(%rbp),%rax
mov    -0x2a0(%rbp),%ecx
mov    -0x2a4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    %rax,-0x2b0(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     23a4 <Extend+0x12a4>
mov    -0x30(%rbp),%eax
mov    %eax,-0x2bc(%rbp)
jmp    23af <Extend+0x12af>
xor    %eax,%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x2bc(%rbp)
mov    -0x2bc(%rbp),%eax
mov    %eax,-0x2c0(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     23d3 <Extend+0x12d3>
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c4(%rbp)
jmp    23de <Extend+0x12de>
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x2c4(%rbp)
mov    -0x2b0(%rbp),%rax
movsd  -0x2b8(%rbp),%xmm0
ff
mov    -0x2c0(%rbp),%ecx
mov    -0x2c4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    22ee <Extend+0x11ee>
jmp    2423 <Extend+0x1323>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    22d7 <Extend+0x11d7>
jmp    243f <Extend+0x133f>
jmp    2444 <Extend+0x1344>
mov    -0xc(%rbp),%ecx
mov    -0x38(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
jmp    214e <Extend+0x104e>
jmp    2459 <Extend+0x1359>
mov    -0xc(%rbp),%ecx
mov    -0x30(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
jmp    2137 <Extend+0x1037>
jmp    2479 <Extend+0x1379>
jmp    247e <Extend+0x137e>
jmp    2483 <Extend+0x1383>
xor    %eax,%eax
add    $0x248,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Extend>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r8d,%r14d
mov    %edx,%r8d
lea    -0x1(%r8),%edx
lea    0x1(%r14),%ebp
test   %r14d,%r14d
mov    %edx,%eax
cmovs  %r8d,%eax
mov    %eax,0x5c(%rsp)
xor    %r12d,%r12d
mov    %r14d,%eax
sub    $0x1,%eax
cmovb  %r12d,%ebp
cmovl  %r12d,%edx
mov    %r9,%rbx
mov    %rdi,%r15
mov    %rsi,%rdi
cmovge %eax,%ebp
imul   %edi,%r8d
lea    -0x1(%rsi),%r13d
imul   %edi,%edx
mov    %rdx,0x8(%rsp)
lea    0x1(%rcx),%edx
mov    %ecx,%eax
sub    $0x1,%eax
cmovb  %r12d,%edx
imul   %edi,%ebp
mov    %rcx,0x20(%rsp)
test   %ecx,%ecx
cmovg  %r13d,%r12d
cmovg  %eax,%edx
mov    %edx,0x10(%rsp)
cmovs  %edi,%r13d
test   %r8d,%r8d
mov    %rsi,0x50(%rsp)
jle    13b4 <Extend+0x2a4>
mov    %r8d,%edx
shl    $0x3,%rdx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r8,0x18(%rsp)
call   1030 <memset@plt>
mov    0x18(%rsp),%r8
mov    0x50(%rsp),%rdi
cmpl   $0x0,0xb0(%rsp)
jne    13c2 <Extend+0x2b2>
mov    0x8(%rsp),%rcx
lea    (%rcx,%r12,1),%eax
cltq
mov    %rax,0x28(%rsp)
movslq %edi,%r14
mov    0x10(%rsp),%eax
movslq %eax,%rdx
mov    %rdx,0x38(%rsp)
movslq %ecx,%rcx
mov    %rcx,0x30(%rsp)
movslq %r12d,%rcx
mov    %rcx,0x48(%rsp)
movslq %r8d,%rcx
mov    %rcx,0x20(%rsp)
movslq %ebp,%r9
sub    %r12d,%eax
mov    %eax,0x10(%rsp)
lea    (%rbx,%r9,8),%r10
lea    0x0(,%r14,8),%rax
mov    %rax,0x18(%rsp)
xor    %r8d,%r8d
jmp    1238 <Extend+0x128>
xchg   %ax,%ax
add    %r14,%r9
add    0x18(%rsp),%r10
cmp    0x20(%rsp),%r8
mov    0x50(%rsp),%rdi
jge    19bd <Extend+0x8ad>
mov    %r8,%rbp
add    %r14,%r8
test   %r9,%r9
js     12f0 <Extend+0x1e0>
cmp    0x20(%rsp),%r9
jge    12f0 <Extend+0x1e0>
test   %edi,%edi
jle    1220 <Extend+0x110>
mov    0x48(%rsp),%rax
lea    (%r9,%rax,1),%r11
mov    0x10(%rsp),%edx
mov    0x38(%rsp),%rdi
jmp    12c3 <Extend+0x1b3>
nopw   0x0(%rax,%rax,1)
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
mov    %r12d,%ecx
sub    %esi,%ecx
neg    %ecx
mov    %r12d,%eax
sub    %esi,%eax
cmovl  %ecx,%eax
cltq
add    %r9,%rax
movsd  (%rbx,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  (%r15,%rbp,8),%xmm0
addsd  %xmm0,%xmm0
addsd  (%rbx,%r11,8),%xmm0
movsd  %xmm0,(%rbx,%r11,8)
add    $0x1,%rbp
add    $0x1,%rdi
add    $0x1,%edx
cmp    %r8,%rbp
jge    1220 <Extend+0x110>
movsd  (%r15,%rbp,8),%xmm0
test   %rdi,%rdi
js     1270 <Extend+0x160>
cmp    %r14,%rdi
jge    1270 <Extend+0x160>
addsd  (%r10,%rdi,8),%xmm0
movsd  %xmm0,(%r10,%rdi,8)
jmp    12af <Extend+0x19f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %edi,%edi
jle    1220 <Extend+0x110>
mov    %r9d,%eax
mov    0x8(%rsp),%rcx
sub    %ecx,%eax
mov    %eax,%esi
neg    %esi
cmovs  %eax,%esi
mov    %ecx,%edi
sub    %esi,%edi
neg    %edi
mov    %ecx,%eax
sub    %esi,%eax
cmovl  %edi,%eax
movslq %eax,%rsi
lea    (%rbx,%rsi,8),%rsi
mov    0x10(%rsp),%r13d
mov    0x38(%rsp),%r11
jmp    1389 <Extend+0x279>
nopl   0x0(%rax)
mov    %r13d,%ecx
neg    %ecx
cmovs  %r13d,%ecx
mov    %r12d,%edx
sub    %ecx,%edx
neg    %edx
mov    %r12d,%edi
sub    %ecx,%edi
cmovl  %edx,%edi
add    %eax,%edi
movslq %edi,%rcx
movsd  (%rbx,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
mov    0x28(%rsp),%rdi
movsd  (%r15,%rbp,8),%xmm0
addsd  %xmm0,%xmm0
addsd  (%rbx,%rdi,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
add    $0x1,%rbp
add    $0x1,%r11
add    $0x1,%r13d
cmp    %r8,%rbp
jge    1220 <Extend+0x110>
movsd  (%r15,%rbp,8),%xmm0
test   %r11,%r11
js     1330 <Extend+0x220>
cmp    %r14,%r11
jge    1330 <Extend+0x220>
movsd  (%rsi,%r11,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%r11,8)
mov    0x30(%rsp),%rcx
lea    (%rcx,%r11,1),%rdi
jmp    1360 <Extend+0x250>
cmpl   $0x0,0xb0(%rsp)
je     19bd <Extend+0x8ad>
mov    %r14,0x70(%rsp)
mov    %r13d,%eax
shr    $0x1f,%eax
add    %r13d,%eax
sar    %eax
mov    %rax,0x18(%rsp)
mov    %ebp,%r9d
neg    %r9d
cmovs  %ebp,%r9d
mov    0x10(%rsp),%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
mov    %rax,0x28(%rsp)
mov    0x8(%rsp),%rax
sub    %r8d,%eax
mov    %eax,0x30(%rsp)
cmp    %r9d,%r8d
jle    165d <Extend+0x54d>
mov    0x8(%rsp),%rcx
mov    %ecx,%r13d
sub    %r9d,%r13d
mov    %r12d,%ebp
sub    %edi,%ebp
mov    0x28(%rsp),%r11
lea    (%r11,%r12,1),%esi
mov    0x18(%rsp),%rdx
sub    %edx,%esi
sub    %edx,%esi
lea    -0x1(%rsi),%eax
mov    %eax,0x10(%rsp)
lea    (%r11,%rdi,1),%eax
mov    %eax,0x48(%rsp)
lea    (%rdx,%rdx,1),%eax
add    $0x1,%eax
mov    %eax,0x44(%rsp)
mov    %esi,%eax
neg    %eax
mov    %rsi,0x38(%rsp)
cmovs  %esi,%eax
mov    %rax,0x68(%rsp)
mov    %r12d,%eax
neg    %eax
cmovs  %r12d,%eax
mov    %rax,0x60(%rsp)
lea    -0x1(%r12),%eax
mov    %eax,0x58(%rsp)
neg    %r11d
mov    %ecx,%r10d
jmp    1496 <Extend+0x386>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rdi
sub    %edi,%r13d
sub    %edi,%r10d
cmp    0x30(%rsp),%r13d
jle    165d <Extend+0x54d>
cmp    %edi,0x28(%rsp)
jge    14f4 <Extend+0x3e4>
mov    %r13d,%ecx
neg    %ecx
cmovs  %r13d,%ecx
mov    %r10d,%edx
neg    %edx
cmovs  %r10d,%edx
mov    %r12d,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r11,%rsi,1),%eax
mov    %eax,%edi
neg    %edi
cmovs  %eax,%edi
add    %ecx,%edi
mov    %esi,%eax
neg    %eax
cmovs  %esi,%eax
movsd  (%r15,%rdi,8),%xmm0
add    %edx,%eax
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
lea    (%r11,%rsi,1),%eax
add    $0xffffffff,%eax
add    $0xffffffff,%esi
cmp    %ebp,%eax
jg     14c0 <Extend+0x3b0>
cmpl   $0x0,0x20(%rsp)
je     1480 <Extend+0x370>
mov    0x28(%rsp),%rax
cmp    0x18(%rsp),%eax
jne    1590 <Extend+0x480>
cmp    %ebp,0x10(%rsp)
jle    1480 <Extend+0x370>
mov    %r13d,%ecx
neg    %ecx
cmovs  %r13d,%ecx
mov    %r10d,%r8d
neg    %r8d
cmovs  %r10d,%r8d
mov    0x10(%rsp),%r14d
mov    %r12d,%edi
nop
mov    %edi,%edx
neg    %edx
cmovs  %edi,%edx
add    %r8d,%edx
movsd  (%rbx,%rdx,8),%xmm0
mov    %r14d,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %esi,%eax
neg    %eax
cmovs  %esi,%eax
add    %ecx,%eax
movsd  (%r15,%rax,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0xffffffff,%esi
cmp    %ebp,%esi
jg     1550 <Extend+0x440>
add    $0xffffffff,%edi
add    $0xffffffff,%r14d
cmp    %ebp,%r14d
jg     1530 <Extend+0x420>
jmp    1480 <Extend+0x370>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %ebp,0x38(%rsp)
jle    1480 <Extend+0x370>
mov    %r13d,%r14d
neg    %r14d
cmovs  %r13d,%r14d
mov    %r10d,%r8d
neg    %r8d
cmovs  %r10d,%r8d
mov    0x38(%rsp),%rsi
mov    %r12d,%ecx
mov    0x48(%rsp),%edx
test   $0x1,%dl
je     15eb <Extend+0x4db>
mov    0x68(%rsp),%rax
add    %r14d,%eax
mov    0x60(%rsp),%rcx
add    %r8d,%ecx
movsd  (%rbx,%rcx,8),%xmm0
subsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
mov    0x10(%rsp),%eax
mov    %eax,%esi
mov    0x58(%rsp),%eax
mov    %eax,%ecx
cmp    0x44(%rsp),%edx
je     1480 <Extend+0x370>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %esi,%eax
neg    %eax
cmovs  %esi,%eax
add    %r14d,%eax
mov    %ecx,%edi
neg    %edi
cmovs  %ecx,%edi
add    %r8d,%edi
movsd  (%rbx,%rdi,8),%xmm0
subsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
lea    -0x1(%rcx),%eax
lea    -0x1(%rsi),%edi
mov    %edi,%edx
neg    %edx
cmovs  %edi,%edx
add    %r14d,%edx
mov    %eax,%edi
neg    %edi
cmovs  %eax,%edi
add    %r8d,%edi
movsd  (%rbx,%rdi,8),%xmm0
subsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
add    $0xfffffffe,%ecx
add    $0xfffffffe,%esi
cmp    %ebp,%esi
jg     1600 <Extend+0x4f0>
jmp    1480 <Extend+0x370>
cmpl   $0x0,0x70(%rsp)
je     19bd <Extend+0x8ad>
mov    0x5c(%rsp),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
imul   %edi,%ecx
lea    (%rcx,%rcx,1),%eax
neg    %eax
cmp    %ecx,%r9d
jne    17f5 <Extend+0x6e5>
add    0x8(%rsp),%ecx
add    %eax,%ecx
sub    %edi,%ecx
cmp    0x30(%rsp),%ecx
jle    19bd <Extend+0x8ad>
cmpl   $0x0,0x20(%rsp)
sete   %r8b
mov    %r12d,%esi
sub    %edi,%esi
mov    0x18(%rsp),%rdx
mov    0x28(%rsp),%r14
cmp    %edx,%r14d
setne  %al
or     %r8b,%al
add    %edx,%edx
not    %edx
add    %r14d,%edx
add    %r12d,%edx
mov    %rdx,%r9
cmp    %esi,%edx
setle  %r10b
or     %al,%r10b
neg    %r14d
jmp    16fd <Extend+0x5ed>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rsp),%rax
sub    %edi,%eax
mov    %rax,0x8(%rsp)
mov    0x20(%rsp),%rcx
sub    %edi,%ecx
cmp    0x30(%rsp),%ecx
jle    19bd <Extend+0x8ad>
mov    0x8(%rsp),%rax
mov    %eax,%ebp
neg    %ebp
cmovs  %eax,%ebp
mov    %rcx,0x20(%rsp)
mov    %ecx,%r13d
jmp    172f <Extend+0x61f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x50(%rsp),%rdi
sub    %edi,%r13d
cmp    0x30(%rsp),%r13d
jle    16e0 <Extend+0x5d0>
cmp    %edi,0x28(%rsp)
jge    1788 <Extend+0x678>
mov    %r13d,%eax
neg    %eax
cmovs  %r13d,%eax
mov    %r12d,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r14,%rcx,1),%edx
mov    %edx,%edi
neg    %edi
cmovs  %edx,%edi
add    %eax,%edi
movsd  (%r15,%rdi,8),%xmm0
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
add    %ebp,%edx
addsd  %xmm0,%xmm0
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
lea    (%r14,%rcx,1),%edx
add    $0xffffffff,%edx
add    $0xffffffff,%ecx
cmp    %esi,%edx
jg     1750 <Extend+0x640>
test   %r10b,%r10b
jne    1720 <Extend+0x610>
mov    %r13d,%ecx
neg    %ecx
cmovs  %r13d,%ecx
mov    %r9d,%r8d
mov    %r12d,%eax
nopl   0x0(%rax)
mov    %eax,%r11d
neg    %r11d
cmovs  %eax,%r11d
add    %ebp,%r11d
movsd  (%rbx,%r11,8),%xmm0
mov    %r8d,%edx
cs nopw 0x0(%rax,%rax,1)
mov    %edx,%edi
neg    %edi
cmovs  %edx,%edi
add    %ecx,%edi
movsd  (%r15,%rdi,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx,%r11,8)
add    $0xffffffff,%edx
cmp    %esi,%edx
jg     17c0 <Extend+0x6b0>
add    $0xffffffff,%eax
add    $0xffffffff,%r8d
cmp    %esi,%r8d
jg     17a0 <Extend+0x690>
jmp    1720 <Extend+0x610>
add    0x8(%rsp),%r9d
add    %eax,%r9d
cmp    0x30(%rsp),%r9d
jle    19bd <Extend+0x8ad>
cmpl   $0x0,0x20(%rsp)
sete   %cl
mov    %r12d,%eax
sub    %edi,%eax
mov    0x18(%rsp),%rsi
mov    0x28(%rsp),%r11
cmp    %esi,%r11d
sete   %dl
or     %cl,%dl
lea    (%r11,%r12,1),%ebp
sub    %esi,%ebp
sub    %esi,%ebp
cmp    %eax,%ebp
setle  %r8b
or     %dl,%r8b
mov    %ebp,%ecx
neg    %ecx
cmovs  %ebp,%ecx
mov    %rcx,0x10(%rsp)
lea    (%r11,%rdi,1),%r14d
mov    %r12d,%ecx
neg    %ecx
cmovs  %r12d,%ecx
mov    %rcx,0x38(%rsp)
lea    0x1(%rsi,%rsi,1),%ecx
mov    %ecx,0x18(%rsp)
lea    -0x1(%r12),%ecx
mov    %ecx,0x48(%rsp)
mov    %rbp,0x20(%rsp)
lea    -0x1(%rbp),%ecx
mov    %ecx,0x44(%rsp)
neg    %r11d
jmp    189f <Extend+0x78f>
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rdi
sub    %edi,%r9d
mov    0x8(%rsp),%rcx
sub    %edi,%ecx
mov    %rcx,0x8(%rsp)
cmp    0x30(%rsp),%r9d
jle    19bd <Extend+0x8ad>
cmp    %edi,0x28(%rsp)
jge    18f4 <Extend+0x7e4>
mov    %r9d,%ecx
neg    %ecx
cmovs  %r9d,%ecx
mov    0x8(%rsp),%rdx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
mov    %r12d,%edx
nopl   (%rax)
lea    (%r11,%rdx,1),%edi
mov    %edi,%ebp
neg    %ebp
cmovs  %edi,%ebp
add    %ecx,%ebp
mov    %edx,%edi
neg    %edi
cmovs  %edx,%edi
add    %esi,%edi
movsd  (%rbx,%rdi,8),%xmm0
subsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
lea    (%r11,%rdx,1),%edi
add    $0xffffffff,%edi
add    $0xffffffff,%edx
cmp    %eax,%edi
jg     18c0 <Extend+0x7b0>
test   %r8b,%r8b
jne    1880 <Extend+0x770>
mov    %r9d,%r10d
neg    %r10d
cmovs  %r9d,%r10d
mov    0x8(%rsp),%rcx
mov    %ecx,%r13d
neg    %r13d
cmovs  %ecx,%r13d
mov    0x20(%rsp),%rsi
mov    %r12d,%ecx
test   $0x1,%r14b
je     194a <Extend+0x83a>
mov    0x10(%rsp),%rcx
add    %r10d,%ecx
mov    0x38(%rsp),%rdx
add    %r13d,%edx
movsd  (%rbx,%rdx,8),%xmm0
subsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
mov    0x44(%rsp),%ecx
mov    %ecx,%esi
mov    0x48(%rsp),%ecx
cmp    0x18(%rsp),%r14d
je     1880 <Extend+0x770>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %esi,%edx
neg    %edx
cmovs  %esi,%edx
add    %r10d,%edx
mov    %ecx,%edi
neg    %edi
cmovs  %ecx,%edi
add    %r13d,%edi
movsd  (%rbx,%rdi,8),%xmm0
subsd  (%r15,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
lea    -0x1(%rcx),%edx
lea    -0x1(%rsi),%edi
mov    %edi,%ebp
neg    %ebp
cmovs  %edi,%ebp
add    %r10d,%ebp
mov    %edx,%edi
neg    %edi
cmovs  %edx,%edi
add    %r13d,%edi
movsd  (%rbx,%rdi,8),%xmm0
subsd  (%r15,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
add    $0xfffffffe,%ecx
add    $0xfffffffe,%esi
cmp    %eax,%esi
jg     1960 <Extend+0x850>
jmp    1880 <Extend+0x770>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @Extend(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
%27 = alloca i32
%28 = 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
%29 = load i32, i32* %9
%30 = load i32, i32* %10
%31 = mul nsw i32 %29, %30
store i32 %31, i32* %15
%32 = load i32, i32* %11
%33 = icmp sgt i32 %32, 0
br i1 %33, label %34, label %37
34: ; preds = %7
%35 = load i32, i32* %9
%36 = sub nsw i32 %35, 1
br label %38
37: ; preds = %7
br label %38
38: ; preds = %37, %34
%39 = phi i32 [ %36, %34 ], [ 0, %37 ]
store i32 %39, i32* %22
%40 = load i32, i32* %9
%41 = load i32, i32* %12
%42 = icmp sgt i32 %41, 0
br i1 %42, label %43, label %46
43: ; preds = %38
%44 = load i32, i32* %10
%45 = sub nsw i32 %44, 1
br label %47
46: ; preds = %38
br label %47
47: ; preds = %46, %43
%48 = phi i32 [ %45, %43 ], [ 0, %46 ]
%49 = mul nsw i32 %40, %48
store i32 %49, i32* %23
%50 = load i32, i32* %11
%51 = icmp sgt i32 %50, 0
br i1 %51, label %52, label %55
52: ; preds = %47
%53 = load i32, i32* %11
%54 = sub nsw i32 %53, 1
br label %64
55: ; preds = %47
%56 = load i32, i32* %11
%57 = icmp slt i32 %56, 0
br i1 %57, label %58, label %61
58: ; preds = %55
%59 = load i32, i32* %11
%60 = add nsw i32 %59, 1
br label %62
61: ; preds = %55
br label %62
62: ; preds = %61, %58
%63 = phi i32 [ %60, %58 ], [ 0, %61 ]
br label %64
64: ; preds = %62, %52
%65 = phi i32 [ %54, %52 ], [ %63, %62 ]
store i32 %65, i32* %24
%66 = load i32, i32* %9
%67 = load i32, i32* %12
%68 = icmp sgt i32 %67, 0
br i1 %68, label %69, label %72
69: ; preds = %64
%70 = load i32, i32* %12
%71 = sub nsw i32 %70, 1
br label %81
72: ; preds = %64
%73 = load i32, i32* %12
%74 = icmp slt i32 %73, 0
br i1 %74, label %75, label %78
75: ; preds = %72
%76 = load i32, i32* %12
%77 = add nsw i32 %76, 1
br label %79
78: ; preds = %72
br label %79
79: ; preds = %78, %75
%80 = phi i32 [ %77, %75 ], [ 0, %78 ]
br label %81
81: ; preds = %79, %69
%82 = phi i32 [ %71, %69 ], [ %80, %79 ]
%83 = mul nsw i32 %66, %82
store i32 %83, i32* %25
%84 = load i32, i32* %11
%85 = icmp slt i32 %84, 0
br i1 %85, label %86, label %89
86: ; preds = %81
%87 = load i32, i32* %9
%88 = sdiv i32 %87, 2
br label %93
89: ; preds = %81
%90 = load i32, i32* %9
%91 = sub nsw i32 %90, 1
%92 = sdiv i32 %91, 2
br label %93
93: ; preds = %89, %86
%94 = phi i32 [ %88, %86 ], [ %92, %89 ]
store i32 %94, i32* %26
%95 = load i32, i32* %9
%96 = load i32, i32* %12
%97 = icmp slt i32 %96, 0
br i1 %97, label %98, label %101
98: ; preds = %93
%99 = load i32, i32* %10
%100 = sdiv i32 %99, 2
br label %105
101: ; preds = %93
%102 = load i32, i32* %10
%103 = sub nsw i32 %102, 1
%104 = sdiv i32 %103, 2
br label %105
105: ; preds = %101, %98
%106 = phi i32 [ %100, %98 ], [ %104, %101 ]
%107 = mul nsw i32 %95, %106
store i32 %107, i32* %27
store i32 0, i32* %28
br label %108
108: ; preds = %117, %105
%109 = load i32, i32* %28
%110 = load i32, i32* %15
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %120
112: ; preds = %108
%113 = load double*, double** %13
%114 = load i32, i32* %28
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double, double* %113, i64 %115
store double 0.000000e+00, double* %116
br label %117
117: ; preds = %112
%118 = load i32, i32* %28
%119 = add nsw i32 %118, 1
store i32 %119, i32* %28
br label %108
120: ; preds = %108
%121 = load i32, i32* %14
%122 = icmp eq i32 %121, 0
br i1 %122, label %123, label %510
123: ; preds = %120
store i32 0, i32* %16
%124 = load i32, i32* %25
store i32 %124, i32* %18
br label %125
125: ; preds = %502, %123
%126 = load i32, i32* %16
%127 = load i32, i32* %15
%128 = icmp slt i32 %126, %127
br i1 %128, label %129, label %509
129: ; preds = %125
%130 = load i32, i32* %18
%131 = icmp sge i32 %130, 0
br i1 %131, label %132, label %256
132: ; preds = %129
%133 = load i32, i32* %18
%134 = load i32, i32* %15
%135 = icmp slt i32 %133, %134
br i1 %135, label %136, label %256
136: ; preds = %132
%137 = load i32, i32* %16
store i32 %137, i32* %17
%138 = load i32, i32* %24
store i32 %138, i32* %19
br label %139
139: ; preds = %250, %136
%140 = load i32, i32* %17
%141 = load i32, i32* %16
%142 = load i32, i32* %9
%143 = add nsw i32 %141, %142
%144 = icmp slt i32 %140, %143
br i1 %144, label %145, label %255
145: ; preds = %139
%146 = load i32, i32* %19
%147 = icmp sge i32 %146, 0
br i1 %147, label %148, label %166
148: ; preds = %145
%149 = load i32, i32* %19
%150 = load i32, i32* %9
%151 = icmp slt i32 %149, %150
br i1 %151, label %152, label %166
152: ; preds = %148
%153 = load double*, double** %8
%154 = load i32, i32* %17
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %153, i64 %155
%157 = load double, double* %156
%158 = load double*, double** %13
%159 = load i32, i32* %18
%160 = load i32, i32* %19
%161 = add nsw i32 %159, %160
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %158, i64 %162
%164 = load double, double* %163
%165 = fadd double %164, %157
store double %165, double* %163
br label %249
166: ; preds = %148, %145
%167 = load double*, double** %8
%168 = load i32, i32* %17
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds double, double* %167, i64 %169
%171 = load double, double* %170
%172 = load double*, double** %13
%173 = load i32, i32* %18
%174 = load i32, i32* %22
%175 = load i32, i32* %19
%176 = load i32, i32* %22
%177 = sub nsw i32 %175, %176
%178 = icmp sge i32 %177, 0
br i1 %178, label %179, label %183
179: ; preds = %166
%180 = load i32, i32* %19
%181 = load i32, i32* %22
%182 = sub nsw i32 %180, %181
br label %188
183: ; preds = %166
%184 = load i32, i32* %19
%185 = load i32, i32* %22
%186 = sub nsw i32 %184, %185
%187 = sub nsw i32 0, %186
br label %188
188: ; preds = %183, %179
%189 = phi i32 [ %182, %179 ], [ %187, %183 ]
%190 = sub nsw i32 %174, %189
%191 = icmp sge i32 %190, 0
br i1 %191, label %192, label %210
192: ; preds = %188
%193 = load i32, i32* %22
%194 = load i32, i32* %19
%195 = load i32, i32* %22
%196 = sub nsw i32 %194, %195
%197 = icmp sge i32 %196, 0
br i1 %197, label %198, label %202
198: ; preds = %192
%199 = load i32, i32* %19
%200 = load i32, i32* %22
%201 = sub nsw i32 %199, %200
br label %207
202: ; preds = %192
%203 = load i32, i32* %19
%204 = load i32, i32* %22
%205 = sub nsw i32 %203, %204
%206 = sub nsw i32 0, %205
br label %207
207: ; preds = %202, %198
%208 = phi i32 [ %201, %198 ], [ %206, %202 ]
%209 = sub nsw i32 %193, %208
br label %229
210: ; preds = %188
%211 = load i32, i32* %22
%212 = load i32, i32* %19
%213 = load i32, i32* %22
%214 = sub nsw i32 %212, %213
%215 = icmp sge i32 %214, 0
br i1 %215, label %216, label %220
216: ; preds = %210
%217 = load i32, i32* %19
%218 = load i32, i32* %22
%219 = sub nsw i32 %217, %218
br label %225
220: ; preds = %210
%221 = load i32, i32* %19
%222 = load i32, i32* %22
%223 = sub nsw i32 %221, %222
%224 = sub nsw i32 0, %223
br label %225
225: ; preds = %220, %216
%226 = phi i32 [ %219, %216 ], [ %224, %220 ]
%227 = sub nsw i32 %211, %226
%228 = sub nsw i32 0, %227
br label %229
229: ; preds = %225, %207
%230 = phi i32 [ %209, %207 ], [ %228, %225 ]
%231 = add nsw i32 %173, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds double, double* %172, i64 %232
%234 = load double, double* %233
%235 = fsub double %234, %171
store double %235, double* %233
%236 = load double*, double** %8
%237 = load i32, i32* %17
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %236, i64 %238
%240 = load double, double* %239
%241 = load double*, double** %13
%242 = load i32, i32* %18
%243 = load i32, i32* %22
%244 = add nsw i32 %242, %243
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %241, i64 %245
%247 = load double, double* %246
%248 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %240, double %247)
store double %248, double* %246
br label %249
249: ; preds = %229, %152
br label %250
250: ; preds = %249
%251 = load i32, i32* %17
%252 = add nsw i32 %251, 1
store i32 %252, i32* %17
%253 = load i32, i32* %19
%254 = add nsw i32 %253, 1
store i32 %254, i32* %19
br label %139
255: ; preds = %139
br label %501
256: ; preds = %132, %129
%257 = load i32, i32* %16
store i32 %257, i32* %17
%258 = load i32, i32* %24
store i32 %258, i32* %19
br label %259
259: ; preds = %495, %256
%260 = load i32, i32* %17
%261 = load i32, i32* %16
%262 = load i32, i32* %9
%263 = add nsw i32 %261, %262
%264 = icmp slt i32 %260, %263
br i1 %264, label %265, label %500
265: ; preds = %259
%266 = load i32, i32* %19
%267 = icmp sge i32 %266, 0
br i1 %267, label %268, label %355
268: ; preds = %265
%269 = load i32, i32* %19
%270 = load i32, i32* %9
%271 = icmp slt i32 %269, %270
br i1 %271, label %272, label %355
272: ; preds = %268
%273 = load double*, double** %8
%274 = load i32, i32* %17
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %273, i64 %275
%277 = load double, double* %276
%278 = load double*, double** %13
%279 = load i32, i32* %23
%280 = load i32, i32* %18
%281 = load i32, i32* %23
%282 = sub nsw i32 %280, %281
%283 = icmp sge i32 %282, 0
br i1 %283, label %284, label %288
284: ; preds = %272
%285 = load i32, i32* %18
%286 = load i32, i32* %23
%287 = sub nsw i32 %285, %286
br label %293
288: ; preds = %272
%289 = load i32, i32* %18
%290 = load i32, i32* %23
%291 = sub nsw i32 %289, %290
%292 = sub nsw i32 0, %291
br label %293
293: ; preds = %288, %284
%294 = phi i32 [ %287, %284 ], [ %292, %288 ]
%295 = sub nsw i32 %279, %294
%296 = icmp sge i32 %295, 0
br i1 %296, label %297, label %315
297: ; preds = %293
%298 = load i32, i32* %23
%299 = load i32, i32* %18
%300 = load i32, i32* %23
%301 = sub nsw i32 %299, %300
%302 = icmp sge i32 %301, 0
br i1 %302, label %303, label %307
303: ; preds = %297
%304 = load i32, i32* %18
%305 = load i32, i32* %23
%306 = sub nsw i32 %304, %305
br label %312
307: ; preds = %297
%308 = load i32, i32* %18
%309 = load i32, i32* %23
%310 = sub nsw i32 %308, %309
%311 = sub nsw i32 0, %310
br label %312
312: ; preds = %307, %303
%313 = phi i32 [ %306, %303 ], [ %311, %307 ]
%314 = sub nsw i32 %298, %313
br label %334
315: ; preds = %293
%316 = load i32, i32* %23
%317 = load i32, i32* %18
%318 = load i32, i32* %23
%319 = sub nsw i32 %317, %318
%320 = icmp sge i32 %319, 0
br i1 %320, label %321, label %325
321: ; preds = %315
%322 = load i32, i32* %18
%323 = load i32, i32* %23
%324 = sub nsw i32 %322, %323
br label %330
325: ; preds = %315
%326 = load i32, i32* %18
%327 = load i32, i32* %23
%328 = sub nsw i32 %326, %327
%329 = sub nsw i32 0, %328
br label %330
330: ; preds = %325, %321
%331 = phi i32 [ %324, %321 ], [ %329, %325 ]
%332 = sub nsw i32 %316, %331
%333 = sub nsw i32 0, %332
br label %334
334: ; preds = %330, %312
%335 = phi i32 [ %314, %312 ], [ %333, %330 ]
%336 = load i32, i32* %19
%337 = add nsw i32 %335, %336
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds double, double* %278, i64 %338
%340 = load double, double* %339
%341 = fsub double %340, %277
store double %341, double* %339
%342 = load double*, double** %8
%343 = load i32, i32* %17
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds double, double* %342, i64 %344
%346 = load double, double* %345
%347 = load double*, double** %13
%348 = load i32, i32* %23
%349 = load i32, i32* %19
%350 = add nsw i32 %348, %349
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double, double* %347, i64 %351
%353 = load double, double* %352
%354 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %346, double %353)
store double %354, double* %352
br label %494
355: ; preds = %268, %265
%356 = load double*, double** %8
%357 = load i32, i32* %17
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double, double* %356, i64 %358
%360 = load double, double* %359
%361 = load double*, double** %13
%362 = load i32, i32* %23
%363 = load i32, i32* %18
%364 = load i32, i32* %23
%365 = sub nsw i32 %363, %364
%366 = icmp sge i32 %365, 0
br i1 %366, label %367, label %371
367: ; preds = %355
%368 = load i32, i32* %18
%369 = load i32, i32* %23
%370 = sub nsw i32 %368, %369
br label %376
371: ; preds = %355
%372 = load i32, i32* %18
%373 = load i32, i32* %23
%374 = sub nsw i32 %372, %373
%375 = sub nsw i32 0, %374
br label %376
376: ; preds = %371, %367
%377 = phi i32 [ %370, %367 ], [ %375, %371 ]
%378 = sub nsw i32 %362, %377
%379 = icmp sge i32 %378, 0
br i1 %379, label %380, label %398
380: ; preds = %376
%381 = load i32, i32* %23
%382 = load i32, i32* %18
%383 = load i32, i32* %23
%384 = sub nsw i32 %382, %383
%385 = icmp sge i32 %384, 0
br i1 %385, label %386, label %390
386: ; preds = %380
%387 = load i32, i32* %18
%388 = load i32, i32* %23
%389 = sub nsw i32 %387, %388
br label %395
390: ; preds = %380
%391 = load i32, i32* %18
%392 = load i32, i32* %23
%393 = sub nsw i32 %391, %392
%394 = sub nsw i32 0, %393
br label %395
395: ; preds = %390, %386
%396 = phi i32 [ %389, %386 ], [ %394, %390 ]
%397 = sub nsw i32 %381, %396
br label %417
398: ; preds = %376
%399 = load i32, i32* %23
%400 = load i32, i32* %18
%401 = load i32, i32* %23
%402 = sub nsw i32 %400, %401
%403 = icmp sge i32 %402, 0
br i1 %403, label %404, label %408
404: ; preds = %398
%405 = load i32, i32* %18
%406 = load i32, i32* %23
%407 = sub nsw i32 %405, %406
br label %413
408: ; preds = %398
%409 = load i32, i32* %18
%410 = load i32, i32* %23
%411 = sub nsw i32 %409, %410
%412 = sub nsw i32 0, %411
br label %413
413: ; preds = %408, %404
%414 = phi i32 [ %407, %404 ], [ %412, %408 ]
%415 = sub nsw i32 %399, %414
%416 = sub nsw i32 0, %415
br label %417
417: ; preds = %413, %395
%418 = phi i32 [ %397, %395 ], [ %416, %413 ]
%419 = load i32, i32* %22
%420 = load i32, i32* %19
%421 = load i32, i32* %22
%422 = sub nsw i32 %420, %421
%423 = icmp sge i32 %422, 0
br i1 %423, label %424, label %428
424: ; preds = %417
%425 = load i32, i32* %19
%426 = load i32, i32* %22
%427 = sub nsw i32 %425, %426
br label %433
428: ; preds = %417
%429 = load i32, i32* %19
%430 = load i32, i32* %22
%431 = sub nsw i32 %429, %430
%432 = sub nsw i32 0, %431
br label %433
433: ; preds = %428, %424
%434 = phi i32 [ %427, %424 ], [ %432, %428 ]
%435 = sub nsw i32 %419, %434
%436 = icmp sge i32 %435, 0
br i1 %436, label %437, label %455
437: ; preds = %433
%438 = load i32, i32* %22
%439 = load i32, i32* %19
%440 = load i32, i32* %22
%441 = sub nsw i32 %439, %440
%442 = icmp sge i32 %441, 0
br i1 %442, label %443, label %447
443: ; preds = %437
%444 = load i32, i32* %19
%445 = load i32, i32* %22
%446 = sub nsw i32 %444, %445
br label %452
447: ; preds = %437
%448 = load i32, i32* %19
%449 = load i32, i32* %22
%450 = sub nsw i32 %448, %449
%451 = sub nsw i32 0, %450
br label %452
452: ; preds = %447, %443
%453 = phi i32 [ %446, %443 ], [ %451, %447 ]
%454 = sub nsw i32 %438, %453
br label %474
455: ; preds = %433
%456 = load i32, i32* %22
%457 = load i32, i32* %19
%458 = load i32, i32* %22
%459 = sub nsw i32 %457, %458
%460 = icmp sge i32 %459, 0
br i1 %460, label %461, label %465
461: ; preds = %455
%462 = load i32, i32* %19
%463 = load i32, i32* %22
%464 = sub nsw i32 %462, %463
br label %470
465: ; preds = %455
%466 = load i32, i32* %19
%467 = load i32, i32* %22
%468 = sub nsw i32 %466, %467
%469 = sub nsw i32 0, %468
br label %470
470: ; preds = %465, %461
%471 = phi i32 [ %464, %461 ], [ %469, %465 ]
%472 = sub nsw i32 %456, %471
%473 = sub nsw i32 0, %472
br label %474
474: ; preds = %470, %452
%475 = phi i32 [ %454, %452 ], [ %473, %470 ]
%476 = add nsw i32 %418, %475
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds double, double* %361, i64 %477
%479 = load double, double* %478
%480 = fsub double %479, %360
store double %480, double* %478
%481 = load double*, double** %8
%482 = load i32, i32* %17
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds double, double* %481, i64 %483
%485 = load double, double* %484
%486 = load double*, double** %13
%487 = load i32, i32* %23
%488 = load i32, i32* %22
%489 = add nsw i32 %487, %488
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds double, double* %486, i64 %490
%492 = load double, double* %491
%493 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %485, double %492)
store double %493, double* %491
br label %494
494: ; preds = %474, %334
br label %495
495: ; preds = %494
%496 = load i32, i32* %17
%497 = add nsw i32 %496, 1
store i32 %497, i32* %17
%498 = load i32, i32* %19
%499 = add nsw i32 %498, 1
store i32 %499, i32* %19
br label %259
500: ; preds = %259
br label %501
501: ; preds = %500, %255
br label %502
502: ; preds = %501
%503 = load i32, i32* %9
%504 = load i32, i32* %16
%505 = add nsw i32 %504, %503
store i32 %505, i32* %16
%506 = load i32, i32* %9
%507 = load i32, i32* %18
%508 = add nsw i32 %507, %506
store i32 %508, i32* %18
br label %125
509: ; preds = %125
br label %1129
510: ; preds = %120
%511 = load i32, i32* %25
%512 = icmp sge i32 %511, 0
br i1 %512, label %513, label %515
513: ; preds = %510
%514 = load i32, i32* %25
br label %518
515: ; preds = %510
%516 = load i32, i32* %25
%517 = sub nsw i32 0, %516
br label %518
518: ; preds = %515, %513
%519 = phi i32 [ %514, %513 ], [ %517, %515 ]
store i32 %519, i32* %25
%520 = load i32, i32* %24
%521 = icmp sge i32 %520, 0
br i1 %521, label %522, label %524
522: ; preds = %518
%523 = load i32, i32* %24
br label %527
524: ; preds = %518
%525 = load i32, i32* %24
%526 = sub nsw i32 0, %525
br label %527
527: ; preds = %524, %522
%528 = phi i32 [ %523, %522 ], [ %526, %524 ]
store i32 %528, i32* %24
%529 = load i32, i32* %23
store i32 %529, i32* %18
%530 = load i32, i32* %23
%531 = load i32, i32* %25
%532 = sub nsw i32 %530, %531
store i32 %532, i32* %16
br label %533
533: ; preds = %761, %527
%534 = load i32, i32* %16
%535 = load i32, i32* %23
%536 = load i32, i32* %15
%537 = sub nsw i32 %535, %536
%538 = icmp sgt i32 %534, %537
br i1 %538, label %539, label %768
539: ; preds = %533
%540 = load i32, i32* %22
store i32 %540, i32* %19
%541 = load i32, i32* %22
%542 = load i32, i32* %24
%543 = sub nsw i32 %541, %542
store i32 %543, i32* %17
br label %544
544: ; preds = %598, %539
%545 = load i32, i32* %17
%546 = load i32, i32* %22
%547 = load i32, i32* %9
%548 = sub nsw i32 %546, %547
%549 = icmp sgt i32 %545, %548
br i1 %549, label %550, label %603
550: ; preds = %544
%551 = load double*, double** %8
%552 = load i32, i32* %16
%553 = icmp sge i32 %552, 0
br i1 %553, label %554, label %556
554: ; preds = %550
%555 = load i32, i32* %16
br label %559
556: ; preds = %550
%557 = load i32, i32* %16
%558 = sub nsw i32 0, %557
br label %559
559: ; preds = %556, %554
%560 = phi i32 [ %555, %554 ], [ %558, %556 ]
%561 = load i32, i32* %17
%562 = icmp sge i32 %561, 0
br i1 %562, label %563, label %565
563: ; preds = %559
%564 = load i32, i32* %17
br label %568
565: ; preds = %559
%566 = load i32, i32* %17
%567 = sub nsw i32 0, %566
br label %568
568: ; preds = %565, %563
%569 = phi i32 [ %564, %563 ], [ %567, %565 ]
%570 = add nsw i32 %560, %569
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds double, double* %551, i64 %571
%573 = load double, double* %572
%574 = load double*, double** %13
%575 = load i32, i32* %18
%576 = icmp sge i32 %575, 0
br i1 %576, label %577, label %579
577: ; preds = %568
%578 = load i32, i32* %18
br label %582
579: ; preds = %568
%580 = load i32, i32* %18
%581 = sub nsw i32 0, %580
br label %582
582: ; preds = %579, %577
%583 = phi i32 [ %578, %577 ], [ %581, %579 ]
%584 = load i32, i32* %19
%585 = icmp sge i32 %584, 0
br i1 %585, label %586, label %588
586: ; preds = %582
%587 = load i32, i32* %19
br label %591
588: ; preds = %582
%589 = load i32, i32* %19
%590 = sub nsw i32 0, %589
br label %591
591: ; preds = %588, %586
%592 = phi i32 [ %587, %586 ], [ %590, %588 ]
%593 = add nsw i32 %583, %592
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds double, double* %574, i64 %594
%596 = load double, double* %595
%597 = fadd double %596, %573
store double %597, double* %595
br label %598
598: ; preds = %591
%599 = load i32, i32* %19
%600 = add nsw i32 %599, -1
store i32 %600, i32* %19
%601 = load i32, i32* %17
%602 = add nsw i32 %601, -1
store i32 %602, i32* %17
br label %544
603: ; preds = %544
%604 = load i32, i32* %11
%605 = icmp ne i32 %604, 0
br i1 %605, label %606, label %760
606: ; preds = %603
%607 = load i32, i32* %24
%608 = load i32, i32* %26
%609 = icmp ne i32 %607, %608
br i1 %609, label %610, label %678
610: ; preds = %606
%611 = load i32, i32* %22
store i32 %611, i32* %19
%612 = load i32, i32* %22
%613 = load i32, i32* %26
%614 = mul nsw i32 2, %613
%615 = sub nsw i32 %612, %614
%616 = load i32, i32* %24
%617 = add nsw i32 %615, %616
store i32 %617, i32* %17
br label %618
618: ; preds = %672, %610
%619 = load i32, i32* %17
%620 = load i32, i32* %22
%621 = load i32, i32* %9
%622 = sub nsw i32 %620, %621
%623 = icmp sgt i32 %619, %622
br i1 %623, label %624, label %677
624: ; preds = %618
%625 = load double*, double** %8
%626 = load i32, i32* %16
%627 = icmp sge i32 %626, 0
br i1 %627, label %628, label %630
628: ; preds = %624
%629 = load i32, i32* %16
br label %633
630: ; preds = %624
%631 = load i32, i32* %16
%632 = sub nsw i32 0, %631
br label %633
633: ; preds = %630, %628
%634 = phi i32 [ %629, %628 ], [ %632, %630 ]
%635 = load i32, i32* %17
%636 = icmp sge i32 %635, 0
br i1 %636, label %637, label %639
637: ; preds = %633
%638 = load i32, i32* %17
br label %642
639: ; preds = %633
%640 = load i32, i32* %17
%641 = sub nsw i32 0, %640
br label %642
642: ; preds = %639, %637
%643 = phi i32 [ %638, %637 ], [ %641, %639 ]
%644 = add nsw i32 %634, %643
%645 = sext i32 %644 to i64
%646 = getelementptr inbounds double, double* %625, i64 %645
%647 = load double, double* %646
%648 = load double*, double** %13
%649 = load i32, i32* %18
%650 = icmp sge i32 %649, 0
br i1 %650, label %651, label %653
651: ; preds = %642
%652 = load i32, i32* %18
br label %656
653: ; preds = %642
%654 = load i32, i32* %18
%655 = sub nsw i32 0, %654
br label %656
656: ; preds = %653, %651
%657 = phi i32 [ %652, %651 ], [ %655, %653 ]
%658 = load i32, i32* %19
%659 = icmp sge i32 %658, 0
br i1 %659, label %660, label %662
660: ; preds = %656
%661 = load i32, i32* %19
br label %665
662: ; preds = %656
%663 = load i32, i32* %19
%664 = sub nsw i32 0, %663
br label %665
665: ; preds = %662, %660
%666 = phi i32 [ %661, %660 ], [ %664, %662 ]
%667 = add nsw i32 %657, %666
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds double, double* %648, i64 %668
%670 = load double, double* %669
%671 = fsub double %670, %647
store double %671, double* %669
br label %672
672: ; preds = %665
%673 = load i32, i32* %19
%674 = add nsw i32 %673, -1
store i32 %674, i32* %19
%675 = load i32, i32* %17
%676 = add nsw i32 %675, -1
store i32 %676, i32* %17
br label %618
677: ; preds = %618
br label %759
678: ; preds = %606
%679 = load i32, i32* %22
store i32 %679, i32* %19
%680 = load i32, i32* %22
%681 = load i32, i32* %26
%682 = mul nsw i32 2, %681
%683 = sub nsw i32 %680, %682
%684 = load i32, i32* %24
%685 = add nsw i32 %683, %684
%686 = sub nsw i32 %685, 1
store i32 %686, i32* %17
br label %687
687: ; preds = %753, %678
%688 = load i32, i32* %17
%689 = load i32, i32* %22
%690 = load i32, i32* %9
%691 = sub nsw i32 %689, %690
%692 = icmp sgt i32 %688, %691
br i1 %692, label %693, label %758
693: ; preds = %687
%694 = load i32, i32* %17
store i32 %694, i32* %21
br label %695
695: ; preds = %749, %693
%696 = load i32, i32* %21
%697 = load i32, i32* %22
%698 = load i32, i32* %9
%699 = sub nsw i32 %697, %698
%700 = icmp sgt i32 %696, %699
br i1 %700, label %701, label %752
701: ; preds = %695
%702 = load double*, double** %8
%703 = load i32, i32* %16
%704 = icmp sge i32 %703, 0
br i1 %704, label %705, label %707
705: ; preds = %701
%706 = load i32, i32* %16
br label %710
707: ; preds = %701
%708 = load i32, i32* %16
%709 = sub nsw i32 0, %708
br label %710
710: ; preds = %707, %705
%711 = phi i32 [ %706, %705 ], [ %709, %707 ]
%712 = load i32, i32* %21
%713 = icmp sge i32 %712, 0
br i1 %713, label %714, label %716
714: ; preds = %710
%715 = load i32, i32* %21
br label %719
716: ; preds = %710
%717 = load i32, i32* %21
%718 = sub nsw i32 0, %717
br label %719
719: ; preds = %716, %714
%720 = phi i32 [ %715, %714 ], [ %718, %716 ]
%721 = add nsw i32 %711, %720
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds double, double* %702, i64 %722
%724 = load double, double* %723
%725 = load double*, double** %13
%726 = load i32, i32* %18
%727 = icmp sge i32 %726, 0
br i1 %727, label %728, label %730
728: ; preds = %719
%729 = load i32, i32* %18
br label %733
730: ; preds = %719
%731 = load i32, i32* %18
%732 = sub nsw i32 0, %731
br label %733
733: ; preds = %730, %728
%734 = phi i32 [ %729, %728 ], [ %732, %730 ]
%735 = load i32, i32* %19
%736 = icmp sge i32 %735, 0
br i1 %736, label %737, label %739
737: ; preds = %733
%738 = load i32, i32* %19
br label %742
739: ; preds = %733
%740 = load i32, i32* %19
%741 = sub nsw i32 0, %740
br label %742
742: ; preds = %739, %737
%743 = phi i32 [ %738, %737 ], [ %741, %739 ]
%744 = add nsw i32 %734, %743
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds double, double* %725, i64 %745
%747 = load double, double* %746
%748 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %724, double %747)
store double %748, double* %746
br label %749
749: ; preds = %742
%750 = load i32, i32* %21
%751 = add nsw i32 %750, -1
store i32 %751, i32* %21
br label %695
752: ; preds = %695
br label %753
753: ; preds = %752
%754 = load i32, i32* %19
%755 = add nsw i32 %754, -1
store i32 %755, i32* %19
%756 = load i32, i32* %17
%757 = add nsw i32 %756, -1
store i32 %757, i32* %17
br label %687
758: ; preds = %687
br label %759
759: ; preds = %758, %677
br label %760
760: ; preds = %759, %603
br label %761
761: ; preds = %760
%762 = load i32, i32* %9
%763 = load i32, i32* %16
%764 = sub nsw i32 %763, %762
store i32 %764, i32* %16
%765 = load i32, i32* %9
%766 = load i32, i32* %18
%767 = sub nsw i32 %766, %765
store i32 %767, i32* %18
br label %533
768: ; preds = %533
%769 = load i32, i32* %12
%770 = icmp ne i32 %769, 0
br i1 %770, label %771, label %1128
771: ; preds = %768
%772 = load i32, i32* %25
%773 = load i32, i32* %27
%774 = icmp ne i32 %772, %773
br i1 %774, label %775, label %937
775: ; preds = %771
%776 = load i32, i32* %23
store i32 %776, i32* %18
%777 = load i32, i32* %23
%778 = load i32, i32* %27
%779 = mul nsw i32 2, %778
%780 = sub nsw i32 %777, %779
%781 = load i32, i32* %25
%782 = add nsw i32 %780, %781
store i32 %782, i32* %16
br label %783
783: ; preds = %929, %775
%784 = load i32, i32* %16
%785 = load i32, i32* %23
%786 = load i32, i32* %15
%787 = sub nsw i32 %785, %786
%788 = icmp sgt i32 %784, %787
br i1 %788, label %789, label %936
789: ; preds = %783
%790 = load i32, i32* %22
store i32 %790, i32* %19
%791 = load i32, i32* %22
%792 = load i32, i32* %24
%793 = sub nsw i32 %791, %792
store i32 %793, i32* %17
br label %794
794: ; preds = %848, %789
%795 = load i32, i32* %17
%796 = load i32, i32* %22
%797 = load i32, i32* %9
%798 = sub nsw i32 %796, %797
%799 = icmp sgt i32 %795, %798
br i1 %799, label %800, label %853
800: ; preds = %794
%801 = load double*, double** %8
%802 = load i32, i32* %16
%803 = icmp sge i32 %802, 0
br i1 %803, label %804, label %806
804: ; preds = %800
%805 = load i32, i32* %16
br label %809
806: ; preds = %800
%807 = load i32, i32* %16
%808 = sub nsw i32 0, %807
br label %809
809: ; preds = %806, %804
%810 = phi i32 [ %805, %804 ], [ %808, %806 ]
%811 = load i32, i32* %17
%812 = icmp sge i32 %811, 0
br i1 %812, label %813, label %815
813: ; preds = %809
%814 = load i32, i32* %17
br label %818
815: ; preds = %809
%816 = load i32, i32* %17
%817 = sub nsw i32 0, %816
br label %818
818: ; preds = %815, %813
%819 = phi i32 [ %814, %813 ], [ %817, %815 ]
%820 = add nsw i32 %810, %819
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds double, double* %801, i64 %821
%823 = load double, double* %822
%824 = load double*, double** %13
%825 = load i32, i32* %18
%826 = icmp sge i32 %825, 0
br i1 %826, label %827, label %829
827: ; preds = %818
%828 = load i32, i32* %18
br label %832
829: ; preds = %818
%830 = load i32, i32* %18
%831 = sub nsw i32 0, %830
br label %832
832: ; preds = %829, %827
%833 = phi i32 [ %828, %827 ], [ %831, %829 ]
%834 = load i32, i32* %19
%835 = icmp sge i32 %834, 0
br i1 %835, label %836, label %838
836: ; preds = %832
%837 = load i32, i32* %19
br label %841
838: ; preds = %832
%839 = load i32, i32* %19
%840 = sub nsw i32 0, %839
br label %841
841: ; preds = %838, %836
%842 = phi i32 [ %837, %836 ], [ %840, %838 ]
%843 = add nsw i32 %833, %842
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds double, double* %824, i64 %844
%846 = load double, double* %845
%847 = fsub double %846, %823
store double %847, double* %845
br label %848
848: ; preds = %841
%849 = load i32, i32* %19
%850 = add nsw i32 %849, -1
store i32 %850, i32* %19
%851 = load i32, i32* %17
%852 = add nsw i32 %851, -1
store i32 %852, i32* %17
br label %794
853: ; preds = %794
%854 = load i32, i32* %11
%855 = icmp ne i32 %854, 0
br i1 %855, label %856, label %928
856: ; preds = %853
%857 = load i32, i32* %24
%858 = load i32, i32* %26
%859 = icmp ne i32 %857, %858
br i1 %859, label %860, label %928
860: ; preds = %856
%861 = load i32, i32* %22
store i32 %861, i32* %19
%862 = load i32, i32* %22
%863 = load i32, i32* %26
%864 = mul nsw i32 2, %863
%865 = sub nsw i32 %862, %864
%866 = load i32, i32* %24
%867 = add nsw i32 %865, %866
store i32 %867, i32* %17
br label %868
868: ; preds = %922, %860
%869 = load i32, i32* %17
%870 = load i32, i32* %22
%871 = load i32, i32* %9
%872 = sub nsw i32 %870, %871
%873 = icmp sgt i32 %869, %872
br i1 %873, label %874, label %927
874: ; preds = %868
%875 = load double*, double** %8
%876 = load i32, i32* %16
%877 = icmp sge i32 %876, 0
br i1 %877, label %878, label %880
878: ; preds = %874
%879 = load i32, i32* %16
br label %883
880: ; preds = %874
%881 = load i32, i32* %16
%882 = sub nsw i32 0, %881
br label %883
883: ; preds = %880, %878
%884 = phi i32 [ %879, %878 ], [ %882, %880 ]
%885 = load i32, i32* %17
%886 = icmp sge i32 %885, 0
br i1 %886, label %887, label %889
887: ; preds = %883
%888 = load i32, i32* %17
br label %892
889: ; preds = %883
%890 = load i32, i32* %17
%891 = sub nsw i32 0, %890
br label %892
892: ; preds = %889, %887
%893 = phi i32 [ %888, %887 ], [ %891, %889 ]
%894 = add nsw i32 %884, %893
%895 = sext i32 %894 to i64
%896 = getelementptr inbounds double, double* %875, i64 %895
%897 = load double, double* %896
%898 = load double*, double** %13
%899 = load i32, i32* %18
%900 = icmp sge i32 %899, 0
br i1 %900, label %901, label %903
901: ; preds = %892
%902 = load i32, i32* %18
br label %906
903: ; preds = %892
%904 = load i32, i32* %18
%905 = sub nsw i32 0, %904
br label %906
906: ; preds = %903, %901
%907 = phi i32 [ %902, %901 ], [ %905, %903 ]
%908 = load i32, i32* %19
%909 = icmp sge i32 %908, 0
br i1 %909, label %910, label %912
910: ; preds = %906
%911 = load i32, i32* %19
br label %915
912: ; preds = %906
%913 = load i32, i32* %19
%914 = sub nsw i32 0, %913
br label %915
915: ; preds = %912, %910
%916 = phi i32 [ %911, %910 ], [ %914, %912 ]
%917 = add nsw i32 %907, %916
%918 = sext i32 %917 to i64
%919 = getelementptr inbounds double, double* %898, i64 %918
%920 = load double, double* %919
%921 = fsub double %920, %897
store double %921, double* %919
br label %922
922: ; preds = %915
%923 = load i32, i32* %19
%924 = add nsw i32 %923, -1
store i32 %924, i32* %19
%925 = load i32, i32* %17
%926 = add nsw i32 %925, -1
store i32 %926, i32* %17
br label %868
927: ; preds = %868
br label %928
928: ; preds = %927, %856, %853
br label %929
929: ; preds = %928
%930 = load i32, i32* %9
%931 = load i32, i32* %16
%932 = sub nsw i32 %931, %930
store i32 %932, i32* %16
%933 = load i32, i32* %9
%934 = load i32, i32* %18
%935 = sub nsw i32 %934, %933
store i32 %935, i32* %18
br label %783
936: ; preds = %783
br label %1127
937: ; preds = %771
%938 = load i32, i32* %23
store i32 %938, i32* %18
%939 = load i32, i32* %23
%940 = load i32, i32* %27
%941 = mul nsw i32 2, %940
%942 = sub nsw i32 %939, %941
%943 = load i32, i32* %25
%944 = add nsw i32 %942, %943
%945 = load i32, i32* %9
%946 = sub nsw i32 %944, %945
store i32 %946, i32* %16
br label %947
947: ; preds = %1119, %937
%948 = load i32, i32* %16
%949 = load i32, i32* %23
%950 = load i32, i32* %15
%951 = sub nsw i32 %949, %950
%952 = icmp sgt i32 %948, %951
br i1 %952, label %953, label %1126
953: ; preds = %947
%954 = load i32, i32* %16
store i32 %954, i32* %20
br label %955
955: ; preds = %1114, %953
%956 = load i32, i32* %20
%957 = load i32, i32* %23
%958 = load i32, i32* %15
%959 = sub nsw i32 %957, %958
%960 = icmp sgt i32 %956, %959
br i1 %960, label %961, label %1118
961: ; preds = %955
%962 = load i32, i32* %22
store i32 %962, i32* %19
%963 = load i32, i32* %22
%964 = load i32, i32* %24
%965 = sub nsw i32 %963, %964
store i32 %965, i32* %17
br label %966
966: ; preds = %1020, %961
%967 = load i32, i32* %17
%968 = load i32, i32* %22
%969 = load i32, i32* %9
%970 = sub nsw i32 %968, %969
%971 = icmp sgt i32 %967, %970
br i1 %971, label %972, label %1025
972: ; preds = %966
%973 = load double*, double** %8
%974 = load i32, i32* %20
%975 = icmp sge i32 %974, 0
br i1 %975, label %976, label %978
976: ; preds = %972
%977 = load i32, i32* %20
br label %981
978: ; preds = %972
%979 = load i32, i32* %20
%980 = sub nsw i32 0, %979
br label %981
981: ; preds = %978, %976
%982 = phi i32 [ %977, %976 ], [ %980, %978 ]
%983 = load i32, i32* %17
%984 = icmp sge i32 %983, 0
br i1 %984, label %985, label %987
985: ; preds = %981
%986 = load i32, i32* %17
br label %990
987: ; preds = %981
%988 = load i32, i32* %17
%989 = sub nsw i32 0, %988
br label %990
990: ; preds = %987, %985
%991 = phi i32 [ %986, %985 ], [ %989, %987 ]
%992 = add nsw i32 %982, %991
%993 = sext i32 %992 to i64
%994 = getelementptr inbounds double, double* %973, i64 %993
%995 = load double, double* %994
%996 = load double*, double** %13
%997 = load i32, i32* %18
%998 = icmp sge i32 %997, 0
br i1 %998, label %999, label %1001
999: ; preds = %990
%1000 = load i32, i32* %18
br label %1004
1001: ; preds = %990
%1002 = load i32, i32* %18
%1003 = sub nsw i32 0, %1002
br label %1004
1004: ; preds = %1001, %999
%1005 = phi i32 [ %1000, %999 ], [ %1003, %1001 ]
%1006 = load i32, i32* %19
%1007 = icmp sge i32 %1006, 0
br i1 %1007, label %1008, label %1010
1008: ; preds = %1004
%1009 = load i32, i32* %19
br label %1013
1010: ; preds = %1004
%1011 = load i32, i32* %19
%1012 = sub nsw i32 0, %1011
br label %1013
1013: ; preds = %1010, %1008
%1014 = phi i32 [ %1009, %1008 ], [ %1012, %1010 ]
%1015 = add nsw i32 %1005, %1014
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds double, double* %996, i64 %1016
%1018 = load double, double* %1017
%1019 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %995, double %1018)
store double %1019, double* %1017
br label %1020
1020: ; preds = %1013
%1021 = load i32, i32* %19
%1022 = add nsw i32 %1021, -1
store i32 %1022, i32* %19
%1023 = load i32, i32* %17
%1024 = add nsw i32 %1023, -1
store i32 %1024, i32* %17
br label %966
1025: ; preds = %966
%1026 = load i32, i32* %11
%1027 = icmp ne i32 %1026, 0
br i1 %1027, label %1028, label %1113
1028: ; preds = %1025
%1029 = load i32, i32* %24
%1030 = load i32, i32* %26
%1031 = icmp eq i32 %1029, %1030
br i1 %1031, label %1032, label %1113
1032: ; preds = %1028
%1033 = load i32, i32* %22
store i32 %1033, i32* %19
%1034 = load i32, i32* %22
%1035 = load i32, i32* %26
%1036 = mul nsw i32 2, %1035
%1037 = sub nsw i32 %1034, %1036
%1038 = load i32, i32* %24
%1039 = add nsw i32 %1037, %1038
%1040 = sub nsw i32 %1039, 1
store i32 %1040, i32* %17
br label %1041
1041: ; preds = %1107, %1032
%1042 = load i32, i32* %17
%1043 = load i32, i32* %22
%1044 = load i32, i32* %9
%1045 = sub nsw i32 %1043, %1044
%1046 = icmp sgt i32 %1042, %1045
br i1 %1046, label %1047, label %1112
1047: ; preds = %1041
%1048 = load i32, i32* %17
store i32 %1048, i32* %21
br label %1049
1049: ; preds = %1103, %1047
%1050 = load i32, i32* %21
%1051 = load i32, i32* %22
%1052 = load i32, i32* %9
%1053 = sub nsw i32 %1051, %1052
%1054 = icmp sgt i32 %1050, %1053
br i1 %1054, label %1055, label %1106
1055: ; preds = %1049
%1056 = load double*, double** %8
%1057 = load i32, i32* %20
%1058 = icmp sge i32 %1057, 0
br i1 %1058, label %1059, label %1061
1059: ; preds = %1055
%1060 = load i32, i32* %20
br label %1064
1061: ; preds = %1055
%1062 = load i32, i32* %20
%1063 = sub nsw i32 0, %1062
br label %1064
1064: ; preds = %1061, %1059
%1065 = phi i32 [ %1060, %1059 ], [ %1063, %1061 ]
%1066 = load i32, i32* %21
%1067 = icmp sge i32 %1066, 0
br i1 %1067, label %1068, label %1070
1068: ; preds = %1064
%1069 = load i32, i32* %21
br label %1073
1070: ; preds = %1064
%1071 = load i32, i32* %21
%1072 = sub nsw i32 0, %1071
br label %1073
1073: ; preds = %1070, %1068
%1074 = phi i32 [ %1069, %1068 ], [ %1072, %1070 ]
%1075 = add nsw i32 %1065, %1074
%1076 = sext i32 %1075 to i64
%1077 = getelementptr inbounds double, double* %1056, i64 %1076
%1078 = load double, double* %1077
%1079 = load double*, double** %13
%1080 = load i32, i32* %18
%1081 = icmp sge i32 %1080, 0
br i1 %1081, label %1082, label %1084
1082: ; preds = %1073
%1083 = load i32, i32* %18
br label %1087
1084: ; preds = %1073
%1085 = load i32, i32* %18
%1086 = sub nsw i32 0, %1085
br label %1087
1087: ; preds = %1084, %1082
%1088 = phi i32 [ %1083, %1082 ], [ %1086, %1084 ]
%1089 = load i32, i32* %19
%1090 = icmp sge i32 %1089, 0
br i1 %1090, label %1091, label %1093
1091: ; preds = %1087
%1092 = load i32, i32* %19
br label %1096
1093: ; preds = %1087
%1094 = load i32, i32* %19
%1095 = sub nsw i32 0, %1094
br label %1096
1096: ; preds = %1093, %1091
%1097 = phi i32 [ %1092, %1091 ], [ %1095, %1093 ]
%1098 = add nsw i32 %1088, %1097
%1099 = sext i32 %1098 to i64
%1100 = getelementptr inbounds double, double* %1079, i64 %1099
%1101 = load double, double* %1100
%1102 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %1078, double %1101)
store double %1102, double* %1100
br label %1103
1103: ; preds = %1096
%1104 = load i32, i32* %21
%1105 = add nsw i32 %1104, -1
store i32 %1105, i32* %21
br label %1049
1106: ; preds = %1049
br label %1107
1107: ; preds = %1106
%1108 = load i32, i32* %19
%1109 = add nsw i32 %1108, -1
store i32 %1109, i32* %19
%1110 = load i32, i32* %17
%1111 = add nsw i32 %1110, -1
store i32 %1111, i32* %17
br label %1041
1112: ; preds = %1041
br label %1113
1113: ; preds = %1112, %1028, %1025
br label %1114
1114: ; preds = %1113
%1115 = load i32, i32* %9
%1116 = load i32, i32* %20
%1117 = sub nsw i32 %1116, %1115
store i32 %1117, i32* %20
br label %955
1118: ; preds = %955
br label %1119
1119: ; preds = %1118
%1120 = load i32, i32* %9
%1121 = load i32, i32* %18
%1122 = sub nsw i32 %1121, %1120
store i32 %1122, i32* %18
%1123 = load i32, i32* %9
%1124 = load i32, i32* %16
%1125 = sub nsw i32 %1124, %1123
store i32 %1125, i32* %16
br label %947
1126: ; preds = %947
br label %1127
1127: ; preds = %1126, %936
br label %1128
1128: ; preds = %1127, %768
br label %1129
1129: ; preds = %1128, %509
ret i32 0
}

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