void Inverse_SO3_Naive_sym(int bw, double *rcoeffs, double *icoeffs,
                           double *rdata, double *idata, double *workspace1,
                           double *workspace2, int flag) {
  int j, n;
  int m1, m2;
  int sampHere, sampHere2, coefHere;
  double *t1r, *t1i;
  double *sinPts, *cosPts, *sinPts2, *cosPts2;
  double *wignersTrans, *scratch;
  double *rdataPtr, *idataPtr;
  double *rcoeffsPtr, *icoeffsPtr;
  double dn;
  n = 2 * bw;
  t1r = workspace1;
  t1i = workspace1 + (n * n * n);
  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);
  genWigTrans_L2(0, 0, bw, sinPts, cosPts, sinPts2, cosPts2, wignersTrans,
                 scratch);
  sampHere = sampLoc_so3(0, 0, bw);
  coefHere = coefLoc_so3(0, 0, bw);
  rcoeffsPtr = rcoeffs;
  icoeffsPtr = icoeffs;
  rdataPtr = rdata;
  idataPtr = idata;
  rdataPtr += sampHere;
  idataPtr += sampHere;
  rcoeffsPtr += coefHere;
  icoeffsPtr += coefHere;
  wigNaiveSynthesis(0, 0, bw, rcoeffsPtr, wignersTrans, rdataPtr, scratch);
  wigNaiveSynthesis(0, 0, bw, icoeffsPtr, wignersTrans, idataPtr, scratch);
  for (m1 = 1; m1 < bw; m1++) {
    genWigTrans_L2(m1, m1, bw, sinPts, cosPts, sinPts2, cosPts2, wignersTrans,
                   scratch);
    sampHere = sampLoc_so3(m1, m1, bw);
    coefHere = coefLoc_so3(m1, m1, bw);
    rcoeffsPtr = rcoeffs;
    icoeffsPtr = icoeffs;
    rdataPtr = rdata;
    idataPtr = idata;
    rdataPtr += sampHere;
    idataPtr += sampHere;
    rcoeffsPtr += coefHere;
    icoeffsPtr += coefHere;
    wigNaiveSynthesis(m1, m1, bw, rcoeffsPtr, wignersTrans, rdataPtr, scratch);
    wigNaiveSynthesis(m1, m1, bw, icoeffsPtr, wignersTrans, idataPtr, scratch);
    if (flag == 0) {
      sampHere = sampLoc_so3(-m1, -m1, bw);
      coefHere = coefLoc_so3(-m1, -m1, bw);
      rcoeffsPtr = rcoeffs;
      icoeffsPtr = icoeffs;
      rdataPtr = rdata;
      idataPtr = idata;
      rdataPtr += sampHere;
      idataPtr += sampHere;
      rcoeffsPtr += coefHere;
      icoeffsPtr += coefHere;
      wigNaiveSynthesis(-m1, -m1, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                        scratch);
      wigNaiveSynthesis(-m1, -m1, bw, icoeffsPtr, wignersTrans, idataPtr,
                        scratch);
    } else {
      sampHere = sampLoc_so3(m1, m1, bw);
      sampHere2 = sampLoc_so3(-m1, -m1, bw);
      for (j = 0; j < 2 * bw; j++) {
        rdata[sampHere2 + j] = rdata[sampHere + j];
        idata[sampHere2 + j] = -idata[sampHere + j];
      }
    }
    sampHere = sampLoc_so3(-m1, m1, bw);
    coefHere = coefLoc_so3(-m1, m1, bw);
    rcoeffsPtr = rcoeffs;
    icoeffsPtr = icoeffs;
    rdataPtr = rdata;
    idataPtr = idata;
    rdataPtr += sampHere;
    idataPtr += sampHere;
    rcoeffsPtr += coefHere;
    icoeffsPtr += coefHere;
    wigNaiveSynthesis_symY(-m1, m1, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                           scratch);
    wigNaiveSynthesis_symY(-m1, m1, bw, icoeffsPtr, wignersTrans, idataPtr,
                           scratch);
    if (flag == 0) {
      sampHere = sampLoc_so3(m1, -m1, bw);
      coefHere = coefLoc_so3(m1, -m1, bw);
      rcoeffsPtr = rcoeffs;
      icoeffsPtr = icoeffs;
      rdataPtr = rdata;
      idataPtr = idata;
      rdataPtr += sampHere;
      idataPtr += sampHere;
      rcoeffsPtr += coefHere;
      icoeffsPtr += coefHere;
      wigNaiveSynthesis_symY(m1, -m1, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                             scratch);
      wigNaiveSynthesis_symY(m1, -m1, bw, icoeffsPtr, wignersTrans, idataPtr,
                             scratch);
    } else {
      sampHere = sampLoc_so3(-m1, m1, bw);
      sampHere2 = sampLoc_so3(m1, -m1, bw);
      for (j = 0; j < 2 * bw; j++) {
        rdata[sampHere2 + j] = rdata[sampHere + j];
        idata[sampHere2 + j] = -idata[sampHere + j];
      }
    }
  }
  for (m1 = 1; m1 < bw; m1++) {
    genWigTrans_L2(m1, 0, bw, sinPts, cosPts, sinPts2, cosPts2, wignersTrans,
                   scratch);
    sampHere = sampLoc_so3(m1, 0, bw);
    coefHere = coefLoc_so3(m1, 0, bw);
    rcoeffsPtr = rcoeffs;
    icoeffsPtr = icoeffs;
    rdataPtr = rdata;
    idataPtr = idata;
    rdataPtr += sampHere;
    idataPtr += sampHere;
    rcoeffsPtr += coefHere;
    icoeffsPtr += coefHere;
    wigNaiveSynthesis(m1, 0, bw, rcoeffsPtr, wignersTrans, rdataPtr, scratch);
    wigNaiveSynthesis(m1, 0, bw, icoeffsPtr, wignersTrans, idataPtr, scratch);
    if (flag == 0) {
      sampHere = sampLoc_so3(-m1, 0, bw);
      coefHere = coefLoc_so3(-m1, 0, bw);
      rcoeffsPtr = rcoeffs;
      icoeffsPtr = icoeffs;
      rdataPtr = rdata;
      idataPtr = idata;
      rdataPtr += sampHere;
      idataPtr += sampHere;
      rcoeffsPtr += coefHere;
      icoeffsPtr += coefHere;
      wigNaiveSynthesis_symX(-m1, 0, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                             scratch);
      wigNaiveSynthesis_symX(-m1, 0, bw, icoeffsPtr, wignersTrans, idataPtr,
                             scratch);
    } else {
      sampHere = sampLoc_so3(m1, 0, bw);
      sampHere2 = sampLoc_so3(-m1, 0, bw);
      for (j = 0; j < 2 * bw; j++) {
        rdata[sampHere2 + j] = rdata[sampHere + j];
        idata[sampHere2 + j] = -idata[sampHere + j];
      }
    }
    sampHere = sampLoc_so3(0, m1, bw);
    coefHere = coefLoc_so3(0, m1, bw);
    rcoeffsPtr = rcoeffs;
    icoeffsPtr = icoeffs;
    rdataPtr = rdata;
    idataPtr = idata;
    rdataPtr += sampHere;
    idataPtr += sampHere;
    rcoeffsPtr += coefHere;
    icoeffsPtr += coefHere;
    wigNaiveSynthesis_symX(0, m1, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                           scratch);
    wigNaiveSynthesis_symX(0, m1, bw, icoeffsPtr, wignersTrans, idataPtr,
                           scratch);
    if (flag == 0) {
      sampHere = sampLoc_so3(0, -m1, bw);
      coefHere = coefLoc_so3(0, -m1, bw);
      rcoeffsPtr = rcoeffs;
      icoeffsPtr = icoeffs;
      rdataPtr = rdata;
      idataPtr = idata;
      rdataPtr += sampHere;
      idataPtr += sampHere;
      rcoeffsPtr += coefHere;
      icoeffsPtr += coefHere;
      wigNaiveSynthesis(0, -m1, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                        scratch);
      wigNaiveSynthesis(0, -m1, bw, icoeffsPtr, wignersTrans, idataPtr,
                        scratch);
    } else {
      sampHere = sampLoc_so3(0, m1, bw);
      sampHere2 = sampLoc_so3(0, -m1, bw);
      for (j = 0; j < 2 * bw; j++) {
        rdata[sampHere2 + j] = rdata[sampHere + j];
        idata[sampHere2 + j] = -idata[sampHere + j];
      }
    }
  }
  for (m1 = 1; m1 < bw; m1++) {
    for (m2 = m1 + 1; m2 < bw; m2++) {
      genWigTrans_L2(m1, m2, bw, sinPts, cosPts, sinPts2, cosPts2, wignersTrans,
                     scratch);
      sampHere = sampLoc_so3(m1, m2, bw);
      coefHere = coefLoc_so3(m1, m2, bw);
      rcoeffsPtr = rcoeffs;
      icoeffsPtr = icoeffs;
      rdataPtr = rdata;
      idataPtr = idata;
      rdataPtr += sampHere;
      idataPtr += sampHere;
      rcoeffsPtr += coefHere;
      icoeffsPtr += coefHere;
      wigNaiveSynthesis(m1, m2, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                        scratch);
      wigNaiveSynthesis(m1, m2, bw, icoeffsPtr, wignersTrans, idataPtr,
                        scratch);
      if (flag == 0) {
        sampHere = sampLoc_so3(-m1, -m2, bw);
        coefHere = coefLoc_so3(-m1, -m2, bw);
        rcoeffsPtr = rcoeffs;
        icoeffsPtr = icoeffs;
        rdataPtr = rdata;
        idataPtr = idata;
        rdataPtr += sampHere;
        idataPtr += sampHere;
        rcoeffsPtr += coefHere;
        icoeffsPtr += coefHere;
        wigNaiveSynthesis_symX(-m1, -m2, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                               scratch);
        wigNaiveSynthesis_symX(-m1, -m2, bw, icoeffsPtr, wignersTrans, idataPtr,
                               scratch);
      } else {
        sampHere = sampLoc_so3(m1, m2, bw);
        sampHere2 = sampLoc_so3(-m1, -m2, bw);
        for (j = 0; j < 2 * bw; j++) {
          rdata[sampHere2 + j] = rdata[sampHere + j];
          idata[sampHere2 + j] = -idata[sampHere + j];
        }
      }
      sampHere = sampLoc_so3(m1, -m2, bw);
      coefHere = coefLoc_so3(m1, -m2, bw);
      rcoeffsPtr = rcoeffs;
      icoeffsPtr = icoeffs;
      rdataPtr = rdata;
      idataPtr = idata;
      rdataPtr += sampHere;
      idataPtr += sampHere;
      rcoeffsPtr += coefHere;
      icoeffsPtr += coefHere;
      wigNaiveSynthesis_symY(m1, -m2, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                             scratch);
      wigNaiveSynthesis_symY(m1, -m2, bw, icoeffsPtr, wignersTrans, idataPtr,
                             scratch);
      if (flag == 0) {
        sampHere = sampLoc_so3(-m1, m2, bw);
        coefHere = coefLoc_so3(-m1, m2, bw);
        rcoeffsPtr = rcoeffs;
        icoeffsPtr = icoeffs;
        rdataPtr = rdata;
        idataPtr = idata;
        rdataPtr += sampHere;
        idataPtr += sampHere;
        rcoeffsPtr += coefHere;
        icoeffsPtr += coefHere;
        wigNaiveSynthesis_symY(-m1, m2, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                               scratch);
        wigNaiveSynthesis_symY(-m1, m2, bw, icoeffsPtr, wignersTrans, idataPtr,
                               scratch);
      } else {
        sampHere = sampLoc_so3(m1, -m2, bw);
        sampHere2 = sampLoc_so3(-m1, m2, bw);
        for (j = 0; j < 2 * bw; j++) {
          rdata[sampHere2 + j] = rdata[sampHere + j];
          idata[sampHere2 + j] = -idata[sampHere + j];
        }
      }
      sampHere = sampLoc_so3(m2, m1, bw);
      coefHere = coefLoc_so3(m2, m1, bw);
      rcoeffsPtr = rcoeffs;
      icoeffsPtr = icoeffs;
      rdataPtr = rdata;
      idataPtr = idata;
      rdataPtr += sampHere;
      idataPtr += sampHere;
      rcoeffsPtr += coefHere;
      icoeffsPtr += coefHere;
      wigNaiveSynthesis_symX(m2, m1, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                             scratch);
      wigNaiveSynthesis_symX(m2, m1, bw, icoeffsPtr, wignersTrans, idataPtr,
                             scratch);
      if (flag == 0) {
        sampHere = sampLoc_so3(-m2, -m1, bw);
        coefHere = coefLoc_so3(-m2, -m1, bw);
        rcoeffsPtr = rcoeffs;
        icoeffsPtr = icoeffs;
        rdataPtr = rdata;
        idataPtr = idata;
        rdataPtr += sampHere;
        idataPtr += sampHere;
        rcoeffsPtr += coefHere;
        icoeffsPtr += coefHere;
        wigNaiveSynthesis(-m2, -m1, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                          scratch);
        wigNaiveSynthesis(-m2, -m1, bw, icoeffsPtr, wignersTrans, idataPtr,
                          scratch);
      } else {
        sampHere = sampLoc_so3(m2, m1, bw);
        sampHere2 = sampLoc_so3(-m2, -m1, bw);
        for (j = 0; j < 2 * bw; j++) {
          rdata[sampHere2 + j] = rdata[sampHere + j];
          idata[sampHere2 + j] = -idata[sampHere + j];
        }
      }
      sampHere = sampLoc_so3(m2, -m1, bw);
      coefHere = coefLoc_so3(m2, -m1, bw);
      rcoeffsPtr = rcoeffs;
      icoeffsPtr = icoeffs;
      rdataPtr = rdata;
      idataPtr = idata;
      rdataPtr += sampHere;
      idataPtr += sampHere;
      rcoeffsPtr += coefHere;
      icoeffsPtr += coefHere;
      wigNaiveSynthesis_symY(m1, -m2, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                             scratch);
      wigNaiveSynthesis_symY(m1, -m2, bw, icoeffsPtr, wignersTrans, idataPtr,
                             scratch);
      if (flag == 0) {
        sampHere = sampLoc_so3(-m2, m1, bw);
        coefHere = coefLoc_so3(-m2, m1, bw);
        rcoeffsPtr = rcoeffs;
        icoeffsPtr = icoeffs;
        rdataPtr = rdata;
        idataPtr = idata;
        rdataPtr += sampHere;
        idataPtr += sampHere;
        rcoeffsPtr += coefHere;
        icoeffsPtr += coefHere;
        wigNaiveSynthesis_symY(-m1, m2, bw, rcoeffsPtr, wignersTrans, rdataPtr,
                               scratch);
        wigNaiveSynthesis_symY(-m1, m2, bw, icoeffsPtr, wignersTrans, idataPtr,
                               scratch);
      } else {
        sampHere = sampLoc_so3(m2, -m1, bw);
        sampHere2 = sampLoc_so3(-m2, m1, bw);
        for (j = 0; j < 2 * bw; j++) {
          rdata[sampHere2 + j] = rdata[sampHere + j];
          idata[sampHere2 + j] = -idata[sampHere + j];
        }
      }
    }
  }
  rdataPtr = rdata + (n) * (bw);
  idataPtr = idata + (n) * (bw);
  for (m1 = 0; m1 < bw; m1++) {
    memset(rdataPtr, 0, sizeof(double) * n);
    memset(idataPtr, 0, sizeof(double) * n);
    rdataPtr += (2 * n) * (bw);
    idataPtr += (2 * n) * (bw);
  }
  rdataPtr = rdata + bw * n * (n);
  idataPtr = idata + bw * n * (n);
  memset(rdataPtr, 0, sizeof(double) * n * n);
  memset(idataPtr, 0, sizeof(double) * n * n);
  rdataPtr += n * n + n * bw;
  idataPtr += n * n + n * bw;
  for (m1 = 1; m1 < bw; m1++) {
    memset(rdataPtr, 0, sizeof(double) * n);
    memset(idataPtr, 0, sizeof(double) * n);
    rdataPtr += (2 * n) * (bw);
    idataPtr += (2 * n) * (bw);
  }
  transpose_so3(rdata, t1r, n, n * n);
  transpose_so3(idata, t1i, n, n * n);
  grid_fourier_so3(t1r, t1i, rdata, idata, n * n, n, scratch);
  transpose_so3(rdata, t1r, n, n * n);
  transpose_so3(idata, 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_sym>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x18(%rbp),%eax
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,-0x58(%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,-0x60(%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
mov    $0x0,%al
call   10b0 <SinEvalPts@plt>
mov    -0x38(%rbp),%edi
mov    -0x70(%rbp),%rsi
mov    $0x0,%al
call   10d0 <CosEvalPts@plt>
mov    -0x38(%rbp),%edi
mov    -0x78(%rbp),%rsi
mov    $0x0,%al
call   1060 <SinEvalPts2@plt>
mov    -0x38(%rbp),%edi
mov    -0x80(%rbp),%rsi
mov    $0x0,%al
call   1040 <CosEvalPts2@plt>
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
xor    %esi,%esi
mov    %esi,%edi
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   10c0 <genWigTrans_L2@plt>
mov    -0x4(%rbp),%edx
xor    %esi,%esi
mov    %esi,%edi
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
mov    -0x4(%rbp),%edx
xor    %esi,%esi
mov    %esi,%edi
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
xor    %esi,%esi
mov    %esi,%edi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
xor    %esi,%esi
mov    %esi,%edi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1aa5 <Inverse_SO3_Naive_sym+0x8d5>
mov    -0x3c(%rbp),%edi
mov    -0x3c(%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)
mov    $0x0,%al
call   10c0 <genWigTrans_L2@plt>
mov    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
mov    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
cmpl   $0x0,0x18(%rbp)
jne    16cf <Inverse_SO3_Naive_sym+0x4ff>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
jmp    1783 <Inverse_SO3_Naive_sym+0x5b3>
mov    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    177e <Inverse_SO3_Naive_sym+0x5ae>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1700 <Inverse_SO3_Naive_sym+0x530>
jmp    1783 <Inverse_SO3_Naive_sym+0x5b3>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
cmpl   $0x0,0x18(%rbp)
jne    19de <Inverse_SO3_Naive_sym+0x80e>
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
jmp    1a92 <Inverse_SO3_Naive_sym+0x8c2>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    1a8d <Inverse_SO3_Naive_sym+0x8bd>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a0f <Inverse_SO3_Naive_sym+0x83f>
jmp    1a92 <Inverse_SO3_Naive_sym+0x8c2>
jmp    1a97 <Inverse_SO3_Naive_sym+0x8c7>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    142c <Inverse_SO3_Naive_sym+0x25c>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    20fc <Inverse_SO3_Naive_sym+0xf2c>
mov    -0x3c(%rbp),%edi
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
xor    %esi,%esi
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   10c0 <genWigTrans_L2@plt>
mov    -0x3c(%rbp),%edi
mov    -0x4(%rbp),%edx
xor    %esi,%esi
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x4(%rbp),%edx
xor    %esi,%esi
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
xor    %esi,%esi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
mov    -0x3c(%rbp),%edi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
xor    %esi,%esi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
cmpl   $0x0,0x18(%rbp)
jne    1d3e <Inverse_SO3_Naive_sym+0xb6e>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x4(%rbp),%edx
xor    %esi,%esi
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x4(%rbp),%edx
xor    %esi,%esi
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
xor    %esi,%esi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1090 <wigNaiveSynthesis_symX@plt>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
xor    %esi,%esi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1090 <wigNaiveSynthesis_symX@plt>
jmp    1dee <Inverse_SO3_Naive_sym+0xc1e>
mov    -0x3c(%rbp),%edi
mov    -0x4(%rbp),%edx
xor    %esi,%esi
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x4(%rbp),%edx
xor    %esi,%esi
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    1de9 <Inverse_SO3_Naive_sym+0xc19>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1d6b <Inverse_SO3_Naive_sym+0xb9b>
jmp    1dee <Inverse_SO3_Naive_sym+0xc1e>
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
xor    %edi,%edi
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
xor    %edi,%edi
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
xor    %edi,%edi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1090 <wigNaiveSynthesis_symX@plt>
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
xor    %edi,%edi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1090 <wigNaiveSynthesis_symX@plt>
cmpl   $0x0,0x18(%rbp)
jne    2039 <Inverse_SO3_Naive_sym+0xe69>
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
xor    %edi,%edi
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
xor    %edi,%edi
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
xor    %edi,%edi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
xor    %edi,%edi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
jmp    20e9 <Inverse_SO3_Naive_sym+0xf19>
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
xor    %edi,%edi
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
xor    %edi,%edi
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    20e4 <Inverse_SO3_Naive_sym+0xf14>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2066 <Inverse_SO3_Naive_sym+0xe96>
jmp    20e9 <Inverse_SO3_Naive_sym+0xf19>
jmp    20ee <Inverse_SO3_Naive_sym+0xf1e>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1aac <Inverse_SO3_Naive_sym+0x8dc>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2dc2 <Inverse_SO3_Naive_sym+0x1bf2>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2daf <Inverse_SO3_Naive_sym+0x1bdf>
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)
mov    $0x0,%al
call   10c0 <genWigTrans_L2@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
cmpl   $0x0,0x18(%rbp)
jne    23bb <Inverse_SO3_Naive_sym+0x11eb>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1090 <wigNaiveSynthesis_symX@plt>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1090 <wigNaiveSynthesis_symX@plt>
jmp    246f <Inverse_SO3_Naive_sym+0x129f>
mov    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    246a <Inverse_SO3_Naive_sym+0x129a>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    23ec <Inverse_SO3_Naive_sym+0x121c>
jmp    246f <Inverse_SO3_Naive_sym+0x129f>
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
cmpl   $0x0,0x18(%rbp)
jne    26ca <Inverse_SO3_Naive_sym+0x14fa>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
jmp    277e <Inverse_SO3_Naive_sym+0x15ae>
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    2779 <Inverse_SO3_Naive_sym+0x15a9>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    26fb <Inverse_SO3_Naive_sym+0x152b>
jmp    277e <Inverse_SO3_Naive_sym+0x15ae>
mov    -0x40(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x40(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1090 <wigNaiveSynthesis_symX@plt>
mov    -0x40(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1090 <wigNaiveSynthesis_symX@plt>
cmpl   $0x0,0x18(%rbp)
jne    29d9 <Inverse_SO3_Naive_sym+0x1809>
xor    %edi,%edi
sub    -0x40(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x40(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
xor    %edi,%edi
sub    -0x40(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
xor    %edi,%edi
sub    -0x40(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <wigNaiveSynthesis@plt>
jmp    2a8d <Inverse_SO3_Naive_sym+0x18bd>
mov    -0x40(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x40(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    2a88 <Inverse_SO3_Naive_sym+0x18b8>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2a0a <Inverse_SO3_Naive_sym+0x183a>
jmp    2a8d <Inverse_SO3_Naive_sym+0x18bd>
mov    -0x40(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    -0x3c(%rbp),%edi
xor    %esi,%esi
sub    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
cmpl   $0x0,0x18(%rbp)
jne    2ce8 <Inverse_SO3_Naive_sym+0x1b18>
xor    %edi,%edi
sub    -0x40(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x40(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1050 <coefLoc_so3@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x44(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xa8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0x4c(%rbp),%ecx
mov    -0xb0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xb0(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xa8(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0x98(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0xb0(%rbp),%rcx
mov    -0x88(%rbp),%r8
mov    -0xa0(%rbp),%r9
mov    -0x90(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10e0 <wigNaiveSynthesis_symY@plt>
jmp    2d9c <Inverse_SO3_Naive_sym+0x1bcc>
mov    -0x40(%rbp),%edi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x44(%rbp)
xor    %edi,%edi
sub    -0x40(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    $0x0,%al
call   1070 <sampLoc_so3@plt>
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    2d97 <Inverse_SO3_Naive_sym+0x1bc7>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2d19 <Inverse_SO3_Naive_sym+0x1b49>
jmp    2d9c <Inverse_SO3_Naive_sym+0x1bcc>
jmp    2da1 <Inverse_SO3_Naive_sym+0x1bd1>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    2118 <Inverse_SO3_Naive_sym+0xf48>
jmp    2db4 <Inverse_SO3_Naive_sym+0x1be4>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2103 <Inverse_SO3_Naive_sym+0xf33>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x4(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2e8b <Inverse_SO3_Naive_sym+0x1cbb>
mov    -0x98(%rbp),%rdi
movslq -0x38(%rbp),%rdx
shl    $0x3,%rdx
xor    %esi,%esi
call   1080 <memset@plt>
mov    -0xa0(%rbp),%rdi
movslq -0x38(%rbp),%rdx
shl    $0x3,%rdx
xor    %esi,%esi
call   1080 <memset@plt>
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x4(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x4(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2e01 <Inverse_SO3_Naive_sym+0x1c31>
mov    -0x20(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x4(%rbp),%ecx
imul   -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rdi
movslq -0x38(%rbp),%rdx
shl    $0x3,%rdx
movslq -0x38(%rbp),%rax
imul   %rax,%rdx
xor    %esi,%esi
call   1080 <memset@plt>
mov    -0xa0(%rbp),%rdi
movslq -0x38(%rbp),%rdx
shl    $0x3,%rdx
movslq -0x38(%rbp),%rax
imul   %rax,%rdx
xor    %esi,%esi
call   1080 <memset@plt>
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
mov    -0x38(%rbp),%eax
imul   -0x4(%rbp),%eax
add    %eax,%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
mov    -0x38(%rbp),%eax
imul   -0x4(%rbp),%eax
add    %eax,%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    2fe8 <Inverse_SO3_Naive_sym+0x1e18>
mov    -0x98(%rbp),%rdi
movslq -0x38(%rbp),%rdx
shl    $0x3,%rdx
xor    %esi,%esi
call   1080 <memset@plt>
mov    -0xa0(%rbp),%rdi
movslq -0x38(%rbp),%rdx
shl    $0x3,%rdx
xor    %esi,%esi
call   1080 <memset@plt>
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x4(%rbp),%ecx
mov    -0x98(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x4(%rbp),%ecx
mov    -0xa0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xa0(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2f5e <Inverse_SO3_Naive_sym+0x1d8e>
mov    -0x20(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x38(%rbp),%edx
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
mov    $0x0,%al
call   10f0 <transpose_so3@plt>
mov    -0x28(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x38(%rbp),%edx
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
mov    $0x0,%al
call   10f0 <transpose_so3@plt>
mov    -0x58(%rbp),%rdi
mov    -0x60(%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)
mov    $0x0,%al
call   10a0 <grid_fourier_so3@plt>
mov    -0x20(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x38(%rbp),%edx
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
mov    $0x0,%al
call   10f0 <transpose_so3@plt>
mov    -0x28(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x38(%rbp),%edx
mov    -0x38(%rbp),%ecx
imul   -0x38(%rbp),%ecx
mov    $0x0,%al
call   10f0 <transpose_so3@plt>
mov    -0x58(%rbp),%rdi
mov    -0x60(%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)
mov    $0x0,%al
call   10a0 <grid_fourier_so3@plt>
cvtsi2sdl -0x38(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
cvtsi2sdl -0x4(%rbp),%xmm0
movsd  0xf3c(%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    3137 <Inverse_SO3_Naive_sym+0x1f67>
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    30df <Inverse_SO3_Naive_sym+0x1f0f>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Inverse_SO3_Naive_sym>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r9,0x130(%rsp)
mov    %r8,0x20(%rsp)
mov    %rcx,0x28(%rsp)
mov    %rdx,0x40(%rsp)
mov    %rsi,0x38(%rsp)
mov    %edi,%r13d
mov    0x170(%rsp),%rdx
lea    0x0(%r13,%r13,1),%ecx
mov    %ecx,%eax
imul   %ecx,%eax
mov    %eax,0x114(%rsp)
imul   %ecx,%eax
mov    %eax,0x118(%rsp)
movslq %ecx,%rbp
lea    (%rdx,%rbp,8),%rbx
mov    %rdx,%rsi
lea    (%rbx,%rbp,8),%r12
lea    (%r12,%rbp,8),%r14
mov    %ecx,0xf4(%rsp)
imul   %edi,%ecx
lea    (%r14,%rbp,8),%r15
mov    %ecx,0xf0(%rsp)
movslq %ecx,%rax
mov    %rax,0x128(%rsp)
lea    (%r15,%rax,8),%rax
mov    %rax,0x68(%rsp)
mov    %ebp,%edi
xor    %eax,%eax
call   10b0 <SinEvalPts@plt>
mov    %ebp,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   10d0 <CosEvalPts@plt>
mov    %ebp,%edi
mov    %r12,%rsi
xor    %eax,%eax
call   1060 <SinEvalPts2@plt>
mov    %rbp,0x120(%rsp)
mov    %ebp,%edi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <CosEvalPts2@plt>
mov    0x68(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14,0xd8(%rsp)
mov    %r14,(%rsp)
xor    %edi,%edi
xor    %esi,%esi
mov    %r13d,%edx
mov    0x170(%rsp),%rcx
mov    %rbx,0xe8(%rsp)
mov    %rbx,%r8
mov    %r12,0xe0(%rsp)
mov    %r12,%r9
xor    %eax,%eax
call   10c0 <genWigTrans_L2@plt>
xor    %edi,%edi
xor    %esi,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebp
xor    %edi,%edi
xor    %esi,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %ebp,%rcx
mov    0x28(%rsp),%rbp
lea    0x0(,%rcx,8),%r9
add    %rbp,%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%r14
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%r12
mov    0x68(%rsp),%rbx
mov    %rbx,(%rsp)
xor    %edi,%edi
xor    %esi,%esi
mov    %r13d,%edx
mov    %r15,%r8
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
mov    %rbx,(%rsp)
xor    %edi,%edi
xor    %esi,%esi
mov    %r13d,%edx
mov    %r12,%rcx
mov    %r15,0x70(%rsp)
mov    %r15,%r8
mov    %r14,%r9
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
cmp    $0x2,%r13d
mov    %rbp,%r12
mov    %r13,0xc0(%rsp)
jl     3923 <Inverse_SO3_Naive_sym+0x2753>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,0x108(%rsp)
mov    0xf4(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%r15d
mov    $0x1,%r10d
cmovge %eax,%r10d
lea    (%r12,%r10,8),%rdx
mov    0x20(%rsp),%rdi
lea    (%rdi,%r10,8),%rax
mov    %r10d,%esi
and    $0x7ffffffc,%esi
mov    %rsi,0x48(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0xb8(%rsp)
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rax,0x78(%rsp)
cmp    %r12,%rax
seta   %al
mov    %rdx,0x80(%rsp)
cmp    %rdi,%rdx
seta   %dl
and    %al,%dl
mov    %dl,0x60(%rsp)
mov    %rsi,%rax
mov    %rsi,0x98(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xa0(%rsp)
mov    %r10,%rax
neg    %rax
mov    %rax,0x90(%rsp)
lea    0x30(%rdi),%rax
mov    %rax,0xd0(%rsp)
lea    0x30(%r12),%rax
mov    %rax,0xc8(%rsp)
lea    0x8(%r12),%rax
mov    %rax,0xb0(%rsp)
lea    0x8(%rdi),%rax
mov    %rax,0xa8(%rsp)
mov    0x68(%rsp),%r14
mov    0x40(%rsp),%rbx
mov    %r10,0x30(%rsp)
jmp    1525 <Inverse_SO3_Naive_sym+0x355>
nopl   0x0(%rax)
mov    0x58(%rsp),%r12d
mov    %r12d,%edi
mov    %ebx,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%r14d
mov    %r12d,%edi
mov    %ebx,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %r14d,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x50(%rsp)
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x40(%rsp),%r14
lea    (%r14,%rax,8),%rax
mov    %rax,0x88(%rsp)
mov    0x68(%rsp),%rbp
mov    %rbp,(%rsp)
mov    %r12d,%edi
mov    %ebx,%esi
mov    %r13d,%edx
mov    0x70(%rsp),%r15
mov    %r15,%r8
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    %rbp,(%rsp)
mov    %r12d,%edi
mov    %ebx,%esi
mov    %r13d,%edx
mov    0x88(%rsp),%rcx
mov    %r15,%r8
mov    0x50(%rsp),%r9
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    %r14,%rbx
mov    %rbp,%r14
mov    0x30(%rsp),%r10
mov    0x58(%rsp),%eax
add    $0x1,%eax
mov    0xc0(%rsp),%r13
mov    %eax,%r15d
cmp    %r13d,%eax
je     1d60 <Inverse_SO3_Naive_sym+0xb90>
mov    %r14,0x10(%rsp)
mov    0x70(%rsp),%r12
mov    %r12,0x8(%rsp)
mov    0xd8(%rsp),%rax
mov    %rax,(%rsp)
mov    %r15d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
mov    0x170(%rsp),%rcx
mov    0xe8(%rsp),%r8
mov    0xe0(%rsp),%r9
xor    %eax,%eax
call   10c0 <genWigTrans_L2@plt>
mov    %r15d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebp
mov    %r15d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %ebp,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x50(%rsp)
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
lea    (%rbx,%rax,8),%rbp
mov    %r14,(%rsp)
mov    %r15d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
mov    %r12,%r8
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
mov    %r14,(%rsp)
mov    %r15d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
mov    %rbp,%rcx
mov    %r12,%r8
mov    0x50(%rsp),%r9
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
cmpl   $0x0,0x178(%rsp)
mov    %r15d,0x58(%rsp)
je     1650 <Inverse_SO3_Naive_sym+0x480>
mov    %r15d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    %r15d,%r12d
neg    %r12d
mov    %r12d,%edi
mov    %r12d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
movslq %ebx,%r8
movslq %eax,%r11
mov    0x30(%rsp),%r9
cmp    $0x4,%r9d
jae    16e0 <Inverse_SO3_Naive_sym+0x510>
xor    %edx,%edx
movapd 0x39c1(%rip),%xmm2
mov    0x20(%rsp),%r10
jmp    18f0 <Inverse_SO3_Naive_sym+0x720>
nopl   0x0(%rax)
mov    %r15d,%ebp
neg    %ebp
mov    %ebp,%edi
mov    %ebp,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%r12d
mov    %ebp,%edi
mov    %ebp,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %r12d,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x50(%rsp)
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
lea    (%rbx,%rax,8),%r12
mov    %r14,(%rsp)
mov    %ebp,%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    0x70(%rsp),%rbx
mov    %rbx,%r8
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
mov    %r14,(%rsp)
mov    %ebp,%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    %r12,%rcx
mov    %ebp,%r12d
mov    %rbx,%r8
mov    0x50(%rsp),%r9
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
jmp    19a5 <Inverse_SO3_Naive_sym+0x7d5>
nopl   0x0(%rax)
mov    %r12d,%r14d
mov    0x28(%rsp),%rax
lea    (%rax,%r11,8),%rcx
mov    0x80(%rsp),%rdx
lea    (%rdx,%r11,8),%rsi
mov    0x20(%rsp),%r9
lea    (%r9,%r11,8),%r12
lea    (%rax,%r8,8),%rdi
lea    (%rdx,%r8,8),%rbx
mov    0x78(%rsp),%rbp
lea    0x0(,%r8,8),%rax
add    %rbp,%rax
cmp    %rbx,%rcx
setb   %dl
cmp    %rsi,%rdi
setb   %r13b
and    %dl,%r13b
or     0x60(%rsp),%r13b
cmp    %rax,%rcx
lea    (%r9,%r8,8),%r9
setb   %dl
cmp    %rsi,%r9
setb   %r10b
cmp    %rbx,%r12
lea    0x0(%rbp,%r11,8),%rsi
setb   %bl
cmp    %rsi,%rdi
setb   %dil
cmp    %rax,%r12
setb   %cl
cmp    %rsi,%r9
setb   %sil
test   %r13b,%r13b
jne    18bd <Inverse_SO3_Naive_sym+0x6ed>
and    %r10b,%dl
movapd 0x388e(%rip),%xmm2
jne    18d3 <Inverse_SO3_Naive_sym+0x703>
and    %dil,%bl
mov    0x20(%rsp),%r10
mov    0x30(%rsp),%r9
mov    %r14d,%r12d
jne    18b9 <Inverse_SO3_Naive_sym+0x6e9>
mov    $0x0,%edx
and    %sil,%cl
jne    18f0 <Inverse_SO3_Naive_sym+0x720>
cmpq   $0x0,0xb8(%rsp)
je     18ab <Inverse_SO3_Naive_sym+0x6db>
mov    0xd0(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    0xc8(%rsp),%rcx
lea    (%rcx,%r8,8),%rdi
lea    (%rax,%r11,8),%rbp
lea    (%rcx,%r11,8),%rbx
mov    0xa0(%rsp),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%rdi,%rdx,8),%xmm0
movups -0x20(%rdi,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,8)
movups %xmm1,-0x20(%rbx,%rdx,8)
movupd -0x30(%rsi,%rdx,8),%xmm0
movupd -0x20(%rsi,%rdx,8),%xmm1
xorpd  %xmm2,%xmm0
xorpd  %xmm2,%xmm1
movupd %xmm0,-0x30(%rbp,%rdx,8)
movupd %xmm1,-0x20(%rbp,%rdx,8)
movups -0x10(%rdi,%rdx,8),%xmm0
movups (%rdi,%rdx,8),%xmm1
movups %xmm0,-0x10(%rbx,%rdx,8)
movups %xmm1,(%rbx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
xorpd  %xmm2,%xmm0
xorpd  %xmm2,%xmm1
movupd %xmm0,-0x10(%rbp,%rdx,8)
movupd %xmm1,0x0(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    17e0 <Inverse_SO3_Naive_sym+0x610>
testb  $0x1,0x98(%rsp)
01
je     1899 <Inverse_SO3_Naive_sym+0x6c9>
lea    (%rdx,%r8,1),%rax
mov    0x28(%rsp),%rcx
movups (%rcx,%rax,8),%xmm0
movups 0x10(%rcx,%rax,8),%xmm1
add    %r11,%rdx
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
movupd (%r10,%rax,8),%xmm0
movupd 0x10(%r10,%rax,8),%xmm1
xorpd  %xmm2,%xmm0
xorpd  %xmm2,%xmm1
movupd %xmm0,(%r10,%rdx,8)
movupd %xmm1,0x10(%r10,%rdx,8)
mov    0x48(%rsp),%rax
mov    %rax,%rdx
cmp    %r9,%rax
jne    18f0 <Inverse_SO3_Naive_sym+0x720>
jmp    199d <Inverse_SO3_Naive_sym+0x7cd>
xor    %edx,%edx
testb  $0x1,0x98(%rsp)
01
jne    1859 <Inverse_SO3_Naive_sym+0x689>
jmp    1899 <Inverse_SO3_Naive_sym+0x6c9>
xor    %edx,%edx
jmp    18f0 <Inverse_SO3_Naive_sym+0x720>
xor    %edx,%edx
mov    0x20(%rsp),%r10
mov    0x30(%rsp),%r9
movapd 0x372f(%rip),%xmm2
jmp    18df <Inverse_SO3_Naive_sym+0x70f>
xor    %edx,%edx
mov    0x20(%rsp),%r10
mov    0x30(%rsp),%r9
mov    %r14d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdx,%rcx
test   $0x1,%r9b
je     1927 <Inverse_SO3_Naive_sym+0x757>
lea    (%rdx,%r8,1),%rax
mov    0x28(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
lea    (%rdx,%r11,1),%rcx
movsd  %xmm0,(%rsi,%rcx,8)
movsd  (%r10,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%r10,%rcx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x90(%rsp),%rdx
je     199d <Inverse_SO3_Naive_sym+0x7cd>
mov    0xb0(%rsp),%rsi
lea    (%rsi,%r11,8),%rdx
mov    0xa8(%rsp),%rdi
lea    (%rdi,%r11,8),%rax
lea    (%rsi,%r8,8),%rsi
lea    (%rdi,%r8,8),%rdi
movapd 0x36a4(%rip),%xmm1
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rcx,8)
movsd  -0x8(%rdi,%rcx,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,-0x8(%rax,%rcx,8)
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  (%rdi,%rcx,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1960 <Inverse_SO3_Naive_sym+0x790>
mov    0xc0(%rsp),%r13
mov    %r12d,%edi
mov    0x58(%rsp),%r14d
mov    %r14d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    %r12d,%edi
mov    %r14d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %ebx,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x50(%rsp)
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%rbp
mov    %r12d,%ebx
mov    0x68(%rsp),%r12
mov    %r12,(%rsp)
mov    %ebx,%edi
mov    %r14d,%esi
mov    %r13d,%edx
mov    0x70(%rsp),%r15
mov    %r15,%r8
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    %r12,(%rsp)
mov    %ebx,%edi
mov    %r14d,%esi
mov    %r13d,%edx
mov    %rbp,%rcx
mov    %r15,%r8
mov    0x50(%rsp),%r9
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
cmpl   $0x0,0x178(%rsp)
je     1460 <Inverse_SO3_Naive_sym+0x290>
mov    %ebx,%edi
mov    0x58(%rsp),%ebp
mov    %ebp,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%r14d
mov    %ebp,%edi
mov    %ebx,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
movslq %r14d,%r8
movslq %eax,%r9
mov    0x30(%rsp),%r10
cmp    $0x4,%r10d
jae    1b60 <Inverse_SO3_Naive_sym+0x990>
xor    %ecx,%ecx
mov    0x68(%rsp),%r14
mov    0x40(%rsp),%rbx
movapd 0x356b(%rip),%xmm2
movapd 0x3563(%rip),%xmm3
mov    %rcx,%rdx
test   $0x1,%r10b
je     1ad7 <Inverse_SO3_Naive_sym+0x907>
lea    (%rcx,%r8,1),%rax
mov    0x28(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
lea    (%rcx,%r9,1),%rdx
movsd  %xmm0,(%rsi,%rdx,8)
mov    0x20(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rsi,%rdx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
cmp    0x90(%rsp),%rcx
je     150a <Inverse_SO3_Naive_sym+0x33a>
mov    0xb0(%rsp),%rsi
lea    (%rsi,%r9,8),%rcx
mov    0xa8(%rsp),%rdi
lea    (%rdi,%r9,8),%rax
lea    (%rsi,%r8,8),%rsi
lea    (%rdi,%r8,8),%rdi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  -0x8(%rdi,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,-0x8(%rax,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  (%rdi,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    1b10 <Inverse_SO3_Naive_sym+0x940>
jmp    150a <Inverse_SO3_Naive_sym+0x33a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x28(%rsp),%rcx
lea    (%rcx,%r9,8),%rax
mov    0x80(%rsp),%rsi
lea    (%rsi,%r9,8),%r11
mov    0x20(%rsp),%rdx
lea    (%rdx,%r9,8),%r10
lea    (%rcx,%r8,8),%r14
lea    (%rsi,%r8,8),%rbp
mov    0x78(%rsp),%rdi
lea    (%rdi,%r8,8),%rsi
cmp    %rbp,%rax
setb   %cl
cmp    %r11,%r14
setb   %bl
and    %cl,%bl
or     0x60(%rsp),%bl
cmp    %rsi,%rax
lea    (%rdx,%r8,8),%rax
setb   %cl
cmp    %r11,%rax
setb   %r11b
cmp    %rbp,%r10
lea    (%rdi,%r9,8),%rbp
setb   %dl
cmp    %rbp,%r14
setb   %dil
cmp    %rsi,%r10
setb   %r10b
cmp    %rbp,%rax
setb   %sil
test   %bl,%bl
jne    1d4a <Inverse_SO3_Naive_sym+0xb7a>
and    %r11b,%cl
mov    0x68(%rsp),%r14
mov    0x40(%rsp),%rbx
movapd 0x3412(%rip),%xmm2
movapd 0x340a(%rip),%xmm3
jne    1cd1 <Inverse_SO3_Naive_sym+0xb01>
and    %dil,%dl
jne    1cd1 <Inverse_SO3_Naive_sym+0xb01>
mov    $0x0,%ecx
and    %sil,%r10b
mov    0x30(%rsp),%r10
jne    1a9d <Inverse_SO3_Naive_sym+0x8cd>
cmpq   $0x0,0xb8(%rsp)
je     1cdd <Inverse_SO3_Naive_sym+0xb0d>
mov    %rbx,%r12
mov    0xd0(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    0xc8(%rsp),%rcx
lea    (%rcx,%r8,8),%rdi
lea    (%rax,%r9,8),%rbp
lea    (%rcx,%r9,8),%rbx
mov    0xa0(%rsp),%rcx
xor    %edx,%edx
mov    0x20(%rsp),%r11
nopl   0x0(%rax)
movups -0x30(%rdi,%rdx,8),%xmm0
movups -0x20(%rdi,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,8)
movups %xmm1,-0x20(%rbx,%rdx,8)
movupd -0x30(%rsi,%rdx,8),%xmm0
movupd -0x20(%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x30(%rbp,%rdx,8)
movupd %xmm1,-0x20(%rbp,%rdx,8)
movups -0x10(%rdi,%rdx,8),%xmm0
movups (%rdi,%rdx,8),%xmm1
movups %xmm0,-0x10(%rbx,%rdx,8)
movups %xmm1,(%rbx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x10(%rbp,%rdx,8)
movupd %xmm1,0x0(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1c60 <Inverse_SO3_Naive_sym+0xa90>
jmp    1ce7 <Inverse_SO3_Naive_sym+0xb17>
xor    %ecx,%ecx
mov    0x30(%rsp),%r10
jmp    1a9d <Inverse_SO3_Naive_sym+0x8cd>
mov    %rbx,%r12
xor    %edx,%edx
mov    0x20(%rsp),%r11
testb  $0x1,0x98(%rsp)
01
mov    %r12,%rbx
je     1d34 <Inverse_SO3_Naive_sym+0xb64>
lea    (%rdx,%r8,1),%rax
mov    0x28(%rsp),%rcx
movups (%rcx,%rax,8),%xmm0
movups 0x10(%rcx,%rax,8),%xmm1
add    %r9,%rdx
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
movupd (%r11,%rax,8),%xmm0
movupd 0x10(%r11,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%r11,%rdx,8)
movupd %xmm1,0x10(%r11,%rdx,8)
mov    0x48(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
je     150a <Inverse_SO3_Naive_sym+0x33a>
jmp    1a9d <Inverse_SO3_Naive_sym+0x8cd>
xor    %ecx,%ecx
mov    0x68(%rsp),%r14
mov    0x40(%rsp),%rbx
mov    0x30(%rsp),%r10
jmp    1a8d <Inverse_SO3_Naive_sym+0x8bd>
cmp    $0x2,%r13d
mov    0x28(%rsp),%r12
jl     3923 <Inverse_SO3_Naive_sym+0x2753>
cmp    %r12,0x78(%rsp)
seta   %al
mov    0x20(%rsp),%rcx
cmp    %rcx,0x80(%rsp)
seta   %cl
and    %al,%cl
mov    %cl,0x60(%rsp)
and    $0x7ffffffc,%r10d
mov    %r10,0x48(%rsp)
mov    0x98(%rsp),%rcx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
mov    %rcx,0xa0(%rsp)
mov    $0x1,%r14d
jmp    1e6b <Inverse_SO3_Naive_sym+0xc9b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14d,%ebp
neg    %ebp
xor    %edi,%edi
mov    %ebp,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%r12d
xor    %edi,%edi
mov    %ebp,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %r12d,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x50(%rsp)
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%r12
mov    %rbx,(%rsp)
xor    %edi,%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    %r15,%r8
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
mov    %rbx,(%rsp)
xor    %edi,%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    %r12,%rcx
mov    %r15,%r8
mov    0x50(%rsp),%r9
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
mov    0x30(%rsp),%rbp
add    $0x1,%r14d
cmp    %r13d,%r14d
mov    0x28(%rsp),%r12
je     26a2 <Inverse_SO3_Naive_sym+0x14d2>
mov    0x68(%rsp),%r15
mov    %r15,0x10(%rsp)
mov    0x70(%rsp),%rbp
mov    %rbp,0x8(%rsp)
mov    0xd8(%rsp),%rax
mov    %rax,(%rsp)
mov    %r14d,%edi
xor    %esi,%esi
mov    %r13d,%edx
mov    0x170(%rsp),%rcx
mov    0xe8(%rsp),%r8
mov    0xe0(%rsp),%r9
xor    %eax,%eax
call   10c0 <genWigTrans_L2@plt>
mov    %r14d,%edi
xor    %esi,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    %r14d,%edi
xor    %esi,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %ebx,%rcx
lea    (%r12,%rcx,8),%r9
mov    %rbp,%r12
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rbx
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%rbp
mov    %r15,(%rsp)
mov    %r14d,%edi
xor    %esi,%esi
mov    %r13d,%edx
mov    %r12,%r8
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
mov    %r15,(%rsp)
mov    %r14d,%edi
xor    %esi,%esi
mov    %r13d,%edx
mov    %rbp,%rcx
mov    %r12,%r8
mov    %rbx,%r9
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
cmpl   $0x0,0x178(%rsp)
mov    %r14d,0x58(%rsp)
je     2050 <Inverse_SO3_Naive_sym+0xe80>
mov    %r14d,%edi
xor    %esi,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    %r14d,%edi
neg    %edi
xor    %esi,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
movslq %ebx,%r8
movslq %eax,%r9
mov    0x30(%rsp),%r10
cmp    $0x4,%r10d
jae    21d0 <Inverse_SO3_Naive_sym+0x1000>
xor    %ecx,%ecx
mov    0x28(%rsp),%r15
mov    0x38(%rsp),%rbp
movapd 0x3077(%rip),%xmm2
movapd 0x306f(%rip),%xmm3
mov    %rcx,%rdx
test   $0x1,%r10b
je     1fc8 <Inverse_SO3_Naive_sym+0xdf8>
lea    (%rcx,%r8,1),%rax
movsd  (%r15,%rax,8),%xmm0
lea    (%rcx,%r9,1),%rdx
movsd  %xmm0,(%r15,%rdx,8)
mov    0x20(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rsi,%rdx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
cmp    0x90(%rsp),%rcx
je     20e6 <Inverse_SO3_Naive_sym+0xf16>
mov    0xb0(%rsp),%rsi
lea    (%rsi,%r9,8),%rcx
mov    0xa8(%rsp),%rdi
lea    (%rdi,%r9,8),%rax
lea    (%rsi,%r8,8),%rsi
lea    (%rdi,%r8,8),%rdi
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  -0x8(%rdi,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,-0x8(%rax,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  (%rdi,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    2000 <Inverse_SO3_Naive_sym+0xe30>
jmp    20e6 <Inverse_SO3_Naive_sym+0xf16>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14d,%ebp
neg    %ebp
mov    %ebp,%edi
xor    %esi,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    %ebp,%edi
xor    %esi,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %ebx,%rcx
mov    0x28(%rsp),%rbx
lea    (%rbx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x50(%rsp)
cltq
mov    0x38(%rsp),%r14
lea    (%r14,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    %rax,0x88(%rsp)
mov    %r15,(%rsp)
mov    %ebp,%edi
xor    %esi,%esi
mov    %r13d,%edx
mov    %r12,%r8
xor    %eax,%eax
call   1090 <wigNaiveSynthesis_symX@plt>
mov    %r15,(%rsp)
mov    %ebp,%edi
xor    %esi,%esi
mov    %r13d,%edx
mov    0x88(%rsp),%rcx
mov    %r12,%r8
mov    0x50(%rsp),%r9
xor    %eax,%eax
call   1090 <wigNaiveSynthesis_symX@plt>
mov    %rbx,%r15
mov    %r14,%rbp
xor    %edi,%edi
mov    0x58(%rsp),%r14d
mov    %r14d,%esi
mov    0xc0(%rsp),%r13
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
xor    %edi,%edi
mov    %r14d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %ebx,%rcx
lea    (%r15,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%r12
cltq
lea    0x0(%rbp,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%rbp
mov    0x68(%rsp),%rbx
mov    %rbx,(%rsp)
xor    %edi,%edi
mov    %r14d,%esi
mov    %r13d,%edx
mov    0x70(%rsp),%r15
mov    %r15,%r8
xor    %eax,%eax
call   1090 <wigNaiveSynthesis_symX@plt>
mov    %rbx,(%rsp)
xor    %edi,%edi
mov    %r14d,%esi
mov    %r13d,%edx
mov    %rbp,%rcx
mov    %r15,%r8
mov    %r12,%r9
xor    %eax,%eax
call   1090 <wigNaiveSynthesis_symX@plt>
cmpl   $0x0,0x178(%rsp)
je     1dd0 <Inverse_SO3_Naive_sym+0xc00>
xor    %edi,%edi
mov    %r14d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    %r14d,%esi
neg    %esi
xor    %edi,%edi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
movslq %ebx,%r8
movslq %eax,%r9
mov    0x30(%rsp),%rbp
cmp    $0x4,%ebp
jae    2350 <Inverse_SO3_Naive_sym+0x1180>
xor    %ecx,%ecx
movapd 0x2e43(%rip),%xmm2
movapd 0x2e3b(%rip),%xmm3
jmp    25f0 <Inverse_SO3_Naive_sym+0x1420>
nopw   0x0(%rax,%rax,1)
mov    0x28(%rsp),%r15
lea    (%r15,%r9,8),%rax
mov    0x80(%rsp),%rsi
lea    (%rsi,%r9,8),%rdx
mov    0x20(%rsp),%rcx
lea    (%rcx,%r9,8),%r10
lea    (%r15,%r8,8),%r14
lea    (%rsi,%r8,8),%rbp
mov    0x78(%rsp),%rdi
lea    (%rdi,%r8,8),%rsi
cmp    %rbp,%rax
setb   %r11b
cmp    %rdx,%r14
setb   %bl
and    %r11b,%bl
or     0x60(%rsp),%bl
cmp    %rsi,%rax
lea    (%rcx,%r8,8),%rax
setb   %cl
cmp    %rdx,%rax
setb   %r11b
cmp    %rbp,%r10
lea    (%rdi,%r9,8),%rbp
setb   %dl
cmp    %rbp,%r14
setb   %dil
cmp    %rsi,%r10
setb   %r10b
cmp    %rbp,%rax
setb   %sil
test   %bl,%bl
jne    25bb <Inverse_SO3_Naive_sym+0x13eb>
and    %r11b,%cl
mov    0x38(%rsp),%rbp
movapd 0x2da5(%rip),%xmm2
movapd 0x2d9d(%rip),%xmm3
jne    2524 <Inverse_SO3_Naive_sym+0x1354>
and    %dil,%dl
jne    2524 <Inverse_SO3_Naive_sym+0x1354>
mov    $0x0,%ecx
and    %sil,%r10b
mov    0x30(%rsp),%r10
jne    1f91 <Inverse_SO3_Naive_sym+0xdc1>
cmpq   $0x0,0xb8(%rsp)
je     2530 <Inverse_SO3_Naive_sym+0x1360>
mov    %rbp,%r11
mov    0xd0(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    0xc8(%rsp),%rcx
lea    (%rcx,%r8,8),%rdi
lea    (%rax,%r9,8),%rbp
lea    (%rcx,%r9,8),%rbx
mov    0xa0(%rsp),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdi,%rdx,8),%xmm0
movups -0x20(%rdi,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,8)
movups %xmm1,-0x20(%rbx,%rdx,8)
movupd -0x30(%rsi,%rdx,8),%xmm0
movupd -0x20(%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x30(%rbp,%rdx,8)
movupd %xmm1,-0x20(%rbp,%rdx,8)
movups -0x10(%rdi,%rdx,8),%xmm0
movups (%rdi,%rdx,8),%xmm1
movups %xmm0,-0x10(%rbx,%rdx,8)
movups %xmm1,(%rbx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x10(%rbp,%rdx,8)
movupd %xmm1,0x0(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    22d0 <Inverse_SO3_Naive_sym+0x1100>
jmp    2535 <Inverse_SO3_Naive_sym+0x1365>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14d,%r15d
mov    0x28(%rsp),%rsi
lea    (%rsi,%r9,8),%rax
mov    0x80(%rsp),%rbp
lea    0x0(,%r9,8),%rdx
add    %rbp,%rdx
mov    0x20(%rsp),%rcx
lea    (%rcx,%r9,8),%r10
lea    (%rsi,%r8,8),%r14
lea    0x0(%rbp,%r8,8),%rbp
mov    0x78(%rsp),%rdi
lea    (%rdi,%r8,8),%rsi
cmp    %rbp,%rax
setb   %r11b
cmp    %rdx,%r14
setb   %bl
and    %r11b,%bl
or     0x60(%rsp),%bl
cmp    %rsi,%rax
lea    (%rcx,%r8,8),%rax
setb   %cl
cmp    %rdx,%rax
setb   %r11b
cmp    %rbp,%r10
lea    (%rdi,%r9,8),%rbp
setb   %dl
cmp    %rbp,%r14
setb   %dil
cmp    %rsi,%r10
setb   %r10b
cmp    %rbp,%rax
setb   %sil
test   %bl,%bl
jne    25cc <Inverse_SO3_Naive_sym+0x13fc>
and    %r11b,%cl
movapd 0x2c1f(%rip),%xmm2
movapd 0x2c17(%rip),%xmm3
jne    25e5 <Inverse_SO3_Naive_sym+0x1415>
and    %dil,%dl
mov    %r15d,%r14d
jne    25b2 <Inverse_SO3_Naive_sym+0x13e2>
mov    $0x0,%ecx
and    %sil,%r10b
mov    0x30(%rsp),%rbp
jne    25f0 <Inverse_SO3_Naive_sym+0x1420>
cmpq   $0x0,0xb8(%rsp)
je     2598 <Inverse_SO3_Naive_sym+0x13c8>
mov    0xd0(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    0xc8(%rsp),%rcx
lea    (%rcx,%r8,8),%rdi
lea    (%rax,%r9,8),%rbp
lea    (%rcx,%r9,8),%rbx
mov    0xa0(%rsp),%rcx
xor    %edx,%edx
mov    0x28(%rsp),%r10
nopl   0x0(%rax)
movups -0x30(%rdi,%rdx,8),%xmm0
movups -0x20(%rdi,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,8)
movups %xmm1,-0x20(%rbx,%rdx,8)
movupd -0x30(%rsi,%rdx,8),%xmm0
movupd -0x20(%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x30(%rbp,%rdx,8)
movupd %xmm1,-0x20(%rbp,%rdx,8)
movups -0x10(%rdi,%rdx,8),%xmm0
movups (%rdi,%rdx,8),%xmm1
movups %xmm0,-0x10(%rbx,%rdx,8)
movups %xmm1,(%rbx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x10(%rbp,%rdx,8)
movupd %xmm1,0x0(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    2450 <Inverse_SO3_Naive_sym+0x1280>
testb  $0x1,0x98(%rsp)
01
je     2509 <Inverse_SO3_Naive_sym+0x1339>
lea    (%rdx,%r8,1),%rax
movups (%r10,%rax,8),%xmm0
movups 0x10(%r10,%rax,8),%xmm1
add    %r9,%rdx
movups %xmm0,(%r10,%rdx,8)
movups %xmm1,0x10(%r10,%rdx,8)
mov    0x20(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%rcx,%rdx,8)
movupd %xmm1,0x10(%rcx,%rdx,8)
mov    0x48(%rsp),%rax
mov    %rax,%rcx
mov    0x30(%rsp),%rbp
cmp    %rbp,%rax
je     1e59 <Inverse_SO3_Naive_sym+0xc89>
jmp    25f0 <Inverse_SO3_Naive_sym+0x1420>
xor    %ecx,%ecx
mov    0x30(%rsp),%r10
jmp    1f91 <Inverse_SO3_Naive_sym+0xdc1>
mov    %rbp,%r11
xor    %edx,%edx
testb  $0x1,0x98(%rsp)
01
mov    %r11,%rbp
je     2582 <Inverse_SO3_Naive_sym+0x13b2>
lea    (%rdx,%r8,1),%rax
movups (%r15,%rax,8),%xmm0
movups 0x10(%r15,%rax,8),%xmm1
add    %r9,%rdx
movups %xmm0,(%r15,%rdx,8)
movups %xmm1,0x10(%r15,%rdx,8)
mov    0x20(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%rcx,%rdx,8)
movupd %xmm1,0x10(%rcx,%rdx,8)
mov    0x48(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
jne    1f91 <Inverse_SO3_Naive_sym+0xdc1>
jmp    20e6 <Inverse_SO3_Naive_sym+0xf16>
xor    %edx,%edx
mov    0x28(%rsp),%r10
testb  $0x1,0x98(%rsp)
01
jne    24c9 <Inverse_SO3_Naive_sym+0x12f9>
jmp    2509 <Inverse_SO3_Naive_sym+0x1339>
xor    %ecx,%ecx
mov    0x30(%rsp),%rbp
jmp    25f0 <Inverse_SO3_Naive_sym+0x1420>
xor    %ecx,%ecx
mov    0x38(%rsp),%rbp
mov    0x30(%rsp),%r10
jmp    1f81 <Inverse_SO3_Naive_sym+0xdb1>
xor    %ecx,%ecx
mov    0x30(%rsp),%rbp
movapd 0x2a25(%rip),%xmm2
movapd 0x2a1d(%rip),%xmm3
jmp    25ec <Inverse_SO3_Naive_sym+0x141c>
xor    %ecx,%ecx
mov    0x30(%rsp),%rbp
mov    %r15d,%r14d
nop
mov    %rcx,%rdx
test   $0x1,%bpl
je     262a <Inverse_SO3_Naive_sym+0x145a>
lea    (%rcx,%r8,1),%rax
mov    0x28(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
lea    (%rcx,%r9,1),%rdx
movsd  %xmm0,(%rsi,%rdx,8)
mov    0x20(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rsi,%rdx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
cmp    0x90(%rsp),%rcx
je     1e59 <Inverse_SO3_Naive_sym+0xc89>
mov    0xb0(%rsp),%rsi
lea    (%rsi,%r9,8),%rcx
mov    0xa8(%rsp),%rdi
lea    (%rdi,%r9,8),%rax
lea    (%rsi,%r8,8),%rsi
lea    (%rdi,%r8,8),%rdi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  -0x8(%rdi,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,-0x8(%rax,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  (%rdi,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rbp
jne    2660 <Inverse_SO3_Naive_sym+0x1490>
jmp    1e59 <Inverse_SO3_Naive_sym+0xc89>
cmp    $0x2,%r13d
jl     3923 <Inverse_SO3_Naive_sym+0x2753>
cmp    %r12,0x78(%rsp)
seta   %al
mov    0x20(%rsp),%rcx
cmp    %rcx,0x80(%rsp)
seta   %cl
and    %al,%cl
mov    %cl,0xa0(%rsp)
and    $0x7ffffffc,%ebp
mov    %rbp,0xf8(%rsp)
mov    0x98(%rsp),%rax
and    %rax,0x108(%rsp)
mov    $0x1,%eax
jmp    2713 <Inverse_SO3_Naive_sym+0x1543>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x11c(%rsp),%eax
cmp    %r15d,%eax
mov    %r15,%r13
je     3923 <Inverse_SO3_Naive_sym+0x2753>
mov    %eax,%r14d
lea    0x1(%r14),%eax
mov    %eax,0x11c(%rsp)
cmp    %r13d,%eax
mov    %r13,%r15
jge    2700 <Inverse_SO3_Naive_sym+0x1530>
mov    %r14d,%eax
neg    %eax
mov    %eax,0x58(%rsp)
mov    0x11c(%rsp),%r13d
mov    %r14,0x88(%rsp)
jmp    27fa <Inverse_SO3_Naive_sym+0x162a>
nopw   0x0(%rax,%rax,1)
mov    %r13d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebp
mov    %r13d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %ebp,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x60(%rsp)
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    %rax,0x48(%rsp)
mov    %r12,(%rsp)
mov    0x58(%rsp),%ebp
mov    %ebp,%edi
mov    0x50(%rsp),%r13d
mov    %r13d,%esi
mov    %ebx,%edx
mov    %r15,%r8
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    %r12,(%rsp)
mov    %ebp,%edi
mov    %r13d,%esi
mov    %ebx,%edx
mov    0x48(%rsp),%rcx
mov    %r15,%r8
mov    0x60(%rsp),%r9
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    0x28(%rsp),%r12
add    $0x1,%r13d
mov    0xc0(%rsp),%r15
cmp    %r15d,%r13d
je     2700 <Inverse_SO3_Naive_sym+0x1530>
mov    0x68(%rsp),%rbp
mov    %rbp,0x10(%rsp)
mov    0x70(%rsp),%r12
mov    %r12,0x8(%rsp)
mov    0xd8(%rsp),%rax
mov    %rax,(%rsp)
mov    %r14d,%edi
mov    %r13d,%esi
mov    %r15d,%edx
mov    0x170(%rsp),%rcx
mov    0xe8(%rsp),%r8
mov    0xe0(%rsp),%r9
xor    %eax,%eax
call   10c0 <genWigTrans_L2@plt>
mov    %r14d,%edi
mov    %r13d,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    %r14d,%edi
mov    %r13d,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %ebx,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x60(%rsp)
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%rbx
mov    %rbp,(%rsp)
mov    %r14d,%edi
mov    %r13d,%esi
mov    %r15d,%edx
mov    %r12,%r8
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
mov    %rbp,(%rsp)
mov    %r14d,%edi
mov    %r13d,%esi
mov    %r15d,%edx
mov    %rbx,%rcx
mov    %r12,%r8
mov    0x60(%rsp),%r9
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
cmpl   $0x0,0x178(%rsp)
mov    %r13d,0x50(%rsp)
je     2930 <Inverse_SO3_Naive_sym+0x1760>
mov    %r14d,%edi
mov    %r13d,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
neg    %r13d
mov    0x58(%rsp),%edi
mov    %r13d,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
movslq %ebx,%r8
movslq %eax,%r11
mov    0x30(%rsp),%r9
cmp    $0x4,%r9d
jae    29d0 <Inverse_SO3_Naive_sym+0x1800>
xor    %edx,%edx
movapd 0x26e4(%rip),%xmm2
mov    0x20(%rsp),%r14
jmp    2bd0 <Inverse_SO3_Naive_sym+0x1a00>
cs nopw 0x0(%rax,%rax,1)
neg    %r13d
mov    0x58(%rsp),%ebp
mov    %ebp,%edi
mov    %r13d,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%r14d
mov    %ebp,%edi
mov    %r13d,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %r14d,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x60(%rsp)
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%r12
mov    0x68(%rsp),%r14
mov    %r14,(%rsp)
mov    %ebp,%edi
mov    %r13d,%esi
mov    %r15d,%edx
mov    0x70(%rsp),%rbx
mov    %rbx,%r8
xor    %eax,%eax
call   1090 <wigNaiveSynthesis_symX@plt>
mov    %r14,(%rsp)
mov    %ebp,%edi
mov    %r13d,%esi
mov    %r15d,%edx
mov    %r12,%rcx
mov    0x28(%rsp),%rbp
mov    %rbx,%r8
mov    0x60(%rsp),%r9
xor    %eax,%eax
call   1090 <wigNaiveSynthesis_symX@plt>
jmp    2c9a <Inverse_SO3_Naive_sym+0x1aca>
xchg   %ax,%ax
mov    %r13d,%r12d
mov    0x28(%rsp),%rax
lea    (%rax,%r11,8),%rcx
mov    0x80(%rsp),%rdx
lea    (%rdx,%r11,8),%rsi
mov    0x20(%rsp),%r9
lea    (%r9,%r11,8),%r14
lea    (%rax,%r8,8),%rdi
lea    (%rdx,%r8,8),%rbx
mov    0x78(%rsp),%rbp
lea    0x0(,%r8,8),%rax
add    %rbp,%rax
cmp    %rbx,%rcx
setb   %dl
cmp    %rsi,%rdi
setb   %r13b
and    %dl,%r13b
or     0xa0(%rsp),%r13b
cmp    %rax,%rcx
lea    (%r9,%r8,8),%r9
setb   %dl
cmp    %rsi,%r9
setb   %r10b
cmp    %rbx,%r14
lea    0x0(%rbp,%r11,8),%rsi
setb   %bl
cmp    %rsi,%rdi
setb   %dil
cmp    %rax,%r14
setb   %cl
cmp    %rsi,%r9
setb   %sil
test   %r13b,%r13b
jne    2ba9 <Inverse_SO3_Naive_sym+0x19d9>
and    %r10b,%dl
jne    2ba9 <Inverse_SO3_Naive_sym+0x19d9>
and    %dil,%bl
mov    0x20(%rsp),%r14
mov    0x30(%rsp),%r9
movapd 0x2588(%rip),%xmm2
mov    %r12d,%r13d
jne    2bc2 <Inverse_SO3_Naive_sym+0x19f2>
mov    $0x0,%edx
and    %sil,%cl
jne    2bd0 <Inverse_SO3_Naive_sym+0x1a00>
cmpq   $0x0,0xb8(%rsp)
je     2b9b <Inverse_SO3_Naive_sym+0x19cb>
mov    0xd0(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    0xc8(%rsp),%rcx
lea    (%rcx,%r8,8),%rdi
lea    (%rax,%r11,8),%rbp
lea    (%rcx,%r11,8),%rbx
mov    0x108(%rsp),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdi,%rdx,8),%xmm0
movups -0x20(%rdi,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,8)
movups %xmm1,-0x20(%rbx,%rdx,8)
movupd -0x30(%rsi,%rdx,8),%xmm0
movupd -0x20(%rsi,%rdx,8),%xmm1
xorpd  %xmm2,%xmm0
xorpd  %xmm2,%xmm1
movupd %xmm0,-0x30(%rbp,%rdx,8)
movupd %xmm1,-0x20(%rbp,%rdx,8)
movups -0x10(%rdi,%rdx,8),%xmm0
movups (%rdi,%rdx,8),%xmm1
movups %xmm0,-0x10(%rbx,%rdx,8)
movups %xmm1,(%rbx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
xorpd  %xmm2,%xmm0
xorpd  %xmm2,%xmm1
movupd %xmm0,-0x10(%rbp,%rdx,8)
movupd %xmm1,0x0(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    2ad0 <Inverse_SO3_Naive_sym+0x1900>
testb  $0x1,0x98(%rsp)
01
je     2b89 <Inverse_SO3_Naive_sym+0x19b9>
lea    (%rdx,%r8,1),%rax
mov    0x28(%rsp),%rcx
movups (%rcx,%rax,8),%xmm0
movups 0x10(%rcx,%rax,8),%xmm1
add    %r11,%rdx
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
movupd (%r14,%rax,8),%xmm0
movupd 0x10(%r14,%rax,8),%xmm1
xorpd  %xmm2,%xmm0
xorpd  %xmm2,%xmm1
movupd %xmm0,(%r14,%rdx,8)
movupd %xmm1,0x10(%r14,%rdx,8)
mov    0xf8(%rsp),%rax
mov    %rax,%rdx
cmp    %r9,%rax
jne    2bd0 <Inverse_SO3_Naive_sym+0x1a00>
jmp    2c14 <Inverse_SO3_Naive_sym+0x1a44>
xor    %edx,%edx
testb  $0x1,0x98(%rsp)
01
jne    2b49 <Inverse_SO3_Naive_sym+0x1979>
jmp    2b89 <Inverse_SO3_Naive_sym+0x19b9>
xor    %edx,%edx
mov    0x20(%rsp),%r14
mov    0x30(%rsp),%r9
movapd 0x2443(%rip),%xmm2
mov    %r12d,%r13d
jmp    2bd0 <Inverse_SO3_Naive_sym+0x1a00>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdx,%rcx
test   $0x1,%r9b
je     2c07 <Inverse_SO3_Naive_sym+0x1a37>
lea    (%rdx,%r8,1),%rax
mov    0x28(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
lea    (%rdx,%r11,1),%rcx
movsd  %xmm0,(%rsi,%rcx,8)
movsd  (%r14,%rax,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%r14,%rcx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x90(%rsp),%rdx
jne    2c20 <Inverse_SO3_Naive_sym+0x1a50>
mov    0x28(%rsp),%rbp
jmp    2c9a <Inverse_SO3_Naive_sym+0x1aca>
nopl   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%rsi
lea    (%rsi,%r11,8),%rdx
mov    0xa8(%rsp),%rdi
lea    (%rdi,%r11,8),%rax
lea    (%rsi,%r8,8),%rsi
lea    (%rdi,%r8,8),%rdi
movapd 0x23b8(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rcx,8)
movsd  -0x8(%rdi,%rcx,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,-0x8(%rax,%rcx,8)
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
movsd  (%rdi,%rcx,8),%xmm0
xorpd  %xmm1,%xmm0
movlpd %xmm0,(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    2c50 <Inverse_SO3_Naive_sym+0x1a80>
mov    0x28(%rsp),%rbp
mov    0xc0(%rsp),%r15
mov    0x88(%rsp),%r14
mov    %r14d,%edi
mov    %r13d,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    %r14d,%edi
mov    %r13d,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %ebx,%rcx
lea    0x0(,%rcx,8),%r9
add    %rbp,%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x48(%rsp)
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%r12
mov    %r13d,%ebp
mov    0x68(%rsp),%r13
mov    %r13,(%rsp)
mov    %r14d,%edi
mov    %ebp,%esi
mov    %r15d,%edx
mov    0x70(%rsp),%rbx
mov    %rbx,%r8
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    %r13,(%rsp)
mov    %r14d,%edi
mov    %ebp,%esi
mov    %r15d,%edx
mov    %r12,%rcx
mov    %rbx,%r8
mov    0x48(%rsp),%r9
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
cmpl   $0x0,0x178(%rsp)
mov    %ebp,0x60(%rsp)
je     2da0 <Inverse_SO3_Naive_sym+0x1bd0>
mov    %r14d,%edi
mov    %ebp,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    0x58(%rsp),%edi
mov    0x50(%rsp),%r12d
mov    %r12d,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
movslq %ebx,%r8
movslq %eax,%r9
mov    0x30(%rsp),%r10
cmp    $0x4,%r10d
mov    %r15,%r13
jae    2e50 <Inverse_SO3_Naive_sym+0x1c80>
xor    %ecx,%ecx
mov    0x38(%rsp),%r14
movapd 0x226f(%rip),%xmm2
jmp    3050 <Inverse_SO3_Naive_sym+0x1e80>
cs nopw 0x0(%rax,%rax,1)
mov    0x58(%rsp),%ebp
mov    %ebp,%edi
mov    0x50(%rsp),%ebx
mov    %ebx,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%r14d
mov    %ebp,%edi
mov    %ebx,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %r14d,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x48(%rsp)
cltq
mov    0x38(%rsp),%r13
lea    0x0(%r13,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    %rax,0x100(%rsp)
mov    0x68(%rsp),%r12
mov    %r12,(%rsp)
mov    %ebp,%edi
mov    %ebx,%esi
mov    %r15d,%edx
mov    0x70(%rsp),%r14
mov    %r14,%r8
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    %r12,(%rsp)
mov    %ebx,%r12d
mov    %ebp,%edi
mov    %ebx,%esi
mov    %r15d,%edx
mov    0x100(%rsp),%rcx
mov    %r14,%r8
mov    0x48(%rsp),%r9
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    %r13,%r14
mov    %r15,%r13
jmp    30fd <Inverse_SO3_Naive_sym+0x1f2d>
nopl   (%rax)
mov    0x28(%rsp),%rcx
lea    (%rcx,%r9,8),%rax
mov    0x80(%rsp),%rsi
lea    (%rsi,%r9,8),%r11
mov    0x20(%rsp),%rdx
lea    (%rdx,%r9,8),%r10
lea    (%rcx,%r8,8),%r14
lea    (%rsi,%r8,8),%rbp
mov    0x78(%rsp),%rdi
lea    (%rdi,%r8,8),%rsi
cmp    %rbp,%rax
setb   %cl
cmp    %r11,%r14
setb   %bl
and    %cl,%bl
or     0xa0(%rsp),%bl
cmp    %rsi,%rax
lea    (%rdx,%r8,8),%rax
setb   %cl
cmp    %r11,%rax
setb   %r11b
cmp    %rbp,%r10
lea    (%rdi,%r9,8),%rbp
setb   %dl
cmp    %rbp,%r14
setb   %dil
cmp    %rsi,%r10
setb   %r10b
cmp    %rbp,%rax
setb   %sil
test   %bl,%bl
jne    3025 <Inverse_SO3_Naive_sym+0x1e55>
and    %r11b,%cl
jne    3025 <Inverse_SO3_Naive_sym+0x1e55>
and    %dil,%dl
mov    0x38(%rsp),%r14
movapd 0x211b(%rip),%xmm2
jne    303b <Inverse_SO3_Naive_sym+0x1e6b>
mov    $0x0,%ecx
and    %sil,%r10b
mov    0x30(%rsp),%r10
jne    3050 <Inverse_SO3_Naive_sym+0x1e80>
cmpq   $0x0,0xb8(%rsp)
je     300f <Inverse_SO3_Naive_sym+0x1e3f>
mov    0xd0(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    0xc8(%rsp),%rcx
lea    (%rcx,%r8,8),%rdi
lea    (%rax,%r9,8),%rbp
lea    (%rcx,%r9,8),%rbx
mov    0x108(%rsp),%rcx
xor    %edx,%edx
movapd 0x20c1(%rip),%xmm3
nop
movups -0x30(%rdi,%rdx,8),%xmm0
movups -0x20(%rdi,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,8)
movups %xmm1,-0x20(%rbx,%rdx,8)
movupd -0x30(%rsi,%rdx,8),%xmm0
movupd -0x20(%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x30(%rbp,%rdx,8)
movupd %xmm1,-0x20(%rbp,%rdx,8)
movups -0x10(%rdi,%rdx,8),%xmm0
movups (%rdi,%rdx,8),%xmm1
movups %xmm0,-0x10(%rbx,%rdx,8)
movups %xmm1,(%rbx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x10(%rbp,%rdx,8)
movupd %xmm1,0x0(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    2f40 <Inverse_SO3_Naive_sym+0x1d70>
testb  $0x1,0x98(%rsp)
01
je     2ffa <Inverse_SO3_Naive_sym+0x1e2a>
lea    (%rdx,%r8,1),%rax
mov    0x28(%rsp),%rcx
movups (%rcx,%rax,8),%xmm0
movups 0x10(%rcx,%rax,8),%xmm1
add    %r9,%rdx
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
mov    0x20(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%rcx,%rdx,8)
movupd %xmm1,0x10(%rcx,%rdx,8)
mov    0xf8(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
jne    3050 <Inverse_SO3_Naive_sym+0x1e80>
jmp    30fd <Inverse_SO3_Naive_sym+0x1f2d>
xor    %edx,%edx
movapd 0x1fe7(%rip),%xmm3
testb  $0x1,0x98(%rsp)
01
jne    2fb9 <Inverse_SO3_Naive_sym+0x1de9>
jmp    2ffa <Inverse_SO3_Naive_sym+0x1e2a>
xor    %ecx,%ecx
mov    0x38(%rsp),%r14
mov    0x30(%rsp),%r10
movapd 0x1fc7(%rip),%xmm2
jmp    3050 <Inverse_SO3_Naive_sym+0x1e80>
xor    %ecx,%ecx
mov    0x30(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rcx,%rdx
test   $0x1,%r10b
je     308e <Inverse_SO3_Naive_sym+0x1ebe>
lea    (%rcx,%r8,1),%rax
mov    0x28(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
lea    (%rcx,%r9,1),%rdx
movsd  %xmm0,(%rsi,%rdx,8)
mov    0x20(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
xorpd  0x1f7e(%rip),%xmm0
movlpd %xmm0,(%rsi,%rdx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
cmp    0x90(%rsp),%rcx
je     30fd <Inverse_SO3_Naive_sym+0x1f2d>
mov    0xb0(%rsp),%rsi
lea    (%rsi,%r9,8),%rcx
mov    0xa8(%rsp),%rdi
lea    (%rdi,%r9,8),%rax
lea    (%rsi,%r8,8),%rsi
lea    (%rdi,%r8,8),%rdi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  -0x8(%rdi,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,-0x8(%rax,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  (%rdi,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    30c0 <Inverse_SO3_Naive_sym+0x1ef0>
mov    %r12d,%edi
mov    0x88(%rsp),%r15
mov    %r15d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %ebx,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x48(%rsp)
cltq
lea    (%r14,%rax,8),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rax,8),%rbp
mov    0x68(%rsp),%rbx
mov    %rbx,(%rsp)
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
mov    0x70(%rsp),%r14
mov    %r14,%r8
xor    %eax,%eax
call   1090 <wigNaiveSynthesis_symX@plt>
mov    %rbx,(%rsp)
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
mov    %rbp,%rcx
mov    %r14,%r8
mov    0x48(%rsp),%r9
xor    %eax,%eax
call   1090 <wigNaiveSynthesis_symX@plt>
cmpl   $0x0,0x178(%rsp)
je     31f0 <Inverse_SO3_Naive_sym+0x2020>
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    0x60(%rsp),%edi
mov    0x58(%rsp),%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
movslq %ebx,%r8
movslq %eax,%r9
mov    0x30(%rsp),%r10
cmp    $0x4,%r10d
mov    %r13,%r12
jae    32a0 <Inverse_SO3_Naive_sym+0x20d0>
xor    %ecx,%ecx
mov    0x40(%rsp),%r15
mov    0x38(%rsp),%r14
movapd 0x1e16(%rip),%xmm2
jmp    34b0 <Inverse_SO3_Naive_sym+0x22e0>
nop
mov    0x60(%rsp),%r12d
mov    %r12d,%edi
mov    0x58(%rsp),%ebp
mov    %ebp,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%r15d
mov    %r12d,%edi
mov    %ebp,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %r15d,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x48(%rsp)
cltq
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x40(%rsp),%r15
lea    (%r15,%rax,8),%rax
mov    %rax,0x100(%rsp)
mov    %rbx,(%rsp)
mov    %r12d,%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    %r14,%r8
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
mov    %rbx,(%rsp)
mov    %r12d,%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    0x100(%rsp),%rcx
mov    %r14,%r8
mov    0x48(%rsp),%r9
xor    %eax,%eax
call   1030 <wigNaiveSynthesis@plt>
mov    %r13,%r12
mov    0x38(%rsp),%r14
jmp    355d <Inverse_SO3_Naive_sym+0x238d>
cs nopw 0x0(%rax,%rax,1)
mov    0x28(%rsp),%rcx
lea    (%rcx,%r9,8),%rax
mov    0x80(%rsp),%rsi
lea    (%rsi,%r9,8),%r11
mov    0x20(%rsp),%rdx
lea    (%rdx,%r9,8),%r10
lea    (%rcx,%r8,8),%r14
lea    (%rsi,%r8,8),%rbp
mov    0x78(%rsp),%rdi
lea    (%rdi,%r8,8),%rsi
cmp    %rbp,%rax
setb   %cl
cmp    %r11,%r14
setb   %bl
and    %cl,%bl
or     0xa0(%rsp),%bl
cmp    %rsi,%rax
lea    (%rdx,%r8,8),%rax
setb   %cl
cmp    %r11,%rax
setb   %r11b
cmp    %rbp,%r10
lea    (%rdi,%r9,8),%rbp
setb   %dl
cmp    %rbp,%r14
setb   %dil
cmp    %rsi,%r10
setb   %r10b
cmp    %rbp,%rax
setb   %sil
test   %bl,%bl
jne    3485 <Inverse_SO3_Naive_sym+0x22b5>
and    %r11b,%cl
jne    3485 <Inverse_SO3_Naive_sym+0x22b5>
and    %dil,%dl
mov    0x40(%rsp),%r15
mov    0x38(%rsp),%r14
movapd 0x1cc6(%rip),%xmm2
jne    34a0 <Inverse_SO3_Naive_sym+0x22d0>
mov    $0x0,%ecx
and    %sil,%r10b
mov    0x30(%rsp),%r10
jne    34b0 <Inverse_SO3_Naive_sym+0x22e0>
cmpq   $0x0,0xb8(%rsp)
je     346f <Inverse_SO3_Naive_sym+0x229f>
mov    0xd0(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    0xc8(%rsp),%rcx
lea    (%rcx,%r8,8),%rdi
lea    (%rax,%r9,8),%rbp
lea    (%rcx,%r9,8),%rbx
mov    0x108(%rsp),%rcx
xor    %edx,%edx
movapd 0x1c6c(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%rdi,%rdx,8),%xmm0
movups -0x20(%rdi,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,8)
movups %xmm1,-0x20(%rbx,%rdx,8)
movupd -0x30(%rsi,%rdx,8),%xmm0
movupd -0x20(%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x30(%rbp,%rdx,8)
movupd %xmm1,-0x20(%rbp,%rdx,8)
movups -0x10(%rdi,%rdx,8),%xmm0
movups (%rdi,%rdx,8),%xmm1
movups %xmm0,-0x10(%rbx,%rdx,8)
movups %xmm1,(%rbx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x10(%rbp,%rdx,8)
movupd %xmm1,0x0(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    33a0 <Inverse_SO3_Naive_sym+0x21d0>
testb  $0x1,0x98(%rsp)
01
je     345a <Inverse_SO3_Naive_sym+0x228a>
lea    (%rdx,%r8,1),%rax
mov    0x28(%rsp),%rcx
movups (%rcx,%rax,8),%xmm0
movups 0x10(%rcx,%rax,8),%xmm1
add    %r9,%rdx
movups %xmm0,(%rcx,%rdx,8)
movups %xmm1,0x10(%rcx,%rdx,8)
mov    0x20(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%rcx,%rdx,8)
movupd %xmm1,0x10(%rcx,%rdx,8)
mov    0xf8(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
jne    34b0 <Inverse_SO3_Naive_sym+0x22e0>
jmp    355d <Inverse_SO3_Naive_sym+0x238d>
xor    %edx,%edx
movapd 0x1b87(%rip),%xmm3
testb  $0x1,0x98(%rsp)
01
jne    3419 <Inverse_SO3_Naive_sym+0x2249>
jmp    345a <Inverse_SO3_Naive_sym+0x228a>
xor    %ecx,%ecx
mov    0x40(%rsp),%r15
mov    0x38(%rsp),%r14
mov    0x30(%rsp),%r10
movapd 0x1b62(%rip),%xmm2
jmp    34b0 <Inverse_SO3_Naive_sym+0x22e0>
xor    %ecx,%ecx
mov    0x30(%rsp),%r10
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rdx
test   $0x1,%r10b
je     34ee <Inverse_SO3_Naive_sym+0x231e>
lea    (%rcx,%r8,1),%rax
mov    0x28(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
lea    (%rcx,%r9,1),%rdx
movsd  %xmm0,(%rsi,%rdx,8)
mov    0x20(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
xorpd  0x1b1e(%rip),%xmm0
movlpd %xmm0,(%rsi,%rdx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
cmp    0x90(%rsp),%rcx
je     355d <Inverse_SO3_Naive_sym+0x238d>
mov    0xb0(%rsp),%rsi
lea    (%rsi,%r9,8),%rcx
mov    0xa8(%rsp),%rdi
lea    (%rdi,%r9,8),%rax
lea    (%rsi,%r8,8),%rsi
lea    (%rdi,%r8,8),%rdi
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  -0x8(%rdi,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,-0x8(%rax,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  (%rdi,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    3520 <Inverse_SO3_Naive_sym+0x2350>
mov    0x50(%rsp),%ebp
mov    %ebp,%edi
mov    0x58(%rsp),%r13d
mov    %r13d,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%ebx
mov    %ebp,%edi
mov    %r13d,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1050 <coefLoc_so3@plt>
movslq %ebx,%rcx
mov    %r12,%rbx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x48(%rsp)
cltq
lea    (%r14,%rax,8),%rcx
lea    (%r15,%rax,8),%rbp
mov    0x68(%rsp),%r12
mov    %r12,(%rsp)
mov    0x88(%rsp),%r14
mov    %r14d,%edi
mov    0x60(%rsp),%r13d
mov    %r13d,%esi
mov    %ebx,%edx
mov    0x70(%rsp),%r15
mov    %r15,%r8
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
mov    %r12,(%rsp)
mov    %r14d,%edi
mov    %r13d,%esi
mov    %ebx,%edx
mov    %rbp,%rcx
mov    %r15,%r8
mov    0x48(%rsp),%r9
xor    %eax,%eax
call   10e0 <wigNaiveSynthesis_symY@plt>
cmpl   $0x0,0x178(%rsp)
je     2750 <Inverse_SO3_Naive_sym+0x1580>
mov    0x50(%rsp),%ebp
mov    %ebp,%edi
mov    0x58(%rsp),%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
mov    %eax,%r15d
mov    %r13d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1070 <sampLoc_so3@plt>
movslq %r15d,%r8
movslq %eax,%r9
mov    0x30(%rsp),%r10
cmp    $0x4,%r10d
mov    %ebp,%r13d
jae    3660 <Inverse_SO3_Naive_sym+0x2490>
xor    %ecx,%ecx
mov    0x28(%rsp),%r12
movapd 0x19b2(%rip),%xmm2
movapd 0x19aa(%rip),%xmm3
jmp    3870 <Inverse_SO3_Naive_sym+0x26a0>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rsi
lea    (%rsi,%r9,8),%rax
mov    0x80(%rsp),%rcx
lea    (%rcx,%r9,8),%r11
mov    0x20(%rsp),%rdx
lea    (%rdx,%r9,8),%r10
mov    %rsi,%r15
lea    (%rsi,%r8,8),%r14
lea    (%rcx,%r8,8),%rbp
mov    0x78(%rsp),%rdi
lea    (%rdi,%r8,8),%rsi
cmp    %rbp,%rax
setb   %cl
cmp    %r11,%r14
setb   %bl
and    %cl,%bl
or     0xa0(%rsp),%bl
cmp    %rsi,%rax
lea    (%rdx,%r8,8),%rax
setb   %cl
cmp    %r11,%rax
setb   %r11b
cmp    %rbp,%r10
lea    (%rdi,%r9,8),%rbp
setb   %dl
cmp    %rbp,%r14
setb   %dil
cmp    %rsi,%r10
setb   %r10b
cmp    %rbp,%rax
setb   %sil
test   %bl,%bl
jne    383a <Inverse_SO3_Naive_sym+0x266a>
and    %r11b,%cl
jne    383a <Inverse_SO3_Naive_sym+0x266a>
and    %dil,%dl
movapd 0x190d(%rip),%xmm2
movapd 0x1905(%rip),%xmm3
mov    0x88(%rsp),%r14
mov    %r15,%r12
jne    385e <Inverse_SO3_Naive_sym+0x268e>
mov    $0x0,%ecx
and    %sil,%r10b
mov    0x30(%rsp),%r10
jne    3870 <Inverse_SO3_Naive_sym+0x26a0>
cmpq   $0x0,0xb8(%rsp)
je     37d1 <Inverse_SO3_Naive_sym+0x2601>
mov    0xd0(%rsp),%rax
lea    (%rax,%r8,8),%rsi
mov    0xc8(%rsp),%rcx
lea    (%rcx,%r8,8),%rdi
lea    (%rax,%r9,8),%rbp
lea    (%rcx,%r9,8),%rbx
mov    0x108(%rsp),%rcx
xor    %edx,%edx
mov    0x20(%rsp),%r11
nopl   (%rax)
movups -0x30(%rdi,%rdx,8),%xmm0
movups -0x20(%rdi,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,8)
movups %xmm1,-0x20(%rbx,%rdx,8)
movupd -0x30(%rsi,%rdx,8),%xmm0
movupd -0x20(%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x30(%rbp,%rdx,8)
movupd %xmm1,-0x20(%rbp,%rdx,8)
movups -0x10(%rdi,%rdx,8),%xmm0
movups (%rdi,%rdx,8),%xmm1
movups %xmm0,-0x10(%rbx,%rdx,8)
movups %xmm1,(%rbx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,-0x10(%rbp,%rdx,8)
movupd %xmm1,0x0(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    3760 <Inverse_SO3_Naive_sym+0x2590>
jmp    37d8 <Inverse_SO3_Naive_sym+0x2608>
xor    %edx,%edx
mov    0x20(%rsp),%r11
testb  $0x1,0x98(%rsp)
01
mov    %r15,%r12
je     3824 <Inverse_SO3_Naive_sym+0x2654>
lea    (%rdx,%r8,1),%rax
movups (%r12,%rax,8),%xmm0
movups 0x10(%r12,%rax,8),%xmm1
add    %r9,%rdx
movups %xmm0,(%r12,%rdx,8)
movups %xmm1,0x10(%r12,%rdx,8)
movupd (%r11,%rax,8),%xmm0
movupd 0x10(%r11,%rax,8),%xmm1
xorpd  %xmm3,%xmm0
xorpd  %xmm3,%xmm1
movupd %xmm0,(%r11,%rdx,8)
movupd %xmm1,0x10(%r11,%rdx,8)
mov    0xf8(%rsp),%rax
mov    %rax,%rcx
cmp    %r10,%rax
je     27e5 <Inverse_SO3_Naive_sym+0x1615>
jmp    3870 <Inverse_SO3_Naive_sym+0x26a0>
xor    %ecx,%ecx
mov    0x30(%rsp),%r10
movapd 0x17b7(%rip),%xmm2
movapd 0x17af(%rip),%xmm3
mov    0x88(%rsp),%r14
mov    %r15,%r12
jmp    3870 <Inverse_SO3_Naive_sym+0x26a0>
xor    %ecx,%ecx
mov    0x30(%rsp),%r10
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rcx,%rdx
test   $0x1,%r10b
je     38a7 <Inverse_SO3_Naive_sym+0x26d7>
lea    (%rcx,%r8,1),%rax
movsd  (%r12,%rax,8),%xmm0
lea    (%rcx,%r9,1),%rdx
movsd  %xmm0,(%r12,%rdx,8)
mov    0x20(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%rsi,%rdx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
cmp    0x90(%rsp),%rcx
je     27e5 <Inverse_SO3_Naive_sym+0x1615>
mov    0xb0(%rsp),%rsi
lea    (%rsi,%r9,8),%rcx
mov    0xa8(%rsp),%rbp
lea    0x0(,%r9,8),%rax
add    %rbp,%rax
lea    (%rsi,%r8,8),%rsi
lea    0x0(%rbp,%r8,8),%rbp
movsd  -0x8(%rsi,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  -0x8(%rbp,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,-0x8(%rax,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    38e0 <Inverse_SO3_Naive_sym+0x2710>
jmp    27e5 <Inverse_SO3_Naive_sym+0x1615>
movslq 0x118(%rsp),%rcx
test   %r13d,%r13d
jle    397e <Inverse_SO3_Naive_sym+0x27ae>
mov    %rcx,0x100(%rsp)
mov    0x120(%rsp),%rax
lea    0x0(,%rax,8),%rbp
mov    %r13d,%eax
imul   %r13d,%eax
shl    $0x2,%eax
movslq %eax,%rdx
lea    -0x1(%r13),%eax
mov    %r13d,%esi
and    $0x7,%esi
cmp    $0x7,%eax
jae    399b <Inverse_SO3_Naive_sym+0x27cb>
mov    0x128(%rsp),%rax
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,8),%r14
lea    (%r12,%rax,8),%r15
jmp    3c9a <Inverse_SO3_Naive_sym+0x2aca>
mov    0x120(%rsp),%rbx
lea    0x0(,%rbx,8),%rbp
mov    0xf0(%rsp),%r13d
jmp    3d12 <Inverse_SO3_Naive_sym+0x2b42>
mov    %esi,0xf8(%rsp)
mov    %r13d,%ecx
and    $0xfffffff8,%ecx
mov    0x128(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0xa0(%rsp)
mov    %r12,%rdi
mov    %rdx,%rax
shl    $0x6,%rax
mov    %rax,0x98(%rsp)
imul   $0x38,%rdx,%r9
mov    0x20(%rsp),%r13
lea    (%r9,%r13,1),%rax
mov    %rax,0x70(%rsp)
mov    %rdx,%r14
shl    $0x4,%r14
lea    (%r14,%r14,2),%r10
lea    (%r10,%r13,1),%rax
mov    %rax,0x58(%rsp)
lea    0x0(,%rdx,8),%r8
lea    (%r8,%r8,4),%rbx
lea    (%rbx,%r13,1),%rax
mov    %rax,0x30(%rsp)
mov    %rdx,%rax
shl    $0x5,%rax
lea    (%rax,%r13,1),%rsi
mov    %rsi,0x88(%rsp)
lea    (%r8,%r8,2),%r8
lea    (%r8,%r13,1),%rsi
mov    %rsi,0x90(%rsp)
lea    (%r14,%r13,1),%rsi
mov    %rsi,0x48(%rsp)
add    %r12,%r9
mov    %r9,0x40(%rsp)
add    %r12,%r10
mov    %r10,0x50(%rsp)
add    %r12,%rbx
add    %r12,%rax
mov    %rax,0x60(%rsp)
add    %r12,%r8
mov    %r8,0x80(%rsp)
add    %r12,%r14
lea    0x0(,%rdx,8),%rax
add    %r13,%rax
mov    %rax,0x78(%rsp)
mov    %rdx,0xb8(%rsp)
lea    (%r12,%rdx,8),%r12
mov    %r13,0x38(%rsp)
mov    0xa0(%rsp),%r15
nopl   0x0(%rax,%rax,1)
mov    %rdi,0xb0(%rsp)
mov    %rbx,0xd8(%rsp)
mov    %r14,0xe0(%rsp)
mov    %ecx,0xe8(%rsp)
add    %r15,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x38(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    %r12,0xa8(%rsp)
lea    (%r12,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x78(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
lea    (%r14,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x48(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x80(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x90(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x60(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x88(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
lea    (%rbx,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x30(%rsp),%r13
lea    (%r15,%r13,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x50(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    %rbp,%rbx
mov    0x58(%rsp),%rbp
lea    (%r15,%rbp,1),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1080 <memset@plt>
mov    0x40(%rsp),%r14
lea    (%r14,%r15,1),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1080 <memset@plt>
mov    0x70(%rsp),%r12
lea    (%r12,%r15,1),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1080 <memset@plt>
mov    0xb0(%rsp),%rdi
mov    0xe8(%rsp),%ecx
mov    0x98(%rsp),%rax
add    %rax,0x38(%rsp)
add    %rax,%r12
mov    %r12,0x70(%rsp)
add    %rax,%rbp
mov    %rbp,0x58(%rsp)
mov    %rbx,%rbp
mov    0xd8(%rsp),%rbx
add    %rax,%r13
mov    %r13,0x30(%rsp)
add    %rax,0x88(%rsp)
add    %rax,0x90(%rsp)
add    %rax,0x48(%rsp)
add    %rax,0x78(%rsp)
add    %rax,%rdi
add    %rax,%r14
mov    %r14,0x40(%rsp)
mov    0xe0(%rsp),%r14
add    %rax,0x50(%rsp)
add    %rax,%rbx
add    %rax,0x60(%rsp)
add    %rax,0x80(%rsp)
add    %rax,%r14
mov    0xa8(%rsp),%r12
add    %rax,%r12
add    $0xfffffff8,%ecx
jne    3a90 <Inverse_SO3_Naive_sym+0x28c0>
mov    0x128(%rsp),%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%r14
lea    (%rdi,%rax,8),%r15
mov    0xb8(%rsp),%rdx
mov    0xf8(%rsp),%esi
test   %esi,%esi
mov    0xf0(%rsp),%r13d
mov    0x120(%rsp),%rbx
je     3d0a <Inverse_SO3_Naive_sym+0x2b3a>
shl    $0x3,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r15,%rbx,1),%rdi
mov    %esi,%r13d
xor    %esi,%esi
mov    %rdx,%r12
mov    %rbp,%rdx
call   1080 <memset@plt>
lea    (%r14,%rbx,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    %r13d,%esi
mov    %r12,%rdx
add    %r12,%rbx
add    $0xffffffff,%esi
jne    3cc0 <Inverse_SO3_Naive_sym+0x2af0>
mov    0x100(%rsp),%rcx
mov    0xf0(%rsp),%r13d
mov    0x120(%rsp),%rbx
jmp    3d12 <Inverse_SO3_Naive_sym+0x2b42>
mov    0x100(%rsp),%rcx
mov    0x130(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0xb0(%rsp)
mov    %r13d,%eax
imul   0xf4(%rsp),%eax
movslq %eax,%r15
mov    0x28(%rsp),%rax
lea    (%rax,%r15,8),%r14
mov    0x20(%rsp),%rax
lea    (%rax,%r15,8),%r12
imul   %rbp,%rbx
mov    %r14,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1080 <memset@plt>
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1080 <memset@plt>
cmpl   $0x2,0xc0(%rsp)
02
jl     4035 <Inverse_SO3_Naive_sym+0x2e65>
add    0x114(%rsp),%r13d
movslq %r13d,%rax
lea    (%r12,%rax,8),%r12
lea    (%r14,%rax,8),%r13
mov    0xc0(%rsp),%rdx
mov    %edx,%ecx
imul   %edx,%ecx
shl    $0x2,%ecx
movslq %ecx,%r9
lea    -0x1(%rdx),%ebx
lea    -0x2(%rdx),%ecx
mov    %ebx,%r14d
and    $0x7,%r14d
cmp    $0x7,%ecx
mov    %r9,0xa8(%rsp)
jb     3ffc <Inverse_SO3_Naive_sym+0x2e2c>
and    $0xfffffff8,%ebx
mov    %r9,%rcx
shl    $0x6,%rcx
mov    %rcx,0x38(%rsp)
lea    0x0(,%r9,8),%rcx
sub    %r9,%rcx
add    %r15,%rcx
add    %rax,%rcx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rcx,8),%rdx
mov    %rdx,0x40(%rsp)
lea    (%r9,%r9,2),%r8
lea    (%r15,%r8,2),%rdx
add    %rax,%rdx
mov    %rdx,0x48(%rsp)
lea    (%rsi,%rdx,8),%rdx
mov    %rdx,0x70(%rsp)
lea    (%r9,%r9,4),%r11
add    %r15,%r11
add    %rax,%r11
lea    (%rsi,%r11,8),%rdx
mov    %rdx,0x58(%rsp)
lea    (%r15,%r9,4),%rdi
add    %rax,%rdi
lea    (%rsi,%rdi,8),%rdx
mov    %rdx,0x30(%rsp)
add    %r15,%r8
add    %rax,%r8
lea    (%rsi,%r8,8),%rdx
mov    %rdx,0x50(%rsp)
lea    (%r15,%r9,2),%r10
add    %rax,%r10
lea    (%rsi,%r10,8),%rdx
mov    %rdx,0x88(%rsp)
add    %rax,%r15
add    %r9,%r15
lea    (%rsi,%r15,8),%rax
mov    %rax,0x60(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%rcx
mov    %rcx,0x90(%rsp)
mov    0x48(%rsp),%rcx
lea    (%rax,%rcx,8),%rcx
mov    %rcx,0x48(%rsp)
lea    (%rax,%r11,8),%rcx
mov    %rcx,0x80(%rsp)
lea    (%rax,%rdi,8),%rcx
mov    %rcx,0x78(%rsp)
lea    (%rax,%r8,8),%rcx
mov    %rcx,0xe8(%rsp)
lea    (%rax,%r10,8),%rcx
mov    %rcx,0xe0(%rsp)
lea    (%rax,%r15,8),%rax
mov    %rax,0xd8(%rsp)
xor    %r15d,%r15d
nopl   0x0(%rax)
lea    (%r15,%r13,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
lea    (%r12,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0xd8(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x60(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0xe0(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x88(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0xe8(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x50(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x78(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x30(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x80(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x58(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x48(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x70(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x90(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
mov    0x40(%rsp),%rax
lea    (%rax,%r15,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
add    0x38(%rsp),%r15
add    $0xfffffff8,%ebx
jne    3eb0 <Inverse_SO3_Naive_sym+0x2ce0>
add    %r15,%r12
add    %r15,%r13
test   %r14d,%r14d
mov    0xa8(%rsp),%r15
je     4035 <Inverse_SO3_Naive_sym+0x2e65>
shl    $0x3,%r15
xor    %ebx,%ebx
nop
lea    (%rbx,%r13,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
lea    (%r12,%rbx,1),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1080 <memset@plt>
add    %r15,%rbx
add    $0xffffffff,%r14d
jne    4010 <Inverse_SO3_Naive_sym+0x2e40>
mov    0x28(%rsp),%rbp
mov    %rbp,%rdi
mov    0x130(%rsp),%r15
mov    %r15,%rsi
mov    0xf4(%rsp),%r14d
mov    %r14d,%edx
mov    0x114(%rsp),%r12d
mov    %r12d,%ecx
xor    %eax,%eax
call   10f0 <transpose_so3@plt>
mov    0x20(%rsp),%rbx
mov    %rbx,%rdi
mov    0xb0(%rsp),%r13
mov    %r13,%rsi
mov    %r14d,%edx
mov    %r12d,%ecx
xor    %eax,%eax
call   10f0 <transpose_so3@plt>
mov    0x68(%rsp),%rax
mov    %rax,(%rsp)
mov    %r15,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
mov    %r12d,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
call   10a0 <grid_fourier_so3@plt>
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r14d,%edx
mov    %r12d,%ecx
xor    %eax,%eax
call   10f0 <transpose_so3@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r14d,%edx
mov    %r12d,%ecx
xor    %eax,%eax
call   10f0 <transpose_so3@plt>
mov    0x68(%rsp),%rax
mov    %rax,(%rsp)
mov    %r15,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
mov    %rbx,%rcx
mov    %r12d,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
call   10a0 <grid_fourier_so3@plt>
mov    0x118(%rsp),%eax
test   %eax,%eax
jle    427e <Inverse_SO3_Naive_sym+0x30ae>
cvtsi2sd %r14d,%xmm1
cvtsi2sdl 0xc0(%rsp),%xmm0
divsd  0xefc(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    %eax,%eax
lea    (%rbx,%rax,8),%rcx
cmp    %rbp,%rcx
jbe    418c <Inverse_SO3_Naive_sym+0x2fbc>
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
cmp    %rbx,%rcx
jbe    418c <Inverse_SO3_Naive_sym+0x2fbc>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbp,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    4140 <Inverse_SO3_Naive_sym+0x2f70>
jmp    427e <Inverse_SO3_Naive_sym+0x30ae>
unpcklpd %xmm0,%xmm0
add    $0xfffffffffffffffc,%rax
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
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 (%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 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)
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)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rdx
jne    41b0 <Inverse_SO3_Naive_sym+0x2fe0>
test   $0x1,%al
je     427e <Inverse_SO3_Naive_sym+0x30ae>
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 (%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)
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @Inverse_SO3_Naive_sym(i32 %0, double* %1, double* %2, double* %3, double* %4, double* %5, double* %6, i32 %7) {
%9 = alloca i32
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca 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 double*
%35 = alloca double*
%36 = alloca double
store i32 %0, i32* %9
store double* %1, double** %10
store double* %2, double** %11
store double* %3, double** %12
store double* %4, double** %13
store double* %5, double** %14
store double* %6, double** %15
store i32 %7, i32* %16
%37 = load i32, i32* %9
%38 = mul nsw i32 2, %37
store i32 %38, i32* %18
%39 = load double*, double** %14
store double* %39, double** %24
%40 = load double*, double** %14
%41 = load i32, i32* %18
%42 = load i32, i32* %18
%43 = mul nsw i32 %41, %42
%44 = load i32, i32* %18
%45 = mul nsw i32 %43, %44
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds double, double* %40, i64 %46
store double* %47, double** %25
%48 = load double*, double** %15
store double* %48, double** %26
%49 = load double*, double** %26
%50 = load i32, i32* %18
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %49, i64 %51
store double* %52, double** %27
%53 = load double*, double** %27
%54 = load i32, i32* %18
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %53, i64 %55
store double* %56, double** %28
%57 = load double*, double** %28
%58 = load i32, i32* %18
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
store double* %60, double** %29
%61 = load double*, double** %29
%62 = load i32, i32* %18
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds double, double* %61, i64 %63
store double* %64, double** %30
%65 = load double*, double** %30
%66 = load i32, i32* %9
%67 = load i32, i32* %18
%68 = mul nsw i32 %66, %67
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %65, i64 %69
store double* %70, double** %31
%71 = load i32, i32* %18
%72 = load double*, double** %26
%73 = call i32 (i32, double*, ...) bitcast (i32 (...)* @SinEvalPts to i32 (i32, double*, ...)*)(i32 %71, double* %72)
%74 = load i32, i32* %18
%75 = load double*, double** %27
%76 = call i32 (i32, double*, ...) bitcast (i32 (...)* @CosEvalPts to i32 (i32, double*, ...)*)(i32 %74, double* %75)
%77 = load i32, i32* %18
%78 = load double*, double** %28
%79 = call i32 (i32, double*, ...) bitcast (i32 (...)* @SinEvalPts2 to i32 (i32, double*, ...)*)(i32 %77, double* %78)
%80 = load i32, i32* %18
%81 = load double*, double** %29
%82 = call i32 (i32, double*, ...) bitcast (i32 (...)* @CosEvalPts2 to i32 (i32, double*, ...)*)(i32 %80, double* %81)
%83 = load i32, i32* %9
%84 = load double*, double** %26
%85 = load double*, double** %27
%86 = load double*, double** %28
%87 = load double*, double** %29
%88 = load double*, double** %30
%89 = load double*, double** %31
%90 = call i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @genWigTrans_L2 to i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...)*)(i32 0, i32 0, i32 %83, double* %84, double* %85, double* %86, double* %87, double* %88, double* %89)
%91 = load i32, i32* %9
%92 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 0, i32 %91)
store i32 %92, i32* %21
%93 = load i32, i32* %9
%94 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 0, i32 %93)
store i32 %94, i32* %23
%95 = load double*, double** %10
store double* %95, double** %34
%96 = load double*, double** %11
store double* %96, double** %35
%97 = load double*, double** %12
store double* %97, double** %32
%98 = load double*, double** %13
store double* %98, double** %33
%99 = load i32, i32* %21
%100 = load double*, double** %32
%101 = sext i32 %99 to i64
%102 = getelementptr inbounds double, double* %100, i64 %101
store double* %102, double** %32
%103 = load i32, i32* %21
%104 = load double*, double** %33
%105 = sext i32 %103 to i64
%106 = getelementptr inbounds double, double* %104, i64 %105
store double* %106, double** %33
%107 = load i32, i32* %23
%108 = load double*, double** %34
%109 = sext i32 %107 to i64
%110 = getelementptr inbounds double, double* %108, i64 %109
store double* %110, double** %34
%111 = load i32, i32* %23
%112 = load double*, double** %35
%113 = sext i32 %111 to i64
%114 = getelementptr inbounds double, double* %112, i64 %113
store double* %114, double** %35
%115 = load i32, i32* %9
%116 = load double*, double** %34
%117 = load double*, double** %30
%118 = load double*, double** %32
%119 = load double*, double** %31
%120 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 0, i32 %115, double* %116, double* %117, double* %118, double* %119)
%121 = load i32, i32* %9
%122 = load double*, double** %35
%123 = load double*, double** %30
%124 = load double*, double** %33
%125 = load double*, double** %31
%126 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 0, i32 %121, double* %122, double* %123, double* %124, double* %125)
store i32 1, i32* %19
br label %127
127: ; preds = %438, %8
%128 = load i32, i32* %19
%129 = load i32, i32* %9
%130 = icmp slt i32 %128, %129
br i1 %130, label %131, label %441
131: ; preds = %127
%132 = load i32, i32* %19
%133 = load i32, i32* %19
%134 = load i32, i32* %9
%135 = load double*, double** %26
%136 = load double*, double** %27
%137 = load double*, double** %28
%138 = load double*, double** %29
%139 = load double*, double** %30
%140 = load double*, double** %31
%141 = call i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @genWigTrans_L2 to i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...)*)(i32 %132, i32 %133, i32 %134, double* %135, double* %136, double* %137, double* %138, double* %139, double* %140)
%142 = load i32, i32* %19
%143 = load i32, i32* %19
%144 = load i32, i32* %9
%145 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %142, i32 %143, i32 %144)
store i32 %145, i32* %21
%146 = load i32, i32* %19
%147 = load i32, i32* %19
%148 = load i32, i32* %9
%149 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %146, i32 %147, i32 %148)
store i32 %149, i32* %23
%150 = load double*, double** %10
store double* %150, double** %34
%151 = load double*, double** %11
store double* %151, double** %35
%152 = load double*, double** %12
store double* %152, double** %32
%153 = load double*, double** %13
store double* %153, double** %33
%154 = load i32, i32* %21
%155 = load double*, double** %32
%156 = sext i32 %154 to i64
%157 = getelementptr inbounds double, double* %155, i64 %156
store double* %157, double** %32
%158 = load i32, i32* %21
%159 = load double*, double** %33
%160 = sext i32 %158 to i64
%161 = getelementptr inbounds double, double* %159, i64 %160
store double* %161, double** %33
%162 = load i32, i32* %23
%163 = load double*, double** %34
%164 = sext i32 %162 to i64
%165 = getelementptr inbounds double, double* %163, i64 %164
store double* %165, double** %34
%166 = load i32, i32* %23
%167 = load double*, double** %35
%168 = sext i32 %166 to i64
%169 = getelementptr inbounds double, double* %167, i64 %168
store double* %169, double** %35
%170 = load i32, i32* %19
%171 = load i32, i32* %19
%172 = load i32, i32* %9
%173 = load double*, double** %34
%174 = load double*, double** %30
%175 = load double*, double** %32
%176 = load double*, double** %31
%177 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %170, i32 %171, i32 %172, double* %173, double* %174, double* %175, double* %176)
%178 = load i32, i32* %19
%179 = load i32, i32* %19
%180 = load i32, i32* %9
%181 = load double*, double** %35
%182 = load double*, double** %30
%183 = load double*, double** %33
%184 = load double*, double** %31
%185 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %178, i32 %179, i32 %180, double* %181, double* %182, double* %183, double* %184)
%186 = load i32, i32* %16
%187 = icmp eq i32 %186, 0
br i1 %187, label %188, label %241
188: ; preds = %131
%189 = load i32, i32* %19
%190 = sub nsw i32 0, %189
%191 = load i32, i32* %19
%192 = sub nsw i32 0, %191
%193 = load i32, i32* %9
%194 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %190, i32 %192, i32 %193)
store i32 %194, i32* %21
%195 = load i32, i32* %19
%196 = sub nsw i32 0, %195
%197 = load i32, i32* %19
%198 = sub nsw i32 0, %197
%199 = load i32, i32* %9
%200 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %196, i32 %198, i32 %199)
store i32 %200, i32* %23
%201 = load double*, double** %10
store double* %201, double** %34
%202 = load double*, double** %11
store double* %202, double** %35
%203 = load double*, double** %12
store double* %203, double** %32
%204 = load double*, double** %13
store double* %204, double** %33
%205 = load i32, i32* %21
%206 = load double*, double** %32
%207 = sext i32 %205 to i64
%208 = getelementptr inbounds double, double* %206, i64 %207
store double* %208, double** %32
%209 = load i32, i32* %21
%210 = load double*, double** %33
%211 = sext i32 %209 to i64
%212 = getelementptr inbounds double, double* %210, i64 %211
store double* %212, double** %33
%213 = load i32, i32* %23
%214 = load double*, double** %34
%215 = sext i32 %213 to i64
%216 = getelementptr inbounds double, double* %214, i64 %215
store double* %216, double** %34
%217 = load i32, i32* %23
%218 = load double*, double** %35
%219 = sext i32 %217 to i64
%220 = getelementptr inbounds double, double* %218, i64 %219
store double* %220, double** %35
%221 = load i32, i32* %19
%222 = sub nsw i32 0, %221
%223 = load i32, i32* %19
%224 = sub nsw i32 0, %223
%225 = load i32, i32* %9
%226 = load double*, double** %34
%227 = load double*, double** %30
%228 = load double*, double** %32
%229 = load double*, double** %31
%230 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %222, i32 %224, i32 %225, double* %226, double* %227, double* %228, double* %229)
%231 = load i32, i32* %19
%232 = sub nsw i32 0, %231
%233 = load i32, i32* %19
%234 = sub nsw i32 0, %233
%235 = load i32, i32* %9
%236 = load double*, double** %35
%237 = load double*, double** %30
%238 = load double*, double** %33
%239 = load double*, double** %31
%240 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %232, i32 %234, i32 %235, double* %236, double* %237, double* %238, double* %239)
br label %289
241: ; preds = %131
%242 = load i32, i32* %19
%243 = load i32, i32* %19
%244 = load i32, i32* %9
%245 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %242, i32 %243, i32 %244)
store i32 %245, i32* %21
%246 = load i32, i32* %19
%247 = sub nsw i32 0, %246
%248 = load i32, i32* %19
%249 = sub nsw i32 0, %248
%250 = load i32, i32* %9
%251 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %247, i32 %249, i32 %250)
store i32 %251, i32* %22
store i32 0, i32* %17
br label %252
252: ; preds = %285, %241
%253 = load i32, i32* %17
%254 = load i32, i32* %9
%255 = mul nsw i32 2, %254
%256 = icmp slt i32 %253, %255
br i1 %256, label %257, label %288
257: ; preds = %252
%258 = load double*, double** %12
%259 = load i32, i32* %21
%260 = load i32, i32* %17
%261 = add nsw i32 %259, %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %258, i64 %262
%264 = load double, double* %263
%265 = load double*, double** %12
%266 = load i32, i32* %22
%267 = load i32, i32* %17
%268 = add nsw i32 %266, %267
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds double, double* %265, i64 %269
store double %264, double* %270
%271 = load double*, double** %13
%272 = load i32, i32* %21
%273 = load i32, i32* %17
%274 = add nsw i32 %272, %273
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %271, i64 %275
%277 = load double, double* %276
%278 = fneg double %277
%279 = load double*, double** %13
%280 = load i32, i32* %22
%281 = load i32, i32* %17
%282 = add nsw i32 %280, %281
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double, double* %279, i64 %283
store double %278, double* %284
br label %285
285: ; preds = %257
%286 = load i32, i32* %17
%287 = add nsw i32 %286, 1
store i32 %287, i32* %17
br label %252
288: ; preds = %252
br label %289
289: ; preds = %288, %188
%290 = load i32, i32* %19
%291 = sub nsw i32 0, %290
%292 = load i32, i32* %19
%293 = load i32, i32* %9
%294 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %291, i32 %292, i32 %293)
store i32 %294, i32* %21
%295 = load i32, i32* %19
%296 = sub nsw i32 0, %295
%297 = load i32, i32* %19
%298 = load i32, i32* %9
%299 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %296, i32 %297, i32 %298)
store i32 %299, i32* %23
%300 = load double*, double** %10
store double* %300, double** %34
%301 = load double*, double** %11
store double* %301, double** %35
%302 = load double*, double** %12
store double* %302, double** %32
%303 = load double*, double** %13
store double* %303, double** %33
%304 = load i32, i32* %21
%305 = load double*, double** %32
%306 = sext i32 %304 to i64
%307 = getelementptr inbounds double, double* %305, i64 %306
store double* %307, double** %32
%308 = load i32, i32* %21
%309 = load double*, double** %33
%310 = sext i32 %308 to i64
%311 = getelementptr inbounds double, double* %309, i64 %310
store double* %311, double** %33
%312 = load i32, i32* %23
%313 = load double*, double** %34
%314 = sext i32 %312 to i64
%315 = getelementptr inbounds double, double* %313, i64 %314
store double* %315, double** %34
%316 = load i32, i32* %23
%317 = load double*, double** %35
%318 = sext i32 %316 to i64
%319 = getelementptr inbounds double, double* %317, i64 %318
store double* %319, double** %35
%320 = load i32, i32* %19
%321 = sub nsw i32 0, %320
%322 = load i32, i32* %19
%323 = load i32, i32* %9
%324 = load double*, double** %34
%325 = load double*, double** %30
%326 = load double*, double** %32
%327 = load double*, double** %31
%328 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %321, i32 %322, i32 %323, double* %324, double* %325, double* %326, double* %327)
%329 = load i32, i32* %19
%330 = sub nsw i32 0, %329
%331 = load i32, i32* %19
%332 = load i32, i32* %9
%333 = load double*, double** %35
%334 = load double*, double** %30
%335 = load double*, double** %33
%336 = load double*, double** %31
%337 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %330, i32 %331, i32 %332, double* %333, double* %334, double* %335, double* %336)
%338 = load i32, i32* %16
%339 = icmp eq i32 %338, 0
br i1 %339, label %340, label %389
340: ; preds = %289
%341 = load i32, i32* %19
%342 = load i32, i32* %19
%343 = sub nsw i32 0, %342
%344 = load i32, i32* %9
%345 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %341, i32 %343, i32 %344)
store i32 %345, i32* %21
%346 = load i32, i32* %19
%347 = load i32, i32* %19
%348 = sub nsw i32 0, %347
%349 = load i32, i32* %9
%350 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %346, i32 %348, i32 %349)
store i32 %350, i32* %23
%351 = load double*, double** %10
store double* %351, double** %34
%352 = load double*, double** %11
store double* %352, double** %35
%353 = load double*, double** %12
store double* %353, double** %32
%354 = load double*, double** %13
store double* %354, double** %33
%355 = load i32, i32* %21
%356 = load double*, double** %32
%357 = sext i32 %355 to i64
%358 = getelementptr inbounds double, double* %356, i64 %357
store double* %358, double** %32
%359 = load i32, i32* %21
%360 = load double*, double** %33
%361 = sext i32 %359 to i64
%362 = getelementptr inbounds double, double* %360, i64 %361
store double* %362, double** %33
%363 = load i32, i32* %23
%364 = load double*, double** %34
%365 = sext i32 %363 to i64
%366 = getelementptr inbounds double, double* %364, i64 %365
store double* %366, double** %34
%367 = load i32, i32* %23
%368 = load double*, double** %35
%369 = sext i32 %367 to i64
%370 = getelementptr inbounds double, double* %368, i64 %369
store double* %370, double** %35
%371 = load i32, i32* %19
%372 = load i32, i32* %19
%373 = sub nsw i32 0, %372
%374 = load i32, i32* %9
%375 = load double*, double** %34
%376 = load double*, double** %30
%377 = load double*, double** %32
%378 = load double*, double** %31
%379 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %371, i32 %373, i32 %374, double* %375, double* %376, double* %377, double* %378)
%380 = load i32, i32* %19
%381 = load i32, i32* %19
%382 = sub nsw i32 0, %381
%383 = load i32, i32* %9
%384 = load double*, double** %35
%385 = load double*, double** %30
%386 = load double*, double** %33
%387 = load double*, double** %31
%388 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %380, i32 %382, i32 %383, double* %384, double* %385, double* %386, double* %387)
br label %437
389: ; preds = %289
%390 = load i32, i32* %19
%391 = sub nsw i32 0, %390
%392 = load i32, i32* %19
%393 = load i32, i32* %9
%394 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %391, i32 %392, i32 %393)
store i32 %394, i32* %21
%395 = load i32, i32* %19
%396 = load i32, i32* %19
%397 = sub nsw i32 0, %396
%398 = load i32, i32* %9
%399 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %395, i32 %397, i32 %398)
store i32 %399, i32* %22
store i32 0, i32* %17
br label %400
400: ; preds = %433, %389
%401 = load i32, i32* %17
%402 = load i32, i32* %9
%403 = mul nsw i32 2, %402
%404 = icmp slt i32 %401, %403
br i1 %404, label %405, label %436
405: ; preds = %400
%406 = load double*, double** %12
%407 = load i32, i32* %21
%408 = load i32, i32* %17
%409 = add nsw i32 %407, %408
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds double, double* %406, i64 %410
%412 = load double, double* %411
%413 = load double*, double** %12
%414 = load i32, i32* %22
%415 = load i32, i32* %17
%416 = add nsw i32 %414, %415
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds double, double* %413, i64 %417
store double %412, double* %418
%419 = load double*, double** %13
%420 = load i32, i32* %21
%421 = load i32, i32* %17
%422 = add nsw i32 %420, %421
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds double, double* %419, i64 %423
%425 = load double, double* %424
%426 = fneg double %425
%427 = load double*, double** %13
%428 = load i32, i32* %22
%429 = load i32, i32* %17
%430 = add nsw i32 %428, %429
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds double, double* %427, i64 %431
store double %426, double* %432
br label %433
433: ; preds = %405
%434 = load i32, i32* %17
%435 = add nsw i32 %434, 1
store i32 %435, i32* %17
br label %400
436: ; preds = %400
br label %437
437: ; preds = %436, %340
br label %438
438: ; preds = %437
%439 = load i32, i32* %19
%440 = add nsw i32 %439, 1
store i32 %440, i32* %19
br label %127
441: ; preds = %127
store i32 1, i32* %19
br label %442
442: ; preds = %722, %441
%443 = load i32, i32* %19
%444 = load i32, i32* %9
%445 = icmp slt i32 %443, %444
br i1 %445, label %446, label %725
446: ; preds = %442
%447 = load i32, i32* %19
%448 = load i32, i32* %9
%449 = load double*, double** %26
%450 = load double*, double** %27
%451 = load double*, double** %28
%452 = load double*, double** %29
%453 = load double*, double** %30
%454 = load double*, double** %31
%455 = call i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @genWigTrans_L2 to i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...)*)(i32 %447, i32 0, i32 %448, double* %449, double* %450, double* %451, double* %452, double* %453, double* %454)
%456 = load i32, i32* %19
%457 = load i32, i32* %9
%458 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %456, i32 0, i32 %457)
store i32 %458, i32* %21
%459 = load i32, i32* %19
%460 = load i32, i32* %9
%461 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %459, i32 0, i32 %460)
store i32 %461, i32* %23
%462 = load double*, double** %10
store double* %462, double** %34
%463 = load double*, double** %11
store double* %463, double** %35
%464 = load double*, double** %12
store double* %464, double** %32
%465 = load double*, double** %13
store double* %465, double** %33
%466 = load i32, i32* %21
%467 = load double*, double** %32
%468 = sext i32 %466 to i64
%469 = getelementptr inbounds double, double* %467, i64 %468
store double* %469, double** %32
%470 = load i32, i32* %21
%471 = load double*, double** %33
%472 = sext i32 %470 to i64
%473 = getelementptr inbounds double, double* %471, i64 %472
store double* %473, double** %33
%474 = load i32, i32* %23
%475 = load double*, double** %34
%476 = sext i32 %474 to i64
%477 = getelementptr inbounds double, double* %475, i64 %476
store double* %477, double** %34
%478 = load i32, i32* %23
%479 = load double*, double** %35
%480 = sext i32 %478 to i64
%481 = getelementptr inbounds double, double* %479, i64 %480
store double* %481, double** %35
%482 = load i32, i32* %19
%483 = load i32, i32* %9
%484 = load double*, double** %34
%485 = load double*, double** %30
%486 = load double*, double** %32
%487 = load double*, double** %31
%488 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %482, i32 0, i32 %483, double* %484, double* %485, double* %486, double* %487)
%489 = load i32, i32* %19
%490 = load i32, i32* %9
%491 = load double*, double** %35
%492 = load double*, double** %30
%493 = load double*, double** %33
%494 = load double*, double** %31
%495 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %489, i32 0, i32 %490, double* %491, double* %492, double* %493, double* %494)
%496 = load i32, i32* %16
%497 = icmp eq i32 %496, 0
br i1 %497, label %498, label %543
498: ; preds = %446
%499 = load i32, i32* %19
%500 = sub nsw i32 0, %499
%501 = load i32, i32* %9
%502 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %500, i32 0, i32 %501)
store i32 %502, i32* %21
%503 = load i32, i32* %19
%504 = sub nsw i32 0, %503
%505 = load i32, i32* %9
%506 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %504, i32 0, i32 %505)
store i32 %506, i32* %23
%507 = load double*, double** %10
store double* %507, double** %34
%508 = load double*, double** %11
store double* %508, double** %35
%509 = load double*, double** %12
store double* %509, double** %32
%510 = load double*, double** %13
store double* %510, double** %33
%511 = load i32, i32* %21
%512 = load double*, double** %32
%513 = sext i32 %511 to i64
%514 = getelementptr inbounds double, double* %512, i64 %513
store double* %514, double** %32
%515 = load i32, i32* %21
%516 = load double*, double** %33
%517 = sext i32 %515 to i64
%518 = getelementptr inbounds double, double* %516, i64 %517
store double* %518, double** %33
%519 = load i32, i32* %23
%520 = load double*, double** %34
%521 = sext i32 %519 to i64
%522 = getelementptr inbounds double, double* %520, i64 %521
store double* %522, double** %34
%523 = load i32, i32* %23
%524 = load double*, double** %35
%525 = sext i32 %523 to i64
%526 = getelementptr inbounds double, double* %524, i64 %525
store double* %526, double** %35
%527 = load i32, i32* %19
%528 = sub nsw i32 0, %527
%529 = load i32, i32* %9
%530 = load double*, double** %34
%531 = load double*, double** %30
%532 = load double*, double** %32
%533 = load double*, double** %31
%534 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %528, i32 0, i32 %529, double* %530, double* %531, double* %532, double* %533)
%535 = load i32, i32* %19
%536 = sub nsw i32 0, %535
%537 = load i32, i32* %9
%538 = load double*, double** %35
%539 = load double*, double** %30
%540 = load double*, double** %33
%541 = load double*, double** %31
%542 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %536, i32 0, i32 %537, double* %538, double* %539, double* %540, double* %541)
br label %588
543: ; preds = %446
%544 = load i32, i32* %19
%545 = load i32, i32* %9
%546 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %544, i32 0, i32 %545)
store i32 %546, i32* %21
%547 = load i32, i32* %19
%548 = sub nsw i32 0, %547
%549 = load i32, i32* %9
%550 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %548, i32 0, i32 %549)
store i32 %550, i32* %22
store i32 0, i32* %17
br label %551
551: ; preds = %584, %543
%552 = load i32, i32* %17
%553 = load i32, i32* %9
%554 = mul nsw i32 2, %553
%555 = icmp slt i32 %552, %554
br i1 %555, label %556, label %587
556: ; preds = %551
%557 = load double*, double** %12
%558 = load i32, i32* %21
%559 = load i32, i32* %17
%560 = add nsw i32 %558, %559
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds double, double* %557, i64 %561
%563 = load double, double* %562
%564 = load double*, double** %12
%565 = load i32, i32* %22
%566 = load i32, i32* %17
%567 = add nsw i32 %565, %566
%568 = sext i32 %567 to i64
%569 = getelementptr inbounds double, double* %564, i64 %568
store double %563, double* %569
%570 = load double*, double** %13
%571 = load i32, i32* %21
%572 = load i32, i32* %17
%573 = add nsw i32 %571, %572
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds double, double* %570, i64 %574
%576 = load double, double* %575
%577 = fneg double %576
%578 = load double*, double** %13
%579 = load i32, i32* %22
%580 = load i32, i32* %17
%581 = add nsw i32 %579, %580
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds double, double* %578, i64 %582
store double %577, double* %583
br label %584
584: ; preds = %556
%585 = load i32, i32* %17
%586 = add nsw i32 %585, 1
store i32 %586, i32* %17
br label %551
587: ; preds = %551
br label %588
588: ; preds = %587, %498
%589 = load i32, i32* %19
%590 = load i32, i32* %9
%591 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %589, i32 %590)
store i32 %591, i32* %21
%592 = load i32, i32* %19
%593 = load i32, i32* %9
%594 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %592, i32 %593)
store i32 %594, i32* %23
%595 = load double*, double** %10
store double* %595, double** %34
%596 = load double*, double** %11
store double* %596, double** %35
%597 = load double*, double** %12
store double* %597, double** %32
%598 = load double*, double** %13
store double* %598, double** %33
%599 = load i32, i32* %21
%600 = load double*, double** %32
%601 = sext i32 %599 to i64
%602 = getelementptr inbounds double, double* %600, i64 %601
store double* %602, double** %32
%603 = load i32, i32* %21
%604 = load double*, double** %33
%605 = sext i32 %603 to i64
%606 = getelementptr inbounds double, double* %604, i64 %605
store double* %606, double** %33
%607 = load i32, i32* %23
%608 = load double*, double** %34
%609 = sext i32 %607 to i64
%610 = getelementptr inbounds double, double* %608, i64 %609
store double* %610, double** %34
%611 = load i32, i32* %23
%612 = load double*, double** %35
%613 = sext i32 %611 to i64
%614 = getelementptr inbounds double, double* %612, i64 %613
store double* %614, double** %35
%615 = load i32, i32* %19
%616 = load i32, i32* %9
%617 = load double*, double** %34
%618 = load double*, double** %30
%619 = load double*, double** %32
%620 = load double*, double** %31
%621 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 %615, i32 %616, double* %617, double* %618, double* %619, double* %620)
%622 = load i32, i32* %19
%623 = load i32, i32* %9
%624 = load double*, double** %35
%625 = load double*, double** %30
%626 = load double*, double** %33
%627 = load double*, double** %31
%628 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 %622, i32 %623, double* %624, double* %625, double* %626, double* %627)
%629 = load i32, i32* %16
%630 = icmp eq i32 %629, 0
br i1 %630, label %631, label %676
631: ; preds = %588
%632 = load i32, i32* %19
%633 = sub nsw i32 0, %632
%634 = load i32, i32* %9
%635 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %633, i32 %634)
store i32 %635, i32* %21
%636 = load i32, i32* %19
%637 = sub nsw i32 0, %636
%638 = load i32, i32* %9
%639 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %637, i32 %638)
store i32 %639, i32* %23
%640 = load double*, double** %10
store double* %640, double** %34
%641 = load double*, double** %11
store double* %641, double** %35
%642 = load double*, double** %12
store double* %642, double** %32
%643 = load double*, double** %13
store double* %643, double** %33
%644 = load i32, i32* %21
%645 = load double*, double** %32
%646 = sext i32 %644 to i64
%647 = getelementptr inbounds double, double* %645, i64 %646
store double* %647, double** %32
%648 = load i32, i32* %21
%649 = load double*, double** %33
%650 = sext i32 %648 to i64
%651 = getelementptr inbounds double, double* %649, i64 %650
store double* %651, double** %33
%652 = load i32, i32* %23
%653 = load double*, double** %34
%654 = sext i32 %652 to i64
%655 = getelementptr inbounds double, double* %653, i64 %654
store double* %655, double** %34
%656 = load i32, i32* %23
%657 = load double*, double** %35
%658 = sext i32 %656 to i64
%659 = getelementptr inbounds double, double* %657, i64 %658
store double* %659, double** %35
%660 = load i32, i32* %19
%661 = sub nsw i32 0, %660
%662 = load i32, i32* %9
%663 = load double*, double** %34
%664 = load double*, double** %30
%665 = load double*, double** %32
%666 = load double*, double** %31
%667 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 %661, i32 %662, double* %663, double* %664, double* %665, double* %666)
%668 = load i32, i32* %19
%669 = sub nsw i32 0, %668
%670 = load i32, i32* %9
%671 = load double*, double** %35
%672 = load double*, double** %30
%673 = load double*, double** %33
%674 = load double*, double** %31
%675 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 %669, i32 %670, double* %671, double* %672, double* %673, double* %674)
br label %721
676: ; preds = %588
%677 = load i32, i32* %19
%678 = load i32, i32* %9
%679 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %677, i32 %678)
store i32 %679, i32* %21
%680 = load i32, i32* %19
%681 = sub nsw i32 0, %680
%682 = load i32, i32* %9
%683 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %681, i32 %682)
store i32 %683, i32* %22
store i32 0, i32* %17
br label %684
684: ; preds = %717, %676
%685 = load i32, i32* %17
%686 = load i32, i32* %9
%687 = mul nsw i32 2, %686
%688 = icmp slt i32 %685, %687
br i1 %688, label %689, label %720
689: ; preds = %684
%690 = load double*, double** %12
%691 = load i32, i32* %21
%692 = load i32, i32* %17
%693 = add nsw i32 %691, %692
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds double, double* %690, i64 %694
%696 = load double, double* %695
%697 = load double*, double** %12
%698 = load i32, i32* %22
%699 = load i32, i32* %17
%700 = add nsw i32 %698, %699
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds double, double* %697, i64 %701
store double %696, double* %702
%703 = load double*, double** %13
%704 = load i32, i32* %21
%705 = load i32, i32* %17
%706 = add nsw i32 %704, %705
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds double, double* %703, i64 %707
%709 = load double, double* %708
%710 = fneg double %709
%711 = load double*, double** %13
%712 = load i32, i32* %22
%713 = load i32, i32* %17
%714 = add nsw i32 %712, %713
%715 = sext i32 %714 to i64
%716 = getelementptr inbounds double, double* %711, i64 %715
store double %710, double* %716
br label %717
717: ; preds = %689
%718 = load i32, i32* %17
%719 = add nsw i32 %718, 1
store i32 %719, i32* %17
br label %684
720: ; preds = %684
br label %721
721: ; preds = %720, %631
br label %722
722: ; preds = %721
%723 = load i32, i32* %19
%724 = add nsw i32 %723, 1
store i32 %724, i32* %19
br label %442
725: ; preds = %442
store i32 1, i32* %19
br label %726
726: ; preds = %1344, %725
%727 = load i32, i32* %19
%728 = load i32, i32* %9
%729 = icmp slt i32 %727, %728
br i1 %729, label %730, label %1347
730: ; preds = %726
%731 = load i32, i32* %19
%732 = add nsw i32 %731, 1
store i32 %732, i32* %20
br label %733
733: ; preds = %1340, %730
%734 = load i32, i32* %20
%735 = load i32, i32* %9
%736 = icmp slt i32 %734, %735
br i1 %736, label %737, label %1343
737: ; preds = %733
%738 = load i32, i32* %19
%739 = load i32, i32* %20
%740 = load i32, i32* %9
%741 = load double*, double** %26
%742 = load double*, double** %27
%743 = load double*, double** %28
%744 = load double*, double** %29
%745 = load double*, double** %30
%746 = load double*, double** %31
%747 = call i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @genWigTrans_L2 to i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...)*)(i32 %738, i32 %739, i32 %740, double* %741, double* %742, double* %743, double* %744, double* %745, double* %746)
%748 = load i32, i32* %19
%749 = load i32, i32* %20
%750 = load i32, i32* %9
%751 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %748, i32 %749, i32 %750)
store i32 %751, i32* %21
%752 = load i32, i32* %19
%753 = load i32, i32* %20
%754 = load i32, i32* %9
%755 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %752, i32 %753, i32 %754)
store i32 %755, i32* %23
%756 = load double*, double** %10
store double* %756, double** %34
%757 = load double*, double** %11
store double* %757, double** %35
%758 = load double*, double** %12
store double* %758, double** %32
%759 = load double*, double** %13
store double* %759, double** %33
%760 = load i32, i32* %21
%761 = load double*, double** %32
%762 = sext i32 %760 to i64
%763 = getelementptr inbounds double, double* %761, i64 %762
store double* %763, double** %32
%764 = load i32, i32* %21
%765 = load double*, double** %33
%766 = sext i32 %764 to i64
%767 = getelementptr inbounds double, double* %765, i64 %766
store double* %767, double** %33
%768 = load i32, i32* %23
%769 = load double*, double** %34
%770 = sext i32 %768 to i64
%771 = getelementptr inbounds double, double* %769, i64 %770
store double* %771, double** %34
%772 = load i32, i32* %23
%773 = load double*, double** %35
%774 = sext i32 %772 to i64
%775 = getelementptr inbounds double, double* %773, i64 %774
store double* %775, double** %35
%776 = load i32, i32* %19
%777 = load i32, i32* %20
%778 = load i32, i32* %9
%779 = load double*, double** %34
%780 = load double*, double** %30
%781 = load double*, double** %32
%782 = load double*, double** %31
%783 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %776, i32 %777, i32 %778, double* %779, double* %780, double* %781, double* %782)
%784 = load i32, i32* %19
%785 = load i32, i32* %20
%786 = load i32, i32* %9
%787 = load double*, double** %35
%788 = load double*, double** %30
%789 = load double*, double** %33
%790 = load double*, double** %31
%791 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %784, i32 %785, i32 %786, double* %787, double* %788, double* %789, double* %790)
%792 = load i32, i32* %16
%793 = icmp eq i32 %792, 0
br i1 %793, label %794, label %847
794: ; preds = %737
%795 = load i32, i32* %19
%796 = sub nsw i32 0, %795
%797 = load i32, i32* %20
%798 = sub nsw i32 0, %797
%799 = load i32, i32* %9
%800 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %796, i32 %798, i32 %799)
store i32 %800, i32* %21
%801 = load i32, i32* %19
%802 = sub nsw i32 0, %801
%803 = load i32, i32* %20
%804 = sub nsw i32 0, %803
%805 = load i32, i32* %9
%806 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %802, i32 %804, i32 %805)
store i32 %806, i32* %23
%807 = load double*, double** %10
store double* %807, double** %34
%808 = load double*, double** %11
store double* %808, double** %35
%809 = load double*, double** %12
store double* %809, double** %32
%810 = load double*, double** %13
store double* %810, double** %33
%811 = load i32, i32* %21
%812 = load double*, double** %32
%813 = sext i32 %811 to i64
%814 = getelementptr inbounds double, double* %812, i64 %813
store double* %814, double** %32
%815 = load i32, i32* %21
%816 = load double*, double** %33
%817 = sext i32 %815 to i64
%818 = getelementptr inbounds double, double* %816, i64 %817
store double* %818, double** %33
%819 = load i32, i32* %23
%820 = load double*, double** %34
%821 = sext i32 %819 to i64
%822 = getelementptr inbounds double, double* %820, i64 %821
store double* %822, double** %34
%823 = load i32, i32* %23
%824 = load double*, double** %35
%825 = sext i32 %823 to i64
%826 = getelementptr inbounds double, double* %824, i64 %825
store double* %826, double** %35
%827 = load i32, i32* %19
%828 = sub nsw i32 0, %827
%829 = load i32, i32* %20
%830 = sub nsw i32 0, %829
%831 = load i32, i32* %9
%832 = load double*, double** %34
%833 = load double*, double** %30
%834 = load double*, double** %32
%835 = load double*, double** %31
%836 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %828, i32 %830, i32 %831, double* %832, double* %833, double* %834, double* %835)
%837 = load i32, i32* %19
%838 = sub nsw i32 0, %837
%839 = load i32, i32* %20
%840 = sub nsw i32 0, %839
%841 = load i32, i32* %9
%842 = load double*, double** %35
%843 = load double*, double** %30
%844 = load double*, double** %33
%845 = load double*, double** %31
%846 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %838, i32 %840, i32 %841, double* %842, double* %843, double* %844, double* %845)
br label %895
847: ; preds = %737
%848 = load i32, i32* %19
%849 = load i32, i32* %20
%850 = load i32, i32* %9
%851 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %848, i32 %849, i32 %850)
store i32 %851, i32* %21
%852 = load i32, i32* %19
%853 = sub nsw i32 0, %852
%854 = load i32, i32* %20
%855 = sub nsw i32 0, %854
%856 = load i32, i32* %9
%857 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %853, i32 %855, i32 %856)
store i32 %857, i32* %22
store i32 0, i32* %17
br label %858
858: ; preds = %891, %847
%859 = load i32, i32* %17
%860 = load i32, i32* %9
%861 = mul nsw i32 2, %860
%862 = icmp slt i32 %859, %861
br i1 %862, label %863, label %894
863: ; preds = %858
%864 = load double*, double** %12
%865 = load i32, i32* %21
%866 = load i32, i32* %17
%867 = add nsw i32 %865, %866
%868 = sext i32 %867 to i64
%869 = getelementptr inbounds double, double* %864, i64 %868
%870 = load double, double* %869
%871 = load double*, double** %12
%872 = load i32, i32* %22
%873 = load i32, i32* %17
%874 = add nsw i32 %872, %873
%875 = sext i32 %874 to i64
%876 = getelementptr inbounds double, double* %871, i64 %875
store double %870, double* %876
%877 = load double*, double** %13
%878 = load i32, i32* %21
%879 = load i32, i32* %17
%880 = add nsw i32 %878, %879
%881 = sext i32 %880 to i64
%882 = getelementptr inbounds double, double* %877, i64 %881
%883 = load double, double* %882
%884 = fneg double %883
%885 = load double*, double** %13
%886 = load i32, i32* %22
%887 = load i32, i32* %17
%888 = add nsw i32 %886, %887
%889 = sext i32 %888 to i64
%890 = getelementptr inbounds double, double* %885, i64 %889
store double %884, double* %890
br label %891
891: ; preds = %863
%892 = load i32, i32* %17
%893 = add nsw i32 %892, 1
store i32 %893, i32* %17
br label %858
894: ; preds = %858
br label %895
895: ; preds = %894, %794
%896 = load i32, i32* %19
%897 = load i32, i32* %20
%898 = sub nsw i32 0, %897
%899 = load i32, i32* %9
%900 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %896, i32 %898, i32 %899)
store i32 %900, i32* %21
%901 = load i32, i32* %19
%902 = load i32, i32* %20
%903 = sub nsw i32 0, %902
%904 = load i32, i32* %9
%905 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %901, i32 %903, i32 %904)
store i32 %905, i32* %23
%906 = load double*, double** %10
store double* %906, double** %34
%907 = load double*, double** %11
store double* %907, double** %35
%908 = load double*, double** %12
store double* %908, double** %32
%909 = load double*, double** %13
store double* %909, double** %33
%910 = load i32, i32* %21
%911 = load double*, double** %32
%912 = sext i32 %910 to i64
%913 = getelementptr inbounds double, double* %911, i64 %912
store double* %913, double** %32
%914 = load i32, i32* %21
%915 = load double*, double** %33
%916 = sext i32 %914 to i64
%917 = getelementptr inbounds double, double* %915, i64 %916
store double* %917, double** %33
%918 = load i32, i32* %23
%919 = load double*, double** %34
%920 = sext i32 %918 to i64
%921 = getelementptr inbounds double, double* %919, i64 %920
store double* %921, double** %34
%922 = load i32, i32* %23
%923 = load double*, double** %35
%924 = sext i32 %922 to i64
%925 = getelementptr inbounds double, double* %923, i64 %924
store double* %925, double** %35
%926 = load i32, i32* %19
%927 = load i32, i32* %20
%928 = sub nsw i32 0, %927
%929 = load i32, i32* %9
%930 = load double*, double** %34
%931 = load double*, double** %30
%932 = load double*, double** %32
%933 = load double*, double** %31
%934 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %926, i32 %928, i32 %929, double* %930, double* %931, double* %932, double* %933)
%935 = load i32, i32* %19
%936 = load i32, i32* %20
%937 = sub nsw i32 0, %936
%938 = load i32, i32* %9
%939 = load double*, double** %35
%940 = load double*, double** %30
%941 = load double*, double** %33
%942 = load double*, double** %31
%943 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %935, i32 %937, i32 %938, double* %939, double* %940, double* %941, double* %942)
%944 = load i32, i32* %16
%945 = icmp eq i32 %944, 0
br i1 %945, label %946, label %995
946: ; preds = %895
%947 = load i32, i32* %19
%948 = sub nsw i32 0, %947
%949 = load i32, i32* %20
%950 = load i32, i32* %9
%951 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %948, i32 %949, i32 %950)
store i32 %951, i32* %21
%952 = load i32, i32* %19
%953 = sub nsw i32 0, %952
%954 = load i32, i32* %20
%955 = load i32, i32* %9
%956 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %953, i32 %954, i32 %955)
store i32 %956, i32* %23
%957 = load double*, double** %10
store double* %957, double** %34
%958 = load double*, double** %11
store double* %958, double** %35
%959 = load double*, double** %12
store double* %959, double** %32
%960 = load double*, double** %13
store double* %960, double** %33
%961 = load i32, i32* %21
%962 = load double*, double** %32
%963 = sext i32 %961 to i64
%964 = getelementptr inbounds double, double* %962, i64 %963
store double* %964, double** %32
%965 = load i32, i32* %21
%966 = load double*, double** %33
%967 = sext i32 %965 to i64
%968 = getelementptr inbounds double, double* %966, i64 %967
store double* %968, double** %33
%969 = load i32, i32* %23
%970 = load double*, double** %34
%971 = sext i32 %969 to i64
%972 = getelementptr inbounds double, double* %970, i64 %971
store double* %972, double** %34
%973 = load i32, i32* %23
%974 = load double*, double** %35
%975 = sext i32 %973 to i64
%976 = getelementptr inbounds double, double* %974, i64 %975
store double* %976, double** %35
%977 = load i32, i32* %19
%978 = sub nsw i32 0, %977
%979 = load i32, i32* %20
%980 = load i32, i32* %9
%981 = load double*, double** %34
%982 = load double*, double** %30
%983 = load double*, double** %32
%984 = load double*, double** %31
%985 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %978, i32 %979, i32 %980, double* %981, double* %982, double* %983, double* %984)
%986 = load i32, i32* %19
%987 = sub nsw i32 0, %986
%988 = load i32, i32* %20
%989 = load i32, i32* %9
%990 = load double*, double** %35
%991 = load double*, double** %30
%992 = load double*, double** %33
%993 = load double*, double** %31
%994 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %987, i32 %988, i32 %989, double* %990, double* %991, double* %992, double* %993)
br label %1043
995: ; preds = %895
%996 = load i32, i32* %19
%997 = load i32, i32* %20
%998 = sub nsw i32 0, %997
%999 = load i32, i32* %9
%1000 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %996, i32 %998, i32 %999)
store i32 %1000, i32* %21
%1001 = load i32, i32* %19
%1002 = sub nsw i32 0, %1001
%1003 = load i32, i32* %20
%1004 = load i32, i32* %9
%1005 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1002, i32 %1003, i32 %1004)
store i32 %1005, i32* %22
store i32 0, i32* %17
br label %1006
1006: ; preds = %1039, %995
%1007 = load i32, i32* %17
%1008 = load i32, i32* %9
%1009 = mul nsw i32 2, %1008
%1010 = icmp slt i32 %1007, %1009
br i1 %1010, label %1011, label %1042
1011: ; preds = %1006
%1012 = load double*, double** %12
%1013 = load i32, i32* %21
%1014 = load i32, i32* %17
%1015 = add nsw i32 %1013, %1014
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds double, double* %1012, i64 %1016
%1018 = load double, double* %1017
%1019 = load double*, double** %12
%1020 = load i32, i32* %22
%1021 = load i32, i32* %17
%1022 = add nsw i32 %1020, %1021
%1023 = sext i32 %1022 to i64
%1024 = getelementptr inbounds double, double* %1019, i64 %1023
store double %1018, double* %1024
%1025 = load double*, double** %13
%1026 = load i32, i32* %21
%1027 = load i32, i32* %17
%1028 = add nsw i32 %1026, %1027
%1029 = sext i32 %1028 to i64
%1030 = getelementptr inbounds double, double* %1025, i64 %1029
%1031 = load double, double* %1030
%1032 = fneg double %1031
%1033 = load double*, double** %13
%1034 = load i32, i32* %22
%1035 = load i32, i32* %17
%1036 = add nsw i32 %1034, %1035
%1037 = sext i32 %1036 to i64
%1038 = getelementptr inbounds double, double* %1033, i64 %1037
store double %1032, double* %1038
br label %1039
1039: ; preds = %1011
%1040 = load i32, i32* %17
%1041 = add nsw i32 %1040, 1
store i32 %1041, i32* %17
br label %1006
1042: ; preds = %1006
br label %1043
1043: ; preds = %1042, %946
%1044 = load i32, i32* %20
%1045 = load i32, i32* %19
%1046 = load i32, i32* %9
%1047 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1044, i32 %1045, i32 %1046)
store i32 %1047, i32* %21
%1048 = load i32, i32* %20
%1049 = load i32, i32* %19
%1050 = load i32, i32* %9
%1051 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1048, i32 %1049, i32 %1050)
store i32 %1051, i32* %23
%1052 = load double*, double** %10
store double* %1052, double** %34
%1053 = load double*, double** %11
store double* %1053, double** %35
%1054 = load double*, double** %12
store double* %1054, double** %32
%1055 = load double*, double** %13
store double* %1055, double** %33
%1056 = load i32, i32* %21
%1057 = load double*, double** %32
%1058 = sext i32 %1056 to i64
%1059 = getelementptr inbounds double, double* %1057, i64 %1058
store double* %1059, double** %32
%1060 = load i32, i32* %21
%1061 = load double*, double** %33
%1062 = sext i32 %1060 to i64
%1063 = getelementptr inbounds double, double* %1061, i64 %1062
store double* %1063, double** %33
%1064 = load i32, i32* %23
%1065 = load double*, double** %34
%1066 = sext i32 %1064 to i64
%1067 = getelementptr inbounds double, double* %1065, i64 %1066
store double* %1067, double** %34
%1068 = load i32, i32* %23
%1069 = load double*, double** %35
%1070 = sext i32 %1068 to i64
%1071 = getelementptr inbounds double, double* %1069, i64 %1070
store double* %1071, double** %35
%1072 = load i32, i32* %20
%1073 = load i32, i32* %19
%1074 = load i32, i32* %9
%1075 = load double*, double** %34
%1076 = load double*, double** %30
%1077 = load double*, double** %32
%1078 = load double*, double** %31
%1079 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %1072, i32 %1073, i32 %1074, double* %1075, double* %1076, double* %1077, double* %1078)
%1080 = load i32, i32* %20
%1081 = load i32, i32* %19
%1082 = load i32, i32* %9
%1083 = load double*, double** %35
%1084 = load double*, double** %30
%1085 = load double*, double** %33
%1086 = load double*, double** %31
%1087 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %1080, i32 %1081, i32 %1082, double* %1083, double* %1084, double* %1085, double* %1086)
%1088 = load i32, i32* %16
%1089 = icmp eq i32 %1088, 0
br i1 %1089, label %1090, label %1143
1090: ; preds = %1043
%1091 = load i32, i32* %20
%1092 = sub nsw i32 0, %1091
%1093 = load i32, i32* %19
%1094 = sub nsw i32 0, %1093
%1095 = load i32, i32* %9
%1096 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1092, i32 %1094, i32 %1095)
store i32 %1096, i32* %21
%1097 = load i32, i32* %20
%1098 = sub nsw i32 0, %1097
%1099 = load i32, i32* %19
%1100 = sub nsw i32 0, %1099
%1101 = load i32, i32* %9
%1102 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1098, i32 %1100, i32 %1101)
store i32 %1102, i32* %23
%1103 = load double*, double** %10
store double* %1103, double** %34
%1104 = load double*, double** %11
store double* %1104, double** %35
%1105 = load double*, double** %12
store double* %1105, double** %32
%1106 = load double*, double** %13
store double* %1106, double** %33
%1107 = load i32, i32* %21
%1108 = load double*, double** %32
%1109 = sext i32 %1107 to i64
%1110 = getelementptr inbounds double, double* %1108, i64 %1109
store double* %1110, double** %32
%1111 = load i32, i32* %21
%1112 = load double*, double** %33
%1113 = sext i32 %1111 to i64
%1114 = getelementptr inbounds double, double* %1112, i64 %1113
store double* %1114, double** %33
%1115 = load i32, i32* %23
%1116 = load double*, double** %34
%1117 = sext i32 %1115 to i64
%1118 = getelementptr inbounds double, double* %1116, i64 %1117
store double* %1118, double** %34
%1119 = load i32, i32* %23
%1120 = load double*, double** %35
%1121 = sext i32 %1119 to i64
%1122 = getelementptr inbounds double, double* %1120, i64 %1121
store double* %1122, double** %35
%1123 = load i32, i32* %20
%1124 = sub nsw i32 0, %1123
%1125 = load i32, i32* %19
%1126 = sub nsw i32 0, %1125
%1127 = load i32, i32* %9
%1128 = load double*, double** %34
%1129 = load double*, double** %30
%1130 = load double*, double** %32
%1131 = load double*, double** %31
%1132 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %1124, i32 %1126, i32 %1127, double* %1128, double* %1129, double* %1130, double* %1131)
%1133 = load i32, i32* %20
%1134 = sub nsw i32 0, %1133
%1135 = load i32, i32* %19
%1136 = sub nsw i32 0, %1135
%1137 = load i32, i32* %9
%1138 = load double*, double** %35
%1139 = load double*, double** %30
%1140 = load double*, double** %33
%1141 = load double*, double** %31
%1142 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %1134, i32 %1136, i32 %1137, double* %1138, double* %1139, double* %1140, double* %1141)
br label %1191
1143: ; preds = %1043
%1144 = load i32, i32* %20
%1145 = load i32, i32* %19
%1146 = load i32, i32* %9
%1147 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1144, i32 %1145, i32 %1146)
store i32 %1147, i32* %21
%1148 = load i32, i32* %20
%1149 = sub nsw i32 0, %1148
%1150 = load i32, i32* %19
%1151 = sub nsw i32 0, %1150
%1152 = load i32, i32* %9
%1153 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1149, i32 %1151, i32 %1152)
store i32 %1153, i32* %22
store i32 0, i32* %17
br label %1154
1154: ; preds = %1187, %1143
%1155 = load i32, i32* %17
%1156 = load i32, i32* %9
%1157 = mul nsw i32 2, %1156
%1158 = icmp slt i32 %1155, %1157
br i1 %1158, label %1159, label %1190
1159: ; preds = %1154
%1160 = load double*, double** %12
%1161 = load i32, i32* %21
%1162 = load i32, i32* %17
%1163 = add nsw i32 %1161, %1162
%1164 = sext i32 %1163 to i64
%1165 = getelementptr inbounds double, double* %1160, i64 %1164
%1166 = load double, double* %1165
%1167 = load double*, double** %12
%1168 = load i32, i32* %22
%1169 = load i32, i32* %17
%1170 = add nsw i32 %1168, %1169
%1171 = sext i32 %1170 to i64
%1172 = getelementptr inbounds double, double* %1167, i64 %1171
store double %1166, double* %1172
%1173 = load double*, double** %13
%1174 = load i32, i32* %21
%1175 = load i32, i32* %17
%1176 = add nsw i32 %1174, %1175
%1177 = sext i32 %1176 to i64
%1178 = getelementptr inbounds double, double* %1173, i64 %1177
%1179 = load double, double* %1178
%1180 = fneg double %1179
%1181 = load double*, double** %13
%1182 = load i32, i32* %22
%1183 = load i32, i32* %17
%1184 = add nsw i32 %1182, %1183
%1185 = sext i32 %1184 to i64
%1186 = getelementptr inbounds double, double* %1181, i64 %1185
store double %1180, double* %1186
br label %1187
1187: ; preds = %1159
%1188 = load i32, i32* %17
%1189 = add nsw i32 %1188, 1
store i32 %1189, i32* %17
br label %1154
1190: ; preds = %1154
br label %1191
1191: ; preds = %1190, %1090
%1192 = load i32, i32* %20
%1193 = load i32, i32* %19
%1194 = sub nsw i32 0, %1193
%1195 = load i32, i32* %9
%1196 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1192, i32 %1194, i32 %1195)
store i32 %1196, i32* %21
%1197 = load i32, i32* %20
%1198 = load i32, i32* %19
%1199 = sub nsw i32 0, %1198
%1200 = load i32, i32* %9
%1201 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1197, i32 %1199, i32 %1200)
store i32 %1201, i32* %23
%1202 = load double*, double** %10
store double* %1202, double** %34
%1203 = load double*, double** %11
store double* %1203, double** %35
%1204 = load double*, double** %12
store double* %1204, double** %32
%1205 = load double*, double** %13
store double* %1205, double** %33
%1206 = load i32, i32* %21
%1207 = load double*, double** %32
%1208 = sext i32 %1206 to i64
%1209 = getelementptr inbounds double, double* %1207, i64 %1208
store double* %1209, double** %32
%1210 = load i32, i32* %21
%1211 = load double*, double** %33
%1212 = sext i32 %1210 to i64
%1213 = getelementptr inbounds double, double* %1211, i64 %1212
store double* %1213, double** %33
%1214 = load i32, i32* %23
%1215 = load double*, double** %34
%1216 = sext i32 %1214 to i64
%1217 = getelementptr inbounds double, double* %1215, i64 %1216
store double* %1217, double** %34
%1218 = load i32, i32* %23
%1219 = load double*, double** %35
%1220 = sext i32 %1218 to i64
%1221 = getelementptr inbounds double, double* %1219, i64 %1220
store double* %1221, double** %35
%1222 = load i32, i32* %19
%1223 = load i32, i32* %20
%1224 = sub nsw i32 0, %1223
%1225 = load i32, i32* %9
%1226 = load double*, double** %34
%1227 = load double*, double** %30
%1228 = load double*, double** %32
%1229 = load double*, double** %31
%1230 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %1222, i32 %1224, i32 %1225, double* %1226, double* %1227, double* %1228, double* %1229)
%1231 = load i32, i32* %19
%1232 = load i32, i32* %20
%1233 = sub nsw i32 0, %1232
%1234 = load i32, i32* %9
%1235 = load double*, double** %35
%1236 = load double*, double** %30
%1237 = load double*, double** %33
%1238 = load double*, double** %31
%1239 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %1231, i32 %1233, i32 %1234, double* %1235, double* %1236, double* %1237, double* %1238)
%1240 = load i32, i32* %16
%1241 = icmp eq i32 %1240, 0
br i1 %1241, label %1242, label %1291
1242: ; preds = %1191
%1243 = load i32, i32* %20
%1244 = sub nsw i32 0, %1243
%1245 = load i32, i32* %19
%1246 = load i32, i32* %9
%1247 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1244, i32 %1245, i32 %1246)
store i32 %1247, i32* %21
%1248 = load i32, i32* %20
%1249 = sub nsw i32 0, %1248
%1250 = load i32, i32* %19
%1251 = load i32, i32* %9
%1252 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1249, i32 %1250, i32 %1251)
store i32 %1252, i32* %23
%1253 = load double*, double** %10
store double* %1253, double** %34
%1254 = load double*, double** %11
store double* %1254, double** %35
%1255 = load double*, double** %12
store double* %1255, double** %32
%1256 = load double*, double** %13
store double* %1256, double** %33
%1257 = load i32, i32* %21
%1258 = load double*, double** %32
%1259 = sext i32 %1257 to i64
%1260 = getelementptr inbounds double, double* %1258, i64 %1259
store double* %1260, double** %32
%1261 = load i32, i32* %21
%1262 = load double*, double** %33
%1263 = sext i32 %1261 to i64
%1264 = getelementptr inbounds double, double* %1262, i64 %1263
store double* %1264, double** %33
%1265 = load i32, i32* %23
%1266 = load double*, double** %34
%1267 = sext i32 %1265 to i64
%1268 = getelementptr inbounds double, double* %1266, i64 %1267
store double* %1268, double** %34
%1269 = load i32, i32* %23
%1270 = load double*, double** %35
%1271 = sext i32 %1269 to i64
%1272 = getelementptr inbounds double, double* %1270, i64 %1271
store double* %1272, double** %35
%1273 = load i32, i32* %19
%1274 = sub nsw i32 0, %1273
%1275 = load i32, i32* %20
%1276 = load i32, i32* %9
%1277 = load double*, double** %34
%1278 = load double*, double** %30
%1279 = load double*, double** %32
%1280 = load double*, double** %31
%1281 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %1274, i32 %1275, i32 %1276, double* %1277, double* %1278, double* %1279, double* %1280)
%1282 = load i32, i32* %19
%1283 = sub nsw i32 0, %1282
%1284 = load i32, i32* %20
%1285 = load i32, i32* %9
%1286 = load double*, double** %35
%1287 = load double*, double** %30
%1288 = load double*, double** %33
%1289 = load double*, double** %31
%1290 = call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %1283, i32 %1284, i32 %1285, double* %1286, double* %1287, double* %1288, double* %1289)
br label %1339
1291: ; preds = %1191
%1292 = load i32, i32* %20
%1293 = load i32, i32* %19
%1294 = sub nsw i32 0, %1293
%1295 = load i32, i32* %9
%1296 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1292, i32 %1294, i32 %1295)
store i32 %1296, i32* %21
%1297 = load i32, i32* %20
%1298 = sub nsw i32 0, %1297
%1299 = load i32, i32* %19
%1300 = load i32, i32* %9
%1301 = call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1298, i32 %1299, i32 %1300)
store i32 %1301, i32* %22
store i32 0, i32* %17
br label %1302
1302: ; preds = %1335, %1291
%1303 = load i32, i32* %17
%1304 = load i32, i32* %9
%1305 = mul nsw i32 2, %1304
%1306 = icmp slt i32 %1303, %1305
br i1 %1306, label %1307, label %1338
1307: ; preds = %1302
%1308 = load double*, double** %12
%1309 = load i32, i32* %21
%1310 = load i32, i32* %17
%1311 = add nsw i32 %1309, %1310
%1312 = sext i32 %1311 to i64
%1313 = getelementptr inbounds double, double* %1308, i64 %1312
%1314 = load double, double* %1313
%1315 = load double*, double** %12
%1316 = load i32, i32* %22
%1317 = load i32, i32* %17
%1318 = add nsw i32 %1316, %1317
%1319 = sext i32 %1318 to i64
%1320 = getelementptr inbounds double, double* %1315, i64 %1319
store double %1314, double* %1320
%1321 = load double*, double** %13
%1322 = load i32, i32* %21
%1323 = load i32, i32* %17
%1324 = add nsw i32 %1322, %1323
%1325 = sext i32 %1324 to i64
%1326 = getelementptr inbounds double, double* %1321, i64 %1325
%1327 = load double, double* %1326
%1328 = fneg double %1327
%1329 = load double*, double** %13
%1330 = load i32, i32* %22
%1331 = load i32, i32* %17
%1332 = add nsw i32 %1330, %1331
%1333 = sext i32 %1332 to i64
%1334 = getelementptr inbounds double, double* %1329, i64 %1333
store double %1328, double* %1334
br label %1335
1335: ; preds = %1307
%1336 = load i32, i32* %17
%1337 = add nsw i32 %1336, 1
store i32 %1337, i32* %17
br label %1302
1338: ; preds = %1302
br label %1339
1339: ; preds = %1338, %1242
br label %1340
1340: ; preds = %1339
%1341 = load i32, i32* %20
%1342 = add nsw i32 %1341, 1
store i32 %1342, i32* %20
br label %733
1343: ; preds = %733
br label %1344
1344: ; preds = %1343
%1345 = load i32, i32* %19
%1346 = add nsw i32 %1345, 1
store i32 %1346, i32* %19
br label %726
1347: ; preds = %726
%1348 = load double*, double** %12
%1349 = load i32, i32* %18
%1350 = load i32, i32* %9
%1351 = mul nsw i32 %1349, %1350
%1352 = sext i32 %1351 to i64
%1353 = getelementptr inbounds double, double* %1348, i64 %1352
store double* %1353, double** %32
%1354 = load double*, double** %13
%1355 = load i32, i32* %18
%1356 = load i32, i32* %9
%1357 = mul nsw i32 %1355, %1356
%1358 = sext i32 %1357 to i64
%1359 = getelementptr inbounds double, double* %1354, i64 %1358
store double* %1359, double** %33
store i32 0, i32* %19
br label %1360
1360: ; preds = %1389, %1347
%1361 = load i32, i32* %19
%1362 = load i32, i32* %9
%1363 = icmp slt i32 %1361, %1362
br i1 %1363, label %1364, label %1392
1364: ; preds = %1360
%1365 = load double*, double** %32
%1366 = bitcast double* %1365 to i8*
%1367 = load i32, i32* %18
%1368 = sext i32 %1367 to i64
%1369 = mul i64 8, %1368
%1370 = load double*, double** %33
%1371 = bitcast double* %1370 to i8*
%1372 = load i32, i32* %18
%1373 = sext i32 %1372 to i64
%1374 = mul i64 8, %1373
%1375 = load i32, i32* %18
%1376 = mul nsw i32 2, %1375
%1377 = load i32, i32* %9
%1378 = mul nsw i32 %1376, %1377
%1379 = load double*, double** %32
%1380 = sext i32 %1378 to i64
%1381 = getelementptr inbounds double, double* %1379, i64 %1380
store double* %1381, double** %32
%1382 = load i32, i32* %18
%1383 = mul nsw i32 2, %1382
%1384 = load i32, i32* %9
%1385 = mul nsw i32 %1383, %1384
%1386 = load double*, double** %33
%1387 = sext i32 %1385 to i64
%1388 = getelementptr inbounds double, double* %1386, i64 %1387
store double* %1388, double** %33
br label %1389
1389: ; preds = %1364
%1390 = load i32, i32* %19
%1391 = add nsw i32 %1390, 1
store i32 %1391, i32* %19
br label %1360
1392: ; preds = %1360
%1393 = load double*, double** %12
%1394 = load i32, i32* %9
%1395 = load i32, i32* %18
%1396 = mul nsw i32 %1394, %1395
%1397 = load i32, i32* %18
%1398 = mul nsw i32 %1396, %1397
%1399 = sext i32 %1398 to i64
%1400 = getelementptr inbounds double, double* %1393, i64 %1399
store double* %1400, double** %32
%1401 = load double*, double** %13
%1402 = load i32, i32* %9
%1403 = load i32, i32* %18
%1404 = mul nsw i32 %1402, %1403
%1405 = load i32, i32* %18
%1406 = mul nsw i32 %1404, %1405
%1407 = sext i32 %1406 to i64
%1408 = getelementptr inbounds double, double* %1401, i64 %1407
store double* %1408, double** %33
%1409 = load double*, double** %32
%1410 = bitcast double* %1409 to i8*
%1411 = load i32, i32* %18
%1412 = sext i32 %1411 to i64
%1413 = mul i64 8, %1412
%1414 = load i32, i32* %18
%1415 = sext i32 %1414 to i64
%1416 = mul i64 %1413, %1415
%1417 = load double*, double** %33
%1418 = bitcast double* %1417 to i8*
%1419 = load i32, i32* %18
%1420 = sext i32 %1419 to i64
%1421 = mul i64 8, %1420
%1422 = load i32, i32* %18
%1423 = sext i32 %1422 to i64
%1424 = mul i64 %1421, %1423
%1425 = load i32, i32* %18
%1426 = load i32, i32* %18
%1427 = mul nsw i32 %1425, %1426
%1428 = load i32, i32* %18
%1429 = load i32, i32* %9
%1430 = mul nsw i32 %1428, %1429
%1431 = add nsw i32 %1427, %1430
%1432 = load double*, double** %32
%1433 = sext i32 %1431 to i64
%1434 = getelementptr inbounds double, double* %1432, i64 %1433
store double* %1434, double** %32
%1435 = load i32, i32* %18
%1436 = load i32, i32* %18
%1437 = mul nsw i32 %1435, %1436
%1438 = load i32, i32* %18
%1439 = load i32, i32* %9
%1440 = mul nsw i32 %1438, %1439
%1441 = add nsw i32 %1437, %1440
%1442 = load double*, double** %33
%1443 = sext i32 %1441 to i64
%1444 = getelementptr inbounds double, double* %1442, i64 %1443
store double* %1444, double** %33
store i32 1, i32* %19
br label %1445
1445: ; preds = %1474, %1392
%1446 = load i32, i32* %19
%1447 = load i32, i32* %9
%1448 = icmp slt i32 %1446, %1447
br i1 %1448, label %1449, label %1477
1449: ; preds = %1445
%1450 = load double*, double** %32
%1451 = bitcast double* %1450 to i8*
%1452 = load i32, i32* %18
%1453 = sext i32 %1452 to i64
%1454 = mul i64 8, %1453
%1455 = load double*, double** %33
%1456 = bitcast double* %1455 to i8*
%1457 = load i32, i32* %18
%1458 = sext i32 %1457 to i64
%1459 = mul i64 8, %1458
%1460 = load i32, i32* %18
%1461 = mul nsw i32 2, %1460
%1462 = load i32, i32* %9
%1463 = mul nsw i32 %1461, %1462
%1464 = load double*, double** %32
%1465 = sext i32 %1463 to i64
%1466 = getelementptr inbounds double, double* %1464, i64 %1465
store double* %1466, double** %32
%1467 = load i32, i32* %18
%1468 = mul nsw i32 2, %1467
%1469 = load i32, i32* %9
%1470 = mul nsw i32 %1468, %1469
%1471 = load double*, double** %33
%1472 = sext i32 %1470 to i64
%1473 = getelementptr inbounds double, double* %1471, i64 %1472
store double* %1473, double** %33
br label %1474
1474: ; preds = %1449
%1475 = load i32, i32* %19
%1476 = add nsw i32 %1475, 1
store i32 %1476, i32* %19
br label %1445
1477: ; preds = %1445
%1478 = load double*, double** %12
%1479 = load double*, double** %24
%1480 = load i32, i32* %18
%1481 = load i32, i32* %18
%1482 = load i32, i32* %18
%1483 = mul nsw i32 %1481, %1482
%1484 = call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @transpose_so3 to i32 (double*, double*, i32, i32, ...)*)(double* %1478, double* %1479, i32 %1480, i32 %1483)
%1485 = load double*, double** %13
%1486 = load double*, double** %25
%1487 = load i32, i32* %18
%1488 = load i32, i32* %18
%1489 = load i32, i32* %18
%1490 = mul nsw i32 %1488, %1489
%1491 = call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @transpose_so3 to i32 (double*, double*, i32, i32, ...)*)(double* %1485, double* %1486, i32 %1487, i32 %1490)
%1492 = load double*, double** %24
%1493 = load double*, double** %25
%1494 = load double*, double** %12
%1495 = load double*, double** %13
%1496 = load i32, i32* %18
%1497 = load i32, i32* %18
%1498 = mul nsw i32 %1496, %1497
%1499 = load i32, i32* %18
%1500 = load double*, double** %31
%1501 = call i32 (double*, double*, double*, double*, i32, i32, double*, ...) bitcast (i32 (...)* @grid_fourier_so3 to i32 (double*, double*, double*, double*, i32, i32, double*, ...)*)(double* %1492, double* %1493, double* %1494, double* %1495, i32 %1498, i32 %1499, double* %1500)
%1502 = load double*, double** %12
%1503 = load double*, double** %24
%1504 = load i32, i32* %18
%1505 = load i32, i32* %18
%1506 = load i32, i32* %18
%1507 = mul nsw i32 %1505, %1506
%1508 = call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @transpose_so3 to i32 (double*, double*, i32, i32, ...)*)(double* %1502, double* %1503, i32 %1504, i32 %1507)
%1509 = load double*, double** %13
%1510 = load double*, double** %25
%1511 = load i32, i32* %18
%1512 = load i32, i32* %18
%1513 = load i32, i32* %18
%1514 = mul nsw i32 %1512, %1513
%1515 = call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @transpose_so3 to i32 (double*, double*, i32, i32, ...)*)(double* %1509, double* %1510, i32 %1511, i32 %1514)
%1516 = load double*, double** %24
%1517 = load double*, double** %25
%1518 = load double*, double** %12
%1519 = load double*, double** %13
%1520 = load i32, i32* %18
%1521 = load i32, i32* %18
%1522 = mul nsw i32 %1520, %1521
%1523 = load i32, i32* %18
%1524 = load double*, double** %31
%1525 = call i32 (double*, double*, double*, double*, i32, i32, double*, ...) bitcast (i32 (...)* @grid_fourier_so3 to i32 (double*, double*, double*, double*, i32, i32, double*, ...)*)(double* %1516, double* %1517, double* %1518, double* %1519, i32 %1522, i32 %1523, double* %1524)
%1526 = load i32, i32* %18
%1527 = sitofp i32 %1526 to double
store double %1527, double* %36
%1528 = load i32, i32* %9
%1529 = sitofp i32 %1528 to double
%1530 = fdiv double %1529, 0x400921FB54442D18
%1531 = load double, double* %36
%1532 = fmul double %1531, %1530
store double %1532, double* %36
store i32 0, i32* %17
br label %1533
1533: ; preds = %1556, %1477
%1534 = load i32, i32* %17
%1535 = load i32, i32* %18
%1536 = load i32, i32* %18
%1537 = mul nsw i32 %1535, %1536
%1538 = load i32, i32* %18
%1539 = mul nsw i32 %1537, %1538
%1540 = icmp slt i32 %1534, %1539
br i1 %1540, label %1541, label %1559
1541: ; preds = %1533
%1542 = load double, double* %36
%1543 = load double*, double** %12
%1544 = load i32, i32* %17
%1545 = sext i32 %1544 to i64
%1546 = getelementptr inbounds double, double* %1543, i64 %1545
%1547 = load double, double* %1546
%1548 = fmul double %1547, %1542
store double %1548, double* %1546
%1549 = load double, double* %36
%1550 = load double*, double** %13
%1551 = load i32, i32* %17
%1552 = sext i32 %1551 to i64
%1553 = getelementptr inbounds double, double* %1550, i64 %1552
%1554 = load double, double* %1553
%1555 = fmul double %1554, %1549
store double %1555, double* %1553
br label %1556
1556: ; preds = %1541
%1557 = load i32, i32* %17
%1558 = add nsw i32 %1557, 1
store i32 %1558, i32* %17
br label %1533
1559: ; preds = %1533
ret void
}

LLVM IR (-O2):
define void @Inverse_SO3_Naive_sym(i32 %0, double* %1, double* %2, double* %3, double* %4, double* %5, double* %6, i32 %7) {
%9 = shl nsw i32 %0, 1
%10 = mul nsw i32 %9, %9
%11 = mul i32 %10, %9
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds double, double* %5, i64 %12
%14 = sext i32 %9 to i64
%15 = getelementptr inbounds double, double* %6, i64 %14
%16 = getelementptr inbounds double, double* %15, i64 %14
%17 = getelementptr inbounds double, double* %16, i64 %14
%18 = getelementptr inbounds double, double* %17, i64 %14
%19 = mul nsw i32 %9, %0
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds double, double* %18, i64 %20
%22 = tail call i32 (i32, double*, ...) bitcast (i32 (...)* @SinEvalPts to i32 (i32, double*, ...)*)(i32 %9, double* %6)
%23 = tail call i32 (i32, double*, ...) bitcast (i32 (...)* @CosEvalPts to i32 (i32, double*, ...)*)(i32 %9, double* %15)
%24 = tail call i32 (i32, double*, ...) bitcast (i32 (...)* @SinEvalPts2 to i32 (i32, double*, ...)*)(i32 %9, double* %16)
%25 = tail call i32 (i32, double*, ...) bitcast (i32 (...)* @CosEvalPts2 to i32 (i32, double*, ...)*)(i32 %9, double* %17)
%26 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @genWigTrans_L2 to i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...)*)(i32 0, i32 0, i32 %0, double* %6, double* %15, double* %16, double* %17, double* %18, double* %21)
%27 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 0, i32 %0)
%28 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 0, i32 %0)
%29 = sext i32 %27 to i64
%30 = getelementptr inbounds double, double* %3, i64 %29
%31 = getelementptr inbounds double, double* %4, i64 %29
%32 = sext i32 %28 to i64
%33 = getelementptr inbounds double, double* %1, i64 %32
%34 = getelementptr inbounds double, double* %2, i64 %32
%35 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 0, i32 %0, double* %33, double* %18, double* %30, double* %21)
%36 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 0, i32 %0, double* %34, double* %18, double* %31, double* %21)
%37 = icmp sgt i32 %0, 1
br i1 %37, label %38, label %1638
38: ; preds = %8
%39 = icmp eq i32 %7, 0
%40 = call i32 @llvm.smax.i32(i32 %9, i32 1)
%41 = zext i32 %40 to i64
%42 = zext i32 %40 to i64
%43 = getelementptr double, double* %3, i64 %41
%44 = getelementptr double, double* %4, i64 %41
%45 = getelementptr double, double* %3, i64 %41
%46 = getelementptr double, double* %4, i64 %41
%47 = getelementptr double, double* %3, i64 %41
%48 = getelementptr double, double* %4, i64 %41
%49 = getelementptr double, double* %3, i64 %41
%50 = getelementptr double, double* %4, i64 %41
%51 = and i64 %41, 2147483644
%52 = add nsw i64 %51, -4
%53 = lshr exact i64 %52, 2
%54 = add nuw nsw i64 %53, 1
%55 = icmp ult i32 %40, 4
%56 = icmp ugt double* %48, %3
%57 = icmp ugt double* %47, %4
%58 = and i1 %56, %57
%59 = and i64 %41, 2147483644
%60 = and i64 %54, 1
%61 = icmp eq i64 %52, 0
%62 = and i64 %54, 9223372036854775806
%63 = icmp eq i64 %60, 0
%64 = icmp eq i64 %59, %41
%65 = and i64 %41, 1
%66 = icmp eq i64 %65, 0
%67 = sub nsw i64 0, %41
%68 = icmp ult i32 %40, 4
%69 = icmp ugt double* %44, %3
%70 = icmp ugt double* %43, %4
%71 = and i1 %69, %70
%72 = and i64 %41, 2147483644
%73 = and i64 %54, 1
%74 = icmp eq i64 %52, 0
%75 = and i64 %54, 9223372036854775806
%76 = icmp eq i64 %73, 0
%77 = icmp eq i64 %72, %41
%78 = and i64 %41, 1
%79 = icmp eq i64 %78, 0
%80 = sub nsw i64 0, %41
br label %121
81: ; preds = %478
br i1 %37, label %82, label %1638
82: ; preds = %81
%83 = icmp eq i32 %7, 0
%84 = call i32 @llvm.smax.i32(i32 %9, i32 1)
%85 = zext i32 %84 to i64
%86 = zext i32 %84 to i64
%87 = getelementptr double, double* %3, i64 %41
%88 = getelementptr double, double* %4, i64 %41
%89 = getelementptr double, double* %3, i64 %41
%90 = getelementptr double, double* %4, i64 %41
%91 = getelementptr double, double* %3, i64 %41
%92 = getelementptr double, double* %4, i64 %41
%93 = getelementptr double, double* %3, i64 %41
%94 = getelementptr double, double* %4, i64 %41
%95 = icmp ult i32 %40, 4
%96 = icmp ugt double* %92, %3
%97 = icmp ugt double* %91, %4
%98 = and i1 %96, %97
%99 = and i64 %41, 2147483644
%100 = and i64 %54, 1
%101 = icmp eq i64 %52, 0
%102 = and i64 %54, 9223372036854775806
%103 = icmp eq i64 %100, 0
%104 = icmp eq i64 %99, %41
%105 = and i64 %41, 1
%106 = icmp eq i64 %105, 0
%107 = sub nsw i64 0, %41
%108 = icmp ult i32 %40, 4
%109 = icmp ugt double* %88, %3
%110 = icmp ugt double* %87, %4
%111 = and i1 %109, %110
%112 = and i64 %41, 2147483644
%113 = and i64 %54, 1
%114 = icmp eq i64 %52, 0
%115 = and i64 %54, 9223372036854775806
%116 = icmp eq i64 %113, 0
%117 = icmp eq i64 %112, %41
%118 = and i64 %41, 1
%119 = icmp eq i64 %118, 0
%120 = sub nsw i64 0, %41
br label %557
121: ; preds = %38, %478
%122 = phi i32 [ 1, %38 ], [ %479, %478 ]
%123 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @genWigTrans_L2 to i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...)*)(i32 %122, i32 %122, i32 %0, double* %6, double* %15, double* %16, double* %17, double* %18, double* %21)
%124 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %122, i32 %122, i32 %0)
%125 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %122, i32 %122, i32 %0)
%126 = sext i32 %124 to i64
%127 = getelementptr inbounds double, double* %3, i64 %126
%128 = getelementptr inbounds double, double* %4, i64 %126
%129 = sext i32 %125 to i64
%130 = getelementptr inbounds double, double* %1, i64 %129
%131 = getelementptr inbounds double, double* %2, i64 %129
%132 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %122, i32 %122, i32 %0, double* %130, double* %18, double* %127, double* %21)
%133 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %122, i32 %122, i32 %0, double* %131, double* %18, double* %128, double* %21)
br i1 %39, label %134, label %146
134: ; preds = %121
%135 = sub nsw i32 0, %122
%136 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %135, i32 %135, i32 %0)
%137 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %135, i32 %135, i32 %0)
%138 = sext i32 %136 to i64
%139 = getelementptr inbounds double, double* %3, i64 %138
%140 = getelementptr inbounds double, double* %4, i64 %138
%141 = sext i32 %137 to i64
%142 = getelementptr inbounds double, double* %1, i64 %141
%143 = getelementptr inbounds double, double* %2, i64 %141
%144 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %135, i32 %135, i32 %0, double* %142, double* %18, double* %139, double* %21)
%145 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %135, i32 %135, i32 %0, double* %143, double* %18, double* %140, double* %21)
br label %301
146: ; preds = %121
%147 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %122, i32 %122, i32 %0)
%148 = sub nsw i32 0, %122
%149 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %148, i32 %148, i32 %0)
%150 = sext i32 %147 to i64
%151 = sext i32 %149 to i64
br i1 %55, label %261, label %152
152: ; preds = %146
%153 = getelementptr double, double* %3, i64 %151
%154 = getelementptr double, double* %47, i64 %151
%155 = getelementptr double, double* %4, i64 %151
%156 = getelementptr double, double* %48, i64 %151
%157 = getelementptr double, double* %3, i64 %150
%158 = getelementptr double, double* %49, i64 %150
%159 = getelementptr double, double* %4, i64 %150
%160 = getelementptr double, double* %50, i64 %150
%161 = icmp ult double* %153, %158
%162 = icmp ult double* %157, %154
%163 = and i1 %161, %162
%164 = or i1 %58, %163
%165 = icmp ult double* %153, %160
%166 = icmp ult double* %159, %154
%167 = and i1 %165, %166
%168 = or i1 %164, %167
%169 = icmp ult double* %155, %158
%170 = icmp ult double* %157, %156
%171 = and i1 %169, %170
%172 = or i1 %168, %171
%173 = icmp ult double* %155, %160
%174 = icmp ult double* %159, %156
%175 = and i1 %173, %174
%176 = or i1 %172, %175
br i1 %176, label %261, label %177
177: ; preds = %152
br i1 %61, label %233, label %178
178: ; preds = %177, %178
%179 = phi i64 [ %230, %178 ], [ 0, %177 ]
%180 = phi i64 [ %231, %178 ], [ 0, %177 ]
%181 = add nsw i64 %179, %150
%182 = getelementptr inbounds double, double* %3, i64 %181
%183 = bitcast double* %182 to <2 x double>*
%184 = load <2 x double>, <2 x double>* %183
%185 = getelementptr inbounds double, double* %182, i64 2
%186 = bitcast double* %185 to <2 x double>*
%187 = load <2 x double>, <2 x double>* %186
%188 = add nsw i64 %179, %151
%189 = getelementptr inbounds double, double* %3, i64 %188
%190 = bitcast double* %189 to <2 x double>*
store <2 x double> %184, <2 x double>* %190
%191 = getelementptr inbounds double, double* %189, i64 2
%192 = bitcast double* %191 to <2 x double>*
store <2 x double> %187, <2 x double>* %192
%193 = getelementptr inbounds double, double* %4, i64 %181
%194 = bitcast double* %193 to <2 x double>*
%195 = load <2 x double>, <2 x double>* %194
%196 = getelementptr inbounds double, double* %193, i64 2
%197 = bitcast double* %196 to <2 x double>*
%198 = load <2 x double>, <2 x double>* %197
%199 = fneg <2 x double> %195
%200 = fneg <2 x double> %198
%201 = getelementptr inbounds double, double* %4, i64 %188
%202 = bitcast double* %201 to <2 x double>*
store <2 x double> %199, <2 x double>* %202
%203 = getelementptr inbounds double, double* %201, i64 2
%204 = bitcast double* %203 to <2 x double>*
store <2 x double> %200, <2 x double>* %204
%205 = or i64 %179, 4
%206 = add nsw i64 %205, %150
%207 = getelementptr inbounds double, double* %3, i64 %206
%208 = bitcast double* %207 to <2 x double>*
%209 = load <2 x double>, <2 x double>* %208
%210 = getelementptr inbounds double, double* %207, i64 2
%211 = bitcast double* %210 to <2 x double>*
%212 = load <2 x double>, <2 x double>* %211
%213 = add nsw i64 %205, %151
%214 = getelementptr inbounds double, double* %3, i64 %213
%215 = bitcast double* %214 to <2 x double>*
store <2 x double> %209, <2 x double>* %215
%216 = getelementptr inbounds double, double* %214, i64 2
%217 = bitcast double* %216 to <2 x double>*
store <2 x double> %212, <2 x double>* %217
%218 = getelementptr inbounds double, double* %4, i64 %206
%219 = bitcast double* %218 to <2 x double>*
%220 = load <2 x double>, <2 x double>* %219
%221 = getelementptr inbounds double, double* %218, i64 2
%222 = bitcast double* %221 to <2 x double>*
%223 = load <2 x double>, <2 x double>* %222
%224 = fneg <2 x double> %220
%225 = fneg <2 x double> %223
%226 = getelementptr inbounds double, double* %4, i64 %213
%227 = bitcast double* %226 to <2 x double>*
store <2 x double> %224, <2 x double>* %227
%228 = getelementptr inbounds double, double* %226, i64 2
%229 = bitcast double* %228 to <2 x double>*
store <2 x double> %225, <2 x double>* %229
%230 = add nuw i64 %179, 8
%231 = add i64 %180, 2
%232 = icmp eq i64 %231, %62
br i1 %232, label %233, label %178
233: ; preds = %178, %177
%234 = phi i64 [ 0, %177 ], [ %230, %178 ]
br i1 %63, label %260, label %235
235: ; preds = %233
%236 = add nsw i64 %234, %150
%237 = getelementptr inbounds double, double* %3, i64 %236
%238 = bitcast double* %237 to <2 x double>*
%239 = load <2 x double>, <2 x double>* %238
%240 = getelementptr inbounds double, double* %237, i64 2
%241 = bitcast double* %240 to <2 x double>*
%242 = load <2 x double>, <2 x double>* %241
%243 = add nsw i64 %234, %151
%244 = getelementptr inbounds double, double* %3, i64 %243
%245 = bitcast double* %244 to <2 x double>*
store <2 x double> %239, <2 x double>* %245
%246 = getelementptr inbounds double, double* %244, i64 2
%247 = bitcast double* %246 to <2 x double>*
store <2 x double> %242, <2 x double>* %247
%248 = getelementptr inbounds double, double* %4, i64 %236
%249 = bitcast double* %248 to <2 x double>*
%250 = load <2 x double>, <2 x double>* %249
%251 = getelementptr inbounds double, double* %248, i64 2
%252 = bitcast double* %251 to <2 x double>*
%253 = load <2 x double>, <2 x double>* %252
%254 = fneg <2 x double> %250
%255 = fneg <2 x double> %253
%256 = getelementptr inbounds double, double* %4, i64 %243
%257 = bitcast double* %256 to <2 x double>*
store <2 x double> %254, <2 x double>* %257
%258 = getelementptr inbounds double, double* %256, i64 2
%259 = bitcast double* %258 to <2 x double>*
store <2 x double> %255, <2 x double>* %259
br label %260
260: ; preds = %233, %235
br i1 %64, label %301, label %261
261: ; preds = %152, %146, %260
%262 = phi i64 [ 0, %152 ], [ 0, %146 ], [ %59, %260 ]
%263 = xor i64 %262, -1
br i1 %66, label %275, label %264
264: ; preds = %261
%265 = add nsw i64 %262, %150
%266 = getelementptr inbounds double, double* %3, i64 %265
%267 = load double, double* %266
%268 = add nsw i64 %262, %151
%269 = getelementptr inbounds double, double* %3, i64 %268
store double %267, double* %269
%270 = getelementptr inbounds double, double* %4, i64 %265
%271 = load double, double* %270
%272 = fneg double %271
%273 = getelementptr inbounds double, double* %4, i64 %268
store double %272, double* %273
%274 = or i64 %262, 1
br label %275
275: ; preds = %264, %261
%276 = phi i64 [ %262, %261 ], [ %274, %264 ]
%277 = icmp eq i64 %263, %67
br i1 %277, label %301, label %278
278: ; preds = %275, %278
%279 = phi i64 [ %299, %278 ], [ %276, %275 ]
%280 = add nsw i64 %279, %150
%281 = getelementptr inbounds double, double* %3, i64 %280
%282 = load double, double* %281
%283 = add nsw i64 %279, %151
%284 = getelementptr inbounds double, double* %3, i64 %283
store double %282, double* %284
%285 = getelementptr inbounds double, double* %4, i64 %280
%286 = load double, double* %285
%287 = fneg double %286
%288 = getelementptr inbounds double, double* %4, i64 %283
store double %287, double* %288
%289 = add nuw nsw i64 %279, 1
%290 = add nsw i64 %289, %150
%291 = getelementptr inbounds double, double* %3, i64 %290
%292 = load double, double* %291
%293 = add nsw i64 %289, %151
%294 = getelementptr inbounds double, double* %3, i64 %293
store double %292, double* %294
%295 = getelementptr inbounds double, double* %4, i64 %290
%296 = load double, double* %295
%297 = fneg double %296
%298 = getelementptr inbounds double, double* %4, i64 %293
store double %297, double* %298
%299 = add nuw nsw i64 %279, 2
%300 = icmp eq i64 %299, %41
br i1 %300, label %301, label %278
301: ; preds = %275, %278, %260, %134
%302 = phi i32 [ %135, %134 ], [ %148, %260 ], [ %148, %278 ], [ %148, %275 ]
%303 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %302, i32 %122, i32 %0)
%304 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %302, i32 %122, i32 %0)
%305 = sext i32 %303 to i64
%306 = getelementptr inbounds double, double* %3, i64 %305
%307 = getelementptr inbounds double, double* %4, i64 %305
%308 = sext i32 %304 to i64
%309 = getelementptr inbounds double, double* %1, i64 %308
%310 = getelementptr inbounds double, double* %2, i64 %308
%311 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %302, i32 %122, i32 %0, double* %309, double* %18, double* %306, double* %21)
%312 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %302, i32 %122, i32 %0, double* %310, double* %18, double* %307, double* %21)
br i1 %39, label %313, label %324
313: ; preds = %301
%314 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %122, i32 %302, i32 %0)
%315 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %122, i32 %302, i32 %0)
%316 = sext i32 %314 to i64
%317 = getelementptr inbounds double, double* %3, i64 %316
%318 = getelementptr inbounds double, double* %4, i64 %316
%319 = sext i32 %315 to i64
%320 = getelementptr inbounds double, double* %1, i64 %319
%321 = getelementptr inbounds double, double* %2, i64 %319
%322 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %122, i32 %302, i32 %0, double* %320, double* %18, double* %317, double* %21)
%323 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %122, i32 %302, i32 %0, double* %321, double* %18, double* %318, double* %21)
br label %478
324: ; preds = %301
%325 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %302, i32 %122, i32 %0)
%326 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %122, i32 %302, i32 %0)
%327 = sext i32 %325 to i64
%328 = sext i32 %326 to i64
br i1 %68, label %438, label %329
329: ; preds = %324
%330 = getelementptr double, double* %3, i64 %328
%331 = getelementptr double, double* %43, i64 %328
%332 = getelementptr double, double* %4, i64 %328
%333 = getelementptr double, double* %44, i64 %328
%334 = getelementptr double, double* %3, i64 %327
%335 = getelementptr double, double* %45, i64 %327
%336 = getelementptr double, double* %4, i64 %327
%337 = getelementptr double, double* %46, i64 %327
%338 = icmp ult double* %330, %335
%339 = icmp ult double* %334, %331
%340 = and i1 %338, %339
%341 = or i1 %71, %340
%342 = icmp ult double* %330, %337
%343 = icmp ult double* %336, %331
%344 = and i1 %342, %343
%345 = or i1 %341, %344
%346 = icmp ult double* %332, %335
%347 = icmp ult double* %334, %333
%348 = and i1 %346, %347
%349 = or i1 %345, %348
%350 = icmp ult double* %332, %337
%351 = icmp ult double* %336, %333
%352 = and i1 %350, %351
%353 = or i1 %349, %352
br i1 %353, label %438, label %354
354: ; preds = %329
br i1 %74, label %410, label %355
355: ; preds = %354, %355
%356 = phi i64 [ %407, %355 ], [ 0, %354 ]
%357 = phi i64 [ %408, %355 ], [ 0, %354 ]
%358 = add nsw i64 %356, %327
%359 = getelementptr inbounds double, double* %3, i64 %358
%360 = bitcast double* %359 to <2 x double>*
%361 = load <2 x double>, <2 x double>* %360
%362 = getelementptr inbounds double, double* %359, i64 2
%363 = bitcast double* %362 to <2 x double>*
%364 = load <2 x double>, <2 x double>* %363
%365 = add nsw i64 %356, %328
%366 = getelementptr inbounds double, double* %3, i64 %365
%367 = bitcast double* %366 to <2 x double>*
store <2 x double> %361, <2 x double>* %367
%368 = getelementptr inbounds double, double* %366, i64 2
%369 = bitcast double* %368 to <2 x double>*
store <2 x double> %364, <2 x double>* %369
%370 = getelementptr inbounds double, double* %4, i64 %358
%371 = bitcast double* %370 to <2 x double>*
%372 = load <2 x double>, <2 x double>* %371
%373 = getelementptr inbounds double, double* %370, i64 2
%374 = bitcast double* %373 to <2 x double>*
%375 = load <2 x double>, <2 x double>* %374
%376 = fneg <2 x double> %372
%377 = fneg <2 x double> %375
%378 = getelementptr inbounds double, double* %4, i64 %365
%379 = bitcast double* %378 to <2 x double>*
store <2 x double> %376, <2 x double>* %379
%380 = getelementptr inbounds double, double* %378, i64 2
%381 = bitcast double* %380 to <2 x double>*
store <2 x double> %377, <2 x double>* %381
%382 = or i64 %356, 4
%383 = add nsw i64 %382, %327
%384 = getelementptr inbounds double, double* %3, i64 %383
%385 = bitcast double* %384 to <2 x double>*
%386 = load <2 x double>, <2 x double>* %385
%387 = getelementptr inbounds double, double* %384, i64 2
%388 = bitcast double* %387 to <2 x double>*
%389 = load <2 x double>, <2 x double>* %388
%390 = add nsw i64 %382, %328
%391 = getelementptr inbounds double, double* %3, i64 %390
%392 = bitcast double* %391 to <2 x double>*
store <2 x double> %386, <2 x double>* %392
%393 = getelementptr inbounds double, double* %391, i64 2
%394 = bitcast double* %393 to <2 x double>*
store <2 x double> %389, <2 x double>* %394
%395 = getelementptr inbounds double, double* %4, i64 %383
%396 = bitcast double* %395 to <2 x double>*
%397 = load <2 x double>, <2 x double>* %396
%398 = getelementptr inbounds double, double* %395, i64 2
%399 = bitcast double* %398 to <2 x double>*
%400 = load <2 x double>, <2 x double>* %399
%401 = fneg <2 x double> %397
%402 = fneg <2 x double> %400
%403 = getelementptr inbounds double, double* %4, i64 %390
%404 = bitcast double* %403 to <2 x double>*
store <2 x double> %401, <2 x double>* %404
%405 = getelementptr inbounds double, double* %403, i64 2
%406 = bitcast double* %405 to <2 x double>*
store <2 x double> %402, <2 x double>* %406
%407 = add nuw i64 %356, 8
%408 = add i64 %357, 2
%409 = icmp eq i64 %408, %75
br i1 %409, label %410, label %355
410: ; preds = %355, %354
%411 = phi i64 [ 0, %354 ], [ %407, %355 ]
br i1 %76, label %437, label %412
412: ; preds = %410
%413 = add nsw i64 %411, %327
%414 = getelementptr inbounds double, double* %3, i64 %413
%415 = bitcast double* %414 to <2 x double>*
%416 = load <2 x double>, <2 x double>* %415
%417 = getelementptr inbounds double, double* %414, i64 2
%418 = bitcast double* %417 to <2 x double>*
%419 = load <2 x double>, <2 x double>* %418
%420 = add nsw i64 %411, %328
%421 = getelementptr inbounds double, double* %3, i64 %420
%422 = bitcast double* %421 to <2 x double>*
store <2 x double> %416, <2 x double>* %422
%423 = getelementptr inbounds double, double* %421, i64 2
%424 = bitcast double* %423 to <2 x double>*
store <2 x double> %419, <2 x double>* %424
%425 = getelementptr inbounds double, double* %4, i64 %413
%426 = bitcast double* %425 to <2 x double>*
%427 = load <2 x double>, <2 x double>* %426
%428 = getelementptr inbounds double, double* %425, i64 2
%429 = bitcast double* %428 to <2 x double>*
%430 = load <2 x double>, <2 x double>* %429
%431 = fneg <2 x double> %427
%432 = fneg <2 x double> %430
%433 = getelementptr inbounds double, double* %4, i64 %420
%434 = bitcast double* %433 to <2 x double>*
store <2 x double> %431, <2 x double>* %434
%435 = getelementptr inbounds double, double* %433, i64 2
%436 = bitcast double* %435 to <2 x double>*
store <2 x double> %432, <2 x double>* %436
br label %437
437: ; preds = %410, %412
br i1 %77, label %478, label %438
438: ; preds = %329, %324, %437
%439 = phi i64 [ 0, %329 ], [ 0, %324 ], [ %72, %437 ]
%440 = xor i64 %439, -1
br i1 %79, label %452, label %441
441: ; preds = %438
%442 = add nsw i64 %439, %327
%443 = getelementptr inbounds double, double* %3, i64 %442
%444 = load double, double* %443
%445 = add nsw i64 %439, %328
%446 = getelementptr inbounds double, double* %3, i64 %445
store double %444, double* %446
%447 = getelementptr inbounds double, double* %4, i64 %442
%448 = load double, double* %447
%449 = fneg double %448
%450 = getelementptr inbounds double, double* %4, i64 %445
store double %449, double* %450
%451 = or i64 %439, 1
br label %452
452: ; preds = %441, %438
%453 = phi i64 [ %439, %438 ], [ %451, %441 ]
%454 = icmp eq i64 %440, %80
br i1 %454, label %478, label %455
455: ; preds = %452, %455
%456 = phi i64 [ %476, %455 ], [ %453, %452 ]
%457 = add nsw i64 %456, %327
%458 = getelementptr inbounds double, double* %3, i64 %457
%459 = load double, double* %458
%460 = add nsw i64 %456, %328
%461 = getelementptr inbounds double, double* %3, i64 %460
store double %459, double* %461
%462 = getelementptr inbounds double, double* %4, i64 %457
%463 = load double, double* %462
%464 = fneg double %463
%465 = getelementptr inbounds double, double* %4, i64 %460
store double %464, double* %465
%466 = add nuw nsw i64 %456, 1
%467 = add nsw i64 %466, %327
%468 = getelementptr inbounds double, double* %3, i64 %467
%469 = load double, double* %468
%470 = add nsw i64 %466, %328
%471 = getelementptr inbounds double, double* %3, i64 %470
store double %469, double* %471
%472 = getelementptr inbounds double, double* %4, i64 %467
%473 = load double, double* %472
%474 = fneg double %473
%475 = getelementptr inbounds double, double* %4, i64 %470
store double %474, double* %475
%476 = add nuw nsw i64 %456, 2
%477 = icmp eq i64 %476, %42
br i1 %477, label %478, label %455
478: ; preds = %452, %455, %437, %313
%479 = add nuw nsw i32 %122, 1
%480 = icmp eq i32 %479, %0
br i1 %480, label %81, label %121
481: ; preds = %915
br i1 %37, label %482, label %1638
482: ; preds = %481
%483 = icmp eq i32 %7, 0
%484 = call i32 @llvm.smax.i32(i32 %9, i32 1)
%485 = zext i32 %484 to i64
%486 = zext i32 %484 to i64
%487 = zext i32 %484 to i64
%488 = zext i32 %484 to i64
%489 = getelementptr double, double* %3, i64 %41
%490 = getelementptr double, double* %4, i64 %41
%491 = getelementptr double, double* %3, i64 %41
%492 = getelementptr double, double* %4, i64 %41
%493 = getelementptr double, double* %3, i64 %41
%494 = getelementptr double, double* %4, i64 %41
%495 = getelementptr double, double* %3, i64 %41
%496 = getelementptr double, double* %4, i64 %41
%497 = getelementptr double, double* %3, i64 %41
%498 = getelementptr double, double* %4, i64 %41
%499 = getelementptr double, double* %3, i64 %41
%500 = getelementptr double, double* %4, i64 %41
%501 = getelementptr double, double* %3, i64 %41
%502 = getelementptr double, double* %4, i64 %41
%503 = getelementptr double, double* %3, i64 %41
%504 = getelementptr double, double* %4, i64 %41
%505 = icmp ult i32 %40, 4
%506 = icmp ugt double* %502, %3
%507 = icmp ugt double* %501, %4
%508 = and i1 %506, %507
%509 = and i64 %41, 2147483644
%510 = and i64 %54, 1
%511 = icmp eq i64 %52, 0
%512 = and i64 %54, 9223372036854775806
%513 = icmp eq i64 %510, 0
%514 = icmp eq i64 %509, %41
%515 = and i64 %41, 1
%516 = icmp eq i64 %515, 0
%517 = sub nsw i64 0, %41
%518 = icmp ult i32 %40, 4
%519 = icmp ugt double* %498, %3
%520 = icmp ugt double* %497, %4
%521 = and i1 %519, %520
%522 = and i64 %41, 2147483644
%523 = and i64 %54, 1
%524 = icmp eq i64 %52, 0
%525 = and i64 %54, 9223372036854775806
%526 = icmp eq i64 %523, 0
%527 = icmp eq i64 %522, %41
%528 = and i64 %41, 1
%529 = icmp eq i64 %528, 0
%530 = sub nsw i64 0, %41
%531 = icmp ult i32 %40, 4
%532 = icmp ugt double* %494, %3
%533 = icmp ugt double* %493, %4
%534 = and i1 %532, %533
%535 = and i64 %41, 2147483644
%536 = and i64 %54, 1
%537 = icmp eq i64 %52, 0
%538 = and i64 %54, 9223372036854775806
%539 = icmp eq i64 %536, 0
%540 = icmp eq i64 %535, %41
%541 = and i64 %41, 1
%542 = icmp eq i64 %541, 0
%543 = sub nsw i64 0, %41
%544 = icmp ult i32 %40, 4
%545 = icmp ugt double* %490, %3
%546 = icmp ugt double* %489, %4
%547 = and i1 %545, %546
%548 = and i64 %41, 2147483644
%549 = and i64 %54, 1
%550 = icmp eq i64 %52, 0
%551 = and i64 %54, 9223372036854775806
%552 = icmp eq i64 %549, 0
%553 = icmp eq i64 %548, %41
%554 = and i64 %41, 1
%555 = icmp eq i64 %554, 0
%556 = sub nsw i64 0, %41
br label %920
557: ; preds = %82, %915
%558 = phi i32 [ 1, %82 ], [ %916, %915 ]
%559 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @genWigTrans_L2 to i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...)*)(i32 %558, i32 0, i32 %0, double* %6, double* %15, double* %16, double* %17, double* %18, double* %21)
%560 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %558, i32 0, i32 %0)
%561 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %558, i32 0, i32 %0)
%562 = sext i32 %560 to i64
%563 = getelementptr inbounds double, double* %3, i64 %562
%564 = getelementptr inbounds double, double* %4, i64 %562
%565 = sext i32 %561 to i64
%566 = getelementptr inbounds double, double* %1, i64 %565
%567 = getelementptr inbounds double, double* %2, i64 %565
%568 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %558, i32 0, i32 %0, double* %566, double* %18, double* %563, double* %21)
%569 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %558, i32 0, i32 %0, double* %567, double* %18, double* %564, double* %21)
br i1 %83, label %570, label %582
570: ; preds = %557
%571 = sub nsw i32 0, %558
%572 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %571, i32 0, i32 %0)
%573 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %571, i32 0, i32 %0)
%574 = sext i32 %572 to i64
%575 = getelementptr inbounds double, double* %3, i64 %574
%576 = getelementptr inbounds double, double* %4, i64 %574
%577 = sext i32 %573 to i64
%578 = getelementptr inbounds double, double* %1, i64 %577
%579 = getelementptr inbounds double, double* %2, i64 %577
%580 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %571, i32 0, i32 %0, double* %578, double* %18, double* %575, double* %21)
%581 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %571, i32 0, i32 %0, double* %579, double* %18, double* %576, double* %21)
br label %737
582: ; preds = %557
%583 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %558, i32 0, i32 %0)
%584 = sub nsw i32 0, %558
%585 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %584, i32 0, i32 %0)
%586 = sext i32 %583 to i64
%587 = sext i32 %585 to i64
br i1 %95, label %697, label %588
588: ; preds = %582
%589 = getelementptr double, double* %3, i64 %587
%590 = getelementptr double, double* %91, i64 %587
%591 = getelementptr double, double* %4, i64 %587
%592 = getelementptr double, double* %92, i64 %587
%593 = getelementptr double, double* %3, i64 %586
%594 = getelementptr double, double* %93, i64 %586
%595 = getelementptr double, double* %4, i64 %586
%596 = getelementptr double, double* %94, i64 %586
%597 = icmp ult double* %589, %594
%598 = icmp ult double* %593, %590
%599 = and i1 %597, %598
%600 = or i1 %98, %599
%601 = icmp ult double* %589, %596
%602 = icmp ult double* %595, %590
%603 = and i1 %601, %602
%604 = or i1 %600, %603
%605 = icmp ult double* %591, %594
%606 = icmp ult double* %593, %592
%607 = and i1 %605, %606
%608 = or i1 %604, %607
%609 = icmp ult double* %591, %596
%610 = icmp ult double* %595, %592
%611 = and i1 %609, %610
%612 = or i1 %608, %611
br i1 %612, label %697, label %613
613: ; preds = %588
br i1 %101, label %669, label %614
614: ; preds = %613, %614
%615 = phi i64 [ %666, %614 ], [ 0, %613 ]
%616 = phi i64 [ %667, %614 ], [ 0, %613 ]
%617 = add nsw i64 %615, %586
%618 = getelementptr inbounds double, double* %3, i64 %617
%619 = bitcast double* %618 to <2 x double>*
%620 = load <2 x double>, <2 x double>* %619
%621 = getelementptr inbounds double, double* %618, i64 2
%622 = bitcast double* %621 to <2 x double>*
%623 = load <2 x double>, <2 x double>* %622
%624 = add nsw i64 %615, %587
%625 = getelementptr inbounds double, double* %3, i64 %624
%626 = bitcast double* %625 to <2 x double>*
store <2 x double> %620, <2 x double>* %626
%627 = getelementptr inbounds double, double* %625, i64 2
%628 = bitcast double* %627 to <2 x double>*
store <2 x double> %623, <2 x double>* %628
%629 = getelementptr inbounds double, double* %4, i64 %617
%630 = bitcast double* %629 to <2 x double>*
%631 = load <2 x double>, <2 x double>* %630
%632 = getelementptr inbounds double, double* %629, i64 2
%633 = bitcast double* %632 to <2 x double>*
%634 = load <2 x double>, <2 x double>* %633
%635 = fneg <2 x double> %631
%636 = fneg <2 x double> %634
%637 = getelementptr inbounds double, double* %4, i64 %624
%638 = bitcast double* %637 to <2 x double>*
store <2 x double> %635, <2 x double>* %638
%639 = getelementptr inbounds double, double* %637, i64 2
%640 = bitcast double* %639 to <2 x double>*
store <2 x double> %636, <2 x double>* %640
%641 = or i64 %615, 4
%642 = add nsw i64 %641, %586
%643 = getelementptr inbounds double, double* %3, i64 %642
%644 = bitcast double* %643 to <2 x double>*
%645 = load <2 x double>, <2 x double>* %644
%646 = getelementptr inbounds double, double* %643, i64 2
%647 = bitcast double* %646 to <2 x double>*
%648 = load <2 x double>, <2 x double>* %647
%649 = add nsw i64 %641, %587
%650 = getelementptr inbounds double, double* %3, i64 %649
%651 = bitcast double* %650 to <2 x double>*
store <2 x double> %645, <2 x double>* %651
%652 = getelementptr inbounds double, double* %650, i64 2
%653 = bitcast double* %652 to <2 x double>*
store <2 x double> %648, <2 x double>* %653
%654 = getelementptr inbounds double, double* %4, i64 %642
%655 = bitcast double* %654 to <2 x double>*
%656 = load <2 x double>, <2 x double>* %655
%657 = getelementptr inbounds double, double* %654, i64 2
%658 = bitcast double* %657 to <2 x double>*
%659 = load <2 x double>, <2 x double>* %658
%660 = fneg <2 x double> %656
%661 = fneg <2 x double> %659
%662 = getelementptr inbounds double, double* %4, i64 %649
%663 = bitcast double* %662 to <2 x double>*
store <2 x double> %660, <2 x double>* %663
%664 = getelementptr inbounds double, double* %662, i64 2
%665 = bitcast double* %664 to <2 x double>*
store <2 x double> %661, <2 x double>* %665
%666 = add nuw i64 %615, 8
%667 = add i64 %616, 2
%668 = icmp eq i64 %667, %102
br i1 %668, label %669, label %614
669: ; preds = %614, %613
%670 = phi i64 [ 0, %613 ], [ %666, %614 ]
br i1 %103, label %696, label %671
671: ; preds = %669
%672 = add nsw i64 %670, %586
%673 = getelementptr inbounds double, double* %3, i64 %672
%674 = bitcast double* %673 to <2 x double>*
%675 = load <2 x double>, <2 x double>* %674
%676 = getelementptr inbounds double, double* %673, i64 2
%677 = bitcast double* %676 to <2 x double>*
%678 = load <2 x double>, <2 x double>* %677
%679 = add nsw i64 %670, %587
%680 = getelementptr inbounds double, double* %3, i64 %679
%681 = bitcast double* %680 to <2 x double>*
store <2 x double> %675, <2 x double>* %681
%682 = getelementptr inbounds double, double* %680, i64 2
%683 = bitcast double* %682 to <2 x double>*
store <2 x double> %678, <2 x double>* %683
%684 = getelementptr inbounds double, double* %4, i64 %672
%685 = bitcast double* %684 to <2 x double>*
%686 = load <2 x double>, <2 x double>* %685
%687 = getelementptr inbounds double, double* %684, i64 2
%688 = bitcast double* %687 to <2 x double>*
%689 = load <2 x double>, <2 x double>* %688
%690 = fneg <2 x double> %686
%691 = fneg <2 x double> %689
%692 = getelementptr inbounds double, double* %4, i64 %679
%693 = bitcast double* %692 to <2 x double>*
store <2 x double> %690, <2 x double>* %693
%694 = getelementptr inbounds double, double* %692, i64 2
%695 = bitcast double* %694 to <2 x double>*
store <2 x double> %691, <2 x double>* %695
br label %696
696: ; preds = %669, %671
br i1 %104, label %737, label %697
697: ; preds = %588, %582, %696
%698 = phi i64 [ 0, %588 ], [ 0, %582 ], [ %99, %696 ]
%699 = xor i64 %698, -1
br i1 %106, label %711, label %700
700: ; preds = %697
%701 = add nsw i64 %698, %586
%702 = getelementptr inbounds double, double* %3, i64 %701
%703 = load double, double* %702
%704 = add nsw i64 %698, %587
%705 = getelementptr inbounds double, double* %3, i64 %704
store double %703, double* %705
%706 = getelementptr inbounds double, double* %4, i64 %701
%707 = load double, double* %706
%708 = fneg double %707
%709 = getelementptr inbounds double, double* %4, i64 %704
store double %708, double* %709
%710 = or i64 %698, 1
br label %711
711: ; preds = %700, %697
%712 = phi i64 [ %698, %697 ], [ %710, %700 ]
%713 = icmp eq i64 %699, %107
br i1 %713, label %737, label %714
714: ; preds = %711, %714
%715 = phi i64 [ %735, %714 ], [ %712, %711 ]
%716 = add nsw i64 %715, %586
%717 = getelementptr inbounds double, double* %3, i64 %716
%718 = load double, double* %717
%719 = add nsw i64 %715, %587
%720 = getelementptr inbounds double, double* %3, i64 %719
store double %718, double* %720
%721 = getelementptr inbounds double, double* %4, i64 %716
%722 = load double, double* %721
%723 = fneg double %722
%724 = getelementptr inbounds double, double* %4, i64 %719
store double %723, double* %724
%725 = add nuw nsw i64 %715, 1
%726 = add nsw i64 %725, %586
%727 = getelementptr inbounds double, double* %3, i64 %726
%728 = load double, double* %727
%729 = add nsw i64 %725, %587
%730 = getelementptr inbounds double, double* %3, i64 %729
store double %728, double* %730
%731 = getelementptr inbounds double, double* %4, i64 %726
%732 = load double, double* %731
%733 = fneg double %732
%734 = getelementptr inbounds double, double* %4, i64 %729
store double %733, double* %734
%735 = add nuw nsw i64 %715, 2
%736 = icmp eq i64 %735, %85
br i1 %736, label %737, label %714
737: ; preds = %711, %714, %696, %570
%738 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %558, i32 %0)
%739 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %558, i32 %0)
%740 = sext i32 %738 to i64
%741 = getelementptr inbounds double, double* %3, i64 %740
%742 = getelementptr inbounds double, double* %4, i64 %740
%743 = sext i32 %739 to i64
%744 = getelementptr inbounds double, double* %1, i64 %743
%745 = getelementptr inbounds double, double* %2, i64 %743
%746 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 %558, i32 %0, double* %744, double* %18, double* %741, double* %21)
%747 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 %558, i32 %0, double* %745, double* %18, double* %742, double* %21)
br i1 %83, label %748, label %760
748: ; preds = %737
%749 = sub nsw i32 0, %558
%750 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %749, i32 %0)
%751 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %749, i32 %0)
%752 = sext i32 %750 to i64
%753 = getelementptr inbounds double, double* %3, i64 %752
%754 = getelementptr inbounds double, double* %4, i64 %752
%755 = sext i32 %751 to i64
%756 = getelementptr inbounds double, double* %1, i64 %755
%757 = getelementptr inbounds double, double* %2, i64 %755
%758 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 %749, i32 %0, double* %756, double* %18, double* %753, double* %21)
%759 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 0, i32 %749, i32 %0, double* %757, double* %18, double* %754, double* %21)
br label %915
760: ; preds = %737
%761 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %558, i32 %0)
%762 = sub nsw i32 0, %558
%763 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 0, i32 %762, i32 %0)
%764 = sext i32 %761 to i64
%765 = sext i32 %763 to i64
br i1 %108, label %875, label %766
766: ; preds = %760
%767 = getelementptr double, double* %3, i64 %765
%768 = getelementptr double, double* %87, i64 %765
%769 = getelementptr double, double* %4, i64 %765
%770 = getelementptr double, double* %88, i64 %765
%771 = getelementptr double, double* %3, i64 %764
%772 = getelementptr double, double* %89, i64 %764
%773 = getelementptr double, double* %4, i64 %764
%774 = getelementptr double, double* %90, i64 %764
%775 = icmp ult double* %767, %772
%776 = icmp ult double* %771, %768
%777 = and i1 %775, %776
%778 = or i1 %111, %777
%779 = icmp ult double* %767, %774
%780 = icmp ult double* %773, %768
%781 = and i1 %779, %780
%782 = or i1 %778, %781
%783 = icmp ult double* %769, %772
%784 = icmp ult double* %771, %770
%785 = and i1 %783, %784
%786 = or i1 %782, %785
%787 = icmp ult double* %769, %774
%788 = icmp ult double* %773, %770
%789 = and i1 %787, %788
%790 = or i1 %786, %789
br i1 %790, label %875, label %791
791: ; preds = %766
br i1 %114, label %847, label %792
792: ; preds = %791, %792
%793 = phi i64 [ %844, %792 ], [ 0, %791 ]
%794 = phi i64 [ %845, %792 ], [ 0, %791 ]
%795 = add nsw i64 %793, %764
%796 = getelementptr inbounds double, double* %3, i64 %795
%797 = bitcast double* %796 to <2 x double>*
%798 = load <2 x double>, <2 x double>* %797
%799 = getelementptr inbounds double, double* %796, i64 2
%800 = bitcast double* %799 to <2 x double>*
%801 = load <2 x double>, <2 x double>* %800
%802 = add nsw i64 %793, %765
%803 = getelementptr inbounds double, double* %3, i64 %802
%804 = bitcast double* %803 to <2 x double>*
store <2 x double> %798, <2 x double>* %804
%805 = getelementptr inbounds double, double* %803, i64 2
%806 = bitcast double* %805 to <2 x double>*
store <2 x double> %801, <2 x double>* %806
%807 = getelementptr inbounds double, double* %4, i64 %795
%808 = bitcast double* %807 to <2 x double>*
%809 = load <2 x double>, <2 x double>* %808
%810 = getelementptr inbounds double, double* %807, i64 2
%811 = bitcast double* %810 to <2 x double>*
%812 = load <2 x double>, <2 x double>* %811
%813 = fneg <2 x double> %809
%814 = fneg <2 x double> %812
%815 = getelementptr inbounds double, double* %4, i64 %802
%816 = bitcast double* %815 to <2 x double>*
store <2 x double> %813, <2 x double>* %816
%817 = getelementptr inbounds double, double* %815, i64 2
%818 = bitcast double* %817 to <2 x double>*
store <2 x double> %814, <2 x double>* %818
%819 = or i64 %793, 4
%820 = add nsw i64 %819, %764
%821 = getelementptr inbounds double, double* %3, i64 %820
%822 = bitcast double* %821 to <2 x double>*
%823 = load <2 x double>, <2 x double>* %822
%824 = getelementptr inbounds double, double* %821, i64 2
%825 = bitcast double* %824 to <2 x double>*
%826 = load <2 x double>, <2 x double>* %825
%827 = add nsw i64 %819, %765
%828 = getelementptr inbounds double, double* %3, i64 %827
%829 = bitcast double* %828 to <2 x double>*
store <2 x double> %823, <2 x double>* %829
%830 = getelementptr inbounds double, double* %828, i64 2
%831 = bitcast double* %830 to <2 x double>*
store <2 x double> %826, <2 x double>* %831
%832 = getelementptr inbounds double, double* %4, i64 %820
%833 = bitcast double* %832 to <2 x double>*
%834 = load <2 x double>, <2 x double>* %833
%835 = getelementptr inbounds double, double* %832, i64 2
%836 = bitcast double* %835 to <2 x double>*
%837 = load <2 x double>, <2 x double>* %836
%838 = fneg <2 x double> %834
%839 = fneg <2 x double> %837
%840 = getelementptr inbounds double, double* %4, i64 %827
%841 = bitcast double* %840 to <2 x double>*
store <2 x double> %838, <2 x double>* %841
%842 = getelementptr inbounds double, double* %840, i64 2
%843 = bitcast double* %842 to <2 x double>*
store <2 x double> %839, <2 x double>* %843
%844 = add nuw i64 %793, 8
%845 = add i64 %794, 2
%846 = icmp eq i64 %845, %115
br i1 %846, label %847, label %792
847: ; preds = %792, %791
%848 = phi i64 [ 0, %791 ], [ %844, %792 ]
br i1 %116, label %874, label %849
849: ; preds = %847
%850 = add nsw i64 %848, %764
%851 = getelementptr inbounds double, double* %3, i64 %850
%852 = bitcast double* %851 to <2 x double>*
%853 = load <2 x double>, <2 x double>* %852
%854 = getelementptr inbounds double, double* %851, i64 2
%855 = bitcast double* %854 to <2 x double>*
%856 = load <2 x double>, <2 x double>* %855
%857 = add nsw i64 %848, %765
%858 = getelementptr inbounds double, double* %3, i64 %857
%859 = bitcast double* %858 to <2 x double>*
store <2 x double> %853, <2 x double>* %859
%860 = getelementptr inbounds double, double* %858, i64 2
%861 = bitcast double* %860 to <2 x double>*
store <2 x double> %856, <2 x double>* %861
%862 = getelementptr inbounds double, double* %4, i64 %850
%863 = bitcast double* %862 to <2 x double>*
%864 = load <2 x double>, <2 x double>* %863
%865 = getelementptr inbounds double, double* %862, i64 2
%866 = bitcast double* %865 to <2 x double>*
%867 = load <2 x double>, <2 x double>* %866
%868 = fneg <2 x double> %864
%869 = fneg <2 x double> %867
%870 = getelementptr inbounds double, double* %4, i64 %857
%871 = bitcast double* %870 to <2 x double>*
store <2 x double> %868, <2 x double>* %871
%872 = getelementptr inbounds double, double* %870, i64 2
%873 = bitcast double* %872 to <2 x double>*
store <2 x double> %869, <2 x double>* %873
br label %874
874: ; preds = %847, %849
br i1 %117, label %915, label %875
875: ; preds = %766, %760, %874
%876 = phi i64 [ 0, %766 ], [ 0, %760 ], [ %112, %874 ]
%877 = xor i64 %876, -1
br i1 %119, label %889, label %878
878: ; preds = %875
%879 = add nsw i64 %876, %764
%880 = getelementptr inbounds double, double* %3, i64 %879
%881 = load double, double* %880
%882 = add nsw i64 %876, %765
%883 = getelementptr inbounds double, double* %3, i64 %882
store double %881, double* %883
%884 = getelementptr inbounds double, double* %4, i64 %879
%885 = load double, double* %884
%886 = fneg double %885
%887 = getelementptr inbounds double, double* %4, i64 %882
store double %886, double* %887
%888 = or i64 %876, 1
br label %889
889: ; preds = %878, %875
%890 = phi i64 [ %876, %875 ], [ %888, %878 ]
%891 = icmp eq i64 %877, %120
br i1 %891, label %915, label %892
892: ; preds = %889, %892
%893 = phi i64 [ %913, %892 ], [ %890, %889 ]
%894 = add nsw i64 %893, %764
%895 = getelementptr inbounds double, double* %3, i64 %894
%896 = load double, double* %895
%897 = add nsw i64 %893, %765
%898 = getelementptr inbounds double, double* %3, i64 %897
store double %896, double* %898
%899 = getelementptr inbounds double, double* %4, i64 %894
%900 = load double, double* %899
%901 = fneg double %900
%902 = getelementptr inbounds double, double* %4, i64 %897
store double %901, double* %902
%903 = add nuw nsw i64 %893, 1
%904 = add nsw i64 %903, %764
%905 = getelementptr inbounds double, double* %3, i64 %904
%906 = load double, double* %905
%907 = add nsw i64 %903, %765
%908 = getelementptr inbounds double, double* %3, i64 %907
store double %906, double* %908
%909 = getelementptr inbounds double, double* %4, i64 %904
%910 = load double, double* %909
%911 = fneg double %910
%912 = getelementptr inbounds double, double* %4, i64 %907
store double %911, double* %912
%913 = add nuw nsw i64 %893, 2
%914 = icmp eq i64 %913, %86
br i1 %914, label %915, label %892
915: ; preds = %889, %892, %874, %748
%916 = add nuw nsw i32 %558, 1
%917 = icmp eq i32 %916, %0
br i1 %917, label %481, label %557
918: ; preds = %1635, %920
%919 = icmp eq i32 %922, %0
br i1 %919, label %1638, label %920
920: ; preds = %482, %918
%921 = phi i32 [ 1, %482 ], [ %922, %918 ]
%922 = add nuw nsw i32 %921, 1
%923 = icmp slt i32 %922, %0
br i1 %923, label %924, label %918
924: ; preds = %920
%925 = sub nsw i32 0, %921
br label %926
926: ; preds = %924, %1635
%927 = phi i32 [ %922, %924 ], [ %1636, %1635 ]
%928 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...) bitcast (i32 (...)* @genWigTrans_L2 to i32 (i32, i32, i32, double*, double*, double*, double*, double*, double*, ...)*)(i32 %921, i32 %927, i32 %0, double* %6, double* %15, double* %16, double* %17, double* %18, double* %21)
%929 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %921, i32 %927, i32 %0)
%930 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %921, i32 %927, i32 %0)
%931 = sext i32 %929 to i64
%932 = getelementptr inbounds double, double* %3, i64 %931
%933 = getelementptr inbounds double, double* %4, i64 %931
%934 = sext i32 %930 to i64
%935 = getelementptr inbounds double, double* %1, i64 %934
%936 = getelementptr inbounds double, double* %2, i64 %934
%937 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %921, i32 %927, i32 %0, double* %935, double* %18, double* %932, double* %21)
%938 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %921, i32 %927, i32 %0, double* %936, double* %18, double* %933, double* %21)
br i1 %483, label %939, label %951
939: ; preds = %926
%940 = sub nsw i32 0, %927
%941 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %925, i32 %940, i32 %0)
%942 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %925, i32 %940, i32 %0)
%943 = sext i32 %941 to i64
%944 = getelementptr inbounds double, double* %3, i64 %943
%945 = getelementptr inbounds double, double* %4, i64 %943
%946 = sext i32 %942 to i64
%947 = getelementptr inbounds double, double* %1, i64 %946
%948 = getelementptr inbounds double, double* %2, i64 %946
%949 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %925, i32 %940, i32 %0, double* %947, double* %18, double* %944, double* %21)
%950 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %925, i32 %940, i32 %0, double* %948, double* %18, double* %945, double* %21)
br label %1106
951: ; preds = %926
%952 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %921, i32 %927, i32 %0)
%953 = sub nsw i32 0, %927
%954 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %925, i32 %953, i32 %0)
%955 = sext i32 %952 to i64
%956 = sext i32 %954 to i64
br i1 %505, label %1066, label %957
957: ; preds = %951
%958 = getelementptr double, double* %3, i64 %956
%959 = getelementptr double, double* %501, i64 %956
%960 = getelementptr double, double* %4, i64 %956
%961 = getelementptr double, double* %502, i64 %956
%962 = getelementptr double, double* %3, i64 %955
%963 = getelementptr double, double* %503, i64 %955
%964 = getelementptr double, double* %4, i64 %955
%965 = getelementptr double, double* %504, i64 %955
%966 = icmp ult double* %958, %963
%967 = icmp ult double* %962, %959
%968 = and i1 %966, %967
%969 = or i1 %508, %968
%970 = icmp ult double* %958, %965
%971 = icmp ult double* %964, %959
%972 = and i1 %970, %971
%973 = or i1 %969, %972
%974 = icmp ult double* %960, %963
%975 = icmp ult double* %962, %961
%976 = and i1 %974, %975
%977 = or i1 %973, %976
%978 = icmp ult double* %960, %965
%979 = icmp ult double* %964, %961
%980 = and i1 %978, %979
%981 = or i1 %977, %980
br i1 %981, label %1066, label %982
982: ; preds = %957
br i1 %511, label %1038, label %983
983: ; preds = %982, %983
%984 = phi i64 [ %1035, %983 ], [ 0, %982 ]
%985 = phi i64 [ %1036, %983 ], [ 0, %982 ]
%986 = add nsw i64 %984, %955
%987 = getelementptr inbounds double, double* %3, i64 %986
%988 = bitcast double* %987 to <2 x double>*
%989 = load <2 x double>, <2 x double>* %988
%990 = getelementptr inbounds double, double* %987, i64 2
%991 = bitcast double* %990 to <2 x double>*
%992 = load <2 x double>, <2 x double>* %991
%993 = add nsw i64 %984, %956
%994 = getelementptr inbounds double, double* %3, i64 %993
%995 = bitcast double* %994 to <2 x double>*
store <2 x double> %989, <2 x double>* %995
%996 = getelementptr inbounds double, double* %994, i64 2
%997 = bitcast double* %996 to <2 x double>*
store <2 x double> %992, <2 x double>* %997
%998 = getelementptr inbounds double, double* %4, i64 %986
%999 = bitcast double* %998 to <2 x double>*
%1000 = load <2 x double>, <2 x double>* %999
%1001 = getelementptr inbounds double, double* %998, i64 2
%1002 = bitcast double* %1001 to <2 x double>*
%1003 = load <2 x double>, <2 x double>* %1002
%1004 = fneg <2 x double> %1000
%1005 = fneg <2 x double> %1003
%1006 = getelementptr inbounds double, double* %4, i64 %993
%1007 = bitcast double* %1006 to <2 x double>*
store <2 x double> %1004, <2 x double>* %1007
%1008 = getelementptr inbounds double, double* %1006, i64 2
%1009 = bitcast double* %1008 to <2 x double>*
store <2 x double> %1005, <2 x double>* %1009
%1010 = or i64 %984, 4
%1011 = add nsw i64 %1010, %955
%1012 = getelementptr inbounds double, double* %3, i64 %1011
%1013 = bitcast double* %1012 to <2 x double>*
%1014 = load <2 x double>, <2 x double>* %1013
%1015 = getelementptr inbounds double, double* %1012, i64 2
%1016 = bitcast double* %1015 to <2 x double>*
%1017 = load <2 x double>, <2 x double>* %1016
%1018 = add nsw i64 %1010, %956
%1019 = getelementptr inbounds double, double* %3, i64 %1018
%1020 = bitcast double* %1019 to <2 x double>*
store <2 x double> %1014, <2 x double>* %1020
%1021 = getelementptr inbounds double, double* %1019, i64 2
%1022 = bitcast double* %1021 to <2 x double>*
store <2 x double> %1017, <2 x double>* %1022
%1023 = getelementptr inbounds double, double* %4, i64 %1011
%1024 = bitcast double* %1023 to <2 x double>*
%1025 = load <2 x double>, <2 x double>* %1024
%1026 = getelementptr inbounds double, double* %1023, i64 2
%1027 = bitcast double* %1026 to <2 x double>*
%1028 = load <2 x double>, <2 x double>* %1027
%1029 = fneg <2 x double> %1025
%1030 = fneg <2 x double> %1028
%1031 = getelementptr inbounds double, double* %4, i64 %1018
%1032 = bitcast double* %1031 to <2 x double>*
store <2 x double> %1029, <2 x double>* %1032
%1033 = getelementptr inbounds double, double* %1031, i64 2
%1034 = bitcast double* %1033 to <2 x double>*
store <2 x double> %1030, <2 x double>* %1034
%1035 = add nuw i64 %984, 8
%1036 = add i64 %985, 2
%1037 = icmp eq i64 %1036, %512
br i1 %1037, label %1038, label %983
1038: ; preds = %983, %982
%1039 = phi i64 [ 0, %982 ], [ %1035, %983 ]
br i1 %513, label %1065, label %1040
1040: ; preds = %1038
%1041 = add nsw i64 %1039, %955
%1042 = getelementptr inbounds double, double* %3, i64 %1041
%1043 = bitcast double* %1042 to <2 x double>*
%1044 = load <2 x double>, <2 x double>* %1043
%1045 = getelementptr inbounds double, double* %1042, i64 2
%1046 = bitcast double* %1045 to <2 x double>*
%1047 = load <2 x double>, <2 x double>* %1046
%1048 = add nsw i64 %1039, %956
%1049 = getelementptr inbounds double, double* %3, i64 %1048
%1050 = bitcast double* %1049 to <2 x double>*
store <2 x double> %1044, <2 x double>* %1050
%1051 = getelementptr inbounds double, double* %1049, i64 2
%1052 = bitcast double* %1051 to <2 x double>*
store <2 x double> %1047, <2 x double>* %1052
%1053 = getelementptr inbounds double, double* %4, i64 %1041
%1054 = bitcast double* %1053 to <2 x double>*
%1055 = load <2 x double>, <2 x double>* %1054
%1056 = getelementptr inbounds double, double* %1053, i64 2
%1057 = bitcast double* %1056 to <2 x double>*
%1058 = load <2 x double>, <2 x double>* %1057
%1059 = fneg <2 x double> %1055
%1060 = fneg <2 x double> %1058
%1061 = getelementptr inbounds double, double* %4, i64 %1048
%1062 = bitcast double* %1061 to <2 x double>*
store <2 x double> %1059, <2 x double>* %1062
%1063 = getelementptr inbounds double, double* %1061, i64 2
%1064 = bitcast double* %1063 to <2 x double>*
store <2 x double> %1060, <2 x double>* %1064
br label %1065
1065: ; preds = %1038, %1040
br i1 %514, label %1106, label %1066
1066: ; preds = %957, %951, %1065
%1067 = phi i64 [ 0, %957 ], [ 0, %951 ], [ %509, %1065 ]
%1068 = xor i64 %1067, -1
br i1 %516, label %1080, label %1069
1069: ; preds = %1066
%1070 = add nsw i64 %1067, %955
%1071 = getelementptr inbounds double, double* %3, i64 %1070
%1072 = load double, double* %1071
%1073 = add nsw i64 %1067, %956
%1074 = getelementptr inbounds double, double* %3, i64 %1073
store double %1072, double* %1074
%1075 = getelementptr inbounds double, double* %4, i64 %1070
%1076 = load double, double* %1075
%1077 = fneg double %1076
%1078 = getelementptr inbounds double, double* %4, i64 %1073
store double %1077, double* %1078
%1079 = or i64 %1067, 1
br label %1080
1080: ; preds = %1069, %1066
%1081 = phi i64 [ %1067, %1066 ], [ %1079, %1069 ]
%1082 = icmp eq i64 %1068, %517
br i1 %1082, label %1106, label %1083
1083: ; preds = %1080, %1083
%1084 = phi i64 [ %1104, %1083 ], [ %1081, %1080 ]
%1085 = add nsw i64 %1084, %955
%1086 = getelementptr inbounds double, double* %3, i64 %1085
%1087 = load double, double* %1086
%1088 = add nsw i64 %1084, %956
%1089 = getelementptr inbounds double, double* %3, i64 %1088
store double %1087, double* %1089
%1090 = getelementptr inbounds double, double* %4, i64 %1085
%1091 = load double, double* %1090
%1092 = fneg double %1091
%1093 = getelementptr inbounds double, double* %4, i64 %1088
store double %1092, double* %1093
%1094 = add nuw nsw i64 %1084, 1
%1095 = add nsw i64 %1094, %955
%1096 = getelementptr inbounds double, double* %3, i64 %1095
%1097 = load double, double* %1096
%1098 = add nsw i64 %1094, %956
%1099 = getelementptr inbounds double, double* %3, i64 %1098
store double %1097, double* %1099
%1100 = getelementptr inbounds double, double* %4, i64 %1095
%1101 = load double, double* %1100
%1102 = fneg double %1101
%1103 = getelementptr inbounds double, double* %4, i64 %1098
store double %1102, double* %1103
%1104 = add nuw nsw i64 %1084, 2
%1105 = icmp eq i64 %1104, %485
br i1 %1105, label %1106, label %1083
1106: ; preds = %1080, %1083, %1065, %939
%1107 = phi i32 [ %940, %939 ], [ %953, %1065 ], [ %953, %1083 ], [ %953, %1080 ]
%1108 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %921, i32 %1107, i32 %0)
%1109 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %921, i32 %1107, i32 %0)
%1110 = sext i32 %1108 to i64
%1111 = getelementptr inbounds double, double* %3, i64 %1110
%1112 = getelementptr inbounds double, double* %4, i64 %1110
%1113 = sext i32 %1109 to i64
%1114 = getelementptr inbounds double, double* %1, i64 %1113
%1115 = getelementptr inbounds double, double* %2, i64 %1113
%1116 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %921, i32 %1107, i32 %0, double* %1114, double* %18, double* %1111, double* %21)
%1117 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %921, i32 %1107, i32 %0, double* %1115, double* %18, double* %1112, double* %21)
br i1 %483, label %1118, label %1129
1118: ; preds = %1106
%1119 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %925, i32 %927, i32 %0)
%1120 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %925, i32 %927, i32 %0)
%1121 = sext i32 %1119 to i64
%1122 = getelementptr inbounds double, double* %3, i64 %1121
%1123 = getelementptr inbounds double, double* %4, i64 %1121
%1124 = sext i32 %1120 to i64
%1125 = getelementptr inbounds double, double* %1, i64 %1124
%1126 = getelementptr inbounds double, double* %2, i64 %1124
%1127 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %925, i32 %927, i32 %0, double* %1125, double* %18, double* %1122, double* %21)
%1128 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %925, i32 %927, i32 %0, double* %1126, double* %18, double* %1123, double* %21)
br label %1283
1129: ; preds = %1106
%1130 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %921, i32 %1107, i32 %0)
%1131 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %925, i32 %927, i32 %0)
%1132 = sext i32 %1130 to i64
%1133 = sext i32 %1131 to i64
br i1 %518, label %1243, label %1134
1134: ; preds = %1129
%1135 = getelementptr double, double* %3, i64 %1133
%1136 = getelementptr double, double* %497, i64 %1133
%1137 = getelementptr double, double* %4, i64 %1133
%1138 = getelementptr double, double* %498, i64 %1133
%1139 = getelementptr double, double* %3, i64 %1132
%1140 = getelementptr double, double* %499, i64 %1132
%1141 = getelementptr double, double* %4, i64 %1132
%1142 = getelementptr double, double* %500, i64 %1132
%1143 = icmp ult double* %1135, %1140
%1144 = icmp ult double* %1139, %1136
%1145 = and i1 %1143, %1144
%1146 = or i1 %521, %1145
%1147 = icmp ult double* %1135, %1142
%1148 = icmp ult double* %1141, %1136
%1149 = and i1 %1147, %1148
%1150 = or i1 %1146, %1149
%1151 = icmp ult double* %1137, %1140
%1152 = icmp ult double* %1139, %1138
%1153 = and i1 %1151, %1152
%1154 = or i1 %1150, %1153
%1155 = icmp ult double* %1137, %1142
%1156 = icmp ult double* %1141, %1138
%1157 = and i1 %1155, %1156
%1158 = or i1 %1154, %1157
br i1 %1158, label %1243, label %1159
1159: ; preds = %1134
br i1 %524, label %1215, label %1160
1160: ; preds = %1159, %1160
%1161 = phi i64 [ %1212, %1160 ], [ 0, %1159 ]
%1162 = phi i64 [ %1213, %1160 ], [ 0, %1159 ]
%1163 = add nsw i64 %1161, %1132
%1164 = getelementptr inbounds double, double* %3, i64 %1163
%1165 = bitcast double* %1164 to <2 x double>*
%1166 = load <2 x double>, <2 x double>* %1165
%1167 = getelementptr inbounds double, double* %1164, i64 2
%1168 = bitcast double* %1167 to <2 x double>*
%1169 = load <2 x double>, <2 x double>* %1168
%1170 = add nsw i64 %1161, %1133
%1171 = getelementptr inbounds double, double* %3, i64 %1170
%1172 = bitcast double* %1171 to <2 x double>*
store <2 x double> %1166, <2 x double>* %1172
%1173 = getelementptr inbounds double, double* %1171, i64 2
%1174 = bitcast double* %1173 to <2 x double>*
store <2 x double> %1169, <2 x double>* %1174
%1175 = getelementptr inbounds double, double* %4, i64 %1163
%1176 = bitcast double* %1175 to <2 x double>*
%1177 = load <2 x double>, <2 x double>* %1176
%1178 = getelementptr inbounds double, double* %1175, i64 2
%1179 = bitcast double* %1178 to <2 x double>*
%1180 = load <2 x double>, <2 x double>* %1179
%1181 = fneg <2 x double> %1177
%1182 = fneg <2 x double> %1180
%1183 = getelementptr inbounds double, double* %4, i64 %1170
%1184 = bitcast double* %1183 to <2 x double>*
store <2 x double> %1181, <2 x double>* %1184
%1185 = getelementptr inbounds double, double* %1183, i64 2
%1186 = bitcast double* %1185 to <2 x double>*
store <2 x double> %1182, <2 x double>* %1186
%1187 = or i64 %1161, 4
%1188 = add nsw i64 %1187, %1132
%1189 = getelementptr inbounds double, double* %3, i64 %1188
%1190 = bitcast double* %1189 to <2 x double>*
%1191 = load <2 x double>, <2 x double>* %1190
%1192 = getelementptr inbounds double, double* %1189, i64 2
%1193 = bitcast double* %1192 to <2 x double>*
%1194 = load <2 x double>, <2 x double>* %1193
%1195 = add nsw i64 %1187, %1133
%1196 = getelementptr inbounds double, double* %3, i64 %1195
%1197 = bitcast double* %1196 to <2 x double>*
store <2 x double> %1191, <2 x double>* %1197
%1198 = getelementptr inbounds double, double* %1196, i64 2
%1199 = bitcast double* %1198 to <2 x double>*
store <2 x double> %1194, <2 x double>* %1199
%1200 = getelementptr inbounds double, double* %4, i64 %1188
%1201 = bitcast double* %1200 to <2 x double>*
%1202 = load <2 x double>, <2 x double>* %1201
%1203 = getelementptr inbounds double, double* %1200, i64 2
%1204 = bitcast double* %1203 to <2 x double>*
%1205 = load <2 x double>, <2 x double>* %1204
%1206 = fneg <2 x double> %1202
%1207 = fneg <2 x double> %1205
%1208 = getelementptr inbounds double, double* %4, i64 %1195
%1209 = bitcast double* %1208 to <2 x double>*
store <2 x double> %1206, <2 x double>* %1209
%1210 = getelementptr inbounds double, double* %1208, i64 2
%1211 = bitcast double* %1210 to <2 x double>*
store <2 x double> %1207, <2 x double>* %1211
%1212 = add nuw i64 %1161, 8
%1213 = add i64 %1162, 2
%1214 = icmp eq i64 %1213, %525
br i1 %1214, label %1215, label %1160
1215: ; preds = %1160, %1159
%1216 = phi i64 [ 0, %1159 ], [ %1212, %1160 ]
br i1 %526, label %1242, label %1217
1217: ; preds = %1215
%1218 = add nsw i64 %1216, %1132
%1219 = getelementptr inbounds double, double* %3, i64 %1218
%1220 = bitcast double* %1219 to <2 x double>*
%1221 = load <2 x double>, <2 x double>* %1220
%1222 = getelementptr inbounds double, double* %1219, i64 2
%1223 = bitcast double* %1222 to <2 x double>*
%1224 = load <2 x double>, <2 x double>* %1223
%1225 = add nsw i64 %1216, %1133
%1226 = getelementptr inbounds double, double* %3, i64 %1225
%1227 = bitcast double* %1226 to <2 x double>*
store <2 x double> %1221, <2 x double>* %1227
%1228 = getelementptr inbounds double, double* %1226, i64 2
%1229 = bitcast double* %1228 to <2 x double>*
store <2 x double> %1224, <2 x double>* %1229
%1230 = getelementptr inbounds double, double* %4, i64 %1218
%1231 = bitcast double* %1230 to <2 x double>*
%1232 = load <2 x double>, <2 x double>* %1231
%1233 = getelementptr inbounds double, double* %1230, i64 2
%1234 = bitcast double* %1233 to <2 x double>*
%1235 = load <2 x double>, <2 x double>* %1234
%1236 = fneg <2 x double> %1232
%1237 = fneg <2 x double> %1235
%1238 = getelementptr inbounds double, double* %4, i64 %1225
%1239 = bitcast double* %1238 to <2 x double>*
store <2 x double> %1236, <2 x double>* %1239
%1240 = getelementptr inbounds double, double* %1238, i64 2
%1241 = bitcast double* %1240 to <2 x double>*
store <2 x double> %1237, <2 x double>* %1241
br label %1242
1242: ; preds = %1215, %1217
br i1 %527, label %1283, label %1243
1243: ; preds = %1134, %1129, %1242
%1244 = phi i64 [ 0, %1134 ], [ 0, %1129 ], [ %522, %1242 ]
%1245 = xor i64 %1244, -1
br i1 %529, label %1257, label %1246
1246: ; preds = %1243
%1247 = add nsw i64 %1244, %1132
%1248 = getelementptr inbounds double, double* %3, i64 %1247
%1249 = load double, double* %1248
%1250 = add nsw i64 %1244, %1133
%1251 = getelementptr inbounds double, double* %3, i64 %1250
store double %1249, double* %1251
%1252 = getelementptr inbounds double, double* %4, i64 %1247
%1253 = load double, double* %1252
%1254 = fneg double %1253
%1255 = getelementptr inbounds double, double* %4, i64 %1250
store double %1254, double* %1255
%1256 = or i64 %1244, 1
br label %1257
1257: ; preds = %1246, %1243
%1258 = phi i64 [ %1244, %1243 ], [ %1256, %1246 ]
%1259 = icmp eq i64 %1245, %530
br i1 %1259, label %1283, label %1260
1260: ; preds = %1257, %1260
%1261 = phi i64 [ %1281, %1260 ], [ %1258, %1257 ]
%1262 = add nsw i64 %1261, %1132
%1263 = getelementptr inbounds double, double* %3, i64 %1262
%1264 = load double, double* %1263
%1265 = add nsw i64 %1261, %1133
%1266 = getelementptr inbounds double, double* %3, i64 %1265
store double %1264, double* %1266
%1267 = getelementptr inbounds double, double* %4, i64 %1262
%1268 = load double, double* %1267
%1269 = fneg double %1268
%1270 = getelementptr inbounds double, double* %4, i64 %1265
store double %1269, double* %1270
%1271 = add nuw nsw i64 %1261, 1
%1272 = add nsw i64 %1271, %1132
%1273 = getelementptr inbounds double, double* %3, i64 %1272
%1274 = load double, double* %1273
%1275 = add nsw i64 %1271, %1133
%1276 = getelementptr inbounds double, double* %3, i64 %1275
store double %1274, double* %1276
%1277 = getelementptr inbounds double, double* %4, i64 %1272
%1278 = load double, double* %1277
%1279 = fneg double %1278
%1280 = getelementptr inbounds double, double* %4, i64 %1275
store double %1279, double* %1280
%1281 = add nuw nsw i64 %1261, 2
%1282 = icmp eq i64 %1281, %486
br i1 %1282, label %1283, label %1260
1283: ; preds = %1257, %1260, %1242, %1118
%1284 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %927, i32 %921, i32 %0)
%1285 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %927, i32 %921, i32 %0)
%1286 = sext i32 %1284 to i64
%1287 = getelementptr inbounds double, double* %3, i64 %1286
%1288 = getelementptr inbounds double, double* %4, i64 %1286
%1289 = sext i32 %1285 to i64
%1290 = getelementptr inbounds double, double* %1, i64 %1289
%1291 = getelementptr inbounds double, double* %2, i64 %1289
%1292 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %927, i32 %921, i32 %0, double* %1290, double* %18, double* %1287, double* %21)
%1293 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symX to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %927, i32 %921, i32 %0, double* %1291, double* %18, double* %1288, double* %21)
br i1 %483, label %1294, label %1305
1294: ; preds = %1283
%1295 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1107, i32 %925, i32 %0)
%1296 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1107, i32 %925, i32 %0)
%1297 = sext i32 %1295 to i64
%1298 = getelementptr inbounds double, double* %3, i64 %1297
%1299 = getelementptr inbounds double, double* %4, i64 %1297
%1300 = sext i32 %1296 to i64
%1301 = getelementptr inbounds double, double* %1, i64 %1300
%1302 = getelementptr inbounds double, double* %2, i64 %1300
%1303 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %1107, i32 %925, i32 %0, double* %1301, double* %18, double* %1298, double* %21)
%1304 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %1107, i32 %925, i32 %0, double* %1302, double* %18, double* %1299, double* %21)
br label %1459
1305: ; preds = %1283
%1306 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %927, i32 %921, i32 %0)
%1307 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1107, i32 %925, i32 %0)
%1308 = sext i32 %1306 to i64
%1309 = sext i32 %1307 to i64
br i1 %531, label %1419, label %1310
1310: ; preds = %1305
%1311 = getelementptr double, double* %3, i64 %1309
%1312 = getelementptr double, double* %493, i64 %1309
%1313 = getelementptr double, double* %4, i64 %1309
%1314 = getelementptr double, double* %494, i64 %1309
%1315 = getelementptr double, double* %3, i64 %1308
%1316 = getelementptr double, double* %495, i64 %1308
%1317 = getelementptr double, double* %4, i64 %1308
%1318 = getelementptr double, double* %496, i64 %1308
%1319 = icmp ult double* %1311, %1316
%1320 = icmp ult double* %1315, %1312
%1321 = and i1 %1319, %1320
%1322 = or i1 %534, %1321
%1323 = icmp ult double* %1311, %1318
%1324 = icmp ult double* %1317, %1312
%1325 = and i1 %1323, %1324
%1326 = or i1 %1322, %1325
%1327 = icmp ult double* %1313, %1316
%1328 = icmp ult double* %1315, %1314
%1329 = and i1 %1327, %1328
%1330 = or i1 %1326, %1329
%1331 = icmp ult double* %1313, %1318
%1332 = icmp ult double* %1317, %1314
%1333 = and i1 %1331, %1332
%1334 = or i1 %1330, %1333
br i1 %1334, label %1419, label %1335
1335: ; preds = %1310
br i1 %537, label %1391, label %1336
1336: ; preds = %1335, %1336
%1337 = phi i64 [ %1388, %1336 ], [ 0, %1335 ]
%1338 = phi i64 [ %1389, %1336 ], [ 0, %1335 ]
%1339 = add nsw i64 %1337, %1308
%1340 = getelementptr inbounds double, double* %3, i64 %1339
%1341 = bitcast double* %1340 to <2 x double>*
%1342 = load <2 x double>, <2 x double>* %1341
%1343 = getelementptr inbounds double, double* %1340, i64 2
%1344 = bitcast double* %1343 to <2 x double>*
%1345 = load <2 x double>, <2 x double>* %1344
%1346 = add nsw i64 %1337, %1309
%1347 = getelementptr inbounds double, double* %3, i64 %1346
%1348 = bitcast double* %1347 to <2 x double>*
store <2 x double> %1342, <2 x double>* %1348
%1349 = getelementptr inbounds double, double* %1347, i64 2
%1350 = bitcast double* %1349 to <2 x double>*
store <2 x double> %1345, <2 x double>* %1350
%1351 = getelementptr inbounds double, double* %4, i64 %1339
%1352 = bitcast double* %1351 to <2 x double>*
%1353 = load <2 x double>, <2 x double>* %1352
%1354 = getelementptr inbounds double, double* %1351, i64 2
%1355 = bitcast double* %1354 to <2 x double>*
%1356 = load <2 x double>, <2 x double>* %1355
%1357 = fneg <2 x double> %1353
%1358 = fneg <2 x double> %1356
%1359 = getelementptr inbounds double, double* %4, i64 %1346
%1360 = bitcast double* %1359 to <2 x double>*
store <2 x double> %1357, <2 x double>* %1360
%1361 = getelementptr inbounds double, double* %1359, i64 2
%1362 = bitcast double* %1361 to <2 x double>*
store <2 x double> %1358, <2 x double>* %1362
%1363 = or i64 %1337, 4
%1364 = add nsw i64 %1363, %1308
%1365 = getelementptr inbounds double, double* %3, i64 %1364
%1366 = bitcast double* %1365 to <2 x double>*
%1367 = load <2 x double>, <2 x double>* %1366
%1368 = getelementptr inbounds double, double* %1365, i64 2
%1369 = bitcast double* %1368 to <2 x double>*
%1370 = load <2 x double>, <2 x double>* %1369
%1371 = add nsw i64 %1363, %1309
%1372 = getelementptr inbounds double, double* %3, i64 %1371
%1373 = bitcast double* %1372 to <2 x double>*
store <2 x double> %1367, <2 x double>* %1373
%1374 = getelementptr inbounds double, double* %1372, i64 2
%1375 = bitcast double* %1374 to <2 x double>*
store <2 x double> %1370, <2 x double>* %1375
%1376 = getelementptr inbounds double, double* %4, i64 %1364
%1377 = bitcast double* %1376 to <2 x double>*
%1378 = load <2 x double>, <2 x double>* %1377
%1379 = getelementptr inbounds double, double* %1376, i64 2
%1380 = bitcast double* %1379 to <2 x double>*
%1381 = load <2 x double>, <2 x double>* %1380
%1382 = fneg <2 x double> %1378
%1383 = fneg <2 x double> %1381
%1384 = getelementptr inbounds double, double* %4, i64 %1371
%1385 = bitcast double* %1384 to <2 x double>*
store <2 x double> %1382, <2 x double>* %1385
%1386 = getelementptr inbounds double, double* %1384, i64 2
%1387 = bitcast double* %1386 to <2 x double>*
store <2 x double> %1383, <2 x double>* %1387
%1388 = add nuw i64 %1337, 8
%1389 = add i64 %1338, 2
%1390 = icmp eq i64 %1389, %538
br i1 %1390, label %1391, label %1336
1391: ; preds = %1336, %1335
%1392 = phi i64 [ 0, %1335 ], [ %1388, %1336 ]
br i1 %539, label %1418, label %1393
1393: ; preds = %1391
%1394 = add nsw i64 %1392, %1308
%1395 = getelementptr inbounds double, double* %3, i64 %1394
%1396 = bitcast double* %1395 to <2 x double>*
%1397 = load <2 x double>, <2 x double>* %1396
%1398 = getelementptr inbounds double, double* %1395, i64 2
%1399 = bitcast double* %1398 to <2 x double>*
%1400 = load <2 x double>, <2 x double>* %1399
%1401 = add nsw i64 %1392, %1309
%1402 = getelementptr inbounds double, double* %3, i64 %1401
%1403 = bitcast double* %1402 to <2 x double>*
store <2 x double> %1397, <2 x double>* %1403
%1404 = getelementptr inbounds double, double* %1402, i64 2
%1405 = bitcast double* %1404 to <2 x double>*
store <2 x double> %1400, <2 x double>* %1405
%1406 = getelementptr inbounds double, double* %4, i64 %1394
%1407 = bitcast double* %1406 to <2 x double>*
%1408 = load <2 x double>, <2 x double>* %1407
%1409 = getelementptr inbounds double, double* %1406, i64 2
%1410 = bitcast double* %1409 to <2 x double>*
%1411 = load <2 x double>, <2 x double>* %1410
%1412 = fneg <2 x double> %1408
%1413 = fneg <2 x double> %1411
%1414 = getelementptr inbounds double, double* %4, i64 %1401
%1415 = bitcast double* %1414 to <2 x double>*
store <2 x double> %1412, <2 x double>* %1415
%1416 = getelementptr inbounds double, double* %1414, i64 2
%1417 = bitcast double* %1416 to <2 x double>*
store <2 x double> %1413, <2 x double>* %1417
br label %1418
1418: ; preds = %1391, %1393
br i1 %540, label %1459, label %1419
1419: ; preds = %1310, %1305, %1418
%1420 = phi i64 [ 0, %1310 ], [ 0, %1305 ], [ %535, %1418 ]
%1421 = xor i64 %1420, -1
br i1 %542, label %1433, label %1422
1422: ; preds = %1419
%1423 = add nsw i64 %1420, %1308
%1424 = getelementptr inbounds double, double* %3, i64 %1423
%1425 = load double, double* %1424
%1426 = add nsw i64 %1420, %1309
%1427 = getelementptr inbounds double, double* %3, i64 %1426
store double %1425, double* %1427
%1428 = getelementptr inbounds double, double* %4, i64 %1423
%1429 = load double, double* %1428
%1430 = fneg double %1429
%1431 = getelementptr inbounds double, double* %4, i64 %1426
store double %1430, double* %1431
%1432 = or i64 %1420, 1
br label %1433
1433: ; preds = %1422, %1419
%1434 = phi i64 [ %1420, %1419 ], [ %1432, %1422 ]
%1435 = icmp eq i64 %1421, %543
br i1 %1435, label %1459, label %1436
1436: ; preds = %1433, %1436
%1437 = phi i64 [ %1457, %1436 ], [ %1434, %1433 ]
%1438 = add nsw i64 %1437, %1308
%1439 = getelementptr inbounds double, double* %3, i64 %1438
%1440 = load double, double* %1439
%1441 = add nsw i64 %1437, %1309
%1442 = getelementptr inbounds double, double* %3, i64 %1441
store double %1440, double* %1442
%1443 = getelementptr inbounds double, double* %4, i64 %1438
%1444 = load double, double* %1443
%1445 = fneg double %1444
%1446 = getelementptr inbounds double, double* %4, i64 %1441
store double %1445, double* %1446
%1447 = add nuw nsw i64 %1437, 1
%1448 = add nsw i64 %1447, %1308
%1449 = getelementptr inbounds double, double* %3, i64 %1448
%1450 = load double, double* %1449
%1451 = add nsw i64 %1447, %1309
%1452 = getelementptr inbounds double, double* %3, i64 %1451
store double %1450, double* %1452
%1453 = getelementptr inbounds double, double* %4, i64 %1448
%1454 = load double, double* %1453
%1455 = fneg double %1454
%1456 = getelementptr inbounds double, double* %4, i64 %1451
store double %1455, double* %1456
%1457 = add nuw nsw i64 %1437, 2
%1458 = icmp eq i64 %1457, %487
br i1 %1458, label %1459, label %1436
1459: ; preds = %1433, %1436, %1418, %1294
%1460 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %927, i32 %925, i32 %0)
%1461 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %927, i32 %925, i32 %0)
%1462 = sext i32 %1460 to i64
%1463 = getelementptr inbounds double, double* %3, i64 %1462
%1464 = getelementptr inbounds double, double* %4, i64 %1462
%1465 = sext i32 %1461 to i64
%1466 = getelementptr inbounds double, double* %1, i64 %1465
%1467 = getelementptr inbounds double, double* %2, i64 %1465
%1468 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %921, i32 %1107, i32 %0, double* %1466, double* %18, double* %1463, double* %21)
%1469 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %921, i32 %1107, i32 %0, double* %1467, double* %18, double* %1464, double* %21)
br i1 %483, label %1470, label %1481
1470: ; preds = %1459
%1471 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1107, i32 %921, i32 %0)
%1472 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @coefLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1107, i32 %921, i32 %0)
%1473 = sext i32 %1471 to i64
%1474 = getelementptr inbounds double, double* %3, i64 %1473
%1475 = getelementptr inbounds double, double* %4, i64 %1473
%1476 = sext i32 %1472 to i64
%1477 = getelementptr inbounds double, double* %1, i64 %1476
%1478 = getelementptr inbounds double, double* %2, i64 %1476
%1479 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %925, i32 %927, i32 %0, double* %1477, double* %18, double* %1474, double* %21)
%1480 = tail call i32 (i32, i32, i32, double*, double*, double*, double*, ...) bitcast (i32 (...)* @wigNaiveSynthesis_symY to i32 (i32, i32, i32, double*, double*, double*, double*, ...)*)(i32 %925, i32 %927, i32 %0, double* %1478, double* %18, double* %1475, double* %21)
br label %1635
1481: ; preds = %1459
%1482 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %927, i32 %925, i32 %0)
%1483 = tail call i32 (i32, i32, i32, ...) bitcast (i32 (...)* @sampLoc_so3 to i32 (i32, i32, i32, ...)*)(i32 %1107, i32 %921, i32 %0)
%1484 = sext i32 %1482 to i64
%1485 = sext i32 %1483 to i64
br i1 %544, label %1595, label %1486
1486: ; preds = %1481
%1487 = getelementptr double, double* %3, i64 %1485
%1488 = getelementptr double, double* %489, i64 %1485
%1489 = getelementptr double, double* %4, i64 %1485
%1490 = getelementptr double, double* %490, i64 %1485
%1491 = getelementptr double, double* %3, i64 %1484
%1492 = getelementptr double, double* %491, i64 %1484
%1493 = getelementptr double, double* %4, i64 %1484
%1494 = getelementptr double, double* %492, i64 %1484
%1495 = icmp ult double* %1487, %1492
%1496 = icmp ult double* %1491, %1488
%1497 = and i1 %1495, %1496
%1498 = or i1 %547, %1497
%1499 = icmp ult double* %1487, %1494
%1500 = icmp ult double* %1493, %1488
%1501 = and i1 %1499, %1500
%1502 = or i1 %1498, %1501
%1503 = icmp ult double* %1489, %1492
%1504 = icmp ult double* %1491, %1490
%1505 = and i1 %1503, %1504
%1506 = or i1 %1502, %1505
%1507 = icmp ult double* %1489, %1494
%1508 = icmp ult double* %1493, %1490
%1509 = and i1 %1507, %1508
%1510 = or i1 %1506, %1509
br i1 %1510, label %1595, label %1511
1511: ; preds = %1486
br i1 %550, label %1567, label %1512
1512: ; preds = %1511, %1512
%1513 = phi i64 [ %1564, %1512 ], [ 0, %1511 ]
%1514 = phi i64 [ %1565, %1512 ], [ 0, %1511 ]
%1515 = add nsw i64 %1513, %1484
%1516 = getelementptr inbounds double, double* %3, i64 %1515
%1517 = bitcast double* %1516 to <2 x double>*
%1518 = load <2 x double>, <2 x double>* %1517
%1519 = getelementptr inbounds double, double* %1516, i64 2
%1520 = bitcast double* %1519 to <2 x double>*
%1521 = load <2 x double>, <2 x double>* %1520
%1522 = add nsw i64 %1513, %1485
%1523 = getelementptr inbounds double, double* %3, i64 %1522
%1524 = bitcast double* %1523 to <2 x double>*
store <2 x double> %1518, <2 x double>* %1524
%1525 = getelementptr inbounds double, double* %1523, i64 2
%1526 = bitcast double* %1525 to <2 x double>*
store <2 x double> %1521, <2 x double>* %1526
%1527 = getelementptr inbounds double, double* %4, i64 %1515
%1528 = bitcast double* %1527 to <2 x double>*
%1529 = load <2 x double>, <2 x double>* %1528
%1530 = getelementptr inbounds double, double* %1527, i64 2
%1531 = bitcast double* %1530 to <2 x double>*
%1532 = load <2 x double>, <2 x double>* %1531
%1533 = fneg <2 x double> %1529
%1534 = fneg <2 x double> %1532
%1535 = getelementptr inbounds double, double* %4, i64 %1522
%1536 = bitcast double* %1535 to <2 x double>*
store <2 x double> %1533, <2 x double>* %1536
%1537 = getelementptr inbounds double, double* %1535, i64 2
%1538 = bitcast double* %1537 to <2 x double>*
store <2 x double> %1534, <2 x double>* %1538
%1539 = or i64 %1513, 4
%1540 = add nsw i64 %1539, %1484
%1541 = getelementptr inbounds double, double* %3, i64 %1540
%1542 = bitcast double* %1541 to <2 x double>*
%1543 = load <2 x double>, <2 x double>* %1542
%1544 = getelementptr inbounds double, double* %1541, i64 2
%1545 = bitcast double* %1544 to <2 x double>*
%1546 = load <2 x double>, <2 x double>* %1545
%1547 = add nsw i64 %1539, %1485
%1548 = getelementptr inbounds double, double* %3, i64 %1547
%1549 = bitcast double* %1548 to <2 x double>*
store <2 x double> %1543, <2 x double>* %1549
%1550 = getelementptr inbounds double, double* %1548, i64 2
%1551 = bitcast double* %1550 to <2 x double>*
store <2 x double> %1546, <2 x double>* %1551
%1552 = getelementptr inbounds double, double* %4, i64 %1540
%1553 = bitcast double* %1552 to <2 x double>*
%1554 = load <2 x double>, <2 x double>* %1553
%1555 = getelementptr inbounds double, double* %1552, i64 2
%1556 = bitcast double* %1555 to <2 x double>*
%1557 = load <2 x double>, <2 x double>* %1556
%1558 = fneg <2 x double> %1554
%1559 = fneg <2 x double> %1557
%1560 = getelementptr inbounds double, double* %4, i64 %1547
%1561 = bitcast double* %1560 to <2 x double>*
store <2 x double> %1558, <2 x double>* %1561
%1562 = getelementptr inbounds double, double* %1560, i64 2
%1563 = bitcast double* %1562 to <2 x double>*
store <2 x double> %1559, <2 x double>* %1563
%1564 = add nuw i64 %1513, 8
%1565 = add i64 %1514, 2
%1566 = icmp eq i64 %1565, %551
br i1 %1566, label %1567, label %1512
1567: ; preds = %1512, %1511
%1568 = phi i64 [ 0, %1511 ], [ %1564, %1512 ]
br i1 %552, label %1594, label %1569
1569: ; preds = %1567
%1570 = add nsw i64 %1568, %1484
%1571 = getelementptr inbounds double, double* %3, i64 %1570
%1572 = bitcast double* %1571 to <2 x double>*
%1573 = load <2 x double>, <2 x double>* %1572
%1574 = getelementptr inbounds double, double* %1571, i64 2
%1575 = bitcast double* %1574 to <2 x double>*
%1576 = load <2 x double>, <2 x double>* %1575
%1577 = add nsw i64 %1568, %1485
%1578 = getelementptr inbounds double, double* %3, i64 %1577
%1579 = bitcast double* %1578 to <2 x double>*
store <2 x double> %1573, <2 x double>* %1579
%1580 = getelementptr inbounds double, double* %1578, i64 2
%1581 = bitcast double* %1580 to <2 x double>*
store <2 x double> %1576, <2 x double>* %1581
%1582 = getelementptr inbounds double, double* %4, i64 %1570
%1583 = bitcast double* %1582 to <2 x double>*
%1584 = load <2 x double>, <2 x double>* %1583
%1585 = getelementptr inbounds double, double* %1582, i64 2
%1586 = bitcast double* %1585 to <2 x double>*
%1587 = load <2 x double>, <2 x double>* %1586
%1588 = fneg <2 x double> %1584
%1589 = fneg <2 x double> %1587
%1590 = getelementptr inbounds double, double* %4, i64 %1577
%1591 = bitcast double* %1590 to <2 x double>*
store <2 x double> %1588, <2 x double>* %1591
%1592 = getelementptr inbounds double, double* %1590, i64 2
%1593 = bitcast double* %1592 to <2 x double>*
store <2 x double> %1589, <2 x double>* %1593
br label %1594
1594: ; preds = %1567, %1569
br i1 %553, label %1635, label %1595
1595: ; preds = %1486, %1481, %1594
%1596 = phi i64 [ 0, %1486 ], [ 0, %1481 ], [ %548, %1594 ]
%1597 = xor i64 %1596, -1
br i1 %555, label %1609, label %1598
1598: ; preds = %1595
%1599 = add nsw i64 %1596, %1484
%1600 = getelementptr inbounds double, double* %3, i64 %1599
%1601 = load double, double* %1600
%1602 = add nsw i64 %1596, %1485
%1603 = getelementptr inbounds double, double* %3, i64 %1602
store double %1601, double* %1603
%1604 = getelementptr inbounds double, double* %4, i64 %1599
%1605 = load double, double* %1604
%1606 = fneg double %1605
%1607 = getelementptr inbounds double, double* %4, i64 %1602
store double %1606, double* %1607
%1608 = or i64 %1596, 1
br label %1609
1609: ; preds = %1598, %1595
%1610 = phi i64 [ %1596, %1595 ], [ %1608, %1598 ]
%1611 = icmp eq i64 %1597, %556
br i1 %1611, label %1635, label %1612
1612: ; preds = %1609, %1612
%1613 = phi i64 [ %1633, %1612 ], [ %1610, %1609 ]
%1614 = add nsw i64 %1613, %1484
%1615 = getelementptr inbounds double, double* %3, i64 %1614
%1616 = load double, double* %1615
%1617 = add nsw i64 %1613, %1485
%1618 = getelementptr inbounds double, double* %3, i64 %1617
store double %1616, double* %1618
%1619 = getelementptr inbounds double, double* %4, i64 %1614
%1620 = load double, double* %1619
%1621 = fneg double %1620
%1622 = getelementptr inbounds double, double* %4, i64 %1617
store double %1621, double* %1622
%1623 = add nuw nsw i64 %1613, 1
%1624 = add nsw i64 %1623, %1484
%1625 = getelementptr inbounds double, double* %3, i64 %1624
%1626 = load double, double* %1625
%1627 = add nsw i64 %1623, %1485
%1628 = getelementptr inbounds double, double* %3, i64 %1627
store double %1626, double* %1628
%1629 = getelementptr inbounds double, double* %4, i64 %1624
%1630 = load double, double* %1629
%1631 = fneg double %1630
%1632 = getelementptr inbounds double, double* %4, i64 %1627
store double %1631, double* %1632
%1633 = add nuw nsw i64 %1613, 2
%1634 = icmp eq i64 %1633, %488
br i1 %1634, label %1635, label %1612
1635: ; preds = %1609, %1612, %1594, %1470
%1636 = add nuw i32 %927, 1
%1637 = icmp eq i32 %1636, %0
br i1 %1637, label %918, label %926
1638: ; preds = %918, %8, %81, %481
%1639 = icmp sgt i32 %0, 0
br i1 %1639, label %1642, label %1640
1640: ; preds = %1638
%1641 = shl nsw i64 %14, 3
br label %1706
1642: ; preds = %1638
%1643 = getelementptr inbounds double, double* %4, i64 %20
%1644 = getelementptr inbounds double, double* %3, i64 %20
%1645 = shl nsw i64 %14, 3
%1646 = shl nsw i32 %0, 2
%1647 = mul nsw i32 %1646, %0
%1648 = sext i32 %1647 to i64
%1649 = add i32 %0, -1
%1650 = and i32 %0, 7
%1651 = icmp ult i32 %1649, 7
br i1 %1651, label %1692, label %1652
1652: ; preds = %1642
%1653 = and i32 %0, -8
br label %1654
1654: ; preds = %1654, %1652
%1655 = phi double* [ %1643, %1652 ], [ %1689, %1654 ]
%1656 = phi double* [ %1644, %1652 ], [ %1688, %1654 ]
%1657 = phi i32 [ 0, %1652 ], [ %1690, %1654 ]
%1658 = bitcast double* %1656 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1658, i8 0, i64 %1645, i1 false)
%1659 = bitcast double* %1655 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1659, i8 0, i64 %1645, i1 false)
%1660 = getelementptr inbounds double, double* %1656, i64 %1648
%1661 = getelementptr inbounds double, double* %1655, i64 %1648
%1662 = bitcast double* %1660 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1662, i8 0, i64 %1645, i1 false)
%1663 = bitcast double* %1661 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1663, i8 0, i64 %1645, i1 false)
%1664 = getelementptr inbounds double, double* %1660, i64 %1648
%1665 = getelementptr inbounds double, double* %1661, i64 %1648
%1666 = bitcast double* %1664 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1666, i8 0, i64 %1645, i1 false)
%1667 = bitcast double* %1665 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1667, i8 0, i64 %1645, i1 false)
%1668 = getelementptr inbounds double, double* %1664, i64 %1648
%1669 = getelementptr inbounds double, double* %1665, i64 %1648
%1670 = bitcast double* %1668 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1670, i8 0, i64 %1645, i1 false)
%1671 = bitcast double* %1669 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1671, i8 0, i64 %1645, i1 false)
%1672 = getelementptr inbounds double, double* %1668, i64 %1648
%1673 = getelementptr inbounds double, double* %1669, i64 %1648
%1674 = bitcast double* %1672 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1674, i8 0, i64 %1645, i1 false)
%1675 = bitcast double* %1673 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1675, i8 0, i64 %1645, i1 false)
%1676 = getelementptr inbounds double, double* %1672, i64 %1648
%1677 = getelementptr inbounds double, double* %1673, i64 %1648
%1678 = bitcast double* %1676 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1678, i8 0, i64 %1645, i1 false)
%1679 = bitcast double* %1677 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1679, i8 0, i64 %1645, i1 false)
%1680 = getelementptr inbounds double, double* %1676, i64 %1648
%1681 = getelementptr inbounds double, double* %1677, i64 %1648
%1682 = bitcast double* %1680 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1682, i8 0, i64 %1645, i1 false)
%1683 = bitcast double* %1681 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1683, i8 0, i64 %1645, i1 false)
%1684 = getelementptr inbounds double, double* %1680, i64 %1648
%1685 = getelementptr inbounds double, double* %1681, i64 %1648
%1686 = bitcast double* %1684 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1686, i8 0, i64 %1645, i1 false)
%1687 = bitcast double* %1685 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1687, i8 0, i64 %1645, i1 false)
%1688 = getelementptr inbounds double, double* %1684, i64 %1648
%1689 = getelementptr inbounds double, double* %1685, i64 %1648
%1690 = add i32 %1657, 8
%1691 = icmp eq i32 %1690, %1653
br i1 %1691, label %1692, label %1654
1692: ; preds = %1654, %1642
%1693 = phi double* [ %1643, %1642 ], [ %1689, %1654 ]
%1694 = phi double* [ %1644, %1642 ], [ %1688, %1654 ]
%1695 = icmp eq i32 %1650, 0
br i1 %1695, label %1706, label %1696
1696: ; preds = %1692, %1696
%1697 = phi double* [ %1703, %1696 ], [ %1693, %1692 ]
%1698 = phi double* [ %1702, %1696 ], [ %1694, %1692 ]
%1699 = phi i32 [ %1704, %1696 ], [ 0, %1692 ]
%1700 = bitcast double* %1698 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1700, i8 0, i64 %1645, i1 false)
%1701 = bitcast double* %1697 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1701, i8 0, i64 %1645, i1 false)
%1702 = getelementptr inbounds double, double* %1698, i64 %1648
%1703 = getelementptr inbounds double, double* %1697, i64 %1648
%1704 = add i32 %1699, 1
%1705 = icmp eq i32 %1704, %1650
br i1 %1705, label %1706, label %1696
1706: ; preds = %1692, %1696, %1640
%1707 = phi i64 [ %1641, %1640 ], [ %1645, %1696 ], [ %1645, %1692 ]
%1708 = mul nsw i32 %19, %9
%1709 = sext i32 %1708 to i64
%1710 = getelementptr inbounds double, double* %3, i64 %1709
%1711 = getelementptr inbounds double, double* %4, i64 %1709
%1712 = bitcast double* %1710 to i8*
%1713 = mul i64 %1707, %14
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1712, i8 0, i64 %1713, i1 false)
%1714 = bitcast double* %1711 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1714, i8 0, i64 %1713, i1 false)
%1715 = add nsw i32 %10, %19
%1716 = sext i32 %1715 to i64
br i1 %37, label %1717, label %1781
1717: ; preds = %1706
%1718 = getelementptr inbounds double, double* %1711, i64 %1716
%1719 = getelementptr inbounds double, double* %1710, i64 %1716
%1720 = shl nsw i32 %0, 2
%1721 = mul nsw i32 %1720, %0
%1722 = sext i32 %1721 to i64
%1723 = add i32 %0, -1
%1724 = add i32 %0, -2
%1725 = and i32 %1723, 7
%1726 = icmp ult i32 %1724, 7
br i1 %1726, label %1767, label %1727
1727: ; preds = %1717
%1728 = and i32 %1723, -8
br label %1729
1729: ; preds = %1729, %1727
%1730 = phi double* [ %1718, %1727 ], [ %1764, %1729 ]
%1731 = phi double* [ %1719, %1727 ], [ %1763, %1729 ]
%1732 = phi i32 [ 0, %1727 ], [ %1765, %1729 ]
%1733 = bitcast double* %1731 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1733, i8 0, i64 %1707, i1 false)
%1734 = bitcast double* %1730 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1734, i8 0, i64 %1707, i1 false)
%1735 = getelementptr inbounds double, double* %1731, i64 %1722
%1736 = getelementptr inbounds double, double* %1730, i64 %1722
%1737 = bitcast double* %1735 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1737, i8 0, i64 %1707, i1 false)
%1738 = bitcast double* %1736 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1738, i8 0, i64 %1707, i1 false)
%1739 = getelementptr inbounds double, double* %1735, i64 %1722
%1740 = getelementptr inbounds double, double* %1736, i64 %1722
%1741 = bitcast double* %1739 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1741, i8 0, i64 %1707, i1 false)
%1742 = bitcast double* %1740 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1742, i8 0, i64 %1707, i1 false)
%1743 = getelementptr inbounds double, double* %1739, i64 %1722
%1744 = getelementptr inbounds double, double* %1740, i64 %1722
%1745 = bitcast double* %1743 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1745, i8 0, i64 %1707, i1 false)
%1746 = bitcast double* %1744 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1746, i8 0, i64 %1707, i1 false)
%1747 = getelementptr inbounds double, double* %1743, i64 %1722
%1748 = getelementptr inbounds double, double* %1744, i64 %1722
%1749 = bitcast double* %1747 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1749, i8 0, i64 %1707, i1 false)
%1750 = bitcast double* %1748 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1750, i8 0, i64 %1707, i1 false)
%1751 = getelementptr inbounds double, double* %1747, i64 %1722
%1752 = getelementptr inbounds double, double* %1748, i64 %1722
%1753 = bitcast double* %1751 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1753, i8 0, i64 %1707, i1 false)
%1754 = bitcast double* %1752 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1754, i8 0, i64 %1707, i1 false)
%1755 = getelementptr inbounds double, double* %1751, i64 %1722
%1756 = getelementptr inbounds double, double* %1752, i64 %1722
%1757 = bitcast double* %1755 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1757, i8 0, i64 %1707, i1 false)
%1758 = bitcast double* %1756 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1758, i8 0, i64 %1707, i1 false)
%1759 = getelementptr inbounds double, double* %1755, i64 %1722
%1760 = getelementptr inbounds double, double* %1756, i64 %1722
%1761 = bitcast double* %1759 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1761, i8 0, i64 %1707, i1 false)
%1762 = bitcast double* %1760 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1762, i8 0, i64 %1707, i1 false)
%1763 = getelementptr inbounds double, double* %1759, i64 %1722
%1764 = getelementptr inbounds double, double* %1760, i64 %1722
%1765 = add i32 %1732, 8
%1766 = icmp eq i32 %1765, %1728
br i1 %1766, label %1767, label %1729
1767: ; preds = %1729, %1717
%1768 = phi double* [ %1718, %1717 ], [ %1764, %1729 ]
%1769 = phi double* [ %1719, %1717 ], [ %1763, %1729 ]
%1770 = icmp eq i32 %1725, 0
br i1 %1770, label %1781, label %1771
1771: ; preds = %1767, %1771
%1772 = phi double* [ %1778, %1771 ], [ %1768, %1767 ]
%1773 = phi double* [ %1777, %1771 ], [ %1769, %1767 ]
%1774 = phi i32 [ %1779, %1771 ], [ 0, %1767 ]
%1775 = bitcast double* %1773 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1775, i8 0, i64 %1707, i1 false)
%1776 = bitcast double* %1772 to i8*
tail call void @llvm.memset.p0i8.i64(i8* align 8 %1776, i8 0, i64 %1707, i1 false)
%1777 = getelementptr inbounds double, double* %1773, i64 %1722
%1778 = getelementptr inbounds double, double* %1772, i64 %1722
%1779 = add i32 %1774, 1
%1780 = icmp eq i32 %1779, %1725
br i1 %1780, label %1781, label %1771
1781: ; preds = %1767, %1771, %1706
%1782 = tail call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @transpose_so3 to i32 (double*, double*, i32, i32, ...)*)(double* %3, double* %5, i32 %9, i32 %10)
%1783 = tail call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @transpose_so3 to i32 (double*, double*, i32, i32, ...)*)(double* %4, double* %13, i32 %9, i32 %10)
%1784 = tail call i32 (double*, double*, double*, double*, i32, i32, double*, ...) bitcast (i32 (...)* @grid_fourier_so3 to i32 (double*, double*, double*, double*, i32, i32, double*, ...)*)(double* %5, double* %13, double* %3, double* %4, i32 %10, i32 %9, double* %21)
%1785 = tail call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @transpose_so3 to i32 (double*, double*, i32, i32, ...)*)(double* %3, double* %5, i32 %9, i32 %10)
%1786 = tail call i32 (double*, double*, i32, i32, ...) bitcast (i32 (...)* @transpose_so3 to i32 (double*, double*, i32, i32, ...)*)(double* %4, double* %13, i32 %9, i32 %10)
%1787 = tail call i32 (double*, double*, double*, double*, i32, i32, double*, ...) bitcast (i32 (...)* @grid_fourier_so3 to i32 (double*, double*, double*, double*, i32, i32, double*, ...)*)(double* %5, double* %13, double* %3, double* %4, i32 %10, i32 %9, double* %21)
%1788 = sitofp i32 %9 to double
%1789 = sitofp i32 %0 to double
%1790 = fdiv double %1789, 0x400921FB54442D18
%1791 = fmul double %1790, %1788
%1792 = icmp sgt i32 %11, 0
br i1 %1792, label %1793, label %1897
1793: ; preds = %1781
%1794 = zext i32 %11 to i64
%1795 = getelementptr double, double* %3, i64 %1794
%1796 = getelementptr double, double* %4, i64 %1794
%1797 = icmp ugt double* %1796, %3
%1798 = icmp ugt double* %1795, %4
%1799 = and i1 %1797, %1798
br i1 %1799, label %1857, label %1800
1800: ; preds = %1793
%1801 = insertelement <2 x double> poison, double %1791, i64 0
%1802 = shufflevector <2 x double> %1801, <2 x double> poison, <2 x i32> zeroinitializer
%1803 = insertelement <2 x double> poison, double %1791, i64 0
%1804 = shufflevector <2 x double> %1803, <2 x double> poison, <2 x i32> zeroinitializer
%1805 = add nsw i64 %1794, -4
%1806 = lshr exact i64 %1805, 2
%1807 = add nuw nsw i64 %1806, 1
%1808 = and i64 %1807, 1
%1809 = and i64 %1807, 9223372036854775806
br label %1810
1810: ; preds = %1810, %1800
%1811 = phi i64 [ 0, %1800 ], [ %1854, %1810 ]
%1812 = phi i64 [ 0, %1800 ], [ %1855, %1810 ]
%1813 = getelementptr inbounds double, double* %3, i64 %1811
%1814 = bitcast double* %1813 to <2 x double>*
%1815 = load <2 x double>, <2 x double>* %1814
%1816 = getelementptr inbounds double, double* %1813, i64 2
%1817 = bitcast double* %1816 to <2 x double>*
%1818 = load <2 x double>, <2 x double>* %1817
%1819 = fmul <2 x double> %1802, %1815
%1820 = fmul <2 x double> %1804, %1818
%1821 = bitcast double* %1813 to <2 x double>*
store <2 x double> %1819, <2 x double>* %1821
%1822 = bitcast double* %1816 to <2 x double>*
store <2 x double> %1820, <2 x double>* %1822
%1823 = getelementptr inbounds double, double* %4, i64 %1811
%1824 = bitcast double* %1823 to <2 x double>*
%1825 = load <2 x double>, <2 x double>* %1824
%1826 = getelementptr inbounds double, double* %1823, i64 2
%1827 = bitcast double* %1826 to <2 x double>*
%1828 = load <2 x double>, <2 x double>* %1827
%1829 = fmul <2 x double> %1802, %1825
%1830 = fmul <2 x double> %1804, %1828
%1831 = bitcast double* %1823 to <2 x double>*
store <2 x double> %1829, <2 x double>* %1831
%1832 = bitcast double* %1826 to <2 x double>*
store <2 x double> %1830, <2 x double>* %1832
%1833 = or i64 %1811, 4
%1834 = getelementptr inbounds double, double* %3, i64 %1833
%1835 = bitcast double* %1834 to <2 x double>*
%1836 = load <2 x double>, <2 x double>* %1835
%1837 = getelementptr inbounds double, double* %1834, i64 2
%1838 = bitcast double* %1837 to <2 x double>*
%1839 = load <2 x double>, <2 x double>* %1838
%1840 = fmul <2 x double> %1802, %1836
%1841 = fmul <2 x double> %1804, %1839
%1842 = bitcast double* %1834 to <2 x double>*
store <2 x double> %1840, <2 x double>* %1842
%1843 = bitcast double* %1837 to <2 x double>*
store <2 x double> %1841, <2 x double>* %1843
%1844 = getelementptr inbounds double, double* %4, i64 %1833
%1845 = bitcast double* %1844 to <2 x double>*
%1846 = load <2 x double>, <2 x double>* %1845
%1847 = getelementptr inbounds double, double* %1844, i64 2
%1848 = bitcast double* %1847 to <2 x double>*
%1849 = load <2 x double>, <2 x double>* %1848
%1850 = fmul <2 x double> %1802, %1846
%1851 = fmul <2 x double> %1804, %1849
%1852 = bitcast double* %1844 to <2 x double>*
store <2 x double> %1850, <2 x double>* %1852
%1853 = bitcast double* %1847 to <2 x double>*
store <2 x double> %1851, <2 x double>* %1853
%1854 = add nuw i64 %1811, 8
%1855 = add i64 %1812, 2
%1856 = icmp eq i64 %1855, %1809
br i1 %1856, label %1874, label %1810
1857: ; preds = %1793, %1857
%1858 = phi i64 [ %1872, %1857 ], [ 0, %1793 ]
%1859 = getelementptr inbounds double, double* %3, i64 %1858
%1860 = load double, double* %1859
%1861 = fmul double %1791, %1860
store double %1861, double* %1859
%1862 = getelementptr inbounds double, double* %4, i64 %1858
%1863 = load double, double* %1862
%1864 = fmul double %1791, %1863
store double %1864, double* %1862
%1865 = or i64 %1858, 1
%1866 = getelementptr inbounds double, double* %3, i64 %1865
%1867 = load double, double* %1866
%1868 = fmul double %1791, %1867
store double %1868, double* %1866
%1869 = getelementptr inbounds double, double* %4, i64 %1865
%1870 = load double, double* %1869
%1871 = fmul double %1791, %1870
store double %1871, double* %1869
%1872 = add nuw nsw i64 %1858, 2
%1873 = icmp eq i64 %1872, %1794
br i1 %1873, label %1897, label %1857
1874: ; preds = %1810
%1875 = icmp eq i64 %1808, 0
br i1 %1875, label %1897, label %1876
1876: ; preds = %1874
%1877 = getelementptr inbounds double, double* %3, i64 %1854
%1878 = bitcast double* %1877 to <2 x double>*
%1879 = load <2 x double>, <2 x double>* %1878
%1880 = getelementptr inbounds double, double* %1877, i64 2
%1881 = bitcast double* %1880 to <2 x double>*
%1882 = load <2 x double>, <2 x double>* %1881
%1883 = fmul <2 x double> %1802, %1879
%1884 = fmul <2 x double> %1804, %1882
%1885 = bitcast double* %1877 to <2 x double>*
store <2 x double> %1883, <2 x double>* %1885
%1886 = bitcast double* %1880 to <2 x double>*
store <2 x double> %1884, <2 x double>* %1886
%1887 = getelementptr inbounds double, double* %4, i64 %1854
%1888 = bitcast double* %1887 to <2 x double>*
%1889 = load <2 x double>, <2 x double>* %1888
%1890 = getelementptr inbounds double, double* %1887, i64 2
%1891 = bitcast double* %1890 to <2 x double>*
%1892 = load <2 x double>, <2 x double>* %1891
%1893 = fmul <2 x double> %1802, %1889
%1894 = fmul <2 x double> %1804, %1892
%1895 = bitcast double* %1887 to <2 x double>*
store <2 x double> %1893, <2 x double>* %1895
%1896 = bitcast double* %1890 to <2 x double>*
store <2 x double> %1894, <2 x double>* %1896
br label %1897
1897: ; preds = %1876, %1874, %1857, %1781
ret void
}