LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpl $0x0, 0x10(%rdi)
je 0x25a7
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x259d
movq (%rbx), %r14
movq 0x8(%rbx), %r15
testq %r14, %r14
je 0x2580
movq %r14, %rdi
callq 0xafd4
movq %r14, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0xb046
movq %rbx, %rdi
callq 0x2100
movq %r15, %rbx
jmp 0x2567
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %rbx
leaq -0xa8(%rbp), %r14
movq %r14, %rdi
callq 0x32fc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26dc
movq %rax, %r14
leaq -0xa8(%rbp), %rdi
callq 0xafd4
testq %r14, %r14
jne 0x2680
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %r12
movq %rax, %rdi
callq 0xb040
pushq $0x40
popq %rdi
callq 0x2120
movq %rax, %r13
movq %rax, %rdi
callq 0xafac
movq %r13, (%r12)
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0xaff4
movq %r13, %rdi
leaq -0x68(%rbp), %rsi
callq 0xb00c
leaq -0x68(%rbp), %rdi
callq 0x2070
movq (%r12), %r13
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0xb016
movq %r13, %rdi
leaq -0x48(%rbp), %rsi
callq 0xb032
leaq -0x48(%rbp), %rdi
callq 0x2070
movq (%rbx), %rcx
movq %rcx, 0x8(%r12)
movq %r12, (%rbx)
movl 0x10(%rbx), %eax
cmpl $0x1, %eax
jne 0x267b
movq %rcx, 0x8(%rbx)
incl %eax
movl %eax, 0x10(%rbx)
testq %r14, %r14
sete %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
jmp 0x26a8
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2070
jmp 0x26d3
movq %rax, %rbx
movq %r13, %rdi
jmp 0x26bd
movq %rax, %rbx
movq %r12, %rdi
callq 0x2100
jmp 0x26d3
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0xafd4
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x98(%rbp), %r13
leaq -0x78(%rbp), %r12
leaq -0xb8(%rbp), %r15
movq %rsi, -0x38(%rbp)
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x27ab
movq (%rbx), %rsi
movq %r13, %rdi
callq 0xaff4
movq %r12, %rdi
movq %r14, %rsi
callq 0xaff4
movq %r13, %rdi
movq %r12, %rsi
callq 0x3336
testb %al, %al
je 0x2792
movq (%rbx), %rsi
leaq -0x58(%rbp), %rdi
callq 0xb016
movq %r15, %rdi
movq %r14, %rsi
callq 0xb016
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3336
movb %al, -0x29(%rbp)
movq %r15, %rdi
callq 0x2070
movq %r14, %rdi
callq 0x2070
movq %r12, %rdi
callq 0x2070
movq %r13, %rdi
callq 0x2070
cmpb $0x0, -0x29(%rbp)
movq -0x38(%rbp), %r14
je 0x27a2
jmp 0x27ab
movq %r12, %rdi
callq 0x2070
movq %r13, %rdi
callq 0x2070
addq $0x8, %rbx
jmp 0x270c
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2070
jmp 0x27d1
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x2070
jmp 0x27df
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29fd
cmpl %esi, 0x10(%rdi)
jle 0x29fd
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdi
subl $0x1, %esi
jb 0x29f9
addq $0x8, %rdi
jmp 0x29eb
movq (%rdi), %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c36
movl 0x10(%rdi), %eax
cmpl %esi, %eax
jle 0x2c36
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %ecx, %ecx
movq %rdi, %rdx
movq (%rdx), %rbx
subl $0x1, %esi
jb 0x2c39
leaq 0x8(%rbx), %rdx
movq %rbx, %rcx
jmp 0x2c25
xorl %eax, %eax
retq
movq (%rdi), %rdx
cmpq %rdx, %rbx
je 0x2c51
cmpq 0x8(%rdi), %rbx
je 0x2c5a
movq 0x8(%rbx), %rdx
movq %rdx, 0x8(%rcx)
jmp 0x2c63
movq 0x8(%rdx), %rcx
movq %rcx, (%rdi)
jmp 0x2c63
andq $0x0, 0x8(%rcx)
movq %rcx, 0x8(%rdi)
decl %eax
movl %eax, 0x10(%rdi)
movq (%rbx), %r14
testq %r14, %r14
je 0x2c78
movq %r14, %rdi
callq 0xafd4
movq %r14, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0xb046
movq %rbx, %rdi
callq 0x2100
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2fa9
cmpl %esi, 0x10(%rdi)
jle 0x2fa9
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdi
subl $0x1, %esi
jb 0x2fa5
addq $0x8, %rdi
jmp 0x2f97
movq %rdi, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x2120
movq %rax, -0x30(%rbp)
movq %rax, %rdi
movq %r15, %rsi
callq 0x23cc
xorl %r15d, %r15d
cmpl 0x10(%r14), %r15d
jge 0x308e
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %r12
movq %rax, %rdi
callq 0xb040
pushq $0x40
popq %rdi
callq 0x2120
movq %rax, %r13
movq %rax, %rdi
callq 0xafac
movq %r13, (%r12)
movq %r14, %rdi
movl %r15d, %esi
callq 0x29dc
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaff4
movq %r13, %rdi
movq %rbx, %rsi
callq 0xb00c
movq %rbx, %rdi
callq 0x2070
movq (%r12), %r13
movq %r14, %rdi
movl %r15d, %esi
callq 0x29dc
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb016
movq %r13, %rdi
movq %rbx, %rsi
callq 0xb032
movq %rbx, %rdi
callq 0x2070
andq $0x0, 0x8(%r12)
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %r12, 0x8(%rax)
movq %r12, 0x8(%rcx)
incl 0x10(%rcx)
incl %r15d
jmp 0x2fdb
movq -0x30(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
jmp 0x30cf
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x30ba
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2070
jmp 0x30d4
movq %rax, %rbx
movq %r12, %rdi
jmp 0x30cf
movq %rax, %rbx
movq %r13, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x316f
movq %rdi, %rbx
movq (%r14), %rax
movq (%rax), %r12
movq 0x8(%rdi), %rax
movq (%rax), %rsi
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0xaff4
movq %r12, %rdi
movq %r15, %rsi
callq 0xb00c
leaq -0x60(%rbp), %rdi
callq 0x2070
movq (%r14), %rax
movq (%rax), %r12
movq 0x8(%rbx), %rax
movq (%rax), %rsi
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0xb016
movq %r12, %rdi
movq %r15, %rsi
callq 0xb032
leaq -0x40(%rbp), %rdi
callq 0x2070
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 0x2c0e
jmp 0x3173
andq $0x0, (%r14)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3182
movq %rax, %rbx
movq %r15, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
pushq $0x1
popq %r14
leaq -0x70(%rbp), %r13
leaq -0x50(%rbp), %r12
movq %rdi, -0x30(%rbp)
leal -0x1(%r14), %eax
movq -0x30(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x32c9
movq (%rbx), %rbx
movq 0xdd83(%rip), %rdi      # 0x10fd0
movl %r14d, %esi
callq 0x2190
movq %rax, %rdi
leaq 0x8db8(%rip), %rsi      # 0xc017
callq 0x2110
movq %rax, %r15
movq (%rbx), %rsi
movq %r13, %rdi
callq 0xaff4
movq %r15, %rdi
movq %r13, %rsi
callq 0x20f0
movq %rax, %rdi
leaq 0x8d93(%rip), %rsi      # 0xc01a
callq 0x2110
movq %rax, %r15
movq (%rbx), %rsi
movq %r12, %rdi
callq 0xb016
movq %r15, %rdi
movq %r12, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
movq %r12, %rdi
callq 0x2070
movq %r13, %rdi
callq 0x2070
addq $0x8, %rbx
incl %r14d
jmp 0x3232
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32da
movq %rax, %rbx
jmp 0x32eb
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2070
leaq -0x70(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
pushq $0x18
popq %rdi
callq 0x2120
movq %rax, %r15
movq %rax, %rdi
callq 0x23bc
movq %r15, 0x20(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2090
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb130
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x2100
jmp 0xb11f
movq %rax, %r14
movq %rbx, %rdi
callq 0x2070
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29d2
movl %eax, %r15d
movq 0x20(%r14), %rdi
movq 0x20(%rbx), %rsi
callq 0x2c98
movq 0x20(%r14), %rdi
callq 0x29d2
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_O2/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 -0x98(%rbp), %rdi
callq 0xafac
movq 0x20(%r14), %rdi
movl %r15d, %esi
callq 0x29dc
leaq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xaff4
leaq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xb00c
leaq -0x58(%rbp), %rdi
callq 0x2070
movq 0x20(%r14), %rdi
movl %r15d, %esi
callq 0x29dc
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xb016
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb032
leaq -0x38(%rbp), %rdi
callq 0x2070
movq 0x20(%r14), %rdi
movl %r15d, %esi
callq 0x2c0e
movq 0x20(%r14), %r14
leaq -0xd8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x32fc
leaq -0xd8(%rbp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x29fe
leaq -0xd8(%rbp), %rdi
callq 0xafd4
leaq -0x98(%rbp), %rdi
callq 0xafd4
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0xafd4
jmp 0xb3d5
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0xb3cb
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2070
jmp 0xb3d5
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0xafd4
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2f88
testq %rax, %rax
je 0xb40c
incl 0x28(%rbx)
movq (%rax), %rax
jmp 0xb40e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x30
popq %rdi
callq 0x2120
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0xb0b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb130
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x30
popq %rdi
callq 0x2120
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0xb0b0
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x32fc
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb1c2
leaq -0x58(%rbp), %rdi
callq 0xafd4
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0xafd4
jmp 0xb4db
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x30
popq %rdi
callq 0x2120
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xb0b0
leaq -0x70(%rbp), %rdi
callq 0xafac
movq 0x20(%rbx), %rdi
callq 0x29d2
movl %eax, %r15d
leaq -0x70(%rbp), %r12
leaq -0xb0(%rbp), %r13
testl %r15d, %r15d
jle 0xb58f
decl %r15d
movq 0x20(%rbx), %rdi
movl %r15d, %esi
callq 0x29dc
movq %r12, %rdi
movq %rax, %rsi
callq 0xaf82
movq -0x30(%rbp), %rax
movq 0x20(%rax), %r14
movq %r13, %rdi
movq %r12, %rsi
callq 0x32fc
movq %r14, %rdi
movq %r13, %rsi
callq 0x2e5e
movq %rax, %r14
movq %r13, %rdi
callq 0xafd4
testq %r14, %r14
je 0xb535
movq %rbx, %rdi
movl %r15d, %esi
callq 0xb278
jmp 0xb535
leaq -0x70(%rbp), %rdi
callq 0xafd4
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb5cd
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
jmp 0xb5d9
movq %rax, %r14
leaq -0xb0(%rbp), %rdi
callq 0xafd4
jmp 0xb5d0
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0xafd4
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/diegofilbal[P]YourJam/src/playlist.cpp
// Function: Playlist::operator-(Musica const&) const
Playlist* Playlist::operator-(Musica const &musica) const{

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

    if(playlist_final->getLista()->buscaMusica(musica)){ // Verifica se a música recebida por parâmetro está na playlist
        for(int i = 0; i < playlist_final->getLista()->getTamanho(); i++){ // Percorre a lista e procura a posição em que a música a ser removida está posicionada
            if(playlist_final->getLista()->buscaMusicaPos(i)->getNome() == musica.getNome() && playlist_final->getLista()->buscaMusicaPos(i)->getArtista() == musica.getArtista()){
                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 $0xd8, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
pushq $0x30
popq %rdi
callq 0x2120
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb0b0
movq %r14, -0x30(%rbp)
movq 0x20(%r14), %r15
leaq -0xd8(%rbp), %rbx
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
callq 0x32fc
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2e5e
movq %rax, %r15
leaq -0xd8(%rbp), %rdi
callq 0xafd4
testq %r15, %r15
movq -0x30(%rbp), %rbx
je 0xb736
xorl %r15d, %r15d
leaq -0x98(%rbp), %r14
leaq -0xf8(%rbp), %r12
movq -0x30(%rbp), %rbx
movq 0x20(%rbx), %rdi
callq 0x29d2
cmpl %eax, %r15d
jge 0xb736
movq 0x20(%rbx), %rdi
movl %r15d, %esi
callq 0x29dc
leaq -0x78(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xaff4
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0xaff4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3336
testb %al, %al
je 0xb71e
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movl %r15d, %esi
callq 0x29dc
leaq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xb016
movq %r12, %rdi
movq -0x38(%rbp), %rsi
callq 0xb016
leaq -0x58(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x3336
movl %eax, %ebx
movq %r12, %rdi
callq 0x2070
movq %r13, %rdi
callq 0x2070
movq %r14, %rdi
callq 0x2070
leaq -0x78(%rbp), %rdi
callq 0x2070
testb %bl, %bl
je 0xb72e
movq -0x30(%rbp), %rdi
movl %r15d, %esi
callq 0xb278
jmp 0xb72e
movq %r14, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2070
incl %r15d
jmp 0xb666
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0xafd4
jmp 0xb794
movq %rax, %rbx
movq %r14, %rdi
callq 0x2100
jmp 0xb794
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x2070
jmp 0xb77f
movq %rax, %rbx
jmp 0xb78b
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x2070
leaq -0x78(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29d2
testl %eax, %eax
je 0xb852
movq (%r14), %r12
movq 0x20(%rbx), %r15
movq %r15, %rdi
callq 0x29d2
leal -0x1(%rax), %esi
movq %r15, %rdi
callq 0x29dc
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xaff4
movq %r12, %rdi
movq %r15, %rsi
callq 0xb00c
leaq -0x60(%rbp), %rdi
callq 0x2070
movq (%r14), %r14
movq 0x20(%rbx), %r15
movq %r15, %rdi
callq 0x29d2
leal -0x1(%rax), %esi
movq %r15, %rdi
callq 0x29dc
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xb016
movq %r14, %rdi
movq %r15, %rsi
callq 0xb032
leaq -0x40(%rbp), %rdi
callq 0x2070
movq 0x20(%rbx), %rdi
callq 0x29d2
leal -0x1(%rax), %esi
movq %rbx, %rdi
callq 0xb278
jmp 0xb856
andq $0x0, (%r14)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb865
movq %rax, %rbx
movq %r15, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb99a
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x56bd(%rip), %rdi      # 0x10fd0
movl %edx, %esi
callq 0x2190
leaq 0x6f6(%rip), %rsi       # 0xc017
movq %rax, %rdi
callq 0x2110
movq %rax, %r12
movq (%r15), %rsi
leaq -0x68(%rbp), %r13
movq %r13, %rdi
callq 0xaff4
movq %r12, %rdi
movq %r13, %rsi
callq 0x20f0
leaq 0x6cd(%rip), %rsi       # 0xc01a
movq %rax, %rdi
callq 0x2110
movq %rax, %r12
movq (%r15), %rsi
leaq -0x48(%rbp), %rdi
callq 0xb016
leaq -0x48(%rbp), %rsi
movq %r12, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x2080
leaq -0x48(%rbp), %rdi
callq 0x2070
leaq -0x68(%rbp), %rdi
callq 0x2070
movq 0x8(%r15), %rsi
incl %ebx
movq %r14, %rdi
movl %ebx, %edx
callq 0xb8ea
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb9b9
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2070
jmp 0xb9bc
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0x29d2
movl %eax, %r15d
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
subl $0x1, %r15d
jb 0xba0e
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x2c0e
jmp 0xb9fb
cmpq $0x0, -0x30(%rbp)
je 0xba66
movq -0x30(%rbp), %rdi
callq 0x29d2
movl %eax, %r15d
xorl %r12d, %r12d
testl %eax, %eax
cmovlel %r12d, %r15d
leaq -0x70(%rbp), %r13
cmpl %r12d, %r15d
je 0xba66
movq 0x20(%r14), %rbx
movq -0x30(%rbp), %rdi
movl %r12d, %esi
callq 0x29dc
movq %r13, %rdi
movq %rax, %rsi
callq 0x32fc
movq %rbx, %rdi
movq %r13, %rsi
callq 0x27f4
movq %r13, %rdi
callq 0xafd4
incl %r12d
jmp 0xba2e
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xafd4
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
pushq $0x1
popq %rbp
pushq $-0x1
popq %r15
leaq 0x4(%rsp), %r12
leaq 0x8(%rsp), %r13
movl (%r14), %ecx
cmpl %ecx, %ebp
jg 0x27de
movq 0x8(%r14), %rax
addl %r15d, %ecx
addl %ecx, %ecx
shrq %cl, %rax
andl $0x3, %eax
movl %eax, 0x4(%rsp)
leaq 0x17ac2(%rip), %rdi     # 0x1a270
movq %r12, %rsi
callq 0x70e6
movsbl (%rax), %edx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x70af
movq %rbx, %rdi
movq %r13, %rsi
callq 0x22a0
movq %r13, %rdi
callq 0x20a0
incl %ebp
decl %r15d
jmp 0x278d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movl %edi, %eax
bswapq %rsi
movq %rsi, %rcx
shrq $0x4, %rcx
movabsq $0xf0f0f0f0f0f0f0f, %rdx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rdx
shlq $0x4, %rsi
movabsq $-0xf0f0f0f0f0f0f10, %rcx # imm = 0xF0F0F0F0F0F0F0F0
andq %rsi, %rcx
orq %rdx, %rcx
movabsq $-0xccccccccccccccd, %rdx # imm = 0xF333333333333333
andq %rcx, %rdx
shrq $0x2, %rcx
movabsq $0x3333333333333333, %rsi # imm = 0x3333333333333333
andq %rcx, %rsi
leaq (%rsi,%rdx,4), %rdx
notq %rdx
leal (%rax,%rax), %ecx
negb %cl
shrq %cl, %rdx
movq %rsp, %rbx
movq %rbx, %rdi
movl %eax, %esi
callq 0x264c
movl (%rbx), %eax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rcx, %rax
leal (%rdi,%rdi), %ecx
shrq %cl, %rax
movl %edx, %ecx
subl %edi, %ecx
addl %ecx, %ecx
shlq %cl, %rsi
orq %rsi, %rax
leal (%rdx,%rdx), %ecx
pushq $-0x1
popq %rsi
movq %rsi, %r8
shlq %cl, %r8
cmpl $0x20, %edx
notq %r8
cmoveq %rsi, %r8
andq %rax, %r8
movq %rsp, %rbx
movq %rbx, %rdi
movl %edx, %esi
movq %r8, %rdx
callq 0x264c
movl (%rbx), %eax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rcx, %rax
movl %edx, %ecx
movq %rsi, %rdx
movl %edi, %esi
addl %ecx, %esi
cmpl $0x21, %esi
jge 0x29b7
addl %ecx, %ecx
shlq %cl, %rdx
orq %rax, %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x264c
movl (%rbx), %eax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
leaq 0xe836(%rip), %rdi      # 0x111f4
leaq 0xe7d7(%rip), %rsi      # 0x1119c
leaq 0xe832(%rip), %rcx      # 0x111fe
movl $0x8a, %edx
callq 0x2110
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
xorl %r14d, %r14d
testl %edi, %edi
movl $0x0, %r15d
cmovgl %edi, %r15d
cmpq %r14, %r15
je 0x2ac2
incq %r14
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2a3c
testb %al, %al
je 0x2a9b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7d76
testq %rax, %rax
je 0x2c30
movq %rax, %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2c4a
subq %rax, %rbx
jmp 0x2c32
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/splatlab[P]debgr/debruijn_graph.cc
// Function: dna::debruijn_graph::insert_read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void debruijn_graph::insert_read(string s) {
		// TODO: handle locking
		if (s.size() < len)
			return;
		kmer k(s.substr(0, len));
		node n = prefix(k, len-1);    
		record_end(n, k);
		record_occurence(k);
		for (auto it = s.begin() + len; it != s.end(); ++it) {
			node nextn = suffix(k, len-1);
			if (can_have_duplex_edges(nextn))
				record_end(nextn, k);
			k = k << base_from_char.at(*it);
			record_occurence(k);
			if (can_have_duplex_edges(nextn))
				record_end(nextn, k);
		}
		n = suffix(k, len-1);
		record_end(n, k);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movl (%rdi), %ecx
cmpq %rcx, 0x8(%rsi)
jb 0x2e3f
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rsi, %rbp
xorl %edx, %edx
callq 0x2230
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x2690
leaq 0x28(%rsp), %rdi
callq 0x20a0
movl 0x18(%rsp), %ebx
movq 0x20(%rsp), %r15
movq 0x10(%rsp), %r13
movl (%r13), %edx
decl %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x29d6
movl %eax, %edi
movq %rdx, %rsi
callq 0x28ad
movl %eax, %r14d
movq %rdx, %r12
movl %ebx, %edi
movq %r15, %rsi
callq 0x28ad
movq %rdx, %r8
movq %r13, %rdi
movl %r14d, %esi
movq %r12, %rdx
movl %eax, %ecx
callq 0x2e64
movl %ebx, 0xc(%rsp)
movl %ebx, %edi
movq %r15, %rsi
callq 0x28ad
movq %r13, %rdi
movl %eax, %esi
callq 0x2ed4
movq (%rbp), %rbx
movl (%r13), %r12d
addq %rbx, %r12
movq %rbp, %rax
movq %rax, %rbp
addq 0x8(%rax), %rbx
movq 0x10(%rsp), %rax
movl (%rax), %edx
decl %edx
movq %r15, %rsi
callq 0x2a02
movl %eax, %edi
movq %rdx, %rsi
callq 0x28ad
movl %eax, %r14d
movq %rdx, %r13
cmpq %rbx, %r12
je 0x2e1e
movl %r14d, %edi
movq %r13, %rsi
callq 0x2ee0
testb %al, %al
movl 0xc(%rsp), %ebx
je 0x2da4
movl %ebx, %edi
movq %r15, %rsi
callq 0x28ad
movq %rdx, %r8
movq 0x10(%rsp), %rdi
movl %r14d, %esi
movq %r13, %rdx
movl %eax, %ecx
callq 0x2e64
leaq 0x17495(%rip), %rdi     # 0x1a240
movq %r12, %rsi
callq 0x711e
movl (%rax), %ecx
movl %ebx, %edi
movq %r15, %rsi
pushq $0x1
popq %rdx
callq 0x28eb
movl %eax, %ebx
movq %rdx, %r15
movl %eax, %edi
movq %rdx, %rsi
callq 0x28ad
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x2ed4
movl %r14d, %edi
movq %r13, %rsi
callq 0x2ee0
testb %al, %al
je 0x2e0b
movl %ebx, %edi
movq %r15, %rsi
callq 0x28ad
movq %rdx, %r8
movq 0x10(%rsp), %rdi
movl %r14d, %esi
movq %r13, %rdx
movl %eax, %ecx
callq 0x2e64
movl %ebx, 0xc(%rsp)
incq %r12
movq %rbp, %rax
movq (%rbp), %rbx
jmp 0x2d41
movl 0xc(%rsp), %edi
movq %r15, %rsi
callq 0x28ad
movq %rdx, %r8
movq 0x10(%rsp), %rdi
movl %r14d, %esi
movq %r13, %rdx
movl %eax, %ecx
callq 0x2e64
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x412d
testb %al, %al
je 0x2ea2
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4102
movl %ebp, %edi
movq %rbx, %rsi
movl %r12d, %edx
movq %r15, %rcx
callq 0x41b8
testb %al, %al
je 0x2ecb
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4118
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x30(%rsi), %r15
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x7df6
leaq 0x48(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x40(%rsp), %rbp
movq %r13, %rdi
movq %r15, %rsi
callq 0x7e4a
movq %rbp, %rdi
movq %r13, %rsi
callq 0x7e21
testb %al, %al
je 0x2ffb
movq %rbp, %rdi
callq 0x7e76
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xb818
movq %r12, %rdi
callq 0xf1de
jmp 0x2fbb
addq $0x58, %r14
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x7df6
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x40(%rsp), %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x7e4a
movq %r13, %rdi
movq %r12, %rsi
callq 0x7e21
testb %al, %al
je 0x305b
movq %r13, %rdi
callq 0x7e76
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb818
movq %r15, %rdi
callq 0xf1de
jmp 0x301b
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x307b
jmp 0x307b
jmp 0x307b
jmp 0x307b
jmp 0x307b
jmp 0x307b
jmp 0x307b
movq %rax, %r14
movq %rbx, %rdi
callq 0x9e2a
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rdi, (%rsp)
andq $0x0, 0x28(%rdi)
xorl %r13d, %r13d
leaq 0xdcd4(%rip), %rbx      # 0x11020
pushq $0x1
popq %r12
cmpq $0x10, %r13
je 0x33b5
movl (%r13,%rbx), %esi
movl %r12d, %edi
movl %ebp, %edx
movq %r14, %rcx
callq 0x2982
movl %eax, %edi
movq %rdx, %rsi
callq 0x28ad
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r15, %rdi
movl %eax, %esi
callq 0x2bfe
testq %rax, %rax
je 0x33af
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rcx
movl %ebp, %edi
movq %r14, %rsi
callq 0x33dc
testb %al, %al
jne 0x33af
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xaba8
addq $0x4, %r13
jmp 0x3350
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
callq 0x9eb0
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %ecx, %ecx
movq $0x0, (%rsp)
xorl %ebx, %ebx
movl 0x8(%rsp), %r12d
movq 0x10(%rsp), %rbp
movl 0xc(%rsp), %r15d
movq 0x18(%rsp), %r14
cmpq $0x10, %rcx
je 0x349b
leaq 0xdbf7(%rip), %rax      # 0x11020
movl (%rcx,%rax), %r13d
movl %r12d, %edi
movq %rbp, %rsi
pushq $0x1
popq %rdx
movq %rcx, 0x20(%rsp)
movq %r13, %rcx
callq 0x2982
movl %eax, %edi
movq %rdx, %rsi
callq 0x28ad
cmpl %r15d, %eax
sete %al
cmpq %r14, %rdx
sete %cl
andb %al, %cl
movq (%rsp), %rax
orb %cl, %al
movq %rax, (%rsp)
pushq $0x1
popq %rdi
movq %r13, %rsi
movl %r12d, %edx
movq %rbp, %rcx
callq 0x2982
movl %eax, %edi
movq %rdx, %rsi
callq 0x28ad
cmpl %r15d, %eax
sete %al
cmpq %r14, %rdx
sete %cl
andb %al, %cl
orb %cl, %bl
movq 0x20(%rsp), %rcx
addq $0x4, %rcx
jmp 0x341c
movq (%rsp), %rax
andb %bl, %al
andb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rdi, (%rsp)
andq $0x0, 0x28(%rdi)
xorl %r13d, %r13d
leaq 0xdb30(%rip), %rbx      # 0x11020
pushq $0x1
popq %r12
cmpq $0x10, %r13
je 0x3559
movl (%r13,%rbx), %ecx
movl %ebp, %edi
movq %r14, %rsi
movl %r12d, %edx
callq 0x2982
movl %eax, %edi
movq %rdx, %rsi
callq 0x28ad
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r15, %rdi
movl %eax, %esi
callq 0x2bfe
testq %rax, %rax
je 0x3553
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rcx
movl %ebp, %edi
movq %r14, %rsi
callq 0x33dc
testb %al, %al
jne 0x3553
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xaba8
addq $0x4, %r13
jmp 0x34f4
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
callq 0x9eb0
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x8(%rdi)
movl %edx, %ebp
andq $0x0, 0x10(%rdi)
movq %rsi, %r15
leaq 0x8(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rdi, (%rsp)
andq $0x0, 0x28(%rdi)
xorl %ebx, %ebx
pushq $0x1
popq %r12
cmpq $0x10, %rbx
je 0x3686
leaq 0xda55(%rip), %rax      # 0x11020
movl (%rbx,%rax), %r13d
movl %r12d, %edi
movq %r13, %rsi
movl %ebp, %edx
movq %r14, %rcx
callq 0x2982
movl %eax, %edi
movq %rdx, %rsi
callq 0x28ad
movl %eax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %r15, %rdi
movl %eax, %esi
callq 0x2bfe
testq %rax, %rax
je 0x3626
movl 0x18(%rsp), %edx
movq 0x20(%rsp), %rcx
movl %ebp, %edi
movq %r14, %rsi
callq 0x33dc
testb %al, %al
je 0x3626
movq (%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xaba8
movl %ebp, %edi
movq %r14, %rsi
movl %r12d, %edx
movq %r13, %rcx
callq 0x2982
movl %eax, %edi
movq %rdx, %rsi
callq 0x28ad
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r15, %rdi
movl %eax, %esi
callq 0x2bfe
testq %rax, %rax
je 0x367d
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rcx
movl %ebp, %edi
movq %r14, %rsi
callq 0x33dc
testb %al, %al
je 0x367d
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xaba8
addq $0x4, %rbx
jmp 0x35ba
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x369b
movq %rax, %r14
movq (%rsp), %rdi
callq 0x9eb0
movq %r14, %rdi
callq 0x23b0
nop