void addmul(int len, int a[], int b[], int c[], int d[]) {
#pragma omp parallel
  {
#pragma omp sections
    {
#pragma omp section
      {
#pragma omp parallel
          {
#pragma omp for schedule(static) nowait
              for (int i = 0; i < len; i++){c[i] = a[i];
    }
#pragma omp for schedule(static)
    for (int i = 0; i < len; i++) {
      c[i] = c[i] + b[i];
    }
  }
}
#pragma omp section
{
#pragma omp parallel
  {
#pragma omp for schedule(static) nowait
    for (int i = 0; i < len; i++) {
      d[i] = a[i];
    }
#pragma omp for schedule(static)
    for (int i = 0; i < len; i++) {
      d[i] = d[i] * b[i];
    }
  }
}
}
}
}


x86 assembly (clang, -O0):
<addmul>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    114e <addmul+0x4e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    111e <addmul+0x1e>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1190 <addmul+0x90>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1155 <addmul+0x55>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11c7 <addmul+0xc7>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1197 <addmul+0x97>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    120a <addmul+0x10a>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11ce <addmul+0xce>
pop    %rbp
ret

x86 assembly (clang, -O2):
<addmul>:
push   %r15
push   %r14
push   %rbx
test   %edi,%edi
jle    17a3 <addmul+0x6a3>
mov    %edi,%r9d
cmp    $0x8,%edi
jb     1127 <addmul+0x27>
lea    (%rsi,%r9,4),%rax
cmp    %rcx,%rax
jbe    1194 <addmul+0x94>
lea    (%rcx,%r9,4),%rax
cmp    %rsi,%rax
jbe    1194 <addmul+0x94>
xor    %r15d,%r15d
mov    %r15,%r10
not    %r10
add    %r9,%r10
mov    %r9,%rbx
and    $0x3,%rbx
je     1152 <addmul+0x52>
nopl   0x0(%rax)
mov    (%rsi,%r15,4),%eax
mov    %eax,(%rcx,%r15,4)
add    $0x1,%r15
add    $0xffffffffffffffff,%rbx
jne    1140 <addmul+0x40>
cmp    $0x3,%r10
jb     127c <addmul+0x17c>
nopl   0x0(%rax)
mov    (%rsi,%r15,4),%eax
mov    %eax,(%rcx,%r15,4)
mov    0x4(%rsi,%r15,4),%eax
mov    %eax,0x4(%rcx,%r15,4)
mov    0x8(%rsi,%r15,4),%eax
mov    %eax,0x8(%rcx,%r15,4)
mov    0xc(%rsi,%r15,4),%eax
mov    %eax,0xc(%rcx,%r15,4)
add    $0x4,%r15
cmp    %r15,%r9
jne    1160 <addmul+0x60>
jmp    127c <addmul+0x17c>
mov    %r9d,%r15d
and    $0xfffffff8,%r15d
lea    -0x8(%r15),%rbx
mov    %rbx,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x18,%rbx
jae    11bb <addmul+0xbb>
xor    %ebx,%ebx
jmp    122c <addmul+0x12c>
and    $0xfffffffffffffffc,%r11
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rbx,4),%xmm0
movups 0x10(%rsi,%rbx,4),%xmm1
movups %xmm0,(%rcx,%rbx,4)
movups %xmm1,0x10(%rcx,%rbx,4)
movups 0x20(%rsi,%rbx,4),%xmm0
movups 0x30(%rsi,%rbx,4),%xmm1
movups %xmm0,0x20(%rcx,%rbx,4)
movups %xmm1,0x30(%rcx,%rbx,4)
movups 0x40(%rsi,%rbx,4),%xmm0
movups 0x50(%rsi,%rbx,4),%xmm1
movups %xmm0,0x40(%rcx,%rbx,4)
movups %xmm1,0x50(%rcx,%rbx,4)
movdqu 0x60(%rsi,%rbx,4),%xmm0
movdqu 0x70(%rsi,%rbx,4),%xmm1
movdqu %xmm0,0x60(%rcx,%rbx,4)
movdqu %xmm1,0x70(%rcx,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%r11
jne    11d0 <addmul+0xd0>
test   %r10,%r10
je     1273 <addmul+0x173>
lea    (%rcx,%rbx,4),%r11
add    $0x10,%r11
lea    (%rsi,%rbx,4),%r14
add    $0x10,%r14
shl    $0x5,%r10
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%r14,%rbx,1),%xmm0
movdqu (%r14,%rbx,1),%xmm1
movdqu %xmm0,-0x10(%r11,%rbx,1)
movdqu %xmm1,(%r11,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    1250 <addmul+0x150>
cmp    %r9,%r15
jne    112a <addmul+0x2a>
test   %edi,%edi
jle    17a3 <addmul+0x6a3>
cmp    $0x8,%edi
jb     129b <addmul+0x19b>
lea    (%rdx,%r9,4),%rax
cmp    %rcx,%rax
jbe    1304 <addmul+0x204>
lea    (%rcx,%r9,4),%rax
cmp    %rdx,%rax
jbe    1304 <addmul+0x204>
xor    %r14d,%r14d
mov    %r14,%r10
not    %r10
add    %r9,%r10
mov    %r9,%rbx
and    $0x3,%rbx
je     12c2 <addmul+0x1c2>
mov    (%rdx,%r14,4),%eax
add    %eax,(%rcx,%r14,4)
add    $0x1,%r14
add    $0xffffffffffffffff,%rbx
jne    12b0 <addmul+0x1b0>
cmp    $0x3,%r10
jb     13e9 <addmul+0x2e9>
nopl   0x0(%rax)
mov    (%rdx,%r14,4),%eax
add    %eax,(%rcx,%r14,4)
mov    0x4(%rdx,%r14,4),%eax
add    %eax,0x4(%rcx,%r14,4)
mov    0x8(%rdx,%r14,4),%eax
add    %eax,0x8(%rcx,%r14,4)
mov    0xc(%rdx,%r14,4),%eax
add    %eax,0xc(%rcx,%r14,4)
add    $0x4,%r14
cmp    %r14,%r9
jne    12d0 <addmul+0x1d0>
jmp    13e9 <addmul+0x2e9>
mov    %r9d,%r14d
and    $0xfffffff8,%r14d
lea    -0x8(%r14),%rbx
mov    %rbx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rbx,%rbx
je     1499 <addmul+0x399>
movabs $0x3ffffffffffffffc,%rbx
ff ff 3f
or     $0x2,%rbx
and    %r10,%rbx
xor    %r11d,%r11d
nopw   0x0(%rax,%rax,1)
movdqu (%rdx,%r11,4),%xmm0
movdqu 0x10(%rdx,%r11,4),%xmm1
movdqu (%rcx,%r11,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rcx,%r11,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rcx,%r11,4),%xmm1
movdqu 0x30(%rcx,%r11,4),%xmm3
movdqu %xmm2,(%rcx,%r11,4)
movdqu %xmm0,0x10(%rcx,%r11,4)
movdqu 0x20(%rdx,%r11,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x30(%rdx,%r11,4),%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,0x20(%rcx,%r11,4)
movdqu %xmm1,0x30(%rcx,%r11,4)
add    $0x10,%r11
add    $0xfffffffffffffffe,%rbx
jne    1340 <addmul+0x240>
test   $0x1,%r10b
je     13e0 <addmul+0x2e0>
movdqu (%rcx,%r11,4),%xmm0
movdqu 0x10(%rcx,%r11,4),%xmm1
movdqu (%rdx,%r11,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rdx,%r11,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,(%rcx,%r11,4)
movdqu %xmm0,0x10(%rcx,%r11,4)
cmp    %r9,%r14
jne    129e <addmul+0x19e>
test   %edi,%edi
jle    17a3 <addmul+0x6a3>
cmp    $0x8,%edi
jb     1408 <addmul+0x308>
lea    (%rsi,%r9,4),%rax
cmp    %r8,%rax
jbe    1470 <addmul+0x370>
lea    (%r8,%r9,4),%rax
cmp    %rsi,%rax
jbe    1470 <addmul+0x370>
xor    %eax,%eax
mov    %rax,%r10
not    %r10
add    %r9,%r10
mov    %r9,%rbx
and    $0x3,%rbx
je     1431 <addmul+0x331>
nopl   0x0(%rax)
mov    (%rsi,%rax,4),%ecx
mov    %ecx,(%r8,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    1420 <addmul+0x320>
cmp    $0x3,%r10
jb     156a <addmul+0x46a>
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rax,4),%ecx
mov    %ecx,(%r8,%rax,4)
mov    0x4(%rsi,%rax,4),%ecx
mov    %ecx,0x4(%r8,%rax,4)
mov    0x8(%rsi,%rax,4),%ecx
mov    %ecx,0x8(%r8,%rax,4)
mov    0xc(%rsi,%rax,4),%ecx
mov    %ecx,0xc(%r8,%rax,4)
add    $0x4,%rax
cmp    %rax,%r9
jne    1440 <addmul+0x340>
jmp    156a <addmul+0x46a>
mov    %r9d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rbx
mov    %rbx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
cmp    $0x18,%rbx
jae    14ab <addmul+0x3ab>
xor    %ebx,%ebx
jmp    1524 <addmul+0x424>
xor    %r11d,%r11d
test   $0x1,%r10b
jne    13b1 <addmul+0x2b1>
jmp    13e0 <addmul+0x2e0>
and    $0xfffffffffffffffc,%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rbx,4),%xmm0
movups 0x10(%rsi,%rbx,4),%xmm1
movups %xmm0,(%r8,%rbx,4)
movups %xmm1,0x10(%r8,%rbx,4)
movups 0x20(%rsi,%rbx,4),%xmm0
movups 0x30(%rsi,%rbx,4),%xmm1
movups %xmm0,0x20(%r8,%rbx,4)
movups %xmm1,0x30(%r8,%rbx,4)
movups 0x40(%rsi,%rbx,4),%xmm0
movups 0x50(%rsi,%rbx,4),%xmm1
movups %xmm0,0x40(%r8,%rbx,4)
movups %xmm1,0x50(%r8,%rbx,4)
movdqu 0x60(%rsi,%rbx,4),%xmm0
movdqu 0x70(%rsi,%rbx,4),%xmm1
movdqu %xmm0,0x60(%r8,%rbx,4)
movdqu %xmm1,0x70(%r8,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rcx
jne    14c0 <addmul+0x3c0>
test   %r10,%r10
je     1561 <addmul+0x461>
lea    (%r8,%rbx,4),%r11
add    $0x10,%r11
lea    (%rsi,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r10
xor    %ecx,%ecx
nop
movdqu -0x10(%rbx,%rcx,1),%xmm0
movdqu (%rbx,%rcx,1),%xmm1
movdqu %xmm0,-0x10(%r11,%rcx,1)
movdqu %xmm1,(%r11,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r10
jne    1540 <addmul+0x440>
cmp    %r9,%rax
jne    140a <addmul+0x30a>
test   %edi,%edi
jle    17a3 <addmul+0x6a3>
cmp    $0x8,%edi
jb     1591 <addmul+0x491>
lea    (%rdx,%r9,4),%rax
cmp    %r8,%rax
jbe    1617 <addmul+0x517>
lea    (%r8,%r9,4),%rax
cmp    %rdx,%rax
jbe    1617 <addmul+0x517>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r9,%rax
mov    %r9,%rsi
and    $0x3,%rsi
je     15c6 <addmul+0x4c6>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdx,%rcx,4),%edi
imul   (%r8,%rcx,4),%edi
mov    %edi,(%r8,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    15b0 <addmul+0x4b0>
cmp    $0x3,%rax
jb     17a3 <addmul+0x6a3>
mov    (%rdx,%rcx,4),%eax
imul   (%r8,%rcx,4),%eax
mov    %eax,(%r8,%rcx,4)
mov    0x4(%rdx,%rcx,4),%eax
imul   0x4(%r8,%rcx,4),%eax
mov    %eax,0x4(%r8,%rcx,4)
mov    0x8(%rdx,%rcx,4),%eax
imul   0x8(%r8,%rcx,4),%eax
mov    %eax,0x8(%r8,%rcx,4)
mov    0xc(%rdx,%rcx,4),%eax
imul   0xc(%r8,%rcx,4),%eax
mov    %eax,0xc(%r8,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    15d0 <addmul+0x4d0>
jmp    17a3 <addmul+0x6a3>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rax,%rax
je     172d <addmul+0x62d>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
and    %rsi,%rdi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movdqu (%rdx,%rax,4),%xmm1
movdqu 0x10(%rdx,%rax,4),%xmm2
movdqu (%r8,%rax,4),%xmm3
movdqu 0x10(%r8,%rax,4),%xmm4
movdqu 0x20(%r8,%rax,4),%xmm5
movdqu 0x30(%r8,%rax,4),%xmm0
pshufd $0xf5,%xmm1,%xmm6
pmuludq %xmm3,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm4,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm3
punpckldq %xmm3,%xmm2
movdqu %xmm1,(%r8,%rax,4)
movdqu %xmm2,0x10(%r8,%rax,4)
movdqu 0x20(%rdx,%rax,4),%xmm1
movdqu 0x30(%rdx,%rax,4),%xmm2
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm5,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm5,%xmm4
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm3
punpckldq %xmm3,%xmm1
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm3,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
movdqu %xmm1,0x20(%r8,%rax,4)
movdqu %xmm2,0x30(%r8,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdi
jne    1650 <addmul+0x550>
jmp    172f <addmul+0x62f>
xor    %eax,%eax
test   $0x1,%sil
je     179a <addmul+0x69a>
movdqu (%r8,%rax,4),%xmm0
movdqu 0x10(%r8,%rax,4),%xmm1
movdqu (%rdx,%rax,4),%xmm2
movdqu 0x10(%rdx,%rax,4),%xmm3
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm4,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
pshufd $0xf5,%xmm3,%xmm0
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm0
punpckldq %xmm0,%xmm3
movdqu %xmm2,(%r8,%rax,4)
movdqu %xmm3,0x10(%r8,%rax,4)
cmp    %r9,%rcx
jne    1593 <addmul+0x493>
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @addmul(i32 %0, i32* %1, i32* %2, i32* %3, i32* %4) {
%6 = alloca i32
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
store i32 %0, i32* %6
store i32* %1, i32** %7
store i32* %2, i32** %8
store i32* %3, i32** %9
store i32* %4, i32** %10
store i32 0, i32* %11
br label %15
15: ; preds = %29, %5
%16 = load i32, i32* %11
%17 = load i32, i32* %6
%18 = icmp slt i32 %16, %17
br i1 %18, label %19, label %32
19: ; preds = %15
%20 = load i32*, i32** %7
%21 = load i32, i32* %11
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i32, i32* %20, i64 %22
%24 = load i32, i32* %23
%25 = load i32*, i32** %9
%26 = load i32, i32* %11
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i32, i32* %25, i64 %27
store i32 %24, i32* %28
br label %29
29: ; preds = %19
%30 = load i32, i32* %11
%31 = add nsw i32 %30, 1
store i32 %31, i32* %11
br label %15
32: ; preds = %15
store i32 0, i32* %12
br label %33
33: ; preds = %53, %32
%34 = load i32, i32* %12
%35 = load i32, i32* %6
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %56
37: ; preds = %33
%38 = load i32*, i32** %9
%39 = load i32, i32* %12
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i32, i32* %38, i64 %40
%42 = load i32, i32* %41
%43 = load i32*, i32** %8
%44 = load i32, i32* %12
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %43, i64 %45
%47 = load i32, i32* %46
%48 = add nsw i32 %42, %47
%49 = load i32*, i32** %9
%50 = load i32, i32* %12
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %49, i64 %51
store i32 %48, i32* %52
br label %53
53: ; preds = %37
%54 = load i32, i32* %12
%55 = add nsw i32 %54, 1
store i32 %55, i32* %12
br label %33
56: ; preds = %33
store i32 0, i32* %13
br label %57
57: ; preds = %71, %56
%58 = load i32, i32* %13
%59 = load i32, i32* %6
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %74
61: ; preds = %57
%62 = load i32*, i32** %7
%63 = load i32, i32* %13
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i32, i32* %62, i64 %64
%66 = load i32, i32* %65
%67 = load i32*, i32** %10
%68 = load i32, i32* %13
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i32, i32* %67, i64 %69
store i32 %66, i32* %70
br label %71
71: ; preds = %61
%72 = load i32, i32* %13
%73 = add nsw i32 %72, 1
store i32 %73, i32* %13
br label %57
74: ; preds = %57
store i32 0, i32* %14
br label %75
75: ; preds = %95, %74
%76 = load i32, i32* %14
%77 = load i32, i32* %6
%78 = icmp slt i32 %76, %77
br i1 %78, label %79, label %98
79: ; preds = %75
%80 = load i32*, i32** %10
%81 = load i32, i32* %14
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i32, i32* %80, i64 %82
%84 = load i32, i32* %83
%85 = load i32*, i32** %8
%86 = load i32, i32* %14
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i32, i32* %85, i64 %87
%89 = load i32, i32* %88
%90 = mul nsw i32 %84, %89
%91 = load i32*, i32** %10
%92 = load i32, i32* %14
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i32, i32* %91, i64 %93
store i32 %90, i32* %94
br label %95
95: ; preds = %79
%96 = load i32, i32* %14
%97 = add nsw i32 %96, 1
store i32 %97, i32* %14
br label %75
98: ; preds = %75
ret void
}

LLVM IR (-O2):
define void @addmul(i32 %0, i32* nocapture %1, i32* nocapture %2, i32* nocapture %3, i32* nocapture %4) {
%6 = icmp sgt i32 %0, 0
br i1 %6, label %7, label %485
7: ; preds = %5
%8 = zext i32 %0 to i64
%9 = icmp ult i32 %0, 8
br i1 %9, label %95, label %10
10: ; preds = %7
%11 = getelementptr i32, i32* %3, i64 %8
%12 = getelementptr i32, i32* %1, i64 %8
%13 = icmp ugt i32* %12, %3
%14 = icmp ugt i32* %11, %1
%15 = and i1 %13, %14
br i1 %15, label %95, label %16
16: ; preds = %10
%17 = and i64 %8, 4294967288
%18 = add nsw i64 %17, -8
%19 = lshr exact i64 %18, 3
%20 = add nuw nsw i64 %19, 1
%21 = and i64 %20, 3
%22 = icmp ult i64 %18, 24
br i1 %22, label %74, label %23
23: ; preds = %16
%24 = and i64 %20, 4611686018427387900
br label %25
25: ; preds = %25, %23
%26 = phi i64 [ 0, %23 ], [ %71, %25 ]
%27 = phi i64 [ 0, %23 ], [ %72, %25 ]
%28 = getelementptr inbounds i32, i32* %1, i64 %26
%29 = bitcast i32* %28 to <4 x i32>*
%30 = load <4 x i32>, <4 x i32>* %29
%31 = getelementptr inbounds i32, i32* %28, i64 4
%32 = bitcast i32* %31 to <4 x i32>*
%33 = load <4 x i32>, <4 x i32>* %32
%34 = getelementptr inbounds i32, i32* %3, i64 %26
%35 = bitcast i32* %34 to <4 x i32>*
store <4 x i32> %30, <4 x i32>* %35
%36 = getelementptr inbounds i32, i32* %34, i64 4
%37 = bitcast i32* %36 to <4 x i32>*
store <4 x i32> %33, <4 x i32>* %37
%38 = or i64 %26, 8
%39 = getelementptr inbounds i32, i32* %1, i64 %38
%40 = bitcast i32* %39 to <4 x i32>*
%41 = load <4 x i32>, <4 x i32>* %40
%42 = getelementptr inbounds i32, i32* %39, i64 4
%43 = bitcast i32* %42 to <4 x i32>*
%44 = load <4 x i32>, <4 x i32>* %43
%45 = getelementptr inbounds i32, i32* %3, i64 %38
%46 = bitcast i32* %45 to <4 x i32>*
store <4 x i32> %41, <4 x i32>* %46
%47 = getelementptr inbounds i32, i32* %45, i64 4
%48 = bitcast i32* %47 to <4 x i32>*
store <4 x i32> %44, <4 x i32>* %48
%49 = or i64 %26, 16
%50 = getelementptr inbounds i32, i32* %1, i64 %49
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = getelementptr inbounds i32, i32* %50, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = getelementptr inbounds i32, i32* %3, i64 %49
%57 = bitcast i32* %56 to <4 x i32>*
store <4 x i32> %52, <4 x i32>* %57
%58 = getelementptr inbounds i32, i32* %56, i64 4
%59 = bitcast i32* %58 to <4 x i32>*
store <4 x i32> %55, <4 x i32>* %59
%60 = or i64 %26, 24
%61 = getelementptr inbounds i32, i32* %1, i64 %60
%62 = bitcast i32* %61 to <4 x i32>*
%63 = load <4 x i32>, <4 x i32>* %62
%64 = getelementptr inbounds i32, i32* %61, i64 4
%65 = bitcast i32* %64 to <4 x i32>*
%66 = load <4 x i32>, <4 x i32>* %65
%67 = getelementptr inbounds i32, i32* %3, i64 %60
%68 = bitcast i32* %67 to <4 x i32>*
store <4 x i32> %63, <4 x i32>* %68
%69 = getelementptr inbounds i32, i32* %67, i64 4
%70 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> %66, <4 x i32>* %70
%71 = add nuw i64 %26, 32
%72 = add i64 %27, 4
%73 = icmp eq i64 %72, %24
br i1 %73, label %74, label %25
74: ; preds = %25, %16
%75 = phi i64 [ 0, %16 ], [ %71, %25 ]
%76 = icmp eq i64 %21, 0
br i1 %76, label %93, label %77
77: ; preds = %74, %77
%78 = phi i64 [ %90, %77 ], [ %75, %74 ]
%79 = phi i64 [ %91, %77 ], [ 0, %74 ]
%80 = getelementptr inbounds i32, i32* %1, i64 %78
%81 = bitcast i32* %80 to <4 x i32>*
%82 = load <4 x i32>, <4 x i32>* %81
%83 = getelementptr inbounds i32, i32* %80, i64 4
%84 = bitcast i32* %83 to <4 x i32>*
%85 = load <4 x i32>, <4 x i32>* %84
%86 = getelementptr inbounds i32, i32* %3, i64 %78
%87 = bitcast i32* %86 to <4 x i32>*
store <4 x i32> %82, <4 x i32>* %87
%88 = getelementptr inbounds i32, i32* %86, i64 4
%89 = bitcast i32* %88 to <4 x i32>*
store <4 x i32> %85, <4 x i32>* %89
%90 = add nuw i64 %78, 8
%91 = add i64 %79, 1
%92 = icmp eq i64 %91, %21
br i1 %92, label %93, label %77
93: ; preds = %77, %74
%94 = icmp eq i64 %17, %8
br i1 %94, label %113, label %95
95: ; preds = %10, %7, %93
%96 = phi i64 [ 0, %10 ], [ 0, %7 ], [ %17, %93 ]
%97 = xor i64 %96, -1
%98 = add nsw i64 %97, %8
%99 = and i64 %8, 3
%100 = icmp eq i64 %99, 0
br i1 %100, label %110, label %101
101: ; preds = %95, %101
%102 = phi i64 [ %107, %101 ], [ %96, %95 ]
%103 = phi i64 [ %108, %101 ], [ 0, %95 ]
%104 = getelementptr inbounds i32, i32* %1, i64 %102
%105 = load i32, i32* %104
%106 = getelementptr inbounds i32, i32* %3, i64 %102
store i32 %105, i32* %106
%107 = add nuw nsw i64 %102, 1
%108 = add i64 %103, 1
%109 = icmp eq i64 %108, %99
br i1 %109, label %110, label %101
110: ; preds = %101, %95
%111 = phi i64 [ %96, %95 ], [ %107, %101 ]
%112 = icmp ult i64 %98, 3
br i1 %112, label %113, label %213
113: ; preds = %110, %213, %93
br i1 %6, label %114, label %485
114: ; preds = %113
%115 = zext i32 %0 to i64
%116 = icmp ult i32 %0, 8
br i1 %116, label %193, label %117
117: ; preds = %114
%118 = getelementptr i32, i32* %3, i64 %8
%119 = getelementptr i32, i32* %2, i64 %8
%120 = icmp ugt i32* %119, %3
%121 = icmp ugt i32* %118, %2
%122 = and i1 %120, %121
br i1 %122, label %193, label %123
123: ; preds = %117
%124 = and i64 %8, 4294967288
%125 = add nsw i64 %124, -8
%126 = lshr exact i64 %125, 3
%127 = add nuw nsw i64 %126, 1
%128 = and i64 %127, 1
%129 = icmp eq i64 %125, 0
br i1 %129, label %171, label %130
130: ; preds = %123
%131 = and i64 %127, 4611686018427387902
br label %132
132: ; preds = %132, %130
%133 = phi i64 [ 0, %130 ], [ %168, %132 ]
%134 = phi i64 [ 0, %130 ], [ %169, %132 ]
%135 = getelementptr inbounds i32, i32* %3, i64 %133
%136 = bitcast i32* %135 to <4 x i32>*
%137 = load <4 x i32>, <4 x i32>* %136
%138 = getelementptr inbounds i32, i32* %135, i64 4
%139 = bitcast i32* %138 to <4 x i32>*
%140 = load <4 x i32>, <4 x i32>* %139
%141 = getelementptr inbounds i32, i32* %2, i64 %133
%142 = bitcast i32* %141 to <4 x i32>*
%143 = load <4 x i32>, <4 x i32>* %142
%144 = getelementptr inbounds i32, i32* %141, i64 4
%145 = bitcast i32* %144 to <4 x i32>*
%146 = load <4 x i32>, <4 x i32>* %145
%147 = add nsw <4 x i32> %143, %137
%148 = add nsw <4 x i32> %146, %140
%149 = bitcast i32* %135 to <4 x i32>*
store <4 x i32> %147, <4 x i32>* %149
%150 = bitcast i32* %138 to <4 x i32>*
store <4 x i32> %148, <4 x i32>* %150
%151 = or i64 %133, 8
%152 = getelementptr inbounds i32, i32* %3, i64 %151
%153 = bitcast i32* %152 to <4 x i32>*
%154 = load <4 x i32>, <4 x i32>* %153
%155 = getelementptr inbounds i32, i32* %152, i64 4
%156 = bitcast i32* %155 to <4 x i32>*
%157 = load <4 x i32>, <4 x i32>* %156
%158 = getelementptr inbounds i32, i32* %2, i64 %151
%159 = bitcast i32* %158 to <4 x i32>*
%160 = load <4 x i32>, <4 x i32>* %159
%161 = getelementptr inbounds i32, i32* %158, i64 4
%162 = bitcast i32* %161 to <4 x i32>*
%163 = load <4 x i32>, <4 x i32>* %162
%164 = add nsw <4 x i32> %160, %154
%165 = add nsw <4 x i32> %163, %157
%166 = bitcast i32* %152 to <4 x i32>*
store <4 x i32> %164, <4 x i32>* %166
%167 = bitcast i32* %155 to <4 x i32>*
store <4 x i32> %165, <4 x i32>* %167
%168 = add nuw i64 %133, 16
%169 = add i64 %134, 2
%170 = icmp eq i64 %169, %131
br i1 %170, label %171, label %132
171: ; preds = %132, %123
%172 = phi i64 [ 0, %123 ], [ %168, %132 ]
%173 = icmp eq i64 %128, 0
br i1 %173, label %191, label %174
174: ; preds = %171
%175 = getelementptr inbounds i32, i32* %3, i64 %172
%176 = bitcast i32* %175 to <4 x i32>*
%177 = load <4 x i32>, <4 x i32>* %176
%178 = getelementptr inbounds i32, i32* %175, i64 4
%179 = bitcast i32* %178 to <4 x i32>*
%180 = load <4 x i32>, <4 x i32>* %179
%181 = getelementptr inbounds i32, i32* %2, i64 %172
%182 = bitcast i32* %181 to <4 x i32>*
%183 = load <4 x i32>, <4 x i32>* %182
%184 = getelementptr inbounds i32, i32* %181, i64 4
%185 = bitcast i32* %184 to <4 x i32>*
%186 = load <4 x i32>, <4 x i32>* %185
%187 = add nsw <4 x i32> %183, %177
%188 = add nsw <4 x i32> %186, %180
%189 = bitcast i32* %175 to <4 x i32>*
store <4 x i32> %187, <4 x i32>* %189
%190 = bitcast i32* %178 to <4 x i32>*
store <4 x i32> %188, <4 x i32>* %190
br label %191
191: ; preds = %171, %174
%192 = icmp eq i64 %124, %8
br i1 %192, label %232, label %193
193: ; preds = %117, %114, %191
%194 = phi i64 [ 0, %117 ], [ 0, %114 ], [ %124, %191 ]
%195 = xor i64 %194, -1
%196 = add nsw i64 %195, %8
%197 = and i64 %8, 3
%198 = icmp eq i64 %197, 0
br i1 %198, label %210, label %199
199: ; preds = %193, %199
%200 = phi i64 [ %207, %199 ], [ %194, %193 ]
%201 = phi i64 [ %208, %199 ], [ 0, %193 ]
%202 = getelementptr inbounds i32, i32* %3, i64 %200
%203 = load i32, i32* %202
%204 = getelementptr inbounds i32, i32* %2, i64 %200
%205 = load i32, i32* %204
%206 = add nsw i32 %205, %203
store i32 %206, i32* %202
%207 = add nuw nsw i64 %200, 1
%208 = add i64 %201, 1
%209 = icmp eq i64 %208, %197
br i1 %209, label %210, label %199
210: ; preds = %199, %193
%211 = phi i64 [ %194, %193 ], [ %207, %199 ]
%212 = icmp ult i64 %196, 3
br i1 %212, label %232, label %339
213: ; preds = %110, %213
%214 = phi i64 [ %230, %213 ], [ %111, %110 ]
%215 = getelementptr inbounds i32, i32* %1, i64 %214
%216 = load i32, i32* %215
%217 = getelementptr inbounds i32, i32* %3, i64 %214
store i32 %216, i32* %217
%218 = add nuw nsw i64 %214, 1
%219 = getelementptr inbounds i32, i32* %1, i64 %218
%220 = load i32, i32* %219
%221 = getelementptr inbounds i32, i32* %3, i64 %218
store i32 %220, i32* %221
%222 = add nuw nsw i64 %214, 2
%223 = getelementptr inbounds i32, i32* %1, i64 %222
%224 = load i32, i32* %223
%225 = getelementptr inbounds i32, i32* %3, i64 %222
store i32 %224, i32* %225
%226 = add nuw nsw i64 %214, 3
%227 = getelementptr inbounds i32, i32* %1, i64 %226
%228 = load i32, i32* %227
%229 = getelementptr inbounds i32, i32* %3, i64 %226
store i32 %228, i32* %229
%230 = add nuw nsw i64 %214, 4
%231 = icmp eq i64 %230, %8
br i1 %231, label %113, label %213
232: ; preds = %210, %339, %191
br i1 %6, label %233, label %485
233: ; preds = %232
%234 = zext i32 %0 to i64
%235 = icmp ult i32 %0, 8
br i1 %235, label %321, label %236
236: ; preds = %233
%237 = getelementptr i32, i32* %4, i64 %8
%238 = getelementptr i32, i32* %1, i64 %8
%239 = icmp ugt i32* %238, %4
%240 = icmp ugt i32* %237, %1
%241 = and i1 %239, %240
br i1 %241, label %321, label %242
242: ; preds = %236
%243 = and i64 %8, 4294967288
%244 = add nsw i64 %243, -8
%245 = lshr exact i64 %244, 3
%246 = add nuw nsw i64 %245, 1
%247 = and i64 %246, 3
%248 = icmp ult i64 %244, 24
br i1 %248, label %300, label %249
249: ; preds = %242
%250 = and i64 %246, 4611686018427387900
br label %251
251: ; preds = %251, %249
%252 = phi i64 [ 0, %249 ], [ %297, %251 ]
%253 = phi i64 [ 0, %249 ], [ %298, %251 ]
%254 = getelementptr inbounds i32, i32* %1, i64 %252
%255 = bitcast i32* %254 to <4 x i32>*
%256 = load <4 x i32>, <4 x i32>* %255
%257 = getelementptr inbounds i32, i32* %254, i64 4
%258 = bitcast i32* %257 to <4 x i32>*
%259 = load <4 x i32>, <4 x i32>* %258
%260 = getelementptr inbounds i32, i32* %4, i64 %252
%261 = bitcast i32* %260 to <4 x i32>*
store <4 x i32> %256, <4 x i32>* %261
%262 = getelementptr inbounds i32, i32* %260, i64 4
%263 = bitcast i32* %262 to <4 x i32>*
store <4 x i32> %259, <4 x i32>* %263
%264 = or i64 %252, 8
%265 = getelementptr inbounds i32, i32* %1, i64 %264
%266 = bitcast i32* %265 to <4 x i32>*
%267 = load <4 x i32>, <4 x i32>* %266
%268 = getelementptr inbounds i32, i32* %265, i64 4
%269 = bitcast i32* %268 to <4 x i32>*
%270 = load <4 x i32>, <4 x i32>* %269
%271 = getelementptr inbounds i32, i32* %4, i64 %264
%272 = bitcast i32* %271 to <4 x i32>*
store <4 x i32> %267, <4 x i32>* %272
%273 = getelementptr inbounds i32, i32* %271, i64 4
%274 = bitcast i32* %273 to <4 x i32>*
store <4 x i32> %270, <4 x i32>* %274
%275 = or i64 %252, 16
%276 = getelementptr inbounds i32, i32* %1, i64 %275
%277 = bitcast i32* %276 to <4 x i32>*
%278 = load <4 x i32>, <4 x i32>* %277
%279 = getelementptr inbounds i32, i32* %276, i64 4
%280 = bitcast i32* %279 to <4 x i32>*
%281 = load <4 x i32>, <4 x i32>* %280
%282 = getelementptr inbounds i32, i32* %4, i64 %275
%283 = bitcast i32* %282 to <4 x i32>*
store <4 x i32> %278, <4 x i32>* %283
%284 = getelementptr inbounds i32, i32* %282, i64 4
%285 = bitcast i32* %284 to <4 x i32>*
store <4 x i32> %281, <4 x i32>* %285
%286 = or i64 %252, 24
%287 = getelementptr inbounds i32, i32* %1, i64 %286
%288 = bitcast i32* %287 to <4 x i32>*
%289 = load <4 x i32>, <4 x i32>* %288
%290 = getelementptr inbounds i32, i32* %287, i64 4
%291 = bitcast i32* %290 to <4 x i32>*
%292 = load <4 x i32>, <4 x i32>* %291
%293 = getelementptr inbounds i32, i32* %4, i64 %286
%294 = bitcast i32* %293 to <4 x i32>*
store <4 x i32> %289, <4 x i32>* %294
%295 = getelementptr inbounds i32, i32* %293, i64 4
%296 = bitcast i32* %295 to <4 x i32>*
store <4 x i32> %292, <4 x i32>* %296
%297 = add nuw i64 %252, 32
%298 = add i64 %253, 4
%299 = icmp eq i64 %298, %250
br i1 %299, label %300, label %251
300: ; preds = %251, %242
%301 = phi i64 [ 0, %242 ], [ %297, %251 ]
%302 = icmp eq i64 %247, 0
br i1 %302, label %319, label %303
303: ; preds = %300, %303
%304 = phi i64 [ %316, %303 ], [ %301, %300 ]
%305 = phi i64 [ %317, %303 ], [ 0, %300 ]
%306 = getelementptr inbounds i32, i32* %1, i64 %304
%307 = bitcast i32* %306 to <4 x i32>*
%308 = load <4 x i32>, <4 x i32>* %307
%309 = getelementptr inbounds i32, i32* %306, i64 4
%310 = bitcast i32* %309 to <4 x i32>*
%311 = load <4 x i32>, <4 x i32>* %310
%312 = getelementptr inbounds i32, i32* %4, i64 %304
%313 = bitcast i32* %312 to <4 x i32>*
store <4 x i32> %308, <4 x i32>* %313
%314 = getelementptr inbounds i32, i32* %312, i64 4
%315 = bitcast i32* %314 to <4 x i32>*
store <4 x i32> %311, <4 x i32>* %315
%316 = add nuw i64 %304, 8
%317 = add i64 %305, 1
%318 = icmp eq i64 %317, %247
br i1 %318, label %319, label %303
319: ; preds = %303, %300
%320 = icmp eq i64 %243, %8
br i1 %320, label %366, label %321
321: ; preds = %236, %233, %319
%322 = phi i64 [ 0, %236 ], [ 0, %233 ], [ %243, %319 ]
%323 = xor i64 %322, -1
%324 = add nsw i64 %323, %8
%325 = and i64 %8, 3
%326 = icmp eq i64 %325, 0
br i1 %326, label %336, label %327
327: ; preds = %321, %327
%328 = phi i64 [ %333, %327 ], [ %322, %321 ]
%329 = phi i64 [ %334, %327 ], [ 0, %321 ]
%330 = getelementptr inbounds i32, i32* %1, i64 %328
%331 = load i32, i32* %330
%332 = getelementptr inbounds i32, i32* %4, i64 %328
store i32 %331, i32* %332
%333 = add nuw nsw i64 %328, 1
%334 = add i64 %329, 1
%335 = icmp eq i64 %334, %325
br i1 %335, label %336, label %327
336: ; preds = %327, %321
%337 = phi i64 [ %322, %321 ], [ %333, %327 ]
%338 = icmp ult i64 %324, 3
br i1 %338, label %366, label %466
339: ; preds = %210, %339
%340 = phi i64 [ %364, %339 ], [ %211, %210 ]
%341 = getelementptr inbounds i32, i32* %3, i64 %340
%342 = load i32, i32* %341
%343 = getelementptr inbounds i32, i32* %2, i64 %340
%344 = load i32, i32* %343
%345 = add nsw i32 %344, %342
store i32 %345, i32* %341
%346 = add nuw nsw i64 %340, 1
%347 = getelementptr inbounds i32, i32* %3, i64 %346
%348 = load i32, i32* %347
%349 = getelementptr inbounds i32, i32* %2, i64 %346
%350 = load i32, i32* %349
%351 = add nsw i32 %350, %348
store i32 %351, i32* %347
%352 = add nuw nsw i64 %340, 2
%353 = getelementptr inbounds i32, i32* %3, i64 %352
%354 = load i32, i32* %353
%355 = getelementptr inbounds i32, i32* %2, i64 %352
%356 = load i32, i32* %355
%357 = add nsw i32 %356, %354
store i32 %357, i32* %353
%358 = add nuw nsw i64 %340, 3
%359 = getelementptr inbounds i32, i32* %3, i64 %358
%360 = load i32, i32* %359
%361 = getelementptr inbounds i32, i32* %2, i64 %358
%362 = load i32, i32* %361
%363 = add nsw i32 %362, %360
store i32 %363, i32* %359
%364 = add nuw nsw i64 %340, 4
%365 = icmp eq i64 %364, %115
br i1 %365, label %232, label %339
366: ; preds = %336, %466, %319
br i1 %6, label %367, label %485
367: ; preds = %366
%368 = zext i32 %0 to i64
%369 = icmp ult i32 %0, 8
br i1 %369, label %446, label %370
370: ; preds = %367
%371 = getelementptr i32, i32* %4, i64 %8
%372 = getelementptr i32, i32* %2, i64 %8
%373 = icmp ugt i32* %372, %4
%374 = icmp ugt i32* %371, %2
%375 = and i1 %373, %374
br i1 %375, label %446, label %376
376: ; preds = %370
%377 = and i64 %8, 4294967288
%378 = add nsw i64 %377, -8
%379 = lshr exact i64 %378, 3
%380 = add nuw nsw i64 %379, 1
%381 = and i64 %380, 1
%382 = icmp eq i64 %378, 0
br i1 %382, label %424, label %383
383: ; preds = %376
%384 = and i64 %380, 4611686018427387902
br label %385
385: ; preds = %385, %383
%386 = phi i64 [ 0, %383 ], [ %421, %385 ]
%387 = phi i64 [ 0, %383 ], [ %422, %385 ]
%388 = getelementptr inbounds i32, i32* %4, i64 %386
%389 = bitcast i32* %388 to <4 x i32>*
%390 = load <4 x i32>, <4 x i32>* %389
%391 = getelementptr inbounds i32, i32* %388, i64 4
%392 = bitcast i32* %391 to <4 x i32>*
%393 = load <4 x i32>, <4 x i32>* %392
%394 = getelementptr inbounds i32, i32* %2, i64 %386
%395 = bitcast i32* %394 to <4 x i32>*
%396 = load <4 x i32>, <4 x i32>* %395
%397 = getelementptr inbounds i32, i32* %394, i64 4
%398 = bitcast i32* %397 to <4 x i32>*
%399 = load <4 x i32>, <4 x i32>* %398
%400 = mul nsw <4 x i32> %396, %390
%401 = mul nsw <4 x i32> %399, %393
%402 = bitcast i32* %388 to <4 x i32>*
store <4 x i32> %400, <4 x i32>* %402
%403 = bitcast i32* %391 to <4 x i32>*
store <4 x i32> %401, <4 x i32>* %403
%404 = or i64 %386, 8
%405 = getelementptr inbounds i32, i32* %4, i64 %404
%406 = bitcast i32* %405 to <4 x i32>*
%407 = load <4 x i32>, <4 x i32>* %406
%408 = getelementptr inbounds i32, i32* %405, i64 4
%409 = bitcast i32* %408 to <4 x i32>*
%410 = load <4 x i32>, <4 x i32>* %409
%411 = getelementptr inbounds i32, i32* %2, i64 %404
%412 = bitcast i32* %411 to <4 x i32>*
%413 = load <4 x i32>, <4 x i32>* %412
%414 = getelementptr inbounds i32, i32* %411, i64 4
%415 = bitcast i32* %414 to <4 x i32>*
%416 = load <4 x i32>, <4 x i32>* %415
%417 = mul nsw <4 x i32> %413, %407
%418 = mul nsw <4 x i32> %416, %410
%419 = bitcast i32* %405 to <4 x i32>*
store <4 x i32> %417, <4 x i32>* %419
%420 = bitcast i32* %408 to <4 x i32>*
store <4 x i32> %418, <4 x i32>* %420
%421 = add nuw i64 %386, 16
%422 = add i64 %387, 2
%423 = icmp eq i64 %422, %384
br i1 %423, label %424, label %385
424: ; preds = %385, %376
%425 = phi i64 [ 0, %376 ], [ %421, %385 ]
%426 = icmp eq i64 %381, 0
br i1 %426, label %444, label %427
427: ; preds = %424
%428 = getelementptr inbounds i32, i32* %4, i64 %425
%429 = bitcast i32* %428 to <4 x i32>*
%430 = load <4 x i32>, <4 x i32>* %429
%431 = getelementptr inbounds i32, i32* %428, i64 4
%432 = bitcast i32* %431 to <4 x i32>*
%433 = load <4 x i32>, <4 x i32>* %432
%434 = getelementptr inbounds i32, i32* %2, i64 %425
%435 = bitcast i32* %434 to <4 x i32>*
%436 = load <4 x i32>, <4 x i32>* %435
%437 = getelementptr inbounds i32, i32* %434, i64 4
%438 = bitcast i32* %437 to <4 x i32>*
%439 = load <4 x i32>, <4 x i32>* %438
%440 = mul nsw <4 x i32> %436, %430
%441 = mul nsw <4 x i32> %439, %433
%442 = bitcast i32* %428 to <4 x i32>*
store <4 x i32> %440, <4 x i32>* %442
%443 = bitcast i32* %431 to <4 x i32>*
store <4 x i32> %441, <4 x i32>* %443
br label %444
444: ; preds = %424, %427
%445 = icmp eq i64 %377, %8
br i1 %445, label %485, label %446
446: ; preds = %370, %367, %444
%447 = phi i64 [ 0, %370 ], [ 0, %367 ], [ %377, %444 ]
%448 = xor i64 %447, -1
%449 = add nsw i64 %448, %8
%450 = and i64 %8, 3
%451 = icmp eq i64 %450, 0
br i1 %451, label %463, label %452
452: ; preds = %446, %452
%453 = phi i64 [ %460, %452 ], [ %447, %446 ]
%454 = phi i64 [ %461, %452 ], [ 0, %446 ]
%455 = getelementptr inbounds i32, i32* %4, i64 %453
%456 = load i32, i32* %455
%457 = getelementptr inbounds i32, i32* %2, i64 %453
%458 = load i32, i32* %457
%459 = mul nsw i32 %458, %456
store i32 %459, i32* %455
%460 = add nuw nsw i64 %453, 1
%461 = add i64 %454, 1
%462 = icmp eq i64 %461, %450
br i1 %462, label %463, label %452
463: ; preds = %452, %446
%464 = phi i64 [ %447, %446 ], [ %460, %452 ]
%465 = icmp ult i64 %449, 3
br i1 %465, label %485, label %486
466: ; preds = %336, %466
%467 = phi i64 [ %483, %466 ], [ %337, %336 ]
%468 = getelementptr inbounds i32, i32* %1, i64 %467
%469 = load i32, i32* %468
%470 = getelementptr inbounds i32, i32* %4, i64 %467
store i32 %469, i32* %470
%471 = add nuw nsw i64 %467, 1
%472 = getelementptr inbounds i32, i32* %1, i64 %471
%473 = load i32, i32* %472
%474 = getelementptr inbounds i32, i32* %4, i64 %471
store i32 %473, i32* %474
%475 = add nuw nsw i64 %467, 2
%476 = getelementptr inbounds i32, i32* %1, i64 %475
%477 = load i32, i32* %476
%478 = getelementptr inbounds i32, i32* %4, i64 %475
store i32 %477, i32* %478
%479 = add nuw nsw i64 %467, 3
%480 = getelementptr inbounds i32, i32* %1, i64 %479
%481 = load i32, i32* %480
%482 = getelementptr inbounds i32, i32* %4, i64 %479
store i32 %481, i32* %482
%483 = add nuw nsw i64 %467, 4
%484 = icmp eq i64 %483, %234
br i1 %484, label %366, label %466
485: ; preds = %463, %486, %444, %5, %113, %232, %366
ret void
486: ; preds = %463, %486
%487 = phi i64 [ %511, %486 ], [ %464, %463 ]
%488 = getelementptr inbounds i32, i32* %4, i64 %487
%489 = load i32, i32* %488
%490 = getelementptr inbounds i32, i32* %2, i64 %487
%491 = load i32, i32* %490
%492 = mul nsw i32 %491, %489
store i32 %492, i32* %488
%493 = add nuw nsw i64 %487, 1
%494 = getelementptr inbounds i32, i32* %4, i64 %493
%495 = load i32, i32* %494
%496 = getelementptr inbounds i32, i32* %2, i64 %493
%497 = load i32, i32* %496
%498 = mul nsw i32 %497, %495
store i32 %498, i32* %494
%499 = add nuw nsw i64 %487, 2
%500 = getelementptr inbounds i32, i32* %4, i64 %499
%501 = load i32, i32* %500
%502 = getelementptr inbounds i32, i32* %2, i64 %499
%503 = load i32, i32* %502
%504 = mul nsw i32 %503, %501
store i32 %504, i32* %500
%505 = add nuw nsw i64 %487, 3
%506 = getelementptr inbounds i32, i32* %4, i64 %505
%507 = load i32, i32* %506
%508 = getelementptr inbounds i32, i32* %2, i64 %505
%509 = load i32, i32* %508
%510 = mul nsw i32 %509, %507
store i32 %510, i32* %506
%511 = add nuw nsw i64 %487, 4
%512 = icmp eq i64 %511, %368
br i1 %512, label %485, label %486
}