LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: DoubleColumn::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("DoubleColumn");
    sb->write("listLength_", listLength_);
    sb->write("arraySize_", arraySize_);
    sb->write("metaArrayStartSize__", metaArrayStartSize_);
    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 0x10343(%rip), %rsi     # 0x1d60f
movq %rbx, %rdi
callq 0x80f6
movl 0x18(%r14), %edx
leaq 0x10187(%rip), %rsi     # 0x1d466
movq %rbx, %rdi
callq 0x8162
movl 0x1c(%r14), %edx
leaq 0x10072(%rip), %rsi     # 0x1d364
movq %rbx, %rdi
callq 0x8162
movl 0x20(%r14), %edx
leaq 0x10317(%rip), %rsi     # 0x1d61c
movq %rbx, %rdi
callq 0x8162
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x100da(%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 0xd371
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/../dataframe/column.h
// Function: DoubleColumn::push_back(double)
void push_back(double val) {
    if (listLength_  >= ((arraySize_* val_->length()))) {
      val_->pushBack(new DoubleArray(arraySize_));
    }
    int array_index = listLength_ / arraySize_;
    DoubleArray* da = dynamic_cast<DoubleArray*>(val_->get(array_index));
    da->pushBack(val);
    listLength_++;

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x28(%rbp)
movq %rdi, %rbx
movslq 0x18(%rdi), %rax
movl 0x1c(%rdi), %ecx
movslq %ecx, %r12
movq 0x10(%rdi), %r14
movq 0x18(%r14), %rdx
imulq %r12, %rdx
cmpq %rax, %rdx
ja 0xd478
movl $0x28, %edi
callq 0x7230
movq %rax, %r15
xorl %eax, %eax
movq %rax, 0x8(%r15)
leaq 0x1a780(%rip), %rcx     # 0x27bb8
movq %rcx, (%r15)
movq %rax, 0x18(%r15)
movq %r12, 0x20(%r15)
leaq (,%r12,8), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x7030
movq %rax, 0x10(%r15)
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x58(%rax)
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %ecx
movq 0x10(%rbx), %r14
cltd
idivl %ecx
movslq %eax, %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
leaq 0x19e42(%rip), %rsi     # 0x272d0
leaq 0x1a763(%rip), %rdx     # 0x27bf8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
movq %rdx, 0x18(%rax)
incl 0x18(%rbx)
addq $0x10, %rsp
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::pushBack(double)
void pushBack(double val) {
        //initialize first key
        if(itemCount_ % chunkSize_ == 0 && itemCount_ != 0) { //if current chunk is full..
            storeChunk(); //stores the previous chunk values in the kv_store
            chunkArray_->pushBack(val);
        } else {
            chunkArray_->pushBack(val);
        }
        itemCount_ +=1;
        //std::cout << uid_ << " " <<itemCount_ << "\n";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq 0x48(%rdi)
testq %rcx, %rcx
je 0xd556
testq %rdx, %rdx
jne 0xd556
movq %rbx, %rdi
movsd %xmm0, -0x10(%rbp)
callq 0xd57c
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
movq %rdx, 0x18(%rax)
movq 0x58(%rbx), %rcx
jmp 0xd56e
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rsi
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
movq %rsi, 0x18(%rax)
incq %rcx
movq %rcx, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::storeChunk()
void storeChunk() {
        //std::cout << "total nodes: " << totalNodes_ << "\n";
        //creates a unique keyname based on provided ID - could be modified to randomly pick number?
        StrBuff sb;
        sb.c(uid_);
        sb.c("_dist_double_array_chunk_");
        sb.c(chunkCount_);
        String* s = sb.get();
        Key* k = new Key(s->c_str(), curNode_); //create new key with current node and keyName
        keys_->pushBack(k);
        char* serialized = chunkArray_->serialize();
        //std::cout << serialized << "\n";
        kv_->put(k, new Value(serialized, (size_t)0)); //adds new IntArray to kvStore
        delete chunkArray_;
        chunkArray_ = new DoubleArray(chunkSize_); //creates new Int array to store values for new chunk
        curNode_+=1;
        chunkCount_+=1;
        if(curNode_ == totalNodes_) { //starts cycle of chunks on nodes again
            curNode_ = 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
leaq -0x48(%rbp), %r14
movq %r15, 0x8(%r14)
leaq 0x19e88(%rip), %rax     # 0x27428
movq %rax, (%r14)
movq $0xa, 0x18(%r14)
movl $0xa, %edi
callq 0x7030
movq %rax, 0x10(%r14)
movq %r15, 0x20(%r14)
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0xd720
movl $0x19, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movups 0x10055(%rip), %xmm0    # 0x1d63a
movups %xmm0, 0x9(%rax,%rcx)
movups 0x10040(%rip), %xmm0    # 0x1d631
movups %xmm0, (%rax,%rcx)
addq $0x19, 0x20(%r14)
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0xd720
movq %r14, %rdi
callq 0x82ba
movq %rax, %r15
movl $0x20, %edi
callq 0x7230
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq 0x60(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x8650
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x58(%rax)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r15
movq 0x10(%rbx), %r12
movl $0x20, %edi
callq 0x7230
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x1a69d(%rip), %rdx     # 0x27d08
movq %rdx, (%rax)
movq %r15, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9b8c
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xd693
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x28, %edi
callq 0x7230
movq %rax, %r14
movq 0x48(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%r14)
leaq 0x1a507(%rip), %rdx     # 0x27bb8
movq %rdx, (%r14)
movq %rcx, 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)
movq 0x60(%rbx), %rax
incq %rax
movq %rax, 0x60(%rbx)
incq 0x50(%rbx)
cmpq 0x68(%rbx), %rax
jne 0xd6fd
movq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd70c
movq %rax, %rbx
movq %r14, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/primatives.h
// Function: Integer::equals(Object*)
virtual bool equals(Object * other) {
		if (other == nullptr) return false;
		Integer *i = dynamic_cast<Integer*>(other);
        if(i == nullptr) return false;
		return this->val_ == i->val_;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xd8f3
movq %rdi, %r14
leaq 0x19a04(%rip), %rax     # 0x272d0
leaq 0x1a5dd(%rip), %rdx     # 0x27eb0
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xd8f5
movl 0x10(%r14), %ecx
cmpl 0x10(%rax), %ecx
sete %bl
jmp 0xd8f5
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::Schema(Schema&)
Schema(Schema& from) {
        //std::cout<<"entered copy constructor\n";
        this->capacity_ = from.capacity_;
        this->empty_index_ = from.empty_index_;
        this->val_ = new char[this->capacity_ + 1];

        for (size_t i = 0; i < this->empty_index_; i++) {
            this->val_[i] = from.val_[i]; 
        }
        this->num_rows_ = from.num_rows_;
        //std::cout<<"upper bound\n";
        this->col_name_idx = from.col_name_idx->clone();
        //std::cout<<"lower bound\n";
        this->row_name_idx = from.row_name_idx->clone();
        this->col_idx_name = from.col_idx_name->clone();
        this->row_idx_name = from.row_idx_name->clone();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x19ef7(%rip), %rcx     # 0x27810
movq %rcx, (%rdi)
movq $0x64, 0x10(%rdi)
movq %rax, 0x20(%rdi)
movq 0x10(%rsi), %rdi
movq %rdi, 0x10(%rbx)
movq 0x20(%rsi), %r15
movq %r15, 0x20(%rbx)
incq %rdi
callq 0x7030
movq %rax, 0x18(%rbx)
testq %r15, %r15
je 0xd962
xorl %eax, %eax
movq 0x18(%r14), %rcx
movb (%rcx,%rax), %cl
movq 0x18(%rbx), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq 0x20(%rbx), %rax
jb 0xd94b
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x30(%rbx)
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x38(%rbx)
movq 0x40(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x40(%rbx)
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x48(%rbx)
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/distributedDataframe.h
// Function: DistributedDataFrame::equals(Object*)
bool equals(Object  * other) {
      if (other == this) return true;
        DistributedDataFrame* x = dynamic_cast<DistributedDataFrame*>(other);
        if (x == nullptr) return false;
        if (this->ncols() != x->ncols()) return false;
        if (this->nrows() != x->nrows()) return false;
        for (size_t i = 0; i < this->ncols(); i++) {
            if (!(this->cols_->get(i)->equals(x->cols_->get(i)))) { 
                return false; 
            }
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb $0x1, %r14b
cmpq %rdi, %rsi
je 0xdbe4
testq %rsi, %rsi
je 0xdbe1
movq %rdi, %rbx
leaq 0x1976e(%rip), %rax     # 0x272d0
leaq 0x1a3af(%rip), %rdx     # 0x27f18
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xdbe1
movq %rax, %r15
movq 0x10(%rbx), %rcx
movq 0x20(%rcx), %rax
movq 0x10(%r15), %rdx
cmpq 0x20(%rdx), %rax
jne 0xdbe1
movq 0x28(%rcx), %rcx
cmpq 0x28(%rdx), %rcx
jne 0xdbe1
testq %rax, %rax
je 0xdbe4
xorl %r12d, %r12d
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
movq %rax, %r14
movq 0x18(%r15), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
movl %eax, %r14d
testb %al, %al
je 0xdbe4
incq %r12
movq 0x10(%rbx), %rax
cmpq 0x20(%rax), %r12
jb 0xdba2
jmp 0xdbe4
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("DistributedDataFrame");
        char * serializedschema = schema_->serialize();
        sb->write("schema_", serializedschema, false);
        char * seralizedcols = cols_->serialize();
        sb->write("cols_", seralizedcols, 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 0xfc75(%rip), %rsi      # 0x1d88b
movq %rbx, %rdi
callq 0x80f6
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xfc71(%rip), %rsi      # 0x1d8a0
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa8f0
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xfc5b(%rip), %rsi      # 0x1d8a8
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 0xdca0
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/../utils/distributedArray.h
// Function: IntDistributedArray::IntDistributedArray(KVStore*)
IntDistributedArray(KVStore* kv) {
        kv_ = kv;
        totalNodes_ = kv->num_nodes_;
        srand(time(nullptr));
        uid_ = rand();
        curNode_ = 0;
        itemCount_ = 0;
        chunkCount_ = 0;
        keys_ = new Array();
        chunkArray_ = new IntArray(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 0x1a361(%rip), %rax     # 0x28040
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 0x199df(%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 0x19e9f(%rip), %rcx     # 0x27c20
movq %rcx, (%r14)
movq %r15, 0x18(%r14)
cltq
movq %rax, 0x20(%r14)
leaq (,%rax,4), %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 0xddbd
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: DistributedIntColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    DistributedIntColumn* other_ic = dynamic_cast<DistributedIntColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    IntDistributedArray* other_val_ = dynamic_cast<IntDistributedArray*>(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 0xde4a
movq %rdi, %rbx
leaq 0x194dd(%rip), %rax     # 0x272d0
leaq 0x1a21e(%rip), %rdx     # 0x28018
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xde4a
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 0xde4a
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: DistributedIntColumn::serialize()
char* serialize() {
    Serializable sb;
    sb.initSerialize("DistributedIntColumn");
    char * seralizedArr = val_->serialize();
    sb.write("val_", seralizedArr, false);
    sb.endSerialize();
    char* value = sb.get();
    return value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0x8094
leaq 0xf7fb(%rip), %rsi      # 0x1d684
movq %r14, %rdi
callq 0x80f6
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xf556(%rip), %rsi      # 0x1d3f8
leaq -0x18(%rbp), %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa8f0
movq -0x18(%rbp), %rbx
movl $0x4, %esi
movq %rbx, %rdi
callq 0x824a
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%rbx)
movq -0x18(%rbp), %rdi
callq 0x82ba
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xdef9
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xdf09
jmp 0xdf09
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xdf1b
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedIntColumn::getColumnOnNode()
Column* getColumnOnNode() override {
    size_t _node = kv_->this_node_;
    IntColumn* col = new IntColumn();
    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;
        IntArray* chunk = dynamic_cast<IntArray*>(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) {
      IntArray* 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 0xe86c
movq 0x18(%r13), %rax
movq 0x38(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0xe078
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 0x192f0(%rip), %rsi     # 0x272d0
leaq 0x19801(%rip), %rdx     # 0x277e8
xorl %ecx, %ecx
callq 0x7280
cmpq %r12, 0x18(%rax)
jne 0xe06b
movq 0x10(%r13), %rdi
movq %rax, %rsi
callq 0xbeb4
movq 0x10(%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x146f0
testq %rax, %rax
je 0xe02f
movq %rax, %rdi
leaq 0x192b4(%rip), %rsi     # 0x272d0
leaq 0x19c3d(%rip), %rdx     # 0x27c60
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0xe032
xorl %r13d, %r13d
cmpq $0x0, 0x18(%r13)
je 0xe059
xorl %r12d, %r12d
movq 0x10(%r13), %rax
movl (%rax,%r12,4), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
incq %r12
cmpq 0x18(%r13), %r12
jb 0xe03c
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
incq %r15
cmpq 0x18(%r14), %r15
jb 0xdfc5
testq %r12, %r12
jne 0xe0ac
movq 0x18(%r13), %rax
movq 0x18(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0xe0ac
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movl (%rax,%r15,4), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x98(%rax)
incq %r15
cmpq 0x18(%r14), %r15
jb 0xe08f
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: IntDistributedArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        IntDistributedArray *s = dynamic_cast<IntDistributedArray*>(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
testq %rsi, %rsi
je 0xe19e
movq %rdi, %rbx
leaq 0x19190(%rip), %rax     # 0x272d0
leaq 0x19f39(%rip), %rdx     # 0x28080
xorl %r15d, %r15d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xe1a1
movq %rax, %r14
movq 0x58(%rbx), %rax
cmpq 0x58(%r14), %rax
jne 0xe19e
testq %rax, %rax
je 0xe1ad
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0xe328
movl %eax, %r15d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe328
cmpl %eax, %r15d
sete %r15b
jne 0xe1a1
incq %r12
cmpq %r12, 0x58(%rbx)
ja 0xe171
jmp 0xe1a1
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r15b
jmp 0xe1a1
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: FloatDistributedArray::hash_me()
size_t hash_me() {
      int 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
xorl %ebx, %ebx
cmpq $0x0, 0x58(%rdi)
je 0x123f1
movq %rdi, %r14
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x12546
xorps %xmm1, %xmm1
cvtsi2ss %ebx, %xmm1
mulss %xmm0, %xmm1
cvttss2si %xmm1, %ebx
incq %r15
cmpq %r15, 0x58(%r14)
ja 0x123cb
movslq %ebx, %rbx
movq %rbx, %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: IntDistributedArray::get(unsigned long)
int get(size_t index) {
       //new logic to check if current chunk
        assert(index < itemCount_);
        //std::cout << "in get " << index <<"\n";
        if (cache_ == nullptr) {
            init_cache_();
        }
        int 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
            IntArray* 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 0xe3dc
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
jne 0xe34e
movq %r14, %rdi
callq 0xe41a
movq 0x48(%r14), %rdi
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
cmpq 0x50(%r14), %rax
jne 0xe366
movq 0x18(%r14), %rcx
jmp 0xe3ca
movq %rax, %xmm0
punpckldq 0xeced(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xecf5(%rip), %xmm0     # 0x1d070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0xecf1(%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 0xe3c2
movq %r14, %rdi
callq 0xe474
movq %rax, %rcx
movq 0x48(%r14), %rdi
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
cmpq %rdx, 0x18(%rcx)
jbe 0xe3fb
movq 0x10(%rcx), %rax
movl (%rax,%rdx,4), %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xf11b(%rip), %rdi      # 0x1d4fe
leaq 0xf127(%rip), %rsi      # 0x1d511
leaq 0xf25a(%rip), %rcx      # 0x1d64b
movl $0x45, %edx
callq 0x7150
leaq 0xf05c(%rip), %rdi      # 0x1d45e
leaq 0xf069(%rip), %rsi      # 0x1d472
leaq 0xf0ad(%rip), %rcx      # 0x1d4bd
movl $0xf3, %edx
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: IntDistributedArray::init_cache_()
void init_cache_() {
        //assuming a dataframe is immutable, so nu pushbacks after the first get call.
        cache_ = new IntArray*[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 0xe46f
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
movq 0x38(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jb 0xe456
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: IntDistributedArray::get_chunk_from_kv_(unsigned long)
IntArray* 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";
        IntArray* doubleVals = new IntArray(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 0xe497
movq %rbx, %rdi
callq 0xe51c
movq 0x10(%rbx), %r15
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xe4ca
leaq 0x18e1c(%rip), %rsi     # 0x272d0
leaq 0x1932d(%rip), %rdx     # 0x277e8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rsi
jmp 0xe4cc
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 0xe56e
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/column.h
// Function: IntColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    IntColumn* other_ic = dynamic_cast<IntColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    for(int i = 0; i < val_->length(); i++) {
      IntArray* ia = dynamic_cast<IntArray*>(val_->get(i));
      IntArray* other_ia = dynamic_cast<IntArray*>(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 0xea89
movq %rdi, %rbx
leaq 0x1893f(%rip), %rax     # 0x272d0
leaq 0x197e8(%rip), %rdx     # 0x28180
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xea8c
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 0xea89
movq 0x10(%rbx), %rdi
movb $0x1, %r14b
cmpq $0x0, 0x18(%rdi)
je 0xea8c
xorl %r12d, %r12d
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xea18
movq %rax, %rdi
leaq 0x188cb(%rip), %rsi     # 0x272d0
leaq 0x19254(%rip), %rdx     # 0x27c60
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0xea1b
xorl %r13d, %r13d
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xea47
movq %rax, %rdi
leaq 0x18899(%rip), %rsi     # 0x272d0
leaq 0x19222(%rip), %rdx     # 0x27c60
xorl %ecx, %ecx
callq 0x7280
jmp 0xea49
xorl %eax, %eax
movq 0x18(%r13), %rcx
testq %rcx, %rcx
je 0xea76
movq 0x18(%rax), %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0xea9e
movq 0x10(%r13), %rdi
movl (%rdi,%rsi,4), %edi
movq 0x10(%rax), %r8
cmpl (%r8,%rsi,4), %edi
jne 0xea89
incq %rsi
cmpq %rsi, %rcx
jne 0xea58
incq %r12
movq 0x10(%rbx), %rdi
cmpq %r12, 0x18(%rdi)
ja 0xe9ed
jmp 0xea8c
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe9b9(%rip), %rdi      # 0x1d45e
leaq 0xe9c6(%rip), %rsi      # 0x1d472
leaq 0xea0a(%rip), %rcx      # 0x1d4bd
movl $0xf3, %edx
callq 0x7150
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: IntColumn::hash_me()
size_t hash_me() {
    size_t hash = 0;
    for(int i = 0; i < val_->length(); i++) {
      IntArray* ia = dynamic_cast<IntArray*>(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 0xeb3d
xorl %r14d, %r14d
leaq 0x187ec(%rip), %r12     # 0x272d0
leaq 0x19175(%rip), %r13     # 0x27c60
xorl %r15d, %r15d
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xeb0e
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x7280
jmp 0xeb10
xorl %eax, %eax
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0xeb2e
movq 0x10(%rax), %rax
xorl %edx, %edx
movslq (%rax,%rdx,4), %rsi
addq %rsi, %r15
incq %rdx
cmpq %rdx, %rcx
jne 0xeb1f
incq %r14
movq 0x10(%rbx), %rdi
cmpq %r14, 0x18(%rdi)
ja 0xeaee
jmp 0xeb40
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: IntColumn::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("IntColumn");
    sb->write("listLength_", listLength_);
    sb->write("arraySize_", arraySize_);
    sb->write("metaArrayStartSize__", metaArrayStartSize_);
    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 0xeb17(%rip), %rsi      # 0x1d68f
movq %rbx, %rdi
callq 0x80f6
movl 0x18(%r14), %edx
leaq 0xe8db(%rip), %rsi      # 0x1d466
movq %rbx, %rdi
callq 0x8162
movl 0x1c(%r14), %edx
leaq 0xe7c6(%rip), %rsi      # 0x1d364
movq %rbx, %rdi
callq 0x8162
movl 0x20(%r14), %edx
leaq 0xea6b(%rip), %rsi      # 0x1d61c
movq %rbx, %rdi
callq 0x8162
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xe82e(%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 0xec1d
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/../dataframe/column.h
// Function: IntColumn::push_back(int)
void push_back(int val) {
    if (listLength_  >= ((arraySize_* val_->length()))) {
      val_->pushBack(new IntArray(arraySize_));
    }
    int array_index = listLength_ / arraySize_;
    IntArray* ia = dynamic_cast<IntArray*>(val_->get(array_index));
    ia->pushBack(val);
    listLength_++;

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movslq 0x18(%rdi), %rax
movl 0x1c(%rdi), %ecx
movslq %ecx, %r13
movq 0x10(%rdi), %r15
movq 0x18(%r15), %rdx
imulq %r13, %rdx
cmpq %rax, %rdx
ja 0xed20
movl $0x28, %edi
callq 0x7230
movq %rax, %r12
xorl %eax, %eax
movq %rax, 0x8(%r12)
leaq 0x18f44(%rip), %rcx     # 0x27c20
movq %rcx, (%r12)
movq %rax, 0x18(%r12)
movq %r13, 0x20(%r12)
leaq (,%r13,4), %rax
testl %r13d, %r13d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x7030
movq %rax, 0x10(%r12)
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x58(%rax)
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %ecx
movq 0x10(%rbx), %r15
cltd
idivl %ecx
movslq %eax, %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x40(%rax)
leaq 0x1859a(%rip), %rsi     # 0x272d0
leaq 0x18f23(%rip), %rdx     # 0x27c60
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movl %r14d, (%rcx,%rdx,4)
incq %rdx
movq %rdx, 0x18(%rax)
incl 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %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: IntDistributedArray::pushBack(int)
void pushBack(int val) {
        //initialize first key
        if(itemCount_ % chunkSize_ == 0 && itemCount_ != 0) { //if current chunk is full..
            storeChunk(); //stores the previous chunk values in the kv_store
            chunkArray_->pushBack(val);
        } else {
            chunkArray_->pushBack(val);
        }
        itemCount_ +=1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x58(%rdi), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq 0x48(%rdi)
testq %rcx, %rcx
je 0xedf9
testq %rdx, %rdx
jne 0xedf9
movq %rbx, %rdi
callq 0xee1c
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movl %r14d, (%rcx,%rdx,4)
incq %rdx
movq %rdx, 0x18(%rax)
movq 0x58(%rbx), %rcx
jmp 0xee10
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rsi
movl %r14d, (%rdx,%rsi,4)
incq %rsi
movq %rsi, 0x18(%rax)
incq %rcx
movq %rcx, 0x58(%rbx)
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: IntDistributedArray::storeChunk()
void storeChunk() {
        //creates a unique keyname based on provided ID - could be modified to randomly pick number?
        StrBuff sb;
        sb.c(uid_);
        sb.c("_dist_int_array_chunk_");
        sb.c(chunkCount_);
        String* s = sb.get();
        Key* k = new Key(s->c_str(), curNode_); //create new key with current node and keyName
        keys_->pushBack(k);
        kv_->put(k, new Value(chunkArray_->serialize(), (size_t)0)); //adds new IntArray to kvStore
        //std::cout << "in store chunk\n";
        delete chunkArray_;
        chunkArray_ = new IntArray(chunkSize_); //creates new Int array to store values for new chunk
        curNode_+=1;
        chunkCount_+=1;
        if(curNode_ == totalNodes_) { //starts cycle of chunks on nodes again
            curNode_ = 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
leaq -0x48(%rbp), %r14
movq %r15, 0x8(%r14)
leaq 0x185e8(%rip), %rax     # 0x27428
movq %rax, (%r14)
movq $0xa, 0x18(%r14)
movl $0xa, %edi
callq 0x7030
movq %rax, 0x10(%r14)
movq %r15, 0x20(%r14)
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0xd720
movl $0x16, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movups 0xe814(%rip), %xmm0     # 0x1d699
movups %xmm0, (%rax,%rcx)
movabsq $0x5f6b6e7568635f79, %rdx # imm = 0x5F6B6E7568635F79
movq %rdx, 0xe(%rax,%rcx)
addq $0x16, 0x20(%r14)
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0xd720
movq %r14, %rdi
callq 0x82ba
movq %rax, %r15
movl $0x20, %edi
callq 0x7230
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq 0x60(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x8650
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x58(%rax)
movq 0x10(%rbx), %r12
movl $0x20, %edi
callq 0x7230
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%r15)
leaq 0x18dfa(%rip), %rdx     # 0x27d08
movq %rdx, (%r15)
movq %rax, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9b8c
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xef36
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x28, %edi
callq 0x7230
movq %rax, %r14
movq 0x48(%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x8(%r14)
leaq 0x18ccc(%rip), %rdx     # 0x27c20
movq %rdx, (%r14)
movq %rcx, 0x18(%r14)
cltq
movq %rax, 0x20(%r14)
leaq (,%rax,4), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x7030
movq %rax, 0x10(%r14)
movq %r14, 0x18(%rbx)
movq 0x60(%rbx), %rax
incq %rax
movq %rax, 0x60(%rbx)
incq 0x50(%rbx)
cmpq 0x68(%rbx), %rax
jne 0xefa0
movq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xefb7
movq %rax, %rbx
movq %r15, %r14
jmp 0xefba
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/../utils/distributedArray.h
// Function: StringDistributedArray::StringDistributedArray(KVStore*)
StringDistributedArray(KVStore* kv) {
        kv_ = kv;
        totalNodes_ = kv->num_nodes_;
        srand(time(nullptr));
        uid_ = rand();
        curNode_ = 0;
        itemCount_ = 0;
        chunkCount_ = 0;
        keys_ = new Array();
        chunkArray_ = new StringArray(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 0x192c3(%rip), %rax     # 0x282a8
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 0x186d9(%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 0x19289(%rip), %rcx     # 0x28310
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 0xf0c3
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: DistributedStringColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    DistributedStringColumn* other_ic = dynamic_cast<DistributedStringColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    StringDistributedArray* other_val_ = dynamic_cast<StringDistributedArray*>(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 0xf150
movq %rdi, %rbx
leaq 0x181d7(%rip), %rax     # 0x272d0
leaq 0x19180(%rip), %rdx     # 0x28280
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xf150
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 0xf150
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: DistributedStringColumn::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("DistributedStringColumn");
    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 0xe592(%rip), %rsi      # 0x1d726
movq %rbx, %rdi
callq 0x80f6
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xe24b(%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 0xf200
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: DistributedStringColumn::getColumnOnNode()
Column* getColumnOnNode() override {
    size_t _node = kv_->this_node_;
    StringColumn* col = new StringColumn();
    Array* keys = val_->keys_;
    // std::cout << "keys length: " << keys->length() << "\n";
    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.
        // std::cout << "here\n";
        Value* val = kv_->get(key);
        Deserializable ds;
        StringArray* chunk = dynamic_cast<StringArray*>(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) {
      StringArray* 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 0xfdcc
movq 0x18(%r13), %rax
movq 0x38(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0xf378
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 0x17ff0(%rip), %rsi     # 0x272d0
leaq 0x18501(%rip), %rdx     # 0x277e8
xorl %ecx, %ecx
callq 0x7280
cmpq %r12, 0x18(%rax)
jne 0xf36b
movq 0x10(%r13), %rdi
movq %rax, %rsi
callq 0xbeb4
movq 0x10(%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x146f0
testq %rax, %rax
je 0xf32f
movq %rax, %rdi
leaq 0x17fb4(%rip), %rsi     # 0x272d0
leaq 0x1902d(%rip), %rdx     # 0x28350
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0xf332
xorl %r13d, %r13d
cmpq $0x0, 0x18(%r13)
je 0xf359
xorl %r12d, %r12d
movq 0x10(%r13), %rax
movq (%rax,%r12,8), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xb8(%rax)
incq %r12
cmpq 0x18(%r13), %r12
jb 0xf33c
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
incq %r15
cmpq 0x18(%r14), %r15
jb 0xf2c5
testq %r12, %r12
jne 0xf3ac
movq 0x18(%r13), %rax
movq 0x18(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0xf3ac
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xb8(%rax)
incq %r15
cmpq 0x18(%r14), %r15
jb 0xf38f
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: StringDistributedArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        StringDistributedArray *s = dynamic_cast<StringDistributedArray*>(o);
        if(s == nullptr) return false;
        if(itemCount_ != s->itemCount_) return false;
        for(int i = 0; i < itemCount_; i++) {
            bool sameInt = s->get(i)->equals(get(i));
            if(!sameInt) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0xf4a8
movq %rdi, %rbx
leaq 0x17e90(%rip), %rax     # 0x272d0
leaq 0x18ea1(%rip), %rdx     # 0x282e8
xorl %r15d, %r15d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xf4ab
movq %rax, %r14
movq 0x58(%rbx), %rax
cmpq 0x58(%r14), %rax
jne 0xf4a8
testq %rax, %rax
je 0xf4b7
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0xf92a
movq %rax, %r15
movq %rbx, %rdi
movq %r12, %rsi
callq 0xf92a
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
movl %eax, %r15d
testb %al, %al
je 0xf4ab
incq %r12
cmpq %r12, 0x58(%rbx)
ja 0xf471
jmp 0xf4ab
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r15b
jmp 0xf4ab
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::hash_me()
size_t hash_me() {
      size_t temp = 0;
      for(int i = 0; i < itemCount_; i++) {
          temp *= get(i)->hash();
      }
      return temp;
  }

// Assembly:
cmpq $0x0, 0x58(%rdi)
je 0xf4f1
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf92a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
incq %r14
cmpq %r14, 0x58(%rbx)
ja 0xf4d0
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq