#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ image;

/* Variables and functions */
int /*<<< orphan*/ decompose(double *, double *, int);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int ButterworthAnalysis2D(double *image, int width, int height, int levels) {
  double *signal_in, *signal_out, *base;
  int cur_level, cur_width, cur_height;
  int i, j, max, offs, n_samples, n_unrol;
  int result;
  max = (width > height ? width : height);
  signal_in = signal_out = NULL;
  signal_in = (double *)malloc(max * sizeof(double));
  signal_out = (double *)malloc(max * sizeof(double));
  if (signal_in == NULL || signal_out == NULL) {
    result = (1);
    goto error;
  }
  n_samples = width * height;
  n_unrol = n_samples & 0xfffffff8;
  for (i = 0; i < n_unrol; i += 8) {
    image[i + 0] -= 128.0;
    image[i + 1] -= 128.0;
    image[i + 2] -= 128.0;
    image[i + 3] -= 128.0;
    image[i + 4] -= 128.0;
    image[i + 5] -= 128.0;
    image[i + 6] -= 128.0;
    image[i + 7] -= 128.0;
  }
  for (; i < n_samples; i++)
    image[i] -= 128.0;
  cur_width = width;
  cur_height = height;
  for (cur_level = 1; cur_level <= levels; cur_level++) {
    n_unrol = cur_width & 0xfffffff8;
    offs = 1;
    for (i = 0; i < cur_height; i++) {
      base = image + i * width;
      for (j = 0; j < n_unrol; j += 8) {
        signal_in[j + 0] = *base;
        base += offs;
        signal_in[j + 1] = *base;
        base += offs;
        signal_in[j + 2] = *base;
        base += offs;
        signal_in[j + 3] = *base;
        base += offs;
        signal_in[j + 4] = *base;
        base += offs;
        signal_in[j + 5] = *base;
        base += offs;
        signal_in[j + 6] = *base;
        base += offs;
        signal_in[j + 7] = *base;
        base += offs;
      }
      for (; j < cur_width; j++) {
        signal_in[j] = *base;
        base += offs;
      }
      decompose(signal_in, signal_out, cur_width);
      base = image + i * width;
      for (j = 0; j < n_unrol; j += 8) {
        *base = signal_out[j + 0];
        base += offs;
        *base = signal_out[j + 1];
        base += offs;
        *base = signal_out[j + 2];
        base += offs;
        *base = signal_out[j + 3];
        base += offs;
        *base = signal_out[j + 4];
        base += offs;
        *base = signal_out[j + 5];
        base += offs;
        *base = signal_out[j + 6];
        base += offs;
        *base = signal_out[j + 7];
        base += offs;
      }
      for (; j < cur_width; j++) {
        *base = signal_out[j];
        base += offs;
      }
    }
    n_unrol = cur_height & 0xfffffff8;
    offs = width;
    for (i = 0; i < cur_width; i++) {
      base = image + i;
      for (j = 0; j < n_unrol; j += 8) {
        signal_in[j + 0] = *base;
        base += offs;
        signal_in[j + 1] = *base;
        base += offs;
        signal_in[j + 2] = *base;
        base += offs;
        signal_in[j + 3] = *base;
        base += offs;
        signal_in[j + 4] = *base;
        base += offs;
        signal_in[j + 5] = *base;
        base += offs;
        signal_in[j + 6] = *base;
        base += offs;
        signal_in[j + 7] = *base;
        base += offs;
      }
      for (; j < cur_height; j++) {
        signal_in[j] = *base;
        base += offs;
      }
      decompose(signal_in, signal_out, cur_height);
      base = image + i;
      for (j = 0; j < n_unrol; j += 8) {
        *base = signal_out[j + 0];
        base += offs;
        *base = signal_out[j + 1];
        base += offs;
        *base = signal_out[j + 2];
        base += offs;
        *base = signal_out[j + 3];
        base += offs;
        *base = signal_out[j + 4];
        base += offs;
        *base = signal_out[j + 5];
        base += offs;
        *base = signal_out[j + 6];
        base += offs;
        *base = signal_out[j + 7];
        base += offs;
      }
      for (; j < cur_height; j++) {
        *base = signal_out[j];
        base += offs;
      }
    }
    cur_width >>= 1;
    cur_height >>= 1;
  }
  n_unrol = n_samples & 0xfffffff8;
  for (i = 0; i < n_unrol; i += 8) {
    image[i + 0] = (((image[i + 0]) < 0) ? (int)((image[i + 0]) - 0.5)
                                         : (int)((image[i + 0]) + 0.5));
    image[i + 1] = (((image[i + 1]) < 0) ? (int)((image[i + 1]) - 0.5)
                                         : (int)((image[i + 1]) + 0.5));
    image[i + 2] = (((image[i + 2]) < 0) ? (int)((image[i + 2]) - 0.5)
                                         : (int)((image[i + 2]) + 0.5));
    image[i + 3] = (((image[i + 3]) < 0) ? (int)((image[i + 3]) - 0.5)
                                         : (int)((image[i + 3]) + 0.5));
    image[i + 4] = (((image[i + 4]) < 0) ? (int)((image[i + 4]) - 0.5)
                                         : (int)((image[i + 4]) + 0.5));
    image[i + 5] = (((image[i + 5]) < 0) ? (int)((image[i + 5]) - 0.5)
                                         : (int)((image[i + 5]) + 0.5));
    image[i + 6] = (((image[i + 6]) < 0) ? (int)((image[i + 6]) - 0.5)
                                         : (int)((image[i + 6]) + 0.5));
    image[i + 7] = (((image[i + 7]) < 0) ? (int)((image[i + 7]) - 0.5)
                                         : (int)((image[i + 7]) + 0.5));
  }
  for (; i < n_samples; i++)
    image[i] =
        (((image[i]) < 0) ? (int)((image[i]) - 0.5) : (int)((image[i]) + 0.5));
  result = (0);
error:
  free(signal_in);
  free(signal_out);
  return result;
}


x86 assembly (clang, -O0):
<ButterworthAnalysis2D>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    115f <ButterworthAnalysis2D+0x2f>
mov    -0xc(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    1165 <ButterworthAnalysis2D+0x35>
mov    -0x10(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x48(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x20(%rbp)
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     11b7 <ButterworthAnalysis2D+0x87>
cmpq   $0x0,-0x28(%rbp)
jne    11c3 <ButterworthAnalysis2D+0x93>
movl   $0x1,-0x58(%rbp)
jmp    20a9 <ButterworthAnalysis2D+0xf79>
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
and    $0xfffffff8,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    130f <ButterworthAnalysis2D+0x1df>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1e05(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1de2(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1dbf(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1d9c(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1d79(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1d56(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1d33(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1d10(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x40(%rbp)
jmp    11dd <ButterworthAnalysis2D+0xad>
jmp    1314 <ButterworthAnalysis2D+0x1e4>
mov    -0x40(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    134c <ButterworthAnalysis2D+0x21c>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1cd3(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1314 <ButterworthAnalysis2D+0x1e4>
mov    -0xc(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1bf6 <ButterworthAnalysis2D+0xac6>
mov    -0x38(%rbp),%eax
and    $0xfffffff8,%eax
mov    %eax,-0x54(%rbp)
movl   $0x1,-0x4c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    17a7 <ButterworthAnalysis2D+0x677>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1540 <ButterworthAnalysis2D+0x410>
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x44(%rbp)
jmp    13ae <ButterworthAnalysis2D+0x27e>
jmp    1545 <ButterworthAnalysis2D+0x415>
mov    -0x44(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1589 <ButterworthAnalysis2D+0x459>
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1545 <ButterworthAnalysis2D+0x415>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x38(%rbp),%edx
call   1050 <decompose@plt>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    174b <ButterworthAnalysis2D+0x61b>
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x44(%rbp)
jmp    15b9 <ButterworthAnalysis2D+0x489>
jmp    1750 <ButterworthAnalysis2D+0x620>
mov    -0x44(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1794 <ButterworthAnalysis2D+0x664>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1750 <ButterworthAnalysis2D+0x620>
jmp    1799 <ButterworthAnalysis2D+0x669>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1382 <ButterworthAnalysis2D+0x252>
mov    -0x3c(%rbp),%eax
and    $0xfffffff8,%eax
mov    %eax,-0x54(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1bd6 <ButterworthAnalysis2D+0xaa6>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1975 <ButterworthAnalysis2D+0x845>
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x44(%rbp)
jmp    17e3 <ButterworthAnalysis2D+0x6b3>
jmp    197a <ButterworthAnalysis2D+0x84a>
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    19be <ButterworthAnalysis2D+0x88e>
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    197a <ButterworthAnalysis2D+0x84a>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x3c(%rbp),%edx
call   1050 <decompose@plt>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1b7a <ButterworthAnalysis2D+0xa4a>
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x44(%rbp)
jmp    19e8 <ButterworthAnalysis2D+0x8b8>
jmp    1b7f <ButterworthAnalysis2D+0xa4f>
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1bc3 <ButterworthAnalysis2D+0xa93>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1b7f <ButterworthAnalysis2D+0xa4f>
jmp    1bc8 <ButterworthAnalysis2D+0xa98>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    17bd <ButterworthAnalysis2D+0x68d>
mov    -0x38(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    135f <ButterworthAnalysis2D+0x22f>
mov    -0x50(%rbp),%eax
and    $0xfffffff8,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    2018 <ButterworthAnalysis2D+0xee8>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1c57 <ButterworthAnalysis2D+0xb27>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x13b9(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x60(%rbp)
jmp    1c78 <ButterworthAnalysis2D+0xb48>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  0x1394(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1cd6 <ButterworthAnalysis2D+0xba6>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x133a(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x64(%rbp)
jmp    1cf7 <ButterworthAnalysis2D+0xbc7>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1315(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1d55 <ButterworthAnalysis2D+0xc25>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x12bb(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x68(%rbp)
jmp    1d76 <ButterworthAnalysis2D+0xc46>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  0x1296(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1dd4 <ButterworthAnalysis2D+0xca4>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x123c(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x6c(%rbp)
jmp    1df5 <ButterworthAnalysis2D+0xcc5>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  0x1217(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1e53 <ButterworthAnalysis2D+0xd23>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x11bd(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x70(%rbp)
jmp    1e74 <ButterworthAnalysis2D+0xd44>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  0x1198(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1ed2 <ButterworthAnalysis2D+0xda2>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x113e(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x74(%rbp)
jmp    1ef3 <ButterworthAnalysis2D+0xdc3>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  0x1119(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1f51 <ButterworthAnalysis2D+0xe21>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x10bf(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x78(%rbp)
jmp    1f72 <ButterworthAnalysis2D+0xe42>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  0x109a(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1fd0 <ButterworthAnalysis2D+0xea0>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x1040(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x7c(%rbp)
jmp    1ff1 <ButterworthAnalysis2D+0xec1>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  0x101b(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x40(%rbp)
jmp    1c06 <ButterworthAnalysis2D+0xad6>
jmp    201d <ButterworthAnalysis2D+0xeed>
mov    -0x40(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    20a2 <ButterworthAnalysis2D+0xf72>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    2064 <ButterworthAnalysis2D+0xf34>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xfac(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x80(%rbp)
jmp    2080 <ButterworthAnalysis2D+0xf50>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  0xf8c(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cvtsi2sd %eax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    201d <ButterworthAnalysis2D+0xeed>
movl   $0x0,-0x58(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ButterworthAnalysis2D>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %ecx,0x34(%rsp)
mov    %edx,%ebx
mov    %rdi,0x20(%rsp)
cmp    %edx,%esi
mov    %edx,%r14d
mov    %esi,%r13d
cmovg  %esi,%ebx
shl    $0x3,%ebx
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %ebx,%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
mov    $0x1,%r12d
test   %r15,%r15
je     241e <ButterworthAnalysis2D+0x12ee>
test   %rbx,%rbx
mov    0x20(%rsp),%r10
je     241e <ButterworthAnalysis2D+0x12ee>
mov    %r14d,%r11d
mov    %r14d,%ebp
imul   %r13d,%ebp
mov    %ebp,%eax
and    $0xfffffff8,%eax
mov    %eax,%ecx
mov    %eax,0x48(%rsp)
jle    11c0 <ButterworthAnalysis2D+0x90>
cmp    $0x9,%rcx
mov    $0x8,%edx
cmovae %rcx,%rdx
add    $0xffffffffffffffff,%rdx
cmp    $0x7,%rdx
jne    11c7 <ButterworthAnalysis2D+0x97>
xor    %eax,%eax
jmp    12d9 <ButterworthAnalysis2D+0x1a9>
xor    %eax,%eax
jmp    138b <ButterworthAnalysis2D+0x25b>
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffffe,%r8
lea    0x0(,%r8,8),%rax
movapd 0x1e19(%rip),%xmm8
mov    %r8,%rsi
mov    %r10,%rdi
nopl   (%rax)
movsd  (%rdi),%xmm11
movsd  0x8(%rdi),%xmm1
movsd  0x10(%rdi),%xmm4
movsd  0x18(%rdi),%xmm2
movhpd 0x40(%rdi),%xmm11
addpd  %xmm8,%xmm11
movhpd 0x48(%rdi),%xmm1
addpd  %xmm8,%xmm1
movhpd 0x50(%rdi),%xmm4
movhpd 0x58(%rdi),%xmm2
addpd  %xmm8,%xmm4
movsd  0x20(%rdi),%xmm5
movhpd 0x60(%rdi),%xmm5
addpd  %xmm8,%xmm2
movsd  0x28(%rdi),%xmm6
movhpd 0x68(%rdi),%xmm6
addpd  %xmm8,%xmm5
movsd  0x30(%rdi),%xmm7
movhpd 0x70(%rdi),%xmm7
addpd  %xmm8,%xmm6
movsd  0x38(%rdi),%xmm0
movhpd 0x78(%rdi),%xmm0
addpd  %xmm8,%xmm7
addpd  %xmm8,%xmm0
movapd %xmm4,%xmm9
unpcklpd %xmm2,%xmm9
movapd %xmm11,%xmm10
unpcklpd %xmm1,%xmm10
movapd %xmm7,%xmm12
unpcklpd %xmm0,%xmm12
movapd %xmm5,%xmm3
unpcklpd %xmm6,%xmm3
movhlps %xmm4,%xmm2
movhlps %xmm11,%xmm1
movhlps %xmm7,%xmm0
movhlps %xmm5,%xmm6
movups %xmm6,0x60(%rdi)
movups %xmm0,0x70(%rdi)
movups %xmm1,0x40(%rdi)
movups %xmm2,0x50(%rdi)
movupd %xmm3,0x20(%rdi)
movupd %xmm12,0x30(%rdi)
movupd %xmm10,(%rdi)
movupd %xmm9,0x10(%rdi)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffe,%rsi
jne    11f0 <ButterworthAnalysis2D+0xc0>
cmp    %r8,%rdx
je     138b <ButterworthAnalysis2D+0x25b>
movsd  0x1d5f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r10,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%rax,8)
movsd  0x8(%r10,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r10,%rax,8)
movsd  0x10(%r10,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r10,%rax,8)
movsd  0x18(%r10,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r10,%rax,8)
movsd  0x20(%r10,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%r10,%rax,8)
movsd  0x28(%r10,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%r10,%rax,8)
movsd  0x30(%r10,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%r10,%rax,8)
movsd  0x38(%r10,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x38(%r10,%rax,8)
add    $0x8,%rax
cmp    %rcx,%rax
jb     12f0 <ButterworthAnalysis2D+0x1c0>
mov    %ebp,%esi
mov    %ebp,0x4c(%rsp)
cmp    %ebp,%eax
jge    14a9 <ButterworthAnalysis2D+0x379>
mov    %eax,%eax
mov    %rsi,%r11
sub    %rax,%r11
cmp    $0x4,%r11
jae    13af <ButterworthAnalysis2D+0x27f>
mov    %r14d,%r11d
jmp    1486 <ButterworthAnalysis2D+0x356>
mov    %r11,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdx
mov    %rdx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     2443 <ButterworthAnalysis2D+0x1313>
movabs $0x7ffffffffffffffc,%rbp
ff ff 7f
or     $0x2,%rbp
and    %r9,%rbp
lea    (%r10,%rax,8),%rdx
add    $0x30,%rdx
xor    %edi,%edi
movapd 0x1c0f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rdi,8),%xmm1
movupd -0x20(%rdx,%rdi,8),%xmm2
movupd -0x10(%rdx,%rdi,8),%xmm3
movupd (%rdx,%rdi,8),%xmm4
addpd  %xmm0,%xmm1
addpd  %xmm0,%xmm2
movupd %xmm1,-0x30(%rdx,%rdi,8)
movupd %xmm2,-0x20(%rdx,%rdi,8)
addpd  %xmm0,%xmm3
addpd  %xmm0,%xmm4
movupd %xmm3,-0x10(%rdx,%rdi,8)
movupd %xmm4,(%rdx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1400 <ButterworthAnalysis2D+0x2d0>
test   $0x1,%r9b
je     147b <ButterworthAnalysis2D+0x34b>
add    %rax,%rdi
movupd (%r10,%rdi,8),%xmm0
movupd 0x10(%r10,%rdi,8),%xmm1
movapd 0x1b9a(%rip),%xmm2
addpd  %xmm2,%xmm0
addpd  %xmm2,%xmm1
movupd %xmm0,(%r10,%rdi,8)
movupd %xmm1,0x10(%r10,%rdi,8)
cmp    %r8,%r11
mov    %r14d,%r11d
je     14a9 <ButterworthAnalysis2D+0x379>
add    %r8,%rax
movsd  0x1bb2(%rip),%xmm0
xchg   %ax,%ax
movsd  (%r10,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1490 <ButterworthAnalysis2D+0x360>
mov    %rsi,0x60(%rsp)
mov    %rcx,0x58(%rsp)
cmpl   $0x0,0x34(%rsp)
jle    1efa <ButterworthAnalysis2D+0xdca>
movslq %r13d,%rcx
lea    0x0(,%rcx,8),%r12
lea    0x70(%r15),%rax
mov    %rax,0x70(%rsp)
lea    0x10(%r15),%rax
mov    %rax,0x80(%rsp)
lea    0x18(%r15),%rax
mov    %rax,0xa0(%rsp)
lea    0x70(%rbx),%rax
mov    %rax,0x68(%rsp)
lea    0x10(%rbx),%rax
mov    %rax,0x78(%rsp)
lea    0x38(%rbx),%rax
mov    %rax,0x98(%rsp)
mov    %rcx,%rax
shl    $0x6,%rax
mov    %rax,0x50(%rsp)
mov    $0x1,%eax
mov    %rcx,0xb0(%rsp)
jmp    1550 <ButterworthAnalysis2D+0x420>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x4(%rsp),%r13d
sar    %r13d
sar    %r11d
mov    0x88(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0x34(%rsp),%ecx
je     1efa <ButterworthAnalysis2D+0xdca>
mov    %rax,0x88(%rsp)
mov    %r11d,%edi
mov    %r13d,0x4(%rsp)
mov    %r13d,%eax
mov    %rax,0x8(%rsp)
test   %r11d,%r11d
mov    %r11d,0x14(%rsp)
mov    %rdi,0x40(%rsp)
jle    1b90 <ButterworthAnalysis2D+0xa60>
mov    0x4(%rsp),%eax
and    $0xfffffff8,%eax
mov    %eax,0x28(%rsp)
movslq %eax,%rbp
mov    0x8(%rsp),%rax
lea    (%rbx,%rax,8),%rcx
mov    %rcx,0xa8(%rsp)
lea    (%r15,%rax,8),%rax
mov    %rax,0x90(%rsp)
mov    %r10,%r13
xor    %ecx,%ecx
mov    %rbp,0x18(%rsp)
jmp    15da <ButterworthAnalysis2D+0x4aa>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x38(%rsp),%rcx
add    $0x1,%rcx
add    %r12,%r13
mov    0x40(%rsp),%rdi
cmp    %rdi,%rcx
je     1b90 <ButterworthAnalysis2D+0xa60>
mov    %rcx,%rax
imul   0xb0(%rsp),%rax
lea    (%r10,%rax,8),%r14
cmpl   $0x0,0x28(%rsp)
mov    %rcx,0x38(%rsp)
jle    1690 <ButterworthAnalysis2D+0x560>
xor    %eax,%eax
xor    %ecx,%ecx
xchg   %ax,%ax
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  0x8(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r15,%rcx,8)
movsd  0x10(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r15,%rcx,8)
movsd  0x18(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r15,%rcx,8)
movsd  0x20(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x20(%r15,%rcx,8)
movsd  0x28(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x28(%r15,%rcx,8)
movsd  0x30(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x30(%r15,%rcx,8)
movsd  0x38(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x38(%r15,%rcx,8)
add    $0x8,%rcx
add    $0x40,%rax
cmp    %rbp,%rcx
jl     1600 <ButterworthAnalysis2D+0x4d0>
add    %r13,%rax
jmp    1695 <ButterworthAnalysis2D+0x565>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    %r14,%rax
mov    0x4(%rsp),%edx
cmp    %edx,%ecx
jge    1867 <ButterworthAnalysis2D+0x737>
mov    %ecx,%ecx
mov    0x8(%rsp),%rdi
mov    %rdi,%r9
sub    %rcx,%r9
cmp    $0x4,%r9
jb     17d3 <ButterworthAnalysis2D+0x6a3>
lea    (%r15,%rcx,8),%rbp
lea    0x0(,%rcx,8),%rsi
lea    (%rax,%rdi,8),%rdi
sub    %rsi,%rdi
cmp    %rdi,%rbp
jae    16de <ButterworthAnalysis2D+0x5ae>
cmp    0x90(%rsp),%rax
jb     17ce <ButterworthAnalysis2D+0x69e>
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rsi
mov    %rsi,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r10d
and    $0x3,%r10d
cmp    $0xc,%rsi
jae    1708 <ButterworthAnalysis2D+0x5d8>
xor    %ebp,%ebp
jmp    177a <ButterworthAnalysis2D+0x64a>
movabs $0x7ffffffffffffffc,%rsi
ff ff 7f
and    %rsi,%rdi
mov    0x70(%rsp),%rsi
lea    (%rsi,%rcx,8),%rsi
xor    %ebp,%ebp
movups (%rax,%rbp,8),%xmm0
movups 0x10(%rax,%rbp,8),%xmm1
movups %xmm0,-0x70(%rsi,%rbp,8)
movups %xmm1,-0x60(%rsi,%rbp,8)
movups 0x20(%rax,%rbp,8),%xmm0
movups 0x30(%rax,%rbp,8),%xmm1
movups %xmm0,-0x50(%rsi,%rbp,8)
movups %xmm1,-0x40(%rsi,%rbp,8)
movups 0x40(%rax,%rbp,8),%xmm0
movups 0x50(%rax,%rbp,8),%xmm1
movups %xmm0,-0x30(%rsi,%rbp,8)
movups %xmm1,-0x20(%rsi,%rbp,8)
movupd 0x60(%rax,%rbp,8),%xmm0
movups 0x70(%rax,%rbp,8),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,8)
movups %xmm1,(%rsi,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1720 <ButterworthAnalysis2D+0x5f0>
test   %r10,%r10
je     17be <ButterworthAnalysis2D+0x68e>
lea    (%rax,%rbp,8),%rsi
add    $0x10,%rsi
add    %rcx,%rbp
mov    0x80(%rsp),%rdi
lea    (%rdi,%rbp,8),%rbp
shl    $0x5,%r10
xor    %edi,%edi
nopl   0x0(%rax)
movupd -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rbp,%rdi,1)
movups %xmm1,0x0(%rbp,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r10
jne    17a0 <ButterworthAnalysis2D+0x670>
cmp    %r8,%r9
je     1867 <ButterworthAnalysis2D+0x737>
add    %r8,%rcx
lea    (%rax,%r8,8),%rax
mov    0x8(%rsp),%rdi
mov    %edi,%esi
sub    %ecx,%esi
mov    %rdi,%rbp
mov    %rcx,%rdi
not    %rdi
add    %rbp,%rdi
and    $0x3,%rsi
je     1808 <ButterworthAnalysis2D+0x6d8>
nopl   0x0(%rax)
movsd  (%rax),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
add    $0x8,%rax
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    17f0 <ButterworthAnalysis2D+0x6c0>
cmp    $0x3,%rdi
jb     1867 <ButterworthAnalysis2D+0x737>
mov    0x8(%rsp),%rdi
sub    %rcx,%rdi
mov    0xa0(%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,-0x18(%rcx,%rsi,8)
movsd  0x8(%rax,%rsi,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%rsi,8)
movsd  0x10(%rax,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rsi,8)
movsd  0x18(%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1830 <ButterworthAnalysis2D+0x700>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1050 <decompose@plt>
cmpl   $0x0,0x28(%rsp)
jle    1930 <ButterworthAnalysis2D+0x800>
xor    %r14d,%r14d
xor    %eax,%eax
mov    0x18(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
movsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%r13,%rax,8)
movsd  0x20(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x20(%r13,%rax,8)
movsd  0x28(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x28(%r13,%rax,8)
movsd  0x30(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x30(%r13,%rax,8)
movsd  0x38(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x38(%r13,%rax,8)
add    $0x8,%rax
add    $0x40,%r14
cmp    %rbp,%rax
jl     1890 <ButterworthAnalysis2D+0x760>
add    %r13,%r14
mov    0x20(%rsp),%r10
mov    0x14(%rsp),%r11d
mov    0x8(%rsp),%rsi
cmp    0x4(%rsp),%eax
jge    15c0 <ButterworthAnalysis2D+0x490>
jmp    1950 <ButterworthAnalysis2D+0x820>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
mov    0x20(%rsp),%r10
mov    0x14(%rsp),%r11d
mov    0x8(%rsp),%rsi
mov    0x18(%rsp),%rbp
cmp    0x4(%rsp),%eax
jge    15c0 <ButterworthAnalysis2D+0x490>
mov    %eax,%eax
mov    %rsi,%r9
sub    %rax,%r9
cmp    $0x4,%r9
jb     1aa0 <ButterworthAnalysis2D+0x970>
cmp    0xa8(%rsp),%r14
jae    1988 <ButterworthAnalysis2D+0x858>
lea    (%r14,%rsi,8),%rcx
lea    0x0(,%rax,8),%rdx
sub    %rdx,%rcx
lea    (%rbx,%rax,8),%rdx
cmp    %rcx,%rdx
jb     1aa0 <ButterworthAnalysis2D+0x970>
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rcx
jae    19b0 <ButterworthAnalysis2D+0x880>
xor    %edx,%edx
jmp    1a32 <ButterworthAnalysis2D+0x902>
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
and    %rcx,%rdi
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups -0x70(%rcx,%rdx,8),%xmm0
movups -0x60(%rcx,%rdx,8),%xmm1
movups %xmm0,(%r14,%rdx,8)
movups %xmm1,0x10(%r14,%rdx,8)
movups -0x50(%rcx,%rdx,8),%xmm0
movups -0x40(%rcx,%rdx,8),%xmm1
movups %xmm0,0x20(%r14,%rdx,8)
movups %xmm1,0x30(%r14,%rdx,8)
movups -0x30(%rcx,%rdx,8),%xmm0
movups -0x20(%rcx,%rdx,8),%xmm1
movups %xmm0,0x40(%r14,%rdx,8)
movups %xmm1,0x50(%r14,%rdx,8)
movupd -0x10(%rcx,%rdx,8),%xmm0
movups (%rcx,%rdx,8),%xmm1
movupd %xmm0,0x60(%r14,%rdx,8)
movups %xmm1,0x70(%r14,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rdi
jne    19d0 <ButterworthAnalysis2D+0x8a0>
test   %rsi,%rsi
je     1a7d <ButterworthAnalysis2D+0x94d>
lea    (%r14,%rdx,8),%rcx
add    $0x10,%rcx
add    %rax,%rdx
mov    0x78(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
shl    $0x5,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rcx,%rdi,1)
movups %xmm1,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1a60 <ButterworthAnalysis2D+0x930>
cmp    %r8,%r9
mov    0x8(%rsp),%rsi
mov    0x18(%rsp),%rbp
je     15c0 <ButterworthAnalysis2D+0x490>
add    %r8,%rax
lea    (%r14,%r8,8),%r14
nopw   0x0(%rax,%rax,1)
mov    %esi,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %rsi,%rcx
and    $0x7,%rdx
je     1ae4 <ButterworthAnalysis2D+0x9b4>
mov    0x18(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r14)
add    $0x8,%r14
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1ac0 <ButterworthAnalysis2D+0x990>
cmp    $0x7,%rcx
jb     15c0 <ButterworthAnalysis2D+0x490>
jmp    1af3 <ButterworthAnalysis2D+0x9c3>
mov    0x18(%rsp),%rbp
cmp    $0x7,%rcx
jb     15c0 <ButterworthAnalysis2D+0x490>
mov    %rsi,%rcx
sub    %rax,%rcx
mov    0x98(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  -0x38(%rax,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
movsd  -0x30(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rdx,8)
movsd  -0x28(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rdx,8)
movsd  -0x20(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rdx,8)
movsd  -0x18(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x20(%r14,%rdx,8)
movsd  -0x10(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x28(%r14,%rdx,8)
movsd  -0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x30(%r14,%rdx,8)
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,0x38(%r14,%rdx,8)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1b10 <ButterworthAnalysis2D+0x9e0>
jmp    15c0 <ButterworthAnalysis2D+0x490>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpl   $0x0,0x4(%rsp)
jle    1530 <ButterworthAnalysis2D+0x400>
mov    %r11d,%r8d
and    $0xfffffff8,%r8d
movslq %r8d,%rbp
mov    %r10,%rsi
xor    %r14d,%r14d
mov    %r8d,0x38(%rsp)
jmp    1bd3 <ButterworthAnalysis2D+0xaa3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r14
add    $0x8,%rsi
cmp    0x8(%rsp),%r14
je     1530 <ButterworthAnalysis2D+0x400>
lea    (%r10,%r14,8),%r13
test   %r8d,%r8d
jle    1c90 <ButterworthAnalysis2D+0xb60>
mov    %rsi,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rcx,%rax
movsd  (%rcx),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
add    %r12,%rcx
movsd  (%rax,%r12,1),%xmm0
movsd  %xmm0,0x8(%r15,%rdx,8)
movsd  (%r12,%rcx,1),%xmm0
add    %r12,%rcx
movsd  %xmm0,0x10(%r15,%rdx,8)
movsd  (%r12,%rcx,1),%xmm0
add    %r12,%rcx
movsd  %xmm0,0x18(%r15,%rdx,8)
movsd  (%r12,%rcx,1),%xmm0
add    %r12,%rcx
movsd  %xmm0,0x20(%r15,%rdx,8)
movsd  (%r12,%rcx,1),%xmm0
add    %r12,%rcx
movsd  %xmm0,0x28(%r15,%rdx,8)
movsd  (%r12,%rcx,1),%xmm0
add    %r12,%rcx
movsd  %xmm0,0x30(%r15,%rdx,8)
movsd  (%r12,%rcx,1),%xmm0
add    %r12,%rcx
movsd  %xmm0,0x38(%r15,%rdx,8)
add    $0x8,%rdx
add    %r12,%rcx
cmp    %rbp,%rdx
jl     1bf0 <ButterworthAnalysis2D+0xac0>
add    0x50(%rsp),%rax
jmp    1c95 <ButterworthAnalysis2D+0xb65>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %edx,%edx
mov    %r13,%rax
mov    %rsi,0x28(%rsp)
cmp    %r11d,%edx
jge    1d26 <ButterworthAnalysis2D+0xbf6>
mov    %edx,%ecx
mov    %edi,%esi
sub    %edx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rdi,%rdx
and    $0x3,%rsi
je     1cd7 <ButterworthAnalysis2D+0xba7>
nopl   0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
add    $0x1,%rcx
add    %r12,%rax
add    $0xffffffffffffffff,%rsi
jne    1cc0 <ButterworthAnalysis2D+0xb90>
cmp    $0x3,%rdx
jb     1d26 <ButterworthAnalysis2D+0xbf6>
nopl   (%rax)
movsd  (%rax),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
movsd  (%rax,%r12,1),%xmm0
add    %r12,%rax
movsd  %xmm0,0x8(%r15,%rcx,8)
movsd  (%r12,%rax,1),%xmm0
add    %r12,%rax
movsd  %xmm0,0x10(%r15,%rcx,8)
movsd  (%r12,%rax,1),%xmm0
add    %r12,%rax
movsd  %xmm0,0x18(%r15,%rcx,8)
add    $0x4,%rcx
add    %r12,%rax
cmp    %rcx,%rdi
jne    1ce0 <ButterworthAnalysis2D+0xbb0>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r11d,%edx
call   1050 <decompose@plt>
mov    0x38(%rsp),%r8d
test   %r8d,%r8d
jle    1e00 <ButterworthAnalysis2D+0xcd0>
mov    0x28(%rsp),%rsi
mov    %rsi,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    %rax,%r13
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rax)
movsd  0x8(%rbx,%rcx,8),%xmm0
add    %r12,%rax
movsd  %xmm0,0x0(%r13,%r12,1)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rax,1)
add    %r12,%rax
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rax,1)
add    %r12,%rax
movsd  0x20(%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rax,1)
add    %r12,%rax
movsd  0x28(%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rax,1)
add    %r12,%rax
movsd  0x30(%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rax,1)
add    %r12,%rax
movsd  0x38(%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rax,1)
add    %r12,%rax
add    $0x8,%rcx
add    %r12,%rax
cmp    %rbp,%rcx
jl     1d50 <ButterworthAnalysis2D+0xc20>
add    0x50(%rsp),%r13
mov    0x20(%rsp),%r10
mov    0x14(%rsp),%r11d
mov    0x40(%rsp),%rdi
cmp    %r11d,%ecx
jge    1bc0 <ButterworthAnalysis2D+0xa90>
jmp    1e1f <ButterworthAnalysis2D+0xcef>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ecx,%ecx
mov    0x20(%rsp),%r10
mov    0x14(%rsp),%r11d
mov    0x40(%rsp),%rdi
mov    0x28(%rsp),%rsi
cmp    %r11d,%ecx
jge    1bc0 <ButterworthAnalysis2D+0xa90>
mov    %ecx,%eax
mov    %edi,%edx
sub    %ecx,%edx
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
and    $0x7,%rdx
je     1e58 <ButterworthAnalysis2D+0xd28>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13)
add    $0x1,%rax
add    %r12,%r13
add    $0xffffffffffffffff,%rdx
jne    1e40 <ButterworthAnalysis2D+0xd10>
cmp    $0x7,%rcx
jb     1bc0 <ButterworthAnalysis2D+0xa90>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13)
movsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%r12,1)
add    %r12,%r13
movsd  0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%r13,1)
add    %r12,%r13
movsd  0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%r13,1)
add    %r12,%r13
movsd  0x20(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%r13,1)
add    %r12,%r13
movsd  0x28(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%r13,1)
add    %r12,%r13
movsd  0x30(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%r13,1)
add    %r12,%r13
movsd  0x38(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%r13,1)
add    %r12,%r13
add    $0x8,%rax
add    %r12,%r13
cmp    %rax,%rdi
jne    1e70 <ButterworthAnalysis2D+0xd40>
jmp    1bc0 <ButterworthAnalysis2D+0xa90>
mov    $0x0,%eax
cmpl   $0x0,0x48(%rsp)
mov    0x4c(%rsp),%r8d
mov    0x60(%rsp),%r9
jle    2321 <ButterworthAnalysis2D+0x11f1>
mov    0x58(%rsp),%rbp
cmp    $0x9,%rbp
mov    $0x8,%ecx
cmovae %rbp,%rcx
add    $0xffffffffffffffff,%rcx
cmp    $0x7,%rcx
jne    1f37 <ButterworthAnalysis2D+0xe07>
xor    %eax,%eax
jmp    216d <ButterworthAnalysis2D+0x103d>
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rdx
and    $0xfffffffffffffffe,%rdx
lea    0x0(,%rdx,8),%rax
xorpd  %xmm8,%xmm8
movapd 0x10b4(%rip),%xmm9
movapd 0x10bb(%rip),%xmm10
mov    %rdx,%rsi
mov    %r10,%rdi
nopl   0x0(%rax,%rax,1)
movsd  (%rdi),%xmm0
movhpd 0x40(%rdi),%xmm0
movapd %xmm0,%xmm1
cmpltpd %xmm8,%xmm1
movapd %xmm10,%xmm3
andpd  %xmm1,%xmm3
andnpd %xmm9,%xmm1
orpd   %xmm3,%xmm1
addpd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm0
cvtdq2pd %xmm0,%xmm13
movsd  0x8(%rdi),%xmm0
movhpd 0x48(%rdi),%xmm0
movapd %xmm0,%xmm1
cmpltpd %xmm8,%xmm1
movapd %xmm10,%xmm4
andpd  %xmm1,%xmm4
andnpd %xmm9,%xmm1
orpd   %xmm4,%xmm1
addpd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm0
cvtdq2pd %xmm0,%xmm11
movsd  0x10(%rdi),%xmm0
movhpd 0x50(%rdi),%xmm0
movapd %xmm0,%xmm1
cmpltpd %xmm8,%xmm1
movapd %xmm10,%xmm5
andpd  %xmm1,%xmm5
andnpd %xmm9,%xmm1
orpd   %xmm5,%xmm1
addpd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm0
cvtdq2pd %xmm0,%xmm14
movsd  0x18(%rdi),%xmm0
movhpd 0x58(%rdi),%xmm0
movapd %xmm0,%xmm1
cmpltpd %xmm8,%xmm1
movapd %xmm10,%xmm6
andpd  %xmm1,%xmm6
andnpd %xmm9,%xmm1
orpd   %xmm6,%xmm1
addpd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm0
cvtdq2pd %xmm0,%xmm12
movsd  0x20(%rdi),%xmm0
movhpd 0x60(%rdi),%xmm0
movapd %xmm0,%xmm1
cmpltpd %xmm8,%xmm1
movapd %xmm10,%xmm7
andpd  %xmm1,%xmm7
andnpd %xmm9,%xmm1
orpd   %xmm7,%xmm1
addpd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm0
cvtdq2pd %xmm0,%xmm5
movsd  0x28(%rdi),%xmm0
movhpd 0x68(%rdi),%xmm0
movapd %xmm0,%xmm1
cmpltpd %xmm8,%xmm1
movapd %xmm10,%xmm2
andpd  %xmm1,%xmm2
andnpd %xmm9,%xmm1
orpd   %xmm2,%xmm1
addpd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm0
cvtdq2pd %xmm0,%xmm0
movsd  0x30(%rdi),%xmm1
movhpd 0x70(%rdi),%xmm1
movapd %xmm1,%xmm2
cmpltpd %xmm8,%xmm2
movapd %xmm10,%xmm4
andpd  %xmm2,%xmm4
andnpd %xmm9,%xmm2
orpd   %xmm4,%xmm2
addpd  %xmm1,%xmm2
cvttpd2dq %xmm2,%xmm1
cvtdq2pd %xmm1,%xmm3
movsd  0x38(%rdi),%xmm2
movhpd 0x78(%rdi),%xmm2
movapd %xmm2,%xmm4
cmpltpd %xmm8,%xmm4
movapd %xmm10,%xmm6
andpd  %xmm4,%xmm6
andnpd %xmm9,%xmm4
orpd   %xmm6,%xmm4
addpd  %xmm2,%xmm4
cvttpd2dq %xmm4,%xmm2
cvtdq2pd %xmm2,%xmm2
movaps %xmm14,%xmm4
movlhps %xmm12,%xmm4
movaps %xmm13,%xmm6
movlhps %xmm11,%xmm6
movaps %xmm3,%xmm1
movlhps %xmm2,%xmm1
movapd %xmm5,%xmm7
unpcklpd %xmm0,%xmm7
unpckhpd %xmm12,%xmm14
unpckhpd %xmm11,%xmm13
unpckhpd %xmm2,%xmm3
unpckhpd %xmm0,%xmm5
movupd %xmm5,0x60(%rdi)
movups %xmm3,0x70(%rdi)
movups %xmm13,0x40(%rdi)
movups %xmm14,0x50(%rdi)
movupd %xmm7,0x20(%rdi)
movups %xmm1,0x30(%rdi)
movups %xmm6,(%rdi)
movups %xmm4,0x10(%rdi)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1f70 <ButterworthAnalysis2D+0xe40>
cmp    %rdx,%rcx
je     2321 <ButterworthAnalysis2D+0x11f1>
xorpd  %xmm0,%xmm0
movsd  0xecf(%rip),%xmm1
movsd  0xecf(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r10,%rax,8),%xmm3
movapd %xmm3,%xmm4
cmpltsd %xmm0,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm1,%xmm5
andnpd %xmm2,%xmm4
orpd   %xmm5,%xmm4
addsd  %xmm3,%xmm4
cvttpd2dq %xmm4,%xmm3
cvtdq2pd %xmm3,%xmm3
movsd  0x8(%r10,%rax,8),%xmm4
movapd %xmm4,%xmm5
cmpltsd %xmm0,%xmm5
movapd %xmm5,%xmm6
andpd  %xmm1,%xmm6
andnpd %xmm2,%xmm5
orpd   %xmm6,%xmm5
addsd  %xmm4,%xmm5
cvttpd2dq %xmm5,%xmm4
cvtdq2pd %xmm4,%xmm4
movlhps %xmm4,%xmm3
movups %xmm3,(%r10,%rax,8)
movsd  0x10(%r10,%rax,8),%xmm3
movapd %xmm3,%xmm4
cmpltsd %xmm0,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm1,%xmm5
andnpd %xmm2,%xmm4
orpd   %xmm5,%xmm4
addsd  %xmm3,%xmm4
cvttpd2dq %xmm4,%xmm3
cvtdq2pd %xmm3,%xmm3
movsd  0x18(%r10,%rax,8),%xmm4
movapd %xmm4,%xmm5
cmpltsd %xmm0,%xmm5
movapd %xmm5,%xmm6
andpd  %xmm1,%xmm6
andnpd %xmm2,%xmm5
orpd   %xmm6,%xmm5
addsd  %xmm4,%xmm5
cvttpd2dq %xmm5,%xmm4
cvtdq2pd %xmm4,%xmm4
movlhps %xmm4,%xmm3
movups %xmm3,0x10(%r10,%rax,8)
movsd  0x20(%r10,%rax,8),%xmm3
movapd %xmm3,%xmm4
cmpltsd %xmm0,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm1,%xmm5
andnpd %xmm2,%xmm4
orpd   %xmm5,%xmm4
addsd  %xmm3,%xmm4
cvttpd2dq %xmm4,%xmm3
cvtdq2pd %xmm3,%xmm3
movsd  0x28(%r10,%rax,8),%xmm4
movapd %xmm4,%xmm5
cmpltsd %xmm0,%xmm5
movapd %xmm5,%xmm6
andpd  %xmm1,%xmm6
andnpd %xmm2,%xmm5
orpd   %xmm6,%xmm5
addsd  %xmm4,%xmm5
cvttpd2dq %xmm5,%xmm4
cvtdq2pd %xmm4,%xmm4
movlhps %xmm4,%xmm3
movups %xmm3,0x20(%r10,%rax,8)
movsd  0x30(%r10,%rax,8),%xmm3
movapd %xmm3,%xmm4
cmpltsd %xmm0,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm1,%xmm5
andnpd %xmm2,%xmm4
orpd   %xmm5,%xmm4
addsd  %xmm3,%xmm4
cvttpd2dq %xmm4,%xmm3
cvtdq2pd %xmm3,%xmm3
movsd  0x38(%r10,%rax,8),%xmm4
movapd %xmm4,%xmm5
cmpltsd %xmm0,%xmm5
movapd %xmm5,%xmm6
andpd  %xmm1,%xmm6
andnpd %xmm2,%xmm5
orpd   %xmm6,%xmm5
addsd  %xmm4,%xmm5
cvttpd2dq %xmm5,%xmm4
cvtdq2pd %xmm4,%xmm4
unpcklpd %xmm4,%xmm3
movupd %xmm3,0x30(%r10,%rax,8)
add    $0x8,%rax
cmp    %rbp,%rax
jb     2190 <ButterworthAnalysis2D+0x1060>
cmp    %r8d,%eax
jge    241b <ButterworthAnalysis2D+0x12eb>
mov    %eax,%esi
mov    %r9,%rcx
sub    %rsi,%rcx
cmp    $0x4,%rcx
jae    2340 <ButterworthAnalysis2D+0x1210>
mov    %rsi,%rax
jmp    23e0 <ButterworthAnalysis2D+0x12b0>
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
lea    (%rdx,%rsi,1),%rax
lea    (%r10,%rsi,8),%rsi
add    $0x10,%rsi
xor    %edi,%edi
xorpd  %xmm0,%xmm0
movapd 0xcaf(%rip),%xmm1
movapd 0xcb7(%rip),%xmm2
nopl   0x0(%rax)
movupd -0x10(%rsi,%rdi,8),%xmm3
movupd (%rsi,%rdi,8),%xmm4
movapd %xmm3,%xmm5
cmpltpd %xmm0,%xmm5
movapd %xmm4,%xmm6
cmpltpd %xmm0,%xmm6
movapd %xmm2,%xmm7
andpd  %xmm5,%xmm7
andnpd %xmm1,%xmm5
orpd   %xmm7,%xmm5
movapd %xmm2,%xmm7
andpd  %xmm6,%xmm7
andnpd %xmm1,%xmm6
orpd   %xmm7,%xmm6
addpd  %xmm3,%xmm5
addpd  %xmm4,%xmm6
cvttpd2dq %xmm5,%xmm3
cvttpd2dq %xmm6,%xmm4
cvtdq2pd %xmm3,%xmm3
cvtdq2pd %xmm4,%xmm4
movupd %xmm3,-0x10(%rsi,%rdi,8)
movups %xmm4,(%rsi,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    2370 <ButterworthAnalysis2D+0x1240>
xor    %r12d,%r12d
cmp    %rdx,%rcx
je     241e <ButterworthAnalysis2D+0x12ee>
xorpd  %xmm0,%xmm0
lea    0xc45(%rip),%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%r10,%rax,8),%xmm1
xor    %edx,%edx
ucomisd %xmm1,%xmm0
seta   %dl
addsd  (%rcx,%rdx,8),%xmm1
cvttpd2dq %xmm1,%xmm1
cvtdq2pd %xmm1,%xmm1
movlpd %xmm1,(%r10,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    23f0 <ButterworthAnalysis2D+0x12c0>
xor    %r12d,%r12d
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r12d,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
test   $0x1,%r9b
jne    144e <ButterworthAnalysis2D+0x31e>
jmp    147b <ButterworthAnalysis2D+0x34b>

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

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