LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, -0x38(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x21d0
cmpl $0x0, (%rbx)
je 0x521f
movl %r15d, %eax
xorl %r12d, %r12d
leaq -0x1c0(%rbp), %r15
leaq -0x29(%rbp), %r14
leaq (%rax,%rax,2), %rax
movq %rax, -0x48(%rbp)
movq %rbx, -0x40(%rbp)
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x21c0
movq -0x48(%rbp), %r14
movq %rbx, %r13
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq %r12, %rbx
shlq $0x5, %rbx
movq (%rax,%rbx), %rsi
movq 0x8(%rax,%rbx), %rdx
movq %r15, %rdi
callq 0x21c0
movq 0x8(%r13), %rcx
movq 0x20(%r13), %rax
movl (%rax,%r12,4), %eax
movq (%rcx,%r14,8), %rcx
movl 0x8(%rcx,%rbx), %ebx
movl %eax, %ecx
subl %ebx, %ecx
testl %ecx, %ecx
leaq -0x29(%rbp), %r14
jle 0x520d
subl %eax, %ebx
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x21c0
incl %ebx
jne 0x51f5
incq %r12
movq -0x40(%rbp), %rbx
movl (%rbx), %eax
cmpq %rax, %r12
jb 0x5198
leaq -0x1b8(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x2250
movq 0x3d6f(%rip), %rsi      # 0x8fa8
leaq -0x1c0(%rbp), %rdi
callq 0x20f0
leaq -0x150(%rbp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x526a
jmp 0x526a
movq %rax, %rbx
movq 0x3d34(%rip), %rsi      # 0x8fa8
leaq -0x1c0(%rbp), %rdi
callq 0x20f0
leaq -0x150(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x21d0
cmpl $0x0, (%r14)
je 0x5331
xorl %r15d, %r15d
leaq -0x50(%rbp), %r12
leaq -0x1c8(%rbp), %r13
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x5148
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %r13, %rdi
callq 0x21c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5329
callq 0x2170
incl %r15d
cmpl (%r14), %r15d
jb 0x52cf
leaq -0x1c0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2250
movq 0x3c5d(%rip), %rsi      # 0x8fa8
leaq -0x1c8(%rbp), %rdi
callq 0x20f0
leaq -0x158(%rbp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x537a
movq %rax, %rbx
jmp 0x5394
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5394
callq 0x2170
movq 0x3c0d(%rip), %rsi      # 0x8fa8
leaq -0x1c8(%rbp), %rdi
callq 0x20f0
leaq -0x158(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rdi)
sete %al
movq (%rdi), %rbx
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x2676
movq (%rbx), %r14
movq 0x8(%rbx), %r15
testq %r14, %r14
je 0x265e
movq %r14, %rdi
callq 0x10692
movq %r14, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x10742
movq %rbx, %rdi
callq 0x20f0
movq %r15, %rbx
testq %r15, %r15
jne 0x2642
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/diegofilbal[P]YourJam/src/lista.cpp
// Function: Lista::insereInicio(Musica)
bool Lista::insereInicio(Musica musica){

    if(busca(musica) == nullptr){ // Verifica se a música já está cadastrada
        // A música não está cadastrada no sistema

        Node *temp = new Node;
        temp->musica = new Musica;

        // Copia informações da música para temp
        temp->musica->setNome(musica.getNome());
        temp->musica->setArtista(musica.getArtista());

        // Atualiza o head
        temp->next = head;
        head = temp;

        if(tamanho == 1){ //  Verifica se só há um elemento na lista
            tail = temp->next; // Atualiza o tail
        }

        tamanho++; //Incrementa o tamanho da lista

        return true; // Retorna código de sucesso

    }else{
        return false; // Retorna código de erro
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x98(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xa8(%rbp), %rdi
callq 0x38da
leaq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x38da
leaq -0xa8(%rbp), %rsi
movq %rbx, %rdi
callq 0x2816
movq %rax, %r15
leaq -0xa8(%rbp), %rdi
callq 0x10692
testq %r15, %r15
jne 0x27a5
movl $0x10, %edi
callq 0x2110
movq %rax, %r12
movq %rax, %rdi
callq 0x1073c
movl $0x40, %edi
callq 0x2110
movq %rax, %r13
movq %rax, %rdi
callq 0x1066c
movq %r13, (%r12)
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0x106c8
movq %r13, %rdi
leaq -0x68(%rbp), %rsi
callq 0x106f4
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x275b
callq 0x20f0
movq (%r12), %r13
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x106fe
movq %r13, %rdi
leaq -0x48(%rbp), %rsi
callq 0x1072c
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2789
callq 0x20f0
movq (%rbx), %rcx
movq %rcx, 0x8(%r12)
movq %r12, (%rbx)
movl 0x10(%rbx), %eax
cmpl $0x1, %eax
jne 0x27a0
movq %rcx, 0x8(%rbx)
incl %eax
movl %eax, 0x10(%rbx)
testq %r15, %r15
sete %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rax
jmp 0x27cd
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x2808
jmp 0x280d
movq %rax, %rbx
movq %r13, %rdi
jmp 0x2808
movq %rax, %rbx
movq %r12, %rdi
jmp 0x2808
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x10692
jmp 0x280d
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
cmpq %r15, %rdi
je 0x280d
callq 0x20f0
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x2946
movq %rsi, %r14
leaq -0x68(%rbp), %r12
movq (%rbx), %rsi
leaq -0x88(%rbp), %rdi
callq 0x106c8
movq %r12, %rdi
movq %r14, %rsi
callq 0x106c8
movq -0x80(%rbp), %rdx
cmpq -0x60(%rbp), %rdx
jne 0x287e
testq %rdx, %rdx
je 0x2883
movq -0x68(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x2120
testl %eax, %eax
sete %r13b
jmp 0x2886
xorl %r13d, %r13d
jmp 0x2886
movb $0x1, %r13b
testb %r13b, %r13b
je 0x28d4
movq (%rbx), %rsi
leaq -0x48(%rbp), %rdi
callq 0x106fe
leaq -0xa8(%rbp), %rdi
movq %r14, %rsi
callq 0x106fe
movq -0x40(%rbp), %rdx
cmpq -0xa0(%rbp), %rdx
jne 0x28d4
testq %rdx, %rdx
je 0x2941
movq -0xa8(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x2120
testl %eax, %eax
sete %r15b
jmp 0x28d7
xorl %r15d, %r15d
testb %r13b, %r13b
je 0x2906
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rax
cmpq %rax, %rdi
je 0x28f4
callq 0x20f0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2906
callq 0x20f0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x2918
callq 0x20f0
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x292d
callq 0x20f0
testb %r15b, %r15b
jne 0x2948
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x283d
jmp 0x2946
movb $0x1, %r15b
jmp 0x28d7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2977
callq 0x20f0
jmp 0x2977
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x298e
callq 0x20f0
jmp 0x298e
movq %rax, %rbx
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x29a3
callq 0x20f0
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
testl %esi, %esi
js 0x2c34
cmpl %esi, 0x10(%rdi)
jle 0x2c34
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
testl %esi, %esi
jle 0x2c30
movq 0x8(%rax), %rax
decl %esi
jne 0x2c28
movq (%rax), %rax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %esi, %esi
js 0x2f9a
movl 0x10(%rdi), %eax
cmpl %esi, %eax
jle 0x2f9a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
testl %esi, %esi
je 0x2f9d
movq %rbx, %rdx
movq 0x8(%rdx), %rbx
movq %rdx, %rcx
movq %rbx, %rdx
decl %esi
jne 0x2f8a
jmp 0x2f9f
xorl %eax, %eax
retq
xorl %ecx, %ecx
movq (%rdi), %rdx
cmpq %rdx, %rbx
je 0x2fb7
cmpq 0x8(%rdi), %rbx
je 0x2fc0
movq 0x8(%rbx), %rdx
movq %rdx, 0x8(%rcx)
jmp 0x2fcc
movq 0x8(%rdx), %rcx
movq %rcx, (%rdi)
jmp 0x2fcc
movq $0x0, 0x8(%rcx)
movq %rcx, 0x8(%rdi)
decl %eax
movl %eax, 0x10(%rdi)
movq (%rbx), %r14
testq %r14, %r14
je 0x2fe9
movq %r14, %rdi
callq 0x10692
movq %r14, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x10742
movq %rbx, %rdi
callq 0x20f0
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
testl %esi, %esi
js 0x3471
cmpl %esi, 0x10(%rdi)
jle 0x3471
movq (%rdi), %rax
testl %esi, %esi
jle 0x3471
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rax), %rax
decl %esi
jne 0x3468
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/diegofilbal[P]YourJam/src/lista.cpp
// Function: Lista::operator+(Lista const&) const
Lista* Lista::operator+(Lista const &lista) const{

    // Insere a primeira lista usando o método sobrecarregado de adição
    Lista* lista_final = new Lista(*this);

    // Percorre a lista recebida e insere suas músicas na lista final
    for(int i = 0; i < lista.getTamanho(); i++){ 

        Node *temp = new Node;
        temp->musica = new Musica;

        // Copia informações da música para temp
        temp->musica->setNome(lista.buscaMusicaPos(i)->getNome());
        temp->musica->setArtista(lista.buscaMusicaPos(i)->getArtista());
        temp->next = nullptr;

        // Atualiza o tail
        lista_final->tail->next = temp;
        lista_final->tail = temp;

        // Incrementa o tamanho da lista
        lista_final->tamanho++; 
    }

    return lista_final;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x2110
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movq %rax, -0x30(%rbp)
movq %rax, %rdi
movq %r15, %rsi
callq 0x2408
cmpl $0x0, 0x10(%r14)
jle 0x359b
xorl %r12d, %r12d
movl $0x10, %edi
callq 0x2110
movq %rax, %r13
movq %rax, %rdi
callq 0x1073c
movl $0x40, %edi
callq 0x2110
movq %rax, %r15
movq %rax, %rdi
callq 0x1066c
movq %r15, (%r13)
movq %r14, %rbx
movq (%r14), %rax
movl %r12d, %ecx
testl %r12d, %r12d
je 0x3501
movq 0x8(%rax), %rax
decl %ecx
jne 0x34f9
movq (%rax), %rsi
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x106c8
movq %r15, %rdi
movq %r14, %rsi
callq 0x106f4
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
movq %rbx, %r14
je 0x3530
callq 0x20f0
movq (%r13), %r15
movq (%r14), %rax
movl %r12d, %ecx
testl %r12d, %r12d
je 0x3547
movq 0x8(%rax), %rax
decl %ecx
jne 0x353f
movq (%rax), %rsi
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x106fe
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1072c
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3573
callq 0x20f0
movq $0x0, 0x8(%r13)
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %r13, 0x8(%rax)
movq %r13, 0x8(%rcx)
incl 0x10(%rcx)
incl %r12d
cmpl 0x10(%r14), %r12d
jl 0x34bd
movq -0x30(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x30(%rbp), %rdi
jmp 0x35e4
movq %rax, %r14
movq %r13, %rdi
jmp 0x35e4
movq %rax, %r14
movq %r15, %rdi
jmp 0x35e4
movq %rax, %r14
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
jmp 0x35df
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x35e9
callq 0x20f0
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
cmpl $0x0, 0x10(%rdi)
je 0x369b
movq %rdi, %rbx
movq (%r14), %rax
movq (%rax), %r15
movq 0x8(%rdi), %rax
movq (%rax), %rsi
leaq -0x60(%rbp), %r12
movq %r12, %rdi
callq 0x106c8
movq %r15, %rdi
movq %r12, %rsi
callq 0x106f4
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3647
callq 0x20f0
movq (%r14), %rax
movq (%rax), %r15
movq 0x8(%rbx), %rax
movq (%rax), %rsi
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x106fe
movq %r15, %rdi
movq %r12, %rsi
callq 0x1072c
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x367d
callq 0x20f0
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rax
movq (%r14), %rcx
movq %rax, 0x8(%rcx)
movl 0x10(%rbx), %esi
decl %esi
movq %rbx, %rdi
callq 0x2f6e
jmp 0x36a2
movq $0x0, (%r14)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
jmp 0x36bf
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36cd
callq 0x20f0
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x0, 0x10(%rdi)
jle 0x3894
movq %rdi, %r15
xorl %r14d, %r14d
leaq -0x48(%rbp), %r12
movq %rdi, %rbx
movq (%rbx), %rbx
incl %r14d
movq 0x14805(%rip), %rdi     # 0x17fd0
movl %r14d, %esi
callq 0x2190
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0xe832(%rip), %rsi      # 0x12017
callq 0x2130
movq (%rbx), %rsi
leaq -0x68(%rbp), %rdi
callq 0x106c8
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %r13, %rdi
callq 0x2130
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0xe802(%rip), %rsi      # 0x1201a
callq 0x2130
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x106fe
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r13, %rdi
callq 0x2130
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2080
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3874
callq 0x20f0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3886
callq 0x20f0
addq $0x8, %rbx
cmpl 0x10(%r15), %r14d
jl 0x37be
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38a5
movq %rax, %rbx
jmp 0x38bf
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x38bf
callq 0x20f0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x38d1
callq 0x20f0
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x18, %edi
callq 0x2110
movq %rax, %r15
movq %rax, %rdi
callq 0x23dc
movq %r15, 0x20(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2060
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movq 0x20(%rbx), %rdi
movq 0x20(%r14), %rsi
callq 0x2408
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x20f0
jmp 0x1082d
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1083a
callq 0x20f0
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0x2c08
movl %eax, %r15d
movq 0x20(%r14), %rdi
movq 0x20(%rbx), %rsi
callq 0x3000
movq 0x20(%r14), %rdi
callq 0x2c08
subl %eax, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
leaq -0x58(%rbp), %rdi
callq 0x1066c
movq 0x20(%r14), %rdi
movl %r15d, %esi
callq 0x2c12
leaq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0x106c8
leaq -0x58(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x106f4
leaq -0xc8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10b1b
callq 0x20f0
movq 0x20(%r14), %rdi
movl %r15d, %esi
callq 0x2c12
leaq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x106fe
leaq -0x58(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1072c
leaq -0xa8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10b5b
callq 0x20f0
movq 0x20(%r14), %rdi
movl %r15d, %esi
callq 0x2f6e
movq 0x20(%r14), %r14
leaq -0x88(%rbp), %r15
movq %r15, -0x10(%r15)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x38da
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
movq %rax, -0x10(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
callq 0x38da
leaq -0x98(%rbp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x2c36
leaq -0x98(%rbp), %rdi
callq 0x10692
leaq -0x58(%rbp), %rdi
callq 0x10692
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x10692
jmp 0x10c28
movq %rax, %rbx
movq -0x98(%rbp), %rdi
cmpq %r15, %rdi
jne 0x10c1e
jmp 0x10c28
movq %rax, %rbx
leaq -0xa8(%rbp), %rax
jmp 0x10c15
movq %rax, %rbx
leaq -0xc8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10c28
callq 0x20f0
jmp 0x10c28
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x10692
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl 0x28(%rbx), %esi
callq 0x3452
testq %rax, %rax
je 0x10c5c
incl 0x28(%rbx)
movq (%rax), %rax
jmp 0x10c5e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x30, %edi
callq 0x2110
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x107b8
movq 0x20(%rbx), %rdi
movq 0x20(%r14), %rsi
callq 0x2408
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x30, %edi
callq 0x2110
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x107b8
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x38da
leaq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x38da
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x10928
leaq -0x58(%rbp), %rdi
callq 0x10692
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x10692
jmp 0x10d68
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
jne 0x10d63
jmp 0x10d68
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movl $0x30, %edi
callq 0x2110
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x107b8
leaq -0xb0(%rbp), %rdi
callq 0x1066c
movq 0x20(%rbx), %rdi
callq 0x2c08
movl %eax, %r15d
testl %eax, %eax
jle 0x10e7e
incl %r15d
leaq -0x70(%rbp), %r13
leal -0x2(%r15), %r12d
movq 0x20(%rbx), %rdi
movl %r12d, %esi
callq 0x2c12
movq %rax, %r14
leaq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x2060
addq $0x20, %r14
leaq -0x90(%rbp), %rdi
movq %r14, %rsi
callq 0x2060
movq -0x30(%rbp), %rax
movq 0x20(%rax), %r14
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x38da
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x38da
movq %r14, %rdi
movq %r13, %rsi
callq 0x32b8
movq %rax, %r14
movq %r13, %rdi
callq 0x10692
testq %r14, %r14
je 0x10e71
movq 0x20(%rbx), %rdi
movl %r12d, %esi
callq 0x2f6e
decl %r15d
cmpl $0x1, %r15d
jg 0x10dca
leaq -0xb0(%rbp), %rdi
callq 0x10692
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10ed3
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
jmp 0x10ee2
movq %rax, %r14
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x10ed6
callq 0x20f0
jmp 0x10ed6
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x10692
jmp 0x10ed6
movq %rax, %r14
leaq -0xb0(%rbp), %rdi
callq 0x10692
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x2c08
testl %eax, %eax
je 0x1122f
movq (%r14), %r15
movq 0x20(%rbx), %r12
movq %r12, %rdi
callq 0x2c08
leal -0x1(%rax), %esi
movq %r12, %rdi
callq 0x2c12
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x106c8
movq %r15, %rdi
movq %r12, %rsi
callq 0x106f4
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x111d2
callq 0x20f0
movq (%r14), %r14
movq 0x20(%rbx), %r15
movq %r15, %rdi
callq 0x2c08
leal -0x1(%rax), %esi
movq %r15, %rdi
callq 0x2c12
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x106fe
movq %r14, %rdi
movq %r15, %rsi
callq 0x1072c
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11218
callq 0x20f0
movq 0x20(%rbx), %rdi
callq 0x2c08
leal -0x1(%rax), %esi
movq 0x20(%rbx), %rdi
callq 0x2f6e
jmp 0x11236
movq $0x0, (%r14)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rax
jmp 0x11253
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11261
callq 0x20f0
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testq %rsi, %rsi
je 0x1141b
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x6c83(%rip), %rdi      # 0x17fd0
movl %edx, %esi
callq 0x2190
movq %rax, %r12
leaq 0xcb9(%rip), %rsi       # 0x12017
movl $0x2, %edx
movq %rax, %rdi
callq 0x2130
movq (%r15), %rsi
leaq -0x68(%rbp), %r13
movq %r13, %rdi
callq 0x106c8
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
leaq 0xc86(%rip), %rsi       # 0x1201a
movl $0x3, %edx
movq %rax, %rdi
callq 0x2130
movq (%r15), %rsi
leaq -0x48(%rbp), %rdi
callq 0x106fe
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2080
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x113f9
callq 0x20f0
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1140b
callq 0x20f0
movq 0x8(%r15), %rsi
incl %ebx
movq %r14, %rdi
movl %ebx, %edx
callq 0x11324
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1142c
movq %rax, %rbx
jmp 0x11446
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11446
callq 0x20f0
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11458
callq 0x20f0
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0x2c08
testl %eax, %eax
jle 0x11496
movl %eax, %ebx
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x2f6e
decl %ebx
jne 0x11487
cmpq $0x0, -0x30(%rbp)
je 0x11519
movq -0x30(%rbp), %rdi
callq 0x2c08
movl %eax, -0x34(%rbp)
testl %eax, %eax
jle 0x11519
xorl %r13d, %r13d
leaq -0x78(%rbp), %r12
movq 0x20(%r14), %rbx
movq -0x30(%rbp), %rdi
movl %r13d, %esi
callq 0x2c12
movq %rax, %r15
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x38da
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x38da
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29ac
movq %r12, %rdi
callq 0x10692
incl %r13d
cmpl %r13d, -0x34(%rbp)
jne 0x114b4
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x1154b
callq 0x20f0
jmp 0x1154b
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x10692
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl (%rsi), %ecx
testl %ecx, %ecx
jle 0x2966
movq %rsi, %r14
xorl %r15d, %r15d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
leaq 0x18(%rsp), %r13
movq 0x8(%r14), %rax
addl %r12d, %ecx
addl %ecx, %ecx
shrq %cl, %rax
andl $0x3, %eax
movl %eax, 0xc(%rsp)
leaq 0x18984(%rip), %rdi     # 0x1b278
leaq 0xc(%rsp), %rsi
callq 0x8826
movb (%rax), %bpl
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0xc8e2
movq 0x20(%rsp), %rsi
movsbl %bpl, %r8d
movl $0x1, %ecx
movq %r13, %rdi
xorl %edx, %edx
callq 0x23f0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x22e0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2954
callq 0x2210
movl (%r14), %ecx
incl %r15d
decl %r12d
cmpl %ecx, %r15d
jl 0x28da
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2994
callq 0x2210
jmp 0x2994
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x29a3
callq 0x2210
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O1/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:
addl %edx, %edi
cmpl $0x21, %edi
jge 0x2ba8
movq %rcx, %rax
addl %edx, %edx
movl %edx, %ecx
shlq %cl, %rsi
orq %rax, %rsi
leal (%rdi,%rdi), %ecx
movq $-0x1, %rax
movq $-0x1, %rdx
shlq %cl, %rdx
cmpl $0x20, %edi
notq %rdx
cmoveq %rax, %rdx
andq %rsi, %rdx
movl %edi, %eax
retq
pushq %rax
leaq 0x11644(%rip), %rdi     # 0x141f4
leaq 0x115e5(%rip), %rsi     # 0x1419c
leaq 0x11640(%rip), %rcx     # 0x141fe
movl $0x8a, %edx
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
testl %edi, %edi
setle %r9b
jle 0x2d4f
leal (%rdi,%rdi), %ecx
movq $-0x1, %rdx
movq $-0x1, %r8
shlq %cl, %r8
cmpl $0x20, %edi
notq %r8
cmoveq %rdx, %r8
movl %esi, %eax
andl $0x3, %eax
movabsq $0x5555555555555555, %rcx # imm = 0x5555555555555555
imulq %rax, %rcx
andq %r8, %rcx
movl $0x1, %eax
cmpq %rsi, %rcx
je 0x2d5b
movl %edi, %r9d
incl %edi
addq %rdi, %rdi
movl $0x4, %ecx
leaq 0x11348(%rip), %r11     # 0x14060
movq %rax, %r10
cmpq %rcx, %rdi
je 0x2d51
movq $-0x1, %rbx
shlq %cl, %rbx
cmpq $0x40, %rcx
notq %rbx
cmoveq %rdx, %rbx
andq %rsi, %rbx
imulq (%r11,%rcx,4), %rbx
andq %r8, %rbx
addq $0x2, %rcx
leaq 0x1(%r10), %rax
cmpq %rsi, %rbx
jne 0x2d18
jmp 0x2d54
jmp 0x2d5b
movq %r10, %rax
cmpq %r9, %r10
setae %r9b
testb %r9b, %r9b
jne 0x2d62
popq %rbx
retq
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
addq $0x8, %rdi
callq 0x99ee
testq %rax, %rax
je 0x2f22
movq %rax, %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2f3c
subq %rax, %rbx
jmp 0x2f24
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r15
movl %ecx, %r12d
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %edi
movq %rdx, %rsi
movl %ecx, %edx
movq %r8, %rcx
callq 0x4721
movl $0x30, %ecx
testb %al, %al
jne 0x31e9
movl %ebp, %edi
movq %rbx, %rsi
movl %r12d, %edx
movq %r15, %rcx
callq 0x47b3
movl $0x58, %ecx
testb %al, %al
je 0x3206
addq %rcx, %r14
movl $0x1, %ecx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9a4c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::get_all_ends() const
unordered_set<debruijn_graph::node> debruijn_graph::get_all_ends(void) const {
		unordered_set<node> result;
		for (auto it = begins.begin(); it != begins.end(); ++it)
			result.insert(*it);
		for (auto it = ends.begin(); it != ends.end(); ++it)
			result.insert(*it);
		//for (const auto & p : left_ends)
		//result.insert(p.first);
		//for (const auto & p : right_ends)
		//result.insert(p.first);
		return result;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
leaq 0x38(%rsi), %r15
leaq 0x48(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x12995
movq 0x50(%r14), %rax
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x10(%rsp), %rbp
movq %rsp, %r13
movq %r15, %rdi
movq %rbp, %rsi
movq $-0x1, %rdx
callq 0x12995
movq 0x50(%r14), %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x12f13
testl %eax, %eax
je 0x3372
movq %rbp, %rdi
callq 0x12f13
testl %eax, %eax
jne 0x33a3
leaq 0x40(%rsp), %rdi
callq 0x9ae0
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rbx, (%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0xe0d8
movq %r12, %rdi
callq 0x12c5d
jmp 0x333f
leaq 0x60(%r14), %r15
leaq 0x48(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x12995
movq 0x78(%r14), %rax
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x10(%rsp), %rbp
movq %rsp, %r13
movq %r15, %rdi
movq %rbp, %rsi
movq $-0x1, %rdx
callq 0x12995
movq 0x78(%r14), %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x12f13
testl %eax, %eax
je 0x3400
movq %rbp, %rdi
callq 0x12f13
testl %eax, %eax
jne 0x3431
leaq 0x40(%rsp), %rdi
callq 0x9ae0
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rbx, (%rsp)
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0xe0d8
movq %r12, %rdi
callq 0x12c5d
jmp 0x33cd
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3451
jmp 0x3451
jmp 0x3451
jmp 0x3451
jmp 0x3451
jmp 0x3451
jmp 0x3451
movq %rax, %r14
movq %rbx, %rdi
callq 0xc72c
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O1/splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::left_edges(dna::canonical_kmer) const
set<debruijn_graph::edge> debruijn_graph::left_edges(node n) const {
		set<edge> result;
		for (const auto b : bases) {
			edge e = b + n;
			if (abundance(e) && !is_duplex_edge(n, e))
				result.insert(e);
		}
		return result;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %r13d, %r13d
movq %r13, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %r13, 0x28(%rdi)
leaq 0x107f6(%rip), %r12     # 0x14020
movl (%r13,%r12), %esi
movl $0x1, %edi
movl %ebp, %edx
movq %r14, %rcx
callq 0x2b70
movl %eax, %edi
movq %rdx, %rsi
callq 0x2a7b
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r15, %rdi
movl %eax, %esi
callq 0x2ef0
testq %rax, %rax
je 0x3884
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rcx
movl %ebp, %edi
movq %r14, %rsi
callq 0x38b3
testb %al, %al
jne 0x3884
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0xd306
addq $0x4, %r13
cmpq $0x10, %r13
jne 0x382a
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc78e
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O1/splatlab[P]debgr/debruijn_graph.cc
// Function: dna::is_duplex_edge(dna::canonical_kmer, dna::canonical_kmer)
bool is_duplex_edge(debruijn_graph::node n, debruijn_graph::edge e) {
		bool lefty = false, righty = false;
		for (const auto b : bases) {
			righty |= (e == canonicalize(n + b));
			lefty |= (e == canonicalize(b + n));
		}
		return righty && lefty;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movl %edi, 0x8(%rsp)
xorl %ebx, %ebx
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x10(%rsp), %r13
movl 0xc(%rsp), %r15d
movq 0x18(%rsp), %r14
leaq 0x10730(%rip), %rax     # 0x14020
movl (%rbp,%rax), %ecx
movq %rcx, 0x20(%rsp)
movl 0x8(%rsp), %edi
movq %r13, %rsi
movl $0x1, %edx
callq 0x2b70
movl %eax, %edi
movq %rdx, %rsi
callq 0x2a7b
cmpl %r15d, %eax
sete %al
cmpq %r14, %rdx
sete %cl
andb %al, %cl
orb %cl, %r12b
movl $0x1, %edi
movq 0x20(%rsp), %rsi
movl 0x8(%rsp), %edx
movq %r13, %rcx
callq 0x2b70
movl %eax, %edi
movq %rdx, %rsi
callq 0x2a7b
cmpl %r15d, %eax
sete %al
cmpq %r14, %rdx
sete %cl
andb %al, %cl
orb %cl, %bl
addq $0x4, %rbp
cmpq $0x10, %rbp
jne 0x38e9
andb %bl, %r12b
andb $0x1, %r12b
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::right_edges(dna::canonical_kmer) const
set<debruijn_graph::edge> debruijn_graph::right_edges(node n) const {
		set<edge> result;
		for (const auto b : bases) {
			edge e = n + b;
			if (abundance(e) && !is_duplex_edge(n, e))
				result.insert(e);
		}
		return result;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %r13d, %r13d
movq %r13, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %r13, 0x28(%rdi)
leaq 0x1066a(%rip), %r12     # 0x14020
movl (%r13,%r12), %ecx
movl %ebp, %edi
movq %r14, %rsi
movl $0x1, %edx
callq 0x2b70
movl %eax, %edi
movq %rdx, %rsi
callq 0x2a7b
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r15, %rdi
movl %eax, %esi
callq 0x2ef0
testq %rax, %rax
je 0x3a10
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rcx
movl %ebp, %edi
movq %r14, %rsi
callq 0x38b3
testb %al, %al
jne 0x3a10
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0xd306
addq $0x4, %r13
cmpq $0x10, %r13
jne 0x39b6
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc78e
movq %r14, %rdi
callq 0x23c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::duplex_edges(dna::canonical_kmer) const
set<debruijn_graph::edge> debruijn_graph::duplex_edges(node n) const {
		set<edge> result;
		for (const auto b : bases) {
			edge e1 = b + n;
			if (abundance(e1) && is_duplex_edge(n, e1))
				result.insert(e1);
			edge e2 = n + b;
			if (abundance(e2) && is_duplex_edge(n, e2))
				result.insert(e2);
		}
		return result;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %r13d, %r13d
movq %r13, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %r13, 0x28(%rdi)
leaq 0x105a2(%rip), %rax     # 0x14020
movl (%r13,%rax), %r12d
movl $0x1, %edi
movq %r12, %rsi
movl %ebp, %edx
movq %r14, %rcx
callq 0x2b70
movl %eax, %edi
movq %rdx, %rsi
callq 0x2a7b
movl %eax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %r15, %rdi
movl %eax, %esi
callq 0x2ef0
testq %rax, %rax
je 0x3adb
movl 0x18(%rsp), %edx
movq 0x20(%rsp), %rcx
movl %ebp, %edi
movq %r14, %rsi
callq 0x38b3
testb %al, %al
je 0x3adb
movq %rbx, %rdi
leaq 0x18(%rsp), %rsi
callq 0xd306
movl %ebp, %edi
movq %r14, %rsi
movl $0x1, %edx
movq %r12, %rcx
callq 0x2b70
movl %eax, %edi
movq %rdx, %rsi
callq 0x2a7b
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r15, %rdi
movl %eax, %esi
callq 0x2ef0
testq %rax, %rax
je 0x3b33
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rcx
movl %ebp, %edi
movq %r14, %rsi
callq 0x38b3
testb %al, %al
je 0x3b33
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0xd306
addq $0x4, %r13
cmpq $0x10, %r13
jne 0x3a77
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b55
movq %rax, %r14
movq %rbx, %rdi
callq 0xc78e
movq %r14, %rdi
callq 0x23c0