LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::process_message_(Message*)
void process_message_(Message* m) {
        MsgKind kind = m->kind_;
        //switch on the kind and call the appropriate processing function.
        switch (kind) {
        case MsgKind::Put: {
            Put* put = dynamic_cast<Put*>(m);
            process_put_request_(put);
            break;
        }
        case MsgKind::Get: {
            Get* get = dynamic_cast<Get*>(m);
            process_get_request_(get);
            break;
        }
        case MsgKind::WaitAndGet: {
            WaitAndGet* waitAndget = dynamic_cast<WaitAndGet*>(m);
            process_waitAndGet_request_(waitAndget);
            break;
        }
        case MsgKind::Reply: {
            store_mtx_.lock();
            received_msg = m;
            store_mtx_.notify_all();
            //std::cout << "notified\n";
            store_mtx_.unlock();
            break;
        }
        case MsgKind::Ack: {
            store_mtx_.lock();
            received_msg = m;
            store_mtx_.notify_all();
            store_mtx_.unlock();
            break;
        }
        case MsgKind::Nack: {
            store_mtx_.lock();
            received_msg = m;
            store_mtx_.notify_all();
            store_mtx_.unlock();
            break;
        }
        default:
            break;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x10(%rsi), %eax
cmpq $0x5, %rax
ja 0x146ff
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8a3c(%rip), %rcx      # 0x1d090
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x68(%rbx), %r15
movq %r15, %rdi
callq 0x7330
testl %eax, %eax
jne 0x14746
movq %r14, 0xd0(%rbx)
addq $0x90, %rbx
movq %rbx, %rdi
callq 0x13c3e
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7180
testq %r14, %r14
je 0x1470a
leaq 0x13c3b(%rip), %rsi     # 0x282e0
leaq 0x14634(%rip), %rdx     # 0x28ce0
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rsi
jmp 0x1470c
testq %r14, %r14
je 0x1471e
leaq 0x13c19(%rip), %rsi     # 0x282e0
leaq 0x1538a(%rip), %rdx     # 0x29a58
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rsi
jmp 0x14720
testq %r14, %r14
je 0x14732
leaq 0x13bf7(%rip), %rsi     # 0x282e0
leaq 0x15380(%rip), %rdx     # 0x29a70
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rsi
jmp 0x14734
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %esi, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x147e8
xorl %esi, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1474e
xorl %esi, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14898
movl %eax, %edi
callq 0x7160
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::process_put_request_(Put*)
void process_put_request_(Put* _put) {
        if (put(_put->key_, _put->value_)) {
            Ack ack(this_node_, _put->sender_, network_->msg_id);
            network_->send_msg(&ack);
        } else {
            Nack nack(this_node_, _put->sender_, network_->msg_id);
            network_->send_msg(&nack);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %rsi
movq 0x38(%r14), %rdx
callq 0x9bbe
testb %al, %al
je 0x1479f
movq 0x18(%r14), %rax
movq 0x18(%rbx), %rcx
movq 0x50(%rbx), %rdi
movq 0x40(%rdi), %rdx
leaq -0x40(%rbp), %rsi
movq $0x0, 0x8(%rsi)
leaq 0x153a5(%rip), %r8      # 0x29b38
movq %r8, (%rsi)
movl $0x0, 0x10(%rsi)
jmp 0x147cc
movq 0x18(%r14), %rax
movq 0x18(%rbx), %rcx
movq 0x50(%rbx), %rdi
movq 0x40(%rdi), %rdx
leaq -0x40(%rbp), %rsi
movq $0x0, 0x8(%rsi)
leaq 0x153de(%rip), %r8      # 0x29ba0
movq %r8, (%rsi)
movl $0x1, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %rax, 0x20(%rsi)
movq %rdx, 0x28(%rsi)
movq (%rdi), %rax
callq *0x50(%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::process_get_request_(Get*)
void process_get_request_(Get* _get) {
        Value* val = get(_get->key_);
        if (val != nullptr) {
            Reply res(val->serialize(), this_node_, _get->sender_, network_->msg_id);
            network_->send_msg(&res);
        } else {
            Nack nack(this_node_, _get->sender_, network_->msg_id);
            network_->send_msg(&nack);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %rsi
callq 0xc02e
testq %rax, %rax
je 0x1484f
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq 0x18(%r14), %rcx
movq 0x18(%rbx), %rdx
movq 0x50(%rbx), %rdi
movq 0x40(%rdi), %r8
leaq -0x48(%rbp), %rsi
movq $0x0, 0x8(%rsi)
leaq 0x15265(%rip), %r9      # 0x29a98
movq %r9, (%rsi)
movl $0x3, 0x10(%rsi)
movq %rdx, 0x18(%rsi)
movq %rcx, 0x20(%rsi)
movq %r8, 0x28(%rsi)
movq %rax, 0x30(%rsi)
jmp 0x14888
movq 0x18(%r14), %rax
movq 0x18(%rbx), %rcx
movq 0x50(%rbx), %rdi
movq 0x40(%rdi), %rdx
leaq -0x48(%rbp), %rsi
movq $0x0, 0x8(%rsi)
leaq 0x1532e(%rip), %r8      # 0x29ba0
movq %r8, (%rsi)
movl $0x1, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %rax, 0x20(%rsi)
movq %rdx, 0x28(%rsi)
movq (%rdi), %rax
callq *0x50(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::process_waitAndGet_request_(WaitAndGet*)
void process_waitAndGet_request_(WaitAndGet* _waitAndget) {
        Value* val = get(_waitAndget->key_);
        if (val != nullptr) {
            Reply res(val->serialize(), this_node_, _waitAndget->sender_, network_->msg_id);
            network_->send_msg(&res);
        } else {
            pendingGets.pushBack(_waitAndget);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %rsi
callq 0xc02e
testq %rax, %rax
je 0x14905
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq 0x18(%r14), %rcx
movq 0x18(%rbx), %rdx
movq 0x50(%rbx), %rdi
movq 0x40(%rdi), %r8
leaq -0x48(%rbp), %rsi
movq $0x0, 0x8(%rsi)
leaq 0x151b5(%rip), %r9      # 0x29a98
movq %r9, (%rsi)
movl $0x3, 0x10(%rsi)
movq %rdx, 0x18(%rsi)
movq %rcx, 0x20(%rsi)
movq %r8, 0x28(%rsi)
movq %rax, 0x30(%rsi)
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x14935
leaq 0xd8(%rbx), %rdi
movl 0xf0(%rbx), %esi
incl %esi
callq 0x8ece
movq 0xe8(%rbx), %rax
movq 0xf0(%rbx), %rcx
movq %r14, (%rax,%rcx,8)
incq %rcx
movq %rcx, 0xf0(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./network.h
// Function: Ack::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Ack");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x80aa
leaq 0x9105(%rip), %rsi      # 0x1da79
movq %rbx, %rdi
callq 0x810c
movl 0x10(%r14), %edx
leaq 0x88ef(%rip), %rsi      # 0x1d276
movq %rbx, %rdi
callq 0x8178
movq 0x18(%r14), %rdx
leaq 0x88e2(%rip), %rsi      # 0x1d27c
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0x88d7(%rip), %rsi      # 0x1d284
movq %rbx, %rdi
callq 0x81e6
movq 0x28(%r14), %rdx
leaq 0x8c02(%rip), %rsi      # 0x1d5c2
movq %rbx, %rdi
callq 0x81e6
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x14a0e
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./network.h
// Function: Nack::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Nack");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x80aa
leaq 0x901b(%rip), %rsi      # 0x1da7d
movq %rbx, %rdi
callq 0x810c
movl 0x10(%r14), %edx
leaq 0x8801(%rip), %rsi      # 0x1d276
movq %rbx, %rdi
callq 0x8178
movq 0x18(%r14), %rdx
leaq 0x87f4(%rip), %rsi      # 0x1d27c
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0x87e9(%rip), %rsi      # 0x1d284
movq %rbx, %rdi
callq 0x81e6
movq 0x28(%r14), %rdx
leaq 0x8b14(%rip), %rsi      # 0x1d5c2
movq %rbx, %rdi
callq 0x81e6
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x14afc
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/jsonHelper.h
// Function: JSONHelper::getPayloadKey(char*)
static String* getPayloadKey(char* s) {
        int len = strlen( s );
        bool nameStarted = false;
        char buff[100];
        int loc = 0;
        //pull the class name from the serialzed string
        for (int i = 0; i < len; i++){
            char temp = s[i];
            if(temp == '\'' && !nameStarted) {
                nameStarted = true;
            } else if(temp == '\'' && nameStarted) {
                //full name has been discovered
                break;
            } else if(nameStarted) {
                buff[loc] = temp;
                loc++;
            }
        }
        buff[loc] = '\0';
        char* className = buff;
        String* str = new String(className);
        return str;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
callq 0x7100
xorl %ecx, %ecx
testl %eax, %eax
jle 0x15b95
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
decq %rax
movl $0x1, %edx
xorl %esi, %esi
xorl %edi, %edi
movb (%rbx,%rsi), %r8b
cmpb $0x27, %r8b
jne 0x15b6a
testb $0x1, %dil
movl %edi, %r8d
movzbl %dil, %edi
cmovel %edx, %edi
jmp 0x15b80
testb $0x1, %dil
je 0x15b7d
movslq %ecx, %rcx
movb %r8b, -0x90(%rbp,%rcx)
incl %ecx
xorl %r8d, %r8d
testb $0x1, %r8b
jne 0x15b92
leaq 0x1(%rsi), %r8
cmpq %rsi, %rax
movq %r8, %rsi
jne 0x15b50
movslq %ecx, %rcx
movb $0x0, -0x90(%rbp,%rcx)
movl $0x20, %edi
callq 0x7230
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x7100
movq %rax, %r14
movq $0x0, 0x8(%rbx)
leaq 0x12890(%rip), %rax     # 0x28458
movq %rax, (%rbx)
movq %r14, 0x10(%rbx)
leaq 0x1(%r14), %r15
movq %r15, %rdi
callq 0x7030
movq %rax, %r12
movq %rax, 0x18(%rbx)
leaq -0x90(%rbp), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x71a0
movb $0x0, (%r12,%r14)
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/../dataframe/dataframe.h
// Function: DataFrame::deserialize(char*)
static DataFrame* deserialize(char* s) {
        Schema* sch = dynamic_cast<Schema*>(DataFrame::deserialize(JSONHelper::getValueFromKey("schema_", s)->c_str()));
        Array* cols = new Array(JSONHelper::getValueFromKey("cols_", s)->c_str());
        DataFrame* df = new DataFrame(sch, cols);
        return df;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x7176(%rip), %rdi      # 0x1d8a0
movq %r14, %rsi
callq 0xcb92
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rdi
callq 0x16716
testq %rax, %rax
je 0x1676a
leaq 0x134e9(%rip), %rsi     # 0x29c38
leaq 0x120fa(%rip), %rdx     # 0x28850
movq %rax, %rdi
movq $-0x2, %rcx
callq 0x7280
movq %rax, %rbx
jmp 0x1676c
xorl %ebx, %ebx
movl $0x28, %edi
callq 0x7230
movq %rax, %r15
leaq 0x7128(%rip), %rdi      # 0x1d8a8
movq %r14, %rsi
callq 0xcb92
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x16b22
movl $0x20, %edi
callq 0x7230
movq $0x0, 0x8(%rax)
leaq 0x134ab(%rip), %rcx     # 0x29c60
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/../dataframe/../store/../utils/queue.h
// Function: Queue::Queue(char*)
Queue(char* serialized) {
    this->head_ = nullptr;
    this->tail_ = nullptr;
    this->size_ = 0;
    Deserializable* ds = new Deserializable();
    char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
    size_t queueLen = std::stoi(JSONHelper::getValueFromKey("size_", payload)->c_str());
    char* vals = JSONHelper::getValueFromKey("queueObjs_", payload)->c_str();
    for(int i = 0; i < queueLen; i++) {
        char* serial = JSONHelper::getArrayValueAt(vals, i)->c_str();
        Object* o = ds->deserialize(serial);
        add(o);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x11805(%rip), %rcx     # 0x288e0
movq %rcx, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq %rax, 0x20(%rdi)
movq %rsi, %rdi
callq 0xc9f0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq 0x62be(%rip), %rdi      # 0x1d3bf
movq %rax, -0x38(%rbp)
movq %rax, %rsi
callq 0xcb92
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x60(%rbp), %r14
leaq -0x29(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x70e0
movq (%r14), %r13
callq 0x7040
movq %rax, %r12
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x0, (%r12)
leaq -0x40(%rbp), %r15
movq %r13, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x72f0
cmpq %r13, (%r15)
je 0x171f9
movq %rax, %r14
movslq %r14d, %rax
cmpq %r14, %rax
jne 0x17205
movl (%r12), %eax
cmpl $0x22, %eax
je 0x17205
testl %eax, %eax
jne 0x17185
movl -0x30(%rbp), %eax
movl %eax, (%r12)
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17197
callq 0x7200
leaq 0x6227(%rip), %rdi      # 0x1d3c5
movq -0x38(%rbp), %rsi
callq 0xcb92
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
testl %r14d, %r14d
je 0x171ea
movq %rax, %r15
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0xcfc4
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rsi
callq 0x14b60
movq %rbx, %rdi
movq %rax, %rsi
callq 0xacdc
incl %r12d
cmpl %r12d, %r14d
jne 0x171bb
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5eff(%rip), %rdi      # 0x1d0ff
callq 0x7140
leaq 0x5ef3(%rip), %rdi      # 0x1d0ff
callq 0x7310
movq %rax, %rbx
cmpl $0x0, (%r12)
jne 0x17222
movl -0x30(%rbp), %eax
movl %eax, (%r12)
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x17234
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/../dataframe/../store/../utils/keyVal.h
// Function: KeyVal::deserialize(char*)
static KeyVal* deserialize(char* s) {
        Deserializable* ds = new Deserializable();
        char* key_serialized = JSONHelper::getValueFromKey("key_", s)->c_str();
        Object* key = ds->deserialize(key_serialized);
        Object* val = ds->deserialize(JSONHelper::getValueFromKey("val_", s)->c_str());
        KeyVal* kv = new KeyVal(key, val);
        return kv;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x600e(%rip), %rdi      # 0x1d3f3
movq %rbx, %rsi
callq 0xcb92
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rsi
callq 0x14b60
movq %rax, %r14
leaq 0x5ff0(%rip), %rdi      # 0x1d3f8
movq %rbx, %rsi
callq 0xcb92
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rsi
callq 0x14b60
movq %rax, %rbx
movl $0x20, %edi
callq 0x7230
movq $0x0, 0x8(%rax)
leaq 0x11523(%rip), %rcx     # 0x28960
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/../network/../store/value.h
// Function: Value::Value(char*)
Value(char* serialized) {
        Deserializable* ds = new Deserializable();
        char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
        char* serialData = JSONHelper::getValueFromKey("data", payload)->c_str();
        this->data = serialData;
        if(JSONHelper::isObject(serialData)) {
            this->data = ds->deserialize(JSONHelper::getValueFromKey("data", payload)->c_str())->serialize();
        } else {
            this->data = serialData;
        }
        this->length = std::stoi(JSONHelper::getValueFromKey("length", payload)->c_str());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x11897(%rip), %rax     # 0x28d08
movq %rax, (%rdi)
movq %rsi, %rdi
callq 0xc9f0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x6104(%rip), %rdi      # 0x1d593
movq %rax, %rsi
callq 0xcb92
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r15
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0xcdac
testb %al, %al
je 0x174df
leaq 0x60d9(%rip), %rdi      # 0x1d593
movq %r14, %rsi
callq 0xcb92
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rsi
callq 0x14b60
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %rax, %r15
movq %r15, 0x10(%rbx)
leaq 0x60ae(%rip), %rdi      # 0x1d598
movq %r14, %rsi
callq 0xcb92
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x58(%rbp), %r14
leaq -0x29(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x70e0
movq (%r14), %r15
callq 0x7040
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x38(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x72f0
cmpq %r15, (%r12)
je 0x1757a
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x17586
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0x17586
testl %ecx, %ecx
jne 0x17553
movl %r13d, (%r14)
cltq
movq %rax, 0x18(%rbx)
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1756b
callq 0x7200
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5b7e(%rip), %rdi      # 0x1d0ff
callq 0x7140
leaq 0x5b72(%rip), %rdi      # 0x1d0ff
callq 0x7310
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1759e
movl %r13d, (%r14)
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x175b0
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::DistributedDataFrame(char*, KVStore*)
DistributedDataFrame(char* serialized, KVStore* kv) {
      Deserializable* d = new Deserializable();
      char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
      Schema* sch = new Schema(JSONHelper::getValueFromKey("schema_", payload)->c_str());
      Array* cols = new Array(JSONHelper::getValueFromKey("cols_", payload)->c_str(), kv);
      this->kv_ = kv;
      this->schema_ = sch;
      this->cols_ = cols;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0xd25b(%rip), %rax      # 0x28ed8
movq %rax, (%rdi)
movq %rsi, %rdi
callq 0xc9f0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r12
movl $0x50, %edi
callq 0x7230
movq %rax, %r15
leaq 0x1bf8(%rip), %rdi      # 0x1d8a0
movq %r12, %rsi
callq 0xcb92
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x167de
movl $0x28, %edi
callq 0x7230
movq %rax, %r13
leaq 0x1bd0(%rip), %rdi      # 0x1d8a8
movq %r12, %rsi
callq 0xcb92
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r13, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x19ee6
movq %r14, 0x20(%rbx)
movq %r15, 0x10(%rbx)
movq %r13, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %r15
jmp 0x1bd1d
movq %rax, %rbx
movq %r15, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/../dataframe/dataframe.h
// Function: DataFrame::equals(Object*)
bool equals(Object  * other) {
      if (other == this) return true;
        DataFrame* x = dynamic_cast<DataFrame*>(other);
        if (x == nullptr) return false;
        if (this->ncols() != x->ncols()) return false;
        if (this->nrows() != x->nrows()) return false;
        for (size_t i = 0; i < this->ncols(); i++) {
            if (!(this->cols_->get(i)->equals(x->cols_->get(i)))) { 
                return false; 
            }
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rdi, %rsi
je 0x1c807
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1c80c
leaq 0xba5a(%rip), %rax      # 0x28248
leaq 0xd443(%rip), %rdx      # 0x29c38
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r14
jmp 0x1c80f
movb $0x1, %r15b
jmp 0x1c886
xorl %r14d, %r14d
testq %r14, %r14
je 0x1c883
movq 0x10(%rbx), %rax
movq 0x20(%rax), %rdx
movq 0x10(%r14), %rcx
cmpq 0x20(%rcx), %rdx
jne 0x1c883
movq 0x28(%rax), %rax
cmpq 0x28(%rcx), %rax
jne 0x1c883
movq 0x10(%rbx), %rax
cmpq $0x0, 0x20(%rax)
sete %r15b
je 0x1c886
xorl %r12d, %r12d
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
movq %rax, %r13
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
movq (%r13), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
testb %al, %al
je 0x1c886
incq %r12
movq 0x10(%rbx), %rax
cmpq 0x20(%rax), %r12
setae %r15b
jb 0x1c842
jmp 0x1c886
xorl %r15d, %r15d
andb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/../dataframe/dataframe.h
// Function: DataFrame::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("DataFrame");
        char * serializedschema = schema_->serialize();
        sb->write("schema_", serializedschema);
        char * seralizedcols = cols_->serialize();
        sb->write("cols_", seralizedcols);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
     }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x80aa
leaq 0xfd4(%rip), %rsi       # 0x1d896
movq %rbx, %rdi
callq 0x810c
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xfc5(%rip), %rsi       # 0x1d8a0
movq %rbx, %rdi
movq %rax, %rdx
callq 0x8576
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xfb1(%rip), %rsi       # 0x1d8a8
movq %rbx, %rdi
movq %rax, %rdx
callq 0x8576
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1c948
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/../network/network.h
// Function: Status::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Status");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        sb->write("status_msg_", status_msg_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x80aa
leaq 0x1476(%rip), %rsi      # 0x1df00
movq %rbx, %rdi
callq 0x810c
movl 0x10(%r14), %edx
leaq 0x7d9(%rip), %rsi       # 0x1d276
movq %rbx, %rdi
callq 0x8178
movq 0x18(%r14), %rdx
leaq 0x7cc(%rip), %rsi       # 0x1d27c
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0x7c1(%rip), %rsi       # 0x1d284
movq %rbx, %rdi
callq 0x81e6
movq 0x28(%r14), %rdx
leaq 0xaec(%rip), %rsi       # 0x1d5c2
movq %rbx, %rdi
callq 0x81e6
movq 0x30(%r14), %rdx
leaq 0x1498(%rip), %rsi      # 0x1df81
movq %rbx, %rdi
callq 0x8576
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1cb37
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/jsonHelper.h
// Function: JSONHelper::arrayLen(char*)
static int arrayLen(char* s) {
        int len = strlen( s );
        bool valuesFound = false;
        char objStart = '{';
        char objEnd = '}';
        int count = 0;
        int startCharDepth = -1;
        //pull the top level object-value from the serialzed string
        for (int i = 0; i < len; i++){
            char temp = s[i];
            if(!valuesFound) {
                //the three ways a payload in our JSON can start, will rely on this to know what character closes the value
                //also keeps track of depth if there are nested objects
                if(temp == '{' || temp == '[' || temp == '\'') {
                    objStart = temp;
                    startCharDepth = 1;
                    valuesFound = true;
                    if(temp == '{') {
                        objEnd = '}';
                    } else if(temp == '[') {
                        objEnd = ']';
                    } else if(temp == '\'') {
                        objEnd = '\'';
                        startCharDepth = 0;
                    }   
                }
            } else if(temp == objStart) {
                startCharDepth++;
            } 
            if(temp == objEnd && valuesFound) {
                if(temp != objStart) {
                    startCharDepth--;
                }
                //if we've reached the final level of end character, break out of loop
                if(startCharDepth <= 0  || (temp == objStart && startCharDepth % 2 == 0)) {
                    count++;
                }
            }
        }
        return count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7100
testl %eax, %eax
jle 0x1cc15
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x7b, %r9b
movb $0x7d, %dil
xorl %edx, %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %r8d, %r8d
xorl %ecx, %ecx
movb (%rbx,%rdx), %r10b
testb $0x1, %r8b
je 0x1cba0
xorl %r11d, %r11d
cmpb %r9b, %r10b
sete %r11b
addl %r11d, %esi
jmp 0x1cbdb
movzbl %r10b, %r11d
cmpl $0x27, %r11d
je 0x1cbd0
cmpl $0x5b, %r11d
je 0x1cbc3
cmpl $0x7b, %r11d
jne 0x1cbdb
movb $0x1, %r8b
movl $0x1, %esi
movb $0x7d, %dil
jmp 0x1cbd8
movb $0x1, %r8b
movl $0x1, %esi
movb $0x5d, %dil
jmp 0x1cbd8
movb $0x1, %r8b
xorl %esi, %esi
movb $0x27, %dil
movl %r10d, %r9d
cmpb %dil, %r10b
jne 0x1cc07
testb $0x1, %r8b
je 0x1cc07
xorl %r11d, %r11d
cmpb %r9b, %r10b
setne %r11b
subl %r11d, %esi
testl %esi, %esi
jle 0x1cc05
cmpb %r9b, %r10b
jne 0x1cc07
movl %esi, %r10d
andl $0x1, %r10d
jne 0x1cc07
incl %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x1cb87
jmp 0x1cc17
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/../network/network.h
// Function: Directory::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Directory");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        sb->write("ports", ports, clients);
        sb->write("clients", clients);
        sb->write("addresses", addresses, clients);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x80aa
leaq 0x12b7(%rip), %rsi      # 0x1df07
movq %rbx, %rdi
callq 0x810c
movl 0x10(%r14), %edx
leaq 0x613(%rip), %rsi       # 0x1d276
movq %rbx, %rdi
callq 0x8178
movq 0x18(%r14), %rdx
leaq 0x606(%rip), %rsi       # 0x1d27c
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0x5fb(%rip), %rsi       # 0x1d284
movq %rbx, %rdi
callq 0x81e6
movq 0x28(%r14), %rdx
leaq 0x926(%rip), %rsi       # 0x1d5c2
movq %rbx, %rdi
callq 0x81e6
movq 0x38(%r14), %rdx
movl 0x30(%r14), %ecx
leaq 0x12e2(%rip), %rsi      # 0x1df95
movq %rbx, %rdi
callq 0x1cd4e
movq 0x30(%r14), %rdx
leaq 0x12c7(%rip), %rsi      # 0x1df8d
movq %rbx, %rdi
callq 0x81e6
movq 0x40(%r14), %rdx
movl 0x30(%r14), %ecx
leaq 0x12be(%rip), %rsi      # 0x1df9b
movq %rbx, %rdi
callq 0xfaec
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1cd2b
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/../serialize/../network/../serialize/serial.h
// Function: Serializable::write(char const*, unsigned long*, int)
void write(const char* name, size_t* val, int len) {
        char str[1000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            sprintf(str, "'%zu',", val[i]);
            buff->c(str);
        }
        buff->c("], ");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movl %ecx, %r14d
movq %rdx, -0x38(%rbp)
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x5ff(%rip), %rsi       # 0x1d375
leaq -0x420(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq %rbx, -0x30(%rbp)
movq (%rbx), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x8260
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
testl %r14d, %r14d
jle 0x1ce1b
movl %r14d, %ebx
xorl %r14d, %r14d
movq -0x38(%rbp), %rax
movq (%rax,%r14,8), %rdx
movq %r12, %rdi
leaq 0x11cd(%rip), %rsi      # 0x1dfa5
xorl %eax, %eax
callq 0x7080
movq -0x30(%rbp), %rax
movq (%rax), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x8260
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
incq %r14
cmpq %r14, %rbx
jne 0x1cdc6
movq -0x30(%rbp), %rax
movq (%rax), %rbx
movl $0x3, %esi
movq %rbx, %rdi
callq 0x8260
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movb $0x20, 0x2(%rax,%rcx)
movw $0x2c5d, (%rax,%rcx)    # imm = 0x2C5D
addq $0x3, 0x20(%rbx)
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wichtounet[P]articles/src/vector_list/bench.cpp
// Function: void bench_all<Trivial<8>, Trivial<32>, Trivial<128>, Trivial<1024>, Trivial<4096>, NonTrivialStringMovable, NonTrivialStringMovableNoExcept, NonTrivialArray<32>>()
void bench_all(){
    bench_types<bench_fill_back,        Types...>();
    bench_types<bench_emplace_back,     Types...>();
    bench_types<bench_fill_front,       Types...>();
    bench_types<bench_emplace_front,    Types...>();
    bench_types<bench_linear_search,    Types...>();
    bench_types<bench_random_insert,    Types...>();
    bench_types<bench_random_remove,    Types...>();
    bench_types<bench_sort,             Types...>();
    bench_types<bench_destruction,      Types...>();

    // it is really slow so run only for limited set of data
    bench_types<bench_number_crunching, TrivialSmall, TrivialMedium>();
}

// Assembly:
pushq %rax
callq 0x59a6
callq 0x5c1a
callq 0x1262a
callq 0x127be
callq 0x175dc
callq 0x17770
callq 0x1ad4a
callq 0x1aede
callq 0x1e41a
callq 0x1e5ae
callq 0x293a4
callq 0x29538
callq 0x354d0
callq 0x3569c
callq 0x3e350
callq 0x3e4e4
callq 0x52632
callq 0x527c6
callq 0x5764e
popq %rax
jmp 0x58726
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/usingDirective.cc
// Function: main
int main() 
{
    // using directive; 
	// the names in blip are ``added'' to the global scope
    using namespace blip; // clash between ::j and blip::j
                          // detected only if j is used

    ++i;        // sets blip::i to 17
    ++::j;      // ok: sets global j to 1
    ++blip::j;  // ok: sets blip::j to 16

    int k = 97; // local k hides blip::k
    ++k;        // sets local k to 98

	::f();        
	blip::f();
	cout << "j: " << ::j << " k: " << k << endl; 

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
incl 0x2d4f(%rip)            # 0x4064
incl 0x2d61(%rip)            # 0x407c
incl 0x2d47(%rip)            # 0x4068
callq 0x11dc
callq 0x1260
movq 0x2ca6(%rip), %rbx      # 0x3fd8
leaq 0xcd0(%rip), %rsi       # 0x2009
movl $0x3, %edx
movq %rbx, %rdi
callq 0x1070
movl 0x2d30(%rip), %esi      # 0x407c
movq %rbx, %rdi
callq 0x1090
movq %rax, %rbx
leaq 0xcaf(%rip), %rsi       # 0x200d
movl $0x4, %edx
movq %rax, %rdi
callq 0x1070
movq %rbx, %rdi
movl $0x62, %esi
callq 0x1090
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/giovifazi[P]knossos-bloodbath/Node.cpp
// Function: Node::set_cardinal(char, Node&)
void Node::set_cardinal(char cardinal_dir, Node& n)
{
	switch (cardinal_dir)
	{
		case 'n':
			nord = &n;
			break;

      case 's':
			sud = &n;
			break;

      case 'e':
			est = &n;
			break;

		case 'o':
			ovest = &n;
			break;
	}
}

// Assembly:
cmpl $0x6e, %esi
jg 0x2e0b
cmpl $0x65, %esi
je 0x2e1c
cmpl $0x6e, %esi
je 0x2e26
jmp 0x2e1b
cmpl $0x6f, %esi
je 0x2e22
cmpl $0x73, %esi
jne 0x2e1b
addq $0x8, %rdi
jmp 0x2e26
retq
addq $0x10, %rdi
jmp 0x2e26
addq $0x18, %rdi
pushq %rbp
movq %rsp, %rbp
movq %rdx, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/giovifazi[P]knossos-bloodbath/Map.cpp
// Function: IntToString[abi:cxx11](int)
std::string IntToString (int num)
{
  std::ostringstream oss;

  // Funziona come un cout
  oss << num;

  // ritrna la stringa
  return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x190(%rbp), %r15
movq %r15, %rdi
callq 0x21a0
movq %r15, %rdi
movl %r14d, %esi
callq 0x2200
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x21e0
movq 0xec2e(%rip), %rsi      # 0x11fc8
leaq -0x190(%rbp), %rdi
callq 0x2070
leaq -0x120(%rbp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0xebfb(%rip), %rsi      # 0x11fc8
leaq -0x190(%rbp), %rdi
callq 0x2070
leaq -0x120(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O1/giovifazi[P]knossos-bloodbath/Map.cpp
// Function: Map::init(int)
void Map::init(int playerNum)
{
  // inizializza la lista delle ordinate per la matrice
  origin = new listaY;
  origin->down = NULL;

  // inizializza la lista delle ascisse
  origin->h = new listaX;
  origin->h->next = NULL;
  origin->h->val = playerNum;

  // inizializza le coordinate del nodo più in alto a sx
  mostUp = 0;
  mostLeft = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2110
movq %rax, %r15
movq %rax, (%r14)
xorl %r12d, %r12d
movq %r12, (%rax)
movl $0x18, %edi
callq 0x2110
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%r15)
movq %r12, (%rax)
movl %ebx, 0x8(%rax)
movq %r12, 0x10(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/giovifazi[P]knossos-bloodbath/Map.cpp
// Function: Map::draw_search()
void Map::draw_search()
{
  // Crea due puntatori che iterano per la matrice
  listaY* ordi = origin;
  listaX* asci;

  while(ordi != NULL)
  {
    asci = ordi->h;

    while(asci != NULL)
    {
      // in base al valore nella ascissa disegna cose diverse
      std::cout << asci->val;

      // scorre alla ascissa successiva
      asci = asci->next;
    }

    // Se il ciclo arriva qui, significa che ha finito una riga
    std::cout << "\n";
    ordi = ordi->down;    // passo alla riga successiva
  }

  //////////////////////////////////////////////
  //DEBUG STUFF
  std::cout << "Top left coordinate";
  std::cout << "(" << mostLeft << ", " << mostUp << ")\n";
  std::cout << "width = " << width << "\nheight = " << height << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x35fc
movq 0xea10(%rip), %r14      # 0x11fd0
leaq 0xb28e(%rip), %r15      # 0xe855
movq 0x8(%r12), %r13
testq %r13, %r13
je 0x35e3
movl 0x8(%r13), %esi
movq %r14, %rdi
callq 0x2200
movq (%r13), %r13
jmp 0x35cc
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2140
movq (%r12), %r12
testq %r12, %r12
jne 0x35c7
movq 0xe9cd(%rip), %r14      # 0x11fd0
leaq 0x6ad6(%rip), %rsi      # 0xa0e0
movl $0x13, %edx
movq %r14, %rdi
callq 0x2140
leaq 0x6ad6(%rip), %rsi      # 0xa0f4
movl $0x1, %edx
movq %r14, %rdi
callq 0x2140
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x2200
movq %rax, %r15
leaq 0x6ab6(%rip), %rsi      # 0xa0f6
movl $0x2, %edx
movq %rax, %rdi
callq 0x2140
movl 0x14(%rbx), %esi
movq %r15, %rdi
callq 0x2200
leaq 0x7573(%rip), %rsi      # 0xabd2
movl $0x2, %edx
movq %rax, %rdi
callq 0x2140
leaq 0x6a86(%rip), %rsi      # 0xa0f9
movl $0x8, %edx
movq %r14, %rdi
callq 0x2140
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x2200
movq %rax, %r14
leaq 0x6a6d(%rip), %rsi      # 0xa102
movl $0xa, %edx
movq %rax, %rdi
callq 0x2140
movl 0xc(%rbx), %esi
movq %r14, %rdi
callq 0x2200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/giovifazi[P]knossos-bloodbath/Map.cpp
// Function: Map::addLine(bool)
void Map::addLine(bool onTop)
{
   // aumento la altezza della mappa
   height++;

   // Crea una nuova riga
   listaY* newLine = new listaY;
   newLine->down = NULL;
   newLine->h = new listaX;
   newLine->h->next = NULL;
   newLine->h->val = 0;
   newLine->h->pres = 0;

   // Popolo la riga appena creata
   // i conta da 1 perchè un nodo lo ho gia' creato sopra
   for (int i = 1; i < width; i++)
   {
      // salva il vecchio nodo
      listaX* tmpx = newLine->h;

      // crea il nuovo nodo in testa
      newLine->h = new listaX;
      newLine->h->val = 0;
      newLine->h->pres = 0;
      newLine->h->next = tmpx;
   }

   // mette la riga creata in testa o in coda
   if (onTop)
   {
      // Aggiorna il valore mostUp
      mostUp++;

      // Se in testa
      listaY* tmpy = origin;

      origin = newLine;
      origin->down = tmpy;
   }
   else
   {
      // Se in coda
      listaY* iter = origin;

      while(iter->down != NULL) // scorro fino alla ultima riga
         iter = iter->down;

      iter->down = newLine;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
incl 0xc(%rdi)
movl $0x10, %edi
callq 0x2110
movq %rax, %rbx
movq $0x0, (%rax)
movl $0x18, %edi
callq 0x2110
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl 0x8(%r14), %r12d
cmpl $0x2, %r12d
jl 0x3b11
movq 0x8(%rbx), %rax
decl %r12d
movq %rax, %r13
movl $0x18, %edi
callq 0x2110
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r13, (%rax)
decl %r12d
jne 0x3aec
movq %rax, 0x8(%rbx)
testb %r15b, %r15b
je 0x3b25
incl 0x14(%r14)
movq (%r14), %rax
movq %rbx, (%r14)
movq %rax, (%rbx)
jmp 0x3b36
movq (%r14), %rax
movq %rax, %rcx
movq (%rax), %rax
testq %rax, %rax
jne 0x3b28
movq %rbx, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/giovifazi[P]knossos-bloodbath/Hud.cpp
// Function: c_in_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
bool c_in_str(std::string s, char c)
{
   for (int i=0; i < s.size(); i++)
      if (s[i] == c)
         return true;

   return false;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
setne %al
je 0x3c76
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
cmpb %sil, (%rdx)
je 0x3c75
movl $0x1, %edi
movq %rdi, %rax
cmpq %rdi, %rcx
je 0x3c6f
leaq 0x1(%rax), %rdi
cmpb %sil, (%rdx,%rax)
jne 0x3c5d
cmpq %rax, %rcx
seta %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/giovifazi[P]knossos-bloodbath/ClassPlayer.cpp
// Function: Player::Player(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int)
Player::Player(std::string n, int life, int att, int np)
{
   name = n;
   hp = life;
   atk = att;
   numPlay = np;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x30(%rbp)
movl %ecx, -0x2c(%rbp)
movl %edx, %ebx
movq %rdi, %r15
leaq 0x8(%rdi), %r12
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x40(%rdi), %r14
movq %r14, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
movq %r12, %rdi
callq 0x2080
movl %ebx, (%r15)
movl -0x2c(%rbp), %eax
movl %eax, 0x4(%r15)
movl -0x30(%rbp), %eax
movl %eax, 0x28(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%r15), %rdi
cmpq %r14, %rdi
je 0x7669
movq (%r14), %rsi
incq %rsi
callq 0x2120
movq %r12, %rdi
movq %r13, %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/giovifazi[P]knossos-bloodbath/ClassPlayer.cpp
// Function: Player::diceRoll_or()
int Player::diceRoll_or() 
{
   srand(time(0));
   int roll = (rand()%20) +1;
   switch(roll)
   {
      case 1: case 2: case 3: case 4: case 5:
      // non succede niente
      return roll;

      // trovato scudo oro
      case 6:
         shield = "gold";
      return roll;

      // se scudo oro trovata pozione curativa
      // scudo argento altrimenti
      case 7: 
            hp += 8;
            return 71;
         
     case 8:   
            hp -=8;
            return 72;
   
      // se senza scudo trovo scudo bronzo
      // piccola arma altrimenti
      case 9: case 10: case 11: case 12:
         if (shield == "")
         {
            shield = "bronze";
            return 91;
         }
         else
         {
            atk += 1;
            return 92;
         }
      break;
   
      // trappola, danno incodizionato
      case 13: case 14: case 15: case 16: case 17:
         hp -= 4;
      return roll;
   
      // trovata spada argento
      case 18: case 19:
         atk+=4;
      return roll;

      // trovata spada magica
      case 20:
         hp += 5;
         atk += 5;
      return roll;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x20e0
movl %eax, %edi
callq 0x20f0
callq 0x2040
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x23, %rcx
addl %edx, %ecx
shll $0x2, %ecx
leal (%rcx,%rcx,4), %ecx
movl %eax, %edx
subl %ecx, %edx
negl %ecx
addl %ecx, %eax
incl %eax
leaq 0x681c(%rip), %rcx      # 0xe8c0
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
addl $-0x4, (%rbx)
jmp 0x8144
leaq 0x30(%rbx), %r14
leaq 0x6796(%rip), %rsi      # 0xe856
movq %r14, %rdi
callq 0x2050
testl %eax, %eax
je 0x80dc
incl 0x4(%rbx)
movl $0x5c, %eax
jmp 0x8144
addl $0x4, 0x4(%rbx)
jmp 0x8144
movq 0x38(%rbx), %rdx
leaq 0x6829(%rip), %rcx      # 0xe910
movl $0x6, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x21d0
movl $0x5b, %eax
jmp 0x8144
addl $0x5, (%rbx)
addl $0x5, 0x4(%rbx)
movl $0x14, %eax
jmp 0x8144
movq 0x38(%rbx), %rdx
addq $0x30, %rbx
leaq 0x6803(%rip), %rcx      # 0xe91e
movl $0x4, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x21d0
movl $0x6, %eax
jmp 0x8144
addl $0x8, (%rbx)
movl $0x47, %eax
jmp 0x8144
addl $-0x8, (%rbx)
movl $0x48, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)