LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq 0x10(%rdi), %rax
movq 0x18(%rax), %r14
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x10462
movq 0x18(%r12), %rax
movq 0x38(%rax), %r13
xorl %r15d, %r15d
movq %r12, -0x40(%rbp)
movq %r13, -0x38(%rbp)
cmpq 0x18(%r13), %r15
jae 0xf810
movq 0x18(%r12), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
movq %rax, %rdi
leaq 0x13b2d(%rip), %rsi     # 0x232a8
leaq 0x1404e(%rip), %rdx     # 0x237d0
xorl %ecx, %ecx
callq 0x72a0
cmpq %r14, 0x18(%rax)
jne 0xf808
movq 0x10(%r12), %rdi
movq %rax, %rsi
callq 0xb84a
movq 0x10(%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x12f4c
testq %rax, %rax
je 0xf7cb
movq %rax, %rdi
leaq 0x13af0(%rip), %rsi     # 0x232a8
leaq 0x14e49(%rip), %rdx     # 0x24608
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r13
jmp 0xf7ce
xorl %r13d, %r13d
xorl %r12d, %r12d
cmpq 0x18(%r13), %r12
jae 0xf7f6
movq %r13, %rdi
movq %r12, %rsi
callq 0xfcb6
movq (%rbx), %rcx
movzbl %al, %esi
movq %rbx, %rdi
callq *0xa8(%rcx)
incq %r12
jmp 0xf7d1
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
incq %r15
jmp 0xf755
testq %r14, %r14
je 0xf827
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r12), %rax
movq 0x18(%rax), %r14
xorl %r15d, %r15d
cmpq 0x18(%r14), %r15
jae 0xf815
movq %r14, %rdi
movq %r15, %rsi
callq 0xfcb6
movq (%rbx), %rcx
movzbl %al, %esi
movq %rbx, %rdi
callq *0xa8(%rcx)
incq %r15
jmp 0xf833
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xf96a
movq %rdi, %rbx
leaq 0x13997(%rip), %rax     # 0x232a8
leaq 0x14c88(%rip), %rdx     # 0x245a0
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xf96d
movq %rax, %r15
movq 0x58(%rbx), %rax
cmpq 0x58(%r15), %rax
jne 0xf96a
xorl %r12d, %r12d
cmpq %r12, 0x58(%rbx)
setbe %r14b
jbe 0xf96d
movq %r15, %rdi
movq %r12, %rsi
callq 0x10094
movl %eax, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10094
incq %r12
cmpb %al, %r13b
je 0xf93d
jmp 0xf96d
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xfb7a
movq %rdi, %rbx
leaq 0x13787(%rip), %rax     # 0x232a8
leaq 0x14ae0(%rip), %rdx     # 0x24608
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xfb7d
movq %rax, %r15
movq 0x18(%rbx), %rax
cmpq 0x18(%r15), %rax
jne 0xfb7a
xorl %r12d, %r12d
cmpq %r12, 0x18(%rbx)
setbe %r14b
jbe 0xfb7d
movq %r15, %rdi
movq %r12, %rsi
callq 0xfcb6
movl %eax, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xfcb6
incq %r12
cmpb %al, %r13b
je 0xfb4d
jmp 0xfb7d
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0xfce8
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xfbdd
movsbl (%rax,%rdx), %esi
cvtsi2ss %esi, %xmm0
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdi
movss %xmm0, (%rsi,%rdi,4)
incq %rdi
movq %rdi, 0x18(%rbx)
incq %rdx
jmp 0xfbb7
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0x8b76(%rip), %rsi      # 0x187a2
movq %rbx, %rdi
callq 0x7fd8
movq 0x18(%r14), %rdx
leaq 0x882c(%rip), %rsi      # 0x1846b
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0x8717(%rip), %rsi      # 0x18369
movq %rbx, %rdi
callq 0x8062
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0x887c(%rip), %rsi      # 0x184e5
movq %rbx, %rdi
callq 0xfffa
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xfc92
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0xfdde
movq %rdi, %rbx
leaq 0x1352c(%rip), %rax     # 0x232a8
leaq 0x148ed(%rip), %rdx     # 0x24670
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xfde1
movq %rax, %r15
movq 0x18(%rbx), %rax
cmpq 0x18(%r15), %rax
jne 0xfdde
xorl %r12d, %r12d
cmpq %r12, 0x18(%rbx)
setbe %r14b
jbe 0xfde1
movq %r15, %rdi
movq %r12, %rsi
callq 0xff2e
movss %xmm0, -0x24(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xff2e
incq %r12
movss -0x24(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jne 0xfde1
jnp 0xfda8
jmp 0xfde1
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
xorps %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xfe78
mulss (%rax,%rdx,4), %xmm0
incq %rdx
jmp 0xfe69
cvttss2si %xmm0, %eax
cltq
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0x88f3(%rip), %rsi      # 0x18797
movq %rbx, %rdi
callq 0x7fd8
movq 0x18(%r14), %rdx
leaq 0x85b4(%rip), %rsi      # 0x1846b
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0x849f(%rip), %rsi      # 0x18369
movq %rbx, %rdi
callq 0x8062
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0x8604(%rip), %rsi      # 0x184e5
movq %rbx, %rdi
callq 0xff62
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xff0a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x3e8, %rsp            # imm = 0x3E8
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
leaq 0x83f2(%rip), %rsi      # 0x1837a
xorl %r13d, %r13d
leaq -0x410(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
testl %ebx, %ebx
cmovlel %r13d, %ebx
cmpq %r13, %rbx
je 0xffd9
cvtss2sd (%r14,%r13,4), %xmm0
movq %r12, %rdi
leaq 0x853b(%rip), %rsi      # 0x184fd
movb $0x1, %al
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
incq %r13
jmp 0xffad
movq (%r15), %rdi
leaq 0x83a5(%rip), %rsi      # 0x18388
callq 0x8114
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x3e8, %rsp            # imm = 0x3E8
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
leaq 0x835a(%rip), %rsi      # 0x1837a
xorl %r13d, %r13d
leaq -0x410(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
testl %ebx, %ebx
cmovlel %r13d, %ebx
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x10073
movzbl (%r14,%r13), %edx
movq %r12, %rdi
leaq 0x8750(%rip), %rsi      # 0x187ac
xorl %eax, %eax
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
incq %r13
jmp 0x10048
movq (%r15), %rdi
leaq 0x830b(%rip), %rsi      # 0x18388
callq 0x8114
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10142
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
jne 0x100ba
movq %r14, %rdi
callq 0x10162
movq 0x48(%r14), %rcx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
cmpq 0x50(%r14), %rax
jne 0x100d2
movq 0x18(%r14), %rdi
jmp 0x1012e
movq %rax, %xmm0
punpckldq 0x7f81(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x7f89(%rip), %xmm0     # 0x18070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
subsd 0x7f85(%rip), %xmm1     # 0x18088
sarq $0x3f, %rdx
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rax, %rsi
movq 0x20(%r14), %rax
movq (%rax,%rsi,8), %rdi
testq %rdi, %rdi
jne 0x1012e
movq %r14, %rdi
callq 0x101c6
movq %rax, %rdi
movq 0x48(%r14), %rcx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xfcb6
leaq 0x83ba(%rip), %rdi      # 0x18503
leaq 0x83c6(%rip), %rsi      # 0x18516
leaq 0x865b(%rip), %rcx      # 0x187b2
movl $0x2cf, %edx            # imm = 0x2CF
callq 0x7170
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x18(%rax), %r15
movq %r15, %rax
shrq $0x3d, %rax
leaq (,%r15,8), %rcx
xorl %r14d, %r14d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x7030
movq %rax, 0x20(%rbx)
cmpq %r15, %r14
jae 0x101bb
movq 0x20(%rbx), %rax
andq $0x0, (%rax,%r14,8)
incq %r14
movq 0x38(%rbx), %rax
movq 0x18(%rax), %r15
jmp 0x101a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x101e9
movq %rbx, %rdi
callq 0x1026c
movq 0x10(%rbx), %r15
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x1021c
leaq 0x130a2(%rip), %rsi     # 0x232a8
leaq 0x135c3(%rip), %rdx     # 0x237d0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %rsi
jmp 0x1021e
xorl %esi, %esi
movq %r15, %rdi
callq 0xb84a
movq 0x10(%rax), %r12
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x102ae
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 0x7220
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: BoolArray::BoolArray(char*)
BoolArray(char* serialized) {
        char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
        this->arraySize_ = std::stoi(JSONHelper::getValueFromKey("arraySize_", payload)->c_str());
        this->listLength_ = std::stoi(JSONHelper::getValueFromKey("listLength_", payload)->c_str());
        char* vals = JSONHelper::getValueFromKey("vals_", payload)->c_str();
        BoolArray* ia = new BoolArray(this->listLength_);
         for(int i = 0; i < this->listLength_; i++) {
             ia->pushBack(std::stoi(JSONHelper::getArrayValueAt(vals, i)->c_str()));
         }
        //delete ia;
        this->vals_ = ia->vals_;
     }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
andq $0x0, 0x8(%rdi)
leaq 0x142fd(%rip), %rax     # 0x245c8
movq %rax, (%rdi)
movq %rdi, -0x38(%rbp)
andq $0x0, 0x18(%rdi)
movq %rsi, %rdi
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x8077(%rip), %rdi      # 0x18369
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x58(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq -0x38(%rbp), %rcx
movq %rax, 0x20(%rcx)
leaq -0x58(%rbp), %rdi
callq 0x7120
leaq 0x8130(%rip), %rdi      # 0x1846b
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x58(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq -0x38(%rbp), %rbx
movq %rax, 0x18(%rbx)
leaq -0x58(%rbp), %rdi
callq 0x7120
leaq 0x8161(%rip), %rdi      # 0x184e5
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r15
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movl 0x18(%rbx), %esi
movq %rax, %rdi
callq 0xf8b6
xorl %r12d, %r12d
leaq -0x58(%rbp), %r13
pushq $0xa
popq %rbx
movq -0x38(%rbp), %rax
cmpq %r12, 0x18(%rax)
jbe 0x10413
movq %r15, %rdi
movl %r12d, %esi
callq 0xc4c8
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r13, %rdi
movq %rax, %rsi
leaq -0x29(%rbp), %rdx
callq 0x70f0
movq %r13, %rdi
xorl %esi, %esi
movl %ebx, %edx
callq 0x771e
testl %eax, %eax
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
setne (%rax,%rcx)
incq %rcx
movq %rcx, 0x18(%r14)
movq %r13, %rdi
callq 0x7120
incq %r12
jmp 0x103b8
movq 0x10(%r14), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x10(%rcx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
jmp 0x1045a
jmp 0x10447
jmp 0x10457
jmp 0x10447
jmp 0x10457
jmp 0x10457
jmp 0x10457
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x7120
jmp 0x1045a
jmp 0x10457
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
testq %rsi, %rsi
je 0x10643
movq %rdi, %r12
leaq 0x12d6e(%rip), %rax     # 0x232a8
leaq 0x1422f(%rip), %rdx     # 0x24770
xorl %r15d, %r15d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0x10646
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0xc8(%rax)
movq %rax, %rbx
movq (%r12), %rax
movq %r12, %rdi
callq *0xc8(%rax)
cmpq %rax, %rbx
jne 0x10643
xorl %ebx, %ebx
leaq 0x12d1d(%rip), %r15     # 0x232a8
leaq 0x14076(%rip), %r13     # 0x24608
movq %r12, -0x30(%rbp)
movq 0x10(%r12), %rdi
cmpq %rbx, 0x18(%rdi)
jbe 0x10658
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x105c8
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r12
jmp 0x105cb
xorl %r12d, %r12d
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x40(%rax)
testq %rax, %rax
movq %rbx, -0x38(%rbp)
je 0x105f6
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r13
jmp 0x105f9
xorl %r13d, %r13d
xorl %ebx, %ebx
cmpq %rbx, 0x18(%r12)
jbe 0x10625
movq %r12, %rdi
movq %rbx, %rsi
callq 0xfcb6
movl %eax, %r15d
movq %r13, %rdi
movq %rbx, %rsi
callq 0xfcb6
incq %rbx
cmpb %al, %r15b
je 0x105fb
jmp 0x10643
movq -0x38(%rbp), %rbx
incq %rbx
movq -0x30(%rbp), %r12
leaq 0x12c71(%rip), %r15     # 0x232a8
leaq 0x13fca(%rip), %r13     # 0x24608
jmp 0x10596
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r15b
jmp 0x10646
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r14d, %r14d
xorl %r13d, %r13d
movq 0x10(%rbx), %rdi
cmpq %r14, 0x18(%rdi)
jbe 0x106d9
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x106aa
movq %rax, %rdi
leaq 0x12c11(%rip), %rsi     # 0x232a8
leaq 0x13f6a(%rip), %rdx     # 0x24608
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r15
jmp 0x106ad
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r12, 0x18(%r15)
jbe 0x106d4
movq %r15, %rdi
movq %r12, %rsi
callq 0xfcb6
xorb $0x1, %al
movzbl %al, %eax
addq %rax, %r13
addq %r14, %r13
addq %r12, %r13
incq %r12
jmp 0x106b0
incq %r14
jmp 0x10675
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12
movq 0x10(%rdi), %r15
movq %r12, %rcx
imulq 0x18(%r15), %rcx
cmpq %rax, %rcx
ja 0x1086c
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
callq 0xf8b6
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0x58(%rax)
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %r12d
movq 0x10(%rbx), %r15
cltd
idivl %r12d
movslq %eax, %rsi
movq (%r15), %rax
movq %r15, %rdi
callq *0x40(%rax)
leaq 0x12a25(%rip), %rsi     # 0x232a8
leaq 0x13d7e(%rip), %rdx     # 0x24608
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
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 %r13, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x48(%rbp), %r14
andq $0x0, 0x8(%r14)
movq %rdi, %rbx
leaq 0x12a82(%rip), %rax     # 0x23400
movq %rax, (%r14)
movq $0xa, 0x18(%r14)
pushq $0xa
popq %rdi
callq 0x7030
movq %rax, 0x10(%r14)
andq $0x0, 0x20(%r14)
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0xcd8c
leaq 0x7e57(%rip), %rsi      # 0x18804
movq %r14, %rdi
callq 0x8114
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0xcd8c
movq %r14, %rdi
callq 0x81d0
movq %rax, %r15
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq 0x60(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x851c
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x58(%rax)
movq 0x10(%rbx), %r12
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
andq $0x0, 0x8(%r15)
leaq 0x132cf(%rip), %rcx     # 0x23cf0
movq %rcx, (%r15)
movq %rax, 0x10(%r15)
andq $0x0, 0x18(%r15)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x98c0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x10a4a
movq (%rdi), %rax
callq *0x8(%rax)
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movl 0x48(%rbx), %esi
movq %rax, %rdi
callq 0xf8b6
movq %r14, 0x18(%rbx)
movq 0x60(%rbx), %rax
incq %rax
movq %rax, 0x60(%rbx)
incq 0x50(%rbx)
cmpq 0x68(%rbx), %rax
jne 0x10a7e
andq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10a95
movq %rax, %rbx
movq %r15, %r14
jmp 0x10a98
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10bce
movq %rdi, %rbx
leaq 0x12731(%rip), %rax     # 0x232a8
leaq 0x13cf2(%rip), %rdx     # 0x24870
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0x10bce
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 0x10bce
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_O2/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
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0x7c50(%rip), %rsi      # 0x18860
movq %rbx, %rdi
callq 0x7fd8
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x77d4(%rip), %rsi      # 0x183fd
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x10c57
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq 0x10(%rdi), %rax
movq 0x18(%rax), %r14
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x11562
movq 0x18(%r12), %rax
movq 0x38(%rax), %r13
xorl %r15d, %r15d
movq %r12, -0x40(%rbp)
movq %r13, -0x38(%rbp)
cmpq 0x18(%r13), %r15
jae 0x10dc7
movq 0x18(%r12), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
movq %rax, %rdi
leaq 0x12573(%rip), %rsi     # 0x232a8
leaq 0x12a94(%rip), %rdx     # 0x237d0
xorl %ecx, %ecx
callq 0x72a0
cmpq %r14, 0x18(%rax)
jne 0x10dbf
movq 0x10(%r12), %rdi
movq %rax, %rsi
callq 0xb84a
movq 0x10(%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x12f4c
testq %rax, %rax
je 0x10d85
movq %rax, %rdi
leaq 0x12536(%rip), %rsi     # 0x232a8
leaq 0x138f7(%rip), %rdx     # 0x24670
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r13
jmp 0x10d88
xorl %r13d, %r13d
xorl %r12d, %r12d
cmpq 0x18(%r13), %r12
jae 0x10dad
movq %r13, %rdi
movq %r12, %rsi
callq 0xff2e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xb0(%rax)
incq %r12
jmp 0x10d8b
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
incq %r15
jmp 0x10d0f
testq %r14, %r14
je 0x10dde
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r12), %rax
movq 0x18(%rax), %r14
xorl %r15d, %r15d
cmpq 0x18(%r14), %r15
jae 0x10dcc
movq %r14, %rdi
movq %r15, %rsi
callq 0xff2e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xb0(%rax)
incq %r15
jmp 0x10dea
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10f3a
movq %rdi, %rbx
leaq 0x123d0(%rip), %rax     # 0x232a8
leaq 0x139f9(%rip), %rdx     # 0x248d8
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0x10f3d
movq %rax, %r15
movq 0x58(%rbx), %rax
cmpq 0x58(%r15), %rax
jne 0x10f3a
xorl %r12d, %r12d
cmpq %r12, 0x58(%rbx)
setbe %r14b
jbe 0x10f3d
movq %r15, %rdi
movq %r12, %rsi
callq 0x110b2
movss %xmm0, -0x24(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x110b2
incq %r12
movss -0x24(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jne 0x10f3d
jnp 0x10f04
jmp 0x10f3d
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11207
movq %rbx, %rdi
callq 0x1128a
movq 0x10(%rbx), %r15
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x1123a
leaq 0x12084(%rip), %rsi     # 0x232a8
leaq 0x125a5(%rip), %rdx     # 0x237d0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %rsi
jmp 0x1123c
xorl %esi, %esi
movq %r15, %rdi
callq 0xb84a
movq 0x10(%rax), %r12
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x112cc
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 0x7220
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: FloatArray::FloatArray(char*)
FloatArray(char* serialized) {
        char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
        this->arraySize_ = std::stoi(JSONHelper::getValueFromKey("arraySize_", payload)->c_str());
        this->listLength_ = std::stoi(JSONHelper::getValueFromKey("listLength_", payload)->c_str());
        char* vals = JSONHelper::getValueFromKey("vals_", payload)->c_str();
        FloatArray* ia = new FloatArray(this->listLength_);
        for(int i = 0; i < this->listLength_; i++) {
            ia->pushBack(std::stof(JSONHelper::getArrayValueAt(vals, i)->c_str()));
        }
        //delete ia;
        this->vals_ = ia->vals_;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
andq $0x0, 0x8(%rdi)
leaq 0x13347(%rip), %rax     # 0x24630
movq %rax, (%rdi)
movq %rdi, -0x38(%rbp)
andq $0x0, 0x18(%rdi)
movq %rsi, %rdi
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x7059(%rip), %rdi      # 0x18369
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x58(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq -0x38(%rbp), %rcx
movq %rax, 0x20(%rcx)
leaq -0x58(%rbp), %rdi
callq 0x7120
leaq 0x7112(%rip), %rdi      # 0x1846b
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x58(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq -0x38(%rbp), %rbx
movq %rax, 0x18(%rbx)
leaq -0x58(%rbp), %rdi
callq 0x7120
leaq 0x7143(%rip), %rdi      # 0x184e5
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r15
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movl 0x18(%rbx), %esi
movq %rax, %rdi
callq 0x10e6a
xorl %r12d, %r12d
leaq -0x58(%rbp), %r13
leaq -0x29(%rbp), %rbx
movq -0x38(%rbp), %rax
cmpq %r12, 0x18(%rax)
jbe 0x1142e
movq %r15, %rdi
movl %r12d, %esi
callq 0xc4c8
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x70f0
movq %r13, %rdi
xorl %esi, %esi
callq 0x1147d
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movss %xmm0, (%rax,%rcx,4)
incq %rcx
movq %rcx, 0x18(%r14)
movq %r13, %rdi
callq 0x7120
incq %r12
jmp 0x113d7
movq 0x10(%r14), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x10(%rcx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
jmp 0x11475
jmp 0x11462
jmp 0x11472
jmp 0x11462
jmp 0x11472
jmp 0x11472
jmp 0x11472
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x7120
jmp 0x11475
jmp 0x11472
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x18, %rsp
testq %rsi, %rsi
je 0x11745
movq %rdi, %r12
leaq 0x11c6e(%rip), %rax     # 0x232a8
leaq 0x13397(%rip), %rdx     # 0x249d8
xorl %r15d, %r15d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0x11748
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0xc8(%rax)
movq %rax, %rbx
movq (%r12), %rax
movq %r12, %rdi
callq *0xc8(%rax)
cmpq %rax, %rbx
jne 0x11745
xorl %r15d, %r15d
leaq 0x11c1c(%rip), %rbx     # 0x232a8
leaq 0x12fdd(%rip), %r13     # 0x24670
movq %r12, -0x38(%rbp)
movq 0x10(%r12), %rdi
cmpq %r15, 0x18(%rdi)
jbe 0x1175a
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x116c9
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r12
jmp 0x116cc
xorl %r12d, %r12d
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x116f3
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r13
jmp 0x116f6
xorl %r13d, %r13d
xorl %ebx, %ebx
cmpq %rbx, 0x18(%r12)
jbe 0x1172b
movq %r12, %rdi
movq %rbx, %rsi
callq 0xff2e
movss %xmm0, -0x2c(%rbp)
movq %r13, %rdi
movq %rbx, %rsi
callq 0xff2e
incq %rbx
movss -0x2c(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jne 0x11745
jnp 0x116f8
jmp 0x11745
incq %r15
movq -0x38(%rbp), %r12
leaq 0x11b6f(%rip), %rbx     # 0x232a8
leaq 0x12f30(%rip), %r13     # 0x24670
jmp 0x11697
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r15b
jmp 0x11748
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
xorl %r14d, %r14d
leaq 0x12eeb(%rip), %r12     # 0x24670
movq 0x10(%rbx), %rdi
cmpq %r14, 0x18(%rdi)
jbe 0x117e3
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0x117b6
movq %rax, %rdi
leaq 0x11b01(%rip), %rsi     # 0x232a8
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r13
jmp 0x117b9
xorl %r13d, %r13d
xorl %r15d, %r15d
cmpq %r15, 0x18(%r13)
jbe 0x117de
movq %r13, %rdi
movq %r15, %rsi
callq 0xff2e
movaps -0x40(%rbp), %xmm1
addss %xmm0, %xmm1
movaps %xmm1, -0x40(%rbp)
incq %r15
jmp 0x117bc
incq %r14
jmp 0x11785
movaps -0x40(%rbp), %xmm0
cvttss2si %xmm0, %rcx
movq %rcx, %rdx
subss 0x688d(%rip), %xmm0     # 0x18084
cvttss2si %xmm0, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r15
movq 0x10(%rdi), %r14
movq %r15, %rcx
imulq 0x18(%r14), %rcx
cmpq %rax, %rcx
ja 0x1199f
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
callq 0x10e6a
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x58(%rax)
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %r15d
movq 0x10(%rbx), %r14
cltd
idivl %r15d
movslq %eax, %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
leaq 0x118f2(%rip), %rsi     # 0x232a8
leaq 0x12cb3(%rip), %rdx     # 0x24670
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
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 %r12, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11a72
testq %rdx, %rdx
jne 0x11a72
movq %rbx, %rdi
movss %xmm0, -0xc(%rbp)
callq 0x11a98
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movss -0xc(%rbp), %xmm0
movss %xmm0, (%rcx,%rdx,4)
incq %rdx
movq %rdx, 0x18(%rax)
movq 0x58(%rbx), %rcx
jmp 0x11a8a
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rsi
movss %xmm0, (%rdx,%rsi,4)
incq %rsi
movq %rsi, 0x18(%rax)
incq %rcx
movq %rcx, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq -0x48(%rbp), %r14
andq $0x0, 0x8(%r14)
movq %rdi, %rbx
leaq 0x11946(%rip), %rax     # 0x23400
movq %rax, (%r14)
movq $0xa, 0x18(%r14)
pushq $0xa
popq %rdi
callq 0x7030
movq %rax, 0x10(%r14)
andq $0x0, 0x20(%r14)
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0xcd8c
leaq 0x6d8e(%rip), %rsi      # 0x18877
movq %r14, %rdi
callq 0x8114
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0xcd8c
movq %r14, %rdi
callq 0x81d0
movq %rax, %r15
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq 0x60(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x851c
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x58(%rax)
movq 0x10(%rbx), %r12
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
andq $0x0, 0x8(%r15)
leaq 0x12193(%rip), %rcx     # 0x23cf0
movq %rcx, (%r15)
movq %rax, 0x10(%r15)
andq $0x0, 0x18(%r15)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x98c0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x11b86
movq (%rdi), %rax
callq *0x8(%rax)
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movl 0x48(%rbx), %esi
movq %rax, %rdi
callq 0x10e6a
movq %r14, 0x18(%rbx)
movq 0x60(%rbx), %rax
incq %rax
movq %rax, 0x60(%rbx)
incq 0x50(%rbx)
cmpq 0x68(%rbx), %rax
jne 0x11bba
andq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11bd1
movq %rax, %rbx
movq %r15, %r14
jmp 0x11bd4
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390