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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int quatVector(double *, double *, double *, int);
int quatVectLoopf(float *q, float *v, float *vout, unsigned long long nq,
                  unsigned long long nv, int p) {
  unsigned long long i, j, qstep, vstep, voutstep, n, istep;
  int trash;
  double qtemp[4], vtemp[3], vouttemp[3];
  voutstep = 3;
  qstep = (nq == 1) ? 0 : 4;
  vstep = (nv == 1) ? 0 : 3;
  if ((nq > 1) && (nv > 1)) {
    n = (nq <= nv) ? nq : nv;
  } else {
    n = (nq >= nv) ? nq : nv;
  }
  if ((nq == 1) && (n > 1)) {
#pragma omp parallel shared(q, v, vout) private(i, j, trash, qtemp, vtemp,     \
                                                vouttemp)                      \
    firstprivate(qstep, vstep, voutstep, n, p)
    {
      for (j = 0; j < 4; j++)
        qtemp[j] = (double)q[j];
#pragma omp for schedule(static) nowait
      for (i = 0; i < n; i++) {
        for (j = 0; j < 3; j++)
          vtemp[j] = (double)v[i * vstep + j];
        trash = quatVector(qtemp, vtemp, vouttemp, p);
        for (j = 0; j < 3; j++)
          vout[i * voutstep + j] = (float)vouttemp[j];
      }
    }
  } else if ((nv == 1) && n > 1) {
#pragma omp parallel shared(q, v, vout) private(i, j, trash, qtemp, vtemp,     \
                                                vouttemp)                      \
    firstprivate(qstep, vstep, voutstep, n, p)
    {
      for (j = 0; j < 3; j++)
        vtemp[j] = (double)v[j];
#pragma omp for schedule(static) nowait
      for (i = 0; i < n; i++) {
        for (j = 0; j < 4; j++)
          qtemp[j] = (double)q[i * qstep + j];
        trash = quatVector(qtemp, vtemp, vouttemp, p);
        for (j = 0; j < 3; j++)
          vout[i * voutstep + j] = (float)vouttemp[j];
      }
    }
  } else {
#pragma omp parallel shared(q, v, vout) private(i, j, trash, qtemp, vtemp,     \
                                                vouttemp)                      \
    firstprivate(qstep, vstep, voutstep, n, p)
    {
#pragma omp for schedule(static) nowait
      for (i = 0; i < n; i++) {
        for (j = 0; j < 3; j++) {
          vtemp[j] = (double)v[i * vstep + j];
        }
        for (j = 0; j < 4; j++) {
          qtemp[j] = (double)q[i * qstep + j];
        }
        trash = quatVector(qtemp, vtemp, vouttemp, p);
        for (j = 0; j < 3; j++)
          vout[i * voutstep + j] = (float)vouttemp[j];
      }
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<quatVectLoopf>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movq   $0x3,-0x58(%rbp)
mov    -0x20(%rbp),%rdx
mov    $0x4,%eax
xor    %ecx,%ecx
cmp    $0x1,%rdx
cmove  %ecx,%eax
cltq
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rdx
mov    $0x3,%eax
xor    %ecx,%ecx
cmp    $0x1,%rdx
cmove  %ecx,%eax
cltq
mov    %rax,-0x50(%rbp)
cmpq   $0x1,-0x20(%rbp)
jbe    11ba <quatVectLoopf+0xaa>
cmpq   $0x1,-0x28(%rbp)
jbe    11ba <quatVectLoopf+0xaa>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
ja     119f <quatVectLoopf+0x8f>
mov    -0x20(%rbp),%rax
mov    %rax,-0xd8(%rbp)
jmp    11aa <quatVectLoopf+0x9a>
mov    -0x28(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
mov    %rax,-0x60(%rbp)
jmp    11ee <quatVectLoopf+0xde>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     11d8 <quatVectLoopf+0xc8>
mov    -0x20(%rbp),%rax
mov    %rax,-0xe0(%rbp)
jmp    11e3 <quatVectLoopf+0xd3>
mov    -0x28(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmpq   $0x1,-0x20(%rbp)
jne    132d <quatVectLoopf+0x21d>
cmpq   $0x1,-0x60(%rbp)
jbe    132d <quatVectLoopf+0x21d>
movq   $0x0,-0x40(%rbp)
cmpq   $0x4,-0x40(%rbp)
jae    1246 <quatVectLoopf+0x136>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    120c <quatVectLoopf+0xfc>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1328 <quatVectLoopf+0x218>
movq   $0x0,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jae    12a7 <quatVectLoopf+0x197>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x50(%rbp),%rcx
add    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1264 <quatVectLoopf+0x154>
lea    -0x90(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
mov    -0x2c(%rbp),%ecx
call   1030 <quatVector@plt>
mov    %eax,-0x6c(%rbp)
movq   $0x0,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jae    1312 <quatVectLoopf+0x202>
mov    -0x40(%rbp),%rax
movsd  -0xd0(%rbp,%rax,8),%xmm0
ff ff
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x58(%rbp),%rcx
add    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12cf <quatVectLoopf+0x1bf>
jmp    1317 <quatVectLoopf+0x207>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    124e <quatVectLoopf+0x13e>
jmp    15a3 <quatVectLoopf+0x493>
cmpq   $0x1,-0x28(%rbp)
jne    146c <quatVectLoopf+0x35c>
cmpq   $0x1,-0x60(%rbp)
jbe    146c <quatVectLoopf+0x35c>
movq   $0x0,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jae    1385 <quatVectLoopf+0x275>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    134b <quatVectLoopf+0x23b>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1467 <quatVectLoopf+0x357>
movq   $0x0,-0x40(%rbp)
cmpq   $0x4,-0x40(%rbp)
jae    13e6 <quatVectLoopf+0x2d6>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x48(%rbp),%rcx
add    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    13a3 <quatVectLoopf+0x293>
lea    -0x90(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
mov    -0x2c(%rbp),%ecx
call   1030 <quatVector@plt>
mov    %eax,-0x6c(%rbp)
movq   $0x0,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jae    1451 <quatVectLoopf+0x341>
mov    -0x40(%rbp),%rax
movsd  -0xd0(%rbp,%rax,8),%xmm0
ff ff
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x58(%rbp),%rcx
add    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    140e <quatVectLoopf+0x2fe>
jmp    1456 <quatVectLoopf+0x346>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    138d <quatVectLoopf+0x27d>
jmp    159e <quatVectLoopf+0x48e>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    1599 <quatVectLoopf+0x489>
movq   $0x0,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jae    14cd <quatVectLoopf+0x3bd>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x50(%rbp),%rcx
add    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,-0xb0(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    148a <quatVectLoopf+0x37a>
movq   $0x0,-0x40(%rbp)
cmpq   $0x4,-0x40(%rbp)
jae    1518 <quatVectLoopf+0x408>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x48(%rbp),%rcx
add    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    14d5 <quatVectLoopf+0x3c5>
lea    -0x90(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
mov    -0x2c(%rbp),%ecx
call   1030 <quatVector@plt>
mov    %eax,-0x6c(%rbp)
movq   $0x0,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jae    1583 <quatVectLoopf+0x473>
mov    -0x40(%rbp),%rax
movsd  -0xd0(%rbp,%rax,8),%xmm0
ff ff
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x58(%rbp),%rcx
add    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1540 <quatVectLoopf+0x430>
jmp    1588 <quatVectLoopf+0x478>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1474 <quatVectLoopf+0x364>
jmp    159e <quatVectLoopf+0x48e>
jmp    15a3 <quatVectLoopf+0x493>
mov    $0x1,%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<quatVectLoopf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
xor    %eax,%eax
cmp    $0x1,%rcx
setne  %r10b
xor    %r11d,%r11d
cmp    $0x1,%r8
setne  %r11b
cmp    %r8,%rcx
mov    %rcx,%r12
cmova  %r8,%r12
mov    %r9d,%r14d
mov    %rdx,%rbx
mov    %rsi,%rbp
mov    %rdi,%r15
mov    %rcx,%rdx
cmovb  %r8,%rdx
cmp    $0x2,%r8
cmovb  %rdx,%r12
cmp    $0x2,%rcx
cmovb  %rdx,%r12
lea    (%r11,%r11,2),%r13
cmp    $0x1,%rcx
jne    120a <quatVectLoopf+0xfa>
cmp    $0x2,%r12
jb     120a <quatVectLoopf+0xfa>
cvtps2pd (%r15),%xmm0
movaps %xmm0,0x40(%rsp)
cvtps2pd 0x8(%r15),%xmm0
movaps %xmm0,0x50(%rsp)
add    $0x8,%rbx
add    $0x8,%rbp
shl    $0x2,%r13
mov    %rsp,%r15
nopw   0x0(%rax,%rax,1)
cvtps2pd -0x8(%rbp),%xmm0
movaps %xmm0,0x20(%rsp)
movss  0x0(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x30(%rsp)
lea    0x40(%rsp),%rdi
lea    0x20(%rsp),%rsi
mov    %r15,%rdx
mov    %r14d,%ecx
call   1030 <quatVector@plt>
movsd  (%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x8(%rbx)
movsd  0x8(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbx)
movsd  0x10(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx)
add    $0xc,%rbx
add    %r13,%rbp
add    $0xffffffffffffffff,%r12
jne    11a0 <quatVectLoopf+0x90>
jmp    1370 <quatVectLoopf+0x260>
mov    %r10b,%al
shl    $0x2,%rax
cmp    $0x1,%r8
jne    12bb <quatVectLoopf+0x1ab>
cmp    $0x1,%r12
jbe    12bb <quatVectLoopf+0x1ab>
cvtps2pd 0x0(%rbp),%xmm0
movaps %xmm0,0x20(%rsp)
movss  0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x30(%rsp)
add    $0x8,%rbx
add    $0x8,%r15
shl    $0x2,%rax
mov    %rsp,%r13
nopl   0x0(%rax)
cvtps2pd -0x8(%r15),%xmm0
movaps %xmm0,0x40(%rsp)
cvtps2pd (%r15),%xmm0
movaps %xmm0,0x50(%rsp)
lea    0x40(%rsp),%rdi
lea    0x20(%rsp),%rsi
mov    %r13,%rdx
mov    %r14d,%ecx
mov    %rax,%rbp
call   1030 <quatVector@plt>
mov    %rbp,%rax
movsd  (%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x8(%rbx)
movsd  0x8(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbx)
movsd  0x10(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx)
add    $0xc,%rbx
add    %rbp,%r15
add    $0xffffffffffffffff,%r12
jne    1250 <quatVectLoopf+0x140>
jmp    1370 <quatVectLoopf+0x260>
test   %r12,%r12
je     1370 <quatVectLoopf+0x260>
add    $0x8,%rbx
add    $0x8,%r15
shl    $0x2,%rax
add    $0x8,%rbp
shl    $0x2,%r13
mov    %r13,0x60(%rsp)
nopl   (%rax)
cvtps2pd -0x8(%rbp),%xmm0
movaps %xmm0,0x20(%rsp)
movss  0x0(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x30(%rsp)
cvtps2pd -0x8(%r15),%xmm0
movaps %xmm0,0x40(%rsp)
cvtps2pd (%r15),%xmm0
movaps %xmm0,0x50(%rsp)
lea    0x40(%rsp),%rdi
lea    0x20(%rsp),%rsi
mov    %rsp,%rdx
mov    %r14d,%ecx
mov    %r14d,%r13d
mov    %rax,%r14
call   1030 <quatVector@plt>
mov    %r14,%rax
mov    %r13d,%r14d
mov    0x60(%rsp),%r13
movsd  (%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x8(%rbx)
movsd  0x8(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbx)
movsd  0x10(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx)
add    $0xc,%rbx
add    %rax,%r15
add    %r13,%rbp
add    $0xffffffffffffffff,%r12
jne    12e0 <quatVectLoopf+0x1d0>
mov    $0x1,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @quatVectLoopf(float* nocapture %0, float* nocapture %1, float* nocapture writeonly %2, i64 %3, i64 %4, i32 %5) {
%7 = alloca [4 x double]
%8 = alloca [3 x double]
%9 = alloca [3 x double]
%10 = bitcast [4 x double]* %7 to i8*
%11 = bitcast [3 x double]* %8 to i8*
%12 = bitcast [3 x double]* %9 to i8*
%13 = icmp eq i64 %3, 1
%14 = select i1 %13, i64 0, i64 4
%15 = icmp eq i64 %4, 1
%16 = select i1 %15, i64 0, i64 3
%17 = icmp ugt i64 %3, 1
%18 = icmp ugt i64 %4, 1
%19 = and i1 %17, %18
%20 = icmp ugt i64 %3, %4
%21 = select i1 %20, i64 %4, i64 %3
%22 = icmp ult i64 %3, %4
%23 = select i1 %22, i64 %4, i64 %3
%24 = select i1 %19, i64 %21, i64 %23
%25 = icmp ugt i64 %24, 1
%26 = and i1 %13, %25
br i1 %26, label %27, label %71
27: ; preds = %6
%28 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 0
%29 = bitcast float* %0 to <2 x float>*
%30 = load <2 x float>, <2 x float>* %29
%31 = fpext <2 x float> %30 to <2 x double>
%32 = bitcast [4 x double]* %7 to <2 x double>*
store <2 x double> %31, <2 x double>* %32
%33 = getelementptr inbounds float, float* %0, i64 2
%34 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 2
%35 = bitcast float* %33 to <2 x float>*
%36 = load <2 x float>, <2 x float>* %35
%37 = fpext <2 x float> %36 to <2 x double>
%38 = bitcast double* %34 to <2 x double>*
store <2 x double> %37, <2 x double>* %38
%39 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 0
%40 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%41 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 2
%42 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 1
%43 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 2
%44 = bitcast [3 x double]* %8 to <2 x double>*
br label %45
45: ; preds = %27, %45
%46 = phi i64 [ %69, %45 ], [ 0, %27 ]
%47 = mul i64 %46, %16
%48 = getelementptr inbounds float, float* %1, i64 %47
%49 = bitcast float* %48 to <2 x float>*
%50 = load <2 x float>, <2 x float>* %49
%51 = fpext <2 x float> %50 to <2 x double>
store <2 x double> %51, <2 x double>* %44
%52 = add i64 %47, 2
%53 = getelementptr inbounds float, float* %1, i64 %52
%54 = load float, float* %53
%55 = fpext float %54 to double
store double %55, double* %41
%56 = call i32 @quatVector(double* %28, double* %39, double* %40, i32 %5)
%57 = mul i64 %46, 3
%58 = load double, double* %40
%59 = fptrunc double %58 to float
%60 = getelementptr inbounds float, float* %2, i64 %57
store float %59, float* %60
%61 = load double, double* %42
%62 = fptrunc double %61 to float
%63 = add i64 %57, 1
%64 = getelementptr inbounds float, float* %2, i64 %63
store float %62, float* %64
%65 = load double, double* %43
%66 = fptrunc double %65 to float
%67 = add i64 %57, 2
%68 = getelementptr inbounds float, float* %2, i64 %67
store float %66, float* %68
%69 = add nuw i64 %46, 1
%70 = icmp eq i64 %69, %24
br i1 %70, label %166, label %45
71: ; preds = %6
%72 = and i1 %15, %25
br i1 %72, label %86, label %73
73: ; preds = %71
%74 = icmp eq i64 %24, 0
br i1 %74, label %166, label %75
75: ; preds = %73
%76 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 0
%77 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 0
%78 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%79 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 2
%80 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 2
%81 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 1
%82 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 2
%83 = bitcast [3 x double]* %8 to <2 x double>*
%84 = bitcast [4 x double]* %7 to <2 x double>*
%85 = bitcast double* %80 to <2 x double>*
br label %130
86: ; preds = %71
%87 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 0
%88 = bitcast float* %1 to <2 x float>*
%89 = load <2 x float>, <2 x float>* %88
%90 = fpext <2 x float> %89 to <2 x double>
%91 = bitcast [3 x double]* %8 to <2 x double>*
store <2 x double> %90, <2 x double>* %91
%92 = getelementptr inbounds float, float* %1, i64 2
%93 = load float, float* %92
%94 = fpext float %93 to double
%95 = getelementptr inbounds [3 x double], [3 x double]* %8, i64 0, i64 2
store double %94, double* %95
%96 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 0
%97 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 0
%98 = getelementptr inbounds [4 x double], [4 x double]* %7, i64 0, i64 2
%99 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 1
%100 = getelementptr inbounds [3 x double], [3 x double]* %9, i64 0, i64 2
%101 = bitcast [4 x double]* %7 to <2 x double>*
%102 = bitcast double* %98 to <2 x double>*
br label %103
103: ; preds = %86, %103
%104 = phi i64 [ %128, %103 ], [ 0, %86 ]
%105 = mul i64 %104, %14
%106 = getelementptr inbounds float, float* %0, i64 %105
%107 = bitcast float* %106 to <2 x float>*
%108 = load <2 x float>, <2 x float>* %107
%109 = fpext <2 x float> %108 to <2 x double>
store <2 x double> %109, <2 x double>* %101
%110 = or i64 %105, 2
%111 = getelementptr inbounds float, float* %0, i64 %110
%112 = bitcast float* %111 to <2 x float>*
%113 = load <2 x float>, <2 x float>* %112
%114 = fpext <2 x float> %113 to <2 x double>
store <2 x double> %114, <2 x double>* %102
%115 = call i32 @quatVector(double* %96, double* %87, double* %97, i32 %5)
%116 = mul i64 %104, 3
%117 = load double, double* %97
%118 = fptrunc double %117 to float
%119 = getelementptr inbounds float, float* %2, i64 %116
store float %118, float* %119
%120 = load double, double* %99
%121 = fptrunc double %120 to float
%122 = add i64 %116, 1
%123 = getelementptr inbounds float, float* %2, i64 %122
store float %121, float* %123
%124 = load double, double* %100
%125 = fptrunc double %124 to float
%126 = add i64 %116, 2
%127 = getelementptr inbounds float, float* %2, i64 %126
store float %125, float* %127
%128 = add nuw i64 %104, 1
%129 = icmp eq i64 %128, %24
br i1 %129, label %166, label %103
130: ; preds = %75, %130
%131 = phi i64 [ 0, %75 ], [ %164, %130 ]
%132 = mul i64 %131, %16
%133 = getelementptr inbounds float, float* %1, i64 %132
%134 = bitcast float* %133 to <2 x float>*
%135 = load <2 x float>, <2 x float>* %134
%136 = fpext <2 x float> %135 to <2 x double>
store <2 x double> %136, <2 x double>* %83
%137 = add i64 %132, 2
%138 = getelementptr inbounds float, float* %1, i64 %137
%139 = load float, float* %138
%140 = fpext float %139 to double
store double %140, double* %79
%141 = mul i64 %131, %14
%142 = getelementptr inbounds float, float* %0, i64 %141
%143 = bitcast float* %142 to <2 x float>*
%144 = load <2 x float>, <2 x float>* %143
%145 = fpext <2 x float> %144 to <2 x double>
store <2 x double> %145, <2 x double>* %84
%146 = or i64 %141, 2
%147 = getelementptr inbounds float, float* %0, i64 %146
%148 = bitcast float* %147 to <2 x float>*
%149 = load <2 x float>, <2 x float>* %148
%150 = fpext <2 x float> %149 to <2 x double>
store <2 x double> %150, <2 x double>* %85
%151 = call i32 @quatVector(double* %76, double* %77, double* %78, i32 %5)
%152 = mul i64 %131, 3
%153 = load double, double* %78
%154 = fptrunc double %153 to float
%155 = getelementptr inbounds float, float* %2, i64 %152
store float %154, float* %155
%156 = load double, double* %81
%157 = fptrunc double %156 to float
%158 = add i64 %152, 1
%159 = getelementptr inbounds float, float* %2, i64 %158
store float %157, float* %159
%160 = load double, double* %82
%161 = fptrunc double %160 to float
%162 = add i64 %152, 2
%163 = getelementptr inbounds float, float* %2, i64 %162
store float %161, float* %163
%164 = add nuw i64 %131, 1
%165 = icmp eq i64 %164, %24
br i1 %165, label %166, label %130
166: ; preds = %130, %103, %45, %73
ret i32 1
}