#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 *calloc(int, int);
void CountingSorting(int *m, int size) {
  int *TempArray = calloc(32768, sizeof(int));
  for (int i = 0; i < size; i++) {
    TempArray[m[i]]++;
  }
  int num = 0;
  for (int i = 0; i < 32768; i++) {
    for (int j = 0; j < TempArray[i]; j++) {
      m[num] = i;
      num++;
    }
  }
}


x86 assembly (clang, -O0):
<CountingSorting>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    $0x8000,%edi
mov    $0x4,%esi
call   1030 <calloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    116c <CountingSorting+0x5c>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1139 <CountingSorting+0x29>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x8000,-0x24(%rbp)
jge    11da <CountingSorting+0xca>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11c7 <CountingSorting+0xb7>
mov    -0x24(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    118e <CountingSorting+0x7e>
jmp    11cc <CountingSorting+0xbc>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    117a <CountingSorting+0x6a>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CountingSorting>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %esi,%ebp
mov    %rdi,%r14
mov    $0x8000,%edi
mov    $0x4,%esi
call   1030 <calloc@plt>
test   %ebp,%ebp
jle    11a1 <CountingSorting+0x91>
mov    %ebp,%edx
lea    -0x1(%rdx),%rsi
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x3,%rsi
jae    1144 <CountingSorting+0x34>
xor    %esi,%esi
jmp    117c <CountingSorting+0x6c>
and    $0xfffffffc,%edx
xor    %esi,%esi
nopl   0x0(%rax)
movslq (%r14,%rsi,4),%rdi
addl   $0x1,(%rax,%rdi,4)
movslq 0x4(%r14,%rsi,4),%rdi
addl   $0x1,(%rax,%rdi,4)
movslq 0x8(%r14,%rsi,4),%rdi
addl   $0x1,(%rax,%rdi,4)
movslq 0xc(%r14,%rsi,4),%rdi
addl   $0x1,(%rax,%rdi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1150 <CountingSorting+0x40>
test   %rcx,%rcx
je     11a1 <CountingSorting+0x91>
lea    (%r14,%rsi,4),%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movslq (%rdx,%rsi,4),%rdi
addl   $0x1,(%rax,%rdi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1190 <CountingSorting+0x80>
lea    0x70(%r14),%r8
lea    0x10(%r14),%r9
xor    %esi,%esi
xor    %edi,%edi
jmp    11c1 <CountingSorting+0xb1>
nop
add    $0x1,%rsi
cmp    $0x8000,%rsi
je     12b2 <CountingSorting+0x1a2>
mov    (%rax,%rsi,4),%ebp
test   %ebp,%ebp
jle    11b0 <CountingSorting+0xa0>
movslq %edi,%rdi
lea    -0x1(%rbp),%r10d
xor    %r11d,%r11d
cmp    $0x7,%r10d
jb     1290 <CountingSorting+0x180>
add    $0x1,%r10
mov    %r10,%r11
and    $0xfffffffffffffff8,%r11
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r11),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r15d
and    $0x3,%r15d
cmp    $0x18,%rcx
jae    1210 <CountingSorting+0x100>
xor    %ebx,%ebx
jmp    1259 <CountingSorting+0x149>
and    $0xfffffffffffffffc,%rdx
lea    (%r8,%rdi,4),%rcx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movdqu %xmm0,-0x70(%rcx,%rbx,4)
movdqu %xmm0,-0x60(%rcx,%rbx,4)
movdqu %xmm0,-0x50(%rcx,%rbx,4)
movdqu %xmm0,-0x40(%rcx,%rbx,4)
movdqu %xmm0,-0x30(%rcx,%rbx,4)
movdqu %xmm0,-0x20(%rcx,%rbx,4)
movdqu %xmm0,-0x10(%rcx,%rbx,4)
movdqu %xmm0,(%rcx,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdx
jne    1220 <CountingSorting+0x110>
test   %r15,%r15
je     1284 <CountingSorting+0x174>
add    %rdi,%rbx
lea    (%r9,%rbx,4),%rcx
shl    $0x5,%r15
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rcx,%rdx,1)
movdqu %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r15
jne    1270 <CountingSorting+0x160>
add    %r11,%rdi
cmp    %r11,%r10
je     11b0 <CountingSorting+0xa0>
sub    %r11d,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %esi,(%r14,%rdi,4)
add    $0x1,%rdi
add    $0xffffffff,%ebp
jne    12a0 <CountingSorting+0x190>
jmp    11b0 <CountingSorting+0xa0>
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @CountingSorting(i32* nocapture %0, i32 %1) {
%3 = tail call i32* @calloc(i32 32768, i32 4)
%4 = icmp sgt i32 %1, 0
br i1 %4, label %5, label %60
5: ; preds = %2
%6 = zext i32 %1 to i64
%7 = add nsw i64 %6, -1
%8 = and i64 %6, 3
%9 = icmp ult i64 %7, 3
br i1 %9, label %45, label %10
10: ; preds = %5
%11 = and i64 %6, 4294967292
br label %12
12: ; preds = %12, %10
%13 = phi i64 [ 0, %10 ], [ %42, %12 ]
%14 = phi i64 [ 0, %10 ], [ %43, %12 ]
%15 = getelementptr inbounds i32, i32* %0, i64 %13
%16 = load i32, i32* %15
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i32, i32* %3, i64 %17
%19 = load i32, i32* %18
%20 = add nsw i32 %19, 1
store i32 %20, i32* %18
%21 = or i64 %13, 1
%22 = getelementptr inbounds i32, i32* %0, i64 %21
%23 = load i32, i32* %22
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i32, i32* %3, i64 %24
%26 = load i32, i32* %25
%27 = add nsw i32 %26, 1
store i32 %27, i32* %25
%28 = or i64 %13, 2
%29 = getelementptr inbounds i32, i32* %0, i64 %28
%30 = load i32, i32* %29
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i32, i32* %3, i64 %31
%33 = load i32, i32* %32
%34 = add nsw i32 %33, 1
store i32 %34, i32* %32
%35 = or i64 %13, 3
%36 = getelementptr inbounds i32, i32* %0, i64 %35
%37 = load i32, i32* %36
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i32, i32* %3, i64 %38
%40 = load i32, i32* %39
%41 = add nsw i32 %40, 1
store i32 %41, i32* %39
%42 = add nuw nsw i64 %13, 4
%43 = add i64 %14, 4
%44 = icmp eq i64 %43, %11
br i1 %44, label %45, label %12
45: ; preds = %12, %5
%46 = phi i64 [ 0, %5 ], [ %42, %12 ]
%47 = icmp eq i64 %8, 0
br i1 %47, label %60, label %48
48: ; preds = %45, %48
%49 = phi i64 [ %57, %48 ], [ %46, %45 ]
%50 = phi i64 [ %58, %48 ], [ 0, %45 ]
%51 = getelementptr inbounds i32, i32* %0, i64 %49
%52 = load i32, i32* %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32, i32* %3, i64 %53
%55 = load i32, i32* %54
%56 = add nsw i32 %55, 1
store i32 %56, i32* %54
%57 = add nuw nsw i64 %49, 1
%58 = add i64 %50, 1
%59 = icmp eq i64 %58, %8
br i1 %59, label %60, label %48
60: ; preds = %45, %48, %2
br label %61
61: ; preds = %60, %141
%62 = phi i64 [ %143, %141 ], [ 0, %60 ]
%63 = phi i32 [ %142, %141 ], [ 0, %60 ]
%64 = getelementptr inbounds i32, i32* %3, i64 %62
%65 = load i32, i32* %64
%66 = icmp sgt i32 %65, 0
br i1 %66, label %67, label %141
67: ; preds = %61
%68 = sext i32 %63 to i64
%69 = trunc i64 %62 to i32
%70 = add i32 %65, -1
%71 = zext i32 %70 to i64
%72 = add nuw nsw i64 %71, 1
%73 = icmp ult i32 %70, 7
br i1 %73, label %134, label %74
74: ; preds = %67
%75 = and i64 %72, 8589934584
%76 = add nsw i64 %75, %68
%77 = trunc i64 %75 to i32
%78 = insertelement <4 x i32> poison, i32 %69, i64 0
%79 = shufflevector <4 x i32> %78, <4 x i32> poison, <4 x i32> zeroinitializer
%80 = insertelement <4 x i32> poison, i32 %69, i64 0
%81 = shufflevector <4 x i32> %80, <4 x i32> poison, <4 x i32> zeroinitializer
%82 = add nsw i64 %75, -8
%83 = lshr exact i64 %82, 3
%84 = add nuw nsw i64 %83, 1
%85 = and i64 %84, 3
%86 = icmp ult i64 %82, 24
br i1 %86, label %118, label %87
87: ; preds = %74
%88 = and i64 %84, 4611686018427387900
br label %89
89: ; preds = %89, %87
%90 = phi i64 [ 0, %87 ], [ %115, %89 ]
%91 = phi i64 [ 0, %87 ], [ %116, %89 ]
%92 = add i64 %90, %68
%93 = getelementptr inbounds i32, i32* %0, i64 %92
%94 = bitcast i32* %93 to <4 x i32>*
store <4 x i32> %79, <4 x i32>* %94
%95 = getelementptr inbounds i32, i32* %93, i64 4
%96 = bitcast i32* %95 to <4 x i32>*
store <4 x i32> %81, <4 x i32>* %96
%97 = or i64 %90, 8
%98 = add i64 %97, %68
%99 = getelementptr inbounds i32, i32* %0, i64 %98
%100 = bitcast i32* %99 to <4 x i32>*
store <4 x i32> %79, <4 x i32>* %100
%101 = getelementptr inbounds i32, i32* %99, i64 4
%102 = bitcast i32* %101 to <4 x i32>*
store <4 x i32> %81, <4 x i32>* %102
%103 = or i64 %90, 16
%104 = add i64 %103, %68
%105 = getelementptr inbounds i32, i32* %0, i64 %104
%106 = bitcast i32* %105 to <4 x i32>*
store <4 x i32> %79, <4 x i32>* %106
%107 = getelementptr inbounds i32, i32* %105, i64 4
%108 = bitcast i32* %107 to <4 x i32>*
store <4 x i32> %81, <4 x i32>* %108
%109 = or i64 %90, 24
%110 = add i64 %109, %68
%111 = getelementptr inbounds i32, i32* %0, i64 %110
%112 = bitcast i32* %111 to <4 x i32>*
store <4 x i32> %79, <4 x i32>* %112
%113 = getelementptr inbounds i32, i32* %111, i64 4
%114 = bitcast i32* %113 to <4 x i32>*
store <4 x i32> %81, <4 x i32>* %114
%115 = add nuw i64 %90, 32
%116 = add i64 %91, 4
%117 = icmp eq i64 %116, %88
br i1 %117, label %118, label %89
118: ; preds = %89, %74
%119 = phi i64 [ 0, %74 ], [ %115, %89 ]
%120 = icmp eq i64 %85, 0
br i1 %120, label %132, label %121
121: ; preds = %118, %121
%122 = phi i64 [ %129, %121 ], [ %119, %118 ]
%123 = phi i64 [ %130, %121 ], [ 0, %118 ]
%124 = add i64 %122, %68
%125 = getelementptr inbounds i32, i32* %0, i64 %124
%126 = bitcast i32* %125 to <4 x i32>*
store <4 x i32> %79, <4 x i32>* %126
%127 = getelementptr inbounds i32, i32* %125, i64 4
%128 = bitcast i32* %127 to <4 x i32>*
store <4 x i32> %81, <4 x i32>* %128
%129 = add nuw i64 %122, 8
%130 = add i64 %123, 1
%131 = icmp eq i64 %130, %85
br i1 %131, label %132, label %121
132: ; preds = %121, %118
%133 = icmp eq i64 %72, %75
br i1 %133, label %138, label %134
134: ; preds = %67, %132
%135 = phi i64 [ %68, %67 ], [ %76, %132 ]
%136 = phi i32 [ 0, %67 ], [ %77, %132 ]
br label %145
137: ; preds = %141
ret void
138: ; preds = %145, %132
%139 = phi i64 [ %76, %132 ], [ %149, %145 ]
%140 = trunc i64 %139 to i32
br label %141
141: ; preds = %138, %61
%142 = phi i32 [ %63, %61 ], [ %140, %138 ]
%143 = add nuw nsw i64 %62, 1
%144 = icmp eq i64 %143, 32768
br i1 %144, label %137, label %61
145: ; preds = %134, %145
%146 = phi i64 [ %149, %145 ], [ %135, %134 ]
%147 = phi i32 [ %150, %145 ], [ %136, %134 ]
%148 = getelementptr inbounds i32, i32* %0, i64 %146
store i32 %69, i32* %148
%149 = add nsw i64 %146, 1
%150 = add nuw nsw i32 %147, 1
%151 = icmp eq i32 %150, %65
br i1 %151, label %138, label %145
}