#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 pickweight(int *, int);
int pickzero(int *, int);
int pickexponential(int *numbreak, int clausesize, int tofix) {
  int i;
  int weight[1000];
  int tochange;
  if (clausesize == 1)
    return (0);
  if ((tochange = pickzero(numbreak, clausesize)) != -1)
    return (tochange);
  for (i = 0; i < clausesize; i++)
    weight[i] = 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2;
  for (i = 0; i < clausesize; i++) {
    weight[i] >>= numbreak[i];
  }
  return (pickweight(weight, clausesize));
}


x86 assembly (clang, -O0):
<pickexponential>:
push   %rbp
mov    %rsp,%rbp
sub    $0xfd0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
cmpl   $0x1,-0x14(%rbp)
jne    114b <pickexponential+0x2b>
movl   $0x0,-0x4(%rbp)
jmp    11f8 <pickexponential+0xd8>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1030 <pickzero@plt>
mov    %eax,-0xfc4(%rbp)
cmp    $0xffffffff,%eax
je     1174 <pickexponential+0x54>
mov    -0xfc4(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    11f8 <pickexponential+0xd8>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11a4 <pickexponential+0x84>
movslq -0x1c(%rbp),%rax
movl   $0x4000,-0xfc0(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    117b <pickexponential+0x5b>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11e6 <pickexponential+0xc6>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x1c(%rbp),%rax
mov    -0xfc0(%rbp,%rax,4),%edx
sar    %cl,%edx
mov    %edx,%ecx
mov    %ecx,-0xfc0(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11ab <pickexponential+0x8b>
lea    -0xfc0(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <pickweight@plt>
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xfd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pickexponential>:
push   %rbp
push   %rbx
sub    $0xfa8,%rsp
xor    %eax,%eax
cmp    $0x1,%esi
je     14ca <pickexponential+0x3aa>
mov    %esi,%ebp
mov    %rdi,%rbx
call   1030 <pickzero@plt>
cmp    $0xffffffff,%eax
jne    14ca <pickexponential+0x3aa>
test   %ebp,%ebp
jle    14c0 <pickexponential+0x3a0>
mov    %ebp,%eax
cmp    $0x8,%ebp
jae    115d <pickexponential+0x3d>
xor    %ecx,%ecx
jmp    1240 <pickexponential+0x120>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x7,%edx
cmp    $0x38,%rdi
jae    1183 <pickexponential+0x63>
xor    %edi,%edi
jmp    1201 <pickexponential+0xe1>
and    $0xfffffffffffffff8,%rsi
xor    %edi,%edi
movaps 0xe70(%rip),%xmm0
movaps %xmm0,(%rsp,%rdi,4)
movaps %xmm0,0x10(%rsp,%rdi,4)
movaps %xmm0,0x20(%rsp,%rdi,4)
movaps %xmm0,0x30(%rsp,%rdi,4)
movaps %xmm0,0x40(%rsp,%rdi,4)
movaps %xmm0,0x50(%rsp,%rdi,4)
movaps %xmm0,0x60(%rsp,%rdi,4)
movaps %xmm0,0x70(%rsp,%rdi,4)
movaps %xmm0,0x80(%rsp,%rdi,4)
movaps %xmm0,0x90(%rsp,%rdi,4)
movaps %xmm0,0xa0(%rsp,%rdi,4)
movaps %xmm0,0xb0(%rsp,%rdi,4)
movaps %xmm0,0xc0(%rsp,%rdi,4)
movaps %xmm0,0xd0(%rsp,%rdi,4)
movaps %xmm0,0xe0(%rsp,%rdi,4)
movaps %xmm0,0xf0(%rsp,%rdi,4)
add    $0x40,%rdi
add    $0xfffffffffffffff8,%rsi
jne    1190 <pickexponential+0x70>
test   %rdx,%rdx
je     1232 <pickexponential+0x112>
lea    (%rsp,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movaps 0xde5(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movaps %xmm0,-0x10(%rsi,%rdi,1)
movaps %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1220 <pickexponential+0x100>
cmp    %rax,%rcx
je     1250 <pickexponential+0x130>
nopw   0x0(%rax,%rax,1)
movl   $0x4000,(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1240 <pickexponential+0x120>
test   %ebp,%ebp
jle    14c0 <pickexponential+0x3a0>
cmp    $0x8,%ebp
jae    1264 <pickexponential+0x144>
xor    %edx,%edx
jmp    14b0 <pickexponential+0x390>
mov    %eax,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rcx,%rcx
je     13f9 <pickexponential+0x2d9>
movabs $0x3ffffffffffffff8,%rdi
ff ff 3f
or     $0x6,%rdi
and    %rsi,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rbx,%rcx,4),%xmm4
movdqu 0x10(%rbx,%rcx,4),%xmm8
pshuflw $0xfe,%xmm4,%xmm3
movdqa (%rsp,%rcx,4),%xmm6
movdqa 0x10(%rsp,%rcx,4),%xmm2
movdqa 0x20(%rsp,%rcx,4),%xmm1
movdqa 0x30(%rsp,%rcx,4),%xmm0
movdqa %xmm6,%xmm7
psrad  %xmm3,%xmm7
pshuflw $0x54,%xmm4,%xmm5
movdqa %xmm6,%xmm3
psrad  %xmm5,%xmm3
punpcklqdq %xmm7,%xmm3
pshufd $0xee,%xmm4,%xmm4
pshuflw $0xfe,%xmm4,%xmm5
movdqa %xmm6,%xmm7
psrad  %xmm5,%xmm7
pshuflw $0x54,%xmm4,%xmm4
psrad  %xmm4,%xmm6
punpckhqdq %xmm7,%xmm6
shufps $0xcc,%xmm6,%xmm3
pshuflw $0xfe,%xmm8,%xmm4
movdqa %xmm2,%xmm5
psrad  %xmm4,%xmm5
pshuflw $0x54,%xmm8,%xmm4
movdqa %xmm2,%xmm6
psrad  %xmm4,%xmm6
punpcklqdq %xmm5,%xmm6
pshufd $0xee,%xmm8,%xmm4
pshuflw $0xfe,%xmm4,%xmm5
movdqa %xmm2,%xmm7
psrad  %xmm5,%xmm7
pshuflw $0x54,%xmm4,%xmm4
psrad  %xmm4,%xmm2
punpckhqdq %xmm7,%xmm2
shufps $0xcc,%xmm2,%xmm6
movaps %xmm3,(%rsp,%rcx,4)
movaps %xmm6,0x10(%rsp,%rcx,4)
movdqu 0x20(%rbx,%rcx,4),%xmm3
movdqu 0x30(%rbx,%rcx,4),%xmm4
pshuflw $0xfe,%xmm3,%xmm2
movdqa %xmm1,%xmm5
psrad  %xmm2,%xmm5
pshuflw $0x54,%xmm3,%xmm6
movdqa %xmm1,%xmm2
psrad  %xmm6,%xmm2
punpcklqdq %xmm5,%xmm2
pshufd $0xee,%xmm3,%xmm3
pshuflw $0xfe,%xmm3,%xmm5
movdqa %xmm1,%xmm6
psrad  %xmm5,%xmm6
pshuflw $0x54,%xmm3,%xmm3
psrad  %xmm3,%xmm1
punpckhqdq %xmm6,%xmm1
shufps $0xcc,%xmm1,%xmm2
pshuflw $0xfe,%xmm4,%xmm1
movdqa %xmm0,%xmm3
psrad  %xmm1,%xmm3
pshuflw $0x54,%xmm4,%xmm1
movdqa %xmm0,%xmm5
psrad  %xmm1,%xmm5
punpcklqdq %xmm3,%xmm5
pshufd $0xee,%xmm4,%xmm1
pshuflw $0xfe,%xmm1,%xmm3
movdqa %xmm0,%xmm4
psrad  %xmm3,%xmm4
pshuflw $0x54,%xmm1,%xmm1
psrad  %xmm1,%xmm0
punpckhqdq %xmm4,%xmm0
shufps $0xcc,%xmm0,%xmm5
movaps %xmm2,0x20(%rsp,%rcx,4)
movaps %xmm5,0x30(%rsp,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rdi
jne    12a0 <pickexponential+0x180>
jmp    13fb <pickexponential+0x2db>
xor    %ecx,%ecx
test   $0x1,%sil
je     14a6 <pickexponential+0x386>
movdqu (%rbx,%rcx,4),%xmm1
movdqu 0x10(%rbx,%rcx,4),%xmm2
movdqa (%rsp,%rcx,4),%xmm3
pshuflw $0xfe,%xmm1,%xmm0
movdqa %xmm3,%xmm4
psrad  %xmm0,%xmm4
pshuflw $0x54,%xmm1,%xmm5
movdqa %xmm3,%xmm0
psrad  %xmm5,%xmm0
pshufd $0xee,%xmm1,%xmm1
pshuflw $0xfe,%xmm1,%xmm5
movdqa %xmm3,%xmm6
psrad  %xmm5,%xmm6
movdqa 0x10(%rsp,%rcx,4),%xmm5
punpcklqdq %xmm4,%xmm0
pshuflw $0x54,%xmm1,%xmm1
psrad  %xmm1,%xmm3
punpckhqdq %xmm6,%xmm3
pshuflw $0xfe,%xmm2,%xmm1
movdqa %xmm5,%xmm4
psrad  %xmm1,%xmm4
shufps $0xcc,%xmm3,%xmm0
pshuflw $0x54,%xmm2,%xmm1
movdqa %xmm5,%xmm3
psrad  %xmm1,%xmm3
pshufd $0xee,%xmm2,%xmm1
pshuflw $0xfe,%xmm1,%xmm2
movdqa %xmm5,%xmm6
psrad  %xmm2,%xmm6
punpcklqdq %xmm4,%xmm3
pshuflw $0x54,%xmm1,%xmm1
psrad  %xmm1,%xmm5
punpckhqdq %xmm6,%xmm5
shufps $0xcc,%xmm5,%xmm3
movaps %xmm0,(%rsp,%rcx,4)
movaps %xmm3,0x10(%rsp,%rcx,4)
cmp    %rax,%rdx
je     14c0 <pickexponential+0x3a0>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rdx,4),%ecx
sarl   %cl,(%rsp,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    14b0 <pickexponential+0x390>
mov    %rsp,%rdi
mov    %ebp,%esi
call   1040 <pickweight@plt>
add    $0xfa8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
define i32 @pickexponential(i32* %0, i32 %1, i32 %2) {
%4 = alloca i32
%5 = alloca i32*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca [1000 x i32]
%10 = alloca i32
store i32* %0, i32** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
%11 = load i32, i32* %6
%12 = icmp eq i32 %11, 1
br i1 %12, label %13, label %14
13: ; preds = %3
store i32 0, i32* %4
br label %56
14: ; preds = %3
%15 = load i32*, i32** %5
%16 = load i32, i32* %6
%17 = call i32 @pickzero(i32* %15, i32 %16)
store i32 %17, i32* %10
%18 = icmp ne i32 %17, -1
br i1 %18, label %19, label %21
19: ; preds = %14
%20 = load i32, i32* %10
store i32 %20, i32* %4
br label %56
21: ; preds = %14
store i32 0, i32* %8
br label %22
22: ; preds = %30, %21
%23 = load i32, i32* %8
%24 = load i32, i32* %6
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %33
26: ; preds = %22
%27 = load i32, i32* %8
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [1000 x i32], [1000 x i32]* %9, i64 0, i64 %28
store i32 16384, i32* %29
br label %30
30: ; preds = %26
%31 = load i32, i32* %8
%32 = add nsw i32 %31, 1
store i32 %32, i32* %8
br label %22
33: ; preds = %22
store i32 0, i32* %8
br label %34
34: ; preds = %49, %33
%35 = load i32, i32* %8
%36 = load i32, i32* %6
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %52
38: ; preds = %34
%39 = load i32*, i32** %5
%40 = load i32, i32* %8
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i32, i32* %39, i64 %41
%43 = load i32, i32* %42
%44 = load i32, i32* %8
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [1000 x i32], [1000 x i32]* %9, i64 0, i64 %45
%47 = load i32, i32* %46
%48 = ashr i32 %47, %43
store i32 %48, i32* %46
br label %49
49: ; preds = %38
%50 = load i32, i32* %8
%51 = add nsw i32 %50, 1
store i32 %51, i32* %8
br label %34
52: ; preds = %34
%53 = getelementptr inbounds [1000 x i32], [1000 x i32]* %9, i64 0, i64 0
%54 = load i32, i32* %6
%55 = call i32 @pickweight(i32* %53, i32 %54)
store i32 %55, i32* %4
br label %56
56: ; preds = %52, %19, %13
%57 = load i32, i32* %4
ret i32 %57
}

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