LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/bendem[P]DiskGraph/src/string_manips.cpp
// Function: parseInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
unsigned parseInt(string str) {
    unsigned res = 0;
    for(unsigned i = 0; i < str.length(); ++i) {
        if(str[i] < '0' || str[i] > '9') {
            throw invalid_argument("NaN");
        }
        res = res * 10 + str[i] - '0';
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x4ae8
movq (%rdi), %rdx
xorl %edi, %edi
movl $0x1, %esi
xorl %eax, %eax
movzbl (%rdx,%rdi), %edi
leal -0x3a(%rdi), %r8d
cmpb $-0xb, %r8b
jbe 0x4aef
leal (%rax,%rax,4), %eax
leal (%rdi,%rax,2), %eax
addl $-0x30, %eax
movl %esi, %edi
incl %esi
cmpq %rdi, %rcx
ja 0x4ac6
jmp 0x4aea
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x1671(%rip), %rsi      # 0x6174
movq %rax, %rdi
callq 0x22e0
movq 0x44be(%rip), %rsi      # 0x8fd0
movq 0x44a7(%rip), %rdx      # 0x8fc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/bendem[P]DiskGraph/src/string_manips.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, unsigned int)
vector<string> split(string str, char sep, unsigned default_size) {
    istringstream ss(str);
    string part;
    vector<string> vector;

    if(default_size != 0) {
        vector.reserve(default_size);
    }

    while(ss.peek() != EOF) {
        getline(ss, part, sep);
        if(part.length() != 0) {
            vector.push_back(part);
        }
    }

    return vector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %ecx, %r15d
movl %edx, %r14d
movq %rdi, %rbx
leaq -0x1c0(%rbp), %rdi
movl $0x8, %edx
callq 0x2290
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
testl %r15d, %r15d
je 0x4b8f
movl %r15d, %esi
movq %rbx, %rdi
callq 0x4c4c
leaq -0x1c0(%rbp), %rdi
callq 0x20a0
cmpl $-0x1, %eax
je 0x4bc9
movsbl %r14b, %edx
leaq -0x1c0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x22d0
cmpq $0x0, -0x38(%rbp)
je 0x4b8f
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x4d36
jmp 0x4b8f
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4bd7
callq 0x2170
movq 0x43c2(%rip), %rsi      # 0x8fa0
leaq -0x1c0(%rbp), %rdi
callq 0x2200
leaq -0x148(%rbp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c0b
movq %rax, %r14
movq %rbx, %rdi
callq 0x40e2
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x4c24
callq 0x2170
movq 0x4375(%rip), %rsi      # 0x8fa0
leaq -0x1c0(%rbp), %rdi
callq 0x2200
leaq -0x148(%rbp), %rdi
callq 0x2080
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/bendem[P]DiskGraph/src/table.cpp
// Function: Table::Table(unsigned int)
Table::Table(unsigned columns) : columns(columns) {
    this->line_sizes.reserve(columns);
    for(unsigned i = 0; i < columns; ++i) {
        this->line_sizes.push_back(0);
    }
    this->lines.reserve(columns);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r13
movl %esi, (%rdi)
leaq 0x8(%rdi), %rax
movq %rax, -0x38(%rbp)
leaq 0x20(%rdi), %r14
movl %esi, %r12d
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movq %r14, %rdi
movq %r12, %rsi
callq 0x5380
testl %r15d, %r15d
je 0x4ff0
leaq -0x2c(%rbp), %rbx
movl $0x0, -0x2c(%rbp)
movq 0x28(%r13), %rsi
cmpq 0x30(%r13), %rsi
je 0x4fe0
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x28(%r13)
jmp 0x4feb
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4574
decl %r15d
jne 0x4fbf
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x541c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x500d
movq %rax, %rbx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x501d
callq 0x2170
movq -0x38(%rbp), %rdi
callq 0x429c
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/bendem[P]DiskGraph/src/table.cpp
// Function: Table::addLine(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
Table& Table::addLine(vector<string> line) {
    if(line.size() != this->columns) {
        throw invalid_argument("invalid number of columns");
    }
    this->lines.push_back(line);
    for(unsigned i = 0; i < this->columns; ++i) {
        if(this->line_sizes[i] < line[i].length()) {
            this->line_sizes[i] = line[i].length();
        }
    }
    return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x5, %rax
movl (%rdi), %ecx
cmpq %rcx, %rax
jne 0x5090
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x5532
movl (%rbx), %eax
testl %eax, %eax
je 0x5088
movq 0x20(%rbx), %rcx
movq (%r14), %rdx
addq $0x8, %rdx
xorl %esi, %esi
movl (%rcx,%rsi,4), %r8d
movq (%rdx), %rdi
cmpq %r8, %rdi
jbe 0x507a
movl %edi, (%rcx,%rsi,4)
movl (%rbx), %eax
incq %rsi
movl %eax, %edi
addq $0x20, %rdx
cmpq %rdi, %rsi
jb 0x5069
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x10fc(%rip), %rsi      # 0x61a0
movq %rax, %rdi
callq 0x22e0
movq 0x3f1d(%rip), %rsi      # 0x8fd0
movq 0x3f06(%rip), %rdx      # 0x8fc0
movq %rbx, %rdi
callq 0x22a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x51e3
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 0x51d1
subl %eax, %ebx
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x21c0
incl %ebx
jne 0x51b9
incq %r12
movq -0x40(%rbp), %rbx
movl (%rbx), %eax
cmpq %rax, %r12
jb 0x515c
leaq -0x1b8(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x2250
movq 0x3dab(%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 0x522e
jmp 0x522e
movq %rax, %rbx
movq 0x3d70(%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_O3/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 0x52f5
xorl %r15d, %r15d
leaq -0x50(%rbp), %r12
leaq -0x1c8(%rbp), %r13
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x510c
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 0x52ed
callq 0x2170
incl %r15d
cmpl (%r14), %r15d
jb 0x5293
leaq -0x1c0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2250
movq 0x3c99(%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 0x533e
movq %rax, %rbx
jmp 0x5358
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5358
callq 0x2170
movq 0x3c49(%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_O3/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 0x2656
movq %r14, %rdi
callq 0x1063e
movq %r14, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x106ee
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_O3/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 0x38ac
leaq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x38ac
leaq -0xa8(%rbp), %rsi
movq %rbx, %rdi
callq 0x2816
movq %rax, %r15
leaq -0xa8(%rbp), %rdi
callq 0x1063e
testq %r15, %r15
jne 0x27a5
movl $0x10, %edi
callq 0x2110
movq %rax, %r12
movq %rax, %rdi
callq 0x106e8
movl $0x40, %edi
callq 0x2110
movq %rax, %r13
movq %rax, %rdi
callq 0x10618
movq %r13, (%r12)
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0x10674
movq %r13, %rdi
leaq -0x68(%rbp), %rsi
callq 0x106a0
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 0x106aa
movq %r13, %rdi
leaq -0x48(%rbp), %rsi
callq 0x106d8
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 0x1063e
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_O3/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 0x293c
movq %rsi, %r14
leaq -0x38(%rbp), %r13
leaq -0x88(%rbp), %r12
movq (%rbx), %rsi
leaq -0x48(%rbp), %rdi
callq 0x10674
movq %r12, %rdi
movq %r14, %rsi
callq 0x10674
movq -0x40(%rbp), %rdx
cmpq -0x80(%rbp), %rdx
jne 0x287e
testq %rdx, %rdx
je 0x2886
movq -0x88(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x2120
testl %eax, %eax
je 0x2886
xorl %r15d, %r15d
jmp 0x2907
movq (%rbx), %rsi
leaq -0x68(%rbp), %rdi
callq 0x106aa
leaq -0xa8(%rbp), %rdi
movq %r14, %rsi
callq 0x106aa
movq -0x60(%rbp), %rdx
cmpq -0xa0(%rbp), %rdx
jne 0x28ce
movq -0xa8(%rbp), %r13
testq %rdx, %rdx
je 0x28da
movq -0x68(%rbp), %rdi
movq %r13, %rsi
callq 0x2120
testl %eax, %eax
sete %r15b
jmp 0x28dd
movq -0xa8(%rbp), %r13
xorl %r15d, %r15d
jmp 0x28dd
movb $0x1, %r15b
leaq -0x98(%rbp), %rax
cmpq %rax, %r13
je 0x28f1
movq %r13, %rdi
callq 0x20f0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x2903
callq 0x20f0
leaq -0x38(%rbp), %r13
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x291c
callq 0x20f0
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x292a
callq 0x20f0
testb %r15b, %r15b
jne 0x293e
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2844
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 -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x296d
callq 0x20f0
jmp 0x296d
movq %rax, %rbx
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x2987
callq 0x20f0
jmp 0x2987
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2999
callq 0x20f0
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c2a
cmpl %esi, 0x10(%rdi)
jle 0x2c2a
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
testl %esi, %esi
je 0x2c26
movq 0x8(%rax), %rax
decl %esi
jne 0x2c1e
movq (%rax), %rax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2fa3
movl 0x10(%rdi), %eax
cmpl %esi, %eax
jle 0x2fa3
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rcx
movq %rcx, %rbx
testl %esi, %esi
je 0x2fa6
movq %rcx, %rbx
movq %rbx, %rdx
movq 0x8(%rbx), %rbx
decl %esi
jne 0x2f83
cmpq %rcx, %rbx
je 0x2fa6
cmpq 0x8(%rdi), %rbx
je 0x2fe1
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rdx)
jmp 0x2fad
xorl %eax, %eax
retq
movq 0x8(%rcx), %rcx
movq %rcx, (%rdi)
decl %eax
movl %eax, 0x10(%rdi)
movq (%rbx), %r14
testq %r14, %r14
je 0x2fc2
movq %r14, %rdi
callq 0x1063e
movq %r14, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x106ee
movq %rbx, %rdi
callq 0x20f0
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
movq $0x0, 0x8(%rdx)
movq %rdx, 0x8(%rdi)
jmp 0x2fad
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3443
cmpl %esi, 0x10(%rdi)
jle 0x3443
movq (%rdi), %rax
testl %esi, %esi
je 0x3443
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rax), %rax
decl %esi
jne 0x343a
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x356d
xorl %r12d, %r12d
movl $0x10, %edi
callq 0x2110
movq %rax, %r13
movq %rax, %rdi
callq 0x106e8
movl $0x40, %edi
callq 0x2110
movq %rax, %r15
movq %rax, %rdi
callq 0x10618
movq %r15, (%r13)
movq %r14, %rbx
movq (%r14), %rax
movl %r12d, %ecx
testl %r12d, %r12d
je 0x34d3
movq 0x8(%rax), %rax
decl %ecx
jne 0x34cb
movq (%rax), %rsi
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x10674
movq %r15, %rdi
movq %r14, %rsi
callq 0x106a0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
movq %rbx, %r14
je 0x3502
callq 0x20f0
movq (%r13), %r15
movq (%r14), %rax
movl %r12d, %ecx
testl %r12d, %r12d
je 0x3519
movq 0x8(%rax), %rax
decl %ecx
jne 0x3511
movq (%rax), %rsi
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x106aa
movq %r15, %rdi
movq %rbx, %rsi
callq 0x106d8
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3545
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 0x348f
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 0x35b6
movq %rax, %r14
movq %r13, %rdi
jmp 0x35b6
movq %rax, %r14
movq %r15, %rdi
jmp 0x35b6
movq %rax, %r14
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
jmp 0x35b1
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x35bb
callq 0x20f0
movq %r14, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x366d
movq %rdi, %rbx
movq (%r14), %rax
movq (%rax), %r15
movq 0x8(%rdi), %rax
movq (%rax), %rsi
leaq -0x60(%rbp), %r12
movq %r12, %rdi
callq 0x10674
movq %r15, %rdi
movq %r12, %rsi
callq 0x106a0
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3619
callq 0x20f0
movq (%r14), %rax
movq (%rax), %r15
movq 0x8(%rbx), %rax
movq (%rax), %rsi
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x106aa
movq %r15, %rdi
movq %r12, %rsi
callq 0x106d8
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x364f
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 0x2f64
jmp 0x3674
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 0x3691
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x369f
callq 0x20f0
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3866
movq %rdi, %r15
xorl %r14d, %r14d
leaq -0x48(%rbp), %r12
movq %rdi, %rbx
movq (%rbx), %rbx
incl %r14d
movq 0x14833(%rip), %rdi     # 0x17fd0
movl %r14d, %esi
callq 0x2190
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0xe860(%rip), %rsi      # 0x12017
callq 0x2130
movq (%rbx), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10674
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %r13, %rdi
callq 0x2130
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0xe830(%rip), %rsi      # 0x1201a
callq 0x2130
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x106aa
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 0x3846
callq 0x20f0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3858
callq 0x20f0
addq $0x8, %rbx
cmpl 0x10(%r15), %r14d
jl 0x3790
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3877
movq %rax, %rbx
jmp 0x3891
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3891
callq 0x20f0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x38a3
callq 0x20f0
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x107d3
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x107e0
callq 0x20f0
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2bfe
movl %eax, %r15d
movq 0x20(%r14), %rdi
movq 0x20(%rbx), %rsi
callq 0x2ff0
movq 0x20(%r14), %rdi
callq 0x2bfe
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_O3/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 0x10618
movq 0x20(%r14), %rdi
movl %r15d, %esi
callq 0x2c08
leaq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0x10674
leaq -0x58(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x106a0
leaq -0xc8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10ac1
callq 0x20f0
movq 0x20(%r14), %rdi
movl %r15d, %esi
callq 0x2c08
leaq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x106aa
leaq -0x58(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x106d8
leaq -0xa8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10b01
callq 0x20f0
movq 0x20(%r14), %rdi
movl %r15d, %esi
callq 0x2f64
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 0x38ac
leaq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
movq %rax, -0x10(%rax)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq %rsi, %rdx
callq 0x38ac
leaq -0x98(%rbp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x2c2c
leaq -0x98(%rbp), %rdi
callq 0x1063e
leaq -0x58(%rbp), %rdi
callq 0x1063e
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x1063e
jmp 0x10bce
movq %rax, %rbx
movq -0x98(%rbp), %rdi
cmpq %r15, %rdi
jne 0x10bc4
jmp 0x10bce
movq %rax, %rbx
leaq -0xa8(%rbp), %rax
jmp 0x10bbb
movq %rax, %rbx
leaq -0xc8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10bce
callq 0x20f0
jmp 0x10bce
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x1063e
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3424
testq %rax, %rax
je 0x10c02
incl 0x28(%rbx)
movq (%rax), %rax
jmp 0x10c04
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1075e
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x38ac
leaq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x38ac
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x108ce
leaq -0x58(%rbp), %rdi
callq 0x1063e
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x1063e
jmp 0x10d0e
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
jne 0x10d09
jmp 0x10d0e
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1075e
leaq -0xb0(%rbp), %rdi
callq 0x10618
movq 0x20(%rbx), %rdi
callq 0x2bfe
movl %eax, %r15d
testl %eax, %eax
jle 0x10e24
incl %r15d
leaq -0x70(%rbp), %r13
leal -0x2(%r15), %r12d
movq 0x20(%rbx), %rdi
movl %r12d, %esi
callq 0x2c08
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 0x38ac
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x38ac
movq %r14, %rdi
movq %r13, %rsi
callq 0x3296
movq %rax, %r14
movq %r13, %rdi
callq 0x1063e
testq %r14, %r14
je 0x10e17
movq 0x20(%rbx), %rdi
movl %r12d, %esi
callq 0x2f64
decl %r15d
cmpl $0x1, %r15d
ja 0x10d70
leaq -0xb0(%rbp), %rdi
callq 0x1063e
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10e79
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
jmp 0x10e88
movq %rax, %r14
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x10e7c
callq 0x20f0
jmp 0x10e7c
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x1063e
jmp 0x10e7c
movq %rax, %r14
leaq -0xb0(%rbp), %rdi
callq 0x1063e
movq %r14, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2bfe
testl %eax, %eax
je 0x111c7
movq (%r14), %r15
movq 0x20(%rbx), %r12
movq %r12, %rdi
callq 0x2bfe
leal -0x1(%rax), %esi
movq %r12, %rdi
callq 0x2c08
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x10674
movq %r15, %rdi
movq %r12, %rsi
callq 0x106a0
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1116a
callq 0x20f0
movq (%r14), %r14
movq 0x20(%rbx), %r15
movq %r15, %rdi
callq 0x2bfe
leal -0x1(%rax), %esi
movq %r15, %rdi
callq 0x2c08
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x106aa
movq %r14, %rdi
movq %r15, %rsi
callq 0x106d8
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x111b0
callq 0x20f0
movq 0x20(%rbx), %rdi
callq 0x2bfe
leal -0x1(%rax), %esi
movq 0x20(%rbx), %rdi
callq 0x2f64
jmp 0x111ce
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 0x111eb
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x111f9
callq 0x20f0
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x113b3
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x6ceb(%rip), %rdi      # 0x17fd0
movl %edx, %esi
callq 0x2190
movq %rax, %r12
leaq 0xd21(%rip), %rsi       # 0x12017
movl $0x2, %edx
movq %rax, %rdi
callq 0x2130
movq (%r15), %rsi
leaq -0x68(%rbp), %r13
movq %r13, %rdi
callq 0x10674
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
leaq 0xcee(%rip), %rsi       # 0x1201a
movl $0x3, %edx
movq %rax, %rdi
callq 0x2130
movq (%r15), %rsi
leaq -0x48(%rbp), %rdi
callq 0x106aa
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 0x11391
callq 0x20f0
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x113a3
callq 0x20f0
movq 0x8(%r15), %rsi
incl %ebx
movq %r14, %rdi
movl %ebx, %edx
callq 0x112bc
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x113c4
movq %rax, %rbx
jmp 0x113de
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x113de
callq 0x20f0
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x113f0
callq 0x20f0
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2bfe
testl %eax, %eax
jle 0x1142e
movl %eax, %ebx
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x2f64
decl %ebx
jne 0x1141f
cmpq $0x0, -0x30(%rbp)
je 0x114b1
movq -0x30(%rbp), %rdi
callq 0x2bfe
movl %eax, -0x34(%rbp)
testl %eax, %eax
jle 0x114b1
xorl %r13d, %r13d
leaq -0x78(%rbp), %r12
movq 0x20(%r14), %rbx
movq -0x30(%rbp), %rdi
movl %r13d, %esi
callq 0x2c08
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 0x38ac
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x38ac
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29a2
movq %r12, %rdi
callq 0x1063e
incl %r13d
cmpl %r13d, -0x34(%rbp)
jne 0x1144c
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 0x114e3
callq 0x20f0
jmp 0x114e3
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x1063e
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2962
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 0x18980(%rip), %rdi     # 0x1b270
leaq 0xc(%rsp), %rsi
callq 0x87bc
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 0xc8b0
movq 0x20(%rsp), %rsi
movsbl %bpl, %r8d
movl $0x1, %ecx
movq %r13, %rdi
xorl %edx, %edx
callq 0x23e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x22d0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2950
callq 0x2200
movl (%r14), %ecx
incl %r15d
decl %r12d
cmpl %ecx, %r15d
jl 0x28d6
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 0x2990
callq 0x2200
jmp 0x2990
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x299f
callq 0x2200
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2ba4
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 0x11648(%rip), %rdi     # 0x141f4
leaq 0x115e9(%rip), %rsi     # 0x1419c
leaq 0x11644(%rip), %rcx     # 0x141fe
movl $0x8a, %edx
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %edi, %edi
jle 0x2d1b
leal (%rdi,%rdi), %ecx
movq $-0x1, %rdx
movq $-0x1, %r8
shlq %cl, %r8
cmpl $0x20, %edi
notq %r8
cmoveq %rdx, %r8
incl %edi
movl $0x1, %eax
movl $0x2, %ecx
leaq 0x11376(%rip), %r9      # 0x14060
movq $-0x1, %r10
shlq %cl, %r10
cmpq $0x20, %rax
notq %r10
cmoveq %rdx, %r10
andq %rsi, %r10
imulq (%r9,%rax,8), %r10
andq %r8, %r10
cmpq %rsi, %r10
je 0x2d21
incq %rax
addq $0x2, %rcx
cmpq %rax, %rdi
jne 0x2cea
pushq %rax
callq 0x2100
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9978
testq %rax, %rax
je 0x2edc
movq %rax, %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x2ef6
subq %rax, %rbx
jmp 0x2ede
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl (%rdi), %ecx
cmpq %rcx, 0x8(%rsi)
jb 0x311e
movq %rsi, %r14
movq %rdi, %r13
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2250
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x2790
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f95
callq 0x2200
movl 0x18(%rsp), %ebp
movq 0x20(%rsp), %r15
movl (%r13), %edx
decl %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x2bc4
movl %eax, %edi
movq %rdx, %rsi
callq 0x2a77
movl %eax, %ebx
movq %rdx, %r12
movl %ebp, %edi
movq %r15, %rsi
callq 0x2a77
movq %rdx, %r8
movq %r13, %rdi
movl %ebx, %esi
movq %r12, %rdx
movl %eax, %ecx
callq 0x314c
movl %ebp, %edi
movq %r15, %rsi
callq 0x2a77
leaq 0x8(%r13), %rdi
movl $0x1, %ecx
movq %rdi, 0x10(%rsp)
movl %eax, %esi
callq 0x990a
movl (%r13), %edx
cmpq %rdx, 0x8(%r14)
je 0x30e9
movq %r14, %rax
movq %r13, %r14
movq %rax, 0x8(%rsp)
movq (%rax), %r13
addq %rdx, %r13
movl (%r14), %edx
decl %edx
movq %r15, %rsi
callq 0x2c19
movl %eax, %edi
movq %rdx, %rsi
callq 0x2a77
movl %eax, %r12d
movq %rdx, %rbx
movl %eax, %edi
movq %rdx, %rsi
callq 0x31c8
testb %al, %al
je 0x305f
movl %ebp, %edi
movq %r15, %rsi
callq 0x2a77
movq %rdx, %r8
movq %r14, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x314c
leaq 0x181da(%rip), %rdi     # 0x1b240
movq %r13, %rsi
callq 0x8802
movl (%rax), %ecx
movl %ebp, %edi
movq %r15, %rsi
movl $0x1, %edx
callq 0x2ab5
movl %eax, %ebp
movq %rdx, %r15
movl %eax, %edi
movq %rdx, %rsi
callq 0x2a77
movl $0x1, %ecx
movq 0x10(%rsp), %rdi
movl %eax, %esi
callq 0x990a
movl %r12d, %edi
movq %rbx, %rsi
callq 0x31c8
testb %al, %al
je 0x30cb
movl %ebp, %edi
movq %r15, %rsi
callq 0x2a77
movq %rdx, %r8
movq %r14, %rdi
movl %r12d, %esi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x314c
incq %r13
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
addq 0x8(%rcx), %rax
cmpq %rax, %r13
jne 0x3017
movq %r14, %r13
movl (%r14), %edx
decl %edx
movq %r15, %rsi
callq 0x2c19
movl %eax, %edi
movq %rdx, %rsi
callq 0x2a77
movl %eax, %ebx
movq %rdx, %r14
movl %ebp, %edi
movq %r15, %rsi
callq 0x2a77
movq %rdx, %r8
movq %r13, %rdi
movl %ebx, %esi
movq %r14, %rdx
movl %eax, %ecx
callq 0x314c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3143
callq 0x2200
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x46cb
movl $0x30, %ecx
testb %al, %al
jne 0x3193
movl %ebp, %edi
movq %rbx, %rsi
movl %r12d, %edx
movq %r15, %rcx
callq 0x4752
movl $0x58, %ecx
testb %al, %al
je 0x31b0
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 0x99d6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop