#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*/ printf(char *, int);
int main() {
  int a[20] = {0, 1, 0, 2, 0, 0, 1, 1, 0, 2, 2, 2, 1, 2, 0, 2, 0, 2, 0, 1};
  int ac = 0;
  int b = 0;
  int c = 0;
  int i = 0;
  int temp = 0;
  int temp1 = 0;
  for (i = 0; i < 20; i++) {
    if (a[i] == 0) {
      ac++;
    } else if (a[i] == 1) {
      b++;
    } else {
      c++;
    }
  }
  for (i = 0; i < ac; i++) {
    a[i] = 0;
  }
  temp = ac + b;
  temp1 = ac + b + c;
  for (i = ac; i < temp; i++) {
    a[i] = 1;
  }
  for (i = temp; i < temp1; i++) {
    a[i] = 2;
  }
  for (i = 0; i < 20; i++) {
    printf("%d\t", a[i]);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x60(%rbp),%rdi
lea    0xec3(%rip),%rsi
mov    $0x50,%edx
call   1040 <memcpy@plt>
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x78(%rbp)
movl   $0x0,-0x70(%rbp)
cmpl   $0x14,-0x70(%rbp)
jge    11dd <main+0xbd>
movslq -0x70(%rbp),%rax
cmpl   $0x0,-0x60(%rbp,%rax,4)
jne    119f <main+0x7f>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    11ca <main+0xaa>
movslq -0x70(%rbp),%rax
cmpl   $0x1,-0x60(%rbp,%rax,4)
jne    11bc <main+0x9c>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    11c5 <main+0xa5>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    11ca <main+0xaa>
jmp    11cf <main+0xaf>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1178 <main+0x58>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    120a <main+0xea>
movslq -0x70(%rbp),%rax
movl   $0x0,-0x60(%rbp,%rax,4)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    11e4 <main+0xc4>
mov    -0x64(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x64(%rbp),%eax
add    -0x68(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    124b <main+0x12b>
movslq -0x70(%rbp),%rax
movl   $0x1,-0x60(%rbp,%rax,4)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1225 <main+0x105>
mov    -0x74(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1277 <main+0x157>
movslq -0x70(%rbp),%rax
movl   $0x2,-0x60(%rbp,%rax,4)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1251 <main+0x131>
movl   $0x0,-0x70(%rbp)
cmpl   $0x14,-0x70(%rbp)
jge    12aa <main+0x18a>
movslq -0x70(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%esi
lea    0xdb9(%rip),%rdi
call   1030 <printf@plt>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    127e <main+0x15e>
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r14
push   %rbx
sub    $0x50,%rsp
movaps 0xf31(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0xf15(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xef9(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xedd(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xec1(%rip),%xmm0
movaps %xmm0,(%rsp)
xor    %ecx,%ecx
mov    $0x2,%eax
xor    %r14d,%r14d
xor    %ebp,%ebp
xor    %ebx,%ebx
cmp    $0x1,%ecx
je     1190 <main+0x70>
cs nopw 0x0(%rax,%rax,1)
test   %ecx,%ecx
jne    11a0 <main+0x80>
add    $0x1,%ebx
jmp    11a4 <main+0x84>
nopl   0x0(%rax)
add    $0x1,%ebp
jmp    11a4 <main+0x84>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r14d
mov    -0x4(%rsp,%rax,4),%ecx
test   %ecx,%ecx
je     11c0 <main+0xa0>
cmp    $0x1,%ecx
jne    11d0 <main+0xb0>
add    $0x1,%ebp
cmp    $0x14,%rax
jne    11da <main+0xba>
jmp    11e8 <main+0xc8>
nopl   0x0(%rax)
add    $0x1,%ebx
cmp    $0x14,%rax
jne    11da <main+0xba>
jmp    11e8 <main+0xc8>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14d
cmp    $0x14,%rax
je     11e8 <main+0xc8>
mov    (%rsp,%rax,4),%ecx
add    $0x2,%rax
cmp    $0x1,%ecx
jne    1180 <main+0x60>
jmp    1190 <main+0x70>
test   %ebx,%ebx
jle    11fc <main+0xdc>
mov    %ebx,%edx
shl    $0x2,%rdx
mov    %rsp,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
lea    (%rbx,%rbp,1),%r9d
test   %ebp,%ebp
jle    12e0 <main+0x1c0>
movslq %ebx,%rcx
movslq %r9d,%rdx
lea    0x1(%rcx),%rsi
cmp    %rdx,%rsi
cmovle %rdx,%rsi
sub    %rcx,%rsi
cmp    $0x8,%rsi
jb     12d0 <main+0x1b0>
mov    %rsi,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %ebp,%ebx
and    $0x3,%ebx
cmp    $0x18,%rax
jae    124b <main+0x12b>
xor    %edi,%edi
jmp    1291 <main+0x171>
and    $0xfffffffffffffffc,%rbp
lea    (%rsp,%rcx,4),%rax
add    $0x70,%rax
xor    %edi,%edi
movaps 0xda0(%rip),%xmm0
movups %xmm0,-0x70(%rax,%rdi,4)
movups %xmm0,-0x60(%rax,%rdi,4)
movups %xmm0,-0x50(%rax,%rdi,4)
movups %xmm0,-0x40(%rax,%rdi,4)
movups %xmm0,-0x30(%rax,%rdi,4)
movups %xmm0,-0x20(%rax,%rdi,4)
movups %xmm0,-0x10(%rax,%rdi,4)
movups %xmm0,(%rax,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rbp
jne    1260 <main+0x140>
test   %rbx,%rbx
je     12c2 <main+0x1a2>
add    %rcx,%rdi
lea    (%rsp,%rdi,4),%rax
add    $0x10,%rax
shl    $0x5,%rbx
xor    %edi,%edi
movaps 0xd52(%rip),%xmm0
xchg   %ax,%ax
movups %xmm0,-0x10(%rax,%rdi,1)
movups %xmm0,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rbx
jne    12b0 <main+0x190>
cmp    %r8,%rsi
je     12e0 <main+0x1c0>
add    %r8,%rcx
nopw   0x0(%rax,%rax,1)
movl   $0x1,(%rsp,%rcx,4)
add    $0x1,%rcx
cmp    %rdx,%rcx
jl     12d0 <main+0x1b0>
test   %r14d,%r14d
jle    13d0 <main+0x2b0>
add    %r9d,%r14d
movslq %r9d,%rax
movslq %r14d,%rcx
lea    0x1(%rax),%rdx
cmp    %rcx,%rdx
cmovle %rcx,%rdx
sub    %rax,%rdx
cmp    $0x8,%rdx
jb     13c0 <main+0x2a0>
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rsi
jae    132f <main+0x20f>
xor    %ebx,%ebx
jmp    1381 <main+0x261>
and    $0xfffffffffffffffc,%rdi
lea    (%rsp,%rax,4),%rsi
add    $0x70,%rsi
xor    %ebx,%ebx
movaps 0xccc(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups %xmm0,-0x70(%rsi,%rbx,4)
movups %xmm0,-0x60(%rsi,%rbx,4)
movups %xmm0,-0x50(%rsi,%rbx,4)
movups %xmm0,-0x40(%rsi,%rbx,4)
movups %xmm0,-0x30(%rsi,%rbx,4)
movups %xmm0,-0x20(%rsi,%rbx,4)
movups %xmm0,-0x10(%rsi,%rbx,4)
movups %xmm0,(%rsi,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1350 <main+0x230>
test   %rbp,%rbp
je     13b2 <main+0x292>
add    %rax,%rbx
lea    (%rsp,%rbx,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rbp
xor    %edi,%edi
movaps 0xc72(%rip),%xmm0
xchg   %ax,%ax
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    13a0 <main+0x280>
cmp    %r8,%rdx
je     13d0 <main+0x2b0>
add    %r8,%rax
nopw   0x0(%rax,%rax,1)
movl   $0x2,(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rcx,%rax
jl     13c0 <main+0x2a0>
mov    (%rsp),%esi
lea    0xc96(%rip),%rbx
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x4(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x8(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0xc(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x10(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x14(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x18(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x1c(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x20(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x24(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x28(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x2c(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x30(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x34(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x38(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x3c(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x40(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x44(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x48(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
mov    0x4c(%rsp),%esi
mov    %rbx,%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
@__const.main.a = [20 x i32] [i32 0, i32 1, i32 0, i32 2, i32 0, i32 0, i32 1, i32 1, i32 0, i32 2, i32 2, i32 2, i32 1, i32 2, i32 0, i32 2, i32 0, i32 2, i32 0, i32 1]
@.str = [4 x i8] c"%d\09\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [20 x i32]
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32 0, i32* %1
%9 = bitcast [20 x i32]* %2 to i8*
store i32 0, i32* %3
store i32 0, i32* %4
store i32 0, i32* %5
store i32 0, i32* %6
store i32 0, i32* %7
store i32 0, i32* %8
store i32 0, i32* %6
br label %10
10: ; preds = %36, %0
%11 = load i32, i32* %6
%12 = icmp slt i32 %11, 20
br i1 %12, label %13, label %39
13: ; preds = %10
%14 = load i32, i32* %6
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %15
%17 = load i32, i32* %16
%18 = icmp eq i32 %17, 0
br i1 %18, label %19, label %22
19: ; preds = %13
%20 = load i32, i32* %3
%21 = add nsw i32 %20, 1
store i32 %21, i32* %3
br label %35
22: ; preds = %13
%23 = load i32, i32* %6
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %24
%26 = load i32, i32* %25
%27 = icmp eq i32 %26, 1
br i1 %27, label %28, label %31
28: ; preds = %22
%29 = load i32, i32* %4
%30 = add nsw i32 %29, 1
store i32 %30, i32* %4
br label %34
31: ; preds = %22
%32 = load i32, i32* %5
%33 = add nsw i32 %32, 1
store i32 %33, i32* %5
br label %34
34: ; preds = %31, %28
br label %35
35: ; preds = %34, %19
br label %36
36: ; preds = %35
%37 = load i32, i32* %6
%38 = add nsw i32 %37, 1
store i32 %38, i32* %6
br label %10
39: ; preds = %10
store i32 0, i32* %6
br label %40
40: ; preds = %48, %39
%41 = load i32, i32* %6
%42 = load i32, i32* %3
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %51
44: ; preds = %40
%45 = load i32, i32* %6
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %46
store i32 0, i32* %47
br label %48
48: ; preds = %44
%49 = load i32, i32* %6
%50 = add nsw i32 %49, 1
store i32 %50, i32* %6
br label %40
51: ; preds = %40
%52 = load i32, i32* %3
%53 = load i32, i32* %4
%54 = add nsw i32 %52, %53
store i32 %54, i32* %7
%55 = load i32, i32* %3
%56 = load i32, i32* %4
%57 = add nsw i32 %55, %56
%58 = load i32, i32* %5
%59 = add nsw i32 %57, %58
store i32 %59, i32* %8
%60 = load i32, i32* %3
store i32 %60, i32* %6
br label %61
61: ; preds = %69, %51
%62 = load i32, i32* %6
%63 = load i32, i32* %7
%64 = icmp slt i32 %62, %63
br i1 %64, label %65, label %72
65: ; preds = %61
%66 = load i32, i32* %6
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %67
store i32 1, i32* %68
br label %69
69: ; preds = %65
%70 = load i32, i32* %6
%71 = add nsw i32 %70, 1
store i32 %71, i32* %6
br label %61
72: ; preds = %61
%73 = load i32, i32* %7
store i32 %73, i32* %6
br label %74
74: ; preds = %82, %72
%75 = load i32, i32* %6
%76 = load i32, i32* %8
%77 = icmp slt i32 %75, %76
br i1 %77, label %78, label %85
78: ; preds = %74
%79 = load i32, i32* %6
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %80
store i32 2, i32* %81
br label %82
82: ; preds = %78
%83 = load i32, i32* %6
%84 = add nsw i32 %83, 1
store i32 %84, i32* %6
br label %74
85: ; preds = %74
store i32 0, i32* %6
br label %86
86: ; preds = %95, %85
%87 = load i32, i32* %6
%88 = icmp slt i32 %87, 20
br i1 %88, label %89, label %98
89: ; preds = %86
%90 = load i32, i32* %6
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [20 x i32], [20 x i32]* %2, i64 0, i64 %91
%93 = load i32, i32* %92
%94 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %93)
br label %95
95: ; preds = %89
%96 = load i32, i32* %6
%97 = add nsw i32 %96, 1
store i32 %97, i32* %6
br label %86
98: ; preds = %86
ret i32 0
}

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