#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 */
size_t *malloc(int);
size_t *realloc(size_t *, size_t);
void AddSorted(size_t value, size_t **out, size_t *outsize) {
  size_t i;
  {
    if (!((*outsize) & ((*outsize) - 1))) {
      (*out) = (*outsize) == 0
                   ? malloc(sizeof(**out))
                   : realloc((*out), (*outsize) * 2 * sizeof(**out));
    }
    (*out)[(*outsize)] = (value);
    (*outsize)++;
  };
  if (*outsize > 0) {
    for (i = 0; i < *outsize - 1; i++) {
      if ((*out)[i] > value) {
        size_t j;
        for (j = *outsize - 1; j > i; j--) {
          (*out)[j] = (*out)[j - 1];
        }
        (*out)[i] = value;
        break;
      }
    }
  }
}


x86 assembly (clang, -O0):
<AddSorted>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    119e <AddSorted+0x7e>
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jne    1174 <AddSorted+0x54>
mov    $0x8,%edi
call   1030 <malloc@plt>
mov    %rax,-0x30(%rbp)
jmp    1193 <AddSorted+0x73>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    -0x18(%rbp),%rax
mov    (%rax),%rsi
shl    $0x1,%rsi
shl    $0x3,%rsi
call   1040 <realloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jbe    128c <AddSorted+0x16c>
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    1287 <AddSorted+0x167>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmp    -0x8(%rbp),%rax
jbe    1271 <AddSorted+0x151>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
sub    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    1259 <AddSorted+0x139>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    1218 <AddSorted+0xf8>
mov    -0x8(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1287 <AddSorted+0x167>
jmp    1276 <AddSorted+0x156>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    11d8 <AddSorted+0xb8>
jmp    128c <AddSorted+0x16c>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<AddSorted>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%r12
mov    (%rdx),%rsi
lea    -0x1(%rsi),%rax
test   %rax,%rsi
jne    1153 <AddSorted+0x33>
test   %rsi,%rsi
je     1158 <AddSorted+0x38>
mov    (%r15),%rdi
shl    $0x4,%rsi
call   1040 <realloc@plt>
mov    (%r14),%rsi
jmp    1164 <AddSorted+0x44>
mov    (%r15),%rax
jmp    1167 <AddSorted+0x47>
mov    $0x8,%edi
call   1030 <malloc@plt>
xor    %esi,%esi
mov    %rax,(%r15)
mov    %r12,(%rax,%rsi,8)
mov    (%r14),%rsi
lea    0x1(%rsi),%rcx
mov    %rcx,(%r14)
lea    -0x1(%rsi),%r8
cmp    $0xfffffffffffffffd,%r8
ja     1201 <AddSorted+0xe1>
xor    %ecx,%ecx
mov    %esi,%edx
nopw   0x0(%rax,%rax,1)
cmp    %r12,(%rax,%rcx,8)
ja     11a4 <AddSorted+0x84>
add    $0x1,%rcx
add    $0x3,%dl
cmp    %rcx,%rsi
jne    1190 <AddSorted+0x70>
jmp    1201 <AddSorted+0xe1>
cmp    %rcx,%rsi
jbe    11fd <AddSorted+0xdd>
mov    %esi,%edi
sub    %ecx,%edi
sub    %rcx,%r8
test   $0x3,%dil
je     120d <AddSorted+0xed>
movzbl %dl,%edi
and    $0x3,%edi
nopl   0x0(%rax)
lea    -0x1(%rsi),%rdx
mov    -0x8(%rax,%rsi,8),%rbx
mov    %rbx,(%rax,%rsi,8)
mov    %rdx,%rsi
add    $0xffffffffffffffff,%rdi
jne    11c0 <AddSorted+0xa0>
cmp    $0x3,%r8
jb     11fd <AddSorted+0xdd>
nopl   0x0(%rax)
movups -0x20(%rax,%rdx,8),%xmm0
movups -0x10(%rax,%rdx,8),%xmm1
movups %xmm1,-0x8(%rax,%rdx,8)
movups %xmm0,-0x18(%rax,%rdx,8)
add    $0xfffffffffffffffc,%rdx
cmp    %rcx,%rdx
ja     11e0 <AddSorted+0xc0>
mov    %r12,(%rax,%rcx,8)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    %rsi,%rdx
cmp    $0x3,%r8
jae    11e0 <AddSorted+0xc0>
jmp    11fd <AddSorted+0xdd>

LLVM IR (-O0):
define void @AddSorted(i64 %0, i64** %1, i64* %2) {
%4 = alloca i64
%5 = alloca i64**
%6 = alloca i64*
%7 = alloca i64
%8 = alloca i64
store i64 %0, i64* %4
store i64** %1, i64*** %5
store i64* %2, i64** %6
%9 = load i64*, i64** %6
%10 = load i64, i64* %9
%11 = load i64*, i64** %6
%12 = load i64, i64* %11
%13 = sub i64 %12, 1
%14 = and i64 %10, %13
%15 = icmp ne i64 %14, 0
br i1 %15, label %33, label %16
16: ; preds = %3
%17 = load i64*, i64** %6
%18 = load i64, i64* %17
%19 = icmp eq i64 %18, 0
br i1 %19, label %20, label %22
20: ; preds = %16
%21 = call i64* @malloc(i32 8)
br label %30
22: ; preds = %16
%23 = load i64**, i64*** %5
%24 = load i64*, i64** %23
%25 = load i64*, i64** %6
%26 = load i64, i64* %25
%27 = mul i64 %26, 2
%28 = mul i64 %27, 8
%29 = call i64* @realloc(i64* %24, i64 %28)
br label %30
30: ; preds = %22, %20
%31 = phi i64* [ %21, %20 ], [ %29, %22 ]
%32 = load i64**, i64*** %5
store i64* %31, i64** %32
br label %33
33: ; preds = %30, %3
%34 = load i64, i64* %4
%35 = load i64**, i64*** %5
%36 = load i64*, i64** %35
%37 = load i64*, i64** %6
%38 = load i64, i64* %37
%39 = getelementptr inbounds i64, i64* %36, i64 %38
store i64 %34, i64* %39
%40 = load i64*, i64** %6
%41 = load i64, i64* %40
%42 = add i64 %41, 1
store i64 %42, i64* %40
%43 = load i64*, i64** %6
%44 = load i64, i64* %43
%45 = icmp ugt i64 %44, 0
br i1 %45, label %46, label %94
46: ; preds = %33
store i64 0, i64* %7
br label %47
47: ; preds = %90, %46
%48 = load i64, i64* %7
%49 = load i64*, i64** %6
%50 = load i64, i64* %49
%51 = sub i64 %50, 1
%52 = icmp ult i64 %48, %51
br i1 %52, label %53, label %93
53: ; preds = %47
%54 = load i64**, i64*** %5
%55 = load i64*, i64** %54
%56 = load i64, i64* %7
%57 = getelementptr inbounds i64, i64* %55, i64 %56
%58 = load i64, i64* %57
%59 = load i64, i64* %4
%60 = icmp ugt i64 %58, %59
br i1 %60, label %61, label %89
61: ; preds = %53
%62 = load i64*, i64** %6
%63 = load i64, i64* %62
%64 = sub i64 %63, 1
store i64 %64, i64* %8
br label %65
65: ; preds = %80, %61
%66 = load i64, i64* %8
%67 = load i64, i64* %7
%68 = icmp ugt i64 %66, %67
br i1 %68, label %69, label %83
69: ; preds = %65
%70 = load i64**, i64*** %5
%71 = load i64*, i64** %70
%72 = load i64, i64* %8
%73 = sub i64 %72, 1
%74 = getelementptr inbounds i64, i64* %71, i64 %73
%75 = load i64, i64* %74
%76 = load i64**, i64*** %5
%77 = load i64*, i64** %76
%78 = load i64, i64* %8
%79 = getelementptr inbounds i64, i64* %77, i64 %78
store i64 %75, i64* %79
br label %80
80: ; preds = %69
%81 = load i64, i64* %8
%82 = add i64 %81, -1
store i64 %82, i64* %8
br label %65
83: ; preds = %65
%84 = load i64, i64* %4
%85 = load i64**, i64*** %5
%86 = load i64*, i64** %85
%87 = load i64, i64* %7
%88 = getelementptr inbounds i64, i64* %86, i64 %87
store i64 %84, i64* %88
br label %93
89: ; preds = %53
br label %90
90: ; preds = %89
%91 = load i64, i64* %7
%92 = add i64 %91, 1
store i64 %92, i64* %7
br label %47
93: ; preds = %83, %47
br label %94
94: ; preds = %93, %33
ret void
}

LLVM IR (-O2):
define void @AddSorted(i64 %0, i64** nocapture %1, i64* nocapture %2) {
%4 = load i64, i64* %2
%5 = tail call i64 @llvm.ctpop.i64(i64 %4)
%6 = icmp ult i64 %5, 2
br i1 %6, label %9, label %7
7: ; preds = %3
%8 = load i64*, i64** %1
br label %21
9: ; preds = %3
%10 = icmp eq i64 %4, 0
br i1 %10, label %11, label %13
11: ; preds = %9
%12 = tail call i64* @malloc(i32 8)
br label %18
13: ; preds = %9
%14 = load i64*, i64** %1
%15 = shl i64 %4, 4
%16 = tail call i64* @realloc(i64* %14, i64 %15)
%17 = load i64, i64* %2
br label %18
18: ; preds = %13, %11
%19 = phi i64 [ 0, %11 ], [ %17, %13 ]
%20 = phi i64* [ %12, %11 ], [ %16, %13 ]
store i64* %20, i64** %1
br label %21
21: ; preds = %7, %18
%22 = phi i64 [ %4, %7 ], [ %19, %18 ]
%23 = phi i64* [ %8, %7 ], [ %20, %18 ]
%24 = getelementptr inbounds i64, i64* %23, i64 %22
store i64 %0, i64* %24
%25 = load i64, i64* %2
%26 = add i64 %25, 1
store i64 %26, i64* %2
%27 = add i64 %25, -1
%28 = icmp ult i64 %27, -2
br i1 %28, label %29, label %78
29: ; preds = %21, %75
%30 = phi i64 [ %76, %75 ], [ 0, %21 ]
%31 = getelementptr inbounds i64, i64* %23, i64 %30
%32 = load i64, i64* %31
%33 = icmp ugt i64 %32, %0
br i1 %33, label %34, label %75
34: ; preds = %29
%35 = getelementptr inbounds i64, i64* %23, i64 %30
%36 = icmp ugt i64 %25, %30
br i1 %36, label %37, label %74
37: ; preds = %34
%38 = sub i64 %25, %30
%39 = xor i64 %30, -1
%40 = add i64 %25, %39
%41 = and i64 %38, 3
%42 = icmp eq i64 %41, 0
br i1 %42, label %52, label %43
43: ; preds = %37, %43
%44 = phi i64 [ %46, %43 ], [ %25, %37 ]
%45 = phi i64 [ %50, %43 ], [ 0, %37 ]
%46 = add i64 %44, -1
%47 = getelementptr inbounds i64, i64* %23, i64 %46
%48 = load i64, i64* %47
%49 = getelementptr inbounds i64, i64* %23, i64 %44
store i64 %48, i64* %49
%50 = add i64 %45, 1
%51 = icmp eq i64 %50, %41
br i1 %51, label %52, label %43
52: ; preds = %43, %37
%53 = phi i64 [ %25, %37 ], [ %46, %43 ]
%54 = icmp ult i64 %40, 3
br i1 %54, label %74, label %55
55: ; preds = %52, %55
%56 = phi i64 [ %69, %55 ], [ %53, %52 ]
%57 = add i64 %56, -1
%58 = getelementptr inbounds i64, i64* %23, i64 %57
%59 = load i64, i64* %58
%60 = getelementptr inbounds i64, i64* %23, i64 %56
store i64 %59, i64* %60
%61 = add i64 %56, -2
%62 = getelementptr inbounds i64, i64* %23, i64 %61
%63 = load i64, i64* %62
%64 = getelementptr inbounds i64, i64* %23, i64 %57
store i64 %63, i64* %64
%65 = add i64 %56, -3
%66 = getelementptr inbounds i64, i64* %23, i64 %65
%67 = load i64, i64* %66
%68 = getelementptr inbounds i64, i64* %23, i64 %61
store i64 %67, i64* %68
%69 = add i64 %56, -4
%70 = getelementptr inbounds i64, i64* %23, i64 %69
%71 = load i64, i64* %70
%72 = getelementptr inbounds i64, i64* %23, i64 %65
store i64 %71, i64* %72
%73 = icmp ugt i64 %69, %30
br i1 %73, label %55, label %74
74: ; preds = %52, %55, %34
store i64 %0, i64* %35
br label %78
75: ; preds = %29
%76 = add nuw i64 %30, 1
%77 = icmp eq i64 %76, %25
br i1 %77, label %78, label %29
78: ; preds = %75, %74, %21
ret void
}