#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 */
scalar_t__ malloc(int);
int /*<<< orphan*/ traverse(int /*<<< orphan*/, int, int *, int *, int *,
                            int *);
int totalNQueens(int n) {
  bool *col = (bool *)malloc(sizeof(bool) * n);
  for (int i = 0; i < n; i++)
    col[i] = true;
  bool *fslash = (bool *)malloc(sizeof(bool) * (2 * n));
  bool *bslash = (bool *)malloc(sizeof(bool) * (2 * n));
  for (int i = 0; i < 2 * n; i++) {
    fslash[i] = true;
    bslash[i] = true;
  }
  int count = 0;
  traverse(0, n, col, fslash, bslash, &count);
  return count;
}


x86 assembly (clang, -O0):
<totalNQueens>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    116e <totalNQueens+0x4e>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1145 <totalNQueens+0x25>
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    11e0 <totalNQueens+0xc0>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a3 <totalNQueens+0x83>
movl   $0x0,-0x30(%rbp)
mov    -0x4(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
xor    %edi,%edi
lea    -0x30(%rbp),%r9
call   1030 <traverse@plt>
mov    -0x30(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<totalNQueens>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %edi,%r14d
lea    0x0(,%r14,4),%edi
call   1040 <malloc@plt>
mov    %rax,%r15
test   %r14d,%r14d
jle    1261 <totalNQueens+0x141>
mov    %r14d,%eax
cmp    $0x8,%r14d
jae    1153 <totalNQueens+0x33>
xor    %ecx,%ecx
jmp    1250 <totalNQueens+0x130>
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    1179 <totalNQueens+0x59>
xor    %edi,%edi
jmp    1215 <totalNQueens+0xf5>
and    $0xfffffffffffffff8,%rsi
xor    %edi,%edi
movaps 0xe7a(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
movups %xmm0,(%r15,%rdi,4)
movups %xmm0,0x10(%r15,%rdi,4)
movups %xmm0,0x20(%r15,%rdi,4)
movups %xmm0,0x30(%r15,%rdi,4)
movups %xmm0,0x40(%r15,%rdi,4)
movups %xmm0,0x50(%r15,%rdi,4)
movups %xmm0,0x60(%r15,%rdi,4)
movups %xmm0,0x70(%r15,%rdi,4)
movups %xmm0,0x80(%r15,%rdi,4)
movups %xmm0,0x90(%r15,%rdi,4)
movups %xmm0,0xa0(%r15,%rdi,4)
movups %xmm0,0xb0(%r15,%rdi,4)
movups %xmm0,0xc0(%r15,%rdi,4)
movups %xmm0,0xd0(%r15,%rdi,4)
movups %xmm0,0xe0(%r15,%rdi,4)
movups %xmm0,0xf0(%r15,%rdi,4)
add    $0x40,%rdi
add    $0xfffffffffffffff8,%rsi
jne    1190 <totalNQueens+0x70>
test   %rdx,%rdx
je     1242 <totalNQueens+0x122>
lea    (%r15,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movaps 0xdd1(%rip),%xmm0
nop
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1230 <totalNQueens+0x110>
cmp    %rax,%rcx
je     1261 <totalNQueens+0x141>
nopw   0x0(%rax,%rax,1)
movl   $0x1,(%r15,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1250 <totalNQueens+0x130>
lea    0x0(,%r14,8),%ebp
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1040 <malloc@plt>
test   %r14d,%r14d
jle    1435 <totalNQueens+0x315>
lea    (%r14,%r14,1),%edx
cmp    $0x2,%edx
mov    $0x1,%ecx
cmovge %edx,%ecx
cmp    $0x8,%ecx
jb     12b1 <totalNQueens+0x191>
lea    (%rax,%rcx,4),%rdx
cmp    %rdx,%rbx
jae    134c <totalNQueens+0x22c>
lea    (%rbx,%rcx,4),%rdx
cmp    %rdx,%rax
jae    134c <totalNQueens+0x22c>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
mov    %rcx,%rdi
and    $0x3,%rdi
je     12e8 <totalNQueens+0x1c8>
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x1,(%rbx,%rdx,4)
movl   $0x1,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    12d0 <totalNQueens+0x1b0>
cmp    $0x3,%rsi
jb     1435 <totalNQueens+0x315>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x1,(%rbx,%rdx,4)
movl   $0x1,(%rax,%rdx,4)
movl   $0x1,0x4(%rbx,%rdx,4)
movl   $0x1,0x4(%rax,%rdx,4)
movl   $0x1,0x8(%rbx,%rdx,4)
movl   $0x1,0x8(%rax,%rdx,4)
movl   $0x1,0xc(%rbx,%rdx,4)
movl   $0x1,0xc(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1300 <totalNQueens+0x1e0>
jmp    1435 <totalNQueens+0x315>
mov    %ecx,%edx
and    $0x7ffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rsi
jae    1374 <totalNQueens+0x254>
xor    %ebp,%ebp
jmp    13e8 <totalNQueens+0x2c8>
movabs $0x3ffffffffffffff8,%rsi
ff ff 3f
or     $0x4,%rsi
and    %rsi,%rdi
xor    %ebp,%ebp
movaps 0xc72(%rip),%xmm0
xchg   %ax,%ax
movups %xmm0,(%rbx,%rbp,4)
movups %xmm0,0x10(%rbx,%rbp,4)
movups %xmm0,(%rax,%rbp,4)
movups %xmm0,0x10(%rax,%rbp,4)
movups %xmm0,0x20(%rbx,%rbp,4)
movups %xmm0,0x30(%rbx,%rbp,4)
movups %xmm0,0x20(%rax,%rbp,4)
movups %xmm0,0x30(%rax,%rbp,4)
movups %xmm0,0x40(%rbx,%rbp,4)
movups %xmm0,0x50(%rbx,%rbp,4)
movups %xmm0,0x40(%rax,%rbp,4)
movups %xmm0,0x50(%rax,%rbp,4)
movups %xmm0,0x60(%rbx,%rbp,4)
movups %xmm0,0x70(%rbx,%rbp,4)
movups %xmm0,0x60(%rax,%rbp,4)
movups %xmm0,0x70(%rax,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1390 <totalNQueens+0x270>
test   %r8,%r8
je     142c <totalNQueens+0x30c>
lea    (%rax,%rbp,4),%rdi
add    $0x10,%rdi
lea    (%rbx,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%r8
xor    %esi,%esi
movaps 0xbf6(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movups %xmm0,-0x10(%rbp,%rsi,1)
movups %xmm0,0x0(%rbp,%rsi,1)
movups %xmm0,-0x10(%rdi,%rsi,1)
movups %xmm0,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r8
jne    1410 <totalNQueens+0x2f0>
cmp    %rcx,%rdx
jne    12b3 <totalNQueens+0x193>
movl   $0x0,0x4(%rsp)
lea    0x4(%rsp),%r9
xor    %edi,%edi
mov    %r14d,%esi
mov    %r15,%rdx
mov    %rbx,%rcx
mov    %rax,%r8
call   1030 <traverse@plt>
mov    0x4(%rsp),%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @totalNQueens(i32 %0) {
%2 = alloca i32
%3 = alloca i32*
%4 = alloca i32
%5 = alloca i32*
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
store i32 %0, i32* %2
%9 = load i32, i32* %2
%10 = sext i32 %9 to i64
%11 = mul i64 4, %10
%12 = trunc i64 %11 to i32
%13 = call i64 @malloc(i32 %12)
%14 = inttoptr i64 %13 to i32*
store i32* %14, i32** %3
store i32 0, i32* %4
br label %15
15: ; preds = %24, %1
%16 = load i32, i32* %4
%17 = load i32, i32* %2
%18 = icmp slt i32 %16, %17
br i1 %18, label %19, label %27
19: ; preds = %15
%20 = load i32*, i32** %3
%21 = load i32, i32* %4
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i32, i32* %20, i64 %22
store i32 1, i32* %23
br label %24
24: ; preds = %19
%25 = load i32, i32* %4
%26 = add nsw i32 %25, 1
store i32 %26, i32* %4
br label %15
27: ; preds = %15
%28 = load i32, i32* %2
%29 = mul nsw i32 2, %28
%30 = sext i32 %29 to i64
%31 = mul i64 4, %30
%32 = trunc i64 %31 to i32
%33 = call i64 @malloc(i32 %32)
%34 = inttoptr i64 %33 to i32*
store i32* %34, i32** %5
%35 = load i32, i32* %2
%36 = mul nsw i32 2, %35
%37 = sext i32 %36 to i64
%38 = mul i64 4, %37
%39 = trunc i64 %38 to i32
%40 = call i64 @malloc(i32 %39)
%41 = inttoptr i64 %40 to i32*
store i32* %41, i32** %6
store i32 0, i32* %7
br label %42
42: ; preds = %56, %27
%43 = load i32, i32* %7
%44 = load i32, i32* %2
%45 = mul nsw i32 2, %44
%46 = icmp slt i32 %43, %45
br i1 %46, label %47, label %59
47: ; preds = %42
%48 = load i32*, i32** %5
%49 = load i32, i32* %7
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i32, i32* %48, i64 %50
store i32 1, i32* %51
%52 = load i32*, i32** %6
%53 = load i32, i32* %7
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i32, i32* %52, i64 %54
store i32 1, i32* %55
br label %56
56: ; preds = %47
%57 = load i32, i32* %7
%58 = add nsw i32 %57, 1
store i32 %58, i32* %7
br label %42
59: ; preds = %42
store i32 0, i32* %8
%60 = load i32, i32* %2
%61 = load i32*, i32** %3
%62 = load i32*, i32** %5
%63 = load i32*, i32** %6
%64 = call i32 @traverse(i32 0, i32 %60, i32* %61, i32* %62, i32* %63, i32* %8)
%65 = load i32, i32* %8
ret i32 %65
}

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