LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/justinpajak[P]Sum_SGX/aggsum.cpp
// Function: readAndDecrypt(std::vector<float, std::allocator<float>>&)
void readAndDecrypt(vector<float>& nums) {
	int enc_data = open("enc.txt", O_RDONLY);
	if (!enc_data) {
		fprintf(stderr, "Unable to open file: %s\n", strerror(errno));
		return;
	}
	unsigned char ciphertext[128];
	unsigned char *key = (unsigned char *)"01234567890123456789012345678901";
    unsigned char *iv = (unsigned char *)"0123456789012345";
	while(read(enc_data, (char*)ciphertext, 128)) {
		unsigned char plaintext[128];
		int plaintext_len = decrypt(ciphertext, 32, key, iv, plaintext);
		plaintext[plaintext_len] = '\0';
		nums.push_back(atof((const char*)plaintext));
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
leaq 0xb95(%rip), %rdi       # 0x2023
xorl %esi, %esi
xorl %eax, %eax
callq 0x1100
testl %eax, %eax
je 0x151f
movl %eax, %r14d
leaq -0x130(%rbp), %r15
leaq -0xb0(%rbp), %r13
leaq -0x2c(%rbp), %r12
movl $0x80, %edx
movl %r14d, %edi
movq %r15, %rsi
callq 0x11a0
testq %rax, %rax
je 0x150d
movq %r15, %rdi
pushq $0x20
popq %rsi
leaq 0xb6e(%rip), %rdx       # 0x2044
leaq 0xb88(%rip), %rcx       # 0x2065
movq %r13, %r8
callq 0x1583
cltq
movb $0x0, -0xb0(%rbp,%rax)
movq %r13, %rdi
callq 0x1180
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17fe
jmp 0x14b4
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2ab2(%rip), %rax      # 0x3fd8
movq (%rax), %rbx
callq 0x1030
movl (%rax), %edi
callq 0x1070
leaq 0xaef(%rip), %rsi       # 0x202b
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_cpp_makefile_star2_O2/justinpajak[P]Sum_SGX/aggsum.cpp
// Function: agg_sum(std::vector<float, std::allocator<float>>)
double agg_sum(vector<float> nums) {
	double sum;
	for (int i = 0; i < nums.size(); i++) {
		sum += nums[i];
	}
	return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x1581
cvtss2sd (%rax,%rdx,4), %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x156e
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]yalz77/./lz77.h
// Function: lz77::push_vlq_uint(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline void push_vlq_uint(size_t n, std::string& out) {

    while (1) {
        unsigned char c = n & 0x7F;
        size_t q = n >> 7;

        if (q == 0) {
            out += c;
            break;
        }

        out += (c | 0x80);
        n = q;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x80, %rdi
jb 0x2e59
movq %rdi, %r14
shrq $0x7, %r14
orb $-0x80, %dil
movsbl %dil, %esi
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
jmp 0x2e34
movsbl %dil, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]yalz77/./lz77.h
// Function: lz77::offsets_dict_t::operator()(unsigned short, unsigned char const*, unsigned char const*, unsigned char const*, unsigned long&, unsigned long&, unsigned long&)
void operator()(uint16_t packed, const unsigned char* i0, const unsigned char* i, const unsigned char* e,
                    size_t& maxrun, size_t& maxoffset, size_t& maxgain) {

        // Select a range of values representing a circular buffer.
        // The first value is the index of the buffer head, the rest are
        // the values of the buffer itself. 

        size_t* cb_start = &offsets[packed * (searchlen + 1)];

        size_t* cb_beg = (cb_start + 1);
        size_t* cb_end = (cb_start + 1 + searchlen);
        size_t* cb_head = cb_beg + *cb_start;

        size_t* cb_i = cb_head;

        while (1) {

            cb_i = prev(cb_beg, cb_end, cb_i);

            if (*cb_i == 0)
                break;

            // The stored value is position + 1 to allow 0 to mean 'uninitialized offset'.
            size_t pos = *cb_i - 1;

            size_t offset = i - i0 - pos;
            size_t run = substr_run(i, e, i0 + pos, e);
            size_t gain = gains(run, offset);

            if (gain > maxgain) {
                maxrun = run;
                maxoffset = offset;
                maxgain = gain;
            }

            if (cb_i == cb_head)
                break;
        }

        *cb_start = push_back(cb_beg, cb_end, cb_head, i - i0 + 1);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x28(%rsp)
movq %r8, %r12
movq %rcx, %rbx
movl %esi, %eax
movq (%rdi), %rcx
movq 0x18(%rdi), %r8
leaq 0x1(%r8), %rsi
imulq %rax, %rsi
leaq (%rcx,%rsi,8), %rdi
leaq (%rcx,%rsi,8), %rax
addq $0x8, %rax
leaq 0x8(%rdi,%r8,8), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq -0x8(%rax), %rax
movq %rdi, 0x20(%rsp)
leaq 0x8(%rdi,%rax,8), %r14
movq %rdx, 0x8(%rsp)
leaq -0x1(%rdx), %rax
movq %rax, 0x30(%rsp)
movq %r14, %r15
cmpq 0x18(%rsp), %r15
cmoveq 0x10(%rsp), %r15
movq -0x8(%r15), %rdx
testq %rdx, %rdx
je 0x2f88
movq 0x8(%rsp), %rax
addq %rdx, %rax
negq %rax
leaq (%rbx,%rax), %r13
incq %r13
addq 0x30(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r12, %rcx
callq 0x3125
movq %rax, %rbp
movq %rax, %rdi
movq %r13, %rsi
callq 0x314f
movq 0x78(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x2f7f
movq 0x28(%rsp), %rcx
movq %rbp, (%rcx)
movq 0x70(%rsp), %rcx
movq %r13, (%rcx)
movq 0x78(%rsp), %rcx
movq %rax, (%rcx)
addq $-0x8, %r15
cmpq %r14, %r15
jne 0x2f16
subq 0x8(%rsp), %rbx
incq %rbx
movq %rbx, (%r14)
addq $0x8, %r14
cmpq 0x10(%rsp), %r14
movq 0x18(%rsp), %rax
cmoveq %rax, %r14
subq %rax, %r14
sarq $0x3, %r14
movq 0x20(%rsp), %rax
movq %r14, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]yalz77/./lz77.h
// Function: lz77::fnv32a(unsigned char const*, unsigned long, unsigned int)
inline uint32_t fnv32a(const unsigned char* i, size_t len, uint32_t hash = 0x811c9dc5) {

    while (len > 0) {
        hash ^= (uint32_t)(*i);
        hash *= (uint32_t)0x01000193;
        ++i;
        --len;
    }

    return hash;
}

// Assembly:
movl %edx, %eax
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x3124
movzbl (%rdi,%rcx), %edx
xorl %edx, %eax
imull $0x1000193, %eax, %eax  # imm = 0x1000193
incq %rcx
jmp 0x310e
retq
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]yalz77/./lz77.h
// Function: lz77::gains(unsigned long, unsigned long)
inline size_t gains(size_t run, size_t offset) {
    // Note: this function uses knowledge about the layout of bits in the compressed data format.
    
    size_t gain = run;
    
    offset = offset << (SHORTRUN_BITS + 1);

    size_t loss = vlq_length(offset);
    
    if (run >= SHORTRUN_MAX) {
        loss += vlq_length(run - MIN_RUN + 1);
    }

    if (loss > gain)
        return 0;

    return gain - loss;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
shlq $0x4, %rsi
movq %rsi, %rdi
callq 0x3188
movq %rax, %r14
cmpq $0x8, %rbx
jb 0x3177
leaq -0x4(%rbx), %rdi
callq 0x3188
addq %rax, %r14
xorl %eax, %eax
subq %r14, %rbx
cmovaeq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ivan-tkatchev[P]yalz77/./lz77.h
// Function: lz77::decompress_t::pop_vlq_uint(unsigned char const*&, unsigned char const*, unsigned long&)
bool pop_vlq_uint(const unsigned char*& i, const unsigned char* e, size_t& res) {

        while (1) {

            if (i == e)
                return false;

            size_t c = *i;

            if ((c & 0x80) == 0) {
                state.vlq_num |= (c << state.vlq_off);
                break;
            }

            state.vlq_num |= ((c & 0x7F) << state.vlq_off);
            state.vlq_off += 7;
            ++i;
        }

        res = state.vlq_num;
        state.vlq_num = 0;
        state.vlq_off = 0;

        return true;
    }

// Assembly:
movq %rcx, %rax
movq (%rsi), %r8
leaq 0x50(%rdi), %r9
movq 0x50(%rdi), %r10
movq 0x58(%rdi), %rcx
cmpq %rdx, %r8
je 0x31fa
movzbl (%r8), %r11d
testb %r11b, %r11b
jns 0x31ea
andl $0x7f, %r11d
shlq %cl, %r11
orq %r11, %r10
movq %r10, 0x50(%rdi)
addq $0x7, %rcx
movq %rcx, 0x58(%rdi)
incq %r8
movq %r8, (%rsi)
jmp 0x31be
shlq %cl, %r11
orq %r11, %r10
movq %r10, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r9)
cmpq %rdx, %r8
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/murry2018[P]mogazi/kakaotalk_chat.cpp
// Function: kakaotalk::chat::chat(std::istream&)
chat::chat(istream& in) {
    if (in) {
      string s;
      int c;
      while (in && (c = in.get()) != '\r')
        s.push_back(c);
      c = in.get(); // eliminate '\n'
      if (!(c == '\n' || c == EOF))
        throw runtime_error("Unexpected File Format");
      full_content = s;
      analyse();
    } else {
      throw domain_error("End of File");
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
movb %al, 0x58(%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsi,%rax)
jne 0x5b21
movq %rsi, %r14
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x38(%rbp), %r15
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
jne 0x5ae7
movq %r14, %rdi
callq 0x4390
cmpl $0xd, %eax
je 0x5ae7
movsbl %al, %esi
movq %r15, %rdi
callq 0x4290
jmp 0x5abe
movq %r14, %rdi
callq 0x4390
cmpl $-0x1, %eax
je 0x5af9
cmpl $0xa, %eax
jne 0x5b53
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x41b0
movq %rbx, %rdi
callq 0x5bd6
leaq -0x38(%rbp), %rdi
callq 0x4538
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4170
movq %rax, %r15
leaq 0xe6ac(%rip), %rsi      # 0x141df
movq %rax, %rdi
callq 0x4200
movq 0x19436(%rip), %rsi     # 0x1ef78
movq 0x19447(%rip), %rdx     # 0x1ef90
movq %r15, %rdi
callq 0x4480
jmp 0x5b83
pushq $0x10
popq %rdi
callq 0x4170
movq %rax, %r15
leaq 0xe663(%rip), %rsi      # 0x141c8
movq %rax, %rdi
callq 0x4100
movq 0x1947c(%rip), %rsi     # 0x1eff0
movq 0x1941d(%rip), %rdx     # 0x1ef98
movq %r15, %rdi
callq 0x4480
movq %rax, %r14
movq %r15, %rdi
callq 0x4260
jmp 0x5ba7
movq %rax, %r14
jmp 0x5bb0
movq %rax, %r14
movq %r15, %rdi
callq 0x4260
jmp 0x5bb0
jmp 0x5ba4
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4538
leaq 0x28(%rbx), %r15
leaq 0x48(%rbx), %rdi
callq 0x4538
movq %r15, %rdi
callq 0x4538
movq %rbx, %rdi
callq 0x4538
movq %r14, %rdi
callq 0x44b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Albuso0[P]entropy/entropy.cpp
// Function: Entropy::estimate() const
double Entropy::estimate() const 
{
    double HEsti = 0;
    int symbolnumber = 0;
    for ( const auto & pair : fin )
    {
        int N = pair.first;
        symbolnumber += pair.second;
        if ( N > N_thr) // plug-in
        {
            double x = (double)N / (double)n;
            HEsti += (-x*log(x)+0.5/n) * (pair.second);
        }
        else // polynomial
        {
            HEsti += getCoeff(N) * (pair.second);
        }
    }
    HEsti += 1.0*getCoeff(0) * (k-symbolnumber);
    
    HEsti = (HEsti > 0)? HEsti:0;
    // HEsti = (HEsti < log(k))?HEsti:log(k);

    return HEsti/log(2); // return the estimated entropy (bits)
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x30(%rdi), %r15
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %ebp, %ebp
cmpq %r15, %r14
je 0x24a1
movl (%r14), %esi
cvtsi2sd %esi, %xmm0
addl 0x4(%r14), %ebp
ucomisd 0x8(%rbx), %xmm0
jbe 0x2479
cvtsi2sdl 0x1c(%rbx), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x2170
movapd %xmm0, %xmm1
cvtsi2sdl 0x1c(%rbx), %xmm2
movsd 0x1b9f(%rip), %xmm0     # 0x4008
divsd %xmm2, %xmm0
mulsd 0x10(%rsp), %xmm1
subsd %xmm1, %xmm0
jmp 0x2481
movq %rbx, %rdi
callq 0x24da
cvtsi2sdl 0x4(%r14), %xmm1
mulsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x8, %r14
jmp 0x242d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x24da
movl 0x20(%rbx), %eax
subl %ebp, %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
addsd 0x8(%rsp), %xmm0
xorpd %xmm1, %xmm1
maxsd %xmm1, %xmm0
divsd 0x1b42(%rip), %xmm0     # 0x4010
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Albuso0[P]entropy/entropy.cpp
// Function: Entropy::getCoeff(int) const
double Entropy::getCoeff( int N ) const
{
    if ( N < 0 )
    {
        std::cerr<<"Compute g(N) for negative N!!"<<std::endl;
        exit(1);
    }
    int L0 = ( N > L )? L:N;
    double gL = a[L0];
    for (int i = L0; i>0; i--) 
        gL = a[i-1] + gL * (N-i+1) / Ratio;
    gL = (gL * Ratio + log(n/Ratio) * N)/n;
    return gL;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
js 0x2569
movl %esi, %ebp
movq %rdi, %rbx
movl 0x18(%rdi), %eax
cmpl %esi, %eax
cmovgel %esi, %eax
movslq %eax, %rsi
movq 0x40(%rdi), %rcx
movsd (%rcx,%rsi,8), %xmm1
movsd 0x10(%rdi), %xmm2
movl %ebp, %edx
subl %esi, %edx
incl %edx
testl %eax, %eax
jle 0x2527
cvtsi2sd %edx, %xmm0
mulsd %xmm0, %xmm1
divsd %xmm2, %xmm1
addsd -0x8(%rcx,%rax,8), %xmm1
decq %rax
jmp 0x250a
cvtsi2sdl 0x1c(%rbx), %xmm0
divsd %xmm2, %xmm0
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, 0x10(%rsp)
callq 0x2170
cvtsi2sd %ebp, %xmm1
mulsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm0
cvtsi2sdl 0x1c(%rbx), %xmm1
divsd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq 0x4a80(%rip), %rdi      # 0x6ff0
leaq 0x1aa1(%rip), %rsi      # 0x4018
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
pushq $0x1
popq %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/Albuso0[P]entropy/entropy.cpp
// Function: Entropy::estimate_non_zero() const
double Entropy::estimate_non_zero() const // Only use fingerprint f_j for j>=1. In other words, g(0)=0.
{
    double HEsti = 0;
    for ( const auto & pair : fin )
    {
        int N = pair.first;
        if ( N > N_thr) // plug-in
        {
            double x = (double)N / (double)n;
            HEsti += (-x*log(x)+0.5/n) * (pair.second);
        }
        else // polynomial
        {
            HEsti += getCoeff(N) * (pair.second);
        }
    }
    
    HEsti = (HEsti > 0)? HEsti:0;
    // HEsti = (HEsti < log(k))?HEsti:log(k);

    return HEsti/log(2); // return the estimated entropy (bits)
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x30(%rdi), %r15
xorpd %xmm0, %xmm0
cmpq %r15, %r14
je 0x2612
movsd %xmm0, 0x8(%rsp)
movl (%r14), %esi
cvtsi2sd %esi, %xmm0
ucomisd 0x8(%rbx), %xmm0
jbe 0x25f0
cvtsi2sdl 0x1c(%rbx), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
callq 0x2170
movapd %xmm0, %xmm1
cvtsi2sdl 0x1c(%rbx), %xmm2
movsd 0x1a27(%rip), %xmm0     # 0x4008
divsd %xmm2, %xmm0
mulsd (%rsp), %xmm1
subsd %xmm1, %xmm0
jmp 0x25f8
movq %rbx, %rdi
callq 0x24da
cvtsi2sdl 0x4(%r14), %xmm1
mulsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
addq $0x8, %r14
jmp 0x25a4
xorpd %xmm1, %xmm1
maxsd %xmm1, %xmm0
divsd 0x19ee(%rip), %xmm0     # 0x4010
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Albuso0[P]entropy/entropy.cpp
// Function: Entropy::estimate_Miller_Madow() const
double Entropy::estimate_Miller_Madow() const
{
    double HEsti = 0;
    int symbolnumber = 0;
    for ( const auto & pair : fin )
    {
        int N = pair.first;
        symbolnumber += pair.second;
        if ( N>0 )
        {
            double x = (double)N / (double)n;
            HEsti += (-x*log(x)) * (pair.second);
        }
    }
    return (HEsti+1.0*(symbolnumber-1)/n/2)/log(2); // return the bias-corrected empirical entropy (bits)
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x30(%rdi), %r15
xorpd %xmm2, %xmm2
xorl %ebp, %ebp
cmpq %r15, %r14
je 0x2695
movl (%r14), %eax
addl 0x4(%r14), %ebp
testl %eax, %eax
jle 0x268f
cvtsi2sd %eax, %xmm0
cvtsi2sdl 0x1c(%rbx), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd %xmm2, 0x10(%rsp)
callq 0x2170
movsd 0x10(%rsp), %xmm2
mulsd 0x8(%rsp), %xmm0
cvtsi2sdl 0x4(%r14), %xmm1
mulsd %xmm0, %xmm1
subsd %xmm1, %xmm2
addq $0x8, %r14
jmp 0x2647
decl %ebp
cvtsi2sd %ebp, %xmm0
cvtsi2sdl 0x1c(%rbx), %xmm1
divsd %xmm1, %xmm0
mulsd 0x195c(%rip), %xmm0     # 0x4008
addsd %xmm0, %xmm2
divsd 0x1958(%rip), %xmm2     # 0x4010
movapd %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Albuso0[P]entropy/entropy.cpp
// Function: Entropy::estimate_plug() const
double Entropy::estimate_plug() const
{
    double HEsti = 0;
    for ( const auto & pair : fin )
    {
        int N = pair.first;
        if ( N>0 )
        {
            double x = (double)N / (double)n;
            HEsti += (-x*log(x)) * (pair.second);
        }
    }
    return HEsti/log(2); // return the empirical entropy (bits)
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x30(%rdi), %r15
xorpd %xmm0, %xmm0
cmpq %r15, %r14
je 0x272c
movl (%r14), %eax
testl %eax, %eax
jle 0x2726
cvtsi2sd %eax, %xmm1
movsd %xmm0, 0x8(%rsp)
cvtsi2sdl 0x1c(%rbx), %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movapd %xmm1, %xmm0
callq 0x2170
mulsd (%rsp), %xmm0
cvtsi2sdl 0x4(%r14), %xmm1
mulsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
addq $0x8, %r14
jmp 0x26e0
divsd 0x18dc(%rip), %xmm0     # 0x4010
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Albuso0[P]entropy/entropy.cpp
// Function: Entropy::setFin(std::shared_ptr<std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>> const>)
void Entropy::setFin(std::shared_ptr< const std::map<int, int> > ptr_fin_map) 
{
    fin.clear();
    n = 0;
    for ( auto it = ptr_fin_map->begin(); it != ptr_fin_map->end(); ++it )
    {
        int freq = it->first, cnt = it->second;
        fin.push_back( std::make_pair( freq, cnt ) );
        n += (freq * cnt);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0x275d
movq %rax, 0x30(%r14)
andl $0x0, 0x1c(%r14)
leaq 0x28(%r14), %r15
movq (%rbx), %rax
movq 0x18(%rax), %r13
addq $0x8, %rax
cmpq %rax, %r13
je 0x27af
movl 0x20(%r13), %ebp
movl 0x24(%r13), %r12d
movq %r12, %rax
shlq $0x20, %rax
orq %rbp, %rax
movq %rax, (%rsp)
movq %r15, %rdi
movq %rsp, %rsi
callq 0x2dc2
imull %ebp, %r12d
addl %r12d, 0x1c(%r14)
movq %r13, %rdi
callq 0x21f0
movq %rax, %r13
movq (%rbx), %rax
jmp 0x276d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Albuso0[P]entropy/entropy.cpp
// Function: Entropy::setHist(std::vector<int, std::allocator<int>> const&)
void Entropy::setHist( const std::vector<int> &hist )
{
    fin.clear();
    n = 0;
    
    std::map<int, int> fin_map;
    for ( const auto & freq : hist )
    {
        auto iter = fin_map.find( freq );
        if ( iter == fin_map.end() )
            fin_map.insert( std::make_pair( freq,1 ) );
        else
            ++(iter->second);
    }
    
    for ( auto it = fin_map.begin(); it != fin_map.end(); ++it )
    {
        int freq = it->first, cnt = it->second;
        fin.push_back( std::make_pair( freq, cnt ) );
        n += (freq * cnt);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0x2955
movq %rax, 0x30(%rbx)
leaq 0x28(%rbx), %r14
andl $0x0, 0x1c(%rbx)
leaq 0x10(%rsp), %rbp
andl $0x0, (%rbp)
andq $0x0, 0x8(%rbp)
movq %rbp, 0x10(%rbp)
movq %rbp, 0x18(%rbp)
andq $0x0, 0x20(%rbp)
movq (%rsi), %r15
movq 0x8(%rsi), %r13
leaq 0x8(%rsp), %r12
cmpq %r13, %r15
je 0x29bb
movq %r12, %rdi
movq %r15, %rsi
callq 0x2f56
cmpq %rbp, %rax
je 0x299e
incl 0x24(%rax)
jmp 0x29b5
movl (%r15), %eax
btsq $0x20, %rax
movq %rax, (%rsp)
movq %r12, %rdi
movq %rsp, %rsi
callq 0x2fa8
addq $0x4, %r15
jmp 0x2984
movq 0x20(%rsp), %r12
cmpq %rbp, %r12
je 0x29fd
movl 0x20(%r12), %r13d
movl 0x24(%r12), %r15d
movq %r15, %rax
shlq $0x20, %rax
orq %r13, %rax
movq %rax, (%rsp)
movq %r14, %rdi
movq %rsp, %rsi
callq 0x2dc2
imull %r13d, %r15d
addl %r15d, 0x1c(%rbx)
movq %r12, %rdi
callq 0x2140
movq %rax, %r12
jmp 0x29c0
leaq 0x8(%rsp), %rdi
callq 0x2d6a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a1a
jmp 0x2a1a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2d6a
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Albuso0[P]entropy/entropy.cpp
// Function: Entropy::setDegree(int)
void Entropy::setDegree( int deg )
{
    L = deg;
    a.clear();
    
    std::fstream fd_coeffs("coeffs.txt");
    // ignore the first L-1 lines
    fd_coeffs.seekg(std::ios::beg);
    for( int i = 0; i < L-1; ++i )
        fd_coeffs.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
    // Read line L
    int test_L;
    fd_coeffs >> test_L;
    if ( L != test_L )
    {
        std::cerr<<"Read the wrong line!!"<<std::endl;
        exit(1);
    }
    double coeff;
    for (int i = 0; i <= L; i++)
    {
        fd_coeffs >> coeff;
        a.push_back(coeff);
    }
    fd_coeffs.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movl %esi, 0x18(%rdi)
movq 0x40(%rdi), %rax
cmpq %rax, 0x48(%rdi)
je 0x2bc9
movq %rax, 0x48(%rbx)
leaq 0x1466(%rip), %rsi      # 0x4036
leaq 0x18(%rsp), %r14
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0x2220
xorl %r13d, %r13d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2210
leaq 0x40(%rbx), %r14
leaq 0x18(%rsp), %r15
movabsq $0x7fffffffffffffff, %r12 # imm = 0x7FFFFFFFFFFFFFFF
pushq $0xa
popq %rbp
movl 0x18(%rbx), %eax
decl %eax
cmpl %eax, %r13d
jge 0x2c21
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x2120
incl %r13d
jmp 0x2c05
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2100
movl 0x18(%rbx), %eax
cmpl 0xc(%rsp), %eax
jne 0x2c8c
xorl %ebp, %ebp
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
cmpl %eax, %ebp
jg 0x2c66
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movq %r14, %rdi
movq %r12, %rsi
callq 0x2d04
incl %ebp
movl 0x18(%rbx), %eax
jmp 0x2c45
leaq 0x18(%rsp), %rdi
callq 0x2040
leaq 0x18(%rsp), %rdi
callq 0x2070
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x435d(%rip), %rdi      # 0x6ff0
leaq 0x13a7(%rip), %rsi      # 0x4041
callq 0x21a0
movq %rax, %rdi
callq 0x20e0
pushq $0x1
popq %rdi
callq 0x2200
jmp 0x2cb7
jmp 0x2cb7
jmp 0x2cb7
jmp 0x2cb7
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/Albuso0[P]entropy/main_test.cpp
// Function: print_param(Entropy const&)
void print_param(const Entropy &entropy)
{
    printf("Parameters:\n");
    printf("Alphabet size\t\t=%d\n", entropy.getAlphabetSize());
    printf("Polynoimal degree\t=%d\n", entropy.getDegree());
    printf("Approximation interval\t=[0,%.2f/n]\n", entropy.getInterval());
    printf("Plug-in threshold\t=%d\n",(int)floor(entropy.getThreshold())+1);
    printf("\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xc62(%rip), %rdi       # 0x4195
callq 0x2260
movl 0x20(%rbx), %esi
leaq 0xb6d(%rip), %rdi       # 0x40af
xorl %eax, %eax
callq 0x2030
movl 0x18(%rbx), %esi
leaq 0xb70(%rip), %rdi       # 0x40c3
xorl %eax, %eax
callq 0x2030
movsd 0x10(%rbx), %xmm0
leaq 0xb74(%rip), %rdi       # 0x40da
movb $0x1, %al
callq 0x2030
movsd 0x8(%rbx), %xmm0
callq 0x2290
cvttsd2si %xmm0, %esi
incl %esi
leaq 0xb7a(%rip), %rdi       # 0x40fe
xorl %eax, %eax
callq 0x2030
pushq $0xa
popq %rdi
popq %rbx
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/Albuso0[P]entropy/main_test.cpp
// Function: print_results(Entropy const&)
void print_results(const Entropy &entropy)
{
    printf("Results:\n");
    printf("Sample size\t=%d\n",entropy.getSampleSize());
    printf("Plug in\t\t=%.6f bits\n",entropy.estimate_plug());
    printf("Miller Madow\t=%.6f bits\n",entropy.estimate_Miller_Madow());
    printf("Polynomial\t=%.6f bits\n",entropy.estimate());
    printf("\n");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xc02(%rip), %rdi       # 0x41a1
callq 0x2260
movl 0x1c(%rbx), %esi
leaq 0xb67(%rip), %rdi       # 0x4115
xorl %eax, %eax
callq 0x2030
movq %rbx, %rdi
callq 0x26c8
leaq 0xb62(%rip), %rdi       # 0x4126
movb $0x1, %al
callq 0x2030
movq %rbx, %rdi
callq 0x262c
leaq 0xb61(%rip), %rdi       # 0x413b
movb $0x1, %al
callq 0x2030
movq %rbx, %rdi
callq 0x240c
leaq 0xb64(%rip), %rdi       # 0x4154
movb $0x1, %al
callq 0x2030
pushq $0xa
popq %rdi
popq %rbx
jmp 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/st0ne[P]XReflectorPlus/dxrfd.cpp
// Function: mute_users(bool)
static void mute_users(bool mute)
{
   a_user_list_type::iterator pos;
   struct a_user *a_user_ptr;

   inbound_type::iterator pos2;
   inbound *inbound_ptr;

   for (pos = a_user_list.begin(); pos != a_user_list.end(); pos++)
   {
      a_user_ptr = (struct a_user *)pos->second;
      a_user_ptr->isMute = mute;
   }

   for (pos2 = inbound_list.begin(); pos2 != inbound_list.end(); pos2++)
   {
      inbound_ptr = (inbound *)pos2->second;
      inbound_ptr->isMute = mute;
   }
   return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x7483(%rip), %rax      # 0x10308
leaq 0x746c(%rip), %r14      # 0x102f8
cmpq %r14, %rax
je 0x8ea2
movq 0x40(%rax), %rcx
movb %bl, 0x9(%rcx)
movq %rax, %rdi
callq 0x2190
jmp 0x8e8c
movq 0x742f(%rip), %rax      # 0x102d8
leaq 0x7418(%rip), %r14      # 0x102c8
cmpq %r14, %rax
je 0x8ec6
movq 0x40(%rax), %rcx
movb %bl, 0x9(%rcx)
movq %rax, %rdi
callq 0x2190
jmp 0x8eb0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/st0ne[P]XReflectorPlus/dxrfd.cpp
// Function: mute_call(char*, bool)
static bool mute_call(char *call, bool mute)
{
   bool found = false;
   a_user_list_type::iterator pos;
   struct a_user *a_user_ptr;

   inbound_type::iterator pos2;
   inbound *inbound_ptr;

   for (pos = a_user_list.begin(); pos != a_user_list.end(); pos++)
   {
      a_user_ptr = (struct a_user *)pos->second;
      if (strcmp(a_user_ptr->call, call) == 0)
      {
         found = true;
         a_user_ptr->isMute = mute;
      }
   }

   for (pos2 = inbound_list.begin(); pos2 != inbound_list.end(); pos2++)
   {
      inbound_ptr = (inbound *)pos2->second;
      if (strcmp(inbound_ptr->call, call) == 0)
      {
         found = true;
         inbound_ptr->isMute = mute;
      }
   }

   return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq 0x7423(%rip), %r15      # 0x10308
xorl %ebp, %ebp
leaq 0x740a(%rip), %r13      # 0x102f8
cmpq %r13, %r15
je 0x8f1b
movq 0x40(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2370
testl %eax, %eax
jne 0x8f0e
movb %bl, 0x9(%r12)
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2190
movq %rax, %r15
jmp 0x8eee
movq 0x73b6(%rip), %r15      # 0x102d8
leaq 0x739f(%rip), %r13      # 0x102c8
cmpq %r13, %r15
je 0x8f56
movq 0x40(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2370
testl %eax, %eax
jne 0x8f49
movb %bl, 0x9(%r12)
movb $0x1, %bpl
movq %r15, %rdi
callq 0x2190
movq %rax, %r15
jmp 0x8f29
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/menu/Menu.cpp
// Function: Menu::displayMenu() const
void Menu :: displayMenu() const {
  cout << endl << endl;
  for (size_t i = 0; i != options.size(); ++i) {
    cout << i + 1 << ". " << options[i] << endl;
  }
  cout << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1c44b(%rip), %r14     # 0x20fc0
movq %r14, %rdi
callq 0x4120
movq %rax, %rdi
callq 0x4120
pushq $0x1
popq %r15
xorl %r13d, %r13d
leaq 0x1048d(%rip), %r12     # 0x15020
leaq -0x1(%r15), %rax
movq 0x10(%rbx), %rcx
subq 0x8(%rbx), %rcx
sarq $0x5, %rcx
cmpq %rcx, %rax
je 0x4bde
movq %r14, %rdi
movq %r15, %rsi
callq 0x41a0
movq %rax, %rdi
movq %r12, %rsi
callq 0x4250
movq 0x8(%rbx), %rsi
addq %r13, %rsi
movq %rax, %rdi
callq 0x4220
movq %rax, %rdi
callq 0x4120
addq $0x20, %r13
incq %r15
jmp 0x4b93
movq 0x1c3db(%rip), %rdi     # 0x20fc0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4120
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: BasicMenu::BasicMenu()
BasicMenu :: BasicMenu()
  : Menu() {
  options.push_back("Display stats");
  options.push_back("Check invnentory");
  options.push_back("Move");
  options.push_back("Go to Main Menu");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x4b3c
leaq 0x1b96e(%rip), %rax     # 0x20698
movq %rax, (%rbx)
leaq 0x10311(%rip), %rsi     # 0x15045
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x102ee(%rip), %rsi     # 0x15053
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x102d2(%rip), %rsi     # 0x15064
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x102aa(%rip), %rsi     # 0x15069
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x4df9
jmp 0x4e08
jmp 0x4df9
jmp 0x4e08
jmp 0x4df9
jmp 0x4e08
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4470
jmp 0x4e0b
movq %rax, %r14
movq %rbx, %rdi
callq 0x57c8
movq %r14, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: BattleMenu::BattleMenu()
BattleMenu :: BattleMenu()
  : Menu() {
  options.push_back("Display stats");
  options.push_back("Attack");
  options.push_back("Cast spell");
  options.push_back("Use potion");
  options.push_back("Change weapon/armor");
  options.push_back("Go to Main Menu");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x4b3c
leaq 0x1b87e(%rip), %rax     # 0x206b0
movq %rax, (%rbx)
leaq 0x10209(%rip), %rsi     # 0x15045
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x1020c(%rip), %rsi     # 0x15079
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x101e6(%rip), %rsi     # 0x15080
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x101c4(%rip), %rsi     # 0x1508b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x101a2(%rip), %rsi     # 0x15096
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x10148(%rip), %rsi     # 0x15069
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x4f63
jmp 0x4f72
jmp 0x4f63
jmp 0x4f72
jmp 0x4f63
jmp 0x4f72
jmp 0x4f63
jmp 0x4f72
jmp 0x4f63
jmp 0x4f72
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4470
jmp 0x4f75
movq %rax, %r14
movq %rbx, %rdi
callq 0x57c8
movq %r14, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: MarketMenu::MarketMenu()
MarketMenu :: MarketMenu()
  : Menu() {
  options.push_back("Display Items/Spells");
  options.push_back("Buy Item/Spell");
  options.push_back("Sell Item/Spell");
  options.push_back("Exit Market");
  options.push_back("Go to Main Menu");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x4b3c
leaq 0x1b72c(%rip), %rax     # 0x206c8
movq %rax, (%rbx)
leaq 0x10104(%rip), %rsi     # 0x150aa
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x100e8(%rip), %rsi     # 0x150bf
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x100ca(%rip), %rsi     # 0x150ce
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x100ad(%rip), %rsi     # 0x150de
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0x1000b(%rip), %rsi     # 0x15069
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x509c
jmp 0x50ab
jmp 0x509c
jmp 0x50ab
jmp 0x509c
jmp 0x50ab
jmp 0x509c
jmp 0x50ab
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4470
jmp 0x50ae
movq %rax, %r14
movq %rbx, %rdi
callq 0x57c8
movq %r14, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: InventoryMenu::InventoryMenu()
InventoryMenu :: InventoryMenu()
  : Menu() {
  options.push_back("Display Items/Spells");
  options.push_back("Equip Item/Spell");
  options.push_back("Discard Item/Spell");
  options.push_back("Use Potion");
  options.push_back("Exit Inventory");
  options.push_back("Go to Main Menu");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x4b3c
leaq 0x1b60c(%rip), %rax     # 0x206e0
movq %rax, (%rbx)
leaq 0xffcc(%rip), %rsi      # 0x150aa
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0xffdb(%rip), %rsi      # 0x150ea
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0xffbf(%rip), %rsi      # 0x150fb
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0xffa5(%rip), %rsi      # 0x1510e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0xff83(%rip), %rsi      # 0x15119
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0xfea6(%rip), %rsi      # 0x15069
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x5205
jmp 0x5214
jmp 0x5205
jmp 0x5214
jmp 0x5205
jmp 0x5214
jmp 0x5205
jmp 0x5214
jmp 0x5205
jmp 0x5214
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4470
jmp 0x5217
movq %rax, %r14
movq %rbx, %rdi
callq 0x57c8
movq %r14, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: MainMenu::MainMenu()
MainMenu :: MainMenu()
  : Menu() {
  options.push_back("Play");
  options.push_back("GenerateMap");
  options.push_back("Help");
  options.push_back("Quit");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x4b3c
leaq 0x1b4ba(%rip), %rax     # 0x206f8
movq %rax, (%rbx)
leaq 0xfee0(%rip), %rsi      # 0x15128
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0xfeb4(%rip), %rsi      # 0x1512d
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0xfe93(%rip), %rsi      # 0x15139
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
leaq 0xfe6b(%rip), %rsi      # 0x1513e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x578c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5898
leaq 0x8(%rsp), %rdi
callq 0x4470
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x530d
jmp 0x531c
jmp 0x530d
jmp 0x531c
jmp 0x530d
jmp 0x531c
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4470
jmp 0x531f
movq %rax, %r14
movq %rbx, %rdi
callq 0x57c8
movq %r14, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: MainMenu::welcome() const
void MainMenu :: welcome() const {  
  cout << endl << "Welcome to ..." << endl;

  displayMenu();

  cout << "Type any of the above options to enter (i.e : \"GenerateMap\" or \"Help\")"
       << endl << endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1bc82(%rip), %r14     # 0x20fc0
movq %r14, %rdi
callq 0x4120
leaq 0xfdf6(%rip), %rsi      # 0x15143
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
leaq 0xfde6(%rip), %rsi      # 0x15152
movq %r14, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4120
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: MainMenu::prompt[abi:cxx11]() const
string MainMenu :: prompt() const {
  string userInput;

  cout << "> ";
  cin >> userInput;
  transform(userInput.begin(), userInput.end(),
	    userInput.begin(), :: tolower);  
  for (size_t i = 0; i < options.size(); i++) {
    string tmp = options[i];
    transform(tmp.begin(), tmp.end(), tmp.begin(), :: tolower);
    if (userInput == tmp) {
      return userInput;
    }
  }

  cout << endl << "Your input does not match any option." << endl << endl;
  return prompt();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x1bc08(%rip), %rdi     # 0x20fc0
leaq 0xfc7d(%rip), %rsi      # 0x1503c
callq 0x4250
movq 0x1bc05(%rip), %rdi     # 0x20fd0
movq %rsp, %rsi
callq 0x42f0
movq %rbx, 0x20(%rsp)
movq (%rsp), %r15
movq 0x8(%rsp), %r12
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x53fb
movsbl (%r15,%rbx), %edi
callq 0x4350
movb %al, (%r15,%rbx)
incq %rbx
jmp 0x53e3
xorl %ebp, %ebp
leaq 0x28(%rsp), %r15
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %rbp
jae 0x546b
movq %rbp, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r15, %rdi
callq 0x4330
movq 0x28(%rsp), %r13
movq 0x30(%rsp), %rbx
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x544f
movsbl (%r13,%r12), %edi
callq 0x4350
movb %al, (%r13,%r12)
incq %r12
jmp 0x5435
movq %rsp, %rdi
movq %r15, %rsi
callq 0x57df
testb %al, %al
jne 0x54a8
movq %r15, %rdi
callq 0x4470
incq %rbp
jmp 0x5402
movq 0x1bb4e(%rip), %rdi     # 0x20fc0
callq 0x4120
movq 0x20(%rsp), %rbx
leaq 0xfd16(%rip), %rsi      # 0x15199
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
movq %rax, %rdi
callq 0x4120
movq %rbx, %rdi
movq %r14, %rsi
callq 0x538c
jmp 0x54f8
movq 0x20(%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsp), %rcx
leaq 0x10(%rsp), %rdx
cmpq %rdx, %rcx
je 0x54d0
movq %rcx, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x54d6
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %rdx, (%rsp)
andq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4470
movq %rsp, %rdi
callq 0x4470
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5514
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4470
movq %rbx, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: MainMenu::displayMenu() const
void MainMenu :: displayMenu() const {

  cout << endl;
  cout << "+---+---+---+---+"                 << endl;
  cout << "| R | o | l | e |"                 << endl;
  cout << "+---+---+---+---+---+---+---+---+" << endl;
  cout << "    | P | l | a | y | i | n | g |" << endl;
  cout << "    +---+---+---+---+---+---+---+" << endl;
  cout << "        | G | a | m | e |"         << endl;
  cout << "        +---+---+---+---+"	      << endl;
  cout << endl;

  for (size_t i = 0; i != options.size(); ++i) {
    cout << "•" << options[i] << endl;
  }
  cout << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1ba85(%rip), %r14     # 0x20fc0
movq %r14, %rdi
callq 0x4120
leaq 0xfd0f(%rip), %rsi      # 0x15259
movq %r14, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
leaq 0xfc5e(%rip), %rsi      # 0x151bf
movq %r14, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
leaq 0xfc59(%rip), %rsi      # 0x151d1
movq %r14, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
leaq 0xfc64(%rip), %rsi      # 0x151f3
movq %r14, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
leaq 0xfc6f(%rip), %rsi      # 0x15215
movq %r14, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
leaq 0xfc7a(%rip), %rsi      # 0x15237
movq %r14, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
leaq 0xfc7d(%rip), %rsi      # 0x15251
movq %r14, %rdi
callq 0x4250
movq %rax, %rdi
callq 0x4120
movq %r14, %rdi
callq 0x4120
xorl %r12d, %r12d
leaq 0xfc75(%rip), %r15      # 0x1526b
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
sarq $0x5, %rax
cmpq %rax, %r13
je 0x5635
movq %r14, %rdi
movq %r15, %rsi
callq 0x4250
movq 0x8(%rbx), %rsi
addq %r12, %rsi
movq %rax, %rdi
callq 0x4220
movq %rax, %rdi
callq 0x4120
incq %r13
addq $0x20, %r12
jmp 0x55f9
movq 0x1b984(%rip), %rdi     # 0x20fc0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4120
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/menu/AllMenus.cpp
// Function: MainMenu::help() const
void MainMenu::help() const {
	ifstream helpFile;

	helpFile.open("input/help.info");

	if (helpFile.is_open()) {
		cout << endl;
		cout << helpFile.rdbuf();
	} else {
		cerr << "A problem occured while opening \"input/help.info\" ";
		cout << endl<< endl;
	}

	string answer;
	  while (answer != "Y" && answer != "y") {
		cout << endl << "Exit to Main Menu?(Y/n) : ";
		cin >> answer;
	  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x42a0
leaq 0xfc00(%rip), %rsi      # 0x1526f
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x4170
leaq 0x98(%rsp), %rdi
callq 0x40a0
testb %al, %al
je 0x56aa
movq 0x1b92e(%rip), %rdi     # 0x20fc0
callq 0x4120
leaq 0x30(%rsp), %rsi
movq 0x1b91d(%rip), %rdi     # 0x20fc0
callq 0x4080
jmp 0x56d1
movq 0x1b937(%rip), %rdi     # 0x20fe8
leaq 0xfbc7(%rip), %rsi      # 0x1527f
callq 0x4250
movq 0x1b8fc(%rip), %rdi     # 0x20fc0
callq 0x4120
movq %rax, %rdi
callq 0x4120
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x106c5(%rip), %rbx     # 0x15dae
movq %rsp, %r14
leaq 0xfa38(%rip), %r15      # 0x1512b
movq 0x1b8c6(%rip), %r12     # 0x20fc0
leaq 0xfbb1(%rip), %r13      # 0x152b2
movq 0x1b8c8(%rip), %rbp     # 0x20fd0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5808
testb %al, %al
je 0x5746
movq %r14, %rdi
movq %r15, %rsi
callq 0x5808
testb %al, %al
je 0x5746
movq %r12, %rdi
callq 0x4120
movq %rax, %rdi
movq %r13, %rsi
callq 0x4250
movq %rbp, %rdi
movq %r14, %rsi
callq 0x42f0
jmp 0x5708
movq %rsp, %rdi
callq 0x4470
leaq 0x20(%rsp), %rdi
callq 0x4460
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x577a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4470
leaq 0x20(%rsp), %rdi
callq 0x4460
movq %rbx, %rdi
callq 0x4410
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/grid/Grid.cpp
// Function: Grid::Tile::~Tile()
Grid :: Tile :: ~Tile() {
  while (livings.empty() == false) {
    delete livings.front();
    livings.pop_front();
  }

  delete market;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq (%rbx), %rax
cmpq %rbx, %rax
je 0x5b56
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x5b4c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x5f82
jmp 0x5b35
movq 0x20(%r14), %r14
testq %r14, %r14
je 0x5b67
movq %r14, %rdi
callq 0xca44
pushq $0x58
popq %rsi
movq %r14, %rdi
callq 0x4270
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6090
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/grid/Grid.cpp
// Function: Grid::Grid(int, int, bool*)
Grid :: Grid(int _maxY, int _maxX, bool* _tileInfo)

  : maxX(_maxX), maxY(_maxY) {

  size_t auxI = 0U;
  
  for (size_t i = 0U; i != maxY; ++i) {
    vector<Tile> newTileVector;
    tiles.push_back(newTileVector);
    
    for (size_t j = 0U; j != maxX; ++j) {

      bool nonAccessible = _tileInfo[auxI];
      bool common = _tileInfo[auxI + 1];

      Tile newTile(nonAccessible, common);
      tiles[i].push_back(newTile);
      
      auxI += 2U;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, (%rdi)
movl %esi, 0x4(%rdi)
leaq 0x8(%rdi), %rax
movq %rax, (%rsp)
andq $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movq %rdi, 0x8(%rsp)
movups %xmm0, 0x8(%rdi)
leaq 0x48(%rsp), %rbp
incq %rcx
movq %rcx, 0x10(%rsp)
xorl %ebx, %ebx
leaq 0x20(%rsp), %r14
leaq 0x40(%rsp), %r13
xorl %r12d, %r12d
movslq %esi, %rax
cmpq %rax, %rbx
je 0x5caf
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x5f8a
movq 0x10(%rsp), %rax
leaq (%rax,%r12), %r14
negq %r12
movq %rbx, 0x18(%rsp)
imulq $0x18, %rbx, %rbx
xorl %r15d, %r15d
movq 0x8(%rsp), %rax
movslq (%rax), %rax
cmpq %rax, %r15
je 0x5c8a
movzwl -0x1(%r14,%r15,2), %eax
movw %ax, 0x40(%rsp)
movq %rbp, 0x50(%rsp)
movq %rbp, 0x48(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbp)
movq (%rsp), %rax
movq (%rax), %rdi
addq %rbx, %rdi
movq %r13, %rsi
callq 0x5fb6
movq %r13, %rdi
callq 0x5b2a
incq %r15
addq $-0x2, %r12
jmp 0x5c3e
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x5fe2
movq 0x18(%rsp), %rbx
incq %rbx
movq 0x8(%rsp), %rax
movl 0x4(%rax), %esi
negq %r12
jmp 0x5c00
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x5cd0
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x5b2a
leaq 0x20(%rsp), %rdi
callq 0x5fe2
movq (%rsp), %rdi
callq 0x6004
movq %r14, %rdi
callq 0x4410
nop
// File: /workspace/github_cpp_makefile_star2_O2/arisKoutsou[P]oopproj/./src/grid/Grid.cpp
// Function: Grid::addMarket(int, int, Market*)
void Grid :: addMarket(int row, int col, Market* _market) {
  if (tiles[row][col].hasMarket()) {
    cerr << "You can't add more than one market in a tile." << endl;
    return;
  }
  
  if (tiles[row][col].isNonAccessible()) {
    cerr << "You can't add a market at a nonAccessible tile." << endl;
    return;
  }
  tiles[row][col].market = _market;  
}

// Assembly:
pushq %rax
movslq %esi, %rax
movq 0x8(%rdi), %rsi
imulq $0x18, %rax, %rax
movslq %edx, %rdx
movq (%rsi,%rax), %rax
imulq $0x28, %rdx, %rdx
cmpq $0x0, 0x20(%rax,%rdx)
je 0x5d2d
movq 0x1b2c4(%rip), %rdi     # 0x20fe8
leaq 0xf635(%rip), %rsi      # 0x15360
jmp 0x5d43
addq %rdx, %rax
cmpb $0x1, (%rax)
jne 0x5d51
movq 0x1b2ac(%rip), %rdi     # 0x20fe8
leaq 0xf64b(%rip), %rsi      # 0x1538e
callq 0x4250
movq %rax, %rdi
popq %rax
jmp 0x4120
movq %rcx, 0x20(%rax)
popq %rax
retq
nop