LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1931a(%rip), %rax     # 0x283f0
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 0xd948
movl $0x16, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movups 0xe57e(%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 0xd948
movq %r14, %rdi
callq 0x82d0
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 0x8670
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 0x19b64(%rip), %rdx     # 0x28d08
movq %rdx, (%r15)
movq %rax, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9bbe
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xf1cc
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 0x19a36(%rip), %rdx     # 0x28c20
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 0xf236
movq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf24d
movq %rax, %rbx
movq %r15, %r14
jmp 0xf250
movq %rax, %rbx
movq %r14, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a02d(%rip), %rax     # 0x292a8
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 0x19443(%rip), %rax     # 0x28720
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 0x19ff3(%rip), %rcx     # 0x29310
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 0xf359
movq %rax, %rbx
movq %r14, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf3e6
movq %rdi, %rbx
leaq 0x18eb9(%rip), %rax     # 0x28248
leaq 0x19eea(%rip), %rdx     # 0x29280
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xf3e6
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 0xf3e6
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_O1/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 0x80aa
leaq 0xe2fc(%rip), %rsi      # 0x1d726
movq %rbx, %rdi
callq 0x810c
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xdfb5(%rip), %rsi      # 0x1d3f8
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa9d0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xf496
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../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 0x100e6
movq 0x18(%r13), %rax
movq 0x38(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0xf60e
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 0x18cd2(%rip), %rsi     # 0x28248
leaq 0x1926b(%rip), %rdx     # 0x287e8
xorl %ecx, %ecx
callq 0x7280
cmpq %r12, 0x18(%rax)
jne 0xf601
movq 0x10(%r13), %rdi
movq %rax, %rsi
callq 0xc02e
movq 0x10(%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x14b60
testq %rax, %rax
je 0xf5c5
movq %rax, %rdi
leaq 0x18c96(%rip), %rsi     # 0x28248
leaq 0x19d97(%rip), %rdx     # 0x29350
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0xf5c8
xorl %r13d, %r13d
cmpq $0x0, 0x18(%r13)
je 0xf5ef
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 0xf5d2
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
incq %r15
cmpq 0x18(%r14), %r15
jb 0xf55b
testq %r12, %r12
jne 0xf642
movq 0x18(%r13), %rax
movq 0x18(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0xf642
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 0xf625
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_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xf77c
movq %rdi, %rbx
leaq 0x18b6b(%rip), %rax     # 0x28248
leaq 0x19c04(%rip), %rdx     # 0x292e8
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xf77f
movq %rax, %r15
movq 0x58(%rbx), %rax
cmpq 0x58(%r15), %rax
jne 0xf77c
cmpq $0x0, 0x58(%rbx)
sete %r14b
je 0xf77f
movq %r15, %rdi
xorl %esi, %esi
callq 0xfc00
movq %rax, %r12
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfc00
movq (%r12), %rcx
movq %r12, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
testb %al, %al
je 0xf77f
movl $0x1, %r12d
cmpq %r12, 0x58(%rbx)
setbe %r14b
jbe 0xf77f
movq %r15, %rdi
movq %r12, %rsi
callq 0xfc00
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0xfc00
movq (%r13), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
incq %r12
testb %al, %al
jne 0xf743
jmp 0xf77f
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf7c7
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfc00
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
incq %r14
cmpq %r14, 0x58(%rbx)
ja 0xf7a6
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: StringArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        StringArray *b = dynamic_cast<StringArray*>(o);
        if(b == nullptr) return false;
        if(listLength_ != b->listLength_) return false;
        for(int i = 0; i < listLength_; i++) {
            bool sameString = b->get(i)->equals(get(i));
            if(!sameString) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0xf9dd
movq %rdi, %r14
leaq 0x188ce(%rip), %rax     # 0x28248
leaq 0x199cf(%rip), %rdx     # 0x29350
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xf9df
movq %rax, %r15
movq 0x18(%r14), %rax
cmpq 0x18(%r15), %rax
jne 0xf9dd
cmpq $0x0, 0x18(%r14)
sete %bl
je 0xf9df
xorl %r12d, %r12d
cmpq %r12, 0x18(%r15)
jbe 0xf9ed
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rdi
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0xf9df
incq %r12
cmpq %r12, 0x18(%r14)
setbe %bl
ja 0xf9af
jmp 0xf9df
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xda6a(%rip), %rdi      # 0x1d45e
leaq 0xda77(%rip), %rsi      # 0x1d472
leaq 0xdcae(%rip), %rcx      # 0x1d6b0
movl $0x2a4, %edx            # imm = 0x2A4
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: StringArray::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("StringArray");
        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 0x80aa
leaq 0xdc93(%rip), %rsi      # 0x1d6d1
movq %rbx, %rdi
callq 0x810c
movq 0x18(%r14), %rdx
leaq 0xda15(%rip), %rsi      # 0x1d466
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0xd900(%rip), %rsi      # 0x1d364
movq %rbx, %rdi
callq 0x81e6
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0xda65(%rip), %rsi      # 0x1d4e0
movq %rbx, %rdi
callq 0xfaec
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xfac9
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, String**, int)
void write(const char* name, String** val, int len) {
        char str[1000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            sprintf(str, "'%s',", val[i]->c_str());
            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 0xd861(%rip), %rsi      # 0x1d375
leaq -0x420(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq %rbx, -0x30(%rbp)
movq (%rbx), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x8260
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
testl %r14d, %r14d
jle 0xfbc2
movl %r14d, %ebx
xorl %r14d, %r14d
movq -0x38(%rbp), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %r12, %rdi
leaq 0xdb61(%rip), %rsi      # 0x1d6dd
movq %rax, %rdx
xorl %eax, %eax
callq 0x7080
movq -0x30(%rbp), %rax
movq (%rax), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x8260
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
incq %r14
cmpq %r14, %rbx
jne 0xfb64
movq -0x30(%rbp), %rax
movq (%rax), %rbx
movl $0x3, %esi
movq %rbx, %rdi
callq 0x8260
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movb $0x20, 0x2(%rax,%rcx)
movw $0x2c5d, (%rax,%rcx)    # imm = 0x2C5D
addq $0x3, 0x20(%rbx)
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::get(unsigned long)
String* get(size_t index) {
        assert(index < itemCount_);
        //std::cout << "in get " << index <<"\n";
        if (cache_ == nullptr) {
            init_cache_();
        }
        String* 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
            StringArray* 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 0xfcaf
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0xfc26
movq %rbx, %rdi
callq 0xfcee
movq %r14, %rax
xorl %edx, %edx
divq 0x48(%rbx)
cmpq 0x50(%rbx), %rax
jne 0xfc3b
movq 0x18(%rbx), %rcx
jmp 0xfc9c
movq %rax, %xmm0
punpckldq 0xd418(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xd420(%rip), %xmm0     # 0x1d070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0xd41c(%rip), %xmm1     # 0x1d088
sarq $0x3f, %rcx
cvttsd2si %xmm1, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq 0x20(%rbx), %rax
movq (%rax,%rsi,8), %rcx
testq %rcx, %rcx
jne 0xfc93
movq %rbx, %rdi
callq 0xfd4c
movq %rax, %rcx
movq %r14, %rax
xorl %edx, %edx
divq 0x48(%rbx)
cmpq %rdx, 0x18(%rcx)
jbe 0xfcce
movq 0x10(%rcx), %rax
movq (%rax,%rdx,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xd848(%rip), %rdi      # 0x1d4fe
leaq 0xd854(%rip), %rsi      # 0x1d511
leaq 0xda1f(%rip), %rcx      # 0x1d6e3
movl $0x1f6, %edx            # imm = 0x1F6
callq 0x7150
leaq 0xd789(%rip), %rdi      # 0x1d45e
leaq 0xd796(%rip), %rsi      # 0x1d472
leaq 0xd9cd(%rip), %rcx      # 0x1d6b0
movl $0x2a4, %edx            # imm = 0x2A4
callq 0x7150
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::init_cache_()
void init_cache_() {
        //assuming a dataframe is immutable, so nu pushbacks after the first get call.
        cache_ = new StringArray*[keys_->length()];
        for (size_t i = 0; i < keys_->length(); i++) {
            cache_[i] = nullptr;
        }
        return;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x18(%rax), %rax
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x7030
movq %rax, 0x20(%rbx)
movq 0x38(%rbx), %rax
cmpq $0x0, 0x18(%rax)
je 0xfd44
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
movq 0x38(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jb 0xfd2b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::get_chunk_from_kv_(unsigned long)
StringArray* 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";
        StringArray* doubleVals = new StringArray(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 0xfd6f
movq %rbx, %rdi
callq 0xfdf4
movq 0x10(%rbx), %r15
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xfda2
leaq 0x184bc(%rip), %rsi     # 0x28248
leaq 0x18a55(%rip), %rdx     # 0x287e8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rsi
jmp 0xfda4
xorl %esi, %esi
movq %r15, %rdi
callq 0xc02e
movq 0x10(%rax), %r12
movl $0x28, %edi
callq 0x7230
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xfe46
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_O1/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: StringColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    StringColumn* other_ic = dynamic_cast<StringColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    for(int i = 0; i < val_->length(); i++) {
      StringArray* ia = dynamic_cast<StringArray*>(val_->get(i));
      StringArray* other_ia = dynamic_cast<StringArray*>(other_ic->val_->get(i));
      for(int j = 0; j < ia->length(); j++) {
        if(!ia->get(j)->equals(other_ia->get(j))) {
          return false;
        }
      }
    }
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x1032e
movq %rdi, %r15
leaq 0x18030(%rip), %rax     # 0x28248
leaq 0x19231(%rip), %rdx     # 0x29450
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x10331
movq %rax, %r12
movq (%rax), %rax
movq %r12, %rdi
callq *0xc8(%rax)
movq %rax, %rbx
movq (%r15), %rax
movq %r15, %rdi
callq *0xc8(%rax)
cmpq %rax, %rbx
jne 0x1032e
movq 0x10(%r15), %rdi
cmpq $0x0, 0x18(%rdi)
sete %r14b
je 0x10331
movq %r12, -0x38(%rbp)
xorl %r12d, %r12d
movq %r15, -0x30(%rbp)
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x102a8
movq %rax, %rdi
leaq 0x17fb3(%rip), %rsi     # 0x28248
leaq 0x190b4(%rip), %rdx     # 0x29350
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0x102ab
xorl %r13d, %r13d
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x102de
movq %rax, %rdi
leaq 0x17f7d(%rip), %rsi     # 0x28248
leaq 0x1907e(%rip), %rdx     # 0x29350
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rbx
jmp 0x102e0
xorl %ebx, %ebx
cmpq $0x0, 0x18(%r13)
je 0x10313
xorl %r15d, %r15d
cmpq %r15, 0x18(%rbx)
jbe 0x10347
movq 0x10(%r13), %rax
movq (%rax,%r15,8), %rdi
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x10331
incq %r15
cmpq %r15, 0x18(%r13)
ja 0x102ea
incq %r12
movq -0x30(%rbp), %r15
movq 0x10(%r15), %rdi
cmpq %r12, 0x18(%rdi)
setbe %r14b
ja 0x1027d
jmp 0x10331
xorl %r14d, %r14d
andb $0x1, %r14b
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd110(%rip), %rdi      # 0x1d45e
leaq 0xd11d(%rip), %rsi      # 0x1d472
leaq 0xd354(%rip), %rcx      # 0x1d6b0
movl $0x2a4, %edx            # imm = 0x2A4
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: StringColumn::hash_me()
size_t hash_me() {
    size_t hash = 0;
    for(int i = 0; i < val_->length(); i++) {
      StringArray* fa = dynamic_cast<StringArray*>(val_->get(i));
      for(int j = 0; j < fa->length(); j++) {
        hash += fa->get(j)->hash_me();
      }
    }
    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 0x103ec
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x103b3
movq %rax, %rdi
leaq 0x17ea8(%rip), %rsi     # 0x28248
leaq 0x18fa9(%rip), %rdx     # 0x29350
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r12
jmp 0x103b6
xorl %r12d, %r12d
cmpq $0x0, 0x18(%r12)
je 0x103dd
xorl %r13d, %r13d
movq 0x10(%r12), %rax
movq (%rax,%r13,8), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
addq %rax, %r15
incq %r13
cmpq %r13, 0x18(%r12)
ja 0x103c1
incq %r14
movq 0x10(%rbx), %rdi
cmpq %r14, 0x18(%rdi)
ja 0x10388
jmp 0x103ef
xorl %r15d, %r15d
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_O1/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: StringColumn::push_back(String*)
void push_back(String* val) {
    if (listLength_  >= ((arraySize_* val_->length()))) {
      val_->pushBack(new StringArray(arraySize_));
    }
    int array_index = listLength_ / arraySize_;
    StringArray* a = dynamic_cast<StringArray*>(val_->get(array_index));
    a->pushBack(val);
    listLength_++;

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x18(%rdi), %rax
movslq 0x1c(%rdi), %r13
movq 0x10(%rdi), %r15
movq 0x18(%r15), %rcx
imulq %r13, %rcx
cmpq %rax, %rcx
ja 0x105db
movl $0x28, %edi
callq 0x7230
movq %rax, %r12
xorl %eax, %eax
movq %rax, 0x8(%r12)
leaq 0x18d6e(%rip), %rcx     # 0x29310
movq %rcx, (%r12)
movq %rax, 0x18(%r12)
movq %r13, 0x20(%r12)
movq %r13, %rax
shlq $0x3, %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
cltd
idivl 0x1c(%rbx)
movq 0x10(%rbx), %rdi
movslq %eax, %rsi
movq (%rdi), %rax
callq *0x40(%rax)
leaq 0x17c52(%rip), %rsi     # 0x28248
leaq 0x18d53(%rip), %rdx     # 0x29350
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movq %r14, (%rcx,%rdx,8)
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_O1/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::pushBack(String*)
void pushBack(String* 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
movq %rsi, %r14
movq %rdi, %rbx
movq 0x58(%rdi), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq 0x48(%rdi)
testq %rcx, %rcx
je 0x10684
testq %rdx, %rdx
jne 0x10684
movq %rbx, %rdi
callq 0x106a4
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movq %r14, (%rcx,%rdx,8)
incq %rdx
movq %rdx, 0x18(%rax)
incq 0x58(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::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_string_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
        delete chunkArray_;
        chunkArray_ = new StringArray(chunkSize_); 
        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 0x17d28(%rip), %rax     # 0x283f0
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 0xd948
movl $0x19, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movups 0xd03a(%rip), %xmm0     # 0x1d747
movups %xmm0, 0x9(%rax,%rcx)
movups 0xd025(%rip), %xmm0     # 0x1d73e
movups %xmm0, (%rax,%rcx)
addq $0x19, 0x20(%r14)
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0xd948
movq %r14, %rdi
callq 0x82d0
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 0x8670
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 0x18575(%rip), %rdx     # 0x28d08
movq %rdx, (%r15)
movq %rax, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9bbe
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x107bb
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 0x18b37(%rip), %rdx     # 0x29310
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 0x10825
movq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1083c
movq %rax, %rbx
movq %r15, %r14
jmp 0x1083f
movq %rax, %rbx
movq %r14, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: BoolDistributedArray::BoolDistributedArray(KVStore*)
BoolDistributedArray(KVStore* kv) {
        kv_ = kv;
        totalNodes_ = kv->num_nodes_;
        srand(time(nullptr));
        uid_ = rand();
        curNode_ = 0;
        itemCount_ = 0;
        chunkCount_ = 0;
        keys_ = new Array();
        chunkArray_ = new BoolArray(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 0x18d0d(%rip), %rax     # 0x29578
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 0x17e53(%rip), %rax     # 0x28720
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
movslq 0x48(%rbx), %rdi
movq %r15, 0x8(%rax)
leaq 0x18cd3(%rip), %rax     # 0x295e0
movq %rax, (%r14)
movq %r15, 0x18(%r14)
movq %rdi, 0x20(%r14)
callq 0x7030
movq %rax, 0x10(%r14)
movq %r14, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10932
movq %rax, %rbx
movq %r14, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedBoolColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    DistributedBoolColumn* other_ic = dynamic_cast<DistributedBoolColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    BoolDistributedArray* other_val_ = dynamic_cast<BoolDistributedArray*>(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 0x109c0
movq %rdi, %rbx
leaq 0x178df(%rip), %rax     # 0x28248
leaq 0x18be0(%rip), %rdx     # 0x29550
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x109c0
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 0x109c0
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_O1/yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedBoolColumn::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("DistributedBoolColumn");
    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 0x80aa
leaq 0xcde5(%rip), %rsi      # 0x1d7e9
movq %rbx, %rdi
callq 0x810c
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xc9db(%rip), %rsi      # 0x1d3f8
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa9d0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x10a70
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedBoolColumn::getColumnOnNode()
Column* getColumnOnNode() override {
    size_t _node = kv_->this_node_;
    BoolColumn* col = new BoolColumn();
    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;
        BoolArray* chunk = dynamic_cast<BoolArray*>(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) {
      BoolArray* 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 0x11b6a
movq 0x18(%r13), %rax
movq 0x38(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0x10be9
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 0x176f8(%rip), %rsi     # 0x28248
leaq 0x17c91(%rip), %rdx     # 0x287e8
xorl %ecx, %ecx
callq 0x7280
cmpq %r12, 0x18(%rax)
jne 0x10bdc
movq 0x10(%r13), %rdi
movq %rax, %rsi
callq 0xc02e
movq 0x10(%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x14b60
testq %rax, %rax
je 0x10b9f
movq %rax, %rdi
leaq 0x176bc(%rip), %rsi     # 0x28248
leaq 0x18a8d(%rip), %rdx     # 0x29620
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0x10ba2
xorl %r13d, %r13d
cmpq $0x0, 0x18(%r13)
je 0x10bca
xorl %r12d, %r12d
movq 0x10(%r13), %rax
movzbl (%rax,%r12), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa8(%rax)
incq %r12
cmpq 0x18(%r13), %r12
jb 0x10bac
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
incq %r15
cmpq 0x18(%r14), %r15
jb 0x10b35
testq %r12, %r12
jne 0x10c1e
movq 0x18(%r13), %rax
movq 0x18(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0x10c1e
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movzbl (%rax,%r15), %esi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa8(%rax)
incq %r15
cmpq 0x18(%r14), %r15
jb 0x10c00
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_O1/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: BoolDistributedArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        BoolDistributedArray *s = dynamic_cast<BoolDistributedArray*>(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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x10d3c
movq %rdi, %rbx
leaq 0x1758f(%rip), %rax     # 0x28248
leaq 0x188f8(%rip), %rdx     # 0x295b8
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x10d3f
movq %rax, %r15
movq 0x58(%rbx), %rax
cmpq 0x58(%r15), %rax
jne 0x10d3c
cmpq $0x0, 0x58(%rbx)
sete %r14b
je 0x10d3f
movq %r15, %rdi
xorl %esi, %esi
callq 0x115fc
movl %eax, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x115fc
cmpb %al, %r12b
jne 0x10d3f
movl $0x1, %r12d
cmpq %r12, 0x58(%rbx)
setbe %r14b
jbe 0x10d3f
movq %r15, %rdi
movq %r12, %rsi
callq 0x115fc
movl %eax, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x115fc
incq %r12
cmpb %al, %r13b
je 0x10d0f
jmp 0x10d3f
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: BoolArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        BoolArray *b = dynamic_cast<BoolArray*>(o);
        if(b == nullptr) return false;
        if(listLength_ != b->listLength_) return false;
        for(int i = 0; i < listLength_; i++) {
            bool sameBool = b->get(i) == get(i);
            if(!sameBool) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x10fa3
movq %rdi, %r14
leaq 0x1731a(%rip), %rax     # 0x28248
leaq 0x186eb(%rip), %rdx     # 0x29620
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x10fa5
movq 0x18(%r14), %rcx
movq 0x18(%rax), %rdx
cmpq %rdx, %rcx
jne 0x10fa3
testq %rcx, %rcx
sete %bl
je 0x10fa5
movq 0x10(%r14), %rsi
negq %rdx
movq %rcx, %rdi
negq %rdi
movl $0x1, %r8d
leaq (%rdx,%r8), %r9
cmpq $0x1, %r9
je 0x10faf
movq 0x10(%rax), %r9
movb -0x1(%r9,%r8), %r9b
cmpb -0x1(%rsi,%r8), %r9b
jne 0x10fa5
cmpq %r8, %rcx
setbe %bl
leaq (%rdi,%r8), %r9
incq %r9
incq %r8
cmpq $0x1, %r9
jne 0x10f71
jmp 0x10fa5
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc4a8(%rip), %rdi      # 0x1d45e
leaq 0xc4b5(%rip), %rsi      # 0x1d472
leaq 0xc794(%rip), %rcx      # 0x1d758
movl $0x23d, %edx            # imm = 0x23D
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: BoolArray::clone()
virtual Object* clone() { 
        FloatArray* temp = new FloatArray();
        for(int i = 0; i < listLength_; i++) {
            float 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 0x18656(%rip), %rcx     # 0x29648
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 0x11047
movq 0x10(%r14), %rsi
movq 0x18(%rbx), %rdx
leaq (%rax,%rdx,4), %rdi
xorl %eax, %eax
movsbl (%rsi,%rax), %r8d
xorps %xmm0, %xmm0
cvtsi2ss %r8d, %xmm0
movss %xmm0, (%rdi,%rax,4)
incq %rax
cmpq %rax, %rcx
jne 0x11026
addq %rax, %rdx
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
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: BoolArray::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("BoolArray");
        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 0x80aa
leaq 0xc709(%rip), %rsi      # 0x1d79d
movq %rbx, %rdi
callq 0x810c
movq 0x18(%r14), %rdx
leaq 0xc3bf(%rip), %rsi      # 0x1d466
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0xc2aa(%rip), %rsi      # 0x1d364
movq %rbx, %rdi
callq 0x81e6
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0xc40f(%rip), %rsi      # 0x1d4e0
movq %rbx, %rdi
callq 0x114f0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1111f
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: FloatArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        FloatArray *f = dynamic_cast<FloatArray*>(o);
        if(f == nullptr) return false;
        if(listLength_ != f->listLength_) return false;
        for(int i = 0; i < listLength_; i++) {
            bool sameFloat = f->get(i) == get(i);
            if(!sameFloat) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x11226
movq %rdi, %r14
leaq 0x1709c(%rip), %rax     # 0x28248
leaq 0x184d5(%rip), %rdx     # 0x29688
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x11228
movq 0x18(%r14), %rcx
movq 0x18(%rax), %rdx
cmpq %rdx, %rcx
jne 0x11226
testq %rcx, %rcx
sete %bl
je 0x11228
movq 0x10(%r14), %rsi
negq %rdx
movq %rcx, %rdi
negq %rdi
movl $0x1, %r8d
leaq (%rdx,%r8), %r9
cmpq $0x1, %r9
je 0x11232
movq 0x10(%rax), %r9
movss -0x4(%r9,%r8,4), %xmm0
ucomiss -0x4(%rsi,%r8,4), %xmm0
jne 0x11228
jp 0x11228
cmpq %r8, %rcx
setbe %bl
leaq (%rdi,%r8), %r9
incq %r9
incq %r8
cmpq $0x1, %r9
jne 0x111ef
jmp 0x11228
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc225(%rip), %rdi      # 0x1d45e
leaq 0xc232(%rip), %rsi      # 0x1d472
leaq 0xc52d(%rip), %rcx      # 0x1d774
movl $0x1d0, %edx            # imm = 0x1D0
callq 0x7150
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: FloatArray::hash_me()
size_t hash_me() {
      float temp = 0;
      for(int i = 0; i < listLength_; i++) {
          temp *= vals_[i];
      }
      return (int)temp;
  }

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x11309
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rcx
xorps %xmm0, %xmm0
xorl %edx, %edx
mulss (%rcx,%rdx,4), %xmm0
incq %rdx
cmpq %rdx, %rax
jne 0x112f4
cvttss2si %xmm0, %eax
cltq
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: FloatArray::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("FloatArray");
        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 0x80aa
leaq 0xc460(%rip), %rsi      # 0x1d792
movq %rbx, %rdi
callq 0x810c
movq 0x18(%r14), %rdx
leaq 0xc121(%rip), %rsi      # 0x1d466
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0xc00c(%rip), %rsi      # 0x1d364
movq %rbx, %rdi
callq 0x81e6
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0xc171(%rip), %rsi      # 0x1d4e0
movq %rbx, %rdi
callq 0x113e0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x113bd
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