void CountSort(int *A, int n) {
  int maxValue = A[0];
  for (int i = 0; i < n; i++)
    maxValue = (maxValue > A[i]) ? (maxValue) : A[i];
  int B[maxValue + 1];
  for (int i = 0; i < maxValue + 1; i++)
    B[i] = 0;
  for (int i = 0; i < n; i++)
    B[A[i]]++;
  int C[maxValue + 1];
  C[0] = B[0];
  for (int i = 1; i < maxValue + 1; i++)
    C[i] = C[i - 1] + B[i];
  for (int i = maxValue; i >= 0; i--) {
    while (C[i]) {
      A[C[i] - 1] = i;
      C[i]--;
    }
  }
}


x86 assembly (clang, -O0):
<CountSort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    116c <CountSort+0x6c>
mov    -0x10(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    114a <CountSort+0x4a>
mov    -0x10(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1158 <CountSort+0x58>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    111f <CountSort+0x1f>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    11cb <CountSort+0xcb>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    119d <CountSort+0x9d>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1205 <CountSort+0x105>
mov    -0x50(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11d2 <CountSort+0xd2>
mov    -0x50(%rbp),%rcx
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,%edx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rax
sub    %rsi,%rax
mov    %rax,-0x58(%rbp)
mov    %rax,%rsp
mov    %rdx,-0x38(%rbp)
mov    (%rcx),%ecx
mov    %ecx,(%rax)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    127a <CountSort+0x17a>
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rax,%rdx,4),%edx
movslq -0x3c(%rbp),%rsi
add    (%rcx,%rsi,4),%edx
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1239 <CountSort+0x139>
mov    -0x10(%rbp),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     12e1 <CountSort+0x1e1>
jmp    128f <CountSort+0x18f>
mov    -0x58(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     12ce <CountSort+0x1ce>
mov    -0x58(%rbp),%rax
mov    -0x40(%rbp),%esi
mov    -0x8(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rax,%rdx,4),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    %esi,(%rcx,%rdx,4)
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
jmp    128f <CountSort+0x18f>
jmp    12d3 <CountSort+0x1d3>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1280 <CountSort+0x180>
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CountSort>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %esi,%r9d
mov    %rdi,%r12
mov    (%rdi),%r10d
mov    %esi,%r8d
mov    %r10d,%r14d
test   %esi,%esi
jle    12c7 <CountSort+0x1b7>
mov    %r10d,%r14d
cmp    $0x1,%r9d
je     12c7 <CountSort+0x1b7>
lea    -0x1(%r8),%rcx
mov    $0x1,%eax
mov    %r10d,%r14d
cmp    $0x8,%rcx
jb     12ac <CountSort+0x19c>
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
movd   %r10d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     15a1 <CountSort+0x491>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
and    %rdx,%rdi
xor    %esi,%esi
movdqa %xmm0,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu 0x4(%r12,%rsi,4),%xmm2
movdqu 0x14(%r12,%rsi,4),%xmm3
movdqu 0x24(%r12,%rsi,4),%xmm4
movdqu 0x34(%r12,%rsi,4),%xmm5
movdqa %xmm0,%xmm6
pcmpgtd %xmm2,%xmm6
pand   %xmm6,%xmm0
pandn  %xmm2,%xmm6
por    %xmm0,%xmm6
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm3,%xmm2
por    %xmm1,%xmm2
movdqa %xmm6,%xmm0
pcmpgtd %xmm4,%xmm0
pand   %xmm0,%xmm6
pandn  %xmm4,%xmm0
por    %xmm6,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm5,%xmm1
por    %xmm2,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    11a0 <CountSort+0x90>
test   $0x1,%dl
je     1258 <CountSort+0x148>
shl    $0x2,%rsi
or     $0x4,%rsi
movdqu (%r12,%rsi,1),%xmm2
movdqu 0x10(%r12,%rsi,1),%xmm3
movdqa %xmm0,%xmm4
pcmpgtd %xmm2,%xmm4
pand   %xmm4,%xmm0
pandn  %xmm2,%xmm4
por    %xmm4,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm3,%xmm2
por    %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%r14d
cmp    %rax,%rcx
je     12c7 <CountSort+0x1b7>
or     $0x1,%rax
mov    %r14d,%ecx
nop
mov    (%r12,%rax,4),%r14d
cmp    %r14d,%ecx
cmovg  %ecx,%r14d
add    $0x1,%rax
mov    %r14d,%ecx
cmp    %rax,%r8
jne    12b0 <CountSort+0x1a0>
lea    0x1(%r14),%eax
mov    %rsp,%r15
mov    %rax,-0x40(%rbp)
lea    0xf(,%rax,4),%r13
and    $0xfffffffffffffff0,%r13
sub    %r13,%r15
mov    %r15,%rsp
mov    %r14d,%ebx
test   %r14d,%r14d
js     1316 <CountSort+0x206>
lea    0x4(,%rbx,4),%rdx
mov    %r15,%rdi
xor    %esi,%esi
mov    %r8,-0x38(%rbp)
mov    %r9d,-0x30(%rbp)
mov    %r10d,-0x2c(%rbp)
call   1030 <memset@plt>
mov    -0x2c(%rbp),%r10d
mov    -0x30(%rbp),%r9d
mov    -0x38(%rbp),%r8
test   %r9d,%r9d
jle    13a2 <CountSort+0x292>
movslq %r10d,%rax
addl   $0x1,(%r15,%rax,4)
cmp    $0x1,%r9d
je     13a2 <CountSort+0x292>
lea    -0x1(%r8),%rcx
add    $0xfffffffffffffffe,%r8
mov    %ecx,%eax
and    $0x3,%eax
mov    $0x1,%edx
cmp    $0x3,%r8
jb     1385 <CountSort+0x275>
and    $0xfffffffffffffffc,%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movslq 0x4(%r12,%rdx,4),%rsi
addl   $0x1,(%r15,%rsi,4)
movslq 0x8(%r12,%rdx,4),%rsi
addl   $0x1,(%r15,%rsi,4)
movslq 0xc(%r12,%rdx,4),%rsi
addl   $0x1,(%r15,%rsi,4)
movslq 0x10(%r12,%rdx,4),%rsi
addl   $0x1,(%r15,%rsi,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1350 <CountSort+0x240>
add    $0x1,%rdx
test   %rax,%rax
je     13a2 <CountSort+0x292>
lea    (%r12,%rdx,4),%rcx
xor    %edx,%edx
movslq (%rcx,%rdx,4),%rsi
addl   $0x1,(%r15,%rsi,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1390 <CountSort+0x280>
mov    %rsp,%rax
mov    %rax,%r11
sub    %r13,%r11
mov    %r11,%rsp
neg    %r13
mov    (%r15),%ecx
mov    %ecx,(%rax,%r13,1)
test   %r14d,%r14d
jle    144f <CountSort+0x33f>
mov    -0x40(%rbp),%rax
lea    -0x1(%rax),%rdi
add    $0xfffffffffffffffe,%rax
mov    %edi,%edx
and    $0x3,%edx
mov    $0x1,%esi
cmp    $0x3,%rax
jb     1425 <CountSort+0x315>
and    $0xfffffffffffffffc,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    0x4(%r15,%rsi,4),%ecx
mov    %ecx,0x4(%r11,%rsi,4)
add    0x8(%r15,%rsi,4),%ecx
mov    %ecx,0x8(%r11,%rsi,4)
add    0xc(%r15,%rsi,4),%ecx
mov    %ecx,0xc(%r11,%rsi,4)
add    0x10(%r15,%rsi,4),%ecx
mov    %ecx,0x10(%r11,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    13f0 <CountSort+0x2e0>
add    $0x1,%rsi
test   %rdx,%rdx
je     144f <CountSort+0x33f>
lea    (%r11,%rsi,4),%rax
lea    (%r15,%rsi,4),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    (%rsi,%rdi,4),%ecx
mov    %ecx,(%rax,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1440 <CountSort+0x330>
test   %r14d,%r14d
js     1592 <CountSort+0x482>
movabs $0x3ffffffffffffffc,%r8
ff ff 3f
lea    -0x10(%r12),%r9
jmp    1488 <CountSort+0x378>
nopl   0x0(%rax)
movl   $0x0,(%r11,%rbx,4)
lea    -0x1(%rbx),%rax
test   %rbx,%rbx
mov    %rax,%rbx
jle    1592 <CountSort+0x482>
movslq (%r11,%rbx,4),%rsi
test   %rsi,%rsi
je     1470 <CountSort+0x360>
lea    -0x1(%rsi),%r14d
cmp    $0x7,%r14d
jb     1580 <CountSort+0x470>
add    $0x1,%r14
mov    %r14,%r10
and    $0xfffffffffffffff8,%r10
movd   %ebx,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r10),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rax
jae    14d9 <CountSort+0x3c9>
xor    %eax,%eax
test   %rcx,%rcx
jne    1531 <CountSort+0x421>
jmp    1567 <CountSort+0x457>
and    %r8,%rdx
lea    (%r9,%rsi,4),%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu %xmm0,(%rdi,%rax,4)
movdqu %xmm0,-0x10(%rdi,%rax,4)
movdqu %xmm0,-0x20(%rdi,%rax,4)
movdqu %xmm0,-0x30(%rdi,%rax,4)
movdqu %xmm0,-0x40(%rdi,%rax,4)
movdqu %xmm0,-0x50(%rdi,%rax,4)
movdqu %xmm0,-0x60(%rdi,%rax,4)
movdqu %xmm0,-0x70(%rdi,%rax,4)
add    $0xffffffffffffffe0,%rax
add    $0xfffffffffffffffc,%rdx
jne    14f0 <CountSort+0x3e0>
neg    %rax
test   %rcx,%rcx
je     1567 <CountSort+0x457>
mov    %rsi,%rdx
sub    %rax,%rdx
lea    (%r9,%rdx,4),%rax
shl    $0x5,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,(%rax,%rdx,1)
movdqu %xmm0,-0x10(%rax,%rdx,1)
add    $0xffffffffffffffe0,%rdx
mov    %rcx,%rdi
add    %rdx,%rdi
jne    1550 <CountSort+0x440>
cmp    %r10,%r14
je     1470 <CountSort+0x360>
sub    %r10,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebx,-0x4(%r12,%rsi,4)
add    $0xffffffffffffffff,%rsi
test   %esi,%esi
jne    1580 <CountSort+0x470>
jmp    1470 <CountSort+0x360>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
movdqa %xmm0,%xmm1
test   $0x1,%dl
jne    121b <CountSort+0x10b>
jmp    1258 <CountSort+0x148>

LLVM IR (-O0):
define void @CountSort(i32* %0, i32 %1) {
%3 = alloca i32*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i64
%9 = alloca i32
%10 = alloca i32
%11 = alloca i64
%12 = alloca i32
%13 = alloca i32
store i32* %0, i32** %3
store i32 %1, i32* %4
%14 = load i32*, i32** %3
%15 = getelementptr inbounds i32, i32* %14, i64 0
%16 = load i32, i32* %15
store i32 %16, i32* %5
store i32 0, i32* %6
br label %17
17: ; preds = %39, %2
%18 = load i32, i32* %6
%19 = load i32, i32* %4
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %42
21: ; preds = %17
%22 = load i32, i32* %5
%23 = load i32*, i32** %3
%24 = load i32, i32* %6
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i32, i32* %23, i64 %25
%27 = load i32, i32* %26
%28 = icmp sgt i32 %22, %27
br i1 %28, label %29, label %31
29: ; preds = %21
%30 = load i32, i32* %5
br label %37
31: ; preds = %21
%32 = load i32*, i32** %3
%33 = load i32, i32* %6
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %32, i64 %34
%36 = load i32, i32* %35
br label %37
37: ; preds = %31, %29
%38 = phi i32 [ %30, %29 ], [ %36, %31 ]
store i32 %38, i32* %5
br label %39
39: ; preds = %37
%40 = load i32, i32* %6
%41 = add nsw i32 %40, 1
store i32 %41, i32* %6
br label %17
42: ; preds = %17
%43 = load i32, i32* %5
%44 = add nsw i32 %43, 1
%45 = zext i32 %44 to i64
%46 = call i8* @llvm.stacksave()
store i8* %46, i8** %7
%47 = alloca i32, i64 %45
store i64 %45, i64* %8
store i32 0, i32* %9
br label %48
48: ; preds = %57, %42
%49 = load i32, i32* %9
%50 = load i32, i32* %5
%51 = add nsw i32 %50, 1
%52 = icmp slt i32 %49, %51
br i1 %52, label %53, label %60
53: ; preds = %48
%54 = load i32, i32* %9
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i32, i32* %47, i64 %55
store i32 0, i32* %56
br label %57
57: ; preds = %53
%58 = load i32, i32* %9
%59 = add nsw i32 %58, 1
store i32 %59, i32* %9
br label %48
60: ; preds = %48
store i32 0, i32* %10
br label %61
61: ; preds = %75, %60
%62 = load i32, i32* %10
%63 = load i32, i32* %4
%64 = icmp slt i32 %62, %63
br i1 %64, label %65, label %78
65: ; preds = %61
%66 = load i32*, i32** %3
%67 = load i32, i32* %10
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %66, i64 %68
%70 = load i32, i32* %69
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i32, i32* %47, i64 %71
%73 = load i32, i32* %72
%74 = add nsw i32 %73, 1
store i32 %74, i32* %72
br label %75
75: ; preds = %65
%76 = load i32, i32* %10
%77 = add nsw i32 %76, 1
store i32 %77, i32* %10
br label %61
78: ; preds = %61
%79 = load i32, i32* %5
%80 = add nsw i32 %79, 1
%81 = zext i32 %80 to i64
%82 = alloca i32, i64 %81
store i64 %81, i64* %11
%83 = getelementptr inbounds i32, i32* %47, i64 0
%84 = load i32, i32* %83
%85 = getelementptr inbounds i32, i32* %82, i64 0
store i32 %84, i32* %85
store i32 1, i32* %12
br label %86
86: ; preds = %105, %78
%87 = load i32, i32* %12
%88 = load i32, i32* %5
%89 = add nsw i32 %88, 1
%90 = icmp slt i32 %87, %89
br i1 %90, label %91, label %108
91: ; preds = %86
%92 = load i32, i32* %12
%93 = sub nsw i32 %92, 1
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %82, i64 %94
%96 = load i32, i32* %95
%97 = load i32, i32* %12
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i32, i32* %47, i64 %98
%100 = load i32, i32* %99
%101 = add nsw i32 %96, %100
%102 = load i32, i32* %12
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i32, i32* %82, i64 %103
store i32 %101, i32* %104
br label %105
105: ; preds = %91
%106 = load i32, i32* %12
%107 = add nsw i32 %106, 1
store i32 %107, i32* %12
br label %86
108: ; preds = %86
%109 = load i32, i32* %5
store i32 %109, i32* %13
br label %110
110: ; preds = %136, %108
%111 = load i32, i32* %13
%112 = icmp sge i32 %111, 0
br i1 %112, label %113, label %139
113: ; preds = %110
br label %114
114: ; preds = %120, %113
%115 = load i32, i32* %13
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i32, i32* %82, i64 %116
%118 = load i32, i32* %117
%119 = icmp ne i32 %118, 0
br i1 %119, label %120, label %135
120: ; preds = %114
%121 = load i32, i32* %13
%122 = load i32*, i32** %3
%123 = load i32, i32* %13
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i32, i32* %82, i64 %124
%126 = load i32, i32* %125
%127 = sub nsw i32 %126, 1
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %122, i64 %128
store i32 %121, i32* %129
%130 = load i32, i32* %13
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i32, i32* %82, i64 %131
%133 = load i32, i32* %132
%134 = add nsw i32 %133, -1
store i32 %134, i32* %132
br label %114
135: ; preds = %114
br label %136
136: ; preds = %135
%137 = load i32, i32* %13
%138 = add nsw i32 %137, -1
store i32 %138, i32* %13
br label %110
139: ; preds = %110
%140 = load i8*, i8** %7
ret void
}

LLVM IR (-O2):
define void @CountSort(i32* nocapture %0, i32 %1) {
%3 = load i32, i32* %0
%4 = icmp sgt i32 %1, 0
br i1 %4, label %5, label %82
5: ; preds = %2
%6 = zext i32 %1 to i64
%7 = icmp eq i32 %1, 1
br i1 %7, label %82, label %8
8: ; preds = %5
%9 = add nsw i64 %6, -1
%10 = icmp ult i64 %9, 8
br i1 %10, label %79, label %11
11: ; preds = %8
%12 = and i64 %9, -8
%13 = or i64 %12, 1
%14 = insertelement <4 x i32> poison, i32 %3, i64 0
%15 = shufflevector <4 x i32> %14, <4 x i32> poison, <4 x i32> zeroinitializer
%16 = add nsw i64 %12, -8
%17 = lshr exact i64 %16, 3
%18 = add nuw nsw i64 %17, 1
%19 = and i64 %18, 1
%20 = icmp eq i64 %16, 0
br i1 %20, label %53, label %21
21: ; preds = %11
%22 = and i64 %18, 4611686018427387902
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %50, %23 ]
%25 = phi <4 x i32> [ %15, %21 ], [ %48, %23 ]
%26 = phi <4 x i32> [ %15, %21 ], [ %49, %23 ]
%27 = phi i64 [ 0, %21 ], [ %51, %23 ]
%28 = or i64 %24, 1
%29 = getelementptr inbounds i32, i32* %0, i64 %28
%30 = bitcast i32* %29 to <4 x i32>*
%31 = load <4 x i32>, <4 x i32>* %30
%32 = getelementptr inbounds i32, i32* %29, i64 4
%33 = bitcast i32* %32 to <4 x i32>*
%34 = load <4 x i32>, <4 x i32>* %33
%35 = icmp sgt <4 x i32> %25, %31
%36 = icmp sgt <4 x i32> %26, %34
%37 = select <4 x i1> %35, <4 x i32> %25, <4 x i32> %31
%38 = select <4 x i1> %36, <4 x i32> %26, <4 x i32> %34
%39 = or i64 %24, 9
%40 = getelementptr inbounds i32, i32* %0, i64 %39
%41 = bitcast i32* %40 to <4 x i32>*
%42 = load <4 x i32>, <4 x i32>* %41
%43 = getelementptr inbounds i32, i32* %40, i64 4
%44 = bitcast i32* %43 to <4 x i32>*
%45 = load <4 x i32>, <4 x i32>* %44
%46 = icmp sgt <4 x i32> %37, %42
%47 = icmp sgt <4 x i32> %38, %45
%48 = select <4 x i1> %46, <4 x i32> %37, <4 x i32> %42
%49 = select <4 x i1> %47, <4 x i32> %38, <4 x i32> %45
%50 = add nuw i64 %24, 16
%51 = add i64 %27, 2
%52 = icmp eq i64 %51, %22
br i1 %52, label %53, label %23
53: ; preds = %23, %11
%54 = phi <4 x i32> [ undef, %11 ], [ %48, %23 ]
%55 = phi <4 x i32> [ undef, %11 ], [ %49, %23 ]
%56 = phi i64 [ 0, %11 ], [ %50, %23 ]
%57 = phi <4 x i32> [ %15, %11 ], [ %48, %23 ]
%58 = phi <4 x i32> [ %15, %11 ], [ %49, %23 ]
%59 = icmp eq i64 %19, 0
br i1 %59, label %72, label %60
60: ; preds = %53
%61 = or i64 %56, 1
%62 = getelementptr inbounds i32, i32* %0, i64 %61
%63 = bitcast i32* %62 to <4 x i32>*
%64 = load <4 x i32>, <4 x i32>* %63
%65 = getelementptr inbounds i32, i32* %62, i64 4
%66 = bitcast i32* %65 to <4 x i32>*
%67 = load <4 x i32>, <4 x i32>* %66
%68 = icmp sgt <4 x i32> %57, %64
%69 = icmp sgt <4 x i32> %58, %67
%70 = select <4 x i1> %68, <4 x i32> %57, <4 x i32> %64
%71 = select <4 x i1> %69, <4 x i32> %58, <4 x i32> %67
br label %72
72: ; preds = %53, %60
%73 = phi <4 x i32> [ %54, %53 ], [ %70, %60 ]
%74 = phi <4 x i32> [ %55, %53 ], [ %71, %60 ]
%75 = icmp sgt <4 x i32> %73, %74
%76 = select <4 x i1> %75, <4 x i32> %73, <4 x i32> %74
%77 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %76)
%78 = icmp eq i64 %9, %12
br i1 %78, label %82, label %79
79: ; preds = %8, %72
%80 = phi i64 [ 1, %8 ], [ %13, %72 ]
%81 = phi i32 [ %3, %8 ], [ %77, %72 ]
br label %93
82: ; preds = %93, %5, %72, %2
%83 = phi i32 [ %3, %2 ], [ %3, %5 ], [ %77, %72 ], [ %99, %93 ]
%84 = add i32 %83, 1
%85 = zext i32 %84 to i64
%86 = alloca i32, i64 %85
%87 = icmp slt i32 %83, 0
br i1 %87, label %102, label %88
88: ; preds = %82
%89 = bitcast i32* %86 to i8*
%90 = zext i32 %83 to i64
%91 = shl nuw nsw i64 %90, 2
%92 = add nuw nsw i64 %91, 4
br label %102
93: ; preds = %79, %93
%94 = phi i64 [ %100, %93 ], [ %80, %79 ]
%95 = phi i32 [ %99, %93 ], [ %81, %79 ]
%96 = getelementptr inbounds i32, i32* %0, i64 %94
%97 = load i32, i32* %96
%98 = icmp sgt i32 %95, %97
%99 = select i1 %98, i32 %95, i32 %97
%100 = add nuw nsw i64 %94, 1
%101 = icmp eq i64 %100, %6
br i1 %101, label %82, label %93
102: ; preds = %88, %82
br i1 %4, label %103, label %132
103: ; preds = %102
%104 = zext i32 %1 to i64
%105 = sext i32 %3 to i64
%106 = getelementptr inbounds i32, i32* %86, i64 %105
%107 = load i32, i32* %106
%108 = add nsw i32 %107, 1
store i32 %108, i32* %106
%109 = icmp eq i32 %1, 1
br i1 %109, label %132, label %110
110: ; preds = %103
%111 = add nsw i64 %104, -1
%112 = add nsw i64 %104, -2
%113 = and i64 %111, 3
%114 = icmp ult i64 %112, 3
br i1 %114, label %117, label %115
115: ; preds = %110
%116 = and i64 %111, -4
br label %143
117: ; preds = %143, %110
%118 = phi i64 [ 1, %110 ], [ %173, %143 ]
%119 = icmp eq i64 %113, 0
br i1 %119, label %132, label %120
120: ; preds = %117, %120
%121 = phi i64 [ %129, %120 ], [ %118, %117 ]
%122 = phi i64 [ %130, %120 ], [ 0, %117 ]
%123 = getelementptr inbounds i32, i32* %0, i64 %121
%124 = load i32, i32* %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i32, i32* %86, i64 %125
%127 = load i32, i32* %126
%128 = add nsw i32 %127, 1
store i32 %128, i32* %126
%129 = add nuw nsw i64 %121, 1
%130 = add i64 %122, 1
%131 = icmp eq i64 %130, %113
br i1 %131, label %132, label %120
132: ; preds = %117, %120, %103, %102
%133 = alloca i32, i64 %85
%134 = load i32, i32* %86
store i32 %134, i32* %133
%135 = icmp slt i32 %83, 1
br i1 %135, label %191, label %136
136: ; preds = %132
%137 = add nsw i64 %85, -1
%138 = add nsw i64 %85, -2
%139 = and i64 %137, 3
%140 = icmp ult i64 %138, 3
br i1 %140, label %176, label %141
141: ; preds = %136
%142 = and i64 %137, -4
br label %195
143: ; preds = %143, %115
%144 = phi i64 [ 1, %115 ], [ %173, %143 ]
%145 = phi i64 [ 0, %115 ], [ %174, %143 ]
%146 = getelementptr inbounds i32, i32* %0, i64 %144
%147 = load i32, i32* %146
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %86, i64 %148
%150 = load i32, i32* %149
%151 = add nsw i32 %150, 1
store i32 %151, i32* %149
%152 = add nuw nsw i64 %144, 1
%153 = getelementptr inbounds i32, i32* %0, i64 %152
%154 = load i32, i32* %153
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %86, i64 %155
%157 = load i32, i32* %156
%158 = add nsw i32 %157, 1
store i32 %158, i32* %156
%159 = add nuw nsw i64 %144, 2
%160 = getelementptr inbounds i32, i32* %0, i64 %159
%161 = load i32, i32* %160
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i32, i32* %86, i64 %162
%164 = load i32, i32* %163
%165 = add nsw i32 %164, 1
store i32 %165, i32* %163
%166 = add nuw nsw i64 %144, 3
%167 = getelementptr inbounds i32, i32* %0, i64 %166
%168 = load i32, i32* %167
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i32, i32* %86, i64 %169
%171 = load i32, i32* %170
%172 = add nsw i32 %171, 1
store i32 %172, i32* %170
%173 = add nuw nsw i64 %144, 4
%174 = add i64 %145, 4
%175 = icmp eq i64 %174, %116
br i1 %175, label %117, label %143
176: ; preds = %195, %136
%177 = phi i32 [ %134, %136 ], [ %216, %195 ]
%178 = phi i64 [ 1, %136 ], [ %218, %195 ]
%179 = icmp eq i64 %139, 0
br i1 %179, label %191, label %180
180: ; preds = %176, %180
%181 = phi i32 [ %186, %180 ], [ %177, %176 ]
%182 = phi i64 [ %188, %180 ], [ %178, %176 ]
%183 = phi i64 [ %189, %180 ], [ 0, %176 ]
%184 = getelementptr inbounds i32, i32* %86, i64 %182
%185 = load i32, i32* %184
%186 = add nsw i32 %185, %181
%187 = getelementptr inbounds i32, i32* %133, i64 %182
store i32 %186, i32* %187
%188 = add nuw nsw i64 %182, 1
%189 = add i64 %183, 1
%190 = icmp eq i64 %189, %139
br i1 %190, label %191, label %180
191: ; preds = %176, %180, %132
%192 = icmp sgt i32 %83, -1
br i1 %192, label %193, label %306
193: ; preds = %191
%194 = zext i32 %83 to i64
br label %221
195: ; preds = %195, %141
%196 = phi i32 [ %134, %141 ], [ %216, %195 ]
%197 = phi i64 [ 1, %141 ], [ %218, %195 ]
%198 = phi i64 [ 0, %141 ], [ %219, %195 ]
%199 = getelementptr inbounds i32, i32* %86, i64 %197
%200 = load i32, i32* %199
%201 = add nsw i32 %200, %196
%202 = getelementptr inbounds i32, i32* %133, i64 %197
store i32 %201, i32* %202
%203 = add nuw nsw i64 %197, 1
%204 = getelementptr inbounds i32, i32* %86, i64 %203
%205 = load i32, i32* %204
%206 = add nsw i32 %205, %201
%207 = getelementptr inbounds i32, i32* %133, i64 %203
store i32 %206, i32* %207
%208 = add nuw nsw i64 %197, 2
%209 = getelementptr inbounds i32, i32* %86, i64 %208
%210 = load i32, i32* %209
%211 = add nsw i32 %210, %206
%212 = getelementptr inbounds i32, i32* %133, i64 %208
store i32 %211, i32* %212
%213 = add nuw nsw i64 %197, 3
%214 = getelementptr inbounds i32, i32* %86, i64 %213
%215 = load i32, i32* %214
%216 = add nsw i32 %215, %211
%217 = getelementptr inbounds i32, i32* %133, i64 %213
store i32 %216, i32* %217
%218 = add nuw nsw i64 %197, 4
%219 = add i64 %198, 4
%220 = icmp eq i64 %219, %142
br i1 %220, label %176, label %195
221: ; preds = %193, %313
%222 = phi i64 [ %194, %193 ], [ %314, %313 ]
%223 = getelementptr inbounds i32, i32* %133, i64 %222
%224 = load i32, i32* %223
%225 = icmp eq i32 %224, 0
br i1 %225, label %313, label %226
226: ; preds = %221
%227 = sext i32 %224 to i64
%228 = trunc i64 %222 to i32
%229 = add i32 %224, -1
%230 = zext i32 %229 to i64
%231 = add nuw nsw i64 %230, 1
%232 = icmp ult i32 %229, 7
br i1 %232, label %304, label %233
233: ; preds = %226
%234 = and i64 %231, 8589934584
%235 = sub nsw i64 %227, %234
%236 = insertelement <4 x i32> poison, i32 %228, i64 0
%237 = shufflevector <4 x i32> %236, <4 x i32> poison, <4 x i32> zeroinitializer
%238 = insertelement <4 x i32> poison, i32 %228, i64 0
%239 = shufflevector <4 x i32> %238, <4 x i32> poison, <4 x i32> zeroinitializer
%240 = add nsw i64 %234, -8
%241 = lshr exact i64 %240, 3
%242 = add nuw nsw i64 %241, 1
%243 = and i64 %242, 3
%244 = icmp ult i64 %240, 24
br i1 %244, label %285, label %245
245: ; preds = %233
%246 = and i64 %242, 4611686018427387900
br label %247
247: ; preds = %247, %245
%248 = phi i64 [ 0, %245 ], [ %282, %247 ]
%249 = phi i64 [ 0, %245 ], [ %283, %247 ]
%250 = xor i64 %248, -1
%251 = add i64 %250, %227
%252 = getelementptr inbounds i32, i32* %0, i64 %251
%253 = getelementptr inbounds i32, i32* %252, i64 -3
%254 = bitcast i32* %253 to <4 x i32>*
store <4 x i32> %237, <4 x i32>* %254
%255 = getelementptr inbounds i32, i32* %252, i64 -4
%256 = getelementptr inbounds i32, i32* %255, i64 -3
%257 = bitcast i32* %256 to <4 x i32>*
store <4 x i32> %239, <4 x i32>* %257
%258 = sub nuw nsw i64 -9, %248
%259 = add i64 %258, %227
%260 = getelementptr inbounds i32, i32* %0, i64 %259
%261 = getelementptr inbounds i32, i32* %260, i64 -3
%262 = bitcast i32* %261 to <4 x i32>*
store <4 x i32> %237, <4 x i32>* %262
%263 = getelementptr inbounds i32, i32* %260, i64 -4
%264 = getelementptr inbounds i32, i32* %263, i64 -3
%265 = bitcast i32* %264 to <4 x i32>*
store <4 x i32> %239, <4 x i32>* %265
%266 = sub nuw nsw i64 -17, %248
%267 = add i64 %266, %227
%268 = getelementptr inbounds i32, i32* %0, i64 %267
%269 = getelementptr inbounds i32, i32* %268, i64 -3
%270 = bitcast i32* %269 to <4 x i32>*
store <4 x i32> %237, <4 x i32>* %270
%271 = getelementptr inbounds i32, i32* %268, i64 -4
%272 = getelementptr inbounds i32, i32* %271, i64 -3
%273 = bitcast i32* %272 to <4 x i32>*
store <4 x i32> %239, <4 x i32>* %273
%274 = sub nuw nsw i64 -25, %248
%275 = add i64 %274, %227
%276 = getelementptr inbounds i32, i32* %0, i64 %275
%277 = getelementptr inbounds i32, i32* %276, i64 -3
%278 = bitcast i32* %277 to <4 x i32>*
store <4 x i32> %237, <4 x i32>* %278
%279 = getelementptr inbounds i32, i32* %276, i64 -4
%280 = getelementptr inbounds i32, i32* %279, i64 -3
%281 = bitcast i32* %280 to <4 x i32>*
store <4 x i32> %239, <4 x i32>* %281
%282 = add nuw i64 %248, 32
%283 = add i64 %249, 4
%284 = icmp eq i64 %283, %246
br i1 %284, label %285, label %247
285: ; preds = %247, %233
%286 = phi i64 [ 0, %233 ], [ %282, %247 ]
%287 = icmp eq i64 %243, 0
br i1 %287, label %302, label %288
288: ; preds = %285, %288
%289 = phi i64 [ %299, %288 ], [ %286, %285 ]
%290 = phi i64 [ %300, %288 ], [ 0, %285 ]
%291 = xor i64 %289, -1
%292 = add i64 %291, %227
%293 = getelementptr inbounds i32, i32* %0, i64 %292
%294 = getelementptr inbounds i32, i32* %293, i64 -3
%295 = bitcast i32* %294 to <4 x i32>*
store <4 x i32> %237, <4 x i32>* %295
%296 = getelementptr inbounds i32, i32* %293, i64 -4
%297 = getelementptr inbounds i32, i32* %296, i64 -3
%298 = bitcast i32* %297 to <4 x i32>*
store <4 x i32> %239, <4 x i32>* %298
%299 = add nuw i64 %289, 8
%300 = add i64 %290, 1
%301 = icmp eq i64 %300, %243
br i1 %301, label %302, label %288
302: ; preds = %288, %285
%303 = icmp eq i64 %231, %234
br i1 %303, label %313, label %304
304: ; preds = %226, %302
%305 = phi i64 [ %227, %226 ], [ %235, %302 ]
br label %307
306: ; preds = %313, %191
ret void
307: ; preds = %304, %307
%308 = phi i64 [ %309, %307 ], [ %305, %304 ]
%309 = add nsw i64 %308, -1
%310 = getelementptr inbounds i32, i32* %0, i64 %309
store i32 %228, i32* %310
%311 = trunc i64 %309 to i32
%312 = icmp eq i32 %311, 0
br i1 %312, label %313, label %307
313: ; preds = %307, %302, %221
store i32 0, i32* %223
%314 = add nsw i64 %222, -1
%315 = icmp sgt i64 %222, 0
br i1 %315, label %221, label %306
}