LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xae01
movq %rsi, %r12
movq %rdi, %rbx
movq 0x10(%rdi), %r14
xorl %r15d, %r15d
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0xae09
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
movq %rax, %r14
decq %r13
jne 0xadda
jmp 0xaec3
xorl %r15d, %r15d
jmp 0xaec3
movq 0x10(%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
testb %al, %al
je 0xae28
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 0xae47
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 0xae76
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 0xaea5
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_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r15, 0x8(%rdi)
leaq 0x1cc5f(%rip), %rax     # 0x27b50
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 0x71f0
movl %eax, %edi
callq 0x7210
callq 0x70a0
cltq
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq %r15, 0x60(%rbx)
movl $0x28, %edi
callq 0x7230
movq %rax, %r14
movq %r15, 0x8(%rax)
leaq 0x1c7cd(%rip), %rax     # 0x27720
movq %rax, (%r14)
movl $0x28, %edi
callq 0x7030
movq %rax, 0x10(%r14)
movq $0x5, 0x20(%r14)
xorl %r15d, %r15d
movq %r15, 0x18(%r14)
movq %r14, 0x38(%rbx)
movl $0x28, %edi
callq 0x7230
movq %rax, %r14
movq 0x48(%rbx), %rax
movq %r15, 0x8(%r14)
leaq 0x1cc25(%rip), %rcx     # 0x27bb8
movq %rcx, (%r14)
movq %r15, 0x18(%r14)
cltq
movq %rax, 0x20(%r14)
leaq (,%rax,8), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x7030
movq %rax, 0x10(%r14)
movq %r14, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xafcf
movq %rax, %rbx
movq %r14, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb05c
movq %rdi, %rbx
leaq 0x1c2cb(%rip), %rax     # 0x272d0
leaq 0x1cb1c(%rip), %rdx     # 0x27b28
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xb05c
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 0xb05c
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_O3/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
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x8094
leaq 0x12564(%rip), %rsi     # 0x1d604
movq %rbx, %rdi
callq 0x80f6
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x1233f(%rip), %rsi     # 0x1d3f8
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa8f0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82ba
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb10c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r13
movq 0x10(%rdi), %rax
movq 0x18(%rax), %r12
movl $0x28, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0xcf6a
movq 0x18(%r13), %rax
movq 0x38(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0xb286
xorl %r15d, %r15d
movq %r12, -0x40(%rbp)
movq %r13, -0x38(%rbp)
movq 0x18(%r13), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
movq %rax, %rdi
leaq 0x1c0e4(%rip), %rsi     # 0x272d0
leaq 0x1c5f5(%rip), %rdx     # 0x277e8
xorl %ecx, %ecx
callq 0x7280
cmpq %r12, 0x18(%rax)
jne 0xb279
movq 0x10(%r13), %rdi
movq %rax, %rsi
callq 0xbeb4
movq 0x10(%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x146f0
testq %rax, %rax
je 0xb23b
movq %rax, %rdi
leaq 0x1c0a8(%rip), %rsi     # 0x272d0
leaq 0x1c9c9(%rip), %rdx     # 0x27bf8
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0xb23e
xorl %r13d, %r13d
cmpq $0x0, 0x18(%r13)
je 0xb267
xorl %r12d, %r12d
movq 0x10(%r13), %rax
movsd (%rax,%r12,8), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
incq %r12
cmpq 0x18(%r13), %r12
jb 0xb248
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
incq %r15
cmpq 0x18(%r14), %r15
jb 0xb1d1
testq %r12, %r12
jne 0xb2bc
movq 0x18(%r13), %rax
movq 0x18(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0xb2bc
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movsd (%rax,%r15,8), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
incq %r15
cmpq 0x18(%r14), %r15
jb 0xb29d
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb3d8
movq %rdi, %rbx
leaq 0x1bf6e(%rip), %rax     # 0x272d0
leaq 0x1c827(%rip), %rdx     # 0x27b90
xorl %r15d, %r15d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xb3db
movq %rax, %r14
movq 0x58(%rbx), %rax
cmpq 0x58(%r14), %rax
jne 0xb3d8
testq %rax, %rax
je 0xb3eb
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0xbc6c
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xbc6c
movsd -0x28(%rbp), %xmm2
movapd %xmm2, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %r15
andl $0x1, %r15d
ucomisd %xmm0, %xmm2
jne 0xb3db
jp 0xb3db
incq %r12
cmpq %r12, 0x58(%rbx)
ja 0xb393
jmp 0xb3db
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r15b
jmp 0xb3db
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpq $0x0, 0x58(%rdi)
je 0xb464
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc6c
movq %r15, %xmm1
punpckldq 0x11c3e(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x11c46(%rip), %xmm1    # 0x1d070
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x11c3a(%rip), %xmm2    # 0x1d088
cvttsd2si %xmm2, %r15
andq %rcx, %r15
orq %rax, %r15
incq %r14
cmpq %r14, 0x58(%rbx)
ja 0xb40a
jmp 0xb467
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x8094
leaq 0x1210e(%rip), %rsi     # 0x1d5aa
movq %rbx, %rdi
callq 0x80f6
movq 0x40(%r14), %rdx
leaq 0x12112(%rip), %rsi     # 0x1d5c1
movq %rbx, %rdi
callq 0x81d0
movq 0x48(%r14), %rdx
leaq 0x12104(%rip), %rsi     # 0x1d5c6
movq %rbx, %rdi
callq 0x81d0
movq 0x50(%r14), %rdx
leaq 0x120fc(%rip), %rsi     # 0x1d5d1
movq %rbx, %rdi
callq 0x81d0
movq 0x58(%r14), %rdx
leaq 0x1201e(%rip), %rsi     # 0x1d506
movq %rbx, %rdi
callq 0x81d0
movq 0x60(%r14), %rdx
leaq 0x120e2(%rip), %rsi     # 0x1d5dd
movq %rbx, %rdi
callq 0x81d0
movq 0x68(%r14), %rdx
leaq 0x120d8(%rip), %rsi     # 0x1d5e6
movq %rbx, %rdi
callq 0x81d0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x120cb(%rip), %rsi     # 0x1d5f2
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa8f0
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x120b3(%rip), %rsi     # 0x1d5f8
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa8f0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82ba
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb598
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
testq %rsi, %rsi
je 0xb68a
movq %rdi, %r14
leaq 0x1bcae(%rip), %rax     # 0x272d0
leaq 0x1c5cf(%rip), %rdx     # 0x27bf8
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xb68c
movq 0x18(%r14), %rcx
cmpq 0x18(%rax), %rcx
jne 0xb68a
testq %rcx, %rcx
je 0xb693
movq 0x10(%rax), %rax
movq 0x10(%r14), %rdx
decq %rcx
xorl %esi, %esi
movsd (%rax,%rsi,8), %xmm0
movsd (%rdx,%rsi,8), %xmm1
movapd %xmm0, %xmm2
cmpeqsd %xmm1, %xmm2
movq %xmm2, %rbx
andl $0x1, %ebx
ucomisd %xmm1, %xmm0
jne 0xb68c
jp 0xb68c
leaq 0x1(%rsi), %rdi
cmpq %rsi, %rcx
movq %rdi, %rsi
jne 0xb659
jmp 0xb68c
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %bl
jmp 0xb68c
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x28, %edi
callq 0x7230
movq %rax, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rbx)
leaq 0x1c564(%rip), %rcx     # 0x27c20
movq %rcx, (%rbx)
movq %rax, 0x18(%rbx)
movq $0x20, 0x20(%rbx)
movl $0x80, %edi
callq 0x7030
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0xb6fc
movq 0x10(%r14), %rsi
xorl %edx, %edx
cvttsd2si (%rsi,%rdx,8), %edi
movl %edi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0xb6e8
movq %rdx, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xb75d
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
mulsd (%rcx,%rdx,8), %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0xb72f
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x11938(%rip), %xmm0    # 0x1d088
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x8094
leaq 0x11d66(%rip), %rsi     # 0x1d4ec
movq %rbx, %rdi
callq 0x80f6
movq 0x18(%r14), %rdx
leaq 0x11ccd(%rip), %rsi     # 0x1d466
movq %rbx, %rdi
callq 0x81d0
movq 0x20(%r14), %rdx
leaq 0x11bb8(%rip), %rsi     # 0x1d364
movq %rbx, %rdi
callq 0x81d0
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0x11d1d(%rip), %rsi     # 0x1d4e0
movq %rbx, %rdi
callq 0xbb5e
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82ba
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb811
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
testq %rsi, %rsi
je 0xb8ea
movq %rdi, %r14
leaq 0x1ba36(%rip), %rax     # 0x272d0
leaq 0x1c3bf(%rip), %rdx     # 0x27c60
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xb8ec
movq 0x18(%r14), %rcx
cmpq 0x18(%rax), %rcx
jne 0xb8ea
testq %rcx, %rcx
je 0xb8f3
movq 0x10(%rax), %rax
movq 0x10(%r14), %rdx
decq %rcx
xorl %esi, %esi
movl (%rax,%rsi,4), %edi
cmpl (%rdx,%rsi,4), %edi
sete %bl
jne 0xb8ec
leaq 0x1(%rsi), %rdi
cmpq %rsi, %rcx
movq %rdi, %rsi
jne 0xb8d1
jmp 0xb8ec
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %bl
jmp 0xb8ec
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x8094
leaq 0x11b33(%rip), %rsi     # 0x1d4d7
movq %rbx, %rdi
callq 0x80f6
movq 0x18(%r14), %rdx
leaq 0x11aaf(%rip), %rsi     # 0x1d466
movq %rbx, %rdi
callq 0x81d0
movq 0x20(%r14), %rdx
leaq 0x1199a(%rip), %rsi     # 0x1d364
movq %rbx, %rdi
callq 0x81d0
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0x11aff(%rip), %rsi     # 0x1d4e0
movq %rbx, %rdi
callq 0xba52
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82ba
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xba2f
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x3f8, %rsp            # imm = 0x3F8
movl %ecx, %r14d
movq %rdx, -0x38(%rbp)
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x118fb(%rip), %rsi     # 0x1d375
leaq -0x420(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq %rbx, -0x30(%rbp)
movq (%rbx), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x824a
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
testl %r14d, %r14d
jle 0xbb1f
movl %r14d, %ebx
xorl %r14d, %r14d
movq -0x38(%rbp), %rax
movl (%rax,%r14,4), %edx
movq %r12, %rdi
leaq 0x11a0a(%rip), %rsi     # 0x1d4e6
xorl %eax, %eax
callq 0x7080
movq -0x30(%rbp), %rax
movq (%rax), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x824a
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
incq %r14
cmpq %r14, %rbx
jne 0xbaca
movq -0x30(%rbp), %rax
movq (%rax), %rbx
movl $0x3, %esi
movq %rbx, %rdi
callq 0x824a
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movb $0x20, 0x2(%rax,%rcx)
movw $0x2c5d, (%rax,%rcx)    # imm = 0x2C5D
addq $0x3, 0x20(%rbx)
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, double*, int)
void write(const char* name, double* val, int len) {
        char str[1000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            sprintf(str, "'%f',", val[i]);
            buff->c(str);
        }
        buff->c("], ");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movl %ecx, %r14d
movq %rdx, -0x38(%rbp)
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x117ef(%rip), %rsi     # 0x1d375
leaq -0x420(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq %rbx, -0x30(%rbp)
movq (%rbx), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x824a
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
testl %r14d, %r14d
jle 0xbc2d
movl %r14d, %ebx
xorl %r14d, %r14d
movq -0x38(%rbp), %rax
movsd (%rax,%r14,8), %xmm0
movq %r12, %rdi
leaq 0x1190e(%rip), %rsi     # 0x1d4f8
movb $0x1, %al
callq 0x7080
movq -0x30(%rbp), %rax
movq (%rax), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x824a
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
incq %r14
cmpq %r14, %rbx
jne 0xbbd6
movq -0x30(%rbp), %rax
movq (%rax), %rbx
movl $0x3, %esi
movq %rbx, %rdi
callq 0x824a
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movb $0x20, 0x2(%rax,%rcx)
movw $0x2c5d, (%rax,%rcx)    # imm = 0x2C5D
addq $0x3, 0x20(%rbx)
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::get(unsigned long)
double get(size_t index) {
        assert(index < itemCount_);
        //std::cout << "in get " << index <<"\n";
        if (cache_ == nullptr) {
            init_cache_();
        }
        double res;
        if(index/chunkSize_ == chunkCount_) {
            res = chunkArray_->get(index % chunkSize_);
        } else {

            size_t key_idx = floor((index/chunkSize_));
            //std::cout << "key index: " << key_idx << "\n";
            //std::cout << key
            DoubleArray* doubleVals;
            if (cache_[key_idx] != nullptr) {
                //std::cout << "get chunk from cache\n";
                doubleVals = cache_[key_idx];
            } else {
                //std::cout << "get chunk from kv\n";
                doubleVals = get_chunk_from_kv_(key_idx);
            }
            res = doubleVals->get(index % chunkSize_);
        }
        //std::cout << "res: " << res << "\n";
        return res; //returns int at correct index in array at this chunk
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq %rsi, 0x58(%rdi)
jbe 0xbd22
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
jne 0xbc92
movq %r14, %rdi
callq 0xbd60
movq 0x48(%r14), %rdi
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
cmpq 0x50(%r14), %rax
jne 0xbcaa
movq 0x18(%r14), %rcx
jmp 0xbd0e
movq %rax, %xmm0
punpckldq 0x113a9(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x113b1(%rip), %xmm0    # 0x1d070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0x113ad(%rip), %xmm1    # 0x1d088
sarq $0x3f, %rcx
cvttsd2si %xmm1, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq 0x20(%r14), %rax
movq (%rax,%rsi,8), %rcx
testq %rcx, %rcx
jne 0xbd06
movq %r14, %rdi
callq 0xbdba
movq %rax, %rcx
movq 0x48(%r14), %rdi
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
cmpq %rdx, 0x18(%rcx)
jbe 0xbd41
movq 0x10(%rcx), %rax
movsd (%rax,%rdx,8), %xmm0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x117d5(%rip), %rdi     # 0x1d4fe
leaq 0x117e1(%rip), %rsi     # 0x1d511
leaq 0x11814(%rip), %rcx     # 0x1d54b
movl $0x3a8, %edx            # imm = 0x3A8
callq 0x7150
leaq 0x11716(%rip), %rdi     # 0x1d45e
leaq 0x11723(%rip), %rsi     # 0x1d472
leaq 0x11747(%rip), %rcx     # 0x1d49d
movl $0x161, %edx            # imm = 0x161
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::init_cache_()
void init_cache_() {
        //assuming a dataframe is immutable, so nu pushbacks after the first get call.
        cache_ = new DoubleArray*[keys_->length()];
        for (size_t i = 0; i < keys_->length(); i++) {
            cache_[i] = nullptr;
        }
        return;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x18(%rax), %r14
movq %r14, %rax
shrq $0x3d, %rax
leaq (,%r14,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x7030
movq %rax, 0x20(%rbx)
testq %r14, %r14
je 0xbdb5
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
movq 0x38(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jb 0xbd9c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::get_chunk_from_kv_(unsigned long)
DoubleArray* get_chunk_from_kv_(size_t key_idx) {
        if (cache_count_ >= max_cache_count) {
            reset_cache_();
        }
        Value* v = kv_->get(dynamic_cast<Key*>(keys_->get(key_idx))); //gets value of given key
        char* serlializedNode = v->data; 
        //std::cout << serlializedNode <<"\n";
        DoubleArray* doubleVals = new DoubleArray(serlializedNode); //turns payload into IntArray object
        cache_[key_idx] = doubleVals;
        cache_count_ += 1;
        return doubleVals;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jb 0xbddd
movq %rbx, %rdi
callq 0xbe62
movq 0x10(%rbx), %r15
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xbe10
leaq 0x1b4d6(%rip), %rsi     # 0x272d0
leaq 0x1b9e7(%rip), %rdx     # 0x277e8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rsi
jmp 0xbe12
xorl %esi, %esi
movq %r15, %rdi
callq 0xbeb4
movq 0x10(%rax), %r12
movl $0x28, %edi
callq 0x7230
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xc026
movq 0x20(%rbx), %rax
movq %r15, (%rax,%r14,8)
incq 0x28(%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::reset_cache_()
void reset_cache_() {
        //std::cout << "reset cache, cache count: " << cache_count_ << "\n";
        for (size_t i = 0; i < keys_->length(); i++) {
            if (cache_[i] != nullptr) {
                //std::cout << "clearing idx: " << i<<"\n";
                delete cache_[i];
                cache_[i] = nullptr;
            }
        }
        cache_count_ = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
cmpq $0x0, 0x18(%rax)
je 0xbea6
xorl %r14d, %r14d
movq 0x20(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0xbe9d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rax
movq $0x0, (%rax,%r14,8)
movq 0x38(%rbx), %rax
incq %r14
cmpq 0x18(%rax), %r14
jb 0xbe7a
movq $0x0, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::get(Key*)
Value* get(Key* key) {
        store_mtx_.lock();
        size_t target = key->node();
        //std::cout << "get: " << "key: " << key->serialize() << "\n";
        Value* val = nullptr;
        if (target == this_node_) {
            std::map<Key*, Value*, KeyCompare>::iterator iter;
            iter = local_store_.find(key);
            if (iter != local_store_.end()) {
                val = iter->second;
            }
        } else {
            Get get(key, this_node_, target, network_->msg_id);
            network_->send_msg(&get); // send get msg over the network to appropriate KVStore.
            store_mtx_.wait();
            Message* m = received_msg;
            //expect Reply or Nack.
            if (m->kind_ == MsgKind::Reply) {
                Reply* resp = dynamic_cast<Reply*>(m);
                char* serializedValue = resp->reply_msg_;
                val = new Value(serializedValue, this);
            } else if (m->kind_ == MsgKind::Nack) {
                std::cout << "unable to get key from node " << target <<"\n";
            }
            received_msg = nullptr;
        }
        store_mtx_.unlock();
        return val;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, -0x28(%rbp)
leaq 0x68(%rdi), %rbx
movq %rbx, %rdi
callq 0x7330
testl %eax, %eax
jne 0xc00b
movq 0x18(%r12), %r15
movq 0x18(%r14), %rax
cmpq %rax, %r15
jne 0xbf12
leaq 0x20(%r14), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc470
addq $0x28, %r14
cmpq %r14, %rax
je 0xbfa6
movq 0x28(%rax), %r15
jmp 0xbff3
movq 0x50(%r14), %rdi
movq 0x40(%rdi), %rcx
leaq -0x60(%rbp), %rsi
movq $0x0, 0x8(%rsi)
leaq 0x1bd73(%rip), %rdx     # 0x27ca0
movq %rdx, (%rsi)
movl $0x4, 0x10(%rsi)
movq %rax, 0x18(%rsi)
movq %r15, 0x20(%rsi)
movq %rcx, 0x28(%rsi)
movq %r12, 0x30(%rsi)
movq (%rdi), %rax
callq *0x50(%rax)
leaq 0x90(%r14), %rdi
movq %rbx, %rsi
callq 0xc64c
movq 0xd0(%r14), %rdi
movl 0x10(%rdi), %eax
cmpl $0x1, %eax
je 0xbfab
cmpl $0x3, %eax
jne 0xbfe5
leaq 0x1b3a1(%rip), %rsi     # 0x27318
leaq 0x1bcfa(%rip), %rdx     # 0x27c78
xorl %ecx, %ecx
callq 0x7280
movq 0x30(%rax), %r12
movl $0x20, %edi
callq 0x7230
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xc306
jmp 0xbfe8
xorl %r15d, %r15d
jmp 0xbff3
movq 0x1d01e(%rip), %r12     # 0x28fd0
leaq 0x115bd(%rip), %rsi     # 0x1d576
movl $0x1c, %edx
movq %r12, %rdi
callq 0x7290
movq %r12, %rdi
movq %r15, %rsi
callq 0x7170
leaq 0x11111(%rip), %rsi     # 0x1d0e9
movl $0x1, %edx
movq %rax, %rdi
callq 0x7290
xorl %r15d, %r15d
movq $0x0, 0xd0(%r14)
movq %rbx, %rdi
callq 0x7180
movq %r15, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x7160
movq %rax, %rbx
movq %r15, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../store/value.h
// Function: Value::Value(char*, KVStore*)
Value(char* serialized, KVStore* kv) {
        Deserializable* ds = new Deserializable();
        char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
        char* serialData = JSONHelper::getValueFromKey("data", payload)->c_str();
        this->data = serialData;
        if(JSONHelper::isObject(serialData)) {
            this->data = ds->deserialize(serialData, kv)->serialize();
        } else {
            this->data = serialData;
        }
        this->length = std::stoi(JSONHelper::getValueFromKey("length", payload)->c_str());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x1b9d9(%rip), %rax     # 0x27d08
movq %rax, (%rdi)
movl $0x1, %edi
callq 0x7230
movq %rax, %r12
movq %r14, %rdi
callq 0xc82c
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x11239(%rip), %rdi     # 0x1d593
movq %rax, %rsi
callq 0xc9a6
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r13
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0xcb5c
testb %al, %al
je 0xc398
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x14d6a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %rax, %r13
movq %r13, 0x10(%rbx)
leaq 0x111f5(%rip), %rdi     # 0x1d598
movq %r14, %rsi
callq 0xc9a6
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x58(%rbp), %r14
leaq -0x29(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x70e0
movq (%r14), %r15
callq 0x7040
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x38(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x72f0
cmpq %r15, (%r12)
je 0xc431
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0xc43d
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0xc43d
testl %ecx, %ecx
jne 0xc40c
movl %r13d, (%r14)
movq %rax, 0x18(%rbx)
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc422
callq 0x7200
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10cc7(%rip), %rdi     # 0x1d0ff
callq 0x7140
leaq 0x10cbb(%rip), %rdi     # 0x1d0ff
callq 0x7310
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0xc455
movl %r13d, (%r14)
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc467
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./network.h
// Function: Get::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Get");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        char* serializedKey = key_->serialize();
        sb->write("key_", serializedKey, false);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x8094
leaq 0x1137d(%rip), %rsi     # 0x1d8ed
movq %rbx, %rdi
callq 0x80f6
movl 0x10(%r14), %edx
leaq 0x10cf3(%rip), %rsi     # 0x1d276
movq %rbx, %rdi
callq 0x8162
movq 0x18(%r14), %rdx
leaq 0x10ce6(%rip), %rsi     # 0x1d27c
movq %rbx, %rdi
callq 0x81d0
movq 0x20(%r14), %rdx
leaq 0x10cdb(%rip), %rsi     # 0x1d284
movq %rbx, %rdi
callq 0x81d0
movq 0x28(%r14), %rdx
leaq 0x11006(%rip), %rsi     # 0x1d5c2
movq %rbx, %rdi
callq 0x81d0
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x10e1e(%rip), %rsi     # 0x1d3f3
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa8f0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82ba
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc628
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../serialize/jsonHelper.h
// Function: JSONHelper::isObject(char*)
static bool isObject(char* s) {
        int len = strlen( s );
        char isObj = '{';
        for(int i = 0; i < len; i++) {
            char temp = s[i];
            if(temp == isObj) {
                return true;
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7100
testl %eax, %eax
jle 0xcb99
movb $0x1, %cl
cmpb $0x7b, (%rbx)
je 0xcb9b
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0xcb91
leaq 0x1(%rcx), %rdx
cmpb $0x7b, (%rbx,%rcx)
jne 0xcb7f
cmpq %rax, %rcx
setb %cl
jmp 0xcb9b
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../store/value.h
// Function: Value::hash()
size_t hash() {
        size_t hash = 0;
        for (size_t i = 0; i < strlen(data); ++i) {
            hash += data[i];
        }
        return hash;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x7100
testq %rax, %rax
je 0xcbdb
xorl %edx, %edx
xorl %ecx, %ecx
movsbq (%rbx,%rdx), %rsi
addq %rsi, %rcx
incq %rdx
cmpq %rdx, %rax
jne 0xcbc9
jmp 0xcbdd
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../store/value.h
// Function: Value::equals(Object*)
bool equals(Object* other) {
        if (other == this) return true;
        Value* x = dynamic_cast<Value *>(other);
        if (x == nullptr) return false;
        if (this->length != x->length) return false;
        return strncmp(data, x->data, length) == 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq %rdi, %rsi
je 0xcc3c
testq %rsi, %rsi
je 0xcc40
movq %rdi, %r14
leaq 0x1a6cd(%rip), %rax     # 0x272d0
leaq 0x1b13e(%rip), %rdx     # 0x27d48
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xcc42
movq 0x18(%r14), %rdx
cmpq 0x18(%rax), %rdx
jne 0xcc40
movq 0x10(%r14), %rdi
movq 0x10(%rax), %rsi
callq 0x7120
testl %eax, %eax
sete %bl
jmp 0xcc42
movb $0x1, %bl
jmp 0xcc42
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../store/value.h
// Function: Value::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Value");
        if(JSONHelper::isObject(data)) {
            sb->write("data", data, false);
        } else {
            sb->write("data", data);
        }
        sb->write("length", length);
        sb->endSerialize();
        char* value = sb->get();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x8094
leaq 0x1092f(%rip), %rsi     # 0x1d59f
movq %rbx, %rdi
callq 0x80f6
movq 0x10(%r14), %rdi
callq 0xcb5c
movq 0x10(%r14), %rdx
leaq 0x10907(%rip), %rsi     # 0x1d593
movq %rbx, %rdi
testb %al, %al
je 0xcc9c
xorl %ecx, %ecx
callq 0xa8f0
jmp 0xcca1
callq 0x8556
movq 0x18(%r14), %rdx
leaq 0x108ec(%rip), %rsi     # 0x1d598
movq %rbx, %rdi
callq 0x81d0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82ba
movq (%rax), %rcx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *0x30(%rcx)
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../serialize/jsonHelper.h
// Function: JSONHelper::endIndex(char*, char, int)
static int endIndex(char* s, char sym, int pos) {
        int len = strlen( s );
        char end = '}';
        int depth = 1;
        if(sym == '[') {
            end = ']';
        }
        //pull the class name from the serialzed string
        for (int i = pos+1; i < len; i++){
            char temp = s[i];
            if(temp == sym) {
                depth++;
            } else if(temp == end) {
                //full name has been discovered
                depth--;
                if(depth == 0) {
                    return i;
                }
            }
        }
        return -1;
        std::cout<<"ERROR: end not found\n";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebx
movq %rdi, %r15
callq 0x7100
movq %rax, %rcx
xorl %edx, %edx
cmpb $0x5b, %bl
setne %dil
leal 0x1(%r14), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %esi
jge 0xcd6d
movb %dil, %dl
shll $0x5, %edx
orl $0x5d, %edx
movslq %r14d, %rdi
addq %r15, %rdi
incq %rdi
movl $0x1, %r8d
movsbl (%rdi), %r9d
cmpb %bl, %r9b
jne 0xcd56
incl %r8d
jmp 0xcd60
cmpl %r9d, %edx
jne 0xcd60
decl %r8d
je 0xcd6b
incl %esi
incq %rdi
cmpl %esi, %ecx
jne 0xcd48
jmp 0xcd6d
movl %esi, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: DoubleColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    DoubleColumn* other_ic = dynamic_cast<DoubleColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    for(int i = 0; i < val_->length(); i++) {
      DoubleArray* ia = dynamic_cast<DoubleArray*>(val_->get(i));
      DoubleArray* other_ia = dynamic_cast<DoubleArray*>(other_ic->val_->get(i));
      for(int j = 0; j < ia->length(); j++) {
        if(ia->get(j) != other_ia->get(j)) {
          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 0xd18c
movq %rdi, %rbx
leaq 0x1a241(%rip), %rax     # 0x272d0
leaq 0x1adb2(%rip), %rdx     # 0x27e48
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xd18f
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0xc8(%rax)
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xc8(%rax)
cmpq %rax, %r14
jne 0xd18c
movq 0x10(%rbx), %rdi
movb $0x1, %r14b
cmpq $0x0, 0x18(%rdi)
je 0xd18f
xorl %r12d, %r12d
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xd116
movq %rax, %rdi
leaq 0x1a1cd(%rip), %rsi     # 0x272d0
leaq 0x1aaee(%rip), %rdx     # 0x27bf8
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0xd119
xorl %r13d, %r13d
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xd145
movq %rax, %rdi
leaq 0x1a19b(%rip), %rsi     # 0x272d0
leaq 0x1aabc(%rip), %rdx     # 0x27bf8
xorl %ecx, %ecx
callq 0x7280
jmp 0xd147
xorl %eax, %eax
movq 0x18(%r13), %rcx
testq %rcx, %rcx
je 0xd179
movq 0x18(%rax), %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0xd1a1
movq 0x10(%r13), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq 0x10(%rax), %rdi
ucomisd (%rdi,%rsi,8), %xmm0
jne 0xd18c
jp 0xd18c
incq %rsi
cmpq %rsi, %rcx
jne 0xd156
incq %r12
movq 0x10(%rbx), %rdi
cmpq %r12, 0x18(%rdi)
ja 0xd0eb
jmp 0xd18f
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x102b6(%rip), %rdi     # 0x1d45e
leaq 0x102c3(%rip), %rsi     # 0x1d472
leaq 0x102e7(%rip), %rcx     # 0x1d49d
movl $0x161, %edx            # imm = 0x161
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: DoubleColumn::hash_me()
size_t hash_me() {
    size_t hash = 0;
    for(int i = 0; i < val_->length(); i++) {
      DoubleArray* ia = dynamic_cast<DoubleArray*>(val_->get(i));
      for(int j = 0; j < ia->length(); j++) {
        hash += ia->get(j);
      }
    }
    return hash;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
cmpq $0x0, 0x18(%rdi)
je 0xd291
xorl %r14d, %r14d
leaq 0x1a0e6(%rip), %r15     # 0x272d0
leaq 0x1aa07(%rip), %r12     # 0x27bf8
xorl %r13d, %r13d
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xd214
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x7280
jmp 0xd216
xorl %eax, %eax
movq 0x18(%rax), %rcx
testq %rcx, %rcx
movq 0xfe3b(%rip), %xmm2     # 0x1d060
movapd 0xfe43(%rip), %xmm3     # 0x1d070
movsd 0xfe53(%rip), %xmm4     # 0x1d088
je 0xd27e
movq 0x10(%rax), %rax
xorl %edx, %edx
movq %r13, %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd (%rax,%rdx,8), %xmm1
cvttsd2si %xmm1, %rsi
movq %rsi, %rdi
sarq $0x3f, %rdi
subsd %xmm4, %xmm1
cvttsd2si %xmm1, %r13
andq %rdi, %r13
orq %rsi, %r13
incq %rdx
cmpq %rdx, %rcx
jne 0xd23d
incq %r14
movq 0x10(%rbx), %rdi
cmpq %r14, 0x18(%rdi)
ja 0xd1f4
jmp 0xd294
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq