#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(unsigned long *, unsigned long *);
void PartitionArray(unsigned long *a, int left, int right, int *PivotLoc) {
  *PivotLoc = left;
  while (1) {
    while (*(a + (*PivotLoc)) <= *(a + right) && *PivotLoc != right) {
      right--;
    }
    if (*PivotLoc == right) {
      break;
    } else if (*(a + (*PivotLoc)) > *(a + right)) {
      Swap((a + (*PivotLoc)), (a + right));
      *PivotLoc = right;
      left++;
    }
    while (*(a + (*PivotLoc)) >= *(a + left) && *PivotLoc != left) {
      left++;
    }
    if (*PivotLoc == left) {
      break;
    } else if (*(a + (*PivotLoc)) < *(a + left)) {
      Swap((a + (*PivotLoc)), (a + left));
      *PivotLoc = left;
      right--;
    }
  }
}


x86 assembly (clang, -O0):
<PartitionArray>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    1134 <PartitionArray+0x24>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x8(%rbp),%rdx
movslq -0x10(%rbp),%rsi
xor    %eax,%eax
cmp    (%rdx,%rsi,8),%rcx
mov    %al,-0x19(%rbp)
ja     1169 <PartitionArray+0x59>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
cmp    -0x10(%rbp),%eax
setne  %al
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%al
test   $0x1,%al
jne    1179 <PartitionArray+0x69>
jmp    1187 <PartitionArray+0x77>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1134 <PartitionArray+0x24>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
cmp    -0x10(%rbp),%eax
jne    119b <PartitionArray+0x8b>
jmp    12c8 <PartitionArray+0x1b8>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jbe    11f4 <PartitionArray+0xe4>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rax
movslq (%rax),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
call   1030 <Swap@plt>
mov    -0x10(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11f9 <PartitionArray+0xe9>
jmp    11fe <PartitionArray+0xee>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x8(%rbp),%rdx
movslq -0xc(%rbp),%rsi
xor    %eax,%eax
cmp    (%rdx,%rsi,8),%rcx
mov    %al,-0x1a(%rbp)
jb     1233 <PartitionArray+0x123>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
cmp    -0xc(%rbp),%eax
setne  %al
mov    %al,-0x1a(%rbp)
mov    -0x1a(%rbp),%al
test   $0x1,%al
jne    1243 <PartitionArray+0x133>
jmp    1251 <PartitionArray+0x141>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11fe <PartitionArray+0xee>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
cmp    -0xc(%rbp),%eax
jne    1265 <PartitionArray+0x155>
jmp    12c8 <PartitionArray+0x1b8>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%rcx
movslq -0xc(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jae    12be <PartitionArray+0x1ae>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rax
movslq (%rax),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
call   1030 <Swap@plt>
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    12c3 <PartitionArray+0x1b3>
jmp    112f <PartitionArray+0x1f>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<PartitionArray>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdi,%r10
mov    %rcx,0x10(%rsp)
mov    %esi,(%rcx)
lea    0x8(%rdi),%rax
mov    %rax,0x20(%rsp)
lea    -0x8(%rdi),%rax
mov    %rax,0x18(%rsp)
movabs $0xffffffff00000000,%r13
ff ff ff
mov    %esi,%r11d
mov    %rdi,0x8(%rsp)
jmp    1177 <PartitionArray+0x67>
xchg   %ax,%ax
mov    %rax,%rsi
mov    %rdx,%rbx
mov    %r11,%rbp
call   1030 <Swap@plt>
mov    %rbp,%r11
mov    %rbx,%rdx
mov    0x8(%rsp),%r10
mov    0x10(%rsp),%rax
mov    %r11d,(%rax)
sub    %r14d,%edx
mov    %r11d,%esi
movslq %esi,%r8
lea    (%r10,%r8,8),%rdi
mov    (%r10,%r8,8),%r9
movslq %edx,%rbx
mov    0x20(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    %rbx,%r12
shl    $0x20,%r12
movabs $0x100000000,%rcx
add    %rcx,%r12
sub    %r8,%rbx
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
mov    %r14,%rbp
add    %r13,%r12
mov    -0x8(%rax),%rcx
add    $0xfffffffffffffff8,%rax
add    $0x1,%r14
cmp    %rcx,%r9
ja     11cc <PartitionArray+0xbc>
cmp    %rbp,%rbx
jne    11b0 <PartitionArray+0xa0>
cmp    %rbp,%rbx
je     1269 <PartitionArray+0x159>
lea    0x1(%rdx),%r15d
sub    %r14,%r15
cmp    %rcx,%r9
jbe    1218 <PartitionArray+0x108>
mov    %rax,%rsi
mov    %rdx,%rbx
mov    %r11,%rbp
call   1030 <Swap@plt>
mov    %rbp,%r11
mov    %rbx,%rdx
mov    0x8(%rsp),%r10
mov    0x10(%rsp),%rax
mov    %r15d,(%rax)
add    $0x1,%r11d
mov    %r12,%r8
sar    $0x20,%r8
sar    $0x1d,%r12
mov    (%r10,%r12,1),%r9
mov    %r15d,%esi
lea    (%r10,%r8,8),%rdi
mov    %r11,%r12
movslq %r11d,%r11
mov    0x18(%rsp),%rax
lea    (%rax,%r11,8),%rax
sub    %r8,%r11
xor    %ecx,%ecx
mov    %rcx,%rbp
mov    0x8(%rax),%rbx
add    $0x8,%rax
add    $0xffffffffffffffff,%rcx
cmp    %rbx,%r9
jb     1249 <PartitionArray+0x139>
cmp    %rbp,%r11
jne    1230 <PartitionArray+0x120>
cmp    %rbp,%r11
je     1269 <PartitionArray+0x159>
mov    %r12,%r11
add    $0xffffffff,%r11d
sub    %rcx,%r11
cmp    %rbx,%r9
jb     1150 <PartitionArray+0x40>
mov    %r15d,%edx
jmp    1177 <PartitionArray+0x67>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @PartitionArray(i64* %0, i32 %1, i32 %2, i32* %3) {
%5 = alloca i64*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32*
store i64* %0, i64** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32* %3, i32** %8
%9 = load i32, i32* %6
%10 = load i32*, i32** %8
store i32 %9, i32* %10
br label %11
11: ; preds = %4, %129
br label %12
12: ; preds = %32, %11
%13 = load i64*, i64** %5
%14 = load i32*, i32** %8
%15 = load i32, i32* %14
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i64, i64* %13, i64 %16
%18 = load i64, i64* %17
%19 = load i64*, i64** %5
%20 = load i32, i32* %7
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i64, i64* %19, i64 %21
%23 = load i64, i64* %22
%24 = icmp ule i64 %18, %23
br i1 %24, label %25, label %30
25: ; preds = %12
%26 = load i32*, i32** %8
%27 = load i32, i32* %26
%28 = load i32, i32* %7
%29 = icmp ne i32 %27, %28
br label %30
30: ; preds = %25, %12
%31 = phi i1 [ false, %12 ], [ %29, %25 ]
br i1 %31, label %32, label %35
32: ; preds = %30
%33 = load i32, i32* %7
%34 = add nsw i32 %33, -1
store i32 %34, i32* %7
br label %12
35: ; preds = %30
%36 = load i32*, i32** %8
%37 = load i32, i32* %36
%38 = load i32, i32* %7
%39 = icmp eq i32 %37, %38
br i1 %39, label %40, label %41
40: ; preds = %35
br label %130
41: ; preds = %35
%42 = load i64*, i64** %5
%43 = load i32*, i32** %8
%44 = load i32, i32* %43
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i64, i64* %42, i64 %45
%47 = load i64, i64* %46
%48 = load i64*, i64** %5
%49 = load i32, i32* %7
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i64, i64* %48, i64 %50
%52 = load i64, i64* %51
%53 = icmp ugt i64 %47, %52
br i1 %53, label %54, label %69
54: ; preds = %41
%55 = load i64*, i64** %5
%56 = load i32*, i32** %8
%57 = load i32, i32* %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i64, i64* %55, i64 %58
%60 = load i64*, i64** %5
%61 = load i32, i32* %7
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i64, i64* %60, i64 %62
%64 = call i32 @Swap(i64* %59, i64* %63)
%65 = load i32, i32* %7
%66 = load i32*, i32** %8
store i32 %65, i32* %66
%67 = load i32, i32* %6
%68 = add nsw i32 %67, 1
store i32 %68, i32* %6
br label %69
69: ; preds = %54, %41
br label %70
70: ; preds = %69
br label %71
71: ; preds = %91, %70
%72 = load i64*, i64** %5
%73 = load i32*, i32** %8
%74 = load i32, i32* %73
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i64, i64* %72, i64 %75
%77 = load i64, i64* %76
%78 = load i64*, i64** %5
%79 = load i32, i32* %6
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i64, i64* %78, i64 %80
%82 = load i64, i64* %81
%83 = icmp uge i64 %77, %82
br i1 %83, label %84, label %89
84: ; preds = %71
%85 = load i32*, i32** %8
%86 = load i32, i32* %85
%87 = load i32, i32* %6
%88 = icmp ne i32 %86, %87
br label %89
89: ; preds = %84, %71
%90 = phi i1 [ false, %71 ], [ %88, %84 ]
br i1 %90, label %91, label %94
91: ; preds = %89
%92 = load i32, i32* %6
%93 = add nsw i32 %92, 1
store i32 %93, i32* %6
br label %71
94: ; preds = %89
%95 = load i32*, i32** %8
%96 = load i32, i32* %95
%97 = load i32, i32* %6
%98 = icmp eq i32 %96, %97
br i1 %98, label %99, label %100
99: ; preds = %94
br label %130
100: ; preds = %94
%101 = load i64*, i64** %5
%102 = load i32*, i32** %8
%103 = load i32, i32* %102
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i64, i64* %101, i64 %104
%106 = load i64, i64* %105
%107 = load i64*, i64** %5
%108 = load i32, i32* %6
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i64, i64* %107, i64 %109
%111 = load i64, i64* %110
%112 = icmp ult i64 %106, %111
br i1 %112, label %113, label %128
113: ; preds = %100
%114 = load i64*, i64** %5
%115 = load i32*, i32** %8
%116 = load i32, i32* %115
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i64, i64* %114, i64 %117
%119 = load i64*, i64** %5
%120 = load i32, i32* %6
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i64, i64* %119, i64 %121
%123 = call i32 @Swap(i64* %118, i64* %122)
%124 = load i32, i32* %6
%125 = load i32*, i32** %8
store i32 %124, i32* %125
%126 = load i32, i32* %7
%127 = add nsw i32 %126, -1
store i32 %127, i32* %7
br label %128
128: ; preds = %113, %100
br label %129
129: ; preds = %128
br label %11
130: ; preds = %99, %40
ret void
}

LLVM IR (-O2):
define void @PartitionArray(i64* %0, i32 %1, i32 %2, i32* nocapture %3) {
store i32 %1, i32* %3
br label %5
5: ; preds = %51, %4
%6 = phi i32 [ %1, %4 ], [ %52, %51 ]
%7 = phi i32 [ %2, %4 ], [ %53, %51 ]
%8 = phi i32 [ %1, %4 ], [ %49, %51 ]
%9 = sext i32 %6 to i64
%10 = getelementptr inbounds i64, i64* %0, i64 %9
%11 = load i64, i64* %10
%12 = sext i32 %7 to i64
br label %13
13: ; preds = %13, %5
%14 = phi i64 [ %20, %13 ], [ %12, %5 ]
%15 = getelementptr inbounds i64, i64* %0, i64 %14
%16 = load i64, i64* %15
%17 = icmp ugt i64 %11, %16
%18 = icmp eq i64 %14, %9
%19 = select i1 %17, i1 true, i1 %18
%20 = add nsw i64 %14, -1
br i1 %19, label %21, label %13
21: ; preds = %13
%22 = getelementptr inbounds i64, i64* %0, i64 %14
%23 = trunc i64 %14 to i32
br i1 %18, label %57, label %24
24: ; preds = %21
br i1 %17, label %25, label %32
25: ; preds = %24
%26 = tail call i32 @Swap(i64* %10, i64* %22)
store i32 %23, i32* %3
%27 = add nsw i32 %8, 1
%28 = shl i64 %14, 32
%29 = ashr exact i64 %28, 32
%30 = getelementptr inbounds i64, i64* %0, i64 %29
%31 = load i64, i64* %30
br label %32
32: ; preds = %24, %25
%33 = phi i64 [ %11, %24 ], [ %31, %25 ]
%34 = phi i64 [ %9, %24 ], [ %29, %25 ]
%35 = phi i32 [ %6, %24 ], [ %23, %25 ]
%36 = phi i32 [ %8, %24 ], [ %27, %25 ]
%37 = getelementptr inbounds i64, i64* %0, i64 %34
%38 = sext i32 %36 to i64
br label %39
39: ; preds = %39, %32
%40 = phi i64 [ %46, %39 ], [ %38, %32 ]
%41 = getelementptr inbounds i64, i64* %0, i64 %40
%42 = load i64, i64* %41
%43 = icmp ult i64 %33, %42
%44 = icmp eq i64 %40, %34
%45 = select i1 %43, i1 true, i1 %44
%46 = add nsw i64 %40, 1
br i1 %45, label %47, label %39
47: ; preds = %39
%48 = getelementptr inbounds i64, i64* %0, i64 %40
%49 = trunc i64 %40 to i32
br i1 %44, label %57, label %50
50: ; preds = %47
br i1 %43, label %54, label %51
51: ; preds = %50, %54
%52 = phi i32 [ %49, %54 ], [ %35, %50 ]
%53 = phi i32 [ %56, %54 ], [ %23, %50 ]
br label %5
54: ; preds = %50
%55 = tail call i32 @Swap(i64* %37, i64* %48)
store i32 %49, i32* %3
%56 = add nsw i32 %23, -1
br label %51
57: ; preds = %47, %21
ret void
}