LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lega911[P]ijson/src/utils.cpp
// Function: GC::release()
void GC::release() {
    for(auto const & i : _list) {
        switch(i.type) {
        case 1:
            {
                auto *it = (::Message*)i.ptr;
                delete it;
                break;
            }
        case 2:
            {
                auto *it = (::DirectMessage*)i.ptr;
                if(it->unlink() == 0) {
                    delete it;
                }
                break;
            }
        }
    }
    _list.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36fb0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36fe0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x37010
testb $0x1, %al
jne 0x36d68
jmp 0x36e14
leaq -0x18(%rbp), %rdi
callq 0x37050
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x44(%rbp)
subl $0x1, %eax
je 0x36d90
jmp 0x36d86
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0x36dc2
jmp 0x36e04
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x36dc0
movq -0x50(%rbp), %rdi
callq 0x2cae0
movq -0x50(%rbp), %rdi
movl $0x38, %esi
callq 0x19300
jmp 0x36e04
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1fb00
cmpl $0x0, %eax
jne 0x36e02
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x36e00
movq -0x58(%rbp), %rdi
callq 0x1fb20
movq -0x58(%rbp), %rdi
movl $0x40, %esi
callq 0x19300
jmp 0x36e02
jmp 0x36e04
jmp 0x36e06
leaq -0x18(%rbp), %rdi
callq 0x37070
jmp 0x36d52
movq -0x40(%rbp), %rdi
callq 0x37090
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lega911[P]ijson/src/buffer.h
// Function: Buffer::add_hex(unsigned long)
void add_hex(u64 n) {
        if(!n) {
            add("0", 1);
            return;
        }
        const char hex[] = "0123456789abcdef";
        char r[16];
        int i = 15;
        while(n) {
            r[i--] = hex[n & 0xf];
            n >>= 4;
        }
        add(&r[i + 1], 15-i);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x36ef6
movq -0x50(%rbp), %rdi
leaq 0x119e(%rip), %rsi      # 0x38088
movl $0x1, %edx
callq 0x1e8b0
jmp 0x36f6e
movq 0x28f3(%rip), %rax      # 0x397f0
movq %rax, -0x30(%rbp)
movq 0x28f0(%rip), %rax      # 0x397f8
movq %rax, -0x28(%rbp)
movb 0x28ee(%rip), %al       # 0x39800
movb %al, -0x20(%rbp)
movl $0xf, -0x44(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x36f4e
movq -0x10(%rbp), %rax
andq $0xf, %rax
movb -0x30(%rbp,%rax), %cl
movl -0x44(%rbp), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, -0x44(%rbp)
cltq
movb %cl, -0x40(%rbp,%rax)
movq -0x10(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x36f1c
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %eax
addl $0x1, %eax
cltq
leaq -0x40(%rbp), %rsi
addq %rax, %rsi
movl $0xf, %edx
subl -0x44(%rbp), %edx
callq 0x1e8b0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: lega911[P]ijson/src/workerlist.cpp
// Function: WorkerItem::pop()
void WorkerItem::pop() {
    list->lock.lock();
    if(this == list->head) {
        list->head = this->next;
        if(list->head) list->head->prev = NULL;
    } else {
        if(this->prev) this->prev->next = this->next;
        if(this->next) this->next->prev = this->prev;
    }
    list->lock.unlock();
    delete this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x1fa50
movq -0x10(%rbp), %rax
movq (%rax), %rcx
cmpq 0x28(%rcx), %rax
jne 0x37987
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq (%rax), %rcx
movq %rdx, 0x28(%rcx)
movq (%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x37985
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq $0x0, 0x8(%rax)
jmp 0x379bf
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x379a2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x379bd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x379bf
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1fa80
movq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x379ec
movq -0x10(%rbp), %rdi
callq 0x378f0
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x19300
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lega911[P]ijson/src/workerlist.cpp
// Function: WorkerList::push(Connect*)
WorkerItem *WorkerList::push(Connect *conn) {
    WorkerItem *n = new WorkerItem(this, conn);
    lock.lock();
    if(head) {
        n->next = head;
        head->prev = n;
        head = n;
    } else head = n;
    lock.unlock();
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x20, %edi
callq 0x27250
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdx
callq 0x378a0
jmp 0x37a3b
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1fa50
movq -0x38(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x37a99
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x10(%rcx)
movq -0x18(%rbp), %rdx
movq 0x28(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x28(%rax)
jmp 0x37aa5
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x20, %esi
callq 0x19300
jmp 0x37ab8
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rdi
callq 0x1fa80
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x194a0
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::~LinkedList()
LinkedList::~LinkedList() {
  if (size != 0) {
    node* temp = nullptr;
    node* cur = nullptr;

    cur = head;

    while (cur != nullptr) {
      temp = cur->next;
      delete cur;
      cur = temp;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x2535
movq -0x20(%rbp), %rax
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2533
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2529
movq -0x28(%rbp), %rdi
callq 0x3b90
movq -0x28(%rbp), %rdi
callq 0x2110
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x24f6
jmp 0x2535
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::LinkedList(LinkedList const&)
LinkedList::LinkedList(const LinkedList& oldList) {
  head = nullptr;
  tail = nullptr;
  size = 0;

  node* temp = oldList.head;

  while (temp != nullptr) {
    insertEnd(temp->data);

    temp = temp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x25d2
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3bb0
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x25f0
jmp 0x25a4
leaq -0x58(%rbp), %rdi
callq 0xa9a0
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x257d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa9a0
jmp 0x25db
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::insertEnd(Song)
void LinkedList::insertEnd(Song value) {
  // Evita a adição de músicas repetidas
  if (search(value) != nullptr) {
    cout << "A música já existe no sistema." << endl;
  } else {
    node* temp = new node;

    temp->data = value;
    temp->next = nullptr;

    if (head == nullptr) {
      head =  temp;
      tail = temp;
      temp = nullptr;
    } else {
      tail->next = temp;
      tail = temp;
    }

    ++size;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3bb0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x2c40
movq %rax, -0x70(%rbp)
jmp 0x2632
leaq -0x50(%rbp), %rdi
callq 0xa9a0
movq -0x70(%rbp), %rax
cmpq $0x0, %rax
je 0x2686
movq 0xc984(%rip), %rdi      # 0xefd0
leaq 0x89b1(%rip), %rsi      # 0xb004
callq 0x2120
movq %rax, %rdi
movq 0xc95e(%rip), %rsi      # 0xefc0
callq 0x2140
jmp 0x2734
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa9a0
jmp 0x273d
movl $0x48, %edi
callq 0x2130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
callq 0x3c10
jmp 0x26a4
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x3c30
movq -0x80(%rbp), %rax
movq -0x68(%rbp), %rcx
movq $0x0, 0x40(%rcx)
cmpq $0x0, (%rax)
jne 0x270c
movq -0x80(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, -0x68(%rbp)
jmp 0x2724
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x2110
jmp 0x273d
movq -0x80(%rbp), %rax
movq -0x68(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x40(%rcx)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x80(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::operator+(LinkedList const&)
LinkedList LinkedList::operator+ (const LinkedList& secondList) {
  LinkedList finalList;

  // Percorre a lista atual copiando os valores para a lista final
  node* temp = head;
  while (temp != nullptr) {
    finalList.insertEnd(temp->data);

    temp = temp->next;
  }
  
  // Percorre a segunda lista copiando os valores para a lista final
  temp = secondList.head;
  while (temp != nullptr) {
    node* newNode = new node;

    newNode->data = temp->data;
    newNode->next = nullptr;
    
    if (finalList.head == nullptr) {
      finalList.head = newNode;
      finalList.tail = newNode;
      newNode = nullptr;
    } else {
      finalList.tail->next = newNode;
      finalList.tail = newNode;
    }

    finalList.size++;
    temp = temp->next;
  }
  
  return finalList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x2490
movq -0x88(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2804
movq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3bb0
jmp 0x27b0
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x25f0
jmp 0x27c2
leaq -0x68(%rbp), %rdi
callq 0xa9a0
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x279a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x290d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa9a0
jmp 0x290d
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x28e7
movl $0x48, %edi
callq 0x2130
movq %rax, -0xa0(%rbp)
jmp 0x282d
movq -0xa0(%rbp), %rdi
callq 0x3c10
jmp 0x283b
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x3c30
jmp 0x2855
movq -0x98(%rbp), %rax
movq -0x80(%rbp), %rcx
movq $0x0, 0x40(%rcx)
cmpq $0x0, (%rax)
jne 0x28a8
movq -0x98(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
movq -0x80(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, -0x80(%rbp)
jmp 0x28c3
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
callq 0x2110
jmp 0x290d
movq -0x98(%rbp), %rax
movq -0x80(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x40(%rcx)
movq -0x80(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x98(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x280f
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x28fd
movq -0x98(%rbp), %rdi
callq 0x24c0
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x24c0
movq -0x70(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::operator>>(node*&)
void LinkedList::operator>> (node*& lastNode){ 
  if (size > 0) {
    lastNode->data = tail->data;
    lastNode->next = tail->next;

    removeLast();
  } else {
    lastNode = nullptr;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jbe 0x2981
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3c30
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x40(%rax)
callq 0x29a0
jmp 0x298c
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::removeLast()
void LinkedList::removeLast() {
  node* pre = nullptr;
  node* cur = nullptr;

  cur = head;

  while (cur->next != nullptr) {
    pre = cur;
    cur = cur->next;
  }

  tail = pre;
  pre->next = nullptr;

  --size;
  delete cur;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x29ec
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x29cb
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq $0x0, 0x40(%rcx)
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2a30
movq -0x28(%rbp), %rdi
callq 0x3b90
movq -0x28(%rbp), %rdi
callq 0x2110
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::operator<<(node*&)
void LinkedList::operator<< (node*& newNode) {
  if (newNode == nullptr) {
    return;
  } else {
    insertEnd(newNode->data);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2a64
jmp 0x2aa9
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3bb0
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x25f0
jmp 0x2a87
leaq -0x50(%rbp), %rdi
callq 0xa9a0
jmp 0x2aa9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa9a0
jmp 0x2aaf
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x21e0
nopl (%rax,%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::insertStart(Song)
void LinkedList::insertStart(Song value) {
  // Evita a adição de músicas repetidas
  if (search(value) != nullptr) {
    cout << "A música já existe no sistema." << endl;
  } else {
    node* temp = new node;

    temp->data = value;
    temp->next = head;
    head = temp;

    ++size;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3bb0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x2c40
movq %rax, -0x70(%rbp)
jmp 0x2b62
leaq -0x50(%rbp), %rdi
callq 0xa9a0
movq -0x70(%rbp), %rax
cmpq $0x0, %rax
je 0x2bb6
movq 0xc454(%rip), %rdi      # 0xefd0
leaq 0x8481(%rip), %rsi      # 0xb004
callq 0x2120
movq %rax, %rdi
movq 0xc42e(%rip), %rsi      # 0xefc0
callq 0x2140
jmp 0x2c2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa9a0
jmp 0x2c36
movl $0x48, %edi
callq 0x2130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x90(%rbp)
callq 0x3c10
jmp 0x2bd4
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x3c30
movq -0x80(%rbp), %rax
movq (%rax), %rdx
movq -0x68(%rbp), %rcx
movq %rdx, 0x40(%rcx)
movq -0x68(%rbp), %rcx
movq %rcx, (%rax)
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x2c2d
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x2110
jmp 0x2c36
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x21e0
nop
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::insertEnd(LinkedList&)
void LinkedList::insertEnd(LinkedList& toInsert) {
  // Tratamento para garantir que a nova lista não está vazia
  if (toInsert.getSize() < 1) {
    return;
  } else {
    node* temp = toInsert.getHead();

    while (temp != nullptr) {
      // Insere cada elemento no fim da lista atual
      insertEnd(temp->data);
      
      temp = temp->next;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b00
cmpq $0x1, %rax
jae 0x300c
jmp 0x3070
movq -0x10(%rbp), %rdi
callq 0x2ac0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x306e
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3bb0
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x25f0
jmp 0x3040
leaq -0x58(%rbp), %rdi
callq 0xa9a0
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3019
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa9a0
jmp 0x3079
jmp 0x3070
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::removeFirst()
void LinkedList::removeFirst() {
  node* temp = head;

  head = head->next;

  --size;
  delete temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
movq 0x40(%rcx), %rcx
movq %rcx, (%rax)
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x33dd
movq -0x18(%rbp), %rdi
callq 0x3b90
movq -0x18(%rbp), %rdi
callq 0x2110
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::removePosition(unsigned long)
void LinkedList::removePosition(size_t pos) {
  node* pre = nullptr;
  node* cur = nullptr;

  if (pos == 1) {
    removeFirst();
  } else if (pos < size) {
    cur = head;

    for (size_t i = 1; i < pos; ++i) {
      pre = cur;
      cur = cur->next;
    }
    
    pre->next = cur->next;

    --size;
    delete cur;
  } else if (pos < 1) {
    return;
  } else {
    removeLast();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x342d
movq -0x30(%rbp), %rdi
callq 0x3390
jmp 0x34d6
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x34c0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x347e
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3452
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x40(%rcx), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x40(%rcx)
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x34be
movq -0x38(%rbp), %rdi
callq 0x3b90
movq -0x38(%rbp), %rdi
callq 0x2110
jmp 0x34d4
cmpq $0x1, -0x10(%rbp)
jae 0x34c9
jmp 0x34d6
movq -0x30(%rbp), %rdi
callq 0x29a0
jmp 0x34d4
jmp 0x34d6
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::removePosition(LinkedList&)
void LinkedList::removePosition(LinkedList& toRemove) {
  // Tratamento para garantir que a nova lista não está vazia
  if (toRemove.getSize() < 1) {
    return;
  } else {
    node* temp = toRemove.getHead();

    while (temp != nullptr) {
      // Obtém a posição da música na lista atual
      size_t pos = getPosition(temp->data);
  
      // Remove da lista atual
      if (pos > 0) {
        removePosition(pos);
      }                      
      
      temp = temp->next;
    }    
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2b00
cmpq $0x1, %rax
jae 0x350f
jmp 0x359b
movq -0x10(%rbp), %rdi
callq 0x2ac0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3599
movq -0x18(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3bb0
movq -0x78(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x35b0
movq %rax, -0x80(%rbp)
jmp 0x354d
leaq -0x60(%rbp), %rdi
callq 0xa9a0
movq -0x80(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x358b
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x33f0
jmp 0x358b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa9a0
jmp 0x35a4
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x351c
jmp 0x359b
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x21e0
nopl (%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::getNode(unsigned long)
node* LinkedList::getNode(size_t pos) {
  // Caso a posição seja inválida, retorna nullptr
  if (pos < 1 || pos > size) {
    return nullptr;
  } else {
    node* temp = head;

    for (size_t i = 1; i < pos; ++i) {
      temp = temp->next;
    }
    // Retorna o ponteiro para o nó correspondente
    return temp;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x18(%rbp)
jb 0x3999
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x10(%rcx), %rax
jbe 0x39a3
movq $0x0, -0x8(%rbp)
jmp 0x39e2
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x39da
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x39b6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: lorenatoscano[P]musify/src/linkedList.cpp
// Function: LinkedList::display()
void LinkedList::display() {
  node* temp = head;
  size_t index = 1;

  while (temp != nullptr) {
    Song s = temp->data;
    cout << index << " - " << s.getTitle() << " - " << s.getArtist() << endl;
    temp = temp->next;
    ++index;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3b75
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x3bb0
movq -0x18(%rbp), %rsi
movq 0xb59b(%rip), %rdi      # 0xefd0
callq 0x2050
movq %rax, -0xb0(%rbp)
jmp 0x3a43
movq -0xb0(%rbp), %rdi
leaq 0x75d4(%rip), %rsi      # 0xb025
callq 0x2120
movq %rax, -0xb8(%rbp)
jmp 0x3a5f
leaq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa9d0
jmp 0x3a71
movq -0xb8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x2100
movq %rax, -0xc0(%rbp)
jmp 0x3a8d
movq -0xc0(%rbp), %rdi
leaq 0x758a(%rip), %rsi      # 0xb025
callq 0x2120
movq %rax, -0xc8(%rbp)
jmp 0x3aa9
leaq -0xa8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xaa00
jmp 0x3abb
movq -0xc8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2100
movq %rax, -0xd0(%rbp)
jmp 0x3ad7
movq -0xd0(%rbp), %rdi
movq 0xb4db(%rip), %rsi      # 0xefc0
callq 0x2140
jmp 0x3aec
leaq -0xa8(%rbp), %rdi
callq 0x20a0
leaq -0x88(%rbp), %rdi
callq 0x20a0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xa9a0
jmp 0x3a12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x3b6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x3b5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x20a0
leaq -0x88(%rbp), %rdi
callq 0x20a0
leaq -0x58(%rbp), %rdi
callq 0xa9a0
jmp 0x3b7e
addq $0xd0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x21e0
nopw (%rax,%rax)
// File: lorenatoscano[P]musify/src/listOfPlaylists.cpp
// Function: ListOfPlaylists::~ListOfPlaylists()
ListOfPlaylists::~ListOfPlaylists() {
  if (size != 0) {
    node_* temp = nullptr;
    node_* cur = nullptr;

    cur = head;

    while (cur != nullptr) {
      temp = cur->next;
      delete cur->data;
      delete cur;
      cur = temp;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x3e1f
movq -0x20(%rbp), %rax
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3e1d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3dfc
movq -0x28(%rbp), %rdi
callq 0x9c70
movq -0x28(%rbp), %rdi
callq 0x2110
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3e13
movq -0x30(%rbp), %rdi
callq 0x2110
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3dc6
jmp 0x3e1f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/listOfPlaylists.cpp
// Function: ListOfPlaylists::getPlaylist(unsigned long)
Playlist* ListOfPlaylists::getPlaylist(size_t pos) {
  // Caso a posição seja inválida, retorna nullptr
  if (pos < 1 || pos > size) {
    return nullptr;
  } else {
    node_* temp = head;

    for (size_t i = 1; i < pos; ++i) {
      temp = temp->next;
    }
    // Retorna o ponteiro para a playlist correspondente
    return temp->data;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x1, -0x18(%rbp)
jb 0x3e79
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x10(%rcx), %rax
jbe 0x3e83
movq $0x0, -0x8(%rbp)
jmp 0x3ec5
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3eba
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3e96
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: lorenatoscano[P]musify/src/listOfPlaylists.cpp
// Function: ListOfPlaylists::searchPlaylist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Playlist* ListOfPlaylists::searchPlaylist(string searchName) {
  node_* temp = head;

  while (temp != nullptr) {
    // Compara os nomes desconsiderando maiúsculas
    if ( toLowercase(temp->data->getName()) == toLowercase(searchName) ) {
      // Retorna o ponteiro para o nó correspondente
      return temp->data; 
    }

    temp = temp->next;
  }
  // Caso não encontre, retorna nullptr
  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xb8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4005
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xa3c0
movq -0xc0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xaa80
jmp 0x3f29
movq -0xb8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x2080
jmp 0x3f3e
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0xaa80
jmp 0x3f53
leaq -0x40(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x3c70
movb %al, -0xc1(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x20a0
leaq -0xb0(%rbp), %rdi
callq 0x20a0
leaq -0x40(%rbp), %rdi
callq 0x20a0
leaq -0x60(%rbp), %rdi
callq 0x20a0
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x3f9f
jmp 0x3ff4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x400d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x3fe9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x3fe0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x20a0
leaq -0x40(%rbp), %rdi
callq 0x20a0
leaq -0x60(%rbp), %rdi
callq 0x20a0
jmp 0x401a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3ef5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/listOfPlaylists.cpp
// Function: ListOfPlaylists::insertPlaylist(Playlist*)
void ListOfPlaylists::insertPlaylist(Playlist* value) {
  if (searchPlaylist(value->getName()) != nullptr) {
    cout << "Já existe uma playlist com esse nome no sistema." << endl;
  } else {
    node_* temp = new node_;

    temp->data = value;
    temp->next = nullptr;

    if (head == nullptr) {
      head =  temp;
      tail = temp;
      temp = nullptr;
    } else {
      tail->next = temp;
      tail = temp;
    }

    ++size;
    cout << "Playlist criada! Adicione algumas músicas." << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xa3c0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x3ed0
movq %rax, -0x50(%rbp)
jmp 0x406c
leaq -0x30(%rbp), %rdi
callq 0x20a0
movq -0x50(%rbp), %rax
cmpq $0x0, %rax
je 0x40c0
movq 0xaf4a(%rip), %rdi      # 0xefd0
leaq 0x6f9c(%rip), %rsi      # 0xb029
callq 0x2120
movq %rax, %rdi
movq 0xaf24(%rip), %rsi      # 0xefc0
callq 0x2140
jmp 0x4159
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20a0
jmp 0x415f
movl $0x10, %edi
callq 0x2130
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq -0x10(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x48(%rbp), %rcx
movq $0x0, 0x8(%rcx)
cmpq $0x0, (%rax)
jne 0x410f
movq -0x60(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, -0x48(%rbp)
jmp 0x4127
movq -0x60(%rbp), %rax
movq -0x48(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0xae92(%rip), %rdi      # 0xefd0
leaq 0x6f16(%rip), %rsi      # 0xb05b
callq 0x2120
movq %rax, %rdi
movq 0xae6c(%rip), %rsi      # 0xefc0
callq 0x2140
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x21e0
nopl (%rax,%rax)
// File: lorenatoscano[P]musify/src/listOfPlaylists.cpp
// Function: ListOfPlaylists::removePlaylist(unsigned long)
void ListOfPlaylists::removePlaylist(size_t pos) {
  node_* pre = nullptr;
  node_* cur = nullptr;

  cur = head;

  if (pos == 1) {
    head = head->next;
  } else if (pos < size) {
    for (size_t i = 1; i < pos; ++i) {
      pre = cur;
      cur = cur->next;
    }
    
    pre->next = cur->next;
  } else {
    while (cur->next != nullptr) {
      pre = cur;
      cur = cur->next;
    }

    tail = pre;
    pre->next = nullptr;
  }

  --size;
  delete cur->data;
  delete cur;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x41b9
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
jmp 0x424a
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x420d
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x41fb
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x41cf
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4248
jmp 0x420f
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4230
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x420f
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x424a
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x427d
movq -0x38(%rbp), %rdi
callq 0x9c70
movq -0x38(%rbp), %rdi
callq 0x2110
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x4294
movq -0x40(%rbp), %rdi
callq 0x2110
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lorenatoscano[P]musify/src/listOfPlaylists.cpp
// Function: ListOfPlaylists::removeFromAll(Song)
void ListOfPlaylists::removeFromAll(Song target) {
  node_* temp = head;

  // Percorre as playlists do sistema
  while (temp != nullptr) {
    // Guarda a lista de músicas atual
    LinkedList* songs = temp->data->getSongs();

    // Verifica se o alvo está na lista 
    if (songs->search(target) != nullptr) {
      // Obtém a posição numérica da música
      size_t pos = songs->getPosition(target);
      // Remove a música da lista
      songs->removePosition(pos);
    }

    temp = temp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x43e1
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0xa120
movq -0xc0(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3bb0
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x2c40
movq %rax, -0xc8(%rbp)
jmp 0x431e
leaq -0x60(%rbp), %rdi
callq 0xa9a0
movq -0xc8(%rbp), %rax
cmpq $0x0, %rax
je 0x43d0
movq -0xc0(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3bb0
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
callq 0x35b0
movq %rax, -0xe0(%rbp)
jmp 0x4379
leaq -0xb8(%rbp), %rdi
callq 0xa9a0
movq -0xe0(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x33f0
jmp 0x43d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xa9a0
jmp 0x43ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0xa9a0
jmp 0x43ea
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x42c5
addq $0xf0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/listOfPlaylists.cpp
// Function: ListOfPlaylists::display()
void ListOfPlaylists::display() {
  node_* temp = head;
  size_t index = 1;
  string name = "";

  while (temp != nullptr) {
    name = temp->data->getName();
    cout << index << " - " << name << endl;
    temp = temp->next;
    ++index;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x21f0
movq -0x78(%rbp), %rdx
leaq 0x6bee(%rip), %rsi      # 0xb028
leaq -0x38(%rbp), %rdi
callq 0x2180
jmp 0x4445
leaq -0x39(%rbp), %rdi
callq 0x2150
cmpq $0x0, -0x10(%rbp)
je 0x4533
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0x70(%rbp), %rdi
callq 0xa3c0
jmp 0x446b
leaq -0x38(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %rsi, -0x88(%rbp)
callq 0x2160
movq -0x88(%rbp), %rdi
callq 0x20a0
movq -0x18(%rbp), %rsi
movq 0xab3a(%rip), %rdi      # 0xefd0
callq 0x2050
movq %rax, -0x80(%rbp)
jmp 0x44a1
movq -0x80(%rbp), %rdi
leaq 0x6b79(%rip), %rsi      # 0xb025
callq 0x2120
movq %rax, -0x90(%rbp)
jmp 0x44ba
movq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2100
movq %rax, -0x98(%rbp)
jmp 0x44d3
movq -0x98(%rbp), %rdi
movq 0xaadf(%rip), %rsi      # 0xefc0
callq 0x2140
jmp 0x44e8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x444e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x2150
jmp 0x4545
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20a0
jmp 0x4545
leaq -0x38(%rbp), %rdi
callq 0x20a0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x21e0
nop
// File: lorenatoscano[P]musify/src/playlist.cpp
// Function: Playlist::Playlist(Playlist const&)
Playlist::Playlist(const Playlist& old) {
  songs = new LinkedList;
  playing = nullptr;
  count = 1;
  name = old.name;

  node* temp = old.songs->getHead();

  while (temp != nullptr) {
    songs->insertEnd(temp->data);

    temp = temp->next;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x2190
movl $0x18, %edi
callq 0x2130
movq %rax, -0x70(%rbp)
jmp 0x9cf7
movq -0x70(%rbp), %rdi
callq 0x2490
jmp 0x9d02
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x1, 0x30(%rdi)
movq -0x10(%rbp), %rsi
callq 0x2030
jmp 0x9d29
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2ac0
movq %rax, -0x88(%rbp)
jmp 0x9d3f
movq -0x88(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9dd8
movq -0x78(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3bb0
jmp 0x9d73
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x25f0
jmp 0x9d85
leaq -0x68(%rbp), %rdi
callq 0xa9a0
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9d4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x9de1
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x9de1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xa9a0
jmp 0x9de1
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x20a0
movq -0x18(%rbp), %rdi
callq 0x21e0
nopw %cs:(%rax,%rax)
// File: lorenatoscano[P]musify/src/playlist.cpp
// Function: Playlist::operator+(Playlist&)
Playlist Playlist::operator+ (Playlist& secondPlaylist) {
  Playlist result;
  
  // Insere as músicas da playlist atual na playlist final
  result.insertSong(*this); 

  // Insere as músicas da segunda playlist na playlist final
  result.insertSong(secondPlaylist);

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x9bd0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x9e90
jmp 0x9e3f
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9e90
jmp 0x9e4e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x9e7a
jmp 0x9e71
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9c70
jmp 0x9e84
movq -0x40(%rbp), %rdi
callq 0x9c70
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x21e0
nopl (%rax)
// File: lorenatoscano[P]musify/src/playlist.cpp
// Function: Playlist::insertSong(Playlist&)
void Playlist::insertSong(Playlist& toInsert) {
  // Tratamento para garantir que a nova lista não está vazia
  if (toInsert.getSongs()->getSize() < 1) {
    return;
  } else {
    // Insere as músicas na playlist atual por meio de sobrecarga
    songs->insertEnd(*toInsert.getSongs());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa120
movq %rax, %rdi
callq 0x2b00
cmpq $0x1, %rax
jae 0x9ec1
jmp 0x9ee2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa120
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x2fe0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lorenatoscano[P]musify/src/playlist.cpp
// Function: Playlist::operator+(Song&)
Playlist Playlist::operator+ (Song& toAdd) {
  Playlist result;

  // Insere as músicas da playlist atual na playlist final
  result.insertSong(*this); 

  // Insere a música do parâmetro no final
  result.songs->insertEnd(toAdd);

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x9bd0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x9e90
jmp 0x9f35
movq -0x80(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x3bb0
jmp 0x9f53
movq -0x90(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x25f0
jmp 0x9f65
leaq -0x70(%rbp), %rdi
callq 0xa9a0
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x9fa8
jmp 0x9f9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x9fb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xa9a0
jmp 0x9fb8
movq -0x80(%rbp), %rdi
callq 0x9c70
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x9c70
movq -0x28(%rbp), %rdi
callq 0x21e0
nopw (%rax,%rax)
// File: lorenatoscano[P]musify/src/playlist.cpp
// Function: Playlist::operator-(Playlist&)
Playlist Playlist::operator- (Playlist& secondPlaylist) {
  // Cria a playlist final a partir da playlist atual
  Playlist result(*this);

  node* temp = secondPlaylist.getSongs()->getHead();
  // Percorre a segunda playlist
  while (temp != nullptr) {
    // Procura a posição da música na playlist final
    size_t pos = result.getSongs()->getPosition(temp->data);

    
    if (pos > 0) {
      result.removeSong(pos);
    }

    temp = temp->next;
  }
  
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0x9cc0
movq -0x18(%rbp), %rdi
callq 0xa120
movq %rax, -0x88(%rbp)
jmp 0xa017
movq -0x88(%rbp), %rdi
callq 0x2ac0
movq %rax, -0xa0(%rbp)
jmp 0xa02c
movq -0xa0(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa0e4
movq -0x98(%rbp), %rdi
callq 0xa120
movq %rax, -0xa8(%rbp)
jmp 0xa057
movq -0x28(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x3bb0
jmp 0xa066
movq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x35b0
movq %rax, -0xb0(%rbp)
jmp 0xa07f
leaq -0x80(%rbp), %rdi
callq 0xa9a0
movq -0xb0(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jbe 0xa0d3
movq -0x98(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xa140
jmp 0xa0ac
jmp 0xa0d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xa10a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xa9a0
jmp 0xa10a
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xa037
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xa0fa
movq -0x98(%rbp), %rdi
callq 0x9c70
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x9c70
movq -0x30(%rbp), %rdi
callq 0x21e0
nop
// File: lorenatoscano[P]musify/src/playlist.cpp
// Function: Playlist::operator-(Song&)
Playlist Playlist::operator- (Song& toRemove) {
  // Cria a playlist final a partir da playlist atual
  Playlist result(*this);

  // Obtém a posição da música na playlist final
  size_t pos = result.getSongs()->getPosition(toRemove);

  // Se existir, remove
  if (pos > 0) {
    result.removeSong(pos);
  }

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x19(%rbp)
callq 0x9cc0
movq -0x88(%rbp), %rdi
callq 0xa120
movq %rax, -0x80(%rbp)
jmp 0xa1b7
movq -0x18(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x3bb0
jmp 0xa1c6
movq -0x80(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x35b0
movq %rax, -0x98(%rbp)
jmp 0xa1dc
leaq -0x78(%rbp), %rdi
callq 0xa9a0
movq -0x98(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0xa230
movq -0x88(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa140
jmp 0xa209
jmp 0xa230
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xa256
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xa9a0
jmp 0xa256
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xa246
movq -0x88(%rbp), %rdi
callq 0x9c70
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x9c70
movq -0x30(%rbp), %rdi
callq 0x21e0
nopl (%rax,%rax)
// File: lorenatoscano[P]musify/src/playlist.cpp
// Function: Playlist::operator>>(Song*&)
void Playlist::operator>> (Song*& lastSong) {
  if (songs->getSize() > 0) {
    node* temp = new node;
    // Extrai o ultimo nó da lista de músicas
    *songs >> temp;
    // Guarda a música desse nó
    *lastSong = temp->data;

    delete temp;
  } else {
    lastSong = nullptr;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x20(%rax), %rdi
callq 0x2b00
cmpq $0x0, %rax
jbe 0xa314
movl $0x48, %edi
callq 0x2130
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x3c10
jmp 0xa2b2
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x20(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2930
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3c30
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xa2fb
movq -0x40(%rbp), %rdi
callq 0x3b90
movq -0x40(%rbp), %rdi
callq 0x2110
jmp 0xa31f
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2110
jmp 0xa325
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x21e0
nop