LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_len_4to8_128b(unsigned char const*, unsigned long, unsigned char const*, unsigned long)
XXH_FORCE_INLINE XXH_PUREF XXH128_hash_t
XXH3_len_4to8_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
{
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(secret != NULL);
    XXH_ASSERT(4 <= len && len <= 8);
    seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32;
    {   xxh_u32 const input_lo = XXH_readLE32(input);
        xxh_u32 const input_hi = XXH_readLE32(input + len - 4);
        xxh_u64 const input_64 = input_lo + ((xxh_u64)input_hi << 32);
        xxh_u64 const bitflip = (XXH_readLE64(secret+16) ^ XXH_readLE64(secret+24)) + seed;
        xxh_u64 const keyed = input_64 ^ bitflip;

        /* Shift len to the left to ensure it is even, this avoids even multiplies. */
        XXH128_hash_t m128 = XXH_mult64to128(keyed, XXH_PRIME64_1 + (len << 2));

        m128.high64 += (m128.low64 << 1);
        m128.low64  ^= (m128.high64 >> 3);

        m128.low64   = XXH_xorshift64(m128.low64, 35);
        m128.low64  *= 0x9FB21C651E98DF25ULL;
        m128.low64   = XXH_xorshift64(m128.low64, 28);
        m128.high64  = XXH3_avalanche(m128.high64);
        return m128;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movl -0x30(%rbp), %edi
callq 0x2ba0
movl %eax, %ecx
shlq $0x20, %rcx
movq -0x30(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x29e0
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
leaq -0x4(%rax,%rcx), %rdi
callq 0x29e0
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movl -0x38(%rbp), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
callq 0x32e0
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x32e0
movq %rax, %rcx
movq -0x58(%rbp), %rax
xorq %rcx, %rax
movq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
xorq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rcx
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
leaq (%rax,%rcx,4), %rsi
callq 0x6450
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
leaq (%rax,%rcx,2), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x3, %rcx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x23, %esi
callq 0x6490
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movabsq $-0x604de39ae16720db, %rcx # imm = 0x9FB21C651E98DF25
imulq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1c, %esi
callq 0x6490
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6400
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_len_1to3_128b(unsigned char const*, unsigned long, unsigned char const*, unsigned long)
XXH_FORCE_INLINE XXH_PUREF XXH128_hash_t
XXH3_len_1to3_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
{
    /* A doubled version of 1to3_64b with different constants. */
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(1 <= len && len <= 3);
    XXH_ASSERT(secret != NULL);
    /*
     * len = 1: combinedl = { input[0], 0x01, input[0], input[0] }
     * len = 2: combinedl = { input[1], 0x02, input[0], input[1] }
     * len = 3: combinedl = { input[2], 0x03, input[0], input[1] }
     */
    {   xxh_u8 const c1 = input[0];
        xxh_u8 const c2 = input[len >> 1];
        xxh_u8 const c3 = input[len - 1];
        xxh_u32 const combinedl = ((xxh_u32)c1 <<16) | ((xxh_u32)c2 << 24)
                                | ((xxh_u32)c3 << 0) | ((xxh_u32)len << 8);
        xxh_u32 const combinedh = XXH_rotl32(XXH_swap32(combinedl), 13);
        xxh_u64 const bitflipl = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed;
        xxh_u64 const bitfliph = (XXH_readLE32(secret+8) ^ XXH_readLE32(secret+12)) - seed;
        xxh_u64 const keyed_lo = (xxh_u64)combinedl ^ bitflipl;
        xxh_u64 const keyed_hi = (xxh_u64)combinedh ^ bitfliph;
        XXH128_hash_t h128;
        h128.low64  = XXH64_avalanche(keyed_lo);
        h128.high64 = XXH64_avalanche(keyed_hi);
        return h128;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq %rcx
movb (%rax,%rcx), %al
movb %al, -0x32(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movb -0x1(%rax,%rcx), %al
movb %al, -0x33(%rbp)
movzbl -0x31(%rbp), %eax
shll $0x10, %eax
movzbl -0x32(%rbp), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movzbl -0x33(%rbp), %ecx
orl %ecx, %eax
movl -0x20(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %edi
callq 0x2ba0
roll $0xd, %eax
movl %eax, -0x3c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x29e0
movl %eax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
addq $0x4, %rdi
callq 0x29e0
movl %eax, %ecx
movl -0x68(%rbp), %eax
xorl %ecx, %eax
movq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x29e0
movl %eax, -0x64(%rbp)
movq -0x28(%rbp), %rdi
addq $0xc, %rdi
callq 0x29e0
movl %eax, %ecx
movl -0x64(%rbp), %eax
xorl %ecx, %eax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
movq -0x48(%rbp), %rcx
xorq %rcx, %rax
movq %rax, -0x58(%rbp)
movl -0x3c(%rbp), %eax
movq -0x50(%rbp), %rcx
xorq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5d90
movq %rax, -0x10(%rbp)
movq -0x60(%rbp), %rdi
callq 0x5d90
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
nop
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH128_mix32B(XXH128_hash_t, unsigned char const*, unsigned char const*, unsigned char const*, unsigned long)
XXH_FORCE_INLINE XXH128_hash_t
XXH128_mix32B(XXH128_hash_t acc, const xxh_u8* input_1, const xxh_u8* input_2,
              const xxh_u8* secret, XXH64_hash_t seed)
{
    acc.low64  += XXH3_mix16B (input_1, secret+0, seed);
    acc.low64  ^= XXH_readLE64(input_2) + XXH_readLE64(input_2 + 8);
    acc.high64 += XXH3_mix16B (input_2, secret+16, seed);
    acc.high64 ^= XXH_readLE64(input_1) + XXH_readLE64(input_1 + 8);
    return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x6540
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x32e0
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x32e0
movq -0x50(%rbp), %rcx
addq %rax, %rcx
movq -0x20(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x10, %rsi
movq -0x40(%rbp), %rdx
callq 0x6540
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
callq 0x32e0
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x32e0
movq -0x48(%rbp), %rcx
addq %rax, %rcx
movq -0x18(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x18(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_hashLong_128b_internal(void const*, unsigned long, unsigned char const*, unsigned long, void (*)(void*, void const*, void const*), void (*)(void*, void const*))
XXH_FORCE_INLINE XXH128_hash_t
XXH3_hashLong_128b_internal(const void* XXH_RESTRICT input, size_t len,
                            const xxh_u8* XXH_RESTRICT secret, size_t secretSize,
                            XXH3_f_accumulate_512 f_acc512,
                            XXH3_f_scrambleAcc f_scramble)
{
    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC;

    XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, secret, secretSize, f_acc512, f_scramble);

    /* converge into final hash */
    XXH_STATIC_ASSERT(sizeof(acc) == 64);
    XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);
    {   XXH128_hash_t h128;
        h128.low64  = XXH3_mergeAccs(acc,
                                     secret + XXH_SECRET_MERGEACCS_START,
                                     (xxh_u64)len * XXH_PRIME64_1);
        h128.high64 = XXH3_mergeAccs(acc,
                                     secret + secretSize
                                            - sizeof(acc) - XXH_SECRET_MERGEACCS_START,
                                     ~((xxh_u64)len * XXH_PRIME64_2));
        return h128;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
leaq -0x80(%rbp), %rdi
leaq 0x3c22(%rip), %rsi      # 0xb140
movl $0x40, %edx
callq 0x2110
leaq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %rax
movq %rax, (%rsp)
callq 0x6660
jmp 0x754f
movq -0x28(%rbp), %rsi
addq $0xb, %rsi
movq -0x20(%rbp), %rdx
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq %rax, %rdx
leaq -0x80(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4ae0
movq -0x88(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
leaq -0x4b(%rax,%rcx), %rsi
movq -0x20(%rbp), %rdx
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
imulq %rax, %rdx
notq %rdx
callq 0x4ae0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x90, %rsp
popq %rbp
retq
// File: sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_hashLong_128b_withSeed_internal(void const*, unsigned long, unsigned long, void (*)(void*, void const*, void const*), void (*)(void*, void const*), void (*)(void*, unsigned long))
XXH_FORCE_INLINE XXH128_hash_t
XXH3_hashLong_128b_withSeed_internal(const void* XXH_RESTRICT input, size_t len,
                                XXH64_hash_t seed64,
                                XXH3_f_accumulate_512 f_acc512,
                                XXH3_f_scrambleAcc f_scramble,
                                XXH3_f_initCustomSecret f_initSec)
{
    if (seed64 == 0)
        return XXH3_hashLong_128b_internal(input, len,
                                           XXH3_kSecret, sizeof(XXH3_kSecret),
                                           f_acc512, f_scramble);
    {   XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
        f_initSec(secret, seed64);
        return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, sizeof(secret),
                                           f_acc512, f_scramble);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7615
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
leaq 0x3a3f(%rip), %rdx      # 0xb040
movl $0xc0, %ecx
callq 0x74f0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x764f
movq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq *%rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x100(%rbp), %rdx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movl $0xc0, %ecx
callq 0x74f0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
// File: sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>::generateRandom(int)
void generateRandom(int chance_set) {
		if(chance_set < 0 || chance_set > 100) {
			throw std::runtime_error("Out of bounds");
		}
		for(int i = 0; i < height; ++i) {
			for(int j = 0; j < width; ++j) {
				field[i * width + j] = ValueType(rand() % 100 < chance_set ? true : false);
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x7743
cmpl $0x64, -0xc(%rbp)
jle 0x7796
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x3a6d(%rip), %rsi      # 0xb1cb
callq 0x2060
jmp 0x7765
movq -0x38(%rbp), %rdi
movq 0x8880(%rip), %rsi      # 0xfff0
movq 0x8841(%rip), %rdx      # 0xffb8
callq 0x2210
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20e0
jmp 0x7836
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x7830
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jge 0x7820
callq 0x2030
movslq %eax, %rcx
imulq $0x51eb851f, %rcx, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
movl -0xc(%rbp), %ecx
subl %ecx, %eax
setl %al
negb %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x25(%rbp), %rdi
callq 0x8b90
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %eax
imull 0x1c(%rdi), %eax
addl -0x24(%rbp), %eax
movslq %eax, %rsi
callq 0x8bb0
movb -0x25(%rbp), %cl
movb %cl, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x77b4
jmp 0x7822
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x779d
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2220
nop
// File: sgielen[P]clife/multi_indep.cpp
// Function: void print_rgb<SimpleValue<(char)-128, (char)0>>(GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>, GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>, GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>)
void print_rgb(GameOfLifeField<ValueType> red, GameOfLifeField<ValueType> green, GameOfLifeField<ValueType> blue) {
	char on = 0x80;
	char off = 0x00;
	for(int y = 0; y < red.get_height(); ++y) {
		for(int x = 0; x < red.get_width(); ++x) {
			std::cout << (red.is_set(y, x) ? on : off);
			std::cout << (green.is_set(y, x) ? on : off);
			std::cout << (blue.is_set(y, x) ? on : off);
		}
	}
	std::cout << std::flush;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $-0x80, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0x8bd0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x796b
movl $0x0, -0x24(%rbp)
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x48(%rbp)
callq 0x8bf0
movl %eax, %ecx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
jge 0x795b
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x8c10
testb $0x1, %al
jne 0x78c3
jmp 0x78cb
movb -0x19(%rbp), %al
movb %al, -0x49(%rbp)
jmp 0x78d1
movb -0x1a(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
movq 0x86e5(%rip), %rdi      # 0xffc0
movsbl %al, %esi
callq 0x2180
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x8c10
testb $0x1, %al
jne 0x78f8
jmp 0x7900
movb -0x19(%rbp), %al
movb %al, -0x4a(%rbp)
jmp 0x7906
movb -0x1a(%rbp), %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
movq 0x86b0(%rip), %rdi      # 0xffc0
movsbl %al, %esi
callq 0x2180
movq -0x30(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x8c10
testb $0x1, %al
jne 0x792d
jmp 0x7935
movb -0x19(%rbp), %al
movb %al, -0x4b(%rbp)
jmp 0x793b
movb -0x1a(%rbp), %al
movb %al, -0x4b(%rbp)
movb -0x4b(%rbp), %al
movq 0x867b(%rip), %rdi      # 0xffc0
movsbl %al, %esi
callq 0x2180
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7892
jmp 0x795d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x786f
movq 0x864e(%rip), %rdi      # 0xffc0
movq 0x864f(%rip), %rsi      # 0xffc8
callq 0x2170
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: sgielen[P]clife/multi_indep.cpp
// Function: void check_stop_condition<GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>>(GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>, std::vector<unsigned long, std::allocator<unsigned long>>&, bool&, int&)
void check_stop_condition(FieldType field, std::vector<uint64_t> &earlier_hashes, bool &done, int &repeats_to_do) {
	uint64_t hash = field.field_hash();
	for(size_t i = 0; i < earlier_hashes.size(); ++i) {
		if(earlier_hashes[i] == hash) {
			done = true;
			repeats_to_do = 10;
			break;
		}
	}
	earlier_hashes.push_back(hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x9f90
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa050
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x7d1f
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xa070
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x7d0f
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x20(%rbp), %rax
movl $0xa, (%rax)
jmp 0x7d1f
jmp 0x7d11
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x7cc9
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa090
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>::neighbors_set(int, int, std::vector<SimpleValue<(char)-128, (char)0>, std::allocator<SimpleValue<(char)-128, (char)0>>>&)
void neighbors_set(int y, int x, std::vector<ValueType> &neigh) {
		add_if_inside_or_wrapping_and_set(neigh, y-1, x-1);
		add_if_inside_or_wrapping_and_set(neigh, y-1, x  );
		add_if_inside_or_wrapping_and_set(neigh, y-1, x+1);
		add_if_inside_or_wrapping_and_set(neigh, y  , x-1);
		add_if_inside_or_wrapping_and_set(neigh, y  , x+1);
		add_if_inside_or_wrapping_and_set(neigh, y+1, x-1);
		add_if_inside_or_wrapping_and_set(neigh, y+1, x  );
		add_if_inside_or_wrapping_and_set(neigh, y+1, x+1);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
subl $0x1, %edx
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
callq 0x9190
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
subl $0x1, %edx
movl -0x10(%rbp), %ecx
callq 0x9190
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
subl $0x1, %edx
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
callq 0x9190
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
callq 0x9190
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
callq 0x9190
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
addl $0x1, %edx
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
callq 0x9190
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
addl $0x1, %edx
movl -0x10(%rbp), %ecx
callq 0x9190
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
addl $0x1, %edx
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
callq 0x9190
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>::add_if_inside_or_wrapping_and_set(std::vector<SimpleValue<(char)-128, (char)0>, std::allocator<SimpleValue<(char)-128, (char)0>>>&, int, int)
void add_if_inside_or_wrapping_and_set(std::vector<ValueType> &vt, int y, int x) {
		if(wrapping) {
			y += height;
			y %= height;
			x += width;
			x %= width;
		}
		return add_if_inside_and_set(vt, y, x);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl 0x18(%rdi), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl 0x18(%rdi), %ecx
movl -0x14(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movl 0x1c(%rdi), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl 0x1c(%rdi), %ecx
movl -0x18(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
callq 0x91f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>::field_hash() const
uint64_t field_hash() const {
                XXH3_state_t state;
                XXH3_64bits_reset(&state);
                for(auto const &cell : field) {
                        bool value = bool(cell);
                        XXH3_64bits_update(&state, &value, sizeof(value));
                }
                return XXH3_64bits_digest(&state);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x40, %rsp
subq $0x2c0, %rsp            # imm = 0x2C0
movq %rdi, 0x2a8(%rsp)
movq 0x2a8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3b80
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x8060
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x8090
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x8470
testb $0x1, %al
jne 0x9ffb
jmp 0xa03a
leaq 0x30(%rsp), %rdi
callq 0x84d0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x8d20
andb $0x1, %al
movb %al, 0x1f(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x1f(%rsp), %rsi
movl $0x1, %edx
callq 0x3f70
leaq 0x30(%rsp), %rdi
callq 0x84f0
jmp 0x9fe6
leaq 0x40(%rsp), %rdi
callq 0x4850
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: SaadBazaz[P]RIP-Protocol-Simulation/./RoutingTable.h
// Function: tokenizeData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
std::vector<std::string> tokenizeData (std::string buffer, char delimiter = ','){
		std::stringstream ss(buffer); 
	    std::vector<std::string> v; 
	  
		while (ss.good()) { 
		    std::string substr; 
		    getline(ss, substr, delimiter); 
		    v.push_back(substr); 
		} 
		
		return v;		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rsi, -0x1e8(%rbp)
movq %rdi, -0x1e0(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x54d0
movq -0x1e8(%rbp), %rsi
movl %eax, %edx
leaq -0x1a0(%rbp), %rdi
callq 0x33f0
movq -0x1e0(%rbp), %rdi
movb $0x0, -0x1a1(%rbp)
callq 0x54f0
movq -0x1a0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1a0(%rbp,%rax), %rdi
callq 0x3420
movb %al, -0x1f1(%rbp)
jmp 0x3697
movb -0x1f1(%rbp), %al
testb $0x1, %al
jne 0x36a6
jmp 0x3729
leaq -0x1d8(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x33a0
movq -0x200(%rbp), %rsi
movsbl -0x11(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
callq 0x3470
jmp 0x36d2
movq -0x1e0(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x5510
jmp 0x36e7
leaq -0x1d8(%rbp), %rdi
callq 0x31a0
jmp 0x3677
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x3761
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x31a0
jmp 0x3761
movb $0x1, -0x1a1(%rbp)
testb $0x1, -0x1a1(%rbp)
jne 0x3745
movq -0x1e0(%rbp), %rdi
callq 0x5580
leaq -0x1a0(%rbp), %rdi
callq 0x3210
movq -0x1f0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1e0(%rbp), %rdi
callq 0x5580
leaq -0x1a0(%rbp), %rdi
callq 0x3210
movq -0x1b0(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: SaadBazaz[P]RIP-Protocol-Simulation/./RoutingTable.h
// Function: operator==(TableRow&, TableRow&)
bool operator== (TableRow &t1, TableRow &t2)
{
    return ( 
	t1.identifier == t2.identifier && 
	t1.fd == t2.fd && 
	t1.status == t2.status && 
	t1.hop_count == t2.hop_count && 
	t1.type == t2.type && 
	t1.in_use == t2.in_use && 
	t1.send_port == t2.send_port && 
	t1.receive_port == t2.receive_port 
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x11(%rbp)
jne 0x386f
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x11(%rbp)
jne 0x386f
movq -0x8(%rbp), %rax
movswl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movswl 0x8(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x386f
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0xc(%rdx), %ecx
movb %al, -0x11(%rbp)
jne 0x386f
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x55e0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x3825
jmp 0x386f
movq -0x8(%rbp), %rax
movb 0x30(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movb 0x30(%rax), %al
andb $0x1, %al
movzbl %al, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
jne 0x386f
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x34(%rdx), %ecx
movb %al, -0x11(%rbp)
jne 0x386f
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x38(%rcx), %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: SaadBazaz[P]RIP-Protocol-Simulation/./RoutingTable.h
// Function: serialize[abi:cxx11](std::vector<TableRow, std::allocator<TableRow>>&)
std::string serialize (std::vector<TableRow> &table){
	std::string returnTo;
	for (int i=0; i<table.size(); i++){
		returnTo += table[i].toString();
		if (i+1 != table.size())
			returnTo += '\n';
	}
	return returnTo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x33a0
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5670
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x396c
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x5690
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movl $0x2c, %edx
callq 0x56b0
jmp 0x38ec
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3380
jmp 0x38fb
leaq -0x38(%rbp), %rdi
callq 0x31a0
movl -0x18(%rbp), %eax
addl $0x1, %eax
cltq
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5670
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
je 0x395c
movq -0x58(%rbp), %rdi
movl $0xa, %esi
callq 0x31b0
jmp 0x3935
jmp 0x395c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3989
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31a0
jmp 0x3989
jmp 0x395e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x38ab
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x397f
movq -0x58(%rbp), %rdi
callq 0x31a0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x31a0
movq -0x40(%rbp), %rdi
callq 0x3440
nopl (%rax,%rax)
// File: SaadBazaz[P]RIP-Protocol-Simulation/./RoutingTable.h
// Function: deserialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<TableRow> deserialize (std::string table_string){
	std::vector <std::string> rows = tokenizeData(table_string, '\n');

	std::vector<TableRow> returnTo; 

	for (int i=0; i<rows.size(); i++){
		TableRow new_row (rows[i]);
		returnTo.push_back(new_row);
	}

	return returnTo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3100
movq -0xc8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movl $0xa, %edx
callq 0x3610
jmp 0x39eb
leaq -0x48(%rbp), %rdi
callq 0x31a0
movq -0xd8(%rbp), %rdi
movb $0x0, -0x55(%rbp)
callq 0x5ca0
movl $0x0, -0x5c(%rbp)
movslq -0x5c(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5cc0
movq %rax, %rcx
movq -0xe0(%rbp), %rax
cmpq %rcx, %rax
jae 0x3b01
movslq -0x5c(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x5ce0
movq %rax, %rsi
leaq -0xc0(%rbp), %rdi
callq 0x3100
jmp 0x3a50
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
movl $0x2c, %edx
callq 0x5d00
jmp 0x3a6a
leaq -0xc0(%rbp), %rdi
callq 0x31a0
movq -0xd8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x5f50
jmp 0x3a8b
leaq -0xa0(%rbp), %rdi
callq 0x5fc0
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x3a0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31a0
jmp 0x3b45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x3b30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x31a0
jmp 0x3b30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x5fc0
jmp 0x3b30
movb $0x1, -0x55(%rbp)
testb $0x1, -0x55(%rbp)
jne 0x3b17
movq -0xd8(%rbp), %rdi
callq 0x5fe0
leaq -0x28(%rbp), %rdi
callq 0x5580
movq -0xd0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x5fe0
leaq -0x28(%rbp), %rdi
callq 0x5580
movq -0x50(%rbp), %rdi
callq 0x3440
nop
// File: SaadBazaz[P]RIP-Protocol-Simulation/DNS.cpp
// Function: SearchDomain(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Directory, std::allocator<Directory>>)
int SearchDomain(string Dom,vector<Directory> List){
    for(int i = 0;i < List.size();i++){
        
        cout<<"Matching '"<<Dom<<"' with "<<List[i].DomainName<<endl;
        if (Dom == List[i].DomainName)
        {
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x6320
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x4b61
movq 0xa4f1(%rip), %rdi      # 0xefc8
leaq 0x5945(%rip), %rsi      # 0xa423
callq 0x32a0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3280
movq %rax, %rdi
leaq 0x5935(%rip), %rsi      # 0xa42e
callq 0x32a0
movq -0x28(%rbp), %rdi
movq %rax, -0x40(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0x6350
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x3280
movq %rax, %rdi
movq 0xa493(%rip), %rsi      # 0xefb8
callq 0x32e0
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6350
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x55e0
testb $0x1, %al
jne 0x4b49
jmp 0x4b51
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4b68
jmp 0x4b53
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4aaf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/RefDB.cc
// Function: RefDB::getRefSeq[abi:cxx11](unsigned int, unsigned int)
string RefDB::getRefSeq(unsigned int refLoc, unsigned int length) {
	//If oversize, return empty seed.
	if (refLoc >= chromosome.size())
		return string("");

	if (refLoc + length > chromosome.size())
		return (chromosome.substr(refLoc, length)
				+ string(refLoc + length - chromosome.size(), 'N'));

	return chromosome.substr(refLoc, length);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movl %edx, 0xb4(%rsp)
movl %ecx, 0xb0(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movl 0xb4(%rsp), %eax
movq %rax, 0x48(%rsp)
addq $0x240, %rdi            # imm = 0x240
callq 0x31b0
movq %rax, %rcx
movq 0x48(%rsp), %rax
cmpq %rcx, %rax
jb 0x4666
leaq 0xaf(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x34a0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x1a73(%rip), %rsi      # 0x609a
callq 0x39f0
jmp 0x462e
leaq 0xaf(%rsp), %rdi
callq 0x32a0
jmp 0x47c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xaf(%rsp), %rdi
callq 0x32a0
jmp 0x47d6
movq 0x40(%rsp), %rdi
movl 0xb4(%rsp), %eax
addl 0xb0(%rsp), %eax
movl %eax, %eax
movq %rax, 0x20(%rsp)
addq $0x240, %rdi            # imm = 0x240
callq 0x31b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jbe 0x47a1
movq 0x40(%rsp), %rsi
addq $0x240, %rsi            # imm = 0x240
movq %rsi, (%rsp)
movl 0xb4(%rsp), %eax
movl %eax, %edx
movl 0xb0(%rsp), %eax
movl %eax, %ecx
leaq 0x78(%rsp), %rdi
callq 0x3270
movq (%rsp), %rdi
movl 0xb4(%rsp), %eax
movl 0xb0(%rsp), %ecx
addl %ecx, %eax
movq %rax, 0x8(%rsp)
callq 0x31b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x34a0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
leaq 0x58(%rsp), %rdi
movl $0x4e, %edx
callq 0x4ce0
jmp 0x4721
movq 0x30(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x4bf0
jmp 0x4737
leaq 0x58(%rsp), %rdi
callq 0x3180
leaq 0x57(%rsp), %rdi
callq 0x32a0
leaq 0x78(%rsp), %rdi
callq 0x3180
jmp 0x47c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x478b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x3180
leaq 0x57(%rsp), %rdi
callq 0x32a0
leaq 0x78(%rsp), %rdi
callq 0x3180
jmp 0x47d6
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
addq $0x240, %rsi            # imm = 0x240
movl 0xb4(%rsp), %eax
movl %eax, %edx
movl 0xb0(%rsp), %eax
movl %eax, %ecx
callq 0x3270
movq 0x38(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0xa0(%rsp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH01_GettingStarted/examples/add.cc
// Function: main
int main()
{
	// prompt user to enter two numbers
	std::cout << "Enter two numbers:" << std::endl; 
	int v1 = 0, v2 = 0;
	std::cin >> v1 >> v2;   
	std::cout << "The sum of " << v1 << " and " << v2
	          << " is " << v1 + v2 << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2dea(%rip), %rdi      # 0x3fd0
leaq 0xe17(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movq 0x2dc4(%rip), %rsi      # 0x3fc0
callq 0x1060
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq 0x2dca(%rip), %rdi      # 0x3fe0
leaq -0x8(%rbp), %rsi
callq 0x1030
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x1030
movq 0x2d9e(%rip), %rdi      # 0x3fd0
leaq 0xdde(%rip), %rsi       # 0x2017
callq 0x1050
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1080
movq %rax, %rdi
leaq 0xdd0(%rip), %rsi       # 0x2023
callq 0x1050
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1080
movq %rax, %rdi
leaq 0xdbc(%rip), %rsi       # 0x2029
callq 0x1050
movq %rax, %rdi
movl -0x8(%rbp), %esi
addl -0xc(%rbp), %esi
callq 0x1080
movq %rax, %rdi
movq 0x2d36(%rip), %rsi      # 0x3fc0
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: m0Mh42[P]mash/./src/main.cpp
// Function: string_to_hex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string string_to_hex(const string& input)
{
    static const char hex_digits[] = "0123456789ABCDEF";

    string output;
    output.reserve(input.length() * 2);
    for (unsigned char c : input)
    {
        output.push_back(hex_digits[c >> 4]);
        output.push_back(hex_digits[c & 15]);
    }
    return output;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb $0x0, 0x47(%rsp)
callq 0x2300
movq 0x48(%rsp), %rdi
callq 0x2340
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq %rsi, %rsi
callq 0x2370
jmp 0x2690
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x21d0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2400
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x31e0
testb $0x1, %al
jne 0x26cd
jmp 0x2743
leaq 0x20(%rsp), %rdi
callq 0x3220
movq 0x8(%rsp), %rdi
movb (%rax), %al
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
shrl $0x4, %eax
leaq 0x2a4f(%rip), %rcx      # 0x5140
movsbl (%rax,%rcx), %esi
callq 0x2180
jmp 0x26fc
movq 0x8(%rsp), %rdi
movzbl 0x17(%rsp), %eax
andl $0xf, %eax
leaq 0x2a30(%rip), %rcx      # 0x5140
movsbl (%rax,%rcx), %esi
callq 0x2180
jmp 0x271b
jmp 0x271d
leaq 0x20(%rsp), %rdi
callq 0x3230
jmp 0x26b8
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x2130
jmp 0x2762
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x2759
movq 0x8(%rsp), %rdi
callq 0x2130
movq (%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x23d0
nopl (%rax)
// File: m0Mh42[P]mash/./src/main.cpp
// Function: check_output(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void check_output(string data){
    if (difficulty > 0){
        for (int i = 0; i < difficulty; i++){
            // If the first characters defined by `difficulty` aren't '0', then we return, as it is false.
            if (data[i] != '0'){
                return;
            }
        }
        // Otherwise, it's the mash we were looking for and we print it, also stop running.
        cout << data << endl;
        run = false;
    } else {
        // There's no difficulty defined, printing the mash and sleeping.
        cout << data << endl;
        usleep(500 * 1000);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x10(%rsp)
movzbl 0x4abe(%rip), %eax      # 0x7242
cmpl $0x0, %eax
jle 0x27ef
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movzbl 0x4aa6(%rip), %ecx      # 0x7242
cmpl %ecx, %eax
jge 0x27c7
movq (%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x2440
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0x27b8
jmp 0x2818
jmp 0x27ba
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2791
movq (%rsp), %rsi
movq 0x47fe(%rip), %rdi      # 0x6fd0
callq 0x21b0
movq %rax, %rdi
movq 0x47df(%rip), %rsi      # 0x6fc0
callq 0x2220
movb $0x0, 0x4a56(%rip)      # 0x7243
jmp 0x2818
movq (%rsp), %rsi
movq 0x47d6(%rip), %rdi      # 0x6fd0
callq 0x21b0
movq %rax, %rdi
movq 0x47b7(%rip), %rsi      # 0x6fc0
callq 0x2220
movl $0x7a120, %edi          # imm = 0x7A120
callq 0x2310
addq $0x18, %rsp
retq
nopl (%rax)
// File: m0Mh42[P]mash/./src/main.cpp
// Function: difficulty_set(char*)
void difficulty_set(char* difficulty_num){
    try {
        difficulty = stoi(difficulty_num);
    } catch(...) {
        // Not Numeric Difficulty
        cout << "Invalid difficulty. Please insert number as difficulty." << endl;
        exit(USAGEERR);
    }
    if (difficulty > 63){
        // Difficulty can't be 64, so we cant find a result with all the characters '0'
        cout << "Invalid difficulty. Difficulty can\'t be more than 63." << endl;
        exit(INVALIDDIFF);
    }
    cout << "Difficulty set to " << difficulty << endl;
    double probability;
    double x = 64.00 - difficulty;
    // The probability to find the mash we look for.
    probability = pow(16.00, x) / pow(16.00, 64.00);
    cout << "Finding Probability: " << probability << endl;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x23e0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0x32a0
jmp 0x2858
xorl %eax, %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
movl $0xa, %edx
callq 0x3250
movl %eax, 0x14(%rsp)
jmp 0x2871
movl 0x14(%rsp), %eax
movb %al, 0x49c7(%rip)       # 0x7242
leaq 0x50(%rsp), %rdi
callq 0x2130
leaq 0x4f(%rsp), %rdi
callq 0x2240
jmp 0x2921
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x28bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2130
leaq 0x4f(%rsp), %rdi
callq 0x2240
movq 0x40(%rsp), %rdi
callq 0x20d0
movq 0x46f9(%rip), %rdi      # 0x6fd0
leaq 0x274a(%rip), %rsi      # 0x5028
callq 0x21f0
movq %rax, 0x8(%rsp)
jmp 0x28ea
movq 0x8(%rsp), %rdi
movq 0x46ca(%rip), %rsi      # 0x6fc0
callq 0x2220
jmp 0x28fd
movl $0x2, %edi
callq 0x2290
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x2390
jmp 0x291c
jmp 0x2a1b
movzbl 0x491a(%rip), %eax      # 0x7242
cmpl $0x3f, %eax
jle 0x2959
movq 0x469c(%rip), %rdi      # 0x6fd0
leaq 0x2725(%rip), %rsi      # 0x5060
callq 0x21f0
movq %rax, %rdi
movq 0x4676(%rip), %rsi      # 0x6fc0
callq 0x2220
movl $0x3, %edi
callq 0x2290
movq 0x4670(%rip), %rdi      # 0x6fd0
leaq 0x272f(%rip), %rsi      # 0x5096
callq 0x21f0
movq %rax, %rdi
movzbl 0x48cc(%rip), %esi      # 0x7242
callq 0x2350
movq %rax, %rdi
movq 0x463b(%rip), %rsi      # 0x6fc0
callq 0x2220
movzbl 0x48b1(%rip), %eax      # 0x7242
cvtsi2sd %eax, %xmm1
movsd 0x2673(%rip), %xmm0     # 0x5010
subsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm1
movsd 0x2653(%rip), %xmm0     # 0x5008
callq 0x23c0
movsd %xmm0, (%rsp)
movsd 0x2641(%rip), %xmm0     # 0x5008
movsd 0x2641(%rip), %xmm1     # 0x5010
callq 0x23c0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x45e3(%rip), %rdi      # 0x6fd0
leaq 0x26b5(%rip), %rsi      # 0x50a9
callq 0x21f0
movq %rax, %rdi
movsd 0x30(%rsp), %xmm0
callq 0x2410
movq %rax, %rdi
movq 0x45af(%rip), %rsi      # 0x6fc0
callq 0x2220
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x23d0
movq %rax, %rdi
callq 0x3360
nopl (%rax)
// File: m0Mh42[P]mash/./src/mash.cpp
// Function: Mash::mash(MashNode)
MashNode Mash::mash(MashNode node){
    // Random Mash
    xor_random(node);
    
    // Mashing each character round
    for (uint i = 0; i < 16; i++){
        node.value[i] = node.value[i] ^ node.value[32 - i - 1];
    }
    return node;
}

// Assembly:
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %rax
movq 0x10(%rsp), %rsi
movq %rdi, 0x18(%rsp)
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movq %rdi, 0x40(%rsp)
movq %rax, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3fa0
movl $0x0, 0x2c(%rsp)
cmpl $0x10, 0x2c(%rsp)
jae 0x3f86
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x2440
movq 0x10(%rsp), %rdi
movsbl (%rax), %eax
movl %eax, 0x8(%rsp)
addq $0x8, %rdi
movl $0x20, %eax
subl 0x2c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x2440
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl 0x8(%rsp), %eax
movsbl (%rcx), %ecx
xorl %ecx, %eax
movb %al, 0xf(%rsp)
addq $0x8, %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x2440
movb 0xf(%rsp), %cl
movb %cl, (%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3f0f
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x46f0
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: m0Mh42[P]mash/./src/mash.cpp
// Function: Mash::xor_random(MashNode&)
void Mash::xor_random(MashNode& node){
    for (int i = 0; i < 32; i++){
        rand_c_generator();
        node.value[i] ^= VERSION;
        node.value[i] ^= rand_c;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x20, 0x14(%rsp)
jge 0x4026
movq 0x8(%rsp), %rdi
callq 0x3ea0
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movslq 0x14(%rsp), %rsi
callq 0x2440
movq %rax, %rcx
movq 0x8(%rsp), %rax
movsbl (%rcx), %edx
xorl $0x33, %edx
movb %dl, (%rcx)
movzbl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movslq 0x14(%rsp), %rsi
callq 0x2440
movl 0x4(%rsp), %edx
movsbl (%rax), %ecx
xorl %edx, %ecx
movb %cl, (%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3fc0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: m0Mh42[P]mash/./src/mash.cpp
// Function: Mashtree::init_mashtree(unsigned int)
void Mashtree::init_mashtree(uint chunksize){
    nodetree = new MashNode[chunksize];
    if (nodetree == nullptr){
        cout << memerr;
        exit(MEMERR);
    }
    tree_size = 0;
    k = 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x3c(%rsp), %eax
movq %rax, 0x28(%rsp)
movl $0x30, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, 0x30(%rsp)
cmpq $0x0, %rax
je 0x41c9
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
imulq $0x30, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4740
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
addq $0x30, %rax
cmpq %rcx, %rax
movq %rax, 0x18(%rsp)
jne 0x41a2
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x41fb
movq 0x2deb(%rip), %rdi      # 0x6fd0
leaq 0xf65(%rip), %rsi       # 0x5151
callq 0x21f0
movl $0x1, %edi
callq 0x2290
movq 0x20(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: m0Mh42[P]mash/./src/mash.cpp
// Function: Mashtree::add_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Mashtree::add_node(const string& value){
    MashNode node;
    node.key = 0;
    node.value = value;
    node.occupied = true;
    for (uint i = 0; i <= tree_size; i++){
        if ((nodetree + i)->occupied == false){
            *(nodetree + i) = node;
            tree_size++;
            return true;
        }
    }
    return false;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4740
movw $0x0, 0x20(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2040
jmp 0x4259
movb $0x1, 0x48(%rsp)
movl $0x0, 0x10(%rsp)
movq (%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl (%rcx), %eax
ja 0x42ff
movq (%rsp), %rax
movq 0x20(%rax), %rax
movl 0x10(%rsp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movb 0x28(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x42ed
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x10(%rsp), %eax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rax, %rdi
leaq 0x20(%rsp), %rsi
callq 0x4770
jmp 0x42b9
movq (%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x1, 0x67(%rsp)
movl $0x1, 0xc(%rsp)
jmp 0x430c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3450
jmp 0x4321
jmp 0x42ef
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x4266
movb $0x0, 0x67(%rsp)
movl $0x1, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3450
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x23d0
nopl (%rax,%rax)