LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: xelia-it[P]mustache/src/./../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::serializer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::hex_bytes(unsigned char)
static std::string hex_bytes(std::uint8_t byte)
    {
        std::string result = "FF";
        constexpr const char* nibble_to_hex = "0123456789ABCDEF";
        result[0] = nibble_to_hex[byte / 16];
        result[1] = nibble_to_hex[byte % 16];
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
leaq -0xb(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x6d7d0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x82f8(%rip), %rsi      # 0xa9f15
callq 0x6bd90
jmp 0xa1c24
leaq -0xb(%rbp), %rdi
callq 0x6ae90
movq -0x38(%rbp), %rdi
leaq 0xc778(%rip), %rcx      # 0xae3b0
movq %rcx, -0x28(%rbp)
movzbl -0x9(%rbp), %eax
shrl $0x4, %eax
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x6e320
movq %rax, -0x48(%rbp)
jmp 0xa1c58
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rax
movb -0x49(%rbp), %cl
movb %cl, (%rax)
movzbl -0x9(%rbp), %eax
andl $0xf, %eax
leaq 0xc73d(%rip), %rcx      # 0xae3b0
movb (%rax,%rcx), %al
movb %al, -0x59(%rbp)
movl $0x1, %esi
callq 0x6e320
movq %rax, -0x58(%rbp)
jmp 0xa1c89
movq -0x58(%rbp), %rax
movb -0x59(%rbp), %cl
movb %cl, (%rax)
movb $0x1, -0xa(%rbp)
testb $0x1, -0xa(%rbp)
jne 0xa1cd5
jmp 0xa1ccc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xb(%rbp), %rdi
callq 0x6ae90
jmp 0xa1cdf
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6e458
jmp 0xa1cdf
movq -0x38(%rbp), %rdi
callq 0x6e458
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6d7b0
nopl (%rax,%rax)
// File: mgabilo[P]prefix-sums-mpi/prefix.cpp
// Function: generate_random(unsigned long, int)
double* generate_random(size_t num, int rank)
{
  // seed the random number generator; add the rank to the
  // time to make sure every process has a different seed
  srandom(time(NULL) + rank);

  double* random_numbers = (double*)
                          malloc(sizeof(double) * num);
  if (!random_numbers) {
    printf("%d Failed to malloc\n", rank);
    exit(EXIT_FAILURE);
  }

  for (size_t i = 0; i < num; i++) {
    random_numbers[i] = random_double() * RAND_MAX_GEN; 
                       
    #ifdef DEBUG
      size_t i_real_pos = num * rank + i;
      printf("Number %02zu: %lf\n", i_real_pos,
            random_numbers[i]);
    #endif

  }
  return random_numbers;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x84c0
movslq 0x1c(%rsp), %rcx
addq %rcx, %rax
movl %eax, %edi
callq 0x8130
movq 0x20(%rsp), %rdi
shlq $0x3, %rdi
callq 0x8740
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x8e9c
movl 0x1c(%rsp), %esi
leaq 0x61bd(%rip), %rdi      # 0xf048
movb $0x0, %al
callq 0x8040
movl $0x1, %edi
callq 0x8660
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x8ee1
callq 0x9340
movsd 0x614a(%rip), %xmm1     # 0xf008
mulsd %xmm1, %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x8ea5
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: mgabilo[P]prefix-sums-mpi/prefix.cpp
// Function: find_sum(double*, unsigned long)
double find_sum(double* numbers, size_t size)
{
  double sum = 0.0;
  for (size_t i = 0; i < size; i++) {
    sum += numbers[i];
  }
  return sum;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x93b3
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x18(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x937c
movsd -0x18(%rsp), %xmm0
retq
nopw (%rax,%rax)
// File: splatlab[P]debgr/./kmer.h
// Function: kmercounting::str_to_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
uint64_t str_to_int(string str)
	{
		uint64_t strint = 0;
		for (auto it = str.begin(); it != str.end(); it++) {
			uint8_t curr = 0;
			switch (*it) {
				case 'A': { curr = DNA_MAP::A; break; }
				case 'T': { curr = DNA_MAP::T; break; }
				case 'C': { curr = DNA_MAP::C; break; }
				case 'G': { curr = DNA_MAP::G; break; }
			}
			strint = strint | curr;
			strint = strint << 2;
		}
		return strint >> 2;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
callq 0x6390
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
callq 0x6230
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xaaa0
testb $0x1, %al
jne 0x6ac1
jmp 0x6b38
movb $0x0, -0x21(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xaae0
movsbl (%rax), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x13, %eax
ja 0x6b09
movq -0x40(%rbp), %rax
leaq 0x15526(%rip), %rcx     # 0x1c010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x21(%rbp)
jmp 0x6b09
movb $0x2, -0x21(%rbp)
jmp 0x6b09
movb $0x0, -0x21(%rbp)
jmp 0x6b09
movb $0x3, -0x21(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x21(%rbp), %ecx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xab00
movq %rax, -0x30(%rbp)
jmp 0x6aa1
movq -0x10(%rbp), %rax
shrq $0x2, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/./kmer.h
// Function: kmercounting::int_to_str[abi:cxx11](unsigned long)
string int_to_str(uint64_t kmer)
	{
		uint8_t base;
		string str;
		for (int i=K; i>0; i--) {
			base = (kmer >> (i*2-2)) & 3ULL;
			char chr = kmer::map_int(base);
			str.push_back(chr);
		}
		return str;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x6620
movl $0x1c, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x6bdc
movq -0x10(%rbp), %rax
movb -0x18(%rbp), %cl
addb %cl, %cl
addb $-0x2, %cl
shrq %cl, %rax
andb $0x3, %al
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %edi
callq 0xab40
movb %al, -0x41(%rbp)
jmp 0x6ba3
movq -0x40(%rbp), %rdi
movb -0x41(%rbp), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %esi
callq 0x6380
jmp 0x6bb8
jmp 0x6bba
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6b7b
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6250
jmp 0x6bf9
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x6bef
movq -0x40(%rbp), %rdi
callq 0x6250
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/./kmer.h
// Function: kmercounting::int_to_str_node[abi:cxx11](unsigned long)
string int_to_str_node(uint64_t kmer)
	{
		uint8_t base;
		string str;
		for (int i=K-1; i>0; i--) {
			base = (kmer >> (i*2-2)) & 3ULL;
			char chr = kmer::map_int(base);
			str.push_back(chr);
		}
		return str;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x6620
movl $0x1b, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x6c9c
movq -0x10(%rbp), %rax
movb -0x18(%rbp), %cl
addb %cl, %cl
addb $-0x2, %cl
shrq %cl, %rax
andb $0x3, %al
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %edi
callq 0xab40
movb %al, -0x41(%rbp)
jmp 0x6c63
movq -0x40(%rbp), %rdi
movb -0x41(%rbp), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %esi
callq 0x6380
jmp 0x6c78
jmp 0x6c7a
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6c3b
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x6250
jmp 0x6cb9
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x6caf
movq -0x40(%rbp), %rdi
callq 0x6250
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/./kmer.h
// Function: kmercounting::kmer::reverse_complement(unsigned long)
uint64_t kmer::reverse_complement(uint64_t kmer)
	{
		uint64_t rc = 0;
		uint8_t base = 0;
		for (int i=0; i<K; i++) {
			base = kmer & 3ULL;
			base = reverse_complement_base(base);
			kmer >>= 2;
			rc |= base;
			rc <<= 2;
		}
		rc >>=2;
		return rc;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1c, -0x18(%rbp)
jge 0x6d3b
movq -0x8(%rbp), %rax
andq $0x3, %rax
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %edi
callq 0xab90
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movq %rax, -0x8(%rbp)
movzbl -0x11(%rbp), %eax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6cef
movq -0x10(%rbp), %rax
shrq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/./kmer.h
// Function: kmercounting::kmer::reverse_complement_node(unsigned long)
uint64_t kmer::reverse_complement_node(uint64_t kmer)
	{
		uint64_t rc = 0;
		uint8_t base = 0;
		for (int i=0; i<K-1; i++) {
			base = kmer & 3ULL;
			base = reverse_complement_base(base);
			kmer >>= 2;
			rc |= base;
			rc <<= 2;
		}
		rc >>=2;
		return rc;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1b, -0x18(%rbp)
jge 0x6dcb
movq -0x8(%rbp), %rax
andq $0x3, %rax
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %edi
callq 0xab90
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movq %rax, -0x8(%rbp)
movzbl -0x11(%rbp), %eax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6d7f
movq -0x10(%rbp), %rax
shrq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/./reader.h
// Function: kmercounting::reader::reader()
reader::reader()
	{
		in = nullptr;
		in_gzip = nullptr;
		in_bzip2 = nullptr;
		bzerror = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movl $0x0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/./reader.h
// Function: kmercounting::reader::reader(_IO_FILE*, gzFile_s*, void*, int)
reader::reader(FILE *_in, gzFile_s *_in_gzip, BZFILE *_in_bzip2, int _bzerror)
	{
		in = _in;
		in_gzip = _in_gzip;
		in_bzip2 = _in_bzip2;
		bzerror = _bzerror;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/main.cc
// Function: count_distinct_kmers(std::multiset<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>>)
uint64_t count_distinct_kmers(multiset<uint64_t> kmers)
{
	uint64_t cnt = 0;
	uint64_t curr_kmer = 0;

	for(uint64_t kmer: kmers) {
		if (kmer != curr_kmer) {
			curr_kmer = kmer;
			cnt++;
		}
	}
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xad10
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xad40
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xad70
testb $0x1, %al
jne 0x6eed
jmp 0x6f28
leaq -0x28(%rbp), %rdi
callq 0xada0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x6f1b
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6f1d
leaq -0x28(%rbp), %rdi
callq 0xadd0
jmp 0x6eda
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/main.cc
// Function: skip_next_eol(char*, long&, long)
bool skip_next_eol(char *part, int64_t &pos, int64_t max_pos)
{
	int64_t i;
	for(i = pos; i < max_pos-2; ++i)
		if((part[i] == '\n' || part[i] == '\r') && !(part[i+1] == '\n' ||
																								 part[i+1] == '\r'))
			break;

	if(i >= max_pos-2)
		return false;
	pos = i+1;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jge 0x7114
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x70de
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x7104
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x7104
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0xd, %eax
je 0x7104
jmp 0x7114
jmp 0x7106
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x70ab
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jl 0x712b
movb $0x0, -0x1(%rbp)
jmp 0x713e
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/main.cc
// Function: is_constant(unsigned long)
bool is_constant(uint64_t n) {
	uint64_t b = n & 3ULL;
	uint64_t val = b * 0x5555555555555555;
	uint64_t n2 = val & BITMASK(2*K);
	return n == n2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $0x3, %rax
movq %rax, -0x10(%rbp)
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
imulq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $0xffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF
andq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: splatlab[P]debgr/main.cc
// Function: is_duplex_edge(unsigned long, unsigned long)
bool is_duplex_edge(uint64_t n, uint64_t e) {
	bool lefty = false, righty = false;
	for (const auto b : bases) {
		righty |= (e == node_r_edge(n, b));
		lefty |= (e == node_l_edge(n, b));
	}
	return righty && lefty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
leaq 0x14d61(%rip), %rax     # 0x1c090
movq %rax, -0x20(%rbp)
leaq 0x14d56(%rip), %rax     # 0x1c090
movq %rax, -0x28(%rbp)
leaq 0x14d4b(%rip), %rax     # 0x1c090
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x73eb
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x72c0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %ecx
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x72e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %ecx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x734d
xorl %eax, %eax
testb $0x1, -0x12(%rbp)
movb %al, -0x49(%rbp)
je 0x73fc
movb -0x11(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: splatlab[P]debgr/main.cc
// Function: is_left_edge(unsigned long, unsigned long)
bool is_left_edge(uint64_t n, uint64_t e) {
	for (const auto b : bases)
		if (e == canonicalize(node_l_edge(n, b)))
			return !is_duplex_edge(n, e);
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x14c69(%rip), %rax     # 0x1c090
movq %rax, -0x20(%rbp)
leaq 0x14c5e(%rip), %rax     # 0x1c090
movq %rax, -0x28(%rbp)
leaq 0x14c53(%rip), %rax     # 0x1c090
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x74a6
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x72e0
movq %rax, %rdi
callq 0x7150
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0x7496
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7310
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x74aa
jmp 0x7498
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x7445
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/main.cc
// Function: is_right_edge(unsigned long, unsigned long)
bool is_right_edge(uint64_t n, uint64_t e) {
	for (const auto b : bases)
		if (e == canonicalize(node_r_edge(n, b)))
			return !is_duplex_edge(n, e);
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x14bb9(%rip), %rax     # 0x1c090
movq %rax, -0x20(%rbp)
leaq 0x14bae(%rip), %rax     # 0x1c090
movq %rax, -0x28(%rbp)
leaq 0x14ba3(%rip), %rax     # 0x1c090
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x7556
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x72c0
movq %rax, %rdi
callq 0x7150
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0x7546
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7310
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x755a
jmp 0x7548
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x74f5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/main.cc
// Function: record_end(unsigned long, unsigned long, flush_object*)
void record_end(uint64_t n, uint64_t e, flush_object *obj) {
	uint64_t hash = HashUtil::hash_64(n, BITMASK(2*(K-1)));
	if (is_left_edge(n, e)) {
		qf_insert(obj->first_qf, hash, 0, 1, true, true);
		//cout << "Begin node: " << int_to_str_node(n) << endl;
		//cout << "Begin edge: " << int_to_str(e) << endl;
	}
	else if (is_right_edge(n, e)) {
		qf_insert(obj->last_qf, hash, 0, 1, true, true);
		//cout << "End node: " << int_to_str_node(n) << endl;
		//cout << "End edge: " << int_to_str(e) << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movabsq $0x3fffffffffffff, %rsi # imm = 0x3FFFFFFFFFFFFF
callq 0x16020
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7410
testb $0x1, %al
jne 0x75ae
jmp 0x75d2
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movl %r9d, %r8d
callq 0x16f50
jmp 0x760a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x74c0
testb $0x1, %al
jne 0x75e5
jmp 0x7608
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movl $0x1, %r9d
movl %r9d, %r8d
callq 0x16f50
jmp 0x760a
addq $0x20, %rsp
popq %rbp
retq
// File: splatlab[P]debgr/main.cc
// Function: dump_local_qf_to_main(flush_object*)
static void dump_local_qf_to_main(flush_object *obj)
{
	QFi local_cfi;

	if (qf_iterator(obj->local_qf, &local_cfi, 0)) {
		do {
			uint64_t key = 0, value = 0, count = 0;
			qfi_get(&local_cfi, &key, &value, &count);
			qf_insert(obj->main_qf, key, 0, count, true, true);
		} while (!qfi_next(&local_cfi));
		qf_reset(obj->local_qf);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x18fa0
testb $0x1, %al
jne 0x80b7
jmp 0x812a
jmp 0x80b9
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x191a0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %r9d
movl %r9d, %r8d
callq 0x16f50
leaq -0x38(%rbp), %rdi
callq 0x19250
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x80b9
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x16d00
addq $0x50, %rsp
popq %rbp
retq
// File: splatlab[P]debgr/main.cc
// Function: getFileReader(int, char*, kmercounting::reader*)
bool getFileReader(int mode, char* fastq_file, reader* file_reader) 
{
	uint64_t gzip_buffer_size = 1ULL << 26;
	uint64_t bzip2_buffer_size = 1ULL << 26;

	if (mode == 0) {
		if ((file_reader->in = fopen(fastq_file, "rb")) == NULL)
			return false;
	} else if (mode == 1) {
		if ((file_reader->in_gzip = gzopen(fastq_file, "rb")) == NULL)
			return false;
		gzbuffer(file_reader->in_gzip, gzip_buffer_size);
	} else if (mode == 2) {
		file_reader->in = fopen(fastq_file, "rb");
		if (!file_reader->in)
			return false;
		setvbuf(file_reader->in, NULL, _IOFBF, bzip2_buffer_size);
		if ((file_reader->in_bzip2 = BZ2_bzReadOpen(&file_reader->bzerror,
																								file_reader->in, 0, 0, NULL,
																								0)) == NULL) {
			fclose(file_reader->in);
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x4000000, -0x20(%rbp) # imm = 0x4000000
movq $0x4000000, -0x28(%rbp) # imm = 0x4000000
cmpl $0x0, -0x8(%rbp)
jne 0x8184
movq -0x10(%rbp), %rdi
leaq 0x1400a(%rip), %rsi     # 0x1c16e
callq 0x6540
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x817f
movb $0x0, -0x1(%rbp)
jmp 0x825f
jmp 0x825b
cmpl $0x1, -0x8(%rbp)
jne 0x81c9
movq -0x10(%rbp), %rdi
leaq 0x13fd9(%rip), %rsi     # 0x1c16e
callq 0x6660
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x81b1
movb $0x0, -0x1(%rbp)
jmp 0x825f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x62f0
jmp 0x8259
cmpl $0x2, -0x8(%rbp)
jne 0x8257
movq -0x10(%rbp), %rdi
leaq 0x13f90(%rip), %rsi     # 0x1c16e
callq 0x6540
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x81fd
movb $0x0, -0x1(%rbp)
jmp 0x825f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x6050
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
xorl %r9d, %r9d
xorl %eax, %eax
movl %eax, %r8d
movl %r9d, %edx
movl %r9d, %ecx
callq 0x66f0
movq -0x18(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x8255
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x6430
movb $0x0, -0x1(%rbp)
jmp 0x825f
jmp 0x8257
jmp 0x8259
jmp 0x825b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: splatlab[P]debgr/./kmer.h
// Function: kmercounting::kmer::map_int(unsigned char)
inline char kmer::map_int(uint8_t base)
	{
		switch(base) {
			case DNA_MAP::A: { return 'A'; }
			case DNA_MAP::T: { return 'T'; }
			case DNA_MAP::C: { return 'C'; }
			case DNA_MAP::G: { return 'G'; }
			default:  { return DNA_MAP::G+1; }
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0xab84
movq -0x10(%rbp), %rax
leaq 0x1153d(%rip), %rcx     # 0x1c0a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x41, -0x1(%rbp)
jmp 0xab88
movb $0x54, -0x1(%rbp)
jmp 0xab88
movb $0x43, -0x1(%rbp)
jmp 0xab88
movb $0x47, -0x1(%rbp)
jmp 0xab88
movb $0x4, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: splatlab[P]debgr/./kmer.h
// Function: kmercounting::kmer::map_base(char)
inline uint8_t kmer::map_base(char base)
	{
		switch(base) {
			case 'A': { return DNA_MAP::A; }
			case 'T': { return DNA_MAP::T; }
			case 'C': { return DNA_MAP::C; }
			case 'G': { return DNA_MAP::G; }
			default:  { return DNA_MAP::G+1; }
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x13, %eax
ja 0xaed8
movq -0x10(%rbp), %rax
leaq 0x111fd(%rip), %rcx     # 0x1c0b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0xaedc
movb $0x2, -0x1(%rbp)
jmp 0xaedc
movb $0x0, -0x1(%rbp)
jmp 0xaedc
movb $0x3, -0x1(%rbp)
jmp 0xaedc
movb $0x4, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: splatlab[P]debgr/main.cc
// Function: is_eof(kmercounting::reader&, int)
inline bool is_eof(reader &file_reader, int mode)
{
	if (mode == 0)
		return feof(file_reader.in) != 0;
	else if (mode == 1)
		return gzeof(file_reader.in_gzip) != 0;
	else if (mode == 2)
		return file_reader.bzerror == BZ_STREAM_END;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x11f0e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x66c0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11f4e
cmpl $0x1, -0x14(%rbp)
jne 0x11f2e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6110
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11f4e
cmpl $0x2, -0x14(%rbp)
jne 0x11f46
movq -0x10(%rbp), %rax
cmpl $0x4, 0x18(%rax)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x11f4e
jmp 0x11f48
jmp 0x11f4a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ldionne[P]hawick_circuits/hawick_circuits.cpp
// Function: main
int main(int argc, char const* argv[]) {
    if (argc < 2) {
        std::cout << "usage: " << argv[0] << " num_vertices < input\n";
        return EXIT_FAILURE;
    }

    unsigned int num_vertices = boost::lexical_cast<unsigned int>(argv[1]);
    std::istream_iterator<unsigned int> first_vertex(std::cin), last_vertex;
    boost::directed_graph<> graph;
    build_graph(graph, num_vertices, first_vertex, last_vertex);

    cycle_printer<std::ostream> visitor(std::cout);
    boost::hawick_circuits(graph, visitor);

    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x356c
movq 0x16a92(%rip), %rdi     # 0x19fc8
leaq 0xbad7(%rip), %rsi      # 0xf014
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x31b0
movq %rax, %rdi
leaq 0xbac1(%rip), %rsi      # 0xf01c
callq 0x31b0
movl $0x1, -0x4(%rbp)
jmp 0x3660
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x36b0
movl %eax, -0x14(%rbp)
movq 0x16a5d(%rip), %rsi     # 0x19fe0
leaq -0x28(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x36f0
leaq -0x38(%rbp), %rdi
callq 0x3720
leaq -0x90(%rbp), %rdi
leaq -0x91(%rbp), %rsi
callq 0x3740
movq -0xe0(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, -0xd4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3a80
jmp 0x35cd
leaq -0xc8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3a80
jmp 0x35df
movl -0xd4(%rbp), %esi
leaq -0x90(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
leaq -0xc8(%rbp), %rcx
callq 0x3790
jmp 0x3601
movq 0x169c0(%rip), %rsi     # 0x19fc8
leaq -0xd0(%rbp), %rdi
callq 0x3ac0
jmp 0x3616
leaq -0x90(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x3ae0
jmp 0x362b
movl $0x0, -0x4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3b20
jmp 0x3660
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3b20
jmp 0x366c
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x32e0
nopl (%rax,%rax)
// File: ldionne[P]hawick_circuits/boost/graph/hawick_circuits.hpp
// Function: boost::hawick_circuits_detail::hawick_circuits_from<boost::directed_graph<boost::no_property, boost::no_property, boost::no_property>, cycle_printer<std::ostream>, boost::adj_list_vertex_property_map<boost::adjacency_list<boost::listS, boost::listS, boost::bidirectionalS, boost::property<boost::vertex_index_t, unsigned int, boost::no_property>, boost::property<boost::edge_index_t, unsigned int, boost::no_property>, boost::no_property, boost::listS>, unsigned int, unsigned int const&, boost::vertex_index_t>, std::vector<void*, std::allocator<void*>>, std::vector<std::vector<void*, std::allocator<void*>>, std::allocator<std::vector<void*, std::allocator<void*>>>>, boost::hawick_circuits_detail::get_all_adjacent_vertices>::blocked_map_starts_all_unblocked() const
bool blocked_map_starts_all_unblocked() const {
        BOOST_FOREACH(Vertex v, vertices(graph_))
            if (is_blocked(v))
                return false;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%rax), %rdi
callq 0x9d40
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb7d0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb800
testb $0x1, %al
jne 0xb0c3
jmp 0xb0c8
jmp 0xb1cd
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xb810
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xb800
testb $0x1, %al
jne 0xb0f3
jmp 0xb0f8
jmp 0xb1cb
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xb850
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0xb800
testb $0x1, %al
jne 0xb123
jmp 0xb128
jmp 0xb1c9
movb $0x1, -0x59(%rbp)
xorl %eax, %eax
testb $0x1, -0x59(%rbp)
movb %al, -0x71(%rbp)
je 0xb14d
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb890
xorb $-0x1, %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0xb156
jmp 0xb1c7
leaq -0x59(%rbp), %rdi
callq 0xb8d0
testb $0x1, %al
jne 0xb165
jmp 0xb167
jmp 0xb1a9
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb8f0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movb -0x59(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb186
jmp 0xb1a7
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xb920
testb $0x1, %al
jne 0xb199
jmp 0xb19f
movb $0x0, -0x1(%rbp)
jmp 0xb1d1
jmp 0xb1a1
movb $0x1, -0x59(%rbp)
jmp 0xb17b
jmp 0xb1a9
jmp 0xb1ab
testb $0x1, -0x59(%rbp)
je 0xb1c0
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xb960
jmp 0xb1c2
jmp 0xb1c2
jmp 0xb12c
jmp 0xb1c9
jmp 0xb1cb
jmp 0xb1cd
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nop
// File: ldionne[P]hawick_circuits/boost/graph/hawick_circuits.hpp
// Function: boost::hawick_circuits_detail::hawick_circuits_from<boost::directed_graph<boost::no_property, boost::no_property, boost::no_property>, cycle_printer<std::ostream>, boost::adj_list_vertex_property_map<boost::adjacency_list<boost::listS, boost::listS, boost::bidirectionalS, boost::property<boost::vertex_index_t, unsigned int, boost::no_property>, boost::property<boost::edge_index_t, unsigned int, boost::no_property>, boost::no_property, boost::listS>, unsigned int, unsigned int const&, boost::vertex_index_t>, std::vector<void*, std::allocator<void*>>, std::vector<std::vector<void*, std::allocator<void*>>, std::allocator<std::vector<void*, std::allocator<void*>>>>, boost::hawick_circuits_detail::get_all_adjacent_vertices>::all_closed_rows_are_empty() const
bool all_closed_rows_are_empty() const {
        BOOST_FOREACH(typename ClosedMatrix::reference row, closed_)
            if (!row.empty())
                return false;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbcd0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb800
testb $0x1, %al
jne 0xb288
jmp 0xb28d
jmp 0xb389
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xbd10
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb800
testb $0x1, %al
jne 0xb2b8
jmp 0xb2bd
jmp 0xb387
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xbd50
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xb800
testb $0x1, %al
jne 0xb2e8
jmp 0xb2ed
jmp 0xb385
movb $0x1, -0x41(%rbp)
xorl %eax, %eax
testb $0x1, -0x41(%rbp)
movb %al, -0x51(%rbp)
je 0xb312
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbd90
xorb $-0x1, %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xb31b
jmp 0xb383
leaq -0x41(%rbp), %rdi
callq 0xb8d0
testb $0x1, %al
jne 0xb32a
jmp 0xb32c
jmp 0xb365
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbdd0
movq %rax, -0x50(%rbp)
movb -0x41(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xb348
jmp 0xb363
movq -0x50(%rbp), %rdi
callq 0xb1e0
testb $0x1, %al
jne 0xb35b
movb $0x0, -0x1(%rbp)
jmp 0xb38d
jmp 0xb35d
movb $0x1, -0x41(%rbp)
jmp 0xb33d
jmp 0xb365
jmp 0xb367
testb $0x1, -0x41(%rbp)
je 0xb37c
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xbe00
jmp 0xb37e
jmp 0xb37e
jmp 0xb2f1
jmp 0xb385
jmp 0xb387
jmp 0xb389
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ldionne[P]hawick_circuits/hawick_circuits.cpp
// Function: void cycle_printer<std::ostream>::cycle<std::vector<void*, std::allocator<void*>>, boost::directed_graph<boost::no_property, boost::no_property, boost::no_property>>(std::vector<void*, std::allocator<void*>> const&, boost::directed_graph<boost::no_property, boost::no_property, boost::no_property> const&)
void cycle(Path const& p, Graph const& g)
    {
        if (p.empty())
            return;

        // Get the property map containing the vertex indices
        // so we can print them.
        typedef typename boost::property_map<
                    Graph, boost::vertex_index_t
                >::const_type IndexMap;

        IndexMap indices = get(boost::vertex_index, g);

        // Iterate over path printing each vertex that forms the cycle.
        typename Path::const_iterator i, before_end = boost::prior(p.end());
        for (i = p.begin(); i != before_end; ++i) {
            os << get(indices, *i) << " ";
        }
        os << get(indices, *i) << '\n';
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb1e0
testb $0x1, %al
jne 0xc58b
jmp 0xc590
jmp 0xc666
movq -0x18(%rbp), %rsi
xorl %edi, %edi
callq 0x9b30
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xd800
movq -0x10(%rbp), %rdi
callq 0xbc70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xd820
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbc40
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd850
testb $0x1, %al
jne 0xc5e9
jmp 0xc62e
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xd890
movq %rax, %rsi
leaq -0x1c(%rbp), %rdi
callq 0xbb60
movq -0x50(%rbp), %rdi
movl (%rax), %esi
callq 0x3230
movq %rax, %rdi
leaq 0x29fc(%rip), %rsi      # 0xf01a
callq 0x31b0
leaq -0x28(%rbp), %rdi
callq 0xd8b0
jmp 0xc5d6
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xd890
movq %rax, %rsi
leaq -0x1c(%rbp), %rdi
callq 0xbb60
movq -0x58(%rbp), %rdi
movl (%rax), %esi
callq 0x3230
movq %rax, %rdi
movl $0xa, %esi
callq 0x3200
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: ldionne[P]hawick_circuits/boost/graph/hawick_circuits.hpp
// Function: boost::hawick_circuits_detail::hawick_circuits_from<boost::directed_graph<boost::no_property, boost::no_property, boost::no_property>, cycle_printer<std::ostream>, boost::adj_list_vertex_property_map<boost::adjacency_list<boost::listS, boost::listS, boost::bidirectionalS, boost::property<boost::vertex_index_t, unsigned int, boost::no_property>, boost::property<boost::edge_index_t, unsigned int, boost::no_property>, boost::no_property, boost::listS>, unsigned int, unsigned int const&, boost::vertex_index_t>, std::vector<void*, std::allocator<void*>>, std::vector<std::vector<void*, std::allocator<void*>>, std::allocator<std::vector<void*, std::allocator<void*>>>>, boost::hawick_circuits_detail::get_all_adjacent_vertices>::unblock(void*)
void unblock(Vertex u) {
        typedef typename ClosedMatrix::reference VertexList;

        put(blocked_, u, blocked_false_color());
        VertexList closed_to_u = closed_[index_of(u)];

        while (!closed_to_u.empty()) {
            Vertex const w = closed_to_u.back();
            closed_to_u.pop_back();
            if (is_blocked(w))
                unblock(w);
        }
        BOOST_ASSERT(closed_to_u.empty());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x28, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xd9e0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl %eax, %edx
callq 0xcca0
movq -0x30(%rbp), %rdi
movq 0x20(%rdi), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0xc410
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0xd9f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb1e0
xorb $-0x1, %al
testb $0x1, %al
jne 0xc713
jmp 0xc74e
movq -0x18(%rbp), %rdi
callq 0xc870
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc8b0
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb920
testb $0x1, %al
jne 0xc73f
jmp 0xc74c
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc6a0
jmp 0xc702
movq -0x18(%rbp), %rdi
callq 0xb1e0
testb $0x1, %al
jne 0xc75d
jmp 0xc75f
jmp 0xc77e
leaq 0x389d(%rip), %rdi      # 0x10003
leaq 0x2b87(%rip), %rsi      # 0xf2f4
movl $0xd0, %edx
leaq 0x389e(%rip), %rcx      # 0x10017
callq 0x3150
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::reset()
void Cryptogram::reset()
{
    cyphertext = SAMPLE_TEXT;
    plaintext = "";
    memset(alphabet, ' ', sizeof(alphabet));
    calcPlaintext();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x39c9(%rip), %rsi      # 0x6004
callq 0x2370
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
leaq 0x3b62(%rip), %rsi      # 0x61b1
callq 0x2370
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movl $0x20, %esi
movl $0x1a, %edx
callq 0x2150
movq -0x10(%rbp), %rdi
callq 0x26b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::calcPlaintext()
void Cryptogram::calcPlaintext()
{
    if (plaintext.length() != cyphertext.length())
        plaintext = string(" ", cyphertext.length());
    string::iterator p = plaintext.begin();
    string::iterator c = cyphertext.begin();
    char ch;
    while (c != cyphertext.end())
    {
        // Get the character
        ch = *c;
        // Normalize it to uppercase
        ch = normalize(ch);
        // Calc the plaintext
        if (isKey(ch))
        {
            *p = alphabet[ch - 'A'];
            if (*p == ' ')
                *p = '_';
        } else {
            *p = *c;
        }
        p++;
        c++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x20, %rdi
callq 0x23e0
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x23e0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
je 0x2768
movq -0x80(%rbp), %rdi
callq 0x23e0
movq %rax, -0x90(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2410
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
leaq 0x3b26(%rip), %rsi      # 0x6244
leaq -0x28(%rbp), %rdi
callq 0x22c0
jmp 0x2729
movq -0x80(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x2330
leaq -0x28(%rbp), %rdi
callq 0x2180
leaq -0x29(%rbp), %rdi
callq 0x2290
jmp 0x2768
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x2290
jmp 0x2868
movq -0x80(%rbp), %rdi
addq $0x20, %rdi
callq 0x21f0
movq -0x80(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x21f0
movq %rax, -0x50(%rbp)
movq -0x80(%rbp), %rdi
callq 0x2160
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4040
testb $0x1, %al
jne 0x27a9
jmp 0x285f
leaq -0x50(%rbp), %rdi
callq 0x4080
movb (%rax), %al
movb %al, -0x51(%rbp)
movsbl -0x51(%rbp), %edi
callq 0x2d10
movb %al, -0x51(%rbp)
movsbl -0x51(%rbp), %edi
callq 0x2d50
testb $0x1, %al
jne 0x27d2
jmp 0x281a
movq -0x80(%rbp), %rax
movsbl -0x51(%rbp), %ecx
subl $0x41, %ecx
movslq %ecx, %rcx
movb 0x40(%rax,%rcx), %al
movb %al, -0x91(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4080
movb -0x91(%rbp), %cl
movb %cl, (%rax)
leaq -0x48(%rbp), %rdi
callq 0x4080
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x2818
leaq -0x48(%rbp), %rdi
callq 0x4080
movb $0x5f, (%rax)
jmp 0x283c
leaq -0x50(%rbp), %rdi
callq 0x4080
movb (%rax), %al
movb %al, -0x92(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4080
movb -0x92(%rbp), %cl
movb %cl, (%rax)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x40a0
movq %rax, -0x68(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x40a0
movq %rax, -0x70(%rbp)
jmp 0x2786
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2400
nopw %cs:(%rax,%rax)
// File: BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::loadFile(char const*)
void Cryptogram::loadFile(const char *filename)
{
    FILE *f;
    char block[4096];
    int size;
    
    cyphertext = SAMPLE_TEXT;
    plaintext = "";
    memset(alphabet, ' ', sizeof(alphabet));

    f = fopen(filename, "rb");
    if (!f)
    {
        reset();
        return;
    }
    size = fread(block, 1, 4096, f);
    block[4095] = 0;
    block[size] = 0;
    fclose(f);

    if (strncmp(block, FILE_HEADER, strlen(FILE_HEADER) + 1) == 0)
    {
        memcpy(alphabet, block + strlen(FILE_HEADER) + 1, sizeof(alphabet));
        cyphertext = strdup(block + strlen(FILE_HEADER) + 1 + sizeof(alphabet));
    } else {
        cyphertext = strdup(block);
    }
    calcPlaintext();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1030(%rbp)
leaq 0x375f(%rip), %rsi      # 0x6004
callq 0x2370
movq -0x1030(%rbp), %rdi
addq $0x20, %rdi
leaq 0x38f5(%rip), %rsi      # 0x61b1
callq 0x2370
movq -0x1030(%rbp), %rdi
addq $0x40, %rdi
movl $0x20, %esi
movl $0x1a, %edx
callq 0x2150
movq -0x10(%rbp), %rdi
leaq 0x38bb(%rip), %rsi      # 0x61a1
callq 0x2300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2907
movq -0x1030(%rbp), %rdi
callq 0x2620
jmp 0x29e3
leaq -0x1020(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x23d0
movl %eax, -0x1024(%rbp)
movb $0x0, -0x21(%rbp)
movslq -0x1024(%rbp), %rax
movb $0x0, -0x1020(%rbp,%rax)
movq -0x18(%rbp), %rdi
callq 0x2220
leaq -0x1020(%rbp), %rdi
leaq 0x3853(%rip), %rsi      # 0x61a4
movl $0x8, %edx
callq 0x2120
cmpl $0x0, %eax
jne 0x29bc
movq -0x1030(%rbp), %rax
movq -0x1018(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x1010(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x1008(%rbp), %rcx
movq %rcx, 0x50(%rax)
movw -0x1000(%rbp), %cx
movw %cx, 0x58(%rax)
leaq -0x1020(%rbp), %rdi
addq $0x7, %rdi
addq $0x1, %rdi
addq $0x1a, %rdi
callq 0x2440
movq -0x1030(%rbp), %rdi
movq %rax, %rsi
callq 0x2370
jmp 0x29d7
leaq -0x1020(%rbp), %rdi
callq 0x2440
movq -0x1030(%rbp), %rdi
movq %rax, %rsi
callq 0x2370
movq -0x1030(%rbp), %rdi
callq 0x26b0
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::saveFileText(char const*)
void Cryptogram::saveFileText(const char *filename)
{
    FILE *f;
    
    f = fopen(filename, "wb");
    if (!f)
        return;
    fwrite(plaintext.c_str(), 1, plaintext.length(), f);
    fwrite("\n\n", 1, 2, f);
    fwrite(cyphertext.c_str(), 1, cyphertext.length(), f);
    fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3799(%rip), %rsi      # 0x61ac
callq 0x2300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2a28
jmp 0x2aa9
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0x2100
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x20, %rdi
callq 0x23e0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x2460
movq -0x18(%rbp), %rcx
leaq 0x3749(%rip), %rdi      # 0x61af
movl $0x1, %esi
movl $0x2, %edx
callq 0x2460
movq -0x20(%rbp), %rdi
callq 0x2100
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x23e0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x2460
movq -0x18(%rbp), %rdi
callq 0x2220
addq $0x30, %rsp
popq %rbp
retq
nop
// File: BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::saveFileBinary(char const*)
void Cryptogram::saveFileBinary(const char *filename)
{
    FILE *f;
    
    f = fopen(filename, "wb");
    if (!f)
        return;
    // Write the header
    fwrite(FILE_HEADER, 1, strlen(FILE_HEADER) + 1, f);
    // Write the alphabet
    fwrite(alphabet, 1, sizeof(alphabet), f);
    // Write the cyphertext
    fwrite(cyphertext.c_str(), 1, cyphertext.length(), f);
    fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x36d9(%rip), %rsi      # 0x61ac
callq 0x2300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2ae5
jmp 0x2b4e
movq -0x18(%rbp), %rcx
leaq 0x36b4(%rip), %rdi      # 0x61a4
movl $0x1, %esi
movl $0x8, %edx
callq 0x2460
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x1a, %edx
callq 0x2460
movq -0x20(%rbp), %rdi
callq 0x2100
movq -0x20(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0x23e0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x2460
movq -0x18(%rbp), %rdi
callq 0x2220
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::saveKeys(char const*)
void Cryptogram::saveKeys(const char *filename)
{
    FILE *f;
    f = fopen(filename, "wb");
    if (!f)
        return;
    fwrite(alphabet, 1, sizeof(alphabet), f);
    fclose(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3629(%rip), %rsi      # 0x61ac
callq 0x2300
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2b95
jmp 0x2bb9
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x1a, %edx
callq 0x2460
movq -0x18(%rbp), %rdi
callq 0x2220
addq $0x20, %rsp
popq %rbp
retq
nop