LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf703
movq %rdi, %rbx
leaq 0x17c2c(%rip), %rax     # 0x272d0
leaq 0x18ca5(%rip), %rdx     # 0x28350
xorl %r15d, %r15d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xf706
movq %rax, %r14
movq 0x18(%rbx), %rax
cmpq 0x18(%r14), %rax
jne 0xf703
testq %rax, %rax
je 0xf712
xorl %r12d, %r12d
cmpq %r12, 0x18(%r14)
jbe 0xf717
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rdi
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %r15d
testb %al, %al
je 0xf706
incq %r12
cmpq %r12, 0x18(%rbx)
ja 0xf6d5
jmp 0xf706
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r15b
jmp 0xf706
leaq 0xdd40(%rip), %rdi      # 0x1d45e
leaq 0xdd4d(%rip), %rsi      # 0x1d472
leaq 0xdf84(%rip), %rcx      # 0x1d6b0
movl $0x2a4, %edx            # imm = 0x2A4
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8094
leaq 0xdf69(%rip), %rsi      # 0x1d6d1
movq %rbx, %rdi
callq 0x80f6
movq 0x18(%r14), %rdx
leaq 0xdceb(%rip), %rsi      # 0x1d466
movq %rbx, %rdi
callq 0x81d0
movq 0x20(%r14), %rdx
leaq 0xdbd6(%rip), %rsi      # 0x1d364
movq %rbx, %rdi
callq 0x81d0
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0xdd3b(%rip), %rsi      # 0x1d4e0
movq %rbx, %rdi
callq 0xf816
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 0xf7f3
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/../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 0xf9df
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
jne 0xf950
movq %r14, %rdi
callq 0xfa1e
movq 0x48(%r14), %rdi
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
cmpq 0x50(%r14), %rax
jne 0xf968
movq 0x18(%r14), %rcx
jmp 0xf9cc
movq %rax, %xmm0
punpckldq 0xd6eb(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xd6f3(%rip), %xmm0     # 0x1d070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0xd6ef(%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 0xf9c4
movq %r14, %rdi
callq 0xfa78
movq %rax, %rcx
movq 0x48(%r14), %rdi
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
cmpq %rdx, 0x18(%rcx)
jbe 0xf9fe
movq 0x10(%rcx), %rax
movq (%rax,%rdx,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xdb18(%rip), %rdi      # 0x1d4fe
leaq 0xdb24(%rip), %rsi      # 0x1d511
leaq 0xdcef(%rip), %rcx      # 0x1d6e3
movl $0x1f6, %edx            # imm = 0x1F6
callq 0x7150
leaq 0xda59(%rip), %rdi      # 0x1d45e
leaq 0xda66(%rip), %rsi      # 0x1d472
leaq 0xdc9d(%rip), %rcx      # 0x1d6b0
movl $0x2a4, %edx            # imm = 0x2A4
callq 0x7150
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfa9b
movq %rbx, %rdi
callq 0xfb20
movq 0x10(%rbx), %r15
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xface
leaq 0x17818(%rip), %rsi     # 0x272d0
leaq 0x17d29(%rip), %rdx     # 0x277e8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rsi
jmp 0xfad0
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 0xfb72
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: 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
pushq %rax
testq %rsi, %rsi
je 0xfffa
movq %rdi, %r14
leaq 0x173df(%rip), %rax     # 0x272d0
leaq 0x18558(%rip), %rdx     # 0x28450
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xfffc
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0xc8(%rax)
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0xc8(%rax)
cmpq %rax, %rbx
jne 0xfffa
movq 0x10(%r14), %rdi
movb $0x1, %bl
cmpq $0x0, 0x18(%rdi)
je 0xfffc
xorl %r12d, %r12d
movq %r14, -0x30(%rbp)
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xff7a
movq %rax, %rdi
leaq 0x17369(%rip), %rsi     # 0x272d0
leaq 0x183e2(%rip), %rdx     # 0x28350
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0xff7d
xorl %r13d, %r13d
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xffac
movq %rax, %rdi
leaq 0x17337(%rip), %rsi     # 0x272d0
leaq 0x183b0(%rip), %rdx     # 0x28350
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rbx
jmp 0xffae
xorl %ebx, %ebx
cmpq $0x0, 0x18(%r13)
je 0xffe1
xorl %r14d, %r14d
cmpq %r14, 0x18(%rbx)
jbe 0x1000d
movq 0x10(%r13), %rax
movq (%rax,%r14,8), %rdi
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0xfffa
incq %r14
cmpq %r14, 0x18(%r13)
ja 0xffb8
incq %r12
movq -0x30(%rbp), %r14
movq 0x10(%r14), %rdi
cmpq %r12, 0x18(%rdi)
ja 0xff4f
movb $0x1, %bl
jmp 0xfffc
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd44a(%rip), %rdi      # 0x1d45e
leaq 0xd457(%rip), %rsi      # 0x1d472
leaq 0xd68e(%rip), %rcx      # 0x1d6b0
movl $0x2a4, %edx            # imm = 0x2A4
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O3/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 0x100b2
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x10079
movq %rax, %rdi
leaq 0x1726a(%rip), %rsi     # 0x272d0
leaq 0x182e3(%rip), %rdx     # 0x28350
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r12
jmp 0x1007c
xorl %r12d, %r12d
cmpq $0x0, 0x18(%r12)
je 0x100a3
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 0x10087
incq %r14
movq 0x10(%rbx), %rdi
cmpq %r14, 0x18(%rdi)
ja 0x1004e
jmp 0x100b5
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_O3/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
movl 0x1c(%rdi), %ecx
movslq %ecx, %r13
movq 0x10(%rdi), %r15
movq 0x18(%r15), %rdx
imulq %r13, %rdx
cmpq %rax, %rdx
ja 0x102ae
movl $0x28, %edi
callq 0x7230
movq %rax, %r12
xorl %eax, %eax
movq %rax, 0x8(%r12)
leaq 0x180a6(%rip), %rcx     # 0x28310
movq %rcx, (%r12)
movq %rax, 0x18(%r12)
movq %r13, 0x20(%r12)
leaq (,%r13,8), %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 0x1700c(%rip), %rsi     # 0x272d0
leaq 0x18085(%rip), %rdx     # 0x28350
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_O3/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 0x1036f
testq %rdx, %rdx
jne 0x1036f
movq %rbx, %rdi
callq 0x10392
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movq %r14, (%rcx,%rdx,8)
incq %rdx
movq %rdx, 0x18(%rax)
movq 0x58(%rbx), %rcx
jmp 0x10386
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rsi
movq %r14, (%rdx,%rsi,8)
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: 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 0x17072(%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 0xd34c(%rip), %xmm0     # 0x1d747
movups %xmm0, 0x9(%rax,%rcx)
movups 0xd337(%rip), %xmm0     # 0x1d73e
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 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 0x17887(%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 0x104a9
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 0x17e49(%rip), %rdx     # 0x28310
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 0x10513
movq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1052a
movq %rax, %rbx
movq %r15, %r14
jmp 0x1052d
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/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 0x1801f(%rip), %rax     # 0x28578
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 0x17165(%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
movslq 0x48(%rbx), %rdi
movq %r15, 0x8(%rax)
leaq 0x17fe5(%rip), %rax     # 0x285e0
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 0x10620
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/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 0x106ae
movq %rdi, %rbx
leaq 0x16c79(%rip), %rax     # 0x272d0
leaq 0x17ef2(%rip), %rdx     # 0x28550
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x106ae
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 0x106ae
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: 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 0x8094
leaq 0xd0f7(%rip), %rsi      # 0x1d7e9
movq %rbx, %rdi
callq 0x80f6
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xcced(%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 0x1075e
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: 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 0x11770
movq 0x18(%r13), %rax
movq 0x38(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0x108d7
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 0x16a92(%rip), %rsi     # 0x272d0
leaq 0x16fa3(%rip), %rdx     # 0x277e8
xorl %ecx, %ecx
callq 0x7280
cmpq %r12, 0x18(%rax)
jne 0x108ca
movq 0x10(%r13), %rdi
movq %rax, %rsi
callq 0xbeb4
movq 0x10(%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x146f0
testq %rax, %rax
je 0x1088d
movq %rax, %rdi
leaq 0x16a56(%rip), %rsi     # 0x272d0
leaq 0x17d9f(%rip), %rdx     # 0x28620
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0x10890
xorl %r13d, %r13d
cmpq $0x0, 0x18(%r13)
je 0x108b8
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 0x1089a
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
incq %r15
cmpq 0x18(%r14), %r15
jb 0x10823
testq %r12, %r12
jne 0x1090c
movq 0x18(%r13), %rax
movq 0x18(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0x1090c
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 0x108ee
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: 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 0x10a08
movq %rdi, %rbx
leaq 0x1692d(%rip), %rax     # 0x272d0
leaq 0x17c0e(%rip), %rdx     # 0x285b8
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x10a0b
movq %rax, %r15
movq 0x58(%rbx), %rax
cmpq 0x58(%r15), %rax
jne 0x10a08
testq %rax, %rax
je 0x10a1d
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x1123e
movl %eax, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1123e
movl %eax, %r14d
xorb %r13b, %r14b
cmpb $0x1, %r14b
je 0x10a02
incq %r12
cmpq %r12, 0x58(%rbx)
ja 0x109d4
xorb $0x1, %r14b
jmp 0x10a0b
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r14b
jmp 0x10a0b
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10c50
movq %rdi, %r14
leaq 0x166d2(%rip), %rax     # 0x272d0
leaq 0x17a1b(%rip), %rdx     # 0x28620
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x10c52
movq 0x18(%r14), %rcx
cmpq 0x18(%rax), %rcx
jne 0x10c50
testq %rcx, %rcx
je 0x10c59
movq 0x10(%rax), %rax
movq 0x10(%r14), %rdx
decq %rcx
xorl %esi, %esi
movb (%rax,%rsi), %dil
cmpb (%rdx,%rsi), %dil
sete %bl
jne 0x10c52
leaq 0x1(%rsi), %rdi
cmpq %rsi, %rcx
movq %rdi, %rsi
jne 0x10c35
jmp 0x10c52
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %bl
jmp 0x10c52
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x179c6(%rip), %rcx     # 0x28648
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 0x10cca
movq 0x10(%r14), %rsi
xorl %edx, %edx
movsbl (%rsi,%rdx), %edi
xorps %xmm0, %xmm0
cvtsi2ss %edi, %xmm0
movss %xmm0, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x10cae
movq %rdx, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: 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 0x8094
leaq 0xca85(%rip), %rsi      # 0x1d79d
movq %rbx, %rdi
callq 0x80f6
movq 0x18(%r14), %rdx
leaq 0xc73b(%rip), %rsi      # 0x1d466
movq %rbx, %rdi
callq 0x81d0
movq 0x20(%r14), %rdx
leaq 0xc626(%rip), %rsi      # 0x1d364
movq %rbx, %rdi
callq 0x81d0
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0xc78b(%rip), %rsi      # 0x1d4e0
movq %rbx, %rdi
callq 0x11132
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 0x10da3
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: 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 0x10e91
movq %rdi, %r14
leaq 0x164a4(%rip), %rax     # 0x272d0
leaq 0x17855(%rip), %rdx     # 0x28688
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x10e93
movq 0x18(%r14), %rcx
cmpq 0x18(%rax), %rcx
jne 0x10e91
testq %rcx, %rcx
je 0x10e9a
movq 0x10(%rax), %rax
movq 0x10(%r14), %rdx
decq %rcx
xorl %esi, %esi
movss (%rax,%rsi,4), %xmm0
movss (%rdx,%rsi,4), %xmm1
movaps %xmm0, %xmm2
cmpeqss %xmm1, %xmm2
movd %xmm2, %ebx
andl $0x1, %ebx
ucomiss %xmm1, %xmm0
jne 0x10e93
jp 0x10e93
leaq 0x1(%rsi), %rdi
cmpq %rsi, %rcx
movq %rdi, %rsi
jne 0x10e63
jmp 0x10e93
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %bl
jmp 0x10e93
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10f4b
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 0x10f36
cvttss2si %xmm0, %eax
cltq
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: 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 0x8094
leaq 0xc81e(%rip), %rsi      # 0x1d792
movq %rbx, %rdi
callq 0x80f6
movq 0x18(%r14), %rdx
leaq 0xc4df(%rip), %rsi      # 0x1d466
movq %rbx, %rdi
callq 0x81d0
movq 0x20(%r14), %rdx
leaq 0xc3ca(%rip), %rsi      # 0x1d364
movq %rbx, %rdi
callq 0x81d0
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0xc52f(%rip), %rsi      # 0x1d4e0
movq %rbx, %rdi
callq 0x11022
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 0x10fff
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, bool*, int)
void write(const char* name, bool* val, int len) {
        char str[1000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            sprintf(str, "'%d',", val[i]);
            buff->c(str);
        }
        buff->c("], ");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movl %ecx, %r14d
movq %rdx, -0x38(%rbp)
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0xc21b(%rip), %rsi      # 0x1d375
leaq -0x420(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq %rbx, -0x30(%rbp)
movq (%rbx), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x824a
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
testl %r14d, %r14d
jle 0x11200
movl %r14d, %ebx
xorl %r14d, %r14d
movq -0x38(%rbp), %rax
movzbl (%rax,%r14), %edx
movq %r12, %rdi
leaq 0xc5ea(%rip), %rsi      # 0x1d7a7
xorl %eax, %eax
callq 0x7080
movq -0x30(%rbp), %rax
movq (%rax), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x824a
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
incq %r14
cmpq %r14, %rbx
jne 0x111aa
movq -0x30(%rbp), %rax
movq (%rax), %rbx
movl $0x3, %esi
movq %rbx, %rdi
callq 0x824a
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movb $0x20, 0x2(%rax,%rcx)
movw $0x2c5d, (%rax,%rcx)    # imm = 0x2C5D
addq $0x3, 0x20(%rbx)
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: BoolDistributedArray::get(unsigned long)
bool get(size_t index) {
        assert(index < itemCount_);
        //std::cout << "in get " << index <<"\n";
        if (cache_ == nullptr) {
            init_cache_();
        }
        bool 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
            BoolArray* boolVals;
            if (cache_[key_idx] != nullptr) {
                //std::cout << "get chunk from cache\n";
                boolVals = cache_[key_idx];
            } else {
                //std::cout << "get chunk from kv\n";
                boolVals = get_chunk_from_kv_(key_idx);
            }
            res = boolVals->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 0x112f2
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
jne 0x11264
movq %r14, %rdi
callq 0x11330
movq 0x48(%r14), %rdi
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
cmpq 0x50(%r14), %rax
jne 0x1127c
movq 0x18(%r14), %rcx
jmp 0x112e0
movq %rax, %xmm0
punpckldq 0xbdd7(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xbddf(%rip), %xmm0     # 0x1d070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0xbddb(%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 0x112d8
movq %r14, %rdi
callq 0x1138a
movq %rax, %rcx
movq 0x48(%r14), %rdi
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
cmpq %rdx, 0x18(%rcx)
jbe 0x11311
movq 0x10(%rcx), %rax
movb (%rax,%rdx), %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc205(%rip), %rdi      # 0x1d4fe
leaq 0xc211(%rip), %rsi      # 0x1d511
leaq 0xc4a6(%rip), %rcx      # 0x1d7ad
movl $0x2cf, %edx            # imm = 0x2CF
callq 0x7150
leaq 0xc146(%rip), %rdi      # 0x1d45e
leaq 0xc153(%rip), %rsi      # 0x1d472
leaq 0xc432(%rip), %rcx      # 0x1d758
movl $0x23d, %edx            # imm = 0x23D
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: BoolDistributedArray::init_cache_()
void init_cache_() {
        //assuming a dataframe is immutable, so nu pushbacks after the first get call.
        cache_ = new BoolArray*[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 0x11385
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
movq 0x38(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jb 0x1136c
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: BoolDistributedArray::get_chunk_from_kv_(unsigned long)
BoolArray* 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";
        BoolArray* boolVals = new BoolArray(serlializedNode); //turns payload into IntArray object
        cache_[key_idx] = boolVals;
        cache_count_ += 1;
        return boolVals;
    }

// 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 0x113ad
movq %rbx, %rdi
callq 0x11432
movq 0x10(%rbx), %r15
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x113e0
leaq 0x15f06(%rip), %rsi     # 0x272d0
leaq 0x16417(%rip), %rdx     # 0x277e8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rsi
jmp 0x113e2
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 0x11484
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: BoolColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    BoolColumn* other_ic = dynamic_cast<BoolColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    for(int i = 0; i < val_->length(); i++) {
      BoolArray* ia = dynamic_cast<BoolArray*>(val_->get(i));
      BoolArray* other_ia = dynamic_cast<BoolArray*>(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 0x11978
movq %rdi, %rbx
leaq 0x15a51(%rip), %rax     # 0x272d0
leaq 0x16f02(%rip), %rdx     # 0x28788
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x1197b
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 0x11978
movq 0x10(%rbx), %rdi
movb $0x1, %r14b
cmpq $0x0, 0x18(%rdi)
je 0x1197b
xorl %r12d, %r12d
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x11906
movq %rax, %rdi
leaq 0x159dd(%rip), %rsi     # 0x272d0
leaq 0x16d26(%rip), %rdx     # 0x28620
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0x11909
xorl %r13d, %r13d
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x11935
movq %rax, %rdi
leaq 0x159ab(%rip), %rsi     # 0x272d0
leaq 0x16cf4(%rip), %rdx     # 0x28620
xorl %ecx, %ecx
callq 0x7280
jmp 0x11937
xorl %eax, %eax
movq 0x18(%r13), %rcx
testq %rcx, %rcx
je 0x11965
movq 0x18(%rax), %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x1198d
movq 0x10(%r13), %rdi
movb (%rdi,%rsi), %dil
movq 0x10(%rax), %r8
cmpb (%r8,%rsi), %dil
jne 0x11978
incq %rsi
cmpq %rsi, %rcx
jne 0x11946
incq %r12
movq 0x10(%rbx), %rdi
cmpq %r12, 0x18(%rdi)
ja 0x118db
jmp 0x1197b
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbaca(%rip), %rdi      # 0x1d45e
leaq 0xbad7(%rip), %rsi      # 0x1d472
leaq 0xbdb6(%rip), %rcx      # 0x1d758
movl $0x23d, %edx            # imm = 0x23D
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: BoolColumn::hash_me()
size_t hash_me() {
    size_t hash = 0;
    for(int i = 0; i < val_->length(); i++) {
      BoolArray* fa = dynamic_cast<BoolArray*>(val_->get(i));
      for(int j = 0; j < fa->length(); j++) {
        int val = 1;
        if(fa->get(j)) {
          val = 0;
        }
        hash += (i + j + val);
      }
    }
    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 0x11a45
movl $0x1, %r15d
xorl %r14d, %r14d
leaq 0x16c48(%rip), %r12     # 0x28620
xorl %r13d, %r13d
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x119ff
movq %rax, %rdi
leaq 0x158dd(%rip), %rsi     # 0x272d0
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x7280
jmp 0x11a01
xorl %eax, %eax
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x11a33
movq 0x10(%rax), %rdx
xorl %eax, %eax
movzbl (%rdx,%rax), %esi
xorq $0x1, %rsi
addq %r13, %rsi
leaq (%r14,%rax), %r13
incq %rax
addq %rsi, %r13
cmpq %rax, %rcx
jne 0x11a10
subq %r15, %rsi
addq %rax, %rsi
movq %rsi, %r13
incq %r14
movq 0x10(%rbx), %rdi
decq %r15
cmpq %r14, 0x18(%rdi)
ja 0x119db
jmp 0x11a48
xorl %r13d, %r13d
movq %r13, %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: BoolColumn::push_back(bool)
void push_back(bool val) {
    if (listLength_  >= ((arraySize_* val_->length()))) {
      val_->pushBack(new BoolArray(arraySize_));
    }
    int array_index = listLength_ / arraySize_;
    BoolArray* ba = dynamic_cast<BoolArray*>(val_->get(array_index));
    ba->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 0x11c21
movl $0x28, %edi
callq 0x7230
movq %rax, %r12
xorl %eax, %eax
movq %rax, 0x8(%r12)
leaq 0x169f0(%rip), %rcx     # 0x285e0
movq %rcx, (%r12)
movq %rax, 0x18(%r12)
movq %r13, 0x20(%r12)
movq %r13, %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 0x15699(%rip), %rsi     # 0x272d0
leaq 0x169e2(%rip), %rdx     # 0x28620
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movb %r14b, (%rcx,%rdx)
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
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: BoolDistributedArray::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_bool_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 BoolArray(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 0x156f4(%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 $0x17, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movups 0xba86(%rip), %xmm0     # 0x1d7ff
movups %xmm0, (%rax,%rcx)
movabsq $0x5f6b6e7568635f79, %rdx # imm = 0x5F6B6E7568635F79
movq %rdx, 0xf(%rax,%rcx)
addq $0x17, 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 0x15f06(%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 0x11e2a
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x28, %edi
callq 0x7230
movq %rax, %r14
movslq 0x48(%rbx), %rdi
xorl %eax, %eax
movq %rax, 0x8(%r14)
leaq 0x16798(%rip), %rcx     # 0x285e0
movq %rcx, (%r14)
movq %rax, 0x18(%r14)
movq %rdi, 0x20(%r14)
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 0x11e7d
movq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11e94
movq %rax, %rbx
movq %r15, %r14
jmp 0x11e97
movq %rax, %rbx
movq %r14, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop