LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_create_element
static struct node *const unordered_map_create_element(unordered_map me,
                                                       const unsigned long hash,
                                                       const void *const key,
                                                       const void *const value)
{
    struct node *const init = malloc(sizeof(struct node));
    if (!init) {
        return NULL;
    }
    init->key = malloc(me->key_size);
    if (!init->key) {
        free(init);
        return NULL;
    }
    memcpy(init->key, key, me->key_size);
    init->value = malloc(me->value_size);
    if (!init->value) {
        free(init->key);
        free(init);
        return NULL;
    }
    memcpy(init->value, value, me->value_size);
    init->hash = hash;
    init->next = NULL;
    return init;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r12
movl $0x20, %edi
callq 0x1080
testq %rax, %rax
je 0x19f6
movq %rax, %rbx
movq %r14, (%rsp)
movq (%r12), %r14
movq %r14, %rdi
callq 0x1080
movq %rax, (%rbx)
testq %rax, %rax
je 0x19ee
movq %rax, %rbp
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1070
movq 0x8(%r12), %r14
movq %r14, %rdi
callq 0x1080
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x19e6
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1070
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
jmp 0x19f8
movq %rbp, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_get
bool unordered_map_get(void *const value, unordered_map me, void *const key)
{
    const unsigned long hash = me->hash(key);
    const int index = (int) (hash % me->capacity);
    struct node *traverse = me->buckets[index];
    while (traverse) {
        if (unordered_map_is_equal(me, traverse, hash, key)) {
            memcpy(value, traverse->value, me->value_size);
            return true;
        }
        traverse = traverse->next;
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq *0x10(%rsi)
movq %rax, %r12
movslq 0x24(%r14), %rcx
xorl %edx, %edx
divq %rcx
movq 0x28(%r14), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r13
testq %r13, %r13
setne %bpl
je 0x1a6f
cmpq %r12, 0x10(%r13)
jne 0x1a59
movq (%r13), %rdi
movq %r15, %rsi
callq *0x18(%r14)
testl %eax, %eax
je 0x1a5f
movq 0x18(%r13), %r13
jmp 0x1a3b
movq 0x8(%r13), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1070
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_contains
bool unordered_map_contains(unordered_map me, void *const key)
{
    const unsigned long hash = me->hash(key);
    const int index = (int) (hash % me->capacity);
    const struct node *traverse = me->buckets[index];
    while (traverse) {
        if (unordered_map_is_equal(me, traverse, hash, key)) {
            return true;
        }
        traverse = traverse->next;
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq *0x10(%r14)
movq %rax, %r15
movslq 0x24(%r14), %rcx
xorl %edx, %edx
divq %rcx
movq 0x28(%r14), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r12
testq %r12, %r12
setne %bpl
je 0x1ad6
cmpq %r15, 0x10(%r12)
jne 0x1acf
movq (%r12), %rdi
movq %rbx, %rsi
callq *0x18(%r14)
testl %eax, %eax
je 0x1ad6
movq 0x18(%r12), %r12
jmp 0x1ab0
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_remove
bool unordered_map_remove(unordered_map me, void *const key)
{
    const unsigned long hash = me->hash(key);
    const int index = (int) (hash % me->capacity);
    if (!me->buckets[index]) {
        return false;
    }
    struct node *traverse = me->buckets[index];
    if (unordered_map_is_equal(me, traverse, hash, key)) {
        me->buckets[index] = traverse->next;
        free(traverse->key);
        free(traverse->value);
        free(traverse);
        me->size--;
        return true;
    }
    while (traverse->next) {
        if (unordered_map_is_equal(me, traverse->next, hash, key)) {
            struct node *const backup = traverse->next;
            traverse->next = traverse->next->next;
            free(backup->key);
            free(backup->value);
            free(backup);
            me->size--;
            return true;
        }
        traverse = traverse->next;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq *0x10(%rbx)
movq %rax, %r12
movslq 0x24(%rbx), %rsi
xorl %ecx, %ecx
xorl %edx, %edx
divq %rsi
movq 0x28(%rbx), %rax
movslq %edx, %r13
movq (%rax,%r13,8), %r14
testq %r14, %r14
je 0x1b9c
cmpq %r12, 0x10(%r14)
jne 0x1b2f
movq (%r14), %rdi
movq %r15, %rsi
callq *0x18(%rbx)
testl %eax, %eax
je 0x1b63
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x1b5f
addq $0x18, %r14
cmpq %r12, 0x10(%rax)
jne 0x1b4f
movq (%rax), %rdi
movq %r15, %rsi
callq *0x18(%rbx)
testl %eax, %eax
je 0x1b71
movq (%r14), %r14
movq 0x18(%r14), %rax
addq $0x18, %r14
testq %rax, %rax
jne 0x1b3c
xorl %ecx, %ecx
jmp 0x1b9c
movq 0x18(%r14), %rax
movq 0x28(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
jmp 0x1b7e
movq (%r14), %rax
movq 0x18(%rax), %rcx
movq %rcx, (%r14)
movq %rax, %r14
movq (%r14), %rdi
callq 0x1030
movq 0x8(%r14), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
decl 0x20(%rbx)
movb $0x1, %cl
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_clear
int unordered_map_clear(unordered_map me)
{
    struct node **temp =
            calloc((size_t) STARTING_BUCKETS, sizeof(struct node *));
    if (!temp) {
        return -ENOMEM;
    }
    for (int i = 0; i < me->capacity; i++) {
        struct node *traverse = me->buckets[i];
        while (traverse) {
            struct node *const backup = traverse;
            traverse = traverse->next;
            free(backup->key);
            free(backup->value);
            free(backup);
        }
        me->buckets[i] = NULL;
    }
    me->size = 0;
    me->capacity = STARTING_BUCKETS;
    free(me->buckets);
    me->buckets = temp;
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x8, %edi
movl $0x8, %esi
callq 0x1050
testq %rax, %rax
je 0x1c3d
movq %rax, %r14
cmpl $0x0, 0x24(%rbx)
jle 0x1c1e
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %r15
testq %r15, %r15
je 0x1c06
movq (%r15), %rdi
movq 0x18(%r15), %r13
callq 0x1030
movq 0x8(%r15), %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
movq %r13, %r15
testq %r13, %r13
jne 0x1be1
movq 0x28(%rbx), %rax
movq $0x0, (%rax,%r12,8)
incq %r12
movslq 0x24(%rbx), %rax
cmpq %rax, %r12
jl 0x1bd4
movabsq $0x800000000, %rax      # imm = 0x800000000
movq %rax, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x1030
movq %r14, 0x28(%rbx)
xorl %eax, %eax
jmp 0x1c42
movl $0xfffffff4, %eax       # imm = 0xFFFFFFF4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_destroy
unordered_map unordered_map_destroy(unordered_map me)
{
    unordered_map_clear(me);
    free(me->buckets);
    free(me);
    return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1ba8
movq 0x28(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/hexify.cc
// Function: main
int main()
{
	const string hexdigits = "0123456789ABCDEF";  // possible hex digits

	cout << "Enter a series of numbers between 0 and 15"
	     << " separated by spaces.  Hit ENTER when finished: " 
	     << endl;
	string result;        // will hold the resulting hexify'd string

	string::size_type n;  // hold numbers from the input
	while (cin >> n)
		if (n < hexdigits.size())    // ignore invalid input
			result += hexdigits[n];  // fetch the indicated hex digit

	cout << "Your hex number is: " << result << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xda7(%rip), %rsi       # 0x2004
leaq 0xdb0(%rip), %rdx       # 0x2014
leaq -0x70(%rbp), %rdi
callq 0x13f2
movq 0x2d5c(%rip), %rdi      # 0x3fd0
leaq 0xd9a(%rip), %rsi       # 0x2015
movl $0x2a, %edx
callq 0x10c0
movq 0x2d44(%rip), %rbx      # 0x3fd0
leaq 0xdad(%rip), %rsi       # 0x2040
movl $0x30, %edx
movq %rbx, %rdi
callq 0x10c0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq 0x2d12(%rip), %rdi      # 0x3fd0
callq 0x1030
movq %rax, %rdi
callq 0x1050
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq 0x2cf9(%rip), %rbx      # 0x3fe0
leaq -0x30(%rbp), %r14
leaq -0x50(%rbp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1324
movq -0x30(%rbp), %rax
cmpq -0x68(%rbp), %rax
jae 0x12ef
movq -0x70(%rbp), %rcx
movsbl (%rcx,%rax), %esi
movq %r15, %rdi
callq 0x1080
jmp 0x12ef
movq 0x2ca5(%rip), %rdi      # 0x3fd0
leaq 0xd3f(%rip), %rsi       # 0x2071
movl $0x14, %edx
callq 0x10c0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq 0x2c85(%rip), %rdi      # 0x3fd0
callq 0x10c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x138f
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x10b0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x13a4
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x10b0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13bc
movq %rax, %rbx
jmp 0x13d4
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x13d4
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x10b0
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0x13e9
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x10b0
movq %rbx, %rdi
callq 0x10e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/MikuAuahDark[P]midi2sif/src/midi2sif.cpp
// Function: ReadVarInt(_IO_FILE*, unsigned long*)
uint32_t ReadVarInt(FILE* stream, size_t* decrementer = NULL)
{
	int32_t temp;
	uint32_t out = 0;

	do
	{
		if((temp = fgetc(stream)) == EOF)
			throw std::runtime_error("Unexpected EOF");

		if(decrementer) (*decrementer)--;

		out = (out << 7) | (temp & 0x7F);
	}
	while ((temp & 0x80) != 0);

	return out;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2210
cmpl $-0x1, %eax
je 0x2754
testq %rbx, %rbx
je 0x273d
decq (%rbx)
movl %ebp, %ecx
shll $0x7, %ecx
movl %eax, %ebp
andl $0x7f, %ebp
orl %ecx, %ebp
testb %al, %al
js 0x2728
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x38d0(%rip), %rsi      # 0x6038
movq %rax, %rdi
callq 0x2080
movq 0x6881(%rip), %rsi      # 0x8ff8
movq 0x6852(%rip), %rdx      # 0x8fd0
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/MikuAuahDark[P]midi2sif/src/midi2sif.cpp
// Function: InsertEvent(std::map<unsigned int, std::vector<EventInformation, std::allocator<EventInformation>>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, std::vector<EventInformation, std::allocator<EventInformation>>>>>&, EventInformation&)
void InsertEvent(std::map<uint32_t, std::vector<EventInformation> >& raw, EventInformation& event)
{
	if(raw.count(event.tick))
	{
		std::vector<EventInformation>& eilist = raw[event.tick];

		event.order = eilist.size();
		eilist.push_back(event);
	}
	else
	{
		std::vector<EventInformation> temp;

		event.order = 0;
		temp.push_back(event);
		raw[event.tick] = temp;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3630
testq %rax, %rax
je 0x27db
movq %r14, %rdi
movq %rbx, %rsi
callq 0x367a
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x6, %rcx
movl %ecx, 0x4(%rbx)
movq %rax, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x36de
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, 0x4(%rbx)
movq %rbx, %rsi
callq 0x36de
movq %r14, %rdi
movq %rbx, %rsi
callq 0x367a
movq %rsp, %rsi
movq %rax, %rdi
callq 0x374a
movq %rsp, %rdi
callq 0x3926
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3926
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/MikuAuahDark[P]midi2sif/src/midi2sif.cpp
// Function: EventInformation::EventInformation(unsigned int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
EventInformation(uint32_t tick, int32_t meta, std::string data): order(0), pos(-1), channel(-1), note_on(false)
	{
		this->tick = tick;
		this->order = order;
		this->meta = meta;
		this->data = data;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x0, 0x4(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r15
movq %r15, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
xorl %eax, %eax
movb %al, 0x20(%rdi)
movq $-0x1, 0x30(%rdi)
movb %al, 0x38(%rdi)
movl %esi, (%rdi)
movl %edx, 0x8(%rdi)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x20d0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x39de
movq (%r15), %rsi
incq %rsi
callq 0x2170
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/MikuAuahDark[P]midi2sif/src/midi2sif.cpp
// Function: ZN10SIFBeatmapcvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv
operator std::string()
	{
		char temp[128];

		sprintf(temp,
			"{"
			"\"timing_sec\": %.4f,"
			"\"notes_attribute\": %d,"
			"\"notes_level\": 1,"
			"\"effect\": %d,"
			"\"effect_value\": %.4f,"
			"\"position\": %d"
			"}",
			timing_sec, notes_attribute, effect, effect == SIFBeatmap::LONG_NOTE ? effect_value : 2.0, position
		);

		return std::string(temp);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm0
movl 0x8(%rsi), %edx
movl 0xc(%rsi), %ecx
cmpl $0x3, %ecx
je 0x3a70
movsd 0x25c2(%rip), %xmm1     # 0x6030
jmp 0x3a75
movsd 0x10(%rsi), %xmm1
movl 0x18(%rsi), %r8d
leaq 0x2741(%rip), %rsi      # 0x61c1
movq %rsp, %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x2050
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x20a0
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ac4
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::set_deleted_key(unsigned int const&)
void set_deleted_key(const key_type &key) {
    // the empty indicator (if specified) and the deleted indicator
    // must be different
    assert((!settings.use_empty() || !equals(key, get_key(val_info.emptyval)))
           && "Passed the empty-key to set_deleted_key");
    // It's only safe to change what "deleted" means if we purge deleted guys
    squash_deleted();
    settings.set_use_deleted(true);
    key_info.delkey = key;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x19(%rdi)
jne 0x19d4
movl (%r14), %eax
cmpl 0x40(%rbx), %eax
je 0x19ee
movq %rbx, %rdi
callq 0x1a0e
movb $0x1, 0x1a(%rbx)
movl (%r14), %eax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1ac8(%rip), %rdi      # 0x34bd
leaq 0x171f(%rip), %rsi      # 0x311b
leaq 0x1b2b(%rip), %rcx      # 0x352e
movl $0x18a, %edx            # imm = 0x18A
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::squash_deleted()
void squash_deleted() {           // gets rid of any deleted entries we have
    if ( num_deleted ) {            // get rid of deleted before writing
      dense_hashtable tmp(*this);   // copying will get rid of deleted
      swap(tmp);                    // now we are tmp
    }
    assert(num_deleted == 0);
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x1a4e
leaq 0x8(%rsp), %r14
movl $0x20, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1a96
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bec
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1a4e
callq 0x10a0
cmpq $0x0, 0x28(%rbx)
jne 0x1a5d
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x2e2d(%rip), %rdi      # 0x4891
leaq 0x16b0(%rip), %rsi      # 0x311b
leaq 0x1db8(%rip), %rcx      # 0x382a
movl $0x17a, %edx            # imm = 0x17A
callq 0x1070
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1a8e
callq 0x10a0
movq %rbx, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::clear_to_size(unsigned long)
void clear_to_size(size_type new_num_buckets) {
    if (!table) {
      table = val_info.allocate(new_num_buckets);
    } else {
      destroy_buckets(0, num_buckets);
      if (new_num_buckets != num_buckets) {   // resize, if necessary
        typedef base::integral_constant<bool,
            base::is_same<value_alloc_type,
                          libc_allocator_with_realloc<value_type> >::value>
            realloc_ok;
        resize_table(num_buckets, new_num_buckets, realloc_ok());
      }
    }
    assert(table);
    fill_range_with_empty(table, table + new_num_buckets);
    num_elements = 0;
    num_deleted = 0;
    num_buckets = new_num_buckets;          // our new size
    settings.reset_thresholds(bucket_count());
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rsi
testq %rsi, %rsi
je 0x1f39
cmpq %r14, 0x38(%rbx)
je 0x1f4a
leaq 0x40(%rbx), %rdi
movq %r14, %rdx
callq 0x2068
jmp 0x1f46
leaq (,%r14,8), %rdi
callq 0x10d0
movq %rax, 0x48(%rbx)
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x2009
testq %r14, %r14
je 0x1f77
leaq (,%r14,8), %rcx
xorl %edx, %edx
movq 0x40(%rbx), %rsi
movq %rsi, (%rax,%rdx)
addq $0x8, %rdx
cmpq %rdx, %rcx
jne 0x1f66
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq %r14, 0x38(%rbx)
testq %r14, %r14
js 0x1f91
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
jmp 0x1faa
movq %r14, %rax
shrq %rax
andl $0x1, %r14d
orq %rax, %r14
xorps %xmm0, %xmm0
cvtsi2ss %r14, %xmm0
addss %xmm0, %xmm0
movss 0x10(%rbx), %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
movss 0x1089(%rip), %xmm2     # 0x3050
subss %xmm2, %xmm1
cvttss2si %xmm1, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, (%rbx)
mulss 0x14(%rbx), %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss %xmm2, %xmm0
cvttss2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x8(%rbx)
movb $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x14a7(%rip), %rdi      # 0x34b7
leaq 0x1104(%rip), %rsi      # 0x311b
leaq 0x2208(%rip), %rcx      # 0x4226
movl $0x314, %edx            # imm = 0x314
callq 0x1070
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::alloc_impl<google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::realloc_or_die(std::pair<unsigned int const, unsigned int>*, unsigned long)
pointer realloc_or_die(pointer ptr, size_type n) {
      pointer retval = this->reallocate(ptr, n);
      if (retval == NULL) {
        fprintf(stderr,
                "sparsehash: FATAL ERROR: failed to reallocate "
                "%lu elements for ptr %p",
                static_cast<unsigned long>(n), static_cast<void*>(ptr));
        exit(1);
      }
      return retval;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
leaq (,%rdx,8), %rsi
movq %rbx, %rdi
callq 0x1100
testq %rax, %rax
je 0x208f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1481
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: std::pair<unsigned int const, unsigned int>& google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::find_or_insert<google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::DefaultValue>(unsigned int const&)
value_type& find_or_insert(const key_type& key) {
    // First, double-check we're not inserting emptykey or delkey
    assert((!settings.use_empty() || !equals(key, get_key(val_info.emptyval)))
           && "Inserting the empty key");
    assert((!settings.use_deleted() || !equals(key, key_info.delkey))
           && "Inserting the deleted key");
    const std::pair<size_type,size_type> pos = find_position(key);
    DefaultValue default_value;
    if ( pos.first != ILLEGAL_BUCKET) {  // object was already there
      return table[pos.first];
    } else if (resize_delta(1)) {        // needed to rehash to make room
      // Since we resized, we can't use pos, so recalculate where to insert.
      return *insert_noresize(default_value(key)).first;
    } else {                             // no need to rehash, insert right here
      return *insert_at(default_value(key), pos.second);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x19(%rdi)
jne 0x215d
movl (%r14), %eax
cmpl 0x40(%rbx), %eax
je 0x21e7
cmpb $0x0, 0x1a(%rbx)
je 0x216f
movl (%r14), %eax
cmpl 0x20(%rbx), %eax
je 0x2206
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2226
cmpq $-0x1, %rax
je 0x218a
shlq $0x3, %rax
addq 0x48(%rbx), %rax
jmp 0x21dd
movq %rdx, %r15
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2306
testb %al, %al
je 0x21bb
movl (%r14), %eax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x249a
jmp 0x21d9
movl (%r14), %eax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2554
movq 0x8(%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2fae(%rip), %rdi      # 0x519c
leaq 0xf26(%rip), %rsi       # 0x311b
leaq 0x3001(%rip), %rcx      # 0x51fd
movl $0x3df, %edx            # imm = 0x3DF
callq 0x1070
leaq 0x334b(%rip), %rdi      # 0x5558
leaq 0xf07(%rip), %rsi       # 0x311b
leaq 0x2fe2(%rip), %rcx      # 0x51fd
movl $0x3e1, %edx            # imm = 0x3E1
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::find_position(unsigned int const&) const
std::pair<size_type, size_type> find_position(const key_type &key) const {
    size_type num_probes = 0;              // how many times we've probed
    const size_type bucket_count_minus_one = bucket_count() - 1;
    size_type bucknum = hash(key) & bucket_count_minus_one;
    size_type insert_pos = ILLEGAL_BUCKET; // where we would insert
    while ( 1 ) {                          // probe until something happens
      if ( test_empty(bucknum) ) {         // bucket is empty
        if ( insert_pos == ILLEGAL_BUCKET )   // found no prior place to insert
          return std::pair<size_type,size_type>(ILLEGAL_BUCKET, bucknum);
        else
          return std::pair<size_type,size_type>(ILLEGAL_BUCKET, insert_pos);

      } else if ( test_deleted(bucknum) ) {// keep searching, but mark to insert
        if ( insert_pos == ILLEGAL_BUCKET )
          insert_pos = bucknum;

      } else if ( equals(key, get_key(table[bucknum])) ) {
        return std::pair<size_type,size_type>(bucknum, ILLEGAL_BUCKET);
      }
      ++num_probes;                        // we're doing another probe
      bucknum = (bucknum + JUMP_(key, num_probes)) & bucket_count_minus_one;
      assert(num_probes < bucket_count()
             && "Hashtable is full: an error in key_equal<> or hash<>");
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x38(%rdi), %r12
decq %r12
movl (%rsi), %ebx
andl %r12d, %ebx
movq $-0x1, %r13
xorl %ebp, %ebp
cmpb $0x0, 0x19(%r15)
je 0x22e7
movq 0x48(%r15), %rax
movl 0x40(%r15), %ecx
cmpl (%rax,%rbx,8), %ecx
je 0x22ba
movq %r15, %rdi
movq %rbx, %rsi
callq 0x266c
testb %al, %al
je 0x227d
cmpq $-0x1, %r13
cmoveq %rbx, %r13
jmp 0x2289
movq 0x48(%r15), %rax
movl (%r14), %ecx
cmpl (%rax,%rbx,8), %ecx
je 0x22ce
addq %rbp, %rbx
incq %rbx
incq %rbp
andq %r12, %rbx
cmpq 0x38(%r15), %rbp
jb 0x224c
leaq 0x1f2e(%rip), %rdi      # 0x41d0
leaq 0xe72(%rip), %rsi       # 0x311b
leaq 0x3302(%rip), %rcx      # 0x55b2
movl $0x354, %edx            # imm = 0x354
callq 0x1070
cmpq $-0x1, %r13
cmovneq %r13, %rbx
movq %rbx, %rdx
movq $-0x1, %rbx
jmp 0x22d5
movq $-0x1, %rdx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2271(%rip), %rdi      # 0x455f
leaq 0xe26(%rip), %rsi       # 0x311b
leaq 0x28bb(%rip), %rcx      # 0x4bb7
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x1070
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::insert_noresize(std::pair<unsigned int const, unsigned int> const&)
std::pair<iterator, bool> insert_noresize(const_reference obj) {
    // First, double-check we're not inserting delkey or emptyval
    assert((!settings.use_empty() || !equals(get_key(obj),
                                             get_key(val_info.emptyval)))
           && "Inserting the empty key");
    assert((!settings.use_deleted() || !equals(get_key(obj), key_info.delkey))
           && "Inserting the deleted key");
    const std::pair<size_type,size_type> pos = find_position(get_key(obj));
    if ( pos.first != ILLEGAL_BUCKET) {      // object was already there
      return std::pair<iterator,bool>(iterator(this, table + pos.first,
                                          table + num_buckets, false),
                                 false);          // false: we didn't insert
    } else {                                 // pos.second says where to put it
      return std::pair<iterator,bool>(insert_at(obj, pos.second), true);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x19(%rsi)
jne 0x24b7
movl (%r15), %eax
cmpl 0x40(%r14), %eax
je 0x2516
cmpb $0x0, 0x1a(%r14)
je 0x24c7
movl (%r15), %eax
cmpl 0x20(%r14), %eax
je 0x2535
movq %r14, %rdi
movq %r15, %rsi
callq 0x2226
cmpq $-0x1, %rax
je 0x24f7
movq 0x38(%r14), %rcx
movq 0x48(%r14), %rdx
leaq (%rdx,%rax,8), %rax
leaq (%rdx,%rcx,8), %rcx
movq %r14, (%rbx)
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
xorl %eax, %eax
jmp 0x250a
movq %rdx, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2554
movb $0x1, %al
movb %al, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x39ce(%rip), %rdi      # 0x5eeb
leaq 0xbf7(%rip), %rsi       # 0x311b
leaq 0x3a2a(%rip), %rcx      # 0x5f55
movl $0x3a8, %edx            # imm = 0x3A8
callq 0x1070
leaq 0x3d29(%rip), %rdi      # 0x6265
leaq 0xbd8(%rip), %rsi       # 0x311b
leaq 0x3a0b(%rip), %rcx      # 0x5f55
movl $0x3aa, %edx            # imm = 0x3AA
callq 0x1070
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/sparsehash/./sparsehash/internal/densehashtable.h
// Function: google::dense_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SelectKey, google::dense_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, google::libc_allocator_with_realloc<std::pair<unsigned int const, unsigned int>>>::insert_at(std::pair<unsigned int const, unsigned int> const&, unsigned long)
iterator insert_at(const_reference obj, size_type pos) {
    if (size() >= max_size()) {
      throw std::length_error("insert overflow");
    }
    if ( test_deleted(pos) ) {      // just replace if it's been del.
      // shrug: shouldn't need to be const.
      const_iterator delpos(this, table + pos, table + num_buckets, false);
      clear_deleted(delpos);
      assert( num_deleted > 0);
      --num_deleted;                // used to be, now it isn't
    } else {
      ++num_elements;               // replacing an empty bucket
    }
    set_value(&table[pos], obj);
    return iterator(this, table + pos, table + num_buckets, false);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq 0x30(%rsi), %rax
subq 0x28(%rsi), %rax
movabsq $0x1fffffffffffffff, %rcx # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jae 0x2607
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x266c
testb %al, %al
je 0x25cd
movq 0x38(%r14), %rax
movq 0x48(%r14), %rcx
leaq (%rcx,%r15,8), %rdx
leaq (%rcx,%rax,8), %rax
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0x27f0
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x2639
decq %rax
movq %rax, 0x28(%r14)
jmp 0x25d1
incq 0x30(%r14)
movq 0x48(%r14), %rax
movq (%r12), %rcx
movq %rcx, (%rax,%r15,8)
movq 0x38(%r14), %rax
movq 0x48(%r14), %rcx
leaq (%rcx,%r15,8), %rdx
leaq (%rcx,%rax,8), %rax
movq %r14, (%rbx)
movq %rdx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x1050
movq %rax, %rbx
leaq 0x3cad(%rip), %rsi      # 0x62c8
movq %rax, %rdi
callq 0x1090
movq 0x69b6(%rip), %rsi      # 0x8fe0
movq 0x699f(%rip), %rdx      # 0x8fd0
movq %rbx, %rdi
callq 0x1110
leaq 0x2567(%rip), %rdi      # 0x4ba7
leaq 0xad4(%rip), %rsi       # 0x311b
leaq 0x3c8a(%rip), %rcx      # 0x62d8
movl $0x39a, %edx            # imm = 0x39A
callq 0x1070
movq %rax, %r14
movq %rbx, %rdi
callq 0x1080
movq %r14, %rdi
callq 0x1120
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/virt-inherit.cc
// Function: main
int main ()
{
	Panda ying_yang;
	dance(ying_yang);   // ok: passes Panda object as a Bear 
	rummage(ying_yang); // ok: passes Panda object as a Raccoon 

	cout << ying_yang;  // ok: passes Panda object as a ZooAnimal

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
xorl %ecx, %ecx
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
movb %cl, 0x10(%rax)
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
leaq -0x90(%rbp), %rax
movq %rax, -0x10(%rax)
movq %rcx, -0x8(%rax)
movb %cl, (%rax)
movl $0x0, 0x10(%rax)
movb %cl, 0x20(%rax)
movl $0x2, 0x30(%rax)
leaq 0x41c3(%rip), %rdx      # 0x6a98
movq %rdx, -0x18(%rax)
leaq 0x4260(%rip), %rdx      # 0x6b40
movq %rdx, 0x38(%rax)
leaq 0x41e5(%rip), %rdx      # 0x6ad0
movq %rdx, 0x18(%rax)
leaq 0x4202(%rip), %rdx      # 0x6af8
movq %rdx, 0x28(%rax)
movb %cl, 0x34(%rax)
callq 0x2795
callq 0x27e3
callq 0x2831
leaq -0x58(%rbp), %rbx
leaq -0x68(%rbp), %rdi
callq 0x30ec
leaq 0x4248(%rip), %rsi      # 0x6b68
leaq -0xa8(%rbp), %rdi
callq 0x29ec
movq %rbx, %rdi
callq 0x2fe0
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x2a78
movq %rbx, %rdi
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/PermMissingElem.cpp
// Function: solution(std::vector<int, std::allocator<int>>&)
int solution(vector<int> &A) {
	int fullSum = 0;	// sum: 1 + 2 + ... n
	int sum = 0;	// sum of input Array A
	int i;
	for (i = 0; i < A.size(); i++) {
		sum += A[i];
		fullSum += i + 1;
	}
	fullSum += i + 1;
	return fullSum - sum;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
je 0x1213
pushq %rbp
movq %rsp, %rbp
sarq $0x2, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
addl (%rcx,%rdi,4), %esi
incq %rdi
addl %edi, %edx
cmpq %rdi, %rax
jne 0x11fe
subl %esi, %edx
addl %edx, %eax
incl %eax
popq %rbp
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/PermMissingElem.cpp
// Function: main
int main() {
	vector<int> A(4);
	A[0] = 2;
	A[1] = 3;
	A[2] = 1;
	A[3] = 5;
	cout << solution(A) << '\n';	// 3
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl $0x10, %edi
callq 0x1040
movq %rax, %rbx
movaps 0xdd8(%rip), %xmm0      # 0x2010
movups %xmm0, (%rax)
xorl %ecx, %ecx
xorl %eax, %eax
addl (%rbx,%rcx,4), %eax
incq %rcx
cmpq $0x4, %rcx
jne 0x123f
movl $0xf, %esi
subl %eax, %esi
movq 0x2d7f(%rip), %rdi      # 0x3fd8
callq 0x1080
leaq -0x11(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1060
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x10, %esi
movq %rbx, %rdi
callq 0x1050
movq %r14, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/KokiKishimoto[P]cp_decomposition/add_rev.cpp
// Function: AddRev::add_rev()
void add_rev(void){
		std::vector<std::string> tmp(3);
		std::string l, m, n;
		int triplesize = triple.size();
		for(int i=0; i<triplesize; i++){
			tmp[0] = triple[i][2];
			tmp[1] = "**" + triple[i][1];
			tmp[2] = triple[i][0];
	
			triple.push_back(tmp);
	
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
leaq 0x18(%rsp), %rdx
movl $0x3, %esi
callq 0x2e20
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x68(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rbp
testl %ebp, %ebp
jle 0x2948
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq 0x180b(%rip), %r14      # 0x40c3
leaq 0x78(%rsp), %r15
movq %rsp, %r12
movq (%rbx), %rax
movq (%rax,%r13), %rsi
addq $0x40, %rsi
movq (%rsp), %rdi
callq 0x2110
movq (%rbx), %rax
movq (%rax,%r13), %rdx
addq $0x20, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3465
movq (%rsp), %rdi
addq $0x20, %rdi
movq %r15, %rsi
callq 0x2210
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x291c
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x21d0
movq (%rbx), %rax
movq (%rax,%r13), %rsi
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0x2110
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2eaa
addq $0x18, %r13
decq %rbp
jne 0x28c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x2964
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x2980
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x299c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rsp, %rdi
callq 0x2f70
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29b8
movq %rax, %rbx
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x29d7
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x29f3
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2a0f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rsp, %rdi
callq 0x2f70
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/KokiKishimoto[P]cp_decomposition/add_rev.cpp
// Function: AddRev::write_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void write_file(const std::string& rev_filename){

		std::ofstream fout;
		fout.open(rev_filename, std::ios::out);

		for(int i=0; i<triple.size(); i++){
			fout << triple[i][0] << '\t' << triple[i][1] << '\t' << triple[i][2] << std::endl; // ??????????
		}
		fout.close();

	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x22b0
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x20e0
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x2b2f
xorl %r13d, %r13d
leaq 0x7(%rsp), %r15
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
xorl %r14d, %r14d
movq (%rax,%r13), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
callq 0x21e0
movb $0x9, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
movq (%rbx), %rcx
movq (%rcx,%r13), %rcx
movq 0x20(%rcx), %rsi
movq 0x28(%rcx), %rdx
movq %rax, %rdi
callq 0x21e0
movb $0x9, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x21e0
movq (%rbx), %rcx
movq (%rcx,%r13), %rcx
movq 0x40(%rcx), %rsi
movq 0x48(%rcx), %rdx
movq %rax, %rdi
callq 0x21e0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2130
incq %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %rbp, %rcx
addq $0x18, %r13
cmpq %r14, %rcx
ja 0x2a76
leaq 0x8(%rsp), %rdi
callq 0x2240
movq 0x3490(%rip), %rax      # 0x5fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x2170
leaq 0x100(%rsp), %rdi
callq 0x20a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b7f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2260
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/KokiKishimoto[P]cp_decomposition/add_rev.cpp
// Function: AddRev::load[abi:cxx11]()
std::vector< std::vector <std::string> > load(void){
		std::fstream fs;
		std::vector<std::string> tmp(3);
		std::string l,m,n;
		fs.open(triple_file, std::ios::in);
		while (fs >> l >> m >> n){
			tmp[0] = l;
			tmp[1] = m;
			tmp[2] = n;
			
			triple.push_back(tmp);
		}
		
		fs.close(); 
		return triple;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x88(%rsp), %rdi
callq 0x21f0
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movl $0x3, %esi
callq 0x2e20
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x78(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x58(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x18(%r14), %rsi
leaq 0x88(%rsp), %rdi
movl $0x8, %edx
callq 0x2230
movq %rbx, 0x40(%rsp)
leaq 0x88(%rsp), %r15
leaq 0x20(%rsp), %r12
leaq 0x68(%rsp), %r13
leaq 0x48(%rsp), %rbp
leaq 0x8(%rsp), %rbx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2220
movq %rax, %rdi
movq %r13, %rsi
callq 0x2220
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2cc3
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2110
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq %r13, %rsi
callq 0x2110
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq %rbp, %rsi
callq 0x2110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2eaa
jmp 0x2c58
leaq 0x88(%rsp), %rdi
callq 0x2040
movq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ed6
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x2cfc
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x2d18
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2d34
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x8(%rsp), %rdi
callq 0x2f70
leaq 0x88(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2dc8
jmp 0x2d67
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x2d86
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x2da2
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x2dbe
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x8(%rsp), %rdi
callq 0x2f70
leaq 0x88(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/brandoncanaday[P]1730sh/1730sh.cpp
// Function: parent_signals()
void parent_signals() {
  if(signal(SIGINT, SIG_IGN) == SIG_ERR) nope_out("signal");
  if(signal(SIGQUIT, SIG_IGN) == SIG_ERR) nope_out("signal");
  if(signal(SIGTSTP, SIG_IGN) == SIG_ERR) nope_out("signal");
  if(signal(SIGTTIN, SIG_IGN) == SIG_ERR) nope_out("signal");
  if(signal(SIGTTOU, SIG_IGN) == SIG_ERR) nope_out("signal");
  if(signal(SIGPIPE, SIG_IGN) == SIG_ERR) nope_out("signal");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, %esi
movl $0x2, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x5755
movl $0x1, %esi
movl $0x3, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x575e
movl $0x1, %esi
movl $0x14, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x5767
movl $0x1, %esi
movl $0x15, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x5770
movl $0x1, %esi
movl $0x16, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x5779
movl $0x1, %esi
movl $0xd, %edi
callq 0x3320
cmpq $-0x1, %rax
je 0x5782
addq $0x20, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x369f
leaq -0x20(%rbp), %rdi
callq 0x366c
leaq -0x20(%rbp), %rdi
callq 0x3639
leaq -0x20(%rbp), %rdi
callq 0x3606
leaq -0x20(%rbp), %rdi
callq 0x35d3
leaq -0x20(%rbp), %rdi
callq 0x35a0
// File: /workspace/github_cpp_makefile_star2_O1/brandoncanaday[P]1730sh/1730sh.cpp
// Function: chdir_home()
void chdir_home() {
  // home dir retrieval
  const char * homedir = nullptr;
  string s_homedir = "";
  if((homedir = getenv("HOME")) == nullptr) {
    homedir = getpwuid(getuid())->pw_dir;
  } // if
  s_homedir = string(homedir);
  chdir(homedir);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x936b(%rip), %rdx      # 0xeb12
leaq -0x40(%rbp), %rdi
movq %rdx, %rsi
callq 0xa038
leaq 0x788a(%rip), %rdi      # 0xd044
callq 0x3340
movq %rax, %rbx
testq %rax, %rax
jne 0x57d7
callq 0x3150
movl %eax, %edi
callq 0x3310
movq 0x20(%rax), %rbx
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rbx, %rsi
callq 0x3110
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %r14
movq %r14, %rsi
callq 0x3350
movq (%r14), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x580f
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3420
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x582c
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x32c0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5839
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x5851
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x32c0
movq %rbx, %rdi
callq 0x3530