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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ CosEvalPts(int, double *);
int /*<<< orphan*/ CosEvalPts2(int, double *);
int /*<<< orphan*/ SinEvalPts(int, double *);
int /*<<< orphan*/ SinEvalPts2(int, double *);
int /*<<< orphan*/ genWigTrans_L2(int, int, int, double *, double *, double *,
                                  double *, double *, double *);
int /*<<< orphan*/ grid_fourier_so3(double *, double *, double *, double *, int,
                                    int, double *);
int /*<<< orphan*/ howMany_so3(int, int, int);
int /*<<< orphan*/ memcpy(double *, double *, int);
int totalCoeffs_so3(int);
int /*<<< orphan*/ transpose_so3(double *, double *, int, int);
int /*<<< orphan*/ wigNaiveSynthesis(int, int, int, double *, double *,
                                     double *, double *);
void Inverse_SO3_Naive(int bw, double *rcoeffs, double *icoeffs, double *rdata,
                       double *idata, double *workspace1, double *workspace2) {
  int j, n;
  int m1, m2;
  double *t1r, *t1i, *t2r, *t2i;
  double *sinPts, *cosPts, *sinPts2, *cosPts2;
  double *wignersTrans, *scratch;
  double *rdataPtr, *idataPtr;
  double *rcoeffsPtr, *icoeffsPtr;
  double dn;
  int tmpInt;
  n = 2 * bw;
  t1r = workspace1;
  t1i = workspace1 + (n * n * n);
  t2r = t1i + (n * n * n);
  t2i = t2r + (n * n * n);
  rdataPtr = rdata;
  idataPtr = idata;
  rcoeffsPtr = rcoeffs;
  icoeffsPtr = icoeffs;
  sinPts = workspace2;
  cosPts = sinPts + n;
  sinPts2 = cosPts + n;
  cosPts2 = sinPts2 + n;
  wignersTrans = cosPts2 + n;
  scratch = wignersTrans + (bw * n);
  SinEvalPts(n, sinPts);
  CosEvalPts(n, cosPts);
  SinEvalPts2(n, sinPts2);
  CosEvalPts2(n, cosPts2);
  tmpInt = totalCoeffs_so3(bw);
  memcpy(t1r, rcoeffs, sizeof(double) * tmpInt);
  memcpy(t1i, icoeffs, sizeof(double) * tmpInt);
  for (m1 = 0; m1 < bw; m1++) {
    for (m2 = 0; m2 < bw; m2++) {
      genWigTrans_L2(m1, m2, bw, sinPts, cosPts, sinPts2, cosPts2, wignersTrans,
                     scratch);
      wigNaiveSynthesis(m1, m2, bw, t1r, wignersTrans, t2r, scratch);
      wigNaiveSynthesis(m1, m2, bw, t1i, wignersTrans, t2i, scratch);
      t1r += howMany_so3(m1, m2, bw);
      t1i += howMany_so3(m1, m2, bw);
      t2r += n;
      t2i += n;
    }
    for (j = 0; j < n; j++) {
      *t2r++ = 0.0;
      *t2i++ = 0.0;
    }
    for (m2 = -(bw - 1); m2 < 0; m2++) {
      genWigTrans_L2(m1, m2, bw, sinPts, cosPts, sinPts2, cosPts2, wignersTrans,
                     scratch);
      wigNaiveSynthesis(m1, m2, bw, t1r, wignersTrans, t2r, scratch);
      wigNaiveSynthesis(m1, m2, bw, t1i, wignersTrans, t2i, scratch);
      t1r += howMany_so3(m1, m2, bw);
      t1i += howMany_so3(m1, m2, bw);
      t2r += n;
      t2i += n;
    }
  }
  for (j = 0; j < n * n; j++) {
    *t2r++ = 0.0;
    *t2i++ = 0.0;
  }
  for (m1 = -(bw - 1); m1 < 0; m1++) {
    for (m2 = 0; m2 < bw; m2++) {
      genWigTrans_L2(m1, m2, bw, sinPts, cosPts, sinPts2, cosPts2, wignersTrans,
                     scratch);
      wigNaiveSynthesis(m1, m2, bw, t1r, wignersTrans, t2r, scratch);
      wigNaiveSynthesis(m1, m2, bw, t1i, wignersTrans, t2i, scratch);
      t1r += howMany_so3(m1, m2, bw);
      t1i += howMany_so3(m1, m2, bw);
      t2r += n;
      t2i += n;
    }
    for (j = 0; j < n; j++) {
      *t2r++ = 0.0;
      *t2i++ = 0.0;
    }
    for (m2 = -(bw - 1); m2 < 0; m2++) {
      genWigTrans_L2(m1, m2, bw, sinPts, cosPts, sinPts2, cosPts2, wignersTrans,
                     scratch);
      wigNaiveSynthesis(m1, m2, bw, t1r, wignersTrans, t2r, scratch);
      wigNaiveSynthesis(m1, m2, bw, t1i, wignersTrans, t2i, scratch);
      t1r += howMany_so3(m1, m2, bw);
      t1i += howMany_so3(m1, m2, bw);
      t2r += n;
      t2i += n;
    }
  }
  t1r -= totalCoeffs_so3(bw);
  t1i -= totalCoeffs_so3(bw);
  t2r -= (n * n * n);
  t2i -= (n * n * n);
  transpose_so3(t2r, t1r, n, n * n);
  transpose_so3(t2i, t1i, n, n * n);
  grid_fourier_so3(t1r, t1i, t2r, t2i, n * n, n, scratch);
  transpose_so3(t2r, t1r, n, n * n);
  transpose_so3(t2i, t1i, n, n * n);
  grid_fourier_so3(t1r, t1i, rdata, idata, n * n, n, scratch);
  dn = (double)n;
  dn *= ((double)bw) / 3.14159265358979323846;
  for (j = 0; j < n * n * n; j++) {
    rdata[j] *= dn;
    idata[j] *= dn;
  }
}


x86 assembly (clang, -O0):
<Inverse_SO3_Naive>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x38(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x38(%rbp),%edi
mov    -0x68(%rbp),%rsi
call   1080 <SinEvalPts@plt>
mov    -0x38(%rbp),%edi
mov    -0x70(%rbp),%rsi
call   10a0 <CosEvalPts@plt>
mov    -0x38(%rbp),%edi
mov    -0x78(%rbp),%rsi
call   1050 <SinEvalPts2@plt>
mov    -0x38(%rbp),%edi
mov    -0x80(%rbp),%rsi
call   1040 <CosEvalPts2@plt>
mov    -0x4(%rbp),%edi
call   10d0 <totalCoeffs_so3@plt>
mov    %eax,-0xbc(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x10(%rbp),%rsi
movslq -0xbc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
mov    -0x50(%rbp),%rdi
mov    -0x18(%rbp),%rsi
movslq -0xbc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15fb <Inverse_SO3_Naive+0x44b>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    147e <Inverse_SO3_Naive+0x2ce>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x70(%rbp),%r8
mov    -0x78(%rbp),%r9
mov    -0x80(%rbp),%r11
mov    -0x88(%rbp),%r10
mov    -0x90(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1090 <genWigTrans_L2@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x48(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x58(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <wigNaiveSynthesis@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x50(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x60(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <wigNaiveSynthesis@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
call   10c0 <howMany_so3@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
call   10c0 <howMany_so3@plt>
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    136c <Inverse_SO3_Naive+0x1bc>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    14cb <Inverse_SO3_Naive+0x31b>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1485 <Inverse_SO3_Naive+0x2d5>
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jge    15e8 <Inverse_SO3_Naive+0x438>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x70(%rbp),%r8
mov    -0x78(%rbp),%r9
mov    -0x80(%rbp),%r11
mov    -0x88(%rbp),%r10
mov    -0x90(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1090 <genWigTrans_L2@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x48(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x58(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <wigNaiveSynthesis@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x50(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x60(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <wigNaiveSynthesis@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
call   10c0 <howMany_so3@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
call   10c0 <howMany_so3@plt>
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14d8 <Inverse_SO3_Naive+0x328>
jmp    15ed <Inverse_SO3_Naive+0x43d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1359 <Inverse_SO3_Naive+0x1a9>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    164e <Inverse_SO3_Naive+0x49e>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1602 <Inverse_SO3_Naive+0x452>
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jge    18fb <Inverse_SO3_Naive+0x74b>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    177e <Inverse_SO3_Naive+0x5ce>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x70(%rbp),%r8
mov    -0x78(%rbp),%r9
mov    -0x80(%rbp),%r11
mov    -0x88(%rbp),%r10
mov    -0x90(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1090 <genWigTrans_L2@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x48(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x58(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <wigNaiveSynthesis@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x50(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x60(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <wigNaiveSynthesis@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
call   10c0 <howMany_so3@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
call   10c0 <howMany_so3@plt>
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    166c <Inverse_SO3_Naive+0x4bc>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    17cb <Inverse_SO3_Naive+0x61b>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1785 <Inverse_SO3_Naive+0x5d5>
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jge    18e8 <Inverse_SO3_Naive+0x738>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x70(%rbp),%r8
mov    -0x78(%rbp),%r9
mov    -0x80(%rbp),%r11
mov    -0x88(%rbp),%r10
mov    -0x90(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1090 <genWigTrans_L2@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x48(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x58(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <wigNaiveSynthesis@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x50(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x60(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1030 <wigNaiveSynthesis@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
call   10c0 <howMany_so3@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
call   10c0 <howMany_so3@plt>
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    17d8 <Inverse_SO3_Naive+0x628>
jmp    18ed <Inverse_SO3_Naive+0x73d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    165b <Inverse_SO3_Naive+0x4ab>
mov    -0x4(%rbp),%edi
call   10d0 <totalCoeffs_so3@plt>
mov    %eax,%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x4(%rbp),%edi
call   10d0 <totalCoeffs_so3@plt>
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x38(%rbp),%edx
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
call   10b0 <transpose_so3@plt>
mov    -0x60(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x38(%rbp),%edx
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
call   10b0 <transpose_so3@plt>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x60(%rbp),%rcx
mov    -0x38(%rbp),%r8d
imul   -0x38(%rbp),%r8d
mov    -0x38(%rbp),%r9d
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1070 <grid_fourier_so3@plt>
mov    -0x58(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x38(%rbp),%edx
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
call   10b0 <transpose_so3@plt>
mov    -0x60(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x38(%rbp),%edx
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
call   10b0 <transpose_so3@plt>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x38(%rbp),%r8d
imul   -0x38(%rbp),%r8d
mov    -0x38(%rbp),%r9d
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
call   1070 <grid_fourier_so3@plt>
cvtsi2sdl -0x38(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
cvtsi2sdl -0x4(%rbp),%xmm0
movsd  0x5af(%rip),%xmm1
divsd  %xmm1,%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    1ac4 <Inverse_SO3_Naive+0x914>
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a6c <Inverse_SO3_Naive+0x8bc>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Inverse_SO3_Naive>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r9,0x48(%rsp)
mov    %r8,0x100(%rsp)
mov    %rcx,0xf8(%rsp)
mov    %rdx,0x50(%rsp)
mov    %rsi,0x58(%rsp)
mov    %edi,%r13d
mov    0x140(%rsp),%rsi
lea    0x0(%r13,%r13,1),%r15d
mov    %r15d,%eax
imul   %eax,%eax
mov    %rax,0xf0(%rsp)
mov    %eax,%ecx
imul   %r15d,%ecx
movslq %r15d,%r14
lea    (%rsi,%r14,8),%rbp
lea    0x0(,%r14,8),%rbx
add    %rbp,%rbx
lea    (%rbx,%r14,8),%r12
mov    %r15d,%eax
imul   %edi,%eax
cltq
lea    (%r12,%r14,8),%rdx
mov    %rdx,0x78(%rsp)
lea    (%rdx,%rax,8),%rax
mov    %rax,0x70(%rsp)
mov    %ecx,0xe4(%rsp)
movslq %ecx,%rax
lea    (%r9,%rax,8),%rcx
mov    %rcx,0x30(%rsp)
lea    (%rcx,%rax,8),%rcx
mov    %rax,0xe8(%rsp)
mov    %rcx,0x18(%rsp)
lea    (%rcx,%rax,8),%rax
mov    %rax,0x20(%rsp)
mov    %r14d,%edi
call   1080 <SinEvalPts@plt>
mov    %r14d,%edi
mov    %rbp,0xa8(%rsp)
mov    %rbp,%rsi
call   10a0 <CosEvalPts@plt>
mov    %r14d,%edi
mov    %rbx,0xa0(%rsp)
mov    %rbx,%rsi
mov    %r12,%rbx
mov    %r12,0x98(%rsp)
call   1050 <SinEvalPts2@plt>
mov    %r14d,%edi
mov    %r12,%rsi
call   1040 <CosEvalPts2@plt>
mov    %r13d,%edi
call   10d0 <totalCoeffs_so3@plt>
lea    0x0(,%rax,8),%ebp
mov    0x48(%rsp),%rdi
mov    0x58(%rsp),%rsi
mov    %ebp,%edx
call   1060 <memcpy@plt>
mov    0x30(%rsp),%rdi
mov    0x50(%rsp),%rsi
mov    %ebp,%edx
mov    %r13,%rbp
call   1060 <memcpy@plt>
test   %ebp,%ebp
mov    %r15d,0x2c(%rsp)
mov    %r14,0xd8(%rsp)
mov    %r13,0x40(%rsp)
jle    1829 <Inverse_SO3_Naive+0x679>
mov    $0x1,%eax
mov    $0x1,%ecx
sub    %ebp,%ecx
mov    %ecx,0xc8(%rsp)
cmp    $0x2,%r15d
cmovge %r15d,%eax
mov    %rax,0x38(%rsp)
add    $0xffffffff,%eax
mov    %rax,0xd0(%rsp)
add    $0x1,%rax
mov    %rax,0x90(%rsp)
movabs $0x1fffffffc,%rcx
and    %rcx,%rax
mov    %rax,0xc0(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xb8(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %eax,%ecx
and    $0x3,%ecx
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
and    %rdx,%rax
mov    %rax,0xb0(%rsp)
lea    0x0(,%r14,8),%rdi
mov    %rcx,0x88(%rsp)
shl    $0x5,%rcx
mov    %rcx,0x80(%rsp)
xor    %eax,%eax
mov    0x20(%rsp),%rcx
mov    %rdi,0x60(%rsp)
jmp    13bf <Inverse_SO3_Naive+0x20f>
nopw   0x0(%rax,%rax,1)
mov    %r12,0x48(%rsp)
mov    0x68(%rsp),%rax
add    $0x1,%eax
mov    0x40(%rsp),%rbp
cmp    %ebp,%eax
mov    0x20(%rsp),%rcx
je     182e <Inverse_SO3_Naive+0x67e>
mov    %rcx,0x20(%rsp)
mov    %rax,0x68(%rsp)
mov    %rcx,%rdx
mov    0x18(%rsp),%rsi
xor    %ebp,%ebp
mov    0x48(%rsp),%r13
nopl   0x0(%rax,%rax,1)
mov    %rsi,0x58(%rsp)
mov    %rdx,0x50(%rsp)
mov    0x70(%rsp),%rbx
mov    %rbx,0x10(%rsp)
mov    0x78(%rsp),%r12
mov    %r12,0x8(%rsp)
mov    0x98(%rsp),%rax
mov    %rax,(%rsp)
mov    0x68(%rsp),%r14
mov    %r14d,%edi
mov    %ebp,%esi
mov    0x40(%rsp),%r15
mov    %r15d,%edx
mov    0x140(%rsp),%rcx
mov    0xa8(%rsp),%r8
mov    0xa0(%rsp),%r9
call   1090 <genWigTrans_L2@plt>
mov    %rbx,(%rsp)
mov    %r14d,%edi
mov    %ebp,%esi
mov    %r15d,%edx
mov    %r13,%rcx
mov    %r12,%r8
mov    0x18(%rsp),%r9
call   1030 <wigNaiveSynthesis@plt>
mov    %rbx,(%rsp)
mov    %r14d,%edi
mov    %ebp,%esi
mov    %r15d,%edx
mov    0x30(%rsp),%rbx
mov    %rbx,%rcx
mov    %r12,%r8
mov    0x20(%rsp),%r12
mov    %r12,%r9
call   1030 <wigNaiveSynthesis@plt>
mov    %r14d,%edi
mov    %ebp,%esi
mov    %r15d,%edx
call   10c0 <howMany_so3@plt>
cltq
lea    0x0(%r13,%rax,8),%r13
mov    %r14d,%edi
mov    %ebp,%esi
mov    %r15d,%edx
call   10c0 <howMany_so3@plt>
mov    0x58(%rsp),%rsi
mov    0x50(%rsp),%rdx
mov    0x60(%rsp),%rdi
cltq
lea    (%rbx,%rax,8),%rbx
mov    %rbx,0x30(%rsp)
mov    0xd8(%rsp),%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x18(%rsp)
lea    (%r12,%rax,8),%r12
mov    %r12,0x20(%rsp)
add    $0x1,%ebp
add    %rdi,%rsi
add    %rdi,%rdx
cmp    %r15d,%ebp
jne    13e0 <Inverse_SO3_Naive+0x230>
mov    0x20(%rsp),%rcx
mov    0x18(%rsp),%r15
mov    %r13,%r12
mov    0x40(%rsp),%r14
xor    %eax,%eax
cmpl   $0x3,0xd0(%rsp)
jae    1510 <Inverse_SO3_Naive+0x360>
mov    %r15,%rbp
mov    %rcx,%r13
jmp    1620 <Inverse_SO3_Naive+0x470>
xchg   %ax,%ax
mov    %rcx,%r13
mov    0x90(%rsp),%r10
lea    (%rcx,%r10,8),%rcx
mov    %r15,%rbp
cmp    %rcx,%r15
jae    153b <Inverse_SO3_Naive+0x38b>
lea    0x0(,%r10,8),%rcx
add    %rbp,%rcx
cmp    %rcx,%r13
jb     1620 <Inverse_SO3_Naive+0x470>
cmpq   $0xc,0xb8(%rsp)
mov    0x80(%rsp),%rbx
xorpd  %xmm0,%xmm0
jae    1556 <Inverse_SO3_Naive+0x3a6>
xor    %eax,%eax
jmp    15c8 <Inverse_SO3_Naive+0x418>
mov    0xb0(%rsp),%rcx
xor    %eax,%eax
movupd %xmm0,(%rsi,%rax,8)
movupd %xmm0,0x10(%rsi,%rax,8)
movupd %xmm0,(%rdx,%rax,8)
movupd %xmm0,0x10(%rdx,%rax,8)
movupd %xmm0,0x20(%rsi,%rax,8)
movupd %xmm0,0x30(%rsi,%rax,8)
movupd %xmm0,0x20(%rdx,%rax,8)
movupd %xmm0,0x30(%rdx,%rax,8)
movupd %xmm0,0x40(%rsi,%rax,8)
movupd %xmm0,0x50(%rsi,%rax,8)
movupd %xmm0,0x40(%rdx,%rax,8)
movupd %xmm0,0x50(%rdx,%rax,8)
movupd %xmm0,0x60(%rsi,%rax,8)
movupd %xmm0,0x70(%rsi,%rax,8)
movupd %xmm0,0x60(%rdx,%rax,8)
movupd %xmm0,0x70(%rdx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1560 <Inverse_SO3_Naive+0x3b0>
cmpq   $0x0,0x88(%rsp)
je     15ff <Inverse_SO3_Naive+0x44f>
lea    (%rdx,%rax,8),%rcx
lea    (%rsi,%rax,8),%rax
xor    %edx,%edx
nopl   (%rax)
movupd %xmm0,(%rax,%rdx,1)
movupd %xmm0,0x10(%rax,%rdx,1)
movupd %xmm0,(%rcx,%rdx,1)
movupd %xmm0,0x10(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbx
jne    15e0 <Inverse_SO3_Naive+0x430>
mov    0xc0(%rsp),%rcx
lea    0x0(%rbp,%rcx,8),%rbp
lea    0x0(%r13,%rcx,8),%r13
mov    %ecx,%eax
cmp    %rcx,%r10
je     1726 <Inverse_SO3_Naive+0x576>
nopl   0x0(%rax)
mov    0x38(%rsp),%rsi
mov    %esi,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %esi,%ecx
and    $0x7,%edx
je     1661 <Inverse_SO3_Naive+0x4b1>
neg    %edx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movq   $0x0,0x0(%rbp)
add    $0x8,%rbp
movq   $0x0,0x0(%r13)
add    $0x8,%r13
add    $0xffffffff,%esi
cmp    %esi,%edx
jne    1640 <Inverse_SO3_Naive+0x490>
sub    %esi,%eax
cmp    $0x7,%ecx
jb     1726 <Inverse_SO3_Naive+0x576>
mov    0x38(%rsp),%rcx
sub    %eax,%ecx
xor    %eax,%eax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,0x0(%rbp,%rdx,8)
movq   $0x0,0x0(%r13,%rdx,8)
movq   $0x0,0x8(%rbp,%rdx,8)
movq   $0x0,0x8(%r13,%rdx,8)
movq   $0x0,0x10(%rbp,%rdx,8)
movq   $0x0,0x10(%r13,%rdx,8)
movq   $0x0,0x18(%rbp,%rdx,8)
movq   $0x0,0x18(%r13,%rdx,8)
movq   $0x0,0x20(%rbp,%rdx,8)
movq   $0x0,0x20(%r13,%rdx,8)
movq   $0x0,0x28(%rbp,%rdx,8)
movq   $0x0,0x28(%r13,%rdx,8)
movq   $0x0,0x30(%rbp,%rdx,8)
movq   $0x0,0x30(%r13,%rdx,8)
movq   $0x0,0x38(%rbp,%rdx,8)
movq   $0x0,0x38(%r13,%rdx,8)
add    $0x8,%rdx
add    $0xffffffffffffffc0,%rax
cmp    %edx,%ecx
jne    1680 <Inverse_SO3_Naive+0x4d0>
sub    %rax,%rbp
sub    %rax,%r13
cmp    $0x1,%r14d
mov    %r13,0x20(%rsp)
mov    %rbp,0x18(%rsp)
je     13a0 <Inverse_SO3_Naive+0x1f0>
mov    0xc8(%rsp),%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x70(%rsp),%rbx
mov    %rbx,0x10(%rsp)
mov    0x78(%rsp),%r15
mov    %r15,0x8(%rsp)
mov    0x98(%rsp),%rax
mov    %rax,(%rsp)
mov    0x68(%rsp),%r13
mov    %r13d,%edi
mov    %ebp,%esi
mov    0x40(%rsp),%r14
mov    %r14d,%edx
mov    0x140(%rsp),%rcx
mov    0xa8(%rsp),%r8
mov    0xa0(%rsp),%r9
call   1090 <genWigTrans_L2@plt>
mov    %rbx,(%rsp)
mov    %r13d,%edi
mov    %ebp,%esi
mov    %r14d,%edx
mov    %r12,%rcx
mov    %r15,%r8
mov    0x18(%rsp),%r9
call   1030 <wigNaiveSynthesis@plt>
mov    %rbx,(%rsp)
mov    %r13d,%edi
mov    %ebp,%esi
mov    %r14d,%edx
mov    0x30(%rsp),%rbx
mov    %rbx,%rcx
mov    %r15,%r8
mov    0x20(%rsp),%r15
mov    %r15,%r9
call   1030 <wigNaiveSynthesis@plt>
mov    %r13d,%edi
mov    %ebp,%esi
mov    %r14d,%edx
call   10c0 <howMany_so3@plt>
cltq
lea    (%r12,%rax,8),%r12
mov    %r13d,%edi
mov    %ebp,%esi
mov    %r14d,%edx
call   10c0 <howMany_so3@plt>
mov    0x60(%rsp),%rdi
cltq
lea    (%rbx,%rax,8),%rbx
mov    %rbx,0x30(%rsp)
add    %rdi,0x18(%rsp)
add    %rdi,%r15
mov    %r15,0x20(%rsp)
inc    %ebp
jne    1750 <Inverse_SO3_Naive+0x5a0>
jmp    13a0 <Inverse_SO3_Naive+0x1f0>
mov    0x20(%rsp),%rcx
mov    0xf0(%rsp),%rdx
test   %edx,%edx
je     186e <Inverse_SO3_Naive+0x6be>
lea    -0x4(%rdx),%esi
lea    (%rcx,%rsi,8),%rax
add    $0x20,%rax
mov    0x18(%rsp),%rdi
cmp    %rax,%rdi
jae    1880 <Inverse_SO3_Naive+0x6d0>
lea    (%rdi,%rsi,8),%rax
add    $0x20,%rax
cmp    %rax,%rcx
jae    1880 <Inverse_SO3_Naive+0x6d0>
lea    -0x1(%rdx),%esi
mov    %edx,%eax
and    $0x4,%eax
cmp    $0x7,%esi
jae    18ae <Inverse_SO3_Naive+0x6fe>
jmp    197c <Inverse_SO3_Naive+0x7cc>
mov    %rcx,%rbx
mov    0x18(%rsp),%r15
mov    0x2c(%rsp),%r8d
jmp    1a8f <Inverse_SO3_Naive+0x8df>
lea    0x4(%rsi),%rbx
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0xc,%esi
jae    19c0 <Inverse_SO3_Naive+0x810>
xor    %esi,%esi
mov    0x2c(%rsp),%r8d
mov    0x18(%rsp),%rdi
jmp    1a48 <Inverse_SO3_Naive+0x898>
mov    %ebp,%edi
imul   %edi,%edi
shr    %edi
and    $0x1fffffff,%edi
shl    $0x3,%rdi
xor    %esi,%esi
xor    %edx,%edx
mov    0x18(%rsp),%r15
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%r15,%rsi,8)
movq   $0x0,(%rcx,%rsi,8)
movq   $0x0,0x8(%r15,%rsi,8)
movq   $0x0,0x8(%rcx,%rsi,8)
movq   $0x0,0x10(%r15,%rsi,8)
movq   $0x0,0x10(%rcx,%rsi,8)
movq   $0x0,0x18(%r15,%rsi,8)
movq   $0x0,0x18(%rcx,%rsi,8)
movq   $0x0,0x20(%r15,%rsi,8)
movq   $0x0,0x20(%rcx,%rsi,8)
movq   $0x0,0x28(%r15,%rsi,8)
movq   $0x0,0x28(%rcx,%rsi,8)
movq   $0x0,0x30(%r15,%rsi,8)
movq   $0x0,0x30(%rcx,%rsi,8)
movq   $0x0,0x38(%r15,%rsi,8)
movq   $0x0,0x38(%rcx,%rsi,8)
add    $0xffffffffffffffc0,%rdx
add    $0x8,%rsi
cmp    %esi,%edi
jne    18d0 <Inverse_SO3_Naive+0x720>
sub    %rdx,%r15
sub    %rdx,%rcx
mov    %r15,0x18(%rsp)
mov    %rcx,%rbx
mov    0x2c(%rsp),%r8d
test   %eax,%eax
je     1a8f <Inverse_SO3_Naive+0x8df>
mov    0x18(%rsp),%r15
mov    %rcx,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,(%r15)
add    $0x8,%r15
movq   $0x0,(%rbx)
add    $0x8,%rbx
add    $0xffffffff,%eax
jne    19a0 <Inverse_SO3_Naive+0x7f0>
jmp    1a8f <Inverse_SO3_Naive+0x8df>
and    $0xfffffffc,%edx
xor    %esi,%esi
xorpd  %xmm0,%xmm0
mov    0x2c(%rsp),%r8d
mov    0x18(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd %xmm0,(%rdi,%rsi,8)
movupd %xmm0,0x10(%rdi,%rsi,8)
movupd %xmm0,(%rcx,%rsi,8)
movupd %xmm0,0x10(%rcx,%rsi,8)
movupd %xmm0,0x20(%rdi,%rsi,8)
movupd %xmm0,0x30(%rdi,%rsi,8)
movupd %xmm0,0x20(%rcx,%rsi,8)
movupd %xmm0,0x30(%rcx,%rsi,8)
movupd %xmm0,0x40(%rdi,%rsi,8)
movupd %xmm0,0x50(%rdi,%rsi,8)
movupd %xmm0,0x40(%rcx,%rsi,8)
movupd %xmm0,0x50(%rcx,%rsi,8)
movupd %xmm0,0x60(%rdi,%rsi,8)
movupd %xmm0,0x70(%rdi,%rsi,8)
movupd %xmm0,0x60(%rcx,%rsi,8)
movupd %xmm0,0x70(%rcx,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdx
jne    19e0 <Inverse_SO3_Naive+0x830>
lea    (%rdi,%rbx,8),%r15
lea    (%rcx,%rbx,8),%rbx
test   %rax,%rax
je     1a8f <Inverse_SO3_Naive+0x8df>
lea    (%rcx,%rsi,8),%rcx
add    $0x10,%rcx
lea    (%rdi,%rsi,8),%rdx
add    $0x10,%rdx
shl    $0x5,%rax
xor    %esi,%esi
xorpd  %xmm0,%xmm0
nop
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm0,(%rdx,%rsi,1)
movupd %xmm0,-0x10(%rcx,%rsi,1)
movupd %xmm0,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rax
jne    1a70 <Inverse_SO3_Naive+0x8c0>
mov    $0x1,%eax
mov    $0x1,%ecx
sub    %ebp,%ecx
mov    %rbx,0x18(%rsp)
js     1aac <Inverse_SO3_Naive+0x8fc>
mov    0x48(%rsp),%r13
jmp    2054 <Inverse_SO3_Naive+0xea4>
cmp    $0x2,%r8d
cmovge %r8d,%eax
mov    %rax,0xc8(%rsp)
add    $0xffffffff,%eax
mov    %rax,0xd0(%rsp)
lea    0x1(%rax),%rdx
movabs $0x1fffffffc,%rax
mov    %rdx,0x90(%rsp)
and    %rdx,%rax
mov    %rax,0x88(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xc0(%rsp)
mov    %rax,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%esi
and    $0x3,%esi
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
and    %rax,%rdx
mov    %rdx,0xb0(%rsp)
mov    0xd8(%rsp),%rax
lea    0x0(,%rax,8),%rdx
mov    %rdx,0x68(%rsp)
mov    %rsi,0xb8(%rsp)
shl    $0x5,%rsi
mov    %rsi,0x80(%rsp)
mov    %ecx,0x38(%rsp)
mov    %ecx,%ebx
mov    0x48(%rsp),%r13
nopl   (%rax)
test   %ebp,%ebp
mov    %ebx,0x58(%rsp)
jle    1cc5 <Inverse_SO3_Naive+0xb15>
xor    %r14d,%r14d
mov    %r15,%r12
mov    %r15,0x50(%rsp)
mov    0x18(%rsp),%r9
mov    %r9,0x60(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r9,0x18(%rsp)
mov    %r12,0x20(%rsp)
mov    0x70(%rsp),%r15
mov    %r15,0x10(%rsp)
mov    0x78(%rsp),%rbp
mov    %rbp,0x8(%rsp)
mov    0x98(%rsp),%rax
mov    %rax,(%rsp)
mov    0x58(%rsp),%r12d
mov    %r12d,%edi
mov    %r14d,%esi
mov    0x40(%rsp),%rbx
mov    %ebx,%edx
mov    0x140(%rsp),%rcx
mov    0xa8(%rsp),%r8
mov    0xa0(%rsp),%r9
call   1090 <genWigTrans_L2@plt>
mov    %r15,(%rsp)
mov    %r12d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
mov    %r13,%rcx
mov    %rbp,%r8
mov    0x50(%rsp),%r9
call   1030 <wigNaiveSynthesis@plt>
mov    %r15,(%rsp)
mov    %r12d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
mov    0x30(%rsp),%r15
mov    %r15,%rcx
mov    %rbp,%r8
mov    0x60(%rsp),%rbp
mov    %rbp,%r9
call   1030 <wigNaiveSynthesis@plt>
mov    %r12d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   10c0 <howMany_so3@plt>
cltq
lea    0x0(%r13,%rax,8),%r13
mov    %r12d,%edi
mov    0x20(%rsp),%r12
mov    %r14d,%esi
mov    %ebx,%edx
call   10c0 <howMany_so3@plt>
mov    0x18(%rsp),%r9
mov    0x68(%rsp),%rcx
cltq
lea    (%r15,%rax,8),%r15
mov    %r15,0x30(%rsp)
mov    0xd8(%rsp),%rax
mov    0x50(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    %rdx,0x50(%rsp)
lea    0x0(%rbp,%rax,8),%rbp
mov    %rbp,0x60(%rsp)
add    $0x1,%r14d
add    %rcx,%r12
add    %rcx,%r9
cmp    %ebx,%r14d
jne    1b80 <Inverse_SO3_Naive+0x9d0>
mov    0x50(%rsp),%r15
mov    0x60(%rsp),%rdi
mov    0x40(%rsp),%r14
test   %r14d,%r14d
jle    1cc0 <Inverse_SO3_Naive+0xb10>
mov    %r12,%r11
xor    %r12d,%r12d
cmpl   $0x3,0xd0(%rsp)
03
jae    1ccf <Inverse_SO3_Naive+0xb1f>
mov    %r13,%rax
mov    0x38(%rsp),%r8d
mov    %r15,%rbp
jmp    1e40 <Inverse_SO3_Naive+0xc90>
nopl   0x0(%rax,%rax,1)
mov    %rdi,0x18(%rsp)
mov    0x38(%rsp),%r8d
jmp    1f4d <Inverse_SO3_Naive+0xd9d>
mov    0x90(%rsp),%rax
lea    (%rdi,%rax,8),%rcx
mov    %r15,%rbp
cmp    %rcx,%r15
jae    1d00 <Inverse_SO3_Naive+0xb50>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
cmp    %rcx,%rdi
jae    1d00 <Inverse_SO3_Naive+0xb50>
mov    %r13,%rax
mov    0x38(%rsp),%r8d
jmp    1e40 <Inverse_SO3_Naive+0xc90>
cmpq   $0xc,0xc0(%rsp)
jae    1d30 <Inverse_SO3_Naive+0xb80>
xor    %eax,%eax
mov    %r13,0x48(%rsp)
mov    0x88(%rsp),%r15
mov    0x38(%rsp),%r8d
mov    0x80(%rsp),%rsi
xorpd  %xmm0,%xmm0
jmp    1dd8 <Inverse_SO3_Naive+0xc28>
mov    0xb0(%rsp),%rcx
xor    %eax,%eax
mov    %r13,0x48(%rsp)
mov    0x88(%rsp),%r15
mov    0x38(%rsp),%r8d
mov    0x80(%rsp),%rsi
xorpd  %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movupd %xmm0,(%r11,%rax,8)
movupd %xmm0,0x10(%r11,%rax,8)
movupd %xmm0,(%r9,%rax,8)
movupd %xmm0,0x10(%r9,%rax,8)
movupd %xmm0,0x20(%r11,%rax,8)
movupd %xmm0,0x30(%r11,%rax,8)
movupd %xmm0,0x20(%r9,%rax,8)
movupd %xmm0,0x30(%r9,%rax,8)
movupd %xmm0,0x40(%r11,%rax,8)
movupd %xmm0,0x50(%r11,%rax,8)
movupd %xmm0,0x40(%r9,%rax,8)
movupd %xmm0,0x50(%r9,%rax,8)
movupd %xmm0,0x60(%r11,%rax,8)
movupd %xmm0,0x70(%r11,%rax,8)
movupd %xmm0,0x60(%r9,%rax,8)
movupd %xmm0,0x70(%r9,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1d60 <Inverse_SO3_Naive+0xbb0>
cmpq   $0x0,0xb8(%rsp)
je     1e0f <Inverse_SO3_Naive+0xc5f>
lea    (%r9,%rax,8),%rcx
lea    (%r11,%rax,8),%rax
xor    %edx,%edx
nopl   (%rax)
movupd %xmm0,(%rax,%rdx,1)
movupd %xmm0,0x10(%rax,%rdx,1)
movupd %xmm0,(%rcx,%rdx,1)
movupd %xmm0,0x10(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1df0 <Inverse_SO3_Naive+0xc40>
lea    0x0(%rbp,%r15,8),%rbp
lea    (%rdi,%r15,8),%rdi
mov    %r15d,%r12d
cmp    %r15,0x90(%rsp)
mov    0x48(%rsp),%rax
jne    1e40 <Inverse_SO3_Naive+0xc90>
mov    %rax,%r13
jmp    1f45 <Inverse_SO3_Naive+0xd95>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0xc8(%rsp),%rbx
mov    %ebx,%edx
sub    %r12d,%edx
mov    %r12d,%ecx
not    %ecx
add    %ebx,%ecx
mov    %rax,%r13
and    $0x7,%edx
je     1e81 <Inverse_SO3_Naive+0xcd1>
neg    %edx
xor    %esi,%esi
movq   $0x0,0x0(%rbp)
add    $0x8,%rbp
movq   $0x0,(%rdi)
add    $0x8,%rdi
add    $0xffffffff,%esi
cmp    %esi,%edx
jne    1e60 <Inverse_SO3_Naive+0xcb0>
sub    %esi,%r12d
cmp    $0x7,%ecx
jb     1f45 <Inverse_SO3_Naive+0xd95>
mov    %ebx,%ecx
sub    %r12d,%ecx
xor    %eax,%eax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   $0x0,0x0(%rbp,%rdx,8)
movq   $0x0,(%rdi,%rdx,8)
movq   $0x0,0x8(%rbp,%rdx,8)
movq   $0x0,0x8(%rdi,%rdx,8)
movq   $0x0,0x10(%rbp,%rdx,8)
movq   $0x0,0x10(%rdi,%rdx,8)
movq   $0x0,0x18(%rbp,%rdx,8)
movq   $0x0,0x18(%rdi,%rdx,8)
movq   $0x0,0x20(%rbp,%rdx,8)
movq   $0x0,0x20(%rdi,%rdx,8)
movq   $0x0,0x28(%rbp,%rdx,8)
movq   $0x0,0x28(%rdi,%rdx,8)
movq   $0x0,0x30(%rbp,%rdx,8)
movq   $0x0,0x30(%rdi,%rdx,8)
movq   $0x0,0x38(%rbp,%rdx,8)
movq   $0x0,0x38(%rdi,%rdx,8)
add    $0x8,%rdx
add    $0xffffffffffffffc0,%rax
cmp    %edx,%ecx
jne    1ea0 <Inverse_SO3_Naive+0xcf0>
sub    %rax,%rbp
sub    %rax,%rdi
mov    %rbp,%r15
mov    %rdi,0x18(%rsp)
mov    %r15,0x20(%rsp)
mov    %r8d,%ebp
mov    0x18(%rsp),%rbx
mov    %r13,%r14
nopl   (%rax)
mov    %rbx,0x18(%rsp)
mov    0x70(%rsp),%rbx
mov    %rbx,0x10(%rsp)
mov    0x78(%rsp),%r12
mov    %r12,0x8(%rsp)
mov    0x98(%rsp),%rax
mov    %rax,(%rsp)
mov    0x58(%rsp),%r15d
mov    %r15d,%edi
mov    %ebp,%esi
mov    0x40(%rsp),%r13
mov    %r13d,%edx
mov    0x140(%rsp),%rcx
mov    0xa8(%rsp),%r8
mov    0xa0(%rsp),%r9
call   1090 <genWigTrans_L2@plt>
mov    %rbx,(%rsp)
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    %r14,%rcx
mov    %r12,%r8
mov    0x20(%rsp),%r9
call   1030 <wigNaiveSynthesis@plt>
mov    %rbx,(%rsp)
mov    0x18(%rsp),%rbx
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    0x30(%rsp),%r12
mov    %r12,%rcx
mov    0x78(%rsp),%r8
mov    %rbx,%r9
call   1030 <wigNaiveSynthesis@plt>
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r13d,%edx
call   10c0 <howMany_so3@plt>
cltq
lea    (%r14,%rax,8),%r14
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r13d,%edx
call   10c0 <howMany_so3@plt>
mov    0x68(%rsp),%rcx
cltq
lea    (%r12,%rax,8),%r12
mov    %r12,0x30(%rsp)
add    %rcx,0x20(%rsp)
add    %rcx,%rbx
inc    %ebp
jne    1f60 <Inverse_SO3_Naive+0xdb0>
mov    %r14,%r13
mov    %rbx,0x18(%rsp)
mov    0x20(%rsp),%r15
mov    0x58(%rsp),%ebx
inc    %ebx
mov    0x40(%rsp),%rbp
jne    1b50 <Inverse_SO3_Naive+0x9a0>
mov    %ebp,%edi
call   10d0 <totalCoeffs_so3@plt>
cltq
shl    $0x3,%rax
mov    %r13,%r14
sub    %rax,%r14
mov    %ebp,%edi
call   10d0 <totalCoeffs_so3@plt>
cltq
shl    $0x3,%rax
mov    0x30(%rsp),%rbp
sub    %rax,%rbp
mov    0xe8(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %r15,%rbx
sub    %rax,%rbx
mov    0x18(%rsp),%r15
sub    %rax,%r15
mov    %rbx,%rdi
mov    %r14,%rsi
mov    0x2c(%rsp),%r13d
mov    %r13d,%edx
mov    0xf0(%rsp),%r12
mov    %r12d,%ecx
call   10b0 <transpose_so3@plt>
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %r13d,%edx
mov    %r12d,%ecx
call   10b0 <transpose_so3@plt>
mov    0x70(%rsp),%rax
mov    %rax,(%rsp)
mov    %r14,%rdi
mov    %rbp,%rsi
mov    %rbx,%rdx
mov    %r15,%rcx
mov    %r12d,%r8d
mov    %r13d,%r9d
call   1070 <grid_fourier_so3@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %r13d,%edx
mov    %r12d,%ecx
call   10b0 <transpose_so3@plt>
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %r13d,%edx
mov    %r12d,%ecx
call   10b0 <transpose_so3@plt>
mov    0x70(%rsp),%rax
mov    %rax,(%rsp)
mov    %r14,%rdi
mov    %rbp,%rsi
mov    0xf8(%rsp),%rbx
mov    %rbx,%rdx
mov    0x100(%rsp),%rbp
mov    %rbp,%rcx
mov    %r12d,%r8d
mov    %r13d,%r9d
call   1070 <grid_fourier_so3@plt>
cmpl   $0x0,0xe8(%rsp)
jle    22ce <Inverse_SO3_Naive+0x111e>
cvtsi2sd %r13d,%xmm1
cvtsi2sdl 0x40(%rsp),%xmm0
divsd  0xea4(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0xe4(%rsp),%eax
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
cmp    %rbx,%rcx
jbe    21dc <Inverse_SO3_Naive+0x102c>
lea    (%rbx,%rax,8),%rcx
cmp    %rbp,%rcx
jbe    21dc <Inverse_SO3_Naive+0x102c>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    2190 <Inverse_SO3_Naive+0xfe0>
jmp    22ce <Inverse_SO3_Naive+0x111e>
unpcklpd %xmm0,%xmm0
add    $0xfffffffffffffffc,%rax
shr    $0x2,%rax
add    $0x1,%rax
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
add    $0x2,%rdx
and    %rax,%rdx
xor    %ecx,%ecx
nop
movupd (%rbx,%rcx,1),%xmm1
movupd 0x10(%rbx,%rcx,1),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rbx,%rcx,1)
movupd %xmm2,0x10(%rbx,%rcx,1)
movupd 0x0(%rbp,%rcx,1),%xmm1
movupd 0x10(%rbp,%rcx,1),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,0x0(%rbp,%rcx,1)
movupd %xmm2,0x10(%rbp,%rcx,1)
movupd 0x20(%rbx,%rcx,1),%xmm1
movupd 0x30(%rbx,%rcx,1),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,0x20(%rbx,%rcx,1)
movupd %xmm2,0x30(%rbx,%rcx,1)
movupd 0x20(%rbp,%rcx,1),%xmm1
movupd 0x30(%rbp,%rcx,1),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,0x20(%rbp,%rcx,1)
movupd %xmm2,0x30(%rbp,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rdx
jne    2200 <Inverse_SO3_Naive+0x1050>
test   $0x1,%al
je     22ce <Inverse_SO3_Naive+0x111e>
movupd (%rbx,%rcx,1),%xmm1
movupd 0x10(%rbx,%rcx,1),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,(%rbx,%rcx,1)
movupd %xmm2,0x10(%rbx,%rcx,1)
movupd 0x0(%rbp,%rcx,1),%xmm1
movupd 0x10(%rbp,%rcx,1),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,0x0(%rbp,%rcx,1)
movupd %xmm2,0x10(%rbp,%rcx,1)
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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