#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*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, int);
void rng_init(int *mystate, int seed) {
  int i, j, l, k, cbit, runup, state_size, tmp[861];
  int *reg, *node;
  state_size = 2 * 55 - 1 + 9;
  l = 55;
  k = 0;
  if (l == 7) {
    k = 4;
    cbit = 1;
    runup = k * 71;
  }
  if (l == 17) {
    k = 12;
    cbit = 5;
    runup = k * 65;
  }
  if (l == 55) {
    k = 31;
    cbit = 18;
    runup = k * 93;
  }
  if (l == 159) {
    k = 128;
    cbit = 63;
    runup = k * 179;
  }
  if (l == 607) {
    k = 334;
    cbit = 166;
    runup = k * 628;
  }
  if (l == 1279) {
    k = 861;
    cbit = 233;
    runup = k * 1291;
  }
  if (!k) {
    printf("\n\n    invalid UTS_ALFG_L value: %d\n\n", l);
    exit(0);
  }
  mystate[0] = state_size;
  mystate[1] = l;
  mystate[2] = seed;
  mystate[3] = k;
  mystate[4] = cbit;
  mystate[5] = runup;
  mystate[6] = l - 1;
  mystate[7] = k - 1;
  mystate[8] = 0;
  node = &(mystate[9]);
  reg = &(mystate[(9 + l - 1)]);
  for (i = 0; i < l - 1; i++)
    node[i] = 0;
  node[0] = 2;
  for (i = 0; i < l; i++)
    reg[i] = 0;
  reg[cbit] += 1;
  mystate[2] = ((mystate[2] << 1) & 0x7fffffff);
  reg[0] = 2 ^ mystate[2];
  k = mystate[3];
  for (j = 0; j < mystate[5]; j += k) {
    for (i = 0; i < k; i++)
      tmp[i] = reg[i + l - k];
    for (i = k; i < l; i++)
      reg[i] = reg[i - k];
    for (i = 0; i < k; i++)
      reg[i] += tmp[i];
  }
}


x86 assembly (clang, -O0):
<rng_init>:
push   %rbp
mov    %rsp,%rbp
sub    $0xdb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x76,-0x28(%rbp)
movl   $0x37,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x7,-0x18(%rbp)
jne    1166 <rng_init+0x46>
movl   $0x4,-0x1c(%rbp)
movl   $0x1,-0x20(%rbp)
imul   $0x47,-0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x11,-0x18(%rbp)
jne    1185 <rng_init+0x65>
movl   $0xc,-0x1c(%rbp)
movl   $0x5,-0x20(%rbp)
imul   $0x41,-0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x37,-0x18(%rbp)
jne    11a4 <rng_init+0x84>
movl   $0x1f,-0x1c(%rbp)
movl   $0x12,-0x20(%rbp)
imul   $0x5d,-0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x9f,-0x18(%rbp)
jne    11c9 <rng_init+0xa9>
movl   $0x80,-0x1c(%rbp)
movl   $0x3f,-0x20(%rbp)
imul   $0xb3,-0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x25f,-0x18(%rbp)
jne    11ee <rng_init+0xce>
movl   $0x14e,-0x1c(%rbp)
movl   $0xa6,-0x20(%rbp)
imul   $0x274,-0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x4ff,-0x18(%rbp)
jne    1213 <rng_init+0xf3>
movl   $0x35d,-0x1c(%rbp)
movl   $0xe9,-0x20(%rbp)
imul   $0x50b,-0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jne    1233 <rng_init+0x113>
mov    -0x18(%rbp),%esi
lea    0xdd9(%rip),%rdi
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
mov    -0x28(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0xc(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x1c(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x24(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x1c(%rax)
mov    -0x8(%rbp),%rax
movl   $0x0,0x20(%rax)
mov    -0x8(%rbp),%rax
add    $0x24,%rax
mov    %rax,-0xdb0(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x9,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xda8(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12f8 <rng_init+0x1d8>
mov    -0xdb0(%rbp),%rax
movslq -0x10(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12c7 <rng_init+0x1a7>
mov    -0xdb0(%rbp),%rax
movl   $0x2,(%rax)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1338 <rng_init+0x218>
mov    -0xda8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    130c <rng_init+0x1ec>
mov    -0xda8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
shl    $0x1,%ecx
and    $0x7fffffff,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
xor    $0x2,%ecx
mov    -0xda8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x8(%rbp),%rcx
cmp    0x14(%rcx),%eax
jge    146a <rng_init+0x34a>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13d9 <rng_init+0x2b9>
mov    -0xda8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    -0x18(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x10(%rbp),%rax
mov    %ecx,-0xda0(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    139e <rng_init+0x27e>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    141a <rng_init+0x2fa>
mov    -0xda8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0xda8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13df <rng_init+0x2bf>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1457 <rng_init+0x337>
movslq -0x10(%rbp),%rax
mov    -0xda0(%rbp,%rax,4),%edx
mov    -0xda8(%rbp),%rax
movslq -0x10(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1421 <rng_init+0x301>
jmp    145c <rng_init+0x33c>
mov    -0x1c(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1387 <rng_init+0x267>
add    $0xdb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rng_init>:
sub    $0xcf8,%rsp
movabs $0x3700000076,%rax
mov    %rax,(%rdi)
movdqa 0xee4(%rip),%xmm0
movdqu %xmm0,0xc(%rdi)
movl   $0x1e,0x1c(%rdi)
xorps  %xmm8,%xmm8
movups %xmm8,0x20(%rdi)
movups %xmm8,0x30(%rdi)
movups %xmm8,0x40(%rdi)
movups %xmm8,0x50(%rdi)
movups %xmm8,0x60(%rdi)
movups %xmm8,0x70(%rdi)
movups %xmm8,0x80(%rdi)
movups %xmm8,0x90(%rdi)
movups %xmm8,0xa0(%rdi)
movups %xmm8,0xb0(%rdi)
movups %xmm8,0xc0(%rdi)
movups %xmm8,0xd0(%rdi)
movups %xmm8,0xe0(%rdi)
movups %xmm8,0xec(%rdi)
movl   $0x2,0x24(%rdi)
movups %xmm8,0x140(%rdi)
movups %xmm8,0x1c0(%rdi)
movups %xmm8,0x1b0(%rdi)
movups %xmm8,0x1a0(%rdi)
movups %xmm8,0x190(%rdi)
movups %xmm8,0x180(%rdi)
movups %xmm8,0x170(%rdi)
movups %xmm8,0x160(%rdi)
movups %xmm8,0x150(%rdi)
movups %xmm8,0x130(%rdi)
movups %xmm8,0x120(%rdi)
movups %xmm8,0x110(%rdi)
movups %xmm8,0x100(%rdi)
movq   $0x0,0x1d0(%rdi)
movl   $0x1,0x144(%rdi)
add    %esi,%esi
and    $0x7ffffffe,%esi
mov    %esi,0x8(%rdi)
xor    $0x2,%esi
mov    %esi,0xfc(%rdi)
lea    0x15c(%rdi),%rax
movd   %esi,%xmm1
movaps 0xddb(%rip),%xmm9
xor    %ecx,%ecx
xorps  %xmm3,%xmm3
xorps  %xmm4,%xmm4
xorps  %xmm5,%xmm5
movups 0x6c(%rax),%xmm6
movups %xmm6,-0x14(%rsp)
movups 0x60(%rax),%xmm6
movaps %xmm6,-0x20(%rsp)
movups 0x50(%rax),%xmm6
movaps %xmm6,-0x30(%rsp)
movups 0x40(%rax),%xmm6
movaps %xmm6,-0x40(%rsp)
movups (%rax),%xmm6
movups 0x10(%rax),%xmm7
movups 0x20(%rax),%xmm0
movups 0x30(%rax),%xmm2
movaps %xmm2,-0x50(%rsp)
movaps %xmm0,-0x60(%rsp)
movaps %xmm7,-0x70(%rsp)
movaps %xmm6,-0x80(%rsp)
movdqu %xmm1,0x178(%rdi)
movups %xmm8,0x188(%rdi)
movups %xmm3,0x198(%rdi)
movups %xmm4,0x1a8(%rdi)
movups %xmm9,0x1b8(%rdi)
movups %xmm5,0x1c8(%rdi)
movd   %xmm1,%edx
add    -0x80(%rsp),%edx
mov    %edx,0xfc(%rdi)
movdqu 0x100(%rdi),%xmm0
movdqu -0x7c(%rsp),%xmm1
paddd  %xmm0,%xmm1
movdqu %xmm1,0x100(%rdi)
movdqu 0x110(%rdi),%xmm0
movdqu -0x6c(%rsp),%xmm1
paddd  %xmm0,%xmm1
movdqu %xmm1,0x110(%rdi)
movdqu 0x120(%rdi),%xmm0
movdqu -0x5c(%rsp),%xmm1
paddd  %xmm0,%xmm1
movdqu %xmm1,0x120(%rdi)
movdqu 0x130(%rdi),%xmm0
movdqu -0x4c(%rsp),%xmm1
paddd  %xmm0,%xmm1
movdqu %xmm1,0x130(%rdi)
movdqu 0x140(%rdi),%xmm0
movdqu -0x3c(%rsp),%xmm1
paddd  %xmm0,%xmm1
movdqu %xmm1,0x140(%rdi)
movdqu 0x150(%rdi),%xmm0
movdqu -0x2c(%rsp),%xmm1
paddd  %xmm0,%xmm1
movdqu %xmm1,0x150(%rdi)
movdqu 0x160(%rdi),%xmm0
movdqu -0x1c(%rsp),%xmm1
paddd  %xmm0,%xmm1
movdqu %xmm1,0x160(%rdi)
mov    -0xc(%rsp),%edx
add    %edx,0x170(%rdi)
mov    -0x8(%rsp),%edx
add    %edx,0x174(%rdi)
cmp    $0xb23,%ecx
ja     13c9 <rng_init+0x2c9>
add    $0x1f,%ecx
movdqu 0xfc(%rdi),%xmm1
movups 0x10c(%rdi),%xmm8
movups 0x11c(%rdi),%xmm3
movups 0x12c(%rdi),%xmm4
movups 0x13c(%rdi),%xmm9
movups 0x14c(%rdi),%xmm5
jmp    1240 <rng_init+0x140>
add    $0xcf8,%rsp
ret

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

LLVM IR (-O2):
define void @rng_init(i32* nocapture %0, i32 %1) {
%3 = alloca [861 x i32]
%4 = bitcast [861 x i32]* %3 to i8*
store i32 118, i32* %0
%5 = getelementptr inbounds i32, i32* %0, i64 1
store i32 55, i32* %5
%6 = getelementptr inbounds i32, i32* %0, i64 2
%7 = getelementptr inbounds i32, i32* %0, i64 3
%8 = bitcast i32* %7 to <4 x i32>*
store <4 x i32> <i32 31, i32 18, i32 2883, i32 54>, <4 x i32>* %8
%9 = getelementptr inbounds i32, i32* %0, i64 7
store i32 30, i32* %9
%10 = getelementptr inbounds i32, i32* %0, i64 8
%11 = getelementptr inbounds i32, i32* %0, i64 9
%12 = getelementptr inbounds i32, i32* %0, i64 63
%13 = bitcast i32* %10 to i8*
store i32 2, i32* %11
%14 = getelementptr inbounds i32, i32* %0, i64 64
%15 = bitcast i32* %14 to i8*
%16 = getelementptr inbounds i32, i32* %0, i64 81
store i32 1, i32* %16
%17 = shl i32 %1, 1
%18 = and i32 %17, 2147483646
store i32 %18, i32* %6
%19 = xor i32 %18, 2
store i32 %19, i32* %12
%20 = getelementptr i32, i32* %0, i64 87
%21 = bitcast i32* %20 to i8*
%22 = getelementptr inbounds i32, i32* %0, i64 94
%23 = getelementptr inbounds i32, i32* %0, i64 67
%24 = getelementptr inbounds i32, i32* %0, i64 98
%25 = getelementptr inbounds i32, i32* %0, i64 71
%26 = getelementptr inbounds i32, i32* %0, i64 102
%27 = getelementptr inbounds i32, i32* %0, i64 75
%28 = getelementptr inbounds i32, i32* %0, i64 106
%29 = getelementptr inbounds i32, i32* %0, i64 79
%30 = getelementptr inbounds i32, i32* %0, i64 110
%31 = getelementptr inbounds i32, i32* %0, i64 83
%32 = getelementptr inbounds i32, i32* %0, i64 114
%33 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %19, i64 0
%34 = getelementptr inbounds i32, i32* %0, i64 92
%35 = bitcast i32* %22 to <4 x i32>*
%36 = bitcast i32* %24 to <4 x i32>*
%37 = bitcast i32* %26 to <4 x i32>*
%38 = bitcast i32* %28 to <4 x i32>*
%39 = bitcast i32* %30 to <4 x i32>*
%40 = bitcast i32* %32 to <4 x i32>*
%41 = getelementptr inbounds [861 x i32], [861 x i32]* %3, i64 0, i64 0
%42 = getelementptr inbounds i32, i32* %0, i64 64
%43 = bitcast i32* %42 to <4 x i32>*
%44 = getelementptr inbounds [861 x i32], [861 x i32]* %3, i64 0, i64 1
%45 = bitcast i32* %44 to <4 x i32>*
%46 = bitcast i32* %42 to <4 x i32>*
%47 = getelementptr inbounds i32, i32* %0, i64 68
%48 = bitcast i32* %47 to <4 x i32>*
%49 = getelementptr inbounds [861 x i32], [861 x i32]* %3, i64 0, i64 5
%50 = bitcast i32* %49 to <4 x i32>*
%51 = bitcast i32* %47 to <4 x i32>*
%52 = getelementptr inbounds i32, i32* %0, i64 72
%53 = bitcast i32* %52 to <4 x i32>*
%54 = getelementptr inbounds [861 x i32], [861 x i32]* %3, i64 0, i64 9
%55 = bitcast i32* %54 to <4 x i32>*
%56 = bitcast i32* %52 to <4 x i32>*
%57 = getelementptr inbounds i32, i32* %0, i64 76
%58 = bitcast i32* %57 to <4 x i32>*
%59 = getelementptr inbounds [861 x i32], [861 x i32]* %3, i64 0, i64 13
%60 = bitcast i32* %59 to <4 x i32>*
%61 = bitcast i32* %57 to <4 x i32>*
%62 = getelementptr inbounds i32, i32* %0, i64 80
%63 = bitcast i32* %62 to <4 x i32>*
%64 = getelementptr inbounds [861 x i32], [861 x i32]* %3, i64 0, i64 17
%65 = bitcast i32* %64 to <4 x i32>*
%66 = bitcast i32* %62 to <4 x i32>*
%67 = getelementptr inbounds i32, i32* %0, i64 84
%68 = bitcast i32* %67 to <4 x i32>*
%69 = getelementptr inbounds [861 x i32], [861 x i32]* %3, i64 0, i64 21
%70 = bitcast i32* %69 to <4 x i32>*
%71 = bitcast i32* %67 to <4 x i32>*
%72 = getelementptr inbounds i32, i32* %0, i64 88
%73 = bitcast i32* %72 to <4 x i32>*
%74 = getelementptr inbounds [861 x i32], [861 x i32]* %3, i64 0, i64 25
%75 = bitcast i32* %74 to <4 x i32>*
%76 = bitcast i32* %72 to <4 x i32>*
%77 = getelementptr inbounds [861 x i32], [861 x i32]* %3, i64 0, i64 29
%78 = getelementptr inbounds i32, i32* %0, i64 92
%79 = getelementptr inbounds i32, i32* %0, i64 93
%80 = getelementptr inbounds [861 x i32], [861 x i32]* %3, i64 0, i64 30
%81 = getelementptr inbounds i32, i32* %0, i64 93
%82 = bitcast i32* %12 to <4 x i32>*
%83 = bitcast i32* %23 to <4 x i32>*
%84 = bitcast i32* %25 to <4 x i32>*
%85 = bitcast i32* %27 to <4 x i32>*
%86 = bitcast i32* %29 to <4 x i32>*
%87 = bitcast i32* %31 to <4 x i32>*
br label %88
88: ; preds = %127, %2
%89 = phi i32 [ %128, %127 ], [ 0, %2 ]
%90 = phi <4 x i32> [ %129, %127 ], [ %33, %2 ]
%91 = phi <4 x i32> [ %130, %127 ], [ zeroinitializer, %2 ]
%92 = phi <4 x i32> [ %131, %127 ], [ zeroinitializer, %2 ]
%93 = phi <4 x i32> [ %132, %127 ], [ zeroinitializer, %2 ]
%94 = phi <4 x i32> [ %133, %127 ], [ <i32 0, i32 0, i32 1, i32 0>, %2 ]
%95 = phi <4 x i32> [ %134, %127 ], [ zeroinitializer, %2 ]
store <4 x i32> %90, <4 x i32>* %35
store <4 x i32> %91, <4 x i32>* %36
store <4 x i32> %92, <4 x i32>* %37
store <4 x i32> %93, <4 x i32>* %38
store <4 x i32> %94, <4 x i32>* %39
store <4 x i32> %95, <4 x i32>* %40
%96 = load i32, i32* %41
%97 = extractelement <4 x i32> %90, i64 0
%98 = add nsw i32 %97, %96
store i32 %98, i32* %12
%99 = load <4 x i32>, <4 x i32>* %43
%100 = load <4 x i32>, <4 x i32>* %45
%101 = add nsw <4 x i32> %99, %100
store <4 x i32> %101, <4 x i32>* %46
%102 = load <4 x i32>, <4 x i32>* %48
%103 = load <4 x i32>, <4 x i32>* %50
%104 = add nsw <4 x i32> %102, %103
store <4 x i32> %104, <4 x i32>* %51
%105 = load <4 x i32>, <4 x i32>* %53
%106 = load <4 x i32>, <4 x i32>* %55
%107 = add nsw <4 x i32> %105, %106
store <4 x i32> %107, <4 x i32>* %56
%108 = load <4 x i32>, <4 x i32>* %58
%109 = load <4 x i32>, <4 x i32>* %60
%110 = add nsw <4 x i32> %108, %109
store <4 x i32> %110, <4 x i32>* %61
%111 = load <4 x i32>, <4 x i32>* %63
%112 = load <4 x i32>, <4 x i32>* %65
%113 = add nsw <4 x i32> %111, %112
store <4 x i32> %113, <4 x i32>* %66
%114 = load <4 x i32>, <4 x i32>* %68
%115 = load <4 x i32>, <4 x i32>* %70
%116 = add nsw <4 x i32> %114, %115
store <4 x i32> %116, <4 x i32>* %71
%117 = load <4 x i32>, <4 x i32>* %73
%118 = load <4 x i32>, <4 x i32>* %75
%119 = add nsw <4 x i32> %117, %118
store <4 x i32> %119, <4 x i32>* %76
%120 = load i32, i32* %34
%121 = load i32, i32* %77
%122 = add nsw i32 %120, %121
store i32 %122, i32* %78
%123 = load i32, i32* %79
%124 = load i32, i32* %80
%125 = add nsw i32 %123, %124
store i32 %125, i32* %81
%126 = icmp ult i32 %89, 2852
br i1 %126, label %127, label %135
127: ; preds = %88
%128 = add nuw nsw i32 %89, 31
%129 = load <4 x i32>, <4 x i32>* %82
%130 = load <4 x i32>, <4 x i32>* %83
%131 = load <4 x i32>, <4 x i32>* %84
%132 = load <4 x i32>, <4 x i32>* %85
%133 = load <4 x i32>, <4 x i32>* %86
%134 = load <4 x i32>, <4 x i32>* %87
br label %88
135: ; preds = %88
ret void
}