#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 A[100], B[100], C[100], i, n, k, j;
  printf("Enter the number of elements to be sorted: ");
  scanf("%d", &n);
  printf("Enter %d elements to be sorted: ", n);
  for (i = 1; i <= n; i++)
    scanf("%d", &A[i]);
  k = A[1];
  for (i = 1; i <= n; i++) {
    if (A[i] > k)
      k = A[i];
  }
  for (i = 0; i <= k; i++)
    C[i] = 0;
  for (j = 1; j <= n; j++)
    C[A[j]] = C[A[j]] + 1;
  for (i = 1; i <= k; i++)
    C[i] = C[i] + C[i - 1];
  for (j = n; j >= 1; j--) {
    B[C[A[j]]] = A[j];
    C[A[j]] = C[A[j]] - 1;
  }
  printf("The sorted elements are: ");
  for (i = 1; i <= n; i++)
    printf("%d ", B[i]);
  printf("\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4d0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xec7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xee5(%rip),%rdi
lea    -0x4c8(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x4c8(%rbp),%esi
lea    0xecf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4c4(%rbp)
mov    -0x4c4(%rbp),%eax
cmp    -0x4c8(%rbp),%eax
jg     11b8 <main+0x98>
movslq -0x4c4(%rbp),%rax
lea    -0x1a0(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe8d(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x4c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c4(%rbp)
jmp    1171 <main+0x51>
mov    -0x19c(%rbp),%eax
mov    %eax,-0x4cc(%rbp)
movl   $0x1,-0x4c4(%rbp)
mov    -0x4c4(%rbp),%eax
cmp    -0x4c8(%rbp),%eax
jg     1227 <main+0x107>
movslq -0x4c4(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%eax
cmp    -0x4cc(%rbp),%eax
jle    120e <main+0xee>
movslq -0x4c4(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%eax
mov    %eax,-0x4cc(%rbp)
jmp    1213 <main+0xf3>
mov    -0x4c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c4(%rbp)
jmp    11ce <main+0xae>
movl   $0x0,-0x4c4(%rbp)
mov    -0x4c4(%rbp),%eax
cmp    -0x4cc(%rbp),%eax
jg     1269 <main+0x149>
movslq -0x4c4(%rbp),%rax
movl   $0x0,-0x4c0(%rbp,%rax,4)
mov    -0x4c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c4(%rbp)
jmp    1231 <main+0x111>
movl   $0x1,-0x4d0(%rbp)
mov    -0x4d0(%rbp),%eax
cmp    -0x4c8(%rbp),%eax
jg     12c8 <main+0x1a8>
movslq -0x4d0(%rbp),%rax
movslq -0x1a0(%rbp,%rax,4),%rax
ff
mov    -0x4c0(%rbp,%rax,4),%ecx
add    $0x1,%ecx
movslq -0x4d0(%rbp),%rax
movslq -0x1a0(%rbp,%rax,4),%rax
ff
mov    %ecx,-0x4c0(%rbp,%rax,4)
mov    -0x4d0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4d0(%rbp)
jmp    1273 <main+0x153>
movl   $0x1,-0x4c4(%rbp)
mov    -0x4c4(%rbp),%eax
cmp    -0x4cc(%rbp),%eax
jg     1326 <main+0x206>
movslq -0x4c4(%rbp),%rax
mov    -0x4c0(%rbp,%rax,4),%ecx
mov    -0x4c4(%rbp),%eax
sub    $0x1,%eax
cltq
add    -0x4c0(%rbp,%rax,4),%ecx
movslq -0x4c4(%rbp),%rax
mov    %ecx,-0x4c0(%rbp,%rax,4)
mov    -0x4c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c4(%rbp)
jmp    12d2 <main+0x1b2>
mov    -0x4c8(%rbp),%eax
mov    %eax,-0x4d0(%rbp)
cmpl   $0x1,-0x4d0(%rbp)
jl     13ae <main+0x28e>
movslq -0x4d0(%rbp),%rax
mov    -0x1a0(%rbp,%rax,4),%ecx
movslq -0x4d0(%rbp),%rax
movslq -0x1a0(%rbp,%rax,4),%rax
ff
movslq -0x4c0(%rbp,%rax,4),%rax
ff
mov    %ecx,-0x330(%rbp,%rax,4)
movslq -0x4d0(%rbp),%rax
movslq -0x1a0(%rbp,%rax,4),%rax
ff
mov    -0x4c0(%rbp,%rax,4),%ecx
sub    $0x1,%ecx
movslq -0x4d0(%rbp),%rax
movslq -0x1a0(%rbp,%rax,4),%rax
ff
mov    %ecx,-0x4c0(%rbp,%rax,4)
mov    -0x4d0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4d0(%rbp)
jmp    1332 <main+0x212>
lea    0xc9b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4c4(%rbp)
mov    -0x4c4(%rbp),%eax
cmp    -0x4c8(%rbp),%eax
jg     1408 <main+0x2e8>
movslq -0x4c4(%rbp),%rax
mov    -0x330(%rbp,%rax,4),%esi
lea    0xc7d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c4(%rbp)
jmp    13c6 <main+0x2a6>
lea    0xc5f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x4d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x4c8,%rsp
lea    0xeac(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xeca(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1060 <scanf@plt>
mov    0xc(%rsp),%esi
lea    0xeb8(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp),%r15d
test   %r15d,%r15d
jle    1389 <main+0x249>
lea    0x1a4(%rsp),%rbx
xor    %ebp,%ebp
lea    0xe8f(%rip),%r14
nopl   (%rax)
mov    %r14,%rdi
mov    %rbx,%rsi
call   1060 <scanf@plt>
movslq 0xc(%rsp),%r15
add    $0x1,%rbp
add    $0x4,%rbx
cmp    %r15,%rbp
jl     11a0 <main+0x60>
mov    0x1a4(%rsp),%ebp
test   %r15d,%r15d
setle  %r14b
jle    1396 <main+0x256>
mov    %r15d,%eax
add    $0x1,%rax
cmp    $0x2,%eax
je     1399 <main+0x259>
lea    -0x2(%rax),%rdx
mov    $0x2,%ecx
mov    %ebp,%ebx
cmp    $0x8,%rdx
jb     1350 <main+0x210>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
movd   %ebp,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rcx),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     15b9 <main+0x479>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
movdqa %xmm0,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu 0x1a8(%rsp,%rsi,4),%xmm2
movdqu 0x1b8(%rsp,%rsi,4),%xmm3
movdqu 0x1c8(%rsp,%rsi,4),%xmm4
movdqu 0x1d8(%rsp,%rsi,4),%xmm5
movdqa %xmm2,%xmm6
pcmpgtd %xmm0,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm0,%xmm6
por    %xmm2,%xmm6
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
pcmpgtd %xmm6,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm6,%xmm0
por    %xmm4,%xmm0
movdqa %xmm5,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm2,%xmm1
por    %xmm5,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1230 <main+0xf0>
test   $0x1,%bl
je     12fd <main+0x1bd>
shl    $0x2,%rsi
or     $0x8,%rsi
movdqu 0x1a0(%rsp,%rsi,1),%xmm2
movdqu 0x1b0(%rsp,%rsi,1),%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%ebx
cmp    %rcx,%rdx
je     1365 <main+0x225>
or     $0x2,%rcx
mov    0x1a0(%rsp,%rcx,4),%edx
cmp    %ebx,%edx
cmovg  %edx,%ebx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1350 <main+0x210>
test   %ebx,%ebx
js     139f <main+0x25f>
mov    %ebx,%eax
lea    0x4(,%rax,4),%rdx
lea    0x10(%rsp),%rdi
xor    %esi,%esi
call   1050 <memset@plt>
test   %r14b,%r14b
je     13a8 <main+0x268>
jmp    1462 <main+0x322>
movl   $0x0,0x10(%rsp)
jmp    1466 <main+0x326>
mov    $0x1,%r14b
mov    %ebp,%ebx
test   %ebx,%ebx
jns    1369 <main+0x229>
test   %r14b,%r14b
jne    14df <main+0x39f>
movslq %ebp,%rax
lea    0x1(%r15),%esi
addl   $0x1,0x10(%rsp,%rax,4)
cmp    $0x2,%esi
je     1462 <main+0x322>
lea    -0x2(%rsi),%rcx
add    $0xfffffffffffffffd,%rsi
mov    %ecx,%eax
and    $0x3,%eax
mov    $0x2,%edx
cmp    $0x3,%rsi
jb     1436 <main+0x2f6>
and    $0xfffffffffffffffc,%rcx
neg    %rcx
mov    $0x2,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq 0x1a0(%rsp,%rdx,4),%rsi
addl   $0x1,0x10(%rsp,%rsi,4)
movslq 0x1a4(%rsp,%rdx,4),%rsi
addl   $0x1,0x10(%rsp,%rsi,4)
movslq 0x1a8(%rsp,%rdx,4),%rsi
addl   $0x1,0x10(%rsp,%rsi,4)
movslq 0x1ac(%rsp,%rdx,4),%rsi
addl   $0x1,0x10(%rsp,%rsi,4)
lea    (%rcx,%rdx,1),%rsi
add    $0x4,%rsi
add    $0x4,%rdx
cmp    $0x2,%rsi
jne    13f0 <main+0x2b0>
test   %rax,%rax
je     1462 <main+0x322>
lea    (%rsp,%rdx,4),%rcx
add    $0x1a0,%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movslq (%rcx,%rdx,4),%rsi
addl   $0x1,0x10(%rsp,%rsi,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1450 <main+0x310>
test   %ebx,%ebx
jle    14df <main+0x39f>
mov    %ebx,%esi
mov    0x10(%rsp),%eax
lea    -0x1(%rsi),%rdi
mov    %esi,%ecx
and    $0x3,%ecx
mov    $0x1,%edx
cmp    $0x3,%rdi
jb     14bd <main+0x37d>
and    $0xfffffffc,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
add    0x14(%rsp,%rdx,4),%eax
mov    %eax,0x14(%rsp,%rdx,4)
add    0x18(%rsp,%rdx,4),%eax
mov    %eax,0x18(%rsp,%rdx,4)
add    0x1c(%rsp,%rdx,4),%eax
mov    %eax,0x1c(%rsp,%rdx,4)
add    0x20(%rsp,%rdx,4),%eax
mov    %eax,0x20(%rsp,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1490 <main+0x350>
add    $0x1,%rdx
test   %rcx,%rcx
je     14df <main+0x39f>
lea    (%rsp,%rdx,4),%rdx
add    $0x10,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
add    (%rdx,%rsi,4),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    14d0 <main+0x390>
test   %r15d,%r15d
jle    1560 <main+0x420>
mov    %r15d,%eax
test   $0x1,%al
je     150a <main+0x3ca>
movslq 0x1a0(%rsp,%rax,4),%rcx
movslq 0x10(%rsp,%rcx,4),%rdx
mov    %ecx,0x330(%rsp,%rdx,4)
add    $0xffffffff,%edx
mov    %edx,0x10(%rsp,%rcx,4)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%r15d
je     1560 <main+0x420>
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq 0x19c(%rsp,%rax,4),%rcx
movslq 0x10(%rsp,%rcx,4),%rdx
mov    %ecx,0x330(%rsp,%rdx,4)
add    $0xffffffff,%edx
mov    %edx,0x10(%rsp,%rcx,4)
movslq 0x198(%rsp,%rax,4),%rcx
movslq 0x10(%rsp,%rcx,4),%rdx
mov    %ecx,0x330(%rsp,%rdx,4)
add    $0xffffffff,%edx
mov    %edx,0x10(%rsp,%rcx,4)
add    $0xfffffffffffffffe,%rax
cmp    $0x1,%rax
ja     1520 <main+0x3e0>
lea    0xae9(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cmpl   $0x0,0xc(%rsp)
jle    159f <main+0x45f>
lea    0xaee(%rip),%rbx
xor    %ebp,%ebp
xchg   %ax,%ax
mov    0x334(%rsp,%rbp,4),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movslq 0xc(%rsp),%rax
add    $0x1,%rbp
cmp    %rax,%rbp
jl     1580 <main+0x440>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0x4c8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
movdqa %xmm0,%xmm1
test   $0x1,%bl
jne    12b3 <main+0x173>
jmp    12fd <main+0x1bd>

LLVM IR (-O0):
@.str = [44 x i8] c"Enter the number of elements to be sorted: \00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [33 x i8] c"Enter %d elements to be sorted: \00"
@.str.3 = [26 x i8] c"The sorted elements are: \00"
@.str.4 = [4 x i8] c"%d \00"
@.str.5 = [2 x i8] c"\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [100 x i32]
%3 = alloca [100 x i32]
%4 = alloca [100 x i32]
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32 0, i32* %1
%9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0))
%10 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %6)
%11 = load i32, i32* %6
%12 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.2, i64 0, i64 0), i32 %11)
store i32 1, i32* %5
br label %13
13: ; preds = %22, %0
%14 = load i32, i32* %5
%15 = load i32, i32* %6
%16 = icmp sle i32 %14, %15
br i1 %16, label %17, label %25
17: ; preds = %13
%18 = load i32, i32* %5
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %19
%21 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %20)
br label %22
22: ; preds = %17
%23 = load i32, i32* %5
%24 = add nsw i32 %23, 1
store i32 %24, i32* %5
br label %13
25: ; preds = %13
%26 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 1
%27 = load i32, i32* %26
store i32 %27, i32* %7
store i32 1, i32* %5
br label %28
28: ; preds = %45, %25
%29 = load i32, i32* %5
%30 = load i32, i32* %6
%31 = icmp sle i32 %29, %30
br i1 %31, label %32, label %48
32: ; preds = %28
%33 = load i32, i32* %5
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %34
%36 = load i32, i32* %35
%37 = load i32, i32* %7
%38 = icmp sgt i32 %36, %37
br i1 %38, label %39, label %44
39: ; preds = %32
%40 = load i32, i32* %5
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %41
%43 = load i32, i32* %42
store i32 %43, i32* %7
br label %44
44: ; preds = %39, %32
br label %45
45: ; preds = %44
%46 = load i32, i32* %5
%47 = add nsw i32 %46, 1
store i32 %47, i32* %5
br label %28
48: ; preds = %28
store i32 0, i32* %5
br label %49
49: ; preds = %57, %48
%50 = load i32, i32* %5
%51 = load i32, i32* %7
%52 = icmp sle i32 %50, %51
br i1 %52, label %53, label %60
53: ; preds = %49
%54 = load i32, i32* %5
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %55
store i32 0, i32* %56
br label %57
57: ; preds = %53
%58 = load i32, i32* %5
%59 = add nsw i32 %58, 1
store i32 %59, i32* %5
br label %49
60: ; preds = %49
store i32 1, i32* %8
br label %61
61: ; preds = %80, %60
%62 = load i32, i32* %8
%63 = load i32, i32* %6
%64 = icmp sle i32 %62, %63
br i1 %64, label %65, label %83
65: ; preds = %61
%66 = load i32, i32* %8
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %67
%69 = load i32, i32* %68
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %70
%72 = load i32, i32* %71
%73 = add nsw i32 %72, 1
%74 = load i32, i32* %8
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %75
%77 = load i32, i32* %76
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %78
store i32 %73, i32* %79
br label %80
80: ; preds = %65
%81 = load i32, i32* %8
%82 = add nsw i32 %81, 1
store i32 %82, i32* %8
br label %61
83: ; preds = %61
store i32 1, i32* %5
br label %84
84: ; preds = %102, %83
%85 = load i32, i32* %5
%86 = load i32, i32* %7
%87 = icmp sle i32 %85, %86
br i1 %87, label %88, label %105
88: ; preds = %84
%89 = load i32, i32* %5
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %90
%92 = load i32, i32* %91
%93 = load i32, i32* %5
%94 = sub nsw i32 %93, 1
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %95
%97 = load i32, i32* %96
%98 = add nsw i32 %92, %97
%99 = load i32, i32* %5
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %100
store i32 %98, i32* %101
br label %102
102: ; preds = %88
%103 = load i32, i32* %5
%104 = add nsw i32 %103, 1
store i32 %104, i32* %5
br label %84
105: ; preds = %84
%106 = load i32, i32* %6
store i32 %106, i32* %8
br label %107
107: ; preds = %138, %105
%108 = load i32, i32* %8
%109 = icmp sge i32 %108, 1
br i1 %109, label %110, label %141
110: ; preds = %107
%111 = load i32, i32* %8
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %112
%114 = load i32, i32* %113
%115 = load i32, i32* %8
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %116
%118 = load i32, i32* %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %119
%121 = load i32, i32* %120
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %122
store i32 %114, i32* %123
%124 = load i32, i32* %8
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %125
%127 = load i32, i32* %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %128
%130 = load i32, i32* %129
%131 = sub nsw i32 %130, 1
%132 = load i32, i32* %8
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [100 x i32], [100 x i32]* %2, i64 0, i64 %133
%135 = load i32, i32* %134
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [100 x i32], [100 x i32]* %4, i64 0, i64 %136
store i32 %131, i32* %137
br label %138
138: ; preds = %110
%139 = load i32, i32* %8
%140 = add nsw i32 %139, -1
store i32 %140, i32* %8
br label %107
141: ; preds = %107
%142 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.3, i64 0, i64 0))
store i32 1, i32* %5
br label %143
143: ; preds = %153, %141
%144 = load i32, i32* %5
%145 = load i32, i32* %6
%146 = icmp sle i32 %144, %145
br i1 %146, label %147, label %156
147: ; preds = %143
%148 = load i32, i32* %5
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %149
%151 = load i32, i32* %150
%152 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i32 %151)
br label %153
153: ; preds = %147
%154 = load i32, i32* %5
%155 = add nsw i32 %154, 1
store i32 %155, i32* %5
br label %143
156: ; preds = %143
%157 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
ret i32 0
}

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