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

/* Forward declarations */

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

/* Variables and functions */
int /*<<< orphan*/ _mm_add_pd(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ _mm_load_sd(double *);
int /*<<< orphan*/ _mm_loadu_pd(double *);
int /*<<< orphan*/ _mm_mul_pd(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ _mm_shuffle_pd(int /*<<< orphan*/, int /*<<< orphan*/, int);
int /*<<< orphan*/ _mm_storeu_pd(double *, int /*<<< orphan*/);
int /*<<< orphan*/ _mm_unpacklo_pd(int /*<<< orphan*/, int /*<<< orphan*/);
void transposeacc_misaligned(double *a, double *b, int N1, int N2,
                             double factor) {
  int i, j, k, k1, it, jt, itt, jtt, it_bound, jt_bound, itt_bound, jtt_bound;
  int conflict, tmp, tmpN, offset, line_offset, setnum,
      set[8192 / (4 * sizeof(double))];
  double *pA, *pB;
  register __m128d x, y, z, w, p, q, fac_vector;
  fac_vector = _mm_load_sd(&factor);
  fac_vector = _mm_unpacklo_pd(fac_vector, fac_vector);
  itt_bound = (N1 / 8) * 8;
  for (itt = 0; itt < itt_bound; itt = itt + 5 * 8) {
    jtt_bound = (N2 / 8) * 8;
    for (jtt = 0; jtt < jtt_bound; jtt = jtt + 5 * 8) {
      it_bound = (itt + 5 * 8 > itt_bound) ? itt_bound : itt + 5 * 8;
      for (it = itt; it < it_bound; it = it + 8) {
        jt_bound = (jtt + 5 * 8 > itt_bound) ? jtt_bound : jtt + 5 * 8;
        for (jt = jtt; jt < jt_bound; jt = jt + 8) {
          k = 0;
          for (j = jt; j < jt + 8; j = j + 2) {
            for (i = it; i < it + 8; i = i + 2) {
              pA = a + i * N2 + j;
              pB = b + j * N1 + i;
              x = _mm_loadu_pd(pA);
              x = _mm_mul_pd(x, fac_vector);
              y = _mm_loadu_pd(pA + N2);
              y = _mm_mul_pd(y, fac_vector);
              p = _mm_loadu_pd(pB);
              q = _mm_loadu_pd(pB + N1);
              z = _mm_shuffle_pd(x, y, 0);
              w = _mm_shuffle_pd(x, y, 3);
              z = _mm_add_pd(z, p);
              w = _mm_add_pd(w, q);
              _mm_storeu_pd(pB, z);
              _mm_storeu_pd(pB + N1, w);
            }
          }
        }
      }
    }
    for (i = itt; i < itt + 5 * 8 && i < itt_bound; i++) {
      for (j = jtt_bound; j < N2; j++) {
        b[j * N1 + i] = factor * a[i * N2 + j] + b[j * N1 + i];
      }
    }
  }
  for (i = itt_bound; i < N1; i++) {
    for (j = 0; j < N2; j++) {
      b[j * N1 + i] = factor * a[i * N2 + j] + b[j * N1 + i];
    }
  }
}


x86 assembly (clang, -O0):
<transposeacc_misaligned>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4b0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
lea    -0x20(%rbp),%rdi
call   1050 <_mm_load_sd@plt>
mov    %eax,-0x49c(%rbp)
mov    -0x49c(%rbp),%edi
mov    -0x49c(%rbp),%esi
call   1030 <_mm_unpacklo_pd@plt>
mov    %eax,-0x49c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
shl    $0x3,%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1555 <transposeacc_misaligned+0x3e5>
mov    -0x18(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
shl    $0x3,%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    147f <transposeacc_misaligned+0x30f>
mov    -0x3c(%rbp),%eax
add    $0x28,%eax
cmp    -0x4c(%rbp),%eax
jle    1219 <transposeacc_misaligned+0xa9>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x4a0(%rbp)
jmp    1225 <transposeacc_misaligned+0xb5>
mov    -0x3c(%rbp),%eax
add    $0x28,%eax
mov    %eax,-0x4a0(%rbp)
mov    -0x4a0(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    146c <transposeacc_misaligned+0x2fc>
mov    -0x40(%rbp),%eax
add    $0x28,%eax
cmp    -0x4c(%rbp),%eax
jle    125d <transposeacc_misaligned+0xed>
mov    -0x50(%rbp),%eax
mov    %eax,-0x4a4(%rbp)
jmp    1269 <transposeacc_misaligned+0xf9>
mov    -0x40(%rbp),%eax
add    $0x28,%eax
mov    %eax,-0x4a4(%rbp)
mov    -0x4a4(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    1459 <transposeacc_misaligned+0x2e9>
movl   $0x0,-0x2c(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x38(%rbp),%ecx
add    $0x8,%ecx
cmp    %ecx,%eax
jge    1446 <transposeacc_misaligned+0x2d6>
mov    -0x34(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    $0x8,%ecx
cmp    %ecx,%eax
jge    1433 <transposeacc_misaligned+0x2c3>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x478(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x480(%rbp)
mov    -0x478(%rbp),%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,-0x484(%rbp)
mov    -0x484(%rbp),%edi
mov    -0x49c(%rbp),%esi
call   1080 <_mm_mul_pd@plt>
mov    %eax,-0x484(%rbp)
mov    -0x478(%rbp),%rdi
movslq -0x18(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,-0x488(%rbp)
mov    -0x488(%rbp),%edi
mov    -0x49c(%rbp),%esi
call   1080 <_mm_mul_pd@plt>
mov    %eax,-0x488(%rbp)
mov    -0x480(%rbp),%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,-0x494(%rbp)
mov    -0x480(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,-0x498(%rbp)
mov    -0x484(%rbp),%edi
mov    -0x488(%rbp),%esi
xor    %edx,%edx
call   1060 <_mm_shuffle_pd@plt>
mov    %eax,-0x48c(%rbp)
mov    -0x484(%rbp),%edi
mov    -0x488(%rbp),%esi
mov    $0x3,%edx
call   1060 <_mm_shuffle_pd@plt>
mov    %eax,-0x490(%rbp)
mov    -0x48c(%rbp),%edi
mov    -0x494(%rbp),%esi
call   1040 <_mm_add_pd@plt>
mov    %eax,-0x48c(%rbp)
mov    -0x490(%rbp),%edi
mov    -0x498(%rbp),%esi
call   1040 <_mm_add_pd@plt>
mov    %eax,-0x490(%rbp)
mov    -0x480(%rbp),%rdi
mov    -0x48c(%rbp),%esi
call   1070 <_mm_storeu_pd@plt>
mov    -0x480(%rbp),%rdi
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x490(%rbp),%esi
call   1070 <_mm_storeu_pd@plt>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    12a8 <transposeacc_misaligned+0x138>
jmp    1438 <transposeacc_misaligned+0x2c8>
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    1291 <transposeacc_misaligned+0x121>
jmp    144b <transposeacc_misaligned+0x2db>
mov    -0x38(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x38(%rbp)
jmp    1278 <transposeacc_misaligned+0x108>
jmp    145e <transposeacc_misaligned+0x2ee>
mov    -0x34(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x34(%rbp)
jmp    1234 <transposeacc_misaligned+0xc4>
jmp    1471 <transposeacc_misaligned+0x301>
mov    -0x40(%rbp),%eax
add    $0x28,%eax
mov    %eax,-0x40(%rbp)
jmp    11f0 <transposeacc_misaligned+0x80>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x3c(%rbp),%edx
add    $0x28,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x4a5(%rbp)
jge    14ad <transposeacc_misaligned+0x33d>
mov    -0x24(%rbp),%eax
cmp    -0x4c(%rbp),%eax
setl   %al
mov    %al,-0x4a5(%rbp)
mov    -0x4a5(%rbp),%al
test   $0x1,%al
jne    14c0 <transposeacc_misaligned+0x350>
jmp    1542 <transposeacc_misaligned+0x3d2>
mov    -0x50(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    152f <transposeacc_misaligned+0x3bf>
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14c6 <transposeacc_misaligned+0x356>
jmp    1534 <transposeacc_misaligned+0x3c4>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1485 <transposeacc_misaligned+0x315>
jmp    1547 <transposeacc_misaligned+0x3d7>
mov    -0x3c(%rbp),%eax
add    $0x28,%eax
mov    %eax,-0x3c(%rbp)
jmp    11cc <transposeacc_misaligned+0x5c>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15ea <transposeacc_misaligned+0x47a>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    15d7 <transposeacc_misaligned+0x467>
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    156e <transposeacc_misaligned+0x3fe>
jmp    15dc <transposeacc_misaligned+0x46c>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    155b <transposeacc_misaligned+0x3eb>
add    $0x4b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<transposeacc_misaligned>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x248,%rsp
mov    %ecx,%r14d
mov    %edx,%ebp
mov    %rsi,%r15
mov    %rdi,0x38(%rsp)
movsd  %xmm0,0x60(%rsp)
lea    0x60(%rsp),%rdi
call   1050 <_mm_load_sd@plt>
mov    %eax,%edi
mov    %eax,%esi
call   1030 <_mm_unpacklo_pd@plt>
lea    0x7(%rbp),%ecx
test   %ebp,%ebp
cmovns %ebp,%ecx
and    $0xfffffff8,%ecx
movslq %r14d,%r8
mov    %rbp,0x78(%rsp)
cmp    $0x8,%ebp
jl     1bf0 <transposeacc_misaligned+0xa80>
lea    0x7(%r8),%edx
test   %r8d,%r8d
cmovns %r14d,%edx
and    $0xfffffff8,%edx
mov    0x78(%rsp),%edi
mov    %edx,0x30(%rsp)
movslq %edx,%r10
movslq %ecx,%r11
mov    %r10,%r13
not    %r13
mov    %r10,%rdx
imul   %rdi,%rdx
mov    %rdx,0x1a0(%rsp)
lea    0x1(%r10),%rdx
mov    %rdx,0x198(%rsp)
mov    %r8,%rdx
neg    %rdx
mov    %rdx,0x1b0(%rsp)
lea    0x30(%r15),%rdx
mov    %rdx,0xd0(%rsp)
mov    %rdi,%rdx
shl    $0x6,%rdx
mov    %rdx,0x220(%rsp)
lea    (%rdx,%rdx,4),%rdx
mov    %rdx,0x1b8(%rsp)
mov    %rdi,%rdx
shl    $0x4,%rdx
mov    %rdx,0x128(%rsp)
lea    (%r15,%rdi,8),%rdx
add    $0x30,%rdx
mov    %rdx,0xc8(%rsp)
lea    0x20(%r15),%rdx
mov    %rdx,0xc0(%rsp)
mov    %r8,%rdx
shl    $0x6,%rdx
lea    (%r15,%rdi,8),%rsi
add    $0x20,%rsi
mov    %rsi,0xb8(%rsp)
lea    0x10(%r15),%rsi
mov    %rsi,0xb0(%rsp)
lea    0x10(%r15,%rdi,8),%rsi
mov    %rsi,0xa8(%rsp)
lea    (%r15,%rdi,8),%rsi
mov    %rsi,0xa0(%rsp)
mov    %rdx,0x1c8(%rsp)
lea    (%rdx,%rdx,4),%rdx
mov    %rdx,0x160(%rsp)
lea    0x0(,%r8,8),%rdx
mov    %rdx,0x8(%rsp)
mov    0x38(%rsp),%rsi
lea    0x8(%rsi),%rdx
mov    %rdx,0x98(%rsp)
mov    %rdi,0x1a8(%rsp)
lea    0x0(,%rdi,8),%rdx
mov    %rdx,0x190(%rsp)
xor    %edx,%edx
mov    %rdx,0x90(%rsp)
mov    %rsi,0x88(%rsp)
mov    %r15,0x80(%rsp)
xor    %r9d,%r9d
mov    %r14d,0x6c(%rsp)
mov    %r15,0x188(%rsp)
mov    %r8,0x180(%rsp)
mov    %ecx,0x2c(%rsp)
mov    %eax,0x4(%rsp)
mov    %r10,0x178(%rsp)
mov    %r11,0x170(%rsp)
mov    %r13,0x168(%rsp)
jmp    13d6 <transposeacc_misaligned+0x266>
nopl   (%rax)
addq   $0x140,0xd0(%rsp)
addq   $0x140,0xc8(%rsp)
addq   $0x140,0xc0(%rsp)
addq   $0x140,0xb8(%rsp)
addq   $0x140,0xb0(%rsp)
addq   $0x140,0xa8(%rsp)
addq   $0x140,0x80(%rsp)
addq   $0x140,0xa0(%rsp)
mov    0x160(%rsp),%rcx
add    %rcx,0x88(%rsp)
add    %rcx,0x98(%rsp)
addq   $0x140,0x90(%rsp)
mov    0x2c(%rsp),%ecx
mov    0x50(%rsp),%r9
cmp    %r9d,%ecx
jle    1bf0 <transposeacc_misaligned+0xa80>
lea    0x28(%r9),%rax
mov    %rax,0x50(%rsp)
cmp    $0x8,%r14d
jl     1ab0 <transposeacc_misaligned+0x940>
mov    0x2c(%rsp),%eax
mov    0x50(%rsp),%rcx
cmp    %ecx,%eax
cmovl  %eax,%ecx
mov    %ecx,0x70(%rsp)
movslq %ecx,%rax
mov    %rax,0x1c0(%rsp)
mov    0x88(%rsp),%rax
mov    %rax,0x118(%rsp)
mov    0xa0(%rsp),%rax
mov    %rax,0x110(%rsp)
mov    0x80(%rsp),%rax
mov    %rax,0x108(%rsp)
mov    0xa8(%rsp),%rax
mov    %rax,0x100(%rsp)
mov    0xb0(%rsp),%rax
mov    %rax,0xf8(%rsp)
mov    0xb8(%rsp),%rax
mov    %rax,0xf0(%rsp)
mov    0xc0(%rsp),%rax
mov    %rax,0xe8(%rsp)
mov    0xc8(%rsp),%rax
mov    %rax,0xe0(%rsp)
mov    0xd0(%rsp),%rax
mov    %rax,0xd8(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
mov    %r9,0x120(%rsp)
jmp    1524 <transposeacc_misaligned+0x3b4>
nopw   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rcx
add    $0x28,%rcx
mov    0x1b8(%rsp),%rax
add    %rax,0xd8(%rsp)
add    %rax,0xe0(%rsp)
add    %rax,0xe8(%rsp)
add    %rax,0xf0(%rsp)
add    %rax,0xf8(%rsp)
add    %rax,0x100(%rsp)
add    %rax,0x108(%rsp)
add    %rax,0x110(%rsp)
addq   $0x140,0x118(%rsp)
mov    %rcx,0x40(%rsp)
cmp    %ecx,0x30(%rsp)
mov    0x120(%rsp),%r9
jle    1ab0 <transposeacc_misaligned+0x940>
cmp    0x1c0(%rsp),%r9
jge    14b0 <transposeacc_misaligned+0x340>
mov    0x40(%rsp),%rax
add    $0x28,%eax
cmp    0x2c(%rsp),%eax
cmovg  0x30(%rsp),%eax
mov    %eax,0x34(%rsp)
mov    0x118(%rsp),%rax
mov    0x110(%rsp),%rcx
mov    0x108(%rsp),%rdx
mov    0x100(%rsp),%rsi
mov    0xf8(%rsp),%rdi
mov    0xf0(%rsp),%rbp
mov    0xe8(%rsp),%r10
mov    0xe0(%rsp),%r8
mov    0xd8(%rsp),%r9
mov    0x120(%rsp),%rbx
jmp    1626 <transposeacc_misaligned+0x4b6>
nopl   0x0(%rax,%rax,1)
mov    0x1d0(%rsp),%rbx
add    $0x8,%rbx
mov    0x1d8(%rsp),%r9
add    $0x40,%r9
mov    0x1e0(%rsp),%r8
add    $0x40,%r8
mov    0x1e8(%rsp),%r10
add    $0x40,%r10
mov    0x1f0(%rsp),%rbp
add    $0x40,%rbp
mov    0x1f8(%rsp),%rdi
add    $0x40,%rdi
mov    0x200(%rsp),%rsi
add    $0x40,%rsi
mov    0x208(%rsp),%rdx
add    $0x40,%rdx
mov    0x210(%rsp),%rcx
add    $0x40,%rcx
mov    0x218(%rsp),%rax
add    0x1c8(%rsp),%rax
cmp    %ebx,0x70(%rsp)
jle    14b0 <transposeacc_misaligned+0x340>
mov    %rbx,0x1d0(%rsp)
mov    %rax,0x218(%rsp)
mov    %rcx,0x210(%rsp)
mov    %rcx,%r15
mov    %rdx,0x208(%rsp)
mov    %rsi,0x200(%rsp)
mov    %rdi,0x1f8(%rsp)
mov    %rbp,0x1f0(%rsp)
mov    %r10,0x1e8(%rsp)
mov    %r8,0x1e0(%rsp)
mov    %r9,0x1d8(%rsp)
mov    0x40(%rsp),%rcx
mov    %rcx,0x48(%rsp)
cmp    %ecx,0x34(%rsp)
jle    15a0 <transposeacc_misaligned+0x430>
nopl   (%rax)
mov    %r9,0x130(%rsp)
mov    %r10,0x138(%rsp)
mov    %rdi,0x140(%rsp)
mov    %r8,0x148(%rsp)
mov    %rbp,0x150(%rsp)
mov    %rsi,0x158(%rsp)
mov    0x48(%rsp),%rsi
lea    0x8(%rsi),%rcx
mov    %rcx,0x48(%rsp)
mov    %rax,0x228(%rsp)
xor    %ecx,%ecx
mov    %r15,0x238(%rsp)
mov    %rdx,0x230(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %rcx,0x10(%rsp)
mov    %rax,0x58(%rsp)
mov    %rsi,0x240(%rsp)
lea    (%rdx,%rcx,1),%rbp
mov    %rbp,0x20(%rsp)
mov    0x58(%rsp),%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%edi
mov    0x4(%rsp),%ebx
mov    %ebx,%esi
call   1080 <_mm_mul_pd@plt>
mov    %eax,%r13d
mov    0x8(%rsp),%rax
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,1),%r12
mov    %r12,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%edi
mov    %ebx,%esi
call   1080 <_mm_mul_pd@plt>
mov    %eax,%r14d
mov    %rbp,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%ebx
mov    0x10(%rsp),%rax
lea    (%r15,%rax,1),%rdi
mov    %rdi,0x18(%rsp)
call   1090 <_mm_loadu_pd@plt>
mov    %eax,0x74(%rsp)
mov    %r13d,%edi
mov    %r14d,%esi
xor    %edx,%edx
call   1060 <_mm_shuffle_pd@plt>
mov    %eax,%r15d
mov    %r13d,%edi
mov    %r14d,%esi
mov    $0x3,%edx
call   1060 <_mm_shuffle_pd@plt>
mov    %eax,%ebp
mov    %r15d,%edi
mov    %ebx,%esi
call   1040 <_mm_add_pd@plt>
mov    %eax,%ebx
mov    %ebp,%edi
mov    0x74(%rsp),%esi
call   1040 <_mm_add_pd@plt>
mov    %eax,%ebp
mov    0x20(%rsp),%rdi
mov    %ebx,%esi
call   1070 <_mm_storeu_pd@plt>
mov    0x18(%rsp),%rdi
mov    %ebp,%esi
call   1070 <_mm_storeu_pd@plt>
mov    0x140(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,1),%rbp
mov    %rbp,0x20(%rsp)
add    0x8(%rsp),%r12
mov    %r12,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%edi
mov    0x4(%rsp),%ebx
mov    %ebx,%esi
call   1080 <_mm_mul_pd@plt>
mov    %eax,%r13d
add    0x8(%rsp),%r12
mov    %r12,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%edi
mov    %ebx,%esi
call   1080 <_mm_mul_pd@plt>
mov    %eax,%ebx
mov    %rbp,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%ebp
mov    0x158(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,1),%r14
mov    %r14,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,0x18(%rsp)
mov    %r13d,%edi
mov    %ebx,%esi
xor    %edx,%edx
call   1060 <_mm_shuffle_pd@plt>
mov    %eax,%r15d
mov    %r13d,%edi
mov    %ebx,%esi
mov    $0x3,%edx
call   1060 <_mm_shuffle_pd@plt>
mov    %eax,%ebx
mov    %r15d,%edi
mov    %ebp,%esi
call   1040 <_mm_add_pd@plt>
mov    %eax,%ebp
mov    %ebx,%edi
mov    0x18(%rsp),%esi
call   1040 <_mm_add_pd@plt>
mov    %eax,%ebx
mov    0x20(%rsp),%rdi
mov    %ebp,%esi
call   1070 <_mm_storeu_pd@plt>
mov    %r14,%rdi
mov    %ebx,%esi
call   1070 <_mm_storeu_pd@plt>
mov    0x138(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,1),%rbp
mov    %rbp,0x20(%rsp)
add    0x8(%rsp),%r12
mov    %r12,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%edi
mov    0x4(%rsp),%ebx
mov    %ebx,%esi
call   1080 <_mm_mul_pd@plt>
mov    %eax,%r13d
add    0x8(%rsp),%r12
mov    %r12,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%edi
mov    %ebx,%esi
call   1080 <_mm_mul_pd@plt>
mov    %eax,%ebx
mov    %rbp,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%ebp
mov    0x150(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,1),%r14
mov    %r14,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,0x18(%rsp)
mov    %r13d,%edi
mov    %ebx,%esi
xor    %edx,%edx
call   1060 <_mm_shuffle_pd@plt>
mov    %eax,%r15d
mov    %r13d,%edi
mov    %ebx,%esi
mov    $0x3,%edx
call   1060 <_mm_shuffle_pd@plt>
mov    %eax,%ebx
mov    %r15d,%edi
mov    %ebp,%esi
call   1040 <_mm_add_pd@plt>
mov    %eax,%ebp
mov    %ebx,%edi
mov    0x18(%rsp),%esi
call   1040 <_mm_add_pd@plt>
mov    %eax,%ebx
mov    0x20(%rsp),%rdi
mov    %ebp,%esi
call   1070 <_mm_storeu_pd@plt>
mov    %r14,%rdi
mov    %ebx,%esi
call   1070 <_mm_storeu_pd@plt>
mov    0x130(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,1),%rbp
mov    %rbp,0x20(%rsp)
add    0x8(%rsp),%r12
mov    %r12,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%edi
mov    0x4(%rsp),%ebx
mov    %ebx,%esi
call   1080 <_mm_mul_pd@plt>
mov    %eax,%r13d
add    0x8(%rsp),%r12
mov    %r12,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%edi
mov    %ebx,%esi
call   1080 <_mm_mul_pd@plt>
mov    %eax,%ebx
mov    %rbp,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,%r12d
mov    0x148(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,1),%r14
mov    %r14,%rdi
call   1090 <_mm_loadu_pd@plt>
mov    %eax,0x18(%rsp)
mov    %r13d,%edi
mov    %ebx,%esi
xor    %edx,%edx
call   1060 <_mm_shuffle_pd@plt>
mov    %eax,%r15d
mov    %r13d,%edi
mov    %ebx,%esi
mov    $0x3,%edx
call   1060 <_mm_shuffle_pd@plt>
mov    %eax,%ebx
mov    %r15d,%edi
mov    0x238(%rsp),%r15
mov    %r12d,%esi
call   1040 <_mm_add_pd@plt>
mov    %eax,%ebp
mov    %ebx,%edi
mov    0x18(%rsp),%esi
call   1040 <_mm_add_pd@plt>
mov    %eax,%ebx
mov    0x20(%rsp),%rdi
mov    %ebp,%esi
call   1070 <_mm_storeu_pd@plt>
mov    %r14,%rdi
mov    %ebx,%esi
call   1070 <_mm_storeu_pd@plt>
mov    0x10(%rsp),%rcx
mov    0x58(%rsp),%rax
mov    0x240(%rsp),%rsi
mov    0x230(%rsp),%rdx
add    $0x2,%rsi
add    0x128(%rsp),%rcx
add    $0x10,%rax
cmp    0x48(%rsp),%rsi
jb     16f0 <transposeacc_misaligned+0x580>
mov    0x220(%rsp),%rax
mov    0x130(%rsp),%r9
add    %rax,%r9
mov    0x148(%rsp),%r8
add    %rax,%r8
mov    0x138(%rsp),%rbx
add    %rax,%rbx
mov    0x150(%rsp),%rbp
add    %rax,%rbp
mov    0x140(%rsp),%rdi
add    %rax,%rdi
mov    0x158(%rsp),%rsi
add    %rax,%rsi
add    %rax,%rdx
add    %rax,%r15
mov    0x228(%rsp),%rax
add    $0x40,%rax
mov    0x48(%rsp),%rcx
cmp    %ecx,0x34(%rsp)
mov    %rbx,%r10
jg     1690 <transposeacc_misaligned+0x520>
jmp    15a0 <transposeacc_misaligned+0x430>
mov    0x170(%rsp),%r11
cmp    %r11,%r9
mov    0x6c(%rsp),%r14d
mov    0x188(%rsp),%r15
mov    0x180(%rsp),%r8
mov    0x178(%rsp),%r10
mov    0x168(%rsp),%r13
jge    1340 <transposeacc_misaligned+0x1d0>
movsd  0x60(%rsp),%xmm0
mov    0x90(%rsp),%rbx
mov    0x98(%rsp),%rcx
nopl   0x0(%rax)
cmp    %r14d,0x30(%rsp)
jge    1bc7 <transposeacc_misaligned+0xa57>
mov    %r10,%rdx
test   $0x1,%r8b
je     1b4e <transposeacc_misaligned+0x9de>
mov    %r9,%rdi
mov    %r9,%rdx
imul   %r8,%rdx
add    %r10,%rdx
mov    0x1a0(%rsp),%rsi
add    %r9,%rsi
mov    0x38(%rsp),%rdi
movsd  (%rdi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r15,%rsi,8),%xmm1
movsd  %xmm1,(%r15,%rsi,8)
mov    0x198(%rsp),%rdx
cmp    0x1b0(%rsp),%r13
mov    0x128(%rsp),%r12
je     1bc7 <transposeacc_misaligned+0xa57>
mov    0x1a8(%rsp),%rsi
imul   %rdx,%rsi
add    %r9,%rsi
lea    0x1(%rdx),%rdi
imul   0x190(%rsp),%rdi
add    %rbx,%rdi
mov    %r15,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rcx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%rbp,%rsi,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rsi,8)
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%rbp,%rdi,1),%xmm1
movsd  %xmm1,0x0(%rbp,%rdi,1)
add    $0x2,%rdx
add    %r12,%rbp
cmp    %rdx,%r8
jne    1b90 <transposeacc_misaligned+0xa20>
add    $0x1,%r9
cmp    0x50(%rsp),%r9
mov    0x8(%rsp),%rdx
jae    1340 <transposeacc_misaligned+0x1d0>
add    %rdx,%rcx
add    $0x8,%rbx
cmp    %r11,%r9
jl     1b00 <transposeacc_misaligned+0x990>
jmp    1340 <transposeacc_misaligned+0x1d0>
mov    0x78(%rsp),%rax
cmp    %eax,%ecx
jge    1cf6 <transposeacc_misaligned+0xb86>
movslq %ecx,%r11
movsd  0x60(%rsp),%xmm0
movslq %eax,%r10
mov    %r14d,%r12d
mov    %r12d,%r13d
and    $0xfffffffe,%r13d
mov    %r8,%rax
imul   %r11,%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
add    $0x8,%rdi
lea    0x0(,%r8,8),%r9
lea    (%r10,%r11,1),%rax
lea    (%r15,%rax,8),%rsi
mov    %r10,%rcx
shl    $0x4,%rcx
lea    (%r15,%r11,8),%rbp
mov    0x38(%rsp),%rbx
jmp    1c68 <transposeacc_misaligned+0xaf8>
nopl   0x0(%rax)
add    $0x1,%r11
add    %r9,%rdi
add    $0x8,%rsi
add    $0x8,%rbp
cmp    %r10,%r11
je     1cf6 <transposeacc_misaligned+0xb86>
test   %r14d,%r14d
jle    1c50 <transposeacc_misaligned+0xae0>
cmp    $0x1,%r14d
jne    1c80 <transposeacc_misaligned+0xb10>
xor    %edx,%edx
jmp    1cc5 <transposeacc_misaligned+0xb55>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rdi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%rbp,%rax,1),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,1)
movsd  (%rdi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rax,1),%xmm1
movsd  %xmm1,(%rsi,%rax,1)
add    $0x2,%rdx
add    %rcx,%rax
cmp    %rdx,%r13
jne    1c90 <transposeacc_misaligned+0xb20>
test   $0x1,%r12b
je     1c50 <transposeacc_misaligned+0xae0>
mov    %r11,%rax
imul   %r8,%rax
add    %rdx,%rax
imul   %r10,%rdx
add    %r11,%rdx
movsd  (%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r15,%rdx,8),%xmm1
movsd  %xmm1,(%r15,%rdx,8)
jmp    1c50 <transposeacc_misaligned+0xae0>
add    $0x248,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @transposeacc_misaligned(double* %0, double* %1, i32 %2, i32 %3, double %4) {
%6 = alloca double
store double %4, double* %6
%7 = call i32 @_mm_load_sd(double* %6)
%8 = call i32 @_mm_unpacklo_pd(i32 %7, i32 %7)
%9 = sdiv i32 %2, 8
%10 = shl nsw i32 %9, 3
%11 = icmp sgt i32 %2, 7
br i1 %11, label %12, label %31
12: ; preds = %5
%13 = sdiv i32 %3, 8
%14 = shl nsw i32 %13, 3
%15 = icmp sgt i32 %3, 7
%16 = sext i32 %3 to i64
%17 = zext i32 %2 to i64
%18 = icmp slt i32 %14, %3
%19 = sext i32 %14 to i64
%20 = sext i32 %10 to i64
%21 = xor i64 %19, -1
%22 = and i64 %16, 1
%23 = icmp eq i64 %22, 0
%24 = mul nsw i64 %19, %17
%25 = or i64 %19, 1
%26 = sub nsw i64 0, %16
%27 = icmp eq i64 %21, %26
br label %44
28: ; preds = %198, %53
%29 = trunc i64 %46 to i32
%30 = icmp sgt i32 %10, %29
br i1 %30, label %44, label %31
31: ; preds = %28, %5
%32 = icmp slt i32 %10, %2
br i1 %32, label %33, label %244
33: ; preds = %31
%34 = icmp sgt i32 %3, 0
%35 = load double, double* %6
%36 = sext i32 %2 to i64
%37 = sext i32 %10 to i64
%38 = sext i32 %3 to i64
%39 = zext i32 %3 to i64
%40 = and i64 %39, 1
%41 = icmp eq i32 %3, 1
%42 = and i64 %39, 4294967294
%43 = icmp eq i64 %40, 0
br label %203
44: ; preds = %12, %28
%45 = phi i64 [ 0, %12 ], [ %46, %28 ]
%46 = add nuw i64 %45, 40
br i1 %15, label %47, label %53
47: ; preds = %44
%48 = trunc i64 %46 to i32
%49 = icmp slt i32 %10, %48
%50 = select i1 %49, i32 %10, i32 %48
%51 = sext i32 %50 to i64
%52 = icmp slt i64 %45, %51
br label %57
53: ; preds = %159, %44
%54 = icmp slt i64 %45, %20
br i1 %54, label %55, label %28
55: ; preds = %53
%56 = load double, double* %6
br label %163
57: ; preds = %47, %159
%58 = phi i64 [ 0, %47 ], [ %160, %159 ]
%59 = trunc i64 %58 to i32
br i1 %52, label %60, label %159
60: ; preds = %57
%61 = add nuw nsw i32 %59, 40
%62 = icmp sgt i32 %61, %10
%63 = select i1 %62, i32 %14, i32 %61
%64 = icmp sgt i32 %63, %59
br label %65
65: ; preds = %60, %155
%66 = phi i64 [ %45, %60 ], [ %156, %155 ]
br i1 %64, label %67, label %155
67: ; preds = %65
%68 = mul nsw i64 %66, %16
%69 = getelementptr inbounds double, double* %0, i64 %68
%70 = or i64 %66, 2
%71 = mul nsw i64 %70, %16
%72 = getelementptr inbounds double, double* %0, i64 %71
%73 = or i64 %66, 4
%74 = mul nsw i64 %73, %16
%75 = getelementptr inbounds double, double* %0, i64 %74
%76 = or i64 %66, 6
%77 = mul nsw i64 %76, %16
%78 = getelementptr inbounds double, double* %0, i64 %77
br label %82
79: ; preds = %85
%80 = trunc i64 %84 to i32
%81 = icmp sgt i32 %63, %80
br i1 %81, label %82, label %155
82: ; preds = %67, %79
%83 = phi i64 [ %58, %67 ], [ %84, %79 ]
%84 = add nuw i64 %83, 8
br label %85
85: ; preds = %82, %85
%86 = phi i64 [ %83, %82 ], [ %153, %85 ]
%87 = mul nsw i64 %86, %17
%88 = getelementptr inbounds double, double* %1, i64 %87
%89 = getelementptr inbounds double, double* %69, i64 %86
%90 = getelementptr inbounds double, double* %88, i64 %66
%91 = call i32 @_mm_loadu_pd(double* %89)
%92 = call i32 @_mm_mul_pd(i32 %91, i32 %8)
%93 = getelementptr inbounds double, double* %89, i64 %16
%94 = call i32 @_mm_loadu_pd(double* %93)
%95 = call i32 @_mm_mul_pd(i32 %94, i32 %8)
%96 = call i32 @_mm_loadu_pd(double* %90)
%97 = getelementptr inbounds double, double* %90, i64 %17
%98 = call i32 @_mm_loadu_pd(double* %97)
%99 = call i32 @_mm_shuffle_pd(i32 %92, i32 %95, i32 0)
%100 = call i32 @_mm_shuffle_pd(i32 %92, i32 %95, i32 3)
%101 = call i32 @_mm_add_pd(i32 %99, i32 %96)
%102 = call i32 @_mm_add_pd(i32 %100, i32 %98)
%103 = call i32 @_mm_storeu_pd(double* %90, i32 %101)
%104 = call i32 @_mm_storeu_pd(double* %97, i32 %102)
%105 = getelementptr inbounds double, double* %72, i64 %86
%106 = getelementptr inbounds double, double* %88, i64 %70
%107 = call i32 @_mm_loadu_pd(double* %105)
%108 = call i32 @_mm_mul_pd(i32 %107, i32 %8)
%109 = getelementptr inbounds double, double* %105, i64 %16
%110 = call i32 @_mm_loadu_pd(double* %109)
%111 = call i32 @_mm_mul_pd(i32 %110, i32 %8)
%112 = call i32 @_mm_loadu_pd(double* %106)
%113 = getelementptr inbounds double, double* %106, i64 %17
%114 = call i32 @_mm_loadu_pd(double* %113)
%115 = call i32 @_mm_shuffle_pd(i32 %108, i32 %111, i32 0)
%116 = call i32 @_mm_shuffle_pd(i32 %108, i32 %111, i32 3)
%117 = call i32 @_mm_add_pd(i32 %115, i32 %112)
%118 = call i32 @_mm_add_pd(i32 %116, i32 %114)
%119 = call i32 @_mm_storeu_pd(double* %106, i32 %117)
%120 = call i32 @_mm_storeu_pd(double* %113, i32 %118)
%121 = getelementptr inbounds double, double* %75, i64 %86
%122 = getelementptr inbounds double, double* %88, i64 %73
%123 = call i32 @_mm_loadu_pd(double* %121)
%124 = call i32 @_mm_mul_pd(i32 %123, i32 %8)
%125 = getelementptr inbounds double, double* %121, i64 %16
%126 = call i32 @_mm_loadu_pd(double* %125)
%127 = call i32 @_mm_mul_pd(i32 %126, i32 %8)
%128 = call i32 @_mm_loadu_pd(double* %122)
%129 = getelementptr inbounds double, double* %122, i64 %17
%130 = call i32 @_mm_loadu_pd(double* %129)
%131 = call i32 @_mm_shuffle_pd(i32 %124, i32 %127, i32 0)
%132 = call i32 @_mm_shuffle_pd(i32 %124, i32 %127, i32 3)
%133 = call i32 @_mm_add_pd(i32 %131, i32 %128)
%134 = call i32 @_mm_add_pd(i32 %132, i32 %130)
%135 = call i32 @_mm_storeu_pd(double* %122, i32 %133)
%136 = call i32 @_mm_storeu_pd(double* %129, i32 %134)
%137 = getelementptr inbounds double, double* %78, i64 %86
%138 = getelementptr inbounds double, double* %88, i64 %76
%139 = call i32 @_mm_loadu_pd(double* %137)
%140 = call i32 @_mm_mul_pd(i32 %139, i32 %8)
%141 = getelementptr inbounds double, double* %137, i64 %16
%142 = call i32 @_mm_loadu_pd(double* %141)
%143 = call i32 @_mm_mul_pd(i32 %142, i32 %8)
%144 = call i32 @_mm_loadu_pd(double* %138)
%145 = getelementptr inbounds double, double* %138, i64 %17
%146 = call i32 @_mm_loadu_pd(double* %145)
%147 = call i32 @_mm_shuffle_pd(i32 %140, i32 %143, i32 0)
%148 = call i32 @_mm_shuffle_pd(i32 %140, i32 %143, i32 3)
%149 = call i32 @_mm_add_pd(i32 %147, i32 %144)
%150 = call i32 @_mm_add_pd(i32 %148, i32 %146)
%151 = call i32 @_mm_storeu_pd(double* %138, i32 %149)
%152 = call i32 @_mm_storeu_pd(double* %145, i32 %150)
%153 = add nuw i64 %86, 2
%154 = icmp ult i64 %153, %84
br i1 %154, label %85, label %79
155: ; preds = %79, %65
%156 = add nuw i64 %66, 8
%157 = trunc i64 %156 to i32
%158 = icmp sgt i32 %50, %157
br i1 %158, label %65, label %159
159: ; preds = %155, %57
%160 = add nuw i64 %58, 40
%161 = trunc i64 %160 to i32
%162 = icmp sgt i32 %14, %161
br i1 %162, label %57, label %53
163: ; preds = %55, %198
%164 = phi i64 [ %45, %55 ], [ %199, %198 ]
br i1 %18, label %165, label %198
165: ; preds = %163
%166 = mul nsw i64 %164, %16
br i1 %23, label %175, label %167
167: ; preds = %165
%168 = add nsw i64 %166, %19
%169 = getelementptr inbounds double, double* %0, i64 %168
%170 = load double, double* %169
%171 = add nsw i64 %24, %164
%172 = getelementptr inbounds double, double* %1, i64 %171
%173 = load double, double* %172
%174 = call double @llvm.fmuladd.f64(double %56, double %170, double %173)
store double %174, double* %172
br label %175
175: ; preds = %167, %165
%176 = phi i64 [ %19, %165 ], [ %25, %167 ]
br i1 %27, label %198, label %177
177: ; preds = %175, %177
%178 = phi i64 [ %196, %177 ], [ %176, %175 ]
%179 = add nsw i64 %178, %166
%180 = getelementptr inbounds double, double* %0, i64 %179
%181 = load double, double* %180
%182 = mul nsw i64 %178, %17
%183 = add nsw i64 %182, %164
%184 = getelementptr inbounds double, double* %1, i64 %183
%185 = load double, double* %184
%186 = call double @llvm.fmuladd.f64(double %56, double %181, double %185)
store double %186, double* %184
%187 = add nsw i64 %178, 1
%188 = add nsw i64 %187, %166
%189 = getelementptr inbounds double, double* %0, i64 %188
%190 = load double, double* %189
%191 = mul nsw i64 %187, %17
%192 = add nsw i64 %191, %164
%193 = getelementptr inbounds double, double* %1, i64 %192
%194 = load double, double* %193
%195 = call double @llvm.fmuladd.f64(double %56, double %190, double %194)
store double %195, double* %193
%196 = add nsw i64 %178, 2
%197 = icmp eq i64 %196, %16
br i1 %197, label %198, label %177
198: ; preds = %175, %177, %163
%199 = add nuw i64 %164, 1
%200 = icmp ult i64 %199, %46
%201 = icmp slt i64 %199, %20
%202 = select i1 %200, i1 %201, i1 false
br i1 %202, label %163, label %28
203: ; preds = %33, %241
%204 = phi i64 [ %37, %33 ], [ %242, %241 ]
br i1 %34, label %205, label %241
205: ; preds = %203
%206 = mul nsw i64 %204, %38
br i1 %41, label %230, label %207
207: ; preds = %205, %207
%208 = phi i64 [ %227, %207 ], [ 0, %205 ]
%209 = phi i64 [ %228, %207 ], [ 0, %205 ]
%210 = add nsw i64 %208, %206
%211 = getelementptr inbounds double, double* %0, i64 %210
%212 = load double, double* %211
%213 = mul nsw i64 %208, %36
%214 = add nsw i64 %213, %204
%215 = getelementptr inbounds double, double* %1, i64 %214
%216 = load double, double* %215
%217 = call double @llvm.fmuladd.f64(double %35, double %212, double %216)
store double %217, double* %215
%218 = or i64 %208, 1
%219 = add nsw i64 %218, %206
%220 = getelementptr inbounds double, double* %0, i64 %219
%221 = load double, double* %220
%222 = mul nsw i64 %218, %36
%223 = add nsw i64 %222, %204
%224 = getelementptr inbounds double, double* %1, i64 %223
%225 = load double, double* %224
%226 = call double @llvm.fmuladd.f64(double %35, double %221, double %225)
store double %226, double* %224
%227 = add nuw nsw i64 %208, 2
%228 = add i64 %209, 2
%229 = icmp eq i64 %228, %42
br i1 %229, label %230, label %207
230: ; preds = %207, %205
%231 = phi i64 [ 0, %205 ], [ %227, %207 ]
br i1 %43, label %241, label %232
232: ; preds = %230
%233 = add nsw i64 %231, %206
%234 = getelementptr inbounds double, double* %0, i64 %233
%235 = load double, double* %234
%236 = mul nsw i64 %231, %36
%237 = add nsw i64 %236, %204
%238 = getelementptr inbounds double, double* %1, i64 %237
%239 = load double, double* %238
%240 = call double @llvm.fmuladd.f64(double %35, double %235, double %239)
store double %240, double* %238
br label %241
241: ; preds = %232, %230, %203
%242 = add nsw i64 %204, 1
%243 = icmp eq i64 %242, %36
br i1 %243, label %244, label %203
244: ; preds = %241, %31
ret void
}