LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::add_column(char, String*)
void add_column(char typ, String* name) {
        if (this->empty_index_ == this->capacity_) {
            resize_();
        }
        if (this->valid_col_char_(typ)) {
            //set the typ for the new column if valid.
            this->val_[this->empty_index_] = typ;
            if (name != nullptr) {
                if (this->col_name_idx->get(name) == nullptr) {
                    Integer* i = new Integer(this->empty_index_);
                    this->col_name_idx->add(name, i);
                    this->col_idx_name->add(i, name);
                }
            }
            //bump up the empty index
            this->empty_index_ += 1;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x10(%rdi), %rax
jne 0x11c09
movq %rbx, %rdi
callq 0x11c90
movsbl %r15b, %eax
addl $-0x42, %eax
cmpl $0x11, %eax
ja 0x11c84
movl $0x20095, %ecx          # imm = 0x20095
btl %eax, %ecx
jae 0x11c84
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movb %r15b, (%rax,%rcx)
testq %r14, %r14
je 0x11c80
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xa248
testq %rax, %rax
jne 0x11c80
pushq $0x18
popq %rdi
callq 0x7250
movq %rax, %r15
movl 0x20(%rbx), %eax
andq $0x0, 0x8(%r15)
leaq 0x121fd(%rip), %rcx     # 0x23e58
movq %rcx, (%r15)
movl %eax, 0x10(%r15)
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xa522
movq 0x40(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xa522
incq 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::resize_()
void resize_() {
        size_t len = this->capacity_;
        //double size.
        len = this->capacity_ * 2;
        //create a new array that has double the size.
        char *copy_ = new char[len + 1];
        
        //copy over elements one by one.
        for (size_t i = 0; i < this->capacity_; i++) {
            copy_[i] = this->val_[i];
        }
        
        //need to free the array.
        delete[] this->val_;
        //need to get old pointer to point to new array. 
        this->val_ = copy_;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r12
leaq (%r12,%r12), %r15
leaq 0x1(,%r12,2), %rdi
callq 0x7030
movq %rax, %r14
movq 0x18(%rbx), %rdi
xorl %eax, %eax
cmpq %rax, %r12
je 0x11ccd
movb (%rdi,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
jmp 0x11cbc
testq %rdi, %rdi
je 0x11cd7
callq 0x72c0
movq %r14, 0x18(%rbx)
movq %r15, 0x10(%rbx)
movb $0x0, (%r14,%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::resolve_local_wait(Key*)
void resolve_local_wait(Key* key) {
         // notification procedure.
        if (wait_for_key_ != nullptr) {
            if (wait_for_key_->equals(key)) {
                store_mtx_.notify_all();
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x100(%rdi), %rdi
testq %rdi, %rdi
je 0x11d22
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x11d22
addq $0x90, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1216c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::resolve_remote_wait(Key*, Value*)
void resolve_remote_wait(Key* key, Value* val) {
        size_t outstandingReqs = pendingGets.length();

        if (outstandingReqs > 0) {
            for (size_t i = 0; i < outstandingReqs; i++) {
                WaitAndGet* req = dynamic_cast<WaitAndGet*>(pendingGets.get(i));
                if (req->key_->equals(key)) {
                    //compose a response to the sender
                    Reply resp(val->serialize(), this_node_, req->sender_, network_->msg_id);
                    //send the message
                    network_->send_msg(&resp);
                }   
            }
            WaitAndGet dummy(key, 0, 0, 0);
            //remove the req from pending reqs list.
            while (pendingGets.get(&dummy) != -1 ) {
                pendingGets.remove(pendingGets.get(&dummy));
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq 0xf0(%rdi), %r14
testq %r14, %r14
je 0x11e6f
movq %rdi, %r12
leaq 0xd8(%rdi), %rbx
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x11e17
movq 0xf0(%r12), %rax
subq $0x1, %rax
setb %cl
cmpq %r15, %rax
setb %al
orb %cl, %al
jne 0x11dad
movq 0xe8(%r12), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x11dad
leaq 0x1150e(%rip), %rsi     # 0x232a8
leaq 0x12cb7(%rip), %rdx     # 0x24a58
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r13
jmp 0x11db0
xorl %r13d, %r13d
movq 0x30(%r13), %rdi
movq (%rdi), %rax
movq -0x30(%rbp), %rsi
callq *0x18(%rax)
testb %al, %al
je 0x11e0f
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x18(%r13), %rcx
movq 0x18(%r12), %rdx
movq 0x50(%r12), %rdi
movq 0x40(%rdi), %rsi
andq $0x0, -0x68(%rbp)
leaq 0x12c96(%rip), %r8      # 0x24a80
movq %r8, -0x70(%rbp)
movl $0x3, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq %rcx, -0x50(%rbp)
movq %rsi, -0x48(%rbp)
movq %rax, -0x40(%rbp)
movq (%rdi), %rax
leaq -0x70(%rbp), %rsi
callq *0x50(%rax)
incq %r15
jmp 0x11d60
leaq -0x70(%rbp), %r15
andq $0x0, 0x8(%r15)
leaq 0x12ca9(%rip), %rax     # 0x24ad0
movq %rax, (%r15)
movl $0x5, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
andq $0x0, 0x28(%r15)
movq -0x30(%rbp), %rax
movq %rax, 0x30(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1219e
cmpl $-0x1, %eax
je 0x11e6f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1219e
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x8b6e
jmp 0x11e47
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./network.h
// Function: Put::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Put");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        char* serializedKey = key_->serialize();
        sb->write("key_", serializedKey, false);
        char* serializedValue = value_->serialize();
        sb->write("value_", serializedValue, false);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0x6842(%rip), %rsi      # 0x188da
movq %rbx, %rdi
callq 0x7fd8
movl 0x10(%r14), %edx
leaq 0x61cb(%rip), %rsi      # 0x18276
movq %rbx, %rdi
callq 0x801c
movq 0x18(%r14), %rdx
leaq 0x61be(%rip), %rsi      # 0x1827c
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0x61b3(%rip), %rsi      # 0x18284
movq %rbx, %rdi
callq 0x8062
movq 0x28(%r14), %rdx
leaq 0x64e3(%rip), %rsi      # 0x185c7
movq %rbx, %rdi
callq 0x8062
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x62fb(%rip), %rsi      # 0x183f8
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq 0x38(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
leaq 0x67c3(%rip), %rsi      # 0x188de
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0xa4a2
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x12149
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::get(Object*)
int get(Object* o) {
        for (size_t i = 0; i < listLength_; i++) {
            if (objs_[i]->equals(o)) {
                return i;
            }
        }
        return -1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
pushq $-0x1
popq %rbx
cmpq 0x18(%r15), %r12
jae 0x121d8
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x18(%rax)
testb %al, %al
jne 0x121d5
incq %r12
jmp 0x121b5
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./network.h
// Function: Reply::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Reply");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        if(JSONHelper::isObject(reply_msg_)) {
            sb->write("msg_", reply_msg_, false);
        } else {
            sb->write("msg_", reply_msg_);
        }
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0x66d3(%rip), %rsi      # 0x188e5
movq %rbx, %rdi
callq 0x7fd8
movl 0x10(%r14), %edx
leaq 0x6051(%rip), %rsi      # 0x18276
movq %rbx, %rdi
callq 0x801c
movq 0x18(%r14), %rdx
leaq 0x6044(%rip), %rsi      # 0x1827c
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0x6039(%rip), %rsi      # 0x18284
movq %rbx, %rdi
callq 0x8062
movq 0x28(%r14), %rdx
leaq 0x6369(%rip), %rsi      # 0x185c7
movq %rbx, %rdi
callq 0x8062
movq 0x30(%r14), %rdi
callq 0xc2d4
movq 0x30(%r14), %rdx
leaq 0x6d0e(%rip), %rsi      # 0x18f88
movq %rbx, %rdi
testb %al, %al
je 0x1228a
xorl %ecx, %ecx
callq 0xa4a2
jmp 0x1228f
callq 0x844c
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x122b0
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./network.h
// Function: WaitAndGet::equals(Object*)
bool equals(Object* other) {
        if (other == this) return true;
        WaitAndGet* x = dynamic_cast<WaitAndGet *>(other);
        if (x == nullptr) return false;
        return this->key_->equals(x->key_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq %rdi, %rsi
je 0x12329
testq %rsi, %rsi
je 0x1232d
movq %rdi, %r14
leaq 0x10faf(%rip), %rax     # 0x232a8
leaq 0x12758(%rip), %rdx     # 0x24a58
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0x1232f
movq 0x30(%r14), %rdi
movq 0x30(%rax), %rsi
movq (%rdi), %rax
movq 0x18(%rax), %rax
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
movb $0x1, %bl
jmp 0x1232f
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::get_double(unsigned long, unsigned long)
int get_double(size_t col, size_t row) {
      assert(col < this->schema_->width());
      char col_type = this->schema_->col_type(col);
      assert(col_type == 'D');
      //std::cout<< "get_double: " << this->cols_->get(col) << "\n";
      DistributedDoubleColumn* doubCol = dynamic_cast<DistributedDoubleColumn*>(this->cols_->get(col));
      //std::cout << "get_double row: " << row << "length: "<< schema_->length() << "\n";
      assert(row < this->schema_->length());
      return doubCol->get(row);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rax
cmpq %rsi, 0x20(%rax)
jbe 0x1263e
movq 0x18(%rax), %rax
cmpb $0x44, (%rax,%rsi)
jne 0x1265d
movq %rdx, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
je 0x12621
leaq 0x10c9d(%rip), %rsi     # 0x232a8
leaq 0x114fe(%rip), %rdx     # 0x23b10
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %rdi
jmp 0x12623
xorl %edi, %edi
movq 0x10(%r14), %rax
cmpq %rbx, 0x28(%rax)
jbe 0x1267c
movq %rbx, %rsi
callq 0x127b4
cvttsd2si %xmm0, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6300(%rip), %rdi      # 0x18945
leaq 0x6316(%rip), %rsi      # 0x18962
leaq 0x6344(%rip), %rcx      # 0x18997
movl $0xac, %edx
callq 0x7170
leaq 0x6368(%rip), %rdi      # 0x189cc
leaq 0x62f7(%rip), %rsi      # 0x18962
leaq 0x6325(%rip), %rcx      # 0x18997
movl $0xae, %edx
callq 0x7170
leaq 0x6359(%rip), %rdi      # 0x189dc
leaq 0x62d8(%rip), %rsi      # 0x18962
leaq 0x6306(%rip), %rcx      # 0x18997
movl $0xb2, %edx
callq 0x7170
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::fromScalar(Key*, KVStore*, int)
static DistributedDataFrame* fromScalar(Key* key, KVStore* kv, int scalar) {
      Schema* s = new Schema(); 
      DistributedIntColumn* dc = new DistributedIntColumn(kv);
      s->add_row(nullptr);
      dc->push_back(scalar);
      DistributedDataFrame* df = new DistributedDataFrame(*s, kv);
      df->add_column(dc, nullptr);
      char* serialized = df->serialize();
      Value* val = new Value(serialized, (size_t)0);
      kv->put(key, val);
      return df;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
callq 0x94d2
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0xcfde
incq 0x28(%r15)
movq (%r13), %rax
movq %r13, %rdi
movl %r12d, %esi
callq *0x98(%rax)
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x95e4
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x9730
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %rax, %r15
pushq $0x20
popq %rdi
callq 0x7250
andq $0x0, 0x8(%rax)
leaq 0x1158b(%rip), %rcx     # 0x23cf0
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x98c0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %r15
jmp 0x127a4
movq %rax, %rbx
movq %r13, %r15
jmp 0x127a4
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::get_int(unsigned long, unsigned long)
int get_int(size_t col, size_t row) {
      assert(col < this->schema_->width());
      char col_type = this->schema_->col_type(col);
      assert(col_type == 'I');
      DistributedIntColumn* intCol = dynamic_cast<DistributedIntColumn*>(this->cols_->get(col));
      assert(row < this->schema_->length());
      return intCol->get(row);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rax
cmpq %rsi, 0x20(%rax)
jbe 0x12855
movq 0x18(%rax), %rax
cmpb $0x49, (%rax,%rsi)
jne 0x12874
movq %rdx, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
testq %rax, %rax
je 0x1283d
leaq 0x10a81(%rip), %rsi     # 0x232a8
leaq 0x117d2(%rip), %rdx     # 0x24000
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %rdi
jmp 0x1283f
xorl %edi, %edi
movq 0x10(%r14), %rax
cmpq %rbx, 0x28(%rax)
jbe 0x12893
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x128b2
leaq 0x60e9(%rip), %rdi      # 0x18945
leaq 0x60ff(%rip), %rsi      # 0x18962
leaq 0x61ac(%rip), %rcx      # 0x18a16
movl $0xa1, %edx
callq 0x7170
leaq 0x61cd(%rip), %rdi      # 0x18a48
leaq 0x60e0(%rip), %rsi      # 0x18962
leaq 0x618d(%rip), %rcx      # 0x18a16
movl $0xa3, %edx
callq 0x7170
leaq 0x6142(%rip), %rdi      # 0x189dc
leaq 0x60c1(%rip), %rsi      # 0x18962
leaq 0x616e(%rip), %rcx      # 0x18a16
movl $0xa5, %edx
callq 0x7170
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::listen()
void listen() {
        std::cout << "started listening on separate thread\n";
        //listen for any incoming requests to the store.
        while (true) {
            Message* message = network_->recv_msg(this);
            //std::cout << "incoming message\n";
            process_message_(message);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x12698(%rip), %rdi     # 0x24fc0
leaq 0x6129(%rip), %rsi      # 0x18a58
callq 0x7240
movq 0x50(%rbx), %rdi
movq %rbx, %rsi
callq 0x129ea
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12aa4
jmp 0x12934
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::process_message_(Message*)
void process_message_(Message* m) {
        MsgKind kind = m->kind_;
        //switch on the kind and call the appropriate processing function.
        switch (kind) {
        case MsgKind::Put: {
            Put* put = dynamic_cast<Put*>(m);
            process_put_request_(put);
            break;
        }
        case MsgKind::Get: {
            Get* get = dynamic_cast<Get*>(m);
            process_get_request_(get);
            break;
        }
        case MsgKind::WaitAndGet: {
            WaitAndGet* waitAndget = dynamic_cast<WaitAndGet*>(m);
            process_waitAndGet_request_(waitAndget);
            break;
        }
        case MsgKind::Reply: {
            store_mtx_.lock();
            received_msg = m;
            store_mtx_.notify_all();
            //std::cout << "notified\n";
            store_mtx_.unlock();
            break;
        }
        case MsgKind::Ack: {
            store_mtx_.lock();
            received_msg = m;
            store_mtx_.notify_all();
            store_mtx_.unlock();
            break;
        }
        case MsgKind::Nack: {
            store_mtx_.lock();
            received_msg = m;
            store_mtx_.notify_all();
            store_mtx_.unlock();
            break;
        }
        default:
            break;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x10(%rsi), %eax
cmpq $0x5, %rax
ja 0x12b8c
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x55c8(%rip), %rcx      # 0x18090
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x68(%rbx), %r15
movq %r15, %rdi
callq 0xbc5c
movq %r14, 0xd0(%rbx)
addq $0x90, %rbx
movq %rbx, %rdi
callq 0x1216c
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x71a0
leaq 0x107e4(%rip), %rsi     # 0x232f0
leaq 0x111b5(%rip), %rdx     # 0x23cc8
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12c28
leaq 0x107b7(%rip), %rsi     # 0x232f0
leaq 0x11f00(%rip), %rdx     # 0x24a40
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12b98
leaq 0x1078a(%rip), %rsi     # 0x232f0
leaq 0x11eeb(%rip), %rdx     # 0x24a58
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12cd2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::process_put_request_(Put*)
void process_put_request_(Put* _put) {
        if (put(_put->key_, _put->value_)) {
            Ack ack(this_node_, _put->sender_, network_->msg_id);
            network_->send_msg(&ack);
        } else {
            Nack nack(this_node_, _put->sender_, network_->msg_id);
            network_->send_msg(&nack);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %rsi
movq 0x38(%r14), %rdx
callq 0x98c0
testb %al, %al
je 0x12be3
movq 0x18(%r14), %rax
movq 0x18(%rbx), %rcx
movq 0x50(%rbx), %rdi
movq 0x40(%rdi), %rdx
leaq -0x40(%rbp), %rsi
andq $0x0, 0x8(%rsi)
leaq 0x11f46(%rip), %r8      # 0x24b20
movq %r8, (%rsi)
andl $0x0, 0x10(%rsi)
jmp 0x12c0d
movq 0x18(%r14), %rax
movq 0x18(%rbx), %rcx
movq 0x50(%rbx), %rdi
movq 0x40(%rdi), %rdx
leaq -0x40(%rbp), %rsi
andq $0x0, 0x8(%rsi)
leaq 0x11f85(%rip), %r8      # 0x24b88
movq %r8, (%rsi)
movl $0x1, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %rax, 0x20(%rsi)
movq %rdx, 0x28(%rsi)
movq (%rdi), %rax
callq *0x50(%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::process_get_request_(Get*)
void process_get_request_(Get* _get) {
        Value* val = get(_get->key_);
        if (val != nullptr) {
            Reply res(val->serialize(), this_node_, _get->sender_, network_->msg_id);
            network_->send_msg(&res);
        } else {
            Nack nack(this_node_, _get->sender_, network_->msg_id);
            network_->send_msg(&nack);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %rsi
callq 0xb84a
testq %rax, %rax
je 0x12c8c
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq 0x18(%r14), %rcx
movq 0x18(%rbx), %rdx
movq 0x50(%rbx), %rdi
movq 0x40(%rdi), %r8
leaq -0x48(%rbp), %rsi
andq $0x0, 0x8(%rsi)
leaq 0x11e10(%rip), %r9      # 0x24a80
movq %r9, (%rsi)
movl $0x3, 0x10(%rsi)
movq %rdx, 0x18(%rsi)
movq %rcx, 0x20(%rsi)
movq %r8, 0x28(%rsi)
movq %rax, 0x30(%rsi)
jmp 0x12cc2
movq 0x18(%r14), %rax
movq 0x18(%rbx), %rcx
movq 0x50(%rbx), %rdi
movq 0x40(%rdi), %rdx
leaq -0x48(%rbp), %rsi
andq $0x0, 0x8(%rsi)
leaq 0x11edc(%rip), %r8      # 0x24b88
movq %r8, (%rsi)
movl $0x1, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %rax, 0x20(%rsi)
movq %rdx, 0x28(%rsi)
movq (%rdi), %rax
callq *0x50(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::process_waitAndGet_request_(WaitAndGet*)
void process_waitAndGet_request_(WaitAndGet* _waitAndget) {
        Value* val = get(_waitAndget->key_);
        if (val != nullptr) {
            Reply res(val->serialize(), this_node_, _waitAndget->sender_, network_->msg_id);
            network_->send_msg(&res);
        } else {
            pendingGets.pushBack(_waitAndget);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x30(%rsi), %rsi
callq 0xb84a
testq %rax, %rax
je 0x12d43
movq (%rax), %rcx
movq %rax, %rdi
callq *0x38(%rcx)
movq 0x18(%rbx), %rcx
movq 0x18(%r14), %rdx
movq 0x50(%r14), %rdi
movq 0x40(%rdi), %r8
leaq -0x48(%rbp), %rsi
andq $0x0, 0x8(%rsi)
leaq 0x11d66(%rip), %r9      # 0x24a80
movq %r9, (%rsi)
movl $0x3, 0x10(%rsi)
movq %rdx, 0x18(%rsi)
movq %rcx, 0x20(%rsi)
movq %r8, 0x28(%rsi)
movq %rax, 0x30(%rsi)
movq (%rdi), %rax
callq *0x50(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0xd8, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x8bc6
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./network.h
// Function: Ack::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Ack");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0x5cec(%rip), %rsi      # 0x18a7e
movq %rbx, %rdi
callq 0x7fd8
movl 0x10(%r14), %edx
leaq 0x54d1(%rip), %rsi      # 0x18276
movq %rbx, %rdi
callq 0x801c
movq 0x18(%r14), %rdx
leaq 0x54c4(%rip), %rsi      # 0x1827c
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0x54b9(%rip), %rsi      # 0x18284
movq %rbx, %rdi
callq 0x8062
movq 0x28(%r14), %rdx
leaq 0x57e9(%rip), %rsi      # 0x185c7
movq %rbx, %rdi
callq 0x8062
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x12e07
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./network.h
// Function: Nack::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Nack");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0x5c2a(%rip), %rsi      # 0x18a82
movq %rbx, %rdi
callq 0x7fd8
movl 0x10(%r14), %edx
leaq 0x540b(%rip), %rsi      # 0x18276
movq %rbx, %rdi
callq 0x801c
movq 0x18(%r14), %rdx
leaq 0x53fe(%rip), %rsi      # 0x1827c
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0x53f3(%rip), %rsi      # 0x18284
movq %rbx, %rdi
callq 0x8062
movq 0x28(%r14), %rdx
leaq 0x5723(%rip), %rsi      # 0x185c7
movq %rbx, %rdi
callq 0x8062
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x12ecd
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7220
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/jsonHelper.h
// Function: JSONHelper::getPayloadKey(char*)
static String* getPayloadKey(char* s) {
        int len = strlen( s );
        bool nameStarted = false;
        char buff[100];
        int loc = 0;
        //pull the class name from the serialzed string
        for (int i = 0; i < len; i++){
            char temp = s[i];
            if(temp == '\'' && !nameStarted) {
                nameStarted = true;
            } else if(temp == '\'' && nameStarted) {
                //full name has been discovered
                break;
            } else if(nameStarted) {
                buff[loc] = temp;
                loc++;
            }
        }
        buff[loc] = '\0';
        char* className = buff;
        String* str = new String(className);
        return str;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
callq 0x7110
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %esi, %esi
xorl %edx, %edx
movslq %esi, %rdi
cmpq %rcx, %rax
je 0x13ecc
movb (%rbx,%rcx), %r8b
cmpb $0x27, %r8b
jne 0x13eb9
testb $0x1, %dl
movb $0x1, %dl
je 0x13ec7
jmp 0x13ecc
testb $0x1, %dl
je 0x13ec7
movb %r8b, -0x80(%rbp,%rdi)
incl %edi
movl %edi, %esi
incq %rcx
jmp 0x13e9e
movb $0x0, -0x80(%rbp,%rdi)
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %rbx
leaq -0x80(%rbp), %rsi
movq %rax, %rdi
callq 0x8e1e
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7220
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/column.h
// Function: StringColumn::StringColumn(char*)
StringColumn(char* serialized) {
    char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
    this->arraySize_ = std::stoi(JSONHelper::getValueFromKey("arraySize_", payload)->c_str());
    this->listLength_ = std::stoi(JSONHelper::getValueFromKey("listLength_", payload)->c_str());
    this->val_ = new Array(JSONHelper::getValueFromKey("val_", payload)->c_str());
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x1043c(%rip), %rax     # 0x24360
movq %rax, (%rdi)
movabsq $0x40000000000, %rax    # imm = 0x40000000000
movq %rax, 0x18(%rdi)
movl $0xa, 0x20(%rdi)
movq %rsi, %rdi
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x4412(%rip), %rdi      # 0x18369
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, 0x1c(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x44d2(%rip), %rdi      # 0x1846b
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, 0x18(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r15
leaq 0x4417(%rip), %rdi      # 0x183fd
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1476a
movq %r15, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14015
jmp 0x14027
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x7120
jmp 0x14037
jmp 0x14027
jmp 0x14027
movq %rax, %rbx
jmp 0x14037
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/column.h
// Function: FloatColumn::deserialize(char*)
static FloatColumn* deserialize(char* s) {
    size_t arraySize = std::stoi(JSONHelper::getValueFromKey("arraySize_", s)->c_str());
    size_t listLength = std::stoi(JSONHelper::getValueFromKey("listLength_", s)->c_str());
    String* arr_string = JSONHelper::getValueFromKey("val_", s);
    char* arr_cstr = arr_string->c_str();
    Array* arr = new Array(arr_cstr);
    FloatColumn* fc = new FloatColumn(arr, listLength);
    return fc;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x4312(%rip), %rdi      # 0x18369
movq %rbx, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x43d5(%rip), %rdi      # 0x1846b
movq %rbx, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, %r14d
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x4325(%rip), %rdi      # 0x183fd
movq %rbx, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rbx
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1476a
pushq $0x28
popq %rdi
callq 0x7250
andq $0x0, 0x8(%rax)
leaq 0x107ea(%rip), %rcx     # 0x24900
movq %rcx, (%rax)
movabsq $0xa00000400, %rcx      # imm = 0xA00000400
movq %rcx, 0x1c(%rax)
movq %r15, 0x10(%rax)
movl %r14d, 0x18(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
jmp 0x1415c
jmp 0x1414b
jmp 0x14159
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x7120
jmp 0x1415c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/column.h
// Function: DoubleColumn::deserialize(char*)
static DoubleColumn* deserialize(char* s) {
    size_t arraySize = std::stoi(JSONHelper::getValueFromKey("arraySize_", s)->c_str());
    size_t listLength = std::stoi(JSONHelper::getValueFromKey("listLength_", s)->c_str());
    String* arr_string = JSONHelper::getValueFromKey("val_", s);
    char* arr_cstr = arr_string->c_str();
    Array* arr = new Array(arr_cstr);
    DoubleColumn* dc = new DoubleColumn(arr, listLength);
    return dc;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x41ee(%rip), %rdi      # 0x18369
movq %rbx, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x42b1(%rip), %rdi      # 0x1846b
movq %rbx, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, %r14d
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x4201(%rip), %rdi      # 0x183fd
movq %rbx, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rbx
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1476a
pushq $0x28
popq %rdi
callq 0x7250
andq $0x0, 0x8(%rax)
leaq 0xfb1e(%rip), %rcx      # 0x23d58
movq %rcx, (%rax)
movabsq $0xa00000400, %rcx      # imm = 0xA00000400
movq %rcx, 0x1c(%rax)
movq %r15, 0x10(%rax)
movl %r14d, 0x18(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
jmp 0x14280
jmp 0x1426f
jmp 0x1427d
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x7120
jmp 0x14280
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/column.h
// Function: BoolColumn::deserialize(char*)
static BoolColumn* deserialize(char* s) {
    size_t arraySize = std::stoi(JSONHelper::getValueFromKey("arraySize_", s)->c_str());
    size_t listLength = std::stoi(JSONHelper::getValueFromKey("listLength_", s)->c_str());
    String* arr_string = JSONHelper::getValueFromKey("val_", s);
    char* arr_cstr = arr_string->c_str();
    Array* arr = new Array(arr_cstr);
    BoolColumn* bc = new BoolColumn(arr, listLength);
    return bc;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x3f92(%rip), %rdi      # 0x18369
movq %rbx, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x4055(%rip), %rdi      # 0x1846b
movq %rbx, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, %r14d
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x3fa5(%rip), %rdi      # 0x183fd
movq %rbx, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rbx
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1476a
pushq $0x28
popq %rdi
callq 0x7250
andq $0x0, 0x8(%rax)
leaq 0x10202(%rip), %rcx     # 0x24698
movq %rcx, (%rax)
movabsq $0xa00000400, %rcx      # imm = 0xA00000400
movq %rcx, 0x1c(%rax)
movq %r15, 0x10(%rax)
movl %r14d, 0x18(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
jmp 0x144dc
jmp 0x144cb
jmp 0x144d9
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x7120
jmp 0x144dc
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/dataframe.h
// Function: DataFrame::deserialize(char*)
static DataFrame* deserialize(char* s) {
        Schema* sch = dynamic_cast<Schema*>(DataFrame::deserialize(JSONHelper::getValueFromKey("schema_", s)->c_str()));
        Array* cols = new Array(JSONHelper::getValueFromKey("cols_", s)->c_str());
        DataFrame* df = new DataFrame(sch, cols);
        return df;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x43ad(%rip), %rdi      # 0x188a5
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rdi
callq 0x144e4
testq %rax, %rax
je 0x14534
leaq 0x10703(%rip), %rsi     # 0x24c20
leaq 0xf314(%rip), %rdx      # 0x23838
pushq $-0x2
popq %rcx
movq %rax, %rdi
callq 0x72a0
movq %rax, %rbx
jmp 0x14536
xorl %ebx, %ebx
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r15
leaq 0x4365(%rip), %rdi      # 0x188ad
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %r15, %rdi
movq %rax, %rsi
callq 0x1476a
pushq $0x20
popq %rdi
callq 0x7250
andq $0x0, 0x8(%rax)
leaq 0x106d0(%rip), %rcx     # 0x24c48
movq %rcx, (%rax)
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/schema.h
// Function: Schema::Schema(char*)
Schema(char* serialized) {
        char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
        this->capacity_ = std::stoi(JSONHelper::getValueFromKey("capacity_", payload)->c_str());
        this->empty_index_ = std::stoi(JSONHelper::getValueFromKey("empty_index_", payload)->c_str());
        this->num_rows_ = std::stoi(JSONHelper::getValueFromKey("num_rows_", payload)->c_str());
        this->val_ = JSONHelper::getValueFromKey("val_", payload)->c_str();
        //for reasons
        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
subq $0x30, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0xf239(%rip), %rax      # 0x237f8
movq %rax, (%rbx)
movq $0x64, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x3e5b(%rip), %rdi      # 0x18442
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x10(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x7120
leaq 0x3e20(%rip), %rdi      # 0x1844c
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x20(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x7120
leaq 0x3de8(%rip), %rdi      # 0x18459
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x38(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x28(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x7120
leaq 0x3d47(%rip), %rdi      # 0x183fd
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, 0x18(%rbx)
pushq $0x30
popq %rdi
callq 0x7250
movq %rax, %r14
movq %rax, %rdi
callq 0x9a6a
movq %r14, 0x30(%rbx)
pushq $0x30
popq %rdi
callq 0x7250
movq %rax, %r14
movq %rax, %rdi
callq 0x9a6a
movq %r14, 0x38(%rbx)
pushq $0x30
popq %rdi
callq 0x7250
movq %rax, %r14
movq %rax, %rdi
callq 0x9a6a
movq %r14, 0x40(%rbx)
pushq $0x30
popq %rdi
callq 0x7250
movq %rax, %r14
movq %rax, %rdi
callq 0x9a6a
movq %r14, 0x48(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x14736
jmp 0x14736
jmp 0x14736
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
jmp 0x14762
jmp 0x1474b
jmp 0x1475f
jmp 0x1474b
jmp 0x1475f
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x7120
jmp 0x14762
jmp 0x1475f
jmp 0x1475f
jmp 0x1475f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/../store/../utils/array.h
// Function: Array::Array(char*)
Array(char* serialized) {
        Deserializable* ds = new Deserializable();
        //std::cout<<serialized<<"\n\n";
        char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
        arraySize_ = std::stoi(JSONHelper::getValueFromKey("arraySize_", payload)->c_str());
        int len = std::stoi(JSONHelper::getValueFromKey("listLength_", payload)->c_str());
        this->listLength_ = len;

        char* vals = JSONHelper::getValueFromKey("objs_", payload)->c_str();
        Array* temp = new Array(len);
        for(int i = 0; i < len; i++) {
            char* serial = JSONHelper::getArrayValueAt(vals, i)->c_str();
            //std::cout<<serial<<"\n";
            Object* o = ds->deserialize(serial);
            temp->pushBack(o);
        }
        //delete temp;
        this->objs_ = temp->objs_;
        delete ds;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0xef7b(%rip), %rax      # 0x23708
movq %rax, (%rbx)
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x3bc1(%rip), %rdi      # 0x18369
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x50(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x20(%rbx)
leaq -0x50(%rbp), %rdi
callq 0x7120
leaq 0x3c7e(%rip), %rdi      # 0x1846b
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x50(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, %r15d
leaq -0x50(%rbp), %rdi
callq 0x7120
movslq %r15d, %r13
movq %r13, 0x18(%rbx)
leaq 0x3b3e(%rip), %rdi      # 0x18374
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r12
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
callq 0x9c9c
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpl %r13d, %r15d
je 0x1489c
movq %r12, %rdi
movl %r13d, %esi
callq 0xc4c8
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rsi
callq 0x12f4c
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x58(%rcx)
incl %r13d
jmp 0x1486a
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
jmp 0x148d9
jmp 0x148c4
jmp 0x148d6
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x7120
jmp 0x148d9
jmp 0x148d6
jmp 0x148d6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/../store/../utils/map.h
// Function: Map::Map(char*)
Map(char* serialized) {
      char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
      this->numBuckets_ = std::stoi(JSONHelper::getValueFromKey("numBuckets_", payload)->c_str());
      this->bucketsUsed_ = std::stoi(JSONHelper::getValueFromKey("bucketsUsed_", payload)->c_str());
      this->items_ = std::stoi(JSONHelper::getValueFromKey("items_", payload)->c_str());
      char* buckets_cstr = JSONHelper::getValueFromKey("buckets_", payload)->c_str();
      this->buckets_ = new Array(buckets_cstr);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0xef5f(%rip), %rax      # 0x23860
movq %rax, (%rbx)
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r14
leaq 0x3af6(%rip), %rdi      # 0x18412
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x10(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x3abd(%rip), %rdi      # 0x1841e
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x18(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x3a85(%rip), %rdi      # 0x1842b
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x40(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
cltq
movq %rax, 0x20(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x7120
leaq 0x3a47(%rip), %rdi      # 0x18432
movq %r14, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r15
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x1476a
movq %r14, 0x28(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
jmp 0x14a50
jmp 0x14a39
jmp 0x14a4d
jmp 0x14a39
jmp 0x14a4d
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x7120
jmp 0x14a50
jmp 0x14a4d
jmp 0x14a4d
jmp 0x14a4d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/../serialize/../dataframe/../store/../utils/queue.h
// Function: Queue::Queue(char*)
Queue(char* serialized) {
    this->head_ = nullptr;
    this->tail_ = nullptr;
    this->size_ = 0;
    Deserializable* ds = new Deserializable();
    char* payload = JSONHelper::getPayloadValue(serialized)->c_str();
    size_t queueLen = std::stoi(JSONHelper::getValueFromKey("size_", payload)->c_str());
    char* vals = JSONHelper::getValueFromKey("queueObjs_", payload)->c_str();
    for(int i = 0; i < queueLen; i++) {
        char* serial = JSONHelper::getArrayValueAt(vals, i)->c_str();
        Object* o = ds->deserialize(serial);
        add(o);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rsi, %rdi
leaq 0xee4f(%rip), %rax      # 0x238c8
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
callq 0xc014
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r12
leaq 0x3924(%rip), %rdi      # 0x183c4
movq %rax, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
leaq -0x48(%rbp), %r15
leaq -0x21(%rbp), %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x70f0
xorl %r14d, %r14d
pushq $0xa
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x771e
movl %eax, %r15d
leaq -0x48(%rbp), %rdi
callq 0x7120
leaq 0x38e3(%rip), %rdi      # 0x183ca
movq %r12, %rsi
callq 0xc140
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %r12
cmpl %r14d, %r15d
je 0x14b2c
movq %r12, %rdi
movl %r14d, %esi
callq 0xc4c8
movq (%rax), %rcx
movq %rax, %rdi
callq *0x30(%rcx)
movq %rax, %rsi
callq 0x12f4c
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa744
incl %r14d
jmp 0x14afb
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x7120
movq %rbx, %rdi
callq 0x7390
nop