LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("Queue");
    sb->write("size_", size_);
    Object** objs_ = new Object*[this->size_];
    //go through the given list.
    for (size_t i = 0; i < this->size_; i++) {
        objs_[i] =  this->get(i);
    }
    sb->write("queueObjs_", objs_, this->size_);
    sb->endSerialize();
    char* value = sb->get();
    delete sb;
    return value;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x9e10
jmp 0xe8ff
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1db31(%rip), %rsi     # 0x2c443
callq 0x9e70
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x1db1f(%rip), %rsi     # 0x2c449
callq 0x9f30
movq -0x48(%rbp), %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, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq 0x20(%rcx), %rax
jae 0xe9b5
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %esi
callq 0xea40
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xe964
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0xea13
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq 0x20(%rax), %rax
movl %eax, %ecx
leaq 0x1da81(%rip), %rsi     # 0x2c44f
callq 0xbe80
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xea09
movq -0x50(%rbp), %rdi
callq 0x9ff0
movq -0x50(%rbp), %rdi
callq 0x8260
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8400
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::get(int)
Object *get(int to_get) {
    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++) {
        if (to_get == i) {
          return curNode->data_;
        }
        curNode = curNode ->getNext();
      }
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xea20
cmpq $0x0, %rax
jbe 0xeac6
movq -0x38(%rbp), %rdi
callq 0xea20
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xeac4
movslq -0x14(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0xeaa8
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xeace
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xea86
jmp 0xeac6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::keys()
Object** keys() {
      Object** keys = new Object*[this->items_];
      size_t index_to_assign = 0;
      for (size_t i = 0; i < this->numBuckets_; i++) {
        Queue *queue_at_index = dynamic_cast<Queue*>(this->buckets_->get(i));
        for (size_t j = 0; j < queue_at_index->size(); j++) {
          KeyVal *key_val = dynamic_cast<KeyVal *>(queue_at_index->get(j));
          keys[index_to_assign] = key_val->getKey();
          index_to_assign +=1;
        }
      }
      return keys;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
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, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0xec63
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xeb9c
movq -0x48(%rbp), %rdi
leaq 0x2b53a(%rip), %rsi     # 0x3a0c0
leaq 0x2bcdb(%rip), %rdx     # 0x3a868
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x50(%rbp)
jmp 0xeba4
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xeba4
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0xea20
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0xec50
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %esi
callq 0xea40
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xec0b
movq -0x60(%rbp), %rdi
leaq 0x2b4cb(%rip), %rsi     # 0x3a0c0
leaq 0x2bc84(%rip), %rdx     # 0x3a880
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x68(%rbp)
jmp 0xec13
xorl %eax, %eax
movq %rax, -0x68(%rbp)
jmp 0xec13
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xee30
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xebb4
jmp 0xec52
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xeb4d
movq -0x10(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::get(Object*)
Object *get(Object* o) {
    if (this->size() > 0) {
      size_t len = this->size();
      //std::cout << "in queue get, size: " << len << "\n";
      //go through the given list.
      ObjectNode *curNode = this->head_;
      for (size_t i = 0; i < len; i++) {
        if (curNode->data_->equals(o)) {
          //std::cout << "found key: "<< curNode->data_->serialize() <<"\n";
          return curNode->data_;
        }
        curNode = curNode ->getNext();
      }
    }
    return nullptr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xea20
cmpq $0x0, %rax
jbe 0xef35
movq -0x38(%rbp), %rdi
callq 0xea20
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xef33
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0xef09
jmp 0xef17
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xef3d
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xeee7
jmp 0xef35
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/keyVal.h
// Function: KeyVal::equals(Object*)
virtual bool equals(Object *other) {
        if (other == nullptr) return false;
		KeyVal *kv = dynamic_cast<KeyVal*>(other);
		if (kv == nullptr) {
			return false;
		}
        //std::cout << "in KevVal equals: " << "key: " << key_->serialize() << " val: " << val_->serialize() << "\n";
        //it is okay to only check if the keys because in a map one key only maps to a single value. 
		return this->getKey()->equals(kv->getKey());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xefe5
movb $0x0, -0x1(%rbp)
jmp 0xf059
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xf014
movq -0x30(%rbp), %rdi
leaq 0x2b0c2(%rip), %rsi     # 0x3a0c0
leaq 0x2b87b(%rip), %rdx     # 0x3a880
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x38(%rbp)
jmp 0xf01c
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xf01c
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xf031
movb $0x0, -0x1(%rbp)
jmp 0xf059
movq -0x28(%rbp), %rdi
callq 0xee30
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0xee30
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/keyVal.h
// Function: KeyVal::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("KeyVal");
        char * seralizedKey = key_->serialize();
        sb->write("key_", seralizedKey, false);
        char * seralizedVal = val_->serialize();
        sb->write("val_", seralizedVal, false);
        sb->endSerialize();
        char* value = sb->get();
        delete sb;
        return value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x9e10
jmp 0xf0bf
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1d3a4(%rip), %rsi     # 0x2c476
callq 0x9e70
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1d385(%rip), %rsi     # 0x2c47d
xorl %ecx, %ecx
callq 0xf190
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x1d362(%rip), %rsi     # 0x2c482
xorl %ecx, %ecx
callq 0xf190
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x10(%rbp), %rdi
callq 0x9fc0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xf15d
movq -0x50(%rbp), %rdi
callq 0x9ff0
movq -0x50(%rbp), %rdi
callq 0x8260
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%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/./../serialize/serial.h
// Function: Serializable::write(char const*, char*, bool)
void write(const char* name, char* val, bool wrap) {
        int SIZEOFINSERTS = 10;
        char str[strlen(val) + strlen(name) + SIZEOFINSERTS];
        if(wrap) {
            sprintf(str, "'%s' : '%s', ", name, val);
        } else {
            sprintf(str, "'%s' : %s, ", name, val);
        }
        buff->c(str);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0xa, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8130
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8130
movq -0x40(%rbp), %rdx
addq %rax, %rdx
movslq -0x20(%rbp), %rcx
movq %rdx, %rax
addq %rcx, %rax
movq %rsp, %rsi
movq %rsi, -0x28(%rbp)
leaq 0xf(%rcx,%rdx), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, %rsp
movq %rax, -0x30(%rbp)
testb $0x1, -0x19(%rbp)
je 0xf224
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x1d1ba(%rip), %rsi     # 0x2c3d5
movb $0x0, %al
callq 0x8090
jmp 0xf23e
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x1d250(%rip), %rsi     # 0x2c487
movb $0x0, %al
callq 0x8090
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0xa0f0
movq -0x28(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::rehash_()
void rehash_() {
      KeyVal *key_val[this->items_];
      Object** this_keys = this->keys();
      for (size_t i = 0; i < this->size(); i++) {
        key_val[i] = new KeyVal(this_keys[i], this->get(this_keys[i]));
      }

      size_t items = this->items_;

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

      delete this->buckets_;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq 0x20(%rdi), %rax
movq %rsp, %rcx
movq %rcx, -0x10(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, %rsp
movq %rax, -0x18(%rbp)
callq 0xeb00
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0xeae0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0xf565
movl $0x20, %edi
callq 0x8290
movq -0x58(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq %rsi, -0x70(%rbp)
callq 0xec70
movq %rax, -0x68(%rbp)
jmp 0xf51a
movq -0x68(%rbp), %rdx
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0xee50
jmp 0xf52d
movq -0x50(%rbp), %rax
movq -0x78(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xf4d0
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x8260
jmp 0xf65e
movq -0x58(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x10(%rax), %rcx
shlq %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq 0x28(%rax), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0xf5a4
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x28, %edi
callq 0x8290
movq %rax, %rdi
movq -0x58(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x88(%rbp)
movq 0x10(%rax), %rsi
callq 0xe200
jmp 0xf5ca
movq -0x58(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0xf652
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xee30
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x90(%rbp)
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xef50
movq -0x58(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq %rax, %rdx
callq 0xf260
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0xf5e1
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x8260
jmp 0xf65e
movq -0x10(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8400
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/queue.h
// Function: Queue::add(Object*)
void add(Object* o) {
    //create the linked list node.
    ObjectNode *newNode = new ObjectNode(o);
    if (this->head_ == nullptr) {
      //adding in first element. set both head and tail to be that element.
      this->head_ = newNode;
      this->tail_ = newNode;
      //increment size.
      this->size_+=1;
    } else{
      this->tail_->setNext(newNode);
      newNode->setPrev(this->tail_);
      this->tail_ = newNode;
      this->size_+=1;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x28, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0xf8a0
jmp 0xf6a7
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0xf6f3
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0xf72f
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x8260
jmp 0xf735
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x50(%rax)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x18(%rax), %rsi
movq (%rdi), %rax
callq *0x58(%rax)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8400
nop
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/map.h
// Function: Map::pop_item(Object*)
Object* pop_item(Object* key) {
      size_t key_hash = key->hash();
      int index = key_hash % this->numBuckets_;
      Queue *queue_at_index = dynamic_cast<Queue *>(this->buckets_->get(index));
      KeyVal *wrappedkey = new KeyVal(key, nullptr);
      this->items_ -= 1;
      if (queue_at_index->size() == 0) {
        this->bucketsUsed_ -= 1;    
      }
      KeyVal *keyVal = dynamic_cast<KeyVal*>(queue_at_index->remove(wrappedkey));
      return keyVal->getVal();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x58(%rbp), %rcx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
xorl %edx, %edx
divq 0x10(%rcx)
movq -0x58(%rbp), %rax
movl %edx, %ecx
movl %ecx, -0x1c(%rbp)
movq 0x28(%rax), %rdi
movslq -0x1c(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xf7b9
movq -0x50(%rbp), %rdi
leaq 0x2a91d(%rip), %rsi     # 0x3a0c0
leaq 0x2b0be(%rip), %rdx     # 0x3a868
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x60(%rbp)
jmp 0xf7c1
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0xf7c1
movq -0x60(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x20, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xee50
jmp 0xf7ec
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x20(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rdi
callq 0xea20
cmpq $0x0, %rax
jne 0xf83c
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x18(%rax)
jmp 0xf83c
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x8260
jmp 0xf896
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xfa60
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0xf874
movq -0x70(%rbp), %rdi
leaq 0x2a862(%rip), %rsi     # 0x3a0c0
leaq 0x2b01b(%rip), %rdx     # 0x3a880
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x78(%rbp)
jmp 0xf87c
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0xf87c
movq -0x78(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xef50
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x8400
nop
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/listNode.h
// Function: ObjectNode::equals(Object*)
virtual bool equals(Object * other) {
		if (other == nullptr) return false;
        ObjectNode *o = dynamic_cast<ObjectNode*>(other);
		if (o == nullptr) {
			return false;
		}
        return this->data_->equals(o->data_);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf965
movb $0x0, -0x1(%rbp)
jmp 0xf9cc
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xf994
movq -0x30(%rbp), %rdi
leaq 0x2a742(%rip), %rsi     # 0x3a0c0
leaq 0x2afd3(%rip), %rdx     # 0x3a958
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x38(%rbp)
jmp 0xf99c
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xf99c
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xf9b1
movb $0x0, -0x1(%rbp)
jmp 0xf9cc
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::DoubleDistributedArray(KVStore*)
DoubleDistributedArray(KVStore* kv) {
        kv_ = kv;
        totalNodes_ = kv->num_nodes_;
        srand(time(nullptr));
        uid_ = rand();
        curNode_ = 0;
        itemCount_ = 0;
        chunkCount_ = 0;
        keys_ = new Array();
        chunkArray_ = new DoubleArray(chunkSize_);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x9780
movq -0x30(%rbp), %rax
leaq 0x2ae88(%rip), %rcx     # 0x3ab80
movq %rcx, (%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x32, 0x30(%rax)
movq $0x400, 0x48(%rax)      # imm = 0x400
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x68(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x8250
movl %eax, %edi
callq 0x8270
callq 0x80c0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, 0x40(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x50(%rax)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x28(%rbp)
jmp 0xfd79
movq -0x28(%rbp), %rdi
callq 0xab80
jmp 0xfd84
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x38(%rax)
movl $0x28, %edi
callq 0x8290
movq %rax, -0x38(%rbp)
jmp 0xfda0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x48(%rax), %esi
callq 0x10490
jmp 0xfdb2
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0xfdfe
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0xfdfe
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
movq -0x30(%rbp), %rdi
callq 0x9830
movq -0x18(%rbp), %rdi
callq 0x8400
// File: yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedDoubleColumn::equals(Object*)
bool equals(Object * o) {
    if(o == nullptr) return false;
    DistributedDoubleColumn* other_ic = dynamic_cast<DistributedDoubleColumn*>(o);
    if(other_ic == nullptr) return false;
    if(other_ic->size() != size()) return false;
    DoubleDistributedArray* other_val_ = dynamic_cast<DoubleDistributedArray*>(other_ic->val_);
    return this->val_->equals(other_val_);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xfe88
movb $0x0, -0x1(%rbp)
jmp 0xff27
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xfeb7
movq -0x38(%rbp), %rdi
leaq 0x2a21f(%rip), %rsi     # 0x3a0c0
leaq 0x2abc8(%rip), %rdx     # 0x3aa70
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0xfebf
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0xfebf
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xfed4
movb $0x0, -0x1(%rbp)
jmp 0xff27
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0xc8(%rax)
movq -0x30(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq (%rdi), %rax
callq *0xc8(%rax)
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0xff04
movb $0x0, -0x1(%rbp)
jmp 0xff27
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/distributedColumn.h
// Function: DistributedDoubleColumn::serialize()
char* serialize() {
    Serializable* sb = new Serializable();
    sb->initSerialize("DistributedDoubleColumn");
    char * seralizedArr = val_->serialize();
    sb->write("val_", seralizedArr, 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 0xff8f
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1c6ec(%rip), %rsi     # 0x2c68e
callq 0x9e70
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1c4ba(%rip), %rsi     # 0x2c482
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 0x10005
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
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        DoubleDistributedArray *s = dynamic_cast<DoubleDistributedArray*>(o);
        if(s == nullptr) return false;
        if(itemCount_ != s->itemCount_) return false;
        for(int i = 0; i < itemCount_; i++) {
            bool sameInt = s->get(i) == (get(i));
            if(!sameInt) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10598
movb $0x0, -0x1(%rbp)
jmp 0x10669
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x105c7
movq -0x38(%rbp), %rdi
leaq 0x29b0f(%rip), %rsi     # 0x3a0c0
leaq 0x2a608(%rip), %rdx     # 0x3abc0
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x105cf
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x105cf
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x105e7
movb $0x0, -0x1(%rbp)
jmp 0x10669
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x58(%rcx), %rax
je 0x105ff
movb $0x0, -0x1(%rbp)
jmp 0x10669
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x10665
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x11340
movq -0x30(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x11340
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x10658
movb $0x0, -0x1(%rbp)
jmp 0x10669
jmp 0x1065a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10606
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::hash_me()
size_t hash_me() {
      size_t temp = 0;
      for(int i = 0; i < itemCount_; i++) {
          temp *= get(i);
      }
      return temp;
  }

// 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 0x58(%rcx), %rax
jae 0x10721
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x11340
movaps %xmm0, %xmm1
movaps 0x1b948(%rip), %xmm2    # 0x2c010
movq -0x10(%rbp), %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x1b947(%rip), %xmm2    # 0x2c020
subpd %xmm2, %xmm0
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x1b9c5(%rip), %xmm1    # 0x2c0c8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x106a3
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        sb->initSerialize("DoubleDistributedArray");
        sb->write("uid_", uid_);
        sb->write("chunkSize_", chunkSize_);
        sb->write("chunkCount_", chunkCount_);
        sb->write("itemCount_", itemCount_);
        sb->write("curNode_", curNode_);
        sb->write("totalNodes_", totalNodes_);
        sb->write("keys_", keys_->serialize(), false);
        sb->write("chunkArray_", chunkArray_->serialize(), 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, -0x38(%rbp)
movl $0x8, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x9e10
jmp 0x1075f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1bec2(%rip), %rsi     # 0x2c634
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x40(%rax), %rdx
leaq 0x1bec1(%rip), %rsi     # 0x2c64b
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x48(%rax), %rdx
leaq 0x1beae(%rip), %rsi     # 0x2c650
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x50(%rax), %rdx
leaq 0x1bea1(%rip), %rsi     # 0x2c65b
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x58(%rax), %rdx
leaq 0x1bdbe(%rip), %rsi     # 0x2c590
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x60(%rax), %rdx
leaq 0x1be7d(%rip), %rsi     # 0x2c667
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x68(%rax), %rdx
leaq 0x1be6e(%rip), %rsi     # 0x2c670
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq 0x1be51(%rip), %rsi     # 0x2c67c
xorl %ecx, %ecx
callq 0xf190
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x48(%rbp), %rdi
movq %rax, %rdx
leaq 0x1be2c(%rip), %rsi     # 0x2c682
xorl %ecx, %ecx
callq 0xf190
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 0x10893
movq -0x40(%rbp), %rdi
callq 0x9ff0
movq -0x40(%rbp), %rdi
callq 0x8260
movq -0x28(%rbp), %rax
addq $0x50, %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
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: DoubleArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        DoubleArray *s = dynamic_cast<DoubleArray*>(o);
        if(s == nullptr) return false;
        if(listLength_ != s->listLength_) return false;
        for(int i = 0; i < listLength_; i++) {
            bool sameDoub = s->get(i) == get(i);
            if(!sameDoub) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10968
movb $0x0, -0x1(%rbp)
jmp 0x10a39
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x10997
movq -0x38(%rbp), %rdi
leaq 0x2973f(%rip), %rsi     # 0x3a0c0
leaq 0x2a2a0(%rip), %rdx     # 0x3ac28
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x1099f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x1099f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x109b7
movb $0x0, -0x1(%rbp)
jmp 0x10a39
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x109cf
movb $0x0, -0x1(%rbp)
jmp 0x10a39
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x10a35
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x10c80
movq -0x30(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x10c80
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x10a28
movb $0x0, -0x1(%rbp)
jmp 0x10a39
jmp 0x10a2a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x109d6
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: DoubleArray::clone()
virtual Object* clone() { 
        IntArray* temp = new IntArray();
        for(int i = 0; i < listLength_; i++) {
            int value = vals_[i];
            temp->pushBack(value);
        }
        return temp;
     }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x28, %edi
callq 0x8290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x10ce0
jmp 0x10a7f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rcx
movslq -0x20(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x10ade
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
cvttsd2si (%rax,%rcx,8), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x10d70
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x10a8e
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x8260
jmp 0x10ae8
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8400
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: DoubleArray::hash_me()
size_t hash_me() {
      double temp = 0;
      for(int i = 0; i < listLength_; i++) {
          temp *= vals_[i];
      }
      return temp;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x10b53
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10b1f
movsd -0x10(%rbp), %xmm0
movsd 0x1b568(%rip), %xmm2    # 0x2c0c8
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
popq %rbp
retq
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: DoubleArray::serialize()
char* serialize() {
        Serializable* sb = new Serializable();
        //std::cout << "in DoubleArray"<< "\n";
        sb->initSerialize("DoubleArray");
        sb->write("listLength_", listLength_);
        sb->write("arraySize_", arraySize_);
        sb->write("vals_", vals_, 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 0x10baf
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1b9b4(%rip), %rsi     # 0x2c576
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x1b916(%rip), %rsi     # 0x2c4f0
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x1b7fc(%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 0x1b95a(%rip), %rsi     # 0x2c56a
callq 0x11260
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 0x10c4b
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: IntArray::equals(Object*)
bool equals(Object * o) {
      if ( o == nullptr) return false;
        IntArray *s = dynamic_cast<IntArray*>(o);
        if(s == nullptr) return false;
        if(listLength_ != s->listLength_) return false;
        for(int i = 0; i < listLength_; i++) {
            bool sameInt = s->get(i) == get(i);
            if(!sameInt) {
                return false;
            }
        }
        return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10e48
movb $0x0, -0x1(%rbp)
jmp 0x10f0a
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x10e77
movq -0x38(%rbp), %rdi
leaq 0x2925f(%rip), %rsi     # 0x3a0c0
leaq 0x29e28(%rip), %rdx     # 0x3ac90
xorl %eax, %eax
movl %eax, %ecx
callq 0x82f0
movq %rax, -0x40(%rbp)
jmp 0x10e7f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x10e7f
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10e94
movb $0x0, -0x1(%rbp)
jmp 0x10f0a
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x10eac
movb $0x0, -0x1(%rbp)
jmp 0x10f0a
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x10f06
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x11120
movq -0x30(%rbp), %rdi
movl %eax, -0x44(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x11120
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x10ef9
movb $0x0, -0x1(%rbp)
jmp 0x10f0a
jmp 0x10efb
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10eb3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: IntArray::hash_me()
size_t hash_me() {
      int temp = 0;
      for(int i = 0; i < listLength_; i++) {
          temp *= vals_[i];
      }
      return temp;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movslq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x1100d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10fde
movslq -0xc(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../application/../store/../utils/array.h
// Function: IntArray::serialize()
char* serialize() {
         //std::cout << "in IntArray"<< "\n";
        Serializable* sb = new Serializable();
        sb->initSerialize("IntArray");
        sb->write("listLength_", listLength_);
        sb->write("arraySize_", arraySize_);
        sb->write("vals_", vals_, 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 0x1104f
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1b4ff(%rip), %rsi     # 0x2c561
callq 0x9e70
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x18(%rax), %rdx
leaq 0x1b476(%rip), %rsi     # 0x2c4f0
callq 0x9f30
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x20(%rax), %rdx
leaq 0x1b35c(%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 0x1b4ba(%rip), %rsi     # 0x2c56a
callq 0x11180
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 0x110eb
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/./../serialize/serial.h
// Function: Serializable::write(char const*, int*, int)
void write(const char* name, int* val, int len) {
        char str[1000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            sprintf(str, "'%i',", val[i]);
            buff->c(str);
        }
        buff->c("], ");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1b248(%rip), %rsi     # 0x2c3ff
movb $0x0, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl $0x0, -0x414(%rbp)
movl -0x414(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x11233
leaq -0x410(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x414(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x1b36b(%rip), %rsi     # 0x2c570
movb $0x0, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
jmp 0x111de
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq 0x1b1c9(%rip), %rsi     # 0x2c40d
callq 0xa0f0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yasz24[P]eau2/src/network/./../serialize/serial.h
// Function: Serializable::write(char const*, double*, int)
void write(const char* name, double* val, int len) {
        char str[1000];
        sprintf(str, "'%s' : [ ", name);
        buff->c(str);
        for(int i = 0; i < len; i++) {
            sprintf(str, "'%f',", val[i]);
            buff->c(str);
        }
        buff->c("], ");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1b168(%rip), %rsi     # 0x2c3ff
movb $0x0, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl $0x0, -0x414(%rbp)
movl -0x414(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x11315
leaq -0x410(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x414(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x1b29b(%rip), %rsi     # 0x2c582
movb $0x1, %al
callq 0x8090
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa0f0
movl -0x414(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x414(%rbp)
jmp 0x112be
movq -0x420(%rbp), %rax
movq (%rax), %rdi
leaq 0x1b0e7(%rip), %rsi     # 0x2c40d
callq 0xa0f0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::get(unsigned long)
double get(size_t index) {
        assert(index < itemCount_);
        //std::cout << "in get " << index <<"\n";
        if (cache_ == nullptr) {
            init_cache_();
        }
        double res;
        if(index/chunkSize_ == chunkCount_) {
            res = chunkArray_->get(index % chunkSize_);
        } else {

            size_t key_idx = floor((index/chunkSize_));
            //std::cout << "key index: " << key_idx << "\n";
            //std::cout << key
            DoubleArray* doubleVals;
            if (cache_[key_idx] != nullptr) {
                //std::cout << "get chunk from cache\n";
                doubleVals = cache_[key_idx];
            } else {
                //std::cout << "get chunk from kv\n";
                doubleVals = get_chunk_from_kv_(key_idx);
            }
            res = doubleVals->get(index % chunkSize_);
        }
        //std::cout << "res: " << res << "\n";
        return res; //returns int at correct index in array at this chunk
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x58(%rcx), %rax
jae 0x11364
jmp 0x11383
leaq 0x1b21d(%rip), %rdi     # 0x2c588
leaq 0x1b229(%rip), %rsi     # 0x2c59b
movl $0x3a8, %edx            # imm = 0x3A8
leaq 0x1b257(%rip), %rcx     # 0x2c5d5
callq 0x81a0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x11397
movq -0x30(%rbp), %rdi
callq 0x11480
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq 0x48(%rcx)
cmpq 0x50(%rcx), %rax
jne 0x113cf
movq -0x30(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq 0x48(%rcx)
movq %rdx, %rsi
callq 0x10c80
movsd %xmm0, -0x18(%rbp)
jmp 0x1146b
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x48(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rdi
callq 0x11520
movq -0x30(%rbp), %rax
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movsd 0x1acc5(%rip), %xmm1    # 0x2c0c8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1143b
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x1144c
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11560
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq 0x48(%rcx)
movq %rdx, %rsi
callq 0x10c80
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yasz24[P]eau2/src/network/./../application/../dataframe/../utils/distributedArray.h
// Function: DoubleDistributedArray::init_cache_()
void init_cache_() {
        //assuming a dataframe is immutable, so nu pushbacks after the first get call.
        cache_ = new DoubleArray*[keys_->length()];
        for (size_t i = 0; i < keys_->length(); i++) {
            cache_[i] = nullptr;
        }
        return;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x38(%rax), %rdi
callq 0x11670
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x8030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x38(%rax), %rdi
callq 0x11670
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x11514
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x114d1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)