LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x11740
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1fb1e
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, %rsi
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x18(%rax), %rdx
movq 0x50(%rax), %rax
movq 0x40(%rax), %r8
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1e5f0
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rsi
movq 0x50(%rax), %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
jmp 0x1fafc
leaq -0x50(%rbp), %rdi
callq 0x1e660
jmp 0x1fb32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1e660
jmp 0x1fb38
movq -0x68(%rbp), %rdi
addq $0xd8, %rdi
movq -0x10(%rbp), %rsi
callq 0xbe20
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./network.h
// Function: Ack::Ack(unsigned long, unsigned long, unsigned long)
Ack(size_t sender, size_t target, size_t id) {
        kind_ = (MsgKind)0; 
        sender_ = sender;
        target_ = target;
        id_ = id;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x9b00
movq -0x28(%rbp), %rax
leaq 0x1bfd8(%rip), %rcx     # 0x3bb58
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: yasz24[P]eau2/src/network/./network.h
// Function: Nack::Nack(unsigned long, unsigned long, unsigned long)
Nack(size_t sender, size_t target, size_t id) {
        kind_ = (MsgKind)1; 
        sender_ = sender;
        target_ = target;
        id_ = id;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x9b00
movq -0x28(%rbp), %rax
leaq 0x1bfc0(%rip), %rcx     # 0x3bbc0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x1, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0x1fdef
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xcd05(%rip), %rsi      # 0x2cb07
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %edx
leaq 0xc4e2(%rip), %rsi      # 0x2c2fb
callq 0x9ed0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0xc4d0(%rip), %rsi      # 0x2c301
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0xc4c0(%rip), %rsi      # 0x2c309
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rdx
leaq 0xc7eb(%rip), %rsi      # 0x2c64c
callq 0x9f30
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1fe9c
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8130
movl %eax, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
movl $0x0, -0x84(%rbp)
movl $0x0, -0x88(%rbp)
movl -0x88(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x22942
movq -0x8(%rbp), %rax
movslq -0x88(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x89(%rbp)
movsbl -0x89(%rbp), %eax
cmpl $0x27, %eax
jne 0x228ee
testb $0x1, -0xd(%rbp)
jne 0x228ee
movb $0x1, -0xd(%rbp)
jmp 0x2292c
movsbl -0x89(%rbp), %eax
cmpl $0x27, %eax
jne 0x22902
testb $0x1, -0xd(%rbp)
je 0x22902
jmp 0x22942
testb $0x1, -0xd(%rbp)
je 0x22928
movb -0x89(%rbp), %cl
movslq -0x84(%rbp), %rax
movb %cl, -0x80(%rbp,%rax)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x2292a
jmp 0x2292c
jmp 0x2292e
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0x228b3
movslq -0x84(%rbp), %rax
movb $0x0, -0x80(%rbp,%rax)
leaq -0x80(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x20, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq -0x98(%rbp), %rsi
callq 0xc630
jmp 0x2297e
movq -0xb8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
callq 0x8260
movq -0xa8(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x9273(%rip), %rdi      # 0x2c92a
callq 0x12db0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, %rdi
callq 0x236a0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x236fb
movq -0x38(%rbp), %rdi
leaq 0x18586(%rip), %rsi     # 0x3bc68
leaq 0x170af(%rip), %rdx     # 0x3a798
movq $-0x2, %rcx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x23703
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x23703
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x920e(%rip), %rdi      # 0x2c932
callq 0x12db0
movq %rax, -0x48(%rbp)
jmp 0x2372f
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, -0x58(%rbp)
jmp 0x23742
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x23c70
jmp 0x23751
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x20, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2b6c0
jmp 0x2377c
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8260
jmp 0x237ba
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8260
movq -0x20(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
callq 0x8290
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x7c58(%rip), %rdi      # 0x2c47d
callq 0x12db0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20680
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x7c24(%rip), %rdi      # 0x2c482
callq 0x12db0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x20680
movq %rax, -0x28(%rbp)
movl $0x20, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xee50
jmp 0x248a2
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x8260
movq -0x38(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x9780
movq -0x58(%rbp), %rax
leaq 0x109f9(%rip), %rcx     # 0x3af08
movq %rcx, (%rax)
movl $0x1, %edi
callq 0x8290
movq %rax, -0x50(%rbp)
jmp 0x2a522
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12b70
movq %rax, -0x60(%rbp)
jmp 0x2a539
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, -0x68(%rbp)
jmp 0x2a54c
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x50, %edi
callq 0x8290
movq %rax, -0x70(%rbp)
jmp 0x2a564
movq -0x38(%rbp), %rsi
leaq 0x23bb(%rip), %rdi      # 0x2c92a
callq 0x12db0
movq %rax, -0x78(%rbp)
jmp 0x2a57a
movq -0x78(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, -0x80(%rbp)
jmp 0x2a58d
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x237d0
jmp 0x2a59c
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x88(%rbp)
jmp 0x2a5b7
movq -0x38(%rbp), %rsi
leaq 0x2370(%rip), %rdi      # 0x2c932
callq 0x12db0
movq %rax, -0x90(%rbp)
jmp 0x2a5d0
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, -0x98(%rbp)
jmp 0x2a5e9
movq -0x98(%rbp), %rsi
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rdx
callq 0x27db0
jmp 0x2a602
movq -0x58(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2a66f
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8260
jmp 0x2a66f
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8260
movq -0x58(%rbp), %rdi
callq 0x9830
movq -0x28(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x2b787
movb $0x1, -0x1(%rbp)
jmp 0x2b8a1
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2b7b6
movq -0x38(%rbp), %rdi
leaq 0xe920(%rip), %rsi      # 0x3a0c0
leaq 0x104c1(%rip), %rdx     # 0x3bc68
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x2b7be
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x2b7be
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2b7d6
movb $0x0, -0x1(%rbp)
jmp 0x2b8a1
movq -0x30(%rbp), %rdi
callq 0x2b9b0
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2b9b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x2b801
movb $0x0, -0x1(%rbp)
jmp 0x2b8a1
movq -0x30(%rbp), %rdi
callq 0x2b9d0
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2b9d0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
je 0x2b829
movb $0x0, -0x1(%rbp)
jmp 0x2b8a1
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x2b9b0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x2b89d
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0x2b88d
movb $0x0, -0x1(%rbp)
jmp 0x2b8a1
jmp 0x2b88f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2b831
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x9e10
jmp 0x2b8df
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x102e(%rip), %rsi      # 0x2c920
callq 0x9e70
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1012(%rip), %rsi      # 0x2c92a
callq 0xa6f0
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0xff4(%rip), %rsi       # 0x2c932
callq 0xa6f0
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x2b979
movq -0x50(%rbp), %rdi
callq 0x9ff0
movq -0x50(%rbp), %rdi
callq 0x8260
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0x2ba6f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1506(%rip), %rsi      # 0x2cf88
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %edx
leaq 0x862(%rip), %rsi       # 0x2c2fb
callq 0x9ed0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x850(%rip), %rsi       # 0x2c301
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x840(%rip), %rsi       # 0x2c309
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rdx
leaq 0xb6b(%rip), %rsi       # 0x2c64c
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x30(%rax), %rdx
leaq 0x1510(%rip), %rsi      # 0x2d009
callq 0xa6f0
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x2bb34
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0x2bd2f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x124d(%rip), %rsi      # 0x2cf8f
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %edx
leaq 0x5a2(%rip), %rsi       # 0x2c2fb
callq 0x9ed0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x590(%rip), %rsi       # 0x2c301
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x580(%rip), %rsi       # 0x2c309
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rdx
leaq 0x8ab(%rip), %rsi       # 0x2c64c
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x38(%rax), %rdx
movq 0x30(%rax), %rax
movl %eax, %ecx
leaq 0x125e(%rip), %rsi      # 0x2d01d
callq 0x2be60
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x30(%rax), %rdx
leaq 0x123e(%rip), %rsi      # 0x2d015
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x40(%rax), %rdx
movq 0x30(%rax), %rax
movl %eax, %ecx
leaq 0x122e(%rip), %rsi      # 0x2d023
callq 0x17ac0
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x2be30
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopl (%rax,%rax)
// File: 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
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x568(%rip), %rsi       # 0x2c3ff
movb $0x0, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl $0x0, -0x414(%rbp)
movl -0x414(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2bf14
leaq -0x410(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x414(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1147(%rip), %rsi      # 0x2d02d
movb $0x0, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
jmp 0x2bebe
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq 0x4e8(%rip), %rsi       # 0x2c40d
callq 0xa0f0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
// File: 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 0x95d0
callq 0x95e0
callq 0x95f0
callq 0x9600
callq 0x9610
callq 0x9620
callq 0x9630
callq 0x9640
callq 0x9650
callq 0x9660
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl 0x2daf(%rip), %eax      # 0x4054
addl $0x1, %eax
movl %eax, 0x2da6(%rip)      # 0x4054
movl 0x2db8(%rip), %eax      # 0x406c
addl $0x1, %eax
movl %eax, 0x2daf(%rip)      # 0x406c
movl 0x2d95(%rip), %eax      # 0x4058
addl $0x1, %eax
movl %eax, 0x2d8c(%rip)      # 0x4058
movl $0x61, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
callq 0x11c0
callq 0x1220
movq 0x2ceb(%rip), %rdi      # 0x3fd8
leaq 0xd15(%rip), %rsi       # 0x2009
callq 0x1040
movq %rax, %rdi
movl 0x2d6a(%rip), %esi      # 0x406c
callq 0x1070
movq %rax, %rdi
leaq 0xcfc(%rip), %rsi       # 0x200d
callq 0x1040
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2c9d(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: giovifazi[P]knossos-bloodbath/Node.cpp
// Function: Node::Node(int, int)
Node::Node(int xx, int yy)
{
   x = xx;
   y = yy;
   nord = NULL;
   sud = NULL;
   est = NULL;
   ovest = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x20(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x24(%rax)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
popq %rbp
retq
nop
// File: giovifazi[P]knossos-bloodbath/Node.cpp
// Function: Node::get_cardinal(char)
Node* Node::get_cardinal(char cardinal_dir)
{
	switch (cardinal_dir)
	{
   	case 'n':
			return nord;
			break;

      case 's':
			return sud;
			break;

      case 'e':
			return est;
			break;

      case 'o':
			return ovest;
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsbl -0x11(%rbp), %eax
addl $-0x65, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xe, %eax
ja 0x3603
movq -0x20(%rbp), %rax
leaq 0x8afd(%rip), %rcx      # 0xc0c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3605
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3605
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3605
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3605
ud2
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movsbl -0x9(%rbp), %eax
addl $-0x65, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xe, %eax
ja 0x3685
movq -0x20(%rbp), %rax
leaq 0x8ab5(%rip), %rcx      # 0xc0fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x3685
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x3685
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x3685
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: giovifazi[P]knossos-bloodbath/Map.cpp
// Function: Map::getPresAt(int, int)
int Map::getPresAt(int x, int y)
{
  // -99999 è il valore di ritorno in caso di coordinate sbagliate
  // Calcolo il numero di spostamenti per arrivare alla cella (x,y)
  int Xmoves = std::abs(mostLeft) + (x);
  int Ymoves = mostUp - (y);

  bool exit = false;  // Serve per uscire dal metodo se ci sono problemi

  // Controllo se vado o meno out of bounds, in tale caso stampa errore
  if ((Ymoves >= height) || (Ymoves < 0))
  {
    //std::cout << "Map get y value is out of bounds (" << y << ")\n";
    exit = true;
  }

  if ((Xmoves >= width) || (Xmoves < 0))
  {
    //std::cout << "Map get x value is out of bounds (" << x << ")\n";
    exit = true;
  }

  // Se i valori x,y sono legali sposta i puntatori lungo gli assi e cambia il val
  if (exit == false)
  {
    listaY* itery = origin;             // iteratore per l' asse y

    for (int i = 0; i < Ymoves; i++)
      itery = itery->down;

    listaX* iterx = itery->h;           // iteratore per l' asse x

    for (int k = 0; k < Xmoves; k++)
      iterx = iterx->next;

    return(iterx->pres);                 // Ritorno il valore
  }
  else
  // se ho coordinate illegali ritorna il valore di errore
    return(-99999);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movl 0x10(%rcx), %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl 0x14(%rcx), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movl -0x20(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x42e1
cmpl $0x0, -0x20(%rbp)
jge 0x42e5
movb $0x1, -0x21(%rbp)
movq -0x50(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x42f7
cmpl $0x0, -0x1c(%rbp)
jge 0x42fb
movb $0x1, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4375
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x4338
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x431a
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4369
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x434b
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x437c
movl $0xfffe7961, -0x4(%rbp) # imm = 0xFFFE7961
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x10, %edi
callq 0x21b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rax
movq $0x0, (%rax)
movl $0x18, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x5140
jmp 0x43e0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdx
movq (%rax), %rcx
movq %rdx, 0x8(%rcx)
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq $0x0, (%rcx)
movl -0xc(%rbp), %edx
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movl %edx, 0x8(%rcx)
movl $0x0, 0x14(%rax)
movl $0x0, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x21c0
movq -0x18(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x46f5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x46d5
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq 0xf90d(%rip), %rdi      # 0x13fd0
callq 0x2310
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x46ae
movq 0xf8f4(%rip), %rdi      # 0x13fd0
leaq 0xc296(%rip), %rsi      # 0x10979
callq 0x21a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x469b
movq 0xf8d4(%rip), %rdi      # 0x13fd0
leaq 0x7a35(%rip), %rsi      # 0xc138
callq 0x21a0
movq 0xf8c1(%rip), %rdi      # 0x13fd0
leaq 0x7a36(%rip), %rsi      # 0xc14c
callq 0x21a0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x2310
movq %rax, %rdi
leaq 0x7a1a(%rip), %rsi      # 0xc14e
callq 0x21a0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x2310
movq %rax, %rdi
leaq 0x85a4(%rip), %rsi      # 0xccf6
callq 0x21a0
movq 0xf872(%rip), %rdi      # 0x13fd0
leaq 0x79ec(%rip), %rsi      # 0xc151
callq 0x21a0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x2310
movq %rax, %rdi
leaq 0x79d7(%rip), %rsi      # 0xc15a
callq 0x21a0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x2310
movq %rax, %rdi
movq 0xf81f(%rip), %rsi      # 0x13fc0
callq 0x21e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: giovifazi[P]knossos-bloodbath/Map.cpp
// Function: Map::changeValue(int, int, int, int)
void Map::changeValue(int x, int y, int v, int p)
{
  // Calcolo il numero di spostamenti per arrivare alla cella (x,y)
  int Xmoves = std::abs(mostLeft) + (x);
  int Ymoves = mostUp - (y);

  bool exit = false;  // Serve per uscire dal metodo se ci sono problemi

  // Controllo se vado o meno out of bounds, in tale caso stampa errore
  if ((Ymoves >= height) || (Ymoves < 0))
  {
    //std::cout << "Map change y value out of bounds (" << y << ")\n";
    exit = true;
  }

  if ((Xmoves >= width) || (Xmoves < 0))
  {
    //std::cout << "Map change x value out of bounds (" << x << ")\n";
    exit = true;
  }

  // Se i valori x,y sono legali sposta i puntatori lungo gli assi e cambia il val
  if (exit == false)
  {
    listaY* itery = origin;             // iteratore per l' asse y

    for (int i = 0; i < Ymoves; i++)
      itery = itery->down;

    listaX* iterx = itery->h;           // iteratore per l' asse x

    for (int k = 0; k < Xmoves; k++)
      iterx = iterx->next;

    iterx->val = v;                     // Cambio il valore
    iterx->pres = iterx->pres + p;
  }
  else
  // se ho coordinate illegali esci
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movl 0x10(%rcx), %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl 0x14(%rcx), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movl -0x20(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x4f98
cmpl $0x0, -0x20(%rbp)
jge 0x4f9c
movb $0x1, -0x21(%rbp)
movq -0x50(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4fae
cmpl $0x0, -0x1c(%rbp)
jge 0x4fb2
movb $0x1, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x503d
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x4fef
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4fd1
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x5020
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5002
movl -0x14(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x40(%rbp), %rax
movl 0xc(%rax), %ecx
addl -0x18(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x503f
jmp 0x503f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: giovifazi[P]knossos-bloodbath/Map.cpp
// Function: Map::set_Turn(int, int, bool)
void Map::set_Turn(int x, int y, bool t)
{
  // Calcolo il numero di spostamenti per arrivare alla cella (x,y)
  int Xmoves = std::abs(mostLeft) + (x);
  int Ymoves = mostUp - (y);

  bool exit = false;  // Serve per uscire dal metodo se ci sono problemi

  // Controllo se vado o meno out of bounds, in tale caso stampa errore
  if ((Ymoves >= height) || (Ymoves < 0))
  {
    //std::cout << "Map change y value out of bounds (" << y << ")\n";
    exit = true;
  }

  if ((Xmoves >= width) || (Xmoves < 0))
  {
    //std::cout << "Map change x value out of bounds (" << x << ")\n";
    exit = true;
  }

  // Se i valori x,y sono legali sposta i puntatori lungo gli assi e cambia il val
  if (exit == false)
  {
    listaY* itery = origin;             // iteratore per l' asse y

    for (int i = 0; i < Ymoves; i++)
      itery = itery->down;

    listaX* iterx = itery->h;           // iteratore per l' asse x

    for (int k = 0; k < Xmoves; k++)
      iterx = iterx->next;

    iterx->turn = t;
  }
  else
  // se ho coordinate illegali esci
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movl 0x10(%rcx), %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
addl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl 0x14(%rcx), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x5098
cmpl $0x0, -0x1c(%rbp)
jge 0x509c
movb $0x1, -0x1d(%rbp)
movq -0x48(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x50ae
cmpl $0x0, -0x18(%rbp)
jge 0x50b2
movb $0x1, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x512f
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x50ef
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x50d1
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5120
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5102
movb -0x11(%rbp), %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
jmp 0x5131
jmp 0x5131
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2120
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x51c5
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x2370
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x51b8
movb $0x1, -0x1(%rbp)
jmp 0x51c9
jmp 0x51ba
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x517d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: giovifazi[P]knossos-bloodbath/Hud.cpp
// Function: printTitle()
void printTitle()
{
   std::cout<<std::endl;
   std::cout<<"          ██ ▄█▀ ███▄    █  ▒█████    ██████   ██████  ▒█████    ██████ "<<std::endl;
   std::cout<<"          ██▄█▒  ██ ▀█   █ ▒██▒  ██▒▒██    ▒ ▒██    ▒ ▒██▒  ██▒▒██    ▒ "<<std::endl;
   std::cout<<"          ▓███▄░ ▓██  ▀█ ██▒▒██░  ██▒░ ▓██▄   ░ ▓██▄   ▒██░  ██▒░ ▓██▄   "<<std::endl;
   std::cout<<"          ▓██ █▄ ▓██▒  ▐▌██▒▒██   ██░  ▒   ██▒  ▒   ██▒▒██   ██░  ▒   ██▒"<<std::endl;
   std::cout<<"          ▒██▒ █▄▒██░   ▓██░░ ████▓▒░▒██████▒▒▒██████▒▒░ ████▓▒░▒██████▒▒"<<std::endl;
   std::cout<<"          ▒ ▒▒ ▓▒░ ▒░   ▒ ▒ ░ ▒░▒░▒░ ▒ ▒▓▒ ▒ ░▒ ▒▓▒ ▒ ░░ ▒░▒░▒░ ▒ ▒▓▒ ▒ ░"<<std::endl;
   std::cout<<"          ░ ░▒ ▒░░ ░░   ░ ▒░  ░ ▒ ▒░ ░ ░▒  ░ ░░ ░▒  ░ ░  ░ ▒ ▒░ ░ ░▒  ░ ░"<<std::endl;
   std::cout<<"          ░ ░░ ░    ░   ░ ░ ░ ░ ░ ▒  ░  ░  ░  ░  ░  ░  ░ ░ ░ ▒  ░  ░  ░  "<<std::endl;
   std::cout<<"          ░  ░            ░     ░ ░        ░        ░      ░ ░       "<<std::endl; 
   std::cout<<"          ░                                                        "<<std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xbc65(%rip), %rdi      # 0x13fd0
movq 0xbc4e(%rip), %rsi      # 0x13fc0
callq 0x21e0
movq 0xbc52(%rip), %rdi      # 0x13fd0
leaq 0x72b2(%rip), %rsi      # 0xf637
callq 0x21a0
movq %rax, %rdi
movq 0xbc2c(%rip), %rsi      # 0x13fc0
callq 0x21e0
movq 0xbc30(%rip), %rdi      # 0x13fd0
leaq 0x7329(%rip), %rsi      # 0xf6d0
callq 0x21a0
movq %rax, %rdi
movq 0xbc0a(%rip), %rsi      # 0x13fc0
callq 0x21e0
movq 0xbc0e(%rip), %rdi      # 0x13fd0
leaq 0x7398(%rip), %rsi      # 0xf761
callq 0x21a0
movq %rax, %rdi
movq 0xbbe8(%rip), %rsi      # 0x13fc0
callq 0x21e0
movq 0xbbec(%rip), %rdi      # 0x13fd0
leaq 0x7416(%rip), %rsi      # 0xf801
callq 0x21a0
movq %rax, %rdi
movq 0xbbc6(%rip), %rsi      # 0x13fc0
callq 0x21e0
movq 0xbbca(%rip), %rdi      # 0x13fd0
leaq 0x748a(%rip), %rsi      # 0xf897
callq 0x21a0
movq %rax, %rdi
movq 0xbba4(%rip), %rsi      # 0x13fc0
callq 0x21e0
movq 0xbba8(%rip), %rdi      # 0x13fd0
leaq 0x7524(%rip), %rsi      # 0xf953
callq 0x21a0
movq %rax, %rdi
movq 0xbb82(%rip), %rsi      # 0x13fc0
callq 0x21e0
movq 0xbb86(%rip), %rdi      # 0x13fd0
leaq 0x75a0(%rip), %rsi      # 0xf9f1
callq 0x21a0
movq %rax, %rdi
movq 0xbb60(%rip), %rsi      # 0x13fc0
callq 0x21e0
movq 0xbb64(%rip), %rdi      # 0x13fd0
leaq 0x760c(%rip), %rsi      # 0xfa7f
callq 0x21a0
movq %rax, %rdi
movq 0xbb3e(%rip), %rsi      # 0x13fc0
callq 0x21e0
movq 0xbb42(%rip), %rdi      # 0x13fd0
leaq 0x7664(%rip), %rsi      # 0xfaf9
callq 0x21a0
movq %rax, %rdi
movq 0xbb1c(%rip), %rsi      # 0x13fc0
callq 0x21e0
movq 0xbb20(%rip), %rdi      # 0x13fd0
leaq 0x769a(%rip), %rsi      # 0xfb51
callq 0x21a0
movq %rax, %rdi
movq 0xbafa(%rip), %rsi      # 0x13fc0
callq 0x21e0
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x22c0
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x48(%rbp)
callq 0x22c0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2030
jmp 0x8883
movq -0x50(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x28(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2100
movq -0x40(%rbp), %rdi
callq 0x2100
movq -0x28(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: giovifazi[P]knossos-bloodbath/Game.cpp
// Function: battleChoice()
bool battleChoice()
{
	std::string choice;

	std::cout<<"Vuoi combattere? [y/n]\n";
	std::cin>>choice;

	if (choice == "y") 
		return true;
	
	else if (choice == "n")
		return false;
	
	else
		return battleChoice();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x28(%rbp), %rdi
callq 0x22c0
movq 0x8878(%rip), %rdi      # 0x13fd0
leaq 0x5c5c(%rip), %rsi      # 0x113bb
callq 0x21a0
jmp 0xb766
movq 0x8873(%rip), %rdi      # 0x13fe0
leaq -0x28(%rbp), %rsi
callq 0x2280
jmp 0xb778
leaq 0x5c54(%rip), %rsi      # 0x113d3
leaq -0x28(%rbp), %rdi
callq 0x97e0
movb %al, -0x39(%rbp)
jmp 0xb78d
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xb796
jmp 0xb7ba
movb $0x1, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0xb7fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2100
jmp 0xb812
leaq 0x5c14(%rip), %rsi      # 0x113d5
leaq -0x28(%rbp), %rdi
callq 0x97e0
movb %al, -0x3a(%rbp)
jmp 0xb7cf
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0xb7d8
jmp 0xb7e5
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0xb7fe
callq 0xb740
movb %al, -0x3b(%rbp)
jmp 0xb7ef
movb -0x3b(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2100
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2320
nopl (%rax,%rax)
// File: giovifazi[P]knossos-bloodbath/Game.cpp
// Function: is_command(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool is_command(std::string cmd, std::string allowed)
{
   int n = allowed.size();

   // Controllo grandezza sui valori validi
   if (n == 0)
      return false;
   
   // Controllo grandezza sull input
   if (cmd.size() != 1) return false;

   // Controllo validita caratteri input
   for (int i=0; i < n; i++)
      if (cmd[0] == allowed[i])
         return true;
   
   return false;  // eseguito qunado fallisce il controllo
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x2120
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xb857
movb $0x0, -0x1(%rbp)
jmp 0xb8bf
movq -0x30(%rbp), %rdi
callq 0x2120
cmpq $0x1, %rax
je 0xb86c
movb $0x0, -0x1(%rbp)
jmp 0xb8bf
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb8bb
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2370
movq -0x28(%rbp), %rdi
movsbl (%rax), %eax
movl %eax, -0x3c(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x2370
movq %rax, %rcx
movl -0x3c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xb8ae
movb $0x1, -0x1(%rbp)
jmp 0xb8bf
jmp 0xb8b0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb873
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)