#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 /*<<< orphan*/ sorti(unsigned char *, int);
int /*<<< orphan*/ sortm(unsigned char *, int);
int /*<<< orphan*/ sortq(unsigned char *, int);
void dmsort(void) {
  unsigned i;
  unsigned char bufi[21] = {20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,
                            9,  8,  7,  6,  5,  4,  3,  2,  1,  0};
  sorti(bufi, 21);
  for (i = 0; i < 21; i++)
    printf("%2d ", bufi[i]);
  printf("... sorti\n");
  unsigned char bufm[21] = {20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,
                            9,  8,  7,  6,  5,  4,  3,  2,  1,  0};
  sortm(bufm, 21);
  for (i = 0; i < 21; i++)
    printf("%2d ", bufm[i]);
  printf("... sortm\n");
  unsigned char bufq[21] = {20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,
                            9,  8,  7,  6,  5,  4,  3,  2,  1,  0};
  sortq(bufq, 21);
  for (i = 0; i < 21; i++)
    printf("%2d ", bufq[i]);
  printf("... sortq\n");
}


x86 assembly (clang, -O0):
<dmsort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0xeb1(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    0xeae(%rip),%rax
mov    %rax,-0x18(%rbp)
mov    0xeac(%rip),%eax
mov    %eax,-0x10(%rbp)
mov    0xea7(%rip),%al
mov    %al,-0xc(%rbp)
lea    -0x20(%rbp),%rdi
mov    $0x15,%esi
call   1040 <sorti@plt>
movl   $0x0,-0x4(%rbp)
cmpl   $0x15,-0x4(%rbp)
jae    11b3 <dmsort+0x73>
mov    -0x4(%rbp),%eax
movzbl -0x20(%rbp,%rax,1),%esi
lea    0xe77(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    1185 <dmsort+0x45>
lea    0xe60(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    0xe38(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xe35(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0xe33(%rip),%eax
mov    %eax,-0x30(%rbp)
mov    0xe2e(%rip),%al
mov    %al,-0x2c(%rbp)
lea    -0x40(%rbp),%rdi
mov    $0x15,%esi
call   1030 <sortm@plt>
movl   $0x0,-0x4(%rbp)
cmpl   $0x15,-0x4(%rbp)
jae    122c <dmsort+0xec>
mov    -0x4(%rbp),%eax
movzbl -0x40(%rbp,%rax,1),%esi
lea    0xdfe(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    11fe <dmsort+0xbe>
lea    0xdf2(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    0xdbf(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    0xdbc(%rip),%rax
mov    %rax,-0x58(%rbp)
mov    0xdba(%rip),%eax
mov    %eax,-0x50(%rbp)
mov    0xdb5(%rip),%al
mov    %al,-0x4c(%rbp)
lea    -0x60(%rbp),%rdi
mov    $0x15,%esi
call   1050 <sortq@plt>
movl   $0x0,-0x4(%rbp)
cmpl   $0x15,-0x4(%rbp)
jae    12a5 <dmsort+0x165>
mov    -0x4(%rbp),%eax
movzbl -0x60(%rbp,%rax,1),%esi
lea    0xd85(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    1277 <dmsort+0x137>
lea    0xd84(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dmsort>:
push   %r14
push   %rbx
sub    $0x58,%rsp
movaps 0xed2(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movabs $0x1020304050607,%r14
mov    %r14,0x4d(%rsp)
lea    0x40(%rsp),%rdi
mov    $0x15,%esi
call   1040 <sorti@plt>
movzbl 0x40(%rsp),%esi
lea    0xe73(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x41(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x42(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x43(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x44(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x45(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x46(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x47(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x48(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x49(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x4a(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x4b(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x4c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x4d(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x4e(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x4f(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x50(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x51(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x52(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x53(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x54(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xd3b(%rip),%rdi
call   1060 <puts@plt>
movaps 0xd5a(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
mov    %r14,0x2d(%rsp)
lea    0x20(%rsp),%rdi
mov    $0x15,%esi
call   1030 <sortm@plt>
movzbl 0x20(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x21(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x22(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x23(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x24(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x25(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x26(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x27(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x28(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x29(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x2a(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x2b(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x2c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x2d(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x2e(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x2f(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x30(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x31(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x32(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x33(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x34(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xbde(%rip),%rdi
call   1060 <puts@plt>
movaps 0xbf3(%rip),%xmm0
movaps %xmm0,(%rsp)
mov    %r14,0xd(%rsp)
mov    %rsp,%rdi
mov    $0x15,%esi
call   1050 <sortq@plt>
movzbl (%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x1(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x2(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x3(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x5(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x6(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x7(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x9(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0xa(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0xb(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0xc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0xd(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0xe(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0xf(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x10(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x11(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x12(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x13(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
movzbl 0x14(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xa85(%rip),%rdi
call   1060 <puts@plt>
add    $0x58,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@__const.dmsort.bufi = [21 x i8] c"\14\13\12\11\10\0F\0E\0D\0C\0B\0A\09\08\07\06\05\04\03\02\01\00"
@.str = [5 x i8] c"%2d \00"
@.str.1 = [11 x i8] c"... sorti\0A\00"
@__const.dmsort.bufm = [21 x i8] c"\14\13\12\11\10\0F\0E\0D\0C\0B\0A\09\08\07\06\05\04\03\02\01\00"
@.str.2 = [11 x i8] c"... sortm\0A\00"
@__const.dmsort.bufq = [21 x i8] c"\14\13\12\11\10\0F\0E\0D\0C\0B\0A\09\08\07\06\05\04\03\02\01\00"
@.str.3 = [11 x i8] c"... sortq\0A\00"
define void @dmsort() {
%1 = alloca i32
%2 = alloca [21 x i8]
%3 = alloca [21 x i8]
%4 = alloca [21 x i8]
%5 = bitcast [21 x i8]* %2 to i8*
%6 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 0
%7 = call i32 @sorti(i8* %6, i32 21)
store i32 0, i32* %1
br label %8
8: ; preds = %18, %0
%9 = load i32, i32* %1
%10 = icmp ult i32 %9, 21
br i1 %10, label %11, label %21
11: ; preds = %8
%12 = load i32, i32* %1
%13 = zext i32 %12 to i64
%14 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 %13
%15 = load i8, i8* %14
%16 = zext i8 %15 to i32
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %16)
br label %18
18: ; preds = %11
%19 = load i32, i32* %1
%20 = add i32 %19, 1
store i32 %20, i32* %1
br label %8
21: ; preds = %8
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0))
%23 = bitcast [21 x i8]* %3 to i8*
%24 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 0
%25 = call i32 @sortm(i8* %24, i32 21)
store i32 0, i32* %1
br label %26
26: ; preds = %36, %21
%27 = load i32, i32* %1
%28 = icmp ult i32 %27, 21
br i1 %28, label %29, label %39
29: ; preds = %26
%30 = load i32, i32* %1
%31 = zext i32 %30 to i64
%32 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 %31
%33 = load i8, i8* %32
%34 = zext i8 %33 to i32
%35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %34)
br label %36
36: ; preds = %29
%37 = load i32, i32* %1
%38 = add i32 %37, 1
store i32 %38, i32* %1
br label %26
39: ; preds = %26
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
%41 = bitcast [21 x i8]* %4 to i8*
%42 = getelementptr inbounds [21 x i8], [21 x i8]* %4, i64 0, i64 0
%43 = call i32 @sortq(i8* %42, i32 21)
store i32 0, i32* %1
br label %44
44: ; preds = %54, %39
%45 = load i32, i32* %1
%46 = icmp ult i32 %45, 21
br i1 %46, label %47, label %57
47: ; preds = %44
%48 = load i32, i32* %1
%49 = zext i32 %48 to i64
%50 = getelementptr inbounds [21 x i8], [21 x i8]* %4, i64 0, i64 %49
%51 = load i8, i8* %50
%52 = zext i8 %51 to i32
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %52)
br label %54
54: ; preds = %47
%55 = load i32, i32* %1
%56 = add i32 %55, 1
store i32 %56, i32* %1
br label %44
57: ; preds = %44
%58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [5 x i8] c"%2d \00"
@__const.dmsort.bufq = [21 x i8] c"\14\13\12\11\10\0F\0E\0D\0C\0B\0A\09\08\07\06\05\04\03\02\01\00"
@str = [10 x i8] c"... sorti\00"
@str.4 = [10 x i8] c"... sortm\00"
@str.5 = [10 x i8] c"... sortq\00"
define void @dmsort() {
%1 = alloca [21 x i8]
%2 = alloca [21 x i8]
%3 = alloca [21 x i8]
%4 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 0
%5 = call i32 @sorti(i8* %4, i32 21)
%6 = load i8, i8* %4
%7 = zext i8 %6 to i32
%8 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %7)
%9 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 1
%10 = load i8, i8* %9
%11 = zext i8 %10 to i32
%12 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %11)
%13 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 2
%14 = load i8, i8* %13
%15 = zext i8 %14 to i32
%16 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %15)
%17 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 3
%18 = load i8, i8* %17
%19 = zext i8 %18 to i32
%20 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %19)
%21 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 4
%22 = load i8, i8* %21
%23 = zext i8 %22 to i32
%24 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %23)
%25 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 5
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
%28 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %27)
%29 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 6
%30 = load i8, i8* %29
%31 = zext i8 %30 to i32
%32 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %31)
%33 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 7
%34 = load i8, i8* %33
%35 = zext i8 %34 to i32
%36 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %35)
%37 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 8
%38 = load i8, i8* %37
%39 = zext i8 %38 to i32
%40 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %39)
%41 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 9
%42 = load i8, i8* %41
%43 = zext i8 %42 to i32
%44 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %43)
%45 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 10
%46 = load i8, i8* %45
%47 = zext i8 %46 to i32
%48 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %47)
%49 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 11
%50 = load i8, i8* %49
%51 = zext i8 %50 to i32
%52 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %51)
%53 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 12
%54 = load i8, i8* %53
%55 = zext i8 %54 to i32
%56 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %55)
%57 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 13
%58 = load i8, i8* %57
%59 = zext i8 %58 to i32
%60 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %59)
%61 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 14
%62 = load i8, i8* %61
%63 = zext i8 %62 to i32
%64 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %63)
%65 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 15
%66 = load i8, i8* %65
%67 = zext i8 %66 to i32
%68 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %67)
%69 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 16
%70 = load i8, i8* %69
%71 = zext i8 %70 to i32
%72 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %71)
%73 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 17
%74 = load i8, i8* %73
%75 = zext i8 %74 to i32
%76 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %75)
%77 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 18
%78 = load i8, i8* %77
%79 = zext i8 %78 to i32
%80 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %79)
%81 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 19
%82 = load i8, i8* %81
%83 = zext i8 %82 to i32
%84 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %83)
%85 = getelementptr inbounds [21 x i8], [21 x i8]* %1, i64 0, i64 20
%86 = load i8, i8* %85
%87 = zext i8 %86 to i32
%88 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %87)
%89 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str, i64 0, i64 0))
%90 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 0
%91 = call i32 @sortm(i8* %90, i32 21)
%92 = load i8, i8* %90
%93 = zext i8 %92 to i32
%94 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %93)
%95 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 1
%96 = load i8, i8* %95
%97 = zext i8 %96 to i32
%98 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %97)
%99 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 2
%100 = load i8, i8* %99
%101 = zext i8 %100 to i32
%102 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %101)
%103 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 3
%104 = load i8, i8* %103
%105 = zext i8 %104 to i32
%106 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %105)
%107 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 4
%108 = load i8, i8* %107
%109 = zext i8 %108 to i32
%110 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %109)
%111 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 5
%112 = load i8, i8* %111
%113 = zext i8 %112 to i32
%114 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %113)
%115 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 6
%116 = load i8, i8* %115
%117 = zext i8 %116 to i32
%118 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %117)
%119 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 7
%120 = load i8, i8* %119
%121 = zext i8 %120 to i32
%122 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %121)
%123 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 8
%124 = load i8, i8* %123
%125 = zext i8 %124 to i32
%126 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %125)
%127 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 9
%128 = load i8, i8* %127
%129 = zext i8 %128 to i32
%130 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %129)
%131 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 10
%132 = load i8, i8* %131
%133 = zext i8 %132 to i32
%134 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %133)
%135 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 11
%136 = load i8, i8* %135
%137 = zext i8 %136 to i32
%138 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %137)
%139 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 12
%140 = load i8, i8* %139
%141 = zext i8 %140 to i32
%142 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %141)
%143 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 13
%144 = load i8, i8* %143
%145 = zext i8 %144 to i32
%146 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %145)
%147 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 14
%148 = load i8, i8* %147
%149 = zext i8 %148 to i32
%150 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %149)
%151 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 15
%152 = load i8, i8* %151
%153 = zext i8 %152 to i32
%154 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %153)
%155 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 16
%156 = load i8, i8* %155
%157 = zext i8 %156 to i32
%158 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %157)
%159 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 17
%160 = load i8, i8* %159
%161 = zext i8 %160 to i32
%162 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %161)
%163 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 18
%164 = load i8, i8* %163
%165 = zext i8 %164 to i32
%166 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %165)
%167 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 19
%168 = load i8, i8* %167
%169 = zext i8 %168 to i32
%170 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %169)
%171 = getelementptr inbounds [21 x i8], [21 x i8]* %2, i64 0, i64 20
%172 = load i8, i8* %171
%173 = zext i8 %172 to i32
%174 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %173)
%175 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.4, i64 0, i64 0))
%176 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 0
%177 = call i32 @sortq(i8* %176, i32 21)
%178 = load i8, i8* %176
%179 = zext i8 %178 to i32
%180 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %179)
%181 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 1
%182 = load i8, i8* %181
%183 = zext i8 %182 to i32
%184 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %183)
%185 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 2
%186 = load i8, i8* %185
%187 = zext i8 %186 to i32
%188 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %187)
%189 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 3
%190 = load i8, i8* %189
%191 = zext i8 %190 to i32
%192 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %191)
%193 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 4
%194 = load i8, i8* %193
%195 = zext i8 %194 to i32
%196 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %195)
%197 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 5
%198 = load i8, i8* %197
%199 = zext i8 %198 to i32
%200 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %199)
%201 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 6
%202 = load i8, i8* %201
%203 = zext i8 %202 to i32
%204 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %203)
%205 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 7
%206 = load i8, i8* %205
%207 = zext i8 %206 to i32
%208 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %207)
%209 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 8
%210 = load i8, i8* %209
%211 = zext i8 %210 to i32
%212 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %211)
%213 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 9
%214 = load i8, i8* %213
%215 = zext i8 %214 to i32
%216 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %215)
%217 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 10
%218 = load i8, i8* %217
%219 = zext i8 %218 to i32
%220 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %219)
%221 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 11
%222 = load i8, i8* %221
%223 = zext i8 %222 to i32
%224 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %223)
%225 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 12
%226 = load i8, i8* %225
%227 = zext i8 %226 to i32
%228 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %227)
%229 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 13
%230 = load i8, i8* %229
%231 = zext i8 %230 to i32
%232 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %231)
%233 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 14
%234 = load i8, i8* %233
%235 = zext i8 %234 to i32
%236 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %235)
%237 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 15
%238 = load i8, i8* %237
%239 = zext i8 %238 to i32
%240 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %239)
%241 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 16
%242 = load i8, i8* %241
%243 = zext i8 %242 to i32
%244 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %243)
%245 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 17
%246 = load i8, i8* %245
%247 = zext i8 %246 to i32
%248 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %247)
%249 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 18
%250 = load i8, i8* %249
%251 = zext i8 %250 to i32
%252 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %251)
%253 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 19
%254 = load i8, i8* %253
%255 = zext i8 %254 to i32
%256 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %255)
%257 = getelementptr inbounds [21 x i8], [21 x i8]* %3, i64 0, i64 20
%258 = load i8, i8* %257
%259 = zext i8 %258 to i32
%260 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %259)
%261 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.5, i64 0, i64 0))
ret void
}