LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8094
leaq 0x142a3(%rip), %rsi     # 0x1d3a5
movq %rbx, %rdi
callq 0x80f6
movq 0x10(%r14), %rdx
leaq 0x14294(%rip), %rsi     # 0x1d3a9
movq %rbx, %rdi
callq 0x917c
movq 0x18(%r14), %rdx
leaq 0x14277(%rip), %rsi     # 0x1d39f
movq %rbx, %rdi
callq 0x81d0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82ba
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_O3/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 0x1fdc8(%rip), %rdi     # 0x28fd0
leaq 0x141a0(%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 0x9229
movq 0x10(%rbx), %rsi
movq 0x20(%rbx), %rdi
movl $0xc350, %edx           # imm = 0xC350
movq %rax, %rcx
movsd %xmm1, -0x10(%rbp)
callq 0x9512
movq 0x10(%rbx), %rsi
movq 0x30(%rbx), %rdi
movsd -0x10(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x964e
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1fd3f(%rip), %rdi     # 0x28fd0
leaq 0x14659(%rip), %rsi     # 0x1d8f1
movl $0x8, %edx
callq 0x7290
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x13ab6
movq 0x10(%rax), %rsi
movq 0x10(%rbx), %rdx
leaq -0x21(%rbp), %rdi
callq 0x14d6a
testq %rax, %rax
je 0x92e2
leaq 0x1e004(%rip), %rsi     # 0x272d0
leaq 0x1ec45(%rip), %rdx     # 0x27f18
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r15
jmp 0x92e5
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x13d14
cltq
addq %rax, %r14
incq %r12
cmpq $0xc350, %r12           # imm = 0xC350
jne 0x92eb
movq 0x1fcc0(%rip), %r15     # 0x28fd0
leaq 0x145e3(%rip), %rsi     # 0x1d8fa
movl $0xc, %edx
movq %r15, %rdi
callq 0x7290
movq %r15, %rdi
movq %r14, %rsi
callq 0x7170
leaq 0x13db3(%rip), %rsi     # 0x1d0e9
movl $0x1, %edx
movq %rax, %rdi
callq 0x7290
movq 0x10(%rbx), %rsi
movq 0x28(%rbx), %rdi
movl %r14d, %edx
callq 0x13ddc
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1fc58(%rip), %r12     # 0x28fd0
leaq 0x14676(%rip), %rsi     # 0x1d9f5
movl $0xb, %edx
movq %r12, %rdi
callq 0x7290
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x13ab6
movq %rax, %r15
movq 0x10(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x13ab6
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
testq %rax, %rax
je 0x93d9
movq %rax, %r13
movq %rax, %rdi
callq 0x7100
movq 0x1fc04(%rip), %rdi     # 0x28fd0
movq %r13, %rsi
movq %rax, %rdx
callq 0x7290
jmp 0x93f2
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x7380
movq 0x1fbd7(%rip), %r12     # 0x28fd0
leaq 0x13ce9(%rip), %rsi     # 0x1d0e9
movl $0x1, %edx
movq %r12, %rdi
callq 0x7290
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
testq %rax, %rax
je 0x943a
movq %rax, %r13
movq %rax, %rdi
callq 0x7100
movq 0x1fba3(%rip), %rdi     # 0x28fd0
movq %r13, %rsi
movq %rax, %rdx
callq 0x7290
jmp 0x9453
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x7380
movq 0x1fb76(%rip), %rdi     # 0x28fd0
leaq 0x13c88(%rip), %rsi     # 0x1d0e9
movl $0x1, %edx
callq 0x7290
movq 0x10(%r15), %rsi
movq 0x10(%rbx), %rdx
leaq -0x29(%rbp), %rdi
callq 0x14d6a
testq %rax, %rax
je 0x949e
leaq 0x1de48(%rip), %rsi     # 0x272d0
leaq 0x1ea89(%rip), %rdx     # 0x27f18
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r15
jmp 0x94a1
xorl %r15d, %r15d
movq 0x10(%r14), %rsi
movq 0x10(%rbx), %rdx
leaq -0x29(%rbp), %rdi
callq 0x14d6a
leaq 0x1de17(%rip), %rsi     # 0x272d0
leaq 0x1ea58(%rip), %rdx     # 0x27f18
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d14
movl %eax, %r14d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13f40
cmpl %eax, %r14d
leaq 0x14512(%rip), %rax     # 0x1da01
leaq 0x14513(%rip), %rsi     # 0x1da09
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x13ed4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9746
movl $0x20, %edi
callq 0x7230
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x9806
testq %r13, %r13
je 0x9577
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 0x9558
movl $0x28, %edi
callq 0x7230
movq %rax, %r15
leaq -0x80(%rbp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x9866
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x99fc
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 0x1e744(%rip), %rdx     # 0x27d08
movq %rdx, (%r12)
movq %rax, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rdx
callq 0x9b8c
leaq 0x1e228(%rip), %rax     # 0x27810
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x95fa
callq 0x72b0
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9616
movq %rax, %rbx
movq %r15, %rdi
jmp 0x961c
movq %rax, %rbx
movq %r12, %rdi
callq 0x7200
jmp 0x962c
jmp 0x9629
jmp 0x9629
jmp 0x9629
movq %rax, %rbx
leaq 0x1e1dd(%rip), %rax     # 0x27810
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x9645
callq 0x72b0
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9746
movl $0x20, %edi
callq 0x7230
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0x9806
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 0x9866
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x99fc
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 0x1e612(%rip), %rdx     # 0x27d08
movq %rdx, (%r15)
movq %rax, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9b8c
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9733
movq %rax, %rbx
movq %r12, %r15
jmp 0x9736
movq %rax, %rbx
movq %r13, %r15
jmp 0x9736
movq %rax, %rbx
movq %r15, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e0b2(%rip), %rax     # 0x27810
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 0x9dbe
movq %r14, 0x30(%rbx)
movl $0x30, %edi
callq 0x7230
movq %rax, %r14
movq %rax, %rdi
callq 0x9dbe
movq %r14, 0x38(%rbx)
movl $0x30, %edi
callq 0x7230
movq %rax, %r14
movq %rax, %rdi
callq 0x9dbe
movq %r14, 0x40(%rbx)
movl $0x30, %edi
callq 0x7230
movq %rax, %r14
movq %rax, %rdi
callq 0x9dbe
movq %r14, 0x48(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x97f2
jmp 0x97f2
jmp 0x97f2
movq %rax, %rbx
movq %r14, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rsi, %r12
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
leaq 0x1e64c(%rip), %rax     # 0x27ed8
movq %rax, (%rdi)
movl $0x50, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
callq 0xd8fc
movq %rbx, 0x10(%r15)
movl $0x28, %edi
callq 0x7230
movq %rax, %r12
movq $0x0, 0x8(%rax)
leaq 0x1de59(%rip), %rax     # 0x27720
movq %rax, (%r12)
movl $0x28, %edi
callq 0x7030
movq %rax, 0x10(%r12)
movq $0x5, 0x20(%r12)
movq $0x0, 0x18(%r12)
movq %r12, 0x18(%r15)
movq %r14, 0x20(%r15)
cmpq $0x0, 0x20(%rbx)
je 0x99c7
xorl %r12d, %r12d
leaq 0x136fb(%rip), %r13     # 0x1d004
movq 0x18(%rbx), %rax
movzbl (%rax,%r12), %eax
leal -0x42(%rax), %ecx
cmpl $0x7, %ecx
ja 0x993e
movslq (%r13,%rcx,4), %rax
addq %r13, %rax
jmpq *%rax
movl $0x20, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xda6e
jmp 0x99a9
cmpl $0x53, %eax
jne 0x99ba
movl $0x20, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xda0e
jmp 0x99a9
movl $0x20, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xdace
jmp 0x99a9
movl $0x20, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xd9ae
jmp 0x99a9
movl $0x20, %edi
callq 0x7230
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x9806
movq 0x18(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x58(%rax)
movq 0x10(%r15), %rbx
incq %r12
cmpq 0x20(%rbx), %r12
jb 0x9909
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rbx
jmp 0x99eb
jmp 0x99e8
jmp 0x99e8
jmp 0x99e8
jmp 0x99e8
jmp 0x99e8
movq %rax, %r14
movq %rbx, %rdi
callq 0x7200
movq %r14, %rdi
callq 0x73b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1da9b(%rip), %rax     # 0x27878
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 0x1d919(%rip), %rax     # 0x27720
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)
xorl %r15d, %r15d
leaq 0x1daaa(%rip), %r12     # 0x278e0
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 0x9e39
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9efa
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 0x9edb
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movb $0x1, %bl
cmpq %rdi, %rsi
je 0x9f6d
testq %rsi, %rsi
je 0x9f6b
movq %rdi, %r14
leaq 0x1d3b5(%rip), %rax     # 0x272d0
leaq 0x1d92e(%rip), %rdx     # 0x27850
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0x9f6b
movq 0x20(%r14), %rcx
cmpq 0x20(%rax), %rcx
jne 0x9f6b
testq %rcx, %rcx
je 0x9f6d
movq 0x18(%r14), %rdx
movq 0x18(%rax), %rax
decq %rcx
xorl %esi, %esi
movb (%rdx,%rsi), %dil
cmpb (%rax,%rsi), %dil
sete %bl
jne 0x9f6d
leaq 0x1(%rsi), %rdi
cmpq %rsi, %rcx
movq %rdi, %rsi
jne 0x9f50
jmp 0x9f6d
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8094
leaq 0x1349c(%rip), %rsi     # 0x1d436
movq %rbx, %rdi
callq 0x80f6
movq 0x10(%r14), %rdx
leaq 0x13490(%rip), %rsi     # 0x1d43d
movq %rbx, %rdi
callq 0x81d0
movq 0x20(%r14), %rdx
leaq 0x13487(%rip), %rsi     # 0x1d447
movq %rbx, %rdi
callq 0x81d0
movq 0x28(%r14), %rdx
leaq 0x13481(%rip), %rsi     # 0x1d454
movq %rbx, %rdi
callq 0x81d0
movq 0x18(%r14), %rdx
leaq 0x13412(%rip), %rsi     # 0x1d3f8
movq %rbx, %rdi
callq 0x8556
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82ba
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa034
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_O3/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 0xa148
movq %rdi, %rbx
leaq 0x1d1fb(%rip), %rax     # 0x272d0
leaq 0x1d7dc(%rip), %rdx     # 0x278b8
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 0xa150
movq %rbx, %rdi
callq 0xa518
cmpq $0x0, 0x20(%rbx)
je 0xa14d
movq %rax, %r15
xorl %r13d, %r13d
movq (%r15,%r13,8), %rsi
movq %rbx, %rdi
callq 0xa626
movq %rax, %r12
movq (%r15,%r13,8), %rsi
movq %r14, %rdi
callq 0xa626
movq (%r12), %rcx
movq %r12, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
movl %eax, %r12d
testb %al, %al
je 0xa150
incq %r13
cmpq 0x20(%rbx), %r13
jb 0xa10e
jmp 0xa150
xorl %r12d, %r12d
jmp 0xa150
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_O3/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 0x9dbe
movq %r13, %rdi
callq 0xa518
movq 0x20(%r13), %r14
testq %r14, %r14
movq %rbx, -0x30(%rbp)
je 0xa1cb
xorl %ebx, %ebx
movq (%rax,%rbx,8), %r12
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %r15
callq 0xa626
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xa996
movq %r15, %rax
incq %rbx
cmpq %rbx, %r14
jne 0xa19f
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_O3/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 0x8094
leaq 0x131f1(%rip), %rsi     # 0x1d409
movq %rbx, %rdi
callq 0x80f6
movq 0x10(%r14), %rdx
leaq 0x131e2(%rip), %rsi     # 0x1d40d
movq %rbx, %rdi
callq 0x81d0
movq 0x18(%r14), %rdx
leaq 0x131db(%rip), %rsi     # 0x1d419
movq %rbx, %rdi
callq 0x81d0
movq 0x20(%r14), %rdx
leaq 0x131d5(%rip), %rsi     # 0x1d426
movq %rbx, %rdi
callq 0x81d0
movq 0x28(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x131c3(%rip), %rsi     # 0x1d42d
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa8f0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82ba
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa2bd
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_O3/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 0xa3ae
movq %rdi, %rbx
leaq 0x1cf8b(%rip), %rax     # 0x272d0
leaq 0x1d5d4(%rip), %rdx     # 0x27920
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
movq 0x20(%rbx), %rcx
cmpq 0x20(%rax), %rcx
jne 0xa3b6
testq %rcx, %rcx
je 0xa3b3
movq 0x10(%rax), %r15
movq 0x10(%rbx), %r12
xorl %r13d, %r13d
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movl %eax, %r14d
testb %al, %al
je 0xa3b6
movq (%r12), %rax
movq %r12, %rdi
callq *0x40(%rax)
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x40(%rax)
movq %rax, %r15
incq %r13
cmpq 0x20(%rbx), %r13
jb 0xa376
jmp 0xa3b6
xorl %r14d, %r14d
jmp 0xa3b6
movb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8094
leaq 0x12fc1(%rip), %rsi     # 0x1d3b9
movq %rbx, %rdi
callq 0x80f6
movq 0x20(%r14), %rdx
leaq 0x12fb4(%rip), %rsi     # 0x1d3bf
movq %rbx, %rdi
callq 0x81d0
movq 0x20(%r14), %r13
movq %r13, %rax
shrq $0x3d, %rax
leaq (,%r13,8), %rcx
xorl %r12d, %r12d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x7030
movq %rax, -0x30(%rbp)
testq %r13, %r13
je 0xa48f
movq %rbx, -0x38(%rbp)
xorl %r12d, %r12d
movslq %r12d, %rbx
movq 0x10(%r14), %rax
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0xa470
movq (%rax), %rcx
movq %rax, %rdi
callq *0x40(%rcx)
incq %r15
cmpq %r15, %r13
jne 0xa456
xorl %eax, %eax
jmp 0xa474
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq 0x20(%r14), %r13
cmpq %r13, %r12
jb 0xa44c
movl %r13d, %r12d
movq -0x38(%rbp), %rbx
leaq 0x12f2f(%rip), %rsi     # 0x1d3c5
movq %rbx, %rdi
movq -0x30(%rbp), %rdx
movl %r12d, %ecx
callq 0x8d74
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82ba
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa4eb
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
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x30(%rbp)
cmpq $0x0, 0x10(%rbx)
je 0xa612
xorl %r13d, %r13d
xorl %esi, %esi
movq %rbx, -0x38(%rbp)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movq %rsi, -0x40(%rbp)
callq *0x40(%rax)
testq %rax, %rax
je 0xa590
movq %rax, %rdi
leaq 0x1cd50(%rip), %rsi     # 0x272d0
leaq 0x1d399(%rip), %rdx     # 0x27920
xorl %ecx, %ecx
callq 0x7280
jmp 0xa592
xorl %eax, %eax
movq 0x20(%rax), %r15
testq %r15, %r15
je 0xa5fd
xorl %r12d, %r12d
movq %rax, -0x48(%rbp)
movslq %r12d, %r14
movq 0x10(%rax), %rax
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0xa5c5
movq (%rax), %rcx
movq %rax, %rdi
callq *0x40(%rcx)
incq %rbx
cmpq %rbx, %r15
jne 0xa5ab
xorl %edi, %edi
jmp 0xa5c9
movq 0x10(%rax), %rdi
leaq 0x1cd00(%rip), %rsi     # 0x272d0
leaq 0x1d361(%rip), %rdx     # 0x27938
xorl %ecx, %ecx
callq 0x7280
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
incq %r12
movq -0x48(%rbp), %rax
movq 0x20(%rax), %r15
cmpq %r15, %r12
jb 0xa5a2
movq -0x40(%rbp), %rsi
incq %rsi
movq -0x38(%rbp), %rbx
cmpq 0x10(%rbx), %rsi
jb 0xa563
movq -0x30(%rbp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1d303(%rip), %rcx     # 0x27960
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 0x1cc4b(%rip), %rsi     # 0x272d0
leaq 0x1d294(%rip), %rdx     # 0x27920
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %rdi
movq %r14, %rsi
callq 0xa75e
testq %rax, %rax
je 0xa6c7
leaq 0x1cc23(%rip), %rsi     # 0x272d0
leaq 0x1d284(%rip), %rdx     # 0x27938
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq 0x18(%rax), %rax
jmp 0xa755
movq 0x1e902(%rip), %r14     # 0x28fd0
leaq 0x12cfb(%rip), %rsi     # 0x1d3d0
movl $0x1b, %edx
movq %r14, %rdi
callq 0x7290
leaq 0x131d1(%rip), %rsi     # 0x1d8ba
movl $0x5, %edx
movq %r14, %rdi
callq 0x7290
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
testq %rax, %rax
je 0xa723
movq %rax, %rbx
movq %rax, %rdi
callq 0x7100
movq 0x1e8ba(%rip), %rdi     # 0x28fd0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x7290
jmp 0xa73b
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x7380
movq 0x1e88e(%rip), %rdi     # 0x28fd0
leaq 0x129a0(%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_O3/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 %r12
pushq %rbx
movq 0x20(%rdi), %r12
testq %r12, %r12
je 0xa79f
movq %rsi, %r14
movq 0x10(%rdi), %r15
xorl %ebx, %ebx
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0xa7a3
movq (%r15), %rax
movq %r15, %rdi
callq *0x40(%rax)
movq %rax, %r15
decq %r12
jne 0xa77b
jmp 0xa7a7
xorl %ebx, %ebx
jmp 0xa7a7
movq 0x10(%r15), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa803
movq %rdi, %rbx
leaq 0x1cafd(%rip), %rax     # 0x272d0
leaq 0x1d15e(%rip), %rdx     # 0x27938
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xa803
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_O3/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 0x8094
leaq 0x12baa(%rip), %rsi     # 0x1d3ec
movq %rbx, %rdi
callq 0x80f6
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x12b98(%rip), %rsi     # 0x1d3f3
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa8f0
movq 0x18(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x12b7f(%rip), %rsi     # 0x1d3f8
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa8f0
movq (%rbx), %r14
movl $0x4, %esi
movq %r14, %rdi
callq 0x824a
movq 0x10(%r14), %rax
movq 0x20(%r14), %rcx
movl $0x7d207d20, (%rax,%rcx) # imm = 0x7D207D20
addq $0x4, 0x20(%r14)
movq (%rbx), %rdi
callq 0x82ba
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xa8cc
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_O3/yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, char*, bool)
void write(const char* name, char* val, bool wrap) {
        int SIZEOFINSERTS = 10;
        char str[strlen(val) + strlen(name) + SIZEOFINSERTS];
        if(wrap) {
            sprintf(str, "'%s' : '%s', ", name, val);
        } else {
            sprintf(str, "'%s' : %s, ", name, val);
        }
        buff->c(str);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x7100
movq %rax, %r14
movq %r12, %rdi
callq 0x7100
addq %r14, %rax
addq $0x19, %rax
andq $-0x10, %rax
movq %rsp, %r14
subq %rax, %r14
movq %r14, %rsp
leaq 0x12a13(%rip), %rax     # 0x1d34b
leaq 0x12abe(%rip), %rsi     # 0x1d3fd
testl %r13d, %r13d
cmovneq %rax, %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x7080
movq (%rbx), %rbx
movq %r14, %rdi
callq 0x7100
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x824a
movq 0x10(%rbx), %rdi
addq 0x20(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x71a0
addq %r15, 0x20(%rbx)
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::add(Object*, Object*)
void add(Object* key, Object* value) {
      //std::cout << "Map put: " << "key: " << key->serialize() << " val: " << value->serialize() << "\n";
      size_t key_hash = key->hash();
      //std::cout << "put hash" << key_hash << "\n";
      KeyVal *key_val = new KeyVal(key, value);
      size_t index = key_hash % this->numBuckets_;
      //std::cout << "map put queue index: " << index << "\n";
      Queue *queue_at_index = dynamic_cast<Queue*>(this->buckets_->get(index));
      if (queue_at_index->size() == 0) {
        this->bucketsUsed_ += 1;
        if (((float) this->bucketsUsed_ / (float) this->numBuckets_) > 0.75) {
          this->rehash_();
        }
      } 
      if (queue_at_index->get(key_val) == nullptr) {
        queue_at_index->add(key_val);
      } else {
        Object* removed = this->pop_item(key);
        //String *before  = dynamic_cast<String*>(key_val->getVal());
        queue_at_index->add(key_val);
        //String *after  = dynamic_cast<String*>(this->get(key));
      }
      this->items_ += 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
movq %rax, %r13
movl $0x20, %edi
callq 0x7230
movq %rax, %r15
movq $0x0, 0x8(%rax)
leaq 0x1cf8b(%rip), %rax     # 0x27960
movq %rax, (%r15)
movq %r14, 0x10(%r15)
movq %r12, 0x18(%r15)
movq %r13, %rax
xorl %edx, %edx
divq 0x10(%rbx)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x40(%rax)
leaq 0x1c8d3(%rip), %rsi     # 0x272d0
leaq 0x1cf1c(%rip), %rdx     # 0x27920
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r12
cmpq $0x0, 0x20(%rax)
jne 0xaa7b
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
incq %rcx
movq %rcx, 0x18(%rbx)
js 0xaa30
cvtsi2ss %rcx, %xmm0
jmp 0xaa45
movq %rcx, %rdx
shrq %rdx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
testq %rax, %rax
js 0xaa51
cvtsi2ss %rax, %xmm1
jmp 0xaa66
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
divss %xmm1, %xmm0
ucomiss 0x1260f(%rip), %xmm0    # 0x1d080
jbe 0xaa7b
movq %rbx, %rdi
callq 0xaab4
movq %r12, %rdi
movq %r15, %rsi
callq 0xa75e
testq %rax, %rax
je 0xaa96
movq %rbx, %rdi
movq %r14, %rsi
callq 0xac7c
movq %r12, %rdi
movq %r15, %rsi
callq 0xac06
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::rehash_()
void rehash_() {
      KeyVal *key_val[this->items_];
      Object** this_keys = this->keys();
      for (size_t i = 0; i < this->size(); i++) {
        key_val[i] = new KeyVal(this_keys[i], this->get(this_keys[i]));
      }

      size_t items = this->items_;

      this->numBuckets_ = 2 * this->numBuckets_;
      this->bucketsUsed_ = 0;
      this->items_ = 0;

      delete this->buckets_;

      this->buckets_ = new Array(this->numBuckets_);

      for (size_t i = 0; i < items; i++) {
        this->add(key_val[i]->getKey(), key_val[i]->getVal());
      }     
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq %rsp, %rcx
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
callq 0xa518
cmpq $0x0, 0x20(%rbx)
je 0xab40
movq %rax, %r15
xorl %r13d, %r13d
movl $0x20, %edi
callq 0x7230
movq %rax, %r14
movq (%r15,%r13,8), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa626
movq $0x0, 0x8(%r14)
leaq 0x1ce41(%rip), %rcx     # 0x27960
movq %rcx, (%r14)
movq %r12, 0x10(%r14)
movq %rax, 0x18(%r14)
movq -0x30(%rbp), %rax
movq %r14, (%rax,%r13,8)
incq %r13
movq 0x20(%rbx), %r12
cmpq %r12, %r13
jb 0xaaf4
jmp 0xab43
xorl %r12d, %r12d
movq 0x10(%rbx), %r15
movq 0x28(%rbx), %rdi
addq %r15, %r15
movq %r15, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
testq %rdi, %rdi
je 0xab68
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %r15
movl $0x28, %edi
callq 0x7230
movq %rax, %r14
movq $0x0, 0x8(%rax)
leaq 0x1cb9c(%rip), %rax     # 0x27720
movq %rax, (%r14)
movq %r15, %rax
shrq $0x3d, %rax
leaq (,%r15,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x7030
movq %rax, 0x10(%r14)
movq %r15, 0x20(%r14)
movq $0x0, 0x18(%r14)
movq %r14, 0x28(%rbx)
testq %r12, %r12
movq -0x30(%rbp), %r15
je 0xabe2
xorl %r14d, %r14d
movq (%r15,%r14,8), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq %rbx, %rdi
callq 0xa996
incq %r14
cmpq %r14, %r12
jne 0xabc6
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xabf3
movq %rax, %rbx
movq %r14, %rdi
callq 0x7200
movq %rbx, %rdi
callq 0x73b0
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::add(Object*)
void add(Object* o) {
    //create the linked list node.
    ObjectNode *newNode = new ObjectNode(o);
    if (this->head_ == nullptr) {
      //adding in first element. set both head and tail to be that element.
      this->head_ = newNode;
      this->tail_ = newNode;
      //increment size.
      this->size_+=1;
    } else{
      this->tail_->setNext(newNode);
      newNode->setPrev(this->tail_);
      this->tail_ = newNode;
      this->size_+=1;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x28, %edi
callq 0x7230
movq %rax, %r14
movq $0x0, 0x8(%rax)
leaq 0x1cd7e(%rip), %rax     # 0x279b0
movq %rax, (%r14)
movq %r15, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
cmpq $0x0, 0x10(%rbx)
je 0xac64
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x50(%rax)
movq 0x18(%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x58(%rax)
jmp 0xac68
movq %r14, 0x10(%rbx)
movq %r14, 0x18(%rbx)
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::pop_item(Object*)
Object* pop_item(Object* key) {
      size_t key_hash = key->hash();
      int index = key_hash % this->numBuckets_;
      Queue *queue_at_index = dynamic_cast<Queue *>(this->buckets_->get(index));
      KeyVal *wrappedkey = new KeyVal(key, nullptr);
      this->items_ -= 1;
      if (queue_at_index->size() == 0) {
        this->bucketsUsed_ -= 1;    
      }
      KeyVal *keyVal = dynamic_cast<KeyVal*>(queue_at_index->remove(wrappedkey));
      return keyVal->getVal();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x10(%rax)
xorl %r15d, %r15d
xorl %edx, %edx
divq 0x10(%rbx)
movq 0x28(%rbx), %rdi
movslq %edx, %rsi
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
je 0xaccb
leaq 0x1c619(%rip), %rsi     # 0x272d0
leaq 0x1cc62(%rip), %rdx     # 0x27920
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq %rax, %r15
movl $0x20, %edi
callq 0x7230
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x1cc7e(%rip), %rdx     # 0x27960
movq %rdx, (%rax)
movq %r14, 0x10(%rax)
movq %rcx, 0x18(%rax)
decq 0x20(%rbx)
cmpq %rcx, 0x20(%r15)
jne 0xacfb
decq 0x18(%rbx)
movq %r15, %rdi
movq %rax, %rsi
callq 0xadb6
leaq 0x1c5c3(%rip), %rsi     # 0x272d0
leaq 0x1cc24(%rip), %rdx     # 0x27938
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x7280
movq 0x18(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/yasz24[P]eau2/src/network/./../application/../store/../utils/listNode.h
// Function: ObjectNode::equals(Object*)
virtual bool equals(Object * other) {
		if (other == nullptr) return false;
        ObjectNode *o = dynamic_cast<ObjectNode*>(other);
		if (o == nullptr) {
			return false;
		}
        return this->data_->equals(o->data_);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xad7d
movq %rdi, %rbx
leaq 0x1c583(%rip), %rax     # 0x272d0
leaq 0x1ccbc(%rip), %rdx     # 0x27a10
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x7280
testq %rax, %rax
je 0xad7d
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