#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*/ abort();
void test_reductions_int(void) {
  const int n = 1000;
  int i;
  int array[n];
  for (i = 0; i < n; i++)
    array[i] = i;
  {
    int res, vres;
    res = (0);
#pragma acc parallel vector_length(vl) copy(res)

#pragma acc loop reduction(+ : res)
    for (i = 0; i < n; i++)
      res = res + (array[i]);
    vres = (0);
    for (i = 0; i < n; i++)
      vres = vres + (array[i]);
    if (res != vres)
      abort();
  };
  {
    int res, vres;
    res = (1);
#pragma acc parallel vector_length(vl) copy(res)

#pragma acc loop reduction(* : res)
    for (i = 0; i < n; i++)
      res = res * (array[i]);
    vres = (1);
    for (i = 0; i < n; i++)
      vres = vres * (array[i]);
    if (res != vres)
      abort();
  };
  {
    int res, vres;
    res = (-1);
#pragma acc parallel vector_length(vl) copy(res)

#pragma acc loop reduction(& : res)
    for (i = 0; i < n; i++)
      res = res & (array[i]);
    vres = (-1);
    for (i = 0; i < n; i++)
      vres = vres & (array[i]);
    if (res != vres)
      abort();
  };
  {
    int res, vres;
    res = (0);
#pragma acc parallel vector_length(vl) copy(res)

#pragma acc loop reduction(| : res)
    for (i = 0; i < n; i++)
      res = res | (array[i]);
    vres = (0);
    for (i = 0; i < n; i++)
      vres = vres | (array[i]);
    if (res != vres)
      abort();
  };
  {
    int res, vres;
    res = (0);
#pragma acc parallel vector_length(vl) copy(res)

#pragma acc loop reduction(^ : res)
    for (i = 0; i < n; i++)
      res = res ^ (array[i]);
    vres = (0);
    for (i = 0; i < n; i++)
      vres = vres ^ (array[i]);
    if (res != vres)
      abort();
  };
}


x86 assembly (clang, -O0):
<test_reductions_int>:
push   %rbp
mov    %rsp,%rbp
sub    $0xfe0,%rsp
movl   $0x3e8,-0x4(%rbp)
mov    %rsp,%rax
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    1159 <test_reductions_int+0x49>
mov    -0x8(%rbp),%ecx
movslq -0x8(%rbp),%rax
mov    %ecx,-0xfe0(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1130 <test_reductions_int+0x20>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    1193 <test_reductions_int+0x83>
mov    -0x14(%rbp),%eax
movslq -0x8(%rbp),%rcx
add    -0xfe0(%rbp,%rcx,4),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1167 <test_reductions_int+0x57>
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    11cd <test_reductions_int+0xbd>
mov    -0x18(%rbp),%eax
movslq -0x8(%rbp),%rcx
add    -0xfe0(%rbp,%rcx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11a1 <test_reductions_int+0x91>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     11e0 <test_reductions_int+0xd0>
mov    $0x0,%al
call   1030 <abort@plt>
movl   $0x1,-0x1c(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    121b <test_reductions_int+0x10b>
mov    -0x1c(%rbp),%eax
movslq -0x8(%rbp),%rcx
imul   -0xfe0(%rbp,%rcx,4),%eax
ff
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11ee <test_reductions_int+0xde>
movl   $0x1,-0x20(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    1256 <test_reductions_int+0x146>
mov    -0x20(%rbp),%eax
movslq -0x8(%rbp),%rcx
imul   -0xfe0(%rbp,%rcx,4),%eax
ff
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1229 <test_reductions_int+0x119>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     1269 <test_reductions_int+0x159>
mov    $0x0,%al
call   1030 <abort@plt>
movl   $0xffffffff,-0x24(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    12a3 <test_reductions_int+0x193>
mov    -0x24(%rbp),%eax
movslq -0x8(%rbp),%rcx
and    -0xfe0(%rbp,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1277 <test_reductions_int+0x167>
movl   $0xffffffff,-0x28(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    12dd <test_reductions_int+0x1cd>
mov    -0x28(%rbp),%eax
movslq -0x8(%rbp),%rcx
and    -0xfe0(%rbp,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12b1 <test_reductions_int+0x1a1>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     12f0 <test_reductions_int+0x1e0>
mov    $0x0,%al
call   1030 <abort@plt>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    132a <test_reductions_int+0x21a>
mov    -0x2c(%rbp),%eax
movslq -0x8(%rbp),%rcx
or     -0xfe0(%rbp,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12fe <test_reductions_int+0x1ee>
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    1364 <test_reductions_int+0x254>
mov    -0x30(%rbp),%eax
movslq -0x8(%rbp),%rcx
or     -0xfe0(%rbp,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1338 <test_reductions_int+0x228>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1377 <test_reductions_int+0x267>
mov    $0x0,%al
call   1030 <abort@plt>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    13b1 <test_reductions_int+0x2a1>
mov    -0x34(%rbp),%eax
movslq -0x8(%rbp),%rcx
xor    -0xfe0(%rbp,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1385 <test_reductions_int+0x275>
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    13eb <test_reductions_int+0x2db>
mov    -0x38(%rbp),%eax
movslq -0x8(%rbp),%rcx
xor    -0xfe0(%rbp,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13bf <test_reductions_int+0x2af>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
je     13fe <test_reductions_int+0x2ee>
mov    $0x0,%al
call   1030 <abort@plt>
mov    -0x10(%rbp),%rax
mov    %rax,%rsp
add    $0xfe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_reductions_int>:
sub    $0xfa8,%rsp
movdqa 0xee1(%rip),%xmm0
xor    %eax,%eax
movdqa 0xee6(%rip),%xmm8
movdqa 0xeed(%rip),%xmm9
movdqa 0xef4(%rip),%xmm10
movdqa 0xefb(%rip),%xmm11
movdqa 0xf02(%rip),%xmm12
movdqa 0xf0a(%rip),%xmm6
movdqa 0xf12(%rip),%xmm7
movdqa 0xf1a(%rip),%xmm1
movdqa 0xf22(%rip),%xmm2
movdqa 0xf2a(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm0,%xmm4
paddd  %xmm8,%xmm4
movdqa %xmm0,(%rsp,%rax,4)
movdqa %xmm4,0x10(%rsp,%rax,4)
movdqa %xmm0,%xmm4
paddd  %xmm9,%xmm4
movdqa %xmm0,%xmm5
paddd  %xmm10,%xmm5
movdqa %xmm4,0x20(%rsp,%rax,4)
movdqa %xmm5,0x30(%rsp,%rax,4)
movdqa %xmm0,%xmm4
paddd  %xmm11,%xmm4
movdqa %xmm0,%xmm5
paddd  %xmm12,%xmm5
movdqa %xmm4,0x40(%rsp,%rax,4)
movdqa %xmm5,0x50(%rsp,%rax,4)
movdqa %xmm0,%xmm4
paddd  %xmm6,%xmm4
movdqa %xmm0,%xmm5
paddd  %xmm7,%xmm5
movdqa %xmm4,0x60(%rsp,%rax,4)
movdqa %xmm5,0x70(%rsp,%rax,4)
movdqa %xmm0,%xmm4
paddd  %xmm1,%xmm4
movdqa %xmm0,%xmm5
paddd  %xmm2,%xmm5
movdqa %xmm4,0x80(%rsp,%rax,4)
movdqa %xmm5,0x90(%rsp,%rax,4)
add    $0x28,%rax
paddd  %xmm3,%xmm0
cmp    $0x3e8,%rax
jne    1180 <test_reductions_int+0x70>
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
paddd  (%rsp,%rax,4),%xmm0
paddd  0x10(%rsp,%rax,4),%xmm1
paddd  0x20(%rsp,%rax,4),%xmm0
paddd  0x30(%rsp,%rax,4),%xmm1
paddd  0x40(%rsp,%rax,4),%xmm0
paddd  0x50(%rsp,%rax,4),%xmm1
paddd  0x60(%rsp,%rax,4),%xmm0
paddd  0x70(%rsp,%rax,4),%xmm1
paddd  0x80(%rsp,%rax,4),%xmm0
paddd  0x90(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x3e8,%rax
jne    1230 <test_reductions_int+0x120>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
paddd  (%rsp,%rcx,4),%xmm0
paddd  0x10(%rsp,%rcx,4),%xmm1
paddd  0x20(%rsp,%rcx,4),%xmm0
paddd  0x30(%rsp,%rcx,4),%xmm1
paddd  0x40(%rsp,%rcx,4),%xmm0
paddd  0x50(%rsp,%rcx,4),%xmm1
paddd  0x60(%rsp,%rcx,4),%xmm0
paddd  0x70(%rsp,%rcx,4),%xmm1
paddd  0x80(%rsp,%rcx,4),%xmm0
paddd  0x90(%rsp,%rcx,4),%xmm1
add    $0x28,%rcx
cmp    $0x3e8,%rcx
jne    12b0 <test_reductions_int+0x1a0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ecx
cmp    %ecx,%eax
jne    18a4 <test_reductions_int+0x794>
movdqa 0xd88(%rip),%xmm2
xor    %eax,%eax
movdqa %xmm2,%xmm3
xchg   %ax,%ax
movdqa (%rsp,%rax,4),%xmm1
movdqa 0x10(%rsp,%rax,4),%xmm0
movdqa 0x20(%rsp,%rax,4),%xmm4
movdqa 0x30(%rsp,%rax,4),%xmm5
pshufd $0xf5,%xmm1,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm6,%xmm2
pshufd $0xf5,%xmm0,%xmm6
pmuludq %xmm3,%xmm0
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm2,%xmm6
pmuludq %xmm4,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm3,%xmm2
pmuludq %xmm5,%xmm0
movdqa 0x40(%rsp,%rax,4),%xmm3
movdqa 0x50(%rsp,%rax,4),%xmm4
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm0
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqa 0x60(%rsp,%rax,4),%xmm2
movdqa 0x70(%rsp,%rax,4),%xmm5
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm7
pmuludq %xmm4,%xmm7
pmuludq %xmm5,%xmm0
movdqa 0x80(%rsp,%rax,4),%xmm3
movdqa 0x90(%rsp,%rax,4),%xmm4
pmuludq %xmm3,%xmm1
pshufd $0xe8,%xmm1,%xmm2
pshufd $0xf5,%xmm3,%xmm1
pmuludq %xmm6,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm2
pmuludq %xmm4,%xmm0
pshufd $0xe8,%xmm0,%xmm3
pshufd $0xf5,%xmm4,%xmm0
pmuludq %xmm7,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm3
add    $0x28,%rax
cmp    $0x3e8,%rax
jne    1330 <test_reductions_int+0x220>
pshufd $0xf5,%xmm2,%xmm0
pshufd $0xf5,%xmm3,%xmm1
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm3
pshufd $0xee,%xmm3,%xmm0
pmuludq %xmm3,%xmm0
pshufd $0xaa,%xmm1,%xmm2
pmuludq %xmm1,%xmm2
pmuludq %xmm0,%xmm2
movd   %xmm2,%eax
movdqa 0xc53(%rip),%xmm2
xor    %ecx,%ecx
movdqa %xmm2,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa (%rsp,%rcx,4),%xmm1
movdqa 0x10(%rsp,%rcx,4),%xmm0
movdqa 0x20(%rsp,%rcx,4),%xmm4
movdqa 0x30(%rsp,%rcx,4),%xmm5
pshufd $0xf5,%xmm1,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm6,%xmm2
pshufd $0xf5,%xmm0,%xmm6
pmuludq %xmm3,%xmm0
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm2,%xmm6
pmuludq %xmm4,%xmm1
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm3,%xmm2
pmuludq %xmm5,%xmm0
movdqa 0x40(%rsp,%rcx,4),%xmm3
movdqa 0x50(%rsp,%rcx,4),%xmm4
pmuludq %xmm3,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm6,%xmm3
pmuludq %xmm4,%xmm0
pshufd $0xf5,%xmm4,%xmm4
pmuludq %xmm2,%xmm4
movdqa 0x60(%rsp,%rcx,4),%xmm2
movdqa 0x70(%rsp,%rcx,4),%xmm5
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm3,%xmm6
pmuludq %xmm2,%xmm1
pshufd $0xf5,%xmm5,%xmm7
pmuludq %xmm4,%xmm7
pmuludq %xmm5,%xmm0
movdqa 0x80(%rsp,%rcx,4),%xmm3
movdqa 0x90(%rsp,%rcx,4),%xmm4
pmuludq %xmm3,%xmm1
pshufd $0xe8,%xmm1,%xmm2
pshufd $0xf5,%xmm3,%xmm1
pmuludq %xmm6,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm2
pmuludq %xmm4,%xmm0
pshufd $0xe8,%xmm0,%xmm3
pshufd $0xf5,%xmm4,%xmm0
pmuludq %xmm7,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm3
add    $0x28,%rcx
cmp    $0x3e8,%rcx
jne    1470 <test_reductions_int+0x360>
pshufd $0xf5,%xmm2,%xmm0
pshufd $0xf5,%xmm3,%xmm1
pmuludq %xmm0,%xmm1
pmuludq %xmm2,%xmm3
pshufd $0xee,%xmm3,%xmm0
pmuludq %xmm3,%xmm0
pshufd $0xaa,%xmm1,%xmm2
pmuludq %xmm1,%xmm2
pmuludq %xmm0,%xmm2
movd   %xmm2,%ecx
cmp    %ecx,%eax
jne    18a4 <test_reductions_int+0x794>
pcmpeqd %xmm0,%xmm0
xor    %eax,%eax
pcmpeqd %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
pand   (%rsp,%rax,4),%xmm0
pand   0x10(%rsp,%rax,4),%xmm1
pand   0x20(%rsp,%rax,4),%xmm0
pand   0x30(%rsp,%rax,4),%xmm1
pand   0x40(%rsp,%rax,4),%xmm0
pand   0x50(%rsp,%rax,4),%xmm1
pand   0x60(%rsp,%rax,4),%xmm0
pand   0x70(%rsp,%rax,4),%xmm1
pand   0x80(%rsp,%rax,4),%xmm0
pand   0x90(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x3e8,%rax
jne    15b0 <test_reductions_int+0x4a0>
pand   %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
pand   %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
pand   %xmm0,%xmm1
movd   %xmm1,%eax
pcmpeqd %xmm0,%xmm0
xor    %ecx,%ecx
pcmpeqd %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
pand   (%rsp,%rcx,4),%xmm0
pand   0x10(%rsp,%rcx,4),%xmm1
pand   0x20(%rsp,%rcx,4),%xmm0
pand   0x30(%rsp,%rcx,4),%xmm1
pand   0x40(%rsp,%rcx,4),%xmm0
pand   0x50(%rsp,%rcx,4),%xmm1
pand   0x60(%rsp,%rcx,4),%xmm0
pand   0x70(%rsp,%rcx,4),%xmm1
pand   0x80(%rsp,%rcx,4),%xmm0
pand   0x90(%rsp,%rcx,4),%xmm1
add    $0x28,%rcx
cmp    $0x3e8,%rcx
jne    1630 <test_reductions_int+0x520>
pand   %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
pand   %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
pand   %xmm0,%xmm1
movd   %xmm1,%ecx
cmp    %ecx,%eax
jne    18a4 <test_reductions_int+0x794>
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
por    (%rsp,%rax,4),%xmm0
por    0x10(%rsp,%rax,4),%xmm1
por    0x20(%rsp,%rax,4),%xmm0
por    0x30(%rsp,%rax,4),%xmm1
por    0x40(%rsp,%rax,4),%xmm0
por    0x50(%rsp,%rax,4),%xmm1
por    0x60(%rsp,%rax,4),%xmm0
por    0x70(%rsp,%rax,4),%xmm1
por    0x80(%rsp,%rax,4),%xmm0
por    0x90(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x3e8,%rax
jne    16b0 <test_reductions_int+0x5a0>
por    %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
por    %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
por    %xmm0,%xmm1
movd   %xmm1,%eax
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
por    (%rsp,%rcx,4),%xmm0
por    0x10(%rsp,%rcx,4),%xmm1
por    0x20(%rsp,%rcx,4),%xmm0
por    0x30(%rsp,%rcx,4),%xmm1
por    0x40(%rsp,%rcx,4),%xmm0
por    0x50(%rsp,%rcx,4),%xmm1
por    0x60(%rsp,%rcx,4),%xmm0
por    0x70(%rsp,%rcx,4),%xmm1
por    0x80(%rsp,%rcx,4),%xmm0
por    0x90(%rsp,%rcx,4),%xmm1
add    $0x28,%rcx
cmp    $0x3e8,%rcx
jne    1730 <test_reductions_int+0x620>
por    %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
por    %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
por    %xmm0,%xmm1
movd   %xmm1,%ecx
cmp    %ecx,%eax
jne    18a4 <test_reductions_int+0x794>
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
pxor   (%rsp,%rax,4),%xmm0
pxor   0x10(%rsp,%rax,4),%xmm1
pxor   0x20(%rsp,%rax,4),%xmm0
pxor   0x30(%rsp,%rax,4),%xmm1
pxor   0x40(%rsp,%rax,4),%xmm0
pxor   0x50(%rsp,%rax,4),%xmm1
pxor   0x60(%rsp,%rax,4),%xmm0
pxor   0x70(%rsp,%rax,4),%xmm1
pxor   0x80(%rsp,%rax,4),%xmm0
pxor   0x90(%rsp,%rax,4),%xmm1
add    $0x28,%rax
cmp    $0x3e8,%rax
jne    17b0 <test_reductions_int+0x6a0>
pxor   %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
pxor   %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
pxor   %xmm0,%xmm1
movd   %xmm1,%eax
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
pxor   (%rsp,%rcx,4),%xmm0
pxor   0x10(%rsp,%rcx,4),%xmm1
pxor   0x20(%rsp,%rcx,4),%xmm0
pxor   0x30(%rsp,%rcx,4),%xmm1
pxor   0x40(%rsp,%rcx,4),%xmm0
pxor   0x50(%rsp,%rcx,4),%xmm1
pxor   0x60(%rsp,%rcx,4),%xmm0
pxor   0x70(%rsp,%rcx,4),%xmm1
pxor   0x80(%rsp,%rcx,4),%xmm0
pxor   0x90(%rsp,%rcx,4),%xmm1
add    $0x28,%rcx
cmp    $0x3e8,%rcx
jne    1830 <test_reductions_int+0x720>
pxor   %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
pxor   %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
pxor   %xmm0,%xmm1
movd   %xmm1,%ecx
cmp    %ecx,%eax
jne    18a4 <test_reductions_int+0x794>
add    $0xfa8,%rsp
ret
xor    %eax,%eax
call   1030 <abort@plt>

LLVM IR (-O0):
define void @test_reductions_int() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store i32 1000, i32* %1
%14 = call i8* @llvm.stacksave()
store i8* %14, i8** %3
%15 = alloca i32, i64 1000
store i32 0, i32* %2
br label %16
16: ; preds = %24, %0
%17 = load i32, i32* %2
%18 = icmp slt i32 %17, 1000
br i1 %18, label %19, label %27
19: ; preds = %16
%20 = load i32, i32* %2
%21 = load i32, i32* %2
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i32, i32* %15, i64 %22
store i32 %20, i32* %23
br label %24
24: ; preds = %19
%25 = load i32, i32* %2
%26 = add nsw i32 %25, 1
store i32 %26, i32* %2
br label %16
27: ; preds = %16
store i32 0, i32* %4
store i32 0, i32* %2
br label %28
28: ; preds = %38, %27
%29 = load i32, i32* %2
%30 = icmp slt i32 %29, 1000
br i1 %30, label %31, label %41
31: ; preds = %28
%32 = load i32, i32* %4
%33 = load i32, i32* %2
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %15, i64 %34
%36 = load i32, i32* %35
%37 = add nsw i32 %32, %36
store i32 %37, i32* %4
br label %38
38: ; preds = %31
%39 = load i32, i32* %2
%40 = add nsw i32 %39, 1
store i32 %40, i32* %2
br label %28
41: ; preds = %28
store i32 0, i32* %5
store i32 0, i32* %2
br label %42
42: ; preds = %52, %41
%43 = load i32, i32* %2
%44 = icmp slt i32 %43, 1000
br i1 %44, label %45, label %55
45: ; preds = %42
%46 = load i32, i32* %5
%47 = load i32, i32* %2
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i32, i32* %15, i64 %48
%50 = load i32, i32* %49
%51 = add nsw i32 %46, %50
store i32 %51, i32* %5
br label %52
52: ; preds = %45
%53 = load i32, i32* %2
%54 = add nsw i32 %53, 1
store i32 %54, i32* %2
br label %42
55: ; preds = %42
%56 = load i32, i32* %4
%57 = load i32, i32* %5
%58 = icmp ne i32 %56, %57
br i1 %58, label %59, label %61
59: ; preds = %55
%60 = call i32 (...) @abort()
unreachable
61: ; preds = %55
store i32 1, i32* %6
store i32 0, i32* %2
br label %62
62: ; preds = %72, %61
%63 = load i32, i32* %2
%64 = icmp slt i32 %63, 1000
br i1 %64, label %65, label %75
65: ; preds = %62
%66 = load i32, i32* %6
%67 = load i32, i32* %2
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %15, i64 %68
%70 = load i32, i32* %69
%71 = mul nsw i32 %66, %70
store i32 %71, i32* %6
br label %72
72: ; preds = %65
%73 = load i32, i32* %2
%74 = add nsw i32 %73, 1
store i32 %74, i32* %2
br label %62
75: ; preds = %62
store i32 1, i32* %7
store i32 0, i32* %2
br label %76
76: ; preds = %86, %75
%77 = load i32, i32* %2
%78 = icmp slt i32 %77, 1000
br i1 %78, label %79, label %89
79: ; preds = %76
%80 = load i32, i32* %7
%81 = load i32, i32* %2
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i32, i32* %15, i64 %82
%84 = load i32, i32* %83
%85 = mul nsw i32 %80, %84
store i32 %85, i32* %7
br label %86
86: ; preds = %79
%87 = load i32, i32* %2
%88 = add nsw i32 %87, 1
store i32 %88, i32* %2
br label %76
89: ; preds = %76
%90 = load i32, i32* %6
%91 = load i32, i32* %7
%92 = icmp ne i32 %90, %91
br i1 %92, label %93, label %95
93: ; preds = %89
%94 = call i32 (...) @abort()
unreachable
95: ; preds = %89
store i32 -1, i32* %8
store i32 0, i32* %2
br label %96
96: ; preds = %106, %95
%97 = load i32, i32* %2
%98 = icmp slt i32 %97, 1000
br i1 %98, label %99, label %109
99: ; preds = %96
%100 = load i32, i32* %8
%101 = load i32, i32* %2
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i32, i32* %15, i64 %102
%104 = load i32, i32* %103
%105 = and i32 %100, %104
store i32 %105, i32* %8
br label %106
106: ; preds = %99
%107 = load i32, i32* %2
%108 = add nsw i32 %107, 1
store i32 %108, i32* %2
br label %96
109: ; preds = %96
store i32 -1, i32* %9
store i32 0, i32* %2
br label %110
110: ; preds = %120, %109
%111 = load i32, i32* %2
%112 = icmp slt i32 %111, 1000
br i1 %112, label %113, label %123
113: ; preds = %110
%114 = load i32, i32* %9
%115 = load i32, i32* %2
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i32, i32* %15, i64 %116
%118 = load i32, i32* %117
%119 = and i32 %114, %118
store i32 %119, i32* %9
br label %120
120: ; preds = %113
%121 = load i32, i32* %2
%122 = add nsw i32 %121, 1
store i32 %122, i32* %2
br label %110
123: ; preds = %110
%124 = load i32, i32* %8
%125 = load i32, i32* %9
%126 = icmp ne i32 %124, %125
br i1 %126, label %127, label %129
127: ; preds = %123
%128 = call i32 (...) @abort()
unreachable
129: ; preds = %123
store i32 0, i32* %10
store i32 0, i32* %2
br label %130
130: ; preds = %140, %129
%131 = load i32, i32* %2
%132 = icmp slt i32 %131, 1000
br i1 %132, label %133, label %143
133: ; preds = %130
%134 = load i32, i32* %10
%135 = load i32, i32* %2
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i32, i32* %15, i64 %136
%138 = load i32, i32* %137
%139 = or i32 %134, %138
store i32 %139, i32* %10
br label %140
140: ; preds = %133
%141 = load i32, i32* %2
%142 = add nsw i32 %141, 1
store i32 %142, i32* %2
br label %130
143: ; preds = %130
store i32 0, i32* %11
store i32 0, i32* %2
br label %144
144: ; preds = %154, %143
%145 = load i32, i32* %2
%146 = icmp slt i32 %145, 1000
br i1 %146, label %147, label %157
147: ; preds = %144
%148 = load i32, i32* %11
%149 = load i32, i32* %2
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %15, i64 %150
%152 = load i32, i32* %151
%153 = or i32 %148, %152
store i32 %153, i32* %11
br label %154
154: ; preds = %147
%155 = load i32, i32* %2
%156 = add nsw i32 %155, 1
store i32 %156, i32* %2
br label %144
157: ; preds = %144
%158 = load i32, i32* %10
%159 = load i32, i32* %11
%160 = icmp ne i32 %158, %159
br i1 %160, label %161, label %163
161: ; preds = %157
%162 = call i32 (...) @abort()
unreachable
163: ; preds = %157
store i32 0, i32* %12
store i32 0, i32* %2
br label %164
164: ; preds = %174, %163
%165 = load i32, i32* %2
%166 = icmp slt i32 %165, 1000
br i1 %166, label %167, label %177
167: ; preds = %164
%168 = load i32, i32* %12
%169 = load i32, i32* %2
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i32, i32* %15, i64 %170
%172 = load i32, i32* %171
%173 = xor i32 %168, %172
store i32 %173, i32* %12
br label %174
174: ; preds = %167
%175 = load i32, i32* %2
%176 = add nsw i32 %175, 1
store i32 %176, i32* %2
br label %164
177: ; preds = %164
store i32 0, i32* %13
store i32 0, i32* %2
br label %178
178: ; preds = %188, %177
%179 = load i32, i32* %2
%180 = icmp slt i32 %179, 1000
br i1 %180, label %181, label %191
181: ; preds = %178
%182 = load i32, i32* %13
%183 = load i32, i32* %2
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds i32, i32* %15, i64 %184
%186 = load i32, i32* %185
%187 = xor i32 %182, %186
store i32 %187, i32* %13
br label %188
188: ; preds = %181
%189 = load i32, i32* %2
%190 = add nsw i32 %189, 1
store i32 %190, i32* %2
br label %178
191: ; preds = %178
%192 = load i32, i32* %12
%193 = load i32, i32* %13
%194 = icmp ne i32 %192, %193
br i1 %194, label %195, label %197
195: ; preds = %191
%196 = call i32 (...) @abort()
unreachable
197: ; preds = %191
%198 = load i8*, i8** %3
ret void
}

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