LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: billDrett[P]Bulletin-Boards/boardServer.cpp
// Function: BoardServer::parseGetMessage(char*, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void BoardServer::parseGetMessage(char* buffer, int nread, int state, std::string& previousRead)
{
    char* chanel1;
    int id, chanelSize1, chanelSize2;

    previousRead.append(buffer, nread);

    if(state == waitingEndCommand)
    {
        string chanelString;
        chanelSize1 = previousRead.size();
        chanel1 = getAfterTag(previousRead.c_str(), "*", chanelSize1); //anamesa sta * * vrisketo to chanel sto opoio tha apothikeutei to message

        chanelSize2 = chanelSize1;
        getBeforeTag(chanel1, "*", chanelSize1);

        chanelString.assign(chanel1, chanelSize1);
        id = atoi(chanelString.c_str());
        chanel1 = getAfterTag(chanel1, "*", chanelSize2);
        previousRead.assign(chanel1, chanelSize2);
        this->addMessageToChanel(id, previousRead);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x3070
cmpl $0x3, -0x18(%rbp)
jne 0x84a4
leaq -0x58(%rbp), %rdi
callq 0x33e0
movq -0x20(%rbp), %rdi
callq 0x3210
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3130
movq %rax, %rdi
leaq 0x2ec8(%rip), %rsi      # 0xb253
leaq -0x30(%rbp), %rdx
callq 0x8de0
movq %rax, -0x98(%rbp)
jmp 0x839d
movq -0x98(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x2e9a(%rip), %rsi      # 0xb253
leaq -0x30(%rbp), %rdx
callq 0x8e70
jmp 0x83c4
movq -0x28(%rbp), %rsi
movslq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x33c0
jmp 0x83d7
leaq -0x58(%rbp), %rdi
callq 0x3130
movq %rax, %rdi
callq 0x3460
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x2e5d(%rip), %rsi      # 0xb253
leaq -0x34(%rbp), %rdx
callq 0x8de0
movq %rax, -0xa0(%rbp)
jmp 0x8408
movq -0xa0(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x33c0
jmp 0x8426
movl -0x2c(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x3150
jmp 0x8441
movl -0xa4(%rbp), %esi
movq -0x90(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x5ef0
jmp 0x845c
leaq -0x88(%rbp), %rdi
callq 0x31f0
leaq -0x58(%rbp), %rdi
callq 0x31f0
jmp 0x84a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x8499
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x31f0
leaq -0x58(%rbp), %rdi
callq 0x31f0
jmp 0x84ad
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: billDrett[P]Bulletin-Boards/stringFuctions.cpp
// Function: findSubstring(char const*, char const*, int)
char* findSubstring(const char* mainString, const char* substring, int mainLength) //epistrefei thn thesh pou vrisketai to subString sto mainString
{
    unsigned int j=0;
    for(int i =0; i < mainLength; i++)
    {
        if(mainString[i]==substring[j])
        {
            j++;
        }
        else
        {
            j = 0;
        }
        if(j == strlen(substring))
        {
            return ((char*)mainString+i-j+1); //to i exei timi thn thesh tou teleutaiou xarakthra tou substring, gia auto afairw to j pou einai to mhkos tou substring kai prosthetw 1 gia na parw thn arxh sto mainString
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x8dc1
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movl -0x20(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x8d6f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8d76
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3160
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0x8db4
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movl -0x20(%rbp), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x8dc9
jmp 0x8db6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8d41
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: billDrett[P]Bulletin-Boards/stringFuctions.cpp
// Function: getAfterTag(char const*, char const*, int&)
char* getAfterTag(const char* mainString, const char* tag, int& length) //epistrefei thn thesh meta to substring, allazei to length gia na ypologisei ta enapominanta bytes
{
    char* start = findSubstring(mainString, tag, length);
    if(start == NULL) return NULL;

    length -= strlen(tag) + (start - mainString); //afairoume ta bytes pou prosperasame
    start+=strlen(tag); //thesh meta to substring
    return start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl (%rax), %edx
callq 0x8d20
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8e1c
movq $0x0, -0x8(%rbp)
jmp 0x8e5b
movq -0x18(%rbp), %rdi
callq 0x3160
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq %rax, %rdx
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
subq %rdx, %rcx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x3160
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: billDrett[P]Bulletin-Boards/stringFuctions.cpp
// Function: getBeforeTag(char const*, char const*, int&)
char* getBeforeTag(const char* mainString, const char* tag, int& length) //allazei to length gia na ypologisei ta enapominanta bytes
{
    char* endTag = findSubstring(mainString, tag, length);
    if(endTag == NULL) return NULL;

    length =endTag-mainString;
    return (char*)mainString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl (%rax), %edx
callq 0x8d20
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8eac
movq $0x0, -0x8(%rbp)
jmp 0x8ec7
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: billDrett[P]Bulletin-Boards/stringFuctions.cpp
// Function: fileNameExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void fileNameExists(string& fileN) //an yparxei to arxeio sto current directory tou prosthetei sto telos to _copy.
{
    int fp;
    while((fp=open(fileN.c_str(), O_RDONLY, 0644)) != -1)
    {
        int found = fileN.find(".");
        if(found ==string::npos) //an dn yparxei h teleia mpainei sto telos
        {
            found = fileN.size();
        }
        fileN.insert(found, "_copy"); //to _copy prepei na mpei prin thn teleia
        close(fp);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3130
movq %rax, %rdi
xorl %esi, %esi
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x3230
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
je 0x8f59
movq -0x8(%rbp), %rdi
leaq 0x216b(%rip), %rsi      # 0xb084
xorl %eax, %eax
movl %eax, %edx
callq 0x3540
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rax
cmpq $-0x1, %rax
jne 0x8f3b
movq -0x8(%rbp), %rdi
callq 0x3210
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
leaq 0x234f(%rip), %rdx      # 0xb299
callq 0x30d0
movl -0xc(%rbp), %edi
callq 0x3520
jmp 0x8eec
addq $0x10, %rsp
popq %rbp
retq
nop
// File: billDrett[P]Bulletin-Boards/List.cpp
// Function: List<int>::~List()
List<T>::~List()
{
    Node<T>* tmp = start;
    Node<T>* del;

    while(tmp != NULL)//diagrafoume enan enan tous komvous
    {
        del = tmp;
        tmp = tmp->get_next();
        listSize--;
        delete del;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9054
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa7f0
movq %rax, -0x28(%rbp)
jmp 0x901a
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x9052
movq -0x30(%rbp), %rdi
callq 0xa7e0
movq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0x32e0
jmp 0x8ffc
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8890
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: billDrett[P]Bulletin-Boards/List.cpp
// Function: List<int>::insertEnd(int*)
void List<T>::insertEnd(T* account)
{
	Node<T>* node = new Node<T>(account);

	if(checkEmpty()) //an einai to monadiko stoixeio prepei na allaksw ton deikti start kai last
	{
	    start = node;
	    last = node;
	    listSize++;
		return;
	}
	//alliws eisodos sto telos ths listas
    last->set_next(node);
    node->set_next(NULL);
    last = node;
    listSize++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x32d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xa7b0
jmp 0x9117
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x9070
testb $0x1, %al
jne 0x912e
jmp 0x9167
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x9198
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x32e0
jmp 0x919e
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xa830
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa830
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34b0
nopw (%rax,%rax)
// File: billDrett[P]Bulletin-Boards/List.cpp
// Function: List<int>::insertBeginning(int*)
void List<T>::insertBeginning(T* account)
{
	Node<T>* node = new Node<T>(account);

	if(checkEmpty()) //an einai to monadiko stoixeio prepei na allaksw ton deikti start kai last
	{
	    start = node;
	    last = node;
	    listSize++;
		return;
	}
	//alliws eisodos stin arxi
    node->set_next(start);
    start = node;
    listSize++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x32d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rsi
callq 0xa7b0
jmp 0x91e7
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x9070
testb $0x1, %al
jne 0x91fe
jmp 0x9237
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x925b
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x32e0
jmp 0x9261
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0xa830
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34b0
nopw (%rax,%rax)
// File: billDrett[P]Bulletin-Boards/List.cpp
// Function: List<int>::deleteFirstNode()
T* List<T>::deleteFirstNode()
{
    Node<T>* tmp;
    T* tmpAccount;
    if(checkEmpty())
    {
        return NULL;
    }

    tmp = start;
    start = start->get_next();
    if(listSize == 1) last = NULL; //arxi kai telos deixnoun sto idio, epomenos i lista exei mono ena stoixeio

    tmpAccount = tmp->get_data();
    delete tmp;
    listSize--;
    return tmpAccount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x9070
testb $0x1, %al
jne 0x928f
jmp 0x9299
movq $0x0, -0x8(%rbp)
jmp 0x930f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rdi
callq 0xa7f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpl $0x1, (%rax)
jne 0x92ca
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0xa810
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x92fc
movq -0x30(%rbp), %rdi
callq 0xa7e0
movq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0x32e0
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: billDrett[P]Bulletin-Boards/List.cpp
// Function: List<int>::deleteLastNode()
T* List<T>::deleteLastNode()
{
    Node<T>* tmp = start;
    T* tmpAccount;
    if(checkEmpty())
    {
        return NULL;
    }

    if(listSize == 1) //an exei mono ena stoixeio tote prepei na allaksei kai o deiktis start
    {
        tmpAccount = start->get_data();
        delete start;
        start = NULL;
        last = NULL;
        listSize--;
        return tmpAccount;
    }

    while(tmp->get_next() != last) //pairnw to proteleutaio stoixeio
    {
        tmp = tmp->get_next();
    }
    tmpAccount = last->get_data();
    delete last;
    last = tmp;
    tmp->set_next(NULL);
    listSize--;
    return tmpAccount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x18(%rbp)
callq 0x9070
testb $0x1, %al
jne 0x9347
jmp 0x9354
movq $0x0, -0x8(%rbp)
jmp 0x944f
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x93c2
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa810
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x939a
movq -0x30(%rbp), %rdi
callq 0xa7e0
movq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0x32e0
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x944f
jmp 0x93c4
movq -0x18(%rbp), %rdi
callq 0xa7f0
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x93e6
movq -0x18(%rbp), %rdi
callq 0xa7f0
movq %rax, -0x18(%rbp)
jmp 0x93c4
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xa810
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x9423
movq -0x38(%rbp), %rdi
callq 0xa7e0
movq -0x38(%rbp), %rdi
movl $0x10, %esi
callq 0x32e0
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa830
movq -0x28(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: billDrett[P]Bulletin-Boards/List.cpp
// Function: List<int>::deleteNode(Node<int>*)
T* List<T>::deleteNode(Node<T>* node) //diagrafei tou sigekrimenou node
{
    Node<T>* tmp = start;
    Node<T>* del = NULL;
    T* data = NULL;

    if(checkEmpty() == true)
    {
        return NULL;
    }

    if(start == node) // an einai o prwtos 'h o monadikos komvos
    {
        return this->deleteFirstNode();
    }

    if(last == node) //an o teleutaios
    {
        return this->deleteLastNode();
    }

    while(tmp->get_next() != node)
    {
        if(tmp->get_next() == NULL)
        {
            return NULL;
        }
        tmp = tmp->get_next();
    }
    del = tmp->get_next();
    tmp->set_next(del->get_next());

    data = del->get_data();
    listSize--;
    delete del;
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
callq 0x9070
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x94ac
movq $0x0, -0x8(%rbp)
jmp 0x959a
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x94cc
movq -0x38(%rbp), %rdi
callq 0x9270
movq %rax, -0x8(%rbp)
jmp 0x959a
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x94ec
movq -0x38(%rbp), %rdi
callq 0x9320
movq %rax, -0x8(%rbp)
jmp 0x959a
jmp 0x94ee
movq -0x20(%rbp), %rdi
callq 0xa7f0
cmpq -0x18(%rbp), %rax
je 0x9528
movq -0x20(%rbp), %rdi
callq 0xa7f0
cmpq $0x0, %rax
jne 0x9519
movq $0x0, -0x8(%rbp)
jmp 0x959a
movq -0x20(%rbp), %rdi
callq 0xa7f0
movq %rax, -0x20(%rbp)
jmp 0x94ee
movq -0x20(%rbp), %rdi
callq 0xa7f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa7f0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xa830
movq -0x28(%rbp), %rdi
callq 0xa810
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x9592
movq -0x40(%rbp), %rdi
callq 0xa7e0
movq -0x40(%rbp), %rdi
movl $0x10, %esi
callq 0x32e0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: billDrett[P]Bulletin-Boards/chanel.cpp
// Function: Chanel::Chanel(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Chanel::Chanel(int Id, string Name): id(Id)
{
    ofstream messageFile;
    char buffId[12];
    name = Name;
    files = new List<string>();

    sprintf(buffId, "%d", Id);
    messageFileName = "message_";
    messageFileName.append(buffId);
    messageFile.open(messageFileName.c_str()); //dimiourgoume to arxeio gia thn apothikeush twn mhnymatwn
    messageFile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdx, -0x250(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x240(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x248(%rbp)
callq 0x33e0
movq -0x240(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x238(%rbp)
callq 0x33e0
leaq -0x218(%rbp), %rdi
callq 0x3490
jmp 0xab12
movq -0x250(%rbp), %rsi
movq -0x240(%rbp), %rdi
addq $0x8, %rdi
callq 0x3040
jmp 0xab2b
movl $0x18, %edi
callq 0x32d0
movq %rax, -0x258(%rbp)
jmp 0xab3e
movq -0x258(%rbp), %rdi
callq 0x95b0
jmp 0xab4c
movq -0x240(%rbp), %rax
movq -0x258(%rbp), %rcx
movq %rcx, 0x48(%rax)
movl -0xc(%rbp), %edx
leaq 0x579(%rip), %rsi       # 0xb0e1
xorl %eax, %eax
leaq -0x230(%rbp), %rdi
callq 0x30a0
movq -0x240(%rbp), %rdi
addq $0x28, %rdi
leaq 0x717(%rip), %rsi       # 0xb29f
callq 0x33d0
jmp 0xab8f
movq -0x240(%rbp), %rdi
addq $0x28, %rdi
leaq -0x230(%rbp), %rsi
callq 0x3500
jmp 0xaba8
movq -0x240(%rbp), %rdi
addq $0x28, %rdi
callq 0x3130
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x3060
jmp 0xabce
leaq -0x218(%rbp), %rdi
callq 0x33f0
jmp 0xabdc
leaq -0x218(%rbp), %rdi
callq 0x3440
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0xac48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0xac3c
movq -0x258(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
movl $0x18, %esi
callq 0x32e0
leaq -0x218(%rbp), %rdi
callq 0x3440
movq -0x238(%rbp), %rdi
callq 0x31f0
movq -0x248(%rbp), %rdi
callq 0x31f0
movq -0x220(%rbp), %rdi
callq 0x34b0
nopl (%rax)
// File: billDrett[P]Bulletin-Boards/chanel.cpp
// Function: Chanel::removeAllFiles()
void Chanel::removeAllFiles()
{
    string* tmp;

    tmp = files->deleteFirstNode();
    while(tmp != NULL)
    {
        unlink(tmp->c_str());
        delete tmp;
        tmp = files->deleteFirstNode();//diagrafoume ta stoixeia tis listas
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x48(%rax), %rdi
callq 0x9870
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xad91
movq -0x10(%rbp), %rdi
callq 0x3130
movq %rax, %rdi
callq 0x31b0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xad7e
movq -0x20(%rbp), %rdi
callq 0x31f0
movq -0x20(%rbp), %rdi
movl $0x20, %esi
callq 0x32e0
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x9870
movq %rax, -0x10(%rbp)
jmp 0xad41
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: billDrett[P]Bulletin-Boards/chanel.cpp
// Function: Chanel::addMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Chanel::addMessage(string& message) //apothikeuoume to onoma sto telos tou arxeiou
{
    ofstream messageFile;
    messageFile.open(messageFileName.c_str(), std::ofstream::out | std::ofstream::app);
    if(!messageFile)
    {
        perror("chanel file cant open");
        exit(3);
    }

    messageFile << message;
    messageFile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3490
movq -0x230(%rbp), %rdi
addq $0x28, %rdi
callq 0x3130
movq %rax, -0x228(%rbp)
movl $0x10, %edi
movl $0x1, %esi
callq 0xaf80
movl %eax, -0x220(%rbp)
jmp 0xaeb8
movl -0x220(%rbp), %edx
movq -0x228(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x3060
jmp 0xaed3
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x3180
movb %al, -0x231(%rbp)
jmp 0xaef3
movb -0x231(%rbp), %al
testb $0x1, %al
jne 0xaeff
jmp 0xaf37
leaq 0x3a2(%rip), %rdi       # 0xb2a8
callq 0x3260
jmp 0xaf0d
movl $0x3, %edi
callq 0x3370
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x3440
jmp 0xaf6c
movq -0x10(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x3290
jmp 0xaf49
leaq -0x210(%rbp), %rdi
callq 0x33f0
jmp 0xaf57
leaq -0x210(%rbp), %rdi
callq 0x3440
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x34b0
nopl (%rax,%rax)
// File: zengfenfei[P]codility/src/FrogJmp.cpp
// Function: solution(int, int, int)
int solution(int X, int Y, int D) {
	int dist = Y - X;
	int steps = dist / D;
	if (dist % D > 0) {
		steps++;
	}

	return steps;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
cmpl $0x0, %edx
jle 0x11e5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 7shi[P]8086run/v1/main.cpp
// Function: getch()
int getch() {
    char ret;
    if (kbchar == EOF) {
        if (read(STDIN_FILENO, &ret, 1) < 1) return EOF;
    } else {
        ret = kbchar;
        kbchar = EOF;
    }
    if (ret == 10) ret = 13;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $-0x1, 0x9e41(%rip)     # 0xb0e0
jne 0x12c2
xorl %edi, %edi
leaq -0x5(%rbp), %rsi
movl $0x1, %edx
callq 0x1150
cmpq $0x1, %rax
jge 0x12c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12e9
jmp 0x12d5
movl 0x9e18(%rip), %eax      # 0xb0e0
movb %al, -0x5(%rbp)
movl $0xffffffff, 0x9e0b(%rip) # imm = 0xFFFFFFFF
movsbl -0x5(%rbp), %eax
cmpl $0xa, %eax
jne 0x12e2
movb $0xd, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 7shi[P]8086run/v1/main.cpp
// Function: kbhit()
int kbhit() {
    if (kbchar != EOF) return 1;
    int f = fcntl(STDIN_FILENO, F_GETFL, 0);
    fcntl(STDIN_FILENO, F_SETFL, f | O_NONBLOCK);
    char ch;
    kbchar = read(STDIN_FILENO, &ch, 1) < 1 ? EOF : ch;
    fcntl(STDIN_FILENO, F_SETFL, f);
    return kbchar != EOF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $-0x1, 0x9dd1(%rip)     # 0xb0e0
je 0x131a
movl $0x1, -0x4(%rbp)
jmp 0x1397
xorl %edx, %edx
movl $0x3, %esi
movl %edx, %edi
movb $0x0, %al
callq 0x1050
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edx
orl $0x800, %edx            # imm = 0x800
xorl %edi, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x1050
xorl %edi, %edi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x1150
cmpq $0x1, %rax
jge 0x1364
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x10(%rbp)
jmp 0x136b
movsbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, 0x9d6c(%rip)      # 0xb0e0
movl -0x8(%rbp), %edx
xorl %edi, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x1050
cmpl $-0x1, 0x9d54(%rip)     # 0xb0e0
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: 7shi[P]8086run/v1/main.cpp
// Function: inittty()
void inittty() {
    termios t;
    tcgetattr(STDIN_FILENO, &t);
    oldt = t;

    struct sigaction sa;
    memset(&sa, 0, sizeof (sa));
    sa.sa_handler = siginthandler;
    sigaction(SIGINT, &sa, NULL);
    atexit(resettty);

    t.c_lflag &= ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, &t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
xorl %edi, %edi
leaq -0x3c(%rbp), %rsi
callq 0x10d0
leaq 0x9d83(%rip), %rdi      # 0xb180
leaq -0x3c(%rbp), %rsi
movl $0x3c, %edx
callq 0x1080
leaq -0xd8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x1040
leaq -0x85(%rip), %rax       # 0x13a0
movq %rax, -0xd8(%rbp)
movl $0x2, %edi
leaq -0xd8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1110
leaq -0x88(%rip), %rdi       # 0x13c0
callq 0x7540
movl -0x30(%rbp), %eax
andl $-0xb, %eax
movl %eax, -0x30(%rbp)
xorl %esi, %esi
leaq -0x3c(%rbp), %rdx
movl %esi, %edi
callq 0x1120
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 7shi[P]8086run/v1/main.cpp
// Function: dump(_IO_FILE*, SReg*, unsigned short, int)
void dump(FILE *f, SReg *seg, uint16_t addr, int len) {
    fprintf(f, "org 0x%04x:0x%04x\n", seg->v, addr);
    for (int i = 0; i < len; ++i) {
        if (i & 7) {
            fprintf(f, ", ");
        } else {
            if (i > 0) fprintf(f, "\n");
            fprintf(f, "db ");
        }
        fprintf(f, "0x%02x", (*seg)[addr + i]);
    }
    fprintf(f, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0x8(%rax), %edx
movzwl -0x12(%rbp), %ecx
leaq 0x6efd(%rip), %rsi      # 0x867e
movb $0x0, %al
callq 0x1140
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x181f
movl -0x1c(%rbp), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x17ba
movq -0x8(%rbp), %rdi
leaq 0x6ee0(%rip), %rsi      # 0x8691
movb $0x0, %al
callq 0x1140
jmp 0x17e4
cmpl $0x0, -0x1c(%rbp)
jle 0x17d2
movq -0x8(%rbp), %rdi
leaq 0x6f7e(%rip), %rsi      # 0x8749
movb $0x0, %al
callq 0x1140
movq -0x8(%rbp), %rdi
leaq 0x6eb7(%rip), %rsi      # 0x8694
movb $0x0, %al
callq 0x1140
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %esi
addl -0x1c(%rbp), %esi
callq 0x6110
movq -0x28(%rbp), %rdi
movzbl (%rax), %edx
leaq 0x6e8e(%rip), %rsi      # 0x8698
movb $0x0, %al
callq 0x1140
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x178f
movq -0x8(%rbp), %rdi
leaq 0x6f1f(%rip), %rsi      # 0x8749
movb $0x0, %al
callq 0x1140
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 7shi[P]8086run/v1/main.cpp
// Function: error(char const*, ...)
void error(const char *fmt, ...) {
    IP = oldip;
    dump(stderr, &CS, IP - 0x18, 0x30);
    debug(stderr, true);
    va_list ap;
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);
    fputc('\n', stderr);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x1875
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movw 0x12991f(%rip), %ax     # 0x12b1c2
movw %ax, 0x129916(%rip)     # 0x12b1c0
movq 0x972f(%rip), %rax      # 0xafe0
movq (%rax), %rdi
movzwl 0x129905(%rip), %eax    # 0x12b1c0
subl $0x18, %eax
leaq 0x129a6b(%rip), %rsi    # 0x12b330
addq $0x10, %rsi
movl $0x30, %ecx
movzwl %ax, %edx
callq 0x1750
movq 0x9703(%rip), %rax      # 0xafe0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x1470
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x96cb(%rip), %rax      # 0xafe0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1130
leaq -0x20(%rbp), %rax
movq 0x96b0(%rip), %rax      # 0xafe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1100
movl $0x1, %edi
callq 0x10f0
nopw (%rax,%rax)
// File: 7shi[P]8086run/v1/main.cpp
// Function: out(unsigned short, unsigned char)
void out(uint16_t n, uint8_t v) {
    switch (n) {
        case 0x0020: // PIC 8259 (master)
            // TODO
            break;
        case 0x0021: // PIC 8259 (master) - OCW1
            // TODO
            break;
        case 0x0042: // PIT 8254 - counter 2
            // TODO
            break;
        case 0x0043: // PIT 8254 - interval, beep
            // TODO
            break;
        case 0x0061: // PPI 8255 - port B
            break;
        default:
            error("not implemented: out %04x,%02x", n, v);
    }
    io[n] = v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movw %di, %cx
movw %cx, -0x2(%rbp)
movb %al, -0x3(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x20, %eax
je 0x199b
jmp 0x1973
movl -0x8(%rbp), %eax
subl $0x21, %eax
je 0x199d
jmp 0x197d
movl -0x8(%rbp), %eax
subl $0x42, %eax
je 0x199f
jmp 0x1987
movl -0x8(%rbp), %eax
subl $0x43, %eax
je 0x19a1
jmp 0x1991
movl -0x8(%rbp), %eax
subl $0x61, %eax
je 0x19a3
jmp 0x19a5
jmp 0x19bb
jmp 0x19bb
jmp 0x19bb
jmp 0x19bb
jmp 0x19bb
movzwl -0x2(%rbp), %esi
movzbl -0x3(%rbp), %edx
leaq 0x6ceb(%rip), %rdi      # 0x869f
movb $0x0, %al
callq 0x1840
movb -0x3(%rbp), %dl
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x1197f5(%rip), %rax    # 0x11b1c0
movb %dl, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 7shi[P]8086run/v1/main.cpp
// Function: in(unsigned short)
uint8_t in(uint16_t n) {
    switch (n) {
        case 0x0020: // PIC 8259 (master)
            // TODO
            break;
        case 0x0021: // PIC 8259 (master) - IMR
            break;
        case 0x0040: // PIT 8254 - counter 0
            // TODO
            break;
        case 0x0061: // PPI 8255 - port B (beep)
            break;
        case 0x00a1: // PIC 8259 (slave) - IMR
            break;
        case 0x03da: // CRTC 6845 - status register
            return io[n] = !io[n];
        default:
            error("not implemented: in %04x", n);
    }
    return io[n];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x4(%rbp)
movzwl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x20, %eax
je 0x1a33
jmp 0x19fd
movl -0x8(%rbp), %eax
subl $0x21, %eax
je 0x1a35
jmp 0x1a07
movl -0x8(%rbp), %eax
subl $0x40, %eax
je 0x1a37
jmp 0x1a11
movl -0x8(%rbp), %eax
subl $0x61, %eax
je 0x1a39
jmp 0x1a1b
movl -0x8(%rbp), %eax
subl $0xa1, %eax
je 0x1a3b
jmp 0x1a27
movl -0x8(%rbp), %eax
subl $0x3da, %eax            # imm = 0x3DA
je 0x1a3d
jmp 0x1a6a
jmp 0x1a7c
jmp 0x1a7c
jmp 0x1a7c
jmp 0x1a7c
jmp 0x1a7c
movzwl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x119776(%rip), %rax    # 0x11b1c0
cmpb $0x0, (%rax,%rcx)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzwl -0x4(%rbp), %ecx
movl %ecx, %edx
leaq 0x11975e(%rip), %rcx    # 0x11b1c0
movb %al, (%rcx,%rdx)
movb %al, -0x1(%rbp)
jmp 0x1a8f
movzwl -0x4(%rbp), %esi
leaq 0x6c49(%rip), %rdi      # 0x86be
movb $0x0, %al
callq 0x1840
movzwl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x119737(%rip), %rax    # 0x11b1c0
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 7shi[P]8086run/v1/main.cpp
// Function: intr(int)
void intr(int n) {
    uint8_t *v = &mem[n << 2];
    uint16_t cs = read16(v + 2), ip = read16(v);
    if (!cs && ip < 0x20) return bios(ip);
    push(getf());
    IF = TF = 0;
    push(*CS);
    push(IP);
    CS = cs;
    IP = ip;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll $0x2, %eax
movslq %eax, %rcx
leaq 0x8e15(%rip), %rax      # 0xb1c0
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
callq 0x6130
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6130
movw %ax, -0x14(%rbp)
cmpw $0x0, -0x12(%rbp)
jne 0x23eb
movzwl -0x14(%rbp), %eax
cmpl $0x20, %eax
jge 0x23eb
movzwl -0x14(%rbp), %edi
callq 0x1aa0
jmp 0x2449
callq 0x6240
movzwl %ax, %edi
callq 0x61f0
movb $0x0, 0x128e24(%rip)    # 0x12b223
movb $0x0, 0x128e1c(%rip)    # 0x12b222
leaq 0x128f23(%rip), %rdi    # 0x12b330
addq $0x10, %rdi
callq 0x60f0
movzwl %ax, %edi
callq 0x61f0
movzwl 0x128d9b(%rip), %edi    # 0x12b1c0
callq 0x61f0
leaq 0x128eff(%rip), %rdi    # 0x12b330
addq $0x10, %rdi
movzwl -0x12(%rbp), %esi
callq 0x6180
movw -0x14(%rbp), %ax
movw %ax, 0x128d77(%rip)     # 0x12b1c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 7shi[P]8086run/v1/main.cpp
// Function: Operand::operator=(int)
inline void operator=(int value) {
        if (type == Reg) {
            if (w) {
                r[v] = value;
            } else {
                *r8[v] = value;
            }
            return;
        }
        uint8_t *p = ptr();
        if (p) {
            if (w) {
                write16(p, value);
            } else {
                *p = value;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, (%rax)
jne 0x64eb
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x64d1
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movw %cx, %dx
movslq 0x8(%rax), %rcx
leaq 0x124d05(%rip), %rax    # 0x12b1d0
movw %dx, (%rax,%rcx,2)
jmp 0x64e9
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movslq 0x8(%rax), %rdx
leaq 0x124cfd(%rip), %rax    # 0x12b1e0
movq (%rax,%rdx,8), %rax
movb %cl, (%rax)
jmp 0x6527
movq -0x20(%rbp), %rdi
callq 0x74b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6527
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x651a
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movzwl %ax, %esi
callq 0x6150
jmp 0x6525
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
jmp 0x6527
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 7shi[P]8086run/v1/main.cpp
// Function: setf8(int)
inline int setf8(int value) {
    int8_t v = value;
    OF = value != v;
    SF = v < 0;
    ZF = v == 0;
    PF = ptable[uint8_t(value)];
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movb %al, -0x5(%rbp)
movl -0x4(%rbp), %eax
movsbl -0x5(%rbp), %ecx
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movb %al, 0x124c1f(%rip)     # 0x12b220
movsbl -0x5(%rbp), %eax
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movb %al, 0x124c11(%rip)     # 0x12b224
movsbl -0x5(%rbp), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, 0x124c00(%rip)     # 0x12b225
movl -0x4(%rbp), %eax
movzbl %al, %eax
movl %eax, %ecx
leaq 0x124bfc(%rip), %rax    # 0x12b230
movb (%rax,%rcx), %al
andb $0x1, %al
movb %al, 0x124be8(%rip)     # 0x12b227
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 7shi[P]8086run/v1/main.cpp
// Function: setf16(int)
inline int setf16(int value) {
    int16_t v = value;
    OF = value != v;
    SF = v < 0;
    ZF = v == 0;
    PF = ptable[uint8_t(value)];
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movw %ax, -0x6(%rbp)
movl -0x4(%rbp), %eax
movswl -0x6(%rbp), %ecx
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movb %al, 0x124bae(%rip)     # 0x12b220
movswl -0x6(%rbp), %eax
cmpl $0x0, %eax
setl %al
andb $0x1, %al
movb %al, 0x124ba0(%rip)     # 0x12b224
movswl -0x6(%rbp), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, 0x124b8f(%rip)     # 0x12b225
movl -0x4(%rbp), %eax
movzbl %al, %eax
movl %eax, %ecx
leaq 0x124b8b(%rip), %rax    # 0x12b230
movb (%rax,%rcx), %al
andb $0x1, %al
movb %al, 0x124b77(%rip)     # 0x12b227
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 7shi[P]8086run/v1/main.cpp
// Function: jumpif(signed char, bool)
inline void jumpif(int8_t offset, bool c) {
    if (c) {
        IP += 2 + offset;
    } else {
        IP += 2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
andb $0x1, %al
movb %al, -0x2(%rbp)
testb $0x1, -0x2(%rbp)
je 0x66f1
movsbl -0x1(%rbp), %ecx
addl $0x2, %ecx
movzwl 0x124ada(%rip), %eax    # 0x12b1c0
addl %ecx, %eax
movw %ax, 0x124ad1(%rip)     # 0x12b1c0
jmp 0x6702
movzwl 0x124ac8(%rip), %eax    # 0x12b1c0
addl $0x2, %eax
movw %ax, 0x124abe(%rip)     # 0x12b1c0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 7shi[P]8086run/v1/main.cpp
// Function: Operand::modrm(unsigned char*, bool, SReg*)
inline size_t modrm(uint8_t *p, bool w, SReg *seg) {
        uint8_t b = p[1], mod = b >> 6, rm = b & 7;
        switch (mod) {
            case 0:
                if (rm == 6) {
                    set(Ptr, w, read16(p + 2), seg);
                    return 4;
                }
                set(ModRM + rm, w, 0, seg);
                return 2;
            case 1:
                set(ModRM + rm, w, (int8_t) p[2], seg);
                return 3;
            case 2:
                set(ModRM + rm, w, (int16_t) read16(p + 2), seg);
                return 4;
        }
        set(Reg, w, rm, NULL);
        return 2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
shrl $0x6, %eax
movb %al, -0x2a(%rbp)
movb -0x29(%rbp), %al
andb $0x7, %al
movb %al, -0x2b(%rbp)
movzbl -0x2a(%rbp), %eax
movl %eax, -0x30(%rbp)
testl %eax, %eax
je 0x677b
jmp 0x675c
movl -0x30(%rbp), %eax
subl $0x1, %eax
je 0x67ef
jmp 0x676a
movl -0x30(%rbp), %eax
subl $0x2, %eax
je 0x681d
jmp 0x6862
movzbl -0x2b(%rbp), %eax
cmpl $0x6, %eax
jne 0x67c4
movb -0x19(%rbp), %al
movb %al, -0x39(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2, %rdi
callq 0x6130
movq -0x38(%rbp), %rdi
movw %ax, %cx
movb -0x39(%rbp), %al
movzwl %cx, %ecx
movq -0x28(%rbp), %r8
movl $0x2, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0x6890
movq $0x4, -0x8(%rbp)
jmp 0x6886
movq -0x38(%rbp), %rdi
movzbl -0x2b(%rbp), %esi
addl $0x3, %esi
movb -0x19(%rbp), %al
movq -0x28(%rbp), %r8
xorl %ecx, %ecx
andb $0x1, %al
movzbl %al, %edx
callq 0x6890
movq $0x2, -0x8(%rbp)
jmp 0x6886
movq -0x38(%rbp), %rdi
movzbl -0x2b(%rbp), %esi
addl $0x3, %esi
movb -0x19(%rbp), %al
movq -0x18(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
movq -0x28(%rbp), %r8
andb $0x1, %al
movzbl %al, %edx
callq 0x6890
movq $0x3, -0x8(%rbp)
jmp 0x6886
movzbl -0x2b(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x40(%rbp)
movb -0x19(%rbp), %al
movb %al, -0x3a(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2, %rdi
callq 0x6130
movq -0x38(%rbp), %rdi
movl -0x40(%rbp), %esi
movw %ax, %cx
movb -0x3a(%rbp), %al
movswl %cx, %ecx
movq -0x28(%rbp), %r8
andb $0x1, %al
movzbl %al, %edx
callq 0x6890
movq $0x4, -0x8(%rbp)
jmp 0x6886
movq -0x38(%rbp), %rdi
movb -0x19(%rbp), %al
movzbl -0x2b(%rbp), %ecx
xorl %esi, %esi
xorl %edx, %edx
movl %edx, %r8d
andb $0x1, %al
movzbl %al, %edx
callq 0x6890
movq $0x2, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: 7shi[P]8086run/v1/main.cpp
// Function: Operand::regrm(Operand*, unsigned char*, bool, bool, SReg*)
inline size_t regrm(Operand *opr, uint8_t *p, bool dir, bool w, SReg *seg) {
        if (dir) {
            set(Reg, w, (p[1] >> 3) & 7, NULL);
            return opr->modrm(p, w, seg);
        }
        opr->set(Reg, w, (p[1] >> 3) & 7, NULL);
        return modrm(p, w, seg);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, -0x21(%rbp)
je 0x6be9
movq -0x38(%rbp), %rdi
movb -0x22(%rbp), %al
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
sarl $0x3, %ecx
andl $0x7, %ecx
xorl %esi, %esi
xorl %edx, %edx
movl %edx, %r8d
andb $0x1, %al
movzbl %al, %edx
callq 0x6890
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb -0x22(%rbp), %al
movq -0x30(%rbp), %rcx
andb $0x1, %al
movzbl %al, %edx
callq 0x6710
movq %rax, -0x8(%rbp)
jmp 0x6c2c
movq -0x18(%rbp), %rdi
movb -0x22(%rbp), %al
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
sarl $0x3, %ecx
andl $0x7, %ecx
xorl %esi, %esi
xorl %edx, %edx
movl %edx, %r8d
andb $0x1, %al
movzbl %al, %edx
callq 0x6890
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movb -0x22(%rbp), %al
movq -0x30(%rbp), %rcx
andb $0x1, %al
movzbl %al, %edx
callq 0x6710
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 7shi[P]8086run/v1/main.cpp
// Function: setf(unsigned short)
inline void setf(uint16_t flags) {
    CF = flags & 0x001;
    PF = flags & 0x004;
    AF = flags & 0x010;
    ZF = flags & 0x040;
    SF = flags & 0x080;
    TF = flags & 0x100;
    IF = flags & 0x200;
    DF = flags & 0x400;
    OF = flags & 0x800;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x1245c8(%rip)     # 0x12b228
movzwl -0x2(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x1245b2(%rip)     # 0x12b227
movzwl -0x2(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x12459c(%rip)     # 0x12b226
movzwl -0x2(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x124586(%rip)     # 0x12b225
movzwl -0x2(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x12456e(%rip)     # 0x12b224
movzwl -0x2(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x124556(%rip)     # 0x12b223
movzwl -0x2(%rbp), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x12453e(%rip)     # 0x12b222
movzwl -0x2(%rbp), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x124526(%rip)     # 0x12b221
movzwl -0x2(%rbp), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x12450e(%rip)     # 0x12b220
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 7shi[P]8086run/v1/main.cpp
// Function: Operand::loadf(SReg*)
inline uint16_t loadf(SReg *seg) {
        uint8_t *p = ptr();
        if (!p) return u();
        *seg = read16(p + 2);
        return read16(p);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x74b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x72a7
movq -0x28(%rbp), %rdi
callq 0x72e0
movw %ax, -0x2(%rbp)
jmp 0x72cd
movq -0x20(%rbp), %rdi
addq $0x2, %rdi
callq 0x6130
movq -0x18(%rbp), %rdi
movzwl %ax, %esi
callq 0x6180
movq -0x20(%rbp), %rdi
callq 0x6130
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 7shi[P]8086run/v1/main.cpp
// Function: Operand::u() const
inline int u() const {
        if (type == Reg) return w ? r[v] : *r8[v];
        uint8_t *p = ptr();
        if (!p) return v;
        return w ? read16(p) : *p;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, (%rax)
jne 0x733c
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x731b
movq -0x20(%rbp), %rax
movslq 0x8(%rax), %rcx
leaq 0x123ebe(%rip), %rax    # 0x12b1d0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x24(%rbp)
jmp 0x7334
movq -0x20(%rbp), %rax
movslq 0x8(%rax), %rcx
leaq 0x123eb6(%rip), %rax    # 0x12b1e0
movq (%rax,%rcx,8), %rax
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7387
movq -0x20(%rbp), %rdi
callq 0x74b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x735c
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x7387
movq -0x20(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x7377
movq -0x18(%rbp), %rdi
callq 0x6130
movzwl %ax, %eax
movl %eax, -0x28(%rbp)
jmp 0x7381
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 7shi[P]8086run/v1/main.cpp
// Function: Disk::open(char const*)
bool open(const char *img) {
        if (!(f = fopen(img, "r+b"))) return false;
        struct stat st;
        fstat(fileno(f), &st);
        switch (st.st_size / 1024) {
            case 360: // 2D
                type = 1, c = 40, h = 2, s = 9;
                break;
            case 720: // 2DD
                type = 3, c = 80, h = 2, s = 9;
                break;
            default: // 2HD
                type = 4, c = 80, h = 2, s = 18;
                break;
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x13a4(%rip), %rsi      # 0x875d
callq 0x10e0
movq -0xb0(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x73d7
movb $0x0, -0x1(%rbp)
jmp 0x74a0
movq -0xb0(%rbp), %rax
movq (%rax), %rdi
callq 0x10b0
movl %eax, %edi
leaq -0xa8(%rbp), %rsi
callq 0x1170
movq -0x78(%rbp), %rax
movq %rax, %rcx
addq $0x3ff, %rcx            # imm = 0x3FF
testq %rax, %rax
cmovsq %rcx, %rax
sarq $0xa, %rax
movq %rax, -0xb8(%rbp)
subq $0x168, %rax            # imm = 0x168
je 0x742f
jmp 0x741e
movq -0xb8(%rbp), %rax
subq $0x2d0, %rax            # imm = 0x2D0
je 0x7454
jmp 0x7479
movq -0xb0(%rbp), %rax
movl $0x1, 0x8(%rax)
movl $0x28, 0xc(%rax)
movl $0x2, 0x10(%rax)
movl $0x9, 0x14(%rax)
jmp 0x749c
movq -0xb0(%rbp), %rax
movl $0x3, 0x8(%rax)
movl $0x50, 0xc(%rax)
movl $0x2, 0x10(%rax)
movl $0x9, 0x14(%rax)
jmp 0x749c
movq -0xb0(%rbp), %rax
movl $0x4, 0x8(%rax)
movl $0x50, 0xc(%rax)
movl $0x2, 0x10(%rax)
movl $0x12, 0x14(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: liujan[P]randomforest/Node.cpp
// Function: Node::Node()
Node::Node(){
    left = NULL;
    right = NULL;
    sum = 0;
    memset(num, 0, sizeof(num));
    attribute = 0;
    value = 0;
    depth = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x90, %rdi
callq 0x26b0
movq -0x10(%rbp), %rdi
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl $0x0, 0x20(%rdi)
addq $0x24, %rdi
xorl %esi, %esi
movl $0x68, %edx
callq 0x20f0
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movl $0x0, 0x8c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)