#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*/ scanf(char *, int *);
int main() {
  int input_list[10];
  int i = 0, j = 0, tmp = 0;
  printf("Please enter ten integers. \n");
  for (i = 0; i < 10; i++) {
    scanf("%d", &input_list[i]);
  }
  printf("The list you entered is ");
  for (i = 0; i < 10; i++) {
    printf("%d ", input_list[i]);
  }
  printf(".\n");
  for (i = 0; i < 9; i++) {
    for (j = i + 1; j < 10; j++) {
      if (input_list[i] > input_list[j]) {
        tmp = input_list[i];
        input_list[i] = input_list[j];
        input_list[j] = tmp;
      } else
        continue;
    }
  }
  printf("The list sorted in descending order is ");
  for (i = 9; i >= 0; i--) {
    printf("%d ", input_list[i]);
  }
  printf(".\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
lea    0xeb5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x34(%rbp)
cmpl   $0xa,-0x34(%rbp)
jge    118c <main+0x6c>
movslq -0x34(%rbp),%rax
lea    -0x30(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xea4(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1159 <main+0x39>
lea    0xe8d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x34(%rbp)
cmpl   $0xa,-0x34(%rbp)
jge    11cf <main+0xaf>
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%esi
lea    0xe7f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a1 <main+0x81>
lea    0xe67(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x34(%rbp)
cmpl   $0x9,-0x34(%rbp)
jge    126d <main+0x14d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0xa,-0x38(%rbp)
jge    125a <main+0x13a>
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
movslq -0x38(%rbp),%rcx
cmp    -0x30(%rbp,%rcx,4),%eax
jle    1242 <main+0x122>
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
mov    %eax,-0x3c(%rbp)
movslq -0x38(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%ecx
movslq -0x34(%rbp),%rax
mov    %ecx,-0x30(%rbp,%rax,4)
mov    -0x3c(%rbp),%ecx
movslq -0x38(%rbp),%rax
mov    %ecx,-0x30(%rbp,%rax,4)
jmp    1247 <main+0x127>
jmp    124c <main+0x12c>
jmp    124c <main+0x12c>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11f7 <main+0xd7>
jmp    125f <main+0x13f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11e4 <main+0xc4>
lea    0xdcc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x9,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     12b0 <main+0x190>
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%esi
lea    0xd9e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1282 <main+0x162>
lea    0xd86(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x30,%rsp
lea    0xf0c(%rip),%rdi
call   1030 <puts@plt>
lea    0xeb8(%rip),%rbx
mov    %rsp,%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x4(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x8(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0xc(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x10(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x14(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x18(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x1c(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x20(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0x24(%rsp),%rsi
mov    %rbx,%rdi
call   1050 <scanf@plt>
lea    0xe34(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%rsp),%esi
lea    0xe3c(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x14(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xdf5(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%eax
mov    (%rsp),%ecx
jmp    128a <main+0x15a>
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0xa,%rax
je     129b <main+0x16b>
mov    (%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1280 <main+0x150>
mov    %edx,(%rsp)
mov    %ecx,(%rsp,%rax,4)
mov    %edx,%ecx
jmp    1280 <main+0x150>
xor    %eax,%eax
jmp    12aa <main+0x17a>
nop
add    $0x1,%rax
cmp    $0x8,%rax
je     12c0 <main+0x190>
mov    0x4(%rsp),%ecx
mov    0x8(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    12a0 <main+0x170>
mov    %edx,0x4(%rsp)
mov    %ecx,0x8(%rsp,%rax,4)
jmp    12a0 <main+0x170>
xor    %eax,%eax
jmp    12da <main+0x1aa>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0x7,%rax
je     12f0 <main+0x1c0>
mov    0x8(%rsp),%ecx
mov    0xc(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    12d0 <main+0x1a0>
mov    %edx,0x8(%rsp)
mov    %ecx,0xc(%rsp,%rax,4)
jmp    12d0 <main+0x1a0>
xor    %eax,%eax
jmp    130a <main+0x1da>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0x6,%rax
je     1320 <main+0x1f0>
mov    0xc(%rsp),%ecx
mov    0x10(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1300 <main+0x1d0>
mov    %edx,0xc(%rsp)
mov    %ecx,0x10(%rsp,%rax,4)
jmp    1300 <main+0x1d0>
xor    %eax,%eax
jmp    133a <main+0x20a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0x5,%rax
je     1350 <main+0x220>
mov    0x10(%rsp),%ecx
mov    0x14(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1330 <main+0x200>
mov    %edx,0x10(%rsp)
mov    %ecx,0x14(%rsp,%rax,4)
jmp    1330 <main+0x200>
xor    %eax,%eax
jmp    136a <main+0x23a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0x4,%rax
je     1380 <main+0x250>
mov    0x14(%rsp),%ecx
mov    0x18(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1360 <main+0x230>
mov    %edx,0x14(%rsp)
mov    %ecx,0x18(%rsp,%rax,4)
jmp    1360 <main+0x230>
xor    %eax,%eax
jmp    139a <main+0x26a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0x3,%rax
je     13b0 <main+0x280>
mov    0x18(%rsp),%ecx
mov    0x1c(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    1390 <main+0x260>
mov    %edx,0x18(%rsp)
mov    %ecx,0x1c(%rsp,%rax,4)
jmp    1390 <main+0x260>
xor    %eax,%eax
jmp    13ca <main+0x29a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0x2,%rax
je     13e0 <main+0x2b0>
mov    0x1c(%rsp),%ecx
mov    0x20(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    13c0 <main+0x290>
mov    %edx,0x1c(%rsp)
mov    %ecx,0x20(%rsp,%rax,4)
jmp    13c0 <main+0x290>
xor    %eax,%eax
jmp    13fa <main+0x2ca>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    $0x1,%rax
je     1410 <main+0x2e0>
mov    0x20(%rsp),%ecx
mov    0x24(%rsp,%rax,4),%edx
cmp    %edx,%ecx
jle    13f0 <main+0x2c0>
mov    %edx,0x20(%rsp)
mov    %ecx,0x24(%rsp,%rax,4)
jmp    13f0 <main+0x2c0>
lea    0xc09(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp),%esi
lea    0xbf3(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x14(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4(%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%rsp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xbad(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@.str = [29 x i8] c"Please enter ten integers. \0A\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [25 x i8] c"The list you entered is \00"
@.str.3 = [4 x i8] c"%d \00"
@.str.4 = [3 x i8] c".\0A\00"
@.str.5 = [40 x i8] c"The list sorted in descending order is \00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [10 x i32]
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %3
store i32 0, i32* %4
store i32 0, i32* %5
%6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %3
br label %7
7: ; preds = %15, %0
%8 = load i32, i32* %3
%9 = icmp slt i32 %8, 10
br i1 %9, label %10, label %18
10: ; preds = %7
%11 = load i32, i32* %3
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 %12
%14 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %13)
br label %15
15: ; preds = %10
%16 = load i32, i32* %3
%17 = add nsw i32 %16, 1
store i32 %17, i32* %3
br label %7
18: ; preds = %7
%19 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %3
br label %20
20: ; preds = %29, %18
%21 = load i32, i32* %3
%22 = icmp slt i32 %21, 10
br i1 %22, label %23, label %32
23: ; preds = %20
%24 = load i32, i32* %3
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 %25
%27 = load i32, i32* %26
%28 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %27)
br label %29
29: ; preds = %23
%30 = load i32, i32* %3
%31 = add nsw i32 %30, 1
store i32 %31, i32* %3
br label %20
32: ; preds = %20
%33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %3
br label %34
34: ; preds = %75, %32
%35 = load i32, i32* %3
%36 = icmp slt i32 %35, 9
br i1 %36, label %37, label %78
37: ; preds = %34
%38 = load i32, i32* %3
%39 = add nsw i32 %38, 1
store i32 %39, i32* %4
br label %40
40: ; preds = %71, %37
%41 = load i32, i32* %4
%42 = icmp slt i32 %41, 10
br i1 %42, label %43, label %74
43: ; preds = %40
%44 = load i32, i32* %3
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 %45
%47 = load i32, i32* %46
%48 = load i32, i32* %4
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 %49
%51 = load i32, i32* %50
%52 = icmp sgt i32 %47, %51
br i1 %52, label %53, label %69
53: ; preds = %43
%54 = load i32, i32* %3
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 %55
%57 = load i32, i32* %56
store i32 %57, i32* %5
%58 = load i32, i32* %4
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 %59
%61 = load i32, i32* %60
%62 = load i32, i32* %3
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 %63
store i32 %61, i32* %64
%65 = load i32, i32* %5
%66 = load i32, i32* %4
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 %67
store i32 %65, i32* %68
br label %70
69: ; preds = %43
br label %71
70: ; preds = %53
br label %71
71: ; preds = %70, %69
%72 = load i32, i32* %4
%73 = add nsw i32 %72, 1
store i32 %73, i32* %4
br label %40
74: ; preds = %40
br label %75
75: ; preds = %74
%76 = load i32, i32* %3
%77 = add nsw i32 %76, 1
store i32 %77, i32* %3
br label %34
78: ; preds = %34
%79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.5, i64 0, i64 0))
store i32 9, i32* %3
br label %80
80: ; preds = %89, %78
%81 = load i32, i32* %3
%82 = icmp sge i32 %81, 0
br i1 %82, label %83, label %92
83: ; preds = %80
%84 = load i32, i32* %3
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [10 x i32], [10 x i32]* %2, i64 0, i64 %85
%87 = load i32, i32* %86
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %87)
br label %89
89: ; preds = %83
%90 = load i32, i32* %3
%91 = add nsw i32 %90, -1
store i32 %91, i32* %3
br label %80
92: ; preds = %80
%93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [25 x i8] c"The list you entered is \00"
@.str.3 = [4 x i8] c"%d \00"
@.str.5 = [40 x i8] c"The list sorted in descending order is \00"
@str = [28 x i8] c"Please enter ten integers. \00"
@str.7 = [2 x i8] c".\00"
define i32 @main() {
%1 = alloca [10 x i32]
%2 = bitcast [10 x i32]* %1 to i8*
%3 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str, i64 0, i64 0))
%4 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 0
%5 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %4)
%6 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 1
%7 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %6)
%8 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 2
%9 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %8)
%10 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 3
%11 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %10)
%12 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 4
%13 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %12)
%14 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 5
%15 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %14)
%16 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 6
%17 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %16)
%18 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 7
%19 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %18)
%20 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 8
%21 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %20)
%22 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 9
%23 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %22)
%24 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0))
%25 = load i32, i32* %4
%26 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %25)
%27 = load i32, i32* %6
%28 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %27)
%29 = load i32, i32* %8
%30 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %29)
%31 = load i32, i32* %10
%32 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %31)
%33 = load i32, i32* %12
%34 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %33)
%35 = load i32, i32* %14
%36 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %35)
%37 = load i32, i32* %16
%38 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %37)
%39 = load i32, i32* %18
%40 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %39)
%41 = load i32, i32* %20
%42 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %41)
%43 = load i32, i32* %22
%44 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %43)
%45 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.7, i64 0, i64 0))
%46 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 0
%47 = load i32, i32* %46
br label %167
48: ; preds = %174
%49 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 1
br label %50
50: ; preds = %57, %48
%51 = phi i64 [ 2, %48 ], [ %58, %57 ]
%52 = load i32, i32* %49
%53 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 %51
%54 = load i32, i32* %53
%55 = icmp sgt i32 %52, %54
br i1 %55, label %56, label %57
56: ; preds = %50
store i32 %54, i32* %49
store i32 %52, i32* %53
br label %57
57: ; preds = %56, %50
%58 = add nuw nsw i64 %51, 1
%59 = icmp eq i64 %58, 10
br i1 %59, label %60, label %50
60: ; preds = %57
%61 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 2
br label %62
62: ; preds = %69, %60
%63 = phi i64 [ 3, %60 ], [ %70, %69 ]
%64 = load i32, i32* %61
%65 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 %63
%66 = load i32, i32* %65
%67 = icmp sgt i32 %64, %66
br i1 %67, label %68, label %69
68: ; preds = %62
store i32 %66, i32* %61
store i32 %64, i32* %65
br label %69
69: ; preds = %68, %62
%70 = add nuw nsw i64 %63, 1
%71 = icmp eq i64 %70, 10
br i1 %71, label %72, label %62
72: ; preds = %69
%73 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 3
br label %74
74: ; preds = %81, %72
%75 = phi i64 [ 4, %72 ], [ %82, %81 ]
%76 = load i32, i32* %73
%77 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 %75
%78 = load i32, i32* %77
%79 = icmp sgt i32 %76, %78
br i1 %79, label %80, label %81
80: ; preds = %74
store i32 %78, i32* %73
store i32 %76, i32* %77
br label %81
81: ; preds = %80, %74
%82 = add nuw nsw i64 %75, 1
%83 = icmp eq i64 %82, 10
br i1 %83, label %84, label %74
84: ; preds = %81
%85 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 4
br label %86
86: ; preds = %93, %84
%87 = phi i64 [ 5, %84 ], [ %94, %93 ]
%88 = load i32, i32* %85
%89 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 %87
%90 = load i32, i32* %89
%91 = icmp sgt i32 %88, %90
br i1 %91, label %92, label %93
92: ; preds = %86
store i32 %90, i32* %85
store i32 %88, i32* %89
br label %93
93: ; preds = %92, %86
%94 = add nuw nsw i64 %87, 1
%95 = icmp eq i64 %94, 10
br i1 %95, label %96, label %86
96: ; preds = %93
%97 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 5
br label %98
98: ; preds = %105, %96
%99 = phi i64 [ 6, %96 ], [ %106, %105 ]
%100 = load i32, i32* %97
%101 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 %99
%102 = load i32, i32* %101
%103 = icmp sgt i32 %100, %102
br i1 %103, label %104, label %105
104: ; preds = %98
store i32 %102, i32* %97
store i32 %100, i32* %101
br label %105
105: ; preds = %104, %98
%106 = add nuw nsw i64 %99, 1
%107 = icmp eq i64 %106, 10
br i1 %107, label %108, label %98
108: ; preds = %105
%109 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 6
br label %110
110: ; preds = %117, %108
%111 = phi i64 [ 7, %108 ], [ %118, %117 ]
%112 = load i32, i32* %109
%113 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 %111
%114 = load i32, i32* %113
%115 = icmp sgt i32 %112, %114
br i1 %115, label %116, label %117
116: ; preds = %110
store i32 %114, i32* %109
store i32 %112, i32* %113
br label %117
117: ; preds = %116, %110
%118 = add nuw nsw i64 %111, 1
%119 = icmp eq i64 %118, 10
br i1 %119, label %120, label %110
120: ; preds = %117
%121 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 7
br label %122
122: ; preds = %129, %120
%123 = phi i64 [ 8, %120 ], [ %130, %129 ]
%124 = load i32, i32* %121
%125 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 %123
%126 = load i32, i32* %125
%127 = icmp sgt i32 %124, %126
br i1 %127, label %128, label %129
128: ; preds = %122
store i32 %126, i32* %121
store i32 %124, i32* %125
br label %129
129: ; preds = %128, %122
%130 = add nuw nsw i64 %123, 1
%131 = icmp eq i64 %130, 10
br i1 %131, label %132, label %122
132: ; preds = %129
%133 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 8
br label %134
134: ; preds = %141, %132
%135 = phi i64 [ 9, %132 ], [ %142, %141 ]
%136 = load i32, i32* %133
%137 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 %135
%138 = load i32, i32* %137
%139 = icmp sgt i32 %136, %138
br i1 %139, label %140, label %141
140: ; preds = %134
store i32 %138, i32* %133
store i32 %136, i32* %137
br label %141
141: ; preds = %140, %134
%142 = add nuw nsw i64 %135, 1
%143 = icmp eq i64 %142, 10
br i1 %143, label %144, label %134
144: ; preds = %141
%145 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.5, i64 0, i64 0))
%146 = load i32, i32* %22
%147 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %146)
%148 = load i32, i32* %20
%149 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %148)
%150 = load i32, i32* %18
%151 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %150)
%152 = load i32, i32* %16
%153 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %152)
%154 = load i32, i32* %14
%155 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %154)
%156 = load i32, i32* %12
%157 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %156)
%158 = load i32, i32* %10
%159 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %158)
%160 = load i32, i32* %8
%161 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %160)
%162 = load i32, i32* %6
%163 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %162)
%164 = load i32, i32* %4
%165 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), i32 %164)
%166 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.7, i64 0, i64 0))
ret i32 0
167: ; preds = %0, %174
%168 = phi i32 [ %47, %0 ], [ %175, %174 ]
%169 = phi i64 [ 1, %0 ], [ %176, %174 ]
%170 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 %169
%171 = load i32, i32* %170
%172 = icmp sgt i32 %168, %171
br i1 %172, label %173, label %174
173: ; preds = %167
store i32 %171, i32* %46
store i32 %168, i32* %170
br label %174
174: ; preds = %167, %173
%175 = phi i32 [ %168, %167 ], [ %171, %173 ]
%176 = add nuw nsw i64 %169, 1
%177 = icmp eq i64 %176, 10
br i1 %177, label %48, label %167
}