void sortColors(int *nums, int numsSize) {
  int cnts[3] = {0, 0, 0};
  int size = numsSize;
  for (int i = 0; i < size; i++) {
    cnts[nums[i]]++;
  }
  int idx = 0;
  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < cnts[i]; j++) {
      nums[idx++] = i;
    }
  }
  return;
}


x86 assembly (clang, -O0):
<sortColors>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
lea    -0x18(%rbp),%rdi
xor    %esi,%esi
mov    $0xc,%edx
call   1030 <memset@plt>
mov    -0xc(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    116d <sortColors+0x5d>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
mov    -0x18(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x18(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    113c <sortColors+0x2c>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    11d6 <sortColors+0xc6>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
movslq -0x28(%rbp),%rcx
cmp    -0x18(%rbp,%rcx,4),%eax
jge    11c3 <sortColors+0xb3>
mov    -0x28(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    118c <sortColors+0x7c>
jmp    11c8 <sortColors+0xb8>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    117b <sortColors+0x6b>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sortColors>:
push   %r14
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%r14
movl   $0x0,0x10(%rsp)
movq   $0x0,0x8(%rsp)
test   %esi,%esi
jle    11be <sortColors+0xae>
mov    %esi,%ecx
lea    -0x1(%rcx),%rdx
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    1148 <sortColors+0x38>
xor    %edx,%edx
jmp    1180 <sortColors+0x70>
and    $0xfffffffc,%ecx
xor    %edx,%edx
nopl   (%rax)
movslq (%r14,%rdx,4),%rsi
addl   $0x1,0x8(%rsp,%rsi,4)
movslq 0x4(%r14,%rdx,4),%rsi
addl   $0x1,0x8(%rsp,%rsi,4)
movslq 0x8(%r14,%rdx,4),%rsi
addl   $0x1,0x8(%rsp,%rsi,4)
movslq 0xc(%r14,%rdx,4),%rsi
addl   $0x1,0x8(%rsp,%rsi,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1150 <sortColors+0x40>
test   %rax,%rax
je     11a2 <sortColors+0x92>
lea    (%r14,%rdx,4),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movslq (%rcx,%rdx,4),%rsi
addl   $0x1,0x8(%rsp,%rsi,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1190 <sortColors+0x80>
mov    0x8(%rsp),%ebx
test   %ebx,%ebx
jle    11be <sortColors+0xae>
lea    0x0(,%rbx,4),%rdx
mov    %r14,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
jmp    11c0 <sortColors+0xb0>
xor    %ebx,%ebx
mov    0xc(%rsp),%eax
test   %eax,%eax
jle    12a1 <sortColors+0x191>
mov    %ebx,%ebx
lea    -0x1(%rax),%r8d
xor    %r9d,%r9d
cmp    $0x7,%r8d
jb     128a <sortColors+0x17a>
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rcx
jae    1208 <sortColors+0xf8>
xor    %edx,%edx
jmp    1251 <sortColors+0x141>
and    $0xfffffffffffffffc,%rdi
lea    (%r14,%rbx,4),%rcx
add    $0x70,%rcx
xor    %edx,%edx
movaps 0xde3(%rip),%xmm0
nopl   (%rax)
movups %xmm0,-0x70(%rcx,%rdx,4)
movups %xmm0,-0x60(%rcx,%rdx,4)
movups %xmm0,-0x50(%rcx,%rdx,4)
movups %xmm0,-0x40(%rcx,%rdx,4)
movups %xmm0,-0x30(%rcx,%rdx,4)
movups %xmm0,-0x20(%rcx,%rdx,4)
movups %xmm0,-0x10(%rcx,%rdx,4)
movups %xmm0,(%rcx,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1220 <sortColors+0x110>
test   %rsi,%rsi
je     1282 <sortColors+0x172>
add    %rbx,%rdx
lea    (%r14,%rdx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rsi
xor    %edx,%edx
movaps 0xd92(%rip),%xmm0
xchg   %ax,%ax
movups %xmm0,-0x10(%rcx,%rdx,1)
movups %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    1270 <sortColors+0x160>
add    %r9,%rbx
cmp    %r9,%r8
je     12a1 <sortColors+0x191>
sub    %r9d,%eax
nopl   (%rax)
movl   $0x1,(%r14,%rbx,4)
add    $0x1,%rbx
add    $0xffffffff,%eax
jne    1290 <sortColors+0x180>
mov    0x10(%rsp),%eax
test   %eax,%eax
jle    138f <sortColors+0x27f>
movslq %ebx,%r8
lea    -0x1(%rax),%r9d
xor    %edx,%edx
cmp    $0x7,%r9d
jb     136a <sortColors+0x25a>
add    $0x1,%r9
mov    %r9,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0x18,%rcx
jae    12e9 <sortColors+0x1d9>
xor    %ecx,%ecx
jmp    1331 <sortColors+0x221>
and    $0xfffffffffffffffc,%rdi
lea    (%r14,%r8,4),%rsi
add    $0x70,%rsi
xor    %ecx,%ecx
movaps 0xd12(%rip),%xmm0
xchg   %ax,%ax
movups %xmm0,-0x70(%rsi,%rcx,4)
movups %xmm0,-0x60(%rsi,%rcx,4)
movups %xmm0,-0x50(%rsi,%rcx,4)
movups %xmm0,-0x40(%rsi,%rcx,4)
movups %xmm0,-0x30(%rsi,%rcx,4)
movups %xmm0,-0x20(%rsi,%rcx,4)
movups %xmm0,-0x10(%rsi,%rcx,4)
movups %xmm0,(%rsi,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1300 <sortColors+0x1f0>
test   %rbx,%rbx
je     1362 <sortColors+0x252>
add    %r8,%rcx
lea    (%r14,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rbx
xor    %esi,%esi
movaps 0xcc2(%rip),%xmm0
xchg   %ax,%ax
movups %xmm0,-0x10(%rcx,%rsi,1)
movups %xmm0,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbx
jne    1350 <sortColors+0x240>
cmp    %rdx,%r9
je     138f <sortColors+0x27f>
add    %rdx,%r8
lea    (%r14,%r8,4),%rcx
sub    %edx,%eax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x2,(%rcx,%rdx,4)
add    $0x1,%rdx
cmp    %edx,%eax
jne    1380 <sortColors+0x270>
add    $0x18,%rsp
pop    %rbx
pop    %r14
ret

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

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