LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: irakr[P]Minimal-File-Compression-Tool/src/header.cpp
// Function: get_cw_entry(HeaderStruct*, unsigned char*)
static HeaderStruct::codeword_table *get_cw_entry(HeaderStruct *header, uchar_t *symbol) {
    uint8_t i;
    static uchar_t sym = 0xff; // 0xff is unlikely to come.
    static HeaderStruct::codeword_table *cache = NULL;

    // Error check
    if(!header || !symbol)
        return NULL;

    // Cache hit
    if(sym == *symbol)
        return cache;

    // Cache miss
    for(i = 0; i < header->nSyms; i++) {
        if((sym = header->cw_table[i].symbol) == *symbol)
            break;
    }
    cache = header->cw_table + i;
    return cache;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xae6a
cmpq $0x0, -0x18(%rbp)
jne 0xae77
movq $0x0, -0x8(%rbp)
jmp 0xaf09
movzbl 0x93ca(%rip), %eax      # 0x14248
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xae96
movq 0x93e0(%rip), %rax      # 0x14270
movq %rax, -0x8(%rbp)
jmp 0xaf09
movb $0x0, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jge 0xaee1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movzbl -0x19(%rbp), %ecx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movb (%rax), %al
movb %al, 0x9383(%rip)       # 0x14248
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xaed5
jmp 0xaee1
jmp 0xaed7
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0xae9a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movzbl -0x19(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x9372(%rip)      # 0x14270
movq 0x936b(%rip), %rax      # 0x14270
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: irakr[P]Minimal-File-Compression-Tool/src/main.cpp
// Function: main
int main(int argc, char **argv) {

	cout << " --- Still under construction ---" << endl;
	Log_static("Started...");
	
	try {
		CompressionDriver driver(argc, (const char**)(argv+1));
		driver.setCompressor("Huffman-Coding");
		cout << "Selected algorithm: " << driver.getCompressorName() << endl;
		driver.compressAll();
	}
	catch(exception &e) {
		Log_static(e.what());
		return FATAR_ERROR;
	}

	return SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x8b00(%rip), %rdi      # 0x13fc0
leaq 0x1d8b(%rip), %rsi      # 0xd252
callq 0x3200
movq %rax, %rdi
movq 0x8aca(%rip), %rsi      # 0x13fa0
callq 0x3230
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
leaq -0x50(%rbp), %rdi
callq 0x86f0
jmp 0xb4f1
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x33f0
movq -0xb8(%rbp), %rdx
leaq 0x1c19(%rip), %rsi      # 0xd12b
leaq -0x80(%rbp), %rdi
callq 0x4740
jmp 0xb51d
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x8880
jmp 0xb52c
leaq -0x80(%rbp), %rdi
callq 0x3150
leaq -0x81(%rbp), %rdi
callq 0x3250
movq 0x8a78(%rip), %rdi      # 0x13fc0
leaq 0x1d25(%rip), %rsi      # 0xd274
callq 0x3200
movq %rax, -0xc0(%rbp)
jmp 0xb55d
leaq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8940
jmp 0xb56f
movq -0xc0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x31e0
movq %rax, -0xc8(%rbp)
jmp 0xb58b
movq -0xc8(%rbp), %rdi
movq 0x8a07(%rip), %rsi      # 0x13fa0
callq 0x3230
jmp 0xb5a0
leaq -0xa8(%rbp), %rdi
callq 0x3150
leaq -0x50(%rbp), %rdi
callq 0x8e60
jmp 0xb5b7
leaq -0x50(%rbp), %rdi
callq 0xb680
jmp 0xb65d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xb633
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xb5f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3150
leaq -0x81(%rbp), %rdi
callq 0x3250
jmp 0xb62a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xb62a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3150
leaq -0x50(%rbp), %rdi
callq 0xb680
movl -0x5c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xb670
movq -0x58(%rbp), %rdi
callq 0x30e0
movq %rax, -0xb0(%rbp)
movl $0x2, -0x4(%rbp)
callq 0x3390
jmp 0xb664
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::stringToBitVector(char const*)
void BitVector::stringToBitVector(const char *str)
{
    int strSize = strlen(str);
    for (int i = 0; i < strSize; i++)
    {
        if (str[i] == '1')
            appendBit(true);
        else if (str[i] == '0')
            appendBit(false);
        else
            //@ throw cRuntimeError("str must represent a binary number");
            throw (new std::overflow_error("BitVector::stringToBitVector(): str must represent a binary number"));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3100
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xba49
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
jne 0xb99b
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0xbaf0
jmp 0xba39
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jne 0xb9b9
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xbaf0
jmp 0xba37
movl $0x8, %edi
callq 0x3110
movq %rax, -0x40(%rbp)
movl $0x10, %edi
callq 0x3210
movq %rax, -0x38(%rbp)
jmp 0xb9d7
movq -0x38(%rbp), %rdi
leaq 0x18fe(%rip), %rsi      # 0xd2e0
callq 0x3070
jmp 0xb9e9
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, (%rdi)
leaq 0x836d(%rip), %rsi      # 0x13d68
xorl %eax, %eax
movl %eax, %edx
callq 0x33b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xba2c
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x3220
movq -0x40(%rbp), %rdi
callq 0x3180
jmp 0xba4f
jmp 0xba39
jmp 0xba3b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb96b
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33e0
nopl (%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::BitVector(unsigned int)
BitVector::BitVector(unsigned int bits)
{
    size = 0;
    if (bits == 0)
        appendBit(false);
    while (bits > 0)
    {
        appendBit(bits % 2);
        bits /= 2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xc540
movq -0x28(%rbp), %rax
movl $0x0, 0x18(%rax)
cmpl $0x0, -0xc(%rbp)
jne 0xbab3
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0xbaf0
jmp 0xba9a
jmp 0xbab3
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xb0b0
jmp 0xbadc
jmp 0xbab5
cmpl $0x0, -0xc(%rbp)
jbe 0xbad6
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
andl $0x1, %esi
callq 0xbaf0
jmp 0xbacc
movl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0xc(%rbp)
jmp 0xbab5
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::BitVector(unsigned int, unsigned int)
BitVector::BitVector(unsigned int bits, unsigned int size)
{
    this->size = 0;
    if (bits == 0)
        appendBit(false);
    while (bits > 0)
    {
        appendBit(bits % 2);
        bits /= 2;
    }
    if (getSize() < size)
        appendBit(false, size - getSize());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xc540
movq -0x28(%rbp), %rax
movl $0x0, 0x18(%rax)
cmpl $0x0, -0xc(%rbp)
jne 0xbb76
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0xbaf0
jmp 0xbb5d
jmp 0xbb76
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xb0b0
jmp 0xbbe0
jmp 0xbb78
cmpl $0x0, -0xc(%rbp)
jbe 0xbb99
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
andl $0x1, %esi
callq 0xbaf0
jmp 0xbb8f
movl -0xc(%rbp), %eax
shrl %eax
movl %eax, -0xc(%rbp)
jmp 0xbb78
movq -0x28(%rbp), %rdi
callq 0xc590
movl %eax, -0x2c(%rbp)
jmp 0xbba7
movl -0x2c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0xbbda
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0xc590
movl %eax, -0x30(%rbp)
jmp 0xbbc3
movq -0x28(%rbp), %rdi
movl -0x30(%rbp), %eax
movl -0x34(%rbp), %edx
subl %eax, %edx
xorl %esi, %esi
callq 0xbbf0
jmp 0xbbd8
jmp 0xbbda
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::setBit(int, bool)
void BitVector::setBit(int pos, bool value)
{
    while (containerSize() <= pos)
        bytes.push_back(uint8_t(0));
    if (pos + 1 > size)
        size = pos + 1;
    uint8_t& field = bytes[pos / UINT8_LENGTH];
    if (value)
        field |= 1 << (pos % UINT8_LENGTH);
    else
        field &= ~(1 << (pos % UINT8_LENGTH));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc5b0
cmpl -0xc(%rbp), %eax
jg 0xbc7f
movq -0x20(%rbp), %rdi
movb $0x0, -0xe(%rbp)
leaq -0xe(%rbp), %rsi
callq 0xc560
jmp 0xbc5e
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
addl $0x1, %eax
cmpl 0x18(%rcx), %eax
jle 0xbc9b
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movslq %eax, %rsi
callq 0xc5d0
movq %rax, -0x18(%rbp)
testb $0x1, -0xd(%rbp)
je 0xbcdd
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
jmp 0xbcff
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
xorl $-0x1, %edx
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::toggleBit(int)
void BitVector::toggleBit(int pos)
{
    if (pos >= size)
        throw (new std::overflow_error("BitVector::toggleBit(): Bit out of range."));
        //@ throw cRuntimeError("Out of range with bit position %d", pos);

    uint8_t& field = bytes[pos / UINT8_LENGTH];
    field ^= 1 << (pos % UINT8_LENGTH);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x18(%rcx), %eax
jl 0xbdad
movl $0x8, %edi
callq 0x3110
movq %rax, -0x40(%rbp)
movl $0x10, %edi
callq 0x3210
movq %rax, -0x38(%rbp)
jmp 0xbd4d
movq -0x38(%rbp), %rdi
leaq 0x1531(%rip), %rsi      # 0xd289
callq 0x3070
jmp 0xbd5f
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, (%rdi)
leaq 0x7ff7(%rip), %rsi      # 0x13d68
xorl %eax, %eax
movl %eax, %edx
callq 0x33b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xbda2
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x3220
movq -0x40(%rbp), %rdi
callq 0x3180
jmp 0xbded
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movslq %eax, %rsi
callq 0xc5d0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x28(%rbp), %rax
movzbl (%rax), %ecx
xorl %edx, %ecx
movb %cl, (%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::getBit(int) const
bool BitVector::getBit(int pos) const
{
    if (pos >= size)
        throw (new std::overflow_error("BitVector::getBit(): Bit out of range."));
    uint8_t field = bytes[pos / UINT8_LENGTH];
    return field & (1 << (pos % UINT8_LENGTH));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x18(%rcx), %eax
jl 0xbe9d
movl $0x8, %edi
callq 0x3110
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x3210
movq %rax, -0x30(%rbp)
jmp 0xbe3d
movq -0x30(%rbp), %rdi
leaq 0x146b(%rip), %rsi      # 0xd2b3
callq 0x3070
jmp 0xbe4f
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
leaq 0x7f07(%rip), %rsi      # 0x13d68
xorl %eax, %eax
movl %eax, %edx
callq 0x33b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xbe92
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x3220
movq -0x38(%rbp), %rdi
callq 0x3180
jmp 0xbee9
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movslq %eax, %rsi
callq 0xc5f0
movb (%rax), %al
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl -0x3c(%rbp), %eax
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: operator<<(std::ostream&, BitVector const&)
std::ostream& operator<<(std::ostream& out, const BitVector& bitVector)
{
    if (bitVector.getBit(0))
        out << "1";
    else
        out << "0";
    for (int i = 1; i < bitVector.size; i++)
    {
        if (bitVector.getBit(i))
            out << " 1";
        else
            out << " 0";
    }
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xbe00
testb $0x1, %al
jne 0xbf21
jmp 0xbf33
movq -0x8(%rbp), %rdi
leaq 0x13af(%rip), %rsi      # 0xd2db
callq 0x3200
jmp 0xbf43
movq -0x8(%rbp), %rdi
leaq 0x13a0(%rip), %rsi      # 0xd2de
callq 0x3200
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0xbf97
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbe00
testb $0x1, %al
jne 0xbf68
jmp 0xbf7a
movq -0x8(%rbp), %rdi
leaq 0x1367(%rip), %rsi      # 0xd2da
callq 0x3200
jmp 0xbf8a
movq -0x8(%rbp), %rdi
leaq 0x1358(%rip), %rsi      # 0xd2dd
callq 0x3200
jmp 0xbf8c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbf4a
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::toString[abi:cxx11]() const
std::string BitVector::toString() const
{
    std::string str;
    for (unsigned int i = 0; i < getSize(); i++)
    {
        if (getBit(i))
            str += "1";
        else
            str += "0";
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3330
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %eax
movl %eax, -0x48(%rbp)
callq 0xc590
movl %eax, -0x44(%rbp)
jmp 0xc0c7
movl -0x48(%rbp), %eax
movl -0x44(%rbp), %ecx
cmpl %ecx, %eax
jae 0xc13a
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xbe00
movb %al, -0x49(%rbp)
jmp 0xc0e2
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xc0eb
jmp 0xc116
movq -0x40(%rbp), %rdi
leaq 0x11e5(%rip), %rsi      # 0xd2db
callq 0x31f0
jmp 0xc0fd
jmp 0xc12a
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3150
jmp 0xc157
movq -0x40(%rbp), %rdi
leaq 0x11bd(%rip), %rsi      # 0xd2de
callq 0x31f0
jmp 0xc128
jmp 0xc12a
jmp 0xc12c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc0b3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xc14d
movq -0x40(%rbp), %rdi
callq 0x3150
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33e0
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::toDecimal() const
unsigned int BitVector::toDecimal() const
{
    unsigned int dec = 0;
    unsigned int powerOfTwo = 1;
    for (unsigned int i = 0; i < getSize(); i++)
    {
        if (getBit(i))
            dec += powerOfTwo;
        powerOfTwo *= 2;
    }
    return dec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0xc590
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jae 0xc1ef
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbe00
testb $0x1, %al
jne 0xc1d3
jmp 0xc1dc
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc1a9
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::reverseToDecimal() const
unsigned int BitVector::reverseToDecimal() const
{
    unsigned int dec = 0;
    unsigned int powerOfTwo = 1;
    for (int i = getSize() - 1; i >= 0; i--)
    {
        if (getBit(i))
            dec += powerOfTwo;
        powerOfTwo *= 2;
    }
    return dec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
callq 0xc590
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xc261
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbe00
testb $0x1, %al
jne 0xc245
jmp 0xc24e
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc22d
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::computeHammingDistance(BitVector const&) const
int BitVector::computeHammingDistance(const BitVector& u) const
{
    if (getSize() != u.getSize())
        throw (new std::overflow_error("BitVector::computeHammingDistance(): You can't compute Hamming distance between two vectors with different sizes"));
        //@ throw cRuntimeError("You can't compute Hamming distance between two vectors with different sizes");
    int hammingDistance = 0;
    for (unsigned int i = 0; i < getSize(); i++)
        if (u.getBit(i) != getBit(i))
            hammingDistance++;
    return hammingDistance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xc590
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc590
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
je 0xc320
movl $0x8, %edi
callq 0x3110
movq %rax, -0x40(%rbp)
movl $0x10, %edi
callq 0x3210
movq %rax, -0x38(%rbp)
jmp 0xc2c0
movq -0x38(%rbp), %rdi
leaq 0x1058(%rip), %rsi      # 0xd323
callq 0x3070
jmp 0xc2d2
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, (%rdi)
leaq 0x7a84(%rip), %rsi      # 0x13d68
xorl %eax, %eax
movl %eax, %edx
callq 0x33b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xc315
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x10, %esi
callq 0x3220
movq -0x40(%rbp), %rdi
callq 0x3180
jmp 0xc394
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0xc590
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jae 0xc38b
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0xbe00
movq -0x30(%rbp), %rdi
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x48(%rbp)
movl -0x24(%rbp), %esi
callq 0xbe00
movb %al, %cl
movl -0x48(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0xc37e
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc380
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc32e
movl -0x20(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x33e0
nopl (%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::operator=(BitVector const&)
BitVector& BitVector::operator=(const BitVector& rhs)
{
    if (this == &rhs)
        return *this;
    copy(rhs);
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0xc3c8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc3dd
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc3f0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::copy(BitVector const&)
void BitVector::copy(const BitVector& other)
{
    size = 0;
    bytes.clear();
    for (unsigned int i = 0; i < other.getSize(); i++)
        appendBit(other.getBit(i));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x0, 0x18(%rdi)
callq 0xc630
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc590
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jae 0xc459
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xbe00
movq -0x20(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0xbaf0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc41b
addq $0x30, %rsp
popq %rbp
retq
nop
// File: irakr[P]Minimal-File-Compression-Tool/src/utils/BitVector.cpp
// Function: BitVector::operator==(BitVector const&) const
bool BitVector::operator==(const BitVector& rhs) const
{
    if (rhs.getSize() != getSize())
        return false;
    for (unsigned int i = 0; i < getSize(); i++)
        if (getBit(i) != rhs.getBit(i))
            return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc590
movq -0x28(%rbp), %rdi
movl %eax, -0x20(%rbp)
callq 0xc590
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
je 0xc49c
movb $0x0, -0x1(%rbp)
jmp 0xc501
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0xc590
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jae 0xc4fd
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xbe00
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xbe00
movb %al, %cl
movl -0x30(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0xc4f0
movb $0x0, -0x1(%rbp)
jmp 0xc501
jmp 0xc4f2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc4a3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH04_Expressions/examples/incr.cc
// Function: main
int main() 
{
	int i = 0, j;
	j = ++i; // j = 1, i = 1: prefix yields the incremented value
	cout << i << " " << j << endl;

	j = i++; // j = 1, i = 2: postfix yields the unincremented value
	cout << i << " " << j << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %esi
movq 0x2dec(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xe09(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2db3(%rip), %rsi      # 0x3fc8
callq 0x1050
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %esi
movq 0x2da6(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xdc3(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2d6d(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: kmiya[P]Needleman-Wunsch/src/Base.cpp
// Function: needleman_wunsch_base::Base::StringToBase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<needleman_wunsch_base::kBase, std::allocator<needleman_wunsch_base::kBase>>*)
void Base::StringToBase(const string &in, vector<kBase> *seq) {
  for ( auto i = in.begin(); i < in.end(); ++i ) {
    if ( *i == 'A' )
      seq->push_back(A);
    else if ( *i == 'C' )
      seq->push_back(C);
    else if ( *i == 'G' )
      seq->push_back(G);
    else if ( *i == 'T' )
      seq->push_back(T);
    else if ( *i == '-' )
      seq->push_back(g);
    else
      seq->push_back(nop);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21a0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2360
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2e10
testb $0x1, %al
jne 0x2714
jmp 0x2809
leaq -0x20(%rbp), %rdi
callq 0x2e50
movsbl (%rax), %eax
cmpl $0x41, %eax
jne 0x273e
movq -0x18(%rbp), %rdi
movl $0x0, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x2e70
jmp 0x27f9
leaq -0x20(%rbp), %rdi
callq 0x2e50
movsbl (%rax), %eax
cmpl $0x43, %eax
jne 0x2768
movq -0x18(%rbp), %rdi
movl $0x1, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x2e70
jmp 0x27f7
leaq -0x20(%rbp), %rdi
callq 0x2e50
movsbl (%rax), %eax
cmpl $0x47, %eax
jne 0x278f
movq -0x18(%rbp), %rdi
movl $0x2, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x2e70
jmp 0x27f5
leaq -0x20(%rbp), %rdi
callq 0x2e50
movsbl (%rax), %eax
cmpl $0x54, %eax
jne 0x27b6
movq -0x18(%rbp), %rdi
movl $0x3, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2e70
jmp 0x27f3
leaq -0x20(%rbp), %rdi
callq 0x2e50
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x27dd
movq -0x18(%rbp), %rdi
movl $0x4, -0x3c(%rbp)
leaq -0x3c(%rbp), %rsi
callq 0x2e70
jmp 0x27f1
movq -0x18(%rbp), %rdi
movl $0x6, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x2e70
jmp 0x27f3
jmp 0x27f5
jmp 0x27f7
jmp 0x27f9
jmp 0x27fb
leaq -0x20(%rbp), %rdi
callq 0x2ea0
jmp 0x26f1
addq $0x40, %rsp
popq %rbp
retq
nop
// File: kmiya[P]Needleman-Wunsch/src/Base.cpp
// Function: needleman_wunsch_base::Base::BaseToString(std::vector<needleman_wunsch_base::kBase, std::allocator<needleman_wunsch_base::kBase>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void Base::BaseToString(const vector<kBase> &in, string *seq) {
  for ( auto i = in.begin(); i < in.end(); ++i ) {
    if ( *i == A )
      seq->push_back('A');
    else if ( *i == C )
      seq->push_back('C');
    else if ( *i == G )
      seq->push_back('G');
    else if ( *i == T )
      seq->push_back('T');
    else if ( *i == g )
      seq->push_back('-');
    else
      seq->push_back('/');
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2d30
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2da0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2d60
testb $0x1, %al
jne 0x28d4
jmp 0x2993
leaq -0x20(%rbp), %rdi
callq 0x2dd0
cmpl $0x0, (%rax)
jne 0x28f5
movq -0x18(%rbp), %rdi
movl $0x41, %esi
callq 0x2170
jmp 0x2983
leaq -0x20(%rbp), %rdi
callq 0x2dd0
cmpl $0x1, (%rax)
jne 0x2913
movq -0x18(%rbp), %rdi
movl $0x43, %esi
callq 0x2170
jmp 0x2981
leaq -0x20(%rbp), %rdi
callq 0x2dd0
cmpl $0x2, (%rax)
jne 0x2931
movq -0x18(%rbp), %rdi
movl $0x47, %esi
callq 0x2170
jmp 0x297f
leaq -0x20(%rbp), %rdi
callq 0x2dd0
cmpl $0x3, (%rax)
jne 0x294f
movq -0x18(%rbp), %rdi
movl $0x54, %esi
callq 0x2170
jmp 0x297d
leaq -0x20(%rbp), %rdi
callq 0x2dd0
cmpl $0x4, (%rax)
jne 0x296d
movq -0x18(%rbp), %rdi
movl $0x2d, %esi
callq 0x2170
jmp 0x297b
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
callq 0x2170
jmp 0x297d
jmp 0x297f
jmp 0x2981
jmp 0x2983
jmp 0x2985
leaq -0x20(%rbp), %rdi
callq 0x2df0
jmp 0x28b1
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: kmiya[P]Needleman-Wunsch/src/BaseAlgorithms.cpp
// Function: needleman_wunsch_basealgorithms::BaseAlgorithms::Alignment(needleman_wunsch_base::Base const&, needleman_wunsch_base::Base const&)
void BaseAlgorithms::Alignment(const Base &inputSequence1, const Base &inputSequence2) {
  // initialize parameter and matrix
  cout << "\n::: Alignment :::" << endl;
  cout << "Initialize phase..." << endl;
  AlignmentInit(inputSequence1, inputSequence2);
  // calculate alignment matrix
  cout << "Calculating alignment score..." << endl;
  CalcAlignmentScore(inputSequence1, inputSequence2);
  //traceback
  cout << "Traceback phase..." << endl;
  Traceback(inputSequence1, inputSequence2);
  // delete variables
  AlignmentCleanUp();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x4e9d(%rip), %rdi      # 0x8fd0
leaq 0x1f36(%rip), %rsi      # 0x6070
callq 0x21b0
movq %rax, %rdi
movq 0x4e77(%rip), %rsi      # 0x8fc0
callq 0x21e0
movq 0x4e7b(%rip), %rdi      # 0x8fd0
leaq 0x1f27(%rip), %rsi      # 0x6083
callq 0x21b0
movq %rax, %rdi
movq 0x4e55(%rip), %rsi      # 0x8fc0
callq 0x21e0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4200
movq 0x4e48(%rip), %rdi      # 0x8fd0
leaq 0x1f08(%rip), %rsi      # 0x6097
callq 0x21b0
movq %rax, %rdi
movq 0x4e22(%rip), %rsi      # 0x8fc0
callq 0x21e0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x43f0
movq 0x4e15(%rip), %rdi      # 0x8fd0
leaq 0x1ef4(%rip), %rsi      # 0x60b6
callq 0x21b0
movq %rax, %rdi
movq 0x4def(%rip), %rsi      # 0x8fc0
callq 0x21e0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x44b0
movq -0x20(%rbp), %rdi
callq 0x4cf0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kmiya[P]Needleman-Wunsch/src/BaseAlgorithms.cpp
// Function: needleman_wunsch_basealgorithms::BaseAlgorithms::CalcAlignmentScore(needleman_wunsch_base::Base const&, needleman_wunsch_base::Base const&)
void BaseAlgorithms::CalcAlignmentScore(const Base &inputSequence1, const Base &inputSequence2) {
  int s;
  for ( unsigned int y = 0; y < kMatSizeY; ++y ) {   // y-axis
    for ( unsigned int x = 0; x < kMatSizeX; ++x ) {   // x-axis
      s = inputSequence1.GetBase(x) == inputSequence2.GetBase(y) ? kMatch : kMismatch;
      Max(y+1, x+1, s);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x28(%rcx), %eax
jae 0x44a9
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x24(%rcx), %eax
jae 0x4499
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x2840
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x2840
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jne 0x4466
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0x4470
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %esi
addl $0x1, %esi
movl -0x24(%rbp), %edx
addl $0x1, %edx
movl -0x1c(%rbp), %ecx
callq 0x46f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x442a
jmp 0x449b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4413
addq $0x40, %rsp
popq %rbp
retq
nop
// File: kmiya[P]Needleman-Wunsch/src/BaseAlgorithms.cpp
// Function: needleman_wunsch_basealgorithms::BaseAlgorithms::Traceback(needleman_wunsch_base::Base const&, needleman_wunsch_base::Base const&)
void BaseAlgorithms::Traceback(const Base &inputSequence1, const Base &inputSequence2) {
  cout << "Start tracebacking from mat["<< kMatSizeY << "," << kMatSizeX << "]:" << endl;
  clock_t start, end;
  start = clock();
  TracebackRecursive(kMatSizeY, kMatSizeX, inputSequence1, inputSequence2);
  end = clock();
  cout << "time(ms): " << (end - start)*1000./CLOCKS_PER_SEC << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x4afd(%rip), %rdi      # 0x8fd0
leaq 0x1bef(%rip), %rsi      # 0x60c9
callq 0x21b0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x1bee(%rip), %rsi      # 0x60e6
callq 0x21b0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movl 0x24(%rax), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x1bd2(%rip), %rsi      # 0x60e8
callq 0x21b0
movq %rax, %rdi
movq 0x4a9b(%rip), %rsi      # 0x8fc0
callq 0x21e0
callq 0x2100
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl 0x28(%rdi), %esi
movl 0x24(%rdi), %edx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x4830
callq 0x2100
movq %rax, -0x28(%rbp)
movq 0x4a76(%rip), %rdi      # 0x8fd0
leaq 0x1b8a(%rip), %rsi      # 0x60eb
callq 0x21b0
movq %rax, %rdi
movq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x1ad2(%rip), %xmm1     # 0x6050
mulsd %xmm1, %xmm0
movsd 0x1abe(%rip), %xmm1     # 0x6048
divsd %xmm1, %xmm0
callq 0x2370
movq %rax, %rdi
movq 0x4a23(%rip), %rsi      # 0x8fc0
callq 0x21e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kmiya[P]Needleman-Wunsch/src/BaseAlgorithms.cpp
// Function: needleman_wunsch_basealgorithms::BaseAlgorithms::ComesFrom(int, int, needleman_wunsch_basealgorithms::BaseAlgorithms::Direction const&)
void BaseAlgorithms::ComesFrom(const int y, const int x, const Direction &direction) {
  switch (direction) {
    case kEdgeTop:
      SetParameters(y, x, x-1,   y, 0, 1); break;
    case kEdgeLeft:
      SetParameters(y, x,   x, y-1, 1, 0); break;
    case kUpperLeft:
      SetParameters(y, x, x-1, y-1, 0, 0); break;
    case kAbove:
      SetParameters(y, x,   x, y-1, 1, 0); break;
    case kLeft:
      SetParameters(y, x, x-1,   y, 0, 1); break;
    case kOrigin:
      SetParameters(y, x,   0,   0, 0, 0); break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x5, %rax
ja 0x46e4
movq -0x20(%rbp), %rax
leaq 0x1a6b(%rip), %rcx      # 0x6058
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movl -0xc(%rbp), %r8d
xorl %r9d, %r9d
movl $0x1, (%rsp)
callq 0x4c20
jmp 0x46e4
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0xc(%rbp), %r8d
subl $0x1, %r8d
movl $0x1, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x4c20
jmp 0x46e4
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movl -0xc(%rbp), %r8d
subl $0x1, %r8d
xorl %r9d, %r9d
movl $0x0, (%rsp)
callq 0x4c20
jmp 0x46e4
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0xc(%rbp), %r8d
subl $0x1, %r8d
movl $0x1, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x4c20
jmp 0x46e4
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movl -0xc(%rbp), %r8d
xorl %r9d, %r9d
movl $0x1, (%rsp)
callq 0x4c20
jmp 0x46e4
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
xorl %r9d, %r9d
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
callq 0x4c20
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kmiya[P]Needleman-Wunsch/src/BaseAlgorithms.cpp
// Function: needleman_wunsch_basealgorithms::BaseAlgorithms::Max(int, int, int)
int BaseAlgorithms::Max(const int y, const int x, const int s) {
  // calculate score
  const int up   = Mat(y-1,   x)->score + kGap;
  const int left = Mat(  y, x-1)->score + kGap;
  const int mid  = Mat(y-1, x-1)->score + s;
  const int maxScore = max(up, max(mid, left));
  Mat(y, x)->score = maxScore;
  // --- for trace back ---
  if ( maxScore == mid ) {
    ComesFrom(y, x, kUpperLeft);    // from upper left
    return 0;
  } else if ( maxScore == up ) {
    ComesFrom(y, x, kAbove);        // from above
    return 0;
  } else if ( maxScore == left ) {
    ComesFrom(y, x, kLeft);         // from left
    return 0;
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0x14(%rbp), %esi
subl $0x1, %esi
movl -0x18(%rbp), %edx
callq 0x4d20
movq -0x48(%rbp), %rdi
movl (%rax), %eax
addl 0x20(%rdi), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x4d20
movq -0x48(%rbp), %rdi
movl (%rax), %eax
addl 0x20(%rdi), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %esi
subl $0x1, %esi
movl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x4d20
movl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x4d50
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x4d50
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x4d20
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x47bd
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl $0x3, -0x30(%rbp)
leaq -0x30(%rbp), %rcx
callq 0x45b0
movl $0x0, -0x4(%rbp)
jmp 0x481e
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jne 0x47e8
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl $0x4, -0x34(%rbp)
leaq -0x34(%rbp), %rcx
callq 0x45b0
movl $0x0, -0x4(%rbp)
jmp 0x481e
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x4813
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl $0x5, -0x38(%rbp)
leaq -0x38(%rbp), %rcx
callq 0x45b0
movl $0x0, -0x4(%rbp)
jmp 0x481e
jmp 0x4815
jmp 0x4817
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kmiya[P]Needleman-Wunsch/src/BaseAlgorithms.cpp
// Function: needleman_wunsch_basealgorithms::BaseAlgorithms::SaveAlignment(std::ostream*)
void BaseAlgorithms::SaveAlignment(std::ostream *fout) {
  unsigned int match = 0;
  resultX->SaveString(fout);
  for (int pos = 0; pos < resultX->SequenceSize(); pos++ ) {
    if ( resultX->GetBase(pos) == resultY->GetBase(pos) ) {
      *fout << "|";
      match++;
    } else { *fout << " ";}
  }
  *fout << endl;
  resultY->SaveString(fout);
  *fout << "scoring:  match = " << kMatch << ",  mismatch = " << kMismatch << ", indel = " << kGap << endl;
  *fout << "matches: " << match << ",  score: " << Mat(kMatSizeY, kMatSizeX)->score <<"\n" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x29d0
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0x2870
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x4b22
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %esi
callq 0x2840
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x28(%rbp)
movq 0x8(%rax), %rdi
movl -0x18(%rbp), %esi
callq 0x2840
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jne 0x4b05
movq -0x10(%rbp), %rdi
leaq 0x161b(%rip), %rsi      # 0x6110
callq 0x21b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4b15
movq -0x10(%rbp), %rdi
leaq 0x15e4(%rip), %rsi      # 0x60f4
callq 0x21b0
jmp 0x4b17
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4aa2
movq -0x10(%rbp), %rdi
movq 0x4493(%rip), %rsi      # 0x8fc0
callq 0x21e0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x29d0
movq -0x10(%rbp), %rdi
leaq 0x15c4(%rip), %rsi      # 0x6112
callq 0x21b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x2320
movq %rax, %rdi
leaq 0x15b9(%rip), %rsi      # 0x6125
callq 0x21b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x2320
movq %rax, %rdi
leaq 0x15aa(%rip), %rsi      # 0x6134
callq 0x21b0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x2320
movq %rax, %rdi
movq 0x4418(%rip), %rsi      # 0x8fc0
callq 0x21e0
movq -0x10(%rbp), %rdi
leaq 0x1587(%rip), %rsi      # 0x613f
callq 0x21b0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2290
movq %rax, %rdi
leaq 0x1577(%rip), %rsi      # 0x6149
callq 0x21b0
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
movl 0x28(%rdi), %esi
movl 0x24(%rdi), %edx
callq 0x4d20
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x2320
movq %rax, %rdi
leaq 0x150f(%rip), %rsi      # 0x610e
callq 0x21b0
movq %rax, %rdi
movq 0x43b2(%rip), %rsi      # 0x8fc0
callq 0x21e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: kmiya[P]Needleman-Wunsch/src/BaseAlgorithms.cpp
// Function: needleman_wunsch_basealgorithms::BaseAlgorithms::SetParameters(int, int, int, int, int, int)
void BaseAlgorithms::SetParameters(const int    y, const int x,
                                   const int preX, const int preY,
                                   const int XGap, const int YGap) {
  Mat(y, x)->previousX = preX;
  Mat(y, x)->previousY = preY;
  Mat(y, x)->XAlignWithGap = XGap;
  Mat(y, x)->YAlignWithGap = YGap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x4d20
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, 0x4(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x4d20
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, 0x8(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x4d20
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, 0xc(%rax)
movl 0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x4d20
movl -0x20(%rbp), %ecx
movl %ecx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kmiya[P]Needleman-Wunsch/src/main.cpp
// Function: printDate(std::ostream*)
void printDate(ostream *fout) {
    time_t now;
    struct tm *local;
    time(&now);
    local = localtime(&now);
    *fout << local->tm_year + 1900 << " "   // year
          << local->tm_mon + 1 << "/"       // month
          << local->tm_mday << " "          // day
          << local->tm_hour << ":"          // hour
          << local->tm_min  << ":"          // minute
          << local->tm_sec                  // second
          << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2190
leaq -0x10(%rbp), %rdi
callq 0x2130
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %esi
addl $0x76c, %esi            # imm = 0x76C
callq 0x2320
movq %rax, %rdi
leaq 0xed2(%rip), %rsi       # 0x60f4
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %esi
addl $0x1, %esi
callq 0x2320
movq %rax, %rdi
leaq 0xf60(%rip), %rsi       # 0x61a3
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x2320
movq %rax, %rdi
leaq 0xe93(%rip), %rsi       # 0x60f4
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x2320
movq %rax, %rdi
leaq 0xe02(%rip), %rsi       # 0x6081
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2320
movq %rax, %rdi
leaq 0xde4(%rip), %rsi       # 0x6081
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x2320
movq %rax, %rdi
movq 0x3d06(%rip), %rsi      # 0x8fc0
callq 0x21e0
addq $0x20, %rsp
popq %rbp
retq
// File: 6851-2021[P]Cache-Oblivious-Data-Structures/static_search_trees/test_map_rep_sst.cpp
// Function: test_get_update_2()
void test_get_update_2() {
    // Test edge case with a tree of size 1.
    map_rep_static_search_tree tree;
    tree.update(0, 2);
    if (tree.get(2) != 0) {
        cout << "test_get_update_2 failed: expected 2 at index 0." << endl;
        return;
    }
    tree.update(0, 5);
    if (tree.get(5) != 0) {
        cout << "test_get_update_2 failed: expected 5 at index 0." << endl;
        return;
    }
    tree.update(0, 501);
    if (tree.get(501) != 0) {
        cout << "test_get_update_2 failed: expected 501 at index 0." << endl;
        return;
    }
    cout << "test_get_update_2: OK" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x60a0
movq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x30a0
jmp 0x574a
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x30d0
movl %eax, -0x4c(%rbp)
jmp 0x575d
movl -0x4c(%rbp), %eax
cmpl $0x0, %eax
je 0x57b6
movq 0x586c(%rip), %rdi      # 0xafd8
leaq 0x1a83(%rip), %rsi      # 0x71f6
callq 0x10d0
movq %rax, -0x58(%rbp)
jmp 0x577e
movq -0x58(%rbp), %rdi
movq 0x583f(%rip), %rsi      # 0xafc8
callq 0x1110
jmp 0x5790
movl $0x1, -0x40(%rbp)
jmp 0x58ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x60c0
jmp 0x58bf
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x30a0
jmp 0x57c8
leaq -0x30(%rbp), %rdi
movl $0x5, %esi
callq 0x30d0
movl %eax, -0x5c(%rbp)
jmp 0x57db
movl -0x5c(%rbp), %eax
cmpl $0x0, %eax
je 0x581a
movq 0x57ee(%rip), %rdi      # 0xafd8
leaq 0x1a36(%rip), %rsi      # 0x7227
callq 0x10d0
movq %rax, -0x68(%rbp)
jmp 0x57fc
movq -0x68(%rbp), %rdi
movq 0x57c1(%rip), %rsi      # 0xafc8
callq 0x1110
jmp 0x580e
movl $0x1, -0x40(%rbp)
jmp 0x58ad
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x1f5, %edx            # imm = 0x1F5
callq 0x30a0
jmp 0x582c
leaq -0x30(%rbp), %rdi
movl $0x1f5, %esi            # imm = 0x1F5
callq 0x30d0
movl %eax, -0x6c(%rbp)
jmp 0x583f
movl -0x6c(%rbp), %eax
cmpl $0x0, %eax
je 0x587b
movq 0x578a(%rip), %rdi      # 0xafd8
leaq 0x1a03(%rip), %rsi      # 0x7258
callq 0x10d0
movq %rax, -0x78(%rbp)
jmp 0x5860
movq -0x78(%rbp), %rdi
movq 0x575d(%rip), %rsi      # 0xafc8
callq 0x1110
jmp 0x5872
movl $0x1, -0x40(%rbp)
jmp 0x58ad
movq 0x5756(%rip), %rdi      # 0xafd8
leaq 0x1a02(%rip), %rsi      # 0x728b
callq 0x10d0
movq %rax, -0x80(%rbp)
jmp 0x5894
movq -0x80(%rbp), %rdi
movq 0x5729(%rip), %rsi      # 0xafc8
callq 0x1110
jmp 0x58a6
movl $0x0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x60c0
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x1190
nopl (%rax,%rax)