#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 */
void *malloc(int);
float producer(int, int);
float **storeAllCompute() {
  int x, y, i, j;
  float producer_arr[4 + 1][40 + 1];
  float **consumer_arr;
  int correctness = 0;
  consumer_arr = malloc(4 * sizeof(float *));
  for (i = 0; i < 4; i++)
    consumer_arr[i] = malloc(40 * sizeof(float));
  for (x = 0; x < 4 + 1; x++)
    for (y = 0; y < 40 + 1; y++)
      producer_arr[x][y] = producer(x, y);
  for (x = 0; x < 4; x++)
    for (y = 0; y < 40; y++)
      consumer_arr[x][y] = producer_arr[x][y] + producer_arr[x + 1][y + 1] +
                           producer_arr[x + 1][y] + producer_arr[x][y + 1];
  return consumer_arr;
}


x86 assembly (clang, -O0):
<storeAllCompute>:
push   %rbp
mov    %rsp,%rbp
sub    $0x360,%rsp
movl   $0x0,-0x35c(%rbp)
mov    $0x20,%edi
call   1040 <malloc@plt>
mov    %rax,-0x358(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x4,-0xc(%rbp)
jge    1181 <storeAllCompute+0x61>
mov    $0xa0,%edi
call   1040 <malloc@plt>
mov    %rax,%rdx
mov    -0x358(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    114d <storeAllCompute+0x2d>
movl   $0x0,-0x4(%rbp)
cmpl   $0x5,-0x4(%rbp)
jge    11ed <storeAllCompute+0xcd>
movl   $0x0,-0x8(%rbp)
cmpl   $0x29,-0x8(%rbp)
jge    11da <storeAllCompute+0xba>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
call   1030 <producer@plt>
movslq -0x4(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0xa4,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1199 <storeAllCompute+0x79>
jmp    11df <storeAllCompute+0xbf>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    1188 <storeAllCompute+0x68>
movl   $0x0,-0x4(%rbp)
cmpl   $0x4,-0x4(%rbp)
jge    12d4 <storeAllCompute+0x1b4>
movl   $0x0,-0x8(%rbp)
cmpl   $0x28,-0x8(%rbp)
jge    12c1 <storeAllCompute+0x1a1>
movslq -0x4(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0xa4,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x350(%rbp),%rax
imul   $0xa4,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x350(%rbp),%rax
imul   $0xa4,%rcx,%rcx
add    %rcx,%rax
movslq -0x8(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movslq -0x4(%rbp),%rcx
lea    -0x350(%rbp),%rax
imul   $0xa4,%rcx,%rcx
add    %rcx,%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x358(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1205 <storeAllCompute+0xe5>
jmp    12c6 <storeAllCompute+0x1a6>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    11f4 <storeAllCompute+0xd4>
mov    -0x358(%rbp),%rax
add    $0x360,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<storeAllCompute>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x338,%rsp
mov    $0x20,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
mov    $0xa0,%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
mov    %rax,(%r14)
mov    $0xa0,%edi
call   1040 <malloc@plt>
mov    %rax,%r13
mov    %rax,0x8(%r14)
mov    $0xa0,%edi
call   1040 <malloc@plt>
mov    %rax,%r12
mov    %rax,0x10(%r14)
mov    $0xa0,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %rax,0x18(%r14)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %edi,%edi
mov    %ebp,%esi
call   1030 <producer@plt>
movss  %xmm0,(%rsp,%rbp,4)
add    $0x1,%rbp
cmp    $0x29,%rbp
jne    1190 <storeAllCompute+0x70>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    $0x1,%edi
mov    %ebp,%esi
call   1030 <producer@plt>
movss  %xmm0,0xa4(%rsp,%rbp,4)
add    $0x1,%rbp
cmp    $0x29,%rbp
jne    11b0 <storeAllCompute+0x90>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x2,%edi
mov    %ebp,%esi
call   1030 <producer@plt>
movss  %xmm0,0x148(%rsp,%rbp,4)
add    $0x1,%rbp
cmp    $0x29,%rbp
jne    11e0 <storeAllCompute+0xc0>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x3,%edi
mov    %ebp,%esi
call   1030 <producer@plt>
movss  %xmm0,0x1ec(%rsp,%rbp,4)
add    $0x1,%rbp
cmp    $0x29,%rbp
jne    1210 <storeAllCompute+0xf0>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x4,%edi
mov    %ebp,%esi
call   1030 <producer@plt>
movss  %xmm0,0x290(%rsp,%rbp,4)
add    $0x1,%rbp
cmp    $0x29,%rbp
jne    1240 <storeAllCompute+0x120>
movups 0xa8(%rsp),%xmm2
movss  0xa4(%rsp),%xmm0
movaps %xmm0,%xmm1
movlhps %xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
movups 0x4(%rsp),%xmm3
movss  (%rsp),%xmm4
movlhps %xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
addps  %xmm2,%xmm4
addps  %xmm1,%xmm4
addps  %xmm3,%xmm4
movups %xmm4,(%rbx)
movups 0x14(%rsp),%xmm1
movups 0xb8(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm2
shufps $0x98,%xmm4,%xmm2
shufps $0x3,%xmm1,%xmm3
shufps $0x98,%xmm1,%xmm3
addps  %xmm4,%xmm3
addps  %xmm2,%xmm3
addps  %xmm1,%xmm3
movups %xmm3,0x10(%rbx)
movups 0x24(%rsp),%xmm2
movups 0xc8(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
addps  %xmm3,%xmm1
addps  %xmm4,%xmm1
addps  %xmm2,%xmm1
movups %xmm1,0x20(%rbx)
movups 0x34(%rsp),%xmm1
movups 0xd8(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
shufps $0x3,%xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
addps  %xmm4,%xmm2
addps  %xmm3,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x30(%rbx)
movups 0x44(%rsp),%xmm2
movups 0xe8(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
addps  %xmm3,%xmm1
addps  %xmm4,%xmm1
addps  %xmm2,%xmm1
movups %xmm1,0x40(%rbx)
movups 0x54(%rsp),%xmm1
movups 0xf8(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
shufps $0x3,%xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
addps  %xmm4,%xmm2
addps  %xmm3,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x50(%rbx)
movups 0x64(%rsp),%xmm2
movups 0x108(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
addps  %xmm3,%xmm1
addps  %xmm4,%xmm1
addps  %xmm2,%xmm1
movups %xmm1,0x60(%rbx)
movups 0x74(%rsp),%xmm1
movups 0x118(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
shufps $0x3,%xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
addps  %xmm4,%xmm2
addps  %xmm3,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x70(%rbx)
movups 0x84(%rsp),%xmm2
movups 0x128(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
addps  %xmm3,%xmm1
addps  %xmm4,%xmm1
addps  %xmm2,%xmm1
movups %xmm1,0x80(%rbx)
movups 0x94(%rsp),%xmm1
movups 0x138(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
shufps $0x3,%xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
addps  %xmm4,%xmm2
addps  %xmm3,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x90(%rbx)
movups 0x14c(%rsp),%xmm2
movss  0x148(%rsp),%xmm1
movaps %xmm1,%xmm3
movlhps %xmm2,%xmm3
shufps $0x98,%xmm2,%xmm3
movups 0xa8(%rsp),%xmm4
movlhps %xmm4,%xmm0
shufps $0x98,%xmm4,%xmm0
addps  %xmm2,%xmm0
addps  %xmm3,%xmm0
addps  %xmm4,%xmm0
movups %xmm0,0x0(%r13)
movups 0xb8(%rsp),%xmm0
movups 0x15c(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm2
shufps $0x98,%xmm3,%xmm2
shufps $0x3,%xmm0,%xmm4
shufps $0x98,%xmm0,%xmm4
addps  %xmm3,%xmm4
addps  %xmm2,%xmm4
addps  %xmm0,%xmm4
movups %xmm4,0x10(%r13)
movups 0xc8(%rsp),%xmm2
movups 0x16c(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
shufps $0x3,%xmm2,%xmm0
shufps $0x98,%xmm2,%xmm0
addps  %xmm4,%xmm0
addps  %xmm3,%xmm0
addps  %xmm2,%xmm0
movups %xmm0,0x20(%r13)
movups 0xd8(%rsp),%xmm0
movups 0x17c(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
shufps $0x3,%xmm0,%xmm2
shufps $0x98,%xmm0,%xmm2
addps  %xmm3,%xmm2
addps  %xmm4,%xmm2
addps  %xmm0,%xmm2
movups %xmm2,0x30(%r13)
movups 0xe8(%rsp),%xmm2
movups 0x18c(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
shufps $0x3,%xmm2,%xmm0
shufps $0x98,%xmm2,%xmm0
addps  %xmm4,%xmm0
addps  %xmm3,%xmm0
addps  %xmm2,%xmm0
movups %xmm0,0x40(%r13)
movups 0xf8(%rsp),%xmm0
movups 0x19c(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
shufps $0x3,%xmm0,%xmm2
shufps $0x98,%xmm0,%xmm2
addps  %xmm3,%xmm2
addps  %xmm4,%xmm2
addps  %xmm0,%xmm2
movups %xmm2,0x50(%r13)
movups 0x108(%rsp),%xmm2
movups 0x1ac(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
shufps $0x3,%xmm2,%xmm0
shufps $0x98,%xmm2,%xmm0
addps  %xmm4,%xmm0
addps  %xmm3,%xmm0
addps  %xmm2,%xmm0
movups %xmm0,0x60(%r13)
movups 0x118(%rsp),%xmm0
movups 0x1bc(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
shufps $0x3,%xmm0,%xmm2
shufps $0x98,%xmm0,%xmm2
addps  %xmm3,%xmm2
addps  %xmm4,%xmm2
addps  %xmm0,%xmm2
movups %xmm2,0x70(%r13)
movups 0x128(%rsp),%xmm2
movups 0x1cc(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
shufps $0x3,%xmm2,%xmm0
shufps $0x98,%xmm2,%xmm0
addps  %xmm4,%xmm0
addps  %xmm3,%xmm0
addps  %xmm2,%xmm0
movups %xmm0,0x80(%r13)
movups 0x138(%rsp),%xmm0
movups 0x1dc(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
shufps $0x3,%xmm0,%xmm2
shufps $0x98,%xmm0,%xmm2
addps  %xmm3,%xmm2
addps  %xmm4,%xmm2
addps  %xmm0,%xmm2
movups %xmm2,0x90(%r13)
movaps 0x1f0(%rsp),%xmm2
movss  0x1ec(%rsp),%xmm0
movaps %xmm0,%xmm3
movlhps %xmm2,%xmm3
shufps $0x98,%xmm2,%xmm3
movups 0x14c(%rsp),%xmm4
movlhps %xmm4,%xmm1
shufps $0x98,%xmm4,%xmm1
addps  %xmm2,%xmm1
addps  %xmm3,%xmm1
addps  %xmm4,%xmm1
movups %xmm1,(%r12)
movaps 0x200(%rsp),%xmm1
shufps $0x3,%xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
movups 0x15c(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
addps  %xmm1,%xmm4
addps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm4,0x10(%r12)
movaps 0x210(%rsp),%xmm2
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
movups 0x16c(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
addps  %xmm2,%xmm3
addps  %xmm1,%xmm3
addps  %xmm4,%xmm3
movups %xmm3,0x20(%r12)
movaps 0x220(%rsp),%xmm1
shufps $0x3,%xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
movups 0x17c(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
addps  %xmm1,%xmm4
addps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm4,0x30(%r12)
movaps 0x230(%rsp),%xmm2
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
movups 0x18c(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
addps  %xmm2,%xmm3
addps  %xmm1,%xmm3
addps  %xmm4,%xmm3
movups %xmm3,0x40(%r12)
movaps 0x240(%rsp),%xmm1
shufps $0x3,%xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
movups 0x19c(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
addps  %xmm1,%xmm4
addps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm4,0x50(%r12)
movaps 0x250(%rsp),%xmm2
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
movups 0x1ac(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
addps  %xmm2,%xmm3
addps  %xmm1,%xmm3
addps  %xmm4,%xmm3
movups %xmm3,0x60(%r12)
movaps 0x260(%rsp),%xmm1
shufps $0x3,%xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
movups 0x1bc(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
addps  %xmm1,%xmm4
addps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm4,0x70(%r12)
movaps 0x270(%rsp),%xmm2
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
movups 0x1cc(%rsp),%xmm4
shufps $0x3,%xmm4,%xmm3
shufps $0x98,%xmm4,%xmm3
addps  %xmm2,%xmm3
addps  %xmm1,%xmm3
addps  %xmm4,%xmm3
movups %xmm3,0x80(%r12)
movaps 0x280(%rsp),%xmm1
shufps $0x3,%xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
movups 0x1dc(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm4
shufps $0x98,%xmm3,%xmm4
addps  %xmm1,%xmm4
addps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movups %xmm4,0x90(%r12)
movups 0x294(%rsp),%xmm1
movss  0x290(%rsp),%xmm2
movlhps %xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
movaps 0x1f0(%rsp),%xmm3
movlhps %xmm3,%xmm0
shufps $0x98,%xmm3,%xmm0
addps  %xmm1,%xmm0
addps  %xmm2,%xmm0
addps  %xmm3,%xmm0
movups %xmm0,(%r15)
movups 0x2a4(%rsp),%xmm0
shufps $0x3,%xmm0,%xmm1
shufps $0x98,%xmm0,%xmm1
movaps 0x200(%rsp),%xmm2
shufps $0x3,%xmm2,%xmm3
shufps $0x98,%xmm2,%xmm3
addps  %xmm0,%xmm3
addps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x10(%r15)
movups 0x2b4(%rsp),%xmm1
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
movaps 0x210(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm2
shufps $0x98,%xmm3,%xmm2
addps  %xmm1,%xmm2
addps  %xmm0,%xmm2
addps  %xmm3,%xmm2
movups %xmm2,0x20(%r15)
movups 0x2c4(%rsp),%xmm0
shufps $0x3,%xmm0,%xmm1
shufps $0x98,%xmm0,%xmm1
movaps 0x220(%rsp),%xmm2
shufps $0x3,%xmm2,%xmm3
shufps $0x98,%xmm2,%xmm3
addps  %xmm0,%xmm3
addps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x30(%r15)
movups 0x2d4(%rsp),%xmm1
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
movaps 0x230(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm2
shufps $0x98,%xmm3,%xmm2
addps  %xmm1,%xmm2
addps  %xmm0,%xmm2
addps  %xmm3,%xmm2
movups %xmm2,0x40(%r15)
movups 0x2e4(%rsp),%xmm0
shufps $0x3,%xmm0,%xmm1
shufps $0x98,%xmm0,%xmm1
movaps 0x240(%rsp),%xmm2
shufps $0x3,%xmm2,%xmm3
shufps $0x98,%xmm2,%xmm3
addps  %xmm0,%xmm3
addps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x50(%r15)
movups 0x2f4(%rsp),%xmm1
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
movaps 0x250(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm2
shufps $0x98,%xmm3,%xmm2
addps  %xmm1,%xmm2
addps  %xmm0,%xmm2
addps  %xmm3,%xmm2
movups %xmm2,0x60(%r15)
movups 0x304(%rsp),%xmm0
shufps $0x3,%xmm0,%xmm1
shufps $0x98,%xmm0,%xmm1
movaps 0x260(%rsp),%xmm2
shufps $0x3,%xmm2,%xmm3
shufps $0x98,%xmm2,%xmm3
addps  %xmm0,%xmm3
addps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x70(%r15)
movups 0x314(%rsp),%xmm1
shufps $0x3,%xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
movaps 0x270(%rsp),%xmm3
shufps $0x3,%xmm3,%xmm2
shufps $0x98,%xmm3,%xmm2
addps  %xmm1,%xmm2
addps  %xmm0,%xmm2
addps  %xmm3,%xmm2
movups %xmm2,0x80(%r15)
movups 0x324(%rsp),%xmm0
shufps $0x3,%xmm0,%xmm1
shufps $0x98,%xmm0,%xmm1
movaps 0x280(%rsp),%xmm2
shufps $0x3,%xmm2,%xmm3
shufps $0x98,%xmm2,%xmm3
addps  %xmm0,%xmm3
addps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm3,0x90(%r15)
mov    %r14,%rax
add    $0x338,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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