void _bucket_sort(int *vet, int s) {
  int i;
  int max = vet[0];
  int exp = 1;
  int sorted[s];
  for (i = 0; i < s; i++)
    if (vet[i] > max)
      max = vet[i];
  while (max / exp > 0) {
    int buckets[10] = {0};
    for (i = 0; i < s; i++)
      buckets[(vet[i] / exp) % 10]++;
    for (i = 1; i < 10; i++)
      buckets[i] += buckets[i - 1];
    for (i = s - 1; i >= 0; i--)
      sorted[--buckets[(vet[i] / exp) % 10]] = vet[i];
    for (i = 0; i < s; i++)
      vet[i] = sorted[i];
    exp *= 10;
  }
}


x86 assembly (clang, -O0):
<_bucket_sort>:
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,-0x14(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0xc(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    119e <_bucket_sort+0x8e>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x14(%rbp),%eax
jle    118b <_bucket_sort+0x7b>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x14(%rbp)
jmp    1190 <_bucket_sort+0x80>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    115d <_bucket_sort+0x4d>
jmp    11a3 <_bucket_sort+0x93>
mov    -0x14(%rbp),%eax
cltd
idivl  -0x18(%rbp)
cmp    $0x0,%eax
jle    12e6 <_bucket_sort+0x1d6>
lea    -0x50(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1030 <memset@plt>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1209 <_bucket_sort+0xf9>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cltd
idivl  -0x18(%rbp)
mov    $0xa,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
mov    -0x50(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11ca <_bucket_sort+0xba>
movl   $0x1,-0x10(%rbp)
cmpl   $0xa,-0x10(%rbp)
jge    1240 <_bucket_sort+0x130>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x50(%rbp,%rax,4),%ecx
movslq -0x10(%rbp),%rax
add    -0x50(%rbp,%rax,4),%ecx
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1210 <_bucket_sort+0x100>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jl     12a3 <_bucket_sort+0x193>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cltd
idivl  -0x18(%rbp)
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    -0x58(%rbp),%rax
mov    %edx,%ecx
mov    -0x5c(%rbp),%edx
movslq %ecx,%rsi
mov    -0x50(%rbp,%rsi,4),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x50(%rbp,%rsi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1249 <_bucket_sort+0x139>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12da <_bucket_sort+0x1ca>
mov    -0x58(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12aa <_bucket_sort+0x19a>
imul   $0xa,-0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    11a3 <_bucket_sort+0x93>
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_bucket_sort>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdi,%rbx
mov    (%rdi),%r12d
mov    %esi,%r13d
mov    %rsp,%r15
lea    0xf(,%r13,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    %esi,-0x2c(%rbp)
cmp    $0x2,%esi
jl     12c3 <_bucket_sort+0x1b3>
lea    -0x1(%r13),%rcx
mov    $0x1,%eax
cmp    $0x8,%rcx
jb     12b0 <_bucket_sort+0x1a0>
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
movd   %r12d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1478 <_bucket_sort+0x368>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0x1,%esi
movdqa %xmm0,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu (%rbx,%rsi,4),%xmm2
movdqu 0x10(%rbx,%rsi,4),%xmm3
movdqu 0x20(%rbx,%rsi,4),%xmm4
movdqu 0x30(%rbx,%rsi,4),%xmm5
movdqa %xmm2,%xmm6
pcmpgtd %xmm0,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm0,%xmm6
por    %xmm2,%xmm6
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
pcmpgtd %xmm6,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm6,%xmm0
por    %xmm4,%xmm0
movdqa %xmm5,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm2,%xmm1
por    %xmm5,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    11a0 <_bucket_sort+0x90>
test   $0x1,%dl
je     1251 <_bucket_sort+0x141>
movdqu (%rbx,%rsi,4),%xmm2
movdqu 0x10(%rbx,%rsi,4),%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %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,%r12d
cmp    %rax,%rcx
je     12c3 <_bucket_sort+0x1b3>
or     $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rax,4),%ecx
cmp    %r12d,%ecx
cmovg  %ecx,%r12d
add    $0x1,%rax
cmp    %rax,%r13
jne    12b0 <_bucket_sort+0x1a0>
test   %r12d,%r12d
jle    1469 <_bucket_sort+0x359>
lea    0x0(,%r13,4),%rax
mov    %rax,-0x68(%rbp)
lea    0x1(%r13),%rax
mov    %rax,-0x70(%rbp)
mov    $0x1,%r14d
pxor   %xmm0,%xmm0
jmp    1306 <_bucket_sort+0x1f6>
nopl   0x0(%rax)
add    %r14d,%r14d
lea    (%r14,%r14,4),%r14d
mov    %r12d,%eax
cltd
idiv   %r14d
test   %eax,%eax
jle    1469 <_bucket_sort+0x359>
movdqa %xmm0,-0x50(%rbp)
movdqa %xmm0,-0x60(%rbp)
movq   $0x0,-0x40(%rbp)
mov    $0x0,%r8d
mov    $0x0,%r9d
mov    $0x0,%r10d
mov    $0x0,%esi
mov    $0x0,%edi
mov    $0x0,%eax
mov    $0x0,%ecx
mov    $0x0,%edx
mov    $0x0,%r11d
cmpl   $0x0,-0x2c(%rbp)
jle    13b7 <_bucket_sort+0x2a7>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%eax
cltd
idiv   %r14d
cltq
imul   $0x66666667,%rax,%rdx
mov    %rdx,%rsi
shr    $0x3f,%rsi
sar    $0x22,%rdx
add    %esi,%edx
add    %edx,%edx
lea    (%rdx,%rdx,4),%edx
sub    %edx,%eax
cltq
addl   $0x1,-0x60(%rbp,%rax,4)
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1360 <_bucket_sort+0x250>
mov    -0x5c(%rbp),%r11d
mov    -0x58(%rbp),%edx
mov    -0x54(%rbp),%ecx
mov    -0x50(%rbp),%eax
mov    -0x4c(%rbp),%edi
mov    -0x48(%rbp),%esi
mov    -0x44(%rbp),%r10d
mov    -0x40(%rbp),%r9d
mov    -0x3c(%rbp),%r8d
add    -0x60(%rbp),%r11d
add    %r11d,%edx
add    %edx,%ecx
add    %ecx,%eax
add    %eax,%edi
add    %edi,%esi
add    %esi,%r10d
add    %r10d,%r9d
add    %r9d,%r8d
mov    %r11d,-0x5c(%rbp)
mov    %edx,-0x58(%rbp)
mov    %ecx,-0x54(%rbp)
mov    %eax,-0x50(%rbp)
mov    %edi,-0x4c(%rbp)
mov    %esi,-0x48(%rbp)
mov    %r10d,-0x44(%rbp)
mov    %r9d,-0x40(%rbp)
mov    %r8d,-0x3c(%rbp)
mov    -0x70(%rbp),%rsi
cmpl   $0x0,-0x2c(%rbp)
jle    12f0 <_bucket_sort+0x1e0>
nopl   0x0(%rax,%rax,1)
lea    -0x2(%rsi),%eax
mov    (%rbx,%rax,4),%ecx
mov    %ecx,%eax
cltd
idiv   %r14d
cltq
imul   $0x66666667,%rax,%rdx
mov    %rdx,%rdi
shr    $0x3f,%rdi
sar    $0x22,%rdx
add    %edi,%edx
add    %edx,%edx
lea    (%rdx,%rdx,4),%edx
sub    %edx,%eax
cltq
movslq -0x60(%rbp,%rax,4),%rdx
lea    -0x1(%rdx),%rdi
mov    %edi,-0x60(%rbp,%rax,4)
mov    %ecx,-0x4(%r15,%rdx,4)
add    $0xffffffffffffffff,%rsi
cmp    $0x1,%rsi
jg     1400 <_bucket_sort+0x2f0>
cmpl   $0x0,-0x2c(%rbp)
jle    12f0 <_bucket_sort+0x1e0>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    -0x68(%rbp),%rdx
call   1030 <memcpy@plt>
pxor   %xmm0,%xmm0
jmp    12f0 <_bucket_sort+0x1e0>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%esi
movdqa %xmm0,%xmm1
test   $0x1,%dl
jne    1216 <_bucket_sort+0x106>
jmp    1251 <_bucket_sort+0x141>

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

LLVM IR (-O2):
define void @_bucket_sort(i32* nocapture %0, i32 %1) {
%3 = bitcast i32* %0 to i8*
%4 = alloca [10 x i32]
%5 = load i32, i32* %0
%6 = zext i32 %1 to i64
%7 = alloca i32, i64 %6
%8 = bitcast i32* %7 to i8*
%9 = icmp sgt i32 %1, 0
%10 = icmp sgt i32 %1, 1
br i1 %10, label %11, label %86
11: ; preds = %2
%12 = add nsw i64 %6, -1
%13 = icmp ult i64 %12, 8
br i1 %13, label %83, label %14
14: ; preds = %11
%15 = and i64 %12, -8
%16 = or i64 %15, 1
%17 = insertelement <4 x i32> poison, i32 %5, i64 0
%18 = shufflevector <4 x i32> %17, <4 x i32> poison, <4 x i32> zeroinitializer
%19 = add nsw i64 %15, -8
%20 = lshr exact i64 %19, 3
%21 = add nuw nsw i64 %20, 1
%22 = and i64 %21, 1
%23 = icmp eq i64 %19, 0
br i1 %23, label %58, label %24
24: ; preds = %14
%25 = and i64 %21, 4611686018427387902
br label %26
26: ; preds = %26, %24
%27 = phi i64 [ 0, %24 ], [ %53, %26 ]
%28 = phi <4 x i32> [ %18, %24 ], [ %51, %26 ]
%29 = phi <4 x i32> [ %18, %24 ], [ %52, %26 ]
%30 = phi i64 [ 0, %24 ], [ %54, %26 ]
%31 = or i64 %27, 1
%32 = getelementptr inbounds i32, i32* %0, i64 %31
%33 = bitcast i32* %32 to <4 x i32>*
%34 = load <4 x i32>, <4 x i32>* %33
%35 = getelementptr inbounds i32, i32* %32, i64 4
%36 = bitcast i32* %35 to <4 x i32>*
%37 = load <4 x i32>, <4 x i32>* %36
%38 = icmp sgt <4 x i32> %34, %28
%39 = icmp sgt <4 x i32> %37, %29
%40 = select <4 x i1> %38, <4 x i32> %34, <4 x i32> %28
%41 = select <4 x i1> %39, <4 x i32> %37, <4 x i32> %29
%42 = or i64 %27, 9
%43 = getelementptr inbounds i32, i32* %0, i64 %42
%44 = bitcast i32* %43 to <4 x i32>*
%45 = load <4 x i32>, <4 x i32>* %44
%46 = getelementptr inbounds i32, i32* %43, i64 4
%47 = bitcast i32* %46 to <4 x i32>*
%48 = load <4 x i32>, <4 x i32>* %47
%49 = icmp sgt <4 x i32> %45, %40
%50 = icmp sgt <4 x i32> %48, %41
%51 = select <4 x i1> %49, <4 x i32> %45, <4 x i32> %40
%52 = select <4 x i1> %50, <4 x i32> %48, <4 x i32> %41
%53 = add nuw i64 %27, 16
%54 = add i64 %30, 2
%55 = icmp eq i64 %54, %25
br i1 %55, label %56, label %26
56: ; preds = %26
%57 = or i64 %53, 1
br label %58
58: ; preds = %56, %14
%59 = phi <4 x i32> [ undef, %14 ], [ %51, %56 ]
%60 = phi <4 x i32> [ undef, %14 ], [ %52, %56 ]
%61 = phi i64 [ 1, %14 ], [ %57, %56 ]
%62 = phi <4 x i32> [ %18, %14 ], [ %51, %56 ]
%63 = phi <4 x i32> [ %18, %14 ], [ %52, %56 ]
%64 = icmp eq i64 %22, 0
br i1 %64, label %76, label %65
65: ; preds = %58
%66 = getelementptr inbounds i32, i32* %0, i64 %61
%67 = bitcast i32* %66 to <4 x i32>*
%68 = load <4 x i32>, <4 x i32>* %67
%69 = getelementptr inbounds i32, i32* %66, i64 4
%70 = bitcast i32* %69 to <4 x i32>*
%71 = load <4 x i32>, <4 x i32>* %70
%72 = icmp sgt <4 x i32> %68, %62
%73 = icmp sgt <4 x i32> %71, %63
%74 = select <4 x i1> %72, <4 x i32> %68, <4 x i32> %62
%75 = select <4 x i1> %73, <4 x i32> %71, <4 x i32> %63
br label %76
76: ; preds = %58, %65
%77 = phi <4 x i32> [ %59, %58 ], [ %74, %65 ]
%78 = phi <4 x i32> [ %60, %58 ], [ %75, %65 ]
%79 = icmp sgt <4 x i32> %77, %78
%80 = select <4 x i1> %79, <4 x i32> %77, <4 x i32> %78
%81 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %80)
%82 = icmp eq i64 %12, %15
br i1 %82, label %86, label %83
83: ; preds = %11, %76
%84 = phi i64 [ 1, %11 ], [ %16, %76 ]
%85 = phi i32 [ %5, %11 ], [ %81, %76 ]
br label %111
86: ; preds = %111, %76, %2
%87 = phi i32 [ %5, %2 ], [ %81, %76 ], [ %117, %111 ]
%88 = icmp sgt i32 %87, 0
br i1 %88, label %89, label %185
89: ; preds = %86
%90 = bitcast [10 x i32]* %4 to i8*
%91 = shl nuw nsw i64 %6, 2
%92 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 0
%93 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 1
%94 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 2
%95 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 3
%96 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 4
%97 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 5
%98 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 6
%99 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 7
%100 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 8
%101 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 9
%102 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 1
%103 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 2
%104 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 3
%105 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 4
%106 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 5
%107 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 6
%108 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 7
%109 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 8
%110 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 9
br label %120
111: ; preds = %83, %111
%112 = phi i64 [ %118, %111 ], [ %84, %83 ]
%113 = phi i32 [ %117, %111 ], [ %85, %83 ]
%114 = getelementptr inbounds i32, i32* %0, i64 %112
%115 = load i32, i32* %114
%116 = icmp sgt i32 %115, %113
%117 = select i1 %116, i32 %115, i32 %113
%118 = add nuw nsw i64 %112, 1
%119 = icmp eq i64 %118, %6
br i1 %119, label %86, label %111
120: ; preds = %89, %181
%121 = phi i32 [ 1, %89 ], [ %182, %181 ]
br i1 %9, label %152, label %134
122: ; preds = %152
%123 = load i32, i32* %92
%124 = load i32, i32* %93
%125 = load i32, i32* %94
%126 = load i32, i32* %95
%127 = load i32, i32* %96
%128 = load i32, i32* %97
%129 = load i32, i32* %98
%130 = load i32, i32* %99
%131 = load i32, i32* %100
%132 = load i32, i32* %101
%133 = add nsw i32 %124, %123
br label %134
134: ; preds = %122, %120
%135 = phi i32 [ %132, %122 ], [ 0, %120 ]
%136 = phi i32 [ %131, %122 ], [ 0, %120 ]
%137 = phi i32 [ %130, %122 ], [ 0, %120 ]
%138 = phi i32 [ %129, %122 ], [ 0, %120 ]
%139 = phi i32 [ %128, %122 ], [ 0, %120 ]
%140 = phi i32 [ %127, %122 ], [ 0, %120 ]
%141 = phi i32 [ %126, %122 ], [ 0, %120 ]
%142 = phi i32 [ %125, %122 ], [ 0, %120 ]
%143 = phi i32 [ %133, %122 ], [ 0, %120 ]
store i32 %143, i32* %102
%144 = add nsw i32 %142, %143
store i32 %144, i32* %103
%145 = add nsw i32 %141, %144
store i32 %145, i32* %104
%146 = add nsw i32 %140, %145
store i32 %146, i32* %105
%147 = add nsw i32 %139, %146
store i32 %147, i32* %106
%148 = add nsw i32 %138, %147
store i32 %148, i32* %107
%149 = add nsw i32 %137, %148
store i32 %149, i32* %108
%150 = add nsw i32 %136, %149
store i32 %150, i32* %109
%151 = add nsw i32 %135, %150
store i32 %151, i32* %110
br i1 %9, label %166, label %181
152: ; preds = %120, %152
%153 = phi i64 [ %162, %152 ], [ 0, %120 ]
%154 = getelementptr inbounds i32, i32* %0, i64 %153
%155 = load i32, i32* %154
%156 = sdiv i32 %155, %121
%157 = srem i32 %156, 10
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %158
%160 = load i32, i32* %159
%161 = add nsw i32 %160, 1
store i32 %161, i32* %159
%162 = add nuw nsw i64 %153, 1
%163 = icmp eq i64 %162, %6
br i1 %163, label %122, label %152
164: ; preds = %166
br i1 %9, label %165, label %181
165: ; preds = %164
br label %181
166: ; preds = %134, %166
%167 = phi i64 [ %168, %166 ], [ %6, %134 ]
%168 = add nsw i64 %167, -1
%169 = and i64 %168, 4294967295
%170 = getelementptr inbounds i32, i32* %0, i64 %169
%171 = load i32, i32* %170
%172 = sdiv i32 %171, %121
%173 = srem i32 %172, 10
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %174
%176 = load i32, i32* %175
%177 = add nsw i32 %176, -1
store i32 %177, i32* %175
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds i32, i32* %7, i64 %178
store i32 %171, i32* %179
%180 = icmp sgt i64 %167, 1
br i1 %180, label %166, label %164
181: ; preds = %134, %165, %164
%182 = mul nsw i32 %121, 10
%183 = sdiv i32 %87, %182
%184 = icmp sgt i32 %183, 0
br i1 %184, label %120, label %185
185: ; preds = %181, %86
ret void
}