LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::getTemplateNameFromContext(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string Mustache::getTemplateNameFromContext(const string& key)
{
    json variable;
    try {
        variable = searchVariableInContext(key);
    } catch(const std::out_of_range& ex) {
        variable = nullptr;
    } catch(const std::invalid_argument& ex) {
        variable = nullptr;
    }

    if (variable.is_null()) {
        error("Missing template variable: " + key);
    } else if (!variable.is_string()) {
        error("Wrong template variable type: " + key + " must be a string");
    }

    return variable.get<string>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movb $0x0, (%r12)
movq $0x0, 0x8(%r12)
movq %r12, %rdi
movl $0x1, %esi
callq 0x17530
movq %r12, %rdi
movl $0x1, %esi
callq 0x17530
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x17c30
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %r15
movq %r15, %rsi
callq 0x17550
movq %r15, %rdi
callq 0x17d70
movzbl -0x30(%rbp), %eax
cmpl $0x3, %eax
jne 0x1c4d5
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x18430
leaq -0x30(%rbp), %rdi
callq 0x17d70
movq %r14, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
jne 0x1c4f5
leaq 0x14939(%rip), %rsi     # 0x30e19
leaq -0x50(%rbp), %rdi
movq %rbx, %rdx
callq 0x17a70
leaq -0x50(%rbp), %rsi
callq 0x17e70
leaq 0x14939(%rip), %rsi     # 0x30e35
leaq -0x80(%rbp), %rdi
movq %rbx, %rdx
callq 0x17a70
leaq 0x14945(%rip), %rsi     # 0x30e54
leaq -0x80(%rbp), %rdi
callq 0x18680
leaq -0x40(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1c537
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
jmp 0x1c542
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x17e70
movq %rax, %r15
movq -0x50(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1c578
callq 0x17b00
jmp 0x1c578
movq %rax, %r15
leaq -0x70(%rbp), %rax
jmp 0x1c585
movq %rax, %r15
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c59c
callq 0x17b00
jmp 0x1c59c
jmp 0x1c599
jmp 0x1c599
movq %rax, %r15
leaq -0x30(%rbp), %rdi
callq 0x17d70
movq %r15, %rdi
callq 0x184b0
movq %rax, %r15
cmpl $0x2, %edx
jne 0x1c5ec
movq %r15, %rdi
callq 0x173f0
leaq -0x90(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x17e20
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x17550
movq %r15, %rdi
callq 0x17d70
callq 0x18320
jmp 0x1c4a4
cmpl $0x1, %edx
jne 0x1c59c
movq %r15, %rdi
callq 0x173f0
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x17e20
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x17550
movq %r15, %rdi
callq 0x17d70
callq 0x18320
jmp 0x1c4a4
jmp 0x1c599
jmp 0x1c599
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/src/mustache-light.cpp
// Function: mustache::Mustache::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
vector<string>& Mustache::split(const string &str, char delim, vector<string> &elems) {
        std::stringstream ss(str);
        std::string item;
        while (std::getline(ss, item, delim)) {
                elems.push_back(item);
        }
        return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rcx, %rbx
movl %edx, %r15d
leaq -0x1d0(%rbp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x18290
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movsbl %r15b, %r15d
leaq -0x48(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x185d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1cefa
movq %rbx, %rdi
movq %r12, %rsi
callq 0x174f0
jmp 0x1ced1
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1cf08
callq 0x17b00
movq 0x20f81(%rip), %rsi     # 0x3de90
leaq -0x1d0(%rbp), %rdi
callq 0x177c0
leaq -0x150(%rbp), %rdi
callq 0x172f0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1cf4d
callq 0x17b00
movq 0x20f3c(%rip), %rsi     # 0x3de90
leaq -0x1d0(%rbp), %rdi
callq 0x177c0
leaq -0x150(%rbp), %rdi
callq 0x172f0
movq %rbx, %rdi
callq 0x184b0
// File: /workspace/github_cpp_makefile_star2_O1/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>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
iterator find(const typename object_t::key_type& key)
    {
        auto result = end();

        if (is_object())
        {
            result.m_it.object_iterator = m_value.object->find(key);
        }

        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x17510
cmpb $0x1, (%r15)
jne 0x1db24
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x18540
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e084
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 0x17920
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x17739(%rip), %rsi     # 0x357e0
leaq -0x40(%rbp), %rdi
callq 0x18400
movb $0x1, %r15b
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
movq %r14, %rcx
callq 0x18370
xorl %r15d, %r15d
movq 0x1fdff(%rip), %rsi     # 0x3ded0
movq 0x1fe00(%rip), %rdx     # 0x3ded8
movq %rbx, %rdi
callq 0x18440
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e0fd
callq 0x17b00
jmp 0x1e0fd
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x1e10a
movq %rbx, %rdi
callq 0x17790
movq %r14, %rdi
callq 0x184b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4026(%rip), %rsi      # 0x31518
leaq 0x4021(%rip), %rdx      # 0x3151a
callq 0x173a0
movl %ebx, %eax
shrl $0x4, %eax
leaq 0x757f(%rip), %rcx      # 0x34a89
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_O1/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 0x2e5db
leaq 0x2606(%rip), %rcx      # 0x30bb8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x8(%r14), %eax
jmp 0x2e5ce
movzbl 0x8(%r14), %eax
jmp 0x2e5ce
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 0x17920
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x6fd0(%rip), %rsi      # 0x355ce
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 0x18370
xorl %r15d, %r15d
movq 0xf8a8(%rip), %rsi      # 0x3ded0
movq 0xf8a9(%rip), %rdx      # 0x3ded8
movq %rbx, %rdi
callq 0x18440
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e654
callq 0x17b00
jmp 0x2e654
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0x2e661
movq %rbx, %rdi
callq 0x17790
movq %r14, %rdi
callq 0x184b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/joncampbell123[P]floppytools/kryoflux1.cpp
// Function: main
int main(int argc,char **argv) {
    if (argc < 2) {
        fprintf(stderr,"%s <raw>\n",argv[0]);
        return 1;
    }

    FILE *fp = fopen(argv[1],"rb");
    if (fp == NULL) return 1;

    struct kryoflux_event ev;
    struct kryoflux_stream_info si;

    while (kryoflux_read(ev,fp)) {
        fprintf(stderr,"flux=%lu(0x%lx) oob=%u ooblen=%zu offset=%lu\n",
                ev.flux_interval,ev.flux_interval,ev.oob_code,ev.msg.size(),ev.offset);

        if (ev.msg.size() != 0 && ev.oob_code == 4) {
            fprintf(stderr,"  oobmsg='");
            fwrite(&ev.msg[0],ev.msg.size(),1,stderr);
            fprintf(stderr,"'\n");

            kryoflux_update_stream_info(si,ev.msg);
            fprintf(stderr,"Updated stream info: name='%s' sck=%.19f ick=%.19f\n",
                si.name.c_str(),si.sck,si.ick);
        }
    }

    fclose(fp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
cmpl $0x1, %edi
jle 0x14a5
movq 0x8(%rsi), %rdi
leaq 0x1c9d(%rip), %rsi      # 0x300e
callq 0x1100
testq %rax, %rax
je 0x14ad
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1af0
leaq -0x50(%rbp), %r15
movq 0x3c3b(%rip), %r13      # 0x4fe0
leaq 0x1c65(%rip), %r12      # 0x3011
leaq 0x1c9a(%rip), %r14      # 0x304d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x14f4
testb %al, %al
je 0x1479
movq (%r13), %rdi
movl -0x50(%rbp), %ecx
movzbl -0x4b(%rbp), %r8d
movq -0x38(%rbp), %r9
subq -0x40(%rbp), %r9
movq -0x48(%rbp), %rax
movq %rax, (%rsp)
movq %r12, %rsi
movl %ecx, %edx
xorl %eax, %eax
callq 0x1130
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x13b3
cmpb $0x4, -0x4b(%rbp)
jne 0x13b3
movq (%r13), %rcx
movl $0xa, %esi
movl $0x1, %edx
leaq 0x1c2c(%rip), %rdi      # 0x303f
callq 0x1190
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
movq (%r13), %rcx
movl $0x1, %edx
callq 0x1190
movq (%r13), %rcx
movl $0x2, %esi
movl $0x1, %edx
leaq 0x1c04(%rip), %rdi      # 0x304a
callq 0x1190
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1c04
movq (%r13), %rdi
movq -0x80(%rbp), %rdx
movsd -0x60(%rbp), %xmm0
movsd -0x58(%rbp), %xmm1
movq %r14, %rsi
movb $0x2, %al
callq 0x1130
jmp 0x13b3
movq %rbx, %rdi
callq 0x10d0
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1493
callq 0x10c0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x14a1
callq 0x10c0
xorl %eax, %eax
jmp 0x14b2
movq %rsi, %rdi
callq 0x11b0
movl $0x1, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x14db
movq %rax, %rbx
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14db
callq 0x10c0
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x14e9
callq 0x10c0
movq %rbx, %rdi
callq 0x1160
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b2e
movq (%rdi), %rdx
xorl %esi, %esi
xorl %edi, %edi
movzbl (%rdx,%rsi), %eax
cmpl $0x54, %eax
je 0x5b04
cmpl $0x47, %eax
je 0x5afd
cmpl $0x41, %eax
jne 0x5b0b
movl $0x1, %eax
jmp 0x5b0d
movl $0x3, %eax
jmp 0x5b0d
movl $0x2, %eax
jmp 0x5b0d
xorl %eax, %eax
orq %rdi, %rax
leaq (,%rax,4), %rdi
incq %rsi
cmpq %rsi, %rcx
jne 0x5ae3
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
andq %rcx, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52d0
decq %r13
addq $-0x2, %r15
cmpq $0x1, %r13
ja 0x5b5f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x5ba9
callq 0x5330
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52d0
decq %r13
addq $-0x2, %r15
cmpq $0x1, %r13
ja 0x5bdf
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x5c29
callq 0x5330
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c39
shrq $0x2, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c61
shrq $0x2, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movl %r8d, 0x18(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5cdd
xorl %ecx, %ecx
movq 0x20(%rax), %r15
xorl %edx, %edx
cmpq %rcx, %r15
setne %dl
addq %rdx, %r14
movq %rax, %rdi
callq 0x5400
movq %r15, %rcx
cmpq %rbx, %rax
jne 0x5cbe
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
setl %al
jge 0x5e58
incq %rcx
movl $0x2, %r9d
subq %rdx, %r9
movzbl -0x1(%rdi,%rcx), %edx
cmpl $0xd, %edx
je 0x5e34
cmpl $0xa, %edx
jne 0x5e42
movzbl (%rdi,%rcx), %edx
cmpl $0xd, %edx
je 0x5e42
cmpl $0xa, %edx
jne 0x5e5b
cmpq %r8, %rcx
setl %al
leaq (%r9,%rcx), %rdx
incq %rdx
incq %rcx
cmpq $0x1, %rdx
jne 0x5e25
andb $0x1, %al
retq
testb $0x1, %al
je 0x5e58
movq %rcx, (%rsi)
jmp 0x5e58
// File: /workspace/github_cpp_makefile_star2_O1/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:
leaq (,%rdi,4), %rdx
xorl %ecx, %ecx
leaq 0xaaa8(%rip), %r8       # 0x10a80
xorl %eax, %eax
xorl %r9d, %r9d
movl (%r9,%r8), %r10d
movq %rdx, %r11
orq %r10, %r11
cmpq %rsi, %r11
sete %r11b
orb %r11b, %al
shlq $0x36, %r10
orq %rdi, %r10
cmpq %rsi, %r10
sete %r10b
orb %r10b, %cl
addq $0x4, %r9
cmpq $0x10, %r9
jne 0x5fdd
andb %cl, %al
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rdi,4), %r12
xorl %r13d, %r13d
leaq 0xaa4c(%rip), %rbp      # 0x10a80
movl (%r13,%rbp), %edi
shlq $0x36, %rdi
orq %r14, %rdi
callq 0x5e64
cmpq %rbx, %rax
jne 0x6086
xorl %ecx, %ecx
xorl %r15d, %r15d
xorl %edx, %edx
movl (%rdx,%rbp), %esi
movq %r12, %rdi
orq %rsi, %rdi
cmpq %rbx, %rdi
sete %dil
orb %dil, %r15b
shlq $0x36, %rsi
orq %r14, %rsi
cmpq %rbx, %rsi
sete %sil
orb %sil, %cl
addq $0x4, %rdx
cmpq $0x10, %rdx
jne 0x6051
andb %cl, %r15b
xorb $0x1, %r15b
cmpq %rbx, %rax
je 0x6098
addq $0x4, %r13
cmpq $0x10, %r13
jne 0x6034
xorl %r15d, %r15d
andb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rdi,4), %r12
xorl %r13d, %r13d
leaq 0xa9af(%rip), %rbp      # 0x10a80
movl (%r13,%rbp), %edi
orq %r12, %rdi
callq 0x5e64
cmpq %rbx, %rax
jne 0x611f
xorl %ecx, %ecx
xorl %r15d, %r15d
xorl %edx, %edx
movl (%rdx,%rbp), %esi
movq %r12, %rdi
orq %rsi, %rdi
cmpq %rbx, %rdi
sete %dil
orb %dil, %r15b
shlq $0x36, %rsi
orq %r14, %rsi
cmpq %rbx, %rsi
sete %sil
orb %sil, %cl
addq $0x4, %rdx
cmpq $0x10, %rdx
jne 0x60ea
andb %cl, %r15b
xorb $0x1, %r15b
cmpq %rbx, %rax
je 0x6131
addq $0x4, %r13
cmpq $0x10, %r13
jne 0x60d1
xorl %r15d, %r15d
andb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb11c
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0x6011
testb %al, %al
jne 0x618c
movq %r12, %rdi
movq %r15, %rsi
callq 0x60ae
testb %al, %al
je 0x61b5
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 0xb9f5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe039
testb %al, %al
je 0x692a
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 0xe28a
movq 0x18(%rbx), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rcx
xorl %edx, %edx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0xb9f5
movq %r14, %rdi
callq 0xe301
testl %eax, %eax
je 0x68d6
movq 0x10(%rbx), %rdi
callq 0xb888
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6998
cmpl $0x1, %edi
je 0x696e
testl %edi, %edi
jne 0x69e2
leaq 0x96cf(%rip), %rax      # 0x10025
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5420
movq %rax, (%rbx)
testq %rax, %rax
jne 0x69e2
jmp 0x69ee
leaq 0x96b0(%rip), %rax      # 0x10025
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5500
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x69ee
movq %rax, %rdi
movl $0x4000000, %esi        # imm = 0x4000000
callq 0x5260
jmp 0x69e2
leaq 0x9686(%rip), %rax      # 0x10025
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5420
movq %rax, (%rbx)
testq %rax, %rax
je 0x69ee
movl $0x4000000, %ecx        # imm = 0x4000000
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5050
leaq 0x18(%rbx), %rdi
movq (%rbx), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5590
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x69e6
movb $0x1, %al
jmp 0x69f0
movq (%rbx), %rdi
callq 0x5360
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x259c
movq %rbx, %rdi
callq 0x20a0
movq 0x6b4c(%rip), %rdi      # 0x8fc8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2190
jmp 0x25b4
leaq -0x24(%rbp), %r14
movl $0x0, (%r14)
leaq -0x8e(%rbp), %rax
movq %rax, 0x6(%rax)
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 0x2964
testb %al, %al
je 0x25e1
movl (%r14), %ebx
movq 0x6af7(%rip), %rax      # 0x8fe0
leaq -0x38(%rbp), %r15
movq %rax, (%r15)
movb $0x1, 0xc(%r15)
movq %r15, %rdi
callq 0x3182
leaq -0x90(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x31bc
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 0x2637
leaq -0x24(%rbp), %rdx
movl $0x0, (%rdx)
movq 0x6a5b(%rip), %rsi      # 0x8fc8
leaq -0x90(%rbp), %rdi
callq 0x3643
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x258c
movl $0x1, %esi
callq 0x2170
leaq -0x90(%rbp), %rdi
callq 0x288e
xorl %eax, %eax
jmp 0x25d1
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2230
movq 0x6a0d(%rip), %rdi      # 0x8fc8
leaq 0x2a4a(%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 0x66c8(%rip), %rax      # 0x8cb0
leaq -0x90(%rbp), %rdi
movq %rax, (%rdi)
movq 0x69bf(%rip), %rax      # 0x8fb8
movq %rax, 0x8(%rdi)
movq 0x69cc(%rip), %rax      # 0x8fd0
movq %rax, 0x10(%rdi)
callq 0x2c73
jmp 0x260f
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x2864
jmp 0x262f
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x2200
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x18(%rax), %r13
addq $0x18, %rax
movq %rax, -0x30(%rbp)
cmpq %rax, %r13
setne %r12b
je 0x3b41
movq %rdi, %rbx
movq 0x10(%r13), %r15
xorl %ecx, %ecx
movl %ecx, %r14d
testb $0x1, %cl
jne 0x3b2e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c62
movb $0x1, %cl
testb %al, %al
je 0x3b0f
testb $0x1, %r14b
je 0x3b41
movq (%r13), %r13
cmpq -0x30(%rbp), %r13
setne %al
andb %al, %r14b
movl %r14d, %r12d
jne 0x3b09
notb %r12b
andb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f2d
movq %rdi, %rbx
addq $-0x8, %r12
cmpq %r12, %r15
je 0x3f0b
leaq 0x1126(%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 0x3ee4
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_O1/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 0x3fc1
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 0x3fb6
leaq (%rcx,%rdx,8), %r15
movq -0x8(%rax), %r14
addq $-0x8, %rax
movq %rax, 0x8(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c62
testb %al, %al
je 0x3fad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f3a
movq 0x8(%r15), %rax
cmpq %rax, (%r15)
jne 0x3f87
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17d7(%rip), %rdi      # 0x579f
leaq 0x17e6(%rip), %rsi      # 0x57b5
leaq 0x1dfd(%rip), %rcx      # 0x5dd3
movl $0x54, %edx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b2f(%rip), %rcx      # 0x5020
movl $0x19c, %r8d            # imm = 0x19C
xorl %esi, %esi
callq 0x22b0
leaq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rdx
leaq 0x2cc0(%rip), %rcx      # 0x51cd
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_O1/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
cmpq %rdx, 0x28(%rdi)
je 0x25c3
leaq 0x20(%rbx), %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2ccd(%rip), %rsi      # 0x5260
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x35d4
movq %r14, %rdi
movq %r15, %rsi
callq 0x2230
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x25c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
cmpq $0x0, 0x8(%rbx)
je 0x261b
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 0x2607
movzbl %sil, %edx
movzbl -0x1(%rbx,%rdx), %esi
movb %sil, (%rcx)
movl $0x5f, %edx
cmpb $0x20, %sil
je 0x2607
movl %esi, %edx
movb %dl, (%rcx)
incq %rcx
incq %rax
movq (%rbx), %rdx
addq 0x8(%rbx), %rdx
cmpq %rdx, %rax
jne 0x25d1
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x29db(%rip), %rcx      # 0x5020
movl $0x19c, %r8d            # imm = 0x19C
xorl %esi, %esi
callq 0x22b0
leaq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rdx
leaq 0x2b6c(%rip), %rcx      # 0x51cd
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x22b0
movaps 0x299e(%rip), %xmm0     # 0x5010
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x4a(%rbx)
leaq 0x2b3c(%rip), %rsi      # 0x51bd
movq %r14, %rdi
callq 0x2200
testq %rax, %rax
je 0x272a
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 0x26ec
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_O1/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 0x2a79(%rip), %rsi      # 0x51c8
movq %rax, %rdi
callq 0x2200
testq %rax, %rax
je 0x27b0
movq %rax, %rbx
movq 0x20(%r14), %rdi
movq 0x28(%r14), %rdx
movl $0x1, %esi
movq %rax, %rcx
callq 0x2320
leaq 0x2a50(%rip), %rdi      # 0x51cb
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_O1/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 0x29ff(%rip), %rsi      # 0x51c8
movq %rax, %rdi
callq 0x2200
testq %rax, %rax
je 0x282b
movq %rax, %rbx
leaq 0x29e0(%rip), %rdi      # 0x51c0
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_O1/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 0x2983(%rip), %rsi      # 0x51c8
movq %rax, %rdi
callq 0x2200
testq %rax, %rax
je 0x287d
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_O1/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 0x2926(%rip), %rsi      # 0x51bd
movq %rax, %rdi
callq 0x2200
testq %rax, %rax
je 0x2900
movq %rax, %r14
leaq 0x40(%rbx), %rdi
movaps 0x275e(%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 0x28e8
movb $0x20, (%rbx,%rax)
incq %rax
cmpq $0x5a, %rax
jne 0x28d9
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_O1/BrianEnigma[P]cryptoslam/src/cryptogram.cpp
// Function: Cryptogram::set(char, char)
char Cryptogram::normalize(char letter)
{
    if ( (letter >= 'a') && (letter <= 'z') )
        return letter - ('a' - 'A');
    else
        return letter;
}

// Assembly:
leal -0x61(%rsi), %eax
leal -0x20(%rsi), %ecx
cmpb $0x1a, %al
movzbl %cl, %eax
cmovael %esi, %eax
leal -0x41(%rax), %ecx
cmpb $0x19, %cl
ja 0x2938
leal -0x61(%rdx), %ecx
leal -0x20(%rdx), %esi
cmpb $0x1a, %cl
movzbl %dl, %ecx
movzbl %sil, %edx
cmovael %ecx, %edx
movzbl %al, %eax
movb %dl, -0x1(%rax,%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %eax, %eax
leal 0x41(%rax), %ecx
movb %cl, 0x40(%rbx,%rax)
incq %rax
cmpq $0x1a, %rax
jne 0x297f
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 0x29a2
popq %rbx
popq %r14
popq %rbp
retq