LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/xocoder[P]m_kcptun/vendor/cm256/cm256.cpp
// Function: CM256Decoder::Initialize(cm256_encoder_params_t&, cm256_block_t*)
bool CM256Decoder::Initialize(cm256_encoder_params& params, cm256_block* blocks)
{
    Params = params;

    cm256_block* block = blocks;
    OriginalCount = 0;
    RecoveryCount = 0;

    // Initialize erasures to zeros
    for (int ii = 0; ii < params.OriginalCount; ++ii)
    {
        ErasuresIndices[ii] = 0;
    }

    // For each input block,
    for (int ii = 0; ii < params.OriginalCount; ++ii, ++block)
    {
        int row = block->Index;

        // If it is an original block,
        if (row < params.OriginalCount)
        {
            Original[OriginalCount++] = block;

            if (ErasuresIndices[row] != 0)
            {
                // Error out if two row indices repeat
                return false;
            }

            ErasuresIndices[row] = 1;
        }
        else
        {
            Recovery[RecoveryCount++] = block;
        }
    }

    // Identify erasures
    for (int ii = 0, indexCount = 0; ii < 256; ++ii)
    {
        if (!ErasuresIndices[ii])
        {
            ErasuresIndices[indexCount] = static_cast<uint8_t>( ii );

            if (++indexCount >= RecoveryCount)
            {
                break;
            }
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movl %eax, 0x1018(%rdi)
movl %eax, 0x810(%rdi)
cmpl %eax, (%rsi)
jle 0x9553
xorl %eax, %eax
movb $0x0, 0x101c(%rdi,%rax)
incq %rax
movslq (%rsi), %rcx
cmpq %rcx, %rax
jl 0x9540
movl (%rsi), %r10d
testl %r10d, %r10d
setle %al
jle 0x95ca
movl 0x1018(%rdi), %r9d
movl 0x810(%rdi), %r8d
xorl %ecx, %ecx
movzbl 0x8(%rdx), %r11d
cmpl %r11d, %r10d
jle 0x95a7
leal 0x1(%r9), %r10d
movl %r10d, 0x1018(%rdi)
movslq %r9d, %r9
movq %rdx, 0x818(%rdi,%r9,8)
cmpb $0x0, 0x101c(%rdi,%r11)
jne 0x95f8
movb $0x1, 0x101c(%rdi,%r11)
movl %r10d, %r9d
jmp 0x95b9
movslq %r8d, %rax
incl %r8d
movl %r8d, 0x810(%rdi)
movq %rdx, 0x10(%rdi,%rax,8)
incl %ecx
addq $0x10, %rdx
movl (%rsi), %r10d
cmpl %r10d, %ecx
setge %al
jl 0x956e
xorl %ecx, %ecx
xorl %edx, %edx
cmpb $0x0, 0x101c(%rdi,%rcx)
jne 0x95ec
movslq %edx, %rdx
movb %cl, 0x101c(%rdi,%rdx)
incl %edx
cmpl 0x810(%rdi), %edx
jge 0x95f8
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x95ce
andb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xocoder[P]m_kcptun/vendor/cm256/cm256.cpp
// Function: CM256Decoder::DecodeM1()
void CM256Decoder::DecodeM1()
{
    // XOR all other blocks into the recovery block
    uint8_t* outBlock = static_cast<uint8_t*>(Recovery[0]->Block);
    const uint8_t* inBlock = 0;

    // For each block,
    for (int ii = 0; ii < OriginalCount; ++ii)
    {
        const uint8_t* inBlock2 = static_cast<const uint8_t*>(Original[ii]->Block);

        if (!inBlock)
        {
            inBlock = inBlock2;
        }
        else
        {
            // outBlock ^= inBlock ^ inBlock2
            gf256_add2_mem(outBlock, inBlock, inBlock2, Params.BlockBytes);
            inBlock = 0;
        }
    }

    // Complete XORs
    if (inBlock)
    {
        gf256_add_mem(outBlock, inBlock, Params.BlockBytes);
    }

    // Recover the index it corresponds to
    Recovery[0]->Index = ErasuresIndices[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq (%rax), %r14
cmpl $0x0, 0x1018(%rdi)
jle 0x964f
xorl %r15d, %r15d
xorl %esi, %esi
movq 0x818(%rbx,%r15,8), %rax
movq (%rax), %rdx
testq %rsi, %rsi
je 0x963b
movl 0x8(%rbx), %ecx
movq %r14, %rdi
callq 0xa526
xorl %edx, %edx
incq %r15
movslq 0x1018(%rbx), %rax
movq %rdx, %rsi
cmpq %rax, %r15
jl 0x961e
jmp 0x9651
xorl %edx, %edx
testq %rdx, %rdx
je 0x9666
movl 0x8(%rbx), %eax
movq %r14, %rdi
movq %rdx, %rsi
movl %eax, %edx
callq 0xa45b
movb 0x101c(%rbx), %al
movq 0x10(%rbx), %rcx
movb %al, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xocoder[P]m_kcptun/vendor/cm256/cm256.cpp
// Function: cm256_decode
int cm256_decode(
    cm256_encoder_params params, // Encoder params
    cm256_block* blocks)         // Array of 'originalCount' blocks as described above
{
    if (params.OriginalCount <= 0 ||
        params.RecoveryCount <= 0 ||
        params.BlockBytes <= 0)
    {
        return -1;
    }
    if (params.OriginalCount + params.RecoveryCount > 256)
    {
        return -2;
    }
    if (!blocks)
    {
        return -3;
    }

    // If there is only one block,
    if (params.OriginalCount == 1)
    {
        // It is the same block repeated
        blocks[0].Index = 0;
        return 0;
    }

    CM256Decoder state;
    if (!state.Initialize(params, blocks))
    {
        return -5;
    }

    // If nothing is erased,
    if (state.RecoveryCount <= 0)
    {
        return 0;
    }

    // If m=1,
    if (params.RecoveryCount == 1)
    {
        state.DecodeM1();
        return 0;
    }

    // Decode for m>1
    state.Decode();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1130, %rsp           # imm = 0x1130
movq %rdi, -0x20(%rbp)
movl %esi, -0x18(%rbp)
testl %edi, %edi
setle %al
movl -0x1c(%rbp), %r14d
testl %r14d, %r14d
setle %cl
testl %esi, %esi
setle %sil
orb %al, %sil
orb %cl, %sil
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jne 0x9d8d
leal (%r14,%rdi), %eax
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
cmpl $0x100, %eax            # imm = 0x100
jg 0x9d8d
testq %rdx, %rdx
je 0x9d49
cmpl $0x1, %edi
jne 0x9d50
movb $0x0, 0x8(%rdx)
xorl %ebx, %ebx
jmp 0x9d8d
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x9d8d
leaq -0x1140(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x951c
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
testb %al, %al
je 0x9d8d
xorl %ebx, %ebx
cmpl $0x0, -0x930(%rbp)
jle 0x9d8d
leaq -0x1140(%rbp), %rdi
cmpl $0x1, %r14d
jne 0x9d88
callq 0x95fc
jmp 0x9d8d
callq 0x9a7c
movl %ebx, %eax
addq $0x1130, %rsp           # imm = 0x1130
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mortrevere[P]ninjat/main.cpp
// Function: init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int init(const std::string& version) {
  std::cout << "ninjat server - v" << version;
#ifdef WIN32
  WSADATA WSAData;
  std::cout << " (Win32)" << std::endl;
  return WSAStartup(MAKEWORD(2,2), &WSAData);
#else
  std::cout << " (GNU/Linux)" << std::endl;
  return 0;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x7a9e(%rip), %rbx      # 0x9fd8
leaq 0x4ac3(%rip), %rsi      # 0x7004
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2280
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2280
leaq 0x4ab2(%rip), %rsi      # 0x7016
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2280
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2160
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mortrevere[P]ninjat/main.cpp
// Function: die(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void die(const std::string& err) {
  std::cout << "[FATAL ERROR] : " << err << std::endl;
#ifdef WIN32
  WSACleanup();
#endif
  std::exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x7a2b(%rip), %rdi      # 0x9fd8
leaq 0x4a6f(%rip), %rsi      # 0x7023
callq 0x2210
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21e0
movq %rax, %rdi
callq 0x2120
movl $0x1, %edi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/mortrevere[P]ninjat/main.cpp
// Function: fileRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string fileRead(const std::string& path) {
  std::ifstream infile(path, std::ios::in);
  std::string out("");
  char chr;
  if(infile){while(infile.get(chr)){out += chr;}return out;}else {return "";}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movl $0x8, %edx
callq 0x2320
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x49d6(%rip), %rdx      # 0x70a2
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x62ae
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
je 0x2704
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x49ab(%rip), %rdx      # 0x70a2
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x62ae
jmp 0x277e
leaq 0x28(%rsp), %r14
leaq 0x7(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x22c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x273b
movsbl 0x7(%rsp), %esi
movq %r12, %rdi
callq 0x21c0
jmp 0x2713
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
cmpq %r13, %rcx
je 0x275a
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2762
movups (%r13), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r13, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2795
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
leaq 0x28(%rsp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x27ba
movq %rax, %rbx
jmp 0x27d4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x27d4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
leaq 0x28(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/mortrevere[P]ninjat/main.cpp
// Function: s(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, bool)
bool s(std::string toSend, int sock, bool format = true) {
  if(sock <= 0)
    return false;
  if(format)
    toSend = "\t\t\t\t\t\t" + toSend;

  int error = send(sock,toSend.c_str(),toSend.size(),0);
  return !(error == SOCKET_ERROR);
}

// Assembly:
testl %esi, %esi
jle 0x29d0
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
testb %dl, %dl
je 0x29b0
leaq 0x471f(%rip), %rsi      # 0x709c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5ea9
movq %r14, %rdi
movq %r15, %rsi
callq 0x22b0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x29b0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x2130
cmpl $-0x1, %eax
setne %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mortrevere[P]ninjat/main.cpp
// Function: setNick(int, std::vector<int, std::allocator<int>>&, std::vector<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>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool setNick(int csock, std::vector<int>& clients, std::vector<std::string>& nicks, std::string nick) {
  for(unsigned int i = 0; i < clients.size(); i++) {
    if(clients[i] == csock) {
      nicks[i] = nick;
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbx
movq (%rsi), %r8
movq 0x8(%rsi), %rsi
subq %r8, %rsi
setne %bl
je 0x2dba
cmpl %edi, (%r8)
jne 0x2d89
xorl %eax, %eax
jmp 0x2da8
sarq $0x2, %rsi
movl $0x1, %r9d
movl %r9d, %eax
cmpq %rax, %rsi
seta %bl
jbe 0x2dba
leal 0x1(%rax), %r9d
cmpl %edi, (%r8,%rax,4)
jne 0x2d93
shlq $0x5, %rax
addq (%rdx), %rax
movq %rax, %rdi
movq %rcx, %rsi
callq 0x2150
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mortrevere[P]ninjat/main.cpp
// Function: getIndex(int, std::vector<int, std::allocator<int>>&)
int getIndex(int csock, std::vector<int>& clients) {
  for (std::size_t i = 0; i < clients.size(); i++) {
    if(clients[i] == csock) {
      return i;
    }
  }
  return -1;
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %rcx, %rdx
je 0x2dea
sarq $0x2, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
cmpl %edi, (%rcx,%rsi,4)
je 0x2deb
incq %rsi
cmpq %rsi, %rdx
jne 0x2ddd
retq
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mortrevere[P]ninjat/main.cpp
// Function: getIndexByNick(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<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 getIndexByNick(std::string nick, std::vector<std::string>& nicks) {
  for (std::size_t i = 0; i < nicks.size(); i++) {
    if(nicks[i] == nick) {
      return i;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r15
movq 0x8(%rsi), %r12
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
subq %r15, %r12
je 0x2e50
movq %rdi, %r14
sarq $0x5, %r12
movq 0x8(%rdi), %r13
cmpq $0x1, %r12
adcq $0x0, %r12
addq $0x8, %r15
xorl %ebp, %ebp
movq (%r15), %rdx
cmpq %r13, %rdx
jne 0x2e40
testq %rdx, %rdx
je 0x2e4e
movq (%r14), %rsi
movq -0x8(%r15), %rdi
callq 0x2240
testl %eax, %eax
je 0x2e4e
incq %rbp
addq $0x20, %r15
cmpq %rbp, %r12
jne 0x2e23
jmp 0x2e50
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/examples/user-types-ex01.cxx
// Function: main
int main() {
    my_type mv1 = { {2, 4, 6}, {1, 3, 5} },
            mv2;
    std::string json;
        cxon::to_bytes(json, mv1);
        cxon::from_bytes(mv2, json);
    // json == "{ \"even\": [2, 4, 6], \"odd\": [1, 3, 5] }"
    assert(mv1 == mv2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movabsq $0x400000002, %rax      # imm = 0x400000002
leaq 0x70(%rsp), %rsi
movq %rax, (%rsi)
movl $0x6, 0x8(%rsi)
leaq 0x40(%rsp), %rdi
movq %rsp, %rcx
movl $0x3, %edx
callq 0x2552
leaq 0x58(%rsp), %rbx
movabsq $0x300000001, %rax      # imm = 0x300000001
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movl $0x5, 0x8(%rsi)
leaq 0x38(%rsp), %rcx
movl $0x3, %edx
movq %rbx, %rdi
callq 0x2590
xorl %eax, %eax
leaq 0x88(%rsp), %r15
movq %rax, -0x8(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%r15)
movq %r15, 0x8(%r15)
movq %r15, (%r15)
movq %rax, 0x10(%r15)
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movl $0x0, (%rsp)
callq 0x2070
movq %rax, %r14
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
movl $0x7b, %esi
callq 0x20e0
leaq 0x3953(%rip), %rdx      # 0x5cf8
leaq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movq %rsp, %rcx
callq 0x280c
movl %eax, %ebp
testb %al, %al
je 0x23cc
leaq 0x18(%rsp), %rdi
movl $0x7d, %esi
callq 0x20e0
cmpl $0x0, (%rsp)
setne %al
xorb %al, %bpl
je 0x24ac
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
addq %rax, %rcx
leaq 0x38(%rsp), %rdx
movq %rax, (%rdx)
movq %rsp, %r8
movl $0x0, (%r8)
movq %r14, 0x8(%r8)
leaq 0x3922(%rip), %rsi      # 0x5d28
leaq 0x70(%rsp), %rdi
callq 0x2b23
cmpl $0x0, (%rsp)
setne %cl
xorb %cl, %al
je 0x24cb
leaq 0x40(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x25da
testb %al, %al
je 0x24ea
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x2445
callq 0x2100
movq 0x88(%rsp), %rdi
cmpq %r15, %rdi
je 0x2462
movq (%rdi), %r14
callq 0x2100
movq %r14, %rdi
cmpq %r15, %r14
jne 0x2452
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x2471
callq 0x2100
movq 0x58(%rsp), %rdi
cmpq %rbx, %rdi
je 0x248b
movq (%rdi), %r14
callq 0x2100
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x247b
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x249a
callq 0x2100
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bd0(%rip), %rdi      # 0x4083
leaq 0x1bd6(%rip), %rsi      # 0x4090
leaq 0x1be4(%rip), %rcx      # 0x40a5
movl $0xe6, %edx
callq 0x20a0
leaq 0x1bb1(%rip), %rdi      # 0x4083
leaq 0x1bb7(%rip), %rsi      # 0x4090
leaq 0x1d06(%rip), %rcx      # 0x41e6
movl $0xbd, %edx
callq 0x20a0
leaq 0x1b37(%rip), %rdi      # 0x4028
leaq 0x1b3b(%rip), %rsi      # 0x4033
leaq 0x1b48(%rip), %rcx      # 0x4047
movl $0x1e, %edx
callq 0x20a0
jmp 0x2524
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x254a
callq 0x2100
jmp 0x254a
movq %rax, %rbx
jmp 0x254a
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x2536
callq 0x2100
leaq 0x70(%rsp), %rdi
callq 0x2656
leaq 0x40(%rsp), %rdi
callq 0x2656
movq %rbx, %rdi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/examples/../src/cxon/lang/common/cio/class.hxx
// Function: bool cxon::cio::cls::imp::imp::write_<cxon::JSON<cxon::cio::key::simple_traits<cxon::json::format_traits>>, 0ul, 2ul>::field<my_type, std::tuple<cxon::cio::cls::field<std::vector<int, std::allocator<int>> my_type::*>, cxon::cio::cls::field<std::__cxx11::list<int, std::allocator<int>> my_type::*>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, my_type const&, std::tuple<cxon::cio::cls::field<std::vector<int, std::allocator<int>> my_type::*>, cxon::cio::cls::field<std::__cxx11::list<int, std::allocator<int>> my_type::*>> const&, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool field(O& o, const T& t, const Fs& fs, Cx& cx) {
                            using E = typename std::tuple_element<N, Fs>::type;
                            CXON_IF_CONSTEXPR (!val::is_sink<typename E::type>::value)
                                if (!std::get<N>(fs).isdf(t))
                                    return  write_field_<X>(o, t, std::get<N>(fs), cx) &&
                                            write_next_<X, N + 1, L>::field(o, t, fs, cx)
                                    ;
                            return          write_<X, N + 1, L>::field(o, t, fs, cx);
                        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rdx), %r13
movq 0x20(%rdx), %rbp
movl $0x22, %esi
callq 0x20e0
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x2050
movq %r12, %rdi
movl $0x22, %esi
callq 0x20e0
movq %r12, %rdi
movl $0x3a, %esi
callq 0x20e0
movq 0x28(%r14), %rsi
addq %r15, %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x2922
testb %al, %al
je 0x2892
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28a4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/oknenavin[P]cxon/examples/../src/cxon/lang/common/cio/class.hxx
// Function: bool cxon::cio::cls::imp::imp::write_next_<cxon::JSON<cxon::cio::key::simple_traits<cxon::json::format_traits>>, 1ul, 2ul>::field<my_type, std::tuple<cxon::cio::cls::field<std::vector<int, std::allocator<int>> my_type::*>, cxon::cio::cls::field<std::__cxx11::list<int, std::allocator<int>> my_type::*>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, my_type const&, std::tuple<cxon::cio::cls::field<std::vector<int, std::allocator<int>> my_type::*>, cxon::cio::cls::field<std::__cxx11::list<int, std::allocator<int>> my_type::*>> const&, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool field(O& o, const T& t, const Fs& fs, Cx& cx) {
                            using E = typename std::tuple_element<N, Fs>::type;
                            CXON_IF_CONSTEXPR (!val::is_sink<typename E::type>::value)
                                if (!std::get<N>(fs).isdf(t))
                                    return  write_sep_<X, T>(o, cx) && write_field_<X>(o, t, std::get<N>(fs), cx) &&
                                            write_next_<X, N + 1, L>::field(o, t, fs, cx)
                                    ;
                            return          write_next_<X, N + 1, L>::field(o, t, fs, cx);
                        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl $0x2c, %esi
callq 0x20e0
movq (%r15), %r13
movq 0x8(%r15), %rbp
movq %r12, %rdi
movl $0x22, %esi
callq 0x20e0
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x2050
movq %r12, %rdi
movl $0x22, %esi
callq 0x20e0
movq %r12, %rdi
movl $0x3a, %esi
callq 0x20e0
addq 0x10(%r15), %r14
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ab2
nop
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms1/./assignment2.hpp
// Function: assignment2::partition(std::vector<int, std::allocator<int>>&, int, int)
int partition(vector<int>& input, int left, int right)
    {
        int p = input[left];
        int i = left + 1;
        
        for (int j = left + 1; j < right; j++)
        {
            if (input[j] < p)
            {
                swap(input[i], input[j]);
                i++;
            }
        }
        swap(input[left], input[i-1]);
        
        return (i-1);
    }

// Assembly:
movslq %esi, %r8
movq (%rdi), %rcx
leal 0x1(%r8), %eax
cmpl %edx, %eax
jge 0x28b4
movl (%rcx,%r8,4), %esi
decl %edx
movq %r8, %rdi
movl 0x4(%rcx,%rdi,4), %r9d
cmpl %esi, %r9d
jge 0x28a9
cltq
movl (%rcx,%rax,4), %r10d
movl %r9d, (%rcx,%rax,4)
movl %r10d, 0x4(%rcx,%rdi,4)
incl %eax
incq %rdi
cmpl %edi, %edx
jne 0x288e
decl %eax
movl %eax, %esi
movslq %esi, %rax
movl (%rcx,%r8,4), %edx
movl (%rcx,%rax,4), %esi
movl %esi, (%rcx,%r8,4)
movl %edx, (%rcx,%rax,4)
retq
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms1/./assignment2.hpp
// Function: assignment2::partitionLast(std::vector<int, std::allocator<int>>&, int, int)
int partitionLast(vector<int>& input, int left, int right)
    {
        noCompLast += right - left - 1;
        
        // swap the last element with the first
        swap(input[right-1], input[left]);
        
        return partition(input, left, right);
    }

// Assembly:
movslq %esi, %rax
notl %esi
addl %edx, %esi
addl %esi, 0xb904(%rip)      # 0xe1e8
movq (%rdi), %rcx
movslq %edx, %rdx
movl -0x4(%rcx,%rdx,4), %esi
movl (%rcx,%rax,4), %r8d
movl %r8d, -0x4(%rcx,%rdx,4)
movl %esi, (%rcx,%rax,4)
movl %eax, %esi
jmp 0x2877
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms1/./assignment2.hpp
// Function: assignment2::partitionMedian(std::vector<int, std::allocator<int>>&, int, int)
int partitionMedian(vector<int>& input, int left, int right)
    {
        noCompMedian += right - left - 1;
        
        int midInd = (left + right - 1) / 2;
        // initially pivot position is unknown
        int p = -1;
        
        // compute the median of the three elements (first, median, last)
        // and assign its index to the pivot
        if (input[left] < input[midInd])
        {
            if (input[left] >= input[right-1])
                p = left;
            else if (input[midInd] < input[right-1])
                p = midInd;
        }
        else
        {
            if (input[midInd] >= input[right-1])
                p = midInd;
            else if (input[left] < input[right-1])
                p = left;
        }
        // fallback
        if (p == -1)
            p = right - 1;
        
        // bring the median pivot to the beginning
        swap(input[left], input[p]);
        
        return partition(input, left, right);
    }

// Assembly:
pushq %rbx
movl %esi, %eax
movl %esi, %ecx
notl %ecx
addl %edx, %ecx
addl %ecx, 0xb8dc(%rip)      # 0xe1ec
leal (%rdx,%rax), %ecx
leal (%rdx,%rax), %esi
decl %esi
shrl $0x1f, %esi
leal (%rsi,%rcx), %r9d
decl %r9d
sarl %r9d
movslq %eax, %rsi
movq (%rdi), %rcx
movl (%rcx,%rsi,4), %r8d
movslq %r9d, %r10
movl (%rcx,%r10,4), %ebx
movslq %edx, %r10
movl -0x4(%rcx,%r10,4), %r11d
cmpl %ebx, %r8d
jge 0x295a
movl %eax, %r10d
cmpl %r11d, %r8d
jge 0x296f
cmpl %r11d, %ebx
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
cmovll %r9d, %r10d
jmp 0x296f
movl %r9d, %r10d
cmpl %r11d, %ebx
jge 0x296f
cmpl %r11d, %r8d
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
cmovll %eax, %r10d
leal -0x1(%rdx), %eax
cmpl $-0x1, %r10d
cmovnel %r10d, %eax
cltq
movl (%rcx,%rax,4), %r9d
movl %r9d, (%rcx,%rsi,4)
movl %r8d, (%rcx,%rax,4)
popq %rbx
jmp 0x2877
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms1/./assignment2.hpp
// Function: assignment2::QuickSort(std::vector<int, std::allocator<int>>&, int, int, int)
void QuickSort(vector<int>& input, int left, int right, int partitionType)
    {
        if (left == right)
            return;
        
        int pivotIndex = -1;
        switch (partitionType)
        {
            case 1: pivotIndex = partitionFirst(input, left, right); break;
            case 2: pivotIndex = partitionLast(input, left, right); break;
            case 3: pivotIndex = partitionMedian(input, left, right); break;
        }
        QuickSort(input, left, pivotIndex, partitionType);
        QuickSort(input, pivotIndex+1, right, partitionType);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %r13
cmpl %ebp, %r15d
je 0x2a30
cmpl $0x3, %ebx
je 0x2a05
cmpl $0x2, %ebx
je 0x29d3
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $0x1, %ebx
jne 0x2a15
movl %r15d, %eax
notl %eax
addl %ebp, %eax
addl %eax, 0xb813(%rip)      # 0xe1e4
jmp 0x29f6
movl %r15d, %eax
notl %eax
addl %ebp, %eax
addl %eax, 0xb808(%rip)      # 0xe1e8
movq (%r14), %rax
movslq %r15d, %rcx
movl -0x4(%rax,%r13,4), %edx
movl (%rax,%rcx,4), %esi
movl %esi, -0x4(%rax,%r13,4)
movl %edx, (%rax,%rcx,4)
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2877
jmp 0x2a12
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2901
movl %eax, %r12d
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %ebx, %ecx
callq 0x298e
incl %r12d
movl %r12d, %r15d
jmp 0x29a6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms1/./assignment4.hpp
// Function: assignment4::DFS(std::map<int, std::vector<int, std::allocator<int>>, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&, int)
void DFS(Graph& g, int i)
    {
        assert(g.count(i) > 0); // every node MUST be in a graph
        
        _seen[i] = 1;           // mark s as seen
        _leaders[i] = _s;

        // for every edge (s, v)
        for (int v : g[i])
        {
            if (!_seen[v])   // if v is not yet explored
            {
                DFS(g, v);
            }
        }
        _time++;
        _times[i] = _time;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movq 0x10(%rdi), %rdx
leaq 0x8(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x2a79
movq %rax, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x2a62
movq %rax, %rdx
cmpq %rax, %rcx
je 0x2a8b
cmpl %esi, 0x20(%rcx)
cmovgq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x2b16
movslq %esi, %rax
movq 0xb772(%rip), %rcx      # 0xe210
movl $0x1, (%rcx,%rax,4)
movl 0xb70d(%rip), %eax      # 0xe1b8
leaq 0xc(%rsp), %rsi
movslq (%rsi), %rcx
movq 0xb776(%rip), %rdx      # 0xe230
movl %eax, (%rdx,%rcx,4)
movq %rbx, %rdi
callq 0x6240
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x2aef
movslq (%r14), %rsi
movq 0xb735(%rip), %rax      # 0xe210
cmpl $0x0, (%rax,%rsi,4)
jne 0x2ae9
movq %rbx, %rdi
callq 0x2a3f
addq $0x4, %r14
jmp 0x2acc
movl 0xb753(%rip), %eax      # 0xe248
incl %eax
movl %eax, 0xb74b(%rip)      # 0xe248
movslq 0xc(%rsp), %rcx
movq 0xb6e7(%rip), %rdx      # 0xe1f0
movl %eax, (%rdx,%rcx,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7563(%rip), %rdi      # 0xa080
leaq 0x756b(%rip), %rsi      # 0xa08f
leaq 0x7576(%rip), %rcx      # 0xa0a1
movl $0x47, %edx
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/Manca[P]algorithms1/./assignment4.hpp
// Function: assignment4::DFSLoop(std::map<int, std::vector<int, std::allocator<int>>, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&)
void DFSLoop(Graph& g)
    {
        // initally time and leader set to 0 and -1, respectively
        // seen list i reset too
        _time = 0;
        _s = -1;
        _seen = seenList(g.size()+1, 0);   // mark all nodes unexplored
        
        int n = g.size();   // we assume the vertex labeling 1..n here
        
        for (int i = n; i > 0; i--)
        {
            if (!_seen[i]) // if i is not yet explored
            {
                _s = i;
                DFS(g, i);
            }
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0xb701(%rip)      # 0xe248
movl $0xffffffff, 0xb667(%rip) # imm = 0xFFFFFFFF
movq 0x28(%rdi), %rsi
incq %rsi
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x10(%rsp), %r14
leaq 0xb(%rsp), %rcx
movq %r14, %rdi
callq 0x62a4
movq 0xb698(%rip), %rdi      # 0xe210
movaps (%r14), %xmm0
movq 0x10(%r14), %rax
movq %rdi, (%r14)
movups 0xb68e(%rip), %xmm1     # 0xe218
movaps %xmm0, 0xb67f(%rip)     # 0xe210
movq %rax, 0xb688(%rip)      # 0xe220
movups %xmm1, 0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, %rdi
je 0x2bb6
callq 0x21b0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2bc5
callq 0x21b0
movq 0x28(%rbx), %r14
testl %r14d, %r14d
jle 0x2c02
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movq 0xb634(%rip), %rax      # 0xe210
cmpl $0x0, (%rax,%r14,4)
jne 0x2bf5
movl %r14d, 0xb5ce(%rip)     # 0xe1b8
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2a3f
leaq -0x1(%r14), %rax
cmpq $0x1, %r14
movq %rax, %r14
jg 0x2bd5
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/migueeelvargas[P]Auto-Complete/DictionaryTrie.cpp
// Function: DictionaryTrie::deleteAll(TrieNode*)
void DictionaryTrie::deleteAll(TrieNode* root) {
  if (root == NULL)
    return;

  deleteAll(root->left);
  deleteAll(root->right);
  deleteAll(root->mid);

  delete root;
}

// Assembly:
testq %rsi, %rsi
je 0x5e1e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
callq 0x5dda
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x5dda
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x5dda
movl $0x28, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21d0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/migueeelvargas[P]Auto-Complete/DictionaryTrie.cpp
// Function: DictionaryTrie::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool DictionaryTrie::find(std::string word) const {
  // If TST is empty, exit.
  if (root == NULL)
    return false;

  // Traverse the tree, looking for word.
  auto retVal = traverse(word);

  // Check if return value is valid & is a word.
  return word[word.length()-1] == retVal.first->symbol
          && retVal.second == word.length()-1 
          && retVal.first->isAWord;
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x609c
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x34b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x60ae
movq %rax, %r14
movl %edx, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x6073
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movb -0x1(%rax,%rcx), %al
decq %rcx
cmpb (%r14), %al
sete %al
movl %ebp, %edx
cmpq %rdx, %rcx
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x609f
movb 0x20(%r14), %al
jmp 0x60a1
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/migueeelvargas[P]Auto-Complete/DictionaryTrie.cpp
// Function: DictionaryTrie::findPrefixWords(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::multimap<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::greater<int>, std::allocator<std::pair<int const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void DictionaryTrie::findPrefixWords (std::string prefix,
  std::multimap<int, std::string, std::greater<int>> &prefixWords) {

  auto retVal = traverse(prefix);
  TrieNode* parent = retVal.first;

  // Checks if the prefix doesn't have any words, exits
  if (parent == NULL)
    return;

  // If the prefix is a word, add it to prefixWords
  if (parent->isAWord) {
    prefixWords.insert(std::pair<int, std::string>(parent->freq, prefix));
  }

  std::string buffer = "";
  // Get all prefix words
  getPrefixWords(parent->mid, prefix, prefixWords);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0x34b0
movq %r14, %rdi
movq %r13, %rsi
callq 0x60ae
movq %rax, %r12
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x6355
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21d0
testq %r12, %r12
je 0x642a
cmpb $0x1, 0x20(%r12)
jne 0x63ad
movl 0x24(%r12), %eax
leaq 0x8(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x34b0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x67c8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x63ad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1cf7(%rip), %rdx      # 0x80b4
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x37e8
movq 0x18(%r12), %r12
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x34b0
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x6490
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6414
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21d0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x642a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x6487
movq 0x18(%rsp), %rsi
jmp 0x647a
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x646c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x646c
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x6487
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x6487
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/migueeelvargas[P]Auto-Complete/DictionaryBST.cpp
// Function: DictionaryBST::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool DictionaryBST::insert(std::string word){
	// Checks if word is already in the dictionary
	if(find(word))
		return false;

	dictionary.insert(word);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x34b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x6bda
movq %rax, %r15
leaq 0x8(%r14), %r13
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6958
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
cmpq %r13, %r15
jne 0x6968
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a32
cmpq %r13, %r15
sete %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6995
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/migueeelvargas[P]Auto-Complete/DictionaryHashtable.cpp
// Function: DictionaryHashtable::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool DictionaryHashtable::insert(std::string word) {
	// Checks if word is already in the dictionary
	if(find(word))
		return false;

	dictionary.insert(word);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x34b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x71f8
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6cda
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
testq %r15, %r15
jne 0x6cf2
leaq 0x20(%rsp), %rdx
movq %r14, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6dd8
testq %r15, %r15
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6d1d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/daklqw[P]beepmania/core.cpp
// Function: gamecore::configtrack(_IO_FILE*)
void gamecore::configtrack(FILE * fin) {
	int tc;
	fscanf(fin, "%d %d", &fpslimit, &tc);
	double spn;
	int C, L, R, dta;
	fscanf(fin, "%lf%d%d%d%d", &spn, &C, &L, &R, &dta);
	tv.clear();
	for (int i = 0; i < tc; ++i) {
		int A, B;
		fscanf(fin, "%d%d", &A, &B);
		binder[A] = i;
		tv.push_back(track());
		tv[i].reset();
		tv[i].setdisplaych(B);
		tv[i].bindscore(&sb);
		tv[i].setspn(spn);
		tv[i].setrange(35000, 80000, 150000, 200000);
		tv[i].setarea(rect(coord(1, R * i + 1), coord(C, R * i + R)));
		tv[i].setdelta(dta);
		tv[i].setlightheight(L);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5a8(%rdi), %rdx
leaq 0x33dc(%rip), %rsi      # 0x6089
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2310
leaq 0x14(%rsp), %rax
movq %rax, (%rsp)
leaq 0x33c3(%rip), %rsi      # 0x608f
leaq 0x38(%rsp), %rdx
leaq 0x1c(%rsp), %rcx
leaq 0x18(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %rbx, 0x30(%rsp)
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2310
movq 0x4c8(%r14), %r15
movq 0x4d0(%r14), %r12
cmpq %r15, %r12
je 0x2d1d
movq %r15, %rbx
movq %rbx, %rdi
callq 0x57f6
addq $0x68, %rbx
cmpq %r12, %rbx
jne 0x2d05
movq %r15, 0x4d0(%r14)
cmpl $0x0, 0xc(%rsp)
jle 0x2e9b
leaq 0x4c8(%r14), %rax
movq %rax, 0x28(%rsp)
leaq 0x4e0(%r14), %rax
movq %rax, 0x20(%rsp)
xorl %ebp, %ebp
xorl %ebx, %ebx
movq 0x30(%rsp), %rdi
leaq 0x3346(%rip), %rsi      # 0x6096
leaq 0x44(%rsp), %r12
movq %r12, %rdx
leaq 0x10(%rsp), %rcx
xorl %eax, %eax
callq 0x2310
movq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x3342
movl %ebx, (%rax)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x57d8
movq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x3b6e
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x57f6
movq 0x4c8(%r14), %rdi
addq %rbp, %rdi
callq 0x5a14
movq 0x4c8(%r14), %rdi
addq %rbp, %rdi
movsbl 0x10(%rsp), %esi
callq 0x59d0
movq 0x4c8(%r14), %rdi
addq %rbp, %rdi
movq %r14, %rsi
callq 0x5810
movq 0x4c8(%r14), %rdi
addq %rbp, %rdi
movsd 0x38(%rsp), %xmm0
callq 0x59d6
movq 0x4c8(%r14), %rdi
addq %rbp, %rdi
movl $0x88b8, %esi           # imm = 0x88B8
movl $0x13880, %edx          # imm = 0x13880
movl $0x249f0, %ecx          # imm = 0x249F0
movl $0x30d40, %r8d          # imm = 0x30D40
callq 0x59dc
movq 0x4c8(%r14), %r12
addq %rbp, %r12
movl 0x8(%rsp), %edx
imull %ebx, %edx
incl %edx
movq %r15, %rdi
movl $0x1, %esi
callq 0x5ec8
movl 0x1c(%rsp), %esi
incq %rbx
movl 0x8(%rsp), %edx
imull %ebx, %edx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x5ec8
leaq 0x50(%rsp), %r13
movq %r13, %rdi
leaq 0x60(%rsp), %rsi
movq %r15, %rdx
callq 0x5f1e
movq %r12, %rdi
movq %r13, %rsi
callq 0x5816
movq 0x4c8(%r14), %rdi
addq %rbp, %rdi
movl 0x14(%rsp), %esi
callq 0x5b96
movq 0x4c8(%r14), %rdi
addq %rbp, %rdi
movl 0x18(%rsp), %esi
callq 0x5ba8
movslq 0xc(%rsp), %rax
addq $0x68, %rbp
cmpq %rax, %rbx
jl 0x2d44
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x57f6
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/daklqw[P]beepmania/core.cpp
// Function: gamecore::configui()
void gamecore::configui() {
	ui.bindtimer(&ti);
	ui.bindscore(&sb);
	ui.setFPS(coord(1, tv.size() * tv[0].getwidth() + 1));
	ui.setStatusPos(coord(tv[0].getdown().p2.x + 1, 3));
	for (int i = 0; i != (int)tv.size(); ++i)
		ui.pushtrack(&tv[i]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x510(%rdi), %r14
leaq 0x38(%rdi), %rsi
movq %r14, %rdi
callq 0x4072
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4078
movq 0x4c8(%rbx), %rdi
movq 0x4d0(%rbx), %r15
subq %rdi, %r15
shrq $0x3, %r15
callq 0x5b9a
imull %r15d, %eax
imull $0xc4ec4ec5, %eax, %edx # imm = 0xC4EC4EC5
incl %edx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
callq 0x5ec8
movq %r14, %rdi
movq %r15, %rsi
callq 0x4080
movq 0x4c8(%rbx), %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x5b44
movl 0x8(%r15), %esi
incl %esi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x3, %edx
callq 0x5ec8
movq %r14, %rdi
movq %r15, %rsi
callq 0x4090
movq 0x4c8(%rbx), %rsi
movq 0x4d0(%rbx), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0xc4ec4ec5, %eax, %eax # imm = 0xC4EC4EC5
testl %eax, %eax
je 0x2fbf
xorl %r15d, %r15d
xorl %r12d, %r12d
addq %r15, %rsi
movq %r14, %rdi
callq 0x4658
incq %r12
movq 0x4c8(%rbx), %rsi
movq 0x4d0(%rbx), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0xc4ec4ec5, %eax, %eax # imm = 0xC4EC4EC5
addq $0x68, %r15
cmpq %rax, %r12
jne 0x2f8d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/daklqw[P]beepmania/core.cpp
// Function: gamecore::getclick(int)
void gamecore::getclick(int ch) {
	bool light = true;
	if (ch < 0) light = false, ch = -ch;
	if (binder.count(ch)) {
		track & tar = tv[binder[ch]];
		if (light) {
			int cur = ti.current();
			tar.checkhit(cur);
		}
		tar.setlight(light);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
movl %eax, 0xc(%rsp)
movq 0x4f0(%rdi), %rsi
leaq 0x4e8(%rdi), %rcx
movq %rcx, %rdx
testq %rsi, %rsi
je 0x3015
movq %rcx, %rdx
xorl %edi, %edi
cmpl %eax, 0x20(%rsi)
setl %dil
cmovgeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x2ffe
movq %rcx, %rsi
cmpq %rcx, %rdx
je 0x3027
cmpl 0x20(%rdx), %eax
cmovlq %rcx, %rdx
movq %rdx, %rsi
cmpq %rcx, %rsi
je 0x3075
leaq 0x4e0(%r14), %rdi
leaq 0xc(%rsp), %rsi
callq 0x3342
movslq (%rax), %rax
imulq $0x68, %rax, %r15
addq 0x4c8(%r14), %r15
testl %ebx, %ebx
js 0x3066
addq $0x38, %r14
movq %r14, %rdi
callq 0x576c
movslq %eax, %rsi
movq %r15, %rdi
callq 0x5a28
notl %ebx
shrl $0x1f, %ebx
movq %r15, %rdi
movl %ebx, %esi
callq 0x5a20
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/daklqw[P]beepmania/core.cpp
// Function: gamecore::start()
void gamecore::start() {
	configtimer();
	int lst = ti.current();
	while (true) {
		while (int t = kb.getNextKey()) getclick(t);
		for (auto & i : tv) i.checkmiss(ti.current());
		if (ti.interval(lst) * fpslimit >= 1) {
			lst = ti.current();
			ui.update(lst);
			ui.flush();
		}
		if (!sd.empty() && ti.current() > sd.front())
			sd.playnext();
		usleep(10);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x575e
movq %r14, %rdi
callq 0x576c
movl %eax, 0xc(%rsp)
leaq 0x4a8(%rbx), %r15
leaq 0x510(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rbx), %rbp
movq %r15, %rdi
callq 0x4c7c
testl %eax, %eax
je 0x30d8
movq %rbx, %rdi
movl %eax, %esi
callq 0x2fcc
jmp 0x30c0
movq 0x4c8(%rbx), %r12
movq 0x4d0(%rbx), %r13
movq %r14, %rdi
cmpq %r13, %r12
je 0x3104
callq 0x576c
movslq %eax, %rsi
movq %r12, %rdi
callq 0x5afe
addq $0x68, %r12
jmp 0x30e6
movl 0xc(%rsp), %esi
callq 0x5794
xorps %xmm1, %xmm1
cvtsi2sdl 0x5a8(%rbx), %xmm1
mulsd %xmm0, %xmm1
ucomisd 0x2eec(%rip), %xmm1     # 0x6010
jb 0x314a
movq %r14, %rdi
callq 0x576c
movl %eax, 0xc(%rsp)
movslq %eax, %rsi
movq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x4134
movq %r12, %rdi
callq 0x45de
movq %rbp, %rdi
callq 0x51c0
testb %al, %al
jne 0x3176
movq %r14, %rdi
callq 0x576c
movl %eax, %r12d
movq %rbp, %rdi
callq 0x51b8
cmpl %eax, %r12d
jle 0x3176
movq %rbp, %rdi
callq 0x51cc
movl $0xa, %edi
callq 0x2230
jmp 0x30c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/daklqw[P]beepmania/cui.cpp
// Function: UI::UI()
UI::UI() {
	initscr();
	start_color();
	FPSset = false;
	init_pair(1, COLOR_BLACK, COLOR_RED);
	init_pair(2, COLOR_BLACK, COLOR_BLUE);
	init_pair(3, COLOR_WHITE, COLOR_BLACK);
	init_pair(4, COLOR_WHITE, COLOR_MAGENTA);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movq %r14, %rdi
xorl %esi, %esi
callq 0x471c
leaq 0x70(%rbx), %rdi
callq 0x5ec0
leaq 0x78(%rbx), %rdi
callq 0x5ec0
leaq 0x80(%rbx), %rdi
callq 0x5ec0
callq 0x2270
callq 0x2070
movb $0x0, 0x88(%rbx)
movl $0x1, %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2040
movl $0x2, %edi
xorl %esi, %esi
movl $0x4, %edx
callq 0x2040
movl $0x3, %edi
movl $0x7, %esi
xorl %edx, %edx
callq 0x2040
movl $0x4, %edi
movl $0x7, %esi
movl $0x5, %edx
callq 0x2040
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x4024
movq %rax, %r15
movq %r14, %rdi
callq 0x46cc
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4038
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %r15, %rdi
callq 0x2300