#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 */
typedef int uint8_t;
typedef int uint64_t;

/* Variables and functions */
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int);
int /*<<< orphan*/ random_permute(int *);
void xcrc_table(uint64_t *buf) {
  uint8_t perm[256];
  int i, j;
  memset(buf, 0, 8 * 256);
  for (i = 0; i < 8; i++) {
    random_permute(perm);
    for (j = 0; j < 256; j++)
      buf[j] = (buf[j] << 8) | perm[j];
  }
}


x86 assembly (clang, -O0):
<xcrc_table>:
push   %rbp
mov    %rsp,%rbp
sub    $0x420,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
xor    %esi,%esi
mov    $0x800,%edx
call   1030 <memset@plt>
movl   $0x0,-0x414(%rbp)
cmpl   $0x8,-0x414(%rbp)
jge    11d6 <xcrc_table+0xb6>
lea    -0x410(%rbp),%rdi
call   1040 <random_permute@plt>
movl   $0x0,-0x418(%rbp)
cmpl   $0x100,-0x418(%rbp)
jge    11bd <xcrc_table+0x9d>
mov    -0x8(%rbp),%rax
movslq -0x418(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
shl    $0x8,%edx
movslq -0x418(%rbp),%rax
or     -0x410(%rbp,%rax,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x418(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x418(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x418(%rbp)
jmp    116c <xcrc_table+0x4c>
jmp    11c2 <xcrc_table+0xa2>
mov    -0x414(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x414(%rbp)
jmp    1149 <xcrc_table+0x29>
add    $0x420,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<xcrc_table>:
push   %r14
push   %rbx
sub    $0x408,%rsp
mov    %rdi,%r14
xor    %ebx,%ebx
xor    %esi,%esi
mov    $0x800,%edx
call   1030 <memset@plt>
mov    %rsp,%rdi
call   1040 <random_permute@plt>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%r14,%rbx,4),%xmm0
movdqu 0x10(%r14,%rbx,4),%xmm1
movdqu 0x20(%r14,%rbx,4),%xmm2
movdqu 0x30(%r14,%rbx,4),%xmm3
pslld  $0x8,%xmm0
pslld  $0x8,%xmm1
por    (%rsp,%rbx,4),%xmm0
por    0x10(%rsp,%rbx,4),%xmm1
movdqu %xmm0,(%r14,%rbx,4)
movdqu %xmm1,0x10(%r14,%rbx,4)
pslld  $0x8,%xmm2
pslld  $0x8,%xmm3
por    0x20(%rsp,%rbx,4),%xmm2
por    0x30(%rsp,%rbx,4),%xmm3
movdqu %xmm2,0x20(%r14,%rbx,4)
movdqu %xmm3,0x30(%r14,%rbx,4)
add    $0x10,%rbx
cmp    $0x100,%rbx
jne    1150 <xcrc_table+0x30>
mov    %rsp,%rdi
call   1040 <random_permute@plt>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movdqu (%r14,%rax,4),%xmm0
movdqu 0x10(%r14,%rax,4),%xmm1
movdqu 0x20(%r14,%rax,4),%xmm2
movdqu 0x30(%r14,%rax,4),%xmm3
pslld  $0x8,%xmm0
pslld  $0x8,%xmm1
por    (%rsp,%rax,4),%xmm0
por    0x10(%rsp,%rax,4),%xmm1
movdqu %xmm0,(%r14,%rax,4)
movdqu %xmm1,0x10(%r14,%rax,4)
pslld  $0x8,%xmm2
pslld  $0x8,%xmm3
por    0x20(%rsp,%rax,4),%xmm2
por    0x30(%rsp,%rax,4),%xmm3
movdqu %xmm2,0x20(%r14,%rax,4)
movdqu %xmm3,0x30(%r14,%rax,4)
add    $0x10,%rax
cmp    $0x100,%rax
jne    11d0 <xcrc_table+0xb0>
mov    %rsp,%rdi
call   1040 <random_permute@plt>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movdqu (%r14,%rax,4),%xmm0
movdqu 0x10(%r14,%rax,4),%xmm1
movdqu 0x20(%r14,%rax,4),%xmm2
movdqu 0x30(%r14,%rax,4),%xmm3
pslld  $0x8,%xmm0
pslld  $0x8,%xmm1
por    (%rsp,%rax,4),%xmm0
por    0x10(%rsp,%rax,4),%xmm1
movdqu %xmm0,(%r14,%rax,4)
movdqu %xmm1,0x10(%r14,%rax,4)
pslld  $0x8,%xmm2
pslld  $0x8,%xmm3
por    0x20(%rsp,%rax,4),%xmm2
por    0x30(%rsp,%rax,4),%xmm3
movdqu %xmm2,0x20(%r14,%rax,4)
movdqu %xmm3,0x30(%r14,%rax,4)
add    $0x10,%rax
cmp    $0x100,%rax
jne    1250 <xcrc_table+0x130>
mov    %rsp,%rdi
call   1040 <random_permute@plt>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movdqu (%r14,%rax,4),%xmm0
movdqu 0x10(%r14,%rax,4),%xmm1
movdqu 0x20(%r14,%rax,4),%xmm2
movdqu 0x30(%r14,%rax,4),%xmm3
pslld  $0x8,%xmm0
pslld  $0x8,%xmm1
por    (%rsp,%rax,4),%xmm0
por    0x10(%rsp,%rax,4),%xmm1
movdqu %xmm0,(%r14,%rax,4)
movdqu %xmm1,0x10(%r14,%rax,4)
pslld  $0x8,%xmm2
pslld  $0x8,%xmm3
por    0x20(%rsp,%rax,4),%xmm2
por    0x30(%rsp,%rax,4),%xmm3
movdqu %xmm2,0x20(%r14,%rax,4)
movdqu %xmm3,0x30(%r14,%rax,4)
add    $0x10,%rax
cmp    $0x100,%rax
jne    12d0 <xcrc_table+0x1b0>
mov    %rsp,%rdi
call   1040 <random_permute@plt>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movdqu (%r14,%rax,4),%xmm0
movdqu 0x10(%r14,%rax,4),%xmm1
movdqu 0x20(%r14,%rax,4),%xmm2
movdqu 0x30(%r14,%rax,4),%xmm3
pslld  $0x8,%xmm0
pslld  $0x8,%xmm1
por    (%rsp,%rax,4),%xmm0
por    0x10(%rsp,%rax,4),%xmm1
movdqu %xmm0,(%r14,%rax,4)
movdqu %xmm1,0x10(%r14,%rax,4)
pslld  $0x8,%xmm2
pslld  $0x8,%xmm3
por    0x20(%rsp,%rax,4),%xmm2
por    0x30(%rsp,%rax,4),%xmm3
movdqu %xmm2,0x20(%r14,%rax,4)
movdqu %xmm3,0x30(%r14,%rax,4)
add    $0x10,%rax
cmp    $0x100,%rax
jne    1350 <xcrc_table+0x230>
mov    %rsp,%rdi
call   1040 <random_permute@plt>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movdqu (%r14,%rax,4),%xmm0
movdqu 0x10(%r14,%rax,4),%xmm1
movdqu 0x20(%r14,%rax,4),%xmm2
movdqu 0x30(%r14,%rax,4),%xmm3
pslld  $0x8,%xmm0
pslld  $0x8,%xmm1
por    (%rsp,%rax,4),%xmm0
por    0x10(%rsp,%rax,4),%xmm1
movdqu %xmm0,(%r14,%rax,4)
movdqu %xmm1,0x10(%r14,%rax,4)
pslld  $0x8,%xmm2
pslld  $0x8,%xmm3
por    0x20(%rsp,%rax,4),%xmm2
por    0x30(%rsp,%rax,4),%xmm3
movdqu %xmm2,0x20(%r14,%rax,4)
movdqu %xmm3,0x30(%r14,%rax,4)
add    $0x10,%rax
cmp    $0x100,%rax
jne    13d0 <xcrc_table+0x2b0>
mov    %rsp,%rdi
call   1040 <random_permute@plt>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movdqu (%r14,%rax,4),%xmm0
movdqu 0x10(%r14,%rax,4),%xmm1
movdqu 0x20(%r14,%rax,4),%xmm2
movdqu 0x30(%r14,%rax,4),%xmm3
pslld  $0x8,%xmm0
pslld  $0x8,%xmm1
por    (%rsp,%rax,4),%xmm0
por    0x10(%rsp,%rax,4),%xmm1
movdqu %xmm0,(%r14,%rax,4)
movdqu %xmm1,0x10(%r14,%rax,4)
pslld  $0x8,%xmm2
pslld  $0x8,%xmm3
por    0x20(%rsp,%rax,4),%xmm2
por    0x30(%rsp,%rax,4),%xmm3
movdqu %xmm2,0x20(%r14,%rax,4)
movdqu %xmm3,0x30(%r14,%rax,4)
add    $0x10,%rax
cmp    $0x100,%rax
jne    1450 <xcrc_table+0x330>
mov    %rsp,%rdi
call   1040 <random_permute@plt>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movdqu (%r14,%rax,4),%xmm0
movdqu 0x10(%r14,%rax,4),%xmm1
movdqu 0x20(%r14,%rax,4),%xmm2
movdqu 0x30(%r14,%rax,4),%xmm3
pslld  $0x8,%xmm0
pslld  $0x8,%xmm1
por    (%rsp,%rax,4),%xmm0
por    0x10(%rsp,%rax,4),%xmm1
movdqu %xmm0,(%r14,%rax,4)
movdqu %xmm1,0x10(%r14,%rax,4)
pslld  $0x8,%xmm2
pslld  $0x8,%xmm3
por    0x20(%rsp,%rax,4),%xmm2
por    0x30(%rsp,%rax,4),%xmm3
movdqu %xmm2,0x20(%r14,%rax,4)
movdqu %xmm3,0x30(%r14,%rax,4)
add    $0x10,%rax
cmp    $0x100,%rax
jne    14d0 <xcrc_table+0x3b0>
add    $0x408,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @xcrc_table(i32* %0) {
%2 = alloca i32*
%3 = alloca [256 x i32]
%4 = alloca i32
%5 = alloca i32
store i32* %0, i32** %2
%6 = load i32*, i32** %2
%7 = call i32 @memset(i32* %6, i32 0, i32 2048)
store i32 0, i32* %4
br label %8
8: ; preds = %37, %1
%9 = load i32, i32* %4
%10 = icmp slt i32 %9, 8
br i1 %10, label %11, label %40
11: ; preds = %8
%12 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 0
%13 = call i32 @random_permute(i32* %12)
store i32 0, i32* %5
br label %14
14: ; preds = %33, %11
%15 = load i32, i32* %5
%16 = icmp slt i32 %15, 256
br i1 %16, label %17, label %36
17: ; preds = %14
%18 = load i32*, i32** %2
%19 = load i32, i32* %5
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds i32, i32* %18, i64 %20
%22 = load i32, i32* %21
%23 = shl i32 %22, 8
%24 = load i32, i32* %5
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %25
%27 = load i32, i32* %26
%28 = or i32 %23, %27
%29 = load i32*, i32** %2
%30 = load i32, i32* %5
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i32, i32* %29, i64 %31
store i32 %28, i32* %32
br label %33
33: ; preds = %17
%34 = load i32, i32* %5
%35 = add nsw i32 %34, 1
store i32 %35, i32* %5
br label %14
36: ; preds = %14
br label %37
37: ; preds = %36
%38 = load i32, i32* %4
%39 = add nsw i32 %38, 1
store i32 %39, i32* %4
br label %8
40: ; preds = %8
ret void
}

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