#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)++;
  };
  for (i = 0; i + 1 < *outsize; 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)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%rax
jae    1276 <AddSorted+0x156>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmp    -0x8(%rbp),%rax
jbe    1260 <AddSorted+0x140>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
sub    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    1248 <AddSorted+0x128>
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    1207 <AddSorted+0xe7>
mov    -0x8(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1276 <AddSorted+0x156>
jmp    1265 <AddSorted+0x145>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    11ca <AddSorted+0xaa>
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),%rcx
lea    0x1(%rcx),%r11
mov    %r11,(%r14)
cmp    $0x2,%r11
mov    $0x1,%edi
cmovae %r11,%rdi
add    $0xffffffffffffffff,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
cmp    %rsi,%rdi
je     1239 <AddSorted+0x119>
lea    0x1(%rsi),%rdx
cmp    %r12,(%rax,%rsi,8)
mov    %rdx,%rsi
jbe    1190 <AddSorted+0x70>
lea    -0x1(%rdx),%r9
cmp    %r9,%rcx
jbe    1234 <AddSorted+0x114>
mov    %rcx,%r8
sub    %rdx,%r8
lea    0x1(%r8),%esi
test   $0x3,%sil
je     11fa <AddSorted+0xda>
lea    (%rax,%rcx,8),%rdi
mov    %ecx,%ebx
sub    %r9b,%bl
movzbl %bl,%r10d
and    $0x3,%r10d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    -0x8(%rdi),%rsi
mov    %rsi,(%rdi)
add    $0xfffffffffffffff8,%rdi
add    $0x1,%rbx
cmp    %rbx,%r10
jne    11e0 <AddSorted+0xc0>
sub    %rbx,%r11
sub    %rbx,%rcx
cmp    $0x3,%r8
jb     1234 <AddSorted+0x114>
mov    -0x10(%rax,%r11,8),%rsi
mov    %rsi,(%rax,%rcx,8)
mov    -0x10(%rax,%rcx,8),%rsi
mov    %rsi,-0x8(%rax,%rcx,8)
mov    -0x20(%rax,%rcx,8),%rsi
mov    -0x18(%rax,%rcx,8),%rdi
mov    %rdi,-0x10(%rax,%rcx,8)
lea    -0x3(%rcx),%r11
mov    %rsi,-0x18(%rax,%rcx,8)
add    $0xfffffffffffffffc,%rcx
cmp    %r9,%rcx
ja     1200 <AddSorted+0xe0>
mov    %r12,-0x8(%rax,%rdx,8)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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
store i64 0, i64* %7
br label %43
43: ; preds = %86, %33
%44 = load i64, i64* %7
%45 = add i64 %44, 1
%46 = load i64*, i64** %6
%47 = load i64, i64* %46
%48 = icmp ult i64 %45, %47
br i1 %48, label %49, label %89
49: ; preds = %43
%50 = load i64**, i64*** %5
%51 = load i64*, i64** %50
%52 = load i64, i64* %7
%53 = getelementptr inbounds i64, i64* %51, i64 %52
%54 = load i64, i64* %53
%55 = load i64, i64* %4
%56 = icmp ugt i64 %54, %55
br i1 %56, label %57, label %85
57: ; preds = %49
%58 = load i64*, i64** %6
%59 = load i64, i64* %58
%60 = sub i64 %59, 1
store i64 %60, i64* %8
br label %61
61: ; preds = %76, %57
%62 = load i64, i64* %8
%63 = load i64, i64* %7
%64 = icmp ugt i64 %62, %63
br i1 %64, label %65, label %79
65: ; preds = %61
%66 = load i64**, i64*** %5
%67 = load i64*, i64** %66
%68 = load i64, i64* %8
%69 = sub i64 %68, 1
%70 = getelementptr inbounds i64, i64* %67, i64 %69
%71 = load i64, i64* %70
%72 = load i64**, i64*** %5
%73 = load i64*, i64** %72
%74 = load i64, i64* %8
%75 = getelementptr inbounds i64, i64* %73, i64 %74
store i64 %71, i64* %75
br label %76
76: ; preds = %65
%77 = load i64, i64* %8
%78 = add i64 %77, -1
store i64 %78, i64* %8
br label %61
79: ; preds = %61
%80 = load i64, i64* %4
%81 = load i64**, i64*** %5
%82 = load i64*, i64** %81
%83 = load i64, i64* %7
%84 = getelementptr inbounds i64, i64* %82, i64 %83
store i64 %80, i64* %84
br label %89
85: ; preds = %49
br label %86
86: ; preds = %85
%87 = load i64, i64* %7
%88 = add i64 %87, 1
store i64 %88, i64* %7
br label %43
89: ; preds = %79, %43
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 = call i64 @llvm.umax.i64(i64 %26, i64 1)
%28 = add i64 %27, -1
br label %29
29: ; preds = %32, %21
%30 = phi i64 [ 0, %21 ], [ %33, %32 ]
%31 = icmp eq i64 %30, %28
br i1 %31, label %86, label %32
32: ; preds = %29
%33 = add nuw i64 %30, 1
%34 = getelementptr inbounds i64, i64* %23, i64 %30
%35 = load i64, i64* %34
%36 = icmp ugt i64 %35, %0
br i1 %36, label %37, label %29
37: ; preds = %32
%38 = getelementptr inbounds i64, i64* %23, i64 %30
%39 = icmp ugt i64 %25, %30
br i1 %39, label %40, label %85
40: ; preds = %37
%41 = sub i64 %25, %30
%42 = xor i64 %30, -1
%43 = add i64 %25, %42
%44 = and i64 %41, 3
%45 = icmp eq i64 %44, 0
br i1 %45, label %57, label %46
46: ; preds = %40, %46
%47 = phi i64 [ %54, %46 ], [ %25, %40 ]
%48 = phi i64 [ %47, %46 ], [ %26, %40 ]
%49 = phi i64 [ %55, %46 ], [ 0, %40 ]
%50 = add i64 %48, -2
%51 = getelementptr inbounds i64, i64* %23, i64 %50
%52 = load i64, i64* %51
%53 = getelementptr inbounds i64, i64* %23, i64 %47
store i64 %52, i64* %53
%54 = add i64 %47, -1
%55 = add i64 %49, 1
%56 = icmp eq i64 %55, %44
br i1 %56, label %57, label %46
57: ; preds = %46, %40
%58 = phi i64 [ %25, %40 ], [ %54, %46 ]
%59 = phi i64 [ %26, %40 ], [ %47, %46 ]
%60 = icmp ult i64 %43, 3
br i1 %60, label %85, label %61
61: ; preds = %57, %61
%62 = phi i64 [ %83, %61 ], [ %58, %57 ]
%63 = phi i64 [ %78, %61 ], [ %59, %57 ]
%64 = add i64 %63, -2
%65 = getelementptr inbounds i64, i64* %23, i64 %64
%66 = load i64, i64* %65
%67 = getelementptr inbounds i64, i64* %23, i64 %62
store i64 %66, i64* %67
%68 = add i64 %62, -1
%69 = add i64 %62, -2
%70 = getelementptr inbounds i64, i64* %23, i64 %69
%71 = load i64, i64* %70
%72 = getelementptr inbounds i64, i64* %23, i64 %68
store i64 %71, i64* %72
%73 = add i64 %62, -2
%74 = add i64 %62, -3
%75 = getelementptr inbounds i64, i64* %23, i64 %74
%76 = load i64, i64* %75
%77 = getelementptr inbounds i64, i64* %23, i64 %73
store i64 %76, i64* %77
%78 = add i64 %62, -3
%79 = add i64 %62, -4
%80 = getelementptr inbounds i64, i64* %23, i64 %79
%81 = load i64, i64* %80
%82 = getelementptr inbounds i64, i64* %23, i64 %78
store i64 %81, i64* %82
%83 = add i64 %62, -4
%84 = icmp ugt i64 %83, %30
br i1 %84, label %61, label %85
85: ; preds = %57, %61, %37
store i64 %0, i64* %38
br label %86
86: ; preds = %29, %85
ret void
}