LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x1018(%rcx), %eax
jge 0xef02
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x818(%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xeed5
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xeef5
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl 0x8(%rax), %ecx
callq 0x10f30
movq $0x0, -0x18(%rbp)
jmp 0xeef7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xee9e
cmpq $0x0, -0x18(%rbp)
je 0xef1d
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl 0x8(%rax), %edx
callq 0x109a0
movq -0x30(%rbp), %rax
movb 0x101c(%rax), %cl
movq 0x10(%rax), %rax
movb %cl, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1150, %rsp           # imm = 0x1150
movq %rdi, -0x20(%rbp)
movl %esi, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movq %rdx, -0x28(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0xfd46
cmpl $0x0, -0xc(%rbp)
jle 0xfd46
cmpl $0x0, -0x8(%rbp)
jg 0xfd52
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfdf3
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
jle 0xfd6b
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xfdf3
cmpq $0x0, -0x28(%rbp)
jne 0xfd7b
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xfdf3
cmpl $0x1, -0x10(%rbp)
jne 0xfd92
movq -0x28(%rbp), %rax
movb $0x0, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xfdf3
movq -0x28(%rbp), %rdx
leaq -0x1148(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xecd0
testb $0x1, %al
jne 0xfdb3
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0xfdf3
cmpl $0x0, -0x938(%rbp)
jg 0xfdc5
movl $0x0, -0x4(%rbp)
jmp 0xfdf3
cmpl $0x1, -0xc(%rbp)
jne 0xfde0
leaq -0x1148(%rbp), %rdi
callq 0xee70
movl $0x0, -0x4(%rbp)
jmp 0xfdf3
leaq -0x1148(%rbp), %rdi
callq 0xf820
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1150, %rsp           # imm = 0x1150
popq %rbp
retq
nop
// File: xocoder[P]m_kcptun/vendor/cm256/gf256.cpp
// Function: gf256_init_
int gf256_init_(int version)
{
    if (version != GF256_VERSION)
        return -1; // User's header does not match library version.

    // Avoid multiple initialization
    if (Initialized)
        return 0;
    Initialized = true;

    if (!IsLittleEndian())
        return -2; // Architecture is not supported (code won't work without mods).

    gf256_architecture_init();
    gf256_poly_init(kDefaultPolynomialIndex);
    gf256_explog_init();
    gf256_muldiv_init();
    gf256_inv_init();
    gf256_sqr_init();
    gf256_mul_mem_init();

    if (!gf256_self_test())
        return -3; // Self-test failed (perhaps untested configuration)

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0xfe1a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfe86
testb $0x1, 0x2ad7f(%rip)     # 0x3aba0
je 0xfe2c
movl $0x0, -0x4(%rbp)
jmp 0xfe86
movb $0x1, 0x2ad6d(%rip)     # 0x3aba0
callq 0xfe90
testb $0x1, %al
jne 0xfe45
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xfe86
callq 0xfee0
movl $0x3, %edi
callq 0xff20
callq 0xff60
callq 0x100b0
callq 0x10200
callq 0x10260
callq 0x102c0
callq 0x10430
testb $0x1, %al
jne 0xfe7f
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xfe86
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: xocoder[P]m_kcptun/vendor/cm256/gf256.cpp
// Function: IsLittleEndian()
static bool IsLittleEndian()
{
    UnionType type;
    for (unsigned i = 0; i < 4; ++i)
        type.CharArray[i] = kLittleEndianTestData[i];
    return 0x01020304 == type.IntValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jae 0xfec2
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x845b(%rip), %rax      # 0x18308
movb (%rax,%rcx), %cl
movl -0x8(%rbp), %eax
movb %cl, -0x4(%rbp,%rax)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xfe9b
movl $0x1020304, %eax        # imm = 0x1020304
cmpl -0x4(%rbp), %eax
sete %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xocoder[P]m_kcptun/vendor/cm256/gf256.cpp
// Function: gf256_explog_init()
static void gf256_explog_init()
{
    unsigned poly = GF256Ctx.Polynomial;
    uint8_t* exptab = GF256Ctx.GF256_EXP_TABLE;
    uint16_t* logtab = GF256Ctx.GF256_LOG_TABLE;

    logtab[0] = 512;
    exptab[0] = 1;
    for (unsigned jj = 1; jj < 255; ++jj)
    {
        unsigned next = (unsigned)exptab[jj - 1] * 2;
        if (next >= 256)
            next ^= poly;

        exptab[jj] = static_cast<uint8_t>( next );
        logtab[exptab[jj]] = static_cast<uint16_t>( jj );
    }
    exptab[255] = exptab[0];
    logtab[exptab[255]] = 255;
    for (unsigned jj = 256; jj < 2 * 255; ++jj)
        exptab[jj] = exptab[jj % 255];
    exptab[2 * 255] = 1;
    for (unsigned jj = 2 * 255 + 1; jj < 4 * 255; ++jj)
        exptab[jj] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x2ac2a(%rip), %eax     # 0x3ab94
movl %eax, -0x4(%rbp)
leaq 0x841c(%rip), %rax      # 0x18390
addq $0x22400, %rax          # imm = 0x22400
movq %rax, -0x10(%rbp)
leaq 0x840b(%rip), %rax      # 0x18390
addq $0x22200, %rax          # imm = 0x22200
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movw $0x200, (%rax)          # imm = 0x200
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
movl $0x1, -0x1c(%rbp)
cmpl $0xff, -0x1c(%rbp)
jae 0x10009
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll %eax
movl %eax, -0x20(%rbp)
cmpl $0x100, -0x20(%rbp)     # imm = 0x100
jb 0xffd6
movl -0x4(%rbp), %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
movw %ax, %dx
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x1c(%rbp), %esi
movzbl (%rcx,%rsi), %ecx
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xffa6
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0xff(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0xff(%rcx), %ecx
movw $0xff, (%rax,%rcx,2)
movl $0x100, -0x24(%rbp)     # imm = 0x100
cmpl $0x1fe, -0x24(%rbp)     # imm = 0x1FE
jae 0x10070
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl $0xff, %ecx
xorl %edx, %edx
divl %ecx
movq -0x30(%rbp), %rax
movl %edx, %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10035
movq -0x10(%rbp), %rax
movb $0x1, 0x1fe(%rax)
movl $0x1ff, -0x28(%rbp)     # imm = 0x1FF
cmpl $0x3fc, -0x28(%rbp)     # imm = 0x3FC
jae 0x100a1
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x10082
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xocoder[P]m_kcptun/vendor/cm256/gf256.cpp
// Function: gf256_muldiv_init()
static void gf256_muldiv_init()
{
    // Allocate table memory 65KB x 2
    uint8_t* m = GF256Ctx.GF256_MUL_TABLE;
    uint8_t* d = GF256Ctx.GF256_DIV_TABLE;

    // Unroll y = 0 subtable
    for (int x = 0; x < 256; ++x)
        m[x] = d[x] = 0;

    // For each other y value:
    for (int y = 1; y < 256; ++y)
    {
        // Calculate log(y) for mult and 255 - log(y) for div
        const uint8_t log_y = static_cast<uint8_t>(GF256Ctx.GF256_LOG_TABLE[y]);
        const uint8_t log_yn = 255 - log_y;

        // Next subtable
        m += 256, d += 256;

        // Unroll x = 0
        m[0] = 0, d[0] = 0;

        // Calculate x * y, x / y
        for (int x = 1; x < 256; ++x)
        {
            uint16_t log_x = GF256Ctx.GF256_LOG_TABLE[x];

            m[x] = GF256Ctx.GF256_EXP_TABLE[log_x + log_y];
            d[x] = GF256Ctx.GF256_EXP_TABLE[log_x + log_yn];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x82d5(%rip), %rax      # 0x18390
addq $0x2000, %rax           # imm = 0x2000
movq %rax, -0x8(%rbp)
leaq 0x82c4(%rip), %rax      # 0x18390
addq $0x12000, %rax          # imm = 0x12000
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x10109
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x100dd
movl $0x1, -0x18(%rbp)
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jge 0x101f9
movslq -0x18(%rbp), %rcx
leaq 0x8268(%rip), %rax      # 0x18390
movw 0x22200(%rax,%rcx,2), %ax
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %ecx
movl $0xff, %eax
subl %ecx, %eax
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x1, -0x20(%rbp)
cmpl $0x100, -0x20(%rbp)     # imm = 0x100
jge 0x101e9
movslq -0x20(%rbp), %rcx
leaq 0x820a(%rip), %rax      # 0x18390
movw 0x22200(%rax,%rcx,2), %ax
movw %ax, -0x22(%rbp)
movzwl -0x22(%rbp), %eax
movzbl -0x19(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x81ea(%rip), %rax      # 0x18390
movb 0x22400(%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movzwl -0x22(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x81c4(%rip), %rax      # 0x18390
movb 0x22400(%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x10172
jmp 0x101eb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x10110
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xe935(%rip), %rdi      # 0x11fd8
leaq 0x895a(%rip), %rsi      # 0xc004
callq 0x3290
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3270
movq 0xe916(%rip), %rdi      # 0x11fd8
leaq 0x894d(%rip), %rsi      # 0xc016
callq 0x3290
movq %rax, %rdi
movq 0xe8e8(%rip), %rsi      # 0x11fc0
callq 0x32d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x270(%rbp)
movq %rdi, %rax
movq %rax, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x3440
leaq -0x239(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x34b0
movq -0x260(%rbp), %rdx
leaq 0x8888(%rip), %rsi      # 0xc0a2
leaq -0x238(%rbp), %rdi
callq 0x6ee0
jmp 0x3828
leaq -0x239(%rbp), %rdi
callq 0x32f0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3370
movb %al, -0x271(%rbp)
jmp 0x3854
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x3863
jmp 0x391b
jmp 0x3865
leaq -0x218(%rbp), %rdi
leaq -0x24d(%rbp), %rsi
callq 0x33b0
movq %rax, -0x280(%rbp)
jmp 0x3881
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3370
movb %al, -0x281(%rbp)
jmp 0x389f
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x38ab
jmp 0x38fc
movsbl -0x24d(%rbp), %esi
leaq -0x238(%rbp), %rdi
callq 0x31e0
jmp 0x38c0
jmp 0x3865
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x239(%rbp), %rdi
callq 0x32f0
jmp 0x39b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
jmp 0x39aa
movq -0x270(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x31b0
movl $0x1, -0x254(%rbp)
jmp 0x3982
leaq -0x255(%rbp), %rdi
movq %rdi, -0x290(%rbp)
callq 0x34b0
movq -0x270(%rbp), %rdi
movq -0x290(%rbp), %rdx
leaq 0x875f(%rip), %rsi      # 0xc0a2
callq 0x6ee0
jmp 0x394a
leaq -0x255(%rbp), %rdi
callq 0x32f0
movl $0x1, -0x254(%rbp)
jmp 0x3982
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x255(%rbp), %rdi
callq 0x32f0
jmp 0x39aa
leaq -0x238(%rbp), %rdi
callq 0x31d0
leaq -0x218(%rbp), %rdi
callq 0x30b0
movq -0x268(%rbp), %rax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x238(%rbp), %rdi
callq 0x31d0
leaq -0x218(%rbp), %rdi
callq 0x30b0
movq -0x248(%rbp), %rdi
callq 0x34a0
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x3c26
movb $0x0, -0x1(%rbp)
jmp 0x3c94
testb $0x1, -0x15(%rbp)
je 0x3c56
movq -0x48(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq 0x8461(%rip), %rsi      # 0xc09c
callq 0x70a0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3350
leaq -0x38(%rbp), %rdi
callq 0x31d0
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
callq 0x3130
movq -0x48(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x3200
movl -0x54(%rbp), %edi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3180
movl %eax, -0x3c(%rbp)
cmpl $-0x1, -0x3c(%rbp)
sete %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: mortrevere[P]ninjat/main.cpp
// Function: buildList(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::string buildList(std::vector<std::string>& nicks) {
  std::string list = std::to_string(nicks.size()) + " users :";
  for(unsigned int i = 0; i < nicks.size(); i++)
    list += " " + (nicks[i].length() ? nicks[i] : "<no_nickname_yet>");
  return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7320
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x7240
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
leaq 0x828a(%rip), %rdx      # 0xc053
callq 0x71f0
jmp 0x3dd0
leaq -0x38(%rbp), %rdi
callq 0x31d0
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7320
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0x3f67
movq -0x10(%rbp), %rdi
movl -0x48(%rbp), %eax
movl %eax, %esi
callq 0x7390
movq %rax, %rdi
callq 0x33f0
movb $0x0, -0x8a(%rbp)
cmpq $0x0, %rax
je 0x3e4a
movq -0x10(%rbp), %rdi
movl -0x48(%rbp), %eax
movl %eax, %esi
callq 0x7390
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
callq 0x3140
jmp 0x3e48
jmp 0x3e82
leaq -0x89(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x34b0
movq -0xb8(%rbp), %rdx
movb $0x1, -0x8a(%rbp)
leaq 0x81ea(%rip), %rsi      # 0xc05c
leaq -0x88(%rbp), %rdi
callq 0x6ee0
jmp 0x3e80
jmp 0x3e82
leaq 0x81c8(%rip), %rsi      # 0xc051
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x7340
jmp 0x3e9b
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3380
jmp 0x3ead
leaq -0x68(%rbp), %rdi
callq 0x31d0
leaq -0x88(%rbp), %rdi
callq 0x31d0
testb $0x1, -0x8a(%rbp)
jne 0x3ecd
jmp 0x3ed9
leaq -0x89(%rbp), %rdi
callq 0x32f0
jmp 0x3edb
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x3de0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
jmp 0x3f99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3f8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3f4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3f42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31d0
leaq -0x88(%rbp), %rdi
callq 0x31d0
testb $0x1, -0x8a(%rbp)
jne 0x3f59
jmp 0x3f65
leaq -0x89(%rbp), %rdi
callq 0x32f0
jmp 0x3f8d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3f7d
movq -0xa0(%rbp), %rdi
callq 0x31d0
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x31d0
movq -0x40(%rbp), %rdi
callq 0x34a0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rcx, -0x30(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x71b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x4030
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x71d0
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x4023
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x7390
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x3040
movb $0x1, -0x1(%rbp)
jmp 0x4034
jmp 0x4025
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3fd2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x71b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x40a1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x71d0
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x4091
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x40a8
jmp 0x4093
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4057
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7320
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x4131
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7390
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x73b0
testb $0x1, %al
jne 0x4118
jmp 0x4121
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x4138
jmp 0x4123
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x40dc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mortrevere[P]ninjat/main.cpp
// Function: clientCleanup(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>>>>&, bool)
void clientCleanup(int csock, std::vector<int>& clients, std::vector<std::string>& nicks, bool notifyEveryone = true) {
  std::string nick = nicks[getIndex(csock, clients)];
  nicks.erase(nicks.begin() + getIndex(csock, clients));
  clients.erase(clients.begin() + getIndex(csock, clients));
  closesocket(csock);
  if(notifyEveryone && nick != "") {
    sAll(" *** [QUIT] : " + nick + "\n", clients);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movb %cl, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xe8(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x4040
movq -0xe8(%rbp), %rdi
movslq %eax, %rsi
callq 0x7390
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x3140
movq -0x18(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x74b0
movq %rax, -0x58(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x4040
movslq %eax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x74e0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7520
movq -0xe0(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x7440
movq %rax, -0xd8(%rbp)
jmp 0x41f5
movq -0xd8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x75d0
movq %rax, -0x88(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x4040
movslq %eax, %rsi
leaq -0x88(%rbp), %rdi
callq 0x7600
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x7640
movq -0xf8(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x7560
movq %rax, -0xf0(%rbp)
jmp 0x425c
movq -0xf0(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0x4(%rbp), %edi
callq 0x3510
jmp 0x4274
testb $0x1, -0x19(%rbp)
je 0x4348
leaq 0x7e1d(%rip), %rsi      # 0xc0a2
leaq -0x40(%rbp), %rdi
callq 0x7680
movb %al, -0xf9(%rbp)
jmp 0x4296
movb -0xf9(%rbp), %al
testb $0x1, %al
jne 0x42a5
jmp 0x4348
leaq 0x7dc2(%rip), %rsi      # 0xc06e
leaq -0xd0(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x70a0
jmp 0x42be
leaq 0x816e(%rip), %rdx      # 0xc433
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x71f0
jmp 0x42da
movq -0x10(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x3ca0
jmp 0x42ec
leaq -0xb0(%rbp), %rdi
callq 0x31d0
leaq -0xd0(%rbp), %rdi
callq 0x31d0
jmp 0x4348
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x435a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x433a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x31d0
leaq -0xd0(%rbp), %rdi
callq 0x31d0
jmp 0x435a
leaq -0x40(%rbp), %rdi
callq 0x31d0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x31d0
movq -0x60(%rbp), %rdi
callq 0x34a0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x118(%rbp)
movl $0x2, -0x54(%rbp)
movl $0x4, -0x50(%rbp)
movl $0x6, -0x4c(%rbp)
leaq -0x54(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x3, -0x40(%rbp)
leaq -0x55(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x28f0
movq -0x118(%rbp), %rdi
movq -0x110(%rbp), %rcx
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x2910
jmp 0x238f
movb $0x1, -0x86(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x128(%rbp)
movl $0x1, -0x84(%rbp)
movl $0x3, -0x80(%rbp)
movl $0x5, -0x7c(%rbp)
leaq -0x84(%rbp), %rax
movq %rax, -0x78(%rbp)
movq $0x3, -0x70(%rbp)
leaq -0x85(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x28f0
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rcx
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x2990
jmp 0x23fc
movb $0x0, -0x86(%rbp)
leaq -0x85(%rbp), %rdi
callq 0x2a40
leaq -0x55(%rbp), %rdi
callq 0x2a40
leaq -0xb8(%rbp), %rdi
callq 0x2ac0
leaq -0xd8(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x21c0
movq -0x130(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x2af0
jmp 0x2450
leaq -0x108(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
callq 0x2b20
jmp 0x246c
leaq -0x38(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x2b50
testb $0x1, %al
jne 0x2482
jmp 0x2487
jmp 0x251f
leaq 0x7b9a(%rip), %rdi      # 0xa028
leaq 0x7b9e(%rip), %rsi      # 0xa033
movl $0x1e, %edx
leaq 0x7ba6(%rip), %rcx      # 0xa047
callq 0x2100
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x24e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x85(%rbp), %rdi
callq 0x2a40
testb $0x1, -0x86(%rbp)
jne 0x24d7
jmp 0x24e3
movq -0x118(%rbp), %rdi
callq 0x2a60
jmp 0x24e5
leaq -0x55(%rbp), %rdi
callq 0x2a40
jmp 0x254c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x20e0
leaq -0xb8(%rbp), %rdi
callq 0x2bc0
leaq -0x38(%rbp), %rdi
callq 0x2bc0
jmp 0x254c
leaq -0xd8(%rbp), %rdi
callq 0x20e0
leaq -0xb8(%rbp), %rdi
callq 0x2bc0
leaq -0x38(%rbp), %rdi
callq 0x2bc0
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x21f0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4c60
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x4c80
testb $0x1, %al
jne 0x4c2e
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4c60
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
callq 0x4ca0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x4c0c
jmp 0x4c24
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x4d20
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4c48
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x4df0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5c20
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x5c40
testb $0x1, %al
jne 0x4dc9
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5c60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x4d6c
jmp 0x4dbf
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5c20
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
callq 0x5c90
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x4da7
jmp 0x4dbf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5d10
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4de3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5d10
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Manca[P]algorithms1/./assignment1.hpp
// Function: assignment1::Count(std::vector<int, std::allocator<int>>&)
long long Count(std::vector<int> &input)
    {
        if (input.size() == 1)
            return 0;
        else
        {
            // prepare two subarrays
            auto mid = input.begin() + (input.size()/2);
            std::vector<int> left(input.begin(), mid);
            std::vector<int> right(mid, input.end());
            
            // find inversions in each half of the array
            long long x = Count(left);
            long long y = Count(right);
            
            // finally if there are split inversions find them two
            long long z = CountSplitInv(input, left, right);
            
            // the result is the sum of the inversions in each step
            return x + y + z;
        }
    }

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x7f90
cmpq $0x1, %rax
jne 0x2983
movq $0x0, 0xd0(%rsp)
jmp 0x2b76
movq 0xc8(%rsp), %rdi
callq 0x8360
movq %rax, 0xb8(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x7f90
movq %rax, %rsi
shrq %rsi
leaq 0xb8(%rsp), %rdi
callq 0x8390
movq %rax, 0xc0(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x8360
movq %rax, 0x98(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x83d0
movq 0x28(%rsp), %rcx
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x83e0
jmp 0x2a1b
leaq 0x8f(%rsp), %rdi
callq 0x8470
movq 0xc0(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x8480
movq %rax, 0x50(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x83d0
movq 0x20(%rsp), %rcx
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x83e0
jmp 0x2a71
leaq 0x4f(%rsp), %rdi
callq 0x8470
leaq 0xa0(%rsp), %rdi
callq 0x2950
movq %rax, 0x18(%rsp)
jmp 0x2a8f
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2950
movq %rax, 0x10(%rsp)
jmp 0x2aaa
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xc8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x25f0
movq %rax, 0x8(%rsp)
jmp 0x2ad5
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
addq 0x38(%rsp), %rax
addq 0x30(%rsp), %rax
movq %rax, 0xd0(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x8300
leaq 0xa0(%rsp), %rdi
callq 0x8300
jmp 0x2b76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x8f(%rsp), %rdi
callq 0x8470
jmp 0x2b86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x8470
jmp 0x2b67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x8300
leaq 0xa0(%rsp), %rdi
callq 0x8300
jmp 0x2b86
movq 0xd0(%rsp), %rax
addq $0xd8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x2330
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x84b0
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x2c77
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x84b0
movl (%rax), %eax
cmpl 0x24(%rsp), %eax
jge 0x2c68
movq 0x30(%rsp), %rdi
movslq 0x20(%rsp), %rsi
callq 0x84b0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x84b0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x2ba0
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x2c6a
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2c0c
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x84b0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x20(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x84b0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2ba0
movl 0x20(%rsp), %eax
subl $0x1, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jne 0x2f74
jmp 0x3016
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x2fa1
jmp 0x2f8b
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x2fb9
jmp 0x2f96
movl 0xc(%rsp), %eax
subl $0x3, %eax
je 0x2fd1
jmp 0x2fe7
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x2cc0
movl %eax, 0x10(%rsp)
jmp 0x2fe7
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x2d00
movl %eax, 0x10(%rsp)
jmp 0x2fe7
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x2d80
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
callq 0x2f50
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
addl $0x1, %esi
movl 0x18(%rsp), %edx
movl 0x14(%rsp), %ecx
callq 0x2f50
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x84d0
cmpq $0x0, %rax
jbe 0x3044
jmp 0x3063
leaq 0x16fcd(%rip), %rdi     # 0x1a018
leaq 0x16fd5(%rip), %rsi     # 0x1a027
movl $0x47, %edx
leaq 0x16fdb(%rip), %rcx     # 0x1a039
callq 0x2140
movslq 0x2c(%rsp), %rsi
leaq 0x21199(%rip), %rdi     # 0x24208
callq 0x84b0
movl $0x1, (%rax)
movl 0x21148(%rip), %eax     # 0x241c8
movl %eax, 0x8(%rsp)
movslq 0x2c(%rsp), %rsi
leaq 0x21190(%rip), %rdi     # 0x24220
callq 0x84b0
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x8530
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x8360
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x8480
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8620
testb $0x1, %al
jne 0x30e2
jmp 0x3124
leaq 0x18(%rsp), %rdi
callq 0x8660
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rsi
leaq 0x2110a(%rip), %rdi     # 0x24208
callq 0x84b0
cmpl $0x0, (%rax)
jne 0x3116
movq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x3020
jmp 0x3118
leaq 0x18(%rsp), %rdi
callq 0x8670
jmp 0x30cd
movl 0x2110e(%rip), %eax     # 0x24238
addl $0x1, %eax
movl %eax, 0x21105(%rip)     # 0x24238
movl 0x210ff(%rip), %eax     # 0x24238
movl %eax, 0x4(%rsp)
movslq 0x2c(%rsp), %rsi
leaq 0x210a7(%rip), %rdi     # 0x241f0
callq 0x84b0
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x0, 0x210c5(%rip)     # 0x24238
movl $0xffffffff, 0x2104b(%rip) # imm = 0xFFFFFFFF
movq 0x50(%rsp), %rdi
callq 0x8690
incq %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x34(%rsp)
leaq 0x33(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x83d0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
leaq 0x38(%rsp), %rdi
leaq 0x34(%rsp), %rdx
callq 0x86a0
jmp 0x31c1
leaq 0x21040(%rip), %rdi     # 0x24208
leaq 0x38(%rsp), %rsi
callq 0x8720
leaq 0x38(%rsp), %rdi
callq 0x8300
leaq 0x33(%rsp), %rdi
callq 0x8470
movq 0x50(%rsp), %rdi
callq 0x8690
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jle 0x325c
movslq 0x1c(%rsp), %rsi
leaq 0x20ff9(%rip), %rdi     # 0x24208
callq 0x84b0
cmpl $0x0, (%rax)
jne 0x324d
movl 0x1c(%rsp), %eax
movl %eax, 0x20fa5(%rip)     # 0x241c8
movq 0x50(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x3020
jmp 0x324d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x33(%rsp), %rdi
callq 0x8470
jmp 0x3261
jmp 0x324f
movl 0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x31fc
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2330
nopl (%rax,%rax)
// File: Manca[P]algorithms1/./lib/Heap.hpp
// Function: DataStructures::Heap::extractMinMax()
int extractMinMax()
        {
            int result;
            if (_heap.size() > 0)
            {
                result = _heap[0];
                _heap[0] = _heap[_heap.size() - 1];
                _heap.pop_back();
                
                bubbleDown(_minHeap);
            }
            return result;
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
callq 0x7f90
cmpq $0x0, %rax
jbe 0x9460
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x84b0
movq 0x10(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0x7f90
movq (%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x84b0
movq 0x10(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x84b0
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rdi
movl %ecx, (%rax)
addq $0x8, %rdi
callq 0xc440
movq 0x10(%rsp), %rdi
movb (%rdi), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xc460
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: Manca[P]algorithms1/./lib/Heap.hpp
// Function: DataStructures::Heap::leftChild(int)
int leftChild(int x)
        {
            size_t left = x*2 + 1;
            if (left < _heap.size())
                return left;
            else
                return x;
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
shll %eax
addl $0x1, %eax
cltq
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0x7f90
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xc95b
movq 0x8(%rsp), %rax
movl %eax, 0x24(%rsp)
jmp 0xc963
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: Manca[P]algorithms1/./lib/Heap.hpp
// Function: DataStructures::Heap::rightChild(int)
int rightChild(int x)
        {
            size_t right = x*2 + 2;
            if (right < _heap.size())
                return right;
            else
                return leftChild(x);
        }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x24(%rsp), %eax
shll %eax
addl $0x2, %eax
cltq
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0x7f90
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xc9c2
movq 0x18(%rsp), %rax
movl %eax, 0x34(%rsp)
jmp 0xc9d4
movq 0x8(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0xc910
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8ee1
jmp 0x8f30
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x8ec0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x8ec0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x8ec0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8f30
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0x3230
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)