LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/src/./../third-party/json/single_include/nlohmann/json.hpp
// Function: 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>::operator[](unsigned long) const
const_reference operator[](size_type idx) const
    {
        // const operator[] only works for arrays
        if (JSON_HEDLEY_LIKELY(is_array()))
        {
            return m_value.array->operator[](idx);
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x1e0fe
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x17460
movq %rax, %rbx
movq %r14, %rdi
callq 0x17900
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x166b3(%rip), %rsi     # 0x347d4
leaq -0x40(%rbp), %rdi
callq 0x183e0
movb $0x1, %r15b
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
movq %r14, %rcx
callq 0x18350
xorl %r15d, %r15d
movq 0x1ed85(%rip), %rsi     # 0x3ced0
movq 0x1ed86(%rip), %rdx     # 0x3ced8
movq %rbx, %rdi
callq 0x18420
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e16f
callq 0x17ae0
testb %r15b, %r15b
jne 0x1e179
jmp 0x1e181
movq %rax, %r14
movq %rbx, %rdi
callq 0x17780
movq %r14, %rdi
callq 0x18490
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x3522(%rip), %rsi      # 0x3050c
leaq 0x351d(%rip), %rdx      # 0x3050e
callq 0x173a0
movl %ebx, %eax
shrl $0x4, %eax
leaq 0x6a7b(%rip), %rcx      # 0x33a7d
movb (%rax,%rcx), %al
movq (%r14), %rdx
movb %al, (%rdx)
andl $0xf, %ebx
movb (%rbx,%rcx), %al
movq (%r14), %rcx
movb %al, 0x1(%rcx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/src/./../third-party/json/single_include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_2::detail::from_json<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>, int, 0>(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> const&, int&)
inline void from_json(const BasicJsonType& j, ArithmeticType& val)
{
    switch (static_cast<value_t>(j))
    {
        case value_t::number_unsigned:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
            break;
        }
        case value_t::number_integer:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
            break;
        }
        case value_t::number_float:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
            break;
        }
        case value_t::boolean:
        {
            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
            break;
        }

        case value_t::null:
        case value_t::object:
        case value_t::array:
        case value_t::string:
        case value_t::binary:
        case value_t::discarded:
        default:
            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movzbl (%rdi), %eax
addl $-0x4, %eax
cmpl $0x3, %eax
ja 0x2e0af
leaq 0x1b26(%rip), %rcx      # 0x2fbac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r14), %eax
jmp 0x2e0a2
movzbl 0x8(%r14), %eax
jmp 0x2e0a2
cvttsd2si 0x8(%r14), %eax
movl %eax, (%rsi)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x17460
movq %rax, %rbx
movq %r14, %rdi
callq 0x17900
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x64f0(%rip), %rsi      # 0x345c2
leaq -0x40(%rbp), %rdi
callq 0x171f0
movb $0x1, %r15b
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi            # imm = 0x12E
movq %r14, %rcx
callq 0x18350
xorl %r15d, %r15d
movq 0xedd4(%rip), %rsi      # 0x3ced0
movq 0xedd5(%rip), %rdx      # 0x3ced8
movq %rbx, %rdi
callq 0x18420
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e120
callq 0x17ae0
testb %r15b, %r15b
jne 0x2e12a
jmp 0x2e132
movq %rax, %r14
movq %rbx, %rdi
callq 0x17780
movq %r14, %rdi
callq 0x18490
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x49de
movq (%rdi), %rdx
xorl %esi, %esi
xorl %edi, %edi
movzbl (%rdx,%rsi), %eax
cmpl $0x54, %eax
je 0x49b4
cmpl $0x47, %eax
je 0x49ad
cmpl $0x41, %eax
jne 0x49bb
movl $0x1, %eax
jmp 0x49bd
movl $0x3, %eax
jmp 0x49bd
movl $0x2, %eax
jmp 0x49bd
xorl %eax, %eax
orq %rdi, %rax
leaq (,%rax,4), %rdi
incq %rsi
cmpq %rsi, %rcx
jne 0x4993
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
andq %rcx, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x1d, %r13d
movl $0x36, %r15d
movq %r14, %rax
movl %r15d, %ecx
shrq %cl, %rax
shll $0x3, %eax
movl $0x47544143, %edx       # imm = 0x47544143
movl %eax, %ecx
shrl %cl, %edx
movzbl %dl, %esi
movq %rbx, %rdi
callq 0x42b0
decq %r13
addq $-0x2, %r15
cmpq $0x1, %r13
ja 0x4a0f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x4a59
callq 0x4310
movq %r14, %rdi
callq 0x4600
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x1c, %r13d
movl $0x34, %r15d
movq %r14, %rax
movl %r15d, %ecx
shrq %cl, %rax
shll $0x3, %eax
movl $0x47544143, %edx       # imm = 0x47544143
movl %eax, %ecx
shrl %cl, %edx
movzbl %dl, %esi
movq %rbx, %rdi
callq 0x42b0
decq %r13
addq $-0x2, %r15
cmpq $0x1, %r13
ja 0x4a8f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x4ad9
callq 0x4310
movq %r14, %rdi
callq 0x4600
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl $0x1c, %ecx
xorl %eax, %eax
movl %edi, %edx
andl $0x3, %edx
addq %rax, %rdx
shrq $0x2, %rdi
shlq $0x2, %rdx
movq %rdx, %rax
xorq $0xc, %rax
decl %ecx
jne 0x4ae9
shrq $0x2, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl $0x1b, %ecx
xorl %eax, %eax
movl %edi, %edx
andl $0x3, %edx
addq %rax, %rdx
shrq $0x2, %rdi
shlq $0x2, %rdx
movq %rdx, %rax
xorq $0xc, %rax
decl %ecx
jne 0x4b11
shrq $0x2, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
addq $0x8, %rbx
xorl %r14d, %r14d
cmpq %rbx, %rax
je 0x4b87
xorl %ecx, %ecx
movq 0x20(%rax), %r15
xorl %edx, %edx
cmpq %rcx, %r15
setne %dl
addq %rdx, %r14
movq %rax, %rdi
callq 0x43e0
movq %r15, %rcx
cmpq %rbx, %rax
jne 0x4b68
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rsi), %rcx
leaq -0x2(%rdx), %r8
cmpq %r8, %rcx
jge 0x4d08
incq %rcx
movl $0x2, %r9d
subq %rdx, %r9
movb $0x1, %al
movzbl -0x1(%rdi,%rcx), %edx
cmpl $0xd, %edx
je 0x4ce2
cmpl $0xa, %edx
jne 0x4cf0
movzbl (%rdi,%rcx), %edx
cmpl $0xd, %edx
je 0x4cf0
cmpl $0xa, %edx
jne 0x4d0c
cmpq %r8, %rcx
setl %al
leaq (%r9,%rcx), %rdx
incq %rdx
incq %rcx
cmpq $0x1, %rdx
jne 0x4cd3
jmp 0x4d0f
xorl %eax, %eax
jmp 0x4d0f
movq %rcx, (%rsi)
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rdi, %xmm0
pshufd $0x44, %xmm0, %xmm1     # xmm1 = xmm0[0,1,0,1]
movdqa %xmm1, %xmm0
psllq $0x2, %xmm0
movq %rsi, %xmm2
pshufd $0x44, %xmm2, %xmm2     # xmm2 = xmm2[0,1,0,1]
movdqa 0xa176(%rip), %xmm3     # 0xf010
por %xmm1, %xmm3
por 0xa17a(%rip), %xmm1     # 0xf020
movdqa 0xa182(%rip), %xmm4     # 0xf030
por %xmm0, %xmm4
por 0xa186(%rip), %xmm0     # 0xf040
pcmpeqd %xmm2, %xmm1
pcmpeqd %xmm2, %xmm3
movdqa %xmm3, %xmm5
shufps $0xdd, %xmm1, %xmm5     # xmm5 = xmm5[1,3],xmm1[1,3]
shufps $0x88, %xmm1, %xmm3     # xmm3 = xmm3[0,2],xmm1[0,2]
andps %xmm5, %xmm3
movmskps %xmm3, %eax
testl %eax, %eax
setne %cl
pcmpeqd %xmm2, %xmm0
pcmpeqd %xmm2, %xmm4
movdqa %xmm4, %xmm1
shufps $0xdd, %xmm0, %xmm1     # xmm1 = xmm1[1,3],xmm0[1,3]
shufps $0x88, %xmm0, %xmm4     # xmm4 = xmm4[0,2],xmm0[0,2]
andps %xmm1, %xmm4
movmskps %xmm4, %eax
testl %eax, %eax
setne %al
andb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq (,%rdi,4), %r15
xorl %r12d, %r12d
leaq 0xa134(%rip), %r13      # 0xf050
movl (%r12,%r13), %edi
shlq $0x36, %rdi
orq %rbx, %rdi
callq 0x4d12
cmpq %r14, %rax
je 0x4f42
addq $0x4, %r12
cmpq $0x10, %r12
jne 0x4f1c
xorl %eax, %eax
jmp 0x4fc8
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movq %r14, %xmm1
movq %rbx, %xmm2
pshufd $0x44, %xmm2, %xmm2     # xmm2 = xmm2[0,1,0,1]
movdqa 0xa0ad(%rip), %xmm3     # 0xf010
por %xmm2, %xmm3
por 0xa0b1(%rip), %xmm2     # 0xf020
movdqa 0xa0b9(%rip), %xmm4     # 0xf030
por %xmm0, %xmm4
por 0xa0bd(%rip), %xmm0     # 0xf040
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
pcmpeqd %xmm1, %xmm2
pcmpeqd %xmm1, %xmm3
movdqa %xmm3, %xmm5
shufps $0xdd, %xmm2, %xmm5     # xmm5 = xmm5[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm3     # xmm3 = xmm3[0,2],xmm2[0,2]
andps %xmm5, %xmm3
movmskps %xmm3, %eax
testl %eax, %eax
sete %cl
pcmpeqd %xmm1, %xmm0
pcmpeqd %xmm1, %xmm4
movdqa %xmm4, %xmm1
shufps $0xdd, %xmm0, %xmm1     # xmm1 = xmm1[1,3],xmm0[1,3]
shufps $0x88, %xmm0, %xmm4     # xmm4 = xmm4[0,2],xmm0[0,2]
andps %xmm1, %xmm4
movmskps %xmm4, %eax
testl %eax, %eax
sete %al
orb %cl, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq (,%rdi,4), %r15
xorl %r12d, %r12d
leaq 0xa05d(%rip), %r13      # 0xf050
movl (%r12,%r13), %edi
orq %r15, %rdi
callq 0x4d12
cmpq %r14, %rax
je 0x5015
addq $0x4, %r12
cmpq $0x10, %r12
jne 0x4ff3
xorl %eax, %eax
jmp 0x509b
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movq %r14, %xmm1
movq %rbx, %xmm2
pshufd $0x44, %xmm2, %xmm2     # xmm2 = xmm2[0,1,0,1]
movdqa 0x9fda(%rip), %xmm3     # 0xf010
por %xmm2, %xmm3
por 0x9fde(%rip), %xmm2     # 0xf020
movdqa 0x9fe6(%rip), %xmm4     # 0xf030
por %xmm0, %xmm4
por 0x9fea(%rip), %xmm0     # 0xf040
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
pcmpeqd %xmm1, %xmm2
pcmpeqd %xmm1, %xmm3
movdqa %xmm3, %xmm5
shufps $0xdd, %xmm2, %xmm5     # xmm5 = xmm5[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm3     # xmm3 = xmm3[0,2],xmm2[0,2]
andps %xmm5, %xmm3
movmskps %xmm3, %eax
testl %eax, %eax
sete %cl
pcmpeqd %xmm1, %xmm0
pcmpeqd %xmm1, %xmm4
movdqa %xmm4, %xmm1
shufps $0xdd, %xmm0, %xmm1     # xmm1 = xmm1[1,3],xmm0[1,3]
shufps $0x88, %xmm0, %xmm4     # xmm4 = xmm4[0,2],xmm0[0,2]
andps %xmm1, %xmm4
movmskps %xmm4, %eax
testl %eax, %eax
sete %al
orb %cl, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movabsq $0x3fffffffffffff, %rsi # imm = 0x3FFFFFFFFFFFFF
callq 0xa012
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0x4efb
testb %al, %al
jne 0x50ea
movq %r12, %rdi
movq %r15, %rsi
callq 0x4fd2
testb %al, %al
je 0x5113
addq $0x8, %r14
movq (%r14), %rdi
movl $0x1, %ecx
movq %rbx, %rsi
xorl %edx, %edx
movl $0x1, %r8d
movl $0x1, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa819
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0xcde6
testb %al, %al
je 0x5823
xorl %ebp, %ebp
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
movq %rsp, %r13
movq %rbp, 0x8(%rsp)
movq %rbp, 0x10(%rsp)
movq %rbp, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0xd057
movq 0x18(%rbx), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rcx
xorl %edx, %edx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0xa819
movq %r14, %rdi
callq 0xd0e9
testl %eax, %eax
je 0x57cf
movq 0x10(%rbx), %rdi
callq 0xa6ac
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdx, %rbx
cmpl $0x2, %edi
je 0x5891
cmpl $0x1, %edi
je 0x5867
testl %edi, %edi
jne 0x58db
leaq 0x982e(%rip), %rax      # 0xf07d
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4400
movq %rax, (%rbx)
testq %rax, %rax
jne 0x58db
jmp 0x58e7
leaq 0x980f(%rip), %rax      # 0xf07d
movq %rsi, %rdi
movq %rax, %rsi
callq 0x44e0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x58e7
movq %rax, %rdi
movl $0x4000000, %esi        # imm = 0x4000000
callq 0x4250
jmp 0x58db
leaq 0x97e5(%rip), %rax      # 0xf07d
movq %rsi, %rdi
movq %rax, %rsi
callq 0x4400
movq %rax, (%rbx)
testq %rax, %rax
je 0x58e7
movl $0x4000000, %ecx        # imm = 0x4000000
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4050
leaq 0x18(%rbx), %rdi
movq (%rbx), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x4570
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x58df
movb $0x1, %al
jmp 0x58e9
movq (%rbx), %rdi
callq 0x4340
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
cmpl $0x1, %edi
jg 0x248c
movq 0x6b7b(%rip), %r14      # 0x8fc8
leaq 0x2bb0(%rip), %rsi      # 0x5004
movl $0x7, %edx
movq %r14, %rdi
callq 0x2190
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x258f
movq %rbx, %rdi
callq 0x20a0
movq 0x6b4c(%rip), %rdi      # 0x8fc8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2190
jmp 0x25a7
leaq -0x24(%rbp), %r14
movl $0x0, (%r14)
leaq -0x8c(%rbp), %r15
movq %r15, 0xc(%r15)
movq 0x8(%rbx), %rbx
movq %rbx, 0x4(%r15)
movq %rbx, %rdi
callq 0x20a0
addq %rbx, %rax
movq %rax, 0xc(%r15)
leaq -0x38(%rbp), %rdi
movq %rbx, (%rdi)
movq %rax, 0x8(%rdi)
movq %r14, %rsi
callq 0x2962
testb %al, %al
je 0x25d4
movl (%r14), %ebx
movq 0x6b02(%rip), %rax      # 0x8fe0
leaq -0x38(%rbp), %r15
movq %rax, (%r15)
movb $0x1, 0xc(%r15)
movq %r15, %rdi
callq 0x3134
leaq -0x90(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x316e
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r12)
movups %xmm0, 0x38(%r12)
movq (%r15), %rax
leaq -0xb0(%rbp), %rdx
movq %rax, (%rdx)
movl 0x8(%r15), %eax
movl %eax, 0x8(%rdx)
movb 0xc(%r15), %al
movb %al, 0xc(%rdx)
leaq -0xa0(%rbp), %rcx
movq $0x0, (%rcx)
movl $0x0, 0x8(%rcx)
movb $0x0, 0xc(%rcx)
movq %r12, %rdi
movl %ebx, %esi
callq 0x262a
leaq -0x24(%rbp), %rdx
movl $0x0, (%rdx)
movq 0x6a66(%rip), %rsi      # 0x8fc8
leaq -0x90(%rbp), %rdi
callq 0x35e9
leaq -0x90(%rbp), %rbx
movq 0x30(%rbx), %rdi
movl $0x1, %esi
callq 0x2170
movq %rbx, %rdi
callq 0x2884
xorl %eax, %eax
jmp 0x25c4
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2230
movq 0x6a1a(%rip), %rdi      # 0x8fc8
leaq 0x2a57(%rip), %rsi      # 0x500c
movl $0x16, %edx
callq 0x2190
movl $0x1, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x671d(%rip), %rax      # 0x8cf8
leaq -0x90(%rbp), %rdi
movq %rax, (%rdi)
movq 0x69cc(%rip), %rax      # 0x8fb8
movq %rax, 0x8(%rdi)
movq 0x69d9(%rip), %rax      # 0x8fd0
movq %rax, 0x10(%rdi)
callq 0x2c4f
jmp 0x2602
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x285e
jmp 0x2622
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq 0x18(%r14), %r15
addq $0x18, %r14
cmpq %r14, %r15
je 0x3a85
movq %rdi, %rbx
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x3b9a
testb %al, %al
jne 0x3a81
movq (%r15), %r15
cmpq %r14, %r15
jne 0x3a69
xorb $0x1, %al
jmp 0x3a87
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x3e5d
movq %rdi, %rbx
addq $-0x8, %r12
cmpq %r12, %r15
je 0x3e3b
leaq 0x11f6(%rip), %r14      # 0x500a
movq (%rbx), %rdi
movq (%r15), %rax
movl 0x30(%rax), %esi
callq 0x2110
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2190
addq $0x8, %r15
cmpq %r12, %r15
jne 0x3e14
movq (%rbx), %rdi
movq (%r15), %rax
movl 0x30(%rax), %esi
callq 0x2110
leaq -0x21(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x30(%rsi), %ecx
cmpq %rcx, 0x28(%rdi)
jbe 0x3ef1
movq %rdi, %rbx
movl %ecx, %eax
shrl $0x3, %eax
movq 0x38(%rdi), %rdx
andb $0x7, %cl
movl $0x1, %edi
shll %cl, %edi
notb %dil
andb %dil, (%rdx,%rax)
movq 0x20(%rbx), %rax
movl 0x30(%rsi), %edx
movq (%rax), %rcx
leaq (%rdx,%rdx,2), %rdx
movq 0x8(%rcx,%rdx,8), %rax
cmpq %rax, (%rcx,%rdx,8)
je 0x3ee6
leaq (%rcx,%rdx,8), %r15
movq -0x8(%rax), %r14
addq $-0x8, %rax
movq %rax, 0x8(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b9a
testb %al, %al
je 0x3edd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e6a
movq 0x8(%r15), %rax
cmpq %rax, (%r15)
jne 0x3eb7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18a7(%rip), %rdi      # 0x579f
leaq 0x18b6(%rip), %rsi      # 0x57b5
leaq 0x1ecd(%rip), %rcx      # 0x5dd3
movl $0x54, %edx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::reset()
void Cryptogram::reset()
{
    cyphertext = SAMPLE_TEXT;
    plaintext = "";
    memset(alphabet, ' ', sizeof(alphabet));
    calcPlaintext();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
leaq 0x2b6f(%rip), %rcx      # 0x5060
movl $0x19c, %r8d            # imm = 0x19C
xorl %esi, %esi
callq 0x22b0
leaq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rdx
leaq 0x2d00(%rip), %rcx      # 0x520d
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x22b0
movaps 0x2af2(%rip), %xmm0     # 0x5010
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x4a(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x2566
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
movq 0x28(%rdi), %rax
cmpq %rdx, %rax
je 0x25ca
leaq 0x20(%rbx), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2d0a(%rip), %rsi      # 0x52a0
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x362a
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x25c6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x261d
movq (%rbx), %rax
movq 0x20(%rbx), %rcx
movzbl (%rax), %edx
leal -0x61(%rdx), %esi
leal -0x20(%rdx), %edi
cmpb $0x1a, %sil
movzbl %dil, %esi
cmovael %edx, %esi
leal -0x41(%rsi), %edi
cmpb $0x19, %dil
ja 0x2609
movzbl %sil, %edx
movzbl -0x1(%rbx,%rdx), %esi
movl $0x5f, %edx
cmpb $0x20, %sil
je 0x2609
movl %esi, %edx
movb %dl, (%rcx)
incq %rcx
incq %rax
movq (%rbx), %rdx
addq 0x8(%rbx), %rdx
cmpq %rdx, %rax
jne 0x25d6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
leaq 0x2a19(%rip), %rcx      # 0x5060
movl $0x19c, %r8d            # imm = 0x19C
xorl %esi, %esi
callq 0x22b0
leaq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rdx
leaq 0x2baa(%rip), %rcx      # 0x520d
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x22b0
movaps 0x299c(%rip), %xmm0     # 0x5010
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x4a(%rbx)
leaq 0x2b7a(%rip), %rsi      # 0x51fd
movq %r14, %rdi
callq 0x2200
testq %rax, %rax
je 0x272c
movq %rax, %r15
movq %rsp, %r14
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %rax, %rcx
callq 0x22a0
xorl %ecx, %ecx
movb %cl, 0xfff(%r14)
cltq
movb %cl, (%rsp,%rax)
movq %r15, %rdi
callq 0x2170
movabsq $0x31454c49464743, %rax # imm = 0x31454C49464743
cmpq %rax, (%r14)
jne 0x26ee
leaq 0x40(%rbx), %rax
leaq 0x22(%rsp), %r14
movups -0x1a(%r14), %xmm0
movups -0x10(%r14), %xmm1
movups %xmm1, 0xa(%rax)
movups %xmm0, (%rax)
movq %r14, %rdi
callq 0x2300
movq %rax, %r14
movq 0x8(%rbx), %r15
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x22b0
movq %rbx, %rdi
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
jmp 0x2566
movq %rbx, %rdi
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
jmp 0x24e2
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %r14
leaq 0x2ab7(%rip), %rsi      # 0x5208
movq %rax, %rdi
callq 0x2200
testq %rax, %rax
je 0x27b2
movq %rax, %rbx
movq 0x20(%r14), %rdi
movq 0x28(%r14), %rdx
movl $0x1, %esi
movq %rax, %rcx
callq 0x2320
leaq 0x2a8e(%rip), %rdi      # 0x520b
movl $0x1, %esi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x2320
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x2320
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2170
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %r14
leaq 0x2a3d(%rip), %rsi      # 0x5208
movq %rax, %rdi
callq 0x2200
testq %rax, %rax
je 0x282d
movq %rax, %rbx
leaq 0x2a1e(%rip), %rdi      # 0x5200
movl $0x1, %esi
movl $0x8, %edx
movq %rax, %rcx
callq 0x2320
leaq 0x40(%r14), %rdi
movl $0x1, %esi
movl $0x1a, %edx
movq %rbx, %rcx
callq 0x2320
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x2320
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2170
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x29c1(%rip), %rsi      # 0x5208
movq %rax, %rdi
callq 0x2200
testq %rax, %rax
je 0x287f
movq %rax, %r14
addq $0x40, %rbx
movl $0x1, %esi
movl $0x1a, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x2320
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2170
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::loadKeys(char const*)
void Cryptogram::loadKeys(const char *filename)
{
    FILE *f;
    unsigned int i;
    f = fopen(filename, "rb");
    if (!f)
        return;
    for (i=0; i<sizeof(alphabet); i++)
        alphabet[i] = ' ';
    fread(alphabet, 1, sizeof(alphabet), f);
    fclose(f);
    for (i=0; i<sizeof(alphabet); i++)
        if ((alphabet[i] < 'A') || (alphabet[i] > 'Z'))
            alphabet[i] = ' ';
    calcPlaintext();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x2964(%rip), %rsi      # 0x51fd
movq %rax, %rdi
callq 0x2200
testq %rax, %rax
je 0x2902
movq %rax, %r14
leaq 0x40(%rbx), %rdi
movaps 0x275c(%rip), %xmm0     # 0x5010
movups %xmm0, 0x4a(%rbx)
movups %xmm0, 0x40(%rbx)
movl $0x1, %esi
movl $0x1a, %edx
movq %rax, %rcx
callq 0x22a0
movq %r14, %rdi
callq 0x2170
movl $0x40, %eax
movb (%rbx,%rax), %cl
addb $-0x5b, %cl
cmpb $-0x1b, %cl
ja 0x28ea
movb $0x20, (%rbx,%rax)
incq %rax
cmpq $0x5a, %rax
jne 0x28db
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2566
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::randomizeKeys()
void Cryptogram::randomizeKeys()
{
    // Probably a better way of doing this....
    int r1, r2;
    char temp;
    for (int i=0; i<26; i++)
        alphabet[i] = i + 'A';
    srand(time(NULL));
    for (int i=0; i<1000; i++)
    {
        r1 = rand() % 26;
        r2 = rand() % 26;
        temp = alphabet[r1];
        alphabet[r1] = alphabet[r2];
        alphabet[r2] = temp;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movdqa 0x2699(%rip), %xmm0     # 0x5020
movl $0x41, %eax
movb $0x42, %cl
movdqa 0x269a(%rip), %xmm1     # 0x5030
movdqa 0x26a2(%rip), %xmm2     # 0x5040
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0x26a5(%rip), %xmm4     # 0x5050
movdqa %xmm0, %xmm5
pxor %xmm1, %xmm5
movdqa %xmm2, %xmm6
pcmpgtd %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pcmpeqd %xmm3, %xmm5
pand %xmm6, %xmm5
movd %xmm5, %edx
testb $0x1, %dl
je 0x29d5
movb %al, -0x1(%rbx,%rax)
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x29e2
movb %cl, (%rbx,%rax)
paddq %xmm4, %xmm0
addq $0x2, %rax
addb $0x2, %cl
cmpq $0x5b, %rax
jne 0x29ab
xorl %edi, %edi
callq 0x2150
movl %eax, %edi
callq 0x2160
movl $0x3e8, %ebp            # imm = 0x3E8
callq 0x2080
movslq %eax, %r14
imulq $0x4ec4ec4f, %r14, %rax # imm = 0x4EC4EC4F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x23, %rax
addl %ecx, %eax
leal (%rax,%rax,4), %ecx
leal (%rcx,%rcx,4), %ecx
addl %eax, %ecx
subl %ecx, %r14d
callq 0x2080
cltq
imulq $0x4ec4ec4f, %rax, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x23, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %edx
leal (%rdx,%rdx,4), %edx
addl %ecx, %edx
subl %edx, %eax
movslq %r14d, %rcx
movb 0x40(%rbx,%rcx), %dl
cltq
movb 0x40(%rbx,%rax), %sil
movb %sil, 0x40(%rbx,%rcx)
movb %dl, 0x40(%rbx,%rax)
decl %ebp
jne 0x2a06
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::randomizeMessage()
void Cryptogram::randomizeMessage()
{
    string tempStr;
    bool matchKey;
    do{
        matchKey = false;
        randomizeKeys();
        for (int i=0; i<26; i++)
        {
            if (alphabet[i]==i+'A')
                matchKey = true;
        }
    }while(matchKey);
    calcPlaintext();
    cyphertext = plaintext;
    plaintext = string(" ", cyphertext.length());
    calcPlaintext();
    for (int i=0; i<26; i++)
        alphabet[i] = ' ';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x40(%rdi), %r13
movq %rbx, %rdi
callq 0x2978
movl $0x41, %ecx
xorl %eax, %eax
movsbq -0x1(%rbx,%rcx), %rdx
movl %edx, %edx
cmpq %rdx, %rcx
sete %dl
orb %dl, %al
incq %rcx
cmpq $0x5b, %rcx
jne 0x2aae
testb $0x1, %al
jne 0x2a9f
movq %rbx, %rdi
callq 0x2566
leaq 0x20(%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2100
leaq 0x38(%rsp), %rbp
leaq 0x27b2(%rip), %rsi      # 0x52a0
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rbp, -0x10(%rbp)
leaq 0x28(%rsp), %rdi
callq 0x362a
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x2b28
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x2566
movaps 0x24d9(%rip), %xmm0     # 0x5010
movups %xmm0, 0xa(%r13)
movups %xmm0, (%r13)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b58
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b69
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b83
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::newRandomMessage()
void Cryptogram::newRandomMessage()
{
    int lines;
    do{
        system("fortune > tmp.tmp");
        loadFile("tmp.tmp");
        lines = 0;
        for (string::iterator c = cyphertext.begin(); 
             c != cyphertext.end(); 
             c++)
        {
            if (*c == '\n')
                lines++;
        }
    }while((lines < 3) || (lines > 8));
    randomizeMessage();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2673(%rip), %r14      # 0x520e
leaq 0x2676(%rip), %r15      # 0x5218
movq %r14, %rdi
callq 0x2140
movq %rbx, %rdi
movq %r15, %rsi
callq 0x262a
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2ba2
movq (%rbx), %rcx
xorl %esi, %esi
xorl %edx, %edx
xorl %edi, %edi
cmpb $0xa, (%rcx,%rsi)
sete %dil
addl %edi, %edx
incq %rsi
cmpq %rsi, %rax
jne 0x2bc5
addl $-0x9, %edx
cmpl $-0x6, %edx
jb 0x2ba2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2a72
// File: /workspace/github_cpp_makefile_star2_O3/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::letterDistribution(char*, int*)
void Cryptogram::letterDistribution(char letters[], int counts[])
{
    char letter;
    for (char c = 'A'; c <= 'Z'; c++)
    {
        letters[c-'A'] = c;
        counts[c-'A'] = 0;
    }
    for (string::iterator t = cyphertext.begin(); t != cyphertext.end(); t++)
    {
        letter = normalize(*t);
        if (isKey(letter))
            counts[letter-'A']++;
    }
    // BUBBLESORT!  YEAY!
    int tempInt;
    char tempChar;
    for (int i=0; i < 26; i++)
        for (int j = i; j < 26; j++)
            if (counts[j] > counts[i])
            {
                tempChar = letters[i];
                letters[i] = letters[j];
                letters[j] = tempChar;
                tempInt = counts[i];
                counts[i] = counts[j];
                counts[j] = tempInt;
            }
}

// Assembly:
xorl %eax, %eax
leal 0x41(%rax), %ecx
movb %cl, (%rsi,%rax)
movl $0x0, (%rdx,%rax,4)
incq %rax
cmpq $0x1a, %rax
jne 0x2bf0
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2c4b
movq (%rdi), %rcx
xorl %edi, %edi
movzbl (%rcx,%rdi), %r9d
leal -0x61(%r9), %r8d
leal -0x20(%r9), %r10d
cmpb $0x1a, %r8b
movzbl %r10b, %r8d
cmovael %r9d, %r8d
leal -0x41(%r8), %r9d
cmpb $0x19, %r9b
ja 0x2c43
movzbl %r8b, %r8d
incl -0x104(%rdx,%r8,4)
incq %rdi
cmpq %rdi, %rax
jne 0x2c14
xorl %eax, %eax
movq %rax, %rcx
movl (%rdx,%rcx,4), %edi
cmpl (%rdx,%rax,4), %edi
jle 0x2c76
movb (%rsi,%rax), %dil
movb (%rsi,%rcx), %r8b
movb %r8b, (%rsi,%rax)
movb %dil, (%rsi,%rcx)
movl (%rdx,%rax,4), %edi
movl (%rdx,%rcx,4), %r8d
movl %r8d, (%rdx,%rax,4)
movl %edi, (%rdx,%rcx,4)
incq %rcx
cmpq $0x1a, %rcx
jne 0x2c50
incq %rax
cmpq $0x1a, %rax
jne 0x2c4d
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::paintAlphabet(_win_st*)
void Cryptogram::paintAlphabet(WINDOW *w)
{
    // Print the alphabet...
    char used[26];
    bool duplicates = false;
    char letter;
    
    for (int i=0; i<26; i++)
        used[i] = 0;

    wcolor_set(w, 2, NULL);
    wmove(w, 0, 0);
    wprintw(w, "Cyphertext: ");
    for (char c='A'; c <= 'Z'; c++)
        wprintw(w, "%c", c);
    wprintw(w, "\nPlaintext:  ");
    for (int i=0; i<26; i++)
    {
        letter = alphabet[i];
        wprintw(w, "%c", letter);
        if (isKey(letter))
        {
            if (used[letter-'A'] == 1)
                duplicates = true;
            else
                used[letter-'A'] = 1;
        }
    }
    if (duplicates)
        wprintw(w, " <-- Warning: duplicates");
    else
        wprintw(w, "                        ");
    mvwprintw(w, 2, 0, "%s %s by %s", PROGNAME, PROGVER, BYLINE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x1a(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rsi, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x2260
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21b0
leaq 0x1fed(%rip), %rsi      # 0x5252
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
movl $0x41, %ebp
leaq 0x1fe4(%rip), %r15      # 0x525f
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2030
incl %ebp
cmpl $0x5b, %ebp
jne 0x327b
leaq 0x1fca(%rip), %rsi      # 0x5262
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0x10(%rsp), %rbp
xorl %r15d, %r15d
movsbl 0x40(%r14,%r15), %r12d
movq %rbx, %rdi
leaq 0x1fa2(%rip), %rsi      # 0x525f
movl %r12d, %edx
xorl %eax, %eax
callq 0x2030
leal -0x41(%r12), %eax
cmpb $0x19, %al
ja 0x32e3
movslq %r12d, %rax
cmpb $0x1, -0x41(%rax,%rbp)
sete %cl
movb $0x1, -0x41(%rax,%rbp)
orb %cl, %r13b
incq %r15
cmpq $0x1a, %r15
jne 0x32ad
leaq 0x1f7d(%rip), %rax      # 0x5270
leaq 0x1f8f(%rip), %rsi      # 0x5289
testb $0x1, %r13b
cmovneq %rax, %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2030
leaq 0x1fab(%rip), %rax      # 0x52be
movq %rax, (%rsp)
leaq 0x1f84(%rip), %rcx      # 0x52a2
leaq 0x1f89(%rip), %r8       # 0x52ae
leaq 0x1f8d(%rip), %r9       # 0x52b9
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2070
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq