LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::hash()
size_t hash() {
       size_t res = 0;
        for(int i = 0; i < listLength_; i++) {
            //specific code to deal with the union data-type
            res+=objs_[i]->hash();
        }
        return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x18(%rdi)
je 0x8bb2
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq %rax, %r14
incq %r15
cmpq %r15, 0x18(%rbx)
ja 0x8b96
jmp 0x8bb5
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Array");
        sb->write("listLength_", listLength_);
        sb->write("arraySize_", arraySize_);
        sb->write("objs_", objs_, listLength_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x80aa
leaq 0x149b5(%rip), %rsi     # 0x1d5bb
movq %rbx, %rdi
callq 0x810c
movq 0x18(%r14), %rdx
leaq 0x1484d(%rip), %rsi     # 0x1d466
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0x14738(%rip), %rsi     # 0x1d364
movq %rbx, %rdi
callq 0x81e6
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0x1472c(%rip), %rsi     # 0x1d36f
movq %rbx, %rdi
callq 0x8dba
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8c91
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::set(unsigned long, Object*)
virtual Object* set(size_t index, Object* o) {
      if(index > listLength_-1) {
            return nullptr;
        }
        Object* temp = get(index);
        objs_[index] = o;
        if(temp == nullptr) {
            listLength_++;
            return nullptr;
        }
        hash_ = 0; //since list has changed in composition, reset stored hash
        return temp;
  }

// Assembly:
movq 0x18(%rdi), %rax
decq %rax
cmpq %rsi, %rax
jae 0x8ce9
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x10(%rbx), %rcx
movq %r14, (%rcx,%r15,8)
testq %rax, %rax
je 0x8d19
movq $0x0, 0x8(%rbx)
jmp 0x8d1f
incq 0x18(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::remove(unsigned long)
virtual Object* remove(size_t index) {
      if(index > listLength_-1) {
            return nullptr;
        }
        Object* temp = get(index);
        for(int i = index; i<listLength_; i++) {
            if(i < listLength_-1) {
                objs_[i] = objs_[i+1];
            }
        }
        listLength_--;
        hash_ = 0; //since list has changed in composition, reset stored hash
        return temp;
  }

// Assembly:
movq 0x18(%rdi), %rax
decq %rax
cmpq %rsi, %rax
jae 0x8d39
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x18(%rbx), %rcx
movslq %r14d, %rdx
cmpq %rdx, %rcx
jbe 0x8d76
leaq -0x1(%rcx), %rsi
cmpq %rdx, %rsi
jbe 0x8d6e
movq 0x10(%rbx), %rdi
movq 0x8(%rdi,%rdx,8), %r8
movq %r8, (%rdi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
ja 0x8d5c
decq %rcx
movq %rcx, 0x18(%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::pushBack(Object*)
virtual void pushBack(Object* o) {
        int newSize = 1+listLength_;
        extend_array(newSize);
        objs_[listLength_] = o;
        listLength_++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rdi), %esi
incl %esi
callq 0x8ece
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq %rbx, (%rax,%rcx,8)
incq %rcx
movq %rcx, 0x18(%r14)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, Object**, int)
void write(const char* name, Object** val, int len) {
        char str[100000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            char* serial = val[i]->serialize();
            sprintf(str, "%s,", serial);
            buff->c(str);
        }
        buff->c("], ");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x186b8, %rsp          # imm = 0x186B8
movl %ecx, %r14d
movq %rdx, -0x38(%rbp)
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x14593(%rip), %rsi     # 0x1d375
leaq -0x186e0(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq %rbx, -0x30(%rbp)
movq (%rbx), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x8260
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
testl %r14d, %r14d
jle 0x8e90
movl %r14d, %ebx
xorl %r14d, %r14d
movq -0x38(%rbp), %rax
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %r12, %rdi
leaq 0x14535(%rip), %rsi     # 0x1d37f
movq %rax, %rdx
xorl %eax, %eax
callq 0x7080
movq -0x30(%rbp), %rax
movq (%rax), %r13
movq %r12, %rdi
callq 0x7100
movq %rax, %r15
movq %r13, %rdi
movq %rax, %rsi
callq 0x8260
movq 0x10(%r13), %rdi
addq 0x20(%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%r13)
incq %r14
cmpq %r14, %rbx
jne 0x8e32
movq -0x30(%rbp), %rax
movq (%rax), %rbx
movl $0x3, %esi
movq %rbx, %rdi
callq 0x8260
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movb $0x20, 0x2(%rax,%rcx)
movw $0x2c5d, (%rax,%rcx)    # imm = 0x2C5D
addq $0x3, 0x20(%rbx)
addq $0x186b8, %rsp          # imm = 0x186B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::extend_array(int)
void extend_array(int newLength) {
        if(arraySize_ <= newLength) {
            int oldSize = arraySize_;
            arraySize_ = newLength*2;
            Object** newObjs = new Object*[arraySize_];
            for (size_t i = 0; i < oldSize ; i++) {
                newObjs[i] = objs_[i];
            }
            delete [] objs_;
            objs_ = newObjs;
        }
        hash_ = 0; //every time the array is
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r15
movslq %esi, %rax
cmpq %rax, %r15
ja 0x8f43
leal (%rsi,%rsi), %eax
cltq
movq %rax, 0x20(%rbx)
shlq $0x3, %rax
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x7030
movq %rax, %r14
shlq $0x20, %r15
je 0x8f31
sarq $0x20, %r15
movq 0x10(%rbx), %rax
cmpq $0x1, %r15
adcq $0x0, %r15
xorl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq %rdx, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x8f21
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x8f3f
callq 0x72b0
movq %r14, 0x10(%rbx)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../store/key.h
// Function: Key::equals(Object*)
bool equals(Object* other) {
        if (other == this) return true;
        Key* x = dynamic_cast<Key *>(other);
        if (x == nullptr) return false;
        //std::cout << "in key equals: name: " << name_->c_str() << " " << x->name_->c_str() <<"\n";
        //std::cout << res << "\n";
        return this->name_->equals(x->name_) && (this->node_ == x->node_);
    }

// Assembly:
cmpq %rdi, %rsi
je 0x907e
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x9081
leaq 0x1f1e3(%rip), %rax     # 0x28248
leaq 0x1f77c(%rip), %rdx     # 0x287e8
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r14
jmp 0x9084
movb $0x1, %al
retq
xorl %r14d, %r14d
testq %r14, %r14
je 0x90a8
movq 0x10(%rbx), %rdi
movq 0x10(%r14), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x90a8
movq 0x18(%rbx), %rax
cmpq 0x18(%r14), %rax
sete %al
jmp 0x90aa
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../store/key.h
// Function: Key::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Key");
        sb->write("name_", name_);
        sb->write("node_", node_);
        sb->endSerialize();
        char* value = sb->get();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x80aa
leaq 0x14273(%rip), %rsi     # 0x1d3a5
movq %rbx, %rdi
callq 0x810c
movq 0x10(%r14), %rdx
leaq 0x14264(%rip), %rsi     # 0x1d3a9
movq %rbx, %rdi
callq 0x91ac
movq 0x18(%r14), %rdx
leaq 0x14247(%rip), %rsi     # 0x1d39f
movq %rbx, %rdi
callq 0x81e6
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *0x30(%rcx)
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/application.h
// Function: Demo::producer()
void producer() {
    std::cout << "producer\n";
    size_t SZ = 50*1000;
    double* vals = new double[SZ];
    double sum = 0;
    for (size_t i = 0; i < SZ; ++i) sum += vals[i] = i;
    DistributedDataFrame::fromArray(main, kv_, SZ, vals);
    DistributedDataFrame::fromScalar(check, kv_, sum);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20d98(%rip), %rdi     # 0x29fd0
leaq 0x14170(%rip), %rsi     # 0x1d3af
movl $0x9, %edx
callq 0x7290
movl $0x61a80, %edi          # imm = 0x61A80
callq 0x7030
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
movsd %xmm0, (%rax,%rcx,8)
addsd %xmm0, %xmm1
incq %rcx
cmpq $0xc350, %rcx           # imm = 0xC350
jne 0x9259
movq 0x10(%rbx), %rsi
movq 0x20(%rbx), %rdi
movl $0xc350, %edx           # imm = 0xC350
movq %rax, %rcx
movsd %xmm1, -0x10(%rbp)
callq 0x9542
movq 0x10(%rbx), %rsi
movq 0x30(%rbx), %rdi
movsd -0x10(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x967e
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/application.h
// Function: Demo::counter()
void counter() {
    std::cout << "counter\n";
    Deserializable ds;
    Value* val = kv_->waitAndget(main);
    //std::cout << "counter val: " << val->serialize() <<"\n";
    DistributedDataFrame* v = dynamic_cast<DistributedDataFrame*>(ds.deserialize(val->data, kv_));
    size_t sum = 0;
    for (size_t i = 0; i < 50*1000; ++i) sum += v->get_double(0,i);
    p("The sum is  ").pln(sum);
    DistributedDataFrame::fromScalar(verify, kv_, (int)sum);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20d0f(%rip), %rdi     # 0x29fd0
leaq 0x14629(%rip), %rsi     # 0x1d8f1
movl $0x8, %edx
callq 0x7290
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x13efa
movq 0x10(%rax), %rsi
movq 0x10(%rbx), %rdx
leaq -0x21(%rbp), %rdi
callq 0x151da
testq %rax, %rax
je 0x9312
leaq 0x1ef4c(%rip), %rsi     # 0x28248
leaq 0x1fc15(%rip), %rdx     # 0x28f18
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r15
jmp 0x9315
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x1415a
cltq
addq %rax, %r14
incq %r12
cmpq $0xc350, %r12           # imm = 0xC350
jne 0x931b
movq 0x20c90(%rip), %r15     # 0x29fd0
leaq 0x145b3(%rip), %rsi     # 0x1d8fa
movl $0xc, %edx
movq %r15, %rdi
callq 0x7290
movq %r15, %rdi
movq %r14, %rsi
callq 0x7170
leaq 0x13d83(%rip), %rsi     # 0x1d0e9
movl $0x1, %edx
movq %rax, %rdi
callq 0x7290
movq 0x10(%rbx), %rsi
movq 0x28(%rbx), %rdi
movl %r14d, %edx
callq 0x14222
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/application.h
// Function: Demo::summarizer()
void summarizer() {
    std::cout << "summarizer\n";
    Deserializable ds;
    Value* verify_val = kv_->waitAndget(verify);
    Value* check_val = kv_->waitAndget(check);
    std::cout << verify_val->serialize() << "\n";
    std::cout << check_val->serialize() << "\n";
    DistributedDataFrame* result = dynamic_cast<DistributedDataFrame*>(ds.deserialize(verify_val->data, kv_));
    DistributedDataFrame* expected = dynamic_cast<DistributedDataFrame*>(ds.deserialize(check_val->data, kv_));
    pln(expected->get_double(0,0)==result->get_int(0,0) ? "SUCCESS":"FAILURE");
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20c28(%rip), %r12     # 0x29fd0
leaq 0x14646(%rip), %rsi     # 0x1d9f5
movl $0xb, %edx
movq %r12, %rdi
callq 0x7290
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x13efa
movq %rax, %r15
movq 0x10(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x13efa
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
testq %rax, %rax
je 0x9409
movq %rax, %r13
movq %rax, %rdi
callq 0x7100
movq 0x20bd4(%rip), %rdi     # 0x29fd0
movq %r13, %rsi
movq %rax, %rdx
callq 0x7290
jmp 0x9422
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x7380
movq 0x20ba7(%rip), %r12     # 0x29fd0
leaq 0x13cb9(%rip), %rsi     # 0x1d0e9
movl $0x1, %edx
movq %r12, %rdi
callq 0x7290
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
testq %rax, %rax
je 0x946a
movq %rax, %r13
movq %rax, %rdi
callq 0x7100
movq 0x20b73(%rip), %rdi     # 0x29fd0
movq %r13, %rsi
movq %rax, %rdx
callq 0x7290
jmp 0x9483
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x7380
movq 0x20b46(%rip), %rdi     # 0x29fd0
leaq 0x13c58(%rip), %rsi     # 0x1d0e9
movl $0x1, %edx
callq 0x7290
movq 0x10(%r15), %rsi
movq 0x10(%rbx), %rdx
leaq -0x29(%rbp), %rdi
callq 0x151da
testq %rax, %rax
je 0x94ce
leaq 0x1ed90(%rip), %rsi     # 0x28248
leaq 0x1fa59(%rip), %rdx     # 0x28f18
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r15
jmp 0x94d1
xorl %r15d, %r15d
movq 0x10(%r14), %rsi
movq 0x10(%rbx), %rdx
leaq -0x29(%rbp), %rdi
callq 0x151da
leaq 0x1ed5f(%rip), %rsi     # 0x28248
leaq 0x1fa28(%rip), %rdx     # 0x28f18
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1415a
movl %eax, %r14d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x14386
cmpl %eax, %r14d
leaq 0x144e2(%rip), %rax     # 0x1da01
leaq 0x144e3(%rip), %rsi     # 0x1da09
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x1431a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::fromArray(Key*, KVStore*, unsigned long, double*)
static DistributedDataFrame* fromArray(Key* key, KVStore* kv, size_t length, double* vals) {
      Schema s;
      DistributedDoubleColumn* dc = new DistributedDoubleColumn(kv);
      for (size_t i = 0; i < length; i++) {
        //std::cout << i <<" in from array\n";
        s.add_row(nullptr);
        dc->push_back(vals[i]);
      }
      DistributedDataFrame* df = new DistributedDataFrame(s, kv);
      df->add_column(dc, nullptr);
      Value* val = new Value(df->serialize(), (size_t)0);
      kv->put(key, val);
      return df;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9776
movl $0x20, %edi
callq 0x7230
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x9836
testq %r13, %r13
je 0x95a7
xorl %ebx, %ebx
incq -0x58(%rbp)
movsd (%r15,%rbx,8), %xmm0
movq (%r12), %rax
movq %r12, %rdi
callq *0xa0(%rax)
incq %rbx
cmpq %rbx, %r13
jne 0x9588
movl $0x28, %edi
callq 0x7230
movq %rax, %r15
leaq -0x80(%rbp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x9896
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x9a2e
movl $0x20, %edi
callq 0x7230
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%r12)
leaq 0x1f714(%rip), %rdx     # 0x28d08
movq %rdx, (%r12)
movq %rax, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rdx
callq 0x9bbe
leaq 0x1f1f8(%rip), %rax     # 0x28810
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x962a
callq 0x72b0
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9646
movq %rax, %rbx
movq %r15, %rdi
jmp 0x964c
movq %rax, %rbx
movq %r12, %rdi
callq 0x7200
jmp 0x965c
jmp 0x9659
jmp 0x9659
jmp 0x9659
movq %rax, %rbx
leaq 0x1f1ad(%rip), %rax     # 0x28810
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x9675
callq 0x72b0
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::fromScalar(Key*, KVStore*, double)
static DistributedDataFrame* fromScalar(Key* key, KVStore* kv, double scalar) {
      Schema* s = new Schema(); 
      DistributedDoubleColumn* dc = new DistributedDoubleColumn(kv);
      s->add_row(nullptr);
      dc->push_back(scalar);
      DistributedDataFrame* df = new DistributedDataFrame(*s, kv);
      df->add_column(dc, nullptr);
      Value* val = new Value(df->serialize(), (size_t)0);
      kv->put(key, val);
      return df;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movl $0x50, %edi
callq 0x7230
movq %rax, %r15
movq %rax, %rdi
callq 0x9776
movl $0x20, %edi
callq 0x7230
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0x9836
incq 0x28(%r15)
movq (%r13), %rax
movq %r13, %rdi
movsd -0x30(%rbp), %xmm0
callq *0xa0(%rax)
movl $0x28, %edi
callq 0x7230
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x9896
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x9a2e
movl $0x20, %edi
callq 0x7230
movq %rax, %r15
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%r15)
leaq 0x1f5e2(%rip), %rdx     # 0x28d08
movq %rdx, (%r15)
movq %rax, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9bbe
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9763
movq %rax, %rbx
movq %r12, %r15
jmp 0x9766
movq %rax, %rbx
movq %r13, %r15
jmp 0x9766
movq %rax, %rbx
movq %r15, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::Schema()
Schema() {
        this->val_ = new char[this->capacity_ + 1];
        //null terminate the string.
        this->val_[this->capacity_] = '\0';
        this->num_rows_ = 0;

        //initialize the row and col maps.
        this->col_name_idx = new Map();
        this->row_name_idx = new Map();
        this->col_idx_name = new Map();
        this->row_idx_name = new Map();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 0x8(%rdi)
leaq 0x1f082(%rip), %rax     # 0x28810
movq %rax, (%rdi)
movq $0x64, 0x10(%rdi)
movq %r14, 0x20(%rdi)
movl $0x65, %edi
callq 0x7030
movq %rax, 0x18(%rbx)
movb $0x0, 0x64(%rax)
movq %r14, 0x28(%rbx)
movl $0x30, %edi
callq 0x7230
movq %rax, %r14
movq %rax, %rdi
callq 0x9df0
movq %r14, 0x30(%rbx)
movl $0x30, %edi
callq 0x7230
movq %rax, %r14
movq %rax, %rdi
callq 0x9df0
movq %r14, 0x38(%rbx)
movl $0x30, %edi
callq 0x7230
movq %rax, %r14
movq %rax, %rdi
callq 0x9df0
movq %r14, 0x40(%rbx)
movl $0x30, %edi
callq 0x7230
movq %rax, %r14
movq %rax, %rdi
callq 0x9df0
movq %r14, 0x48(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x9822
jmp 0x9822
jmp 0x9822
movq %rax, %rbx
movq %r14, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::DistributedDataFrame(Schema&, KVStore*)
DistributedDataFrame(Schema& schema, KVStore* kv) {
      this->schema_ = new Schema(schema);
      this->cols_ = new Array();
      kv_ = kv;
      for (size_t i = 0; i < this->schema_->width(); i++) {
        char col_type = this->schema_->col_type(i);
        Column* col;
        switch (col_type) {
        case 'I':
          col = new DistributedIntColumn(kv);
          break;
        case 'S':
          col = new DistributedStringColumn(kv);
          break;
        case 'B':
          col = new DistributedBoolColumn(kv);
          break;
        case 'F':
          col = new DistributedFloatColumn(kv);
          break;
        case 'D':
          col = new DistributedDoubleColumn(kv);
          break;
        default:
          col = nullptr;
          break;
        }

        if (col != nullptr) {
          this->cols_->pushBack(col);
        }
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq $0x0, 0x8(%rdi)
leaq 0x1f61c(%rip), %rax     # 0x28ed8
movq %rax, (%rdi)
movl $0x50, %edi
callq 0x7230
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xdb24
movq %r15, 0x10(%r14)
movl $0x28, %edi
callq 0x7230
movq %rax, %r15
movq $0x0, 0x8(%rax)
leaq 0x1ee29(%rip), %rax     # 0x28720
movq %rax, (%r15)
movl $0x28, %edi
callq 0x7030
movq %rax, 0x10(%r15)
movq $0x5, 0x20(%r15)
movq $0x0, 0x18(%r15)
movq %r15, 0x18(%r14)
movq %rbx, 0x20(%r14)
movq 0x10(%r14), %rax
cmpq $0x0, 0x20(%rax)
je 0x99ff
xorl %r12d, %r12d
leaq 0x136cb(%rip), %r13     # 0x1d004
movq 0x18(%rax), %rax
movzbl (%rax,%r12), %eax
xorl %r15d, %r15d
leal -0x42(%rax), %ecx
cmpl $0x7, %ecx
ja 0x9971
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
movl $0x20, %edi
callq 0x7230
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xdc96
jmp 0x99dc
cmpl $0x53, %eax
jne 0x99dc
movl $0x20, %edi
callq 0x7230
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xdc36
jmp 0x99dc
movl $0x20, %edi
callq 0x7230
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xdcf6
jmp 0x99dc
movl $0x20, %edi
callq 0x7230
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0xdbd6
jmp 0x99dc
movl $0x20, %edi
callq 0x7230
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x9836
testq %r15, %r15
je 0x99ee
movq 0x18(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x58(%rax)
incq %r12
movq 0x10(%r14), %rax
cmpq 0x20(%rax), %r12
jb 0x9939
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9a1a
jmp 0x9a1a
jmp 0x9a1a
jmp 0x9a1a
jmp 0x9a1a
jmp 0x9a1a
movq %rax, %rbx
movq %r15, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::Map()
Map() { 
      this->numBuckets_ = 32;
      this->bucketsUsed_ = 0;
      this->items_ = 0;
      this->buckets_ = new Array(32);
      for (size_t i = 0; i < this->numBuckets_; i++) {
        this->buckets_->pushBack(new Queue());
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r15, 0x8(%rdi)
leaq 0x1ea69(%rip), %rax     # 0x28878
movq %rax, (%rdi)
movq $0x20, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl $0x28, %edi
callq 0x7230
movq %rax, %r14
movq %r15, 0x8(%rax)
leaq 0x1e8e7(%rip), %rax     # 0x28720
movq %rax, (%r14)
movl $0x100, %edi            # imm = 0x100
callq 0x7030
movq %rax, 0x10(%r14)
movq $0x20, 0x20(%r14)
movq $0x0, 0x18(%r14)
movq %r14, 0x28(%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x9ea7
xorl %r15d, %r15d
leaq 0x1ea71(%rip), %r12     # 0x288e0
xorl %r13d, %r13d
movq 0x28(%rbx), %r14
movl $0x28, %edi
callq 0x7230
movq %r15, 0x8(%rax)
movq %r12, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r15, 0x20(%rax)
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x58(%rcx)
incq %r13
cmpq 0x10(%rbx), %r13
jb 0x9e72
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::hash()
size_t hash() {
        size_t hash_ = 0;
        for (size_t i = 0; i < this->width(); i++) {
            hash_ += (i + 1) * this->val_[i]; 
        }
        
        return hash_;
    }

// Assembly:
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x9f34
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rdx
negq %rcx
movl $0x1, %esi
xorl %eax, %eax
movsbq -0x1(%rdx,%rsi), %rdi
imulq %rsi, %rdi
addq %rdi, %rax
leaq (%rcx,%rsi), %rdi
incq %rdi
incq %rsi
cmpq $0x1, %rdi
jne 0x9f15
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::equals(Object*)
bool equals(Object* other) {
        if (other == this) return true;
        Schema* x = dynamic_cast<Schema *>(other);
        if (x == nullptr) return false;
        if (this->width() != x->width()) return false;
        for (size_t i = 0; i < this->width(); i++) {
            if ( this->val_[i] != x->col_type(i)) { 
                return false; 
            }
        }
        return true;
    }

// Assembly:
cmpq %rdi, %rsi
je 0x9f68
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x9f6c
leaq 0x1e2f6(%rip), %rax     # 0x28248
leaq 0x1e8f7(%rip), %rdx     # 0x28850
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
jmp 0x9f6e
movb $0x1, %cl
jmp 0x9fba
xorl %eax, %eax
testq %rax, %rax
je 0x9fb2
movq 0x20(%rbx), %rdx
movq 0x20(%rax), %rsi
cmpq %rsi, %rdx
jne 0x9fb2
testq %rdx, %rdx
sete %cl
je 0x9fb4
movq 0x18(%rbx), %rdi
xorl %r8d, %r8d
movb $0x20, %r9b
cmpq %r8, %rsi
jbe 0x9f9f
movq 0x18(%rax), %r9
movb (%r9,%r8), %r9b
cmpb %r9b, (%rdi,%r8)
jne 0x9fb4
incq %r8
cmpq %rdx, %r8
setae %cl
jne 0x9f8f
jmp 0x9fb4
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
andb $0x1, %cl
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Schema");
        sb->write("capacity_", capacity_);
        sb->write("empty_index_", empty_index_);
        sb->write("num_rows_", num_rows_);
        sb->write("val_", this->val_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x80aa
leaq 0x13450(%rip), %rsi     # 0x1d436
movq %rbx, %rdi
callq 0x810c
movq 0x10(%r14), %rdx
leaq 0x13444(%rip), %rsi     # 0x1d43d
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0x1343b(%rip), %rsi     # 0x1d447
movq %rbx, %rdi
callq 0x81e6
movq 0x28(%r14), %rdx
leaq 0x13435(%rip), %rsi     # 0x1d454
movq %rbx, %rdi
callq 0x81e6
movq 0x18(%r14), %rdx
leaq 0x133c6(%rip), %rsi     # 0x1d3f8
movq %rbx, %rdi
callq 0x8576
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa080
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::equals(Object*)
virtual bool equals(Object* o) {
      if (o == nullptr) return false;
      Map *m = dynamic_cast<Map*>(o);
      if (o == nullptr) {
        return false;
      }
      
      if (this->size() != m->size()) return false;

      Object** this_keys = this->keys();
      for (size_t i = 0; i < this->size(); i++) {
        Object* this_val = this->get(this_keys[i]);
        Object* that_val = m->get(this_keys[i]);

        if (!this_val->equals(that_val)) {
          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 0xa19d
movq %rdi, %rbx
leaq 0x1e123(%rip), %rax     # 0x28248
leaq 0x1e78c(%rip), %rdx     # 0x288b8
xorl %r12d, %r12d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r14
movq 0x20(%rbx), %rax
cmpq 0x20(%r14), %rax
jne 0xa1a0
movq %rbx, %rdi
callq 0xa596
cmpq $0x0, 0x20(%rbx)
sete %r12b
je 0xa1a0
movq %rax, %r15
xorl %r13d, %r13d
movq (%r15,%r13,8), %rsi
movq %rbx, %rdi
callq 0xa6de
movq %rax, %r12
movq (%r15,%r13,8), %rsi
movq %r14, %rdi
callq 0xa6de
movq (%r12), %rcx
movq %r12, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
testb %al, %al
je 0xa19d
incq %r13
cmpq 0x20(%rbx), %r13
setae %r12b
jb 0xa162
jmp 0xa1a0
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::clone()
Map* clone() {
      Map *new_map = new Map();
      Object** this_keys = this->keys();
      size_t len = this->size();
      for (size_t i = 0; i < len; i++) {
        new_map->add(this_keys[i], this->get(this_keys[i]));
      }
      return new_map;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r13
movl $0x30, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x9df0
movq %r13, %rdi
callq 0xa596
movq 0x20(%r13), %r14
testq %r14, %r14
movq %rbx, -0x30(%rbp)
je 0xa21b
xorl %ebx, %ebx
movq (%rax,%rbx,8), %r12
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %r15
callq 0xa6de
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xaa76
movq %r15, %rax
incq %rbx
cmpq %rbx, %r14
jne 0xa1ef
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Map");
        sb->write("numBuckets_", numBuckets_);
        sb->write("bucketsUsed_", bucketsUsed_);
        sb->write("items_", items_);
        char * seralizedBuckets = buckets_->serialize();
        sb->write("buckets_", seralizedBuckets, false);
        sb->endSerialize();
        char* value = sb->get();
        
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x80aa
leaq 0x131a1(%rip), %rsi     # 0x1d409
movq %rbx, %rdi
callq 0x810c
movq 0x10(%r14), %rdx
leaq 0x13192(%rip), %rsi     # 0x1d40d
movq %rbx, %rdi
callq 0x81e6
movq 0x18(%r14), %rdx
leaq 0x1318b(%rip), %rsi     # 0x1d419
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %rdx
leaq 0x13185(%rip), %rsi     # 0x1d426
movq %rbx, %rdi
callq 0x81e6
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x13173(%rip), %rsi     # 0x1d42d
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa9d0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa30d
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::hash()
size_t hash() {
    size_t res = 0;
    if (this->size() > 0) {
      size_t len = this->size();
      //go through the given list.
      ObjectNode *curNode = this->head_;
      for (size_t i = 0; i < len; i++) {
        Object *data = curNode->data_;
        //add the data's hash val to result.
        res += data->hash();
      }
    }
    return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0xa367
movq 0x10(%rdi), %r15
xorl %ebx, %ebx
movq 0x10(%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq %rax, %rbx
decq %r14
jne 0xa353
jmp 0xa369
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::equals(Object*)
bool equals(Object* o) {
    //if the given object is a nullptr, it's not equal to this.
    if (o == nullptr) return false;
    //if the given pointer is not an ObjectQueue, it's not equal to this.
		Queue *other = dynamic_cast<Queue*>(o);
    //if two queue's don't have the same size they're not equal.
    if (this->size_ != other->size()) {
      return false;
    }

    if (this->size_ > 0) {
      ObjectNode *node1 = this->head_;
      ObjectNode *node2 = other->head_;
      for (size_t i = 0; i < this->size_; i++) {
        //if the node's at the corresponding indices are not the same, the queue's are not equal. 
        if (!(node1->equals(node2))) {
          return false;
        }
        //shift the respective node pointers to the next elements.
        node1 = node1->getNext();
        node2 = node2->getNext();
      }
      return true;

    } else {
      //queue's of size 0 are equal.
      return true;
    } 
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xa408
movq %rdi, %rbx
leaq 0x1deb3(%rip), %rax     # 0x28248
leaq 0x1e584(%rip), %rdx     # 0x28920
xorl %r12d, %r12d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
movq 0x20(%rbx), %rcx
cmpq 0x20(%rax), %rcx
jne 0xa410
testq %rcx, %rcx
je 0xa40d
cmpq $0x0, 0x20(%rbx)
sete %r12b
je 0xa410
movq 0x10(%rax), %r14
movq 0x10(%rbx), %r15
xorl %r13d, %r13d
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x18(%rax)
testb %al, %al
je 0xa408
movq (%r15), %rax
movq %r15, %rdi
callq *0x40(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
movq %rax, %r14
incq %r13
cmpq 0x20(%rbx), %r13
setae %r12b
jb 0xa3d1
jmp 0xa410
xorl %r12d, %r12d
jmp 0xa410
movb $0x1, %r12b
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("Queue");
    sb->write("size_", size_);
    Object** objs_ = new Object*[this->size_];
    //go through the given list.
    for (size_t i = 0; i < this->size_; i++) {
        objs_[i] =  this->get(i);
    }
    sb->write("queueObjs_", objs_, this->size_);
    sb->endSerialize();
    char* value = sb->get();
    delete sb;
    return value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x80aa
leaq 0x12f67(%rip), %rsi     # 0x1d3b9
movq %rbx, %rdi
callq 0x810c
movq 0x20(%r14), %rdx
leaq 0x12f5a(%rip), %rsi     # 0x1d3bf
movq %rbx, -0x40(%rbp)
movq %rbx, %rdi
callq 0x81e6
movq 0x20(%r14), %r12
movq %r12, %rax
shrq $0x3d, %rax
leaq (,%r12,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x7030
movq %rax, -0x38(%rbp)
testq %r12, %r12
je 0xa508
xorl %r13d, %r13d
movq %r14, -0x30(%rbp)
movq 0x10(%r14), %rax
movq %r13, %rcx
shlq $0x20, %rcx
je 0xa4de
movslq %r13d, %rbx
leaq -0x1(%r12), %r15
xorl %r14d, %r14d
movq (%rax), %rcx
movq %rax, %rdi
callq *0x40(%rcx)
cmpq %r14, %r15
je 0xa4ee
incq %r14
cmpq %r14, %rbx
jne 0xa4bc
cmpq %r12, %r14
setb %cl
movq -0x30(%rbp), %r14
jmp 0xa4e0
movb $0x1, %cl
testb %cl, %cl
je 0xa4ea
movq 0x10(%rax), %rax
jmp 0xa4f4
xorl %eax, %eax
jmp 0xa4f4
xorl %eax, %eax
movq -0x30(%rbp), %r14
movq -0x38(%rbp), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
movq 0x20(%r14), %r12
cmpq %r12, %r13
jb 0xa4a4
leaq 0x12eb6(%rip), %rsi     # 0x1d3c5
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq -0x38(%rbp), %rdx
movl %r12d, %ecx
callq 0x8dba
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa568
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::keys()
Object** keys() {
      Object** keys = new Object*[this->items_];
      size_t index_to_assign = 0;
      for (size_t i = 0; i < this->numBuckets_; i++) {
        Queue *queue_at_index = dynamic_cast<Queue*>(this->buckets_->get(i));
        for (size_t j = 0; j < queue_at_index->size(); j++) {
          KeyVal *key_val = dynamic_cast<KeyVal *>(queue_at_index->get(j));
          keys[index_to_assign] = key_val->getKey();
          index_to_assign +=1;
        }
      }
      return keys;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq %rax, %rcx
shrq $0x3d, %rcx
shlq $0x3, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x7030
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x10(%rbx)
je 0xa6cb
xorl %r14d, %r14d
xorl %esi, %esi
movq %rbx, -0x48(%rbp)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movq %rsi, -0x50(%rbp)
callq *0x40(%rax)
testq %rax, %rax
je 0xa611
movq %rax, %rdi
leaq 0x1dc4a(%rip), %rsi     # 0x28248
leaq 0x1e31b(%rip), %rdx     # 0x28920
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rbx
jmp 0xa613
xorl %ebx, %ebx
movq 0x20(%rbx), %r15
testq %r15, %r15
je 0xa6b6
xorl %r12d, %r12d
movq %rbx, -0x30(%rbp)
movq 0x10(%rbx), %rax
movq %r12, %rcx
shlq $0x20, %rcx
je 0xa668
movq %r14, -0x40(%rbp)
movslq %r12d, %r14
leaq -0x1(%r15), %rbx
xorl %r13d, %r13d
movq (%rax), %rcx
movq %rax, %rdi
callq *0x40(%rcx)
cmpq %r13, %rbx
je 0xa678
incq %r13
cmpq %r13, %r14
jne 0xa642
cmpq %r15, %r13
setb %cl
movq -0x40(%rbp), %r14
movq -0x30(%rbp), %rbx
jmp 0xa66a
movb $0x1, %cl
testb %cl, %cl
je 0xa674
movq 0x10(%rax), %rdi
jmp 0xa682
xorl %edi, %edi
jmp 0xa682
xorl %edi, %edi
movq -0x40(%rbp), %r14
movq -0x30(%rbp), %rbx
leaq 0x1dbbf(%rip), %rsi     # 0x28248
leaq 0x1e2a8(%rip), %rdx     # 0x28938
xorl %ecx, %ecx
callq 0x7280
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
incq %r12
movq 0x20(%rbx), %r15
cmpq %r15, %r12
jb 0xa627
movq -0x50(%rbp), %rsi
incq %rsi
movq -0x48(%rbp), %rbx
cmpq 0x10(%rbx), %rsi
jb 0xa5e1
movq -0x38(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::get(Object*)
Object* get(Object* key) {
      //std::cout << "Map get: " << "key: " << key->serialize() << "\n";
      size_t key_hash = key->hash();
      //std::cout << "get hash" << key_hash << "\n";
      KeyVal *wrappedkey = new KeyVal(key, nullptr);
      size_t index = key_hash % this->numBuckets_;
      //std::cout << "map get queue index: " << index << " num buckets: "<< numBuckets_<<"\n";
      Queue *queue_at_index = dynamic_cast<Queue*>(this->buckets_->get(index));
      //std::cout << "get queue: " << queue_at_index->serialize() << "\n";
      Object* keyVal = queue_at_index->get(wrappedkey);
      if (keyVal != nullptr) {
        //key is in map.
        //std::cout << "found key in map\n";
        KeyVal *key_val = dynamic_cast<KeyVal*>(keyVal);
        Object* val = key_val->getVal();
        // if (val == nullptr) {
        //   std::cout << "val is null " << "\n";
        // }
        // std::cout << "val is not null " << "\n";
        return val;
      } else {
        std::cout << "ERROR: Key not found in map" << "key: " << key->serialize() << "\n";
        //key is not in map
        //std::cout<<"ERROR: Key not found in map\n";
        return nullptr;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movq %rax, %r12
movl $0x20, %edi
callq 0x7230
movq %rax, %r14
xorl %eax, %eax
movq %rax, 0x8(%r14)
leaq 0x1e24b(%rip), %rcx     # 0x28960
movq %rcx, (%r14)
movq %rbx, 0x10(%r14)
movq %rax, 0x18(%r14)
movq %r12, %rax
xorl %edx, %edx
divq 0x10(%r15)
movq 0x28(%r15), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x40(%rax)
leaq 0x1db0b(%rip), %rsi     # 0x28248
leaq 0x1e1dc(%rip), %rdx     # 0x28920
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rdi
movq %r14, %rsi
callq 0xa816
testq %rax, %rax
je 0xa77f
leaq 0x1dae3(%rip), %rsi     # 0x28248
leaq 0x1e1cc(%rip), %rdx     # 0x28938
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq 0x18(%rax), %rax
jmp 0xa80d
movq 0x1f84a(%rip), %r14     # 0x29fd0
leaq 0x12c43(%rip), %rsi     # 0x1d3d0
movl $0x1b, %edx
movq %r14, %rdi
callq 0x7290
leaq 0x13119(%rip), %rsi     # 0x1d8ba
movl $0x5, %edx
movq %r14, %rdi
callq 0x7290
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
testq %rax, %rax
je 0xa7db
movq %rax, %rbx
movq %rax, %rdi
callq 0x7100
movq 0x1f802(%rip), %rdi     # 0x29fd0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7290
jmp 0xa7f3
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x7380
movq 0x1f7d6(%rip), %rdi     # 0x29fd0
leaq 0x128e8(%rip), %rsi     # 0x1d0e9
movl $0x1, %edx
callq 0x7290
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::get(Object*)
Object *get(Object* o) {
    if (this->size() > 0) {
      size_t len = this->size();
      //std::cout << "in queue get, size: " << len << "\n";
      //go through the given list.
      ObjectNode *curNode = this->head_;
      for (size_t i = 0; i < len; i++) {
        if (curNode->data_->equals(o)) {
          //std::cout << "found key: "<< curNode->data_->serialize() <<"\n";
          return curNode->data_;
        }
        curNode = curNode ->getNext();
      }
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0xa882
movq %rsi, %r14
movq 0x10(%rdi), %rbx
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb $0x1, %cl
testb %al, %al
jne 0xa876
leaq -0x1(%r15), %r13
xorl %r12d, %r12d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
cmpq %r12, %r13
je 0xa87c
movq %rax, %rbx
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
incq %r12
testb %al, %al
je 0xa84b
cmpq %r15, %r12
setb %cl
movq 0x10(%rbx), %rax
jmp 0xa87e
xorl %ecx, %ecx
testb %cl, %cl
jne 0xa884
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/keyVal.h
// Function: KeyVal::equals(Object*)
virtual bool equals(Object *other) {
        if (other == nullptr) return false;
		KeyVal *kv = dynamic_cast<KeyVal*>(other);
		if (kv == nullptr) {
			return false;
		}
        //std::cout << "in KevVal equals: " << "key: " << key_->serialize() << " val: " << val_->serialize() << "\n";
        //it is okay to only check if the keys because in a map one key only maps to a single value. 
		return this->getKey()->equals(kv->getKey());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xa8e3
movq %rdi, %rbx
leaq 0x1d995(%rip), %rax     # 0x28248
leaq 0x1e07e(%rip), %rdx     # 0x28938
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xa8e3
movq 0x10(%rbx), %rdi
movq 0x10(%rax), %rsi
movq (%rdi), %rax
movq 0x18(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yasz24[P]eau2/src/network/./../application/../store/../utils/keyVal.h
// Function: KeyVal::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("KeyVal");
        char * seralizedKey = key_->serialize();
        sb->write("key_", seralizedKey, false);
        char * seralizedVal = val_->serialize();
        sb->write("val_", seralizedVal, false);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x8, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
callq 0x80aa
leaq 0x12aca(%rip), %rsi     # 0x1d3ec
movq %rbx, %rdi
callq 0x810c
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x12ab8(%rip), %rsi     # 0x1d3f3
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa9d0
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x12a9f(%rip), %rsi     # 0x1d3f8
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa9d0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x8260
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa9ac
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7200
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop