LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
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 0x1a394
jmp 0x1a3b3
leaq 0x121ed(%rip), %rdi     # 0x2c588
leaq 0x121f9(%rip), %rsi     # 0x2c59b
movl $0x2cf, %edx            # imm = 0x2CF
leaq 0x12489(%rip), %rcx     # 0x2c837
callq 0x81a0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x1a3c7
movq -0x30(%rbp), %rdi
callq 0x1a4b0
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq 0x48(%rcx)
cmpq 0x50(%rcx), %rax
jne 0x1a3ff
movq -0x30(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq 0x48(%rcx)
movq %rdx, %rsi
callq 0x19c80
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x1a49b
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 0x11c95(%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 0x1a46b
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x1a47c
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a550
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 0x19c80
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
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 0x1a57b
movq -0x40(%rbp), %rdi
callq 0x1a660
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 0x1a5c0
movq -0x48(%rbp), %rdi
leaq 0x1fb16(%rip), %rsi     # 0x3a0c0
leaq 0x2017f(%rip), %rdx     # 0x3a730
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x58(%rbp)
jmp 0x1a5c8
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x1a5c8
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 0x1a710
jmp 0x1a604
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: 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
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 0x1b018
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 0x1af95
movq -0x40(%rbp), %rdi
leaq 0x1f141(%rip), %rsi     # 0x3a0c0
leaq 0x206ca(%rip), %rdx     # 0x3b650
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x48(%rbp)
jmp 0x1af9d
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x1af9d
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 0x1ac80
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x1b008
movl $0x1, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x19c80
testb $0x1, %al
jne 0x1afe3
jmp 0x1afea
movl $0x0, -0x28(%rbp)
movl -0x14(%rbp), %eax
addl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1afac
jmp 0x1b00a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1af33
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%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 0x1b2b1
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 0x19550
jmp 0x1b287
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x1b2b1
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x1b332
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 0x1b2fe
movq -0x58(%rbp), %rdi
leaq 0x1edd8(%rip), %rsi     # 0x3a0c0
leaq 0x20361(%rip), %rdx     # 0x3b650
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x60(%rbp)
jmp 0x1b306
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x1b306
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x1ab20
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
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: FloatDistributedArray::FloatDistributedArray(KVStore*)
FloatDistributedArray(KVStore* kv) {
        kv_ = kv;
        totalNodes_ = kv->num_nodes_;
        srand(time(nullptr));
        uid_ = rand();
        curNode_ = 0;
        itemCount_ = 0;
        chunkCount_ = 0;
        keys_ = new Array();
        chunkArray_ = new FloatArray(chunkSize_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 0x20218(%rip), %rcx     # 0x3b8e0
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 0x1b749
movq -0x28(%rbp), %rdi
callq 0xab80
jmp 0x1b754
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x38(%rbp)
jmp 0x1b770
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x1be20
jmp 0x1b782
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 0x1b7ce
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x1b7ce
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: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1b858
movb $0x0, -0x1(%rbp)
jmp 0x1b8f7
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1b887
movq -0x38(%rbp), %rdi
leaq 0x1e84f(%rip), %rsi     # 0x3a0c0
leaq 0x20040(%rip), %rdx     # 0x3b8b8
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x1b88f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x1b88f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1b8a4
movb $0x0, -0x1(%rbp)
jmp 0x1b8f7
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 0x1b8d4
movb $0x0, -0x1(%rbp)
jmp 0x1b8f7
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/../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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1bf28
movb $0x0, -0x1(%rbp)
jmp 0x1bff8
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1bf57
movq -0x38(%rbp), %rdi
leaq 0x1e17f(%rip), %rsi     # 0x3a0c0
leaq 0x1f9d8(%rip), %rdx     # 0x3b920
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x1bf5f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x1bf5f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1bf77
movb $0x0, -0x1(%rbp)
jmp 0x1bff8
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x58(%rcx), %rax
je 0x1bf8f
movb $0x0, -0x1(%rbp)
jmp 0x1bff8
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x1bff4
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x1c210
movq -0x30(%rbp), %rdi
movss %xmm0, -0x44(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x1c210
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 0x1bfe7
movb $0x0, -0x1(%rbp)
jmp 0x1bff8
jmp 0x1bfe9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1bf96
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/../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
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 0x1c41b
movq -0x40(%rbp), %rdi
callq 0x1c500
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 0x1c460
movq -0x48(%rbp), %rdi
leaq 0x1dc76(%rip), %rsi     # 0x3a0c0
leaq 0x1e2df(%rip), %rdx     # 0x3a730
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x58(%rbp)
jmp 0x1c468
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x1c468
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 0x1c5b0
jmp 0x1c4a4
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: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rdi
callq 0x11670
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1d01b
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1cfb5
movq -0x38(%rbp), %rdi
leaq 0x1d121(%rip), %rsi     # 0x3a0c0
leaq 0x1e712(%rip), %rdx     # 0x3b6b8
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x1cfbd
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x1cfbd
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cca0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x1d00b
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1a150
addss -0xc(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1cfcc
jmp 0x1d00d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1cf53
movss -0xc(%rbp), %xmm0
movss 0xf0a8(%rip), %xmm2     # 0x2c0d0
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
cvttss2si %xmm1, %rcx
cvttss2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -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 0x1d2eb
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 0x1be20
jmp 0x1d2c4
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x1d2eb
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x1d369
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 0x1d338
movq -0x58(%rbp), %rdi
leaq 0x1cd9e(%rip), %rsi     # 0x3a0c0
leaq 0x1e38f(%rip), %rdx     # 0x3b6b8
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x60(%rbp)
jmp 0x1d340
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x1d340
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movss -0xc(%rbp), %xmm0
callq 0x19d70
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
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x58(%rcx), %rax
xorl %edx, %edx
divq 0x48(%rcx)
cmpq $0x0, %rdx
jne 0x1d421
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x1d421
movq -0x18(%rbp), %rdi
callq 0x1d450
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movss -0xc(%rbp), %xmm0
callq 0x19d70
jmp 0x1d433
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movss -0xc(%rbp), %xmm0
callq 0x19d70
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::add_column(char, String*)
void add_column(char typ, String* name) {
        if (this->empty_index_ == this->capacity_) {
            resize_();
        }
        if (this->valid_col_char_(typ)) {
            //set the typ for the new column if valid.
            this->val_[this->empty_index_] = typ;
            if (name != nullptr) {
                if (this->col_name_idx->get(name) == nullptr) {
                    Integer* i = new Integer(this->empty_index_);
                    this->col_name_idx->add(name, i);
                    this->col_idx_name->add(i, name);
                }
            }
            //bump up the empty index
            this->empty_index_ += 1;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq 0x20(%rcx), %rax
cmpq 0x10(%rcx), %rax
jne 0x1d751
movq -0x38(%rbp), %rdi
callq 0x1d830
movq -0x38(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x1d8f0
testb $0x1, %al
jne 0x1d767
jmp 0x1d81a
movq -0x38(%rbp), %rcx
movb -0x9(%rbp), %dl
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
movb %dl, (%rax,%rcx)
cmpq $0x0, -0x18(%rbp)
je 0x1d80a
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xec70
cmpq $0x0, %rax
jne 0x1d808
movl $0x18, %edi
callq 0x8290
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movl 0x20(%rax), %esi
callq 0x146a0
jmp 0x1d7bd
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xf260
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf260
jmp 0x1d808
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8260
jmp 0x1d820
jmp 0x1d80a
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x8400
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::resize_()
void resize_() {
        size_t len = this->capacity_;
        //double size.
        len = this->capacity_ * 2;
        //create a new array that has double the size.
        char *copy_ = new char[len + 1];
        
        //copy over elements one by one.
        for (size_t i = 0; i < this->capacity_; i++) {
            copy_[i] = this->val_[i];
        }
        
        //need to free the array.
        delete[] this->val_;
        //need to get old pointer to point to new array. 
        this->val_ = copy_;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rax), %rax
shlq %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x8030
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x1d8a6
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1d870
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1d8c1
movq -0x30(%rbp), %rdi
callq 0x8300
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rcx)
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rcx)
movq 0x18(%rcx), %rax
movq 0x10(%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./network.h
// Function: Put::Put(Key*, Value*, unsigned long, unsigned long, unsigned long)
Put(Key* key, Value* value, size_t sender, size_t target, size_t id) {
        kind_ = (MsgKind)2; 
        sender_ = sender;
        target_ = target;
        id_ = id;
        key_ = key;
        value_ = value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x9b00
movq -0x38(%rbp), %rax
leaq 0x1e040(%rip), %rcx     # 0x3ba38
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x2, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x38(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::resolve_local_wait(Key*)
void resolve_local_wait(Key* key) {
         // notification procedure.
        if (wait_for_key_ != nullptr) {
            if (wait_for_key_->equals(key)) {
                store_mtx_.notify_all();
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x100(%rax)
je 0x1daac
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0x1da9d
jmp 0x1daaa
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0x1e520
jmp 0x1daac
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./network.h
// Function: Put::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Put");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        char* serializedKey = key_->serialize();
        sb->write("key_", serializedKey, false);
        char* serializedValue = value_->serialize();
        sb->write("value_", serializedValue, false);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x9e10
jmp 0x1e3ef
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xe55d(%rip), %rsi      # 0x2c95f
callq 0x9e70
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %edx
leaq 0xdee2(%rip), %rsi      # 0x2c2fb
callq 0x9ed0
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0xded0(%rip), %rsi      # 0x2c301
callq 0x9f30
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0xdec0(%rip), %rsi      # 0x2c309
callq 0x9f30
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rdx
leaq 0xe1eb(%rip), %rsi      # 0x2c64c
callq 0x9f30
movq -0x48(%rbp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0xdff6(%rip), %rsi      # 0x2c47d
xorl %ecx, %ecx
callq 0xf190
movq -0x48(%rbp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0xe4b4(%rip), %rsi      # 0x2c963
xorl %ecx, %ecx
callq 0xf190
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x1e4ec
movq -0x50(%rbp), %rdi
callq 0x9ff0
movq -0x50(%rbp), %rdi
callq 0x8260
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%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)
nop
// File: yasz24[P]eau2/src/network/./network.h
// Function: Reply::Reply(char*, unsigned long, unsigned long, unsigned long)
Reply(char* reply_msg, size_t sender, size_t target, size_t id) {
        kind_ = (MsgKind)3; 
        sender_ = sender;
        target_ = target;
        id_ = id;
        reply_msg_ = reply_msg;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x9b00
movq -0x30(%rbp), %rax
leaq 0x1d494(%rip), %rcx     # 0x3bab8
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x3, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./network.h
// Function: WaitAndGet::WaitAndGet(Key*, unsigned long, unsigned long, unsigned long)
WaitAndGet(Key* key, size_t sender, size_t target, size_t id) {
        kind_ = (MsgKind)5; 
        sender_ = sender;
        target_ = target;
        id_ = id;
        key_ = key;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x9b00
movq -0x30(%rbp), %rax
leaq 0x1d454(%rip), %rcx     # 0x3bb08
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x5, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::get(Object*)
int get(Object* o) {
        for (size_t i = 0; i < listLength_; i++) {
            if (objs_[i]->equals(o)) {
                return i;
            }
        }
        return -1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x1e757
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0x1e73e
jmp 0x1e747
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x1e75e
jmp 0x1e749
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1e710
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./network.h
// Function: Reply::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Reply");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        if(JSONHelper::isObject(reply_msg_)) {
            sb->write("msg_", reply_msg_, false);
        } else {
            sb->write("msg_", reply_msg_);
        }
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 0x1e7ef
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xe168(%rip), %rsi      # 0x2c96a
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %edx
leaq 0xdae2(%rip), %rsi      # 0x2c2fb
callq 0x9ed0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0xdad0(%rip), %rsi      # 0x2c301
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0xdac0(%rip), %rsi      # 0x2c309
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rdx
leaq 0xddeb(%rip), %rsi      # 0x2c64c
callq 0x9f30
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x13010
testb $0x1, %al
jne 0x1e879
jmp 0x1e8ac
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x30(%rax), %rdx
leaq 0xe784(%rip), %rsi      # 0x2d010
xorl %ecx, %ecx
callq 0xf190
jmp 0x1e8c4
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x1e904
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x30(%rax), %rdx
leaq 0xe751(%rip), %rsi      # 0x2d010
callq 0xa6f0
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 0x1e8fa
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8400
nopl (%rax)
// File: yasz24[P]eau2/src/network/./network.h
// Function: WaitAndGet::equals(Object*)
bool equals(Object* other) {
        if (other == this) return true;
        WaitAndGet* x = dynamic_cast<WaitAndGet *>(other);
        if (x == nullptr) return false;
        return this->key_->equals(x->key_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x1e964
movb $0x1, -0x1(%rbp)
jmp 0x1e9cb
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1e993
movq -0x30(%rbp), %rdi
leaq 0x1b743(%rip), %rsi     # 0x3a0c0
leaq 0x1d11c(%rip), %rdx     # 0x3baa0
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x38(%rbp)
jmp 0x1e99b
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x1e99b
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1e9b0
movb $0x0, -0x1(%rbp)
jmp 0x1e9cb
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::get_double(unsigned long, unsigned long)
int get_double(size_t col, size_t row) {
      assert(col < this->schema_->width());
      char col_type = this->schema_->col_type(col);
      assert(col_type == 'D');
      //std::cout<< "get_double: " << this->cols_->get(col) << "\n";
      DistributedDoubleColumn* doubCol = dynamic_cast<DistributedDoubleColumn*>(this->cols_->get(col));
      //std::cout << "get_double row: " << row << "length: "<< schema_->length() << "\n";
      assert(row < this->schema_->length());
      return doubCol->get(row);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rdi
callq 0xfc20
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1ee8b
jmp 0x1eeaa
leaq 0xdb38(%rip), %rdi      # 0x2c9ca
leaq 0xdb4e(%rip), %rsi      # 0x2c9e7
movl $0xac, %edx
leaq 0xdb77(%rip), %rcx      # 0x2ca1c
callq 0x81a0
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xfc40
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x44, %eax
jne 0x1eec9
jmp 0x1eee8
leaq 0xdb81(%rip), %rdi      # 0x2ca51
leaq 0xdb10(%rip), %rsi      # 0x2c9e7
movl $0xae, %edx
leaq 0xdb39(%rip), %rcx      # 0x2ca1c
callq 0x81a0
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1ef25
movq -0x40(%rbp), %rdi
leaq 0x1b1b1(%rip), %rsi     # 0x3a0c0
leaq 0x1bb5a(%rip), %rdx     # 0x3aa70
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x48(%rbp)
jmp 0x1ef2d
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x1ef2d
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rdi
callq 0x1d700
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x1ef58
jmp 0x1ef77
leaq 0xdb02(%rip), %rdi      # 0x2ca61
leaq 0xda81(%rip), %rsi      # 0x2c9e7
movl $0xb2, %edx
leaq 0xdaaa(%rip), %rcx      # 0x2ca1c
callq 0x81a0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f1a0
cvttsd2si %xmm0, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::fromScalar(Key*, KVStore*, int)
static DistributedDataFrame* fromScalar(Key* key, KVStore* kv, int scalar) {
      Schema* s = new Schema(); 
      DistributedIntColumn* dc = new DistributedIntColumn(kv);
      s->add_row(nullptr);
      dc->push_back(scalar);
      DistributedDataFrame* df = new DistributedDataFrame(*s, kv);
      df->add_column(dc, nullptr);
      char* serialized = df->serialize();
      Value* val = new Value(serialized, (size_t)0);
      kv->put(key, val);
      return df;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x50, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0xd1f0
jmp 0x1f051
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x20, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
callq 0x14970
jmp 0x1f078
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd420
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
movq (%rdi), %rax
movq 0x98(%rax), %rax
callq *%rax
movl $0x28, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xd4f0
jmp 0x1f0c3
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, -0x78(%rbp)
callq 0xd7f0
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x48(%rbp)
movl $0x20, %edi
callq 0x8290
movq -0x78(%rbp), %rdx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq -0x48(%rbp), %rsi
callq 0xdad0
jmp 0x1f114
movq -0x70(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0xdb20
movq -0x40(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8260
jmp 0x1f194
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8260
jmp 0x1f194
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8260
jmp 0x1f194
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8260
movq -0x28(%rbp), %rdi
callq 0x8400
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::get_int(unsigned long, unsigned long)
int get_int(size_t col, size_t row) {
      assert(col < this->schema_->width());
      char col_type = this->schema_->col_type(col);
      assert(col_type == 'I');
      DistributedIntColumn* intCol = dynamic_cast<DistributedIntColumn*>(this->cols_->get(col));
      assert(row < this->schema_->length());
      return intCol->get(row);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rdi
callq 0xfc20
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f25b
jmp 0x1f27a
leaq 0xd768(%rip), %rdi      # 0x2c9ca
leaq 0xd77e(%rip), %rsi      # 0x2c9e7
movl $0xa1, %edx
leaq 0xd826(%rip), %rcx      # 0x2ca9b
callq 0x81a0
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xfc40
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x49, %eax
jne 0x1f299
jmp 0x1f2b8
leaq 0xd82d(%rip), %rdi      # 0x2cacd
leaq 0xd740(%rip), %rsi      # 0x2c9e7
movl $0xa3, %edx
leaq 0xd7e8(%rip), %rcx      # 0x2ca9b
callq 0x81a0
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1f2f5
movq -0x40(%rbp), %rdi
leaq 0x1ade1(%rip), %rsi     # 0x3a0c0
leaq 0x1bd62(%rip), %rdx     # 0x3b048
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x48(%rbp)
jmp 0x1f2fd
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x1f2fd
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rdi
callq 0x1d700
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x1f328
jmp 0x1f347
leaq 0xd732(%rip), %rdi      # 0x2ca61
leaq 0xd6b1(%rip), %rsi      # 0x2c9e7
movl $0xa5, %edx
leaq 0xd759(%rip), %rcx      # 0x2ca9b
callq 0x81a0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f360
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::listen()
void listen() {
        std::cout << "started listening on separate thread\n";
        //listen for any incoming requests to the store.
        while (true) {
            Message* message = network_->recv_msg(this);
            //std::cout << "incoming message\n";
            process_message_(message);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x1cbb5(%rip), %rdi     # 0x3bfc0
leaq 0xd6cb(%rip), %rsi      # 0x2cadd
callq 0x8280
movq -0x18(%rbp), %rsi
movq 0x50(%rsi), %rdi
callq 0x1f540
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1f630
jmp 0x1f417
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::process_put_request_(Put*)
void process_put_request_(Put* _put) {
        if (put(_put->key_, _put->value_)) {
            Ack ack(this_node_, _put->sender_, network_->msg_id);
            network_->send_msg(&ack);
        } else {
            Nack nack(this_node_, _put->sender_, network_->msg_id);
            network_->send_msg(&nack);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdx
callq 0xdb20
testb $0x1, %al
jne 0x1f849
jmp 0x1f8b6
movq -0x88(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdx
movq 0x18(%rax), %rsi
movq 0x50(%rax), %rax
movq 0x40(%rax), %rcx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x1fb50
movq -0x88(%rbp), %rax
movq -0x90(%rbp), %rsi
movq 0x50(%rax), %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
jmp 0x1f891
leaq -0x40(%rbp), %rdi
callq 0x1fbb0
jmp 0x1f920
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1fbb0
jmp 0x1f929
movq -0x88(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdx
movq 0x18(%rax), %rsi
movq 0x50(%rax), %rax
movq 0x40(%rax), %rcx
leaq -0x80(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1fbd0
movq -0x88(%rbp), %rax
movq -0x98(%rbp), %rsi
movq 0x50(%rax), %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
jmp 0x1f8fe
leaq -0x80(%rbp), %rdi
callq 0x1fc30
jmp 0x1f920
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1fc30
jmp 0x1f929
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::process_get_request_(Get*)
void process_get_request_(Get* _get) {
        Value* val = get(_get->key_);
        if (val != nullptr) {
            Reply res(val->serialize(), this_node_, _get->sender_, network_->msg_id);
            network_->send_msg(&res);
        } else {
            Nack nack(this_node_, _get->sender_, network_->msg_id);
            network_->send_msg(&nack);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x11740
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1f9f3
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, %rsi
movq -0x98(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x18(%rax), %rdx
movq 0x50(%rax), %rax
movq 0x40(%rax), %r8
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1e5f0
movq -0x98(%rbp), %rax
movq -0xa0(%rbp), %rsi
movq 0x50(%rax), %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
jmp 0x1f9ce
leaq -0x50(%rbp), %rdi
callq 0x1e660
jmp 0x1fa66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1e660
jmp 0x1fa6f
movq -0x98(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rdx
movq 0x18(%rax), %rsi
movq 0x50(%rax), %rax
movq 0x40(%rax), %rcx
leaq -0x90(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1fbd0
movq -0x98(%rbp), %rax
movq -0xa8(%rbp), %rsi
movq 0x50(%rax), %rdi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
jmp 0x1fa3e
leaq -0x90(%rbp), %rdi
callq 0x1fc30
jmp 0x1fa66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1fc30
jmp 0x1fa6f
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x8400
nopl (%rax,%rax)