LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: bendem[P]DiskGraph/src/table.cpp
// Function: Table::getLine[abi:cxx11](unsigned int) const
string Table::getLine(unsigned column) const {
    ostringstream ss;
    for(unsigned i = 0; i < this->columns; ++i) {
        ss << ' ';
        ss << this->lines[column][i];
        int diff = (int) (this->line_sizes[i] - this->lines[column][i].length());
        if(diff > 0) {
            for (; diff != 0; --diff) {
                ss << ' ';
            }
        }
    }
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b0(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x2210
movl $0x0, -0x194(%rbp)
movq -0x1b0(%rbp), %rcx
movl -0x194(%rbp), %eax
cmpl (%rcx), %eax
jae 0x8639
leaq -0x190(%rbp), %rdi
movl $0x20, %esi
callq 0x2200
jmp 0x8530
movq -0x1b0(%rbp), %rdi
addq $0x8, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8b30
movq %rax, %rdi
movl -0x194(%rbp), %eax
movl %eax, %esi
callq 0x7930
movq %rax, %rsi
leaq -0x190(%rbp), %rdi
callq 0x2170
jmp 0x8566
movq -0x1b0(%rbp), %rdi
addq $0x20, %rdi
movl -0x194(%rbp), %eax
movl %eax, %esi
callq 0x8a50
movq -0x1b0(%rbp), %rdi
movl (%rax), %eax
movq %rax, -0x1c8(%rbp)
addq $0x8, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x8b30
movq %rax, %rdi
movl -0x194(%rbp), %eax
movl %eax, %esi
callq 0x7930
movq %rax, %rdi
callq 0x2270
movq %rax, %rcx
movq -0x1c8(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x1a8(%rbp)
cmpl $0x0, -0x1a8(%rbp)
jle 0x8623
jmp 0x85d2
cmpl $0x0, -0x1a8(%rbp)
je 0x8621
leaq -0x190(%rbp), %rdi
movl $0x20, %esi
callq 0x2200
jmp 0x85ee
jmp 0x85f0
movl -0x1a8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1a8(%rbp)
jmp 0x85d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x2050
jmp 0x866a
jmp 0x8623
jmp 0x8625
movl -0x194(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x194(%rbp)
jmp 0x8508
movq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x21c0
jmp 0x864e
leaq -0x190(%rbp), %rdi
callq 0x2050
movq -0x1b8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: bendem[P]DiskGraph/src/table.cpp
// Function: Table::toString[abi:cxx11]() const
string Table::toString() const {
    ostringstream ss;

    for(unsigned i = 0; i < this->columns; ++i) {
        ss << getLine(i) << endl;
    }

    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x2210
movl $0x0, -0x18c(%rbp)
movq -0x1c8(%rbp), %rcx
movl -0x18c(%rbp), %eax
cmpl (%rcx), %eax
jae 0x8777
movq -0x1c8(%rbp), %rsi
movl -0x18c(%rbp), %edx
leaq -0x1b0(%rbp), %rdi
callq 0x84c0
jmp 0x86f5
leaq -0x188(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x2170
movq %rax, -0x1e0(%rbp)
jmp 0x8711
movq -0x1e0(%rbp), %rdi
movq 0x6879(%rip), %rsi      # 0xef98
callq 0x21e0
jmp 0x8726
leaq -0x1b0(%rbp), %rdi
callq 0x2368
movl -0x18c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18c(%rbp)
jmp 0x86c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x87a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x2368
jmp 0x87a8
movq -0x1d8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x21c0
jmp 0x878c
leaq -0x188(%rbp), %rdi
callq 0x2050
movq -0x1d0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0x2050
movq -0x1b8(%rbp), %rdi
callq 0x2300
// File: suyash[P]chan/examples/raw_pointers.cc
// Function: consumer(chan::read_chan<int>*)
void consumer(chan::read_chan<int>* ch) {
	for (int i = 0 ; i < 100 ; i++) {
		int x = 0;
		ch->recv(x);
		printf("r %d\n", x);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0x23d9
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x26f0
movl -0x10(%rbp), %esi
leaq 0x1c43(%rip), %rdi      # 0x400a
movb $0x0, %al
callq 0x2030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x23a3
addq $0x10, %rsp
popq %rbp
retq
nop
// File: suyash[P]chan/examples/raw_pointers.cc
// Function: main
int main() {
	// auto ch = new chan::unbuffered_chan<int>();
	chan::unbuffered_chan<int> ch;

	std::thread t1(producer, &ch);
	std::thread t2(consumer, &ch);

	t1.join();
	t2.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
leaq -0x100(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x2720
movq -0x138(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0xd3(%rip), %rsi       # 0x2340
leaq -0x108(%rbp), %rdi
leaq -0x110(%rbp), %rdx
callq 0x2790
jmp 0x2428
leaq -0x100(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0xad(%rip), %rsi       # 0x2390
leaq -0x128(%rbp), %rdi
leaq -0x130(%rbp), %rdx
callq 0x2850
jmp 0x2452
leaq -0x108(%rbp), %rdi
callq 0x2140
jmp 0x2460
leaq -0x128(%rbp), %rdi
callq 0x2140
jmp 0x246e
leaq -0x128(%rbp), %rdi
callq 0x2910
leaq -0x108(%rbp), %rdi
callq 0x2910
leaq -0x100(%rbp), %rdi
callq 0x2940
xorl %eax, %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x24ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x24e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x2910
leaq -0x108(%rbp), %rdi
callq 0x2910
leaq -0x100(%rbp), %rdi
callq 0x2940
movq -0x118(%rbp), %rdi
callq 0x2160
nopw (%rax,%rax)
// File: diegofilbal[P]YourJam/src/lista.cpp
// Function: Lista::Lista(Lista const&)
Lista::Lista(Lista const &lista){

    // Inicializa os atributos
    this->head = nullptr;
    this->tail = head;
    this->tamanho = 0;

    // Chama a função sobrecarregada de inserção para copiar as músicas
    insereFim(lista);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq $0x0, (%rdi)
movq (%rdi), %rax
movq %rax, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq -0x10(%rbp), %rsi
callq 0x24e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: diegofilbal[P]YourJam/src/lista.cpp
// Function: Lista::~Lista()
Lista::~Lista(){

    if(tamanho == 0){ //  Verifica se a lista já não está vazia
        return;
    }else{
        // Lista não está vazia

        Node* atual = head; // Ponteiro do node que vai percorrer a lista

        while (atual != nullptr){ // Percorre a lista, desalocando cada posição ainda existente
            Node* temp = atual->next;
            delete atual->musica;
            delete atual;
            atual = temp;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x10(%rax)
jne 0x273c
jmp 0x27a9
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x27a7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x277d
movq -0x28(%rbp), %rdi
callq 0x135f0
movq -0x28(%rbp), %rdi
callq 0x2120
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x279d
movq -0x30(%rbp), %rdi
callq 0x136e0
movq -0x30(%rbp), %rdi
callq 0x2120
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2747
jmp 0x27a9
addq $0x30, %rsp
popq %rbp
retq
nop
// File: diegofilbal[P]YourJam/src/lista.cpp
// Function: Lista::busca(Musica) const
Node* Lista::busca(Musica musica) const{

    Node *atual = head; // Objeto a receber os elementos da lista durante as iterações do laço

    while(atual != nullptr){
        if(atual->musica->getNome() == musica.getNome() && atual->musica->getArtista() == musica.getArtista()){
            // Achou a música no sistema
            return atual; // Retorna o ponteiro para o node que armazena a música buscada
        }else{
            atual = atual->next; // Pula para o pŕoximo node
        }
    }

    return nullptr; // A música não está no sistema
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2b87
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x13620
movq -0xc8(%rbp), %rsi
movb $0x0, -0x91(%rbp)
movb $0x0, -0xb9(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x13620
jmp 0x2a50
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4020
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xc9(%rbp)
jne 0x2a6e
jmp 0x2abf
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x90(%rbp), %rdi
callq 0x13670
jmp 0x2a83
movq -0xc8(%rbp), %rsi
movb $0x1, -0x91(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x13670
jmp 0x2a9f
movb $0x1, -0xb9(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x4020
movb %al, -0xc9(%rbp)
movb -0xc9(%rbp), %al
movb %al, -0xca(%rbp)
testb $0x1, -0xb9(%rbp)
jne 0x2ad6
jmp 0x2ae2
leaq -0xb8(%rbp), %rdi
callq 0x20b0
testb $0x1, -0x91(%rbp)
jne 0x2aed
jmp 0x2af9
leaq -0x90(%rbp), %rdi
callq 0x20b0
leaq -0x60(%rbp), %rdi
callq 0x20b0
leaq -0x40(%rbp), %rdi
callq 0x20b0
movb -0xca(%rbp), %al
testb $0x1, %al
jne 0x2b17
jmp 0x2b76
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2b6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2b62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
testb $0x1, -0x91(%rbp)
jne 0x2b54
jmp 0x2b60
leaq -0x90(%rbp), %rdi
callq 0x20b0
jmp 0x2b62
leaq -0x60(%rbp), %rdi
callq 0x20b0
leaq -0x40(%rbp), %rdi
callq 0x20b0
jmp 0x2b9c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2a15
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: diegofilbal[P]YourJam/src/lista.cpp
// Function: Lista::buscaMusicaPos(int) const
Musica* Lista::buscaMusicaPos(int posicao) const{

    if(posicao >= 0 && posicao < tamanho){ // Verifica se a posição é válida

        Node *temp = head; // Objeto a receber os elementos da lista durante as iterações do laço

        for(int i = 0; i < posicao; i++){ // Percorre a lista até chegar no elemento desejado
            temp = temp->next;
        }
        return temp->musica; // Retorna o ponteiro para a música
    }

    return nullptr; // Posição inválida
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x3013
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x3013
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3006
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2fe7
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x301b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: diegofilbal[P]YourJam/src/lista.cpp
// Function: Lista::remove(int)
bool Lista::remove(int posicao){

    if(posicao >= 0 && posicao < tamanho){

        Node *atual = head;
        Node *anterior = nullptr;

        for(int i = 0; i < posicao; i++){ // Percorre a lista até chegar no elemento a ser removido
            anterior = atual;
            atual = atual->next;
        }

        if(atual == head){ // Verifica se o elemento a ser removida é o primeiro
            head = head->next;
        }else{
            if(atual == tail){ // Verifica se o elemento a ser removida é o último
                anterior->next = nullptr;
                tail = anterior; // Atualiza o tail
            }else{
                anterior->next = atual->next;
            }
        }
        
        tamanho--; // Decrementa o tamanho da lista

        // Libera os espaços alocados para a Música e para o Node
        delete atual->musica;
        delete atual;

        return true; // Retorna código de sucesso
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x356f
movq -0x38(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x356f
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x34c2
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x349b
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq (%rcx), %rax
jne 0x34df
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
jmp 0x3519
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x8(%rcx), %rax
jne 0x3507
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq $0x0, 0x8(%rcx)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x3517
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3519
movq -0x38(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x3549
movq -0x40(%rbp), %rdi
callq 0x135f0
movq -0x40(%rbp), %rdi
callq 0x2120
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x3569
movq -0x48(%rbp), %rdi
callq 0x136e0
movq -0x48(%rbp), %rdi
callq 0x2120
movb $0x1, -0x1(%rbp)
jmp 0x3573
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: diegofilbal[P]YourJam/src/lista.cpp
// Function: Lista::buscaPos(int) const
Node* Lista::buscaPos(int posicao) const{

    if(posicao >= 0 && posicao < tamanho){ // Verifica se a posição é válida

        Node *temp = head; // Objeto a receber os elementos da lista durante as iterações do laço

        for(int i = 0; i < posicao; i++){ // Percorre a lista até chegar no elemento desejado
            temp = temp->next;
        }

        return temp; // Retorna o ponteiro para o Node
    }

    return nullptr; // Posição inválida
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x3a60
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x3a60
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3a56
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3a37
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a68
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: diegofilbal[P]YourJam/src/lista.cpp
// Function: Lista::operator>>(Node*&)
void Lista::operator>>(Node *&node){

    if(!tamanho){ // Verifica se a lista está vazia
        node = nullptr;

    }else{
        // Extrai o último elemento da lista para o node
        node->musica->setNome(tail->musica->getNome());
        node->musica->setArtista(tail->musica->getArtista());
        node->next = tail->next;
        
        remove(tamanho-1); // Remove o último elemento da lista
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpl $0x0, 0x10(%rax)
jne 0x3cd1
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x3da5
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, -0x78(%rbp)
movq 0x8(%rax), %rax
movq (%rax), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x13620
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x13650
jmp 0x3d06
leaq -0x30(%rbp), %rdi
callq 0x20b0
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, -0x88(%rbp)
movq 0x8(%rax), %rax
movq (%rax), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x13670
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x136a0
jmp 0x3d4a
leaq -0x60(%rbp), %rdi
callq 0x20b0
movq -0x68(%rbp), %rdi
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movl 0x10(%rdi), %esi
subl $0x1, %esi
callq 0x3450
jmp 0x3da5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20b0
jmp 0x3dae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x20b0
jmp 0x3dae
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2200
nopw (%rax,%rax)
// File: diegofilbal[P]YourJam/src/lista.cpp
// Function: Lista::imprime() const
void Lista::imprime() const{

    Node *temp = head;

    for(int i = 0; i < tamanho; i++){ // Percorre os elementos da lista e imprime um a um
        std::cout << i+1 << ". " << temp->musica->getNome() << " - " << temp->musica->getArtista() << std:: endl;
        temp = temp->next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x70(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x3fa9
movl -0x14(%rbp), %esi
incl %esi
movq 0x1611f(%rip), %rdi     # 0x19fd0
callq 0x21f0
movq %rax, %rdi
leaq 0x11157(%rip), %rsi     # 0x15017
callq 0x2130
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x13620
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x2110
movq %rax, -0x78(%rbp)
jmp 0x3ef6
movq -0x78(%rbp), %rdi
leaq 0x11119(%rip), %rsi     # 0x1501a
callq 0x2130
movq %rax, -0x90(%rbp)
jmp 0x3f0f
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x68(%rbp), %rdi
callq 0x13670
jmp 0x3f21
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2110
movq %rax, -0x98(%rbp)
jmp 0x3f3a
movq -0x98(%rbp), %rdi
movq 0x16070(%rip), %rsi     # 0x19fb8
callq 0x2150
jmp 0x3f4f
leaq -0x68(%rbp), %rdi
callq 0x20b0
leaq -0x38(%rbp), %rdi
callq 0x20b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3e95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3f9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x20b0
leaq -0x38(%rbp), %rdi
callq 0x20b0
jmp 0x3fb2
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2200
nopl (%rax,%rax)
// File: diegofilbal[P]YourJam/src/playlist.cpp
// Function: Playlist::Playlist(Playlist const&)
Playlist::Playlist(Playlist const &playlist){
    
    // Inicializa os atributos 
    this->playlist = new Lista;
    this->nome = playlist.nome;
    this->proxima = playlist.proxima;

    // Chama a função sobrecarregada de inserção para copiar as músicas
    insereFim(playlist);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x21b0
movl $0x18, %edi
callq 0x2140
movq %rax, -0x28(%rbp)
jmp 0x137b4
movq -0x28(%rbp), %rdi
callq 0x2470
jmp 0x137bf
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, 0x20(%rdi)
movq -0x10(%rbp), %rsi
callq 0x2040
jmp 0x137d6
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x28(%rdi)
movq -0x10(%rbp), %rsi
callq 0x13830
jmp 0x137ef
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x13818
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2120
movq -0x38(%rbp), %rdi
callq 0x20b0
movq -0x18(%rbp), %rdi
callq 0x2200
nopw (%rax,%rax)
// File: diegofilbal[P]YourJam/src/playlist.cpp
// Function: Playlist::remove(Playlist const&)
int Playlist::remove(Playlist const &playlist){

    int diferenca = this->playlist->getTamanho(); // Armazena o tamanho inicial da playlist

    this->playlist->remove(*playlist.getLista()); // Remove da playlist local as músicas presentes na playlist recebida

    diferenca -= this->playlist->getTamanho(); // Calcula quantas músicas foram removidas

    return diferenca; // Retorna o número de músicas que foram removidas
}

// 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)
movq 0x20(%rax), %rdi
callq 0x2f90
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x139a0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x3580
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2f90
movl %eax, %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: diegofilbal[P]YourJam/src/playlist.cpp
// Function: Playlist::moveMusica(int, int)
void Playlist::moveMusica(int pos_inicial, int pos_final){

    Musica musica;// Variável a receber as informações da musica a ser movida

    // Copia as informações da música a ser movida
    musica.setNome(playlist->buscaMusicaPos(pos_inicial)->getNome());
    musica.setArtista(playlist->buscaMusicaPos(pos_inicial)->getArtista());

    playlist->remove(pos_inicial); // Remove a música da posição atual
    playlist->inserePos(pos_final, musica); // Insere a música na posição para qual o usuário deseja movê-la
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x135c0
movq -0xf0(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x2fb0
movq %rax, -0xe8(%rbp)
jmp 0x13b35
movq -0xe8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x13620
jmp 0x13b47
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x13650
jmp 0x13b56
leaq -0x70(%rbp), %rdi
callq 0x20b0
movq -0xf0(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x2fb0
movq %rax, -0xf8(%rbp)
jmp 0x13b7b
movq -0xf8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x13670
jmp 0x13b90
leaq -0x50(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x136a0
jmp 0x13ba2
leaq -0xa0(%rbp), %rdi
callq 0x20b0
movq -0xf0(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x3450
jmp 0x13bc3
movq -0xf0(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x108(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xfc(%rbp)
leaq -0xe0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3fc0
jmp 0x13bf0
movl -0xfc(%rbp), %esi
movq -0x108(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
callq 0x3030
jmp 0x13c0b
leaq -0xe0(%rbp), %rdi
callq 0x135f0
leaq -0x50(%rbp), %rdi
callq 0x135f0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x13c80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20b0
jmp 0x13c80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x20b0
jmp 0x13c80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x135f0
leaq -0x50(%rbp), %rdi
callq 0x135f0
movq -0x78(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: diegofilbal[P]YourJam/src/playlist.cpp
// Function: Playlist::proxMusica()
Musica* Playlist::proxMusica(){

    Node *node = playlist->buscaPos(proxima); // Recebe o node que armazena a próxima música a ser tocada

    if(node != nullptr){ // Verifica se ainda há música para tocar
        proxima++;
        return node->musica; // Retorna a música 
    }

    return nullptr; // A reprodução das músicas chegou ao fim
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x20(%rax), %rdi
movl 0x28(%rax), %esi
callq 0x3a00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13ce5
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13ced
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: diegofilbal[P]YourJam/src/playlist.cpp
// Function: Playlist::operator+(Playlist const&) const
Playlist* Playlist::operator+(Playlist const &playlist) const{

    // Insere a primeira playlist usando o método sobrecarregado de inserção
    Playlist *playlist_final = new Playlist(*this);

    // Insere a segunda playlist usando o método sobrecarregado de inserção
    playlist_final->insereFim(playlist);

    // Retorna o ponteiro de playlist
    return playlist_final;
}

// 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 $0x30, %edi
callq 0x2140
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x13780
jmp 0x13d37
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13830
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2120
movq -0x20(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: diegofilbal[P]YourJam/src/playlist.cpp
// Function: Playlist::operator+(Musica const&) const
Playlist* Playlist::operator+(Musica const &musica) const{

    // Insere a playlist local usando o método sobrecarregado de inserção
    Playlist *playlist_final = new Playlist(*this);

    // Insera a música na última posição da playlist
    playlist_final->insereFim(musica);

    // Retorna o ponteiro de playlist
    return playlist_final;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x30, %edi
callq 0x2140
movq -0x78(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x13780
jmp 0x13dba
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3fc0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x13930
jmp 0x13df0
leaq -0x68(%rbp), %rdi
callq 0x135f0
movq -0x18(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2120
jmp 0x13e32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x135f0
movq -0x20(%rbp), %rdi
callq 0x2200
nopl (%rax,%rax)
// File: diegofilbal[P]YourJam/src/playlist.cpp
// Function: Playlist::operator-(Playlist const&) const
Playlist* Playlist::operator-(Playlist const &playlist) const{

    // Insere todas as músicas da playlist local utilizando o método sobrecarregado de inserção
    Playlist* playlist_final = new Playlist(*this);

    // Armazena as músicas para a comparação durante o laço
    Musica musica;

    // Remove da playlist final as músicas que estão na playlist recebid apor parâmetro
    for(int i = playlist_final->playlist->getTamanho() - 1; i >= 0; i--){

        musica = *playlist_final->getLista()->buscaMusicaPos(i);

        if(playlist.getLista()->buscaMusica(musica)){ // Verifica se a música está nas duas playlists
            playlist_final->remove(i); // Remove a música
        }
    }

    return playlist_final;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movl $0x30, %edi
callq 0x2140
movq -0xc0(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
callq 0x13780
jmp 0x13e83
movq -0xb8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x135c0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2f90
movl %eax, -0xc4(%rbp)
jmp 0x13eac
movl -0xc4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jl 0x13fb9
movq -0x18(%rbp), %rdi
callq 0x139a0
movq %rax, -0xd0(%rbp)
jmp 0x13ed4
movq -0xd0(%rbp), %rdi
movl -0x6c(%rbp), %esi
callq 0x2fb0
movq %rax, -0xd8(%rbp)
jmp 0x13eec
movq -0xd8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x13580
jmp 0x13efe
movq -0x10(%rbp), %rdi
callq 0x139a0
movq %rax, -0xe0(%rbp)
jmp 0x13f10
leaq -0xb0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3fc0
jmp 0x13f22
movq -0xe0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x3840
movq %rax, -0xe8(%rbp)
jmp 0x13f3e
leaq -0xb0(%rbp), %rdi
callq 0x135f0
movq -0xe8(%rbp), %rax
cmpq $0x0, %rax
je 0x13fa9
movq -0x18(%rbp), %rdi
movl -0x6c(%rbp), %esi
callq 0x13a50
jmp 0x13f65
jmp 0x13fa9
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2120
jmp 0x13fe6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x13fdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x135f0
jmp 0x13fdd
jmp 0x13fab
movl -0x6c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x13eb8
movq -0x18(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x135f0
movq -0xf0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x135f0
movq -0x20(%rbp), %rdi
callq 0x2200
nop
// File: diegofilbal[P]YourJam/src/playlist.cpp
// Function: Playlist::operator>>(Musica*&)
void Playlist::operator>>(Musica *&musica){

    if(!playlist->getTamanho()){ // Verifica se a lista está vazia
        musica = nullptr;

    }else{
        // Extrai o último elemento da lista para e armazena em música
        musica->setNome(playlist->buscaMusicaPos(playlist->getTamanho() - 1)->getNome());
        musica->setArtista(playlist->buscaMusicaPos(playlist->getTamanho() - 1)->getArtista());

        remove(playlist->getTamanho() - 1); // Remove o último elemento da lista
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x20(%rax), %rdi
callq 0x2f90
cmpl $0x0, %eax
jne 0x14319
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0x14418
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x78(%rbp)
movq 0x20(%rax), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2f90
movq -0x80(%rbp), %rdi
movl %eax, %esi
decl %esi
callq 0x2fb0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x13620
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x13650
jmp 0x14361
leaq -0x30(%rbp), %rdi
callq 0x20b0
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, -0x90(%rbp)
movq 0x20(%rax), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2f90
movq -0x98(%rbp), %rdi
movl %eax, %esi
decl %esi
callq 0x2fb0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x13670
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x136a0
jmp 0x143c4
leaq -0x60(%rbp), %rdi
callq 0x20b0
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2f90
movq -0x68(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
callq 0x13a50
jmp 0x14418
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20b0
jmp 0x14421
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x20b0
jmp 0x14421
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2200
nopw (%rax,%rax)
// File: diegofilbal[P]YourJam/src/playlist.cpp
// Function: Playlist::imprime(Node*, int) const
void Playlist::imprime(Node* const node, int contador) const{
    if(node == nullptr){ // Verifica se a lista já chegou ao fim
        return;
    }
    std::cout << contador << ". " << node->musica->getNome() << " - " << node->musica->getArtista() << std::endl;
    imprime(node->next, contador + 1); // Faz a chamada recursiva para a immressão do próximo node 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x144fa
jmp 0x145cb
movl -0x14(%rbp), %esi
movq 0x5acc(%rip), %rdi      # 0x19fd0
callq 0x21f0
movq %rax, %rdi
leaq 0xb04(%rip), %rsi       # 0x15017
callq 0x2130
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x13620
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x2110
movq %rax, -0x78(%rbp)
jmp 0x14549
movq -0x78(%rbp), %rdi
leaq 0xac6(%rip), %rsi       # 0x1501a
callq 0x2130
movq %rax, -0x90(%rbp)
jmp 0x14562
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x68(%rbp), %rdi
callq 0x13670
jmp 0x14574
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2110
movq %rax, -0x98(%rbp)
jmp 0x1458d
movq -0x98(%rbp), %rdi
movq 0x5a1d(%rip), %rsi      # 0x19fb8
callq 0x2150
jmp 0x145a2
leaq -0x68(%rbp), %rdi
callq 0x20b0
leaq -0x38(%rbp), %rdi
callq 0x20b0
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x144d0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x145f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x20b0
leaq -0x38(%rbp), %rdi
callq 0x20b0
movq -0x40(%rbp), %rdi
callq 0x2200
nopl (%rax)
// File: diegofilbal[P]YourJam/src/playlist.cpp
// Function: Playlist::setLista(Lista*)
void Playlist::setLista(Lista* const lista){

    int tamanho_pl = playlist->getTamanho(); // Recebe o tamanho da playlist a ser redefinida

    for (int i = 0; i < tamanho_pl; i++){ // Remove todos os elementos antigos
        playlist->remove(0);
    }

    if(lista != nullptr){ // Verifica se o ponteiro não é nulo
        tamanho_pl = lista->getTamanho(); // Recebe o tamanho da nova lista

        for (int i = 0; i < tamanho_pl; i++){ // Insere todos os elementos da nova lista na lista original
            playlist->insereFim(*lista->buscaMusicaPos(i));
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0x20(%rax), %rdi
callq 0x2f90
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x14660
movq -0x78(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0x3450
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1463e
cmpq $0x0, -0x10(%rbp)
je 0x146f0
movq -0x10(%rbp), %rdi
callq 0x2f90
movl %eax, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x146ee
movq -0x78(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2fb0
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3fc0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x2bb0
jmp 0x146c3
leaq -0x60(%rbp), %rdi
callq 0x135f0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1467e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x135f0
jmp 0x146f9
jmp 0x146f0
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::string_to_kmer_val(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static uint64_t string_to_kmer_val(string s) {
		uint64_t val = 0;
		for (auto c : s)
			val = (val << 2) | ((uint64_t)(base_from_char.at(c)));
		return val;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3250
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3130
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xdd60
testb $0x1, %al
jne 0x39f5
jmp 0x3a3a
leaq -0x20(%rbp), %rdi
callq 0xde40
movb (%rax), %al
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rax
shlq $0x2, %rax
movq %rax, -0x38(%rbp)
leaq 0x368a2(%rip), %rdi     # 0x3a2b8
leaq -0x29(%rbp), %rsi
callq 0xdda0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl (%rcx), %ecx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xde60
jmp 0x39e2
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: ZNK3dna4kmercvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv
kmer::operator string() const {
		string s;
		for (auto i = 1; i < len+1; i++)
			s = s + base_to_char.at((base)((val >> (2*(len - i))) & BITMASK(2)));
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x33c0
movl $0x1, -0x18(%rbp)
movq -0x58(%rbp), %rcx
movl -0x18(%rbp), %eax
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3b11
movq -0x58(%rbp), %rcx
movq 0x8(%rcx), %rax
movl (%rcx), %ecx
movl -0x18(%rbp), %edx
subl %edx, %ecx
addb %cl, %cl
shrq %cl, %rax
andl $0x3, %eax
movl %eax, -0x3c(%rbp)
leaq 0x36834(%rip), %rdi     # 0x3a2e8
leaq -0x3c(%rbp), %rsi
callq 0xdba0
movq %rax, -0x70(%rbp)
jmp 0x3ac3
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rax
movsbl (%rax), %edx
leaq -0x38(%rbp), %rdi
callq 0xdb20
jmp 0x3ad9
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3370
leaq -0x38(%rbp), %rdi
callq 0x3150
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3a83
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3150
jmp 0x3b2e
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3b24
movq -0x68(%rbp), %rdi
callq 0x3150
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3480
nopw (%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::operator-(dna::kmer)
kmer operator-(kmer k) {
		uint64_t val = k.val;
		val =
			(val >> 32) |
			(val << 32);
		val =
			((val >> 16) & 0x0000ffff0000ffff) |
			((val << 16) & 0xffff0000ffff0000);
		val =
			((val >> 8) & 0x00ff00ff00ff00ff) |
			((val << 8) & 0xff00ff00ff00ff00);
		val =
			((val >> 4) & 0x0f0f0f0f0f0f0f0f) |
			((val << 4) & 0xf0f0f0f0f0f0f0f0);
		val =
			((val >> 2) & 0x3333333333333333) |
			((val << 2) & 0xcccccccccccccccc);
		val = ~val;
		val >>= 64-2*k.len;
		return kmer(k.len, val);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
rolq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, %rax
shrq $0x10, %rax
movabsq $0xffff0000ffff, %rdx   # imm = 0xFFFF0000FFFF
andq %rdx, %rax
shlq $0x10, %rcx
movabsq $-0xffff00010000, %rdx  # imm = 0xFFFF0000FFFF0000
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, %rax
shrq $0x8, %rax
movabsq $0xff00ff00ff00ff, %rdx # imm = 0xFF00FF00FF00FF
andq %rdx, %rax
shlq $0x8, %rcx
movabsq $-0xff00ff00ff0100, %rdx # imm = 0xFF00FF00FF00FF00
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, %rax
shrq $0x4, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rdx # imm = 0xF0F0F0F0F0F0F0F
andq %rdx, %rax
shlq $0x4, %rcx
movabsq $-0xf0f0f0f0f0f0f10, %rdx # imm = 0xF0F0F0F0F0F0F0F0
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, %rax
shrq $0x2, %rax
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
andq %rdx, %rax
movabsq $-0xccccccccccccccd, %rdx # imm = 0xF333333333333333
andq %rdx, %rcx
leaq (%rax,%rcx,4), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
notq %rax
movq %rax, -0x28(%rbp)
movb -0x20(%rbp), %cl
movq -0x28(%rbp), %rax
addb %cl, %cl
negb %cl
shrq %cl, %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %esi
movq -0x28(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x3840
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::operator>>(dna::kmer, dna::kmer)
kmer operator>>(kmer a, kmer b) {
		uint64_t val
			= ((b.val >> (2*a.len)) | (a.val << (2*(b.len - a.len))))
			& BITMASK(2*b.len);
		return kmer(b.len, val);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
shll %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq -0x18(%rbp), %rdx
movl -0x30(%rbp), %ecx
subl -0x20(%rbp), %ecx
shll %ecx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x30(%rbp), %eax
shll %eax
cmpl $0x40, %eax
jne 0x3ec6
movq $-0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x3edf
movl -0x30(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
andq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x30(%rbp), %esi
movq -0x38(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x3840
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::operator+(dna::kmer, dna::kmer)
kmer operator+(kmer a, kmer b) {
		int len = a.len + b.len;
		assert(len <= 32);
		uint64_t val = (a.val << (2*b.len)) | b.val;
		return kmer(len, val);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x20(%rbp), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x20, -0x34(%rbp)
jg 0x3f37
jmp 0x3f56
leaq 0x262a3(%rip), %rdi     # 0x2a1e1
leaq 0x26244(%rip), %rsi     # 0x2a189
movl $0x8a, %edx
leaq 0x2629a(%rip), %rcx     # 0x2a1eb
callq 0x3160
movq -0x18(%rbp), %rax
movb -0x30(%rbp), %cl
addb %cl, %cl
shlq %cl, %rax
movq -0x28(%rbp), %rcx
orq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x34(%rbp), %esi
movq -0x40(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x3840
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::period_divides(dna::kmer, unsigned long)
bool period_divides(kmer k, uint64_t periodicity)	{
		static const uint64_t multipliers[33] =
			{
				0,
				0x5555555555555555, // 1
				0x1111111111111111, // 2
				0x1041041041041041, // 3
				0x0101010101010101, // 4
				0x1004010040100401, // 5
				0x1001001001001001, // 6
				0x0100040010004001, // 7
				0x0001000100010001, // 8
				0x0040001000040001, // 9
				0x1000010000100001, // 10
				0x0000100000400001, // 11
				0x0001000001000001, // 12
				0x0010000004000001, // 13
				0x0100000010000001, // 14
				0x1000000040000001, // 15
				0x0000000100000001, // 16
				0x0000000400000001, // 17
				0x0000001000000001, // 18
				0x0000004000000001, // 19
				0x0000010000000001, // 20
				0x0000040000000001, // 21
				0x0000100000000001, // 22
				0x0000400000000001, // 23
				0x0001000000000001, // 24
				0x0004000000000001, // 25
				0x0010000000000001, // 26
				0x0040000000000001, // 27
				0x0100000000000001, // 28
				0x0400000000000001, // 29
				0x1000000000000001, // 30
				0x4000000000000001, // 31
				0x0000000000000001, // 32
			};
		uint64_t piece = k.val & BITMASK(2*periodicity);
		piece = piece * multipliers[periodicity];
		piece = piece & BITMASK(2*k.len);
		return piece == k.val;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
shlq %rax
cmpq $0x40, %rax
jne 0x4081
movq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4098
movq -0x18(%rbp), %rcx
shlq %rcx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
andq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
leaq 0x25fba(%rip), %rcx     # 0x2a070
imulq (%rcx,%rdx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %eax
shll %eax
cmpl $0x40, %eax
jne 0x40de
movq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x40f7
movl -0x10(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
andq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
sete %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::period(dna::kmer)
uint64_t period(kmer k) {
		for (int i = 1; i <= k.len; i++) {
			if (period_divides(k, i))
				return i;
		}
		abort();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x417b
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rdx
movl -0x28(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x4050
testb $0x1, %al
jne 0x4164
jmp 0x416e
movslq -0x14(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
jmp 0x4170
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4136
callq 0x3110
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::abundance(dna::canonical_kmer) const
uint64_t debruijn_graph::abundance(edge e) const {
		uint64_t o = get_occurences(e);
		if (o)
			return o - get_corrections(e);
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %esi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x44e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x44ca
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x48(%rbp), %esi
movq -0x40(%rbp), %rdx
callq 0x4520
movq %rax, %rcx
movq -0x58(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x44d2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::record_end(dna::canonical_kmer, dna::canonical_kmer)
void debruijn_graph::record_end(node n, edge e) {
		if (is_left_edge(n, e)) {
			record_left_end(n);
			//cout << "Begin node: " << string(n) << endl;
			//cout << "Begin edge: " <<  string(e) << endl;
		} else if (is_right_edge(n, e)) {
			record_right_end(n);
			//cout << "End node: " << string(n) << endl;
			//cout << "End edge: " <<  string(e) << endl;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x38(%rbp), %edi
movq -0x30(%rbp), %rsi
movl -0x48(%rbp), %edx
movq -0x40(%rbp), %rcx
callq 0x7a90
testb $0x1, %al
jne 0x4b51
jmp 0x4b76
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x58(%rbp), %esi
movq -0x50(%rbp), %rdx
callq 0x7970
jmp 0x4bda
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x68(%rbp), %edi
movq -0x60(%rbp), %rsi
movl -0x78(%rbp), %edx
movq -0x70(%rbp), %rcx
callq 0x7bf0
testb $0x1, %al
jne 0x4baf
jmp 0x4bd8
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x88(%rbp), %esi
movq -0x80(%rbp), %rdx
callq 0x7a00
jmp 0x4bda
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)