LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: cristian-bicheru[P]arith/./arith.h
// Function: arith::CompressBuffer(std::vector<unsigned char, std::allocator<unsigned char>>&, buffer::CodecByteStream&)
CodecStatusCode CompressBuffer(std::vector<unsigned char>& UncompressedBuffer, buffer::CodecByteStream& CompressedBuffer) {
        std::cout << "Initializing Compressor..." << std::endl;
        CodecProbabilityTable ProbabilityTable;
        ProbabilityTable.GenerateTable(UncompressedBuffer);
        CompressBuffer(UncompressedBuffer, ProbabilityTable, CompressedBuffer);
        uint64_t UncompressedBufferSize = UncompressedBuffer.size();
        buffer::EncodeTypeToBuffer<uint64_t>(CompressedBuffer.GetBuffer(), 0, &UncompressedBufferSize);
        ProbabilityTable.EncodeToBuffer(CompressedBuffer.GetBuffer(), 8);
        return Success;
    }

// Assembly:
subq $0x428, %rsp            # imm = 0x428
movq %rdi, 0x420(%rsp)
movq %rsi, 0x418(%rsp)
movq 0x1e6b2(%rip), %rdi     # 0x21fc0
leaq 0x1477f(%rip), %rsi     # 0x18094
callq 0x21a0
movq %rax, %rdi
movq 0x1e67c(%rip), %rsi     # 0x21fa0
callq 0x21d0
leaq 0x10(%rsp), %rdi
callq 0x5380
movq 0x420(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x53d0
movq 0x420(%rsp), %rdi
movq 0x418(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x2ba0
movq 0x420(%rsp), %rdi
callq 0x4b20
movq %rax, 0x8(%rsp)
movq 0x418(%rsp), %rdi
callq 0x55f0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x8(%rsp), %rdx
callq 0x5580
movq 0x418(%rsp), %rdi
callq 0x55f0
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
movl $0x8, %edx
callq 0x5600
xorl %eax, %eax
addq $0x428, %rsp            # imm = 0x428
retq
nopl (%rax,%rax)
// File: cristian-bicheru[P]arith/./arith.h
// Function: arith::UncompressBuffer(buffer::CodecByteStream&, std::vector<unsigned char, std::allocator<unsigned char>>&)
CodecStatusCode UncompressBuffer(buffer::CodecByteStream& UncompressedBuffer, std::vector<unsigned char>& CompressedBuffer) {
        std::cout << "Initializing Uncompressor..." << std::endl;
        uint64_t UncompressedBufferSize;
        CodecProbabilityTable ProbabilityTable;

        buffer::DecodeTypeFromBuffer<uint64_t>(CompressedBuffer, 0, &UncompressedBufferSize);
        ProbabilityTable.DecodeFromBuffer(CompressedBuffer, 8);

        UncompressBuffer(CompressedBuffer,
                         ProbabilityTable,
                         UncompressedBuffer,
                         UncompressedBufferSize);

        UncompressedBuffer.TruncateOne();

        return Success;
    }

// Assembly:
subq $0x428, %rsp            # imm = 0x428
movq %rdi, 0x420(%rsp)
movq %rsi, 0x418(%rsp)
movq 0x1e5e2(%rip), %rdi     # 0x21fc0
leaq 0x146ca(%rip), %rsi     # 0x180af
callq 0x21a0
movq %rax, %rdi
movq 0x1e5ac(%rip), %rsi     # 0x21fa0
callq 0x21d0
leaq 0x8(%rsp), %rdi
callq 0x5380
movq 0x418(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x410(%rsp), %rdx
callq 0x5670
movq 0x418(%rsp), %rsi
leaq 0x8(%rsp), %rdi
movl $0x8, %edx
callq 0x56d0
movq 0x418(%rsp), %rdi
movq 0x420(%rsp), %rdx
movq 0x410(%rsp), %rcx
leaq 0x8(%rsp), %rsi
callq 0x31a0
movq 0x420(%rsp), %rdi
callq 0x5740
xorl %eax, %eax
addq $0x428, %rsp            # imm = 0x428
retq
nopl (%rax)
// File: cristian-bicheru[P]arith/./arith.h
// Function: arith::CompressFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CodecStatusCode CompressFile(const std::string& InFile, const std::string& OutFile) {
        std::vector<unsigned char> UncompressedBuffer;

        if (buffer::LoadFile(&InFile, UncompressedBuffer)) {
            buffer::CodecByteStream CompressedBuffer(256*4+8);
            arith::CompressBuffer(UncompressedBuffer, CompressedBuffer);
            if (buffer::SaveFile(CompressedBuffer.GetBuffer(), &OutFile)) {
                return Success;
            } else {
                std::cerr << "File Write Error." << std::endl;
                return FileWriteError;
            }
        } else {
            std::cerr << "File Read Error." << std::endl;
            return FileReadError;
        }
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x5790
movq 0x28(%rsp), %rsi
movq 0x98(%rsp), %rdi
callq 0x26a0
movb %al, 0x33(%rsp)
jmp 0x3aae
movb 0x33(%rsp), %al
testb $0x1, %al
jne 0x3abb
jmp 0x3ba1
leaq 0x38(%rsp), %rdi
movl $0x408, %esi            # imm = 0x408
callq 0x57a0
jmp 0x3acc
leaq 0x78(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x38f0
jmp 0x3add
leaq 0x38(%rsp), %rdi
callq 0x55f0
movq %rax, 0x20(%rsp)
jmp 0x3aee
movq 0x20(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x2850
movb %al, 0x1f(%rsp)
jmp 0x3b06
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x3b10
jmp 0x3b55
movl $0x0, 0xa4(%rsp)
movl $0x1, 0x34(%rsp)
jmp 0x3b95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x3bfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5830
jmp 0x3bfa
movq 0x1e48c(%rip), %rdi     # 0x21fe8
leaq 0x14569(%rip), %rsi     # 0x180cc
callq 0x21a0
movq %rax, 0x10(%rsp)
jmp 0x3b6f
movq 0x10(%rsp), %rdi
movq 0x1e425(%rip), %rsi     # 0x21fa0
callq 0x21d0
jmp 0x3b82
movl $0x2, 0xa4(%rsp)
movl $0x1, 0x34(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5830
jmp 0x3be1
movq 0x1e440(%rip), %rdi     # 0x21fe8
leaq 0x1452f(%rip), %rsi     # 0x180de
callq 0x21a0
movq %rax, 0x8(%rsp)
jmp 0x3bbb
movq 0x8(%rsp), %rdi
movq 0x1e3d9(%rip), %rsi     # 0x21fa0
callq 0x21d0
jmp 0x3bce
movl $0x1, 0xa4(%rsp)
movl $0x1, 0x34(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5050
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq
leaq 0x78(%rsp), %rdi
callq 0x5050
movq 0x70(%rsp), %rdi
callq 0x2310
nop
// File: cristian-bicheru[P]arith/./huffman.h
// Function: huffman::CompressFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
CodecStatusCode CompressFile(const std::string& InFile, const std::string& OutFile) {
        std::vector<unsigned char> UncompressedBuffer;

        if (buffer::LoadFile(&InFile, UncompressedBuffer)) {
            buffer::CodecByteStream CompressedBuffer(2+8+256*(1+8));
            CompressBuffer<unsigned char, uint64_t>(UncompressedBuffer, CompressedBuffer);
            if (buffer::SaveFile(CompressedBuffer.GetBuffer(), &OutFile)) {
                return Success;
            } else {
                std::cerr << "File Write Error." << std::endl;
                return FileWriteError;
            }
        } else {
            std::cerr << "File Read Error." << std::endl;
            return FileReadError;
        }
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x5790
movq 0x28(%rsp), %rsi
movq 0x98(%rsp), %rdi
callq 0x26a0
movb %al, 0x33(%rsp)
jmp 0x3ebe
movb 0x33(%rsp), %al
testb $0x1, %al
jne 0x3ecb
jmp 0x3fb1
leaq 0x38(%rsp), %rdi
movl $0x90a, %esi            # imm = 0x90A
callq 0x57a0
jmp 0x3edc
leaq 0x78(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5850
jmp 0x3eed
leaq 0x38(%rsp), %rdi
callq 0x55f0
movq %rax, 0x20(%rsp)
jmp 0x3efe
movq 0x20(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x2850
movb %al, 0x1f(%rsp)
jmp 0x3f16
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x3f20
jmp 0x3f65
movl $0x0, 0xa4(%rsp)
movl $0x1, 0x34(%rsp)
jmp 0x3fa5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x400a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5830
jmp 0x400a
movq 0x1e07c(%rip), %rdi     # 0x21fe8
leaq 0x14159(%rip), %rsi     # 0x180cc
callq 0x21a0
movq %rax, 0x10(%rsp)
jmp 0x3f7f
movq 0x10(%rsp), %rdi
movq 0x1e015(%rip), %rsi     # 0x21fa0
callq 0x21d0
jmp 0x3f92
movl $0x2, 0xa4(%rsp)
movl $0x1, 0x34(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5830
jmp 0x3ff1
movq 0x1e030(%rip), %rdi     # 0x21fe8
leaq 0x1411f(%rip), %rsi     # 0x180de
callq 0x21a0
movq %rax, 0x8(%rsp)
jmp 0x3fcb
movq 0x8(%rsp), %rdi
movq 0x1dfc9(%rip), %rsi     # 0x21fa0
callq 0x21d0
jmp 0x3fde
movl $0x1, 0xa4(%rsp)
movl $0x1, 0x34(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5050
movl 0xa4(%rsp), %eax
addq $0xa8, %rsp
retq
leaq 0x78(%rsp), %rdi
callq 0x5050
movq 0x70(%rsp), %rdi
callq 0x2310
nop
// File: cristian-bicheru[P]arith/codec.cpp
// Function: print_help()
void print_help() {
    std::cout << usage << std::endl;
    std::cout << "options:" << std::endl;
    std::cout << help0 << std::endl;
    std::cout << help1 << std::endl;
    std::cout << help2 << std::endl;
}

// Assembly:
pushq %rax
movq 0x1dd68(%rip), %rdi     # 0x21fc0
leaq 0x1df79(%rip), %rsi     # 0x221d8
callq 0x2170
movq %rax, %rdi
movq 0x1dd32(%rip), %rsi     # 0x21fa0
callq 0x21d0
movq 0x1dd46(%rip), %rdi     # 0x21fc0
leaq 0x13f25(%rip), %rsi     # 0x181a6
callq 0x21a0
movq %rax, %rdi
movq 0x1dd10(%rip), %rsi     # 0x21fa0
callq 0x21d0
movq 0x1dd24(%rip), %rdi     # 0x21fc0
leaq 0x1df55(%rip), %rsi     # 0x221f8
callq 0x2170
movq %rax, %rdi
movq 0x1dcee(%rip), %rsi     # 0x21fa0
callq 0x21d0
movq 0x1dd02(%rip), %rdi     # 0x21fc0
leaq 0x1df53(%rip), %rsi     # 0x22218
callq 0x2170
movq %rax, %rdi
movq 0x1dccc(%rip), %rsi     # 0x21fa0
callq 0x21d0
movq 0x1dce0(%rip), %rdi     # 0x21fc0
leaq 0x1df51(%rip), %rsi     # 0x22238
callq 0x2170
movq %rax, %rdi
movq 0x1dcaa(%rip), %rsi     # 0x21fa0
callq 0x21d0
popq %rax
retq
nopl (%rax)
// File: cristian-bicheru[P]arith/./bufferops.h
// Function: buffer::CodecBufferWrapper::CodecBufferWrapper(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char)
CodecBufferWrapper(std::vector<unsigned char>& InBuffer, uint8_t Shift) {
            Buffer = InBuffer;
            BitShift = Shift;
            IBitShift = 8u-Shift;
            EffectiveSize = Buffer.size() - (Shift == 0 ? 0 : 1); // If a shift is used, the buffer size effectively decreases by one
        }

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
callq 0x5790
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x6080
jmp 0x4b9b
movq (%rsp), %rdi
movb 0x27(%rsp), %al
movb %al, 0x18(%rdi)
movzbl 0x27(%rsp), %ecx
movl $0x8, %eax
subl %ecx, %eax
movb %al, 0x19(%rdi)
callq 0x4b20
movq %rax, %rcx
movq (%rsp), %rax
movzbl 0x27(%rsp), %edi
movl $0x1, %edx
xorl %esi, %esi
cmpl $0x0, %edi
cmovel %esi, %edx
movslq %edx, %rdx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
addq $0x38, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x5050
movq 0x18(%rsp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
nop
// File: cristian-bicheru[P]arith/./bufferops.h
// Function: buffer::CodecByteStream::WriteBitBuffered(unsigned char)
void WriteBitBuffered(uint8_t Bit) {
            WriteBit(Bit);
            Bit ^= 1u;
            while (PendingBits > 0) {
                WriteBit(Bit);
                PendingBits--;
            }
        }

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movzbl 0xf(%rsp), %esi
callq 0x50d0
movzbl 0xf(%rsp), %eax
xorl $0x1, %eax
movb %al, 0xf(%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x28(%rax)
jle 0x4ec6
movq (%rsp), %rdi
movzbl 0xf(%rsp), %esi
callq 0x50d0
movq (%rsp), %rax
movl 0x28(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x4e9f
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: cristian-bicheru[P]arith/./bufferops.h
// Function: buffer::CodecByteStream::WriteBit(unsigned char)
void WriteBit(uint8_t Bit) {
            Data[ByteIndex] |= Bit<<IBitIndex;
            if (IBitIndex == 0) {
                ByteIndex++;
                Data.push_back(0u);
                IBitIndex = 7u;
            } else {
                IBitIndex--;
            }
        }

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movzbl 0x1f(%rsp), %eax
movzbl 0x18(%rdi), %ecx
shll %cl, %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rdi), %rsi
callq 0x4ae0
movl 0xc(%rsp), %esi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movzbl (%rcx), %edx
orl %esi, %edx
movb %dl, (%rcx)
movzbl 0x18(%rax), %eax
cmpl $0x0, %eax
jne 0x5149
movq 0x10(%rsp), %rdi
movq 0x20(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x20(%rdi)
movb $0x0, 0x1e(%rsp)
leaq 0x1e(%rsp), %rsi
callq 0x6e50
movq 0x10(%rsp), %rax
movb $0x7, 0x18(%rax)
jmp 0x5157
movq 0x10(%rsp), %rax
movb 0x18(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x18(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: cristian-bicheru[P]arith/./bufferops.h
// Function: buffer::CodecBitIterator::ReadBit()
uint8_t ReadBit() {
            uint8_t bit = (Buffer[ByteIndex]>>BitIndex)&1u;
            if (BitIndex == 0u) {
                BitIndex = 7u;
                ByteIndex++;
            } else {
                BitIndex--;
            }
            return bit;
        }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rdi), %rsi
callq 0x4ae0
movq %rax, %rcx
movq (%rsp), %rax
movzbl (%rcx), %edx
movq 0x20(%rax), %rcx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
movb %cl, 0xf(%rsp)
cmpq $0x0, 0x20(%rax)
jne 0x51b5
movq (%rsp), %rax
movq $0x7, 0x20(%rax)
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0x51c5
movq (%rsp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movb 0xf(%rsp), %al
addq $0x18, %rsp
retq
nop
// File: cristian-bicheru[P]arith/./arith.h
// Function: arith::CodecProbabilityTable::DecodeFromCount(unsigned long)
std::tuple<uint32_t, uint32_t, uint8_t> DecodeFromCount(uint64_t count) {
            for (uint16_t i = 0; i < 256; i++) {
                if (Frequencies[i+1] > count) {
                    return std::make_tuple(Frequencies[i], Frequencies[i+1], i);
                }
            }
            throw std::runtime_error("Bad Value Encountered In Decode.");
        }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movw $0x0, 0x3e(%rsp)
movzwl 0x3e(%rsp), %eax
cmpl $0x100, %eax            # imm = 0x100
jge 0x5289
movq 0x18(%rsp), %rax
movzwl 0x3e(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpq 0x40(%rsp), %rax
jbe 0x5274
movq 0x18(%rsp), %rdx
movzwl 0x3e(%rsp), %eax
shlq $0x2, %rax
movq %rdx, %rsi
addq %rax, %rsi
movzwl 0x3e(%rsp), %eax
addl $0x1, %eax
cltq
shlq $0x2, %rax
addq %rax, %rdx
leaq 0x30(%rsp), %rdi
leaq 0x3e(%rsp), %rcx
callq 0x7be0
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x7c20
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
jmp 0x5276
movw 0x3e(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x3e(%rsp)
jmp 0x5201
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x12f48(%rip), %rsi     # 0x181ec
callq 0x20a0
jmp 0x52ab
movq (%rsp), %rdi
movq 0x1cd3a(%rip), %rsi     # 0x21ff0
movq 0x1ccfb(%rip), %rdx     # 0x21fb8
callq 0x22e0
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x2120
movq 0x28(%rsp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cristian-bicheru[P]arith/./arith.h
// Function: arith::CodecProbabilityTable::GenerateTable(std::vector<unsigned char, std::allocator<unsigned char>>&)
void GenerateTable(std::vector<unsigned char>& UncompressedBuffer) {
            uint32_t tables[256*8] = {0};
            double deviations[8] = {0};

            for (uint16_t i = 0; i < 8; i++) {
                ComputeProbabilities(&tables[i*256], UncompressedBuffer, (uint8_t) i);
                deviations[i] = StandardDeviation(&tables[i*256], 256);
            }

            uint16_t max = 0u;
            double pmax = 0;

            for (uint16_t i = 0; i < 8; i++) {
                if (deviations[i] > pmax) {
                    pmax = deviations[i];
                    max = i;
                }
            }

            std::copy(tables+256*max, tables+256*(max+1), Frequencies + 1);

            for (uint16_t i = 1; i < 257; i++) {
                Frequencies[i] += Frequencies[i-1];
            }

            BitShift = max;
        }

// Assembly:
subq $0x2078, %rsp           # imm = 0x2078
movq %rdi, 0x2070(%rsp)
movq %rsi, 0x2068(%rsp)
movq 0x2070(%rsp), %rax
movq %rax, (%rsp)
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x2100
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2100
movw $0x0, 0x1e(%rsp)
movzwl 0x1e(%rsp), %eax
cmpl $0x8, %eax
jge 0x548c
movzwl 0x1e(%rsp), %eax
shll $0x8, %eax
cltq
leaq 0x60(%rsp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movq 0x2068(%rsp), %rsi
movw 0x1e(%rsp), %ax
movzbl %al, %edx
callq 0x2940
movzwl 0x1e(%rsp), %eax
shll $0x8, %eax
cltq
leaq 0x60(%rsp), %rdi
shlq $0x2, %rax
addq %rax, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x2ad0
movzwl 0x1e(%rsp), %eax
movsd %xmm0, 0x20(%rsp,%rax,8)
movw 0x1e(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x1e(%rsp)
jmp 0x541c
movw $0x0, 0x1c(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movw $0x0, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
cmpl $0x8, %eax
jge 0x54ed
movzwl 0xe(%rsp), %eax
movsd 0x20(%rsp,%rax,8), %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0x54db
movzwl 0xe(%rsp), %eax
movsd 0x20(%rsp,%rax,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movw 0xe(%rsp), %ax
movw %ax, 0x1c(%rsp)
jmp 0x54dd
movw 0xe(%rsp), %ax
addw $0x1, %ax
movw %ax, 0xe(%rsp)
jmp 0x54a3
movq (%rsp), %rdx
leaq 0x60(%rsp), %rdi
movzwl 0x1c(%rsp), %eax
shll $0x8, %eax
cltq
shlq $0x2, %rax
addq %rax, %rdi
leaq 0x60(%rsp), %rsi
movzwl 0x1c(%rsp), %eax
addl $0x1, %eax
shll $0x8, %eax
cltq
shlq $0x2, %rax
addq %rax, %rsi
addq $0x4, %rdx
callq 0x8090
movw $0x1, 0xc(%rsp)
movzwl 0xc(%rsp), %eax
cmpl $0x101, %eax            # imm = 0x101
jge 0x5569
movq (%rsp), %rax
movzwl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movzwl 0xc(%rsp), %ecx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movw 0xc(%rsp), %ax
addw $0x1, %ax
movw %ax, 0xc(%rsp)
jmp 0x5530
movq (%rsp), %rax
movw 0x1c(%rsp), %cx
movb %cl, 0x404(%rax)
addq $0x2078, %rsp           # imm = 0x2078
retq
// File: cristian-bicheru[P]arith/./huffman.h
// Function: huffman::HuffmanTree<unsigned char, unsigned long>::ConstructSymbolTable()
void ConstructSymbolTable() {
            RootNodeIterator<SymbolType, ValueType> RootIterator(this);
            HuffmanNode<SymbolType, ValueType>* RootNode;
            do {
                RootNode = &RootIterator.GetCurrentRootNode();
                //std::cout << "Symbol: " << (int) RootNode->GetSymbol() << std::endl;
                SymbolTable[RootNode->GetSymbol()] = RootIterator.GetCurrentIndex();
            } while (RootIterator++);

        }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rsi
movq %rsi, 0x30(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x11380
leaq 0x80(%rsp), %rdi
callq 0x11420
movq %rax, 0x28(%rsp)
jmp 0xa4ed
movq 0x28(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x11440
jmp 0xa50b
movq 0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rdi
callq 0x11560
movb %al, 0x27(%rsp)
jmp 0xa529
movq 0x18(%rsp), %rdi
movb 0x27(%rsp), %al
movb %al, 0x3f(%rsp)
leaq 0x3f(%rsp), %rsi
callq 0x11470
movq %rax, 0x10(%rsp)
jmp 0xa547
movq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x11570
leaq 0x40(%rsp), %rdi
callq 0xabf0
leaq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0x115e0
movb %al, 0xf(%rsp)
jmp 0xa575
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xa4d9
jmp 0xa583
leaq 0x80(%rsp), %rdi
callq 0x11750
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xa5c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xabf0
leaq 0x80(%rsp), %rdi
callq 0x11750
movq 0x70(%rsp), %rdi
callq 0x2310
nopw (%rax,%rax)
// File: cristian-bicheru[P]arith/./huffman.h
// Function: huffman::HuffmanNode<unsigned char, unsigned long>::HuffmanNode(huffman::HuffmanNode<unsigned char, unsigned long>*, huffman::HuffmanNode<unsigned char, unsigned long>*)
HuffmanNode (HuffmanNode* x1, HuffmanNode* x2) {
            nodes[0] = x1;
            nodes[1] = x2;
            isRoot = false;
            value = (*x1)+(*x2);
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x111c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: cristian-bicheru[P]arith/./huffman.h
// Function: huffman::RootNodeIterator<unsigned char, unsigned long>::RootNodeIterator(huffman::HuffmanTree<unsigned char, unsigned long>*)
explicit RootNodeIterator(HuffmanTree<SymbolType, ValueType>* ITree) {
            Tree = ITree;
            do {
                Index.push_back(0);
            } while (!(*Tree)[Index].IsRoot());
        }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0x8, %rdi
movq %rdi, 0x18(%rsp)
callq 0xa7c0
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0x11770
jmp 0x113c5
jmp 0x113c7
movq 0x20(%rsp), %rsi
movq (%rsi), %rdi
addq $0x8, %rsi
callq 0x11850
movq %rax, 0x10(%rsp)
jmp 0x113df
movq 0x10(%rsp), %rdi
callq 0x11930
movb %al, 0xf(%rsp)
jmp 0x113ef
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x113b3
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xabf0
movq 0x30(%rsp), %rdi
callq 0x2310
// File: cristian-bicheru[P]arith/./huffman.h
// Function: huffman::RootNodeIterator<unsigned char, unsigned long>::operator++(int)
bool operator++(int) {
            auto LastLeftBranch = std::find(Index.rbegin(), Index.rend(), false);
            if (LastLeftBranch != Index.rend()) {
                uint64_t LeftBranch = Index.size()-1ull-(LastLeftBranch-Index.rbegin());
                Index.resize(LeftBranch+1ull);
                Index[LeftBranch] = 1;
                while (!(*Tree)[Index].IsRoot()) {
                    Index.push_back(0);
                }
                //this->DumpIndex();
                return true;
            } else {
                return false;
            }

        }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movq 0x88(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x8, %rsi
leaq 0x60(%rsp), %rdi
callq 0x14f50
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x50(%rsp), %rdi
callq 0x14fc0
movb $0x0, 0x4f(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x50(%rsp), %rdx
leaq 0x4f(%rsp), %rcx
callq 0x14ed0
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
leaq 0x38(%rsp), %rdi
callq 0x14fc0
leaq 0x70(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x15030
testb $0x1, %al
jne 0x1166d
jmp 0x11736
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x12980
movq 0x8(%rsp), %rsi
subq $0x1, %rax
movq %rax, (%rsp)
addq $0x8, %rsi
leaq 0x20(%rsp), %rdi
callq 0x14f50
leaq 0x70(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x15060
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
subq %rcx, %rax
movq %rax, 0x30(%rsp)
addq $0x8, %rdi
movq 0x30(%rsp), %rsi
addq $0x1, %rsi
xorl %edx, %edx
callq 0x150d0
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x30(%rsp), %rsi
callq 0x15220
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x119b0
movq 0x8(%rsp), %rsi
movq (%rsi), %rdi
addq $0x8, %rsi
callq 0x11850
movq %rax, %rdi
callq 0x11930
xorb $-0x1, %al
testb $0x1, %al
jne 0x1171a
jmp 0x1172c
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0x11770
jmp 0x116f9
movb $0x1, 0x97(%rsp)
jmp 0x1173e
movb $0x0, 0x97(%rsp)
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
nop
// File: cristian-bicheru[P]arith/./huffman.h
// Function: huffman::HuffmanTree<unsigned char, unsigned long>::operator[](std::vector<bool, std::allocator<bool>>&)
HuffmanNode<SymbolType, ValueType>& operator[](std::vector<bool>& index) {
            HuffmanNode<SymbolType, ValueType>* ptr = ParentNode;
            for (auto branch : index) {
                ptr = (*ptr)[branch];
            }
            return (*ptr);
        }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0xaaa0
movl %edx, 0x40(%rsp)
movq %rax, 0x38(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x50(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
callq 0xaae0
movl %edx, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xab00
testb $0x1, %al
jne 0x118d4
jmp 0x1191a
leaq 0x48(%rsp), %rdi
callq 0xab30
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0xab70
movq (%rsp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x13760
movq %rax, 0x60(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xaba0
jmp 0x118bf
movq 0x60(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: oknenavin[P]cxon/examples/overriding-default-serializers.cxx
// Function: main
int main() {
    double d = 0.0;
        cxon::from_bytes(d, "0");
    assert(d == 42.);   // the override is used for double
    int i = 0;
        cxon::from_bytes(i, "42");
    assert(i == 42);    // the other types are intact
    float f = 0.0;
        cxon::from_bytes<CUSTOM_JSON>(f, "0");
    assert(f == 42.);   // the override is used for CUSTOM_JSON
    unsigned u = 0;
        cxon::from_bytes<CUSTOM_JSON>(u, "42");
    assert(u == 42);    // the other types are as in JSON<>
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq 0x1dff(%rip), %rdx      # 0x3038
callq 0x16d0
movsd -0x10(%rbp), %xmm0
movsd 0x1dbd(%rip), %xmm1     # 0x3008
ucomisd %xmm1, %xmm0
jne 0x1255
jp 0x1255
jmp 0x1274
leaq 0x1dde(%rip), %rdi      # 0x303a
leaq 0x1de0(%rip), %rsi      # 0x3043
movl $0x24, %edx
leaq 0x1df7(%rip), %rcx      # 0x3066
callq 0x1080
movl $0x0, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
leaq 0x1dec(%rip), %rdx      # 0x3076
callq 0x1700
cmpl $0x2a, -0x2c(%rbp)
jne 0x1297
jmp 0x12b6
leaq 0x1dd3(%rip), %rdi      # 0x3071
leaq 0x1d9e(%rip), %rsi      # 0x3043
movl $0x27, %edx
leaq 0x1db5(%rip), %rcx      # 0x3066
callq 0x1080
xorps %xmm0, %xmm0
movss %xmm0, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
leaq 0x1d6b(%rip), %rdx      # 0x3038
callq 0x1730
movss -0x4c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1d25(%rip), %xmm1     # 0x3008
ucomisd %xmm1, %xmm0
jne 0x12ed
jp 0x12ed
jmp 0x130c
leaq 0x1d85(%rip), %rdi      # 0x3079
leaq 0x1d48(%rip), %rsi      # 0x3043
movl $0x2a, %edx
leaq 0x1d5f(%rip), %rcx      # 0x3066
callq 0x1080
movl $0x0, -0x6c(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
leaq 0x1d51(%rip), %rdx      # 0x3076
callq 0x1760
cmpl $0x2a, -0x6c(%rbp)
jne 0x1332
jmp 0x1351
leaq 0x1d49(%rip), %rdi      # 0x3082
leaq 0x1d03(%rip), %rsi      # 0x3043
movl $0x2d, %edx
leaq 0x1d1a(%rip), %rcx      # 0x3066
callq 0x1080
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: janthonyo[P]Redes-Practicas/./domino.cc
// Function: domino::newHand()
std::vector <ficha> newHand()
	{
		std::vector<ficha> playerHand;
		int x;

		for(int i = 0; i < 7; i++)
		{
			x = rand() % (int) forStole.size();

			playerHand.push_back(forStole[x]);

			forStole.erase(forStole.begin() + x);
		}

		return playerHand;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x96c0
movl $0x0, -0x1c(%rbp)
cmpl $0x7, -0x1c(%rbp)
jge 0x7669
callq 0x30c0
movq -0x58(%rbp), %rdi
movl %eax, -0x6c(%rbp)
addq $0x18, %rdi
movq %rdi, -0x78(%rbp)
callq 0x8bc0
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl -0x6c(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
movslq -0x18(%rbp), %rsi
callq 0x9750
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x96e0
jmp 0x75f0
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x88(%rbp)
callq 0x8e60
movq %rax, -0x48(%rbp)
movslq -0x18(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9520
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x97e0
movq -0x88(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x9770
movq %rax, -0x80(%rbp)
jmp 0x763c
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x75a6
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x76a0
jmp 0x7689
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x767c
movq -0x68(%rbp), %rdi
callq 0x76a0
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: janthonyo[P]Redes-Practicas/./domino.cc
// Function: domino::emptyBoard()
void emptyBoard()
	{
		board.clear();
		forStole.clear();
		first = -1;
		last = -1;
		player1.socket = -1;
		player2.socket = -1;


		//"Amontonamos" las fichas para repartir y robar.
		ficha aux;

		for (int i = 0; i < 7; i++)
		{
			for (int j = i; j < 7; j++)
			{
				aux.left = i;
				aux.right = j;
				forStole.push_back(aux);
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xb060
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0xb060
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x130(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x134(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x94(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x114(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
cmpl $0x7, -0x14(%rbp)
jge 0x7c10
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x7, -0x18(%rbp)
jge 0x7c03
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0xc(%rbp)
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x96e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7bd5
jmp 0x7c05
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7bc9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: janthonyo[P]Redes-Practicas/./domino.cc
// Function: domino::hasFicha(ficha, std::vector<ficha, std::allocator<ficha>>)
bool hasFicha(ficha f, std::vector<ficha> hand)
	{
		bool result = false;

		for (int i = 0; i < (int) hand.size(); ++i)
		{
			if(( hand[i].left == f.left ) and ( hand[i].right == f.right ))
				result = true;

			else if (( hand[i].left == f.right ) and ( hand[i].right == f.left ))
				result = true;
		}

		return result;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x8bc0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x7cca
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x9750
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x7c8b
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x9750
movl 0x4(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x7c8b
movb $0x1, -0x19(%rbp)
jmp 0x7cba
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x9750
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x7cb8
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x9750
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x7cb8
movb $0x1, -0x19(%rbp)
jmp 0x7cba
jmp 0x7cbc
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7c43
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: janthonyo[P]Redes-Practicas/./domino.cc
// Function: domino::stealPiece()
ficha stealPiece()
	{
		int x = rand() % (int) forStole.size();
		ficha stolenPiece = forStole[x];

		forStole.erase(forStole.begin() + x);

		return stolenPiece;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x30c0
movq -0x48(%rbp), %rdi
movl %eax, -0x4c(%rbp)
addq $0x18, %rdi
callq 0x8bc0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x9750
movq -0x48(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
callq 0x8e60
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x9520
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x97e0
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9770
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: janthonyo[P]Redes-Practicas/./domino.cc
// Function: domino::addToHand(int, ficha)
bool addToHand(int i, ficha pieceToAdd)
	{
		if(i==getSocketP1())
		{
			player1.hand.push_back(pieceToAdd);
		}
		else if(i==getSocketP2())
		{
			player2.hand.push_back(pieceToAdd);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x7b30
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jne 0x7ee6
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
addq $0x68, %rdi
leaq -0x8(%rbp), %rsi
callq 0x96e0
jmp 0x7f18
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x7b50
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jne 0x7f16
movq -0x20(%rbp), %rdi
addq $0xb0, %rdi
addq $0x68, %rdi
leaq -0x8(%rbp), %rsi
callq 0x96e0
jmp 0x7f18
ud2
nopw (%rax,%rax)
// File: janthonyo[P]Redes-Practicas/./domino.cc
// Function: domino::putInBoard(ficha)
bool putInBoard(ficha f)
	{
		//Estructura ficha auxiliar para "girar" la ficha
		ficha aux;
		bool inserted = false;

		if(isBoardEmpty())
		{
			setFirst(f.left);
			setLast(f.right);
			board.push_back(f);

			inserted = true;
		}

		//Se comprueba si la ficha se puede colocar en el extremo inicial.
		else if((first == f.left) or (first == f.right))
		{
			if( f.left == first )
			{
				setFirst(f.right);
				aux.left = f.right;
				aux.right = f.left;
				board.insert(board.begin(), aux);
			}

			else
			{
				setFirst(f.left);
				board.insert(board.begin(), f);
			}

			inserted = true;
		}

		//Si no, se comprueba si la ficha se puede colocar en el extremo final.
		else if((last == f.left) or (last == f.right))
		{
			if( f.left == last )
			{
				setLast(f.right);
				board.push_back(f);
			}

			else
			{
				setLast(f.left);
				aux.left = f.right;
				aux.right = f.left;
				board.push_back(aux);
			}

			inserted = true;
		}

		//Si no, se devuelve false (valor inicial de inserted)
		return inserted;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xa9d0
testb $0x1, %al
jne 0xa2f7
jmp 0xa325
movq -0x58(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0xa9f0
movq -0x58(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0xaa10
movq -0x58(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x96e0
movb $0x1, -0x19(%rbp)
jmp 0xa455
movq -0x58(%rbp), %rax
movl 0x130(%rax), %eax
cmpl -0x8(%rbp), %eax
je 0xa347
movq -0x58(%rbp), %rax
movl 0x130(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xa3e0
movq -0x58(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x130(%rcx), %eax
jne 0xa39f
movq -0x58(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0xa9f0
movq -0x58(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0x8e60
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x97e0
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xaa30
movq %rax, -0x38(%rbp)
jmp 0xa3da
movq -0x58(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0xa9f0
movq -0x58(%rbp), %rdi
callq 0x8e60
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x97e0
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x8(%rbp), %rdx
callq 0xaa30
movq %rax, -0x50(%rbp)
movb $0x1, -0x19(%rbp)
jmp 0xa453
movq -0x58(%rbp), %rax
movl 0x134(%rax), %eax
cmpl -0x8(%rbp), %eax
je 0xa3fe
movq -0x58(%rbp), %rax
movl 0x134(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xa451
movq -0x58(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x134(%rcx), %eax
jne 0xa428
movq -0x58(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0xaa10
movq -0x58(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x96e0
jmp 0xa44d
movq -0x58(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0xaa10
movq -0x58(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x96e0
movb $0x1, -0x19(%rbp)
jmp 0xa453
jmp 0xa455
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
// File: janthonyo[P]Redes-Practicas/./domino.cc
// Function: domino::quitPieceJ1(ficha)
void quitPieceJ1(ficha f)
	{
		bool erase = false;

		for (int i = 0; i < (int) player1.hand.size(); i++)
		{
			if (erase == false)
			{
				if(( player1.hand[i].left == f.left ) and ( player1.hand[i].right == f.right ))
				{
					player1.hand.erase(player1.hand.begin() + i);
					erase = true;
				}

				else if(( player1.hand[i].left == f.right ) and ( player1.hand[i].right == f.left ))
				{
					player1.hand.erase(player1.hand.begin() + i);
					erase = true;
				}
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x64(%rbp)
addq $0x30, %rdi
addq $0x68, %rdi
callq 0x8bc0
movq %rax, %rcx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jge 0xa5f5
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xa5e5
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
addq $0x68, %rdi
movslq -0x18(%rbp), %rsi
callq 0x9750
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xa551
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
addq $0x68, %rdi
movslq -0x18(%rbp), %rsi
callq 0x9750
movl 0x4(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xa551
movq -0x60(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
addq $0x68, %rax
movq %rax, -0x70(%rbp)
addq $0x30, %rdi
addq $0x68, %rdi
callq 0x8e60
movq %rax, -0x30(%rbp)
movslq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x9520
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x97e0
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9770
movq %rax, -0x38(%rbp)
movb $0x1, -0x11(%rbp)
jmp 0xa5e3
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
addq $0x68, %rdi
movslq -0x18(%rbp), %rsi
callq 0x9750
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xa5e1
movq -0x60(%rbp), %rdi
addq $0x30, %rdi
addq $0x68, %rdi
movslq -0x18(%rbp), %rsi
callq 0x9750
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xa5e1
movq -0x60(%rbp), %rdi
movq %rdi, %rax
addq $0x30, %rax
addq $0x68, %rax
movq %rax, -0x78(%rbp)
addq $0x30, %rdi
addq $0x68, %rdi
callq 0x8e60
movq %rax, -0x50(%rbp)
movslq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x9520
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x97e0
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x9770
movq %rax, -0x58(%rbp)
movb $0x1, -0x11(%rbp)
jmp 0xa5e3
jmp 0xa5e5
jmp 0xa5e7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa486
addq $0x80, %rsp
popq %rbp
retq
nop
// File: janthonyo[P]Redes-Practicas/./domino.cc
// Function: domino::quitPieceJ2(ficha)
void quitPieceJ2(ficha f)
	{
		bool erase = false;

		for (int i = 0; i < (int) player2.hand.size(); i++)
		{
			if (erase == false)
			{
				if(( player2.hand[i].left == f.left ) and ( player2.hand[i].right == f.right ))
				{
					player2.hand.erase(player2.hand.begin() + i);
					erase = true;
				}

				else if(( player2.hand[i].left == f.right ) and ( player2.hand[i].right == f.left ))
				{
					player2.hand.erase(player2.hand.begin() + i);
					erase = true;
				}
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x64(%rbp)
addq $0xb0, %rdi
addq $0x68, %rdi
callq 0x8bc0
movq %rax, %rcx
movl -0x64(%rbp), %eax
cmpl %ecx, %eax
jge 0xa7b2
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xa7a2
movq -0x60(%rbp), %rdi
addq $0xb0, %rdi
addq $0x68, %rdi
movslq -0x18(%rbp), %rsi
callq 0x9750
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xa703
movq -0x60(%rbp), %rdi
addq $0xb0, %rdi
addq $0x68, %rdi
movslq -0x18(%rbp), %rsi
callq 0x9750
movl 0x4(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xa703
movq -0x60(%rbp), %rdi
movq %rdi, %rax
addq $0xb0, %rax
addq $0x68, %rax
movq %rax, -0x70(%rbp)
addq $0xb0, %rdi
addq $0x68, %rdi
callq 0x8e60
movq %rax, -0x30(%rbp)
movslq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x9520
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x97e0
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9770
movq %rax, -0x38(%rbp)
movb $0x1, -0x11(%rbp)
jmp 0xa7a0
movq -0x60(%rbp), %rdi
addq $0xb0, %rdi
addq $0x68, %rdi
movslq -0x18(%rbp), %rsi
callq 0x9750
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0xa79e
movq -0x60(%rbp), %rdi
addq $0xb0, %rdi
addq $0x68, %rdi
movslq -0x18(%rbp), %rsi
callq 0x9750
movl 0x4(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xa79e
movq -0x60(%rbp), %rdi
movq %rdi, %rax
addq $0xb0, %rax
addq $0x68, %rax
movq %rax, -0x78(%rbp)
addq $0xb0, %rdi
addq $0x68, %rdi
callq 0x8e60
movq %rax, -0x50(%rbp)
movslq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x9520
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x97e0
movq -0x78(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x9770
movq %rax, -0x58(%rbp)
movb $0x1, -0x11(%rbp)
jmp 0xa7a0
jmp 0xa7a2
jmp 0xa7a4
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa626
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: janthonyo[P]Redes-Practicas/./domino.cc
// Function: domino::domino()
domino()
	{
		//Inicializador de numeros aleatorios.
		srand(time(NULL));

		first = -1;
		last = -1;
		board.clear();
		forStole.clear();
		player1.socket = -1;
		player2.socket = -1;

		//"Amontonamos" las fichas para repartir y robar.
		ficha aux;

		for (int i = 0; i < 7; i++)
		{
			for (int j = i; j < 7; j++)
			{
				aux.left = i;
				aux.right = j;

				forStole.push_back(aux);
			}
		}

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x96c0
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x48(%rbp)
callq 0x96c0
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x40(%rbp)
callq 0xc820
movq -0x30(%rbp), %rdi
addq $0xb0, %rdi
movq %rdi, -0x38(%rbp)
callq 0xc820
xorl %eax, %eax
movl %eax, %edi
callq 0x3250
movl %eax, %edi
callq 0x3280
movq -0x30(%rbp), %rdi
movl $0xffffffff, 0x130(%rdi) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x134(%rdi) # imm = 0xFFFFFFFF
callq 0xb060
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0xb060
movq -0x30(%rbp), %rax
movl $0xffffffff, 0x94(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x114(%rax) # imm = 0xFFFFFFFF
movl $0x0, -0x14(%rbp)
cmpl $0x7, -0x14(%rbp)
jge 0xc805
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x7, -0x18(%rbp)
jge 0xc7f8
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0xc(%rbp)
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0x96e0
jmp 0xc7b9
jmp 0xc7bb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc794
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xbf80
movq -0x40(%rbp), %rdi
callq 0xbf80
movq -0x48(%rbp), %rdi
callq 0x76a0
movq -0x30(%rbp), %rdi
callq 0x76a0
jmp 0xc80b
jmp 0xc7fa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc788
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
nop
// File: janthonyo[P]Redes-Practicas/message.cc
// Function: sendBoardAndHands(domino&)
void sendBoardAndHands(domino& game)
{
    char mensaje[MSG_SIZE];

    // Enviamos el tablero
    strcpy(mensaje, game.showBoard().c_str());
    sendBoth(game, mensaje);

    // Send hands
    strcpy(mensaje, game.messageHandP1().c_str());
    send(game.getSocketP1(), mensaje, strlen(mensaje), 0);

    strcpy(mensaje, game.messageHandP2().c_str());
    send(game.getSocketP2(), mensaje, strlen(mensaje), 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x1a8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x130(%rbp), %rdi
callq 0xe870
leaq -0x130(%rbp), %rdi
callq 0x3120
movq -0x1a8(%rbp), %rdi
movq %rax, %rsi
callq 0x3260
leaq -0x130(%rbp), %rdi
callq 0x3190
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0xdfd0
leaq -0x110(%rbp), %rax
movq %rax, -0x1a0(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x150(%rbp), %rdi
callq 0xebe0
leaq -0x150(%rbp), %rdi
callq 0x3120
movq -0x1a0(%rbp), %rdi
movq %rax, %rsi
callq 0x3260
leaq -0x150(%rbp), %rdi
callq 0x3190
movq -0x8(%rbp), %rdi
callq 0x7b30
movl %eax, -0x194(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x190(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x3140
movl -0x194(%rbp), %edi
movq -0x190(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3150
leaq -0x110(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x170(%rbp), %rdi
callq 0xef00
leaq -0x170(%rbp), %rdi
callq 0x3120
movq -0x188(%rbp), %rdi
movq %rax, %rsi
callq 0x3260
leaq -0x170(%rbp), %rdi
callq 0x3190
movq -0x8(%rbp), %rdi
callq 0x7b50
movl %eax, -0x17c(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x178(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x3140
movl -0x17c(%rbp), %edi
movq -0x178(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3150
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopw (%rax,%rax)