void swt_out2(double *sigIn, int sigInLength, double *approxMatrix,
              double *detailMatrix, int rowLength, int colLength,
              double *filterLow, double *filterHi, int filterLength, int step) {
  int row, count, *filterLen;
  double *approxMatrixTemp, *detailMatrixTemp, *approxTemp;
  double *filterLowTemp, *filterHiTemp, *filterLowM, *filterHiM;
  filterLen = malloc(step * sizeof(int));
  approxTemp = malloc(colLength * sizeof(double));
  approxMatrixTemp = malloc(rowLength * colLength * sizeof(double));
  detailMatrixTemp = malloc(rowLength * colLength * sizeof(double));
  filterLen[0] = filterLength;
  if (step > 1) {
    for (count = 1; count < step; count++)
      filterLen[count] = filterLen[count - 1] * 2;
  }
  filterLowTemp = malloc((filterLen[step - 1]) * sizeof(double));
  filterHiTemp = malloc((filterLen[step - 1]) * sizeof(double));
  filterLowM = malloc((filterLen[step - 1]) * sizeof(double));
  filterHiM = malloc((filterLen[step - 1]) * sizeof(double));
  for (count = 0; count < (filterLen[step - 1]); count++) {
    filterLowM[count] = 0;
    filterHiM[count] = 0;
  }
  verbatim_copy(filterLow, filterLength, filterLowTemp, filterLen[0]);
  verbatim_copy(filterHi, filterLength, filterHiTemp, filterLen[0]);
  verbatim_copy(sigIn, sigInLength, approxTemp, sigInLength);
  for (row = 0; row < step; row++) {
    swt_conv(approxTemp, sigInLength, approxMatrixTemp + row * colLength,
             sigInLength, detailMatrixTemp + row * colLength, sigInLength,
             filterLowTemp, filterHiTemp, filterLen[row]);
    verbatim_copy(approxMatrixTemp + row * colLength, sigInLength, approxTemp,
                  sigInLength);
    if (row < (step - 1)) {
      for (count = 0; count < filterLen[row]; count++) {
        filterLowM[2 * count] = filterLowTemp[count];
        filterLowM[2 * count + 1] = 0;
        filterHiM[2 * count] = filterHiTemp[count];
        filterHiM[2 * count + 1] = 0;
      }
      verbatim_copy(filterLowM, filterLen[row] * 2, filterLowTemp,
                    filterLen[row] * 2);
      verbatim_copy(filterHiM, filterLen[row] * 2, filterHiTemp,
                    filterLen[row] * 2);
    }
  }
  free(approxTemp);
  matrix_tran(approxMatrixTemp, rowLength, colLength, approxMatrix, colLength,
              rowLength);
  matrix_tran(detailMatrixTemp, rowLength, colLength, detailMatrix, colLength,
              rowLength);
  free(approxMatrixTemp);
  free(detailMatrixTemp);
  free(filterLowM);
  free(filterHiM);
  free(filterLowTemp);
  free(filterHiTemp);
  free(filterLen);
  return;
}


x86 assembly (clang, -O0):
<swt_out2>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x88,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9d,-0x30(%rbp)
movslq 0x28(%rbp),%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x30(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x30(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x30(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    0x20(%rbp),%ecx
mov    -0x40(%rbp),%rax
mov    %ecx,(%rax)
cmpl   $0x1,0x28(%rbp)
jle    1228 <swt_out2+0xd8>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1223 <swt_out2+0xd3>
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
shl    $0x1,%edx
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11eb <swt_out2+0x9b>
jmp    1228 <swt_out2+0xd8>
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movslq (%rax,%rcx,4),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movslq (%rax,%rcx,4),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movslq (%rax,%rcx,4),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x40(%rbp),%rax
mov    0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movslq (%rax,%rcx,4),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x40(%rbp),%rcx
mov    0x28(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    12ee <swt_out2+0x19e>
mov    -0x70(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12a7 <swt_out2+0x157>
mov    0x10(%rbp),%rdi
mov    0x20(%rbp),%esi
mov    -0x60(%rbp),%rdx
mov    -0x40(%rbp),%rax
mov    (%rax),%ecx
mov    $0x0,%al
call   1060 <verbatim_copy@plt>
mov    0x18(%rbp),%rdi
mov    0x20(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x40(%rbp),%rax
mov    (%rax),%ecx
mov    $0x0,%al
call   1060 <verbatim_copy@plt>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x58(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    $0x0,%al
call   1060 <verbatim_copy@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    14d9 <swt_out2+0x389>
mov    -0x58(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x48(%rbp),%rdx
mov    -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x14(%rbp),%ecx
mov    -0x50(%rbp),%r8
mov    -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%r8
mov    -0x14(%rbp),%r9d
mov    -0x60(%rbp),%r11
mov    -0x68(%rbp),%r10
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rbx
mov    (%rax,%rbx,4),%eax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1050 <swt_conv@plt>
mov    -0x48(%rbp),%rdi
mov    -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x14(%rbp),%esi
mov    -0x58(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    $0x0,%al
call   1060 <verbatim_copy@plt>
mov    -0x34(%rbp),%eax
mov    0x28(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14c6 <swt_out2+0x376>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1470 <swt_out2+0x320>
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13e0 <swt_out2+0x290>
mov    -0x70(%rbp),%rdi
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
shl    $0x1,%esi
mov    -0x60(%rbp),%rdx
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
shl    $0x1,%ecx
mov    $0x0,%al
call   1060 <verbatim_copy@plt>
mov    -0x78(%rbp),%rdi
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
shl    $0x1,%esi
mov    -0x68(%rbp),%rdx
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
shl    $0x1,%ecx
mov    $0x0,%al
call   1060 <verbatim_copy@plt>
jmp    14cb <swt_out2+0x37b>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    133a <swt_out2+0x1ea>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%r8d
mov    -0x2c(%rbp),%r9d
mov    $0x0,%al
call   1070 <matrix_tran@plt>
mov    -0x50(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8d
mov    -0x2c(%rbp),%r9d
mov    $0x0,%al
call   1070 <matrix_tran@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
add    $0x88,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<swt_out2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9d,%ebx
mov    %r8d,%r15d
mov    %rcx,0x78(%rsp)
mov    %rdx,0x70(%rsp)
mov    %esi,0x4(%rsp)
mov    %rdi,0x68(%rsp)
movslq 0xd8(%rsp),%r14
mov    0xd0(%rsp),%r12d
mov    0xc8(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0xc0(%rsp),%rax
mov    %rax,0x58(%rsp)
lea    0x0(,%r14,4),%rdi
call   1050 <malloc@plt>
mov    %rax,%rbp
movslq %ebx,%rax
mov    %rax,0x80(%rsp)
lea    0x0(,%rax,8),%rdi
call   1050 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    %ebx,0x28(%rsp)
mov    %r15d,0x2c(%rsp)
imul   %r15d,%ebx
movslq %ebx,%rbx
shl    $0x3,%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %r12,%r15
mov    %rax,0x48(%rsp)
mov    %r15d,0x0(%rbp)
mov    %r14d,%eax
mov    %rax,0x38(%rsp)
cmp    $0x2,%r14
jl     12be <swt_out2+0x15e>
mov    0x38(%rsp),%rax
lea    -0x1(%rax),%rsi
lea    -0x2(%rax),%rdi
mov    %esi,%eax
and    $0x3,%eax
mov    $0x1,%edx
mov    %r15d,%ecx
cmp    $0x3,%rdi
jb     1291 <swt_out2+0x131>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
mov    %r15d,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rcx,1),%edi
mov    %edi,0x4(%rbp,%rdx,4)
lea    0x0(,%rcx,4),%edi
mov    %edi,0x8(%rbp,%rdx,4)
lea    0x0(,%rcx,8),%edi
mov    %edi,0xc(%rbp,%rdx,4)
shl    $0x4,%ecx
mov    %ecx,0x10(%rbp,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1260 <swt_out2+0x100>
add    $0x1,%rdx
test   %rax,%rax
je     12be <swt_out2+0x15e>
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %ecx,%ecx
mov    %ecx,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    12b0 <swt_out2+0x150>
mov    %r14,0x20(%rsp)
movslq %r14d,%rax
mov    %rbp,0x30(%rsp)
mov    %rax,0x40(%rsp)
movslq -0x4(%rbp,%rax,4),%r14
lea    0x0(,%r14,8),%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,%r12
test   %r14,%r14
jle    1331 <swt_out2+0x1d1>
mov    %r14d,%ebp
shl    $0x3,%rbp
mov    %r13,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
mov    0x58(%rsp),%rdi
mov    %r15,%rbp
mov    %ebp,%esi
mov    %rbx,%rdx
mov    %ebp,%ecx
xor    %eax,%eax
call   1070 <verbatim_copy@plt>
mov    0x60(%rsp),%rdi
mov    %ebp,%esi
mov    0x8(%rsp),%rdx
mov    %ebp,%ecx
xor    %eax,%eax
call   1070 <verbatim_copy@plt>
mov    0x68(%rsp),%rdi
mov    0x4(%rsp),%ecx
mov    %ecx,%esi
mov    0x10(%rsp),%rdx
xor    %eax,%eax
call   1070 <verbatim_copy@plt>
cmpl   $0x0,0x20(%rsp)
jle    15b9 <swt_out2+0x459>
addq   $0xffffffffffffffff,0x40(%rsp)
mov    %r15,%r10
xor    %r15d,%r15d
mov    %rbx,0x50(%rsp)
nop
mov    %r15,0x20(%rsp)
mov    %r15,%rax
imul   0x80(%rsp),%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rbp
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,8),%r8
sub    $0x8,%rsp
mov    0x18(%rsp),%r14
mov    %r14,%rdi
mov    0xc(%rsp),%r15d
mov    %r15d,%esi
mov    %rbp,%rdx
mov    %r15d,%ecx
mov    %r15d,%r9d
xor    %eax,%eax
push   %r10
push   0x18(%rsp)
push   %rbx
mov    %r10,%rbx
call   1060 <swt_conv@plt>
add    $0x20,%rsp
mov    %rbp,%rdi
mov    %r15d,%esi
mov    %r14,%rdx
mov    %r15d,%ecx
mov    0x20(%rsp),%r15
xor    %eax,%eax
call   1070 <verbatim_copy@plt>
cmp    0x40(%rsp),%r15
jge    1586 <swt_out2+0x426>
test   %ebx,%ebx
mov    %rbx,%rcx
mov    0x50(%rsp),%rdx
mov    0x8(%rsp),%r14
jle    1564 <swt_out2+0x404>
mov    %ecx,%ebx
cmp    $0x1,%ecx
jne    142b <swt_out2+0x2cb>
xor    %eax,%eax
jmp    1525 <swt_out2+0x3c5>
mov    %ebx,%eax
and    $0xfffffffe,%eax
lea    -0x2(%rax),%rsi
mov    %rsi,%r8
shr    %r8
add    $0x1,%r8
test   %rsi,%rsi
je     15a4 <swt_out2+0x444>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0x10,%ebp
xor    %esi,%esi
pxor   %xmm2,%xmm2
nopl   0x0(%rax)
movdqu -0x10(%rdx,%rbp,1),%xmm0
movq   %xmm0,%xmm1
punpckhqdq %xmm2,%xmm0
movdqu %xmm0,-0x10(%r13,%rbp,2)
movdqu %xmm1,-0x20(%r13,%rbp,2)
movdqu -0x10(%r14,%rbp,1),%xmm0
movq   %xmm0,%xmm1
punpckhqdq %xmm2,%xmm0
movdqu %xmm0,-0x10(%r12,%rbp,2)
movdqu %xmm1,-0x20(%r12,%rbp,2)
movdqu (%rdx,%rbp,1),%xmm0
movq   %xmm0,%xmm1
punpckhqdq %xmm2,%xmm0
movdqu %xmm0,0x10(%r13,%rbp,2)
movdqu %xmm1,0x0(%r13,%rbp,2)
movdqu (%r14,%rbp,1),%xmm0
movq   %xmm0,%xmm1
punpckhqdq %xmm2,%xmm0
movdqu %xmm0,0x10(%r12,%rbp,2)
movdqu %xmm1,(%r12,%rbp,2)
add    $0x4,%rsi
add    $0x20,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1460 <swt_out2+0x300>
test   $0x1,%r8b
je     1520 <swt_out2+0x3c0>
movdqu (%rdx,%rsi,8),%xmm0
mov    %rsi,%rdi
shl    $0x4,%rdi
movq   %xmm0,%xmm1
punpckhqdq %xmm2,%xmm0
movdqu %xmm0,0x10(%r13,%rdi,1)
movdqu %xmm1,0x0(%r13,%rdi,1)
movdqu (%r14,%rsi,8),%xmm0
movq   %xmm0,%xmm1
punpckhqdq %xmm2,%xmm0
movdqu %xmm0,0x10(%r12,%rdi,1)
movdqu %xmm1,(%r12,%rdi,1)
cmp    %rbx,%rax
je     1564 <swt_out2+0x404>
sub    %rax,%rbx
shl    $0x3,%rax
nopl   0x0(%rax)
movsd  (%rdx,%rax,1),%xmm0
movsd  %xmm0,0x0(%r13,%rax,2)
movq   $0x0,0x8(%r13,%rax,2)
movq   (%r14,%rax,1),%xmm0
movq   %xmm0,(%r12,%rax,2)
movq   $0x0,0x8(%r12,%rax,2)
add    $0x8,%rax
add    $0xffffffffffffffff,%rbx
jne    1530 <swt_out2+0x3d0>
add    %ecx,%ecx
mov    %r13,%rdi
mov    %ecx,%esi
xor    %eax,%eax
mov    %rcx,%rbp
call   1070 <verbatim_copy@plt>
mov    %r12,%rdi
mov    %ebp,%esi
mov    %r14,%rdx
mov    %ebp,%ecx
xor    %eax,%eax
call   1070 <verbatim_copy@plt>
add    $0x1,%r15
cmp    0x38(%rsp),%r15
mov    0x50(%rsp),%rbx
je     15b9 <swt_out2+0x459>
mov    0x30(%rsp),%rax
mov    (%rax,%r15,4),%r10d
jmp    1390 <swt_out2+0x230>
xor    %esi,%esi
pxor   %xmm2,%xmm2
test   $0x1,%r8b
jne    14e3 <swt_out2+0x383>
jmp    1520 <swt_out2+0x3c0>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
mov    0x2c(%rsp),%r14d
mov    %r14d,%esi
mov    0x28(%rsp),%ebp
mov    %ebp,%edx
mov    0x70(%rsp),%rcx
mov    %ebp,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
call   1080 <matrix_tran@plt>
mov    0x48(%rsp),%r15
mov    %r15,%rdi
mov    %r14d,%esi
mov    %ebp,%edx
mov    0x78(%rsp),%rcx
mov    %ebp,%r8d
mov    %r14d,%r9d
xor    %eax,%eax
call   1080 <matrix_tran@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
define void @swt_out2(double* %0, i32 %1, double* %2, double* %3, i32 %4, i32 %5, double* %6, double* %7, i32 %8, i32 %9) {
%11 = alloca double*
%12 = alloca i32
%13 = alloca double*
%14 = alloca double*
%15 = alloca i32
%16 = alloca i32
%17 = alloca double*
%18 = alloca double*
%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*
store double* %0, double** %11
store i32 %1, i32* %12
store double* %2, double** %13
store double* %3, double** %14
store i32 %4, i32* %15
store i32 %5, i32* %16
store double* %6, double** %17
store double* %7, double** %18
store i32 %8, i32* %19
store i32 %9, i32* %20
%31 = load i32, i32* %20
%32 = sext i32 %31 to i64
%33 = mul i64 %32, 4
%34 = call i8* @malloc(i64 %33)
%35 = bitcast i8* %34 to i32*
store i32* %35, i32** %23
%36 = load i32, i32* %16
%37 = sext i32 %36 to i64
%38 = mul i64 %37, 8
%39 = call i8* @malloc(i64 %38)
%40 = bitcast i8* %39 to double*
store double* %40, double** %26
%41 = load i32, i32* %15
%42 = load i32, i32* %16
%43 = mul nsw i32 %41, %42
%44 = sext i32 %43 to i64
%45 = mul i64 %44, 8
%46 = call i8* @malloc(i64 %45)
%47 = bitcast i8* %46 to double*
store double* %47, double** %24
%48 = load i32, i32* %15
%49 = load i32, i32* %16
%50 = mul nsw i32 %48, %49
%51 = sext i32 %50 to i64
%52 = mul i64 %51, 8
%53 = call i8* @malloc(i64 %52)
%54 = bitcast i8* %53 to double*
store double* %54, double** %25
%55 = load i32, i32* %19
%56 = load i32*, i32** %23
%57 = getelementptr inbounds i32, i32* %56, i64 0
store i32 %55, i32* %57
%58 = load i32, i32* %20
%59 = icmp sgt i32 %58, 1
br i1 %59, label %60, label %81
60: ; preds = %10
store i32 1, i32* %22
br label %61
61: ; preds = %77, %60
%62 = load i32, i32* %22
%63 = load i32, i32* %20
%64 = icmp slt i32 %62, %63
br i1 %64, label %65, label %80
65: ; preds = %61
%66 = load i32*, i32** %23
%67 = load i32, i32* %22
%68 = sub nsw i32 %67, 1
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i32, i32* %66, i64 %69
%71 = load i32, i32* %70
%72 = mul nsw i32 %71, 2
%73 = load i32*, i32** %23
%74 = load i32, i32* %22
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i32, i32* %73, i64 %75
store i32 %72, i32* %76
br label %77
77: ; preds = %65
%78 = load i32, i32* %22
%79 = add nsw i32 %78, 1
store i32 %79, i32* %22
br label %61
80: ; preds = %61
br label %81
81: ; preds = %80, %10
%82 = load i32*, i32** %23
%83 = load i32, i32* %20
%84 = sub nsw i32 %83, 1
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i32, i32* %82, i64 %85
%87 = load i32, i32* %86
%88 = sext i32 %87 to i64
%89 = mul i64 %88, 8
%90 = call i8* @malloc(i64 %89)
%91 = bitcast i8* %90 to double*
store double* %91, double** %27
%92 = load i32*, i32** %23
%93 = load i32, i32* %20
%94 = sub nsw i32 %93, 1
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %92, i64 %95
%97 = load i32, i32* %96
%98 = sext i32 %97 to i64
%99 = mul i64 %98, 8
%100 = call i8* @malloc(i64 %99)
%101 = bitcast i8* %100 to double*
store double* %101, double** %28
%102 = load i32*, i32** %23
%103 = load i32, i32* %20
%104 = sub nsw i32 %103, 1
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i32, i32* %102, i64 %105
%107 = load i32, i32* %106
%108 = sext i32 %107 to i64
%109 = mul i64 %108, 8
%110 = call i8* @malloc(i64 %109)
%111 = bitcast i8* %110 to double*
store double* %111, double** %29
%112 = load i32*, i32** %23
%113 = load i32, i32* %20
%114 = sub nsw i32 %113, 1
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32, i32* %112, i64 %115
%117 = load i32, i32* %116
%118 = sext i32 %117 to i64
%119 = mul i64 %118, 8
%120 = call i8* @malloc(i64 %119)
%121 = bitcast i8* %120 to double*
store double* %121, double** %30
store i32 0, i32* %22
br label %122
122: ; preds = %140, %81
%123 = load i32, i32* %22
%124 = load i32*, i32** %23
%125 = load i32, i32* %20
%126 = sub nsw i32 %125, 1
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i32, i32* %124, i64 %127
%129 = load i32, i32* %128
%130 = icmp slt i32 %123, %129
br i1 %130, label %131, label %143
131: ; preds = %122
%132 = load double*, double** %29
%133 = load i32, i32* %22
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %132, i64 %134
store double 0.000000e+00, double* %135
%136 = load double*, double** %30
%137 = load i32, i32* %22
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %136, i64 %138
store double 0.000000e+00, double* %139
br label %140
140: ; preds = %131
%141 = load i32, i32* %22
%142 = add nsw i32 %141, 1
store i32 %142, i32* %22
br label %122
143: ; preds = %122
%144 = load double*, double** %17
%145 = load i32, i32* %19
%146 = load double*, double** %27
%147 = load i32*, i32** %23
%148 = getelementptr inbounds i32, i32* %147, i64 0
%149 = load i32, i32* %148
%150 = call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %144, i32 %145, double* %146, i32 %149)
%151 = load double*, double** %18
%152 = load i32, i32* %19
%153 = load double*, double** %28
%154 = load i32*, i32** %23
%155 = getelementptr inbounds i32, i32* %154, i64 0
%156 = load i32, i32* %155
%157 = call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %151, i32 %152, double* %153, i32 %156)
%158 = load double*, double** %11
%159 = load i32, i32* %12
%160 = load double*, double** %26
%161 = load i32, i32* %12
%162 = call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %158, i32 %159, double* %160, i32 %161)
store i32 0, i32* %21
br label %163
163: ; preds = %283, %143
%164 = load i32, i32* %21
%165 = load i32, i32* %20
%166 = icmp slt i32 %164, %165
br i1 %166, label %167, label %286
167: ; preds = %163
%168 = load double*, double** %26
%169 = load i32, i32* %12
%170 = load double*, double** %24
%171 = load i32, i32* %21
%172 = load i32, i32* %16
%173 = mul nsw i32 %171, %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds double, double* %170, i64 %174
%176 = load i32, i32* %12
%177 = load double*, double** %25
%178 = load i32, i32* %21
%179 = load i32, i32* %16
%180 = mul nsw i32 %178, %179
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double, double* %177, i64 %181
%183 = load i32, i32* %12
%184 = load double*, double** %27
%185 = load double*, double** %28
%186 = load i32*, i32** %23
%187 = load i32, i32* %21
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %186, i64 %188
%190 = load i32, i32* %189
%191 = call i32 (double*, i32, double*, i32, double*, i32, double*, double*, i32, ...) bitcast (i32 (...)* @swt_conv to i32 (double*, i32, double*, i32, double*, i32, double*, double*, i32, ...)*)(double* %168, i32 %169, double* %175, i32 %176, double* %182, i32 %183, double* %184, double* %185, i32 %190)
%192 = load double*, double** %24
%193 = load i32, i32* %21
%194 = load i32, i32* %16
%195 = mul nsw i32 %193, %194
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %192, i64 %196
%198 = load i32, i32* %12
%199 = load double*, double** %26
%200 = load i32, i32* %12
%201 = call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %197, i32 %198, double* %199, i32 %200)
%202 = load i32, i32* %21
%203 = load i32, i32* %20
%204 = sub nsw i32 %203, 1
%205 = icmp slt i32 %202, %204
br i1 %205, label %206, label %282
206: ; preds = %167
store i32 0, i32* %22
br label %207
207: ; preds = %248, %206
%208 = load i32, i32* %22
%209 = load i32*, i32** %23
%210 = load i32, i32* %21
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i32, i32* %209, i64 %211
%213 = load i32, i32* %212
%214 = icmp slt i32 %208, %213
br i1 %214, label %215, label %251
215: ; preds = %207
%216 = load double*, double** %27
%217 = load i32, i32* %22
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %216, i64 %218
%220 = load double, double* %219
%221 = load double*, double** %29
%222 = load i32, i32* %22
%223 = mul nsw i32 2, %222
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds double, double* %221, i64 %224
store double %220, double* %225
%226 = load double*, double** %29
%227 = load i32, i32* %22
%228 = mul nsw i32 2, %227
%229 = add nsw i32 %228, 1
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %226, i64 %230
store double 0.000000e+00, double* %231
%232 = load double*, double** %28
%233 = load i32, i32* %22
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds double, double* %232, i64 %234
%236 = load double, double* %235
%237 = load double*, double** %30
%238 = load i32, i32* %22
%239 = mul nsw i32 2, %238
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %237, i64 %240
store double %236, double* %241
%242 = load double*, double** %30
%243 = load i32, i32* %22
%244 = mul nsw i32 2, %243
%245 = add nsw i32 %244, 1
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double, double* %242, i64 %246
store double 0.000000e+00, double* %247
br label %248
248: ; preds = %215
%249 = load i32, i32* %22
%250 = add nsw i32 %249, 1
store i32 %250, i32* %22
br label %207
251: ; preds = %207
%252 = load double*, double** %29
%253 = load i32*, i32** %23
%254 = load i32, i32* %21
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds i32, i32* %253, i64 %255
%257 = load i32, i32* %256
%258 = mul nsw i32 %257, 2
%259 = load double*, double** %27
%260 = load i32*, i32** %23
%261 = load i32, i32* %21
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i32, i32* %260, i64 %262
%264 = load i32, i32* %263
%265 = mul nsw i32 %264, 2
%266 = call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %252, i32 %258, double* %259, i32 %265)
%267 = load double*, double** %30
%268 = load i32*, i32** %23
%269 = load i32, i32* %21
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i32, i32* %268, i64 %270
%272 = load i32, i32* %271
%273 = mul nsw i32 %272, 2
%274 = load double*, double** %28
%275 = load i32*, i32** %23
%276 = load i32, i32* %21
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds i32, i32* %275, i64 %277
%279 = load i32, i32* %278
%280 = mul nsw i32 %279, 2
%281 = call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %267, i32 %273, double* %274, i32 %280)
br label %282
282: ; preds = %251, %167
br label %283
283: ; preds = %282
%284 = load i32, i32* %21
%285 = add nsw i32 %284, 1
store i32 %285, i32* %21
br label %163
286: ; preds = %163
%287 = load double*, double** %26
%288 = bitcast double* %287 to i8*
%289 = load double*, double** %24
%290 = load i32, i32* %15
%291 = load i32, i32* %16
%292 = load double*, double** %13
%293 = load i32, i32* %16
%294 = load i32, i32* %15
%295 = call i32 (double*, i32, i32, double*, i32, i32, ...) bitcast (i32 (...)* @matrix_tran to i32 (double*, i32, i32, double*, i32, i32, ...)*)(double* %289, i32 %290, i32 %291, double* %292, i32 %293, i32 %294)
%296 = load double*, double** %25
%297 = load i32, i32* %15
%298 = load i32, i32* %16
%299 = load double*, double** %14
%300 = load i32, i32* %16
%301 = load i32, i32* %15
%302 = call i32 (double*, i32, i32, double*, i32, i32, ...) bitcast (i32 (...)* @matrix_tran to i32 (double*, i32, i32, double*, i32, i32, ...)*)(double* %296, i32 %297, i32 %298, double* %299, i32 %300, i32 %301)
%303 = load double*, double** %24
%304 = bitcast double* %303 to i8*
%305 = load double*, double** %25
%306 = bitcast double* %305 to i8*
%307 = load double*, double** %29
%308 = bitcast double* %307 to i8*
%309 = load double*, double** %30
%310 = bitcast double* %309 to i8*
%311 = load double*, double** %27
%312 = bitcast double* %311 to i8*
%313 = load double*, double** %28
%314 = bitcast double* %313 to i8*
%315 = load i32*, i32** %23
%316 = bitcast i32* %315 to i8*
ret void
}

LLVM IR (-O2):
define void @swt_out2(double* %0, i32 %1, double* %2, double* %3, i32 %4, i32 %5, double* %6, double* %7, i32 %8, i32 %9) {
%11 = sext i32 %9 to i64
%12 = shl nsw i64 %11, 2
%13 = tail call i8* @malloc(i64 %12)
%14 = bitcast i8* %13 to i32*
%15 = sext i32 %5 to i64
%16 = shl nsw i64 %15, 3
%17 = tail call i8* @malloc(i64 %16)
%18 = bitcast i8* %17 to double*
%19 = mul nsw i32 %5, %4
%20 = sext i32 %19 to i64
%21 = shl nsw i64 %20, 3
%22 = tail call i8* @malloc(i64 %21)
%23 = bitcast i8* %22 to double*
%24 = tail call i8* @malloc(i64 %21)
%25 = bitcast i8* %24 to double*
store i32 %8, i32* %14
%26 = icmp sgt i32 %9, 1
br i1 %26, label %27, label %66
27: ; preds = %10
%28 = zext i32 %9 to i64
%29 = add nsw i64 %28, -1
%30 = add nsw i64 %28, -2
%31 = and i64 %29, 3
%32 = icmp ult i64 %30, 3
br i1 %32, label %53, label %33
33: ; preds = %27
%34 = and i64 %29, -4
br label %35
35: ; preds = %35, %33
%36 = phi i32 [ %8, %33 ], [ %48, %35 ]
%37 = phi i64 [ 1, %33 ], [ %50, %35 ]
%38 = phi i64 [ 0, %33 ], [ %51, %35 ]
%39 = shl nsw i32 %36, 1
%40 = getelementptr inbounds i32, i32* %14, i64 %37
store i32 %39, i32* %40
%41 = add nuw nsw i64 %37, 1
%42 = shl nsw i32 %36, 2
%43 = getelementptr inbounds i32, i32* %14, i64 %41
store i32 %42, i32* %43
%44 = add nuw nsw i64 %37, 2
%45 = shl nsw i32 %36, 3
%46 = getelementptr inbounds i32, i32* %14, i64 %44
store i32 %45, i32* %46
%47 = add nuw nsw i64 %37, 3
%48 = shl nsw i32 %36, 4
%49 = getelementptr inbounds i32, i32* %14, i64 %47
store i32 %48, i32* %49
%50 = add nuw nsw i64 %37, 4
%51 = add i64 %38, 4
%52 = icmp eq i64 %51, %34
br i1 %52, label %53, label %35
53: ; preds = %35, %27
%54 = phi i32 [ %8, %27 ], [ %48, %35 ]
%55 = phi i64 [ 1, %27 ], [ %50, %35 ]
%56 = icmp eq i64 %31, 0
br i1 %56, label %66, label %57
57: ; preds = %53, %57
%58 = phi i32 [ %61, %57 ], [ %54, %53 ]
%59 = phi i64 [ %63, %57 ], [ %55, %53 ]
%60 = phi i64 [ %64, %57 ], [ 0, %53 ]
%61 = shl nsw i32 %58, 1
%62 = getelementptr inbounds i32, i32* %14, i64 %59
store i32 %61, i32* %62
%63 = add nuw nsw i64 %59, 1
%64 = add i64 %60, 1
%65 = icmp eq i64 %64, %31
br i1 %65, label %66, label %57
66: ; preds = %53, %57, %10
%67 = add nsw i32 %9, -1
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %14, i64 %68
%70 = load i32, i32* %69
%71 = sext i32 %70 to i64
%72 = shl nsw i64 %71, 3
%73 = tail call i8* @malloc(i64 %72)
%74 = bitcast i8* %73 to double*
%75 = tail call i8* @malloc(i64 %72)
%76 = bitcast i8* %75 to double*
%77 = tail call i8* @malloc(i64 %72)
%78 = bitcast i8* %77 to double*
%79 = tail call i8* @malloc(i64 %72)
%80 = bitcast i8* %79 to double*
%81 = icmp sgt i32 %70, 0
br i1 %81, label %82, label %85
82: ; preds = %66
%83 = zext i32 %70 to i64
%84 = shl nuw nsw i64 %83, 3
br label %85
85: ; preds = %82, %66
%86 = tail call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %6, i32 %8, double* %74, i32 %8)
%87 = tail call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %7, i32 %8, double* %76, i32 %8)
%88 = tail call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %0, i32 %1, double* %18, i32 %1)
%89 = icmp sgt i32 %9, 0
br i1 %89, label %90, label %202
90: ; preds = %85
%91 = zext i32 %9 to i64
%92 = getelementptr inbounds double, double* %78, i64 -1
%93 = getelementptr inbounds double, double* %80, i64 -1
%94 = getelementptr inbounds double, double* %78, i64 -1
%95 = getelementptr inbounds double, double* %80, i64 -1
%96 = getelementptr inbounds double, double* %78, i64 -1
%97 = getelementptr inbounds double, double* %80, i64 -1
br label %98
98: ; preds = %199, %90
%99 = phi i32 [ %8, %90 ], [ %201, %199 ]
%100 = phi i64 [ 0, %90 ], [ %197, %199 ]
%101 = mul nsw i64 %100, %15
%102 = getelementptr inbounds double, double* %23, i64 %101
%103 = getelementptr inbounds double, double* %25, i64 %101
%104 = tail call i32 (double*, i32, double*, i32, double*, i32, double*, double*, i32, ...) bitcast (i32 (...)* @swt_conv to i32 (double*, i32, double*, i32, double*, i32, double*, double*, i32, ...)*)(double* %18, i32 %1, double* %102, i32 %1, double* %103, i32 %1, double* %74, double* %76, i32 %99)
%105 = tail call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %102, i32 %1, double* %18, i32 %1)
%106 = icmp slt i64 %100, %68
br i1 %106, label %107, label %196
107: ; preds = %98
%108 = icmp sgt i32 %99, 0
br i1 %108, label %109, label %192
109: ; preds = %107
%110 = zext i32 %99 to i64
%111 = icmp eq i32 %99, 1
br i1 %111, label %176, label %112
112: ; preds = %109
%113 = and i64 %110, 4294967294
%114 = add nsw i64 %113, -2
%115 = lshr exact i64 %114, 1
%116 = add nuw i64 %115, 1
%117 = and i64 %116, 1
%118 = icmp eq i64 %114, 0
br i1 %118, label %156, label %119
119: ; preds = %112
%120 = and i64 %116, -2
br label %121
121: ; preds = %121, %119
%122 = phi i64 [ 0, %119 ], [ %153, %121 ]
%123 = phi i64 [ 0, %119 ], [ %154, %121 ]
%124 = getelementptr inbounds double, double* %74, i64 %122
%125 = bitcast double* %124 to <2 x double>*
%126 = load <2 x double>, <2 x double>* %125
%127 = shl nuw nsw i64 %122, 1
%128 = or i64 %127, 1
%129 = getelementptr inbounds double, double* %92, i64 %128
%130 = bitcast double* %129 to <4 x double>*
%131 = shufflevector <2 x double> %126, <2 x double> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %131, <4 x double>* %130
%132 = getelementptr inbounds double, double* %76, i64 %122
%133 = bitcast double* %132 to <2 x double>*
%134 = load <2 x double>, <2 x double>* %133
%135 = getelementptr inbounds double, double* %93, i64 %128
%136 = bitcast double* %135 to <4 x double>*
%137 = shufflevector <2 x double> %134, <2 x double> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %137, <4 x double>* %136
%138 = or i64 %122, 2
%139 = getelementptr inbounds double, double* %74, i64 %138
%140 = bitcast double* %139 to <2 x double>*
%141 = load <2 x double>, <2 x double>* %140
%142 = shl nuw nsw i64 %138, 1
%143 = or i64 %142, 1
%144 = getelementptr inbounds double, double* %94, i64 %143
%145 = bitcast double* %144 to <4 x double>*
%146 = shufflevector <2 x double> %141, <2 x double> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %146, <4 x double>* %145
%147 = getelementptr inbounds double, double* %76, i64 %138
%148 = bitcast double* %147 to <2 x double>*
%149 = load <2 x double>, <2 x double>* %148
%150 = getelementptr inbounds double, double* %95, i64 %143
%151 = bitcast double* %150 to <4 x double>*
%152 = shufflevector <2 x double> %149, <2 x double> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %152, <4 x double>* %151
%153 = add nuw i64 %122, 4
%154 = add nuw i64 %123, 2
%155 = icmp eq i64 %154, %120
br i1 %155, label %156, label %121
156: ; preds = %121, %112
%157 = phi i64 [ 0, %112 ], [ %153, %121 ]
%158 = icmp eq i64 %117, 0
br i1 %158, label %174, label %159
159: ; preds = %156
%160 = getelementptr inbounds double, double* %74, i64 %157
%161 = bitcast double* %160 to <2 x double>*
%162 = load <2 x double>, <2 x double>* %161
%163 = shl nuw nsw i64 %157, 1
%164 = or i64 %163, 1
%165 = getelementptr inbounds double, double* %96, i64 %164
%166 = bitcast double* %165 to <4 x double>*
%167 = shufflevector <2 x double> %162, <2 x double> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %167, <4 x double>* %166
%168 = getelementptr inbounds double, double* %76, i64 %157
%169 = bitcast double* %168 to <2 x double>*
%170 = load <2 x double>, <2 x double>* %169
%171 = getelementptr inbounds double, double* %97, i64 %164
%172 = bitcast double* %171 to <4 x double>*
%173 = shufflevector <2 x double> %170, <2 x double> zeroinitializer, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x double> %173, <4 x double>* %172
br label %174
174: ; preds = %156, %159
%175 = icmp eq i64 %113, %110
br i1 %175, label %192, label %176
176: ; preds = %109, %174
%177 = phi i64 [ 0, %109 ], [ %113, %174 ]
br label %178
178: ; preds = %176, %178
%179 = phi i64 [ %190, %178 ], [ %177, %176 ]
%180 = getelementptr inbounds double, double* %74, i64 %179
%181 = load double, double* %180
%182 = shl nuw nsw i64 %179, 1
%183 = getelementptr inbounds double, double* %78, i64 %182
store double %181, double* %183
%184 = or i64 %182, 1
%185 = getelementptr inbounds double, double* %78, i64 %184
store double 0.000000e+00, double* %185
%186 = getelementptr inbounds double, double* %76, i64 %179
%187 = load double, double* %186
%188 = getelementptr inbounds double, double* %80, i64 %182
store double %187, double* %188
%189 = getelementptr inbounds double, double* %80, i64 %184
store double 0.000000e+00, double* %189
%190 = add nuw nsw i64 %179, 1
%191 = icmp eq i64 %190, %110
br i1 %191, label %192, label %178
192: ; preds = %178, %174, %107
%193 = shl nsw i32 %99, 1
%194 = tail call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %78, i32 %193, double* %74, i32 %193)
%195 = tail call i32 (double*, i32, double*, i32, ...) bitcast (i32 (...)* @verbatim_copy to i32 (double*, i32, double*, i32, ...)*)(double* %80, i32 %193, double* %76, i32 %193)
br label %196
196: ; preds = %98, %192
%197 = add nuw nsw i64 %100, 1
%198 = icmp eq i64 %197, %91
br i1 %198, label %202, label %199
199: ; preds = %196
%200 = getelementptr inbounds i32, i32* %14, i64 %197
%201 = load i32, i32* %200
br label %98
202: ; preds = %196, %85
tail call void @free(i8* %17)
%203 = tail call i32 (double*, i32, i32, double*, i32, i32, ...) bitcast (i32 (...)* @matrix_tran to i32 (double*, i32, i32, double*, i32, i32, ...)*)(double* %23, i32 %4, i32 %5, double* %2, i32 %5, i32 %4)
%204 = tail call i32 (double*, i32, i32, double*, i32, i32, ...) bitcast (i32 (...)* @matrix_tran to i32 (double*, i32, i32, double*, i32, i32, ...)*)(double* %25, i32 %4, i32 %5, double* %3, i32 %5, i32 %4)
tail call void @free(i8* %22)
tail call void @free(i8* %24)
tail call void @free(i8* %77)
tail call void @free(i8* %79)
tail call void @free(i8* %73)
tail call void @free(i8* %75)
tail call void @free(i8* %13)
ret void
}