void sortColors(int *nums, int numsSize) {
  int red = 0, white = 0, blue = 0;
  for (int *p = nums; p < nums + numsSize; p++) {
    switch (*p) {
    case 0:
      red++;
      break;
    case 1:
      white++;
      break;
    case 2:
      blue++;
      break;
    default:
      break;
    }
  }
  int *p = nums;
  for (; p < nums + red; p++) {
    *p = 0;
  }
  for (; p < nums + red + white; p++) {
    *p = 1;
  }
  for (; p < nums + blue + red + white; p++) {
    *p = 2;
  }
}


x86 assembly (clang, -O0):
<sortColors>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    11c1 <sortColors+0xc1>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x2c(%rbp)
test   %eax,%eax
je     117c <sortColors+0x7c>
jmp    115a <sortColors+0x5a>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
je     118a <sortColors+0x8a>
jmp    116b <sortColors+0x6b>
mov    -0x2c(%rbp),%eax
sub    $0x2,%eax
je     1198 <sortColors+0x98>
jmp    11a6 <sortColors+0xa6>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11ab <sortColors+0xab>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11ab <sortColors+0xab>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11ab <sortColors+0xab>
jmp    11ab <sortColors+0xab>
jmp    11b0 <sortColors+0xb0>
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
jmp    1128 <sortColors+0x28>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x10(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    1200 <sortColors+0x100>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    11c9 <sortColors+0xc9>
jmp    1205 <sortColors+0x105>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x10(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    1247 <sortColors+0x147>
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    1205 <sortColors+0x105>
jmp    124c <sortColors+0x14c>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x18(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x10(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    1299 <sortColors+0x199>
mov    -0x28(%rbp),%rax
movl   $0x2,(%rax)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    124c <sortColors+0x14c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<sortColors>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r15
test   %esi,%esi
jle    11be <sortColors+0xae>
movslq %esi,%rax
lea    (%r15,%rax,4),%rax
xor    %ebp,%ebp
mov    %r15,%rcx
xor    %ebx,%ebx
xor    %edx,%edx
jmp    114c <sortColors+0x3c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebx
add    $0x4,%rcx
cmp    %rax,%rcx
jae    1175 <sortColors+0x65>
mov    (%rcx),%esi
cmp    $0x2,%esi
je     1170 <sortColors+0x60>
cmp    $0x1,%esi
je     1140 <sortColors+0x30>
test   %esi,%esi
jne    1143 <sortColors+0x33>
add    $0x1,%edx
jmp    1143 <sortColors+0x33>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebp
jmp    1143 <sortColors+0x33>
movslq %edx,%r14
lea    (%r15,%r14,4),%r12
test   %r14d,%r14d
jle    11c8 <sortColors+0xb8>
lea    (%r15,%r14,4),%rax
lea    0x4(%r15),%rcx
cmp    %rcx,%rax
cmova  %rax,%rcx
mov    %r15,%rax
not    %rax
lea    (%rcx,%rax,1),%r13
and    $0xfffffffffffffffc,%r13
lea    (%rcx,%rax,1),%rdx
add    $0x4,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %r15,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
lea    (%r15,%r13,1),%rax
add    $0x4,%rax
jmp    11cb <sortColors+0xbb>
xor    %r14d,%r14d
mov    %r15,%r12
xor    %ebp,%ebp
xor    %ebx,%ebx
mov    %r15,%rax
movslq %ebx,%r9
lea    (%r12,%r9,4),%rdx
cmp    %rdx,%rax
jae    12ff <sortColors+0x1ef>
lea    0x4(%rax),%rcx
cmp    %rcx,%rdx
cmova  %rdx,%rcx
mov    %rax,%rsi
not    %rsi
add    %rcx,%rsi
cmp    $0x1c,%rsi
jb     12f0 <sortColors+0x1e0>
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rsi,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%edi
and    $0x7,%edi
cmp    $0x38,%rcx
jae    1229 <sortColors+0x119>
xor    %ecx,%ecx
jmp    12b1 <sortColors+0x1a1>
and    $0xfffffffffffffff8,%rbx
xor    %ecx,%ecx
movaps 0xdca(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
movups %xmm0,(%rax,%rcx,4)
movups %xmm0,0x10(%rax,%rcx,4)
movups %xmm0,0x20(%rax,%rcx,4)
movups %xmm0,0x30(%rax,%rcx,4)
movups %xmm0,0x40(%rax,%rcx,4)
movups %xmm0,0x50(%rax,%rcx,4)
movups %xmm0,0x60(%rax,%rcx,4)
movups %xmm0,0x70(%rax,%rcx,4)
movups %xmm0,0x80(%rax,%rcx,4)
movups %xmm0,0x90(%rax,%rcx,4)
movups %xmm0,0xa0(%rax,%rcx,4)
movups %xmm0,0xb0(%rax,%rcx,4)
movups %xmm0,0xc0(%rax,%rcx,4)
movups %xmm0,0xd0(%rax,%rcx,4)
movups %xmm0,0xe0(%rax,%rcx,4)
movups %xmm0,0xf0(%rax,%rcx,4)
add    $0x40,%rcx
add    $0xfffffffffffffff8,%rbx
jne    1240 <sortColors+0x130>
test   %rdi,%rdi
je     12e2 <sortColors+0x1d2>
lea    (%rax,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rdi
xor    %ebx,%ebx
movaps 0xd35(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movups %xmm0,-0x10(%rcx,%rbx,1)
movups %xmm0,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rdi
jne    12d0 <sortColors+0x1c0>
lea    (%rax,%r8,4),%rax
cmp    %r8,%rsi
je     12ff <sortColors+0x1ef>
nopl   0x0(%rax,%rax,1)
movl   $0x1,(%rax)
add    $0x4,%rax
cmp    %rdx,%rax
jb     12f0 <sortColors+0x1e0>
movslq %ebp,%rcx
lea    (%r15,%rcx,4),%rdx
lea    (%rdx,%r14,4),%rdx
lea    (%rdx,%r9,4),%rdx
cmp    %rdx,%rax
jae    143f <sortColors+0x32f>
lea    (%r15,%r14,4),%rsi
lea    (%rsi,%rcx,4),%rcx
lea    (%rcx,%r9,4),%rcx
lea    0x4(%rax),%rsi
cmp    %rsi,%rcx
cmova  %rcx,%rsi
mov    %rax,%rcx
not    %rcx
add    %rsi,%rcx
cmp    $0x1c,%rcx
jb     1430 <sortColors+0x320>
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,%rsi
and    $0xfffffffffffffff8,%rsi
lea    -0x8(%rsi),%rbx
mov    %rbx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebp
and    $0x7,%ebp
cmp    $0x38,%rbx
jae    1371 <sortColors+0x261>
xor    %ebx,%ebx
jmp    13f1 <sortColors+0x2e1>
and    $0xfffffffffffffff8,%rdi
xor    %ebx,%ebx
movaps 0xc92(%rip),%xmm0
xchg   %ax,%ax
movups %xmm0,(%rax,%rbx,4)
movups %xmm0,0x10(%rax,%rbx,4)
movups %xmm0,0x20(%rax,%rbx,4)
movups %xmm0,0x30(%rax,%rbx,4)
movups %xmm0,0x40(%rax,%rbx,4)
movups %xmm0,0x50(%rax,%rbx,4)
movups %xmm0,0x60(%rax,%rbx,4)
movups %xmm0,0x70(%rax,%rbx,4)
movups %xmm0,0x80(%rax,%rbx,4)
movups %xmm0,0x90(%rax,%rbx,4)
movups %xmm0,0xa0(%rax,%rbx,4)
movups %xmm0,0xb0(%rax,%rbx,4)
movups %xmm0,0xc0(%rax,%rbx,4)
movups %xmm0,0xd0(%rax,%rbx,4)
movups %xmm0,0xe0(%rax,%rbx,4)
movups %xmm0,0xf0(%rax,%rbx,4)
add    $0x40,%rbx
add    $0xfffffffffffffff8,%rdi
jne    1380 <sortColors+0x270>
test   %rbp,%rbp
je     1422 <sortColors+0x312>
lea    (%rax,%rbx,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rbp
xor    %ebx,%ebx
movaps 0xc05(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm0,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rbp
jne    1410 <sortColors+0x300>
cmp    %rsi,%rcx
je     143f <sortColors+0x32f>
lea    (%rax,%rsi,4),%rax
nopl   0x0(%rax,%rax,1)
movl   $0x2,(%rax)
add    $0x4,%rax
cmp    %rdx,%rax
jb     1430 <sortColors+0x320>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @sortColors(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*
store i32* %0, i32** %3
store i32 %1, i32* %4
store i32 0, i32* %5
store i32 0, i32* %6
store i32 0, i32* %7
%10 = load i32*, i32** %3
store i32* %10, i32** %8
br label %11
11: ; preds = %32, %2
%12 = load i32*, i32** %8
%13 = load i32*, i32** %3
%14 = load i32, i32* %4
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i32, i32* %13, i64 %15
%17 = icmp ult i32* %12, %16
br i1 %17, label %18, label %35
18: ; preds = %11
%19 = load i32*, i32** %8
%20 = load i32, i32* %19
switch i32 %20, label %30 [
i32 0, label %21
i32 1, label %24
i32 2, label %27
]
21: ; preds = %18
%22 = load i32, i32* %5
%23 = add nsw i32 %22, 1
store i32 %23, i32* %5
br label %31
24: ; preds = %18
%25 = load i32, i32* %6
%26 = add nsw i32 %25, 1
store i32 %26, i32* %6
br label %31
27: ; preds = %18
%28 = load i32, i32* %7
%29 = add nsw i32 %28, 1
store i32 %29, i32* %7
br label %31
30: ; preds = %18
br label %31
31: ; preds = %30, %27, %24, %21
br label %32
32: ; preds = %31
%33 = load i32*, i32** %8
%34 = getelementptr inbounds i32, i32* %33, i32 1
store i32* %34, i32** %8
br label %11
35: ; preds = %11
%36 = load i32*, i32** %3
store i32* %36, i32** %9
br label %37
37: ; preds = %46, %35
%38 = load i32*, i32** %9
%39 = load i32*, i32** %3
%40 = load i32, i32* %5
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i32, i32* %39, i64 %41
%43 = icmp ult i32* %38, %42
br i1 %43, label %44, label %49
44: ; preds = %37
%45 = load i32*, i32** %9
store i32 0, i32* %45
br label %46
46: ; preds = %44
%47 = load i32*, i32** %9
%48 = getelementptr inbounds i32, i32* %47, i32 1
store i32* %48, i32** %9
br label %37
49: ; preds = %37
br label %50
50: ; preds = %62, %49
%51 = load i32*, i32** %9
%52 = load i32*, i32** %3
%53 = load i32, i32* %5
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i32, i32* %52, i64 %54
%56 = load i32, i32* %6
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %55, i64 %57
%59 = icmp ult i32* %51, %58
br i1 %59, label %60, label %65
60: ; preds = %50
%61 = load i32*, i32** %9
store i32 1, i32* %61
br label %62
62: ; preds = %60
%63 = load i32*, i32** %9
%64 = getelementptr inbounds i32, i32* %63, i32 1
store i32* %64, i32** %9
br label %50
65: ; preds = %50
br label %66
66: ; preds = %81, %65
%67 = load i32*, i32** %9
%68 = load i32*, i32** %3
%69 = load i32, i32* %7
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i32, i32* %68, i64 %70
%72 = load i32, i32* %5
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %71, i64 %73
%75 = load i32, i32* %6
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i32, i32* %74, i64 %76
%78 = icmp ult i32* %67, %77
br i1 %78, label %79, label %84
79: ; preds = %66
%80 = load i32*, i32** %9
store i32 2, i32* %80
br label %81
81: ; preds = %79
%82 = load i32*, i32** %9
%83 = getelementptr inbounds i32, i32* %82, i32 1
store i32* %83, i32** %9
br label %66
84: ; preds = %66
ret void
}

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