#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*/ swap(int *, int *);
void bubbleSort(int *sortMe, short start, short end) {
  short i, j, flag;
  for (j = 0; j <= end; j++) {
    for (i = 0; i < end - j; i++) {
      if (sortMe[i] > sortMe[i + 1]) {
        swap(&sortMe[i], &sortMe[i + 1]);
      }
    }
  }
}


x86 assembly (clang, -O0):
<bubbleSort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %dx,%ax
mov    %si,%cx
mov    %rdi,-0x8(%rbp)
mov    %cx,-0xa(%rbp)
mov    %ax,-0xc(%rbp)
movw   $0x0,-0x10(%rbp)
movswl -0x10(%rbp),%eax
movswl -0xc(%rbp),%ecx
cmp    %ecx,%eax
jg     11d4 <bubbleSort+0xc4>
movw   $0x0,-0xe(%rbp)
movswl -0xe(%rbp),%eax
movswl -0xc(%rbp),%ecx
movswl -0x10(%rbp),%edx
sub    %edx,%ecx
cmp    %ecx,%eax
jge    11be <bubbleSort+0xae>
mov    -0x8(%rbp),%rax
movswq -0xe(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movswl -0xe(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jle    11a8 <bubbleSort+0x98>
mov    -0x8(%rbp),%rdi
movswq -0xe(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movswl -0xe(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
call   1030 <swap@plt>
jmp    11ad <bubbleSort+0x9d>
mov    -0xe(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xe(%rbp)
jmp    1146 <bubbleSort+0x36>
jmp    11c3 <bubbleSort+0xb3>
mov    -0x10(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x10(%rbp)
jmp    1130 <bubbleSort+0x20>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bubbleSort>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %edx,%r14d
test   %r14w,%r14w
js     117a <bubbleSort+0x6a>
mov    %rdi,%rbx
xor    %r15d,%r15d
jmp    113e <bubbleSort+0x2e>
nopl   0x0(%rax)
add    $0x1,%r15d
movswl %r15w,%r15d
cmp    %r14w,%r15w
jg     117a <bubbleSort+0x6a>
mov    %r14d,%r12d
sub    %r15d,%r12d
jle    1130 <bubbleSort+0x20>
xor    %ebp,%ebp
jmp    115b <bubbleSort+0x4b>
nopw   0x0(%rax,%rax,1)
add    $0x1,%ebp
movswl %bp,%ebp
cmp    %ebp,%r12d
jle    1130 <bubbleSort+0x20>
movslq %ebp,%rax
mov    (%rbx,%rax,4),%ecx
cmp    0x4(%rbx,%rax,4),%ecx
jle    1150 <bubbleSort+0x40>
lea    (%rbx,%rax,4),%rdi
lea    (%rbx,%rax,4),%rsi
add    $0x4,%rsi
call   1030 <swap@plt>
jmp    1150 <bubbleSort+0x40>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @bubbleSort(i32* %0, i16 signext %1, i16 signext %2) {
%4 = alloca i32*
%5 = alloca i16
%6 = alloca i16
%7 = alloca i16
%8 = alloca i16
%9 = alloca i16
store i32* %0, i32** %4
store i16 %1, i16* %5
store i16 %2, i16* %6
store i16 0, i16* %8
br label %10
10: ; preds = %57, %3
%11 = load i16, i16* %8
%12 = sext i16 %11 to i32
%13 = load i16, i16* %6
%14 = sext i16 %13 to i32
%15 = icmp sle i32 %12, %14
br i1 %15, label %16, label %60
16: ; preds = %10
store i16 0, i16* %7
br label %17
17: ; preds = %53, %16
%18 = load i16, i16* %7
%19 = sext i16 %18 to i32
%20 = load i16, i16* %6
%21 = sext i16 %20 to i32
%22 = load i16, i16* %8
%23 = sext i16 %22 to i32
%24 = sub nsw i32 %21, %23
%25 = icmp slt i32 %19, %24
br i1 %25, label %26, label %56
26: ; preds = %17
%27 = load i32*, i32** %4
%28 = load i16, i16* %7
%29 = sext i16 %28 to i64
%30 = getelementptr inbounds i32, i32* %27, i64 %29
%31 = load i32, i32* %30
%32 = load i32*, i32** %4
%33 = load i16, i16* %7
%34 = sext i16 %33 to i32
%35 = add nsw i32 %34, 1
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds i32, i32* %32, i64 %36
%38 = load i32, i32* %37
%39 = icmp sgt i32 %31, %38
br i1 %39, label %40, label %52
40: ; preds = %26
%41 = load i32*, i32** %4
%42 = load i16, i16* %7
%43 = sext i16 %42 to i64
%44 = getelementptr inbounds i32, i32* %41, i64 %43
%45 = load i32*, i32** %4
%46 = load i16, i16* %7
%47 = sext i16 %46 to i32
%48 = add nsw i32 %47, 1
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i32, i32* %45, i64 %49
%51 = call i32 @swap(i32* %44, i32* %50)
br label %52
52: ; preds = %40, %26
br label %53
53: ; preds = %52
%54 = load i16, i16* %7
%55 = add i16 %54, 1
store i16 %55, i16* %7
br label %17
56: ; preds = %17
br label %57
57: ; preds = %56
%58 = load i16, i16* %8
%59 = add i16 %58, 1
store i16 %59, i16* %8
br label %10
60: ; preds = %10
ret void
}

LLVM IR (-O2):
define void @bubbleSort(i32* %0, i16 signext %1, i16 signext %2) {
%4 = sext i16 %2 to i32
%5 = icmp slt i16 %2, 0
br i1 %5, label %32, label %6
6: ; preds = %3, %28
%7 = phi i32 [ %30, %28 ], [ 0, %3 ]
%8 = trunc i32 %7 to i16
%9 = sub nsw i32 %4, %7
%10 = icmp sgt i32 %9, 0
br i1 %10, label %11, label %28
11: ; preds = %6, %23
%12 = phi i32 [ %26, %23 ], [ 0, %6 ]
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds i32, i32* %0, i64 %13
%15 = load i32, i32* %14
%16 = add nsw i32 %12, 1
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i32, i32* %0, i64 %17
%19 = load i32, i32* %18
%20 = icmp sgt i32 %15, %19
br i1 %20, label %21, label %23
21: ; preds = %11
%22 = tail call i32 @swap(i32* %14, i32* %18)
br label %23
23: ; preds = %11, %21
%24 = shl nsw i32 %12, 16
%25 = add i32 %24, 65536
%26 = ashr exact i32 %25, 16
%27 = icmp sgt i32 %9, %26
br i1 %27, label %11, label %28
28: ; preds = %23, %6
%29 = add i16 %8, 1
%30 = sext i16 %29 to i32
%31 = icmp sgt i16 %29, %2
br i1 %31, label %32, label %6
32: ; preds = %28, %3
ret void
}