LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
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 0x1158b
movq -0x40(%rbp), %rdi
callq 0x11690
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 0x115d0
movq -0x48(%rbp), %rdi
leaq 0x28b06(%rip), %rsi     # 0x3a0c0
leaq 0x2916f(%rip), %rdx     # 0x3a730
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x58(%rbp)
jmp 0x115d8
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x115d8
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 0x119f0
jmp 0x11614
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/../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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x38(%rax), %rdi
callq 0x11670
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x11728
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x11718
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x11704
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x1171a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x116ac
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./network.h
// Function: Get::Get(Key*, unsigned long, unsigned long, unsigned long)
Get(Key* key, size_t sender, size_t target, size_t id) {
        kind_ = (MsgKind)4; 
        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 0x28d8c(%rip), %rcx     # 0x3acc0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x4, 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/./../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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x9780
movq -0x78(%rbp), %rax
leaq 0x28d69(%rip), %rcx     # 0x3ad38
movq %rcx, (%rax)
movl $0x1, %edi
callq 0x8290
movq %rax, -0x70(%rbp)
jmp 0x11fe2
movq -0x70(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12b70
movq %rax, -0x80(%rbp)
jmp 0x11ff9
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, -0x88(%rbp)
jmp 0x1200f
movq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq 0x1a5f8(%rip), %rdi     # 0x2c61d
callq 0x12db0
movq %rax, -0x90(%rbp)
jmp 0x12033
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, -0x98(%rbp)
jmp 0x1204c
movq -0x78(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rdi
callq 0x13010
movb %al, -0x99(%rbp)
jmp 0x12074
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x12080
jmp 0x120d5
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x21400
movq %rax, -0xa8(%rbp)
jmp 0x1209a
movq -0xa8(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0xb0(%rbp)
jmp 0x120b3
movq -0x78(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x120e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x121ae
movq -0x78(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rsi
leaq 0x1a536(%rip), %rdi     # 0x2c622
callq 0x12db0
movq %rax, -0xb8(%rbp)
jmp 0x120fa
movq -0xb8(%rbp), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, -0xc0(%rbp)
jmp 0x12113
leaq -0x61(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x8410
movq -0xc0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x8310
jmp 0x1213c
xorl %eax, %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
movl $0xa, %edx
callq 0x89a0
movl %eax, -0xcc(%rbp)
jmp 0x12156
movq -0x78(%rbp), %rax
movl -0xcc(%rbp), %ecx
movslq %ecx, %rcx
movq %rcx, 0x18(%rax)
leaq -0x60(%rbp), %rdi
callq 0x8190
leaq -0x61(%rbp), %rdi
callq 0x82d0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x121a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8190
leaq -0x61(%rbp), %rdi
callq 0x82d0
movq -0x78(%rbp), %rdi
callq 0x9830
movq -0x28(%rbp), %rdi
callq 0x8400
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x9e10
jmp 0x1258f
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1a3d5(%rip), %rsi     # 0x2c977
callq 0x9e70
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %edx
leaq 0x19d42(%rip), %rsi     # 0x2c2fb
callq 0x9ed0
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x19d30(%rip), %rsi     # 0x2c301
callq 0x9f30
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x19d20(%rip), %rsi     # 0x2c309
callq 0x9f30
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rdx
leaq 0x1a04b(%rip), %rsi     # 0x2c64c
callq 0x9f30
movq -0x40(%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 0x19e56(%rip), %rsi     # 0x2c47d
xorl %ecx, %ecx
callq 0xf190
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x12664
movq -0x48(%rbp), %rdi
callq 0x9ff0
movq -0x48(%rbp), %rdi
callq 0x8260
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8130
movl %eax, -0x14(%rbp)
movb $0x7b, -0x15(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x13068
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movsbl -0x1d(%rbp), %eax
movsbl -0x15(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1305b
movb $0x1, -0x1(%rbp)
jmp 0x1306c
jmp 0x1305d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13033
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rdi
callq 0x8130
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x1313c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movsbq (%rax,%rcx), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x130f4
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x13177
movb $0x1, -0x1(%rbp)
jmp 0x131ff
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x131a6
movq -0x30(%rbp), %rdi
leaq 0x26f30(%rip), %rsi     # 0x3a0c0
leaq 0x27be1(%rip), %rdx     # 0x3ad78
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x38(%rbp)
jmp 0x131ae
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x131ae
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x131c3
movb $0x0, -0x1(%rbp)
jmp 0x131ff
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x131db
movb $0x0, -0x1(%rbp)
jmp 0x131ff
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq 0x18(%rax), %rdx
callq 0x8150
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
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 0x1323f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x193d7(%rip), %rsi     # 0x2c629
callq 0x9e70
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x13010
testb $0x1, %al
jne 0x1326a
jmp 0x1329d
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
leaq 0x193a0(%rip), %rsi     # 0x2c61d
xorl %ecx, %ecx
callq 0xf190
jmp 0x132b5
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x132ed
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
leaq 0x1936d(%rip), %rsi     # 0x2c61d
callq 0xa6f0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x1935a(%rip), %rsi     # 0x2c622
callq 0x9f30
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8130
movl %eax, -0x1c(%rbp)
movb $0x7d, -0x1d(%rbp)
movl $0x1, -0x24(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x5b, %eax
jne 0x13339
movb $0x5d, -0x1d(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x133a3
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1336f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x13396
movsbl -0x29(%rbp), %eax
movsbl -0x1d(%rbp), %ecx
cmpl %ecx, %eax
jne 0x13394
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x13392
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x133aa
jmp 0x13394
jmp 0x13396
jmp 0x13398
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x13342
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
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 0x13d1c
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 0x13c65
movq -0x40(%rbp), %rdi
leaq 0x26471(%rip), %rsi     # 0x3a0c0
leaq 0x26fd2(%rip), %rdx     # 0x3ac28
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x48(%rbp)
jmp 0x13c6d
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x13c6d
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 0x13950
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x13d0c
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x10c80
movaps %xmm0, %xmm1
movaps 0x18360(%rip), %xmm2    # 0x2c010
movq -0x10(%rbp), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x1835f(%rip), %xmm2    # 0x2c020
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x183dd(%rip), %xmm1    # 0x2c0c8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x13c7c
jmp 0x13d0e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13c03
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x9e10
jmp 0x13d5f
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x18927(%rip), %rsi     # 0x2c699
callq 0x9e70
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x18(%rax), %edx
leaq 0x18767(%rip), %rsi     # 0x2c4f0
callq 0x9ed0
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x1c(%rax), %edx
leaq 0x1864e(%rip), %rsi     # 0x2c3ee
callq 0x9ed0
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x20(%rax), %edx
leaq 0x188ef(%rip), %rsi     # 0x2c6a6
callq 0x9ed0
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x186a5(%rip), %rsi     # 0x2c482
xorl %ecx, %ecx
callq 0xf190
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x13e1a
movq -0x48(%rbp), %rdi
callq 0x9ff0
movq -0x48(%rbp), %rdi
callq 0x8260
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/column.h
// Function: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movslq 0x18(%rax), %rcx
movq %rcx, -0x30(%rbp)
movslq 0x1c(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rdi
callq 0x11670
movq -0x38(%rbp), %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
imulq %rdx, %rcx
cmpq %rcx, %rax
jb 0x13f9b
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 0x10490
jmp 0x13f74
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x13f9b
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x14019
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 0x13fe8
movq -0x58(%rbp), %rdi
leaq 0x260ee(%rip), %rsi     # 0x3a0c0
leaq 0x26c4f(%rip), %rdx     # 0x3ac28
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x60(%rbp)
jmp 0x13ff0
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x13ff0
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x133c0
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: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x58(%rcx), %rax
xorl %edx, %edx
divq 0x48(%rcx)
cmpq $0x0, %rdx
jne 0x14101
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x14101
movq -0x18(%rbp), %rdi
callq 0x14130
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x133c0
jmp 0x14113
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x133c0
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/../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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x14775
movb $0x0, -0x1(%rbp)
jmp 0x147d7
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x147a4
movq -0x30(%rbp), %rdi
leaq 0x25932(%rip), %rsi     # 0x3a0c0
leaq 0x2674b(%rip), %rdx     # 0x3aee0
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x38(%rbp)
jmp 0x147ac
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x147ac
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x147c1
movb $0x0, -0x1(%rbp)
jmp 0x147d7
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x9780
movq -0x38(%rbp), %rax
leaq 0x25f40(%rip), %rcx     # 0x3a758
movq %rcx, (%rax)
movq $0x64, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rax), %rdi
incq %rdi
callq 0x8030
movq %rax, -0x30(%rbp)
jmp 0x14855
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq 0x20(%rcx), %rax
jae 0x148bd
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x28(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x14869
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9830
jmp 0x1495f
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq %rax, -0x40(%rbp)
jmp 0x148e4
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq %rax, -0x48(%rbp)
jmp 0x14907
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq %rax, -0x50(%rbp)
jmp 0x1492a
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq %rax, -0x58(%rbp)
jmp 0x1494d
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x48(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8400
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x14c67
movb $0x1, -0x1(%rbp)
jmp 0x14d81
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x14c96
movq -0x38(%rbp), %rdi
leaq 0x25440(%rip), %rsi     # 0x3a0c0
leaq 0x262c1(%rip), %rdx     # 0x3af48
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x14c9e
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x14c9e
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14cb6
movb $0x0, -0x1(%rbp)
jmp 0x14d81
movq -0x30(%rbp), %rdi
callq 0x1d6c0
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1d6c0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x14ce1
movb $0x0, -0x1(%rbp)
jmp 0x14d81
movq -0x30(%rbp), %rdi
callq 0x1d6e0
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1d6e0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
je 0x14d09
movb $0x0, -0x1(%rbp)
jmp 0x14d81
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x1d6c0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x14d7d
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0x14d6d
movb $0x0, -0x1(%rbp)
jmp 0x14d81
jmp 0x14d6f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x14d11
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
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 0x14dbf
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x17b43(%rip), %rsi     # 0x2c915
callq 0x9e70
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x17b32(%rip), %rsi     # 0x2c92a
xorl %ecx, %ecx
callq 0xf190
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x17b12(%rip), %rsi     # 0x2c932
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 0x14e5d
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/./../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
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 0x261b8(%rip), %rcx     # 0x3b070
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 0x14f39
movq -0x28(%rbp), %rdi
callq 0xab80
jmp 0x14f44
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x38(%rbp)
jmp 0x14f60
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x15610
jmp 0x14f72
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 0x14fbe
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x14fbe
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: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15048
movb $0x0, -0x1(%rbp)
jmp 0x150e7
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x15077
movq -0x38(%rbp), %rdi
leaq 0x2505f(%rip), %rsi     # 0x3a0c0
leaq 0x25fe0(%rip), %rdx     # 0x3b048
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x1507f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x1507f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x15094
movb $0x0, -0x1(%rbp)
jmp 0x150e7
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 0x150c4
movb $0x0, -0x1(%rbp)
jmp 0x150e7
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x9e10
movq -0x38(%rbp), %rdi
leaq 0x175c2(%rip), %rsi     # 0x2c70e
callq 0x9e70
jmp 0x15153
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x48(%rbp)
jmp 0x1516a
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
leaq 0x17305(%rip), %rsi     # 0x2c482
leaq -0x10(%rbp), %rdi
xorl %ecx, %ecx
callq 0xf190
jmp 0x1518a
leaq -0x10(%rbp), %rdi
callq 0x9f90
jmp 0x15195
leaq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x50(%rbp)
jmp 0x151a4
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x9ff0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x9ff0
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x15718
movb $0x0, -0x1(%rbp)
jmp 0x157da
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x15747
movq -0x38(%rbp), %rdi
leaq 0x2498f(%rip), %rsi     # 0x3a0c0
leaq 0x25978(%rip), %rdx     # 0x3b0b0
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x1574f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x1574f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x15764
movb $0x0, -0x1(%rbp)
jmp 0x157da
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x58(%rcx), %rax
je 0x1577c
movb $0x0, -0x1(%rbp)
jmp 0x157da
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x157d6
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x159e0
movq -0x30(%rbp), %rdi
movl %eax, -0x44(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x159e0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x157c9
movb $0x0, -0x1(%rbp)
jmp 0x157da
jmp 0x157cb
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15783
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movslq -0x10(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x1583f
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x159e0
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x15812
movslq -0xc(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
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 0x15a04
jmp 0x15a23
leaq 0x16b7d(%rip), %rdi     # 0x2c588
leaq 0x16b89(%rip), %rsi     # 0x2c59b
movl $0x45, %edx
leaq 0x16cb7(%rip), %rcx     # 0x2c6d5
callq 0x81a0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x15a37
movq -0x30(%rbp), %rdi
callq 0x15b10
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq 0x48(%rcx)
cmpq 0x50(%rcx), %rax
jne 0x15a6d
movq -0x30(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq 0x48(%rcx)
movq %rdx, %rsi
callq 0x11120
movl %eax, -0x14(%rbp)
jmp 0x15b07
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 0x16627(%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 0x15ad9
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x15aea
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x15bb0
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 0x11120
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: IntDistributedArray::init_cache_()
void init_cache_() {
        //assuming a dataframe is immutable, so nu pushbacks after the first get call.
        cache_ = new IntArray*[keys_->length()];
        for (size_t i = 0; i < keys_->length(); i++) {
            cache_[i] = nullptr;
        }
        return;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x38(%rax), %rdi
callq 0x11670
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x38(%rax), %rdi
callq 0x11670
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x15ba4
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x15b61
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: IntDistributedArray::get_chunk_from_kv_(unsigned long)
IntArray* 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";
        IntArray* doubleVals = new IntArray(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 0x15bdb
movq -0x40(%rbp), %rdi
callq 0x15cc0
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 0x15c20
movq -0x48(%rbp), %rdi
leaq 0x244b6(%rip), %rsi     # 0x3a0c0
leaq 0x24b1f(%rip), %rdx     # 0x3a730
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x58(%rbp)
jmp 0x15c28
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x15c28
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 0x15d70
jmp 0x15c64
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: IntColumn::hash_me()
size_t hash_me() {
    size_t hash = 0;
    for(int i = 0; i < val_->length(); i++) {
      IntArray* ia = dynamic_cast<IntArray*>(val_->get(i));
      for(int j = 0; j < ia->length(); j++) {
        hash += ia->get(j);
      }
    }
    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 0x165fb
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 0x16595
movq -0x40(%rbp), %rdi
leaq 0x23b41(%rip), %rsi     # 0x3a0c0
leaq 0x2470a(%rip), %rdx     # 0x3ac90
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x48(%rbp)
jmp 0x1659d
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x1659d
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 0x16290
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x165eb
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x11120
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x165ac
jmp 0x165ed
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16533
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop