#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 main() {
  int output[16], count[6], i = 0;
  int input[16] = {1, 4, 4, 5, 0, 5, 3, 1, 1, 2, 4, 1, 1, 5, 5, 5};
  for (i = 0; i < 6; i++) {
    count[i] = 0;
  }
  printf("Input: ");
  for (i = 0; i < 16; i++) {
    count[input[i]] = count[input[i]] + 1;
    printf(" %d ", input[i]);
    output[i] = 0;
  }
  printf("\n");
  for (i = 1; i < 6; i++) {
    count[i] += count[i - 1];
  }
  printf("\n");
  for (i = 16; i > 0; i--) {
    output[count[input[i - 1]] - 1] = input[i - 1];
    count[input[i - 1]] -= 1;
  }
  printf("Output: ");
  for (i = 0; i < 16; i++) {
    printf(" %d ", output[i]);
  }
  printf("\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x74(%rbp)
lea    -0xc0(%rbp),%rdi
lea    0xeb9(%rip),%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
movl   $0x0,-0x74(%rbp)
cmpl   $0x6,-0x74(%rbp)
jge    117c <main+0x5c>
movslq -0x74(%rbp),%rax
movl   $0x0,-0x70(%rbp,%rax,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1158 <main+0x38>
lea    0xebd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x74(%rbp)
cmpl   $0x10,-0x74(%rbp)
jge    11f1 <main+0xd1>
movslq -0x74(%rbp),%rax
movslq -0xc0(%rbp,%rax,4),%rax
ff
mov    -0x70(%rbp,%rax,4),%ecx
add    $0x1,%ecx
movslq -0x74(%rbp),%rax
movslq -0xc0(%rbp,%rax,4),%rax
ff
mov    %ecx,-0x70(%rbp,%rax,4)
movslq -0x74(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%esi
lea    0xe78(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movslq -0x74(%rbp),%rax
movl   $0x0,-0x50(%rbp,%rax,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1191 <main+0x71>
lea    0xe55(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x74(%rbp)
cmpl   $0x6,-0x74(%rbp)
jge    1236 <main+0x116>
mov    -0x74(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x70(%rbp,%rax,4),%ecx
movslq -0x74(%rbp),%rax
add    -0x70(%rbp,%rax,4),%ecx
mov    %ecx,-0x70(%rbp,%rax,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1206 <main+0xe6>
lea    0xe10(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x10,-0x74(%rbp)
cmpl   $0x0,-0x74(%rbp)
jle    12aa <main+0x18a>
mov    -0x74(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0xc0(%rbp,%rax,4),%ecx
mov    -0x74(%rbp),%eax
sub    $0x1,%eax
cltq
movslq -0xc0(%rbp,%rax,4),%rax
ff
mov    -0x70(%rbp,%rax,4),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x74(%rbp),%eax
sub    $0x1,%eax
cltq
movslq -0xc0(%rbp,%rax,4),%rax
ff
mov    -0x70(%rbp,%rax,4),%ecx
sub    $0x1,%ecx
mov    %ecx,-0x70(%rbp,%rax,4)
mov    -0x74(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x74(%rbp)
jmp    124b <main+0x12b>
lea    0xd9e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x74(%rbp)
cmpl   $0x10,-0x74(%rbp)
jge    12ed <main+0x1cd>
movslq -0x74(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%esi
lea    0xd70(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12bf <main+0x19f>
lea    0xd59(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %rbx
sub    $0x60,%rsp
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movq   $0x0,0x10(%rsp)
lea    0xf00(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeb2(%rip),%r15
lea    0xef3(%rip),%r14
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movslq (%rbx,%r15,1),%rsi
addl   $0x1,(%rsp,%rsi,4)
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movl   $0x0,0x20(%rsp,%rbx,1)
add    $0x4,%rbx
cmp    $0x40,%rbx
jne    1160 <main+0x40>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x4(%rsp),%eax
add    (%rsp),%eax
mov    %eax,0x4(%rsp)
add    0x8(%rsp),%eax
mov    %eax,0x8(%rsp)
add    0xc(%rsp),%eax
mov    %eax,0xc(%rsp)
add    0x10(%rsp),%eax
mov    %eax,0x10(%rsp)
add    %eax,0x14(%rsp)
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    $0xe,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq 0x4(%r15,%rax,4),%rcx
movslq (%rsp,%rcx,4),%rdx
mov    %ecx,0x1c(%rsp,%rdx,4)
add    $0xffffffffffffffff,%rdx
mov    %edx,(%rsp,%rcx,4)
movslq (%r15,%rax,4),%rcx
movslq (%rsp,%rcx,4),%rdx
mov    %ecx,0x1c(%rsp,%rdx,4)
add    $0xffffffffffffffff,%rdx
mov    %edx,(%rsp,%rcx,4)
add    $0xfffffffffffffffe,%rax
cmp    $0xfffffffffffffffe,%rax
jne    11d0 <main+0xb0>
lea    0xe45(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%esi
lea    0xe2e(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x34(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x3c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x40(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x44(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x48(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x50(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x54(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x58(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x5c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

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