LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/lega911[P]ijson/src/server.cpp
// Function: Loop::add_worker(ISlice, Connect*)
void Loop::add_worker(ISlice name, Connect *worker) {
    char *ptr = name.ptr();
    int start = 0;
    int i = 0;
    Slice n;
    for(;i<name.size();i++) {
        if(ptr[i] == ',' || ptr[i] == ' ') {
            n.set(&ptr[start], i - start);
            start = i + 1;
            if(_add_worker(n, worker) == 1) {
                // worker is taken
                return;
            }
        }
    }
    if(start < name.size()) {
        n.set(&ptr[start], i - start);
        _add_worker(n, worker);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
jle 0x11e7d
movl %edx, -0x2c(%rbp)
movl %edx, %r13d
xorl %r12d, %r12d
xorl %eax, %eax
movzbl (%r14,%r12), %ecx
cmpl $0x2c, %ecx
je 0x11e51
cmpl $0x20, %ecx
jne 0x11e70
cltq
leaq (%r14,%rax), %rsi
movl %r12d, %edx
subl %eax, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x11ebe
testl %eax, %eax
jne 0x11eae
leaq 0x1(%r12), %rax
incq %r12
cmpq %r12, %r13
jne 0x11e42
movl -0x2c(%rbp), %edx
jmp 0x11e82
xorl %r12d, %r12d
xorl %eax, %eax
cmpl %edx, %eax
jge 0x11eae
movslq %eax, %rcx
addq %rcx, %r14
subl %eax, %r12d
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11ebe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lega911[P]ijson/src/server.cpp
// Function: Loop::worker_result(ISlice, Connect*)
int Loop::worker_result(ISlice id, Connect *worker) {
    auto it = server->wait_response.find(id.as_string());
    if(it == server->wait_response.end()) return -1;
    Connect *client = it->second;
    server->wait_lock.lock();
    server->wait_response.erase(it);
    server->wait_lock.unlock();

    client->unlink();
    if(client->is_closed()) return -2;
    if(worker) client->send.status("200 OK")->header("Id", id)->done(worker->body);
    else client->send.status("503 Service Unavailable")->header("Id", id)->done(-1);
    client->status = Status::net;

    if(worker && worker->nloop != worker->need_loop) migrate(worker, client);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq -0x30(%rbp), %rax
movq %rsi, (%rax)
movl %edx, 0x8(%rax)
movl $0x20128, %r15d         # imm = 0x20128
addq 0x18(%rdi), %r15
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0xc468
movq %r15, %rdi
movq %r12, %rsi
callq 0x14586
movq %rax, %r12
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12c82
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8320
movq 0x18(%r14), %rdi
leaq 0x20130(%rdi), %rax
cmpq %rax, %r12
je 0x12d11
movq 0x40(%r12), %r15
addq $0x20158, %rdi          # imm = 0x20158
callq 0x83f0
testl %eax, %eax
jne 0x12d86
movl $0x20128, %edi          # imm = 0x20128
addq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0x15d14
movl $0x20158, %edi          # imm = 0x20158
addq 0x18(%r14), %rdi
callq 0x8240
movq %r15, %rdi
callq 0x898c
cmpl $-0x1, (%r15)
je 0x12d19
leaq 0x18(%r15), %rdi
testq %rbx, %rbx
je 0x12d21
leaq 0x4551(%rip), %rsi      # 0x17239
callq 0x9ee0
leaq 0x58ad(%rip), %rsi      # 0x185a1
leaq -0x30(%rbp), %rdx
movq %rax, %rdi
callq 0xbbd6
leaq 0xd0(%rbx), %rsi
movq %rax, %rdi
callq 0xa704
jmp 0x12d4d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x12d76
movl $0xfffffffe, %r12d      # imm = 0xFFFFFFFE
jmp 0x12d76
leaq 0x58d7(%rip), %rsi      # 0x185ff
callq 0x9ee0
leaq 0x586d(%rip), %rsi      # 0x185a1
leaq -0x30(%rbp), %rdx
movq %rax, %rdi
callq 0xbbd6
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9f54
xorl %r12d, %r12d
movl $0x0, 0xcc(%r15)
testq %rbx, %rbx
je 0x12d76
movl 0x38(%rbx), %eax
cmpl 0x3c(%rbx), %eax
je 0x12d76
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x12db2
movl %r12d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x81d0
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12da9
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x8320
movq %rbx, %rdi
callq 0x84a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/lega911[P]ijson/src/server.cpp
// Function: Loop::migrate(Connect*, Connect*)
void Loop::migrate(Connect *w, Connect *c) {
    if(_nloop == w->need_loop && server->log & 1) std::cout << "migrate warning: connection is on target loop\n";

    w->go_loop = true;
    c->go_loop = true;
    c->need_loop = w->need_loop;
    if(server->log & 64) std::cout << "migrate: loop " << _nloop << " -> " << w->need_loop << ", fd " << w->fd << ", " << c->fd << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rdi), %eax
cmpl 0x3c(%rsi), %eax
jne 0x12df0
movq 0x18(%r15), %rax
testb $0x1, 0x20(%rax)
je 0x12df0
movq 0xb1f1(%rip), %rdi      # 0x1dfd0
leaq 0x58c7(%rip), %rsi      # 0x186ad
movl $0x2e, %edx
callq 0x8350
movb $0x1, %al
movb %al, 0x40(%r14)
movb %al, 0x40(%rbx)
movl 0x3c(%r14), %eax
movl %eax, 0x3c(%rbx)
movq 0x18(%r15), %rax
testb $0x40, 0x20(%rax)
jne 0x12e13
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xb1b6(%rip), %r12      # 0x1dfd0
leaq 0x58bb(%rip), %rsi      # 0x186dc
movl $0xe, %edx
movq %r12, %rdi
callq 0x8350
movl 0x4(%r15), %esi
movq %r12, %rdi
callq 0x8490
movq %rax, %r15
leaq 0x566d(%rip), %rsi      # 0x184b1
movl $0x4, %edx
movq %rax, %rdi
callq 0x8350
movl 0x3c(%r14), %esi
movq %r15, %rdi
callq 0x8490
movq %rax, %r15
leaq 0x5884(%rip), %rsi      # 0x186eb
movl $0x5, %edx
movq %rax, %rdi
callq 0x8350
movl 0xc(%r14), %esi
movq %r15, %rdi
callq 0x8490
movq %rax, %r14
leaq 0x5624(%rip), %rsi      # 0x184ae
movl $0x2, %edx
movq %rax, %rdi
callq 0x8350
movl 0xc(%rbx), %esi
movq %r14, %rdi
callq 0x8490
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x82f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x81f0
// File: /workspace/github_cpp_makefile_star2_O1/lega911[P]ijson/src/server.cpp
// Function: Loop::worker_result_noid(Connect*)
int Loop::worker_result_noid(Connect *worker) {
    stat_result++;
    auto client = worker->client;
    if(!client) THROW("No connected client for noid");

    if(!worker->worker_mode) {
        worker->noid = false;
        worker->fail_on_disconnect = false;
    }
    worker->client = NULL;
    client->unlink();

    if(client->is_closed()) return -2;
    client->status = Status::net;
    client->send.status("200 OK")->done(worker->body);

    if(worker->nloop != worker->need_loop) migrate(worker, client);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
incq 0x88(%rdi)
movq 0x120(%rsi), %r14
testq %r14, %r14
je 0x12f81
movq %rdi, %rbx
movq %rsi, %r15
cmpb $0x0, 0xf3(%rsi)
jne 0x12f0f
movw $0x0, 0xf0(%r15)
movq $0x0, 0x120(%r15)
movq %r14, %rdi
callq 0x898c
cmpl $-0x1, (%r14)
je 0x12f6f
movl $0x0, 0xcc(%r14)
leaq 0x18(%r14), %rdi
leaq 0x42fb(%rip), %rsi      # 0x17239
callq 0x9ee0
leaq 0xd0(%r15), %rsi
movq %rax, %rdi
callq 0xa704
movl 0x38(%r15), %eax
xorl %r12d, %r12d
cmpl 0x3c(%r15), %eax
je 0x12f75
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12db2
jmp 0x12f75
movl $0xfffffffe, %r12d      # imm = 0xFFFFFFFE
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x30, %edi
callq 0x8170
movq %rax, %rbx
leaq 0x5682(%rip), %rsi      # 0x18617
leaq 0x5256(%rip), %rdx      # 0x181f2
leaq 0x5691(%rip), %r8       # 0x18634
movq %rax, %rdi
movl $0x3ac, %ecx            # imm = 0x3AC
callq 0xcd04
leaq 0xad61(%rip), %rsi      # 0x1dd18
leaq -0x5cae(%rip), %rdx     # 0xd310
movq %rbx, %rdi
callq 0x8480
movq %rax, %r14
movq %rbx, %rdi
callq 0x8220
movq %r14, %rdi
callq 0x84a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/lega911[P]ijson/src/connect.h
// Function: Connect::Connect(Server*, int)
Connect(Server *server, int fd) {
        this->server = server;
        this->fd = fd;
        loop = server->loops[0];
        send.set_connect(this);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rdi)
xorl %eax, %eax
movl %eax, 0x8(%rdi)
leaq 0x88(%rdi), %r14
leaq 0xb8(%rdi), %r15
movl %eax, 0x160(%rdi)
movl %eax, 0x140(%rdi)
movq %rax, 0x138(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rdi)
movl %eax, 0x158(%rdi)
movq %rax, 0x168(%rdi)
movl %eax, 0x170(%rdi)
leaq 0x190(%rdi), %rdi
movups %xmm0, 0x18(%rbx)
movq %rax, 0x28(%rbx)
movq %rax, 0x38(%rbx)
movb $0x0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x6c(%rbx)
movups %xmm0, 0xa4(%rbx)
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0x88(%rbx)
movq %rax, 0xe8(%rbx)
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xc8(%rbx)
movups %xmm0, 0xb8(%rbx)
movups %xmm0, 0x122(%rbx)
movups %xmm0, 0x112(%rbx)
movups %xmm0, 0x102(%rbx)
movups %xmm0, 0xf2(%rbx)
movw $0x0, 0x132(%rbx)
movq %rax, 0x1d8(%rbx)
movups %xmm0, 0x1c8(%rbx)
movups %xmm0, 0x1b8(%rbx)
movups %xmm0, 0x1a8(%rbx)
movups %xmm0, 0x198(%rbx)
movups %xmm0, 0x188(%rbx)
movups %xmm0, 0x178(%rbx)
xorl %esi, %esi
callq 0x13778
movq $0x0, 0x1e0(%rbx)
movq %r12, 0x48(%rbx)
movl %r13d, 0xc(%rbx)
movq 0x20050(%r12), %rax
movq (%rax), %rax
movq %rax, 0x30(%rbx)
movq %rbx, 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x48(%rbp)
leaq 0x180(%rbx), %rdi
leaq 0x110(%rbx), %r13
leaq 0x100(%rbx), %r12
leaq 0xe0(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq 0xd0(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0x98(%rbx), %rax
movq %rax, -0x40(%rbp)
addq $0x20, %rbx
callq 0xc536
movq %r13, %rdi
callq 0xc536
movq %r12, %rdi
callq 0xc536
movq -0x30(%rbp), %rdi
callq 0xc536
movq -0x38(%rbp), %rdi
callq 0xc536
movq %r15, %rdi
callq 0xc536
movq -0x40(%rbp), %rdi
callq 0xc536
movq %r14, %rdi
callq 0xc536
movq %rbx, %rdi
callq 0xc536
movq -0x48(%rbp), %rdi
callq 0x84a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/lega911[P]ijson/src/service.cpp
// Function: Service::_free_memory()
void Service::_free_memory() {
    if(!server->_free_list.size()) return;

    server->_free_lock.lock();
    std::vector<char*> v(server->_free_list);
    server->_free_list.clear();
    server->_free_lock.unlock();
    usleep(10'000);
    for(auto const &ptr : v) _free(ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x200b8(%rdi), %rax
cmpq 0x200b0(%rdi), %rax
je 0x16105
addq $0x20088, %rdi          # imm = 0x20088
callq 0x83f0
testl %eax, %eax
jne 0x1610e
movl $0x200b0, %esi          # imm = 0x200B0
addq 0x8(%rbx), %rsi
leaq -0x28(%rbp), %rdi
callq 0x16420
movq 0x8(%rbx), %rdi
movq 0x200b0(%rdi), %rax
cmpq %rax, 0x200b8(%rdi)
je 0x160bf
movq %rax, 0x200b8(%rdi)
addq $0x20088, %rdi          # imm = 0x20088
callq 0x8240
movl $0x2710, %edi           # imm = 0x2710
callq 0x83d0
movq -0x28(%rbp), %rbx
movq -0x20(%rbp), %r14
cmpq %r14, %rbx
je 0x160f0
movq (%rbx), %rdi
callq 0xee37
addq $0x8, %rbx
jmp 0x160dd
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x16105
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x8320
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %edi
callq 0x81d0
jmp 0x16117
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x1612f
movq -0x18(%rbp), %rsi
subq %rdi, %rsi
callq 0x8320
movq %rbx, %rdi
callq 0x84a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/lega911[P]ijson/src/utils.cpp
// Function: Lock::lock(int)
void Lock::lock(int n) {
    u64 v = 1 << n;
    if(mask & v) return;
    mask |= v;
    server->loops[n]->del_lock.lock();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
movq 0x8(%rdi), %rdx
testq %rax, %rdx
jne 0x16827
orq %rax, %rdx
movq %rdx, 0x8(%rdi)
movq (%rdi), %rax
movq 0x20050(%rax), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
addq $0x38, %rdi
callq 0x83f0
testl %eax, %eax
jne 0x16829
popq %rbp
retq
movl %eax, %edi
callq 0x81d0
// File: /workspace/github_cpp_makefile_star2_O1/lega911[P]ijson/src/utils.cpp
// Function: Lock::unlock()
void Lock::unlock() {
    u64 v = 1;
    for(int i=0;i<server->threads;i++) {
        if(v & mask) server->loops[i]->del_lock.unlock();
        v <<= 1;
    }
    mask = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
cmpl $0x0, 0x28(%rax)
jle 0x1687b
movl $0x1, %r14d
xorl %r15d, %r15d
testq %r14, 0x8(%rbx)
je 0x16869
movq 0x20050(%rax), %rax
movq (%rax,%r15,8), %rdi
addq $0x38, %rdi
callq 0x8240
addq %r14, %r14
incq %r15
movq (%rbx), %rax
movslq 0x28(%rax), %rcx
cmpq %rcx, %r15
jl 0x1684f
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r15
je 0x16979
movl 0x8(%r15), %eax
cmpl $0x2, %eax
je 0x16953
cmpl $0x1, %eax
jne 0x16973
movq (%r15), %r14
testq %r14, %r14
je 0x16973
movq %r14, %rdi
callq 0x12fda
movl $0x38, %esi
jmp 0x1696b
movq (%r15), %r14
lock
decl 0x3c(%r14)
jne 0x16973
leaq 0x28(%r14), %rdi
callq 0xc536
movl $0x40, %esi
movq %r14, %rdi
callq 0x8320
addq $0x10, %r15
jmp 0x16929
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x16986
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x16a00
xorl %r15d, %r15d
leaq 0x1e11(%rip), %rax      # 0x187c0
movq %rsi, %rcx
movl %esi, %edx
andl $0xf, %edx
movb (%rdx,%rax), %dl
movb %dl, -0x21(%rbp,%r15)
shrq $0x4, %rcx
decq %r15
cmpq $0xf, %rsi
movq %rcx, %rsi
ja 0x169b2
leaq (%r15,%rbp), %r14
addq $-0x20, %r14
movl 0x8(%rbx), %esi
subl %r15d, %esi
movq %rbx, %rdi
callq 0xc5a2
movslq 0x8(%rbx), %rdi
addq (%rbx), %rdi
movq %r15, %rdx
negq %rdx
movq %r14, %rsi
callq 0x8270
subl %r15d, 0x8(%rbx)
jmp 0x16a1b
movl 0x8(%rbx), %esi
incl %esi
movq %rbx, %rdi
callq 0xc5a2
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
movb $0x30, (%rax,%rcx)
incl 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x83f0
testl %eax, %eax
jne 0x16c29
movq (%rbx), %rdi
cmpq %rbx, 0x28(%rdi)
je 0x16bf6
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x16beb
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
jne 0x16c05
jmp 0x16c09
movq 0x10(%rbx), %rcx
movq %rcx, 0x28(%rdi)
testq %rcx, %rcx
je 0x16c09
xorl %eax, %eax
movq %rax, 0x8(%rcx)
callq 0x8240
movq %rbx, %rdi
callq 0x16b8c
movl $0x20, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8320
movl %eax, %edi
callq 0x81d0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x20, %edi
callq 0xee48
movq %rax, %r14
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %r15, 0x18(%rax)
incl 0x8(%r15)
movq %rbx, %rdi
callq 0x83f0
testl %eax, %eax
jne 0x16c96
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x16c7c
movq %rax, 0x10(%r14)
movq %r14, 0x8(%rax)
movq %r14, 0x28(%rbx)
movq %rbx, %rdi
callq 0x8240
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x81d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
cmpq $0x0, 0x10(%rdi)
sete %al
movq (%rdi), %rbx
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x2418
movq 0x40(%rbx), %r14
movq %rbx, %rdi
callq 0x99c6
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rbx
testq %r14, %r14
jne 0x23fc
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r13
testq %r13, %r13
je 0x24a2
movq %rdi, %rbx
leaq -0x48(%rbp), %r14
leaq -0x38(%rbp), %r12
leaq -0x68(%rbp), %r15
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x37d8
movq %r12, -0x48(%rbp)
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x37d8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24dc
movq %r15, %rdi
callq 0x99c6
movq 0x40(%r13), %r13
testq %r13, %r13
jne 0x2454
addq $0x48, %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 0x24d4
callq 0x20e0
jmp 0x24d4
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x99c6
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x37d8
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x37d8
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x2a10
movq %rax, %r15
leaq -0x60(%rbp), %rdi
callq 0x99c6
testq %r15, %r15
je 0x2589
movq 0xba84(%rip), %rbx      # 0xdfd0
leaq 0x7ab1(%rip), %rsi      # 0xa004
movl $0x20, %edx
movq %rbx, %rdi
callq 0x2120
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2080
jmp 0x25df
movl $0x48, %edi
callq 0x2100
movq %rax, %r15
movq %rax, %rdi
callq 0x99a0
leaq 0x20(%r14), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x2040
movq %r15, %rdi
addq $0x20, %rdi
movq %r12, %rsi
callq 0x2040
movq $0x0, 0x40(%r15)
cmpq $0x0, (%rbx)
je 0x25d4
movq 0x8(%rbx), %rax
movq %r15, 0x40(%rax)
jmp 0x25d7
movq %r15, (%rbx)
movq %r15, 0x8(%rbx)
incq 0x10(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
jmp 0x260e
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x99c6
jmp 0x2613
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x2613
callq 0x20e0
movq %rbx, %rdi
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x30(%rbp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r14
testq %r14, %r14
je 0x26a3
leaq -0x50(%rbp), %r15
leaq -0x40(%rbp), %r13
leaq -0x70(%rbp), %r12
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x37d8
movq %r13, -0x50(%rbp)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x37d8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x24dc
movq %r12, %rdi
callq 0x99c6
movq 0x40(%r14), %r14
testq %r14, %r14
jne 0x2656
movq (%rbx), %r12
movq -0x30(%rbp), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x2713
movl $0x48, %edi
callq 0x2100
movq %rax, %r15
movq %rax, %rdi
callq 0x99a0
movq %r15, %rdi
movq %r14, %rsi
callq 0x2040
movq %r15, %rdi
addq $0x20, %rdi
leaq 0x20(%r14), %rsi
callq 0x2040
movq $0x0, 0x40(%r15)
movq %r15, %rax
testq %r12, %r12
je 0x26fd
movq 0x8(%rbx), %rax
movq %r15, 0x40(%rax)
movq %r12, %rax
movq %r15, 0x8(%rbx)
incq 0x10(%rbx)
movq 0x40(%r14), %r14
movq %rax, %r12
testq %r14, %r14
jne 0x26b2
jmp 0x2716
movq %r12, %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, (%rbx)
movq %r15, %rdi
jmp 0x274b
movq %rax, %r14
jmp 0x2766
movq %rax, %r14
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x2766
callq 0x20e0
jmp 0x2766
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x99c6
jmp 0x2766
movq %rax, %r14
movq %r12, (%rbx)
movq %rbx, %rdi
callq 0x23e0
movq %r14, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x27d2
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq (%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2040
addq $0x20, %r12
addq $0x20, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x2040
movq 0x8(%r14), %rax
movq 0x40(%rax), %rax
movq (%rbx), %rcx
movq %rax, 0x40(%rcx)
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x27e2
movq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq (%rdi), %rax
xorl %ecx, %ecx
movq %rax, %rbx
movq %rcx, %rdx
movq 0x40(%rax), %rax
movq %rbx, %rcx
testq %rax, %rax
jne 0x27ed
movq %rdx, 0x8(%rdi)
movq $0x0, 0x40(%rdx)
decq 0x10(%rdi)
testq %rbx, %rbx
je 0x282a
movq %rbx, %rdi
callq 0x99c6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20e0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq (%rsi), %r15
testq %r15, %r15
je 0x2896
movq %rdi, %rbx
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0x37d8
leaq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
callq 0x37d8
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x24dc
leaq -0x58(%rbp), %rdi
callq 0x99c6
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x99c6
jmp 0x28c0
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0x28c0
callq 0x20e0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x37d8
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x37d8
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x2a10
movq %rax, %r15
leaq -0x60(%rbp), %rdi
callq 0x99c6
testq %r15, %r15
je 0x2993
movq 0xb67a(%rip), %rbx      # 0xdfd0
leaq 0x76a7(%rip), %rsi      # 0xa004
movl $0x20, %edx
movq %rbx, %rdi
callq 0x2120
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2080
jmp 0x29d4
movl $0x48, %edi
callq 0x2100
movq %rax, %r15
movq %rax, %rdi
callq 0x99a0
leaq 0x20(%r14), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x2040
movq %r15, %rdi
addq $0x20, %rdi
movq %r12, %rsi
callq 0x2040
movq (%rbx), %rax
movq %rax, 0x40(%r15)
movq %r15, (%rbx)
incq 0x10(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
jmp 0x2a03
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x99c6
jmp 0x2a08
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x2a08
callq 0x20e0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x10(%rsi)
je 0x2deb
movq (%rsi), %r13
testq %r13, %r13
je 0x2deb
movq %rdi, %rbx
leaq -0x48(%rbp), %r14
leaq -0x38(%rbp), %r12
leaq -0x68(%rbp), %r15
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x37d8
movq %r12, -0x48(%rbp)
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x37d8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24dc
movq %r15, %rdi
callq 0x99c6
movq 0x40(%r13), %r13
testq %r13, %r13
jne 0x2d9d
addq $0x48, %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 0x2e1d
callq 0x20e0
jmp 0x2e1d
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x99c6
movq %rbx, %rdi
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movq 0x40(%rbx), %rax
movq %rax, (%rdi)
decq 0x10(%rdi)
testq %rbx, %rbx
je 0x313f
movq %rbx, %rdi
callq 0x99c6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20e0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
cmpq $0x1, %rsi
jne 0x315d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3110
movq 0x10(%rdi), %rax
cmpq %rsi, %rax
jbe 0x31a2
movq (%rdi), %rbx
decq %rsi
movq %rbx, %rcx
movq 0x40(%rbx), %rbx
decq %rsi
jne 0x316c
movq 0x40(%rbx), %rdx
movq %rdx, 0x40(%rcx)
decq %rax
movq %rax, 0x10(%rdi)
testq %rbx, %rbx
je 0x31b2
movq %rbx, %rdi
callq 0x99c6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20e0
testq %rsi, %rsi
je 0x31b2
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x27e2
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpq $0x0, 0x10(%rsi)
je 0x3247
movq (%rsi), %r13
testq %r13, %r13
je 0x3247
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
leaq -0x68(%rbp), %r15
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x37d8
movq %r14, -0x48(%rbp)
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x37d8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3282
movq %rax, %r12
movq %r15, %rdi
callq 0x99c6
testq %r12, %r12
je 0x323e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3146
movq 0x40(%r13), %r13
testq %r13, %r13
jne 0x31e5
addq $0x48, %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 0x3279
callq 0x20e0
jmp 0x3279
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x99c6
movq %rbx, %rdi
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rdi), %r12
testq %r12, %r12
je 0x3760
movl $0x1, %r14d
leaq -0xa8(%rbp), %r15
leaq 0x69df(%rip), %r13      # 0xa025
leaq -0x98(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x37d8
leaq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x37d8
movq 0xa93d(%rip), %rdi      # 0xdfd0
movq %r14, %rsi
callq 0x2070
movq %rax, %rbx
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2120
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x99fc
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x2120
movq %rax, %rbx
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2120
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x9a28
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x2120
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2080
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3735
callq 0x20e0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3747
callq 0x20e0
movq 0x40(%r12), %r12
incq %r14
movq %r15, %rdi
callq 0x99c6
testq %r12, %r12
jne 0x3646
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rax
cmpq %rax, %rdi
je 0x37d0
callq 0x20e0
jmp 0x37d0
jmp 0x3793
jmp 0x3798
movq %rax, %rbx
jmp 0x37c4
movq %rax, %rbx
jmp 0x37b2
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x37b2
callq 0x20e0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x37c4
callq 0x20e0
leaq -0xa8(%rbp), %rdi
callq 0x99c6
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
sete %al
movq (%rdi), %rbx
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x38d3
movq (%rbx), %r14
movq 0x8(%rbx), %r15
testq %r14, %r14
je 0x38c3
movq %r14, %rdi
callq 0x8ef4
movq %r14, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20e0
movq %r15, %rbx
testq %r15, %r15
jne 0x38a7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
leaq -0x1(%rsi), %rcx
cmpq 0x10(%rdi), %rcx
jae 0x390d
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
cmpq $0x2, %rsi
jb 0x3908
movq 0x8(%rax), %rax
decq %rcx
jne 0x38ff
movq (%rax), %rax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rdi), %r14
testq %r14, %r14
je 0x3a10
movq %rsi, %rbx
leaq -0xa8(%rbp), %r15
leaq -0x48(%rbp), %r13
movq (%r14), %rsi
movq %r15, %rdi
callq 0x94a8
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
callq 0x9a70
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x37d8
leaq -0x88(%rbp), %rdi
movq %r13, %rsi
callq 0x9a70
movq -0x60(%rbp), %rdx
cmpq -0x80(%rbp), %rdx
jne 0x39a5
testq %rdx, %rdx
je 0x39aa
movq -0x88(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x2110
testl %eax, %eax
sete %r12b
jmp 0x39ad
xorl %r12d, %r12d
jmp 0x39ad
movb $0x1, %r12b
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x39c2
callq 0x20e0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x39d4
callq 0x20e0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x39e6
callq 0x20e0
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rax
cmpq %rax, %rdi
je 0x39fe
callq 0x20e0
testb %r12b, %r12b
jne 0x3a14
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x393e
xorl %eax, %eax
jmp 0x3a17
movq (%r14), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3a43
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3a43
callq 0x20e0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3a5a
callq 0x20e0
jmp 0x3a5a
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rax
cmpq %rax, %rdi
je 0x3a72
callq 0x20e0
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x94a8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3910
movq %rax, %r15
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ab9
callq 0x20e0
testq %r15, %r15
je 0x3ad3
movq 0xa50b(%rip), %rdi      # 0xdfd0
leaq 0x6587(%rip), %rsi      # 0xa053
movl $0x31, %edx
jmp 0x3b16
movl $0x10, %edi
callq 0x2100
movq %r14, (%rax)
movq $0x0, 0x8(%rax)
cmpq $0x0, (%rbx)
je 0x3af8
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
jmp 0x3afb
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
incq 0x10(%rbx)
movq 0xa4c6(%rip), %rdi      # 0xdfd0
leaq 0x6574(%rip), %rsi      # 0xa085
movl $0x2b, %edx
callq 0x2120
movq 0xa4ae(%rip), %rbx      # 0xdfd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2080
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b69
callq 0x20e0
movq %rbx, %rdi
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq (%rdi), %rbx
cmpq $0x1, %rsi
jne 0x3b8b
movq 0x8(%rbx), %rax
movq %rax, (%rdi)
jmp 0x3bcd
cmpq %rsi, 0x10(%rdi)
jbe 0x3baa
decq %rsi
movq %rbx, %rax
movq 0x8(%rbx), %rbx
decq %rsi
jne 0x3b94
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x3bcd
xorl %ecx, %ecx
movq %rbx, %rax
movq %rcx, %rdx
movq 0x8(%rbx), %rbx
movq %rax, %rcx
testq %rbx, %rbx
jne 0x3bac
movq %rdx, 0x8(%rdi)
movq $0x0, 0x8(%rdx)
movq %rax, %rbx
decq 0x10(%rdi)
movq (%rbx), %r14
testq %r14, %r14
je 0x3be9
movq %r14, %rdi
callq 0x8ef4
movq %r14, %rdi
callq 0x20e0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rdi), %r13
testq %r13, %r13
je 0x3cf5
movq %rsi, %rbx
leaq -0x68(%rbp), %r12
movq (%r13), %rdi
callq 0x9280
movq %rax, %r15
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x37d8
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x37d8
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a10
movq %rax, %r14
movq %r12, %rdi
callq 0x99c6
testq %r14, %r14
je 0x3ce8
leaq -0x98(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0xa8(%rbp), %r12
movq %r12, %rdi
callq 0x37d8
leaq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x37d8
movq %r15, %rdi
movq %r12, %rsi
callq 0x3282
movq %rax, %r14
movq %r12, %rdi
callq 0x99c6
movq %r15, %rdi
movq %r14, %rsi
callq 0x3146
leaq -0x68(%rbp), %r12
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x3c1d
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
jmp 0x3d44
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rax
jmp 0x3d31
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3d49
callq 0x20e0
jmp 0x3d49
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x99c6
movq %rbx, %rdi
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %r12
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x62b3(%rip), %rdx      # 0xa028
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0x3e72
testq %r12, %r12
je 0x3e31
movl $0x1, %ebx
leaq -0x68(%rbp), %r14
leaq 0x628b(%rip), %r13      # 0xa025
movq (%r12), %rsi
movq %r14, %rdi
callq 0x94a8
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x2130
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x3dc4
callq 0x20e0
movq 0xa205(%rip), %rdi      # 0xdfd0
movq %rbx, %rsi
callq 0x2070
movq %rax, %r15
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2120
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x2120
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x20f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2080
movq 0x8(%r12), %r12
incq %rbx
testq %r12, %r12
jne 0x3d9a
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3e43
callq 0x20e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e54
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3e69
callq 0x20e0
movq %rbx, %rdi
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x18, %edi
callq 0x2100
movq %rax, %r15
movq %rax, %rdi
callq 0x23cc
movq %r15, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
movq $0x1, 0x30(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2040
movq 0x20(%r14), %rdi
callq 0x28c8
movq %rax, %r14
testq %rax, %rax
je 0x8fff
leaq -0x40(%rbp), %r15
leaq -0x70(%rbp), %r12
movq 0x20(%rbx), %r13
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x37d8
movq %r15, -0x50(%rbp)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x37d8
movq %r13, %rdi
movq %r12, %rsi
callq 0x24dc
movq %r12, %rdi
callq 0x99c6
movq 0x40(%r14), %r14
testq %r14, %r14
jne 0x8fad
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x901a
movq %rax, %r14
movq %r15, %rdi
jmp 0x902f
jmp 0x901a
movq %rax, %r14
jmp 0x9042
movq %rax, %r14
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x9042
callq 0x20e0
jmp 0x9042
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x99c6
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x9050
callq 0x20e0
movq %r14, %rdi
callq 0x2170