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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int /*<<< orphan*/);
void sumCATMULT(int tipCase, double *sum, double *x1_start, double *x2_start,
                double *tipVector, char *tipX1, char *tipX2, int *modelptr,
                int loopStart, int n) {
  double *x1, *x2;
  int i, model;
  switch (tipCase) {
  case 0:
    for (i = loopStart; i < n; i++) {
      model = modelptr[i];
      x1 = &(tipVector[model * 64 + tipX1[i] * 4]);
      x2 = &(tipVector[model * 64 + tipX2[i] * 4]);
      sum[i * 4] = x1[0] * x2[0];
      sum[i * 4 + 1] = x1[1] * x2[1];
      sum[i * 4 + 2] = x1[2] * x2[2];
      sum[i * 4 + 3] = x1[3] * x2[3];
    }
    break;
  case 1:
    for (i = loopStart; i < n; i++) {
      model = modelptr[i];
      x1 = &(tipVector[model * 64 + 4 * tipX1[i]]);
      x2 = &x2_start[4 * i];
      sum[i * 4] = x1[0] * x2[0];
      sum[i * 4 + 1] = x1[1] * x2[1];
      sum[i * 4 + 2] = x1[2] * x2[2];
      sum[i * 4 + 3] = x1[3] * x2[3];
    }
    break;
  case 2:
    for (i = loopStart; i < n; i++) {
      x1 = &x1_start[4 * i];
      x2 = &x2_start[4 * i];
      sum[i * 4] = x1[0] * x2[0];
      sum[i * 4 + 1] = x1[1] * x2[1];
      sum[i * 4 + 2] = x1[2] * x2[2];
      sum[i * 4 + 3] = x1[3] * x2[3];
    }
    break;
  default:
    assert(0);
  }
}


x86 assembly (clang, -O0):
<sumCATMULT>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x4c(%rbp)
test   %eax,%eax
je     1172 <sumCATMULT+0x62>
jmp    1150 <sumCATMULT+0x40>
mov    -0x4c(%rbp),%eax
sub    $0x1,%eax
je     128e <sumCATMULT+0x17e>
jmp    1161 <sumCATMULT+0x51>
mov    -0x4c(%rbp),%eax
sub    $0x2,%eax
je     1399 <sumCATMULT+0x289>
jmp    1485 <sumCATMULT+0x375>
mov    0x20(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1289 <sumCATMULT+0x179>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x6,%ecx
mov    -0x30(%rbp),%rdx
movslq -0x44(%rbp),%rsi
movsbl (%rdx,%rsi,1),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x6,%ecx
mov    0x10(%rbp),%rdx
movslq -0x44(%rbp),%rsi
movsbl (%rdx,%rsi,1),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1178 <sumCATMULT+0x68>
jmp    148c <sumCATMULT+0x37c>
mov    0x20(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1394 <sumCATMULT+0x284>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x6,%ecx
mov    -0x30(%rbp),%rdx
movslq -0x44(%rbp),%rsi
movsbl (%rdx,%rsi,1),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1294 <sumCATMULT+0x184>
jmp    148c <sumCATMULT+0x37c>
mov    0x20(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1480 <sumCATMULT+0x370>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x40(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    139f <sumCATMULT+0x28f>
jmp    148c <sumCATMULT+0x37c>
xor    %edi,%edi
call   1030 <assert@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sumCATMULT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,%r10
mov    0x50(%rsp),%edx
mov    0x48(%rsp),%r15d
mov    0x40(%rsp),%rbp
test   %edi,%edi
je     13f7 <sumCATMULT+0x2e7>
cmp    $0x1,%edi
je     14be <sumCATMULT+0x3ae>
cmp    $0x2,%edi
jne    156d <sumCATMULT+0x45d>
cmp    %edx,%r15d
jge    15f3 <sumCATMULT+0x4e3>
movslq %r15d,%r12
movslq %edx,%rdi
mov    %rdi,%r14
sub    %r12,%r14
cmp    $0x2,%r14
jb     1583 <sumCATMULT+0x473>
mov    %r12,-0x8(%rsp)
mov    %r12,%r9
not    %r9
add    %rdi,%r9
mov    $0x4,%edx
mov    %r9d,%eax
mul    %edx
mov    %eax,%r8d
lea    0x0(,%r15,4),%ebx
seto   %r11b
lea    (%r8,%r15,4),%r13d
mov    $0x20,%edx
mov    %r9,%rax
mul    %rdx
seto   %r12b
cmp    %ebx,%r13d
jl     157e <sumCATMULT+0x46e>
test   %r11b,%r11b
jne    157e <sumCATMULT+0x46e>
shr    $0x20,%r9
jne    157e <sumCATMULT+0x46e>
lea    0x1(,%r15,4),%edx
lea    (%r8,%r15,4),%ebp
add    $0x1,%ebp
cmp    %edx,%ebp
jl     157e <sumCATMULT+0x46e>
test   %r11b,%r11b
jne    157e <sumCATMULT+0x46e>
test   %r9,%r9
jne    157e <sumCATMULT+0x46e>
lea    0x2(,%r15,4),%edx
lea    (%r8,%r15,4),%ebp
add    $0x2,%ebp
cmp    %edx,%ebp
jl     157e <sumCATMULT+0x46e>
test   %r11b,%r11b
jne    157e <sumCATMULT+0x46e>
test   %r9,%r9
jne    157e <sumCATMULT+0x46e>
lea    0x3(,%r15,4),%edx
lea    (%r8,%r15,4),%ebp
add    $0x3,%ebp
cmp    %edx,%ebp
jl     157e <sumCATMULT+0x46e>
test   %r11b,%r11b
jne    157e <sumCATMULT+0x46e>
test   %r9,%r9
jne    157e <sumCATMULT+0x46e>
movslq %ebx,%rdx
lea    (%rsi,%rdx,8),%r9
lea    (%rsi,%rdx,8),%r8
add    $0x10,%r8
lea    (%rax,%r9,1),%rbp
add    $0x10,%rbp
cmp    %r8,%rbp
jb     157e <sumCATMULT+0x46e>
test   %r12b,%r12b
jne    157e <sumCATMULT+0x46e>
lea    (%rsi,%rdx,8),%r8
add    $0x18,%r8
lea    (%rax,%r9,1),%rbp
add    $0x18,%rbp
cmp    %r8,%rbp
jb     157e <sumCATMULT+0x46e>
test   %r12b,%r12b
jne    157e <sumCATMULT+0x46e>
lea    (%rsi,%rdx,8),%rdx
add    $0x8,%rdx
lea    (%rax,%r9,1),%rbp
add    $0x8,%rbp
cmp    %rdx,%rbp
jb     157e <sumCATMULT+0x46e>
test   %r12b,%r12b
jne    157e <sumCATMULT+0x46e>
add    %r9,%rax
cmp    %r9,%rax
jb     157e <sumCATMULT+0x46e>
test   %r12b,%r12b
jne    157e <sumCATMULT+0x46e>
shl    $0x2,%r15d
movslq %r15d,%rax
lea    (%rsi,%rax,8),%r8
lea    (%rax,%rdi,4),%rbp
mov    -0x8(%rsp),%r12
lea    0x0(,%r12,4),%rdx
sub    %rdx,%rbp
lea    (%rsi,%rbp,8),%rdx
lea    (%r10,%rax,8),%r9
lea    (%r10,%rbp,8),%r11
lea    (%rcx,%rax,8),%r15
lea    (%rcx,%rbp,8),%rax
cmp    %r11,%r8
setb   %r11b
cmp    %rdx,%r9
setb   %r9b
cmp    %rax,%r8
setb   %al
cmp    %rdx,%r15
setb   %dl
test   %r9b,%r11b
jne    1583 <sumCATMULT+0x473>
and    %dl,%al
jne    1583 <sumCATMULT+0x473>
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
add    %rax,%r12
mov    %rax,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %ebx,%rbx
movupd (%r10,%rbx,8),%xmm6
movupd 0x10(%r10,%rbx,8),%xmm4
movupd 0x20(%r10,%rbx,8),%xmm5
movupd 0x30(%r10,%rbx,8),%xmm8
movupd (%rcx,%rbx,8),%xmm0
movupd 0x10(%rcx,%rbx,8),%xmm1
movupd 0x20(%rcx,%rbx,8),%xmm7
movupd 0x30(%rcx,%rbx,8),%xmm9
movapd %xmm6,%xmm3
unpcklpd %xmm5,%xmm3
movapd %xmm0,%xmm2
unpcklpd %xmm7,%xmm2
mulpd  %xmm3,%xmm2
unpckhpd %xmm5,%xmm6
unpckhpd %xmm7,%xmm0
mulpd  %xmm6,%xmm0
movapd %xmm4,%xmm3
unpcklpd %xmm8,%xmm3
movapd %xmm1,%xmm5
unpcklpd %xmm9,%xmm5
mulpd  %xmm3,%xmm5
unpckhpd %xmm8,%xmm4
unpckhpd %xmm9,%xmm1
mulpd  %xmm4,%xmm1
lea    0x3(%rbx),%ebp
movslq %ebp,%rbp
movapd %xmm5,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm2,%xmm4
unpcklpd %xmm0,%xmm4
movhlps %xmm5,%xmm1
movhlps %xmm2,%xmm0
movups %xmm0,0x8(%rsi,%rbp,8)
movups %xmm1,0x18(%rsi,%rbp,8)
movupd %xmm4,-0x18(%rsi,%rbp,8)
movupd %xmm3,-0x8(%rsi,%rbp,8)
add    $0x8,%ebx
add    $0xfffffffffffffffe,%rdx
jne    1330 <sumCATMULT+0x220>
cmp    %rax,%r14
jne    1583 <sumCATMULT+0x473>
jmp    15f3 <sumCATMULT+0x4e3>
cmp    %edx,%r15d
jge    15f3 <sumCATMULT+0x4e3>
mov    0x38(%rsp),%r10
movslq %r15d,%rcx
movslq %edx,%r11
shl    $0x2,%r15d
lea    0x0(,%rcx,4),%r14
add    %rbp,%r14
xor    %ebx,%ebx
nopl   0x0(%rax)
movslq (%r14,%rbx,1),%rbp
shl    $0x6,%rbp
movsbq (%r9,%rcx,1),%rax
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
movsbq (%r10,%rcx,1),%rdx
movslq %ebp,%rbp
lea    0x0(%rbp,%rdx,4),%rdx
movsd  (%r8,%rax,8),%xmm0
mulsd  (%r8,%rdx,8),%xmm0
lea    (%r15,%rbx,1),%rbp
movslq %ebp,%rbp
movsd  %xmm0,(%rsi,%rbp,8)
movsd  0x8(%r8,%rax,8),%xmm0
mulsd  0x8(%r8,%rdx,8),%xmm0
lea    0x1(%rbp),%edi
movslq %edi,%rdi
movsd  %xmm0,(%rsi,%rdi,8)
movsd  0x10(%r8,%rax,8),%xmm0
mulsd  0x10(%r8,%rdx,8),%xmm0
lea    0x2(%rbp),%edi
movslq %edi,%rdi
movsd  %xmm0,(%rsi,%rdi,8)
movsd  0x18(%r8,%rax,8),%xmm0
mulsd  0x18(%r8,%rdx,8),%xmm0
add    $0x3,%ebp
movslq %ebp,%rax
movsd  %xmm0,(%rsi,%rax,8)
add    $0x1,%rcx
add    $0x4,%rbx
cmp    %rcx,%r11
jne    1420 <sumCATMULT+0x310>
jmp    15f3 <sumCATMULT+0x4e3>
cmp    %edx,%r15d
jge    15f3 <sumCATMULT+0x4e3>
movslq %r15d,%rax
movslq %edx,%r10
shl    $0x2,%r15d
lea    0x0(,%rax,4),%r11
add    %rbp,%r11
xor    %ebx,%ebx
xchg   %ax,%ax
movslq (%r11,%rbx,1),%rbp
movsbq (%r9,%rax,1),%rdx
shl    $0x6,%rbp
lea    0x0(,%rdx,4),%rdx
add    %rbp,%rdx
lea    (%r15,%rbx,1),%rbp
movslq %ebp,%rbp
movsd  (%r8,%rdx,8),%xmm0
mulsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
movsd  0x8(%r8,%rdx,8),%xmm0
mulsd  0x8(%rcx,%rbp,8),%xmm0
lea    0x1(%rbp),%edi
movslq %edi,%rdi
movsd  %xmm0,(%rsi,%rdi,8)
movsd  0x10(%r8,%rdx,8),%xmm0
mulsd  0x10(%rcx,%rbp,8),%xmm0
lea    0x2(%rbp),%edi
movslq %edi,%rdi
movsd  %xmm0,(%rsi,%rdi,8)
movsd  0x18(%r8,%rdx,8),%xmm0
mulsd  0x18(%rcx,%rbp,8),%xmm0
lea    0x3(%rbp),%edx
movslq %edx,%rdx
movsd  %xmm0,(%rsi,%rdx,8)
add    $0x1,%rax
add    $0x4,%rbx
cmp    %rax,%r10
jne    14e0 <sumCATMULT+0x3d0>
jmp    15f3 <sumCATMULT+0x4e3>
xor    %edi,%edi
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <assert@plt>
mov    -0x8(%rsp),%r12
lea    0x0(,%r12,4),%eax
sub    %r12,%rdi
xchg   %ax,%ax
cltq
movsd  (%r10,%rax,8),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  0x8(%r10,%rax,8),%xmm0
mulsd  0x8(%rcx,%rax,8),%xmm0
lea    0x1(%rax),%edx
movslq %edx,%rdx
movsd  %xmm0,(%rsi,%rdx,8)
movsd  0x10(%r10,%rax,8),%xmm0
mulsd  0x10(%rcx,%rax,8),%xmm0
lea    0x2(%rax),%edx
movslq %edx,%rdx
movsd  %xmm0,(%rsi,%rdx,8)
movsd  0x18(%r10,%rax,8),%xmm0
mulsd  0x18(%rcx,%rax,8),%xmm0
lea    0x3(%rax),%edx
movslq %edx,%rdx
movsd  %xmm0,(%rsi,%rdx,8)
add    $0x4,%eax
add    $0xffffffffffffffff,%rdi
jne    1590 <sumCATMULT+0x480>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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