LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_generateSecret
XXH_PUBLIC_API XXH_errorcode
XXH3_generateSecret(void* secretBuffer, size_t secretSize, const void* customSeed, size_t customSeedSize)
{
#if (XXH_DEBUGLEVEL >= 1)
    XXH_ASSERT(secretBuffer != NULL);
    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);
#else
    /* production mode, assert() are disabled */
    if (secretBuffer == NULL) return XXH_ERROR;
    if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;
#endif

    if (customSeedSize == 0) {
        customSeed = XXH3_kSecret;
        customSeedSize = XXH_SECRET_DEFAULT_SIZE;
    }
#if (XXH_DEBUGLEVEL >= 1)
    XXH_ASSERT(customSeed != NULL);
#else
    if (customSeed == NULL) return XXH_ERROR;
#endif

    /* Fill secretBuffer with a copy of customSeed - repeat as needed */
    {   size_t pos = 0;
        while (pos < secretSize) {
            size_t const toCopy = XXH_MIN((secretSize - pos), customSeedSize);
            memcpy((char*)secretBuffer + pos, customSeed, toCopy);
            pos += toCopy;
    }   }

    {   size_t const nbSeg16 = secretSize / 16;
        size_t n;
        XXH128_canonical_t scrambler;
        XXH128_canonicalFromHash(&scrambler, XXH128(customSeed, customSeedSize, 0));
        for (n=0; n<nbSeg16; n++) {
            XXH128_hash_t const h128 = XXH128(&scrambler, sizeof(scrambler), n);
            XXH3_combine16((char*)secretBuffer + n*16, h128);
        }
        /* last segment */
        XXH3_combine16((char*)secretBuffer + secretSize - 16, XXH128_hashFromCanonical(&scrambler));
    }
    return XXH_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
testq %rdi, %rdi
sete %al
cmpq $0x88, %rsi
setb %dl
orb %al, %dl
movl $0x1, %eax
jne 0x44e6
testq %rcx, %rcx
movl $0xc0, %r13d
cmovneq %rcx, %r13
leaq 0x1c36(%rip), %rcx      # 0x6040
cmoveq %rcx, %r12
testq %r12, %r12
je 0x44e6
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x4448
xorl %ebp, %ebp
movq %rbx, %r15
subq %rbp, %r15
cmpq %r13, %r15
cmovaeq %r13, %r15
leaq (%r14,%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2120
addq %r15, %rbp
cmpq %rbx, %rbp
jb 0x4424
leaq 0x1bf1(%rip), %rcx      # 0x6040
leaq -0x36f(%rip), %r9       # 0x40e7
movl $0xc0, %r8d
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3ba2
bswapq %rdx
bswapq %rax
movq %rdx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
cmpq $0x10, %rbx
jb 0x44ca
movq %rbx, %r13
shrq $0x4, %r13
leaq 0x8(%r14), %rbp
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movl $0x10, %esi
movl $0xc0, %r8d
movq %r15, %rdi
movq %r12, %rdx
leaq 0x1b96(%rip), %rcx      # 0x6040
leaq -0x3ca(%rip), %r9       # 0x40e7
callq 0x3ba2
xorq %rax, -0x8(%rbp)
xorq %rdx, (%rbp)
incq %r12
addq $0x10, %rbp
cmpq %r12, %r13
jne 0x4492
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
bswapq %rax
bswapq %rcx
xorq %rcx, -0x10(%r14,%rbx)
xorq %rax, -0x8(%r14,%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_generateSecret_fromSeed
XXH_PUBLIC_API void
XXH3_generateSecret_fromSeed(void* secretBuffer, XXH64_hash_t seed)
{
    XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];
    XXH3_initCustomSecret(secret, seed);
    XXH_ASSERT(secretBuffer != NULL);
    memcpy(secretBuffer, secret, XXH_SECRET_DEFAULT_SIZE);
}

// Assembly:
subq $0xc8, %rsp
movl $0x8, %eax
leaq 0x1b38(%rip), %rcx      # 0x6040
movq -0x8(%rax,%rcx), %rdx
addq %rsi, %rdx
movq (%rax,%rcx), %r8
subq %rsi, %r8
movq %rdx, -0x8(%rsp,%rax)
movq %r8, (%rsp,%rax)
addq $0x10, %rax
cmpq $0xc8, %rax
jne 0x4508
movq %rsp, %rsi
movl $0xc0, %edx
callq 0x2120
addq $0xc8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_len_4to8_64b(unsigned char const*, unsigned long, unsigned char const*, unsigned long)
static xxh_u32 XXH_swap32 (xxh_u32 x)
{
    return  ((x << 24) & 0xff000000 ) |
            ((x <<  8) & 0x00ff0000 ) |
            ((x >>  8) & 0x0000ff00 ) |
            ((x >> 24) & 0x000000ff );
}

// Assembly:
movl %ecx, %eax
bswapl %eax
shlq $0x20, %rax
xorq %rcx, %rax
movl -0x4(%rdi,%rsi), %ecx
movq 0x10(%rdx), %r8
xorq 0x8(%rdx), %r8
subq %rax, %r8
movl (%rdi), %eax
shlq $0x20, %rax
orq %rcx, %rax
xorq %r8, %rax
movq %rax, %rcx
rolq $0x31, %rcx
movq %rax, %rdx
rolq $0x18, %rdx
xorq %rcx, %rdx
xorq %rax, %rdx
movabsq $-0x604de39ae16720db, %rax # imm = 0x9FB21C651E98DF25
imulq %rax, %rdx
movq %rdx, %rcx
shrq $0x23, %rcx
addq %rsi, %rcx
xorq %rdx, %rcx
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x1c, %rax
xorq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/sgielen[P]clife/./xxhash/xxhash.h
// Function: XXH3_len_1to3_64b(unsigned char const*, unsigned long, unsigned char const*, unsigned long)
XXH_FORCE_INLINE XXH_PUREF XXH64_hash_t
XXH3_len_1to3_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)
{
    XXH_ASSERT(input != NULL);
    XXH_ASSERT(1 <= len && len <= 3);
    XXH_ASSERT(secret != NULL);
    /*
     * len = 1: combined = { input[0], 0x01, input[0], input[0] }
     * len = 2: combined = { input[1], 0x02, input[0], input[1] }
     * len = 3: combined = { 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 combined = ((xxh_u32)c1 << 16) | ((xxh_u32)c2  << 24)
                               | ((xxh_u32)c3 <<  0) | ((xxh_u32)len << 8);
        xxh_u64 const bitflip = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed;
        xxh_u64 const keyed = (xxh_u64)combined ^ bitflip;
        return XXH64_avalanche(keyed);
    }
}

// Assembly:
movzbl (%rdi), %eax
movq %rsi, %r8
shrq %r8
movzbl -0x1(%rdi,%rsi), %r9d
shll $0x10, %eax
movzbl (%rdi,%r8), %edi
shll $0x18, %edi
shll $0x8, %esi
orl %esi, %eax
orl %edi, %eax
movl 0x4(%rdx), %esi
xorl (%rdx), %esi
addq %rcx, %rsi
orq %r9, %rax
movq %rsi, %rcx
shrq $0x21, %rcx
xorq %rsi, %rcx
xorq %rax, %rcx
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
imulq %rcx, %rax
movq %rax, %rcx
shrq $0x1d, %rcx
xorq %rax, %rcx
movabsq $0x165667b19e3779f9, %rdx # imm = 0x165667B19E3779F9
imulq %rcx, %rdx
movq %rdx, %rax
shrq $0x20, %rax
xorq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rsi
movaps 0xe6a(%rip), %xmm0      # 0x6130
movq %rsp, %rbx
movaps %xmm0, 0x30(%rbx)
movaps 0xe4c(%rip), %xmm0      # 0x6120
movaps %xmm0, 0x20(%rbx)
movaps 0xe31(%rip), %xmm0      # 0x6110
movaps %xmm0, 0x10(%rbx)
movaps 0xe16(%rip), %xmm0      # 0x6100
movaps %xmm0, (%rbx)
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x4efe
leaq 0xb(%r12), %rsi
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
imulq %r14, %rdx
movq %rbx, %rdi
callq 0x3b3c
movq %rax, %r13
leaq (%r12,%r15), %rsi
addq $-0x4b, %rsi
movabsq $-0x3d4d51c2d82b14b1, %rdx # imm = 0xC2B2AE3D27D4EB4F
imulq %r14, %rdx
notq %rdx
movq %rbx, %rdi
callq 0x3b3c
movq %rax, %rdx
movq %r13, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x64, %esi
ja 0x53ca
movq %rdi, %r14
cmpl $0x0, 0x18(%rdi)
jle 0x53c0
movl %esi, %ebx
xorl %r15d, %r15d
cmpl $0x0, 0x1c(%r14)
jle 0x53b7
movslq %r15d, %r12
xorl %r13d, %r13d
callq 0x2040
cltq
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
movslq 0x1c(%r14), %rcx
imulq %r12, %rcx
addq (%r14), %rcx
cmpl %ebx, %eax
setl (%r13,%rcx)
incq %r13
cmpl 0x1c(%r14), %r13d
jl 0x537b
incl %r15d
cmpl 0x18(%r14), %r15d
jl 0x536e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x2090
movq %rax, %rbx
leaq 0xdad(%rip), %rsi       # 0x618b
movq %rax, %rdi
callq 0x2070
movq 0x3c03(%rip), %rsi      # 0x8ff0
movq 0x3bcc(%rip), %rdx      # 0x8fc0
movq %rbx, %rdi
callq 0x2200
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x18(%rdi)
jle 0x54c7
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
movq 0x3b92(%rip), %r12      # 0x8fc8
cmpl $0x0, 0x1c(%r15)
jle 0x54bb
xorl %r13d, %r13d
movq %r15, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x57ee
shlb $0x7, %al
movb %al, 0x5(%rsp)
movl $0x1, %edx
movq %r12, %rdi
leaq 0x5(%rsp), %rsi
callq 0x2180
movq %r14, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x57ee
shlb $0x7, %al
movb %al, 0x6(%rsp)
movl $0x1, %edx
movq %r12, %rdi
leaq 0x6(%rsp), %rsi
callq 0x2180
movq %rbx, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x57ee
shlb $0x7, %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r12, %rdi
leaq 0x7(%rsp), %rsi
callq 0x2180
incl %r13d
cmpl 0x1c(%r15), %r13d
jl 0x5440
incl %ebp
cmpl 0x18(%r15), %ebp
jl 0x5436
movq 0x3afa(%rip), %rdi      # 0x8fc8
callq 0x20d0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sgielen[P]clife/./clife.hpp
// Function: GameOfLifeField<SimpleValue<(char)-128, (char)0>, true>::nextState()
void nextState() {
		std::vector<ValueType> new_field(width * height, ValueType());
		std::vector<ValueType> neighbors;
		for(int y = 0; y < height; ++y) {
			for(int x = 0; x < width; ++x) {
				neighbors.clear();
				neighbors_set(y, x, neighbors);
				int num = neighbors.size();
				bool set = is_set(y, x);
				if(set && (num == 2 || num == 3)) {
					new_field[y * width + x] = field[y * width + x];
					new_field[y * width + x].age_once();
				} else if(num == 3) {
					new_field[y * width + x] = ValueType(neighbors);
				}
			}
		}
		field = new_field;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movslq 0x1c(%rdi), %rax
movslq 0x18(%rdi), %rsi
imulq %rax, %rsi
leaq 0x10(%rsp), %r14
movb $0x0, (%r14)
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movq %r14, %rdx
callq 0x579c
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
cmpl $0x0, 0x18(%rbx)
jle 0x560e
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
cmpl $0x0, 0x1c(%rbx)
jle 0x5601
movslq %r14d, %rbp
xorl %r13d, %r13d
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x555c
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movl %r14d, %esi
movl %r13d, %edx
movq %r15, %rcx
callq 0x5860
movl 0x18(%rsp), %r12d
subl 0x10(%rsp), %r12d
movq %rbx, %rdi
movl %r14d, %esi
movl %r13d, %edx
callq 0x57ee
movl %r12d, %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
setne %cl
xorb $0x1, %al
orb %cl, %al
jne 0x55b7
movl 0x1c(%rbx), %eax
imull %r14d, %eax
cltq
movq (%rbx), %rcx
addq %rax, %rcx
addq 0x28(%rsp), %rax
movb (%r13,%rcx), %cl
movb %cl, (%r13,%rax)
jmp 0x55f4
cmpl $0x3, %r12d
jne 0x55f4
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x5716
movslq 0x1c(%rbx), %rax
imulq %rbp, %rax
addq 0x28(%rsp), %rax
movb $0x1, (%r13,%rax)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x55f4
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
incq %r13
cmpl 0x1c(%rbx), %r13d
jl 0x554b
incl %r14d
cmpl 0x18(%rbx), %r14d
jl 0x553b
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x59dc
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5632
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5649
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x565e
jmp 0x565e
jmp 0x565e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5678
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x568f
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
callq 0x5c52
movq %rax, 0x8(%rsp)
movq (%rbx), %rcx
movq 0x8(%rbx), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
je 0x56eb
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %edi, %edi
cmpq %rax, (%rcx,%rdi,8)
je 0x56e0
incq %rdi
cmpq %rdi, %rdx
jne 0x56d0
jmp 0x56eb
movb $0x1, (%r15)
movl $0xa, (%r14)
cmpq 0x10(%rbx), %rsi
je 0x56fe
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x570b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5d70
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
movl 0x18(%rdi), %ecx
movl 0x1c(%rdi), %esi
leal (%rcx,%r12), %eax
decl %eax
cltd
idivl %ecx
movl %edx, %r8d
leal (%rsi,%r15), %eax
decl %eax
cltd
idivl %esi
movl %edx, %ecx
movq %rbx, %rsi
movl %r8d, %edx
callq 0x5a9e
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %esi
leal (%rcx,%r12), %eax
decl %eax
cltd
idivl %ecx
movl %edx, %r8d
leal (%rsi,%r15), %eax
cltd
idivl %esi
movl %edx, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %r8d, %edx
callq 0x5a9e
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %esi
leal (%rcx,%r12), %eax
decl %eax
cltd
idivl %ecx
movl %edx, %r8d
leal (%rsi,%r15), %eax
incl %eax
cltd
idivl %esi
movl %edx, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %r8d, %edx
callq 0x5a9e
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %esi
leal (%rcx,%r12), %eax
cltd
idivl %ecx
movl %edx, %r8d
leal (%rsi,%r15), %eax
decl %eax
cltd
idivl %esi
movl %edx, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %r8d, %edx
callq 0x5a9e
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %esi
movl %r12d, %eax
addl %ecx, %eax
cltd
idivl %ecx
movl %edx, %r8d
leal (%rsi,%r15), %eax
incl %eax
cltd
idivl %esi
movl %edx, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %r8d, %edx
callq 0x5a9e
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %esi
leal (%rcx,%r12), %eax
incl %eax
cltd
idivl %ecx
movl %edx, %r8d
leal (%rsi,%r15), %eax
decl %eax
cltd
idivl %esi
movl %edx, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %r8d, %edx
callq 0x5a9e
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %esi
leal (%rcx,%r12), %eax
incl %eax
cltd
idivl %ecx
movl %edx, %r8d
movl %r15d, %eax
addl %esi, %eax
cltd
idivl %esi
movl %edx, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %r8d, %edx
callq 0x5a9e
movl 0x18(%r14), %ecx
movl 0x1c(%r14), %esi
leal (%rcx,%r12), %eax
incl %eax
cltd
idivl %ecx
movl %edx, %r8d
leal (%rsi,%r15), %eax
incl %eax
cltd
idivl %esi
movl %edx, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %r8d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5a9e
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
andq $-0x40, %rsp
subq $0x2c0, %rsp            # imm = 0x2C0
xorps %xmm0, %xmm0
movaps %xmm0, 0x240(%rsp)
xorl %eax, %eax
movq %rax, 0x250(%rsp)
movl $0x85ebca77, %ecx       # imm = 0x85EBCA77
leaq 0x3cc6e3c6(%rcx), %rdx
movq %rdx, 0x40(%rsp)
movabsq $-0x61c8864e7a143579, %rdx # imm = 0x9E3779B185EBCA87
movq %rdx, 0x48(%rsp)
movabsq $-0x3d4d51c2d82b14b1, %rdx # imm = 0xC2B2AE3D27D4EB4F
movq %rdx, 0x50(%rsp)
movabsq $0x165667b19e3779f9, %rdx # imm = 0x165667B19E3779F9
movq %rdx, 0x58(%rsp)
movabsq $-0x7a1435883d4d519d, %rdx # imm = 0x85EBCA77C2B2AE63
movq %rdx, 0x60(%rsp)
movq %rcx, 0x68(%rsp)
movabsq $0x27d4eb2f165667c5, %rdx # imm = 0x27D4EB2F165667C5
movq %rdx, 0x70(%rsp)
addq $0x184baf3a, %rcx       # imm = 0x184BAF3A
movq %rcx, 0x78(%rsp)
movq %rax, 0x268(%rsp)
movl $0x0, 0x244(%rsp)
leaq 0x33c(%rip), %rax       # 0x6040
movq %rax, 0x278(%rsp)
movq $0x80, 0x260(%rsp)
movq $0x10, 0x258(%rsp)
movq (%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r15
je 0x5d59
leaq 0x40(%rsp), %rbx
leaq 0x3f(%rsp), %r14
movb (%r15), %al
movb %al, 0x3f(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3533
incq %r15
cmpq %r12, %r15
jne 0x5d3a
leaq 0x40(%rsp), %rdi
callq 0x3912
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0x22c0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
jne 0x2543
leaq 0x18(%rsp), %r12
movsbl %bpl, %ebp
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r12, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2300
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4308
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2533
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
je 0x24f1
movq 0x7a6e(%rip), %rsi      # 0x9fb8
leaq 0x28(%rsp), %rdi
callq 0x2170
leaq 0xa8(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x258e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x4346
movq 0x7a1b(%rip), %rsi      # 0x9fb8
leaq 0x28(%rsp), %rdi
callq 0x2170
leaq 0xa8(%rsp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0x2626
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x2629
movzwl 0x8(%r14), %eax
cmpw 0x8(%rbx), %ax
jne 0x2629
movl 0xc(%r14), %eax
cmpl 0xc(%rbx), %eax
jne 0x2629
movq 0x18(%r14), %rdx
cmpq 0x18(%rbx), %rdx
jne 0x2629
testq %rdx, %rdx
je 0x2608
movq 0x10(%rbx), %rsi
movq 0x10(%r14), %rdi
callq 0x2210
testl %eax, %eax
jne 0x2629
movb 0x30(%r14), %al
cmpb 0x30(%rbx), %al
jne 0x2629
movl 0x34(%r14), %eax
cmpl 0x34(%rbx), %eax
jne 0x2629
movl 0x38(%r14), %eax
cmpl 0x38(%rbx), %eax
sete %al
jmp 0x262b
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rsi
cmpq %rsi, 0x8(%r14)
je 0x26e6
leaq 0x18(%rsp), %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
addq %rbp, %rsi
movq %r15, %rdi
movl $0x2c, %edx
callq 0x43a2
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2080
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x26af
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
incq %r12
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x6, %rax
cmpq %rax, %r12
je 0x26cf
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x6, %rax
addq $0x40, %rbp
cmpq %r12, %rax
ja 0x2676
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26fa
movq %rax, %r14
jmp 0x2719
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2719
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x2731
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5cd8
movq %rsp, %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x249c
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x2797
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2200
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x2852
leaq 0x28(%rsp), %r12
movl $0x8, %ebp
xorl %r13d, %r13d
leaq 0x18(%rsp), %r14
leaq 0x58(%rsp), %r15
movq %r12, 0x18(%rsp)
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x5cd8
movq %r15, %rdi
movq %r14, %rsi
movl $0x2c, %edx
callq 0x555e
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x280b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
movq %r15, %rsi
callq 0x59b2
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x2832
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2200
incq %r13
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %rbp
cmpq %r13, %rcx
ja 0x27cb
movq %rsp, %rdi
callq 0x4346
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x28d3
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x28d3
movq %rax, %r14
jmp 0x28c3
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x28c3
movq 0x28(%rsp), %rsi
jmp 0x28bb
movq %rax, %r14
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x28c3
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x5a18
movq %rsp, %rdi
callq 0x4346
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O1/CMU-SAFARI[P]optimal-seed-solver/RefDB.cc
// Function: RefDB::loadChromo(int)
bool RefDB::loadChromo(int chromoNum) {
	if (curChromoNum == chromoNum)
			return true;

	curChromoNum = chromoNum;

	cout << "RefDB loading chromosome: " << chromoNum << endl;

	if (chromoNum >= refPos.size())
		return false;

	chromosome.clear();
	refFile.clear();
	refFile.seekg(refPos[chromoNum]);

	getline(refFile, chromoName);

	string temp;

	while (refFile.good() && (temp.size() == 0 || temp[0] != '<')) {
		chromosome.append(temp);
		getline(refFile, temp);
		if (temp[0] == '>') {
			cout << "stop!" << endl;
			break;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movb $0x1, %bl
cmpl %esi, 0x260(%rdi)
je 0x2ef7
movl %esi, %ebp
movq %rdi, %r14
movl %esi, 0x260(%rdi)
movq 0x3286(%rip), %r15      # 0x5fd0
leaq 0x134a(%rip), %rsi      # 0x409b
movl $0x1a, %edx
movq %r15, %rdi
callq 0x2240
movq %r15, %rdi
movl %ebp, %esi
callq 0x2310
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movslq %ebp, %r12
movq 0x210(%r14), %rax
subq 0x208(%r14), %rax
sarq $0x4, %rax
cmpq %r12, %rax
jbe 0x2ef5
leaq 0x240(%r14), %r15
xorl %ebp, %ebp
movq %rbp, 0x248(%r14)
movq 0x240(%r14), %rax
movb %bpl, (%rax)
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x2300
movq 0x208(%r14), %rax
shlq $0x4, %r12
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %r14, %rdi
callq 0x2280
leaq 0x220(%r14), %r12
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2350
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rbp, -0x8(%r13)
movb %bpl, (%r13)
leaq 0x8(%rsp), %r12
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
jne 0x2edc
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x2e5d
movq 0x8(%rsp), %rax
cmpb $0x3c, (%rax)
je 0x2edc
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x20b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2350
movq 0x8(%rsp), %rax
cmpb $0x3e, (%rax)
jne 0x2e36
movq 0x3133(%rip), %r14      # 0x5fd0
leaq 0x1212(%rip), %rsi      # 0x40b6
movl $0x5, %edx
movq %r14, %rdi
callq 0x2240
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x3101(%rip), %rdi      # 0x5fd0
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ef7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x2ef7
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f0a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2f24
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %r14d
movq %rdi, %rbx
movl %edx, %edx
movq 0x248(%rsi), %rax
cmpq %rdx, %rax
jbe 0x3056
movq %rsi, %r15
addq $0x240, %rsi            # imm = 0x240
addl %ecx, %r14d
movl %ecx, %ecx
cmpq %r14, %rax
jae 0x3074
leaq 0x20(%rsp), %rdi
callq 0x2200
subq 0x248(%r15), %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsp, %rdi
movq %r14, %rsi
movl $0x4e, %edx
callq 0x2250
leaq 0x30(%rsp), %r14
movq -0x10(%r14), %rcx
movq -0x8(%r14), %r8
movq 0x8(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %esi
cmpq %r14, %rcx
je 0x302c
movq 0x30(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x3046
movl $0xf, %esi
cmpq %r15, (%rsp)
je 0x3041
movq 0x10(%rsp), %rsi
cmpq %rsi, %rax
jbe 0x307e
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x20b0
jmp 0x308a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1036(%rip), %rdx      # 0x409a
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x27f0
jmp 0x30f8
movq %rbx, %rdi
callq 0x2200
jmp 0x30f8
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2220
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x30a9
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x30af
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x30e1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x30f8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3123
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x3123
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x313e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/jamesgrimmett[P]orbital_determination/ex10-1_linear_least_squares.cc
// Function: inverse(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>)
std::vector<std::vector<double> > inverse(std::vector<std::vector<double> > arr_) {
  // Calculate the inverse of a 2x2 matrix

  int i, j;
  // tmp variable to store matrix elements
  std::vector<std::vector<double> > inv_ = arr_;
  
  double det_ = determinant(arr_);

  inv_[0][0] = arr_[1][1];
  inv_[1][1] = arr_[0][0];
  inv_[0][1] = -arr_[1][0];
  inv_[1][0] = -arr_[0][1];


  for ( i = 0; i < 2; i++ ) {
    for ( j = 0; j < 2; j++ ) {
      inv_[i][j] = inv_[i][j] / det_;
    }
  }

  return inv_;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1d3a
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x1d3a
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq (%rax), %rcx
movq 0x18(%rax), %rax
movsd (%rax), %xmm0
mulsd 0x8(%rcx), %xmm0
movsd (%rcx), %xmm1
mulsd 0x8(%rax), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x1dd4
movq (%r14), %rcx
movq 0x18(%rcx), %rdx
movsd 0x8(%rdx), %xmm0
movq (%rbx), %rax
movq (%rax), %rsi
movsd %xmm0, (%rsi)
movq (%rcx), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rax), %rdi
movsd %xmm0, 0x8(%rdi)
movsd (%rdx), %xmm0
movapd 0x157d(%rip), %xmm1     # 0x3020
xorpd %xmm1, %xmm0
movlpd %xmm0, 0x8(%rsi)
movsd 0x8(%rcx), %xmm0
xorpd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm1
movlpd %xmm0, (%rdi)
xorl %ecx, %ecx
leaq (%rcx,%rcx,2), %rdx
movq (%rax,%rdx,8), %rdx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq $0x1, %rsi
je 0x1acb
leaq 0x1(%rcx), %rdx
testq %rcx, %rcx
movq %rdx, %rcx
je 0x1ac1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1dd4
movq %r14, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O1/jamesgrimmett[P]orbital_determination/ex10-1_linear_least_squares.cc
// Function: dot_product(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>, std::vector<double, std::allocator<double>>)
std::vector<double> dot_product(std::vector<std::vector<double> > a_, 
                                  std::vector<double> b_) {
  // calculate the dot production of a 2x2 matrix with a 1x2 vector
                          
  std::vector<double> result_ = {0.0, 0.0};
  std::vector<double> a0_ = {a_[0][0], a_[0][1]};
  std::vector<double> a1_ = {a_[1][0], a_[1][1]};

  result_[0] = std::inner_product(a0_.begin(),a0_.end(),b_.begin(),0.0);
  result_[1] = std::inner_product(a1_.begin(),a1_.end(),b_.begin(),0.0);

  return result_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x30(%rsp), %r12
movl $0x2, %edx
movq %r12, %rcx
callq 0x1caa
movq (%r15), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%r12)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%r12)
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x48(%rsp), %rcx
movl $0x2, %edx
callq 0x1caa
movq (%r15), %rax
movq 0x18(%rax), %rax
movsd (%rax), %xmm0
leaq 0x48(%rsp), %rsi
movsd %xmm0, (%rsi)
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsi)
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x2, %edx
callq 0x1caa
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq (%r14), %rax
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
cmpq %rdx, %rcx
je 0x1bda
movq %rax, %rsi
movsd (%rcx), %xmm2
mulsd (%rsi), %xmm2
addsd %xmm2, %xmm1
addq $0x8, %rcx
addq $0x8, %rsi
cmpq %rdx, %rcx
jne 0x1bc1
movq (%rbx), %rcx
movsd %xmm1, (%rcx)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
cmpq %rdx, %rdi
je 0x1c10
xorpd %xmm0, %xmm0
movq %rdi, %rsi
movsd (%rsi), %xmm1
mulsd (%rax), %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rsi
addq $0x8, %rax
cmpq %rdx, %rsi
jne 0x1bf7
movsd %xmm0, 0x8(%rcx)
testq %rdi, %rdi
je 0x1c27
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c3e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c6c
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
jmp 0x1c6c
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1c80
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x10d0
movq %r14, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2dd3(%rip), %rbx      # 0x3fd0
leaq 0xe00(%rip), %rsi       # 0x2004
movl $0x12, %edx
movq %rbx, %rdi
callq 0x1080
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
leaq -0x20(%rbp), %r14
movl %eax, (%r14)
leaq -0x1c(%rbp), %r15
movl %eax, (%r15)
movq 0x2d91(%rip), %rdi      # 0x3fe0
movq %r14, %rsi
callq 0x1040
movq %rax, %rdi
movq %r15, %rsi
callq 0x1040
leaq 0xdae(%rip), %rsi       # 0x2017
movl $0xb, %edx
movq %rbx, %rdi
callq 0x1080
movl (%r14), %esi
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rbx
leaq 0xd98(%rip), %rsi       # 0x2023
movl $0x5, %edx
movq %rax, %rdi
callq 0x1080
movl (%r15), %esi
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rbx
leaq 0xd7c(%rip), %rsi       # 0x2029
movl $0x4, %edx
movq %rax, %rdi
callq 0x1080
movl (%r15), %esi
addl (%r14), %esi
movq %rbx, %rdi
callq 0x10a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
addq %rsi, %rsi
callq 0x22b0
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x258a
movq (%r14), %r14
xorl %r13d, %r13d
leaq 0x1bf6(%rip), %rbp      # 0x4150
movzbl (%r14,%r13), %r15d
movl %r15d, %eax
shrl $0x4, %eax
movsbl (%rax,%rbp), %esi
movq %rbx, %rdi
callq 0x2150
andl $0xf, %r15d
movsbl (%r15,%rbp), %esi
movq %rbx, %rdi
callq 0x2150
incq %r13
cmpq %r13, %r12
jne 0x255a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x259e
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x25b9
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21e0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movzbl 0x3be9(%rip), %eax      # 0x61b2
movq (%rdi), %rsi
testq %rax, %rax
je 0x263a
cmpb $0x30, (%rsi)
jne 0x2638
leaq -0x1(%rax), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x25f4
leaq 0x1(%rdx), %r8
cmpb $0x30, 0x1(%rsi,%rdx)
movq %r8, %rdx
je 0x25dc
cmpq %rax, %r8
jb 0x2638
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x39d6(%rip), %rdi      # 0x5fd8
callq 0x2200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movb $0x0, 0x3b7b(%rip)      # 0x61b3
popq %rbx
retq
movq 0x8(%rdi), %rdx
movq 0x3993(%rip), %rdi      # 0x5fd8
callq 0x2200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movl $0x7a120, %edi          # imm = 0x7A120
popq %rbx
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x33e0
movl $0x1f, %eax
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movb (%rdx,%rax), %sil
xorb %sil, (%rdx,%rcx)
incq %rcx
decq %rax
cmpq $0x10, %rcx
jne 0x336e
movzwl (%rbx), %eax
movw %ax, (%r14)
leaq 0x18(%r14), %rcx
movq %rcx, 0x8(%r14)
movq 0x8(%rbx), %rdx
leaq 0x18(%rbx), %rax
cmpq %rax, %rdx
je 0x33af
movq %rdx, 0x8(%r14)
movq (%rax), %rcx
movq %rcx, 0x18(%r14)
jmp 0x33b5
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%r14)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movb 0x28(%rbx), %al
movb %al, 0x28(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
callq 0x20a0
movb %al, (%r14)
movq 0x8(%rbx), %rax
xorb $0x33, (%rax,%r15)
movb (%r14), %al
movq 0x8(%rbx), %rcx
xorb %al, (%rcx,%r15)
incq %r15
cmpq $0x20, %r15
jne 0x33ee
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r15d
movq %r15, %r14
shlq $0x4, %r14
leaq (%r14,%r14,2), %rdi
addq $0x8, %rdi
callq 0x2030
movq %r15, (%rax)
leaq 0x8(%rax), %rcx
testl %ebp, %ebp
je 0x34ab
addq $0x20, %rax
leaq (%r14,%r14,2), %rdx
xorl %esi, %esi
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb %sil, (%rax)
movb %sil, 0x10(%rax)
addq $0x30, %rax
addq $-0x30, %rdx
jne 0x348e
movq %rcx, 0x20(%rbx)
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
xorl %eax, %eax
movb %al, (%r15)
movb %al, 0x10(%r15)
movw $0x0, -0x18(%r15)
movq %r14, %rdi
callq 0x20f0
movb $0x1, 0x28(%rsp)
movq 0x20(%rbx), %r12
cmpb $0x0, 0x28(%r12)
je 0x3538
movl (%rbx), %eax
movl $0x1, %ecx
cmpl %eax, %ecx
setbe %bpl
ja 0x355c
movl %ecx, %edx
leaq (%rdx,%rdx,2), %rdx
shlq $0x4, %rdx
incl %ecx
cmpb $0x0, 0x28(%r12,%rdx)
jne 0x3517
addq %rdx, %r12
jmp 0x353b
movb $0x1, %bpl
movzwl (%rsp), %eax
movw %ax, (%r12)
leaq 0x8(%r12), %rdi
movq %r14, %rsi
callq 0x20f0
movb 0x28(%rsp), %al
movb %al, 0x28(%r12)
incl (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3573
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3584
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x359e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/m0Mh42[P]mash/./src/mash.cpp
// Function: Mashtree::mash_k_matching_nodes()
void Mashtree::mash_k_matching_nodes(){
    for (uint i = 0; i < tree_size; i++){
    for (uint n = 0; n < tree_size; n++){
        if (i == n)
            continue;
        if ((nodetree + i)->occupied && (nodetree + n)->occupied){
            if ((nodetree + i)->key == (nodetree + n)->key){
                mash.xor_random(*(nodetree + i));
                mash.xor_random(*(nodetree + n));
                mash.xor_chunks(*(nodetree + i), *(nodetree + n));
                (nodetree + i)->key += 1;
                (nodetree + n)->occupied = false;
                i = 0;
                n = 0;
            }
        }
    }
    }
}

// Assembly:
cmpl $0x0, (%rdi)
je 0x369a
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorl %eax, %eax
cmpl $0x0, (%rbx)
je 0x3687
xorl %ecx, %ecx
cmpl %ecx, %eax
je 0x367d
movq 0x20(%rbx), %rdx
movl %eax, %esi
leaq (%rsi,%rsi,2), %r15
shlq $0x4, %r15
cmpb $0x1, 0x28(%rdx,%r15)
jne 0x367d
movl %ecx, %r13d
leaq (,%r13,2), %r12
addq %r13, %r12
shlq $0x4, %r12
cmpb $0x1, 0x28(%rdx,%r12)
jne 0x367d
leaq (%rdx,%r15), %rsi
addq %r12, %rdx
movzwl (%rsi), %edi
cmpw (%rdx), %di
jne 0x367d
movq %r14, %rdi
callq 0x33e0
shlq $0x4, %r13
leaq (%r13,%r13,2), %r13
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x33e0
movq 0x20(%rbx), %rcx
leaq (%rcx,%r15), %rax
addq $0x8, %rax
addq %r13, %rcx
addq $0x8, %rcx
xorl %edx, %edx
movq (%rax), %rsi
xorb $0x33, (%rsi,%rdx)
movq (%rcx), %rsi
movb (%rsi,%rdx), %sil
movq (%rax), %rdi
xorb %sil, (%rdi,%rdx)
incq %rdx
cmpq $0x20, %rdx
jne 0x364c
movq 0x20(%rbx), %rax
incw (%rax,%r15)
movb $0x0, 0x28(%rax,%r12)
xorl %eax, %eax
xorl %ecx, %ecx
incl %ecx
cmpl (%rbx), %ecx
jb 0x35cc
incl %eax
cmpl (%rbx), %eax
jb 0x35c1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/m0Mh42[P]mash/./src/file.cpp
// Function: File::open_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void File::open_file(string filename){
    if(file.is_open()){
        file.close();
    }
    if (file.is_open() == false){
        file.open(filename, ios::binary);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x10(%rdi), %r14
addq $0x88, %r15
movq %r15, %rdi
callq 0x2080
testb %al, %al
je 0x386a
movq %r14, %rdi
callq 0x2070
movq %r15, %rdi
callq 0x2080
testb %al, %al
je 0x387c
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
movl $0x4, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x2160
nop