LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: IntColumn::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("IntColumn");
    sb->write("listLength_", listLength_);
    sb->write("arraySize_", arraySize_);
    sb->write("metaArrayStartSize__", metaArrayStartSize_);
    char * seralizedArr = val_->serialize();
    sb->write("val_", seralizedArr, false);
    sb->endSerialize();
    char* value = sb->get();
    delete sb;
    return value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x9e10
jmp 0x1663f
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x160c7(%rip), %rsi     # 0x2c719
callq 0x9e70
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x18(%rax), %edx
leaq 0x15e87(%rip), %rsi     # 0x2c4f0
callq 0x9ed0
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x1c(%rax), %edx
leaq 0x15d6e(%rip), %rsi     # 0x2c3ee
callq 0x9ed0
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x20(%rax), %edx
leaq 0x1600f(%rip), %rsi     # 0x2c6a6
callq 0x9ed0
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x15dc5(%rip), %rsi     # 0x2c482
xorl %ecx, %ecx
callq 0xf190
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x166fa
movq -0x48(%rbp), %rdi
callq 0x9ff0
movq -0x48(%rbp), %rdi
callq 0x8260
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: IntColumn::push_back(int)
void push_back(int val) {
    if (listLength_  >= ((arraySize_* val_->length()))) {
      val_->pushBack(new IntArray(arraySize_));
    }
    int array_index = listLength_ / arraySize_;
    IntArray* ia = dynamic_cast<IntArray*>(val_->get(array_index));
    ia->pushBack(val);
    listLength_++;

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq 0x18(%rax), %rcx
movq %rcx, -0x30(%rbp)
movslq 0x1c(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rdi
callq 0x11670
movq -0x38(%rbp), %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
imulq %rdx, %rcx
cmpq %rcx, %rax
jb 0x16869
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movl $0x28, %edi
callq 0x8290
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movl 0x1c(%rax), %esi
callq 0x15610
jmp 0x16842
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x16869
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x168e5
movq -0x40(%rbp), %rcx
movl 0x18(%rcx), %eax
cltd
idivl 0x1c(%rcx)
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x20(%rbp)
movq 0x10(%rax), %rdi
movslq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x168b6
movq -0x58(%rbp), %rdi
leaq 0x23820(%rip), %rsi     # 0x3a0c0
leaq 0x243e9(%rip), %rdx     # 0x3ac90
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x60(%rbp)
jmp 0x168be
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x168be
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x10d70
movq -0x40(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8400
nop
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: IntDistributedArray::pushBack(int)
void pushBack(int val) {
        //initialize first key
        if(itemCount_ % chunkSize_ == 0 && itemCount_ != 0) { //if current chunk is full..
            storeChunk(); //stores the previous chunk values in the kv_store
            chunkArray_->pushBack(val);
        } else {
            chunkArray_->pushBack(val);
        }
        itemCount_ +=1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x58(%rcx), %rax
xorl %edx, %edx
divq 0x48(%rcx)
cmpq $0x0, %rdx
jne 0x169cd
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x169cd
movq -0x18(%rbp), %rdi
callq 0x16a00
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x10d70
jmp 0x169dd
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x10d70
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::StringDistributedArray(KVStore*)
StringDistributedArray(KVStore* kv) {
        kv_ = kv;
        totalNodes_ = kv->num_nodes_;
        srand(time(nullptr));
        uid_ = rand();
        curNode_ = 0;
        itemCount_ = 0;
        chunkCount_ = 0;
        keys_ = new Array();
        chunkArray_ = new StringArray(chunkSize_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x9780
movq -0x30(%rbp), %rax
leaq 0x24640(%rip), %rcx     # 0x3b2d8
movq %rcx, (%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x32, 0x30(%rax)
movq $0x400, 0x48(%rax)      # imm = 0x400
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x68(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x8250
movl %eax, %edi
callq 0x8270
callq 0x80c0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, 0x40(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x50(%rax)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x28(%rbp)
jmp 0x16d19
movq -0x28(%rbp), %rdi
callq 0xab80
jmp 0x16d24
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x38(%rbp)
jmp 0x16d40
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x173f0
jmp 0x16d52
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x16d9e
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x16d9e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x30(%rbp), %rdi
callq 0x9830
movq -0x18(%rbp), %rdi
callq 0x8400
// File: yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedStringColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    DistributedStringColumn* other_ic = dynamic_cast<DistributedStringColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    StringDistributedArray* other_val_ = dynamic_cast<StringDistributedArray*>(other_ic->val_);
    return this->val_->equals(other_val_);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16e28
movb $0x0, -0x1(%rbp)
jmp 0x16ec7
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x16e57
movq -0x38(%rbp), %rdi
leaq 0x2327f(%rip), %rsi     # 0x3a0c0
leaq 0x24468(%rip), %rdx     # 0x3b2b0
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x16e5f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x16e5f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x16e74
movb $0x0, -0x1(%rbp)
jmp 0x16ec7
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0xc8(%rax)
movq -0x30(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq (%rdi), %rax
callq *0xc8(%rax)
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x16ea4
movb $0x0, -0x1(%rbp)
jmp 0x16ec7
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedStringColumn::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("DistributedStringColumn");
    char * seralizedArr = val_->serialize();
    sb->write("val_", seralizedArr, false);
    sb->endSerialize();
    char* value = sb->get();
    delete sb;
    return value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x9e10
jmp 0x16f2f
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1586e(%rip), %rsi     # 0x2c7b0
callq 0x9e70
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1551a(%rip), %rsi     # 0x2c482
xorl %ecx, %ecx
callq 0xf190
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x16fa5
movq -0x48(%rbp), %rdi
callq 0x9ff0
movq -0x48(%rbp), %rdi
callq 0x8260
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        StringDistributedArray *s = dynamic_cast<StringDistributedArray*>(o);
        if(s == nullptr) return false;
        if(itemCount_ != s->itemCount_) return false;
        for(int i = 0; i < itemCount_; i++) {
            bool sameInt = s->get(i)->equals(get(i));
            if(!sameInt) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x174f8
movb $0x0, -0x1(%rbp)
jmp 0x175be
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x17527
movq -0x38(%rbp), %rdi
leaq 0x22baf(%rip), %rsi     # 0x3a0c0
leaq 0x23e00(%rip), %rdx     # 0x3b318
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x1752f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x1752f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x17544
movb $0x0, -0x1(%rbp)
jmp 0x175be
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x58(%rcx), %rax
je 0x1755c
movb $0x0, -0x1(%rbp)
jmp 0x175be
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x175ba
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x17bb0
movq -0x30(%rbp), %rdi
movq %rax, -0x48(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x17bb0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x175ad
movb $0x0, -0x1(%rbp)
jmp 0x175be
jmp 0x175af
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x17563
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::hash_me()
size_t hash_me() {
      size_t temp = 0;
      for(int i = 0; i < itemCount_; i++) {
          temp *= get(i)->hash();
      }
      return temp;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x1762b
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x17bb0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
imulq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x175f3
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: StringArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        StringArray *b = dynamic_cast<StringArray*>(o);
        if(b == nullptr) return false;
        if(listLength_ != b->listLength_) return false;
        for(int i = 0; i < listLength_; i++) {
            bool sameString = b->get(i)->equals(get(i));
            if(!sameString) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x17878
movb $0x0, -0x1(%rbp)
jmp 0x1793e
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x178a7
movq -0x38(%rbp), %rdi
leaq 0x2282f(%rip), %rsi     # 0x3a0c0
leaq 0x23ae8(%rip), %rdx     # 0x3b380
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x178af
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x178af
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x178c4
movb $0x0, -0x1(%rbp)
jmp 0x1793e
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x178dc
movb $0x0, -0x1(%rbp)
jmp 0x1793e
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x1793a
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x17a60
movq -0x30(%rbp), %rdi
movq %rax, -0x48(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x17a60
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x1792d
movb $0x0, -0x1(%rbp)
jmp 0x1793e
jmp 0x1792f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x178e3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: StringArray::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("StringArray");
        sb->write("listLength_", listLength_);
        sb->write("arraySize_", arraySize_);
        sb->write("vals_", vals_, listLength_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
     }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0x1798f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x14db9(%rip), %rsi     # 0x2c75b
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x14b36(%rip), %rsi     # 0x2c4f0
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x14a1c(%rip), %rsi     # 0x2c3ee
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rax
movl %eax, %ecx
leaq 0x14b7a(%rip), %rsi     # 0x2c56a
callq 0x17ac0
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x17a2b
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, String**, int)
void write(const char* name, String** val, int len) {
        char str[1000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            sprintf(str, "'%s',", val[i]->c_str());
            buff->c(str);
        }
        buff->c("], ");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x14908(%rip), %rsi     # 0x2c3ff
movb $0x0, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl $0x0, -0x414(%rbp)
movl -0x414(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x17b8b
leaq -0x410(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x18(%rbp), %rax
movslq -0x414(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x428(%rbp), %rdi
movq %rax, %rdx
leaq 0x14c0a(%rip), %rsi     # 0x2c767
movb $0x0, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
jmp 0x17b1e
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq 0x14871(%rip), %rsi     # 0x2c40d
callq 0xa0f0
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::get(unsigned long)
String* get(size_t index) {
        assert(index < itemCount_);
        //std::cout << "in get " << index <<"\n";
        if (cache_ == nullptr) {
            init_cache_();
        }
        String* res;
        if(index/chunkSize_ == chunkCount_) {
            res = chunkArray_->get(index % chunkSize_);
        } else {

            size_t key_idx = floor((index/chunkSize_));
            //std::cout << "key index: " << key_idx << "\n";
            //std::cout << key
            StringArray* doubleVals;
            if (cache_[key_idx] != nullptr) {
                //std::cout << "get chunk from cache\n";
                doubleVals = cache_[key_idx];
            } else {
                //std::cout << "get chunk from kv\n";
                doubleVals = get_chunk_from_kv_(key_idx);
            }
            res = doubleVals->get(index % chunkSize_);
        }
        //std::cout << "res: " << res << "\n";
        return res; //returns int at correct index in array at this chunk
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x17bd4
jmp 0x17bf3
leaq 0x149ad(%rip), %rdi     # 0x2c588
leaq 0x149b9(%rip), %rsi     # 0x2c59b
movl $0x1f6, %edx            # imm = 0x1F6
leaq 0x14b7f(%rip), %rcx     # 0x2c76d
callq 0x81a0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x17c07
movq -0x30(%rbp), %rdi
callq 0x17cf0
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq 0x48(%rcx)
cmpq 0x50(%rcx), %rax
jne 0x17c3e
movq -0x30(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq 0x48(%rcx)
movq %rdx, %rsi
callq 0x17a60
movq %rax, -0x18(%rbp)
jmp 0x17cd9
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x48(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rdi
callq 0x11520
movq -0x30(%rbp), %rax
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movsd 0x14456(%rip), %xmm1    # 0x2c0c8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x17caa
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x17cbb
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x17d90
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq 0x48(%rcx)
movq %rdx, %rsi
callq 0x17a60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::get_chunk_from_kv_(unsigned long)
StringArray* get_chunk_from_kv_(size_t key_idx) {
        if (cache_count_ >= max_cache_count) {
            reset_cache_();
        }
        Value* v = kv_->get(dynamic_cast<Key*>(keys_->get(key_idx))); //gets value of given key
        char* serlializedNode = v->data; 
        //std::cout << serlializedNode <<"\n";
        StringArray* doubleVals = new StringArray(serlializedNode); //turns payload into IntArray object
        cache_[key_idx] = doubleVals;
        cache_count_ += 1;
        return doubleVals;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq 0x28(%rcx), %rax
cmpq 0x30(%rcx), %rax
jb 0x17dbb
movq -0x40(%rbp), %rdi
callq 0x17ea0
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x17e00
movq -0x48(%rbp), %rdi
leaq 0x222d6(%rip), %rsi     # 0x3a0c0
leaq 0x2293f(%rip), %rdx     # 0x3a730
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x58(%rbp)
jmp 0x17e08
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x17e08
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x11740
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x28, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rsi
callq 0x17f50
jmp 0x17e44
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x8260
movq -0x30(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: StringColumn::hash_me()
size_t hash_me() {
    size_t hash = 0;
    for(int i = 0; i < val_->length(); i++) {
      StringArray* fa = dynamic_cast<StringArray*>(val_->get(i));
      for(int j = 0; j < fa->length(); j++) {
        hash += fa->get(j)->hash_me();
      }
    }
    return hash;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rdi
callq 0x11670
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x18762
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x186f5
movq -0x40(%rbp), %rdi
leaq 0x219e1(%rip), %rsi     # 0x3a0c0
leaq 0x22c9a(%rip), %rdx     # 0x3b380
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x48(%rbp)
jmp 0x186fd
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x186fd
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x183f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x18752
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x17a60
movq %rax, %rdi
movq (%rdi), %rax
callq *0x28(%rax)
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1870c
jmp 0x18754
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18693
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: StringColumn::push_back(String*)
void push_back(String* val) {
    if (listLength_  >= ((arraySize_* val_->length()))) {
      val_->pushBack(new StringArray(arraySize_));
    }
    int array_index = listLength_ / arraySize_;
    StringArray* a = dynamic_cast<StringArray*>(val_->get(array_index));
    a->pushBack(val);
    listLength_++;

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq 0x18(%rax), %rcx
movq %rcx, -0x30(%rbp)
movslq 0x1c(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rdi
callq 0x11670
movq -0x38(%rbp), %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
imulq %rdx, %rcx
cmpq %rcx, %rax
jb 0x18a1a
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movl $0x28, %edi
callq 0x8290
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movl 0x1c(%rax), %esi
callq 0x173f0
jmp 0x189f3
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x18a1a
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x18a97
movq -0x40(%rbp), %rcx
movl 0x18(%rcx), %eax
cltd
idivl 0x1c(%rcx)
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x20(%rbp)
movq 0x10(%rax), %rdi
movslq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x18a67
movq -0x58(%rbp), %rdi
leaq 0x2166f(%rip), %rsi     # 0x3a0c0
leaq 0x22928(%rip), %rdx     # 0x3b380
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x60(%rbp)
jmp 0x18a6f
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x18a6f
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x182a0
movq -0x40(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8400
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: StringDistributedArray::pushBack(String*)
void pushBack(String* val) {
        //initialize first key
        if(itemCount_ % chunkSize_ == 0 && itemCount_ != 0) { //if current chunk is full..
            storeChunk(); //stores the previous chunk values in the kv_store
            chunkArray_->pushBack(val);
        } else {
            chunkArray_->pushBack(val);
        }
        itemCount_ +=1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x58(%rcx), %rax
xorl %edx, %edx
divq 0x48(%rcx)
cmpq $0x0, %rdx
jne 0x18b2f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x18b2f
movq -0x18(%rbp), %rdi
callq 0x18b60
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x182a0
jmp 0x18b40
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x182a0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: BoolDistributedArray::BoolDistributedArray(KVStore*)
BoolDistributedArray(KVStore* kv) {
        kv_ = kv;
        totalNodes_ = kv->num_nodes_;
        srand(time(nullptr));
        uid_ = rand();
        curNode_ = 0;
        itemCount_ = 0;
        chunkCount_ = 0;
        keys_ = new Array();
        chunkArray_ = new BoolArray(chunkSize_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x9780
movq -0x30(%rbp), %rax
leaq 0x227b0(%rip), %rcx     # 0x3b5a8
movq %rcx, (%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x32, 0x30(%rax)
movq $0x400, 0x48(%rax)      # imm = 0x400
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x68(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x8250
movl %eax, %edi
callq 0x8270
callq 0x80c0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, 0x40(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x50(%rax)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x28(%rbp)
jmp 0x18e79
movq -0x28(%rbp), %rdi
callq 0xab80
jmp 0x18e84
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x38(%rbp)
jmp 0x18ea0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x19550
jmp 0x18eb2
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x18efe
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x18efe
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x30(%rbp), %rdi
callq 0x9830
movq -0x18(%rbp), %rdi
callq 0x8400
// File: yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedBoolColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    DistributedBoolColumn* other_ic = dynamic_cast<DistributedBoolColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    BoolDistributedArray* other_val_ = dynamic_cast<BoolDistributedArray*>(other_ic->val_);
    return this->val_->equals(other_val_);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x18f88
movb $0x0, -0x1(%rbp)
jmp 0x19027
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x18fb7
movq -0x38(%rbp), %rdi
leaq 0x2111f(%rip), %rsi     # 0x3a0c0
leaq 0x225d8(%rip), %rdx     # 0x3b580
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x18fbf
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x18fbf
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x18fd4
movb $0x0, -0x1(%rbp)
jmp 0x19027
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0xc8(%rax)
movq -0x30(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq (%rdi), %rax
callq *0xc8(%rax)
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x19004
movb $0x0, -0x1(%rbp)
jmp 0x19027
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedBoolColumn::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("DistributedBoolColumn");
    char * seralizedArr = val_->serialize();
    sb->write("val_", seralizedArr, false);
    sb->endSerialize();
    char* value = sb->get();
    delete sb;
    return value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x9e10
jmp 0x1908f
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x137d1(%rip), %rsi     # 0x2c873
callq 0x9e70
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x133ba(%rip), %rsi     # 0x2c482
xorl %ecx, %ecx
callq 0xf190
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x19105
movq -0x48(%rbp), %rdi
callq 0x9ff0
movq -0x48(%rbp), %rdi
callq 0x8260
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x19648
movb $0x0, -0x1(%rbp)
jmp 0x19718
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x19677
movq -0x38(%rbp), %rdi
leaq 0x20a5f(%rip), %rsi     # 0x3a0c0
leaq 0x21f80(%rip), %rdx     # 0x3b5e8
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x1967f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x1967f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x19697
movb $0x0, -0x1(%rbp)
jmp 0x19718
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x58(%rcx), %rax
je 0x196af
movb $0x0, -0x1(%rbp)
jmp 0x19718
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x19714
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x1a370
movq -0x30(%rbp), %rdi
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x1a370
movb %al, %cl
movl -0x44(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x19707
movb $0x0, -0x1(%rbp)
jmp 0x19718
jmp 0x19709
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x196b6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x199d8
movb $0x0, -0x1(%rbp)
jmp 0x19aa8
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x19a07
movq -0x38(%rbp), %rdi
leaq 0x206cf(%rip), %rsi     # 0x3a0c0
leaq 0x21c58(%rip), %rdx     # 0x3b650
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x19a0f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x19a0f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x19a27
movb $0x0, -0x1(%rbp)
jmp 0x19aa8
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x19a3f
movb $0x0, -0x1(%rbp)
jmp 0x19aa8
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x19aa4
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x19c80
movq -0x30(%rbp), %rdi
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x19c80
movb %al, %cl
movl -0x44(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x19a97
movb $0x0, -0x1(%rbp)
jmp 0x19aa8
jmp 0x19a99
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x19a46
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x28, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x19ce0
jmp 0x19aef
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rcx
movslq -0x20(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x19b59
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movss -0x24(%rbp), %xmm0
callq 0x19d70
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x19afe
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x19b63
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8400
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0x19baf
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x12c65(%rip), %rsi     # 0x2c827
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x12916(%rip), %rsi     # 0x2c4f0
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x127fc(%rip), %rsi     # 0x2c3ee
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rax
movl %eax, %ecx
leaq 0x1295a(%rip), %rsi     # 0x2c56a
callq 0x1a290
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x19c4b
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x19e58
movb $0x0, -0x1(%rbp)
jmp 0x19f28
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x19e87
movq -0x38(%rbp), %rdi
leaq 0x2024f(%rip), %rsi     # 0x3a0c0
leaq 0x21840(%rip), %rdx     # 0x3b6b8
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x19e8f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x19e8f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x19ea7
movb $0x0, -0x1(%rbp)
jmp 0x19f28
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x19ebf
movb $0x0, -0x1(%rbp)
jmp 0x19f28
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x19f24
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x1a150
movq -0x30(%rbp), %rdi
movss %xmm0, -0x44(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x1a150
movaps %xmm0, %xmm1
movss -0x44(%rbp), %xmm0
ucomiss %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x19f17
movb $0x0, -0x1(%rbp)
jmp 0x19f28
jmp 0x19f19
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x19ec6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movslq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x1a043
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
mulss -0xc(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a00f
cvttss2si -0xc(%rbp), %eax
cltq
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0x1a07f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1278a(%rip), %rsi     # 0x2c81c
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x12446(%rip), %rsi     # 0x2c4f0
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x1232c(%rip), %rsi     # 0x2c3ee
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rax
movl %eax, %ecx
leaq 0x1248a(%rip), %rsi     # 0x2c56a
callq 0x1a1b0
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1a11b
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x12218(%rip), %rsi     # 0x2c3ff
movb $0x0, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl $0x0, -0x414(%rbp)
movl -0x414(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1a269
leaq -0x410(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x414(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x12347(%rip), %rsi     # 0x2c582
movb $0x1, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
jmp 0x1a20e
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq 0x12193(%rip), %rsi     # 0x2c40d
callq 0xa0f0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x12138(%rip), %rsi     # 0x2c3ff
movb $0x0, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl $0x0, -0x414(%rbp)
movl -0x414(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1a348
leaq -0x410(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x414(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movzbl %al, %edx
leaq 0x12517(%rip), %rsi     # 0x2c831
movb $0x0, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
jmp 0x1a2ee
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq 0x120b4(%rip), %rsi     # 0x2c40d
callq 0xa0f0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw (%rax,%rax)