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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
void t19() {
  int n[32 * 32], arr_a[32 * 32 * 32], arr_b[32 * 32 * 32], i;
  int num_workers, num_gangs;
  for (num_workers = 1; num_workers <= 32; num_workers <<= 1)
    for (num_gangs = 1; num_gangs <= 32; num_gangs <<= 1) {
      for (i = 0; i < 32 * 32 * 32; i++)
        arr_a[i] = i;
      for (i = 0; i < 32 * 32; i++)
        n[i] = 0;
#pragma acc parallel copy(n) copyin(arr_a) copyout(arr_b) num_gangs(num_gangs) \
    num_workers(num_workers) vector_length(32)
      {
        int j;
#pragma acc loop gang
        for (j = 0; j < 32; j++) {
          int k;
#pragma acc loop worker
          for (k = 0; k < 32; k++) {
            int m;
            n[j * 32 + k]++;
#pragma acc loop vector
            for (m = 0; m < 32; m++) {
              if (((j * 1024 + k * 32 + m) % 2) == 0)
                arr_b[j * 1024 + k * 32 + (31 - m)] =
                    arr_a[j * 1024 + k * 32 + m] * 2;
              else
                arr_b[j * 1024 + k * 32 + (31 - m)] =
                    arr_a[j * 1024 + k * 32 + m] * 3;
            }
            n[j * 32 + k]++;
#pragma acc loop vector
            for (m = 0; m < 32; m++) {
              if (((j * 1024 + k * 32 + m) % 3) == 0)
                arr_a[j * 1024 + k * 32 + (31 - m)] =
                    arr_b[j * 1024 + k * 32 + m] * 5;
              else
                arr_a[j * 1024 + k * 32 + (31 - m)] =
                    arr_b[j * 1024 + k * 32 + m] * 7;
            }
#pragma acc loop vector
            for (m = 0; m < 32; m++) {
              if (((j * 1024 + k * 32 + m) % 2) == 0)
                arr_b[j * 1024 + k * 32 + (31 - m)] =
                    arr_a[j * 1024 + k * 32 + m] * 3;
              else
                arr_b[j * 1024 + k * 32 + (31 - m)] =
                    arr_a[j * 1024 + k * 32 + m] * 2;
            }
          }
        }
      }
      for (i = 0; i < 32 * 32; i++)
        assert(n[i] == 2);
      for (i = 0; i < 32 * 32 * 32; i++) {
        int m = 6 * ((i % 3) == 0 ? 5 : 7);
        assert(arr_b[i] == (i ^ 31) * m);
      }
    }
}


x86 assembly (clang, -O0):
<t19>:
push   %rbp
mov    %rsp,%rbp
sub    $0x41020,%rsp
movl   $0x1,-0x41008(%rbp)
cmpl   $0x20,-0x41008(%rbp)
jg     1665 <t19+0x555>
movl   $0x1,-0x4100c(%rbp)
cmpl   $0x20,-0x4100c(%rbp)
jg     164c <t19+0x53c>
movl   $0x0,-0x41004(%rbp)
cmpl   $0x8000,-0x41004(%rbp)
jge    118b <t19+0x7b>
mov    -0x41004(%rbp),%ecx
movslq -0x41004(%rbp),%rax
mov    %ecx,-0x21000(%rbp,%rax,4)
mov    -0x41004(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x41004(%rbp)
jmp    1153 <t19+0x43>
movl   $0x0,-0x41004(%rbp)
cmpl   $0x400,-0x41004(%rbp)
jge    11cb <t19+0xbb>
movslq -0x41004(%rbp),%rax
movl   $0x0,-0x1000(%rbp,%rax,4)
mov    -0x41004(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x41004(%rbp)
jmp    1195 <t19+0x85>
movl   $0x0,-0x41010(%rbp)
cmpl   $0x20,-0x41010(%rbp)
jge    1567 <t19+0x457>
movl   $0x0,-0x41014(%rbp)
cmpl   $0x20,-0x41014(%rbp)
jge    154e <t19+0x43e>
mov    -0x41010(%rbp),%eax
shl    $0x5,%eax
add    -0x41014(%rbp),%eax
cltq
mov    -0x1000(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x1000(%rbp,%rax,4)
movl   $0x0,-0x41018(%rbp)
cmpl   $0x20,-0x41018(%rbp)
jge    1319 <t19+0x209>
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
add    -0x41018(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    12b2 <t19+0x1a2>
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
add    -0x41018(%rbp),%eax
cltq
mov    -0x21000(%rbp,%rax,4),%ecx
shl    $0x1,%ecx
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%edx
shl    $0x5,%edx
add    %edx,%eax
mov    $0x1f,%edx
sub    -0x41018(%rbp),%edx
add    %edx,%eax
cltq
mov    %ecx,-0x41000(%rbp,%rax,4)
jmp    1300 <t19+0x1f0>
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
add    -0x41018(%rbp),%eax
cltq
imul   $0x3,-0x21000(%rbp,%rax,4),%ecx
03
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%edx
shl    $0x5,%edx
add    %edx,%eax
mov    $0x1f,%edx
sub    -0x41018(%rbp),%edx
add    %edx,%eax
cltq
mov    %ecx,-0x41000(%rbp,%rax,4)
jmp    1305 <t19+0x1f5>
mov    -0x41018(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x41018(%rbp)
jmp    1225 <t19+0x115>
mov    -0x41010(%rbp),%eax
shl    $0x5,%eax
add    -0x41014(%rbp),%eax
cltq
mov    -0x1000(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x1000(%rbp,%rax,4)
movl   $0x0,-0x41018(%rbp)
cmpl   $0x20,-0x41018(%rbp)
jge    1437 <t19+0x327>
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
add    -0x41018(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    13d0 <t19+0x2c0>
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
add    -0x41018(%rbp),%eax
cltq
imul   $0x5,-0x41000(%rbp,%rax,4),%ecx
05
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%edx
shl    $0x5,%edx
add    %edx,%eax
mov    $0x1f,%edx
sub    -0x41018(%rbp),%edx
add    %edx,%eax
cltq
mov    %ecx,-0x21000(%rbp,%rax,4)
jmp    141e <t19+0x30e>
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
add    -0x41018(%rbp),%eax
cltq
imul   $0x7,-0x41000(%rbp,%rax,4),%ecx
07
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%edx
shl    $0x5,%edx
add    %edx,%eax
mov    $0x1f,%edx
sub    -0x41018(%rbp),%edx
add    %edx,%eax
cltq
mov    %ecx,-0x21000(%rbp,%rax,4)
jmp    1423 <t19+0x313>
mov    -0x41018(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x41018(%rbp)
jmp    1345 <t19+0x235>
movl   $0x0,-0x41018(%rbp)
cmpl   $0x20,-0x41018(%rbp)
jge    1535 <t19+0x425>
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
add    -0x41018(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    14cc <t19+0x3bc>
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
add    -0x41018(%rbp),%eax
cltq
imul   $0x3,-0x21000(%rbp,%rax,4),%ecx
03
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%edx
shl    $0x5,%edx
add    %edx,%eax
mov    $0x1f,%edx
sub    -0x41018(%rbp),%edx
add    %edx,%eax
cltq
mov    %ecx,-0x41000(%rbp,%rax,4)
jmp    151c <t19+0x40c>
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
add    -0x41018(%rbp),%eax
cltq
mov    -0x21000(%rbp,%rax,4),%ecx
shl    $0x1,%ecx
mov    -0x41010(%rbp),%eax
shl    $0xa,%eax
mov    -0x41014(%rbp),%edx
shl    $0x5,%edx
add    %edx,%eax
mov    $0x1f,%edx
sub    -0x41018(%rbp),%edx
add    %edx,%eax
cltq
mov    %ecx,-0x41000(%rbp,%rax,4)
jmp    1521 <t19+0x411>
mov    -0x41018(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x41018(%rbp)
jmp    1441 <t19+0x331>
jmp    153a <t19+0x42a>
mov    -0x41014(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x41014(%rbp)
jmp    11ec <t19+0xdc>
jmp    1553 <t19+0x443>
mov    -0x41010(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x41010(%rbp)
jmp    11d5 <t19+0xc5>
movl   $0x0,-0x41004(%rbp)
cmpl   $0x400,-0x41004(%rbp)
jge    15b1 <t19+0x4a1>
movslq -0x41004(%rbp),%rax
cmpl   $0x2,-0x1000(%rbp,%rax,4)
02
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x41004(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x41004(%rbp)
jmp    1571 <t19+0x461>
movl   $0x0,-0x41004(%rbp)
cmpl   $0x8000,-0x41004(%rbp)
jge    1633 <t19+0x523>
mov    -0x41004(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    $0x7,%eax
mov    $0x5,%ecx
cmp    $0x0,%edx
cmove  %ecx,%eax
imul   $0x6,%eax,%eax
mov    %eax,-0x4101c(%rbp)
movslq -0x41004(%rbp),%rax
mov    -0x41000(%rbp,%rax,4),%eax
mov    -0x41004(%rbp),%ecx
xor    $0x1f,%ecx
imul   -0x4101c(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x41004(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x41004(%rbp)
jmp    15bb <t19+0x4ab>
jmp    1638 <t19+0x528>
mov    -0x4100c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x4100c(%rbp)
jmp    113c <t19+0x2c>
jmp    1651 <t19+0x541>
mov    -0x41008(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x41008(%rbp)
jmp    1125 <t19+0x15>
add    $0x41020,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<t19>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x41048,%rsp
mov    $0x1,%eax
movdqa 0xed1(%rip),%xmm8
movdqa 0xed8(%rip),%xmm9
movdqa 0xedf(%rip),%xmm10
movdqa 0xee7(%rip),%xmm6
movdqa 0xeef(%rip),%xmm7
movdqa 0xef7(%rip),%xmm3
movdqa 0xeff(%rip),%xmm4
movdqa 0xf07(%rip),%xmm5
jmp    118e <t19+0x6e>
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%eax
add    %eax,%eax
cmp    $0x21,%eax
jge    164e <t19+0x52e>
mov    %eax,(%rsp)
mov    $0x1,%eax
jmp    11ee <t19+0xce>
nopl   0x0(%rax,%rax,1)
mov    0x4(%rsp),%eax
add    %eax,%eax
cmp    $0x21,%eax
movdqa 0xe5e(%rip),%xmm8
movdqa 0xe65(%rip),%xmm9
movdqa 0xe6c(%rip),%xmm10
movdqa 0xe74(%rip),%xmm6
movdqa 0xe7c(%rip),%xmm7
movdqa 0xe84(%rip),%xmm3
movdqa 0xe8c(%rip),%xmm4
movdqa 0xe94(%rip),%xmm5
jge    1180 <t19+0x60>
mov    %eax,0x4(%rsp)
xor    %eax,%eax
movdqa 0xe04(%rip),%xmm0
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddd  %xmm8,%xmm1
movdqa %xmm0,0x1040(%rsp,%rax,4)
movdqa %xmm1,0x1050(%rsp,%rax,4)
movdqa %xmm0,%xmm1
paddd  %xmm9,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm10,%xmm2
movdqa %xmm1,0x1060(%rsp,%rax,4)
movdqa %xmm2,0x1070(%rsp,%rax,4)
movdqa %xmm0,%xmm1
paddd  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm7,%xmm2
movdqa %xmm1,0x1080(%rsp,%rax,4)
movdqa %xmm2,0x1090(%rsp,%rax,4)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm1,0x10a0(%rsp,%rax,4)
movdqa %xmm2,0x10b0(%rsp,%rax,4)
add    $0x20,%rax
paddd  %xmm5,%xmm0
cmp    $0x8000,%rax
jne    1200 <t19+0xe0>
mov    $0x1000,%edx
lea    0x40(%rsp),%rdi
xor    %esi,%esi
call   1030 <memset@plt>
lea    0x21040(%rsp),%rcx
lea    0x10b0(%rsp),%r9
lea    0x1040(%rsp),%rsi
xor    %r11d,%r11d
lea    0x210b0(%rsp),%rdi
xor    %r10d,%r10d
movdqa 0xdb9(%rip),%xmm9
movdqa 0xdc1(%rip),%xmm6
pxor   %xmm7,%xmm7
movdqa 0xdc4(%rip),%xmm8
movdqa 0xdcc(%rip),%xmm5
movdqa 0xdd3(%rip),%xmm10
movdqa 0xdda(%rip),%xmm11
movdqa 0xde1(%rip),%xmm12
nop
mov    %r10,%rax
shl    $0x5,%rax
mov    %rax,0x38(%rsp)
mov    %r10,0x8(%rsp)
shl    $0xa,%r10
mov    %rcx,0x30(%rsp)
mov    %r9,0x28(%rsp)
mov    %rsi,0x20(%rsp)
mov    %r11,0x18(%rsp)
mov    %rdi,0x10(%rsp)
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rax
lea    (%r12,%rax,1),%r15
mov    0x40(%rsp,%r15,4),%r8d
mov    %r12,%rax
shl    $0x5,%rax
add    %r10,%rax
movq   %rax,%xmm0
pshufd $0x44,%xmm0,%xmm0
mov    %rdi,%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movq   %rdx,%xmm1
pshufd $0x44,%xmm1,%xmm1
por    %xmm9,%xmm1
lea    (%r11,%rdx,1),%r13
paddq  %xmm0,%xmm1
lea    -0x1(%r13),%r14d
movq   %r13,%xmm2
punpcklqdq %xmm1,%xmm2
pshufd $0xee,%xmm1,%xmm1
movd   %r14d,%xmm3
punpcklqdq %xmm3,%xmm1
pand   %xmm6,%xmm1
pand   %xmm6,%xmm2
pcmpeqd %xmm7,%xmm2
pcmpeqd %xmm7,%xmm1
movdqa %xmm2,%xmm3
shufps $0xdd,%xmm1,%xmm3
shufps $0x88,%xmm1,%xmm2
andps  %xmm3,%xmm2
movdqa (%rsi,%rdx,4),%xmm1
movdqa %xmm1,%xmm3
paddd  %xmm1,%xmm3
paddd  %xmm3,%xmm1
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
pshufd $0x1b,%xmm2,%xmm1
movdqa %xmm1,(%rax)
add    $0x4,%rdx
add    $0xfffffffffffffff0,%rax
cmp    $0x20,%rdx
jne    1380 <t19+0x260>
add    $0x2,%r8d
mov    %r8d,0x40(%rsp,%r15,4)
mov    %r9,%rdx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movq   %rax,%xmm1
pshufd $0x44,%xmm1,%xmm1
por    %xmm8,%xmm1
lea    (%r11,%rax,1),%rbp
paddq  %xmm0,%xmm1
lea    0x3(%rbp),%ebx
movq   %rbp,%xmm2
pshufd $0xee,%xmm1,%xmm3
punpckldq %xmm1,%xmm2
movd   %ebx,%xmm1
punpckldq %xmm1,%xmm3
punpcklqdq %xmm3,%xmm2
pshufd $0xf5,%xmm2,%xmm1
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm5,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm2
pxor   %xmm10,%xmm2
pcmpgtd %xmm11,%xmm2
movdqa (%rcx,%rax,4),%xmm1
movdqa %xmm2,%xmm3
psrld  $0x1d,%xmm3
pandn  %xmm12,%xmm2
por    %xmm3,%xmm2
pshufd $0xf5,%xmm2,%xmm3
pshufd $0xf5,%xmm1,%xmm4
pmuludq %xmm3,%xmm4
pmuludq %xmm1,%xmm2
pshufd $0xe2,%xmm2,%xmm1
pshufd $0xe2,%xmm4,%xmm2
punpckldq %xmm1,%xmm2
movdqa %xmm2,(%rdx)
add    $0x4,%rax
add    $0xfffffffffffffff0,%rdx
cmp    $0x20,%rax
jne    1420 <t19+0x300>
mov    %rdi,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movq   %rdx,%xmm1
pshufd $0x44,%xmm1,%xmm1
por    %xmm9,%xmm1
lea    (%r11,%rdx,1),%rbp
paddq  %xmm0,%xmm1
lea    -0x1(%rbp),%ebx
movq   %rbp,%xmm2
punpcklqdq %xmm1,%xmm2
pshufd $0xee,%xmm1,%xmm1
movd   %ebx,%xmm3
punpcklqdq %xmm3,%xmm1
pand   %xmm6,%xmm1
pand   %xmm6,%xmm2
pcmpeqd %xmm7,%xmm2
pcmpeqd %xmm7,%xmm1
movdqa %xmm2,%xmm3
shufps $0xdd,%xmm1,%xmm3
shufps $0x88,%xmm1,%xmm2
andps  %xmm3,%xmm2
movdqa (%rsi,%rdx,4),%xmm1
movdqa %xmm1,%xmm3
paddd  %xmm1,%xmm3
paddd  %xmm3,%xmm1
pand   %xmm2,%xmm1
pandn  %xmm3,%xmm2
por    %xmm1,%xmm2
pshufd $0x1b,%xmm2,%xmm1
movdqa %xmm1,(%rax)
add    $0x4,%rdx
add    $0xfffffffffffffff0,%rax
cmp    $0x20,%rdx
jne    14d0 <t19+0x3b0>
add    $0x1,%r12
sub    $0xffffffffffffff80,%rdi
add    $0x20,%r11
sub    $0xffffffffffffff80,%rsi
sub    $0xffffffffffffff80,%r9
sub    $0xffffffffffffff80,%rcx
cmp    $0x20,%r12
jne    1350 <t19+0x230>
mov    0x8(%rsp),%r10
add    $0x1,%r10
mov    0x10(%rsp),%rdi
add    $0x1000,%rdi
mov    0x18(%rsp),%r11
add    $0x400,%r11
mov    0x20(%rsp),%rsi
add    $0x1000,%rsi
mov    0x28(%rsp),%r9
add    $0x1000,%r9
mov    0x30(%rsp),%rcx
add    $0x1000,%rcx
cmp    $0x20,%r10
jne    1310 <t19+0x1f0>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
xor    %edi,%edi
cmpl   $0x2,0x40(%rsp,%rbx,4)
sete   %dil
call   1040 <assert@plt>
add    $0x1,%rbx
cmp    $0x400,%rbx
jne    15d0 <t19+0x4b0>
xor    %ebx,%ebx
xor    %ebp,%ebp
jmp    162e <t19+0x50e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebp,%ecx
xor    $0x1f,%ecx
imul   %eax,%ecx
xor    %edi,%edi
cmp    %ecx,0x21040(%rsp,%rbp,4)
sete   %dil
call   1040 <assert@plt>
add    $0x1,%rbp
add    $0xffffffff,%ebx
cmp    $0x8000,%rbp
je     11a0 <t19+0x80>
movzwl %bp,%eax
imul   $0xaaab,%eax,%eax
shr    $0x11,%eax
lea    (%rax,%rax,2),%ecx
mov    $0x1e,%eax
add    %bx,%cx
je     1600 <t19+0x4e0>
mov    $0x2a,%eax
jmp    1600 <t19+0x4e0>
add    $0x41048,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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