LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2240
cmpl $-0x1, %eax
je 0x2404
testq %rbx, %rbx
je 0x23ed
decq (%rbx)
movl %ebp, %ecx
shll $0x7, %ecx
movl %eax, %ebp
andl $0x7f, %ebp
orl %ecx, %ebp
testb %al, %al
js 0x23d8
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x3c22(%rip), %rsi      # 0x6038
movq %rax, %rdi
callq 0x2080
movq 0x7bd3(%rip), %rsi      # 0x9ff8
movq 0x7ba4(%rip), %rdx      # 0x9fd0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 0x31a8
testq %rax, %rax
je 0x2489
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31c2
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 0x3210
xorps %xmm0, %xmm0
movq %rsp, %rdi
andq $0x0, 0x10(%rdi)
movaps %xmm0, (%rdi)
andl $0x0, 0x4(%rbx)
movq %rbx, %rsi
callq 0x3210
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31c2
movq %rsp, %rsi
movq %rax, %rdi
callq 0x323c
movq %rsp, %rdi
callq 0x3306
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3306
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/MikuAuahDark[P]midi2sif/src/midi2sif.cpp
// Function: EventInformation::EventInformation(unsigned int, bool, int, int)
EventInformation(uint32_t tick, bool note_on, int32_t pos, int32_t channel): order(0), meta(-1), data("")
	{
		this->tick = tick;
		this->order = order;
		this->note_on = note_on;
		this->pos = pos;
		this->channel = channel;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x4(%rdi)
addq $0x10, %rdi
leaq 0x2e39(%rip), %rsi      # 0x6194
leaq 0xf(%rsp), %rdx
callq 0x356a
movl %r15d, (%r12)
movb %r14b, 0x38(%r12)
movl %ebp, 0x30(%r12)
movl %ebx, 0x34(%r12)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
andl $0x0, 0x4(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
xorl %eax, %eax
movb %al, 0x20(%rdi)
orq $-0x1, 0x30(%rdi)
leaq 0x10(%rdi), %rbx
movb %al, 0x38(%rdi)
movl %esi, (%rdi)
movl %edx, 0x8(%rdi)
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x20e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x98, %rsp
movq %rdi, %rbx
movsd (%rsi), %xmm0
movl 0x8(%rsi), %edx
movl 0xc(%rsi), %ecx
cmpl $0x3, %ecx
je 0x3522
movsd 0x2b10(%rip), %xmm1     # 0x6030
jmp 0x3527
movsd 0x10(%rsi), %xmm1
movl 0x18(%rsi), %r8d
leaq 0x2c8f(%rip), %rsi      # 0x61c1
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movb $0x2, %al
callq 0x2050
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x356a
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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_empty_key(std::pair<unsigned int const, unsigned int> const&)
void set_empty_key(const_reference val) {
    // Once you set the empty key, you can't change it
    assert(!settings.use_empty() && "Calling set_empty_key multiple times");
    // The deleted indicator (if specified) and the empty indicator
    // must be different.
    assert((!settings.use_deleted() || !equals(get_key(val), key_info.delkey))
           && "Setting the empty key the same as the deleted key");
    settings.set_use_empty(true);
    set_value(&val_info.emptyval, val);

    assert(!table);                  // must set before first use
    // num_buckets was set in constructor even though table was NULL
    table = val_info.allocate(num_buckets);
    assert(table);
    fill_range_with_empty(table, table + num_buckets);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x1, 0x19(%rdi)
je 0x17e9
movq %rdi, %rbx
cmpb $0x1, 0x1a(%rdi)
jne 0x17a7
movl (%rsi), %eax
cmpl 0x20(%rbx), %eax
je 0x1846
movb $0x1, 0x19(%rbx)
movq (%rsi), %r15
movq %r15, 0x40(%rbx)
cmpq $0x0, 0x48(%rbx)
jne 0x1808
movq 0x38(%rbx), %r14
shlq $0x3, %r14
movq %r14, %rdi
callq 0x10d0
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x1827
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x17e3
movq %r15, (%rax,%rcx)
addq $0x8, %rcx
jmp 0x17d4
popq %rbx
popq %r14
popq %r15
retq
leaq 0x18cb(%rip), %rdi      # 0x30bb
leaq 0x1904(%rip), %rsi      # 0x30fb
leaq 0x1924(%rip), %rcx      # 0x3122
movl $0x1f2, %edx            # imm = 0x1F2
callq 0x1070
leaq 0x1c87(%rip), %rdi      # 0x3496
leaq 0x18e5(%rip), %rsi      # 0x30fb
leaq 0x1905(%rip), %rcx      # 0x3122
movl $0x1fa, %edx            # imm = 0x1FA
callq 0x1070
leaq 0x1c69(%rip), %rdi      # 0x3497
leaq 0x18c6(%rip), %rsi      # 0x30fb
leaq 0x18e6(%rip), %rcx      # 0x3122
movl $0x1fd, %edx            # imm = 0x1FD
callq 0x1070
leaq 0x1bce(%rip), %rdi      # 0x341b
leaq 0x18a7(%rip), %rsi      # 0x30fb
leaq 0x18c7(%rip), %rcx      # 0x3122
movl $0x1f6, %edx            # imm = 0x1F6
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x187e
movl (%r14), %eax
cmpl 0x40(%rbx), %eax
je 0x1898
movq %rbx, %rdi
callq 0x18b8
movb $0x1, 0x1a(%rbx)
movl (%r14), %eax
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1bfe(%rip), %rdi      # 0x349d
leaq 0x1855(%rip), %rsi      # 0x30fb
leaq 0x1c61(%rip), %rcx      # 0x350e
movl $0x18a, %edx            # imm = 0x18A
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x0, 0x28(%rdi)
je 0x18f8
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
pushq $0x20
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1934
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19dc
movq 0x50(%rsp), %rdi
callq 0x10a0
cmpq $0x0, 0x28(%rbx)
jne 0x1900
addq $0x58, %rsp
popq %rbx
popq %r14
retq
leaq 0x2f6a(%rip), %rdi      # 0x4871
leaq 0x17ed(%rip), %rsi      # 0x30fb
leaq 0x1ef5(%rip), %rcx      # 0x380a
movl $0x17a, %edx            # imm = 0x17A
callq 0x1070
movq %rax, %rbx
movq 0x50(%rsp), %rdi
callq 0x10a0
movq %rbx, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O2/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>>>::dense_hashtable(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>>> const&, unsigned long)
dense_hashtable(const dense_hashtable& ht,
                  size_type min_buckets_wanted = HT_DEFAULT_STARTING_BUCKETS)
      : settings(ht.settings),
        key_info(ht.key_info),
        num_deleted(0),
        num_elements(0),
        num_buckets(0),
        val_info(ht.val_info),
        table(NULL) {
    if (!ht.settings.use_empty()) {
      // If use_empty isn't set, copy_from will crash, so we do our own copying.
      assert(ht.empty());
      num_buckets = settings.min_buckets(ht.size(), min_buckets_wanted);
      settings.reset_thresholds(bucket_count());
      return;
    }
    settings.reset_thresholds(bucket_count());
    copy_from(ht, min_buckets_wanted);   // copy_from() ignores deleted entries
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
andq $0x0, 0x38(%rdi)
movq 0x40(%rsi), %rax
movq %rax, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movq %rdx, %r15
cmpb $0x0, 0x19(%rsi)
je 0x1992
movq %rbx, %rdi
xorl %esi, %esi
callq 0x170e
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1a88
movq 0x30(%r14), %rax
cmpq 0x28(%r14), %rax
jne 0x19bd
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1658
movq %rax, 0x38(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x170e
leaq 0x2131(%rip), %rdi      # 0x3af5
leaq 0x1730(%rip), %rsi      # 0x30fb
leaq 0x212e(%rip), %rcx      # 0x3b00
movl $0x2d3, %edx            # imm = 0x2D3
callq 0x1070
// File: /workspace/github_cpp_makefile_star2_O2/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>>>::swap(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>>>&)
void swap(dense_hashtable& ht) {
    std::swap(settings, ht.settings);
    std::swap(key_info, ht.key_info);
    std::swap(num_deleted, ht.num_deleted);
    std::swap(num_elements, ht.num_elements);
    std::swap(num_buckets, ht.num_buckets);
    { value_type tmp;     // for annoying reasons, swap() doesn't work
      set_value(&tmp, val_info.emptyval);
      set_value(&val_info.emptyval, ht.val_info.emptyval);
      set_value(&ht.val_info.emptyval, tmp);
    }
    std::swap(table, ht.table);
    settings.reset_thresholds(bucket_count());  // also resets consider_shrink
    ht.settings.reset_thresholds(ht.bucket_count());
    // we purposefully don't swap the allocator, which may not be swap-able
  }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
movl 0x20(%rdi), %eax
movl 0x20(%rsi), %ecx
movl %ecx, 0x20(%rdi)
movl %eax, 0x20(%rsi)
movq 0x28(%rdi), %rax
movq 0x28(%rsi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x28(%rsi)
movq 0x30(%rdi), %rax
movq 0x30(%rsi), %rcx
movq %rcx, 0x30(%rdi)
movq %rax, 0x30(%rsi)
movq 0x38(%rdi), %rax
movq 0x38(%rsi), %rcx
movq %rcx, 0x38(%rdi)
movq %rax, 0x38(%rsi)
movq 0x40(%rdi), %rax
movq 0x40(%rsi), %rcx
movq %rcx, 0x40(%rdi)
movq %rax, 0x40(%rsi)
movq 0x48(%rdi), %rax
movq 0x48(%rsi), %rcx
movq %rcx, 0x48(%rdi)
movq %rax, 0x48(%rsi)
movq 0x38(%rdi), %rsi
callq 0x170e
movq 0x38(%rbx), %rsi
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
jmp 0x170e
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x1bbb
movq 0x38(%r14), %rsi
cmpq %rbx, %rsi
je 0x1bd1
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1cec
movq 0x48(%r14), %rax
jmp 0x1bcc
leaq (,%rbx,8), %rdi
callq 0x10d0
movq %rax, 0x48(%r14)
testq %rax, %rax
je 0x1c0c
leaq (,%rbx,8), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x1bee
movq 0x40(%r14), %rsi
movq %rsi, (%rax,%rdx)
addq $0x8, %rdx
jmp 0x1bdb
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq %rbx, 0x38(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x170e
leaq 0x1884(%rip), %rdi      # 0x3497
leaq 0x14e1(%rip), %rsi      # 0x30fb
leaq 0x25e5(%rip), %rcx      # 0x4206
movl $0x314, %edx            # imm = 0x314
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1d2b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x72a6(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
leaq 0x27bd(%rip), %rsi      # 0x44f9
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10e0
pushq $0x1
popq %rdi
callq 0x10c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1e53
movl (%r14), %eax
cmpl 0x40(%rbx), %eax
je 0x1edb
cmpb $0x0, 0x1a(%rbx)
je 0x1e65
movl (%r14), %eax
cmpl 0x20(%rbx), %eax
je 0x1efa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f1a
cmpq $-0x1, %rax
je 0x1e80
shlq $0x3, %rax
addq 0x48(%rbx), %rax
jmp 0x1ed1
movq %rdx, %r15
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1fca
testb %al, %al
je 0x1eaf
movl (%r14), %eax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x214e
jmp 0x1ecd
movl (%r14), %eax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2208
movq 0x8(%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x359d(%rip), %rdi      # 0x547f
leaq 0x1212(%rip), %rsi      # 0x30fb
leaq 0x35f0(%rip), %rcx      # 0x54e0
movl $0x3df, %edx            # imm = 0x3DF
callq 0x1070
leaq 0x393a(%rip), %rdi      # 0x583b
leaq 0x11f3(%rip), %rsi      # 0x30fb
leaq 0x35d1(%rip), %rcx      # 0x54e0
movl $0x3e1, %edx            # imm = 0x3E1
callq 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %r12
movq 0x38(%rdi), %r13
decq %r13
movl (%rsi), %ebx
andl %r13d, %ebx
pushq $-0x1
popq %rbp
xorl %r14d, %r14d
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1c78
testb %al, %al
jne 0x1fa4
movq %r12, %rdi
movq %rbx, %rsi
callq 0x231e
testb %al, %al
je 0x1f65
cmpq $-0x1, %rbp
cmoveq %rbx, %rbp
jmp 0x1f72
movq 0x48(%r12), %rax
movl (%r15), %ecx
cmpl (%rax,%rbx,8), %ecx
je 0x1fb4
addq %r14, %rbx
incq %rbx
incq %r14
andq %r13, %rbx
cmpq 0x38(%r12), %r14
jb 0x1f3d
leaq 0x2224(%rip), %rdi      # 0x41b0
leaq 0x1168(%rip), %rsi      # 0x30fb
leaq 0x38fb(%rip), %rcx      # 0x5895
movl $0x354, %edx            # imm = 0x354
callq 0x1070
cmpq $-0x1, %rbp
cmovneq %rbp, %rbx
movq %rbx, %rdx
pushq $-0x1
popq %rbx
jmp 0x1fb7
pushq $-0x1
popq %rdx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x216b
movl (%r15), %eax
cmpl 0x40(%r14), %eax
je 0x21ca
cmpb $0x0, 0x1a(%r14)
je 0x217b
movl (%r15), %eax
cmpl 0x20(%r14), %eax
je 0x21e9
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f1a
cmpq $-0x1, %rax
je 0x21ab
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 0x21be
movq %rdx, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2208
movb $0x1, %al
movb %al, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3ffd(%rip), %rdi      # 0x61ce
leaq 0xf23(%rip), %rsi       # 0x30fb
leaq 0x4059(%rip), %rcx      # 0x6238
movl $0x3a8, %edx            # imm = 0x3A8
callq 0x1070
leaq 0x4358(%rip), %rdi      # 0x6548
leaq 0xf04(%rip), %rsi       # 0x30fb
leaq 0x403a(%rip), %rcx      # 0x6238
movl $0x3aa, %edx            # imm = 0x3AA
callq 0x1070
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22bb
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x231e
testb %al, %al
je 0x2281
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 0x2492
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x22eb
decq %rax
movq %rax, 0x28(%r14)
jmp 0x2285
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
pushq $0x10
popq %rdi
callq 0x1050
movq %rax, %rbx
leaq 0x42de(%rip), %rsi      # 0x65ab
movq %rax, %rdi
callq 0x1090
movq 0x6d04(%rip), %rsi      # 0x8fe0
movq 0x6ced(%rip), %rdx      # 0x8fd0
movq %rbx, %rdi
callq 0x1110
leaq 0x2895(%rip), %rdi      # 0x4b87
leaq 0xe02(%rip), %rsi       # 0x30fb
leaq 0x42bb(%rip), %rcx      # 0x65bb
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_O2/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 -0xa8(%rbp), %rdi
callq 0x274c
callq 0x25eb
callq 0x260b
callq 0x262b
leaq -0xa8(%rbp), %rdi
callq 0x27ae
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x27ae
movq %rbx, %rdi
callq 0x20d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
sarq $0x2, %rax
xorl %esi, %esi
xorl %edx, %edx
xorl %edi, %edi
cmpq %rsi, %rax
je 0x1253
addl (%rcx,%rsi,4), %edi
incq %rsi
addl %esi, %edx
jmp 0x1244
subl %edi, %edx
addl %edx, %eax
incl %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
leaq -0x28(%rbp), %rbx
pushq $0x4
popq %rsi
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x12cc
movq (%rbx), %rax
movaps 0xd8f(%rip), %xmm0      # 0x2010
movups %xmm0, (%rax)
movq %rbx, %rdi
callq 0x122c
movq 0x2d45(%rip), %rdi      # 0x3fd8
movl %eax, %esi
callq 0x10d0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x10b0
leaq -0x28(%rbp), %rdi
callq 0x1358
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x1358
movq %rbx, %rdi
callq 0x10e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/KokiKishimoto[P]cp_decomposition/add_rev.cpp
// Function: main
int main(int argc, char **argv){
	std::string file_name;
	std::string rev_filename;
	int i;
	if ((i = ArgPos((char *)"-file_name", argc, argv)) > 0) file_name = argv[i + 1];
	if ((i = ArgPos((char *)"-rev_filename", argc, argv)) > 0) rev_filename = argv[i + 1];
	AddRev addrev(file_name);
	addrev.add_rev();
	addrev.write_file(rev_filename);
	std::cout << addrev.triple.size() << std::endl;
	std::cout << addrev.triple.front().size() << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x1b80(%rip), %rsi      # 0x4019
leaq 0xa0(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2634
leaq 0xa0(%rsp), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x23dc
movl %eax, %r14d
leaq 0xa0(%rsp), %rdi
callq 0x20b0
testl %r14d, %r14d
jle 0x24e4
movl %r14d, %eax
movq 0x8(%rbx,%rax,8), %rsi
leaq 0x60(%rsp), %rdi
callq 0x2290
leaq 0x1b39(%rip), %rsi      # 0x4024
leaq 0x80(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2634
leaq 0x80(%rsp), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x23dc
movl %eax, %ebp
leaq 0x80(%rsp), %rdi
callq 0x20b0
testl %ebp, %ebp
jle 0x2533
movl %ebp, %eax
movq 0x8(%rbx,%rax,8), %rsi
leaq 0x40(%rsp), %rdi
callq 0x2290
leaq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2670
leaq 0x8(%rsp), %rdi
callq 0x26e0
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x283a
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq 0x3a64(%rip), %rdi      # 0x5fd8
movq %rax, %rsi
callq 0x2100
movq %rax, %rdi
callq 0x20d0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x5, %rsi
movq 0x3a3d(%rip), %rdi      # 0x5fd8
callq 0x2100
movq %rax, %rdi
callq 0x20d0
leaq 0x8(%rsp), %rdi
callq 0x2926
leaq 0x40(%rsp), %rdi
callq 0x20b0
leaq 0x60(%rsp), %rdi
callq 0x20b0
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x25f9
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
jmp 0x25f0
jmp 0x25f9
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x20b0
jmp 0x260b
jmp 0x25f9
movq %rax, %rbx
jmp 0x260b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2926
leaq 0x40(%rsp), %rdi
callq 0x20b0
leaq 0x60(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
pushq $0x3
popq %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
callq 0x2b14
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x68(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %r13d, %r13d
movb %r13b, (%rax)
movb %r13b, (%rcx)
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %r13b, (%rax)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
testl %eax, %eax
cmovlel %r13d, %eax
imulq $0x18, %rax, %rbp
leaq 0x194a(%rip), %r15      # 0x40a7
leaq 0x78(%rsp), %r12
cmpq %r13, %rbp
je 0x27ce
movq (%rbx), %rax
movq (%rax,%r13), %rsi
addq $0x40, %rsi
movq (%rsp), %rdi
callq 0x20f0
movq (%rbx), %rax
movq (%rax,%r13), %rdx
addq $0x20, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x30ed
movq (%rsp), %rdi
addq $0x20, %rdi
movq %r12, %rsi
callq 0x21c0
movq %r12, %rdi
callq 0x20b0
movq (%rbx), %rax
movq (%rax,%r13), %rsi
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0x20f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b66
addq $0x18, %r13
jmp 0x2762
leaq 0x38(%rsp), %rdi
callq 0x20b0
leaq 0x58(%rsp), %rdi
callq 0x20b0
leaq 0x18(%rsp), %rdi
callq 0x20b0
movq %rsp, %rdi
callq 0x2bec
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2808
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x20b0
leaq 0x58(%rsp), %rdi
callq 0x20b0
leaq 0x18(%rsp), %rdi
callq 0x20b0
movq %rsp, %rdi
callq 0x2bec
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2260
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x20c0
xorl %r15d, %r15d
pushq $0x18
popq %r12
leaq 0x8(%rsp), %r14
pushq $0x9
popq %rbp
xorl %r13d, %r13d
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x28e9
movq (%rcx,%r15), %rsi
movq %r14, %rdi
callq 0x2150
movq %rax, %rdi
movl %ebp, %esi
callq 0x2190
movq (%rbx), %rcx
movq (%rcx,%r15), %rsi
addq $0x20, %rsi
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
movl %ebp, %esi
callq 0x2190
movq (%rbx), %rcx
movq (%rcx,%r15), %rsi
addq $0x40, %rsi
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20d0
incq %r13
addq $0x18, %r15
jmp 0x287e
leaq 0x8(%rsp), %rdi
callq 0x2200
leaq 0x8(%rsp), %rdi
callq 0x2220
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2911
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21a0
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
leaq 0x28(%rsp), %rdx
callq 0x2b14
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
leaq 0x78(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
leaq 0x58(%rsp), %rsi
movq %rsi, -0x10(%rsi)
andq $0x0, -0x8(%rsi)
movb %cl, (%rax)
movb %cl, (%rdx)
movb %cl, (%rsi)
leaq 0x18(%r14), %rsi
leaq 0x88(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x21e0
movq %rbx, 0x20(%rsp)
leaq 0x88(%rsp), %r15
leaq 0x28(%rsp), %r12
leaq 0x68(%rsp), %r13
leaq 0x48(%rsp), %rbp
leaq 0x8(%rsp), %rbx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
movq %rax, %rdi
movq %r13, %rsi
callq 0x21d0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x21d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2a44
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x20f0
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq %r13, %rsi
callq 0x20f0
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq %rbp, %rsi
callq 0x20f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b66
jmp 0x29d9
leaq 0x88(%rsp), %rdi
callq 0x2030
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b92
leaq 0x48(%rsp), %rdi
callq 0x20b0
leaq 0x68(%rsp), %rdi
callq 0x20b0
leaq 0x28(%rsp), %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x2bec
leaq 0x88(%rsp), %rdi
callq 0x2050
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 0x2add
jmp 0x2ab2
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20b0
leaq 0x68(%rsp), %rdi
callq 0x20b0
leaq 0x28(%rsp), %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
callq 0x2bec
leaq 0x88(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0x28, %rsp
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
callq 0x32e0
cmpq $-0x1, %rax
jne 0x45af
leaq 0x74b5(%rip), %rsi      # 0xba45
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x30(%rbp), %rdi
callq 0x76be
leaq -0x30(%rbp), %rdi
callq 0x3120
pushq $0x3
popq %rdi
pushq $0x1
popq %rsi
callq 0x32e0
cmpq $-0x1, %rax
jne 0x45e6
leaq 0x747e(%rip), %rsi      # 0xba45
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x30(%rbp), %rdi
callq 0x76be
leaq -0x30(%rbp), %rdi
callq 0x3120
pushq $0x14
popq %rdi
pushq $0x1
popq %rsi
callq 0x32e0
cmpq $-0x1, %rax
jne 0x461d
leaq 0x7447(%rip), %rsi      # 0xba45
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x30(%rbp), %rdi
callq 0x76be
leaq -0x30(%rbp), %rdi
callq 0x3120
pushq $0x15
popq %rdi
pushq $0x1
popq %rsi
callq 0x32e0
cmpq $-0x1, %rax
jne 0x4654
leaq 0x7410(%rip), %rsi      # 0xba45
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x30(%rbp), %rdi
callq 0x76be
leaq -0x30(%rbp), %rdi
callq 0x3120
pushq $0x16
popq %rdi
pushq $0x1
popq %rsi
callq 0x32e0
cmpq $-0x1, %rax
jne 0x468b
leaq 0x73d9(%rip), %rsi      # 0xba45
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x30(%rbp), %rdi
callq 0x76be
leaq -0x30(%rbp), %rdi
callq 0x3120
pushq $0xd
popq %rdi
pushq $0x1
popq %rsi
callq 0x32e0
cmpq $-0x1, %rax
jne 0x46c2
leaq 0x73a2(%rip), %rsi      # 0xba45
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x3100
leaq -0x30(%rbp), %rdi
callq 0x76be
leaq -0x30(%rbp), %rdi
callq 0x3120
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x46db
jmp 0x46db
jmp 0x46eb
jmp 0x46db
jmp 0x46eb
jmp 0x46db
jmp 0x46eb
jmp 0x46db
jmp 0x46eb
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3120
jmp 0x46ee
jmp 0x46eb
movq %rax, %rbx
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x73d8(%rip), %rsi      # 0xbae2
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x3100
leaq 0x5926(%rip), %rdi      # 0xa044
callq 0x3300
movq %rax, %rbx
testq %rax, %rax
jne 0x473b
callq 0x3140
movl %eax, %edi
callq 0x32d0
movq 0x20(%rax), %rbx
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rbx, %rsi
callq 0x3100
leaq -0x60(%rbp), %r14
leaq -0x40(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3310
movq %r15, %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x33f0
movq %r14, %rdi
callq 0x3120
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4783
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x34b0