#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 double clock_t;

/* Variables and functions */
int /*<<< orphan*/ adjointinvwavelet_transform3D(float *, int, int, int, int,
                                                 int, float *);
int /*<<< orphan*/ adjointwavelet_transform3D(float *, int, int, int, int, int,
                                              float *);
scalar_t__ calloc(unsigned int, int);
double clock();
int fabs(double);
int /*<<< orphan*/ free(float *);
int /*<<< orphan*/ invwavelet_transform3D(float *, int, int, int, int, int,
                                          float *);
double log10(double);
int /*<<< orphan*/ printf(char *, ...);
unsigned int random();
int sqrt(double);
int /*<<< orphan*/ wavelet_transform3D(float *, int, int, int, int, int,
                                       float *);
int main() {
  int Xlength = 400;
  int Ylength = 100;
  int Zlength = 400;
  clock_t time0, time1, time2, time3, time4, time5, time6, time7;
  clock_t time3a, time5a;
  int k, l, j;
  float *randbody, *randcoeff;
  float *waveletcoeff;
  float *invwaveletvector, *adjointvector, *invadjointvector;
  float *coeff_save, *body_save;
  unsigned int a = 0;
  unsigned int mask12 = 0xfff;
  float *ptr;
  int size;
  double sum1, sum2, sum3, sum4;
  double xsum1, ysum1, zsum1;
  double xsum2, ysum2, zsum2;
  double xsum3, ysum3, zsum3;
  double xsum4, ysum4, zsum4;
  float *Dptr, *iWptr, *Wptr, *Cptr, *Aptr, *iAptr;
  ;
  printf("Test of adjoint with symmetric biorthogonal filters \n          "
         "Filterlength=%d, Number of scales=%d\n\n",
         3, 2);
  size = Xlength * Ylength * Zlength;
  printf("Xlength=%d, Ylength=%d, Zlength=%d\n", Xlength, Ylength, Zlength);
  printf("size=%d,\n", size);
  randbody = (float *)calloc((unsigned int)size, sizeof(float));
  body_save = (float *)calloc((unsigned int)size, sizeof(float));
  randcoeff = (float *)calloc((unsigned int)size, sizeof(float));
  coeff_save = (float *)calloc((unsigned int)size, sizeof(float));
  waveletcoeff = (float *)calloc((unsigned int)size, sizeof(float));
  invwaveletvector = (float *)calloc((unsigned int)size, sizeof(float));
  adjointvector = (float *)calloc((unsigned int)size, sizeof(float));
  invadjointvector = (float *)calloc((unsigned int)size, sizeof(float));
  time0 = clock();
  ptr = randbody;
  for (k = 0; k < size; k++) {
    a = mask12 & random();
    *ptr++ = (float)a;
  }
  ptr = randcoeff;
  for (k = 0; k < size; k++) {
    a = mask12 & random();
    *ptr++ = (float)a;
  }
  time1 = clock();
  for (k = 0; k < size; k++)
    body_save[k] = randbody[k];
  for (k = 0; k < size; k++)
    coeff_save[k] = randcoeff[k];
  time2 = clock();
  adjointinvwavelet_transform3D(randbody, Xlength, Ylength, Zlength, 3, 2,
                                invadjointvector);
  time3 = clock();
  for (k = 0; k < size; k++)
    randbody[k] = body_save[k];
  time3a = clock();
  wavelet_transform3D(randbody, Xlength, Ylength, Zlength, 3, 2, waveletcoeff);
  time4 = clock();
  adjointwavelet_transform3D(randcoeff, Xlength, Ylength, Zlength, 3, 2,
                             adjointvector);
  time5 = clock();
  for (k = 0; k < size; k++)
    randcoeff[k] = coeff_save[k];
  time5a = clock();
  invwavelet_transform3D(randcoeff, Xlength, Ylength, Zlength, 3, 2,
                         invwaveletvector);
  time6 = clock();
  sum1 = 0.0;
  printf("\n");
  Dptr = body_save;
  Cptr = coeff_save;
  Aptr = adjointvector;
  iWptr = invwaveletvector;
  Wptr = waveletcoeff;
  iAptr = invadjointvector;
  zsum1 = 0.0;
  zsum2 = 0.0;
  zsum3 = 0.0;
  zsum4 = 0.0;
  for (k = 0; k < Zlength; k++) {
    ysum1 = 0.0;
    ysum2 = 0.0;
    ysum3 = 0.0;
    ysum4 = 0.0;
    for (j = 0; j < Ylength; j++) {
      xsum1 = 0.0;
      xsum2 = 0.0;
      xsum3 = 0.0;
      xsum4 = 0.0;
      for (l = 0; l < Xlength; l++) {
        xsum1 += (*Dptr) * (*Dptr);
        xsum2 += (*Cptr) * (*Cptr);
        xsum3 += (*Aptr++) * (*Dptr) - (*Cptr) * (*Wptr++);
        xsum4 += (*iAptr++) * (*Cptr++) - (*Dptr++) * (*iWptr++);
      }
      ysum1 += xsum1;
      ysum2 += xsum2;
      ysum3 += xsum3;
      ysum4 += xsum4;
    }
    zsum1 += ysum1;
    zsum2 += ysum2;
    zsum3 += ysum3;
    zsum4 += ysum4;
  }
  sum1 = zsum1;
  sum2 = zsum2;
  sum3 = zsum3;
  sum4 = zsum4;
  printf("\n");
  time7 = clock();
  printf("Inner produkt1=%e, Inner produkt2 = %e, adjointdiff = "
         "%e,invadjointdiff = %e\n",
         sum1, sum2, sum3, sum4);
  printf("SignaltoError rate adjoint  %f decibel\n",
         (-10.0 * log10((double)(fabs(sum3) / sqrt(sum1 * sum2)))));
  printf("SignaltoError rate invadjoint  %f decibel\n",
         (-10.0 * log10((double)(fabs(sum4) / sqrt(sum1 * sum2)))));
  printf(
      "Size %d x %d x %d,Gen Rand:%f sek,Cpy File  %fe Sek;\n    iAT  %f sek, "
      "WT;  %f sek, AT;  %f sek,  iWT;  %f sek, \n , Inner prod %f sek\n",
      Xlength, Ylength, Zlength, 0.000001 * (time1 - time0),
      0.000001 * ((time2 - time1) + (time3a - time3) + (time5a - time5)),
      0.000001 * (time3 - time2), 0.000001 * (time4 - time3a),
      0.000001 * (time5 - time4), 0.000001 * (time6 - time5a),
      0.000001 * (time7 - time6));
  if (randbody != NULL)
    free(randbody);
  if (randcoeff != NULL)
    free(randcoeff);
  if (adjointvector != NULL)
    free(adjointvector);
  if (waveletcoeff != NULL)
    free(waveletcoeff);
  if (invwaveletvector != NULL)
    free(invwaveletvector);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x190,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x190,-0x8(%rbp)
movl   $0x64,-0xc(%rbp)
movl   $0x190,-0x10(%rbp)
movl   $0x0,-0xb4(%rbp)
movl   $0xfff,-0xb8(%rbp)
lea    0xe0e(%rip),%rdi
mov    $0x3,%esi
mov    $0x2,%edx
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x8(%rbp),%eax
imul   -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
lea    0xe42(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0xc4(%rbp),%esi
lea    0xe52(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0xc4(%rbp),%edi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0xc4(%rbp),%edi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0xb0(%rbp)
mov    -0xc4(%rbp),%edi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x80(%rbp)
mov    -0xc4(%rbp),%edi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0xa8(%rbp)
mov    -0xc4(%rbp),%edi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0xc4(%rbp),%edi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x90(%rbp)
mov    -0xc4(%rbp),%edi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x98(%rbp)
mov    -0xc4(%rbp),%edi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0xa0(%rbp)
mov    $0x0,%al
call   1040 <clock@plt>
movsd  %xmm0,-0x18(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0xc0(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    1383 <main+0x1c3>
mov    -0xb8(%rbp),%eax
mov    %eax,-0x17c(%rbp)
xor    %eax,%eax
call   10a0 <random@plt>
mov    %eax,%ecx
mov    -0x17c(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cvtsi2ss %rax,%xmm0
mov    -0xc0(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xc0(%rbp)
movss  %xmm0,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    131f <main+0x15f>
mov    -0x80(%rbp),%rax
mov    %rax,-0xc0(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    13f9 <main+0x239>
mov    -0xb8(%rbp),%eax
mov    %eax,-0x180(%rbp)
xor    %eax,%eax
call   10a0 <random@plt>
mov    %eax,%ecx
mov    -0x180(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cvtsi2ss %rax,%xmm0
mov    -0xc0(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xc0(%rbp)
movss  %xmm0,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1395 <main+0x1d5>
mov    $0x0,%al
call   1040 <clock@plt>
movsd  %xmm0,-0x20(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    1446 <main+0x286>
mov    -0x78(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    140c <main+0x24c>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    1487 <main+0x2c7>
mov    -0x80(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    144d <main+0x28d>
mov    $0x0,%al
call   1040 <clock@plt>
movsd  %xmm0,-0x28(%rbp)
mov    -0x78(%rbp),%rdi
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
mov    -0xa0(%rbp),%rax
mov    $0x3,%r8d
mov    $0x2,%r9d
mov    %rax,(%rsp)
call   10e0 <adjointinvwavelet_transform3D@plt>
mov    $0x0,%al
call   1040 <clock@plt>
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    1509 <main+0x349>
mov    -0xb0(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    14cf <main+0x30f>
mov    $0x0,%al
call   1040 <clock@plt>
movsd  %xmm0,-0x58(%rbp)
mov    -0x78(%rbp),%rdi
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
mov    -0x88(%rbp),%rax
mov    $0x3,%r8d
mov    $0x2,%r9d
mov    %rax,(%rsp)
call   10d0 <wavelet_transform3D@plt>
mov    $0x0,%al
call   1040 <clock@plt>
movsd  %xmm0,-0x38(%rbp)
mov    -0x80(%rbp),%rdi
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
mov    -0x98(%rbp),%rax
mov    $0x3,%r8d
mov    $0x2,%r9d
mov    %rax,(%rsp)
call   1060 <adjointwavelet_transform3D@plt>
mov    $0x0,%al
call   1040 <clock@plt>
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    15c0 <main+0x400>
mov    -0xa8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1586 <main+0x3c6>
mov    $0x0,%al
call   1040 <clock@plt>
movsd  %xmm0,-0x60(%rbp)
mov    -0x80(%rbp),%rdi
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
mov    -0x90(%rbp),%rax
mov    $0x3,%r8d
mov    $0x2,%r9d
mov    %rax,(%rsp)
call   1090 <invwavelet_transform3D@plt>
mov    $0x0,%al
call   1040 <clock@plt>
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
lea    0xa61(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0xb0(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0x178(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1967 <main+0x7a7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18f9 <main+0x739>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    188b <main+0x6cb>
mov    -0x150(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x150(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x168(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x168(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x170(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x170(%rbp)
movss  (%rax),%xmm0
mov    -0x150(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x168(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x160(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x160(%rbp)
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x178(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x178(%rbp)
movss  (%rax),%xmm0
mov    -0x168(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x168(%rbp)
movss  (%rax),%xmm2
mov    -0x150(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x150(%rbp)
movss  (%rax),%xmm1
mov    -0x158(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x158(%rbp)
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    171f <main+0x55f>
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
addsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
addsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    16e0 <main+0x520>
movsd  -0xf8(%rbp),%xmm0
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
addsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
addsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
addsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    16a1 <main+0x4e1>
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
lea    0x6c6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    $0x0,%al
call   1040 <clock@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm3
ff
lea    0x6bc(%rip),%rdi
mov    $0x4,%al
call   1050 <printf@plt>
movsd  -0xe0(%rbp),%xmm0
ff
call   1080 <fabs@plt>
mov    %eax,-0x188(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
call   10c0 <sqrt@plt>
mov    %eax,%ecx
mov    -0x188(%rbp),%eax
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
call   10b0 <log10@plt>
movaps %xmm0,%xmm1
movsd  0x5d2(%rip),%xmm0
mulsd  %xmm1,%xmm0
lea    0x6b1(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movsd  -0xe8(%rbp),%xmm0
ff
call   1080 <fabs@plt>
mov    %eax,-0x184(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
call   10c0 <sqrt@plt>
mov    %eax,%ecx
mov    -0x184(%rbp),%eax
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
call   10b0 <log10@plt>
movaps %xmm0,%xmm1
movsd  0x579(%rip),%xmm0
mulsd  %xmm1,%xmm0
lea    0x680(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
movsd  -0x20(%rbp),%xmm1
subsd  -0x18(%rbp),%xmm1
movsd  0x544(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  -0x28(%rbp),%xmm2
subsd  -0x20(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
subsd  -0x30(%rbp),%xmm1
addsd  %xmm1,%xmm2
movsd  -0x60(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
addsd  %xmm1,%xmm2
movsd  0x512(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  -0x30(%rbp),%xmm3
subsd  -0x28(%rbp),%xmm3
movsd  0x4fc(%rip),%xmm2
mulsd  %xmm3,%xmm2
movsd  -0x38(%rbp),%xmm4
subsd  -0x58(%rbp),%xmm4
movsd  0x4e6(%rip),%xmm3
mulsd  %xmm4,%xmm3
movsd  -0x40(%rbp),%xmm5
subsd  -0x38(%rbp),%xmm5
movsd  0x4d0(%rip),%xmm4
mulsd  %xmm5,%xmm4
movsd  -0x48(%rbp),%xmm6
subsd  -0x60(%rbp),%xmm6
movsd  0x4ba(%rip),%xmm5
mulsd  %xmm6,%xmm5
movsd  -0x50(%rbp),%xmm7
subsd  -0x48(%rbp),%xmm7
movsd  0x4a4(%rip),%xmm6
mulsd  %xmm7,%xmm6
lea    0x5de(%rip),%rdi
mov    $0x7,%al
call   1050 <printf@plt>
cmpq   $0x0,-0x78(%rbp)
je     1b82 <main+0x9c2>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x80(%rbp)
je     1b96 <main+0x9d6>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x98(%rbp)
je     1bb0 <main+0x9f0>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x88(%rbp)
je     1bca <main+0xa0a>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x90(%rbp)
je     1be4 <main+0xa24>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x190,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
lea    0xe28(%rip),%rdi
mov    $0x3,%esi
mov    $0x2,%edx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xe76(%rip),%rdi
mov    $0x190,%esi
mov    $0x64,%edx
mov    $0x190,%ecx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xe7d(%rip),%rdi
mov    $0xf42400,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xf42400,%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,%rbp
mov    $0xf42400,%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,0x10(%rsp)
mov    $0xf42400,%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,%r12
mov    $0xf42400,%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,%r14
mov    $0xf42400,%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,0x38(%rsp)
mov    $0xf42400,%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,%r13
mov    $0xf42400,%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,0x30(%rsp)
mov    $0xf42400,%edi
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,0x8(%rsp)
xor    %eax,%eax
call   1050 <clock@plt>
movsd  %xmm0,0x98(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
call   10b0 <random@plt>
and    $0xfff,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x0(%rbp,%rbx,4)
add    $0x1,%rbx
cmp    $0xf42400,%ebx
jne    12e0 <main+0x110>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
call   10b0 <random@plt>
and    $0xfff,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%r12,%rbx,4)
add    $0x1,%rbx
cmp    $0xf42400,%ebx
jne    1310 <main+0x140>
xor    %eax,%eax
call   1050 <clock@plt>
mov    0x10(%rsp),%rcx
lea    0x3d09000(%rcx),%rbx
lea    0x3d09000(%rbp),%r15
cmp    %r15,%rcx
mov    %r13,0x28(%rsp)
movsd  %xmm0,0x90(%rsp)
jae    13b9 <main+0x1e9>
cmp    %rbx,%rbp
jae    13b9 <main+0x1e9>
mov    $0x4,%eax
nopl   0x0(%rax)
movss  -0x10(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x10(%rcx,%rax,4)
movss  -0xc(%rbp,%rax,4),%xmm0
movss  %xmm0,-0xc(%rcx,%rax,4)
movss  -0x8(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x8(%rcx,%rax,4)
movss  -0x4(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x4(%rcx,%rax,4)
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
add    $0x5,%rax
cmp    $0xf42404,%rax
jne    1370 <main+0x1a0>
jmp    1437 <main+0x267>
mov    $0x24,%eax
xchg   %ax,%ax
movups -0x90(%rbp,%rax,4),%xmm0
ff
movups -0x80(%rbp,%rax,4),%xmm1
movups %xmm0,-0x90(%rcx,%rax,4)
ff
movups %xmm1,-0x80(%rcx,%rax,4)
movups -0x70(%rbp,%rax,4),%xmm0
movups -0x60(%rbp,%rax,4),%xmm1
movups %xmm0,-0x70(%rcx,%rax,4)
movups %xmm1,-0x60(%rcx,%rax,4)
movups -0x50(%rbp,%rax,4),%xmm0
movups -0x40(%rbp,%rax,4),%xmm1
movups %xmm0,-0x50(%rcx,%rax,4)
movups %xmm1,-0x40(%rcx,%rax,4)
movups -0x30(%rbp,%rax,4),%xmm0
movups -0x20(%rbp,%rax,4),%xmm1
movups %xmm0,-0x30(%rcx,%rax,4)
movups %xmm1,-0x20(%rcx,%rax,4)
movups -0x10(%rbp,%rax,4),%xmm0
movupd 0x0(%rbp,%rax,4),%xmm1
movups %xmm0,-0x10(%rcx,%rax,4)
movupd %xmm1,(%rcx,%rax,4)
add    $0x28,%rax
cmp    $0xf42424,%rax
jne    13c0 <main+0x1f0>
lea    0x3d09000(%r14),%r13
lea    0x3d09000(%r12),%rax
03
cmp    %rax,%r14
mov    %rax,0x40(%rsp)
jae    14b5 <main+0x2e5>
cmp    %r13,%r12
jae    14b5 <main+0x2e5>
mov    $0x4,%eax
nopw   0x0(%rax,%rax,1)
movss  -0x10(%r12,%rax,4),%xmm0
movss  %xmm0,-0x10(%r14,%rax,4)
movss  -0xc(%r12,%rax,4),%xmm0
movss  %xmm0,-0xc(%r14,%rax,4)
movss  -0x8(%r12,%rax,4),%xmm0
movss  %xmm0,-0x8(%r14,%rax,4)
movss  -0x4(%r12,%rax,4),%xmm0
movss  %xmm0,-0x4(%r14,%rax,4)
movss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%r14,%rax,4)
add    $0x5,%rax
cmp    $0xf42404,%rax
jne    1460 <main+0x290>
jmp    154e <main+0x37e>
mov    $0x24,%eax
nopw   0x0(%rax,%rax,1)
movups -0x90(%r12,%rax,4),%xmm0
ff ff
movups -0x80(%r12,%rax,4),%xmm1
movups %xmm0,-0x90(%r14,%rax,4)
ff ff
movups %xmm1,-0x80(%r14,%rax,4)
movups -0x70(%r12,%rax,4),%xmm0
movups -0x60(%r12,%rax,4),%xmm1
movups %xmm0,-0x70(%r14,%rax,4)
movups %xmm1,-0x60(%r14,%rax,4)
movups -0x50(%r12,%rax,4),%xmm0
movups -0x40(%r12,%rax,4),%xmm1
movups %xmm0,-0x50(%r14,%rax,4)
movups %xmm1,-0x40(%r14,%rax,4)
movups -0x30(%r12,%rax,4),%xmm0
movups -0x20(%r12,%rax,4),%xmm1
movups %xmm0,-0x30(%r14,%rax,4)
movups %xmm1,-0x20(%r14,%rax,4)
movups -0x10(%r12,%rax,4),%xmm0
movupd (%r12,%rax,4),%xmm1
movups %xmm0,-0x10(%r14,%rax,4)
movupd %xmm1,(%r14,%rax,4)
add    $0x28,%rax
cmp    $0xf42424,%rax
jne    14c0 <main+0x2f0>
xor    %eax,%eax
call   1050 <clock@plt>
movsd  %xmm0,0x80(%rsp)
mov    0x8(%rsp),%rax
mov    %rax,(%rsp)
mov    %rbp,%rdi
mov    $0x190,%esi
mov    $0x64,%edx
mov    $0x190,%ecx
mov    $0x3,%r8d
mov    $0x2,%r9d
call   10f0 <adjointinvwavelet_transform3D@plt>
xor    %eax,%eax
call   1050 <clock@plt>
cmp    %rbx,%rbp
mov    0x10(%rsp),%rcx
movsd  %xmm0,0x88(%rsp)
jae    15f9 <main+0x429>
cmp    %r15,%rcx
jae    15f9 <main+0x429>
mov    $0x4,%eax
xchg   %ax,%ax
movss  -0x10(%rcx,%rax,4),%xmm0
movss  %xmm0,-0x10(%rbp,%rax,4)
movss  -0xc(%rcx,%rax,4),%xmm0
movss  %xmm0,-0xc(%rbp,%rax,4)
movss  -0x8(%rcx,%rax,4),%xmm0
movss  %xmm0,-0x8(%rbp,%rax,4)
movss  -0x4(%rcx,%rax,4),%xmm0
movss  %xmm0,-0x4(%rbp,%rax,4)
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x5,%rax
cmp    $0xf42404,%rax
jne    15b0 <main+0x3e0>
jmp    1677 <main+0x4a7>
mov    $0x24,%eax
xchg   %ax,%ax
movups -0x90(%rcx,%rax,4),%xmm0
ff
movups -0x80(%rcx,%rax,4),%xmm1
movups %xmm0,-0x90(%rbp,%rax,4)
ff
movups %xmm1,-0x80(%rbp,%rax,4)
movups -0x70(%rcx,%rax,4),%xmm0
movups -0x60(%rcx,%rax,4),%xmm1
movups %xmm0,-0x70(%rbp,%rax,4)
movups %xmm1,-0x60(%rbp,%rax,4)
movups -0x50(%rcx,%rax,4),%xmm0
movups -0x40(%rcx,%rax,4),%xmm1
movups %xmm0,-0x50(%rbp,%rax,4)
movups %xmm1,-0x40(%rbp,%rax,4)
movups -0x30(%rcx,%rax,4),%xmm0
movups -0x20(%rcx,%rax,4),%xmm1
movups %xmm0,-0x30(%rbp,%rax,4)
movups %xmm1,-0x20(%rbp,%rax,4)
movups -0x10(%rcx,%rax,4),%xmm0
movupd (%rcx,%rax,4),%xmm1
movups %xmm0,-0x10(%rbp,%rax,4)
movupd %xmm1,0x0(%rbp,%rax,4)
add    $0x28,%rax
cmp    $0xf42424,%rax
jne    1600 <main+0x430>
xor    %eax,%eax
call   1050 <clock@plt>
movsd  %xmm0,0x78(%rsp)
mov    0x38(%rsp),%rax
mov    %rax,(%rsp)
mov    %rbp,%rdi
mov    $0x190,%esi
mov    $0x64,%edx
mov    $0x190,%ecx
mov    $0x3,%r8d
mov    $0x2,%r9d
call   10e0 <wavelet_transform3D@plt>
xor    %eax,%eax
call   1050 <clock@plt>
movsd  %xmm0,0x68(%rsp)
mov    0x30(%rsp),%rax
mov    %rax,(%rsp)
mov    %r12,%rdi
mov    $0x190,%esi
mov    $0x64,%edx
mov    $0x190,%ecx
mov    $0x3,%r8d
mov    $0x2,%r9d
call   1070 <adjointwavelet_transform3D@plt>
xor    %eax,%eax
call   1050 <clock@plt>
cmp    %r13,%r12
mov    %rbp,0xa8(%rsp)
movsd  %xmm0,0x70(%rsp)
jae    1775 <main+0x5a5>
cmp    0x40(%rsp),%r14
jae    1775 <main+0x5a5>
mov    $0x4,%eax
mov    0x28(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x10(%r14,%rax,4),%xmm0
movss  %xmm0,-0x10(%r12,%rax,4)
movss  -0xc(%r14,%rax,4),%xmm0
movss  %xmm0,-0xc(%r12,%rax,4)
movss  -0x8(%r14,%rax,4),%xmm0
movss  %xmm0,-0x8(%r12,%rax,4)
movss  -0x4(%r14,%rax,4),%xmm0
movss  %xmm0,-0x4(%r12,%rax,4)
movss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%r12,%rax,4)
add    $0x5,%rax
cmp    $0xf42404,%rax
jne    1720 <main+0x550>
jmp    180e <main+0x63e>
mov    $0x24,%eax
mov    0x28(%rsp),%rbp
nop
movups -0x90(%r14,%rax,4),%xmm0
ff ff
movups -0x80(%r14,%rax,4),%xmm1
movups %xmm0,-0x90(%r12,%rax,4)
ff ff
movups %xmm1,-0x80(%r12,%rax,4)
movups -0x70(%r14,%rax,4),%xmm0
movups -0x60(%r14,%rax,4),%xmm1
movups %xmm0,-0x70(%r12,%rax,4)
movups %xmm1,-0x60(%r12,%rax,4)
movups -0x50(%r14,%rax,4),%xmm0
movups -0x40(%r14,%rax,4),%xmm1
movups %xmm0,-0x50(%r12,%rax,4)
movups %xmm1,-0x40(%r12,%rax,4)
movups -0x30(%r14,%rax,4),%xmm0
movups -0x20(%r14,%rax,4),%xmm1
movups %xmm0,-0x30(%r12,%rax,4)
movups %xmm1,-0x20(%r12,%rax,4)
movups -0x10(%r14,%rax,4),%xmm0
movupd (%r14,%rax,4),%xmm1
movups %xmm0,-0x10(%r12,%rax,4)
movupd %xmm1,(%r12,%rax,4)
add    $0x28,%rax
cmp    $0xf42424,%rax
jne    1780 <main+0x5b0>
mov    %r12,%rbx
xor    %r12d,%r12d
xor    %eax,%eax
call   1050 <clock@plt>
movsd  %xmm0,0x60(%rsp)
mov    %rbp,(%rsp)
mov    %rbx,0xa0(%rsp)
mov    %rbx,%rdi
mov    $0x190,%esi
mov    $0x64,%edx
mov    $0x190,%ecx
mov    $0x3,%r8d
mov    $0x2,%r9d
call   10a0 <invwavelet_transform3D@plt>
xor    %eax,%eax
call   1050 <clock@plt>
movsd  %xmm0,0x58(%rsp)
mov    $0xa,%edi
call   1040 <putchar@plt>
xorpd  %xmm9,%xmm9
mov    0x30(%rsp),%rcx
mov    0x38(%rsp),%r9
mov    %rbp,%r10
xorpd  %xmm10,%xmm10
xchg   %ax,%ax
mov    0x10(%rsp),%rax
mov    0x8(%rsp),%rbx
lea    0x27100(%rcx),%rdx
mov    %rdx,0x40(%rsp)
lea    0x27100(%rbx),%rdx
mov    %rdx,0x8(%rsp)
lea    0x27100(%rax),%rdx
mov    %rdx,0x10(%rsp)
mov    %r14,%rsi
mov    %r9,%rdi
mov    %r10,%rdx
xor    %ebp,%ebp
xorpd  %xmm1,%xmm1
xorpd  %xmm8,%xmm8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x640(%rcx),%r8
lea    0x640(%rbx),%r13
lea    0x640(%rax),%r11
xorpd  %xmm2,%xmm2
xor    %r15d,%r15d
xorpd  %xmm3,%xmm3
movss  (%rax,%r15,1),%xmm4
movaps %xmm4,%xmm5
mulss  %xmm4,%xmm5
movss  (%rsi,%r15,1),%xmm6
movaps %xmm6,%xmm7
mulss  %xmm6,%xmm7
unpcklps %xmm5,%xmm7
movss  (%rdi,%r15,1),%xmm5
mulss  %xmm6,%xmm5
movss  (%rcx,%r15,1),%xmm0
mulss  %xmm4,%xmm0
mulss  (%rdx,%r15,1),%xmm4
mulss  (%rbx,%r15,1),%xmm6
subss  %xmm5,%xmm0
subss  %xmm4,%xmm6
unpcklps %xmm0,%xmm6
movlhps %xmm7,%xmm6
cvtps2pd %xmm6,%xmm0
cvtps2pd %xmm7,%xmm4
addpd  %xmm0,%xmm2
addpd  %xmm4,%xmm3
add    $0x4,%r15
cmp    $0x640,%r15d
jne    18f0 <main+0x720>
add    $0x640,%rdi
add    $0x640,%rsi
add    $0x640,%rdx
addpd  %xmm2,%xmm1
addpd  %xmm3,%xmm8
add    $0x1,%ebp
mov    %r13,%rbx
mov    %r8,%rcx
mov    %r11,%rax
cmp    $0x64,%ebp
jne    18d0 <main+0x700>
add    $0x27100,%r9
add    $0x27100,%r14
add    $0x27100,%r10
addpd  %xmm1,%xmm9
addpd  %xmm8,%xmm10
add    $0x1,%r12d
cmp    $0x190,%r12d
mov    0x40(%rsp),%rcx
jne    1880 <main+0x6b0>
mov    $0xa,%edi
movapd %xmm9,0xc0(%rsp)
movapd %xmm10,0xb0(%rsp)
call   1040 <putchar@plt>
xor    %eax,%eax
call   1050 <clock@plt>
movsd  %xmm0,0x8(%rsp)
movaps 0xc0(%rsp),%xmm3
movaps %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movaps %xmm0,%xmm2
movaps %xmm0,0x40(%rsp)
movaps 0xb0(%rsp),%xmm1
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
movaps %xmm0,0x10(%rsp)
lea    0x689(%rip),%rdi
mov    $0x4,%al
call   1060 <printf@plt>
movaps 0x40(%rsp),%xmm0
call   1090 <fabs@plt>
mov    %eax,%ebp
movapd 0x10(%rsp),%xmm0
mulsd  0xb0(%rsp),%xmm0
movapd %xmm0,0x10(%rsp)
call   10d0 <sqrt@plt>
mov    %eax,%ecx
mov    %ebp,%eax
cltd
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
call   10c0 <log10@plt>
mulsd  0x59d(%rip),%xmm0
lea    0x688(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movaps 0xc0(%rsp),%xmm0
call   1090 <fabs@plt>
mov    %eax,%ebp
movaps 0x10(%rsp),%xmm0
call   10d0 <sqrt@plt>
mov    %eax,%ecx
mov    %ebp,%eax
cltd
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
call   10c0 <log10@plt>
mulsd  0x55b(%rip),%xmm0
lea    0x66e(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movsd  0x80(%rsp),%xmm8
movapd %xmm8,%xmm4
movsd  0x90(%rsp),%xmm0
subsd  %xmm0,%xmm4
subsd  0x98(%rsp),%xmm0
movsd  0x527(%rip),%xmm10
mulsd  %xmm10,%xmm0
movsd  0x68(%rsp),%xmm9
movapd %xmm9,%xmm3
movsd  0x78(%rsp),%xmm6
subsd  %xmm6,%xmm3
movsd  0x88(%rsp),%xmm2
subsd  %xmm2,%xmm6
addsd  %xmm4,%xmm6
movsd  0x58(%rsp),%xmm5
movsd  0x8(%rsp),%xmm7
subsd  %xmm5,%xmm7
movsd  0x60(%rsp),%xmm1
subsd  %xmm1,%xmm5
movsd  0x70(%rsp),%xmm4
subsd  %xmm4,%xmm1
addsd  %xmm6,%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm8,%xmm2
mulsd  %xmm10,%xmm2
mulsd  %xmm10,%xmm3
subsd  %xmm9,%xmm4
mulsd  %xmm10,%xmm4
mulsd  %xmm10,%xmm5
mulsd  %xmm10,%xmm7
movapd %xmm7,%xmm6
lea    0x5dd(%rip),%rdi
mov    $0x190,%esi
mov    $0x64,%edx
mov    $0x190,%ecx
mov    $0x7,%al
call   1060 <printf@plt>
mov    0xa8(%rsp),%rdi
test   %rdi,%rdi
je     1b90 <main+0x9c0>
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
test   %rdi,%rdi
mov    0x38(%rsp),%rbp
je     1ba7 <main+0x9d7>
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
test   %rdi,%rdi
mov    0x28(%rsp),%rbx
je     1bbb <main+0x9eb>
call   1030 <free@plt>
test   %rbp,%rbp
je     1bc8 <main+0x9f8>
mov    %rbp,%rdi
call   1030 <free@plt>
test   %rbx,%rbx
je     1bd5 <main+0xa05>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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