LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::encodeInstructionAddress(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Assembler::encodeInstructionAddress(string mne, string label)
{
	//get opcode (make it a binary string)
	string opcode = getOpcode(mne);

	//get memory address of operand
	string operand = sTable.getAddress(label);

	//initialises templine to be 32 0s
	string tempLine = "";
	for (int i = 0; i < 32; i++)
	{
		tempLine += "0";
	}

	// 6 for 64x32 store
	// 4 for 4 bit opcode (0-15)
	tempLine.replace(0, 6, operand);

	tempLine.replace(13, 4, opcode);

	return tempLine;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, %rax
movq -0xe0(%rbp), %rsi
movq %rdi, -0xd8(%rbp)
movq %rdi, %rdx
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3100
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x72e0
jmp 0x64d8
leaq -0x60(%rbp), %rdi
callq 0x31c0
movq -0xc8(%rbp), %rax
movq -0xe8(%rbp), %rsi
addq $0x38, %rax
movq %rax, -0xf0(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3100
jmp 0x6508
movq -0xf0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
callq 0x48f0
jmp 0x6524
leaq -0xb0(%rbp), %rdi
callq 0x31c0
movb $0x0, -0xb1(%rbp)
leaq -0xb2(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x3460
movq -0xd8(%rbp), %rdi
movq -0xf8(%rbp), %rdx
leaq 0x4b85(%rip), %rsi      # 0xb0e4
callq 0x7630
jmp 0x6566
leaq -0xb2(%rbp), %rdi
callq 0x32f0
movl $0x0, -0xb8(%rbp)
cmpl $0x20, -0xb8(%rbp)
jge 0x6630
movq -0xd8(%rbp), %rdi
leaq 0x4ae9(%rip), %rsi      # 0xb080
callq 0x3280
jmp 0x659e
jmp 0x65a0
movl -0xb8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb8(%rbp)
jmp 0x657c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31c0
jmp 0x66c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x66b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x31c0
jmp 0x66b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb2(%rbp), %rdi
callq 0x32f0
jmp 0x66ab
movq -0xd8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x31c0
jmp 0x66ab
movq -0xd8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x6, %edx
leaq -0x90(%rbp), %rcx
callq 0x30c0
jmp 0x664e
movq -0xd8(%rbp), %rdi
movl $0xd, %esi
movl $0x4, %edx
leaq -0x40(%rbp), %rcx
callq 0x30c0
jmp 0x666a
movb $0x1, -0xb1(%rbp)
testb $0x1, -0xb1(%rbp)
jne 0x6686
movq -0xd8(%rbp), %rdi
callq 0x31c0
leaq -0x90(%rbp), %rdi
callq 0x31c0
leaq -0x40(%rbp), %rdi
callq 0x31c0
movq -0xd0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x90(%rbp), %rdi
callq 0x31c0
leaq -0x40(%rbp), %rdi
callq 0x31c0
movq -0x68(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: czmccrory[P]ManchesterBaby/assembler.cpp
// Function: Assembler::getOpcode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Assembler::getOpcode(string mne)
{
	// getOpcode as int
	int opCodeInt = iSet.getOpcode(mne);

	// convert to 4 bit binary string and return
	string strOpcode = decToBinaryString(opCodeInt, 4);

	return strOpcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x80(%rbp)
movq %rsi, %rax
movq -0x80(%rbp), %rsi
movq %rdi, -0x78(%rbp)
movq %rdi, %rcx
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3100
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x41d0
movl %eax, -0x54(%rbp)
jmp 0x7334
leaq -0x40(%rbp), %rdi
callq 0x31c0
movl -0x54(%rbp), %eax
movq -0x78(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movb $0x0, -0x4d(%rbp)
movl -0x1c(%rbp), %esi
movl $0x4, %edx
callq 0x4b60
movb $0x1, -0x4d(%rbp)
testb $0x1, -0x4d(%rbp)
jne 0x7384
jmp 0x737b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31c0
jmp 0x7391
movq -0x78(%rbp), %rdi
callq 0x31c0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: czmccrory[P]ManchesterBaby/assembler.cpp
// Function: main
int main(int argc, char** argv)
{
	if (argc != 2)
	{
		cerr << "error please (only) enter a filename as parameter" << endl;
		return -1;
	}

	// initialises assembler with given filename and runs it
	 Assembler assembler(argv[1]);
	 assembler.assemble();

	 return 0;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x73ed
movq 0x8c2a(%rip), %rdi      # 0xfff0
leaq 0x3db4(%rip), %rsi      # 0xb181
callq 0x3290
movq %rax, %rdi
movq 0x8bdc(%rip), %rsi      # 0xffb8
callq 0x32d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x74cf
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xc8(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3460
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0x7630
jmp 0x742b
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x3610
jmp 0x743d
leaq -0xa0(%rbp), %rdi
callq 0x31c0
leaq -0xa1(%rbp), %rdi
callq 0x32f0
leaq -0x80(%rbp), %rdi
callq 0x4ca0
jmp 0x7460
movl $0x0, -0x4(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x81f0
jmp 0x74cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x74a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x31c0
leaq -0xa1(%rbp), %rdi
callq 0x32f0
jmp 0x74db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x81f0
jmp 0x74db
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/sparsehash/test-1.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	google::sparse_hash_map<uint32_t, uint32_t, Hash32> h;
	h.set_deleted_key(0xfffffffeu);
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		z += ++h[get_key(n, x)];
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0xc8, %rsp
movl %edi, 0xc4(%rsp)
movl %esi, 0xc0(%rsp)
movl $0x0, 0xb4(%rsp)
leaq 0x55(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x1860
movq 0x30(%rsp), %r8
xorl %eax, %eax
movl %eax, %esi
leaq 0x58(%rsp), %rdi
leaq 0x57(%rsp), %rdx
leaq 0x56(%rsp), %rcx
callq 0x1870
jmp 0x16be
leaq 0x55(%rsp), %rdi
callq 0x18c0
movl $0xfffffffe, 0x40(%rsp) # imm = 0xFFFFFFFE
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x18d0
jmp 0x16e1
movl $0x0, 0xbc(%rsp)
movl 0xc0(%rsp), %eax
movl %eax, 0xb8(%rsp)
movl 0xbc(%rsp), %eax
cmpl 0xc4(%rsp), %eax
jae 0x17c9
movl 0xb8(%rsp), %edi
callq 0x1310
movl %eax, 0x2c(%rsp)
jmp 0x1720
movl 0x2c(%rsp), %eax
movl %eax, 0xb8(%rsp)
movl 0xc4(%rsp), %edi
movl 0xb8(%rsp), %esi
callq 0x1380
movl %eax, 0x28(%rsp)
jmp 0x1744
movl 0x28(%rsp), %eax
movl %eax, 0x3c(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x1900
movq %rax, 0x20(%rsp)
jmp 0x1762
movq 0x20(%rsp), %rcx
movl (%rcx), %eax
addl $0x1, %eax
movl %eax, (%rcx)
addl 0xb4(%rsp), %eax
movl %eax, 0xb4(%rsp)
movl 0xbc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xbc(%rsp)
jmp 0x16fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x55(%rsp), %rdi
callq 0x18c0
jmp 0x1838
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1940
jmp 0x1838
movq 0xd808(%rip), %rax      # 0xefd8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1930
movq %rax, 0x18(%rsp)
jmp 0x17e9
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rdi
movl 0xb4(%rsp), %ecx
leaq 0x6880(%rip), %rsi      # 0x8081
xorl %eax, %eax
callq 0x1130
leaq 0x58(%rsp), %rdi
callq 0x1930
movq %rax, 0x8(%rsp)
jmp 0x1819
movq 0x8(%rsp), %rax
movl %eax, 0x4(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1940
movl 0x4(%rsp), %eax
addq $0xc8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x1190
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/sparsehash/./sparsehash/internal/hashtable-common.h
// Function: google::sparsehash_internal::sh_hashtable_settings<unsigned int, Hash32, unsigned long, 4>::min_buckets(unsigned long, unsigned long)
size_type min_buckets(size_type num_elts, size_type min_buckets_wanted) {
    float enlarge = enlarge_factor();
    size_type sz = HT_MIN_BUCKETS;             // min buckets allowed
    while ( sz < min_buckets_wanted ||
            num_elts >= static_cast<size_type>(sz * enlarge) ) {
      // This just prevents overflowing size_type, since sz can exceed
      // max_size() here.
      if (static_cast<size_type>(sz * 2) < sz) {
        throw std::length_error("resize overflow");  // protect against overflow
      }
      sz *= 2;
    }
    return sz;
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0x22b0
movss %xmm0, 0x3c(%rsp)
movq $0x4, 0x30(%rsp)
movq 0x30(%rsp), %rcx
movb $0x1, %al
cmpq 0x40(%rsp), %rcx
movb %al, 0x23(%rsp)
jb 0x1f8f
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x18(%rsp)
testq %rax, %rax
movss %xmm0, 0x1c(%rsp)
js 0x1f4a
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movss 0x1c(%rsp), %xmm0
movss 0x3c(%rsp), %xmm1
mulss %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttss2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movss 0x60b2(%rip), %xmm1     # 0x8028
subss %xmm1, %xmm0
cvttss2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
cmpq %rcx, %rax
setae %al
movb %al, 0x23(%rsp)
movb 0x23(%rsp), %al
testb $0x1, %al
jne 0x1f99
jmp 0x200f
movq 0x30(%rsp), %rax
shlq %rax
cmpq 0x30(%rsp), %rax
jae 0x1ffd
movl $0x10, %edi
callq 0x1070
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x60df(%rip), %rsi      # 0x80a3
callq 0x10e0
jmp 0x1fcb
movq 0x8(%rsp), %rdi
movq 0xd009(%rip), %rsi      # 0xefe0
movq 0xcff2(%rip), %rdx      # 0xefd0
callq 0x1180
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x10c0
jmp 0x2019
movq 0x30(%rsp), %rax
shlq %rax
movq %rax, 0x30(%rsp)
jmp 0x1eec
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x1190
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: attractivechaos[P]udb2/sparsehash/./sparsehash/internal/hashtable-common.h
// Function: google::sparsehash_internal::sh_hashtable_settings<unsigned int, Hash32, unsigned long, 4>::reset_thresholds(unsigned long)
void reset_thresholds(size_type num_buckets) {
    set_enlarge_threshold(enlarge_size(num_buckets));
    set_shrink_threshold(shrink_size(num_buckets));
    // whatever caused us to reset already considered
    set_consider_shrink(false);
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x3e30
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x3e10
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3ee0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x3ec0
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x3f70
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_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::sparse_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) {
    // 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3fe0
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x40a0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x20(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_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::sparse_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
      sparse_hashtable tmp(MoveDontGrow, *this);
      swap(tmp);                    // now we are tmp
    }
    assert(num_deleted == 0);
  }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x28(%rax)
je 0x4058
movq 0x10(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x1, %esi
movl $0x20, %ecx
callq 0x40c0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x41d0
jmp 0x4032
leaq 0x28(%rsp), %rdi
callq 0x1950
jmp 0x4058
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1950
jmp 0x408d
movq 0x10(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x4066
jmp 0x4085
leaq 0x4b22(%rip), %rdi      # 0x8b8f
leaq 0x408d(%rip), %rsi      # 0x8101
movl $0x1d3, %edx            # imm = 0x1D3
leaq 0x40a9(%rip), %rcx      # 0x8129
callq 0x10b0
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x1190
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_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::sparse_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::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_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::sparse_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(sparse_hashtable& ht) {
    std::swap(settings, ht.settings);
    std::swap(key_info, ht.key_info);
    std::swap(num_deleted, ht.num_deleted);
    table.swap(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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x60f0
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
addq $0x20, %rsi
callq 0x6180
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
movq 0x18(%rsp), %rsi
addq $0x28, %rsi
callq 0x61b0
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x18(%rsp), %rsi
addq $0x30, %rsi
callq 0x61f0
movq 0x8(%rsp), %rdi
callq 0x21e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2180
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x21e0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x2180
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_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::sparse_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()
void clear() {
    if (!empty() || (num_deleted != 0)) {
      table.clear();
    }
    settings.reset_thresholds(bucket_count());
    num_deleted = 0;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4cf0
testb $0x1, %al
jne 0x45ce
jmp 0x45da
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x45e8
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x4d10
movq 0x8(%rsp), %rdi
callq 0x21e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2180
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_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::sparse_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 deleted
      // The set() below will undelete this object.  We just worry about stats
      assert(num_deleted > 0);
      --num_deleted;                // used to be, now it isn't
    }
    table.set(pos, obj);
    return iterator(this, table.get_iter(pos), table.nonempty_end());
  }

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0x50(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0xd0(%rsp)
movq %rdx, 0xc8(%rsp)
movq %rcx, 0xc0(%rsp)
movq 0xd0(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x4620
movq 0x60(%rsp), %rdi
movq %rax, 0x68(%rsp)
callq 0x7b80
movq %rax, %rcx
movq 0x68(%rsp), %rax
cmpq %rcx, %rax
jb 0x6ea5
movl $0x10, %edi
callq 0x1070
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x48(%rsp)
leaq 0x45bb(%rip), %rsi      # 0xb41e
callq 0x10e0
jmp 0x6e6a
movq 0x48(%rsp), %rdi
movq 0x816a(%rip), %rsi      # 0xefe0
movq 0x8153(%rip), %rdx      # 0xefd0
callq 0x1180
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
callq 0x10c0
jmp 0x6fb8
movq 0x60(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0x7000
testb $0x1, %al
jne 0x6ebd
jmp 0x6efb
movq 0x60(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jbe 0x6ecb
jmp 0x6eea
leaq 0x1fde(%rip), %rdi      # 0x8eb0
leaq 0x1228(%rip), %rsi      # 0x8101
movl $0x3a4, %edx            # imm = 0x3A4
leaq 0x4549(%rip), %rcx      # 0xb42e
callq 0x10b0
movq 0x60(%rsp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
movq 0x60(%rsp), %rdi
addq $0x30, %rdi
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
callq 0x4b80
movq 0x60(%rsp), %rsi
addq $0x30, %rsi
movq 0xc0(%rsp), %rdx
leaq 0x90(%rsp), %rdi
callq 0x6750
movq 0x60(%rsp), %rsi
addq $0x30, %rsi
leaq 0x70(%rsp), %rdi
callq 0x76b0
movq 0x50(%rsp), %rdi
movq 0x60(%rsp), %rsi
leaq 0x90(%rsp), %rcx
leaq 0x70(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x38(%rsp)
callq 0x7720
movq 0x58(%rsp), %rax
addq $0xd8, %rsp
retq
movq 0xb8(%rsp), %rdi
callq 0x1190
nopw %cs:(%rax,%rax)
nop
// File: attractivechaos[P]udb2/sparsehash/./sparsehash/internal/sparsehashtable.h
// Function: google::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, google::sparse_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::sparse_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>>>::test_deleted(unsigned long) const
bool test_deleted(size_type bucknum) const {
    // Invariant: !use_deleted() implies num_deleted is 0.
    assert(settings.use_deleted() || num_deleted == 0);
    return num_deleted > 0 && table.test(bucknum) &&
        test_deleted_key(get_key(table.unsafe_get(bucknum)));
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5ca0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x703b
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
sete %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x7045
jmp 0x7047
jmp 0x7066
leaq 0x1b27(%rip), %rdi      # 0x8b75
leaq 0x10ac(%rip), %rsi      # 0x8101
movl $0x1f3, %edx            # imm = 0x1F3
leaq 0x3092(%rip), %rcx      # 0xa0f3
callq 0x10b0
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x28(%rcx)
movb %al, 0x7(%rsp)
jbe 0x70cb
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x18(%rsp), %rsi
callq 0x4b00
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x709a
jmp 0x70cb
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x18(%rsp), %rsi
callq 0x70e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4ab0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x5cb0
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Reputeless[P]PerlinNoise/./PerlinNoise.hpp
// Function: void siv::perlin_detail::Shuffle<unsigned char*, std::random_device>(unsigned char*, unsigned char*, std::random_device&&)
inline void Shuffle(RandomIt first, RandomIt last, URBG&& urbg)
		{
			if (first == last)
			{
				return;
			}

			using difference_type = typename std::iterator_traits<RandomIt>::difference_type;

			for (RandomIt it = first + 1; it < last; ++it)
			{
				const std::uint64_t n = static_cast<std::uint64_t>(it - first);
				std::iter_swap(it, first + static_cast<difference_type>(Random(n, std::forward<URBG>(urbg))));
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x4d90
jmp 0x4df0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4df0
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4e60
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq %rax, %rsi
callq 0x4e30
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4d9c
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Reputeless[P]PerlinNoise/./PerlinNoise.hpp
// Function: auto siv::perlin_detail::Octave3D<siv::BasicPerlinNoise<double>, double>(siv::BasicPerlinNoise<double> const&, double, double, double, int, double)
[[nodiscard]]
		inline auto Octave3D(const Noise& noise, Float x, Float y, Float z, const std::int32_t octaves, const Float persistence) noexcept
		{
			using value_type = Float;
			value_type result = 0;
			value_type amplitude = 1;

			for (std::int32_t i = 0; i < octaves; ++i)
			{
				result += (noise.noise3D(x, y, z) * amplitude);
				x *= 2;
				y *= 2;
				z *= 2;
				amplitude *= persistence;
			}

			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movsd %xmm3, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x110d(%rip), %xmm0     # 0x6030
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4fbd
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
callq 0x4fd0
movsd -0x40(%rbp), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x10ce(%rip), %xmm0     # 0x6040
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x10bc(%rip), %xmm0     # 0x6040
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x10aa(%rip), %xmm0     # 0x6040
mulsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x30(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x4f2f
movsd -0x38(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Reputeless[P]PerlinNoise/./PerlinNoise.hpp
// Function: double siv::perlin_detail::Grad<double>(unsigned char, double, double, double)
[[nodiscard]]
		inline constexpr Float Grad(const std::uint8_t hash, const Float x, const Float y, const Float z) noexcept
		{
			const std::uint8_t h = hash & 15;
			const Float u = h < 8 ? x : y;
			const Float v = h < 4 ? y : h == 12 || h == 14 ? x : z;
			return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movzbl -0x1(%rbp), %eax
andl $0xf, %eax
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x8, %eax
jge 0x5588
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x5592
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x4, %eax
jge 0x55b1
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x55e3
movzbl -0x21(%rbp), %eax
cmpl $0xc, %eax
je 0x55c3
movzbl -0x21(%rbp), %eax
cmpl $0xe, %eax
jne 0x55cf
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
jmp 0x55d9
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movzbl -0x21(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x5605
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
jmp 0x5626
movsd -0x30(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movzbl -0x21(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x5648
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
jmp 0x5669
movsd -0x38(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x60(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
addsd %xmm1, %xmm0
popq %rbp
retq
nopl (%rax)
// File: Reputeless[P]PerlinNoise/./PerlinNoise.hpp
// Function: double siv::perlin_detail::RemapClamp_01<double>(double)
[[nodiscard]]
		inline constexpr Float RemapClamp_01(const Float x) noexcept
		{
			if (x <= Float(-1.0))
			{
				return Float(0.0);
			}
			else if (Float(1.0) <= x)
			{
				return Float(1.0);
			}

			return (x * Float(0.5) + Float(0.5));
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd 0x4d7(%rip), %xmm0      # 0x6058
ucomisd -0x10(%rbp), %xmm0
jb 0x5b92
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5bd0
movsd -0x10(%rbp), %xmm0
movsd 0x491(%rip), %xmm1      # 0x6030
ucomisd %xmm1, %xmm0
jb 0x5bb4
movsd 0x483(%rip), %xmm0      # 0x6030
movsd %xmm0, -0x8(%rbp)
jmp 0x5bd0
jmp 0x5bb6
movsd -0x10(%rbp), %xmm0
movsd 0x45d(%rip), %xmm1      # 0x6020
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: Reputeless[P]PerlinNoise/./PerlinNoise.hpp
// Function: auto siv::perlin_detail::Octave2D<siv::BasicPerlinNoise<double>, double>(siv::BasicPerlinNoise<double> const&, double, double, int, double)
[[nodiscard]]
		inline auto Octave2D(const Noise& noise, Float x, Float y, const std::int32_t octaves, const Float persistence) noexcept
		{
			using value_type = Float;
			value_type result = 0;
			value_type amplitude = 1;

			for (std::int32_t i = 0; i < octaves; ++i)
			{
				result += (noise.noise2D(x, y) * amplitude);
				x *= 2;
				y *= 2;
				amplitude *= persistence;
			}

			return result;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movsd %xmm2, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x3e2(%rip), %xmm0      # 0x6030
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5cca
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x5ce0
movsd -0x38(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x3ac(%rip), %xmm0      # 0x6040
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x39a(%rip), %xmm0      # 0x6040
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x28(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5c5a
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: AraKhachatryan[P]GraphAlgo/biconnectivity.cpp
// Function: GraphAlgo::biconnectivity::new_bicomponent(int const&, int const&)
void biconnectivity::
new_bicomponent( const vertex& v, const vertex& w )
{
	int f, s ;
	graph gr;

	do {
		f = m_edge_stack.top().first;
		s = m_edge_stack.top().second;
		gr.add_edge(m_edge_stack.top());
		m_edge_stack.pop();
	} while ( ! ( f == v && s == w) );

	graphs_out.push_back(gr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x16d80
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x5de0
movq %rax, -0xa0(%rbp)
jmp 0x5294
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
addq $0x8, %rdi
callq 0x5de0
movq %rax, -0xa8(%rbp)
jmp 0x52b9
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x5de0
movq %rax, -0xb0(%rbp)
jmp 0x52df
movq -0xb0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x169d0
jmp 0x52f1
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x5e00
jmp 0x5303
jmp 0x5305
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0xb1(%rbp)
jne 0x532a
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
sete %al
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x527b
movq -0x98(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
leaq -0x80(%rbp), %rsi
callq 0x5e20
jmp 0x5353
leaq -0x80(%rbp), %rdi
callq 0x16dc0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x16dc0
movq -0x88(%rbp), %rdi
callq 0x22b0
nopl (%rax)
// File: AraKhachatryan[P]GraphAlgo/biconnectivity.cpp
// Function: GraphAlgo::biconnectivity::bicomponents()
void biconnectivity::
bicomponents()
{
	time =  0;

	vertices::const_iterator it = m_vertices.begin();
	for ( ; it != m_vertices.end(); ++it)
	{
		m_parent.insert(parent::value_type( *it, -1 ));
		m_discovery_time.insert(discovery_time::value_type( *it, time ));
		m_back.insert(back::value_type( *it,  m_vertices.size()  + 1 ));
	}
	
	vertices::const_iterator it2 = m_vertices.begin();
	for ( ; it2 != m_vertices.end(); ++it2)
	{
		if( m_discovery_time[*it2] == 0) {
			biDFS(*it2);     // for each connected graph
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movl $0x0, (%rdi)
addq $0x160, %rdi            # imm = 0x160
callq 0x6050
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6080
movq -0x98(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x6100
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x60c0
testb $0x1, %al
jne 0x581a
jmp 0x5928
movq -0x98(%rbp), %rax
addq $0x58, %rax
movq %rax, -0xb8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6130
movq %rax, %rsi
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x62a0
movq -0xb8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6260
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0x40(%rbp)
movb %dl, -0x38(%rbp)
addq $0x88, %rax
movq %rax, -0xb0(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6130
movq -0x98(%rbp), %rdx
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x62d0
movq -0xb0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6260
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, -0x58(%rbp)
movb %dl, -0x50(%rbp)
addq $0xb8, %rax
movq %rax, -0xa0(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6130
movq -0x98(%rbp), %rdi
movq %rax, -0xa8(%rbp)
addq $0x160, %rdi            # imm = 0x160
callq 0x6300
movq -0xa8(%rbp), %rsi
addq $0x1, %rax
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x6320
movq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x6260
movq %rax, -0x78(%rbp)
movb %dl, -0x70(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x6240
jmp 0x57ed
movq -0x98(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x6050
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x6080
movq -0x98(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x6100
movq %rax, -0x90(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x60c0
testb $0x1, %al
jne 0x5982
jmp 0x59db
movq -0x98(%rbp), %rax
addq $0x88, %rax
movq %rax, -0xc0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6130
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x5e90
cmpl $0x0, (%rax)
jne 0x59cb
leaq -0x80(%rbp), %rdi
callq 0x6130
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x5390
jmp 0x59cd
leaq -0x80(%rbp), %rdi
callq 0x6240
jmp 0x5952
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AraKhachatryan[P]GraphAlgo/biconnectivity.cpp
// Function: GraphAlgo::biconnectivity::biconnectivity(GraphAlgo::graph const&)
biconnectivity::
biconnectivity( const graph& g )
{
	g_in = g;

	m_vertices = g_in.get_vertices();
	m_neighborhood = g_in.get_neighborhood();
		
	bicomponents();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x8, %rdi
movq %rdi, -0x98(%rbp)
callq 0x6350
movq -0x78(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x90(%rbp)
callq 0x6380
movq -0x78(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x88(%rbp)
callq 0x6380
movq -0x78(%rbp), %rdi
addq $0xb8, %rdi
movq %rdi, -0x80(%rbp)
callq 0x6380
movq -0x78(%rbp), %rdi
addq $0xe8, %rdi
movq %rdi, -0x70(%rbp)
callq 0x16d80
jmp 0x5a70
movq -0x78(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
movq %rdi, -0xb8(%rbp)
callq 0x63a0
movq -0x78(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
movq %rdi, -0xb0(%rbp)
callq 0x63c0
movq -0x78(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
movq %rdi, -0xa8(%rbp)
callq 0x63e0
movq -0x78(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
movq %rdi, -0xa0(%rbp)
callq 0x6400
movq -0x78(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0xe8, %rdi
callq 0x16e00
jmp 0x5ae2
movq -0x78(%rbp), %rsi
addq $0xe8, %rsi
leaq -0x38(%rbp), %rdi
callq 0x16180
jmp 0x5af8
movq -0x78(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
leaq -0x38(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
callq 0x6420
movq -0xc0(%rbp), %rdi
callq 0x6450
movq -0x78(%rbp), %rsi
addq $0xe8, %rsi
leaq -0x68(%rbp), %rdi
callq 0x160d0
jmp 0x5b35
movq -0x78(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
leaq -0x68(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
callq 0x64b0
movq -0xc8(%rbp), %rdi
callq 0x64e0
movq -0x78(%rbp), %rdi
callq 0x57b0
jmp 0x5b67
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x5bc3
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x64e0
movq -0xa8(%rbp), %rdi
callq 0x6500
movq -0xb0(%rbp), %rdi
callq 0x6450
movq -0xb8(%rbp), %rdi
callq 0x6520
movq -0x70(%rbp), %rdi
callq 0x16dc0
movq -0x80(%rbp), %rdi
callq 0x6580
movq -0x88(%rbp), %rdi
callq 0x6580
movq -0x90(%rbp), %rdi
callq 0x6580
movq -0x98(%rbp), %rdi
callq 0x65a0
movq -0x18(%rbp), %rdi
callq 0x22b0
nopl (%rax)
// File: AraKhachatryan[P]GraphAlgo/connectivity.cpp
// Function: GraphAlgo::connectivity::connected_parts(GraphAlgo::graph&)
void connectivity::
connected_parts( graph& g_in ) 
{
	while( !g_in.get_vertices().empty() )
	{
		initialize();	

		graph g_copy = g_in;
		visit::iterator it = m_visit.begin();
		for ( ; it != m_visit.end(); ++it )
		{
			if ( it->second == false ) {
				g_copy.remove_vertex(it->first);
			}
			if ( it->second == true ) {
				g_in.remove_vertex(it->first);	
			}
		}
		graphs_out.push_back( g_copy );

		connected_parts( g_in );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x16180
leaq -0x28(%rbp), %rdi
callq 0xc500
xorb $-0x1, %al
movb %al, -0xb1(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6450
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xc104
jmp 0xc255
movq -0xb0(%rbp), %rdi
callq 0xc270
movq -0x10(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x16c30
movq -0xb0(%rbp), %rdi
addq $0x78, %rdi
callq 0xc540
movq %rax, -0x90(%rbp)
movq -0xb0(%rbp), %rdi
addq $0x78, %rdi
callq 0xc5a0
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xc570
testb $0x1, %al
jne 0xc16a
jmp 0xc219
leaq -0x90(%rbp), %rdi
callq 0xc5d0
movb 0x4(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xc1c4
leaq -0x90(%rbp), %rdi
callq 0xc5d0
movl (%rax), %esi
leaq -0x88(%rbp), %rdi
callq 0x15970
jmp 0xc19f
jmp 0xc1c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x16dc0
jmp 0xc25e
leaq -0x90(%rbp), %rdi
callq 0xc5d0
movb 0x4(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xc206
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xc5d0
movq -0xc0(%rbp), %rdi
movl (%rax), %esi
callq 0x15970
jmp 0xc204
jmp 0xc206
jmp 0xc208
leaq -0x90(%rbp), %rdi
callq 0xc5f0
jmp 0xc137
movq -0xb0(%rbp), %rdi
addq $0x60, %rdi
leaq -0x88(%rbp), %rsi
callq 0x5e20
jmp 0xc232
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc0b0
jmp 0xc244
leaq -0x88(%rbp), %rdi
callq 0x16dc0
jmp 0xc0ce
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: AraKhachatryan[P]GraphAlgo/connectivity.cpp
// Function: GraphAlgo::connectivity::initialize()
void connectivity::
initialize()
{	
	vertex first = g_in.get_vertices().front();
	
	dfs tree(g_in, first);
	
	m_visit.clear();
	m_visit = tree.get_visit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x1b0(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x16180
movq -0x1c0(%rbp), %rdi
callq 0xc620
movq -0x1c0(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1b4(%rbp)
callq 0x6450
movl -0x1b4(%rbp), %eax
movq -0x1b0(%rbp), %rsi
movl %eax, -0xc(%rbp)
leaq -0x160(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
leaq -0xc(%rbp), %rdx
callq 0xcef0
movq -0x1b0(%rbp), %rdi
addq $0x78, %rdi
callq 0xc650
movq -0x1a8(%rbp), %rsi
leaq -0x190(%rbp), %rdi
callq 0xcd90
jmp 0xc306
movq -0x1b0(%rbp), %rdi
addq $0x78, %rdi
leaq -0x190(%rbp), %rsi
callq 0xc670
leaq -0x190(%rbp), %rdi
callq 0xc6a0
leaq -0x160(%rbp), %rdi
callq 0xd190
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x160(%rbp), %rdi
callq 0xd190
movq -0x198(%rbp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: AraKhachatryan[P]GraphAlgo/connectivity.cpp
// Function: GraphAlgo::connectivity::is_connected()
bool connectivity::
is_connected()
{
	initialize();	

	visit::iterator it = m_visit.begin();
	for( ; it != m_visit.end(); ++it )
	{
		if ( it->second == false ) {
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xc270
movq -0x28(%rbp), %rdi
addq $0x78, %rdi
callq 0xc540
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x78, %rdi
callq 0xc5a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc570
testb $0x1, %al
jne 0xc3be
jmp 0xc3e7
leaq -0x18(%rbp), %rdi
callq 0xc5d0
movb 0x4(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xc3da
movb $0x0, -0x1(%rbp)
jmp 0xc3eb
jmp 0xc3dc
leaq -0x18(%rbp), %rdi
callq 0xc5f0
jmp 0xc39a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AraKhachatryan[P]GraphAlgo/dfs.cpp
// Function: GraphAlgo::dfs::dfs_traversal(int const&)
void dfs::
dfs_traversal( const vertex& v )
{
	vertices::const_iterator it = m_neighborhood[v].begin();
	for ( ; it != m_neighborhood[v].end(); ++it ) 
	{
		if ( ! m_visit[*it] ) 
		{
			m_visit[*it] = true ;
			g_out.add_edge(v, *it);
			dfs_traversal(*it);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x108, %rdi            # imm = 0x108
movq -0x10(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6050
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6080
movq -0x30(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movq -0x10(%rbp), %rsi
callq 0x5f70
movq %rax, %rdi
callq 0x6100
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x60c0
testb $0x1, %al
jne 0xce47
jmp 0xceea
movq -0x30(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6130
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xd220
testb $0x1, (%rax)
jne 0xceda
movq -0x30(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6130
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0xd220
movq %rax, %rcx
movq -0x30(%rbp), %rax
movb $0x1, (%rcx)
addq $0x60, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6130
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x16290
leaq -0x18(%rbp), %rdi
callq 0x6130
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xcdd0
jmp 0xcedc
leaq -0x18(%rbp), %rdi
callq 0x6240
jmp 0xce11
addq $0x50, %rsp
popq %rbp
retq
// File: AraKhachatryan[P]GraphAlgo/dfs.cpp
// Function: GraphAlgo::dfs::dfs(GraphAlgo::graph const&, int const&)
dfs::
dfs( const graph& g, const vertex& v )
{
	g_in = g;

	m_vertices = g.get_vertices();
	m_neighborhood = g.get_neighborhood();

	vertices::const_iterator it = m_vertices.begin();
	for( ; it != m_vertices.end(); ++it ) 
	{
		m_visit.insert( visit::value_type(*it, false) );
	}
	
	m_visit[v] = true;      
	dfs_traversal(v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
callq 0x16d80
movq -0xb8(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0xb0(%rbp)
callq 0x16d80
jmp 0xcf3a
movq -0xc0(%rbp), %rdi
addq $0xc0, %rdi
movq %rdi, -0xd8(%rbp)
callq 0xc6c0
movq -0xc0(%rbp), %rdi
addq $0xf0, %rdi
movq %rdi, -0xd0(%rbp)
callq 0x63c0
movq -0xc0(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
movq %rdi, -0xc8(%rbp)
callq 0x6400
movq -0xc0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16e00
jmp 0xcf9a
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x16180
jmp 0xcfa9
movq -0xc0(%rbp), %rdi
addq $0xf0, %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
callq 0x6420
movq -0xe0(%rbp), %rdi
callq 0x6450
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x160d0
jmp 0xcfe2
movq -0xc0(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
leaq -0x70(%rbp), %rsi
callq 0x64b0
leaq -0x70(%rbp), %rdi
callq 0x64e0
movq -0xc0(%rbp), %rdi
addq $0xf0, %rdi
callq 0x6050
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x6080
movq -0xc0(%rbp), %rdi
addq $0xf0, %rdi
callq 0x6100
movq %rax, -0x88(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x60c0
testb $0x1, %al
jne 0xd059
jmp 0xd12e
movq -0xc0(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0xe8(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6130
movq %rax, %rsi
movb $0x0, -0x91(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x91(%rbp), %rdx
callq 0xd340
jmp 0xd095
movq -0xe8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xd300
movb %dl, -0xf1(%rbp)
movq %rax, -0xf0(%rbp)
jmp 0xd0b7
movb -0xf1(%rbp), %al
movq -0xf0(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movb %al, -0xa0(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6240
jmp 0xd026
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xd173
movq -0xc8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x64e0
movq -0xd0(%rbp), %rdi
callq 0x6450
movq -0xd8(%rbp), %rdi
callq 0xc6a0
movq -0xb0(%rbp), %rdi
callq 0x16dc0
jmp 0xd173
movq -0xc0(%rbp), %rdi
addq $0xc0, %rdi
movq -0x18(%rbp), %rsi
callq 0xd220
movq %rax, -0x100(%rbp)
jmp 0xd14e
movq -0xc0(%rbp), %rdi
movq -0x100(%rbp), %rax
movb $0x1, (%rax)
movq -0x18(%rbp), %rsi
callq 0xcdd0
jmp 0xd16a
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x16dc0
movq -0x20(%rbp), %rdi
callq 0x22b0
nopl (%rax,%rax)