LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::KVStore(unsigned long, unsigned long, NetworkIP*)
KVStore(size_t num_nodes, size_t this_node, NetworkIP* network) {
        this->num_nodes_ = num_nodes;
        this->this_node_ = this_node;
        network_ = network;
        wait_for_key_ = nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x9780
movq -0x40(%rbp), %rdi
leaq 0x2fb08(%rip), %rax     # 0x3a4d8
movq %rax, (%rdi)
addq $0x20, %rdi
movq %rdi, -0x48(%rbp)
callq 0xaaf0
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x38(%rbp)
callq 0xab10
jmp 0xa9f3
movq -0x40(%rbp), %rdi
addq $0xd8, %rdi
callq 0xab80
jmp 0xaa05
movq -0x40(%rbp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0xac00
movq -0x40(%rbp), %rax
movb $0x0, 0x110(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq $0x0, 0x100(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xaa6c
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xac20
movq -0x48(%rbp), %rdi
callq 0xac60
movq -0x40(%rbp), %rdi
callq 0x9830
movq -0x28(%rbp), %rdi
callq 0x8400
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/kvstore.h
// Function: KVStore::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("KVStore");
        sb->write("num_nodes_", num_nodes_);
        sb->write("this_node_", this_node_);
        sb->endSerialize();
        char* value = sb->get();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0xad4f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x216af(%rip), %rsi     # 0x2c411
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
leaq 0x2169f(%rip), %rsi     # 0x2c419
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x21692(%rip), %rsi     # 0x2c424
callq 0x9f30
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::hash()
size_t hash() {
       size_t res = 0;
        for(int i = 0; i < listLength_; i++) {
            //specific code to deal with the union data-type
            res+=objs_[i]->hash();
        }
        return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0xbb0a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbad3
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Array");
        sb->write("listLength_", listLength_);
        sb->write("arraySize_", arraySize_);
        sb->write("objs_", objs_, listLength_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0xbb7f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x20ab3(%rip), %rsi     # 0x2c645
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x20946(%rip), %rsi     # 0x2c4f0
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x2082c(%rip), %rsi     # 0x2c3ee
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rax
movl %eax, %ecx
leaq 0x20819(%rip), %rsi     # 0x2c3f9
callq 0xbe80
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xbc1b
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::set(unsigned long, Object*)
virtual Object* set(size_t index, Object* o) {
      if(index > listLength_-1) {
            return nullptr;
        }
        Object* temp = get(index);
        objs_[index] = o;
        if(temp == nullptr) {
            listLength_++;
            return nullptr;
        }
        hash_ = 0; //since list has changed in composition, reset stored hash
        return temp;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0xbce7
movq $0x0, -0x8(%rbp)
jmp 0xbd45
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdx
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x28(%rbp)
jne 0xbd31
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq $0x0, -0x8(%rbp)
jmp 0xbd45
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::remove(unsigned long)
virtual Object* remove(size_t index) {
      if(index > listLength_-1) {
            return nullptr;
        }
        Object* temp = get(index);
        for(int i = index; i<listLength_; i++) {
            if(i < listLength_-1) {
                objs_[i] = objs_[i+1];
            }
        }
        listLength_--;
        hash_ = 0; //since list has changed in composition, reset stored hash
        return temp;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0xbd86
movq $0x0, -0x8(%rbp)
jmp 0xbe10
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0xbdf0
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xbde3
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movl -0x24(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xbde5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xbd9f
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::pushBack(Object*)
virtual void pushBack(Object* o) {
        int newSize = 1+listLength_;
        extend_array(newSize);
        objs_[listLength_] = o;
        listLength_++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq 0x18(%rdi), %rax
addq $0x1, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0xbf70
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rsi
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, Object**, int)
void write(const char* name, Object** val, int len) {
        char str[100000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            char* serial = val[i]->serialize();
            sprintf(str, "%s,", serial);
            buff->c(str);
        }
        buff->c("], ");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x186e0, %rsp          # imm = 0x186E0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x186d8(%rbp)
leaq -0x186c0(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x20548(%rip), %rsi     # 0x2c3ff
movb $0x0, %al
callq 0x8090
movq -0x186d8(%rbp), %rax
movq (%rax), %rdi
leaq -0x186c0(%rbp), %rsi
callq 0xa0f0
movl $0x0, -0x186c4(%rbp)
movl -0x186c4(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xbf48
movq -0x18(%rbp), %rax
movslq -0x186c4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x186d0(%rbp)
leaq -0x186c0(%rbp), %rdi
movq -0x186d0(%rbp), %rdx
leaq 0x204ef(%rip), %rsi     # 0x2c409
movb $0x0, %al
callq 0x8090
movq -0x186d8(%rbp), %rax
movq (%rax), %rdi
leaq -0x186c0(%rbp), %rsi
callq 0xa0f0
movl -0x186c4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x186c4(%rbp)
jmp 0xbede
movq -0x186d8(%rbp), %rax
movq (%rax), %rdi
leaq 0x204b4(%rip), %rsi     # 0x2c40d
callq 0xa0f0
addq $0x186e0, %rsp          # imm = 0x186E0
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: Array::extend_array(int)
void extend_array(int newLength) {
        if(arraySize_ <= newLength) {
            int oldSize = arraySize_;
            arraySize_ = newLength*2;
            Object** newObjs = new Object*[arraySize_];
            for (size_t i = 0; i < oldSize ; i++) {
                newObjs[i] = objs_[i];
            }
            delete [] objs_;
            objs_ = newObjs;
        }
        hash_ = 0; //every time the array is
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
ja 0xc03e
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
movl %ecx, -0x10(%rbp)
movl -0xc(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jae 0xc017
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xbfe0
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xc032
movq -0x30(%rbp), %rdi
callq 0x8300
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: yasz24[P]eau2/src/network/./../store/key.h
// Function: Key::equals(Object*)
bool equals(Object* other) {
        if (other == this) return true;
        Key* x = dynamic_cast<Key *>(other);
        if (x == nullptr) return false;
        //std::cout << "in key equals: name: " << name_->c_str() << " " << x->name_->c_str() <<"\n";
        //std::cout << res << "\n";
        return this->name_->equals(x->name_) && (this->node_ == x->node_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0xc6e7
movb $0x1, -0x1(%rbp)
jmp 0xc775
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xc716
movq -0x30(%rbp), %rdi
leaq 0x2d9c0(%rip), %rsi     # 0x3a0c0
leaq 0x2e029(%rip), %rdx     # 0x3a730
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x38(%rbp)
jmp 0xc71e
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xc71e
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc733
movb $0x0, -0x1(%rbp)
jmp 0xc775
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0xc757
jmp 0xc76d
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0xc86f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1fbad(%rip), %rsi     # 0x2c42f
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
leaq 0x1fb99(%rip), %rsi     # 0x2c433
callq 0xc9f0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x1fb77(%rip), %rsi     # 0x2c429
callq 0x9f30
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../utils/string.h
// Function: String::String(char const*, unsigned long)
String(char const* cstr, size_t len) {
       size_ = len;
       cstr_ = new char[size_ + 1];
       memcpy(cstr_, cstr, size_ + 1);
       cstr_[size_] = 0; // terminate
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x9780
movq -0x38(%rbp), %rax
leaq 0x2da64(%rip), %rcx     # 0x3a390
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
incq %rdi
callq 0x8030
movq %rax, -0x30(%rbp)
jmp 0xc949
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq 0x10(%rax), %rdx
addq $0x1, %rdx
callq 0x8200
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x10(%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9830
movq -0x20(%rbp), %rdi
callq 0x8400
nop
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x2f505(%rip), %rdi     # 0x3bfc0
leaq 0x1f977(%rip), %rsi     # 0x2c439
callq 0x8280
movq $0xc350, -0x10(%rbp)    # imm = 0xC350
movq -0x10(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xcb5e
movaps 0x1f4f7(%rip), %xmm1    # 0x2c010
movq -0x28(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x1f4f6(%rip), %xmm1    # 0x2c020
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xcb08
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0xce60
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdi
movq 0x10(%rax), %rsi
movsd -0x20(%rbp), %xmm0
callq 0xd070
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x2f405(%rip), %rdi     # 0x3bfc0
leaq 0x1fdb9(%rip), %rsi     # 0x2c97b
callq 0x8280
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rax), %rsi
callq 0x1eb10
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq 0x10(%rax), %rdx
leaq -0x9(%rbp), %rdi
callq 0x21400
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xcc23
movq -0x38(%rbp), %rdi
leaq 0x2d4b3(%rip), %rsi     # 0x3a0c0
leaq 0x2e334(%rip), %rdx     # 0x3af48
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x48(%rbp)
jmp 0xcc2b
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0xcc2b
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0xc350, -0x30(%rbp)    # imm = 0xC350
jae 0xcc76
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x1ee50
cltq
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xcc43
movq -0x40(%rbp), %rdi
leaq 0x1fd03(%rip), %rsi     # 0x2c984
callq 0x1ef90
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x1efd0
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rdi
movq 0x10(%rax), %rsi
movq -0x28(%rbp), %rax
movl %eax, %edx
callq 0x1f020
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x2f2f5(%rip), %rdi     # 0x3bfc0
leaq 0x1fdad(%rip), %rsi     # 0x2ca7f
callq 0x8280
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rax), %rsi
callq 0x1eb10
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rdi
movq 0x30(%rax), %rsi
callq 0x1eb10
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %rsi
movq 0x2f2a8(%rip), %rdi     # 0x3bfc0
callq 0x8280
movq %rax, %rdi
leaq 0x1f406(%rip), %rsi     # 0x2c12d
callq 0x8280
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %rsi
movq 0x2f280(%rip), %rdi     # 0x3bfc0
callq 0x8280
movq %rax, %rdi
leaq 0x1f3de(%rip), %rsi     # 0x2c12d
callq 0x8280
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq 0x10(%rax), %rdx
leaq -0x9(%rbp), %rdi
callq 0x21400
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xcd98
movq -0x38(%rbp), %rdi
leaq 0x2d33e(%rip), %rsi     # 0x3a0c0
leaq 0x2e1bf(%rip), %rdx     # 0x3af48
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x48(%rbp)
jmp 0xcda0
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0xcda0
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq 0x10(%rax), %rdx
leaq -0x9(%rbp), %rdi
callq 0x21400
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xcdec
movq -0x50(%rbp), %rdi
leaq 0x2d2ea(%rip), %rsi     # 0x3a0c0
leaq 0x2e16b(%rip), %rdx     # 0x3af48
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x58(%rbp)
jmp 0xcdf4
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0xcdf4
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1ee50
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1f220
movl %eax, %ecx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jne 0xce35
leaq 0x1fc5c(%rip), %rax     # 0x2ca8b
movq %rax, -0x68(%rbp)
jmp 0xce42
leaq 0x1fc57(%rip), %rax     # 0x2ca93
movq %rax, -0x68(%rbp)
jmp 0xce42
movq -0x40(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x1f1d0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xd1f0
movl $0x20, %edi
callq 0x8290
movq %rax, -0xa8(%rbp)
jmp 0xce97
movq -0xa8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd380
jmp 0xcea9
movq -0xa8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq $0x0, -0x90(%rbp)
movq -0x90(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xcf47
xorl %eax, %eax
movl %eax, %esi
leaq -0x70(%rbp), %rdi
callq 0xd420
jmp 0xcedb
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x90(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
jmp 0xcefd
jmp 0xceff
movq -0x90(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0xcebf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xd05c
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x8260
jmp 0xd05c
movl $0x28, %edi
callq 0x8290
movq %rax, -0xb0(%rbp)
jmp 0xcf5a
movq -0xb0(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x70(%rbp), %rsi
callq 0xd4f0
jmp 0xcf70
movq -0xb0(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
movq -0x78(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd7f0
jmp 0xcf94
movl $0x20, %edi
callq 0x8290
movq %rax, -0xb8(%rbp)
jmp 0xcfa7
movq -0x98(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0xc0(%rbp)
jmp 0xcfc0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0xdad0
jmp 0xcfd9
movq -0xb8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
callq 0xdb20
jmp 0xcffd
movq -0x98(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xdda0
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x8260
jmp 0xd05c
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
callq 0x8260
leaq -0x70(%rbp), %rdi
callq 0xdda0
movq -0x80(%rbp), %rdi
callq 0x8400
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl $0x50, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0xd1f0
jmp 0xd0a0
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x20, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0xd380
jmp 0xd0c7
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd420
movq -0x38(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
movl $0x28, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xd4f0
jmp 0xd114
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd7f0
movl $0x20, %edi
callq 0x8290
movq %rax, -0x70(%rbp)
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
movq %rax, -0x68(%rbp)
jmp 0xd14e
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0xdad0
jmp 0xd161
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xdb20
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8260
jmp 0xd1de
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8260
jmp 0xd1de
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8260
jmp 0xd1de
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8260
movq -0x28(%rbp), %rdi
callq 0x8400
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x9780
movq -0x28(%rbp), %rax
leaq 0x2d544(%rip), %rcx     # 0x3a758
movq %rcx, (%rax)
movq $0x64, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq 0x10(%rax), %rdi
incq %rdi
callq 0x8030
movq %rax, -0x20(%rbp)
jmp 0xd239
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rcx
movb $0x0, (%rcx,%rdx)
movq $0x0, 0x28(%rax)
movl $0x30, %edi
callq 0x8290
movq %rax, -0x30(%rbp)
jmp 0xd269
movq -0x30(%rbp), %rdi
callq 0xddf0
jmp 0xd274
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x30(%rax)
movl $0x30, %edi
callq 0x8290
movq %rax, -0x38(%rbp)
jmp 0xd290
movq -0x38(%rbp), %rdi
callq 0xddf0
jmp 0xd29b
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl $0x30, %edi
callq 0x8290
movq %rax, -0x40(%rbp)
jmp 0xd2b7
movq -0x40(%rbp), %rdi
callq 0xddf0
jmp 0xd2c2
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x40(%rax)
movl $0x30, %edi
callq 0x8290
movq %rax, -0x48(%rbp)
jmp 0xd2de
movq -0x48(%rbp), %rdi
callq 0xddf0
jmp 0xd2e9
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x48(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xd363
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8260
jmp 0xd363
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8260
jmp 0xd363
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8260
jmp 0xd363
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8260
movq -0x28(%rbp), %rdi
callq 0x9830
movq -0x10(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::add_row(String*)
void add_row(String* name) {
        if (name != nullptr ) {
            if (this->row_name_idx->get(name) == nullptr) {
                Integer* i = new Integer(this->num_rows_);
                this->row_name_idx->add(name, i);
                this->row_idx_name->add(i, name);
            }
        }
        this->num_rows_ += 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd4c9
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xec70
cmpq $0x0, %rax
jne 0xd4c7
movl $0x18, %edi
callq 0x8290
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movl 0x28(%rax), %esi
callq 0x146a0
jmp 0xd47c
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf260
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xf260
jmp 0xd4c7
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8260
jmp 0xd4df
jmp 0xd4c9
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8400
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x9780
movq -0x30(%rbp), %rax
leaq 0x2c9ac(%rip), %rcx     # 0x3a7c0
movq %rcx, (%rax)
movq $0x20, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x28(%rbp)
jmp 0xde3f
movq -0x28(%rbp), %rdi
movl $0x20, %esi
callq 0xe200
jmp 0xde4f
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0xdefb
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x38(%rbp)
jmp 0xde91
movq -0x38(%rbp), %rdi
callq 0xe290
jmp 0xde9c
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x58(%rax), %rax
callq *%rax
jmp 0xdeaf
jmp 0xdeb1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xde63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xdf01
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8260
jmp 0xdf01
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8260
jmp 0xdf01
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x9830
movq -0x10(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xfc20
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xdfc4
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq 0x18(%rcx), %rcx
movq -0x18(%rbp), %rdx
movsbq (%rcx,%rdx), %rcx
imulq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xdf74
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0xdff7
movb $0x1, -0x1(%rbp)
jmp 0xe0d9
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xe026
movq -0x38(%rbp), %rdi
leaq 0x2c0b0(%rip), %rsi     # 0x3a0c0
leaq 0x2c781(%rip), %rdx     # 0x3a798
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0xe02e
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0xe02e
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe046
movb $0x0, -0x1(%rbp)
jmp 0xe0d9
movq -0x30(%rbp), %rdi
callq 0xfc20
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0xfc20
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0xe06e
movb $0x0, -0x1(%rbp)
jmp 0xe0d9
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0xfc20
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0xe0d5
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x54(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xfc40
movb %al, %cl
movl -0x54(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
je 0xe0c5
movb $0x0, -0x1(%rbp)
jmp 0xe0d9
jmp 0xe0c7
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xe076
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0xe11f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1e38e(%rip), %rsi     # 0x2c4c0
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
leaq 0x1e37d(%rip), %rsi     # 0x2c4c7
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x1e36f(%rip), %rsi     # 0x2c4d1
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x28(%rax), %rdx
leaq 0x1e364(%rip), %rsi     # 0x2c4de
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x1e2f0(%rip), %rsi     # 0x2c482
callq 0xa6f0
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xe1cd
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xe3a8
movb $0x0, -0x1(%rbp)
jmp 0xe4b2
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xe3d7
movq -0x50(%rbp), %rdi
leaq 0x2bcff(%rip), %rsi     # 0x3a0c0
leaq 0x2c438(%rip), %rdx     # 0x3a800
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x58(%rbp)
jmp 0xe3df
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0xe3df
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xe3f7
movb $0x0, -0x1(%rbp)
jmp 0xe4b2
movq -0x48(%rbp), %rdi
callq 0xeae0
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0xeae0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0xe422
movb $0x0, -0x1(%rbp)
jmp 0xe4b2
movq -0x48(%rbp), %rdi
callq 0xeb00
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0xeae0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0xe4ae
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xec70
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xec70
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0xe49e
movb $0x0, -0x1(%rbp)
jmp 0xe4b2
jmp 0xe4a0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xe437
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x30, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0xddf0
jmp 0xe4ef
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0xeb00
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0xeae0
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xe585
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0xec70
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0xf260
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xe519
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0xe58f
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8400
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x9e10
jmp 0xe5cf
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1deb1(%rip), %rsi     # 0x2c493
callq 0x9e70
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x10(%rax), %rdx
leaq 0x1de9d(%rip), %rsi     # 0x2c497
callq 0x9f30
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x1de91(%rip), %rsi     # 0x2c4a3
callq 0x9f30
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x1de86(%rip), %rsi     # 0x2c4b0
callq 0x9f30
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1de67(%rip), %rsi     # 0x2c4b7
xorl %ecx, %ecx
callq 0xf190
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xe68d
movq -0x48(%rbp), %rdi
callq 0x9ff0
movq -0x48(%rbp), %rdi
callq 0x8260
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::hash()
size_t hash() {
    size_t res = 0;
    if (this->size() > 0) {
      size_t len = this->size();
      //go through the given list.
      ObjectNode *curNode = this->head_;
      for (size_t i = 0; i < len; i++) {
        Object *data = curNode->data_;
        //add the data's hash val to result.
        res += data->hash();
      }
    }
    return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, -0x10(%rbp)
callq 0xea20
cmpq $0x0, %rax
jbe 0xe793
movq -0x38(%rbp), %rdi
callq 0xea20
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xe791
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xe75b
jmp 0xe793
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xe7c8
movb $0x0, -0x1(%rbp)
jmp 0xe8b6
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xe7f7
movq -0x48(%rbp), %rdi
leaq 0x2b8df(%rip), %rsi     # 0x3a0c0
leaq 0x2c080(%rip), %rdx     # 0x3a868
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x50(%rbp)
jmp 0xe7ff
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xe7ff
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
callq 0xea20
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
je 0xe831
movb $0x0, -0x1(%rbp)
jmp 0xe8b6
movq -0x40(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jbe 0xe8b2
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq 0x20(%rcx), %rax
jae 0xe8ac
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0xe882
movb $0x0, -0x1(%rbp)
jmp 0xe8b6
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xe85c
movb $0x1, -0x1(%rbp)
jmp 0xe8b6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)