LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, float*, int)
void write(const char* name, float* val, int len) {
        char str[1000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            sprintf(str, "'%f',", val[i]);
            buff->c(str);
        }
        buff->c("], ");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movl %ecx, %r14d
movq %rdx, -0x38(%rbp)
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0xbf6d(%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 0x114b2
movl %r14d, %ebx
xorl %r14d, %r14d
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%r14,4), %xmm0
movq %r12, %rdi
leaq 0xc089(%rip), %rsi      # 0x1d4f8
movb $0x1, %al
callq 0x7080
movq -0x30(%rbp), %rax
movq (%rax), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 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 0x11458
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: 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 0x116aa
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0x11622
movq %rbx, %rdi
callq 0x116e8
movq %r14, %rax
xorl %edx, %edx
divq 0x48(%rbx)
cmpq 0x50(%rbx), %rax
jne 0x11637
movq 0x18(%rbx), %rcx
jmp 0x11698
movq %rax, %xmm0
punpckldq 0xba1c(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xba24(%rip), %xmm0     # 0x1d070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0xba20(%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 0x1168f
movq %rbx, %rdi
callq 0x11746
movq %rax, %rcx
movq %r14, %rax
xorl %edx, %edx
divq 0x48(%rbx)
cmpq %rdx, 0x18(%rcx)
jbe 0x116c9
movq 0x10(%rcx), %rax
movb (%rax,%rdx), %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbe4d(%rip), %rdi      # 0x1d4fe
leaq 0xbe59(%rip), %rsi      # 0x1d511
leaq 0xc0ee(%rip), %rcx      # 0x1d7ad
movl $0x2cf, %edx            # imm = 0x2CF
callq 0x7150
leaq 0xbd8e(%rip), %rdi      # 0x1d45e
leaq 0xbd9b(%rip), %rsi      # 0x1d472
leaq 0xc07a(%rip), %rcx      # 0x1d758
movl $0x23d, %edx            # imm = 0x23D
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O1/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 %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 0x1173e
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
movq 0x38(%rbx), %rcx
cmpq 0x18(%rcx), %rax
jb 0x11725
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: 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 0x11769
movq %rbx, %rdi
callq 0x117ee
movq 0x10(%rbx), %r15
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x1179c
leaq 0x16ac2(%rip), %rsi     # 0x28248
leaq 0x1705b(%rip), %rdx     # 0x287e8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rsi
jmp 0x1179e
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 0x11840
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: 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 0x11d81
movq %rdi, %rbx
leaq 0x165c5(%rip), %rax     # 0x28248
leaq 0x17afe(%rip), %rdx     # 0x29788
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x11d84
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 0x11d81
movq 0x10(%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
sete %r14b
je 0x11d84
xorl %r12d, %r12d
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x11d0b
movq %rax, %rdi
leaq 0x16550(%rip), %rsi     # 0x28248
leaq 0x17921(%rip), %rdx     # 0x29620
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0x11d0e
xorl %r13d, %r13d
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x11d3a
movq %rax, %rdi
leaq 0x1651e(%rip), %rsi     # 0x28248
leaq 0x178ef(%rip), %rdx     # 0x29620
xorl %ecx, %ecx
callq 0x7280
jmp 0x11d3c
xorl %eax, %eax
movq 0x18(%r13), %rcx
testq %rcx, %rcx
je 0x11d6a
movq 0x18(%rax), %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x11d9a
movq 0x10(%r13), %rdi
movb (%rdi,%rsi), %dil
movq 0x10(%rax), %r8
cmpb (%r8,%rsi), %dil
jne 0x11d84
incq %rsi
cmpq %rsi, %rcx
jne 0x11d4b
incq %r12
movq 0x10(%rbx), %rdi
cmpq %r12, 0x18(%rdi)
setbe %r14b
ja 0x11ce0
jmp 0x11d84
xorl %r14d, %r14d
andb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb6bd(%rip), %rdi      # 0x1d45e
leaq 0xb6ca(%rip), %rsi      # 0x1d472
leaq 0xb9a9(%rip), %rcx      # 0x1d758
movl $0x23d, %edx            # imm = 0x23D
callq 0x7150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11e53
movl $0x1, %r15d
xorl %r14d, %r14d
leaq 0x1783a(%rip), %r12     # 0x29620
xorl %r13d, %r13d
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x11e0d
movq %rax, %rdi
leaq 0x16447(%rip), %rsi     # 0x28248
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x7280
jmp 0x11e0f
xorl %eax, %eax
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x11e41
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 0x11e1e
subq %r15, %rsi
addq %rax, %rsi
movq %rsi, %r13
incq %r14
movq 0x10(%rbx), %rdi
decq %r15
cmpq %r14, 0x18(%rdi)
ja 0x11de9
jmp 0x11e56
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_O1/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
movslq 0x1c(%rdi), %r13
movq 0x10(%rdi), %r15
movq 0x18(%r15), %rcx
imulq %r13, %rcx
cmpq %rax, %rcx
ja 0x12023
movl $0x28, %edi
callq 0x7230
movq %rax, %r12
xorl %eax, %eax
movq %rax, 0x8(%r12)
leaq 0x175e4(%rip), %rcx     # 0x295e0
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
cltd
idivl 0x1c(%rbx)
movq 0x10(%rbx), %rdi
movslq %eax, %rsi
movq (%rdi), %rax
callq *0x40(%rax)
leaq 0x1620a(%rip), %rsi     # 0x28248
leaq 0x175db(%rip), %rdx     # 0x29620
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x162d4(%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 $0x17, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movups 0xb69e(%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 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 0x16b1e(%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 0x12212
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 0x173b0(%rip), %rcx     # 0x295e0
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 0x12265
movq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1227c
movq %rax, %rbx
movq %r15, %r14
jmp 0x1227f
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: FloatDistributedArray::FloatDistributedArray(KVStore*)
FloatDistributedArray(KVStore* kv) {
        kv_ = kv;
        totalNodes_ = kv->num_nodes_;
        srand(time(nullptr));
        uid_ = rand();
        curNode_ = 0;
        itemCount_ = 0;
        chunkCount_ = 0;
        keys_ = new Array();
        chunkArray_ = new FloatArray(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 0x17605(%rip), %rax     # 0x298b0
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 0x16413(%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 0x172fb(%rip), %rcx     # 0x29648
movq %rcx, (%r14)
movq %r15, 0x18(%r14)
cltq
movq %rax, 0x20(%r14)
leaq (,%rax,4), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x7030
movq %rax, 0x10(%r14)
movq %r14, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12389
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: DistributedFloatColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    DistributedFloatColumn* other_ic = dynamic_cast<DistributedFloatColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    FloatDistributedArray* other_val_ = dynamic_cast<FloatDistributedArray*>(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 0x12416
movq %rdi, %rbx
leaq 0x15e89(%rip), %rax     # 0x28248
leaq 0x174c2(%rip), %rdx     # 0x29888
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x12416
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 0x12416
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: DistributedFloatColumn::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("DistributedFloatColumn");
    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 0xb401(%rip), %rsi      # 0x1d85b
movq %rbx, %rdi
callq 0x810c
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xaf85(%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 0x124c6
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: DistributedFloatColumn::getColumnOnNode()
Column* getColumnOnNode() override {
    size_t _node = kv_->this_node_;
    FloatColumn* col = new FloatColumn();
    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;
        FloatArray* chunk = dynamic_cast<FloatArray*>(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) {
      FloatArray* 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 0x12ebc
movq 0x18(%r13), %rax
movq 0x38(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0x12640
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 0x15ca2(%rip), %rsi     # 0x28248
leaq 0x1623b(%rip), %rdx     # 0x287e8
xorl %ecx, %ecx
callq 0x7280
cmpq %r12, 0x18(%rax)
jne 0x12633
movq 0x10(%r13), %rdi
movq %rax, %rsi
callq 0xc02e
movq 0x10(%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x14b60
testq %rax, %rax
je 0x125f5
movq %rax, %rdi
leaq 0x15c66(%rip), %rsi     # 0x28248
leaq 0x1709f(%rip), %rdx     # 0x29688
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0x125f8
xorl %r13d, %r13d
cmpq $0x0, 0x18(%r13)
je 0x12621
xorl %r12d, %r12d
movq 0x10(%r13), %rax
movss (%rax,%r12,4), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xb0(%rax)
incq %r12
cmpq 0x18(%r13), %r12
jb 0x12602
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
incq %r15
cmpq 0x18(%r14), %r15
jb 0x1258b
testq %r12, %r12
jne 0x12676
movq 0x18(%r13), %rax
movq 0x18(%rax), %r14
cmpq $0x0, 0x18(%r14)
je 0x12676
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movss (%rax,%r15,4), %xmm0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xb0(%rax)
incq %r15
cmpq 0x18(%r14), %r15
jb 0x12657
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: FloatDistributedArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        FloatDistributedArray *s = dynamic_cast<FloatDistributedArray*>(o);
        if(s == nullptr) return false;
        if(itemCount_ != s->itemCount_) return false;
        for(int i = 0; i < itemCount_; i++) {
            bool sameInt = s->get(i) == get(i);
            if(!sameInt) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x127a7
movq %rdi, %rbx
leaq 0x15b36(%rip), %rax     # 0x28248
leaq 0x171d7(%rip), %rdx     # 0x298f0
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x127aa
movq %rax, %r15
movq 0x58(%rbx), %rax
cmpq 0x58(%r15), %rax
jne 0x127a7
cmpq $0x0, 0x58(%rbx)
sete %r14b
je 0x127aa
movq %r15, %rdi
xorl %esi, %esi
callq 0x1294e
movss %xmm0, -0x24(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1294e
movss -0x24(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jne 0x127aa
jp 0x127aa
movl $0x1, %r12d
cmpq %r12, 0x58(%rbx)
setbe %r14b
jbe 0x127aa
movq %r15, %rdi
movq %r12, %rsi
callq 0x1294e
movss %xmm0, -0x24(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1294e
incq %r12
movss -0x24(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jne 0x127aa
jnp 0x12771
jmp 0x127aa
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: FloatDistributedArray::get_chunk_from_kv_(unsigned long)
FloatArray* 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";
        FloatArray* doubleVals = new FloatArray(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 0x12abd
movq %rbx, %rdi
callq 0x12b42
movq 0x10(%rbx), %r15
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x12af0
leaq 0x1576e(%rip), %rsi     # 0x28248
leaq 0x15d07(%rip), %rdx     # 0x287e8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rsi
jmp 0x12af2
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 0x12b94
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: FloatColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    FloatColumn* other_ic = dynamic_cast<FloatColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    for(int i = 0; i < val_->length(); i++) {
      FloatArray* ia = dynamic_cast<FloatArray*>(val_->get(i));
      FloatArray* other_ia = dynamic_cast<FloatArray*>(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 0x130ec
movq %rdi, %rbx
leaq 0x1525d(%rip), %rax     # 0x28248
leaq 0x169fe(%rip), %rdx     # 0x299f0
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x130ef
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 0x130ec
movq 0x10(%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
sete %r14b
je 0x130ef
xorl %r12d, %r12d
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x13073
movq %rax, %rdi
leaq 0x151e8(%rip), %rsi     # 0x28248
leaq 0x16621(%rip), %rdx     # 0x29688
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r13
jmp 0x13076
xorl %r13d, %r13d
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x130a2
movq %rax, %rdi
leaq 0x151b6(%rip), %rsi     # 0x28248
leaq 0x165ef(%rip), %rdx     # 0x29688
xorl %ecx, %ecx
callq 0x7280
jmp 0x130a4
xorl %eax, %eax
movq 0x18(%r13), %rcx
testq %rcx, %rcx
je 0x130d5
movq 0x18(%rax), %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x13105
movq 0x10(%r13), %rdi
movss (%rdi,%rsi,4), %xmm0
movq 0x10(%rax), %rdi
ucomiss (%rdi,%rsi,4), %xmm0
jne 0x130ef
jp 0x130ef
incq %rsi
cmpq %rsi, %rcx
jne 0x130b3
incq %r12
movq 0x10(%rbx), %rdi
cmpq %r12, 0x18(%rdi)
setbe %r14b
ja 0x13048
jmp 0x130ef
xorl %r14d, %r14d
andb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa352(%rip), %rdi      # 0x1d45e
leaq 0xa35f(%rip), %rsi      # 0x1d472
leaq 0xa65a(%rip), %rcx      # 0x1d774
movl $0x1d0, %edx            # imm = 0x1D0
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: FloatColumn::hash_me()
size_t hash_me() {
    float hash = 0;
    for(int i = 0; i < val_->length(); i++) {
      FloatArray* fa = dynamic_cast<FloatArray*>(val_->get(i));
      for(int j = 0; j < fa->length(); j++) {
        hash += fa->get(j);
      }
    }
    return ((size_t)hash);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x131cd
xorps %xmm0, %xmm0
xorl %r14d, %r14d
leaq 0x150f6(%rip), %r15     # 0x28248
leaq 0x1652f(%rip), %r12     # 0x29688
movaps %xmm0, -0x30(%rbp)
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x1317d
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x7280
jmp 0x1317f
xorl %eax, %eax
movq 0x18(%rax), %rcx
testq %rcx, %rcx
movaps -0x30(%rbp), %xmm0
je 0x1319f
movq 0x10(%rax), %rax
xorl %edx, %edx
addss (%rax,%rdx,4), %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x13192
incq %r14
movq 0x10(%rbx), %rdi
cmpq %r14, 0x18(%rdi)
ja 0x13159
cvttss2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subss 0x9ec4(%rip), %xmm0     # 0x1d084
cvttss2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
jmp 0x131cf
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: FloatColumn::push_back(float)
void push_back(float val) {
    if (listLength_  >= ((arraySize_* val_->length()))) {
      val_->pushBack(new FloatArray(arraySize_));
    }
    int array_index = listLength_ / arraySize_;
    FloatArray* fa = dynamic_cast<FloatArray*>(val_->get(array_index));
    fa->pushBack(val);
    listLength_++;

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, -0x24(%rbp)
movq %rdi, %rbx
movslq 0x18(%rdi), %rax
movslq 0x1c(%rdi), %r12
movq 0x10(%rdi), %r14
movq 0x18(%r14), %rcx
imulq %r12, %rcx
cmpq %rax, %rcx
ja 0x133ad
movl $0x28, %edi
callq 0x7230
movq %rax, %r15
xorl %eax, %eax
movq %rax, 0x8(%r15)
leaq 0x162d0(%rip), %rcx     # 0x29648
movq %rcx, (%r15)
movq %rax, 0x18(%r15)
movq %r12, 0x20(%r15)
movq %r12, %rax
shlq $0x2, %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x7030
movq %rax, 0x10(%r15)
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x58(%rax)
movl 0x18(%rbx), %eax
cltd
idivl 0x1c(%rbx)
movq 0x10(%rbx), %rdi
movslq %eax, %rsi
movq (%rdi), %rax
callq *0x40(%rax)
leaq 0x14e80(%rip), %rsi     # 0x28248
leaq 0x162b9(%rip), %rdx     # 0x29688
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movss -0x24(%rbp), %xmm0
movss %xmm0, (%rcx,%rdx,4)
incq %rdx
movq %rdx, 0x18(%rax)
incl 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: FloatDistributedArray::pushBack(float)
void pushBack(float 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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq 0x48(%rdi)
testq %rcx, %rcx
je 0x13466
testq %rdx, %rdx
jne 0x13466
movq %rbx, %rdi
movss %xmm0, -0xc(%rbp)
callq 0x1348a
movss -0xc(%rbp), %xmm0
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movss %xmm0, (%rcx,%rdx,4)
incq %rdx
movq %rdx, 0x18(%rax)
incq 0x58(%rbx)
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: FloatDistributedArray::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_float_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 FloatArray(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 0x14f42(%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 $0x18, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movups 0xa37f(%rip), %xmm0     # 0x1d872
movups %xmm0, (%rax,%rcx)
movabsq $0x5f6b6e7568635f79, %rdx # imm = 0x5F6B6E7568635F79
movq %rdx, 0x10(%rax,%rcx)
addq $0x18, 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 0x1578c(%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 0x135a4
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 0x16086(%rip), %rdx     # 0x29648
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 0x1360e
movq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13625
movq %rax, %rbx
movq %r15, %r14
jmp 0x13628
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/schema.h
// Function: Schema::add_column(char, String*)
void add_column(char typ, String* name) {
        if (this->empty_index_ == this->capacity_) {
            resize_();
        }
        if (this->valid_col_char_(typ)) {
            //set the typ for the new column if valid.
            this->val_[this->empty_index_] = typ;
            if (name != nullptr) {
                if (this->col_name_idx->get(name) == nullptr) {
                    Integer* i = new Integer(this->empty_index_);
                    this->col_name_idx->add(name, i);
                    this->col_idx_name->add(i, name);
                }
            }
            //bump up the empty index
            this->empty_index_ += 1;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x10(%rdi), %rax
jne 0x1365d
movq %rbx, %rdi
callq 0x136e8
movsbl %r15b, %eax
addl $-0x42, %eax
cmpl $0x11, %eax
ja 0x136dd
movl $0x20095, %ecx          # imm = 0x20095
btl %eax, %ecx
jae 0x136dd
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movb %r15b, (%rax,%rcx)
testq %r14, %r14
je 0x136d9
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xa6de
testq %rax, %rax
jne 0x136d9
movl $0x18, %edi
callq 0x7230
movq %rax, %r15
movl 0x20(%rbx), %eax
movq $0x0, 0x8(%r15)
leaq 0x157bc(%rip), %rcx     # 0x28e70
movq %rcx, (%r15)
movl %eax, 0x10(%r15)
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xaa76
movq 0x40(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xaa76
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::resize_()
void resize_() {
        size_t len = this->capacity_;
        //double size.
        len = this->capacity_ * 2;
        //create a new array that has double the size.
        char *copy_ = new char[len + 1];
        
        //copy over elements one by one.
        for (size_t i = 0; i < this->capacity_; i++) {
            copy_[i] = this->val_[i];
        }
        
        //need to free the array.
        delete[] this->val_;
        //need to get old pointer to point to new array. 
        this->val_ = copy_;

        //double the length.
        this->capacity_ = len;

        //null terminate.
        this->val_[capacity_] = '\0';
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r15
leaq 0x1(,%r15,2), %rdi
callq 0x7030
movq %rax, %r14
testq %r15, %r15
je 0x13723
movq 0x18(%rbx), %rax
xorl %ecx, %ecx
movb (%rax,%rcx), %dl
movb %dl, (%r14,%rcx)
incq %rcx
cmpq %rcx, %r15
jne 0x13714
addq %r15, %r15
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x13734
callq 0x72b0
movq %r14, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movb $0x0, (%r14,%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./network.h
// Function: Put::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Put");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        char* serializedKey = key_->serialize();
        sb->write("key_", serializedKey, false);
        char* serializedValue = value_->serialize();
        sb->write("value_", serializedValue, 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 0x9d91(%rip), %rsi      # 0x1d8d5
movq %rbx, %rdi
callq 0x810c
movl 0x10(%r14), %edx
leaq 0x971f(%rip), %rsi      # 0x1d276
movq %rbx, %rdi
callq 0x8178
movq 0x18(%r14), %rdx
leaq 0x9712(%rip), %rsi      # 0x1d27c
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0x9707(%rip), %rsi      # 0x1d284
movq %rbx, %rdi
callq 0x81e6
movq 0x28(%r14), %rdx
leaq 0x9a32(%rip), %rsi      # 0x1d5c2
movq %rbx, %rdi
callq 0x81e6
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x984a(%rip), %rsi      # 0x1d3f3
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa9d0
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x9d12(%rip), %rsi      # 0x1d8d9
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 0x13c1a
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/./network.h
// Function: Reply::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Reply");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        if(JSONHelper::isObject(reply_msg_)) {
            sb->write("msg_", reply_msg_, false);
        } else {
            sb->write("msg_", reply_msg_);
        }
        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 0x9c34(%rip), %rsi      # 0x1d8e0
movq %rbx, %rdi
callq 0x810c
movl 0x10(%r14), %edx
leaq 0x95b7(%rip), %rsi      # 0x1d276
movq %rbx, %rdi
callq 0x8178
movq 0x18(%r14), %rdx
leaq 0x95aa(%rip), %rsi      # 0x1d27c
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0x959f(%rip), %rsi      # 0x1d284
movq %rbx, %rdi
callq 0x81e6
movq 0x28(%r14), %rdx
leaq 0x98ca(%rip), %rsi      # 0x1d5c2
movq %rbx, %rdi
callq 0x81e6
movq 0x30(%r14), %rdi
callq 0xcdac
movq 0x30(%r14), %rdx
leaq 0xa274(%rip), %rsi      # 0x1df88
movq %rbx, %rdi
testb %al, %al
je 0x13d24
xorl %ecx, %ecx
callq 0xa9d0
jmp 0x13d29
callq 0x8576
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 0x13d6f
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/./network.h
// Function: WaitAndGet::equals(Object*)
bool equals(Object* other) {
        if (other == this) return true;
        WaitAndGet* x = dynamic_cast<WaitAndGet *>(other);
        if (x == nullptr) return false;
        return this->key_->equals(x->key_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq %rdi, %rsi
je 0x13dcc
movq %rdi, %rbx
testq %rsi, %rsi
je 0x13dd0
leaq 0x14492(%rip), %rax     # 0x28248
leaq 0x15cb3(%rip), %rdx     # 0x29a70
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
jmp 0x13dd2
movb $0x1, %al
jmp 0x13df0
xorl %eax, %eax
testq %rax, %rax
je 0x13dee
movq 0x30(%rbx), %rdi
movq 0x30(%rax), %rsi
movq (%rdi), %rax
movq 0x18(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::get_double(unsigned long, unsigned long)
int get_double(size_t col, size_t row) {
      assert(col < this->schema_->width());
      char col_type = this->schema_->col_type(col);
      assert(col_type == 'D');
      //std::cout<< "get_double: " << this->cols_->get(col) << "\n";
      DistributedDoubleColumn* doubCol = dynamic_cast<DistributedDoubleColumn*>(this->cols_->get(col));
      //std::cout << "get_double row: " << row << "length: "<< schema_->length() << "\n";
      assert(row < this->schema_->length());
      return doubCol->get(row);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rax
cmpq %rsi, 0x20(%rax)
jbe 0x141c5
movq 0x18(%rax), %rax
cmpb $0x44, (%rax,%rsi)
jne 0x141e4
movq %rdx, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
je 0x141a4
leaq 0x140b7(%rip), %rsi     # 0x28248
leaq 0x14990(%rip), %rdx     # 0x28b28
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
jmp 0x141a6
xorl %eax, %eax
movq 0x10(%r14), %rcx
cmpq %rbx, 0x28(%rcx)
jbe 0x14203
movq 0x18(%rax), %rdi
movq %rbx, %rsi
callq 0xbde8
cvttsd2si %xmm0, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9774(%rip), %rdi      # 0x1d940
leaq 0x978a(%rip), %rsi      # 0x1d95d
leaq 0x97b8(%rip), %rcx      # 0x1d992
movl $0xac, %edx
callq 0x7150
leaq 0x97dc(%rip), %rdi      # 0x1d9c7
leaq 0x976b(%rip), %rsi      # 0x1d95d
leaq 0x9799(%rip), %rcx      # 0x1d992
movl $0xae, %edx
callq 0x7150
leaq 0x97cd(%rip), %rdi      # 0x1d9d7
leaq 0x974c(%rip), %rsi      # 0x1d95d
leaq 0x977a(%rip), %rcx      # 0x1d992
movl $0xb2, %edx
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::fromScalar(Key*, KVStore*, int)
static DistributedDataFrame* fromScalar(Key* key, KVStore* kv, int scalar) {
      Schema* s = new Schema(); 
      DistributedIntColumn* dc = new DistributedIntColumn(kv);
      s->add_row(nullptr);
      dc->push_back(scalar);
      DistributedDataFrame* df = new DistributedDataFrame(*s, kv);
      df->add_column(dc, nullptr);
      char* serialized = df->serialize();
      Value* val = new Value(serialized, (size_t)0);
      kv->put(key, val);
      return df;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movl $0x50, %edi
callq 0x7230
movq %rax, %r15
movq %rax, %rdi
callq 0x9776
movl $0x20, %edi
callq 0x7230
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0xdbd6
movq %rbx, -0x30(%rbp)
incq 0x28(%r15)
movq (%r13), %rax
movq %r13, %rdi
movl %r12d, %esi
callq *0x98(%rax)
movl $0x28, %edi
callq 0x7230
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x9896
xorl %ebx, %ebx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x9a2e
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %rax, %r15
movl $0x20, %edi
callq 0x7230
movq %rbx, 0x8(%rax)
leaq 0x14a3e(%rip), %rcx     # 0x28d08
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x9bbe
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %r15
jmp 0x14309
movq %rax, %rbx
movq %r13, %r15
jmp 0x14309
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/distributedDataframe.h
// Function: DistributedDataFrame::get_int(unsigned long, unsigned long)
int get_int(size_t col, size_t row) {
      assert(col < this->schema_->width());
      char col_type = this->schema_->col_type(col);
      assert(col_type == 'I');
      DistributedIntColumn* intCol = dynamic_cast<DistributedIntColumn*>(this->cols_->get(col));
      assert(row < this->schema_->length());
      return intCol->get(row);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rax
cmpq %rsi, 0x20(%rax)
jbe 0x143ec
movq 0x18(%rax), %rax
cmpb $0x49, (%rax,%rsi)
jne 0x1440b
movq %rdx, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
je 0x143d0
leaq 0x13e8b(%rip), %rsi     # 0x28248
leaq 0x14c54(%rip), %rdx     # 0x29018
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
jmp 0x143d2
xorl %eax, %eax
movq 0x10(%r14), %rcx
cmpq %rbx, 0x28(%rcx)
jbe 0x1442a
movq 0x18(%rax), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xe596
leaq 0x954d(%rip), %rdi      # 0x1d940
leaq 0x9563(%rip), %rsi      # 0x1d95d
leaq 0x9610(%rip), %rcx      # 0x1da11
movl $0xa1, %edx
callq 0x7150
leaq 0x9631(%rip), %rdi      # 0x1da43
leaq 0x9544(%rip), %rsi      # 0x1d95d
leaq 0x95f1(%rip), %rcx      # 0x1da11
movl $0xa3, %edx
callq 0x7150
leaq 0x95a6(%rip), %rdi      # 0x1d9d7
leaq 0x9525(%rip), %rsi      # 0x1d95d
leaq 0x95d2(%rip), %rcx      # 0x1da11
movl $0xa5, %edx
callq 0x7150
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::listen()
void listen() {
        std::cout << "started listening on separate thread\n";
        //listen for any incoming requests to the store.
        while (true) {
            Message* message = network_->recv_msg(this);
            //std::cout << "incoming message\n";
            process_message_(message);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x15b22(%rip), %rdi     # 0x29fd0
leaq 0x959e(%rip), %rsi      # 0x1da53
movl $0x25, %edx
callq 0x7290
movq 0x50(%rbx), %rdi
movq %rbx, %rsi
callq 0x1456a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14630
jmp 0x144bf