LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::clone()
Map* clone() {
      Map *new_map = new Map();
      Object** this_keys = this->keys();
      size_t len = this->size();
      for (size_t i = 0; i < len; i++) {
        new_map->add(this_keys[i], this->get(this_keys[i]));
      }
      return new_map;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x30
popq %rdi
callq 0x7250
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0x9a6a
movq %rbx, %rdi
callq 0xa152
movq %rax, %r15
movq %rbx, %r14
movq 0x20(%rbx), %r13
xorl %ebx, %ebx
cmpq %rbx, %r13
je 0x9e39
movq (%r15,%rbx,8), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xa248
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xa522
incq %rbx
jmp 0x9e11
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Map");
        sb->write("numBuckets_", numBuckets_);
        sb->write("bucketsUsed_", bucketsUsed_);
        sb->write("items_", items_);
        char * seralizedBuckets = buckets_->serialize();
        sb->write("buckets_", seralizedBuckets, false);
        sb->endSerialize();
        char* value = sb->get();
        
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xe58a(%rip), %rsi      # 0x1840e
movq %rbx, %rdi
callq 0x7fd8
movq 0x10(%r14), %rdx
leaq 0xe57b(%rip), %rsi      # 0x18412
movq %rbx, %rdi
callq 0x8062
movq 0x18(%r14), %rdx
leaq 0xe574(%rip), %rsi      # 0x1841e
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0xe56e(%rip), %rsi      # 0x1842b
movq %rbx, %rdi
callq 0x8062
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xe55c(%rip), %rsi      # 0x18432
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9f04
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::hash()
size_t hash() {
    size_t res = 0;
    if (this->size() > 0) {
      size_t len = this->size();
      //go through the given list.
      ObjectNode *curNode = this->head_;
      for (size_t i = 0; i < len; i++) {
        Object *data = curNode->data_;
        //add the data's hash val to result.
        res += data->hash();
      }
    }
    return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x9f60
movq 0x10(%rdi), %r15
xorl %ebx, %ebx
subq $0x1, %r14
jb 0x9f62
movq 0x10(%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq %rax, %rbx
jmp 0x9f4b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::equals(Object*)
bool equals(Object* o) {
    //if the given object is a nullptr, it's not equal to this.
    if (o == nullptr) return false;
    //if the given pointer is not an ObjectQueue, it's not equal to this.
		Queue *other = dynamic_cast<Queue*>(o);
    //if two queue's don't have the same size they're not equal.
    if (this->size_ != other->size()) {
      return false;
    }

    if (this->size_ > 0) {
      ObjectNode *node1 = this->head_;
      ObjectNode *node2 = other->head_;
      for (size_t i = 0; i < this->size_; i++) {
        //if the node's at the corresponding indices are not the same, the queue's are not equal. 
        if (!(node1->equals(node2))) {
          return false;
        }
        //shift the respective node pointers to the next elements.
        node1 = node1->getNext();
        node2 = node2->getNext();
      }
      return true;

    } else {
      //queue's of size 0 are equal.
      return true;
    } 
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x9ff8
movq %rdi, %rbx
leaq 0x1931b(%rip), %rax     # 0x232a8
leaq 0x19974(%rip), %rdx     # 0x23908
xorl %r12d, %r12d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
movq 0x20(%rbx), %rcx
cmpq 0x20(%rax), %rcx
jne 0xa000
testq %rcx, %rcx
je 0x9ffd
movq 0x10(%rbx), %r14
movq 0x10(%rax), %r15
xorl %r13d, %r13d
cmpq %rcx, %r13
setae %r12b
jae 0xa000
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x18(%rax)
testb %al, %al
je 0xa000
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x40(%rax)
movq %rax, %r15
incq %r13
movq 0x20(%rbx), %rcx
jmp 0x9fbe
xorl %r12d, %r12d
jmp 0xa000
movb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("Queue");
    sb->write("size_", size_);
    Object** objs_ = new Object*[this->size_];
    //go through the given list.
    for (size_t i = 0; i < this->size_; i++) {
        objs_[i] =  this->get(i);
    }
    sb->write("queueObjs_", objs_, this->size_);
    sb->endSerialize();
    char* value = sb->get();
    delete sb;
    return value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xe381(%rip), %rsi      # 0x183be
movq %rbx, %rdi
callq 0x7fd8
movq 0x20(%r14), %rdx
leaq 0xe374(%rip), %rsi      # 0x183c4
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %r15
movq %r15, %rax
shrq $0x3d, %rax
leaq (,%r15,8), %rcx
xorl %r12d, %r12d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x7030
movq %rax, %r13
cmpq %r15, %r12
jae 0xa0a2
movq %r14, %rdi
movl %r12d, %esi
callq 0xa106
movq %rax, (%r13,%r12,8)
incq %r12
movq 0x20(%r14), %r15
jmp 0xa084
leaq 0xe321(%rip), %rsi      # 0x183ca
movq %rbx, %rdi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x8bf6
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa0d8
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::get(int)
Object *get(int to_get) {
    if (this->size() > 0) {
      size_t len = this->size();
      //go through the given list.
      ObjectNode *curNode = this->head_;
      for (size_t i = 0; i < len; i++) {
        if (to_get == i) {
          return curNode->data_;
        }
        curNode = curNode ->getNext();
      }
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0xa13e
movq 0x10(%rdi), %rax
movslq %esi, %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpq %r12, %r14
je 0xa146
cmpq %r12, %r15
je 0xa142
movq (%rax), %rcx
movq %rax, %rdi
callq *0x40(%rcx)
incq %r12
jmp 0xa126
xorl %ebx, %ebx
jmp 0xa146
movq 0x10(%rax), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::keys()
Object** keys() {
      Object** keys = new Object*[this->items_];
      size_t index_to_assign = 0;
      for (size_t i = 0; i < this->numBuckets_; i++) {
        Queue *queue_at_index = dynamic_cast<Queue*>(this->buckets_->get(i));
        for (size_t j = 0; j < queue_at_index->size(); j++) {
          KeyVal *key_val = dynamic_cast<KeyVal *>(queue_at_index->get(j));
          keys[index_to_assign] = key_val->getKey();
          index_to_assign +=1;
        }
      }
      return keys;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
xorl %r14d, %r14d
negq %rcx
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x7030
movq %rax, -0x30(%rbp)
leaq 0x19112(%rip), %r12     # 0x232a8
leaq 0x19783(%rip), %r13     # 0x23920
movq $0x0, -0x38(%rbp)
movq %rbx, -0x40(%rbp)
cmpq 0x10(%rbx), %r14
jae 0xa234
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
movq %r14, -0x48(%rbp)
je 0xa1e2
movq %rax, %rdi
movq %r12, %rsi
leaq 0x19732(%rip), %rdx     # 0x23908
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r15
jmp 0xa1e5
xorl %r15d, %r15d
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
leaq (%rax,%rcx,8), %r14
xorl %ebx, %ebx
cmpq 0x20(%r15), %rbx
jae 0xa220
movq %r15, %rdi
movl %ebx, %esi
callq 0xa106
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x72a0
movq 0x10(%rax), %rax
movq %rax, (%r14,%rbx,8)
incq %rbx
jmp 0xa1f3
movq -0x48(%rbp), %r14
incq %r14
addq %rbx, -0x38(%rbp)
movq -0x40(%rbp), %rbx
jmp 0xa1a9
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::get(Object*)
Object* get(Object* key) {
      //std::cout << "Map get: " << "key: " << key->serialize() << "\n";
      size_t key_hash = key->hash();
      //std::cout << "get hash" << key_hash << "\n";
      KeyVal *wrappedkey = new KeyVal(key, nullptr);
      size_t index = key_hash % this->numBuckets_;
      //std::cout << "map get queue index: " << index << " num buckets: "<< numBuckets_<<"\n";
      Queue *queue_at_index = dynamic_cast<Queue*>(this->buckets_->get(index));
      //std::cout << "get queue: " << queue_at_index->serialize() << "\n";
      Object* keyVal = queue_at_index->get(wrappedkey);
      if (keyVal != nullptr) {
        //key is in map.
        //std::cout << "found key in map\n";
        KeyVal *key_val = dynamic_cast<KeyVal*>(keyVal);
        Object* val = key_val->getVal();
        // if (val == nullptr) {
        //   std::cout << "val is null " << "\n";
        // }
        // std::cout << "val is not null " << "\n";
        return val;
      } else {
        std::cout << "ERROR: Key not found in map" << "key: " << key->serialize() << "\n";
        //key is not in map
        //std::cout<<"ERROR: Key not found in map\n";
        return nullptr;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movq %rax, %r12
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r14
andq $0x0, 0x8(%rax)
leaq 0x196cc(%rip), %rax     # 0x23948
movq %rax, (%r14)
movq %rbx, 0x10(%r14)
andq $0x0, 0x18(%r14)
movq %r12, %rax
xorl %edx, %edx
divq 0x10(%r15)
movq 0x28(%r15), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x40(%rax)
leaq 0x19003(%rip), %rsi     # 0x232a8
leaq 0x1965c(%rip), %rdx     # 0x23908
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %rdi
movq %r14, %rsi
callq 0xa338
testq %rax, %rax
je 0xa2e4
leaq 0x18fdb(%rip), %rsi     # 0x232a8
leaq 0x1964c(%rip), %rdx     # 0x23920
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq 0x18(%rax), %rax
jmp 0xa32e
movq 0x1acd5(%rip), %rdi     # 0x24fc0
leaq 0xe0e3(%rip), %rsi      # 0x183d5
callq 0x7240
leaq 0xe5c1(%rip), %rsi      # 0x188bf
movq %rax, %rdi
callq 0x7240
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x7240
leaq 0xddc5(%rip), %rsi      # 0x180e9
movq %rax, %rdi
callq 0x7240
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::get(Object*)
Object *get(Object* o) {
    if (this->size() > 0) {
      size_t len = this->size();
      //std::cout << "in queue get, size: " << len << "\n";
      //go through the given list.
      ObjectNode *curNode = this->head_;
      for (size_t i = 0; i < len; i++) {
        if (curNode->data_->equals(o)) {
          //std::cout << "found key: "<< curNode->data_->serialize() <<"\n";
          return curNode->data_;
        }
        curNode = curNode ->getNext();
      }
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x20(%rdi), %r12
testq %r12, %r12
je 0xa37a
movq %rsi, %r14
movq 0x10(%rdi), %r15
xorl %ebx, %ebx
subq $0x1, %r12
jb 0xa382
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0xa37e
movq (%r15), %rax
movq %r15, %rdi
callq *0x40(%rax)
movq %rax, %r15
jmp 0xa355
xorl %ebx, %ebx
jmp 0xa382
movq 0x10(%r15), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/keyVal.h
// Function: KeyVal::equals(Object*)
virtual bool equals(Object *other) {
        if (other == nullptr) return false;
		KeyVal *kv = dynamic_cast<KeyVal*>(other);
		if (kv == nullptr) {
			return false;
		}
        //std::cout << "in KevVal equals: " << "key: " << key_->serialize() << " val: " << val_->serialize() << "\n";
        //it is okay to only check if the keys because in a map one key only maps to a single value. 
		return this->getKey()->equals(kv->getKey());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xa3dd
movq %rdi, %rbx
leaq 0x18efb(%rip), %rax     # 0x232a8
leaq 0x1956c(%rip), %rdx     # 0x23920
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xa3dd
movq 0x10(%rbx), %rdi
movq 0x10(%rax), %rsi
movq (%rdi), %rax
movq 0x18(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/keyVal.h
// Function: KeyVal::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("KeyVal");
        char * seralizedKey = key_->serialize();
        sb->write("key_", seralizedKey, false);
        char * seralizedVal = val_->serialize();
        sb->write("val_", seralizedVal, false);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xdfd7(%rip), %rsi      # 0x183f1
movq %rbx, %rdi
callq 0x7fd8
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xdfc5(%rip), %rsi      # 0x183f8
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xdfac(%rip), %rsi      # 0x183fd
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa47f
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, char*, bool)
void write(const char* name, char* val, bool wrap) {
        int SIZEOFINSERTS = 10;
        char str[strlen(val) + strlen(name) + SIZEOFINSERTS];
        if(wrap) {
            sprintf(str, "'%s' : '%s', ", name, val);
        } else {
            sprintf(str, "'%s' : %s, ", name, val);
        }
        buff->c(str);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x7110
movq %rax, %r13
movq %r15, %rdi
callq 0x7110
addq %r13, %rax
addq $0x19, %rax
andq $-0x10, %rax
movq %rsp, %r13
subq %rax, %r13
movq %r13, %rsp
leaq 0xde66(%rip), %rax      # 0x18350
leaq 0xdf11(%rip), %rsi      # 0x18402
testl %r12d, %r12d
cmovneq %rax, %rsi
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x7080
movq (%rbx), %rdi
movq %r13, %rsi
callq 0x8114
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::add(Object*, Object*)
void add(Object* key, Object* value) {
      //std::cout << "Map put: " << "key: " << key->serialize() << " val: " << value->serialize() << "\n";
      size_t key_hash = key->hash();
      //std::cout << "put hash" << key_hash << "\n";
      KeyVal *key_val = new KeyVal(key, value);
      size_t index = key_hash % this->numBuckets_;
      //std::cout << "map put queue index: " << index << "\n";
      Queue *queue_at_index = dynamic_cast<Queue*>(this->buckets_->get(index));
      if (queue_at_index->size() == 0) {
        this->bucketsUsed_ += 1;
        if (((float) this->bucketsUsed_ / (float) this->numBuckets_) > 0.75) {
          this->rehash_();
        }
      } 
      if (queue_at_index->get(key_val) == nullptr) {
        queue_at_index->add(key_val);
      } else {
        Object* removed = this->pop_item(key);
        //String *before  = dynamic_cast<String*>(key_val->getVal());
        queue_at_index->add(key_val);
        //String *after  = dynamic_cast<String*>(this->get(key));
      }
      this->items_ += 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movq %rax, %r13
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
andq $0x0, 0x8(%rax)
leaq 0x193ec(%rip), %rax     # 0x23948
movq %rax, (%r15)
movq %r14, 0x10(%r15)
movq %r12, 0x18(%r15)
movq %r13, %rax
xorl %edx, %edx
divq 0x10(%rbx)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x40(%rax)
leaq 0x18d24(%rip), %rsi     # 0x232a8
leaq 0x1937d(%rip), %rdx     # 0x23908
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r12
cmpq $0x0, 0x20(%rax)
jne 0xa602
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
incq %rcx
movq %rcx, 0x18(%rbx)
js 0xa5b7
cvtsi2ss %rcx, %xmm0
jmp 0xa5cc
movq %rcx, %rdx
shrq %rdx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
testq %rax, %rax
js 0xa5d8
cvtsi2ss %rax, %xmm1
jmp 0xa5ed
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
ucomiss 0xda88(%rip), %xmm0     # 0x18080
jbe 0xa602
movq %rbx, %rdi
callq 0xa63c
movq %r12, %rdi
movq %r15, %rsi
callq 0xa338
testq %rax, %rax
je 0xa61d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa7b4
movq %r12, %rdi
movq %r15, %rsi
callq 0xa744
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::rehash_()
void rehash_() {
      KeyVal *key_val[this->items_];
      Object** this_keys = this->keys();
      for (size_t i = 0; i < this->size(); i++) {
        key_val[i] = new KeyVal(this_keys[i], this->get(this_keys[i]));
      }

      size_t items = this->items_;

      this->numBuckets_ = 2 * this->numBuckets_;
      this->bucketsUsed_ = 0;
      this->items_ = 0;

      delete this->buckets_;

      this->buckets_ = new Array(this->numBuckets_);

      for (size_t i = 0; i < items; i++) {
        this->add(key_val[i]->getKey(), key_val[i]->getVal());
      }     
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq %rsp, %rcx
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
callq 0xa152
movq %rax, %r15
xorl %r12d, %r12d
movq 0x20(%rbx), %r13
cmpq %r13, %r12
jae 0xa6bc
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r14
movq (%r15,%r12,8), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa248
andq $0x0, 0x8(%r14)
leaq 0x192a4(%rip), %rcx     # 0x23948
movq %rcx, (%r14)
movq %r13, 0x10(%r14)
movq %rax, 0x18(%r14)
movq -0x30(%rbp), %rax
movq %r14, (%rax,%r12,8)
incq %r12
jmp 0xa675
movq 0x10(%rbx), %r15
movq 0x28(%rbx), %rdi
addq %r15, %r15
movq %r15, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
testq %rdi, %rdi
je 0xa6e1
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %r15
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x9c9c
movq %r14, 0x28(%rbx)
xorl %r14d, %r14d
cmpq %r14, %r13
je 0xa720
movq -0x30(%rbp), %rax
movq (%rax,%r14,8), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq %rbx, %rdi
callq 0xa522
incq %r14
jmp 0xa6fe
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa731
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::add(Object*)
void add(Object* o) {
    //create the linked list node.
    ObjectNode *newNode = new ObjectNode(o);
    if (this->head_ == nullptr) {
      //adding in first element. set both head and tail to be that element.
      this->head_ = newNode;
      this->tail_ = newNode;
      //increment size.
      this->size_+=1;
    } else{
      this->tail_->setNext(newNode);
      newNode->setPrev(this->tail_);
      this->tail_ = newNode;
      this->size_+=1;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
andq $0x0, 0x8(%rax)
leaq 0x1922d(%rip), %rax     # 0x23998
movq %rax, (%r14)
movq %r15, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
cmpq $0x0, 0x10(%rbx)
je 0xa79d
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x50(%rax)
movq 0x18(%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x58(%rax)
jmp 0xa7a1
movq %r14, 0x10(%rbx)
movq %r14, 0x18(%rbx)
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::pop_item(Object*)
Object* pop_item(Object* key) {
      size_t key_hash = key->hash();
      int index = key_hash % this->numBuckets_;
      Queue *queue_at_index = dynamic_cast<Queue *>(this->buckets_->get(index));
      KeyVal *wrappedkey = new KeyVal(key, nullptr);
      this->items_ -= 1;
      if (queue_at_index->size() == 0) {
        this->bucketsUsed_ -= 1;    
      }
      KeyVal *keyVal = dynamic_cast<KeyVal*>(queue_at_index->remove(wrappedkey));
      return keyVal->getVal();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
xorl %r15d, %r15d
xorl %edx, %edx
divq 0x10(%rbx)
movq 0x28(%rbx), %rdi
movslq %edx, %rsi
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
je 0xa803
leaq 0x18ab9(%rip), %rsi     # 0x232a8
leaq 0x19112(%rip), %rdx     # 0x23908
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r15
pushq $0x20
popq %rdi
callq 0x7250
andq $0x0, 0x8(%rax)
leaq 0x19131(%rip), %rcx     # 0x23948
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
andq $0x0, 0x18(%rax)
decq 0x20(%rbx)
xorl %ecx, %ecx
cmpq %rcx, 0x20(%r15)
jne 0xa833
decq 0x18(%rbx)
movq %r15, %rdi
movq %rax, %rsi
callq 0xa8ee
leaq 0x18a63(%rip), %rsi     # 0x232a8
leaq 0x190d4(%rip), %rdx     # 0x23920
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq 0x18(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/listNode.h
// Function: ObjectNode::equals(Object*)
virtual bool equals(Object * other) {
		if (other == nullptr) return false;
        ObjectNode *o = dynamic_cast<ObjectNode*>(other);
		if (o == nullptr) {
			return false;
		}
        return this->data_->equals(o->data_);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xa8b5
movq %rdi, %rbx
leaq 0x18a23(%rip), %rax     # 0x232a8
leaq 0x1916c(%rip), %rdx     # 0x239f8
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xa8b5
movq 0x10(%rbx), %rdi
movq 0x10(%rax), %rsi
movq (%rdi), %rax
movq 0x18(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::remove(Object*)
Object* remove(Object* o) {
    if (this->size() > 0) {
      size_t len = this->size();
      ObjectNode *to_remove = nullptr;
      //go through the given list.
      ObjectNode *curNode = this->head_;
      for (size_t i = 0; i < len; i++) {
        //check if curNode's data is the same as o.
        if (curNode->data_->equals(o)) {
          //set the first node that is equal to the object to be removed.
          to_remove = curNode;
          break;
        }
        curNode = curNode->getNext(); 
      }
      if (!(to_remove == nullptr)) {
        if (to_remove->equals(this->head_)) {
          this->head_ = this->head_->getNext();
        }
        if (to_remove->equals(this->tail_)) {
          this->tail_ = this->tail_->getPrev();
        }
        //set to_remove's next's prev to to_remove's prev
        if (to_remove->getNext() != nullptr) {
          to_remove->getNext()->setPrev(to_remove->getPrev());
        }
        if (to_remove->getPrev() != nullptr) {
          to_remove->getPrev()->setNext(to_remove->getNext());
        }
        to_remove->setNext(nullptr);
        to_remove->setPrev(nullptr);
        this->size_ -= 1;
        return to_remove->data_;
      }
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r13
testq %r13, %r13
je 0xa93b
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rdi), %r14
xorl %r15d, %r15d
subq $0x1, %r13
jb 0xa9fd
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0xa943
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
movq %rax, %r14
jmp 0xa912
xorl %r15d, %r15d
jmp 0xa9fd
movq 0x10(%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
testb %al, %al
je 0xa962
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
testb %al, %al
je 0xa981
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, 0x18(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
testq %rax, %rax
je 0xa9b0
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq *0x58(%rcx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
testq %rax, %rax
je 0xa9df
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq *0x50(%rcx)
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
callq *0x50(%rax)
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
callq *0x58(%rax)
decq 0x20(%rbx)
movq 0x10(%r14), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::DoubleDistributedArray(KVStore*)
DoubleDistributedArray(KVStore* kv) {
        kv_ = kv;
        totalNodes_ = kv->num_nodes_;
        srand(time(nullptr));
        uid_ = rand();
        curNode_ = 0;
        itemCount_ = 0;
        chunkCount_ = 0;
        keys_ = new Array();
        chunkArray_ = new DoubleArray(chunkSize_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x19112(%rip), %rax     # 0x23b38
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq $0x32, 0x30(%rdi)
movq $0x400, 0x48(%rdi)      # imm = 0x400
movq %rsi, 0x10(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x68(%rdi)
xorl %edi, %edi
callq 0x7210
movl %eax, %edi
callq 0x7230
callq 0x70a0
cltq
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
andq $0x0, 0x60(%rbx)
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movq %rax, %rdi
callq 0x869c
movq %r14, 0x38(%rbx)
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movl 0x48(%rbx), %esi
movq %rax, %rdi
callq 0xaddc
movq %r14, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xaaa9
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedDoubleColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    DistributedDoubleColumn* other_ic = dynamic_cast<DistributedDoubleColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    DoubleDistributedArray* other_val_ = dynamic_cast<DoubleDistributedArray*>(other_ic->val_);
    return this->val_->equals(other_val_);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xab36
movq %rdi, %rbx
leaq 0x187c9(%rip), %rax     # 0x232a8
leaq 0x1902a(%rip), %rdx     # 0x23b10
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xab36
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0xc8(%rax)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xc8(%rax)
cmpq %rax, %r15
jne 0xab36
movq 0x18(%r14), %rsi
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedDoubleColumn::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("DistributedDoubleColumn");
    char * seralizedArr = val_->serialize();
    sb->write("val_", seralizedArr, false);
    sb->endSerialize();
    char* value = sb->get();
    delete sb;
    return value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xda91(%rip), %rsi      # 0x18609
movq %rbx, %rdi
callq 0x7fd8
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xd86c(%rip), %rsi      # 0x183fd
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xabbf
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedDoubleColumn::getColumnOnNode()
Column* getColumnOnNode() override {
    size_t _node = kv_->this_node_;
    DoubleColumn* col = new DoubleColumn();
    Array* keys = val_->keys_;
    for (size_t i = 0; i < keys->length(); i++) {
      Key* key = dynamic_cast<Key*>(val_->keys_->get(i));
      if (key->node_ == _node) { //only get the chunks that live locally on this node.
        Value* val = kv_->get(key);
        Deserializable ds;
        DoubleArray* chunk = dynamic_cast<DoubleArray*>(ds.deserialize(val->data));
        for (size_t j = 0; j < chunk->length(); j++) {
          col->push_back(chunk->get(j));
        }
        delete chunk;
      }
    }
    //if node 0, append the chunk_array_ at the end too.
    if (_node == 0) {
      DoubleArray* chunk_array = val_->chunkArray_;
      for (size_t j = 0; j < chunk_array->length(); j++) {
          col->push_back(chunk_array->get(j));
      }
    }
    return col;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movq 0x10(%rdi), %rax
movq 0x18(%rax), %r14
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0xc6fe
movq 0x18(%r12), %rax
movq 0x38(%rax), %r13
xorl %r15d, %r15d
movq %r12, -0x40(%rbp)
movq %r13, -0x38(%rbp)
cmpq 0x18(%r13), %r15
jae 0xad2f
movq 0x18(%r12), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
movq %rax, %rdi
leaq 0x1860b(%rip), %rsi     # 0x232a8
leaq 0x18b2c(%rip), %rdx     # 0x237d0
xorl %ecx, %ecx
callq 0x72a0
cmpq %r14, 0x18(%rax)
jne 0xad27
movq 0x10(%r12), %rdi
movq %rax, %rsi
callq 0xb84a
movq 0x10(%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x12f4c
testq %rax, %rax
je 0xaced
movq %rax, %rdi
leaq 0x185ce(%rip), %rsi     # 0x232a8
leaq 0x18eff(%rip), %rdx     # 0x23be0
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r13
jmp 0xacf0
xorl %r13d, %r13d
xorl %r12d, %r12d
cmpq 0x18(%r13), %r12
jae 0xad15
movq %r13, %rdi
movq %r12, %rsi
callq 0xb27e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
incq %r12
jmp 0xacf3
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
incq %r15
jmp 0xac77
testq %r14, %r14
je 0xad46
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r12), %rax
movq 0x18(%rax), %r14
xorl %r15d, %r15d
cmpq 0x18(%r14), %r15
jae 0xad34
movq %r14, %rdi
movq %r15, %rsi
callq 0xb27e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
incq %r15
jmp 0xad52
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        DoubleDistributedArray *s = dynamic_cast<DoubleDistributedArray*>(o);
        if(s == nullptr) return false;
        if(itemCount_ != s->itemCount_) return false;
        for(int i = 0; i < itemCount_; i++) {
            bool sameInt = s->get(i) == (get(i));
            if(!sameInt) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0xaead
movq %rdi, %rbx
leaq 0x1845e(%rip), %rax     # 0x232a8
leaq 0x18d27(%rip), %rdx     # 0x23b78
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xaeb0
movq %rax, %r15
movq 0x58(%rbx), %rax
cmpq 0x58(%r15), %rax
jne 0xaead
xorl %r12d, %r12d
cmpq %r12, 0x58(%rbx)
setbe %r14b
jbe 0xaeb0
movq %r15, %rdi
movq %r12, %rsi
callq 0xb630
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb630
incq %r12
movsd -0x28(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jne 0xaeb0
jnp 0xae76
jmp 0xaeb0
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::hash_me()
size_t hash_me() {
      size_t temp = 0;
      for(int i = 0; i < itemCount_; i++) {
          temp *= get(i);
      }
      return temp;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %r14, 0x58(%rbx)
jbe 0xaf2d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb630
movq %r15, %xmm1
punpckldq 0xd16f(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xd177(%rip), %xmm1     # 0x18070
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %rcx
subsd 0xd16f(%rip), %xmm2     # 0x18088
cvttsd2si %xmm2, %r15
sarq $0x3f, %rcx
andq %rcx, %r15
orq %rax, %r15
incq %r14
jmp 0xaed3
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("DoubleDistributedArray");
        sb->write("uid_", uid_);
        sb->write("chunkSize_", chunkSize_);
        sb->write("chunkCount_", chunkCount_);
        sb->write("itemCount_", itemCount_);
        sb->write("curNode_", curNode_);
        sb->write("totalNodes_", totalNodes_);
        sb->write("keys_", keys_->serialize(), false);
        sb->write("chunkArray_", chunkArray_->serialize(), false);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xd64f(%rip), %rsi      # 0x185af
movq %rbx, %rdi
callq 0x7fd8
movq 0x40(%r14), %rdx
leaq 0xd653(%rip), %rsi      # 0x185c6
movq %rbx, %rdi
callq 0x8062
movq 0x48(%r14), %rdx
leaq 0xd645(%rip), %rsi      # 0x185cb
movq %rbx, %rdi
callq 0x8062
movq 0x50(%r14), %rdx
leaq 0xd63d(%rip), %rsi      # 0x185d6
movq %rbx, %rdi
callq 0x8062
movq 0x58(%r14), %rdx
leaq 0xd55f(%rip), %rsi      # 0x1850b
movq %rbx, %rdi
callq 0x8062
movq 0x60(%r14), %rdx
leaq 0xd623(%rip), %rsi      # 0x185e2
movq %rbx, %rdi
callq 0x8062
movq 0x68(%r14), %rdx
leaq 0xd619(%rip), %rsi      # 0x185eb
movq %rbx, %rdi
callq 0x8062
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xd60c(%rip), %rsi      # 0x185f7
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xd5f4(%rip), %rsi      # 0x185fd
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb037
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: DoubleArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        DoubleArray *s = dynamic_cast<DoubleArray*>(o);
        if(s == nullptr) return false;
        if(listLength_ != s->listLength_) return false;
        for(int i = 0; i < listLength_; i++) {
            bool sameDoub = s->get(i) == get(i);
            if(!sameDoub) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0xb117
movq %rdi, %rbx
leaq 0x181f4(%rip), %rax     # 0x232a8
leaq 0x18b25(%rip), %rdx     # 0x23be0
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xb11a
movq %rax, %r15
movq 0x18(%rbx), %rax
cmpq 0x18(%r15), %rax
jne 0xb117
xorl %r12d, %r12d
cmpq %r12, 0x18(%rbx)
setbe %r14b
jbe 0xb11a
movq %r15, %rdi
movq %r12, %rsi
callq 0xb27e
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb27e
incq %r12
movsd -0x28(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jne 0xb11a
jnp 0xb0e0
jmp 0xb11a
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: DoubleArray::clone()
virtual Object* clone() { 
        IntArray* temp = new IntArray();
        for(int i = 0; i < listLength_; i++) {
            int value = vals_[i];
            temp->pushBack(value);
        }
        return temp;
     }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0xb2b2
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xb173
cvttsd2si (%rax,%rdx,8), %esi
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %r8
movl %esi, (%rdi,%r8,4)
incq %r8
movq %r8, 0x18(%rbx)
incq %rdx
jmp 0xb151
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: DoubleArray::hash_me()
size_t hash_me() {
      double temp = 0;
      for(int i = 0; i < listLength_; i++) {
          temp *= vals_[i];
      }
      return temp;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xb1af
mulsd (%rax,%rdx,8), %xmm0
incq %rdx
jmp 0xb1a0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
subsd 0xcec9(%rip), %xmm0     # 0x18088
cvttsd2si %xmm0, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: DoubleArray::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        //std::cout << "in DoubleArray"<< "\n";
        sb->initSerialize("DoubleArray");
        sb->write("listLength_", listLength_);
        sb->write("arraySize_", arraySize_);
        sb->write("vals_", vals_, listLength_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
     }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xd2fd(%rip), %rsi      # 0x184f1
movq %rbx, %rdi
callq 0x7fd8
movq 0x18(%r14), %rdx
leaq 0xd264(%rip), %rsi      # 0x1846b
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0xd14f(%rip), %rsi      # 0x18369
movq %rbx, %rdi
callq 0x8062
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0xd2b4(%rip), %rsi      # 0x184e5
movq %rbx, %rdi
callq 0xb598
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb25a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: IntArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        IntArray *s = dynamic_cast<IntArray*>(o);
        if(s == nullptr) return false;
        if(listLength_ != s->listLength_) return false;
        for(int i = 0; i < listLength_; i++) {
            bool sameInt = s->get(i) == get(i);
            if(!sameInt) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xb39e
movq %rdi, %rbx
leaq 0x17f63(%rip), %rax     # 0x232a8
leaq 0x188fc(%rip), %rdx     # 0x23c48
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xb3a1
movq %rax, %r15
movq 0x18(%rbx), %rax
cmpq 0x18(%r15), %rax
jne 0xb39e
xorl %r12d, %r12d
cmpq %r12, 0x18(%rbx)
setbe %r14b
jbe 0xb3a1
movq %r15, %rdi
movq %r12, %rsi
callq 0xb4cc
movl %eax, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb4cc
incq %r12
cmpl %eax, %r13d
je 0xb371
jmp 0xb3a1
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: IntArray::serialize()
char* serialize() {
         //std::cout << "in IntArray"<< "\n";
        Serializable* sb = new Serializable();
        sb->initSerialize("IntArray");
        sb->write("listLength_", listLength_);
        sb->write("arraySize_", arraySize_);
        sb->write("vals_", vals_, listLength_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
     }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xd09a(%rip), %rsi      # 0x184dc
movq %rbx, %rdi
callq 0x7fd8
movq 0x18(%r14), %rdx
leaq 0xd016(%rip), %rsi      # 0x1846b
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0xcf01(%rip), %rsi      # 0x18369
movq %rbx, %rdi
callq 0x8062
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0xd066(%rip), %rsi      # 0x184e5
movq %rbx, %rdi
callq 0xb4fe
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb4a8
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, int*, int)
void write(const char* name, int* val, int len) {
        char str[1000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            sprintf(str, "'%i',", val[i]);
            buff->c(str);
        }
        buff->c("], ");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
leaq 0xce56(%rip), %rsi      # 0x1837a
xorl %r13d, %r13d
leaq -0x410(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
testl %ebx, %ebx
cmovlel %r13d, %ebx
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0xb576
movl (%r14,%r13,4), %edx
movq %r12, %rdi
leaq 0xcf8c(%rip), %rsi      # 0x184eb
xorl %eax, %eax
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
incq %r13
jmp 0xb54c
movq (%r15), %rdi
leaq 0xce08(%rip), %rsi      # 0x18388
callq 0x8114
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop