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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
leaq 0xcdbc(%rip), %rsi      # 0x1837a
xorl %r13d, %r13d
leaq -0x410(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
testl %ebx, %ebx
cmovlel %r13d, %ebx
cmpq %r13, %rbx
je 0xb60f
movsd (%r14,%r13,8), %xmm0
movq %r12, %rdi
leaq 0xcf05(%rip), %rsi      # 0x184fd
movb $0x1, %al
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
incq %r13
jmp 0xb5e3
movq (%r15), %rdi
leaq 0xcd6f(%rip), %rsi      # 0x18388
callq 0x8114
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::get(unsigned long)
double get(size_t index) {
        assert(index < itemCount_);
        //std::cout << "in get " << index <<"\n";
        if (cache_ == nullptr) {
            init_cache_();
        }
        double 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
            DoubleArray* doubleVals;
            if (cache_[key_idx] != nullptr) {
                //std::cout << "get chunk from cache\n";
                doubleVals = cache_[key_idx];
            } else {
                //std::cout << "get chunk from kv\n";
                doubleVals = get_chunk_from_kv_(key_idx);
            }
            res = doubleVals->get(index % chunkSize_);
        }
        //std::cout << "res: " << res << "\n";
        return res; //returns int at correct index in array at this chunk
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq %rsi, 0x58(%rdi)
jbe 0xb6de
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
jne 0xb656
movq %r14, %rdi
callq 0xb6fe
movq 0x48(%r14), %rcx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
cmpq 0x50(%r14), %rax
jne 0xb66e
movq 0x18(%r14), %rdi
jmp 0xb6ca
movq %rax, %xmm0
punpckldq 0xc9e5(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xc9ed(%rip), %xmm0     # 0x18070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
subsd 0xc9e9(%rip), %xmm1     # 0x18088
sarq $0x3f, %rdx
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rax, %rsi
movq 0x20(%r14), %rax
movq (%rax,%rsi,8), %rdi
testq %rdi, %rdi
jne 0xb6ca
movq %r14, %rdi
callq 0xb762
movq %rax, %rdi
movq 0x48(%r14), %rcx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xb27e
leaq 0xce1e(%rip), %rdi      # 0x18503
leaq 0xce2a(%rip), %rsi      # 0x18516
leaq 0xce5d(%rip), %rcx      # 0x18550
movl $0x3a8, %edx            # imm = 0x3A8
callq 0x7170
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::init_cache_()
void init_cache_() {
        //assuming a dataframe is immutable, so nu pushbacks after the first get call.
        cache_ = new DoubleArray*[keys_->length()];
        for (size_t i = 0; i < keys_->length(); i++) {
            cache_[i] = nullptr;
        }
        return;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x18(%rax), %r15
movq %r15, %rax
shrq $0x3d, %rax
leaq (,%r15,8), %rcx
xorl %r14d, %r14d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x7030
movq %rax, 0x20(%rbx)
cmpq %r15, %r14
jae 0xb757
movq 0x20(%rbx), %rax
andq $0x0, (%rax,%r14,8)
incq %r14
movq 0x38(%rbx), %rax
movq 0x18(%rax), %r15
jmp 0xb73c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::get_chunk_from_kv_(unsigned long)
DoubleArray* 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";
        DoubleArray* doubleVals = new DoubleArray(serlializedNode); //turns payload into IntArray object
        cache_[key_idx] = doubleVals;
        cache_count_ += 1;
        return doubleVals;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jb 0xb785
movq %rbx, %rdi
callq 0xb808
movq 0x10(%rbx), %r15
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xb7b8
leaq 0x17b06(%rip), %rsi     # 0x232a8
leaq 0x18027(%rip), %rdx     # 0x237d0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %rsi
jmp 0xb7ba
xorl %esi, %esi
movq %r15, %rdi
callq 0xb84a
movq 0x10(%rax), %r12
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xb998
movq 0x20(%rbx), %rax
movq %r15, (%rax,%r14,8)
incq 0x28(%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::reset_cache_()
void reset_cache_() {
        //std::cout << "reset cache, cache count: " << cache_count_ << "\n";
        for (size_t i = 0; i < keys_->length(); i++) {
            if (cache_[i] != nullptr) {
                //std::cout << "clearing idx: " << i<<"\n";
                delete cache_[i];
                cache_[i] = nullptr;
            }
        }
        cache_count_ = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
cmpq 0x18(%rax), %r14
jae 0xb840
movq 0x20(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xb83b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rax
andq $0x0, (%rax,%r14,8)
incq %r14
jmp 0xb815
andq $0x0, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::get(Key*)
Value* get(Key* key) {
        store_mtx_.lock();
        size_t target = key->node();
        //std::cout << "get: " << "key: " << key->serialize() << "\n";
        Value* val = nullptr;
        if (target == this_node_) {
            std::map<Key*, Value*, KeyCompare>::iterator iter;
            iter = local_store_.find(key);
            if (iter != local_store_.end()) {
                val = iter->second;
            }
        } else {
            Get get(key, this_node_, target, network_->msg_id);
            network_->send_msg(&get); // send get msg over the network to appropriate KVStore.
            store_mtx_.wait();
            Message* m = received_msg;
            //expect Reply or Nack.
            if (m->kind_ == MsgKind::Reply) {
                Reply* resp = dynamic_cast<Reply*>(m);
                char* serializedValue = resp->reply_msg_;
                val = new Value(serializedValue, this);
            } else if (m->kind_ == MsgKind::Nack) {
                std::cout << "unable to get key from node " << target <<"\n";
            }
            received_msg = nullptr;
        }
        store_mtx_.unlock();
        return val;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, -0x30(%rbp)
leaq 0x68(%rdi), %rbx
movq %rbx, %rdi
callq 0xbc5c
movq 0x18(%r12), %r15
movq 0x18(%r14), %rax
cmpq %rax, %r15
jne 0xb8a2
leaq 0x20(%r14), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbc72
addq $0x28, %r14
cmpq %r14, %rax
je 0xb92e
movq 0x28(%rax), %r15
jmp 0xb96b
leaq 0x58(%r14), %r13
movq 0x50(%r14), %rdi
movq 0x40(%rdi), %rcx
leaq -0x68(%rbp), %rsi
andq $0x0, 0x8(%rsi)
leaq 0x183ca(%rip), %rdx     # 0x23c88
movq %rdx, (%rsi)
movl $0x4, 0x10(%rsi)
movq %rax, 0x18(%rsi)
movq %r15, 0x20(%rsi)
movq %rcx, 0x28(%rsi)
movq %r12, 0x30(%rsi)
movq (%rdi), %rax
callq *0x50(%rax)
movq %r13, %rdi
callq 0xbb4a
movq 0xd0(%r14), %rdi
movl 0x10(%rdi), %eax
cmpl $0x1, %eax
je 0xb933
cmpl $0x3, %eax
jne 0xb960
leaq 0x179ef(%rip), %rsi     # 0x232f0
leaq 0x18358(%rip), %rdx     # 0x23c60
xorl %ecx, %ecx
callq 0x72a0
movq 0x30(%rax), %r12
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xbb60
jmp 0xb963
xorl %r15d, %r15d
jmp 0xb96b
movq 0x19686(%rip), %rdi     # 0x24fc0
leaq 0xcc3a(%rip), %rsi      # 0x1857b
callq 0x7240
movq %rax, %rdi
movq %r15, %rsi
callq 0x7190
leaq 0xc791(%rip), %rsi      # 0x180e9
movq %rax, %rdi
callq 0x7240
xorl %r15d, %r15d
andq $0x0, 0xd0(%r14)
movq %rbx, %rdi
callq 0x71a0
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: DoubleArray::DoubleArray(char*)
DoubleArray(char* serialized) {
        char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
        this->arraySize_ = std::stoi(JSONHelper::getValueFromKey("arraySize_", payload)->c_str());
        this->listLength_ = std::stoi(JSONHelper::getValueFromKey("listLength_", payload)->c_str());
        char* vals = JSONHelper::getValueFromKey("vals_", payload)->c_str();
        DoubleArray* temp = new DoubleArray(this->listLength_);
         for(int i = 0; i < this->listLength_; i++) {
             temp->pushBack(std::stod(JSONHelper::getArrayValueAt(vals, i)->c_str()));
         }
         //delete temp;
         this->vals_=temp->vals_;
     }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
andq $0x0, 0x8(%rdi)
leaq 0x181eb(%rip), %rax     # 0x23ba0
movq %rax, (%rdi)
movq %rdi, -0x38(%rbp)
andq $0x0, 0x18(%rdi)
movq %rsi, %rdi
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0xc98d(%rip), %rdi      # 0x18369
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x58(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq -0x38(%rbp), %rcx
movq %rax, 0x20(%rcx)
leaq -0x58(%rbp), %rdi
callq 0x7120
leaq 0xca46(%rip), %rdi      # 0x1846b
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x58(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq -0x38(%rbp), %rbx
movq %rax, 0x18(%rbx)
leaq -0x58(%rbp), %rdi
callq 0x7120
leaq 0xca77(%rip), %rdi      # 0x184e5
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r15
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movl 0x18(%rbx), %esi
movq %rax, %rdi
callq 0xaddc
xorl %r12d, %r12d
leaq -0x58(%rbp), %r13
leaq -0x29(%rbp), %rbx
movq -0x38(%rbp), %rax
cmpq %r12, 0x18(%rax)
jbe 0xbafa
movq %r15, %rdi
movl %r12d, %esi
callq 0xc4c8
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x70f0
movq %r13, %rdi
xorl %esi, %esi
callq 0xc4aa
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movsd %xmm0, (%rax,%rcx,8)
incq %rcx
movq %rcx, 0x18(%r14)
movq %r13, %rdi
callq 0x7120
incq %r12
jmp 0xbaa3
movq 0x10(%r14), %rax
movq -0x38(%rbp), %rcx
movq %rax, 0x10(%rcx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
jmp 0xbb41
jmp 0xbb2e
jmp 0xbb3e
jmp 0xbb2e
jmp 0xbb3e
jmp 0xbb3e
jmp 0xbb3e
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x7120
jmp 0xbb41
jmp 0xbb3e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../store/value.h
// Function: Value::Value(char*, KVStore*)
Value(char* serialized, KVStore* kv) {
        Deserializable* ds = new Deserializable();
        char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
        char* serialData = JSONHelper::getValueFromKey("data", payload)->c_str();
        this->data = serialData;
        if(JSONHelper::isObject(serialData)) {
            this->data = ds->deserialize(serialData, kv)->serialize();
        } else {
            this->data = serialData;
        }
        this->length = std::stoi(JSONHelper::getValueFromKey("length", payload)->c_str());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rdx, %r15
movq %rsi, %r14
leaq 0x1816a(%rip), %rax     # 0x23cf0
movq %rax, (%rdi)
pushq $0x1
popq %rdi
callq 0x7250
movq %rax, %r12
movq %r14, %rdi
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0xc9e9(%rip), %rdi      # 0x18598
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r13
movq %rax, 0x10(%rbx)
movq %rax, %rdi
callq 0xc2d4
testb %al, %al
je 0xbbed
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1358a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq %rax, %r13
movq %r13, 0x10(%rbx)
leaq 0xc9a5(%rip), %rdi      # 0x1859d
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x50(%rbp), %r14
leaq -0x29(%rbp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x70f0
pushq $0xa
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x18(%rbx)
leaq -0x50(%rbp), %rdi
callq 0x7120
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x7120
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./network.h
// Function: Get::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Get");
        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);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xcb88(%rip), %rsi      # 0x188f2
movq %rbx, %rdi
callq 0x7fd8
movl 0x10(%r14), %edx
leaq 0xc4f9(%rip), %rsi      # 0x18276
movq %rbx, %rdi
callq 0x801c
movq 0x18(%r14), %rdx
leaq 0xc4ec(%rip), %rsi      # 0x1827c
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0xc4e1(%rip), %rsi      # 0x18284
movq %rbx, %rdi
callq 0x8062
movq 0x28(%r14), %rdx
leaq 0xc811(%rip), %rsi      # 0x185c7
movq %rbx, %rdi
callq 0x8062
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xc629(%rip), %rsi      # 0x183f8
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbdfd
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../serialize/jsonHelper.h
// Function: JSONHelper::isObject(char*)
static bool isObject(char* s) {
        int len = strlen( s );
        char isObj = '{';
        for(int i = 0; i < len; i++) {
            char temp = s[i];
            if(temp == isObj) {
                return true;
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7110
xorl %esi, %esi
testl %eax, %eax
movl %eax, %ecx
cmovlel %esi, %ecx
movq %rsi, %rdx
cmpq %rsi, %rcx
je 0xc2fd
leaq 0x1(%rdx), %rsi
cmpb $0x7b, (%rbx,%rdx)
jne 0xc2eb
cltq
cmpq %rax, %rdx
setl %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../store/value.h
// Function: Value::hash()
size_t hash() {
        size_t hash = 0;
        for (size_t i = 0; i < strlen(data); ++i) {
            hash += data[i];
        }
        return hash;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x7110
movq %rax, %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xc341
movsbq (%rbx,%rdx), %rsi
addq %rsi, %rax
incq %rdx
jmp 0xc32f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../store/value.h
// Function: Value::equals(Object*)
bool equals(Object* other) {
        if (other == this) return true;
        Value* x = dynamic_cast<Value *>(other);
        if (x == nullptr) return false;
        if (this->length != x->length) return false;
        return strncmp(data, x->data, length) == 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq %rdi, %rsi
je 0xc39c
testq %rsi, %rsi
je 0xc3a0
movq %rdi, %r14
leaq 0x16f45(%rip), %rax     # 0x232a8
leaq 0x179c6(%rip), %rdx     # 0x23d30
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xc3a2
movq 0x18(%r14), %rdx
cmpq 0x18(%rax), %rdx
jne 0xc3a0
movq 0x10(%r14), %rdi
movq 0x10(%rax), %rsi
callq 0x7140
testl %eax, %eax
sete %bl
jmp 0xc3a2
movb $0x1, %bl
jmp 0xc3a2
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../store/value.h
// Function: Value::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Value");
        if(JSONHelper::isObject(data)) {
            sb->write("data", data, false);
        } else {
            sb->write("data", data);
        }
        sb->write("length", length);
        sb->endSerialize();
        char* value = sb->get();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xc1d6(%rip), %rsi      # 0x185a4
movq %rbx, %rdi
callq 0x7fd8
movq 0x10(%r14), %rdi
callq 0xc2d4
movq 0x10(%r14), %rdx
leaq 0xc1ae(%rip), %rsi      # 0x18598
movq %rbx, %rdi
testb %al, %al
je 0xc3fa
xorl %ecx, %ecx
callq 0xa4a2
jmp 0xc3ff
callq 0x844c
movq 0x18(%r14), %rdx
leaq 0xc193(%rip), %rsi      # 0x1859d
movq %rbx, %rdi
callq 0x8062
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x80bc
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../serialize/jsonHelper.h
// Function: JSONHelper::endIndex(char*, char, int)
static int endIndex(char* s, char sym, int pos) {
        int len = strlen( s );
        char end = '}';
        int depth = 1;
        if(sym == '[') {
            end = ']';
        }
        //pull the class name from the serialzed string
        for (int i = pos+1; i < len; i++){
            char temp = s[i];
            if(temp == sym) {
                depth++;
            } else if(temp == end) {
                //full name has been discovered
                depth--;
                if(depth == 0) {
                    return i;
                }
            }
        }
        return -1;
        std::cout<<"ERROR: end not found\n";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %ebx
movq %rdi, %r14
callq 0x7110
xorl %ecx, %ecx
cmpb $0x5b, %bl
setne %cl
shll $0x5, %ecx
orl $0x5d, %ecx
movslq %r15d, %rdi
movslq %eax, %rdx
pushq $0x1
popq %r8
pushq $-0x1
popq %rsi
movq %rdi, %r9
incq %r9
movl %edi, %eax
cmpq %rdx, %r9
jge 0xc49d
movq %r9, %rdi
movsbl (%r14,%r9), %r10d
cmpb %bl, %r10b
je 0xc498
incl %eax
leaq 0x1(%rdi), %r9
cmpl %r10d, %ecx
jne 0xc474
decl %r8d
jne 0xc46c
jmp 0xc49f
incl %r8d
jmp 0xc46c
movl %esi, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: DoubleColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    DoubleColumn* other_ic = dynamic_cast<DoubleColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    for(int i = 0; i < val_->length(); i++) {
      DoubleArray* ia = dynamic_cast<DoubleArray*>(val_->get(i));
      DoubleArray* other_ia = dynamic_cast<DoubleArray*>(other_ic->val_->get(i));
      for(int j = 0; j < ia->length(); j++) {
        if(ia->get(j) != other_ia->get(j)) {
          return false;
        }
      }
    }
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0xc8e2
movq %rdi, %r12
leaq 0x16ad2(%rip), %rax     # 0x232a8
leaq 0x17653(%rip), %rdx     # 0x23e30
xorl %r15d, %r15d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xc8e5
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0xc8(%rax)
movq %rax, %rbx
movq (%r12), %rax
movq %r12, %rdi
callq *0xc8(%rax)
cmpq %rax, %rbx
jne 0xc8e2
xorl %r15d, %r15d
leaq 0x16a80(%rip), %rbx     # 0x232a8
leaq 0x173b1(%rip), %r13     # 0x23be0
movq %r12, -0x30(%rbp)
movq 0x10(%r12), %rdi
cmpq %r15, 0x18(%rdi)
jbe 0xc8f7
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xc865
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r12
jmp 0xc868
xorl %r12d, %r12d
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xc88f
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r13
jmp 0xc892
xorl %r13d, %r13d
xorl %ebx, %ebx
cmpq %rbx, 0x18(%r12)
jbe 0xc8c8
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb27e
movsd %xmm0, -0x38(%rbp)
movq %r13, %rdi
movq %rbx, %rsi
callq 0xb27e
incq %rbx
movsd -0x38(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jne 0xc8e2
jnp 0xc894
jmp 0xc8e2
incq %r15
movq -0x30(%rbp), %r12
leaq 0x169d2(%rip), %rbx     # 0x232a8
leaq 0x17303(%rip), %r13     # 0x23be0
jmp 0xc833
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r15b
jmp 0xc8e5
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: DoubleColumn::hash_me()
size_t hash_me() {
    size_t hash = 0;
    for(int i = 0; i < val_->length(); i++) {
      DoubleArray* ia = dynamic_cast<DoubleArray*>(val_->get(i));
      for(int j = 0; j < ia->length(); j++) {
        hash += ia->get(j);
      }
    }
    return hash;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r13d, %r13d
movq 0x10(%rbx), %rdi
cmpq %r14, 0x18(%rdi)
jbe 0xc9b4
movq (%rdi), %rax
movq %r14, %rsi
callq *0x40(%rax)
testq %rax, %rax
je 0xc94c
movq %rax, %rdi
leaq 0x1696f(%rip), %rsi     # 0x232a8
leaq 0x172a0(%rip), %rdx     # 0x23be0
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r15
jmp 0xc94f
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r12, 0x18(%r15)
jbe 0xc9ac
movq %r15, %rdi
movq %r12, %rsi
callq 0xb27e
movq %r13, %xmm1
punpckldq 0xb6f0(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xb6f8(%rip), %xmm1     # 0x18070
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
addsd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movq %rax, %rcx
subsd 0xb6f0(%rip), %xmm2     # 0x18088
cvttsd2si %xmm2, %r13
sarq $0x3f, %rcx
andq %rcx, %r13
orq %rax, %r13
incq %r12
jmp 0xc952
incq %r14
jmp 0xc913
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: DoubleColumn::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("DoubleColumn");
    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
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xbc2a(%rip), %rsi      # 0x18614
movq %rbx, %rdi
callq 0x7fd8
movl 0x18(%r14), %edx
leaq 0xba6e(%rip), %rsi      # 0x1846b
movq %rbx, %rdi
callq 0x801c
movl 0x1c(%r14), %edx
leaq 0xb959(%rip), %rsi      # 0x18369
movq %rbx, %rdi
callq 0x801c
movl 0x20(%r14), %edx
leaq 0xbbfe(%rip), %rsi      # 0x18621
movq %rbx, %rdi
callq 0x801c
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xb9c1(%rip), %rsi      # 0x183fd
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xca6a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: DoubleColumn::push_back(double)
void push_back(double val) {
    if (listLength_  >= ((arraySize_* val_->length()))) {
      val_->pushBack(new DoubleArray(arraySize_));
    }
    int array_index = listLength_ / arraySize_;
    DoubleArray* da = dynamic_cast<DoubleArray*>(val_->get(array_index));
    da->pushBack(val);
    listLength_++;

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, -0x28(%rbp)
movq %rdi, %rbx
movslq 0x18(%rdi), %rax
movslq 0x1c(%rdi), %r15
movq 0x10(%rdi), %r14
movq %r15, %rcx
imulq 0x18(%r14), %rcx
cmpq %rax, %rcx
ja 0xcb43
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r12
movq %rax, %rdi
movl %r15d, %esi
callq 0xaddc
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x58(%rax)
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %r15d
movq 0x10(%rbx), %r14
cltd
idivl %r15d
movslq %eax, %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
leaq 0x1674e(%rip), %rsi     # 0x232a8
leaq 0x1707f(%rip), %rdx     # 0x23be0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movsd -0x28(%rbp), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
movq %rdx, 0x18(%rax)
incl 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::pushBack(double)
void pushBack(double 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;
        //std::cout << uid_ << " " <<itemCount_ << "\n";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq 0x48(%rdi)
testq %rcx, %rcx
je 0xcc22
testq %rdx, %rdx
jne 0xcc22
movq %rbx, %rdi
movsd %xmm0, -0x10(%rbp)
callq 0xcc48
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
movq %rdx, 0x18(%rax)
movq 0x58(%rbx), %rcx
jmp 0xcc3a
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rsi
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
movq %rsi, 0x18(%rax)
incq %rcx
movq %rcx, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::storeChunk()
void storeChunk() {
        //std::cout << "total nodes: " << totalNodes_ << "\n";
        //creates a unique keyname based on provided ID - could be modified to randomly pick number?
        StrBuff sb;
        sb.c(uid_);
        sb.c("_dist_double_array_chunk_");
        sb.c(chunkCount_);
        String* s = sb.get();
        Key* k = new Key(s->c_str(), curNode_); //create new key with current node and keyName
        keys_->pushBack(k);
        char* serialized = chunkArray_->serialize();
        //std::cout << serialized << "\n";
        kv_->put(k, new Value(serialized, (size_t)0)); //adds new IntArray to kvStore
        delete chunkArray_;
        chunkArray_ = new DoubleArray(chunkSize_); //creates new Int array to store values for new chunk
        curNode_+=1;
        chunkCount_+=1;
        if(curNode_ == totalNodes_) { //starts cycle of chunks on nodes again
            curNode_ = 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
leaq -0x48(%rbp), %r14
andq $0x0, 0x8(%r14)
movq %rdi, %rbx
leaq 0x16796(%rip), %rax     # 0x23400
movq %rax, (%r14)
movq $0xa, 0x18(%r14)
pushq $0xa
popq %rdi
callq 0x7030
movq %rax, 0x10(%r14)
andq $0x0, 0x20(%r14)
movq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0xcd8c
leaq 0xb99d(%rip), %rsi      # 0x18636
movq %r14, %rdi
callq 0x8114
movq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0xcd8c
movq %r14, %rdi
callq 0x81d0
movq %rax, %r15
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq 0x60(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x851c
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x58(%rax)
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r15
movq 0x10(%rbx), %r12
pushq $0x20
popq %rdi
callq 0x7250
andq $0x0, 0x8(%rax)
leaq 0x16fe3(%rip), %rcx     # 0x23cf0
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x98c0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xcd36
movq (%rdi), %rax
callq *0x8(%rax)
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movl 0x48(%rbx), %esi
movq %rax, %rdi
callq 0xaddc
movq %r14, 0x18(%rbx)
movq 0x60(%rbx), %rax
incq %rax
movq %rax, 0x60(%rbx)
incq 0x50(%rbx)
cmpq 0x68(%rbx), %rax
jne 0xcd6a
andq $0x0, 0x60(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcd79
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/primatives.h
// Function: Integer::equals(Object*)
virtual bool equals(Object * other) {
		if (other == nullptr) return false;
		Integer *i = dynamic_cast<Integer*>(other);
        if(i == nullptr) return false;
		return this->val_ == i->val_;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xcf23
movq %rdi, %r14
leaq 0x163ac(%rip), %rax     # 0x232a8
leaq 0x16f95(%rip), %rdx     # 0x23e98
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xcf25
movl 0x10(%r14), %ecx
cmpl 0x10(%rax), %ecx
sete %bl
jmp 0xcf25
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::Schema(Schema&)
Schema(Schema& from) {
        //std::cout<<"entered copy constructor\n";
        this->capacity_ = from.capacity_;
        this->empty_index_ = from.empty_index_;
        this->val_ = new char[this->capacity_ + 1];

        for (size_t i = 0; i < this->empty_index_; i++) {
            this->val_[i] = from.val_[i]; 
        }
        this->num_rows_ = from.num_rows_;
        //std::cout<<"upper bound\n";
        this->col_name_idx = from.col_name_idx->clone();
        //std::cout<<"lower bound\n";
        this->row_name_idx = from.row_name_idx->clone();
        this->col_idx_name = from.col_idx_name->clone();
        this->row_idx_name = from.row_idx_name->clone();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
leaq 0x168b0(%rip), %rax     # 0x237f8
movq %rax, (%rdi)
movq $0x64, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movq 0x10(%rsi), %rdi
movq %rdi, 0x10(%rbx)
movq 0x20(%rsi), %r15
movq %r15, 0x20(%rbx)
incq %rdi
callq 0x7030
movq %rax, 0x18(%rbx)
xorl %eax, %eax
cmpq %r15, %rax
jae 0xcf92
movq 0x18(%r14), %rcx
movb (%rcx,%rax), %cl
movq 0x18(%rbx), %rdx
movb %cl, (%rdx,%rax)
incq %rax
movq 0x20(%rbx), %r15
jmp 0xcf76
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x30(%rbx)
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x38(%rbx)
movq 0x40(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x40(%rbx)
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::equals(Object*)
bool equals(Object  * other) {
      if (other == this) return true;
        DistributedDataFrame* x = dynamic_cast<DistributedDataFrame*>(other);
        if (x == nullptr) return false;
        if (this->ncols() != x->ncols()) return false;
        if (this->nrows() != x->nrows()) return false;
        for (size_t i = 0; i < this->ncols(); i++) {
            if (!(this->cols_->get(i)->equals(x->cols_->get(i)))) { 
                return false; 
            }
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rdi, %rsi
je 0xd206
testq %rsi, %rsi
je 0xd201
movq %rdi, %rbx
leaq 0x16126(%rip), %rax     # 0x232a8
leaq 0x16d77(%rip), %rdx     # 0x23f00
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xd209
movq %rax, %r15
movq 0x10(%rbx), %rax
movq 0x20(%rax), %rdx
movq 0x10(%r15), %rcx
cmpq 0x20(%rcx), %rdx
jne 0xd201
movq 0x28(%rax), %rax
cmpq 0x28(%rcx), %rax
jne 0xd201
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
cmpq 0x20(%rax), %r12
setae %r14b
jae 0xd209
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
movq %rax, %r13
movq 0x18(%r15), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x40(%rax)
movq (%r13), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
incq %r12
testb %al, %al
jne 0xd1c0
jmp 0xd209
xorl %r14d, %r14d
jmp 0xd209
movb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("DistributedDataFrame");
        char * serializedschema = schema_->serialize();
        sb->write("schema_", serializedschema, false);
        char * seralizedcols = cols_->serialize();
        sb->write("cols_", seralizedcols, false);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
     }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xb650(%rip), %rsi      # 0x18890
movq %rbx, %rdi
callq 0x7fd8
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xb64c(%rip), %rsi      # 0x188a5
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xb636(%rip), %rsi      # 0x188ad
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd2a5
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: IntDistributedArray::IntDistributedArray(KVStore*)
IntDistributedArray(KVStore* kv) {
        kv_ = kv;
        totalNodes_ = kv->num_nodes_;
        srand(time(nullptr));
        uid_ = rand();
        curNode_ = 0;
        itemCount_ = 0;
        chunkCount_ = 0;
        keys_ = new Array();
        chunkArray_ = new IntArray(chunkSize_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x16d4a(%rip), %rax     # 0x24028
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq $0x32, 0x30(%rdi)
movq $0x400, 0x48(%rdi)      # imm = 0x400
movq %rsi, 0x10(%rdi)
movq 0x10(%rsi), %rax
movq %rax, 0x68(%rdi)
xorl %edi, %edi
callq 0x7210
movl %eax, %edi
callq 0x7230
callq 0x70a0
cltq
movq %rax, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
andq $0x0, 0x60(%rbx)
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movq %rax, %rdi
callq 0x869c
movq %r14, 0x38(%rbx)
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movl 0x48(%rbx), %esi
movq %rax, %rdi
callq 0xd696
movq %r14, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xd361
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedIntColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    DistributedIntColumn* other_ic = dynamic_cast<DistributedIntColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    IntDistributedArray* other_val_ = dynamic_cast<IntDistributedArray*>(other_ic->val_);
    return this->val_->equals(other_val_);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xd3ee
movq %rdi, %rbx
leaq 0x15f11(%rip), %rax     # 0x232a8
leaq 0x16c62(%rip), %rdx     # 0x24000
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xd3ee
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0xc8(%rax)
movq %rax, %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xc8(%rax)
cmpq %rax, %r15
jne 0xd3ee
movq 0x18(%r14), %rsi
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedIntColumn::serialize()
char* serialize() {
    Serializable sb;
    sb.initSerialize("DistributedIntColumn");
    char * seralizedArr = val_->serialize();
    sb.write("val_", seralizedArr, false);
    sb.endSerialize();
    char* value = sb.get();
    return value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0x7fa0
leaq 0xb25c(%rip), %rsi      # 0x18689
movq %r14, %rdi
callq 0x7fd8
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0xafb7(%rip), %rsi      # 0x183fd
leaq -0x18(%rbp), %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
leaq -0x18(%rbp), %rdi
callq 0x80a8
leaq -0x18(%rbp), %rdi
callq 0x80bc
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xd478
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xd488
jmp 0xd488
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0xd49a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedIntColumn::getColumnOnNode()
Column* getColumnOnNode() override {
    size_t _node = kv_->this_node_;
    IntColumn* col = new IntColumn();
    Array* keys = val_->keys_;
    for (size_t i = 0; i < keys->length(); i++) {
      Key* key = dynamic_cast<Key*>(val_->keys_->get(i));
      if (key->node_ == _node) { //only get the chunks that live locally on this node.
        Value* val = kv_->get(key);
        Deserializable ds;
        IntArray* chunk = dynamic_cast<IntArray*>(ds.deserialize(val->data));
        for (size_t j = 0; j < chunk->length(); j++) {
          col->push_back(chunk->get(j));
        }
        delete chunk;
      }
    }
    //if node 0, append the chunk_array_ at the end too.
    if (_node == 0) {
      IntArray* chunk_array = val_->chunkArray_;
      for (size_t j = 0; j < chunk_array->length(); j++) {
          col->push_back(chunk_array->get(j));
      }
    }
    return col;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movq 0x10(%rdi), %rax
movq 0x18(%rax), %r14
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0xdc84
movq 0x18(%r12), %rax
movq 0x38(%rax), %r13
xorl %r15d, %r15d
movq %r12, -0x40(%rbp)
movq %r13, -0x38(%rbp)
cmpq 0x18(%r13), %r15
jae 0xd5f1
movq 0x18(%r12), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
movq %rax, %rdi
leaq 0x15d4b(%rip), %rsi     # 0x232a8
leaq 0x1626c(%rip), %rdx     # 0x237d0
xorl %ecx, %ecx
callq 0x72a0
cmpq %r14, 0x18(%rax)
jne 0xd5e9
movq 0x10(%r12), %rdi
movq %rax, %rsi
callq 0xb84a
movq 0x10(%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x12f4c
testq %rax, %rax
je 0xd5ad
movq %rax, %rdi
leaq 0x15d0e(%rip), %rsi     # 0x232a8
leaq 0x166a7(%rip), %rdx     # 0x23c48
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r13
jmp 0xd5b0
xorl %r13d, %r13d
xorl %r12d, %r12d
cmpq 0x18(%r13), %r12
jae 0xd5d7
movq %r13, %rdi
movq %r12, %rsi
callq 0xb4cc
movq (%rbx), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq *0x98(%rcx)
incq %r12
jmp 0xd5b3
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
incq %r15
jmp 0xd537
testq %r14, %r14
je 0xd608
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r12), %rax
movq 0x18(%rax), %r14
xorl %r15d, %r15d
cmpq 0x18(%r14), %r15
jae 0xd5f6
movq %r14, %rdi
movq %r15, %rsi
callq 0xb4cc
movq (%rbx), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq *0x98(%rcx)
incq %r15
jmp 0xd614
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: IntDistributedArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        IntDistributedArray *s = dynamic_cast<IntDistributedArray*>(o);
        if(s == nullptr) return false;
        if(itemCount_ != s->itemCount_) return false;
        for(int i = 0; i < itemCount_; i++) {
            bool sameInt = s->get(i) == get(i);
            if(!sameInt) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xd75c
movq %rdi, %rbx
leaq 0x15ba5(%rip), %rax     # 0x232a8
leaq 0x1695e(%rip), %rdx     # 0x24068
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0xd75f
movq %rax, %r15
movq 0x58(%rbx), %rax
cmpq 0x58(%r15), %rax
jne 0xd75c
xorl %r12d, %r12d
cmpq %r12, 0x58(%rbx)
setbe %r14b
jbe 0xd75f
movq %r15, %rdi
movq %r12, %rsi
callq 0xd8ba
movl %eax, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd8ba
incq %r12
cmpl %eax, %r13d
je 0xd72f
jmp 0xd75f
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: IntDistributedArray::hash_me()
size_t hash_me() {
      int temp = 0;
      for(int i = 0; i < itemCount_; i++) {
          temp *= get(i);
      }
      return temp;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq %r14, 0x58(%rbx)
jbe 0xd795
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd8ba
incq %r14
jmp 0xd77f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: IntDistributedArray::get(unsigned long)
int get(size_t index) {
       //new logic to check if current chunk
        assert(index < itemCount_);
        //std::cout << "in get " << index <<"\n";
        if (cache_ == nullptr) {
            init_cache_();
        }
        int 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
            IntArray* doubleVals;
            if (cache_[key_idx] != nullptr) {
                //std::cout << "get chunk from cache\n";
                doubleVals = cache_[key_idx];
            } else {
                //std::cout << "get chunk from kv\n";
                doubleVals = get_chunk_from_kv_(key_idx);
            }
            res = doubleVals->get(index % chunkSize_);
        }
        //std::cout << "res: " << res << "\n";
        return res; //returns int at correct index in array at this chunk
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq %rsi, 0x58(%rdi)
jbe 0xd968
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
jne 0xd8e0
movq %r14, %rdi
callq 0xd986
movq 0x48(%r14), %rcx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
cmpq 0x50(%r14), %rax
jne 0xd8f8
movq 0x18(%r14), %rdi
jmp 0xd954
movq %rax, %xmm0
punpckldq 0xa75b(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xa763(%rip), %xmm0     # 0x18070
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
subsd 0xa75f(%rip), %xmm1     # 0x18088
sarq $0x3f, %rdx
cvttsd2si %xmm1, %rsi
andq %rdx, %rsi
orq %rax, %rsi
movq 0x20(%r14), %rax
movq (%rax,%rsi,8), %rdi
testq %rdi, %rdi
jne 0xd954
movq %r14, %rdi
callq 0xd9ea
movq %rax, %rdi
movq 0x48(%r14), %rcx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xb4cc
leaq 0xab94(%rip), %rdi      # 0x18503
leaq 0xaba0(%rip), %rsi      # 0x18516
leaq 0xacd3(%rip), %rcx      # 0x18650
pushq $0x45
popq %rdx
callq 0x7170
nop