LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/src/edlib.cpp
// Function: createReverseCopy(unsigned char const*, int)
static inline unsigned char* createReverseCopy(const unsigned char* const seq, const int length) {
    unsigned char* rSeq = new unsigned char[length];
    for (int i = 0; i < length; i++) {
        rSeq[i] = seq[length - i - 1];
    }
    return rSeq;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r14
movq %r14, %rdi
callq 0x6030
xorl %ecx, %ecx
testl %r14d, %r14d
movl $0x0, %edx
cmovgl %r14d, %edx
decl %r14d
cmpq %rcx, %rdx
je 0x239e8
movslq %r14d, %r14
movb (%rbx,%r14), %sil
movb %sil, (%rax,%rcx)
incq %rcx
jmp 0x239d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/src/edlib.cpp
// Function: calculateBlock(unsigned long, unsigned long, unsigned long, int, unsigned long&, unsigned long&)
static inline int calculateBlock(Word Pv, Word Mv, Word Eq, const int hin,
                                 Word &PvOut, Word &MvOut) {
    // hin can be 1, -1 or 0.
    // 1  -> 00...01
    // 0  -> 00...00
    // -1 -> 11...11 (2-complement)

    Word hinIsNeg = static_cast<Word>(hin >> 2) & WORD_1; // 00...001 if hin is -1, 00...000 if 0 or 1

    Word Xv = Eq | Mv;
    // This is instruction below written using 'if': if (hin < 0) Eq |= (Word)1;
    Eq |= hinIsNeg;
    Word Xh = (((Eq & Pv) + Pv) ^ Pv) | Eq;

    Word Ph = Mv | ~(Xh | Pv);
    Word Mh = Pv & Xh;

    int hout = 0;
    // This is instruction below written using 'if': if (Ph & HIGH_BIT_MASK) hout = 1;
    hout = (Ph & HIGH_BIT_MASK) >> (WORD_SIZE - 1);
    // This is instruction below written using 'if': if (Mh & HIGH_BIT_MASK) hout = -1;
    hout -= (Mh & HIGH_BIT_MASK) >> (WORD_SIZE - 1);

    Ph <<= 1;
    Mh <<= 1;

    // This is instruction below written using 'if': if (hin < 0) Mh |= (Word)1;
    Mh |= hinIsNeg;
    // This is instruction below written using 'if': if (hin > 0) Ph |= (Word)1;
    Ph |= static_cast<Word>((hin + 1) >> 1);

    PvOut = Mh | ~(Xv | Ph);
    MvOut = Ph & Xv;

    return hout;
}

// Assembly:
pushq %rbx
movl %ecx, %r10d
shrl $0x2, %r10d
andl $0x1, %r10d
movq %r10, %rax
orq %rdx, %rax
orq %rsi, %rdx
movq %rax, %r11
andq %rdi, %r11
addq %rdi, %r11
xorq %rdi, %r11
orq %rax, %r11
movq %r11, %rbx
orq %rdi, %rbx
notq %rbx
orq %rsi, %rbx
andq %rdi, %r11
movq %rbx, %rax
shrq $0x3f, %rax
movq %r11, %rsi
sarq $0x3f, %rsi
addl %esi, %eax
addq %rbx, %rbx
addq %r11, %r11
incl %ecx
shrl %ecx
orq %rbx, %rcx
movq %rcx, %rsi
orq %rdx, %rsi
notq %rsi
orq %r10, %r11
orq %rsi, %r11
movq %r11, (%r8)
andq %rdx, %rcx
movq %rcx, (%r9)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/src/edlib.cpp
// Function: allBlockCellsLarger(Block, int)
static inline bool allBlockCellsLarger(const Block block, const int k) {
    vector<int> scores = getBlockCellValues(block);
    for (int i = 0; i < WORD_SIZE; i++) {
        if (scores[i] <= k) return false;
    }
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edi, %ebx
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x24a63
xorl %edx, %edx
movq (%r14), %rax
movq %rdx, %rcx
cmpq $0x40, %rdx
je 0x24a48
leaq 0x1(%rcx), %rdx
cmpl %ebx, (%rax,%rcx,4)
jg 0x24a36
cmpq $0x40, %rcx
setae %bl
leaq 0x20(%rsp), %rdi
callq 0x22326
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/src/edlib.cpp
// Function: getBlockCellValues(Block)
static inline vector<int> getBlockCellValues(const Block block) {
    vector<int> scores(WORD_SIZE);
    int score = block.score;
    Word mask = HIGH_BIT_MASK;
    for (int i = 0; i < WORD_SIZE - 1; i++) {
        scores[i] = score;
        if (block.P & mask) score--;
        if (block.M & mask) score++;
        mask >>= 1;
    }
    scores[WORD_SIZE - 1] = score;
    return scores;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
pushq $0x40
popq %rsi
leaq 0xf(%rsp), %rdx
callq 0x24d68
movl 0x30(%rsp), %eax
movq (%rbx), %rcx
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rsi
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
xorl %r8d, %r8d
cmpq $0x3f, %r8
je 0x24ac2
movl %eax, (%rcx,%r8,4)
movq %rdx, %r9
andq %rdi, %r9
cmpq $0x1, %r9
adcl $-0x1, %eax
movq %rsi, %r9
andq %rdi, %r9
cmpq $0x1, %r9
sbbl $-0x1, %eax
shrq %rdi
incq %r8
jmp 0x24a96
movl %eax, 0xfc(%rcx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rsi), %rax
movl %eax, %ecx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movq %rdi, %rsi
cmpq %rax, %rdx
je 0x24b1c
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x24b10
cmpq %rdi, %rdx
sete (%rsi,%rdi)
incq %rdi
jmp 0x24aff
incq %rdx
addq $0x100, %rsi            # imm = 0x100
jmp 0x24af8
testq %r14, %r14
je 0x24b7c
xorl %ebp, %ebp
testl %ebx, %ebx
cmovlel %ebp, %ebx
cmpq %rbp, %rbx
je 0x24b7c
movsbl (%r14,%rbp,2), %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x6520
movq %rax, %r13
movsbl 0x1(%r14,%rbp,2), %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x6520
cmpq $-0x1, %r13
je 0x24b77
cmpq $-0x1, %rax
je 0x24b77
movq %rax, %rcx
shlq $0x8, %rcx
addq %r12, %rcx
movb $0x1, %dl
movb %dl, (%r13,%rcx)
shlq $0x8, %r13
addq %r12, %r13
movb %dl, (%rax,%r13)
incq %rbp
jmp 0x24b28
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x24b9d
callq 0x6500
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x24bab
callq 0x6500
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x24bb9
callq 0x6500
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x24bc7
callq 0x6500
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x24bd6
popq %rbx
jmp 0x6500
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x1
popq %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)
movl %ebp, %r14d
shlq $0x2, %r14
testl %ebp, %ebp
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
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/src/seq_tools.cpp
// Function: getEnds(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::vector<int> getEnds(std::string s1, std::string s2) {
  std::vector<int> res;
  EdlibAlignResult result = edlibAlign(s1.c_str(),
                                       s1.length(),
                                       s2.c_str(),
                                       s2.length(),
                                       edlibNewAlignConfig(-1,
                                                           EDLIB_MODE_HW,
                                                           EDLIB_TASK_PATH,
                                                           NULL,
                                                           0));
  if (result.status == EDLIB_STATUS_OK) {
    res.push_back(result.editDistance);
    res.push_back(result.startLocations[0]);
    res.push_back(result.endLocations[0]);
  } else {
    res.push_back(999);
    res.push_back(-1);
    res.push_back(-1);
  }
  edlibFreeAlignResult(result);
  return(res);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %r14
movq 0x8(%rsi), %r15
movq (%rdx), %r12
movq 0x8(%rdx), %r13
leaq 0x70(%rsp), %rdi
pushq $-0x1
popq %rsi
pushq $0x2
popq %rcx
movl %ecx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x24951
movups 0x70(%rsp), %xmm0
movups 0x80(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %r12, %rcx
movl %r13d, %r8d
callq 0x22528
cmpl $0x0, 0x40(%rsp)
je 0x25113
leaq 0x3c(%rsp), %rsi
movl $0x3e7, (%rsi)          # imm = 0x3E7
movq %rbx, %rdi
callq 0x24bf2
leaq 0x3c(%rsp), %rsi
orl $-0x1, (%rsi)
movq %rbx, %rdi
callq 0x24bf2
leaq 0x3c(%rsp), %rsi
orl $-0x1, (%rsi)
movq %rbx, %rdi
callq 0x24bf2
jmp 0x2513a
leaq 0x44(%rsp), %rsi
movq %rbx, %rdi
callq 0x25f58
movq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x25f58
movq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x25f58
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movups 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2497e
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x25176
jmp 0x25176
jmp 0x25176
movq %rax, %r14
movq %rbx, %rdi
callq 0x22326
movq %r14, %rdi
callq 0x66a0
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
movq %rcx, %rdx
subq 0x8(%r14), %rdx
jbe 0x251b5
movq (%r14), %rsi
pushq $0x41
popq %rcx
movq %r14, %rdi
callq 0x64e0
jmp 0x251da
jae 0x251da
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6410
movq %r14, %rdi
movq %r15, %rsi
callq 0x64d0
movq %r15, %rdi
callq 0x6768
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6510
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/src/seq_tools.cpp
// Function: fix_barcodes(ParsedBarcode&)
void fix_barcodes(ParsedBarcode &bc) {
    if(! v2_bc1_whitelisted(bc.barcode1)){
        bc.barcode1 = v2_corrected_bc(bc.barcode1, V2_BC1, 2);
        if(bc.barcode1 == "") {
            bc.status = BC_ERROR_BAD_BARCODE;
        } else {
            bc.bc_fixed = true;
        }
    }
    if(! v2_bc2_whitelisted(bc.barcode2)){
        bc.barcode2 = v2_corrected_bc(bc.barcode2, V2_BC2, 2);
        if(bc.barcode2 == "") {
            bc.status = BC_ERROR_BAD_BARCODE;
        } else {
            bc.bc_fixed = true;
        }
    }
    if(bc.bc_fixed) {
        fix_quality_lengths(bc);
    }
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6580
movq %r15, %rdi
callq 0x2530d
movl %eax, %ebp
leaq 0x88(%rsp), %rdi
callq 0x6768
testb %bpl, %bpl
jne 0x25681
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x6580
leaq 0x132c7(%rip), %rsi     # 0x388d0
leaq 0xd8(%rsp), %rdi
callq 0x2617e
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xd8(%rsp), %rdx
pushq $0x2
popq %rcx
callq 0x257b7
leaq 0x48(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x64d0
movq %r15, %rdi
callq 0x6768
leaq 0xd8(%rsp), %rdi
callq 0x14bd8
leaq 0x28(%rsp), %rdi
callq 0x6768
leaq 0x2dcf(%rip), %rsi      # 0x28435
movq %r14, %rdi
callq 0x1a703
testb %al, %al
je 0x2567a
movl $0x4, (%rbx)
jmp 0x25681
movb $0x1, 0xc8(%rbx)
leaq 0x48(%rbx), %r14
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6580
movq %r15, %rdi
callq 0x2532c
movl %eax, %ebp
leaq 0x68(%rsp), %rdi
callq 0x6768
testb %bpl, %bpl
jne 0x2573e
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6580
leaq 0x1323a(%rip), %rsi     # 0x38900
leaq 0xa8(%rsp), %rdi
callq 0x2617e
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
pushq $0x2
popq %rcx
callq 0x257b7
leaq 0x48(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x64d0
movq %r15, %rdi
callq 0x6768
leaq 0xa8(%rsp), %rdi
callq 0x14bd8
leaq 0x8(%rsp), %rdi
callq 0x6768
leaq 0x2d12(%rip), %rsi      # 0x28435
movq %r14, %rdi
callq 0x1a703
testb %al, %al
je 0x25737
movl $0x4, (%rbx)
jmp 0x2573e
movb $0x1, 0xc8(%rbx)
cmpb $0x1, 0xc8(%rbx)
jne 0x2574f
movq %rbx, %rdi
callq 0x251f2
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x14bd8
jmp 0x25772
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x257aa
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x14bd8
jmp 0x2578e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x257aa
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x257aa
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x6768
movq %rbx, %rdi
callq 0x66a0
// File: /workspace/github_cpp_makefile_star2_O2/VanAndelInstitute[P]intent/src/seq_tools.cpp
// Function: v2_corrected_bc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, int)
std::string v2_corrected_bc(std::string bc, std::set<std::string> whitelist, int maxdist) {
  int mindist = 999;
  std::string best_candidate = "";
  bool ambig = false;
  for(auto cand : whitelist) {
    int dist = 999;
    if(((bc.length() - cand.length())^2) < 4)
      dist = levenshteinDistance(bc, cand, maxdist);
    if(dist < mindist) {
      mindist = dist;
      best_candidate = cand;
      ambig = false;
    } else if (dist == mindist) {
      ambig = true;
    }
  }
  if(mindist <= maxdist) {
    return(best_candidate);
  } else {
    return("");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x2c5c(%rip), %rsi      # 0x28435
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %r13
movq %r13, %rdx
callq 0x1463a
movq 0x18(%r14), %rbx
addq $0x8, %r14
movl %ebp, 0x4(%rsp)
movslq %ebp, %rax
movq %rax, 0x30(%rsp)
movl $0x3e7, %ebp            # imm = 0x3E7
cmpq %r14, %rbx
je 0x25867
leaq 0x20(%rbx), %rsi
movq %r13, %rdi
callq 0x6580
movq 0x8(%r15), %rax
subq 0x40(%rsp), %rax
movl $0x3e7, %r12d           # imm = 0x3E7
cmpq $0x3, %rax
ja 0x2583d
movq %r15, %rdi
movq %r13, %rsi
movq 0x30(%rsp), %rdx
callq 0x25911
movl %eax, %r12d
cmpl %ebp, %r12d
jge 0x25852
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x6280
movl %r12d, %ebp
movq %r13, %rdi
callq 0x6768
movq %rbx, %rdi
callq 0x6470
movq %rax, %rbx
jmp 0x25804
cmpl 0x4(%rsp), %ebp
jle 0x25888
leaq 0x2bc1(%rip), %rsi      # 0x28435
leaq 0x38(%rsp), %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1463a
jmp 0x258cf
movq 0x8(%rsp), %rbx
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x258b0
movq %rdx, (%rbx)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x258b6
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6768
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x258ed
movq %rax, %rbx
jmp 0x258ff
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6768
leaq 0x10(%rsp), %rdi
callq 0x6768
movq %rbx, %rdi
callq 0x66a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
pushq $0x6
popq %rdx
callq 0x20a0
movl %eax, (%rbx)
testl %eax, %eax
js 0x42d2
leaq -0x14(%rbp), %rcx
movl $0x1, (%rcx)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x2330
testl %eax, %eax
js 0x42db
leaq -0x24(%rbp), %rsi
andq $0x0, 0x8(%rsi)
movw $0x2, (%rsi)
rolw $0x8, %r14w
movw %r14w, 0x2(%rsi)
andl $0x0, 0x4(%rsi)
movl (%rbx), %edi
pushq $0x10
popq %rdx
callq 0x2060
testl %eax, %eax
js 0x42e4
movl (%rbx), %edi
pushq $0xa
popq %rsi
callq 0x2240
testl %eax, %eax
js 0x42ed
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2107(%rip), %rdi      # 0x63e0
jmp 0x42f4
leaq 0x20ea(%rip), %rdi      # 0x63cc
jmp 0x42f4
leaq 0x20d3(%rip), %rdi      # 0x63be
jmp 0x42f4
leaq 0x20ba(%rip), %rdi      # 0x63ae
callq 0x22c0
pushq $0x1
popq %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4331
movq %rax, (%r14)
xorl %edi, %edi
movq %rbx, %rsi
callq 0x22e0
addq $0x8, %r14
jmp 0x4319
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x435d
movq (%rdi), %r8
xorl %r9d, %r9d
cmpb %sil, (%r8,%rdx)
sete %r9b
addl %r9d, %eax
incq %rdx
jmp 0x4342
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
movq %r12, %rdi
callq 0x5140
pushq $0x1
popq %rbx
pushq $0x48
popq %r14
movq %r14, %r13
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %rcx, %rax
subq %rsi, %rax
cqto
idivq %r14
cmpq %rbx, %rax
jbe 0x43cd
addq %r13, %rsi
movq %r12, %rdi
callq 0x2c5e
addq $0x2, %rbx
addq $0x90, %r13
jmp 0x439e
xorl %r13d, %r13d
pushq $0x48
popq %rbx
leaq -0x50(%rbp), %r12
xorl %r14d, %r14d
subq %rsi, %rcx
movq %rcx, %rax
cqto
idivq %rbx
cmpq %r14, %rax
jbe 0x4409
addq %r13, %rsi
movq %r12, %rdi
callq 0x2c5e
addq $0x2, %r14
movq (%r15), %rsi
movq 0x8(%r15), %rcx
addq $0x90, %r13
jmp 0x43da
movl -0x2c(%rbp), %r14d
testl %r14d, %r14d
je 0x4440
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2cdc
movq -0x58(%rbp), %rbx
decl %r14d
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x435f
leaq -0x70(%rbp), %rdi
callq 0x2c32
jmp 0x4467
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rbx
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)
andq $0x0, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2c32
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 0x2c32
jmp 0x4497
jmp 0x4494
jmp 0x4494
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2c32
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/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 0x45c1
cmpl $0x6e, %esi
je 0x4574
cmpl $0x70, %esi
jne 0x45d5
leaq 0x1b6f(%rip), %rsi      # 0x60e1
jmp 0x45c8
leaq 0x28(%r14), %rdx
leaq 0x1b6f(%rip), %rsi      # 0x60ee
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x52f9
leaq 0x1af3(%rip), %rdx      # 0x6085
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x5398
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x536f
leaq -0x38(%rbp), %rdi
callq 0x2140
leaq -0x58(%rbp), %rdi
callq 0x2140
jmp 0x45e8
leaq 0x1b2e(%rip), %rsi      # 0x60f6
movq %rbx, %rdi
movq %r14, %rdx
callq 0x52f9
jmp 0x45e8
leaq 0x1aaa(%rip), %rsi      # 0x6086
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x515c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2140
jmp 0x4607
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
movq %r12, %rdi
callq 0x514e
pushq $0x1
popq %rbx
pushq $0x58
popq %r14
movq %r14, %r13
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %rcx, %rax
subq %rsi, %rax
cqto
idivq %r14
cmpq %rbx, %rax
jbe 0x4686
addq %r13, %rsi
movq %r12, %rdi
callq 0x5198
addq $0x2, %rbx
addq $0xb0, %r13
jmp 0x4657
xorl %r13d, %r13d
pushq $0x58
popq %rbx
leaq -0x50(%rbp), %r12
xorl %r14d, %r14d
subq %rsi, %rcx
movq %rcx, %rax
cqto
idivq %rbx
cmpq %r14, %rax
jbe 0x46c2
addq %r13, %rsi
movq %r12, %rdi
callq 0x5198
addq $0x2, %r14
movq (%r15), %rsi
movq 0x8(%r15), %rcx
addq $0xb0, %r13
jmp 0x4693
movl -0x2c(%rbp), %r14d
testl %r14d, %r14d
je 0x46f9
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x51ee
movq -0x58(%rbp), %rbx
decl %r14d
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x4618
leaq -0x70(%rbp), %rdi
callq 0x5114
jmp 0x4720
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rbx
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)
andq $0x0, -0x40(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x5114
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 0x5114
jmp 0x4750
jmp 0x474d
jmp 0x474d
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x5114
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x77, %esi
je 0x4809
cmpl $0x6e, %esi
je 0x4795
cmpl $0x71, %esi
je 0x4800
cmpl $0x6a, %esi
jne 0x481a
leaq 0x196f(%rip), %rsi      # 0x6102
jmp 0x4810
leaq -0x1b0(%rbp), %rdi
callq 0x21b0
leaq -0x1a0(%rbp), %rdi
movq 0x5e31(%rip), %rax      # 0xa5e0
subq 0x5e22(%rip), %rax      # 0xa5d8
pushq $0x48
popq %rcx
cqto
idivq %rcx
movq %rax, %rsi
callq 0x21a0
leaq -0x198(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2300
leaq 0x194f(%rip), %rsi      # 0x612c
leaq -0x28(%rbp), %rdx
movq %rbx, %rdi
callq 0x53c1
leaq -0x28(%rbp), %rdi
callq 0x2140
leaq -0x1b0(%rbp), %rdi
callq 0x21d0
jmp 0x4830
leaq 0x193d(%rip), %rsi      # 0x6144
jmp 0x4821
leaq 0x1905(%rip), %rsi      # 0x6115
movq %rbx, %rdi
callq 0x52f9
jmp 0x4830
leaq 0x1865(%rip), %rsi      # 0x6086
leaq -0x1b0(%rbp), %rdx
movq %rbx, %rdi
callq 0x515c
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x2140
jmp 0x4850
jmp 0x484d
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x21d0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r15d, %r15d
leaq -0x70(%rbp), %r14
leaq -0x50(%rbp), %r12
pushq $0x64
popq %rbx
xorl %r13d, %r13d
movq 0x5db3(%rip), %rax      # 0xa640
subq 0x5da4(%rip), %rax      # 0xa638
cqto
pushq $0x58
popq %rcx
idivq %rcx
cmpq %r13, %rax
jbe 0x4910
movq %r14, %rdi
leaq 0x17db(%rip), %rsi      # 0x6086
leaq -0x29(%rbp), %rdx
callq 0x515c
movq %r12, %rdi
pushq $0x71
popq %rsi
movq %r14, %rdx
callq 0x4761
movq %r14, %rdi
callq 0x2140
movq 0x5d67(%rip), %rdi      # 0xa638
addq %r15, %rdi
callq 0x2940
movq -0x50(%rbp), %rsi
movl %eax, %edi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2150
movl %eax, 0x59a1(%rip)      # 0xa290
testl %eax, %eax
jle 0x4904
movq %r12, %rdi
callq 0x2140
incq %r13
addq $0x58, %r15
jmp 0x4886
leaq 0x1ae5(%rip), %rdi      # 0x63f0
callq 0x22c0
pushq $0x1
popq %rdi
callq 0x2260
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x492d
movq %rax, %rbx
jmp 0x4932
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: parseAnswer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Card, std::allocator<Card>>&)
int parseAnswer(string message, vector<Card> &answers) {
	char* messageDiv[2]; // [0] has first half, [1] has content
	char* getCommand[2]; // [0] has command, [1] has source
	splitString(messageDiv, (char*)message.c_str(), "\n");
	splitString(getCommand, messageDiv[0], " ");
	
	if(strcmp((const char*)getCommand[0], "ANSWER") == 0 || strcmp((const char*)getCommand[0], "NSWER") == 0) {
		players[getPlayerIndex(string(getCommand[1]))].takeCard(string(messageDiv[1]));
		answers.push_back(Card(string(messageDiv[1]), string(getCommand[1])));
		return 1;
	}
	else {
		return -1;
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x172a(%rip), %rdx      # 0x6085
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x4301
movq (%r14), %rsi
leaq 0x17a2(%rip), %rdx      # 0x6113
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x4301
movq (%r14), %r14
leaq 0x1736(%rip), %rsi      # 0x60bd
movq %r14, %rdi
callq 0x22a0
testl %eax, %eax
je 0x49ad
leaq 0x1724(%rip), %rsi      # 0x60be
movq %r14, %rdi
callq 0x22a0
testl %eax, %eax
je 0x49ad
pushq $-0x1
jmp 0x4aa4
movq -0x38(%rbp), %r14
leaq -0xd0(%rbp), %rdi
leaq -0x118(%rbp), %rdx
movq %r14, %rsi
callq 0x515c
leaq -0xd0(%rbp), %rdi
callq 0x4ed4
movl %eax, %r13d
movq 0x5c5b(%rip), %r12      # 0xa638
movq -0x48(%rbp), %r15
leaq -0xb0(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r15, %rsi
callq 0x515c
movslq %r13d, %rax
imulq $0x58, %rax, %rax
addq %rax, %r12
leaq -0x160(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
movq %r12, %rsi
callq 0x2ac8
leaq -0x160(%rbp), %rdi
callq 0x2d36
leaq -0xb0(%rbp), %rdi
callq 0x2140
leaq -0xd0(%rbp), %rdi
callq 0x2140
leaq -0x90(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r15, %rsi
callq 0x515c
leaq -0x70(%rbp), %rdi
leaq -0x2a(%rbp), %rdx
movq %r14, %rsi
callq 0x515c
leaq -0x118(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x2744
leaq -0x118(%rbp), %rsi
movq %rbx, %rdi
callq 0x5ca6
leaq -0x118(%rbp), %rdi
callq 0x2d36
leaq -0x70(%rbp), %rdi
callq 0x2140
leaq -0x90(%rbp), %rdi
callq 0x2140
pushq $0x1
popq %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x2d36
jmp 0x4acb
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2140
jmp 0x4ad9
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x4b01
jmp 0x4b08
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x2140
jmp 0x4afa
jmp 0x4af7
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x2140
jmp 0x4b0b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/muzuka[P]Cards-Against-Humanity-Online/Server.cpp
// Function: getPlayerIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int getPlayerIndex(string name) {
	for (int i = 0; i < players.size(); i++) {
		if (strcmp(players[i].getName().c_str(), name.c_str()) == 0) {
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
xorl %r13d, %r13d
leaq -0x48(%rbp), %r15
xorl %ebx, %ebx
movq 0x5748(%rip), %rax      # 0xa640
movq 0x5739(%rip), %rsi      # 0xa638
subq %rsi, %rax
cqto
pushq $0x58
popq %rcx
idivq %rcx
cmpq %rbx, %rax
jbe 0x4f3f
addq %r13, %rsi
movq %r15, %rdi
callq 0x291e
movq -0x48(%rbp), %rdi
movq (%r14), %rsi
callq 0x22a0
movl %eax, %r12d
movq %r15, %rdi
callq 0x2140
testl %r12d, %r12d
je 0x4f44
incq %rbx
addq $0x58, %r13
jmp 0x4ef1
pushq $-0x1
popq %rax
jmp 0x4f46
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
pushq $-0x58
popq %r14
pushq $-0x1
popq %rbx
leaq -0x50(%rbp), %r12
movq 0x56c1(%rip), %rax      # 0xa640
movq 0x56b2(%rip), %rcx      # 0xa638
subq %rcx, %rax
cqto
pushq $0x58
popq %rsi
idivq %rsi
incq %rbx
cmpq %rbx, %rax
jbe 0x4fe1
leaq (%rcx,%r14), %rsi
addq $0x58, %rsi
addq $0x58, %r14
movq %r12, %rdi
callq 0x291e
movq -0x50(%rbp), %rdi
movq (%r15), %rsi
callq 0x22a0
movl %eax, %r13d
movq %r12, %rdi
callq 0x2140
testl %r13d, %r13d
jne 0x4f78
addq 0x5668(%rip), %r14      # 0xa638
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53f0
jmp 0x4fed
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x27c8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, -0x30(%rbp)
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
xorl %r15d, %r15d
leaq -0x70(%rbp), %r12
xorl %ebx, %ebx
movq 0x560d(%rip), %rax      # 0xa640
movq 0x55fe(%rip), %rsi      # 0xa638
subq %rsi, %rax
cqto
pushq $0x58
popq %rcx
idivq %rcx
cmpq %rbx, %rax
jbe 0x50a9
addq %r15, %rsi
movq %r12, %rdi
callq 0x291e
movq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0x22a0
movl %eax, %r14d
movq %r12, %rdi
callq 0x2140
movq 0x55c1(%rip), %r13      # 0xa638
addq %r15, %r13
testl %r14d, %r14d
je 0x508d
leaq -0x50(%rbp), %rdi
movq %r13, %rsi
callq 0x5198
jmp 0x50a0
movq %r13, %rdi
callq 0x50ea
movq %r13, %rdi
pushq $0x58
popq %rsi
callq 0x2230
incq %rbx
addq $0x58, %r15
jmp 0x502c
leaq 0x5588(%rip), %rdi      # 0xa638
leaq -0x50(%rbp), %rsi
callq 0x5458
leaq -0x50(%rbp), %rdi
callq 0x5114
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x50d5
jmp 0x50d5
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x5114
movq %rbx, %rdi
callq 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x4(%rsp), %rdi
andl $0x0, (%rdi)
leaq 0x20(%rbx), %r14
leaq 0x40(%rbx), %r15
movq %rsp, %rsi
movl $0x1, (%rsi)
callq 0x2b20
testl %eax, %eax
leaq 0x1c1a(%rip), %rax      # 0x4009
leaq 0x1c0e(%rip), %rsi      # 0x4004
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x2240
leaq 0x1c05(%rip), %rsi      # 0x400e
movq %r14, %rdi
callq 0x2240
leaq 0x1bfa(%rip), %rsi      # 0x4012
movq %r15, %rdi
callq 0x2240
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x242e
movq %rax, %r12
movq %r15, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
movq %r12, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
leaq 0x1bb6(%rip), %rsi      # 0x401f
leaq 0x30(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x2220
leaq 0x1bb9(%rip), %rsi      # 0x4036
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2806
leaq 0xa8(%rsp), %rdi
callq 0x2050
testb %al, %al
je 0x24e7
leaq 0x8(%rsp), %rdi
andl $0x0, (%rdi)
leaq 0xc(%rsp), %rsi
movl $0xf9e, (%rsi)          # imm = 0xF9E
callq 0x2b20
xorl %ebp, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r15
subl $0x1, %ebp
jb 0x24d8
movq %r14, %rdi
movq %r15, %rsi
callq 0x2040
jmp 0x24c6
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2040
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x20e0
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x30(%rsp), %rdi
callq 0x2060
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2521
jmp 0x2521
jmp 0x2521
movq %rax, %rbx
jmp 0x252e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x30(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
leaq 0x1aef(%rip), %rsi      # 0x4046
leaq 0x30(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x2220
leaq 0x1af1(%rip), %rsi      # 0x405c
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2806
leaq 0xa8(%rsp), %rdi
callq 0x2050
testb %al, %al
je 0x25d5
leaq 0x8(%rsp), %rdi
andl $0x0, (%rdi)
leaq 0xc(%rsp), %rsi
movl $0x3e6, (%rsi)          # imm = 0x3E6
callq 0x2b20
xorl %ebp, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r15
subl $0x1, %ebp
jb 0x25c6
movq %r14, %rdi
movq %r15, %rsi
callq 0x2040
jmp 0x25b4
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2040
addq $0x20, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x20e0
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x30(%rsp), %rdi
callq 0x2060
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2613
jmp 0x2613
jmp 0x2613
movq %rax, %rbx
jmp 0x2620
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x30(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/mattearly[P]english-name-generator/src/humangenerator.cpp
// Function: HumanGenerator::newSSN()
void HumanGenerator::newSSN()
{
  string tmp = "SSNFAILED";
  tmp = to_string(getRandomNumber(100, 999)) + "-";
  tmp += to_string(getRandomNumber(10, 99)) + "-";
  tmp += to_string(getRandomNumber(1000, 9999));
  SSN = tmp;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x1a28(%rip), %rsi      # 0x406b
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2806
movq %rsp, %rdi
movl $0x64, (%rdi)
leaq 0x4(%rsp), %rsi
movl $0x3e7, (%rsi)          # imm = 0x3E7
callq 0x2b20
leaq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x2860
leaq 0x19f7(%rip), %rdx      # 0x4075
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2841
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x20b0
leaq 0x28(%rsp), %rdi
callq 0x20b0
movq %rsp, %rdi
movl $0xa, (%rdi)
leaq 0x4(%rsp), %rsi
movl $0x63, (%rsi)
callq 0x2b20
leaq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x2860
leaq 0x1998(%rip), %rdx      # 0x4075
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2841
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2250
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x20b0
movl $0x3e8, (%r14)          # imm = 0x3E8
movq %rsp, %rsi
movl $0x270f, (%rsi)         # imm = 0x270F
leaq 0x28(%rsp), %rdi
callq 0x2b20
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x2860
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2250
leaq 0x8(%rsp), %rdi
callq 0x20b0
addq $0x40, %rbx
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x20e0
leaq 0x48(%rsp), %rdi
callq 0x20b0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x27a4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x2799
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
jmp 0x2794
jmp 0x2791
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20b0
jmp 0x27a7
jmp 0x27a4
jmp 0x27a4
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x88, %rsp
movq 0x35dc(%rip), %rbx      # 0x5fd8
leaq 0x1776(%rip), %rsi      # 0x4179
movq %rbx, %rdi
callq 0x2160
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x238c
pushq $0xa
popq %rbp
leaq 0x8(%rsp), %r15
subl $0x1, %ebp
jb 0x2ab8
movq %r14, %rdi
callq 0x2452
movq %r14, %rdi
callq 0x2540
movq %r14, %rdi
callq 0x2632
movq %r15, %rdi
movq %r14, %rsi
callq 0x27d6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20c0
movq %r15, %rdi
callq 0x20b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x27ba
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20c0
movq %r15, %rdi
callq 0x20b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x27ea
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
callq 0x20c0
movq %r15, %rdi
callq 0x20b0
jmp 0x2a20
leaq 0x28(%rsp), %rdi
callq 0x2b00
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2aeb
jmp 0x2aeb
jmp 0x2aeb
jmp 0x2adc
jmp 0x2adc
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
jmp 0x2aee
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2b00
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3628(%rip), %al       # 0x6158
testb %al, %al
je 0x2b6f
movb 0x363e(%rip), %al       # 0x6178
testb %al, %al
je 0x2b99
movl (%r14), %eax
movl (%rbx), %ecx
movl %eax, (%rsp)
movl %ecx, 0x4(%rsp)
movb 0x49b8(%rip), %al       # 0x7508
testb %al, %al
je 0x2bf0
leaq 0x3621(%rip), %rsi      # 0x6180
movq %rsp, %rdi
callq 0x2cc8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x35e2(%rip), %rdi      # 0x6158
callq 0x2210
testl %eax, %eax
je 0x2b34
callq 0x2030
movq %rax, 0x35c5(%rip)      # 0x6150
leaq 0x35c6(%rip), %rdi      # 0x6158
callq 0x2100
jmp 0x2b34
leaq 0x35d8(%rip), %rdi      # 0x6178
callq 0x2210
testl %eax, %eax
je 0x2b3e
movq 0x35a0(%rip), %rax      # 0x6150
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x35a3(%rip), %rdi      # 0x6160
pushq $0x2
popq %rdx
callq 0x2c4c
leaq 0xf6(%rip), %rdi        # 0x2cc2
leaq 0x358d(%rip), %rsi      # 0x6160
leaq 0x355e(%rip), %rdx      # 0x6138
callq 0x2140
leaq 0x3592(%rip), %rdi      # 0x6178
callq 0x2100
jmp 0x2b3e
leaq 0x4911(%rip), %rdi      # 0x7508
callq 0x2210
testl %eax, %eax
je 0x2b58
leaq 0x3575(%rip), %rdi      # 0x6180
leaq 0x354e(%rip), %rsi      # 0x6160
callq 0x2f1c
leaq 0x48ea(%rip), %rdi      # 0x7508
callq 0x2100
jmp 0x2b58
movq %rax, %rbx
leaq 0x48d6(%rip), %rdi      # 0x7508
jmp 0x2c3e
movq %rax, %rbx
leaq 0x353a(%rip), %rdi      # 0x6178
callq 0x20f0
movq %rbx, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/network.cc
// Function: toUpperCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string toUpperCase(const std::string & s)
{
    std::string ret(s.size(), char());
    for(unsigned int i = 0; i < s.size(); ++i)
        ret[i] = (s[i] <= 'z' && s[i] >= 'a') ? s[i]-('a'-'A') : s[i];
    return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x4520
movl %ebp, %eax
cmpq %rax, 0x8(%r14)
jbe 0x52a6
movq (%r14), %rcx
movzbl (%rcx,%rax), %ecx
leal -0x61(%rcx), %edx
leal -0x20(%rcx), %esi
cmpb $0x1a, %dl
movzbl %sil, %edx
cmovael %ecx, %edx
movq (%rbx), %rcx
movb %dl, (%rcx,%rax)
leal 0x1(%rax), %ebp
jmp 0x527c
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq