#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*/ free(int *);
scalar_t__ malloc(int);
int power(int, int);
void radixsort(int *l, int left, int right) {
  int i, j, k, d;
  int n = right - left + 1;
  int sizes[10] = {0};
  int counts[10];
  int **bucket;
  bucket = (int **)malloc(10 * sizeof(int *));
  for (k = 0; k < 16; k++) {
    for (d = 0; d < 10; d++) {
      sizes[d] = 0;
    }
    for (i = 0; i < n; i++) {
      d = (l[i] % power(10, k + 1)) / power(10, k);
      sizes[d]++;
    }
    for (d = 0; d < 10; d++) {
      bucket[d] = (int *)malloc(sizes[d] * sizeof(int));
    }
    for (j = 0; j < 10; j++)
      counts[j] = 0;
    for (i = 0; i < n; i++) {
      d = (l[i] % power(10, k + 1)) / power(10, k);
      bucket[d][counts[d]++] = l[i];
    }
    for (j = 0; j < 10; j++)
      counts[j] = 0;
    i = 0;
    for (d = 0; d < 10; d++) {
      for (j = 0; j < sizes[d]; j++) {
        l[i++] = bucket[d][j];
      }
    }
    for (d = 0; d < 10; d++) {
      free(bucket[d]);
    }
  }
}


x86 assembly (clang, -O0):
<radixsort>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
lea    -0x50(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
mov    $0x50,%edi
call   1060 <malloc@plt>
mov    %rax,-0x88(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x10,-0x1c(%rbp)
jge    1437 <radixsort+0x2f7>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    11be <radixsort+0x7e>
movslq -0x20(%rbp),%rax
movl   $0x0,-0x50(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    119a <radixsort+0x5a>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    123b <radixsort+0xfb>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x90(%rbp)
mov    -0x1c(%rbp),%esi
add    $0x1,%esi
mov    $0xa,%edi
call   1040 <power@plt>
mov    %eax,%ecx
mov    -0x90(%rbp),%eax
cltd
idiv   %ecx
mov    %edx,-0x8c(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0xa,%edi
call   1040 <power@plt>
mov    %eax,%ecx
mov    -0x8c(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,-0x20(%rbp)
movslq -0x20(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11c5 <radixsort+0x85>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    1280 <radixsort+0x140>
movslq -0x20(%rbp),%rax
movslq -0x50(%rbp,%rax,4),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x88(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1242 <radixsort+0x102>
movl   $0x0,-0x18(%rbp)
cmpl   $0xa,-0x18(%rbp)
jge    12ab <radixsort+0x16b>
movslq -0x18(%rbp),%rax
movl   $0x0,-0x80(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1287 <radixsort+0x147>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    134a <radixsort+0x20a>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x98(%rbp)
mov    -0x1c(%rbp),%esi
add    $0x1,%esi
mov    $0xa,%edi
call   1040 <power@plt>
mov    %eax,%ecx
mov    -0x98(%rbp),%eax
cltd
idiv   %ecx
mov    %edx,-0x94(%rbp)
mov    -0x1c(%rbp),%esi
mov    $0xa,%edi
call   1040 <power@plt>
mov    %eax,%ecx
mov    -0x94(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x88(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rsi
mov    -0x80(%rbp,%rsi,4),%ecx
mov    %ecx,%edi
add    $0x1,%edi
mov    %edi,-0x80(%rbp,%rsi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12b2 <radixsort+0x172>
movl   $0x0,-0x18(%rbp)
cmpl   $0xa,-0x18(%rbp)
jge    1375 <radixsort+0x235>
movslq -0x18(%rbp),%rax
movl   $0x0,-0x80(%rbp,%rax,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1351 <radixsort+0x211>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    13f1 <radixsort+0x2b1>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
movslq -0x20(%rbp),%rcx
cmp    -0x50(%rbp,%rcx,4),%eax
jge    13de <radixsort+0x29e>
mov    -0x88(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x14(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1394 <radixsort+0x254>
jmp    13e3 <radixsort+0x2a3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1383 <radixsort+0x243>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    1424 <radixsort+0x2e4>
mov    -0x88(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13f8 <radixsort+0x2b8>
jmp    1429 <radixsort+0x2e9>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1189 <radixsort+0x49>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<radixsort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %edx,%ebx
mov    %esi,%ebp
mov    %rdi,%r15
mov    $0x50,%edi
call   1050 <malloc@plt>
mov    %ebp,%edx
mov    %ebx,%ecx
mov    %rax,%r13
mov    %ebx,%esi
sub    %ebp,%esi
add    $0x1,%esi
lea    0x70(%r15),%rax
mov    %rax,0x78(%rsp)
lea    0x10(%r15),%rax
mov    %rax,0x70(%rsp)
lea    0xc(%r15),%rax
mov    %rax,0x68(%rsp)
xor    %eax,%eax
xorps  %xmm0,%xmm0
mov    %ebx,0xc(%rsp)
mov    %ebp,0x8(%rsp)
mov    %rsi,0x58(%rsp)
mov    %r13,0x60(%rsp)
jmp    1216 <radixsort+0xe6>
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13),%rdi
call   1030 <free@plt>
mov    0x8(%r13),%rdi
call   1030 <free@plt>
mov    0x10(%r13),%rdi
call   1030 <free@plt>
mov    0x18(%r13),%rdi
call   1030 <free@plt>
mov    0x20(%r13),%rdi
call   1030 <free@plt>
mov    0x28(%r13),%rdi
call   1030 <free@plt>
mov    0x30(%r13),%rdi
call   1030 <free@plt>
mov    0x38(%r13),%rdi
call   1030 <free@plt>
mov    0x40(%r13),%rdi
call   1030 <free@plt>
mov    0x48(%r13),%rdi
call   1030 <free@plt>
xorps  %xmm0,%xmm0
mov    0x10(%rsp),%rax
add    $0x1,%eax
cmp    $0x10,%eax
mov    0xc(%rsp),%ecx
mov    0x8(%rsp),%edx
je     162c <radixsort+0x4fc>
mov    %rax,0x10(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movq   $0x0,0x50(%rsp)
mov    $0x0,%r11d
mov    $0x0,%eax
mov    $0x0,%r8d
mov    $0x0,%ebp
mov    $0x0,%r9d
mov    $0x0,%r10d
mov    $0x0,%r14d
mov    $0x0,%ebx
mov    $0x0,%r12d
mov    $0x0,%edi
cmp    %edx,%ecx
jl     12f6 <radixsort+0x1c6>
mov    0x10(%rsp),%r13
lea    0x1(%r13),%r14d
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    (%r15,%rbx,4),%ebp
mov    $0xa,%edi
mov    %r14d,%esi
call   1040 <power@plt>
mov    %eax,%ecx
mov    %ebp,%eax
cltd
idiv   %ecx
mov    %edx,%ebp
mov    $0xa,%edi
mov    %r13d,%esi
call   1040 <power@plt>
mov    %eax,%ecx
mov    %ebp,%eax
cltd
idiv   %ecx
cltq
addl   $0x1,0x30(%rsp,%rax,4)
mov    0x58(%rsp),%rsi
add    $0x1,%rbx
cmp    %rbx,%rsi
jne    1280 <radixsort+0x150>
mov    0x30(%rsp),%edi
mov    0x34(%rsp),%r12d
mov    0x38(%rsp),%ebx
mov    0x3c(%rsp),%r14d
mov    0x40(%rsp),%r10d
mov    0x44(%rsp),%r9d
mov    0x48(%rsp),%ebp
mov    0x4c(%rsp),%r8d
mov    0x50(%rsp),%eax
mov    0x54(%rsp),%r11d
mov    0x60(%rsp),%r13
mov    %r9d,0x1c(%rsp)
mov    %ebp,0x20(%rsp)
mov    %r8d,0x24(%rsp)
mov    %eax,0x28(%rsp)
mov    %r11d,0x2c(%rsp)
shl    $0x2,%edi
mov    %r12d,%ebp
mov    %r10d,%r12d
call   1050 <malloc@plt>
mov    %rax,0x0(%r13)
shl    $0x2,%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x8(%r13)
shl    $0x2,%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,0x10(%r13)
shl    $0x2,%r14d
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %rax,0x18(%r13)
shl    $0x2,%r12d
mov    %r12d,%edi
call   1050 <malloc@plt>
mov    %rax,0x20(%r13)
mov    0x1c(%rsp),%edi
shl    $0x2,%edi
call   1050 <malloc@plt>
mov    %rax,0x28(%r13)
mov    0x20(%rsp),%edi
shl    $0x2,%edi
call   1050 <malloc@plt>
mov    %rax,0x30(%r13)
mov    0x24(%rsp),%edi
shl    $0x2,%edi
call   1050 <malloc@plt>
mov    %rax,0x38(%r13)
mov    0x28(%rsp),%edi
shl    $0x2,%edi
call   1050 <malloc@plt>
mov    %rax,0x40(%r13)
mov    0x2c(%rsp),%edi
shl    $0x2,%edi
call   1050 <malloc@plt>
mov    %rax,0x48(%r13)
xorps  %xmm0,%xmm0
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movq   $0x0,0xa0(%rsp)
mov    0xc(%rsp),%eax
cmp    0x8(%rsp),%eax
mov    %r13,%r12
mov    0x10(%rsp),%r13
jl     1448 <radixsort+0x318>
lea    0x1(%r13),%r14d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15,%rbx,4),%ebp
mov    $0xa,%edi
mov    %r14d,%esi
call   1040 <power@plt>
mov    %eax,%ecx
mov    %ebp,%eax
cltd
idiv   %ecx
mov    %edx,%ebp
mov    $0xa,%edi
mov    %r13d,%esi
call   1040 <power@plt>
mov    %eax,%ecx
mov    %ebp,%eax
cltd
idiv   %ecx
mov    (%r15,%rbx,4),%ecx
cltq
mov    (%r12,%rax,8),%rdx
movslq 0x80(%rsp,%rax,4),%rsi
lea    0x1(%rsi),%edi
mov    %edi,0x80(%rsp,%rax,4)
mov    %ecx,(%rdx,%rsi,4)
add    $0x1,%rbx
cmp    %rbx,0x58(%rsp)
jne    13f0 <radixsort+0x2c0>
xorps  %xmm0,%xmm0
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movq   $0x0,0xa0(%rsp)
xor    %r8d,%r8d
xor    %ecx,%ecx
mov    0x70(%rsp),%r11
mov    0x68(%rsp),%r14
mov    %r12,%r13
jmp    148e <radixsort+0x35e>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8
cmp    $0xa,%r8
je     11a0 <radixsort+0x70>
mov    0x30(%rsp,%r8,4),%r10d
test   %r10d,%r10d
jle    1480 <radixsort+0x350>
mov    0x0(%r13,%r8,8),%rsi
movslq %ecx,%rcx
cmp    $0x8,%r10d
jb     14c4 <radixsort+0x394>
lea    (%r15,%rcx,4),%rax
lea    (%rsi,%r10,4),%rdx
cmp    %rdx,%rax
jae    153f <radixsort+0x40f>
lea    (%rcx,%r10,1),%rax
lea    (%r15,%rax,4),%rax
cmp    %rax,%rsi
jae    153f <radixsort+0x40f>
xor    %edi,%edi
mov    %rdi,%rax
not    %rax
add    %r10,%rax
mov    %r10,%rdx
and    $0x3,%rdx
je     14f5 <radixsort+0x3c5>
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rdi,4),%ebp
mov    %ebp,(%r15,%rcx,4)
add    $0x1,%rcx
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    14e0 <radixsort+0x3b0>
cmp    $0x3,%rax
jb     1480 <radixsort+0x350>
sub    %rdi,%r10
lea    (%rsi,%rdi,4),%rax
add    $0xc,%rax
lea    (%r14,%rcx,4),%rsi
xor    %edx,%edx
nopl   0x0(%rax)
mov    -0xc(%rax,%rdx,4),%edi
mov    %edi,-0xc(%rsi,%rdx,4)
mov    -0x8(%rax,%rdx,4),%edi
mov    %edi,-0x8(%rsi,%rdx,4)
mov    -0x4(%rax,%rdx,4),%edi
mov    %edi,-0x4(%rsi,%rdx,4)
mov    (%rax,%rdx,4),%edi
mov    %edi,(%rsi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r10
jne    1510 <radixsort+0x3e0>
add    %rdx,%rcx
jmp    1480 <radixsort+0x350>
mov    %r10d,%edi
and    $0xfffffff8,%edi
lea    -0x8(%rdi),%rax
mov    %rax,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %ebp,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1565 <radixsort+0x435>
xor    %eax,%eax
jmp    15d8 <radixsort+0x4a8>
and    $0xfffffffffffffffc,%rbp
mov    0x78(%rsp),%rax
lea    (%rax,%rcx,4),%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rsi,%rax,4),%xmm0
movups 0x10(%rsi,%rax,4),%xmm1
movups %xmm0,-0x70(%rbx,%rax,4)
movups %xmm1,-0x60(%rbx,%rax,4)
movups 0x20(%rsi,%rax,4),%xmm0
movups 0x30(%rsi,%rax,4),%xmm1
movups %xmm0,-0x50(%rbx,%rax,4)
movups %xmm1,-0x40(%rbx,%rax,4)
movups 0x40(%rsi,%rax,4),%xmm0
movups 0x50(%rsi,%rax,4),%xmm1
movups %xmm0,-0x30(%rbx,%rax,4)
movups %xmm1,-0x20(%rbx,%rax,4)
movups 0x60(%rsi,%rax,4),%xmm0
movups 0x70(%rsi,%rax,4),%xmm1
movups %xmm0,-0x10(%rbx,%rax,4)
movups %xmm1,(%rbx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rbp
jne    1580 <radixsort+0x450>
test   %r9,%r9
je     161b <radixsort+0x4eb>
lea    (%rsi,%rax,4),%rdx
add    $0x10,%rdx
add    %rcx,%rax
lea    (%r11,%rax,4),%rax
shl    $0x5,%r9
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdx,%rbp,1),%xmm0
movups (%rdx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rax,%rbp,1)
movups %xmm1,(%rax,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r9
jne    1600 <radixsort+0x4d0>
add    %rdi,%rcx
cmp    %r10,%rdi
je     1480 <radixsort+0x350>
jmp    14c6 <radixsort+0x396>
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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