LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/vendor/m_foundation/src/model/m_skiplist.c
// Function: skt_insert
void*
skt_insert(skt_t *lst, uint64_t key, void *value) {
   if (lst && key>0 && key<SKT_KEY_MASK && value) {
      int k;
      skt_node_t *p, *next;
      skt_node_t *update[kMaxNumberOfLevels];   
      
      p = lst->header;
      k = lst->level;
      do {
         while (next = p->forward[k], next->key < key) {
            p = next;
         }
         update[k] = p;
      } while(--k >= 0);

      if (next->key == key) {
         return NULL;
      }

      k = _randomLevel(lst);
      if (k > lst->level) {
         k = ++lst->level;
         update[k] = lst->header;
      }
      next = _newNodeOfLevel(k);
      next->key = key;
      next->value = value;
      do {
         p = update[k];
         next->forward[k] = p->forward[k];
         p->forward[k] = next;
      } while(--k >= 0);
      lst->count += 1;
      return value;
   }
   return NULL;
}

// Assembly:
xorl %eax, %eax
testq %rdx, %rdx
je 0x6ec1
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
testq %rdi, %rdi
je 0x6eb0
movq %rsi, %r15
leaq -0x1(%rsi), %rcx
cmpq $-0x3, %rcx
ja 0x6eb0
movq 0x10(%r14), %rcx
movslq 0x8(%r14), %rax
movq %rcx, %rsi
movq %rsi, %rcx
movq 0x10(%rsi,%rax,8), %rsi
movq (%rsi), %rdi
cmpq %r15, %rdi
jb 0x6dc1
movq %rcx, -0xb0(%rbp,%rax,8)
leaq -0x1(%rax), %rsi
testq %rax, %rax
movq %rsi, %rax
jg 0x6dbe
cmpq %r15, %rdi
jne 0x6df2
xorl %r12d, %r12d
jmp 0x6ead
movq %rdx, -0x30(%rbp)
leaq 0x20(%r14), %r12
movl (%r14), %ecx
movl 0x4(%r14), %ebx
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %ebx, %eax
sarl $0x2, %eax
movl %eax, 0x4(%r14)
decl %ecx
movl %ecx, (%r14)
jne 0x6e2f
movq %r12, %rdi
callq 0x5b5d
movl %eax, 0x4(%r14)
movl $0xf, (%r14)
movl $0xf, %ecx
incl %r13d
testb $0x3, %bl
movl %eax, %ebx
je 0x6e07
cmpl $0xf, %r13d
movl $0xf, %ecx
cmovll %r13d, %ecx
movslq 0x8(%r14), %rax
cmpl %eax, %ecx
jle 0x6e64
leaq 0x1(%rax), %rbx
movl %ebx, 0x8(%r14)
movq 0x10(%r14), %rcx
movq %rcx, -0xa8(%rbp,%rax,8)
jmp 0x6e66
movl %ecx, %ebx
movq -0x30(%rbp), %r12
leaq 0x18(,%rbx,8), %rdi
leaq 0x4b25(%rip), %rsi      # 0xb99e
movl $0x30, %edx
callq 0x5cc4
movq %r15, (%rax)
movq %r12, 0x8(%rax)
incq %rbx
movq -0xb8(%rbp,%rbx,8), %rcx
movq 0x8(%rcx,%rbx,8), %rdx
movq %rdx, 0x8(%rax,%rbx,8)
movq %rax, 0x8(%rcx,%rbx,8)
decq %rbx
jg 0x6e8d
incl 0xc(%r14)
movq %r12, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/vendor/m_foundation/src/model/m_skiplist.c
// Function: skt_remove
void*
skt_remove(skt_t *lst, uint64_t key) {
   void *ret_value = NULL;
   if (lst && key>0 && key<SKT_KEY_MASK) {
      int k, m;
      skt_node_t *p, *next;
      skt_node_t *update[kMaxNumberOfLevels];      
      
      p = lst->header;
      k = m = lst->level;
      do {
         while (next = p->forward[k], next->key < key) {
            p = next;
         }
         update[k] = p;
      } while(--k >= 0);

      if (next->key == key) {
         ret_value = next->value;         
         for (k=0; k<=m && (p=update[k])->forward[k] == next; k++) {
            p->forward[k] = next->forward[k];
         }
         mm_free(next);
         while (lst->header->forward[m]==lst->tail && m>0) {
            m--;
         }
         lst->level = m;
         lst->count -= 1;
      }
   }
   return ret_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
testq %rdi, %rdi
sete %al
leaq -0x1(%rsi), %rcx
cmpq $-0x2, %rcx
setae %cl
orb %al, %cl
jne 0x6f90
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movslq 0x8(%rdi), %r15
movl %r15d, %eax
movq %r15, %rdx
movq %rcx, %rdi
movq %rdi, %rcx
movq 0x10(%rdi,%rdx,8), %rdi
movq (%rdi), %r8
cmpq %rsi, %r8
jb 0x6eff
movq %rcx, -0xa0(%rbp,%rdx,8)
leaq -0x1(%rdx), %r9
testq %rdx, %rdx
movq %r9, %rdx
jg 0x6efc
cmpq %rsi, %r8
jne 0x6f90
movq 0x8(%rdi), %r14
testl %eax, %eax
js 0x6f56
incq %rax
xorl %ecx, %ecx
movq -0xa0(%rbp,%rcx,8), %rdx
cmpq %rdi, 0x10(%rdx,%rcx,8)
jne 0x6f56
movq 0x10(%rdi,%rcx,8), %rsi
movq %rsi, 0x10(%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x6f35
leaq 0x4a41(%rip), %rsi      # 0xb99e
movl $0xc9, %edx
callq 0x5dc6
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
leal 0x1(%r15), %edx
decl %edx
testq %r15, %r15
jle 0x6f88
leaq -0x1(%r15), %rsi
cmpq %rcx, 0x10(%rax,%r15,8)
movq %rsi, %r15
je 0x6f73
movl %edx, 0x8(%rbx)
decl 0xc(%rbx)
jmp 0x6f93
xorl %r14d, %r14d
movq %r14, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/vendor/m_foundation/src/model/m_skiplist.c
// Function: skt_popf
void*
skt_popf(skt_t *lst) {
   if (lst && lst->count>0) {
      skt_node_t *p = lst->header->forward[0];
      return skt_remove(lst, p->key);
   }
   return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x6fe4
cmpl $0x0, 0xc(%rdi)
jle 0x6fe4
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
popq %rbp
jmp 0x6ec2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/vendor/m_foundation/src/model/m_skiplist.c
// Function: skt_iter_init
skt_iter_t*
skt_iter_init(skt_t *lst, skt_iter_t *it) {
   if (lst && lst->count>0 && it) {
      memset(it, 0, sizeof(*it));
      return it;
   }
   return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x700b
testq %rsi, %rsi
je 0x700b
cmpl $0x0, 0xc(%rdi)
jle 0x700b
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
movq %rsi, %rax
jmp 0x700d
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/vendor/m_foundation/src/model/m_skiplist.c
// Function: skt_iter_next
skt_iter_t*
skt_iter_next(skt_t *lst, skt_iter_t *it) {
   if (lst && lst->count>0 && it) {
      if (it->prev == NULL) {
         it->prev = lst->header;
      } else if ( it->curr ) {
         it->prev = ((skt_node_t*)it->prev)->forward[0];
      }
      it->curr = ((skt_node_t*)it->prev)->forward[0];
      skt_node_t *node = (skt_node_t*)it->curr;
      if (node != lst->tail) {
         it->key = node->key;
         it->value = node->value;
         return it;
      }
   }
   return NULL;
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x7066
testq %rsi, %rsi
je 0x7066
cmpl $0x0, 0xc(%rdi)
jle 0x7066
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rax
movq %rdi, %rcx
testq %rax, %rax
je 0x703a
cmpq $0x0, 0x8(%rsi)
movq %rax, %rcx
je 0x7041
movq 0x10(%rcx), %rax
movq %rax, (%rsi)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsi)
cmpq 0x18(%rdi), %rax
je 0x7063
movq (%rax), %rcx
movq %rcx, 0x10(%rsi)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsi)
movq %rsi, %rax
jmp 0x7065
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/vendor/m_foundation/src/model/m_skiplist.c
// Function: skt_iter_remove
void*
skt_iter_remove(skt_t *lst, skt_iter_t *it) {
   if (lst && lst->count>0 && it) {
      if (it->key > 0) {
         it->curr = NULL;
         return skt_remove(lst, it->key);
      }
   }
   return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x7095
testq %rsi, %rsi
je 0x7095
cmpl $0x0, 0xc(%rdi)
jle 0x7095
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x7095
movq $0x0, 0x8(%rsi)
movq %rax, %rsi
popq %rbp
jmp 0x6ec2
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/session_proto.cpp
// Function: proto_probe(unsigned char const*, int, proto_t*)
int
proto_probe(const unsigned char *buf, int buf_len, proto_t *proto) {
   if (buf && buf_len>0 && proto) {
      proto->ptype = (buf[0] >> _TYPE_OFFSET);
      proto->sid = (buf[1]<<8) | buf[2];
      if (proto->ptype == PROTO_TYPE_CTRL) {
         proto->u.cmd = (buf[0] & _CMD_MASK);
      } else {
         proto->u.data = (unsigned char*)(buf + 3);

      }
      proto->data_length = buf_len - 3;
      return 1;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
sete %al
testl %esi, %esi
setle %cl
testq %rdx, %rdx
sete %r8b
orb %al, %r8b
xorl %eax, %eax
orb %cl, %r8b
jne 0x70f3
movzbl (%rdi), %eax
shrl $0x5, %eax
movl %eax, (%rdx)
movzwl 0x1(%rdi), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
movl %ecx, 0x4(%rdx)
cmpl $0x1, %eax
jne 0x70e0
movb (%rdi), %al
andb $0x1f, %al
movb %al, 0x8(%rdx)
jmp 0x70e8
addq $0x3, %rdi
movq %rdi, 0x8(%rdx)
addl $-0x3, %esi
movl %esi, 0x10(%rdx)
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/session_proto.cpp
// Function: proto_mark_data(unsigned char*, unsigned int)
int
proto_mark_data(unsigned char *buf, unsigned sid) {
   if (buf) {
      buf[0] = (PROTO_TYPE_DATA << _TYPE_OFFSET);
      buf[1] = (sid >> 8) & 0xff;
      buf[2] = (sid & 0xff);
      return 3;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x713f
movl %esi, %eax
movb $0x40, (%rdi)
movb %ah, 0x1(%rdi)
movb %al, 0x2(%rdi)
movl $0x3, %eax
jmp 0x7141
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/kcp_local.cpp
// Function: local_tcpin_listen(chann_msg_t*)
void
_local_tcpin_listen(chann_msg_t *e) {
   if (e->event == CHANN_EVENT_ACCEPT) {

      tun_local_t *tun = (tun_local_t*)e->opaque;
      if ( tun ) {

         // setup local session
         unsigned sid = ++tun->session_idx;
         session_unit_t *u = session_create(tun->session_lst, sid, e->r, tun);
         if ( u ) {
            mnet_chann_set_cb(e->r, _local_tcpin_callback, u);

            // open remote tcp
            unsigned char buf[16] = { 0 };
            if ( proto_mark_cmd(buf, sid, PROTO_CMD_OPEN) ) {
               ikcp_send(tun->kcpout, (const char*)buf, 16);
            }

            cout << "accept tcpin: " << e->r << ", sid " << sid << endl;
            return;
         }
      }

      mnet_chann_disconnect(e->r);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpl $0x3, (%rdi)
jne 0x891d
movq %rdi, %r14
movq 0x18(%rdi), %r15
testq %r15, %r15
je 0x8928
movl 0x58(%r15), %ebx
incl %ebx
movl %ebx, 0x58(%r15)
movq 0x50(%r15), %rdi
movq 0x10(%r14), %rdx
movl %ebx, %esi
movq %r15, %rcx
callq 0x8de8
testq %rax, %rax
je 0x8928
movq 0x10(%r14), %rdi
leaq 0xed(%rip), %rsi        # 0x8964
movq %rax, %rdx
callq 0x4af5
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdi
movaps %xmm0, (%rdi)
movl %ebx, %esi
movl $0x1, %edx
callq 0x70f5
testl %eax, %eax
je 0x88ab
movq 0x48(%r15), %rdi
leaq -0x30(%rbp), %rsi
movl $0x10, %edx
callq 0x2d1a
movq 0x771e(%rip), %r15      # 0xffd0
leaq 0x372a(%rip), %rsi      # 0xbfe3
movl $0xe, %edx
movq %r15, %rdi
callq 0x22f0
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x2220
movq %rax, %r14
leaq 0x3716(%rip), %rsi      # 0xbff2
movl $0x6, %edx
movq %rax, %rdi
callq 0x22f0
movl %ebx, %esi
movq %r14, %rdi
callq 0x21d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2280
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x21e0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r14), %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4a59
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/kcp_local.cpp
// Function: local_kcpout_callback(char const*, int, IKCPCB*, void*)
int
_local_kcpout_callback(const char *buf, int len, ikcpcb *kcp, void *user) {
   tun_local_t *tun = (tun_local_t*)user;
   chann_t *udpout = tun->udpout[tun->udpout_idx];
   tun->udpout_idx = (tun->udpout_idx + 1) % tun->conf->src_count;

   if (tun && mnet_chann_state(udpout) >= CHANN_STATE_CONNECTED) {
      const int rs_offset = tun->rt ? sizeof(uint16_t) : 0;
      int data_len = len;
      uint8_t *data = tun->buf + rs_offset;

      if ( tun->conf->crypto ) {
         data_len = rc4_encrypt(buf, len,
                                (char*)data, MKCP_BUF_SIZE - XOR64_CHECKSUM_SIZE,
                                tun->ukey, (tun->ti>>20));
      } else {
         memcpy(data, buf, len);
      }

      int ret = 0;
      
      if ( tun->rt ) {
         int plen = 0;
         *((uint16_t*)tun->buf) = data_len;
         int raw_len = rskcp_enc_info(tun->rt, (data_len + rs_offset), &plen);
         ret = rskcp_encode(tun->rt, tun->buf, (data_len + rs_offset), &tun->buf[raw_len]);
         data_len = raw_len + plen;
      } else {
         ret = xor64_checksum_gen((uint8_t*)data, data_len, &tun->buf[data_len]);
         data_len += XOR64_CHECKSUM_SIZE;
      }

      if (ret && data_len>0) {
         ret = mnet_chann_send(udpout, tun->buf, data_len);
         if (ret == data_len) {
            return len;
         }
      }
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movl %esi, %ebx
movq %rdi, %r14
movslq (%rcx), %rax
movq 0x8(%rcx,%rax,8), %r12
incl %eax
movq 0x78(%rcx), %rcx
cltd
idivl (%rcx)
movl %edx, (%r15)
movq %r12, %rdi
callq 0x4600
cmpl $0x3, %eax
jl 0x8dd5
movq %r12, -0x40(%rbp)
xorl %r13d, %r13d
cmpq $0x0, 0x90(%r15)
setne %r13b
addl %r13d, %r13d
leaq (%r15,%r13), %rcx
addq $0x98, %rcx
movq 0x78(%r15), %rax
cmpl $0x0, 0x148(%rax)
movq %rcx, -0x38(%rbp)
je 0x8d3f
movq 0x60(%r15), %r8
movq 0x68(%r15), %r9
shrq $0x14, %r9
movq %r14, %rdi
movl %ebx, %esi
movq %rcx, %rdx
movl $0xfff8, %ecx           # imm = 0xFFF8
callq 0x56d9
movl %eax, %r12d
jmp 0x8d50
movslq %ebx, %rdx
movq %rcx, %rdi
movq %r14, %rsi
callq 0x2230
movl %ebx, %r12d
leaq 0x98(%r15), %r14
movq 0x90(%r15), %rdi
testq %rdi, %rdi
je 0x8da2
leaq -0x2c(%rbp), %rdx
movl $0x0, (%rdx)
movw %r12w, 0x98(%r15)
addl %r12d, %r13d
movl %r13d, %esi
callq 0x8f4b
movq 0x90(%r15), %rdi
movslq %eax, %r12
leaq (%r14,%r12), %rcx
movq %r14, %rsi
movl %r13d, %edx
callq 0x8fac
leaq -0x2c(%rbp), %rcx
addl (%rcx), %r12d
jmp 0x8db8
movslq %r12d, %rdx
addq %r14, %rdx
movq -0x38(%rbp), %rdi
movl %r12d, %esi
callq 0x5b98
addl $0x8, %r12d
testl %eax, %eax
je 0x8dd5
testl %r12d, %r12d
jle 0x8dd5
movq -0x40(%rbp), %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x4d37
cmpl %r12d, %eax
je 0x8dd7
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/session_mgnt.cpp
// Function: session_create(s_skt*, unsigned int, s_mchann*, void*)
session_unit_t*
session_create(skt_t *lst, unsigned sid, chann_t *tcp, void *opaque) {
   if (lst && tcp) {
      session_unit_t *u = (session_unit_t*)malloc(sizeof(*u));
      if (u) {
         u->sid = sid;
         u->tcp = tcp;
         u->opaque = opaque;
         u->connected = 0;
         if ( skt_insert(lst, sid, u) ) {
            return u;
         }
         free(u); // fail to insert
      }
   }
   return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x8e51
movq %rdx, %r13
movl %esi, %r15d
movq %rdi, %r14
movl $0x20, %edi
callq 0x2360
testq %rax, %rax
je 0x8e51
movq %rax, %rbx
movl %r15d, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x18(%rax)
movl $0x0, 0x10(%rax)
movl %r15d, %esi
movq %r14, %rdi
movq %rax, %rdx
callq 0x6d7a
testq %rax, %rax
jne 0x8e53
movq %rbx, %rdi
callq 0x2320
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/session_mgnt.cpp
// Function: session_destroy(s_skt*, session_unit_t*)
void
session_destroy(skt_t *lst, session_unit_t *u) {
   if (lst && u) {
      skt_remove(lst, u->sid);
   }
   if ( u ) {
      memset(u, 0, sizeof(*u));
      free(u);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x8ea8
movl (%rbx), %esi
callq 0x6ec2
jmp 0x8ead
testq %rbx, %rbx
je 0x8ebb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2320
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/rs_kcp.cpp
// Function: rskcp_create(int, int)
rskcp_t*
rskcp_create(int data_bytes, int parity_bytes) {
   if ( cm256_init() ) {
      return (rskcp_t*)0;
   }

   rskcp_t *rt = (rskcp_t*)mm_malloc(sizeof(rskcp_t));
   if (rt) {
      cm256_encoder_params p = { data_bytes, parity_bytes, 1 };
      rt->param = p;
      for (int i=0; i<(data_bytes + parity_bytes); i++) {
         rt->blocks[i].Index = i;
      }
   }
   return rt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
movl $0x2, %edi
callq 0x9148
testl %eax, %eax
je 0x8ee5
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3214(%rip), %rsi      # 0xc100
movl $0x1010, %edi           # imm = 0x1010
movl $0x1d, %edx
callq 0x5cc4
testq %rax, %rax
je 0x8ede
movl %r14d, (%rax)
movl %ebx, 0x4(%rax)
movl $0x1, 0x8(%rax)
addl %r14d, %ebx
jle 0x8ee0
movl %ebx, %ecx
movq %rax, %rdx
addq $0x18, %rdx
xorl %esi, %esi
movb %sil, (%rdx)
incq %rsi
addq $0x10, %rdx
cmpq %rsi, %rcx
jne 0x8f1d
jmp 0x8ee0
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/rs_kcp.cpp
// Function: rskcp_enc_info(s_rskcp*, int, int*)
int
rskcp_enc_info(rskcp_t *rt, int raw_len, int *parity_len) {
   if (!rt || raw_len<=0 || !parity_len) {
      return 0;
   }

   cm256_encoder_params *p = &rt->param;
   int di=0, pi=0;
   do {
      di += p->OriginalCount;
      pi += p->RecoveryCount;
   } while (di < raw_len);

   *parity_len = pi;
   return di;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
sete %al
testl %esi, %esi
setle %cl
testq %rdx, %rdx
sete %r8b
orb %al, %r8b
xorl %eax, %eax
orb %cl, %r8b
jne 0x8f80
movl (%rdi), %ecx
movl 0x4(%rdi), %r8d
xorl %edi, %edi
xorl %eax, %eax
addl %r8d, %edi
addl %ecx, %eax
cmpl %esi, %eax
jl 0x8f75
movl %edi, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/rs_kcp.cpp
// Function: rskcp_dec_info(s_rskcp*, int)
int
rskcp_dec_info(rskcp_t *rt, int data_len) {
   if (!rt || data_len<=0) {
      return 0;
   }

   cm256_encoder_params *p = &rt->param;
   int di=0, pi=0;
   do {
      di += p->OriginalCount;
      pi += p->RecoveryCount;
   } while (data_len < di + pi);

   return di;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
sete %cl
testl %esi, %esi
setle %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x8faa
movl (%rdi), %ecx
movl 0x4(%rdi), %edx
addl %ecx, %edx
xorl %edi, %edi
xorl %eax, %eax
addl %edx, %edi
addl %ecx, %eax
cmpl %esi, %edi
jg 0x8fa2
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/rs_kcp.cpp
// Function: rskcp_encode(s_rskcp*, unsigned char*, int, unsigned char*)
int
rskcp_encode(rskcp_t *rt, unsigned char *raw, int raw_len, unsigned char *parity) {
   if (!rt || !raw_len || raw_len<=0 || !parity) {
      return 0;
   }

   cm256_encoder_params *p = &rt->param;
   cm256_block *blocks = rt->blocks;
   int ri=0, pi=0, ret=0;
   
   do {
      _rskcp_fill_blocks(blocks, &raw[ri], p->OriginalCount);

      ret = cm256_encode(*p, blocks, &parity[pi]);
      if ( !ret ) {
         ri += p->OriginalCount;
         pi += p->RecoveryCount;
      }
   } while (!ret && raw_len<ri);

   return !ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rsi, -0x38(%rbp)
testq %rdi, %rdi
sete %al
movl %edx, -0x2c(%rbp)
testl %edx, %edx
setle %dl
testq %rcx, %rcx
sete %sil
orb %al, %sil
xorl %ecx, %ecx
orb %dl, %sil
jne 0x904a
movq %rdi, %r12
leaq 0x10(%rdi), %r13
movl (%rdi), %ecx
xorl %r15d, %r15d
xorl %r14d, %r14d
testl %ecx, %ecx
jle 0x9016
movslq %r14d, %rax
addq -0x38(%rbp), %rax
movl %ecx, %ecx
shlq $0x4, %rcx
xorl %edx, %edx
movq %rax, (%r13,%rdx)
addq $0x10, %rdx
incq %rax
cmpq %rdx, %rcx
jne 0x9005
movq (%r12), %rdi
movl 0x8(%r12), %esi
movslq %r15d, %rcx
addq %rbx, %rcx
movq %r13, %rdx
callq 0x9291
testl %eax, %eax
jne 0x9043
movl (%r12), %ecx
addl %ecx, %r14d
addl 0x4(%r12), %r15d
cmpl -0x2c(%rbp), %r14d
jg 0x8ff2
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/src/rs_kcp.cpp
// Function: rskcp_decode(s_rskcp*, unsigned char*, int, unsigned char*)
int
rskcp_decode(rskcp_t *rt, unsigned char *data, int data_len, unsigned char *parity) {
   if (!rt || !data || data_len<=0 || !parity) {
      return 0;
   }

   cm256_encoder_params *p = &rt->param;
   cm256_block *blocks = rt->blocks;
   int di=0, pi=0, ret=0;
   
   do {
      _rskcp_fill_blocks(blocks, &data[di], p->OriginalCount);
      _rskcp_fill_blocks(blocks + p->OriginalCount, &parity[pi], p->RecoveryCount);
      
      ret = cm256_decode(*p, blocks);
      if ( !ret ) {
         di += p->OriginalCount;
         pi += p->RecoveryCount;
      }
   } while (!ret && data_len<di+pi);
   
   return !ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
testq %rdi, %rdi
sete %al
movq %rsi, -0x30(%rbp)
testq %rsi, %rsi
sete %dl
orb %al, %dl
testl %r14d, %r14d
setle %al
movq %rcx, -0x38(%rbp)
testq %rcx, %rcx
sete %sil
xorl %ecx, %ecx
orb %al, %sil
orb %dl, %sil
jne 0x9134
movq %rdi, %r12
leaq 0x10(%rdi), %r13
movl (%rdi), %ecx
xorl %ebx, %ebx
xorl %r15d, %r15d
testl %ecx, %ecx
jle 0x90d2
movslq %r15d, %rax
addq -0x30(%rbp), %rax
movl %ecx, %edx
shlq $0x4, %rdx
xorl %esi, %esi
movq %rax, (%r13,%rsi)
addq $0x10, %rsi
incq %rax
cmpq %rsi, %rdx
jne 0x90c1
movslq 0x4(%r12), %rax
testq %rax, %rax
jle 0x9103
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %r13, %rcx
movslq %ebx, %rdx
addq -0x38(%rbp), %rdx
shlq $0x4, %rax
xorl %esi, %esi
movq %rdx, (%rcx,%rsi)
addq $0x10, %rsi
incq %rdx
cmpq %rsi, %rax
jne 0x90f3
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r13, %rdx
callq 0x9af3
testl %eax, %eax
jne 0x912d
movl (%r12), %ecx
addl %ecx, %r15d
addl 0x4(%r12), %ebx
leal (%rbx,%r15), %edx
cmpl %r14d, %edx
jg 0x90ae
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/vendor/cm256/cm256.cpp
// Function: cm256_encode
int cm256_encode(
    cm256_encoder_params params, // Encoder params
    cm256_block* originals,      // Array of pointers to original blocks
    void* recoveryBlocks)        // Output recovery blocks end-to-end
{
    // Validate input:
    if (params.OriginalCount <= 0 ||
        params.RecoveryCount <= 0 ||
        params.BlockBytes <= 0)
    {
        return -1;
    }
    if (params.OriginalCount + params.RecoveryCount > 256)
    {
        return -2;
    }
    if (!originals || !recoveryBlocks)
    {
        return -3;
    }

    uint8_t* recoveryBlock = static_cast<uint8_t*>(recoveryBlocks);

    for (int block = 0; block < params.RecoveryCount; ++block, recoveryBlock += params.BlockBytes)
    {
        cm256_encode_block(params, originals, (params.OriginalCount + block), recoveryBlock);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdi, %r15
movq %rdi, %r12
shrq $0x20, %r12
testl %r15d, %r15d
setle %al
testl %r12d, %r12d
setle %cl
testl %esi, %esi
setle %r8b
orb %al, %r8b
orb %cl, %r8b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x9329
leal (%r12,%r15), %ecx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
cmpl $0x100, %ecx            # imm = 0x100
ja 0x9329
testq %rdx, %rdx
sete %cl
testq %rbx, %rbx
sete %r8b
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
orb %cl, %r8b
jne 0x9329
movl %esi, %r14d
movl %esi, %eax
movq %rax, -0x30(%rbp)
movl %r15d, %r13d
movq %rdx, -0x38(%rbp)
movq %r15, %rdi
movl %r14d, %esi
movl %r13d, %ecx
movq %rbx, %r8
callq 0x9163
movq -0x38(%rbp), %rdx
addq -0x30(%rbp), %rbx
incl %r13d
decl %r12d
jne 0x9306
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/vendor/cm256/cm256.cpp
// Function: CM256Decoder::Initialize(cm256_encoder_params_t&, cm256_block_t*)
bool CM256Decoder::Initialize(cm256_encoder_params& params, cm256_block* blocks)
{
    Params = params;

    cm256_block* block = blocks;
    OriginalCount = 0;
    RecoveryCount = 0;

    // Initialize erasures to zeros
    for (int ii = 0; ii < params.OriginalCount; ++ii)
    {
        ErasuresIndices[ii] = 0;
    }

    // For each input block,
    for (int ii = 0; ii < params.OriginalCount; ++ii, ++block)
    {
        int row = block->Index;

        // If it is an original block,
        if (row < params.OriginalCount)
        {
            Original[OriginalCount++] = block;

            if (ErasuresIndices[row] != 0)
            {
                // Error out if two row indices repeat
                return false;
            }

            ErasuresIndices[row] = 1;
        }
        else
        {
            Recovery[RecoveryCount++] = block;
        }
    }

    // Identify erasures
    for (int ii = 0, indexCount = 0; ii < 256; ++ii)
    {
        if (!ErasuresIndices[ii])
        {
            ErasuresIndices[indexCount] = static_cast<uint8_t>( ii );

            if (++indexCount >= RecoveryCount)
            {
                break;
            }
        }
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movl %eax, 0x1018(%rdi)
movl %eax, 0x810(%rdi)
cmpl %eax, (%rsi)
jle 0x93d5
xorl %ecx, %ecx
movb $0x0, 0x101c(%rdi,%rcx)
incq %rcx
movslq (%rsi), %r8
cmpq %r8, %rcx
jl 0x935d
testl %r8d, %r8d
jle 0x93d5
xorl %ecx, %ecx
xorl %r9d, %r9d
xorl %r10d, %r10d
movzbl 0x8(%rdx), %r11d
cmpl %r11d, %r8d
jle 0x93b8
leal 0x1(%r10), %ebx
movl %ebx, 0x1018(%rdi)
movslq %r10d, %r8
movq %rdx, 0x818(%rdi,%r8,8)
cmpb $0x0, 0x101c(%rdi,%r11)
jne 0x9405
movb $0x1, 0x101c(%rdi,%r11)
movl (%rsi), %r8d
movl %ebx, %r10d
jmp 0x93ca
movslq %r9d, %r11
incl %r9d
movl %r9d, 0x810(%rdi)
movq %rdx, 0x10(%rdi,%r11,8)
incl %ecx
addq $0x10, %rdx
cmpl %r8d, %ecx
jl 0x937d
xorl %ecx, %ecx
cmpb $0x0, 0x101c(%rdi,%rcx)
jne 0x93f4
cltq
movb %cl, 0x101c(%rdi,%rax)
incl %eax
cmpl 0x810(%rdi), %eax
jge 0x9400
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x93d7
movb $0x1, %al
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x9402
nop
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/vendor/cm256/cm256.cpp
// Function: CM256Decoder::DecodeM1()
void CM256Decoder::DecodeM1()
{
    // XOR all other blocks into the recovery block
    uint8_t* outBlock = static_cast<uint8_t*>(Recovery[0]->Block);
    const uint8_t* inBlock = 0;

    // For each block,
    for (int ii = 0; ii < OriginalCount; ++ii)
    {
        const uint8_t* inBlock2 = static_cast<const uint8_t*>(Original[ii]->Block);

        if (!inBlock)
        {
            inBlock = inBlock2;
        }
        else
        {
            // outBlock ^= inBlock ^ inBlock2
            gf256_add2_mem(outBlock, inBlock, inBlock2, Params.BlockBytes);
            inBlock = 0;
        }
    }

    // Complete XORs
    if (inBlock)
    {
        gf256_add_mem(outBlock, inBlock, Params.BlockBytes);
    }

    // Recover the index it corresponds to
    Recovery[0]->Index = ErasuresIndices[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1018(%rdi), %eax
testl %eax, %eax
jle 0x9470
movq 0x10(%rbx), %rcx
movq (%rcx), %r14
xorl %r15d, %r15d
xorl %esi, %esi
movq 0x818(%rbx,%r15,8), %rcx
movq (%rcx), %rdx
testq %rsi, %rsi
jne 0x9442
movq %rdx, %rsi
jmp 0x9455
movl 0x8(%rbx), %ecx
movq %r14, %rdi
callq 0xa297
movl 0x1018(%rbx), %eax
xorl %esi, %esi
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x942d
testq %rsi, %rsi
je 0x9470
movl 0x8(%rbx), %edx
movq %r14, %rdi
callq 0xa1cc
movb 0x101c(%rbx), %al
movq 0x10(%rbx), %rcx
movb %al, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xocoder[P]m_kcptun/vendor/cm256/cm256.cpp
// Function: cm256_decode
int cm256_decode(
    cm256_encoder_params params, // Encoder params
    cm256_block* blocks)         // Array of 'originalCount' blocks as described above
{
    if (params.OriginalCount <= 0 ||
        params.RecoveryCount <= 0 ||
        params.BlockBytes <= 0)
    {
        return -1;
    }
    if (params.OriginalCount + params.RecoveryCount > 256)
    {
        return -2;
    }
    if (!blocks)
    {
        return -3;
    }

    // If there is only one block,
    if (params.OriginalCount == 1)
    {
        // It is the same block repeated
        blocks[0].Index = 0;
        return 0;
    }

    CM256Decoder state;
    if (!state.Initialize(params, blocks))
    {
        return -5;
    }

    // If nothing is erased,
    if (state.RecoveryCount <= 0)
    {
        return 0;
    }

    // If m=1,
    if (params.RecoveryCount == 1)
    {
        state.DecodeM1();
        return 0;
    }

    // Decode for m>1
    state.Decode();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x1130, %rsp           # imm = 0x1130
movq %rdi, -0x20(%rbp)
movl %esi, -0x18(%rbp)
testl %edi, %edi
setle %al
movq %rdi, %r14
shrq $0x20, %r14
testl %r14d, %r14d
setle %cl
testl %esi, %esi
setle %sil
orb %al, %sil
orb %cl, %sil
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jne 0x9b93
leal (%r14,%rdi), %eax
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
cmpl $0x100, %eax            # imm = 0x100
ja 0x9b93
testq %rdx, %rdx
je 0x9b4f
cmpl $0x1, %edi
jne 0x9b56
movb $0x0, 0x8(%rdx)
xorl %ebx, %ebx
jmp 0x9b93
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
jmp 0x9b93
leaq -0x1140(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9338
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
testb %al, %al
je 0x9b93
xorl %ebx, %ebx
cmpl $0x0, -0x930(%rbp)
jle 0x9b93
leaq -0x1140(%rbp), %rdi
cmpl $0x1, %r14d
jne 0x9b8e
callq 0x940a
jmp 0x9b93
callq 0x9888
movl %ebx, %eax
addq $0x1130, %rsp           # imm = 0x1130
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/mortrevere[P]ninjat/main.cpp
// Function: fileRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string fileRead(const std::string& path) {
  std::ifstream infile(path, std::ios::in);
  std::string out("");
  char chr;
  if(infile){while(infile.get(chr)){out += chr;}return out;}else {return "";}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movl $0x8, %edx
callq 0x2320
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x49d6(%rip), %rdx      # 0x70a2
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x6390
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
je 0x271b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x49ab(%rip), %rdx      # 0x70a2
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6390
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2782
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
jmp 0x2782
leaq 0x28(%rsp), %r14
leaq 0x7(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x22c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2752
movsbl 0x7(%rsp), %esi
movq %r12, %rdi
callq 0x21c0
jmp 0x272a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
cmpq %r13, %rcx
je 0x2771
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2779
movups (%r13), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x2070
movq %rbx, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x27a7
movq %rax, %rbx
jmp 0x27c1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x27c1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
leaq 0x28(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O3/mortrevere[P]ninjat/main.cpp
// Function: s(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, bool)
bool s(std::string toSend, int sock, bool format = true) {
  if(sock <= 0)
    return false;
  if(format)
    toSend = "\t\t\t\t\t\t" + toSend;

  int error = send(sock,toSend.c_str(),toSend.size(),0);
  return !(error == SOCKET_ERROR);
}

// Assembly:
testl %esi, %esi
jle 0x29bd
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
testb %dl, %dl
je 0x299d
leaq 0x4732(%rip), %rsi      # 0x709c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5f98
movq %r14, %rdi
movq %r15, %rsi
callq 0x22b0
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x299d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x2130
cmpl $-0x1, %eax
setne %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/mortrevere[P]ninjat/main.cpp
// Function: setNick(int, std::vector<int, std::allocator<int>>&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool setNick(int csock, std::vector<int>& clients, std::vector<std::string>& nicks, std::string nick) {
  for(unsigned int i = 0; i < clients.size(); i++) {
    if(clients[i] == csock) {
      nicks[i] = nick;
      return true;
    }
  }
  return false;
}

// Assembly:
movq (%rsi), %r8
movq 0x8(%rsi), %rsi
subq %r8, %rsi
je 0x2d86
pushq %rax
sarq $0x2, %rsi
movl $0x1, %r9d
xorl %eax, %eax
cmpl %edi, (%r8,%rax,4)
je 0x2d89
movl %r9d, %eax
incl %r9d
cmpq %rax, %rsi
ja 0x2d71
xorl %eax, %eax
jmp 0x2d9d
xorl %eax, %eax
retq
shlq $0x5, %rax
addq (%rdx), %rax
movq %rax, %rdi
movq %rcx, %rsi
callq 0x2150
movb $0x1, %al
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mortrevere[P]ninjat/main.cpp
// Function: getIndex(int, std::vector<int, std::allocator<int>>&)
int getIndex(int csock, std::vector<int>& clients) {
  for (std::size_t i = 0; i < clients.size(); i++) {
    if(clients[i] == csock) {
      return i;
    }
  }
  return -1;
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subq %rcx, %rdx
je 0x2dce
sarq $0x2, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
cmpl %edi, (%rcx,%rsi,4)
je 0x2dcf
incq %rsi
cmpq %rsi, %rdx
jne 0x2dc1
retq
movl %esi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/mortrevere[P]ninjat/main.cpp
// Function: getIndexByNick(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
int getIndexByNick(std::string nick, std::vector<std::string>& nicks) {
  for (std::size_t i = 0; i < nicks.size(); i++) {
    if(nicks[i] == nick) {
      return i;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r12
movq 0x8(%rsi), %r13
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
subq %r12, %r13
je 0x2e36
movq %rdi, %r14
sarq $0x5, %r13
movq 0x8(%rdi), %r15
cmpq $0x1, %r13
adcq $0x0, %r13
addq $0x8, %r12
xorl %ebp, %ebp
cmpq %r15, (%r12)
jne 0x2e26
testq %r15, %r15
je 0x2e34
movq (%r14), %rsi
movq -0x8(%r12), %rdi
movq %r15, %rdx
callq 0x2240
testl %eax, %eax
je 0x2e34
incq %rbp
addq $0x20, %r12
cmpq %rbp, %r13
jne 0x2e07
jmp 0x2e36
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/examples/../src/cxon/lang/common/cio/class.hxx
// Function: bool cxon::cio::cls::imp::imp::write_<cxon::JSON<cxon::cio::key::simple_traits<cxon::json::format_traits>>, 0ul, 2ul>::field<my_type, std::tuple<cxon::cio::cls::field<std::vector<int, std::allocator<int>> my_type::*>, cxon::cio::cls::field<std::__cxx11::list<int, std::allocator<int>> my_type::*>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, my_type const&, std::tuple<cxon::cio::cls::field<std::vector<int, std::allocator<int>> my_type::*>, cxon::cio::cls::field<std::__cxx11::list<int, std::allocator<int>> my_type::*>> const&, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool field(O& o, const T& t, const Fs& fs, Cx& cx) {
                            using E = typename std::tuple_element<N, Fs>::type;
                            CXON_IF_CONSTEXPR (!val::is_sink<typename E::type>::value)
                                if (!std::get<N>(fs).isdf(t))
                                    return  write_field_<X>(o, t, std::get<N>(fs), cx) &&
                                            write_next_<X, N + 1, L>::field(o, t, fs, cx)
                                    ;
                            return          write_<X, N + 1, L>::field(o, t, fs, cx);
                        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rdx), %r13
movq 0x20(%rdx), %rbp
movl $0x22, %esi
callq 0x20e0
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x2050
movq %r12, %rdi
movl $0x22, %esi
callq 0x20e0
movq %r12, %rdi
movl $0x3a, %esi
callq 0x20e0
movq 0x28(%r14), %rsi
addq %r15, %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x291c
testb %al, %al
je 0x288c
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x289e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms1/./assignment2.hpp
// Function: assignment2::partition(std::vector<int, std::allocator<int>>&, int, int)
int partition(vector<int>& input, int left, int right)
    {
        int p = input[left];
        int i = left + 1;
        
        for (int j = left + 1; j < right; j++)
        {
            if (input[j] < p)
            {
                swap(input[i], input[j]);
                i++;
            }
        }
        swap(input[left], input[i-1]);
        
        return (i-1);
    }

// Assembly:
movslq %esi, %r8
movq (%rdi), %rcx
movl (%rcx,%r8,4), %edi
leal 0x1(%r8), %eax
cmpl %edx, %eax
jge 0x28b8
decl %edx
movq %r8, %rsi
movl 0x4(%rcx,%rsi,4), %r9d
cmpl %edi, %r9d
jge 0x28a9
cltq
movl (%rcx,%rax,4), %r10d
movl %r9d, (%rcx,%rax,4)
movl %r10d, 0x4(%rcx,%rsi,4)
incl %eax
incq %rsi
cmpl %esi, %edx
jne 0x288e
movl (%rcx,%r8,4), %edi
decl %eax
movl %eax, %esi
movslq %esi, %rax
movl (%rcx,%rax,4), %edx
movl %edx, (%rcx,%r8,4)
movl %edi, (%rcx,%rax,4)
retq
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms1/./assignment2.hpp
// Function: assignment2::partitionMedian(std::vector<int, std::allocator<int>>&, int, int)
int partitionMedian(vector<int>& input, int left, int right)
    {
        noCompMedian += right - left - 1;
        
        int midInd = (left + right - 1) / 2;
        // initially pivot position is unknown
        int p = -1;
        
        // compute the median of the three elements (first, median, last)
        // and assign its index to the pivot
        if (input[left] < input[midInd])
        {
            if (input[left] >= input[right-1])
                p = left;
            else if (input[midInd] < input[right-1])
                p = midInd;
        }
        else
        {
            if (input[midInd] >= input[right-1])
                p = midInd;
            else if (input[left] < input[right-1])
                p = left;
        }
        // fallback
        if (p == -1)
            p = right - 1;
        
        // bring the median pivot to the beginning
        swap(input[left], input[p]);
        
        return partition(input, left, right);
    }

// Assembly:
pushq %rbp
pushq %rbx
movl %esi, %eax
movl %esi, %ecx
notl %ecx
addl %edx, %ecx
addl %ecx, 0xb8db(%rip)      # 0xe1ec
leal -0x1(%rdx), %ecx
leal (%rdx,%rax), %esi
decl %esi
movl %esi, %r10d
shrl $0x1f, %r10d
addl %esi, %r10d
sarl %r10d
movslq %eax, %rsi
movq (%rdi), %r8
movl (%r8,%rsi,4), %r9d
movslq %r10d, %r11
movl (%r8,%r11,4), %ebp
movslq %edx, %r11
movl -0x4(%r8,%r11,4), %ebx
cmpl %ebp, %r9d
jge 0x295a
movl %eax, %r11d
cmpl %ebx, %r9d
jge 0x296e
cmpl %ebx, %ebp
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
cmovll %r10d, %r11d
jmp 0x296e
movl %r10d, %r11d
cmpl %ebx, %ebp
jge 0x296e
cmpl %ebx, %r9d
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
cmovll %eax, %r11d
cmpl $-0x1, %r11d
cmovnel %r11d, %ecx
movslq %ecx, %rax
movl (%r8,%rax,4), %ecx
movl %ecx, (%r8,%rsi,4)
movl %r9d, (%r8,%rax,4)
popq %rbx
popq %rbp
jmp 0x2877
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms1/./assignment2.hpp
// Function: assignment2::QuickSort(std::vector<int, std::allocator<int>>&, int, int, int)
void QuickSort(vector<int>& input, int left, int right, int partitionType)
    {
        if (left == right)
            return;
        
        int pivotIndex = -1;
        switch (partitionType)
        {
            case 1: pivotIndex = partitionFirst(input, left, right); break;
            case 2: pivotIndex = partitionLast(input, left, right); break;
            case 3: pivotIndex = partitionMedian(input, left, right); break;
        }
        QuickSort(input, left, pivotIndex, partitionType);
        QuickSort(input, pivotIndex+1, right, partitionType);
    }

// Assembly:
cmpl %edx, %esi
je 0x2a3f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movslq %edx, %r13
cmpl $0x3, %ebx
je 0x2a02
cmpl $0x2, %ebx
je 0x29d0
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpl $0x1, %ebx
jne 0x2a12
movl %r15d, %eax
notl %eax
addl %ebp, %eax
addl %eax, 0xb816(%rip)      # 0xe1e4
jmp 0x29f3
movl %r15d, %eax
notl %eax
addl %ebp, %eax
addl %eax, 0xb80b(%rip)      # 0xe1e8
movq (%r14), %rax
movslq %r15d, %rcx
movl -0x4(%rax,%r13,4), %edx
movl (%rax,%rcx,4), %esi
movl %esi, -0x4(%rax,%r13,4)
movl %edx, (%rax,%rcx,4)
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2877
jmp 0x2a0f
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x2901
movl %eax, %r12d
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %ebx, %ecx
callq 0x298c
incl %r12d
movl %r12d, %r15d
cmpl %ebp, %r12d
jne 0x29ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms1/./assignment4.hpp
// Function: assignment4::DFS(std::map<int, std::vector<int, std::allocator<int>>, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&, int)
void DFS(Graph& g, int i)
    {
        assert(g.count(i) > 0); // every node MUST be in a graph
        
        _seen[i] = 1;           // mark s as seen
        _leaders[i] = _s;

        // for every edge (s, v)
        for (int v : g[i])
        {
            if (!_seen[v])   // if v is not yet explored
            {
                DFS(g, v);
            }
        }
        _time++;
        _times[i] = _time;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, 0xc(%rsp)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2b16
movq %rdi, %rbx
leaq 0x8(%rdi), %rdx
movq %rdx, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rax)
setl %dil
cmovgeq %rax, %rcx
movq 0x10(%rax,%rdi,8), %rax
testq %rax, %rax
jne 0x2a64
cmpq %rdx, %rcx
je 0x2b16
cmpl %esi, 0x20(%rcx)
jg 0x2b16
movslq %esi, %rax
movq 0xb779(%rip), %rcx      # 0xe210
movl $0x1, (%rcx,%rax,4)
movl 0xb714(%rip), %ecx      # 0xe1b8
movq 0xb785(%rip), %rdx      # 0xe230
movl %ecx, (%rdx,%rax,4)
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x61cc
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x2aef
movq 0xb742(%rip), %rax      # 0xe210
movslq (%r14), %rsi
cmpl $0x0, (%rax,%rsi,4)
jne 0x2ae6
movq %rbx, %rdi
callq 0x2a40
movq 0xb72a(%rip), %rax      # 0xe210
addq $0x4, %r14
cmpq %r15, %r14
jne 0x2ace
movl 0xb753(%rip), %eax      # 0xe248
incl %eax
movl %eax, 0xb74b(%rip)      # 0xe248
movslq 0xc(%rsp), %rcx
movq 0xb6e7(%rip), %rdx      # 0xe1f0
movl %eax, (%rdx,%rcx,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7563(%rip), %rdi      # 0xa080
leaq 0x756b(%rip), %rsi      # 0xa08f
leaq 0x7576(%rip), %rcx      # 0xa0a1
movl $0x47, %edx
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O3/Manca[P]algorithms1/./assignment4.hpp
// Function: assignment4::DFSLoop(std::map<int, std::vector<int, std::allocator<int>>, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&)
void DFSLoop(Graph& g)
    {
        // initally time and leader set to 0 and -1, respectively
        // seen list i reset too
        _time = 0;
        _s = -1;
        _seen = seenList(g.size()+1, 0);   // mark all nodes unexplored
        
        int n = g.size();   // we assume the vertex labeling 1..n here
        
        for (int i = n; i > 0; i--)
        {
            if (!_seen[i]) // if i is not yet explored
            {
                _s = i;
                DFS(g, i);
            }
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movl %eax, 0xb701(%rip)      # 0xe248
movl $0xffffffff, 0xb667(%rip) # imm = 0xFFFFFFFF
movq 0x28(%rdi), %rsi
incq %rsi
leaq 0xc(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x10(%rsp), %r14
leaq 0xb(%rsp), %rcx
movq %r14, %rdi
callq 0x6232
movq 0xb698(%rip), %rdi      # 0xe210
movaps (%r14), %xmm0
movaps %xmm0, 0xb68d(%rip)     # 0xe210
movq 0x10(%r14), %rax
movq %rax, 0xb692(%rip)      # 0xe220
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, %rdi
je 0x2bb6
callq 0x21b0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2bb6
callq 0x21b0
movq 0x28(%rbx), %r14
testl %r14d, %r14d
jle 0x2bfa
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movq 0xb643(%rip), %rax      # 0xe210
cmpl $0x0, (%rax,%r14,4)
jne 0x2bed
movl %r14d, 0xb5dd(%rip)     # 0xe1b8
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2a40
movq 0xb623(%rip), %rax      # 0xe210
leaq -0x1(%r14), %rcx
cmpq $0x1, %r14
movq %rcx, %r14
jg 0x2bcd
addq $0x28, %rsp
popq %rbx
popq %r14
retq