LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/client.cpp
// Function: main
int main(int argc, char *argv[]) 
{ 
	char *ip;
	size_t port;
	size_t node_idx;

	if (argc != 5  || (strcmp(argv[1], "-ip") != 0) || (strcmp(argv[3], "-idx") != 0)) {
	    fprintf(stderr,"usage: client -ip <host-ip-address>:PORT -idx <node_idx>\n");
	    _exit(1);
	} 
	ip = strtok(argv[2], ":");
    port = std::stoi(strtok(NULL, ":"));
	node_idx = std::stoi(argv[4]);

	std::cout<< "port is: "<<port << "\n";
	NetworkIP* client_ = new NetworkIP();

	client_->client_init(node_idx, ip, port, SERVER_IP, PORT);
	Demo* demo = new Demo(node_idx, client_);
	demo->start_kv();
	demo->run_();
	while (true) {
		
	}
	return 0; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpl $0x5, %edi
jne 0x76d0
movq %rsi, %r14
movq 0x8(%rsi), %rdi
leaq 0x10b26(%rip), %rsi     # 0x180a8
callq 0x72d0
testl %eax, %eax
jne 0x76d0
movq 0x18(%r14), %rdi
leaq 0x10b12(%rip), %rsi     # 0x180ac
callq 0x72d0
testl %eax, %eax
jne 0x76d0
movq 0x10(%r14), %rdi
leaq 0x10be4(%rip), %r15     # 0x18196
movq %r15, %rsi
callq 0x7340
movq %rax, %rbx
xorl %edi, %edi
movq %r15, %rsi
callq 0x7340
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %rax, %rsi
callq 0x70f0
leaq -0x48(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, %r12d
leaq -0x48(%rbp), %rdi
callq 0x7120
movq 0x20(%r14), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x70f0
leaq -0x48(%rbp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x771e
movl %eax, %r15d
movslq %r12d, %r14
leaq -0x48(%rbp), %rdi
callq 0x7120
movq 0x1d99a(%rip), %rdi     # 0x24fc0
leaq 0x10abe(%rip), %rsi     # 0x180eb
callq 0x7240
movq %rax, %rdi
movq %r14, %rsi
callq 0x7190
leaq 0x10aa5(%rip), %rsi     # 0x180e9
movq %rax, %rdi
callq 0x7240
pushq $0x48
popq %rdi
callq 0x7250
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
leaq 0x1bbc8(%rip), %rax     # 0x23238
movq %rax, (%r12)
movq $0x1, 0x18(%r12)
andq $0x0, 0x40(%r12)
movslq %r15d, %r15
leaq 0x10a68(%rip), %r8      # 0x180f5
movl $0xbb8, %r9d            # imm = 0xBB8
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x7740
pushq $0x38
popq %rdi
callq 0x7250
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x79e8
movq %r14, %rdi
callq 0x7a7e
movq (%r14), %rax
movq %r14, %rdi
callq *0x40(%rax)
jmp 0x76ce
movq 0x1d8f9(%rip), %rax     # 0x24fd0
movq (%rax), %rcx
leaq 0x109d0(%rip), %rdi     # 0x180b1
pushq $0x39
popq %rsi
pushq $0x1
popq %rdx
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x7350
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
jmp 0x7716
jmp 0x7705
jmp 0x7713
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x7120
jmp 0x7716
movq %rax, %rbx
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./network_ip.h
// Function: NetworkIP::send_msg(Message*)
void send_msg(Message* msg) {
        size_t target_node = msg->target();
        //std::cout << "send msg target: " << target_node << "\n";
        NodeInfo &target = nodes_[target_node];
        int server_port = ntohs(target.address.sin_port);
        char server_ip[INET_ADDRSTRLEN];
        inet_ntop(AF_INET, &target.address.sin_addr, server_ip, INET_ADDRSTRLEN);
        //std::cout << "attempting to send msg to: " << server_ip << ":" << server_port << "\n";
        int connection = socket(AF_INET, SOCK_STREAM, 0);
        assert(connection >= 0);
        if (connect(connection, (sockaddr*)&target.address, sizeof(target.address)) < 0) {
            perror("connection failed. Error");
            return;
        }
        msg->id_ = msg_id;
        msg_id++;
        //assert(connect(connection, (sockaddr*)&target.address, sizeof(target.address)) >= 0);
        char* serialized = msg->serialize();
        //std::cout << "sending msg: " << serialized << "\n";
        size_t length = strlen(serialized);
        send(connection, &length, sizeof(size_t), 0);
        send(connection, serialized, length, 0);
        close(connection);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %r12
imulq $0x28, 0x20(%rsi), %r13
leaq (%r12,%r13), %rsi
addq $0x1c, %rsi
pushq $0x2
popq %rbx
leaq -0x40(%rbp), %rdx
pushq $0x10
popq %rcx
movl %ebx, %edi
callq 0x7280
pushq $0x1
popq %rsi
movl %ebx, %edi
xorl %edx, %edx
callq 0x7090
testl %eax, %eax
js 0x7ceb
movl %eax, %ebx
leaq (%r12,%r13), %rsi
addq $0x18, %rsi
pushq $0x10
popq %rdx
movl %eax, %edi
callq 0x71d0
testl %eax, %eax
js 0x7cdd
movq 0x40(%r15), %rax
movq %rax, 0x28(%r14)
incq %rax
movq %rax, 0x40(%r15)
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r14
movq %rax, %rdi
callq 0x7110
leaq -0x30(%rbp), %r15
movq %rax, (%r15)
pushq $0x8
popq %rdx
movl %ebx, %edi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x7150
movq (%r15), %rdx
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x7150
movl %ebx, %edi
callq 0x73e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1046b(%rip), %rdi     # 0x1814f
callq 0x71e0
jmp 0x7cce
leaq 0x10412(%rip), %rdi     # 0x18104
leaq 0x1041b(%rip), %rsi     # 0x18114
leaq 0x10423(%rip), %rcx     # 0x18123
movl $0x89, %edx
callq 0x7170
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./network_ip.h
// Function: NetworkIP::recv_msg()
Message* recv_msg() {
        sockaddr_in sender;
        socklen_t addrlen = sizeof(sender);
        int req = accept(sock_, (sockaddr*)&sender, &addrlen);
        size_t size = 0;
        read(req, &size, sizeof(size_t));
        char* buf = new char[size];
        int rd = 0;
        while (rd != size) {
            rd+= read(req, buf + rd, size - rd);
        }
        //std::cout << "received msg: " << buf << "\n";
        Deserializable ds;
        Message* msg = dynamic_cast<Message*>(ds.deserialize(buf));
        close(req);
        return msg;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq -0x28(%rbp), %rdx
movl $0x10, (%rdx)
movl 0x28(%rdi), %edi
leaq -0x40(%rbp), %rsi
callq 0x70d0
movl %eax, %ebx
leaq -0x30(%rbp), %r14
andq $0x0, (%r14)
pushq $0x8
popq %rdx
movl %eax, %edi
movq %r14, %rsi
callq 0x72f0
movq (%r14), %r14
movq %r14, %rdi
callq 0x7030
movq %rax, %r15
xorl %eax, %eax
movslq %eax, %r12
movq %r14, %rdx
subq %r12, %rdx
je 0x7d71
leaq (%r15,%r12), %rsi
movl %ebx, %edi
callq 0x72f0
addq %r12, %rax
jmp 0x7d56
leaq -0x21(%rbp), %rdi
movq %r15, %rsi
callq 0x12f4c
testq %rax, %rax
je 0x7d9f
leaq 0x1b51f(%rip), %rsi     # 0x232a8
leaq 0x1b560(%rip), %rdx     # 0x232f0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r14
jmp 0x7da2
xorl %r14d, %r14d
movl %ebx, %edi
callq 0x73e0
movq %r14, %rax
addq $0x20, %rsp
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_ip.h
// Function: NetworkIP::init_sock_(char*, unsigned long)
void init_sock_(char* ip, size_t port) {
        assert((sock_ = socket(AF_INET, SOCK_STREAM, 0)) >= 0);
        int opt =1;
        assert(setsockopt(sock_, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt) == 0));
        ip_.sin_family = AF_INET;
        //ip_.sin_addr.s_addr = inet_addr(ip);
        inet_pton(AF_INET, ip, &ip_.sin_addr);
        ip_.sin_port = htons(port);
        //int res = bind(sock_, (sockaddr*) &ip_, sizeof(ip_));
        if( bind(sock_, (sockaddr*) &ip_, sizeof(ip_)) < 0){
            perror("bind failed. Error");
            return;
        }
        if( (listen(sock_, 100)) < 0){
            perror("listen failed. Error");
            return;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x7090
movl %eax, 0x28(%rbx)
testl %eax, %eax
js 0x7e74
leaq -0x24(%rbp), %rcx
movl $0x1, (%rcx)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movl %eax, %edi
xorl %r8d, %r8d
callq 0x73a0
testl %eax, %eax
je 0x7e8d
leaq 0x2c(%rbx), %r12
movw $0x2, 0x2c(%rbx)
leaq 0x30(%rbx), %rdx
pushq $0x2
popq %rdi
movq %r15, %rsi
callq 0x73c0
rolw $0x8, %r14w
movw %r14w, 0x2e(%rbx)
movl 0x28(%rbx), %edi
pushq $0x10
popq %rdx
movq %r12, %rsi
callq 0x7060
testl %eax, %eax
js 0x7e5d
movl 0x28(%rbx), %edi
pushq $0x64
popq %rsi
callq 0x7290
testl %eax, %eax
js 0x7e66
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x103ea(%rip), %rdi     # 0x1824e
jmp 0x7e6d
leaq 0x103f4(%rip), %rdi     # 0x18261
callq 0x71e0
jmp 0x7e50
leaq 0x10335(%rip), %rdi     # 0x181b0
leaq 0x10292(%rip), %rsi     # 0x18114
leaq 0x10356(%rip), %rcx     # 0x181df
pushq $0x6e
jmp 0x7ea4
leaq 0x10376(%rip), %rdi     # 0x1820a
leaq 0x10279(%rip), %rsi     # 0x18114
leaq 0x1033d(%rip), %rcx     # 0x181df
pushq $0x70
popq %rdx
callq 0x7170
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./network.h
// Function: Register::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Register");
        sb->write("kind_", (int)kind_);
        sb->write("sender_", sender_);
        sb->write("target_", target_);
        sb->write("id_", id_);
        sb->write("port", port_);
        sb->write("client", client);
        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 0x10459(%rip), %rsi     # 0x1833b
movq %rbx, %rdi
callq 0x7fd8
movl 0x10(%r14), %edx
leaq 0x10381(%rip), %rsi     # 0x18276
movq %rbx, %rdi
callq 0x801c
movq 0x18(%r14), %rdx
leaq 0x10374(%rip), %rsi     # 0x1827c
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0x10369(%rip), %rsi     # 0x18284
movq %rbx, %rdi
callq 0x8062
movq 0x28(%r14), %rdx
leaq 0x10699(%rip), %rsi     # 0x185c7
movq %rbx, %rdi
callq 0x8062
movq 0x38(%r14), %rdx
leaq 0x10403(%rip), %rsi     # 0x18344
movq %rbx, %rdi
callq 0x8062
movq 0x30(%r14), %rdx
leaq 0x103f5(%rip), %rsi     # 0x18349
movq %rbx, %rdi
callq 0x844c
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7f7d
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/./../utils/string.h
// Function: StrBuff::c(char const*)
StrBuff& c(const char* str) {
        size_t step = strlen(str);
        grow_by_(step);
        memcpy(val_+size_, str, step);
        size_ += step;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x7110
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x8160
movq 0x10(%r14), %rdi
addq 0x20(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x71c0
addq %r15, 0x20(%r14)
movq %r14, %rax
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/./../utils/string.h
// Function: StrBuff::grow_by_(unsigned long)
void grow_by_(size_t step) {
        if (step + size_ < capacity_) return;
        capacity_ *= 2;
        if (step + size_ >= capacity_) capacity_ += step;        
        char* oldV = val_;
        val_ = new char[capacity_];
        memcpy(val_, oldV, size_);
        delete[] oldV;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rbx
leaq (%rbx,%rsi), %rcx
cmpq %rax, %rcx
jb 0x81c5
movq %rdi, %r14
leaq (%rax,%rax), %rdx
xorl %edi, %edi
cmpq %rdx, %rcx
cmovbq %rdi, %rsi
leaq (%rsi,%rax,2), %rdi
movq %rdi, 0x18(%r14)
movq 0x10(%r14), %r15
callq 0x7030
movq %rax, 0x10(%r14)
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x71c0
testq %r15, %r15
je 0x81c5
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x72c0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../utils/string.h
// Function: StrBuff::get()
String* get() {
        assert(val_ != nullptr); // can be called only once
        grow_by_(1);     // ensure space for terminator
        val_[size_] = '\0'; // terminate
        String *res = new String(true, val_, size_);
        val_ = new char[capacity_ = 10]; // val_ was consumed above
        size_ = 0;
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0x10(%rdi)
je 0x8234
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x8160
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movb $0x0, (%rax,%rcx)
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r14
movq 0x10(%rbx), %rdx
movq 0x20(%rbx), %rcx
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x8266
movq $0xa, 0x18(%rbx)
pushq $0xa
popq %rdi
callq 0x7030
movq %rax, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1007f(%rip), %rdi     # 0x182ba
leaq 0x10088(%rip), %rsi     # 0x182ca
leaq 0x10095(%rip), %rcx     # 0x182de
movl $0x8e, %edx
callq 0x7170
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../utils/string.h
// Function: String::equals(Object*)
bool equals(Object* other) {
        if (other == this) return true;
        String* x = dynamic_cast<String *>(other);
        if (x == nullptr) return false;
        if (size_ != x->size_) return false;
        return strncmp(cstr_, x->cstr_, size_) == 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq %rdi, %rsi
je 0x837a
testq %rsi, %rsi
je 0x837e
movq %rdi, %r14
leaq 0x1af67(%rip), %rax     # 0x232a8
leaq 0x1b160(%rip), %rdx     # 0x234a8
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0x8380
movq 0x10(%r14), %rdx
cmpq 0x10(%rax), %rdx
jne 0x837e
movq 0x18(%r14), %rdi
movq 0x18(%rax), %rsi
callq 0x7140
testl %eax, %eax
sete %bl
jmp 0x8380
movb $0x1, %bl
jmp 0x8380
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../utils/string.h
// Function: String::hash_me()
size_t hash_me() {
        size_t hash = 0;
        for (size_t i = 0; i < size_; ++i)
            hash = cstr_[i] + (hash << 6) + (hash << 16) - hash;
        return hash;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
xorl %eax, %eax
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x83ed
movsbq (%rdx,%rsi), %rdi
imulq $0x1003f, %rax, %rax    # imm = 0x1003F
addq %rdi, %rax
incq %rsi
jmp 0x83d4
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, char*)
void write(const char* name, char* val) {
        int SIZEOFINSERTS = 10;
        char str[strlen(val) + strlen(name) + SIZEOFINSERTS];
        sprintf(str, "'%s' : '%s', ", name, val);
        buff->c(str);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x7110
movq %rax, %r12
movq %r15, %rdi
callq 0x7110
addq %r12, %rax
addq $0x19, %rax
andq $-0x10, %rax
movq %rsp, %r12
subq %rax, %r12
movq %r12, %rsp
leaq 0xfec2(%rip), %rsi      # 0x18350
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x7080
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x8114
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/application.h
// Function: Demo::run_()
void run_() override {
    switch(this_node()) {
    case 0:   producer();     break;
    case 1:   counter();      break;
    case 2:   summarizer();
   }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rdi), %rax
cmpq $0x2, %rax
je 0x85a9
cmpq $0x1, %rax
je 0x85a3
testq %rax, %rax
jne 0x85af
popq %rbp
jmp 0x9058
popq %rbp
jmp 0x90d2
popq %rbp
jmp 0x919c
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x1afde(%rip), %rax     # 0x235b0
movq %rax, (%rdi)
andl $0x0, 0x28(%rdi)
movq %rdx, %r15
andq $0x0, 0x30(%rdi)
movq %rsi, %r12
leaq 0x28(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %rax, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
leaq 0x58(%rdi), %r13
movq %r13, %rdi
callq 0x866e
leaq 0xd8(%rbx), %rdi
callq 0x869c
movb $0x0, 0x110(%rbx)
movq %r12, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movq %r14, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, %rdi
callq 0x86d4
jmp 0x8649
movq %rax, %r14
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8db8
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xfc1a(%rip), %rsi      # 0x1838c
movq %rbx, %rdi
callq 0x7fd8
movq 0x10(%r14), %rdx
leaq 0xfc0f(%rip), %rsi      # 0x18394
movq %rbx, %rdi
callq 0x8062
movq 0x18(%r14), %rdx
leaq 0xfc07(%rip), %rsi      # 0x1839f
movq %rbx, %rdi
callq 0x8062
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x80bc
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/./../application/../store/../utils/array.h
// Function: Array::hash()
size_t hash() {
       size_t res = 0;
        for(int i = 0; i < listLength_; i++) {
            //specific code to deal with the union data-type
            res+=objs_[i]->hash();
        }
        return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
cmpq %r15, 0x18(%rbx)
jbe 0x8a1d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq %rax, %r14
incq %r15
jmp 0x8a01
movq %r14, %rax
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/../utils/array.h
// Function: Array::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Array");
        sb->write("listLength_", listLength_);
        sb->write("arraySize_", arraySize_);
        sb->write("objs_", objs_, listLength_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xfb50(%rip), %rsi      # 0x185c0
movq %rbx, %rdi
callq 0x7fd8
movq 0x18(%r14), %rdx
leaq 0xf9e8(%rip), %rsi      # 0x1846b
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0xf8d3(%rip), %rsi      # 0x18369
movq %rbx, %rdi
callq 0x8062
movq 0x10(%r14), %rdx
movl 0x18(%r14), %ecx
leaq 0xf8c7(%rip), %rsi      # 0x18374
movq %rbx, %rdi
callq 0x8bf6
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8ad6
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/./../application/../store/../utils/array.h
// Function: Array::set(unsigned long, Object*)
virtual Object* set(size_t index, Object* o) {
      if(index > listLength_-1) {
            return nullptr;
        }
        Object* temp = get(index);
        objs_[index] = o;
        if(temp == nullptr) {
            listLength_++;
            return nullptr;
        }
        hash_ = 0; //since list has changed in composition, reset stored hash
        return temp;
  }

// Assembly:
movq 0x18(%rdi), %rax
decq %rax
cmpq %rsi, %rax
jae 0x8b2f
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x10(%rbx), %rcx
movq %r14, (%rcx,%r15,8)
testq %rax, %rax
je 0x8b5c
andq $0x0, 0x8(%rbx)
jmp 0x8b62
incq 0x18(%rbx)
xorl %eax, %eax
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/../utils/array.h
// Function: Array::remove(unsigned long)
virtual Object* remove(size_t index) {
      if(index > listLength_-1) {
            return nullptr;
        }
        Object* temp = get(index);
        for(int i = index; i<listLength_; i++) {
            if(i < listLength_-1) {
                objs_[i] = objs_[i+1];
            }
        }
        listLength_--;
        hash_ = 0; //since list has changed in composition, reset stored hash
        return temp;
  }

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x186a8, %rsp          # imm = 0x186A8
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r15
leaq 0xf75e(%rip), %rsi      # 0x1837a
xorl %r13d, %r13d
leaq -0x186d0(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
testl %ebx, %ebx
cmovlel %r13d, %ebx
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x8c77
movq (%r14,%r13,8), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %r12, %rdi
leaq 0xf727(%rip), %rsi      # 0x18384
movq %rax, %rdx
xorl %eax, %eax
callq 0x7080
movq (%r15), %rdi
movq %r12, %rsi
callq 0x8114
incq %r13
jmp 0x8c44
movq (%r15), %rdi
leaq 0xf707(%rip), %rsi      # 0x18388
callq 0x8114
addq $0x186a8, %rsp          # imm = 0x186A8
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/./../application/../store/../utils/array.h
// Function: Array::extend_array(int)
void extend_array(int newLength) {
        if(arraySize_ <= newLength) {
            int oldSize = arraySize_;
            arraySize_ = newLength*2;
            Object** newObjs = new Object*[arraySize_];
            for (size_t i = 0; i < oldSize ; i++) {
                newObjs[i] = objs_[i];
            }
            delete [] objs_;
            objs_ = newObjs;
        }
        hash_ = 0; //every time the array is
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r15
movslq %esi, %rax
cmpq %rax, %r15
ja 0x8cf8
leal (%rsi,%rsi), %eax
cltq
movq %rax, 0x20(%rbx)
shlq $0x3, %rax
testl %esi, %esi
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x7030
movq %rax, %r14
movslq %r15d, %rax
movq 0x10(%rbx), %rdi
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x8cea
movq (%rdi,%rcx,8), %rdx
movq %rdx, (%r14,%rcx,8)
incq %rcx
jmp 0x8cd8
testq %rdi, %rdi
je 0x8cf4
callq 0x72c0
movq %r14, 0x10(%rbx)
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq %rdi, %rsi
je 0x8ead
testq %rsi, %rsi
je 0x8eb2
movq %rdi, %rbx
leaq 0x1a43a(%rip), %rax     # 0x232a8
leaq 0x1a95b(%rip), %rdx     # 0x237d0
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0x8eb5
movq %rax, %r15
movq 0x10(%rbx), %rdi
movq 0x10(%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb %al, %al
je 0x8eb2
movq 0x18(%rbx), %rax
cmpq 0x18(%r15), %rax
sete %r14b
jmp 0x8eb5
movb $0x1, %r14b
jmp 0x8eb5
xorl %r14d, %r14d
movl %r14d, %eax
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/./../store/key.h
// Function: Key::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Key");
        sb->write("name_", name_);
        sb->write("node_", node_);
        sb->endSerialize();
        char* value = sb->get();
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xf45e(%rip), %rsi      # 0x183aa
movq %rbx, %rdi
callq 0x7fd8
movq 0x10(%r14), %rdx
leaq 0xf44f(%rip), %rsi      # 0x183ae
movq %rbx, %rdi
callq 0x9002
movq 0x18(%r14), %rdx
leaq 0xf432(%rip), %rsi      # 0x183a4
movq %rbx, %rdi
callq 0x8062
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x80bc
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/./../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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
andq $0x0, 0x8(%rdi)
leaq 0x1a4a3(%rip), %rax     # 0x23468
movq %rax, (%rdi)
movq %rdx, 0x10(%rdi)
leaq 0x1(%rdx), %r12
movq %r12, %rdi
callq 0x7030
movq %rax, %r13
movq %rax, 0x18(%r15)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x71c0
movb $0x0, (%r13,%rbx)
addq $0x8, %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/./../application/application.h
// Function: Demo::producer()
void producer() {
    std::cout << "producer\n";
    size_t SZ = 50*1000;
    double* vals = new double[SZ];
    double sum = 0;
    for (size_t i = 0; i < SZ; ++i) sum += vals[i] = i;
    DistributedDataFrame::fromArray(main, kv_, SZ, vals);
    DistributedDataFrame::fromScalar(check, kv_, sum);
  }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x1bed5(%rip), %rdi     # 0x24fc0
leaq 0xf804(%rip), %rsi      # 0x188f6
callq 0x7240
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x12410
movq 0x10(%rax), %rsi
movq 0x10(%rbx), %rdx
leaq -0x21(%rbp), %rdi
callq 0x1358a
testq %rax, %rax
je 0x9137
leaq 0x1a187(%rip), %rsi     # 0x232a8
leaq 0x1add8(%rip), %rdx     # 0x23f00
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r15
jmp 0x913a
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %r12d, %r12d
cmpq $0xc350, %r12           # imm = 0xC350
je 0x9160
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x125d4
cltq
addq %rax, %r14
incq %r12
jmp 0x9140
movq 0x1be59(%rip), %rdi     # 0x24fc0
leaq 0xf791(%rip), %rsi      # 0x188ff
callq 0x7240
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1269c
movq 0x10(%rbx), %rsi
movq 0x28(%rbx), %rdi
movl %r14d, %edx
callq 0x126ca
addq $0x10, %rsp
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/application.h
// Function: Demo::summarizer()
void summarizer() {
    std::cout << "summarizer\n";
    Deserializable ds;
    Value* verify_val = kv_->waitAndget(verify);
    Value* check_val = kv_->waitAndget(check);
    std::cout << verify_val->serialize() << "\n";
    std::cout << check_val->serialize() << "\n";
    DistributedDataFrame* result = dynamic_cast<DistributedDataFrame*>(ds.deserialize(verify_val->data, kv_));
    DistributedDataFrame* expected = dynamic_cast<DistributedDataFrame*>(ds.deserialize(check_val->data, kv_));
    pln(expected->get_double(0,0)==result->get_int(0,0) ? "SUCCESS":"FAILURE");
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1be0c(%rip), %r15     # 0x24fc0
leaq 0xf83f(%rip), %rsi      # 0x189fa
movq %r15, %rdi
callq 0x7240
movq 0x10(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x12410
movq %rax, %r12
movq 0x10(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x12410
movq %rax, %r14
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7240
leaq 0xeeea(%rip), %r13      # 0x180e9
movq %rax, %rdi
movq %r13, %rsi
callq 0x7240
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x7240
movq %rax, %rdi
movq %r13, %rsi
callq 0x7240
movq 0x10(%r12), %rsi
movq 0x10(%rbx), %rdx
leaq -0x29(%rbp), %rdi
callq 0x1358a
testq %rax, %rax
je 0x925d
leaq 0x1a061(%rip), %rsi     # 0x232a8
leaq 0x1acb2(%rip), %rdx     # 0x23f00
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %r15
jmp 0x9260
xorl %r15d, %r15d
movq 0x10(%r14), %rsi
movq 0x10(%rbx), %rdx
leaq -0x29(%rbp), %rdi
callq 0x1358a
leaq 0x1a030(%rip), %rsi     # 0x232a8
leaq 0x1ac81(%rip), %rdx     # 0x23f00
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x72a0
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x125d4
movl %eax, %r14d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x127f0
cmpl %eax, %r14d
leaq 0xf758(%rip), %rax      # 0x18a06
leaq 0xf759(%rip), %rsi      # 0x18a0e
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x127c2
addq $0x8, %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/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::fromArray(Key*, KVStore*, unsigned long, double*)
static DistributedDataFrame* fromArray(Key* key, KVStore* kv, size_t length, double* vals) {
      Schema s;
      DistributedDoubleColumn* dc = new DistributedDoubleColumn(kv);
      for (size_t i = 0; i < length; i++) {
        //std::cout << i <<" in from array\n";
        s.add_row(nullptr);
        dc->push_back(vals[i]);
      }
      DistributedDataFrame* df = new DistributedDataFrame(s, kv);
      df->add_column(dc, nullptr);
      Value* val = new Value(df->serialize(), (size_t)0);
      kv->put(key, val);
      return df;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x94d2
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x9588
xorl %ebx, %ebx
cmpq %rbx, %r13
je 0x9330
incq -0x58(%rbp)
movsd (%r15,%rbx,8), %xmm0
movq (%r12), %rax
movq %r12, %rdi
callq *0xa0(%rax)
incq %rbx
jmp 0x930f
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r15
leaq -0x80(%rbp), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x95e4
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x9730
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
andq $0x0, 0x8(%r12)
leaq 0x1a978(%rip), %rcx     # 0x23cf0
movq %rcx, (%r12)
movq %rax, 0x10(%r12)
andq $0x0, 0x18(%r12)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rdx
callq 0x98c0
leaq -0x80(%rbp), %rdi
callq 0x9a4a
movq %r15, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x93bb
movq %rax, %rbx
movq %r15, %rdi
jmp 0x93c1
movq %rax, %rbx
movq %r12, %rdi
callq 0x7220
jmp 0x93d1
jmp 0x93ce
jmp 0x93ce
jmp 0x93ce
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x9a4a
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::fromScalar(Key*, KVStore*, double)
static DistributedDataFrame* fromScalar(Key* key, KVStore* kv, double scalar) {
      Schema* s = new Schema(); 
      DistributedDoubleColumn* dc = new DistributedDoubleColumn(kv);
      s->add_row(nullptr);
      dc->push_back(scalar);
      DistributedDataFrame* df = new DistributedDataFrame(*s, kv);
      df->add_column(dc, nullptr);
      Value* val = new Value(df->serialize(), (size_t)0);
      kv->put(key, val);
      return df;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
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 0x9588
incq 0x28(%r15)
movq (%r13), %rax
movq %r13, %rdi
movsd -0x30(%rbp), %xmm0
callq *0xa0(%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
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
movq (%r12), %rax
movq %r12, %rdi
callq *0x38(%rax)
andq $0x0, 0x8(%r15)
leaq 0x1a86f(%rip), %rcx     # 0x23cf0
movq %rcx, (%r15)
movq %rax, 0x10(%r15)
andq $0x0, 0x18(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x98c0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x94bf
movq %rax, %rbx
movq %r12, %r15
jmp 0x94c2
movq %rax, %rbx
movq %r13, %r15
jmp 0x94c2
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/schema.h
// Function: Schema::Schema()
Schema() {
        this->val_ = new char[this->capacity_ + 1];
        //null terminate the string.
        this->val_[this->capacity_] = '\0';
        this->num_rows_ = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x1a310(%rip), %rax     # 0x237f8
movq %rax, (%rdi)
movq $0x64, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
pushq $0x65
popq %rdi
callq 0x7030
movq %rax, 0x18(%rbx)
movb $0x0, 0x64(%rax)
andq $0x0, 0x28(%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)
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x9574
jmp 0x9574
jmp 0x9574
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/distributedDataframe.h
// Function: DistributedDataFrame::DistributedDataFrame(Schema&, KVStore*)
DistributedDataFrame(Schema& schema, KVStore* kv) {
      this->schema_ = new Schema(schema);
      this->cols_ = new Array();
      kv_ = kv;
      for (size_t i = 0; i < this->schema_->width(); i++) {
        char col_type = this->schema_->col_type(i);
        Column* col;
        switch (col_type) {
        case 'I':
          col = new DistributedIntColumn(kv);
          break;
        case 'S':
          col = new DistributedStringColumn(kv);
          break;
        case 'B':
          col = new DistributedBoolColumn(kv);
          break;
        case 'F':
          col = new DistributedFloatColumn(kv);
          break;
        case 'D':
          col = new DistributedDoubleColumn(kv);
          break;
        default:
          col = nullptr;
          break;
        }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rdx, %r14
movq %rsi, %r12
leaq 0x1a8b9(%rip), %rax     # 0x23ec0
movq %rax, (%rdi)
pushq $0x50
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xcf2c
movq %r15, 0x10(%rbx)
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
callq 0x869c
movq %r15, 0x18(%rbx)
movq %r14, 0x20(%rbx)
xorl %r13d, %r13d
leaq 0xe9bb(%rip), %r12      # 0x18004
movq 0x10(%rbx), %rax
cmpq 0x20(%rax), %r13
jae 0x9701
movq 0x18(%rax), %rax
movzbl (%rax,%r13), %eax
leal -0x42(%rax), %ecx
cmpl $0x7, %ecx
ja 0x9689
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
jmpq *%rax
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xd096
jmp 0x96ec
cmpl $0x53, %eax
jne 0x96f9
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xd03a
jmp 0x96ec
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xd0f2
jmp 0x96ec
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xcfde
jmp 0x96ec
pushq $0x20
popq %rdi
callq 0x7250
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x9588
movq 0x18(%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x58(%rax)
incq %r13
jmp 0x9649
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x971c
jmp 0x971c
jmp 0x971c
jmp 0x971c
jmp 0x971c
jmp 0x971c
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/./../application/../store/../utils/map.h
// Function: Map::Map()
Map() { 
      this->numBuckets_ = 32;
      this->bucketsUsed_ = 0;
      this->items_ = 0;
      this->buckets_ = new Array(32);
      for (size_t i = 0; i < this->numBuckets_; i++) {
        this->buckets_->pushBack(new Queue());
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
leaq 0x19dd9(%rip), %rax     # 0x23860
movq %rax, (%rdi)
movq $0x20, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
pushq $0x28
popq %rdi
callq 0x7250
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x9c9c
movq %r14, 0x28(%rbx)
xorl %r12d, %r12d
pushq $0x28
popq %r14
leaq 0x19e07(%rip), %r13     # 0x238c8
cmpq 0x10(%rbx), %r12
jae 0x9af8
movq 0x28(%rbx), %r15
movq %r14, %rdi
callq 0x7250
andq $0x0, 0x8(%rax)
movq %r13, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andq $0x0, 0x20(%rax)
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq *0x58(%rcx)
incq %r12
jmp 0x9ac1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x7220
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x18(%rdi), %rcx
xorl %eax, %eax
xorl %edx, %edx
subq 0x20(%rdi), %rdx
movabsq $0x1, %rsi
leaq (%rdx,%rsi), %rdi
cmpq $0x1, %rdi
je 0x9b6c
movsbq -0x1(%rcx,%rsi), %rdi
imulq %rsi, %rdi
addq %rdi, %rax
incq %rsi
jmp 0x9b50
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yasz24[P]eau2/src/network/./../application/../dataframe/schema.h
// Function: Schema::equals(Object*)
bool equals(Object* other) {
        if (other == this) return true;
        Schema* x = dynamic_cast<Schema *>(other);
        if (x == nullptr) return false;
        if (this->width() != x->width()) return false;
        for (size_t i = 0; i < this->width(); i++) {
            if ( this->val_[i] != x->col_type(i)) { 
                return false; 
            }
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq %rdi, %rsi
je 0x9bd3
testq %rsi, %rsi
je 0x9bd7
movq %rdi, %r14
leaq 0x1971f(%rip), %rax     # 0x232a8
leaq 0x19ca8(%rip), %rdx     # 0x23838
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
testq %rax, %rax
je 0x9bd9
movq 0x20(%r14), %rcx
cmpq 0x20(%rax), %rcx
jne 0x9bd7
movq 0x18(%r14), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
sete %bl
je 0x9bd9
movb (%rdx,%rsi), %dil
movq 0x18(%rax), %r8
leaq 0x1(%rsi), %r9
cmpb (%r8,%rsi), %dil
movq %r9, %rsi
je 0x9bb4
jmp 0x9bd9
movb $0x1, %bl
jmp 0x9bd9
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/schema.h
// Function: Schema::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("Schema");
        sb->write("capacity_", capacity_);
        sb->write("empty_index_", empty_index_);
        sb->write("num_rows_", num_rows_);
        sb->write("val_", this->val_);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x7250
movq %rax, %rbx
movq %rax, %rdi
callq 0x7fa0
leaq 0xe837(%rip), %rsi      # 0x1843b
movq %rbx, %rdi
callq 0x7fd8
movq 0x10(%r14), %rdx
leaq 0xe82b(%rip), %rsi      # 0x18442
movq %rbx, %rdi
callq 0x8062
movq 0x20(%r14), %rdx
leaq 0xe822(%rip), %rsi      # 0x1844c
movq %rbx, %rdi
callq 0x8062
movq 0x28(%r14), %rdx
leaq 0xe81c(%rip), %rsi      # 0x18459
movq %rbx, %rdi
callq 0x8062
movq 0x18(%r14), %rdx
leaq 0xe7ad(%rip), %rsi      # 0x183fd
movq %rbx, %rdi
callq 0x844c
movq %rbx, %rdi
callq 0x80a8
movq %rbx, %rdi
callq 0x80bc
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9c79
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/map.h
// Function: Map::equals(Object*)
virtual bool equals(Object* o) {
      if (o == nullptr) return false;
      Map *m = dynamic_cast<Map*>(o);
      if (o == nullptr) {
        return false;
      }
      
      if (this->size() != m->size()) return false;

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

        if (!this_val->equals(that_val)) {
          return false;
        }
      }

      return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x9dc2
movq %rdi, %rbx
leaq 0x19555(%rip), %rax     # 0x232a8
leaq 0x19b46(%rip), %rdx     # 0x238a0
xorl %r14d, %r14d
movq %rsi, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x72a0
movq 0x20(%rbx), %rcx
movq %rax, -0x30(%rbp)
cmpq 0x20(%rax), %rcx
jne 0x9dc5
movq %rbx, %rdi
callq 0xa152
movq %rax, %r12
xorl %r15d, %r15d
cmpq 0x20(%rbx), %r15
setae %r14b
jae 0x9dc5
movq (%r12,%r15,8), %rsi
movq %rbx, %rdi
callq 0xa248
movq %rax, %r13
movq (%r12,%r15,8), %rsi
movq -0x30(%rbp), %rdi
callq 0xa248
movq (%r13), %rcx
movq %r13, %rdi
movq %rax, %rsi
callq *0x18(%rcx)
incq %r15
testb %al, %al
jne 0x9d86
jmp 0x9dc5
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop