LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::detail::z_stream_wrapper::z_stream_wrapper(bool, int)
z_stream_wrapper(bool _is_input = true, int _level = Z_DEFAULT_COMPRESSION)
        : is_input(_is_input)
    {
        this->zalloc = Z_NULL;
        this->zfree = Z_NULL;
        this->opaque = Z_NULL;
        int ret;
        if (is_input)
        {
            this->avail_in = 0;
            this->next_in = Z_NULL;
            ret = inflateInit2(this, 15+32);
        }
        else
        {
            ret = deflateInit2(this, _level, Z_DEFLATED, 15+16, 8, Z_DEFAULT_STRATEGY);
        }
        if (ret != Z_OK) throw Exception(this, ret);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb %sil, 0x70(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq $0x0, 0x50(%rdi)
testl %esi, %esi
je 0x1ae91
movl $0x0, 0x8(%rbx)
movq $0x0, (%rbx)
leaq 0x167e1(%rip), %rdx     # 0x3165e
movq %rbx, %rdi
movl $0x2f, %esi
movl $0x70, %ecx
callq 0x6350
jmp 0x1aebc
leaq 0x167c6(%rip), %rax     # 0x3165e
movq %rbx, %rdi
movl %edx, %esi
movl $0x8, %edx
movl $0x1f, %ecx
movl $0x8, %r8d
xorl %r9d, %r9d
pushq $0x70
pushq %rax
callq 0x6090
addq $0x10, %rsp
movl %eax, %ebp
testl %eax, %eax
jne 0x1aec7
popq %rbx
popq %r14
popq %rbp
retq
movl $0x28, %edi
callq 0x61f0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1af0a
leaq 0x23848(%rip), %rsi     # 0x3e730
leaq 0x2a5(%rip), %rdx       # 0x1b194
movq %r14, %rdi
callq 0x6640
movq %rax, %rbx
movq %r14, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6660
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::ostreambuf(std::basic_streambuf<char, std::char_traits<char>>*, unsigned long, int)
ostreambuf(std::streambuf * _sbuf_p,
               std::size_t _buff_size = default_buff_size, int _level = Z_DEFAULT_COMPRESSION)
        : sbuf_p(_sbuf_p),
          zstrm_p(new detail::z_stream_wrapper(false, _level)),
          buff_size(_buff_size)
    {
        assert(sbuf_p);
        in_buff = new char [buff_size];
        out_buff = new char [buff_size];
        setp(in_buff, in_buff + buff_size);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x23d5d(%rip), %r13     # 0x3ef80
addq $0x10, %r13
movq %r13, (%rdi)
leaq 0x38(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %r14, %rdi
callq 0x66f0
leaq 0x237b4(%rip), %rax     # 0x3ea00
movq %rax, (%rbx)
movq %r12, 0x40(%rbx)
movl $0x78, %edi
callq 0x63b0
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x1ae4a
movq %r12, 0x58(%rbx)
movq %r15, 0x60(%rbx)
cmpq $0x0, 0x40(%rbx)
je 0x1b2b7
movq %r15, %rdi
callq 0x6030
movq %rax, %r12
movq %rax, 0x48(%rbx)
movq %r15, %rdi
callq 0x6030
movq %rax, 0x50(%rbx)
movq %r12, %rax
addq %r15, %rax
movq %r12, 0x28(%rbx)
movq %r12, 0x20(%rbx)
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x162ad(%rip), %rdi     # 0x3156b
leaq 0x162ad(%rip), %rsi     # 0x31572
leaq 0x164c2(%rip), %rcx     # 0x3178e
movl $0xeb, %edx
callq 0x6290
movq %rax, %r15
movl $0x78, %esi
movq %r12, %rdi
callq 0x63c0
jmp 0x1b2eb
movq %rax, %r15
movq %r13, (%rbx)
movq %r14, %rdi
callq 0x6580
movq %r15, %rdi
callq 0x6660
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/include/strict_fstream.hpp
// Function: strict_fstream::ofstream::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::_Ios_Openmode)
void open(const std::string& filename, std::ios_base::openmode mode = std::ios_base::out)
    {
        mode |= std::ios_base::out;
        exceptions(std::ios_base::badbit);
        detail::static_method_holder::check_mode(filename, mode);
        std::ofstream::open(filename, mode);
        detail::static_method_holder::check_open(this, filename, mode);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
orl $0x10, %ebx
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
movl $0x1, 0x1c(%r15,%rax)
movl 0x20(%r15,%rax), %esi
callq 0x6630
movq %r14, %rdi
movl %ebx, %esi
callq 0x1b5e0
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x61e0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1b8fc
nop
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/include/strict_fstream.hpp
// Function: strict_fstream::detail::static_method_holder::mode_to_string[abi:cxx11](std::_Ios_Openmode)
static std::string mode_to_string(std::ios_base::openmode mode)
    {
        static const int n_modes = 6;
        static const std::ios_base::openmode mode_val_v[n_modes] =
            {
                std::ios_base::in,
                std::ios_base::out,
                std::ios_base::app,
                std::ios_base::ate,
                std::ios_base::trunc,
                std::ios_base::binary
            };

        static const char * mode_name_v[n_modes] =
            {
                "in",
                "out",
                "app",
                "ate",
                "trunc",
                "binary"
            };
        std::string res;
        for (int i = 0; i < n_modes; ++i)
        {
            if (mode & mode_val_v[i])
            {
                res += (! res.empty()? "|" : "");
                res += mode_name_v[i];
            }
        }
        if (res.empty()) res = "none";
        return res;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x235ce(%rip), %r14     # 0x3f390
xorl %r12d, %r12d
leaq 0x16374(%rip), %r13     # 0x32140
leaq 0x15a3f(%rip), %r15     # 0x31812
testl %ebp, (%r12,%r13)
je 0x1bdff
cmpq $0x0, 0x8(%rbx)
movq %r15, %rsi
leaq 0x15651(%rip), %rax     # 0x31439
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x66e0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x66e0
addq $0x8, %r14
addq $0x4, %r12
cmpq $0x18, %r12
jne 0x1bdd3
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
jne 0x1be2d
leaq 0x15942(%rip), %rcx     # 0x3175f
movl $0x4, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x65d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1be41
movq %rax, %r14
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x1be5c
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x63c0
movq %r14, %rdi
callq 0x6660
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::~ostreambuf()
virtual ~ostreambuf()
    {
        // flush the zlib stream
        //
        // NOTE: Errors here (sync() return value not 0) are ignored, because we
        // cannot throw in a destructor. This mirrors the behaviour of
        // std::basic_filebuf::~basic_filebuf(). To see an exception on error,
        // close the ofstream with an explicit call to close(), and do not rely
        // on the implicit call in the destructor.
        //
        sync();
        delete [] in_buff;
        delete [] out_buff;
        delete zstrm_p;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x22afe(%rip), %rax     # 0x3ea00
movq %rax, (%rdi)
callq 0x1bf86
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1bf18
callq 0x64f0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x1bf26
callq 0x64f0
movq 0x58(%rbx), %r14
testq %r14, %r14
je 0x1bf44
movq %r14, %rdi
callq 0x1ae2c
movl $0x78, %esi
movq %r14, %rdi
callq 0x63c0
movq 0x23035(%rip), %rax     # 0x3ef80
addq $0x10, %rax
movq %rax, (%rbx)
addq $0x38, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6580
movq %rax, %rdi
callq 0x1a9dd
nop
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::sync()
virtual int sync()
    {
        // first, call overflow to clear in_buff
        overflow();
        if (! pptr()) return -1;
        // then, call deflate asking to finish the zlib stream
        zstrm_p->next_in = nullptr;
        zstrm_p->avail_in = 0;
        if (deflate_loop(Z_FINISH) != 0) return -1;
        deflateReset(zstrm_p);
        return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq *0x68(%rax)
cmpq $0x0, 0x28(%r14)
je 0x1bfd2
movq 0x58(%r14), %rax
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movq %r14, %rdi
movl $0x4, %esi
callq 0x1c072
testl %eax, %eax
jne 0x1bfd2
movq 0x58(%r14), %rdi
callq 0x6590
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::overflow(int)
virtual std::streambuf::int_type overflow(std::streambuf::int_type c = traits_type::eof())
    {
        zstrm_p->next_in = reinterpret_cast< decltype(zstrm_p->next_in) >(pbase());
        zstrm_p->avail_in = pptr() - pbase();
        while (zstrm_p->avail_in > 0)
        {
            int r = deflate_loop(Z_NO_FLUSH);
            if (r != 0)
            {
                setp(nullptr, nullptr);
                return traits_type::eof();
            }
        }
        setp(in_buff, in_buff + buff_size);
        return traits_type::eq_int_type(c, traits_type::eof()) ? traits_type::eof() : sputc(c);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq 0x20(%rdi), %rax
movq 0x58(%rdi), %rcx
movq %rax, (%rcx)
movl 0x28(%rdi), %edx
subl %eax, %edx
movl %edx, 0x8(%rcx)
movq 0x58(%rbx), %rax
cmpl $0x0, 0x8(%rax)
je 0x1c025
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1c072
testl %eax, %eax
je 0x1bffc
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
jmp 0x1c054
movq 0x48(%rbx), %rax
movq 0x60(%rbx), %rcx
leaq (%rax,%rcx), %rdx
movq %rax, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movq %rdx, 0x30(%rbx)
cmpl $-0x1, %ebp
je 0x1c054
testq %rcx, %rcx
jle 0x1c05e
movb %bpl, (%rax)
incq 0x28(%rbx)
movzbl %bpl, %eax
jmp 0x1c059
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
movzbl %bpl, %esi
movq (%rbx), %rax
movq 0x68(%rax), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/include/zstr.hpp
// Function: zstr::ostreambuf::deflate_loop(int)
int deflate_loop(int flush)
    {
        while (true)
        {
            zstrm_p->next_out = reinterpret_cast< decltype(zstrm_p->next_out) >(out_buff);
            zstrm_p->avail_out = buff_size;
            int ret = deflate(zstrm_p, flush);
            if (ret != Z_OK && ret != Z_STREAM_END && ret != Z_BUF_ERROR) throw Exception(zstrm_p, ret);
            std::streamsize sz = sbuf_p->sputn(out_buff, reinterpret_cast< decltype(out_buff) >(zstrm_p->next_out) - out_buff);
            if (sz != reinterpret_cast< decltype(out_buff) >(zstrm_p->next_out) - out_buff)
            {
                // there was an error in the sink stream
                return -1;
            }
            if (ret == Z_STREAM_END || ret == Z_BUF_ERROR || sz == 0)
            {
                break;
            }
        }
        return 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x3, %r15d
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rdi
movq %rax, 0x18(%rdi)
movl 0x60(%rbx), %eax
movl %eax, 0x20(%rdi)
movl %ebp, %esi
callq 0x61d0
movl %eax, %r14d
cmpl $0x2, %eax
jb 0x1c0ab
cmpl $-0x5, %r14d
jne 0x1c117
movq 0x40(%rbx), %rdi
movq 0x50(%rbx), %rsi
movq 0x58(%rbx), %rax
movq 0x18(%rax), %rdx
subq %rsi, %rdx
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x58(%rbx), %rcx
movq 0x18(%rcx), %rdx
subq 0x50(%rbx), %rdx
movl $0x1, %ecx
cmpq %rdx, %rax
jne 0x1c0fa
testq %rax, %rax
je 0x1c0f5
xorl %eax, %eax
cmpl $0x1, %r14d
sete %al
cmpl $-0x5, %r14d
leal (%rax,%rax,2), %ecx
cmovel %r15d, %ecx
jmp 0x1c0fa
movl $0x3, %ecx
testl %ecx, %ecx
je 0x1c084
cmpl $0x1, %ecx
jne 0x1c10a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1c10c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x61f0
movq %rax, %r15
movq 0x58(%rbx), %rsi
movq %rax, %rdi
movl %r14d, %edx
callq 0x1af0a
leaq 0x225f6(%rip), %rsi     # 0x3e730
leaq -0xfad(%rip), %rdx      # 0x1b194
movq %r15, %rdi
callq 0x6640
movq %rax, %rbx
movq %r15, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6660
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/src/edlib.cpp
// Function: EqualityDefinition::EqualityDefinition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, EdlibEqualityPair const*, int)
EqualityDefinition(const string& alphabet,
                       const EdlibEqualityPair* additionalEqualities = NULL,
                       const int additionalEqualitiesLength = 0) {
        for (int i = 0; i < static_cast<int>(alphabet.size()); i++) {
            for (int j = 0; j < static_cast<int>(alphabet.size()); j++) {
                matrix[i][j] = (i == j);
            }
        }
        if (additionalEqualities != NULL) {
            for (int i = 0; i < additionalEqualitiesLength; i++) {
                size_t firstTransformed = alphabet.find(additionalEqualities[i].first);
                size_t secondTransformed = alphabet.find(additionalEqualities[i].second);
                if (firstTransformed != string::npos && secondTransformed != string::npos) {
                    matrix[firstTransformed][secondTransformed] = matrix[secondTransformed][firstTransformed] = true;
                }
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rax
testl %eax, %eax
jle 0x2d6c4
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
movq %r15, %rsi
xorl %edi, %edi
cmpq %rdi, %rdx
sete (%rsi,%rdi)
incq %rdi
cmpq %rdi, %rax
jne 0x2d6a6
incq %rdx
addq $0x100, %rsi            # imm = 0x100
cmpq %rax, %rdx
jne 0x2d6a4
testq %rbx, %rbx
sete %al
testl %ecx, %ecx
setle %dl
orb %al, %dl
jne 0x2d727
movl %ecx, %r13d
xorl %ebp, %ebp
movsbl (%rbx,%rbp,2), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x6500
movq %rax, %r12
movsbl 0x1(%rbx,%rbp,2), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x6500
cmpq $-0x1, %r12
je 0x2d71f
cmpq $-0x1, %rax
je 0x2d71f
movq %rax, %rcx
shlq $0x8, %rcx
addq %r15, %rcx
movb $0x1, %dl
movb %dl, (%r12,%rcx)
shlq $0x8, %r12
addq %r15, %r12
movb %dl, (%rax,%r12)
incq %rbp
cmpq %rbp, %r13
jne 0x2d6d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/src/edlib.cpp
// Function: AlignmentData::~AlignmentData()
~AlignmentData() {
        delete[] Ps;
        delete[] Ms;
        delete[] scores;
        delete[] firstBlocks;
        delete[] lastBlocks;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2d747
callq 0x64f0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2d755
callq 0x64f0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2d763
callq 0x64f0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2d771
callq 0x64f0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x2d780
popq %rbx
jmp 0x64f0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/src/edlib.cpp
// Function: AlignmentData::AlignmentData(int, int)
AlignmentData(int maxNumBlocks, int targetLength) {
        // We build a complete table and mark first and last block for each column
        // (because algorithm is banded so only part of each columns is used).
        // TODO: do not build a whole table, but just enough blocks for each column.
         Ps     = new Word[maxNumBlocks * targetLength];
         Ms     = new Word[maxNumBlocks * targetLength];
         scores = new  int[maxNumBlocks * targetLength];
         firstBlocks = new int[targetLength];
         lastBlocks  = new int[targetLength];
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
imull %edx, %esi
movslq %esi, %rax
leaq (,%rax,8), %r14
testl %eax, %eax
movq $-0x1, %r12
cmovsq %r12, %r14
leaq (,%rax,4), %r15
cmovsq %r12, %r15
movq %r14, %rdi
callq 0x6030
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x6030
movq %rax, 0x8(%rbx)
movq %r15, %rdi
callq 0x6030
movq %rax, 0x10(%rbx)
movslq %ebp, %rax
leaq (,%rax,4), %r14
testl %eax, %eax
cmovsq %r12, %r14
movq %r14, %rdi
callq 0x6030
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x6030
movq %rax, 0x20(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/VanAndelInstitute[P]intent/src/seq_tools.cpp
// Function: fix_qual_length(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string fix_qual_length(std::string seq, std::string qual) {
    if(qual.length() < seq.length()) {
        qual.insert(qual.begin(), seq.length() - qual.length(), 'A');
    } else if (qual.length() > seq.length()) {
        qual = qual.substr(0, seq.length());
    }
    return(qual);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rcx
movq %rcx, %rax
subq 0x8(%rdx), %rax
jbe 0x2dcee
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rax, %rcx
movl $0x41, %r8d
callq 0x66b0
jmp 0x2dd25
jae 0x2dd25
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x63f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2dd25
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x63c0
leaq 0x10(%r14), %rcx
movq %rcx, (%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x2dd44
movq %rdx, (%r14)
movq (%rax), %rcx
movq %rcx, 0x10(%r14)
jmp 0x2dd4a
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: initServer(int&, int)
void initServer(int& serverSock, int port) {
	struct sockaddr_in serverAddr;
	
	if((serverSock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
		printf("socket() failed\n");
		exit(1);
	}
	
	int yes = 1;
	if(setsockopt(serverSock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) < 0) {
		printf("setsockopt() failed\n");
		exit(1);
	}
	
	memset(&serverAddr, 0, sizeof(serverAddr));
	serverAddr.sin_family = AF_INET;
	serverAddr.sin_port = htons(port);
	serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	
	if(bind(serverSock, (sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {
		printf("bind() failed\n");
		exit(1);
	}
	
	if(listen(serverSock, MAXPLAYERS) < 0) {
		printf("listen() failed\n");
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x2090
movl %eax, (%rbx)
testl %eax, %eax
js 0x52b4
leaq -0x14(%rbp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x2330
testl %eax, %eax
js 0x52bd
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
rolw $0x8, %r14w
movw $0x2, (%rsi)
movw %r14w, 0x2(%rsi)
movl $0x0, 0x4(%rsi)
movl (%rbx), %edi
movl $0x10, %edx
callq 0x2060
testl %eax, %eax
js 0x52c6
movl (%rbx), %edi
movl $0xa, %esi
callq 0x2240
testl %eax, %eax
js 0x52cf
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x312b(%rip), %rdi      # 0x83e6
jmp 0x52d6
leaq 0x310e(%rip), %rdi      # 0x83d2
jmp 0x52d6
leaq 0x30f7(%rip), %rdi      # 0x83c4
jmp 0x52d6
leaq 0x30de(%rip), %rdi      # 0x83b4
callq 0x22b0
movl $0x1, %edi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: splitString(char**, char*, char const*)
void splitString(char* parts[], char* target, const char* delim) {
	char* tok;
	tok = std::strtok(target, delim);
	int i = 0;
	while (tok != NULL) {
		parts[i] = tok;
		tok = strtok(NULL, delim);
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x22e0
testq %rax, %rax
je 0x5315
movq %rax, (%r14)
xorl %edi, %edi
movq %rbx, %rsi
callq 0x22e0
addq $0x8, %r14
jmp 0x52fd
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: countChars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
int countChars(string l, char s) {
	int elements = 0;
	for (int i = 0; i < l.length(); i++) {
		if(l[i] == s) {
			elements++;
		}
	}
	return elements;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x5346
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
xorl %edi, %edi
xorl %eax, %eax
xorl %r8d, %r8d
cmpb %sil, (%rdx,%rdi)
sete %r8b
addl %r8d, %eax
incq %rdi
cmpq %rdi, %rcx
jne 0x532e
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: shuffle(std::vector<Card, std::allocator<Card>>, int)
vector<Card> shuffle(vector<Card> deck, int seed) {
	vector<Card> newDeck;
	newDeck.clear();
	
	for (int i = 1; i < deck.size(); i+=2) {
		newDeck.push_back(deck[i]);
	}
	for (int i = 0; i < deck.size(); i+=2) {
		newDeck.push_back(deck[i]);
	}
	if(seed == 0) {
		return newDeck;
	}
	else {
		return shuffle(newDeck, seed - 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r15
movq %rdi, -0x58(%rbp)
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %esi, %esi
callq 0x6c92
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %r13 # imm = 0x8E38E38E38E38E39
imulq %r13, %rax
cmpq $0x2, %rax
jb 0x53db
movl $0x1, %ebx
movl $0x48, %r14d
leaq -0x50(%rbp), %r12
addq %r14, %rsi
movq %r12, %rdi
callq 0x2fd4
addq $0x2, %rbx
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0x90, %r14
cmpq %rbx, %rax
ja 0x53ae
movq (%r15), %rsi
cmpq %rsi, 0x8(%r15)
je 0x541a
xorl %ebx, %ebx
leaq -0x50(%rbp), %r12
xorl %r14d, %r14d
addq %rbx, %rsi
movq %r12, %rdi
callq 0x2fd4
addq $0x2, %r14
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0x90, %rbx
cmpq %r14, %rax
ja 0x53ed
movl -0x2c(%rbp), %r14d
testl %r14d, %r14d
movq -0x58(%rbp), %rbx
je 0x5451
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x300c
decl %r14d
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x5349
leaq -0x70(%rbp), %rdi
callq 0x2f96
jmp 0x5477
movq -0x50(%rbp), %rax
movq %rax, (%rbx)
movq -0x48(%rbp), %rax
movq %rax, 0x8(%rbx)
movq -0x40(%rbp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2f96
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2f96
jmp 0x54a7
jmp 0x54a4
jmp 0x54a4
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2f96
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: composeSENDMessage[abi:cxx11](char, Card)
string composeSENDMessage(char type, Card cardToSend) {
	if(type == 'p') {
		//printf("About to send POST:\n%s\n", cardToSend.content.c_str());
		return "POST Server\n" + cardToSend.content;
	}
	else if(type == 'n') {
		//printf("About to send ANSWER:\n%s %s\n", cardToSend.owner.c_str(), cardToSend.content.c_str());
		return "ANSWER " + cardToSend.owner + "\n" + cardToSend.content;
	}
	else if (type == 'd') {
		//printf("About to send ADD:\n%s\n", cardToSend.content.c_str());
		return "ADD Server\n" + cardToSend.content;
	}
	else {
		return "";
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x64, %esi
je 0x560d
cmpl $0x6e, %esi
je 0x55c3
cmpl $0x70, %esi
jne 0x5624
leaq 0x2b50(%rip), %rsi      # 0x8111
jmp 0x5614
leaq 0x28(%r14), %rdx
leaq 0x2b50(%rip), %rsi      # 0x811e
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x69f6
leaq 0x2ad4(%rip), %rsi      # 0x80b5
movq %r15, %rdi
callq 0x2360
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5642
movq %rdx, -0x38(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x28(%rbp)
jmp 0x5649
leaq 0x2b12(%rip), %rsi      # 0x8126
movq %rbx, %rdi
movq %r14, %rdx
callq 0x69f6
jmp 0x56dd
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2a84(%rip), %rdx      # 0x80b6
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6cf2
jmp 0x56dd
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq -0x38(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x20d0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x5692
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x5698
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x56c4
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2230
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56dd
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x5708
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2230
jmp 0x5708
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5721
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: shuffle(std::vector<Player, std::allocator<Player>>, int)
vector<Player> shuffle(vector<Player> deck, int seed) {
	vector<Player> newDeck;
	newDeck.clear();
	
	for (int i = 1; i < deck.size(); i+=2) {
		newDeck.push_back(deck[i]);
	}
	for (int i = 0; i < deck.size(); i+=2) {
		newDeck.push_back(deck[i]);
	}
	if (seed == 0) {
		return newDeck;
	}
	else {
		return shuffle(newDeck, seed - 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r15
movq %rdi, -0x58(%rbp)
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %esi, %esi
callq 0x6cc2
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %r13 # imm = 0x2E8BA2E8BA2E8BA3
imulq %r13, %rax
cmpq $0x2, %rax
jb 0x57bb
movl $0x1, %ebx
movl $0x58, %r14d
leaq -0x50(%rbp), %r12
addq %r14, %rsi
movq %r12, %rdi
callq 0x691c
addq $0x2, %rbx
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0xb0, %r14
cmpq %rbx, %rax
ja 0x578e
movq (%r15), %rsi
cmpq %rsi, 0x8(%r15)
je 0x57fa
xorl %ebx, %ebx
leaq -0x50(%rbp), %r12
xorl %r14d, %r14d
addq %rbx, %rsi
movq %r12, %rdi
callq 0x691c
addq $0x2, %r14
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r13, %rax
addq $0xb0, %rbx
cmpq %r14, %rax
ja 0x57cd
movl -0x2c(%rbp), %r14d
testl %r14d, %r14d
movq -0x58(%rbp), %rbx
je 0x5831
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6954
decl %r14d
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x5729
leaq -0x70(%rbp), %rdi
callq 0x68a0
jmp 0x5857
movq -0x50(%rbp), %rax
movq %rax, (%rbx)
movq -0x48(%rbp), %rax
movq %rax, 0x8(%rbx)
movq -0x40(%rbp), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x68a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x68a0
jmp 0x5887
jmp 0x5884
jmp 0x5884
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x68a0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: composeNOTIFYMessage(char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string composeNOTIFYMessage(char purpose, string playerName) {
	if (purpose == 'j') {
		return "NOTIFY Server\nCP: " + playerName;
	}
	else if (purpose == 'w') {
		return "NOTIFY Server\nwinner: " + playerName;
	}
	else if(purpose == 'n') {
		stringstream s;
		s << answers.size();
		return "NOTIFY Server\nplayers: " + s.str();
	}
	else if(purpose == 'q') {
		return "NOTIFY Server\nquit: Server";
	}
	else {
		return "";
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
cmpl $0x70, %esi
jg 0x5946
cmpl $0x6a, %esi
je 0x596f
cmpl $0x6e, %esi
jne 0x5959
leaq -0x1b0(%rbp), %rdi
callq 0x21a0
movq 0x5d0b(%rip), %rax      # 0xb5e0
subq 0x5cfc(%rip), %rax      # 0xb5d8
leaq -0x1a0(%rbp), %rdi
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %rsi # imm = 0x8E38E38E38E38E39
imulq %rax, %rsi
callq 0x2190
leaq -0x198(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2300
leaq 0x284b(%rip), %rcx      # 0x815c
leaq -0x28(%rbp), %rdi
movl $0x17, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2250
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x599f
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x59a5
cmpl $0x71, %esi
je 0x5980
cmpl $0x77, %esi
jne 0x5959
leaq 0x27ee(%rip), %rsi      # 0x8145
jmp 0x5976
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x274f(%rip), %rdx      # 0x80b6
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x5998
leaq 0x27bc(%rip), %rsi      # 0x8132
movq %rbx, %rdi
callq 0x69f6
jmp 0x59f4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x27e6(%rip), %rsi      # 0x8174
leaq 0x27f9(%rip), %rdx      # 0x818e
movq %rbx, %rdi
callq 0x6cf2
jmp 0x59f4
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59d5
movq -0x18(%rbp), %rsi
incq %rsi
callq 0x2230
movq 0x55f4(%rip), %rsi      # 0xafd0
leaq -0x1b0(%rbp), %rdi
callq 0x21c0
leaq -0x130(%rbp), %rdi
callq 0x2100
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a24
movq -0x18(%rbp), %rsi
incq %rsi
callq 0x2230
jmp 0x5a24
jmp 0x5a21
movq %rax, %rbx
movq 0x55a5(%rip), %rsi      # 0xafd0
leaq -0x1b0(%rbp), %rdi
callq 0x21c0
leaq -0x130(%rbp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: shutdown()
void shutdown() {
	for (int i = 0; i < players.size(); i++) {
		string quit = composeNOTIFYMessage('q', "");
		bytesSent = send(players[i].getSocket(), (char*)quit.c_str(), 100, 0);
		if(bytesSent <= 0) {
			printf("Couldn't send quit.\n");
			exit(1);
		}
	}	
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x5bdd(%rip), %rax      # 0xb640
cmpq 0x5bce(%rip), %rax      # 0xb638
jne 0x5a76
movl $0x1, %edi
callq 0x2270
leaq -0x60(%rbp), %r14
leaq -0x40(%rbp), %r13
xorl %r15d, %r15d
leaq 0x262e(%rip), %rbx      # 0x80b6
xorl %r12d, %r12d
movq %r14, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x6cf2
movq %r13, -0x50(%rbp)
movq $0x1a, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x2340
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movups 0x26b2(%rip), %xmm0     # 0x817e
movups %xmm0, 0xa(%rax)
movups 0x269d(%rip), %xmm0     # 0x8174
movups %xmm0, (%rax)
movq %rcx, -0x48(%rbp)
movq -0x50(%rbp), %rax
movb $0x0, (%rax,%rcx)
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x5afb
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2230
movq 0x5b36(%rip), %rdi      # 0xb638
addq %r15, %rdi
callq 0x2ac4
movq -0x50(%rbp), %rsi
movl $0x64, %edx
movl %eax, %edi
xorl %ecx, %ecx
callq 0x2140
movl %eax, 0x576e(%rip)      # 0xb290
testl %eax, %eax
jle 0x5b70
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x5b3b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2230
incq %r12
movq 0x5afb(%rip), %rax      # 0xb640
subq 0x5aec(%rip), %rax      # 0xb638
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %rcx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rcx, %rax
addq $0x58, %r15
cmpq %r12, %rax
ja 0x5a8b
jmp 0x5a6c
leaq 0x287f(%rip), %rdi      # 0x83f6
callq 0x22b0
jmp 0x5a6c
movq %rax, %rbx
movq -0x70(%rbp), %rdi
movq %r14, %r13
cmpq %r14, %rdi
jne 0x5b9e
jmp 0x5baa
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x5baa
movq (%r13), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: getPlayer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Player getPlayer(string name) {
	for (int i = 0; i < players.size(); i++) {
		if (strcmp(players[i].getName().c_str(), name.c_str()) == 0) {
			return players[i];
		}
	}
	return Player();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq 0x5071(%rip), %rsi      # 0xb638
cmpq %rsi, 0x5072(%rip)      # 0xb640
setne %bl
je 0x66b8
xorl %r15d, %r15d
xorl %r14d, %r14d
addq %r15, %rsi
leaq -0x60(%rbp), %rdi
callq 0x2a8e
movq -0x60(%rbp), %r12
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq %r12, %rdi
callq 0x2290
movl %eax, %r13d
leaq -0x50(%rbp), %rax
cmpq %rax, %r12
je 0x6617
movq -0x50(%rbp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x2230
testl %r13d, %r13d
movq -0x30(%rbp), %r12
je 0x6654
incq %r14
movq 0x5016(%rip), %rax      # 0xb640
movq 0x5007(%rip), %rsi      # 0xb638
subq %rsi, %rax
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %rcx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rcx, %rax
addq $0x58, %r15
cmpq %r14, %rax
seta %bl
ja 0x65dd
jmp 0x66b8
movq 0x4fdd(%rip), %r13      # 0xb638
leaq 0x10(%r12), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%r12)
leaq (%r15,%r13), %r14
addq $0x28, %r14
movq -0x28(%r14), %rsi
movq -0x20(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x315c
movq -0x8(%r14), %rax
movq %rax, 0x20(%r12)
leaq 0x28(%r12), %rdi
movq %rdi, -0x40(%rbp)
movq %r14, %rsi
callq 0x300c
leaq 0x40(%r12), %rdi
leaq (%r15,%r13), %rsi
addq $0x40, %rsi
callq 0x300c
testb $0x1, %bl
movq -0x30(%rbp), %rax
jne 0x66c5
movq -0x30(%rbp), %rdi
callq 0x28f8
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
callq 0x2f96
jmp 0x66e5
movq %rax, %r14
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0x6701
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2230
movq %r14, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: deletePlayer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void deletePlayer(string playerName) {
	vector<Player> temp;
	for (int i = 0; i < players.size(); i++) {
		if (strcmp(players[i].getName().c_str(), playerName.c_str()) != 0) {
			temp.push_back(players[i]);
		}
		else {
			delete &players[i];
		}
		
	}
	players = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, -0x50(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movq 0x4f04(%rip), %rsi      # 0xb638
cmpq %rsi, 0x4f05(%rip)      # 0xb640
je 0x6820
xorl %r15d, %r15d
xorl %r14d, %r14d
addq %r15, %rsi
leaq -0x70(%rbp), %rdi
callq 0x2a8e
movq -0x70(%rbp), %r12
movq -0x50(%rbp), %rax
movq (%rax), %rsi
movq %r12, %rdi
callq 0x2290
movl %eax, %r13d
leaq -0x60(%rbp), %rax
cmpq %rax, %r12
je 0x6781
movq -0x60(%rbp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x2230
movq 0x4eb0(%rip), %rbx      # 0xb638
leaq (%rbx,%r15), %r12
testl %r13d, %r13d
je 0x679f
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq 0x691c
jmp 0x67ed
leaq (%rbx,%r15), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
leaq (%rbx,%r15), %rdi
addq $0x40, %rdi
callq 0x2f96
leaq (%rbx,%r15), %r13
addq $0x28, %r13
movq %r13, %rdi
callq 0x2f96
movq -0x48(%rbp), %rax
movq -0x28(%r13), %rdi
cmpq %rdi, %rax
je 0x67e0
movq (%rax), %rsi
incq %rsi
callq 0x2230
movl $0x58, %esi
movq %r12, %rdi
callq 0x2230
incq %r14
movq 0x4e49(%rip), %rax      # 0xb640
movq 0x4e3a(%rip), %rsi      # 0xb638
subq %rsi, %rax
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %rcx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rcx, %rax
addq $0x58, %r15
cmpq %r14, %rax
ja 0x6747
leaq 0x4e11(%rip), %rdi      # 0xb638
leaq -0x40(%rbp), %rsi
callq 0x6a88
leaq -0x40(%rbp), %rdi
callq 0x68a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x684c
jmp 0x684c
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x68a0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O1/mattearly[P]english-name-generator/src/humangenerator.cpp
// Function: HumanGenerator::HumanGenerator()
HumanGenerator::HumanGenerator()
{
  int isMale = getRandomNumber(0, 1);
  if (isMale) {
    FirstName = "John";
  } else {
    FirstName = "Jane";
  }

  LastName = "Doe";
  SSN = "555-555-5555";

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rbp
movq %rbp, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %r15
leaq 0x50(%rdi), %r12
movq %r12, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x14(%rsp), %rdi
movl $0x0, (%rdi)
leaq 0x10(%rsp), %rsi
movl $0x1, (%rsi)
callq 0x2fe4
testl %eax, %eax
movq 0x8(%rbx), %rdx
leaq 0x1c0e(%rip), %rax      # 0x4009
leaq 0x1c02(%rip), %rcx      # 0x4004
cmoveq %rax, %rcx
movl $0x4, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21a0
movq 0x28(%rbx), %rdx
leaq 0x1bed(%rip), %rcx      # 0x400e
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x21a0
movq 0x48(%rbx), %rdx
leaq 0x1bd6(%rip), %rcx      # 0x4012
movl $0xc, %r8d
movq %r15, %rdi
xorl %esi, %esi
callq 0x21a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x245d
movq %rax, 0x8(%rsp)
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x2476
movq (%r12), %rsi
incq %rsi
callq 0x2150
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x248a
movq (%rbp), %rsi
incq %rsi
callq 0x2150
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x249e
movq (%r13), %rsi
incq %rsi
callq 0x2150
movq 0x8(%rsp), %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/mattearly[P]english-name-generator/src/humangenerator.cpp
// Function: HumanGenerator::newFirstName()
void HumanGenerator::newFirstName()
{
  ifstream firstNameFile("./data/first_names.dat");
  string tmp = "FIRSTNAMEFAILED";

  if (firstNameFile.is_open()) {
    int seed = getRandomNumber(0, 3998);
    for (int i = 0; i < seed; i++) {
      getline(firstNameFile, tmp);   ///skip lines = to the seed
    }
    getline(firstNameFile, tmp);
  }

  FirstName = tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
leaq 0x1b5e(%rip), %rsi      # 0x401f
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x21f0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1b52(%rip), %rsi      # 0x4036
leaq 0x1b5a(%rip), %rdx      # 0x4045
movq %rsp, %rdi
callq 0x2ce4
leaq 0xa0(%rsp), %rdi
callq 0x2050
testb %al, %al
je 0x2576
leaq 0x24(%rsp), %rdi
movl $0x0, (%rdi)
leaq 0x20(%rsp), %rsi
movl $0xf9e, (%rsi)          # imm = 0xF9E
callq 0x2fe4
movl %eax, %ebp
testl %eax, %eax
jle 0x2550
movq %rsp, %r15
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
decl %ebp
jne 0x2528
movq 0x28(%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %edx
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x2200
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x20a0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2597
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x28(%rsp), %rdi
callq 0x2060
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25bc
jmp 0x25bc
jmp 0x25bc
movq %rax, %rbx
jmp 0x25d5
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x25d5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x28(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mattearly[P]english-name-generator/src/humangenerator.cpp
// Function: HumanGenerator::newLastName()
void HumanGenerator::newLastName()
{
  ifstream lastNameFile("./data/last_names.dat");
  string tmp = "LASTNAMEFAILED";

  if (lastNameFile.is_open()) {
    int seed = getRandomNumber(0, 998);
    for (int i = 0; i < seed; i++) {
      getline(lastNameFile, tmp);   ///skip lines = to the seed
    }
    getline(lastNameFile, tmp);
  }

  LastName = tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
leaq 0x1a45(%rip), %rsi      # 0x4046
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x21f0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a38(%rip), %rsi      # 0x405c
leaq 0x1a3f(%rip), %rdx      # 0x406a
movq %rsp, %rdi
callq 0x2ce4
leaq 0xa0(%rsp), %rdi
callq 0x2050
testb %al, %al
je 0x26b6
leaq 0x24(%rsp), %rdi
movl $0x0, (%rdi)
leaq 0x20(%rsp), %rsi
movl $0x3e6, (%rsi)          # imm = 0x3E6
callq 0x2fe4
movl %eax, %ebp
testl %eax, %eax
jle 0x2690
movq %rsp, %r15
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
decl %ebp
jne 0x2668
movq 0x28(%rsp), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %edx
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x2200
addq $0x20, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x20a0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x26db
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x28(%rsp), %rdi
callq 0x2060
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2700
jmp 0x2700
jmp 0x2700
movq %rax, %rbx
jmp 0x2719
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2719
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x28(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mattearly[P]english-name-generator/src/main.cpp
// Function: main
int main(int argc, char** argv) {

  cout << "BEGIN RANDOM NAME GEN!!\n";

  HumanGenerator human;
  for (int i = 0; i < 10; i++) {
    human.newFirstName();
    human.newLastName();
    human.newSSN();

    cout << human.getFirstName() << endl;
    cout << human.getLastName() << endl;
    cout << human.getSSN() << endl;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0x324c(%rip), %rbx      # 0x5fd8
leaq 0x13e6(%rip), %rsi      # 0x4179
movl $0x18, %edx
movq %rbx, %rdi
callq 0x2160
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x238c
leaq 0x18(%rsp), %r13
movl $0xa, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x24a8
movq %r14, %rdi
callq 0x25e8
movq %r14, %rdi
callq 0x272c
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b92
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2160
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2e32
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b64
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2160
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2e90
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
movq %r15, %rdi
movq %r14, %rsi
callq 0x2bba
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2160
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2eee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
decl %ebp
jne 0x2dbc
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f11
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f2c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f47
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2150
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f61
jmp 0x2f61
jmp 0x2f61
movq %rax, %rbx
jmp 0x2f84
jmp 0x2f6a
jmp 0x2f6a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2f84
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2150
leaq 0x28(%rsp), %rdi
callq 0x2f96
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/mattearly[P]english-name-generator/src/utility.cpp
// Function: getRandomNumber(int const&, int const&)
int getRandomNumber(const int& start, const int& end) {

  static long long int timeSeed = std::chrono::high_resolution_clock::now().time_since_epoch().count();

  static std::seed_seq ss{uint32_t(timeSeed & 0xffffffff), uint32_t(timeSeed >> 32)};

  std::uniform_int_distribution<int> unif(start, end);

  static std::mt19937 mgen(ss);

  return unif(mgen);

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0x3144(%rip), %al       # 0x6138
testb %al, %al
je 0x3032
movb 0x315a(%rip), %al       # 0x6158
testb %al, %al
je 0x3039
movl (%r14), %eax
movl (%rbx), %ecx
movl %eax, (%rsp)
movl %ecx, 0x4(%rsp)
movb 0x44d4(%rip), %al       # 0x74e8
testb %al, %al
je 0x3092
leaq 0x3141(%rip), %rsi      # 0x6160
movq %rsp, %rdi
movq %rdi, %rdx
callq 0x3652
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2230
jmp 0x2ff8
leaq 0x3118(%rip), %rdi      # 0x6158
callq 0x21e0
testl %eax, %eax
je 0x3002
movq 0x30e0(%rip), %rax      # 0x6130
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x30e3(%rip), %rdi      # 0x6140
movl $0x2, %edx
callq 0x30ee
leaq 0x11e(%rip), %rdi       # 0x318c
leaq 0x30cb(%rip), %rsi      # 0x6140
leaq 0x309c(%rip), %rdx      # 0x6118
callq 0x2120
leaq 0x30d0(%rip), %rdi      # 0x6158
callq 0x20d0
jmp 0x3002
leaq 0x444f(%rip), %rdi      # 0x74e8
callq 0x21e0
testl %eax, %eax
je 0x3018
leaq 0x30b3(%rip), %rdi      # 0x6160
leaq 0x308c(%rip), %rsi      # 0x6140
callq 0x3376
leaq 0x4428(%rip), %rdi      # 0x74e8
callq 0x20d0
jmp 0x3018
movq %rax, %rbx
leaq 0x4414(%rip), %rdi      # 0x74e8
jmp 0x30e0
movq %rax, %rbx
leaq 0x3078(%rip), %rdi      # 0x6158
callq 0x20c0
movq %rbx, %rdi
callq 0x21c0
nop