LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sisong[P]ApkDiffPatch/zlib1.3.1/trees.c
// Function: tr_tally
int ZLIB_INTERNAL _tr_tally(deflate_state *s, unsigned dist, unsigned lc) {
#ifdef LIT_MEM
    s->d_buf[s->sym_next] = (ush)dist;
    s->l_buf[s->sym_next++] = (uch)lc;
#else
    s->sym_buf[s->sym_next++] = (uch)dist;
    s->sym_buf[s->sym_next++] = (uch)(dist >> 8);
    s->sym_buf[s->sym_next++] = (uch)lc;
#endif
    if (dist == 0) {
        /* lc is the unmatched char */
        s->dyn_ltree[lc].Freq++;
    } else {
        s->matches++;
        /* Here, lc is the match length - MIN_MATCH */
        dist--;             /* dist = match distance - 1 */
        Assert((ush)dist < (ush)MAX_DIST(s) &&
               (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
               (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");

        s->dyn_ltree[_length_code[lc] + LITERALS + 1].Freq++;
        s->dyn_dtree[d_code(dist)].Freq++;
    }
    return (s->sym_next == s->sym_end);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x1700(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x170c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x170c(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x1700(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x170c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x170c(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x1700(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x170c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x170c(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
cmpl $0x0, -0xc(%rbp)
jne 0xa0c45
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movw 0xd4(%rax,%rcx,4), %dx
addw $0x1, %dx
movw %dx, 0xd4(%rax,%rcx,4)
jmp 0xa0cf4
movq -0x8(%rbp), %rax
movl 0x1728(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1728(%rax)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
leaq 0x1d66f(%rip), %rcx     # 0xbe2e0
movzbl (%rcx,%rdx), %ecx
addl $0x100, %ecx            # imm = 0x100
addl $0x1, %ecx
movslq %ecx, %rcx
movw 0xd4(%rax,%rcx,4), %dx
addw $0x1, %dx
movw %dx, 0xd4(%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0x9c8, %rax            # imm = 0x9C8
movq %rax, -0x18(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0xa0cc1
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1d428(%rip), %rax     # 0xbe0e0
movzbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
jmp 0xa0cde
movl -0xc(%rbp), %eax
shrl $0x7, %eax
addl $0x100, %eax            # imm = 0x100
movl %eax, %eax
movl %eax, %ecx
leaq 0x1d409(%rip), %rax     # 0xbe0e0
movzbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,4), %dx
addw $0x1, %dx
movw %dx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x170c(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1710(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/trees.c
// Function: gen_codes
local void gen_codes(ct_data *tree, int max_code, ushf *bl_count) {
    ush next_code[MAX_BITS+1]; /* next code value for each bit length */
    unsigned code = 0;         /* running code value */
    int bits;                  /* bit index */
    int n;                     /* code index */

    /* The distribution counts are first used to generate the code values
     * without bit reversal.
     */
    for (bits = 1; bits <= MAX_BITS; bits++) {
        code = (code + bl_count[bits - 1]) << 1;
        next_code[bits] = (ush)code;
    }
    /* Check that the bit counts in bl_count are consistent. The last code
     * must be all ones.
     */
    Assert (code + bl_count[MAX_BITS] - 1 == (1 << MAX_BITS) - 1,
            "inconsistent bit counts");
    Tracev((stderr,"\ngen_codes: max_code %d ", max_code));

    for (n = 0;  n <= max_code; n++) {
        int len = tree[n].Len;
        if (len == 0) continue;
        /* Now reverse the bits */
        tree[n].Code = (ush)bi_reverse(next_code[len]++, len);

        Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
            n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len] - 1));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x1, -0x48(%rbp)
cmpl $0xf, -0x48(%rbp)
jg 0xa12bc
movl -0x44(%rbp), %eax
movq -0x18(%rbp), %rcx
movl -0x48(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
shll %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movw %ax, %cx
movslq -0x48(%rbp), %rax
movw %cx, -0x40(%rbp,%rax,2)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xa1281
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0xa131d
movq -0x8(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movzwl 0x2(%rax,%rcx,4), %eax
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x50(%rbp)
jne 0xa12e3
jmp 0xa1312
movslq -0x50(%rbp), %rcx
movw -0x40(%rbp,%rcx,2), %ax
movw %ax, %dx
addw $0x1, %dx
movw %dx, -0x40(%rbp,%rcx,2)
movzwl %ax, %edi
movl -0x50(%rbp), %esi
callq 0xa1330
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movw %dx, (%rax,%rcx,4)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xa12c3
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/zlib1.3.1/trees.c
// Function: bi_reverse
local unsigned bi_reverse(unsigned code, int len) {
    register unsigned res = 0;
    do {
        res |= code & 1;
        code >>= 1, res <<= 1;
    } while (--len > 0);
    return res >> 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x4(%rbp), %eax
andl $0x1, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jg 0xa1341
movl -0xc(%rbp), %eax
shrl %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzmaDec.c
// Function: LzmaDec_InitDicAndState
void LzmaDec_InitDicAndState(CLzmaDec *p, BoolInt initDic, BoolInt initState)
{
  p->remainLen = kMatchSpecLenStart + 1;
  p->tempBufSize = 0;

  if (initDic)
  {
    p->processedPos = 0;
    p->checkDicSize = 0;
    p->remainLen = kMatchSpecLenStart + 2;
  }
  if (initState)
    p->remainLen = kMatchSpecLenStart + 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x113, 0x5c(%rax)      # imm = 0x113
movq -0x8(%rbp), %rax
movl $0x0, 0x64(%rax)
cmpl $0x0, -0xc(%rbp)
je 0xa5c9b
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x44(%rax)
movq -0x8(%rbp), %rax
movl $0x114, 0x5c(%rax)      # imm = 0x114
cmpl $0x0, -0x10(%rbp)
je 0xa5cac
movq -0x8(%rbp), %rax
movl $0x114, 0x5c(%rax)      # imm = 0x114
popq %rbp
retq
nop
// File: sisong[P]ApkDiffPatch/lzma/C/LzmaDec.c
// Function: LzmaDec_WriteRem
static void Z7_FASTCALL LzmaDec_WriteRem(CLzmaDec *p, SizeT limit)
{
  unsigned len = (unsigned)p->remainLen;
  if (len == 0 /* || len >= kMatchSpecLenStart */)
    return;
  {
    SizeT dicPos = p->dicPos;
    Byte *dic;
    SizeT dicBufSize;
    SizeT rep0;   /* we use SizeT to avoid the BUG of VC14 for AMD64 */
    {
      SizeT rem = limit - dicPos;
      if (rem < len)
      {
        len = (unsigned)(rem);
        if (len == 0)
          return;
      }
    }

    if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= len)
      p->checkDicSize = p->prop.dicSize;

    p->processedPos += (UInt32)len;
    p->remainLen -= (UInt32)len;
    dic = p->dic;
    rep0 = p->reps[0];
    dicBufSize = p->dicBufSize;
    do
    {
      dic[dicPos] = dic[dicPos - rep0 + (dicPos < rep0 ? dicBufSize : 0)];
      dicPos++;
    }
    while (--len);
    p->dicPos = dicPos;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xa6541
jmp 0xa6656
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jae 0xa6579
movq -0x40(%rbp), %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xa6577
jmp 0xa6656
jmp 0xa6579
movq -0x8(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0xa65a4
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x40(%rcx), %eax
cmpl -0x14(%rbp), %eax
ja 0xa65a4
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x40(%rax), %ecx
movl %ecx, 0x40(%rax)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x5c(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xa660b
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0xa6613
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0xa6613
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %rdx
addq %rdx, %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0xa65e3
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzmaDec.c
// Function: LzmaDec_DecodeReal2
static int Z7_FASTCALL LzmaDec_DecodeReal2(CLzmaDec *p, SizeT limit, const Byte *bufLimit)
{
  if (p->checkDicSize == 0)
  {
    UInt32 rem = p->prop.dicSize - p->processedPos;
    if (limit - p->dicPos > rem)
      limit = p->dicPos + rem;
  }
  {
    int res = LZMA_DECODE_REAL(p, limit, bufLimit);
    if (p->checkDicSize == 0 && p->processedPos >= p->prop.dicSize)
      p->checkDicSize = p->prop.dicSize;
    return res;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0xa73f7
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x40(%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq 0x28(%rcx), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0xa73f5
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0xa73f7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa7b80
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0xa7433
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jb 0xa7433
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzmaDec.c
// Function: LzmaProps_Decode
SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size)
{
  UInt32 dicSize;
  Byte d;
  
  if (size < LZMA_PROPS_SIZE)
    return SZ_ERROR_UNSUPPORTED;
  else
    dicSize = data[1] | ((UInt32)data[2] << 8) | ((UInt32)data[3] << 16) | ((UInt32)data[4] << 24);
 
  if (dicSize < LZMA_DIC_MIN)
    dicSize = LZMA_DIC_MIN;
  p->dicSize = dicSize;

  d = data[0];
  if (d >= (9 * 5 * 5))
    return SZ_ERROR_UNSUPPORTED;

  p->lc = (Byte)(d % 9);
  d /= 9;
  p->pb = (Byte)(d / 5);
  p->lp = (Byte)(d % 5);

  return SZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jae 0xa76a1
movl $0x4, -0x4(%rbp)
jmp 0xa775e
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0x20(%rbp)
cmpl $0x1000, -0x20(%rbp)    # imm = 0x1000
jae 0xa76e3
movl $0x1000, -0x20(%rbp)    # imm = 0x1000
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0xe1, %eax
jl 0xa770a
movl $0x4, -0x4(%rbp)
jmp 0xa775e
movzbl -0x21(%rbp), %eax
movl $0x9, %ecx
cltd
idivl %ecx
movb %dl, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movzbl -0x21(%rbp), %eax
movl $0x9, %ecx
cltd
idivl %ecx
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movzbl -0x21(%rbp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
movb %dl, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzmaDec.c
// Function: LzmaDec_AllocateProbs
SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc)
{
  CLzmaProps propNew;
  RINOK(LzmaProps_Decode(&propNew, props, propsSize))
  RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc))
  p->prop = propNew;
  return SZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0xa7680
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xa77a8
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa77dc
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0xa77f0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0xa77ca
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa77dc
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzmaDec.c
// Function: LzmaDec_AllocateProbs2
static SRes LzmaDec_AllocateProbs2(CLzmaDec *p, const CLzmaProps *propNew, ISzAllocPtr alloc)
{
  UInt32 numProbs = LzmaProps_GetNumProbs(propNew);
  if (!p->probs || numProbs != p->numProbs)
  {
    LzmaDec_FreeProbs(p, alloc);
    p->probs = (CLzmaProb *)ISzAlloc_Alloc(alloc, numProbs * sizeof(CLzmaProb));
    if (!p->probs)
      return SZ_ERROR_MEM;
    p->probs_1664 = p->probs + 1664;
    p->numProbs = numProbs;
  }
  return SZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movl $0x300, %eax            # imm = 0x300
shll %cl, %eax
addl $0x7c0, %eax            # imm = 0x7C0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa783b
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x60(%rcx), %eax
je 0xa789d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa75d0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %ecx
movl %ecx, %esi
shlq %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xa787c
movl $0x2, -0x4(%rbp)
jmp 0xa78a4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0xd00, %rcx            # imm = 0xD00
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x60(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzmaDec.c
// Function: LzmaDec_Allocate
SRes LzmaDec_Allocate(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc)
{
  CLzmaProps propNew;
  SizeT dicBufSize;
  RINOK(LzmaProps_Decode(&propNew, props, propsSize))
  RINOK(LzmaDec_AllocateProbs2(p, &propNew, alloc))

  {
    UInt32 dictSize = propNew.dicSize;
    SizeT mask = ((UInt32)1 << 12) - 1;
         if (dictSize >= ((UInt32)1 << 30)) mask = ((UInt32)1 << 22) - 1;
    else if (dictSize >= ((UInt32)1 << 22)) mask = ((UInt32)1 << 20) - 1;
    dicBufSize = ((SizeT)dictSize + mask) & ~mask;
    if (dicBufSize < dictSize)
      dicBufSize = dictSize;
  }

  if (!p->dic || dicBufSize != p->dicBufSize)
  {
    LzmaDec_FreeDict(p, alloc);
    p->dic = (Byte *)ISzAlloc_Alloc(alloc, dicBufSize);
    if (!p->dic)
    {
      LzmaDec_FreeProbs(p, alloc);
      return SZ_ERROR_MEM;
    }
  }
  p->dicBufSize = dicBufSize;
  p->prop = propNew;
  return SZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x30(%rbp), %rdi
callq 0xa7680
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0xa78eb
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa79f0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0xa77f0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0xa7910
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa79f0
movl -0x2c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq $0xfff, -0x50(%rbp)     # imm = 0xFFF
cmpl $0x40000000, -0x44(%rbp) # imm = 0x40000000
jb 0xa7931
movq $0x3fffff, -0x50(%rbp)  # imm = 0x3FFFFF
jmp 0xa7944
cmpl $0x400000, -0x44(%rbp)  # imm = 0x400000
jb 0xa7942
movq $0xfffff, -0x50(%rbp)   # imm = 0xFFFFF
jmp 0xa7944
movl -0x44(%rbp), %eax
addq -0x50(%rbp), %rax
movq -0x50(%rbp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl -0x44(%rbp), %ecx
cmpq %rcx, %rax
jae 0xa796d
movl -0x44(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xa7986
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0xa79d2
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa7640
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xa79d0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa75d0
movl $0x2, -0x4(%rbp)
jmp 0xa79f0
jmp 0xa79d2
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/LzmaDec.c
// Function: LzmaDecode
SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
    const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
    ELzmaStatus *status, ISzAllocPtr alloc)
{
  CLzmaDec p;
  SRes res;
  SizeT outSize = *destLen, inSize = *srcLen;
  *destLen = *srcLen = 0;
  *status = LZMA_STATUS_NOT_SPECIFIED;
  if (inSize < RC_INIT_SIZE)
    return SZ_ERROR_INPUT_EOF;
  LzmaDec_CONSTRUCT(&p)
  RINOK(LzmaDec_AllocateProbs(&p, propData, propSize, alloc))
  p.dic = dest;
  p.dicBufSize = outSize;
  LzmaDec_Init(&p);
  *srcLen = inSize;
  res = LzmaDec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
  *destLen = p.dicPos;
  if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
    res = SZ_ERROR_INPUT_EOF;
  LzmaDec_FreeProbs(&p, alloc);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq 0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x5, -0xd0(%rbp)
jae 0xa7a80
movl $0x6, -0x4(%rbp)
jmp 0xa7b69
movq $0x0, -0xa0(%rbp)
movq $0x0, -0xb0(%rbp)
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
movq 0x20(%rbp), %rcx
leaq -0xb8(%rbp), %rdi
callq 0xa7770
movl %eax, -0xd4(%rbp)
cmpl $0x0, -0xd4(%rbp)
je 0xa7aca
movl -0xd4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa7b69
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xc8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0xa5cb0
movq -0xd0(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0xc8(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl 0x10(%rbp), %r8d
movq 0x18(%rbp), %r9
leaq -0xb8(%rbp), %rdi
callq 0xa5ce0
movl %eax, -0xbc(%rbp)
movq -0x90(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0xbc(%rbp)
jne 0xa7b50
movq 0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0xa7b50
movl $0x6, -0xbc(%rbp)
movq 0x20(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0xa75d0
movl -0xbc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/Lzma2Dec.c
// Function: Lzma2Dec_GetOldProps
static SRes Lzma2Dec_GetOldProps(Byte prop, Byte *props)
{
  UInt32 dicSize;
  if (prop > 40)
    return SZ_ERROR_UNSUPPORTED;
  dicSize = (prop == 40) ? 0xFFFFFFFF : LZMA2_DIC_SIZE_FROM_PROP(prop);
  props[0] = (Byte)LZMA2_LCLP_MAX;
  props[1] = (Byte)(dicSize);
  props[2] = (Byte)(dicSize >> 8);
  props[3] = (Byte)(dicSize >> 16);
  props[4] = (Byte)(dicSize >> 24);
  return SZ_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movzbl -0x5(%rbp), %eax
cmpl $0x28, %eax
jle 0xab093
movl $0x4, -0x4(%rbp)
jmp 0xab119
movzbl -0x5(%rbp), %eax
cmpl $0x28, %eax
jne 0xab0a6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0xab0cc
movzbl -0x5(%rbp), %eax
andl $0x1, %eax
orl $0x2, %eax
movl %eax, -0x1c(%rbp)
movzbl -0x5(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl $0xb, %ecx
shll %cl, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movb $0x4, (%rax)
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x14(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0x14(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: sisong[P]ApkDiffPatch/lzma/C/Lzma2Dec.c
// Function: Lzma2Dec_Init
void Lzma2Dec_Init(CLzma2Dec *p)
{
  p->state = LZMA2_STATE_CONTROL;
  p->needInitLevel = 0xE0;
  p->isExtraMode = False;
  p->unpackSize = 0;
  
  // p->decoder.dicPos = 0; // we can use it instead of full init
  LzmaDec_Init(&p->decoder);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $-0x20, 0x5(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x6(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0xa5cb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/Lzma2Dec.c
// Function: LzmaDec_UpdateWithUncompressed
static void LzmaDec_UpdateWithUncompressed(CLzmaDec *p, const Byte *src, SizeT size)
{
  memcpy(p->dic + p->dicPos, src, size);
  p->dicPos += size;
  if (p->checkDicSize == 0 && p->prop.dicSize - p->processedPos <= size)
    p->checkDicSize = p->prop.dicSize;
  p->processedPos += (UInt32)size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4320
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0xab83f
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x40(%rcx), %eax
movl %eax, %eax
cmpq -0x18(%rbp), %rax
ja 0xab83f
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addl 0x40(%rax), %ecx
movl %ecx, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sisong[P]ApkDiffPatch/lzma/C/Lzma2Dec.c
// Function: Lzma2Decode
SRes Lzma2Decode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
    Byte prop, ELzmaFinishMode finishMode, ELzmaStatus *status, ISzAllocPtr alloc)
{
  CLzma2Dec p;
  SRes res;
  SizeT outSize = *destLen, inSize = *srcLen;
  *destLen = *srcLen = 0;
  *status = LZMA_STATUS_NOT_SPECIFIED;
  Lzma2Dec_CONSTRUCT(&p)
  RINOK(Lzma2Dec_AllocateProbs(&p, prop, alloc))
  p.decoder.dic = dest;
  p.decoder.dicBufSize = outSize;
  Lzma2Dec_Init(&p);
  *srcLen = inSize;
  res = Lzma2Dec_DecodeToDic(&p, outSize, src, srcLen, finishMode, status);
  *destLen = p.decoder.dicPos;
  if (res == SZ_OK && *status == LZMA_STATUS_NEEDS_MORE_INPUT)
    res = SZ_ERROR_INPUT_EOF;
  Lzma2Dec_FreeProbs(&p, alloc);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %r8b, %al
movq 0x18(%rbp), %r8
movq 0x10(%rbp), %r8
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x29(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd8(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq 0x10(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x98(%rbp)
movq $0x0, -0xa8(%rbp)
movb -0x29(%rbp), %al
movq 0x18(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
movzbl %al, %esi
callq 0xab010
movl %eax, -0xdc(%rbp)
cmpl $0x0, -0xdc(%rbp)
je 0xabe12
movl -0xdc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xabeb5
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xab180
movq -0xd8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0xd0(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x30(%rbp), %r8d
movq 0x10(%rbp), %r9
leaq -0xc0(%rbp), %rdi
callq 0xab1d0
movl %eax, -0xc4(%rbp)
movq -0x88(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0xc4(%rbp)
jne 0xabe98
movq 0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0xabe98
movl $0x6, -0xc4(%rbp)
leaq -0xc0(%rbp), %rdi
addq $0x10, %rdi
movq 0x18(%rbp), %rsi
callq 0xa75d0
movl -0xc4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
// File: bjohnsonfl[P]Overhead-Chess-Engine-/main.cpp
// Function: main
int main(int argc, const char * argv[]) {
 
    square sw = square(e8 ^ (black * 56));
    sw = square(f8 ^ (black * 56));
   
    
    bitboards::init();
    evaluation::init();
    
    UCI newUCI;
    
    newUCI.loop();

    
 /*
    position * pos = new position();
    
    bitboard nodes = 0;
    clock_t t;
    std::cout <<"Starting Perft... \n\n";
    t = clock();
    nodes= perftDivide(5, *pos);
    t = clock() - t;
    
    std::cout << "nodes = " << nodes << " seconds: " << float(t)/CLOCKS_PER_SEC << std::endl;
    std::cout << "totalNodes = " << pos->get_nodes() << "\n";
   // pos -> printAllBitboards();
    pos->printBoard();
  //  printBitboard((pos -> get_pieces(p_queen, p_rook)) & pos->get_pieces(white));
    
*/
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp            # imm = 0x3F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x4, -0x14(%rbp)
movl $0x5, -0x14(%rbp)
callq 0x3fe0
callq 0xadb0
leaq -0x3d0(%rbp), %rdi
movq %rdi, -0x3e8(%rbp)
callq 0xb330
movq -0x3e8(%rbp), %rdi
callq 0xb390
jmp 0x3b22
movl $0x0, -0x4(%rbp)
leaq -0x3d0(%rbp), %rdi
callq 0x3c20
movl -0x4(%rbp), %eax
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x3d8(%rbp)
movl %eax, -0x3dc(%rbp)
leaq -0x3d0(%rbp), %rdi
callq 0x3c20
movq -0x3d8(%rbp), %rdi
callq 0x3390
nopl (%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/bitboard.cpp
// Function: randomU64()
uint64_t randomU64 ()
{
    uint64_t val1, val2, val3, val4;
    val1 = uint64_t(rand() & 0xFFFF);
    val2 = uint64_t(rand() & 0xFFFF) << 16;
    val3 = uint64_t(rand() & 0xFFFF) << 32;
    val4 = uint64_t(rand() & 0xFFFF) << 48;
    
    
    return val1 | val2 | val3 | val4;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x3080
andl $0xffff, %eax           # imm = 0xFFFF
cltq
movq %rax, -0x8(%rbp)
callq 0x3080
andl $0xffff, %eax           # imm = 0xFFFF
cltq
shlq $0x10, %rax
movq %rax, -0x10(%rbp)
callq 0x3080
andl $0xffff, %eax           # imm = 0xFFFF
cltq
shlq $0x20, %rax
movq %rax, -0x18(%rbp)
callq 0x3080
andl $0xffff, %eax           # imm = 0xFFFF
cltq
shlq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
orq -0x10(%rbp), %rax
orq -0x18(%rbp), %rax
orq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/bitboard.cpp
// Function: diagMasks(int, unsigned long)
bitboard diagMasks (int sq, bitboard occupied){
    int iter = sq;
   bitboard bb = squareBitMask[sq];
    
    //Diagonal
    //north east
    bitboard diag = bb;
    while( (square_to_rank(square(iter)) < numOfRank-1) && (square_to_file(square(iter)) < numOfFile-1) )
    {
        
        iter += noEa;
        diag |= (diag << noEa);
        if( squareBitMask[iter] & occupied) break;
    }
    
    //south west
    iter = sq;
    while( (square_to_rank(square(iter)) >= 0) && (square_to_file(square(iter)) > 0) && iter >= 0 )
    {
        iter +=soWe;
        diag |= (diag >> -soWe);
        if( squareBitMask[iter] & occupied) break;
    }
    
    //diagonalBitMask[sq] = diag;
    
    return diag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xed20(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x59d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x7, %ecx
movb %al, -0x29(%rbp)
jge 0x41b5
movl -0x14(%rbp), %edi
callq 0x59f0
cmpl $0x7, %eax
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x41be
jmp 0x41f4
movl -0x14(%rbp), %eax
addl $0x9, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
shlq $0x9, %rax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xecbe(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x41f2
jmp 0x41f4
jmp 0x4190
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x59d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
jl 0x422c
movl -0x14(%rbp), %edi
callq 0x59f0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
jle 0x422c
cmpl $0x0, -0x14(%rbp)
setge %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x4235
jmp 0x426b
movl -0x14(%rbp), %eax
addl $-0x9, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
shrq $0x9, %rax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xec47(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x4269
jmp 0x426b
jmp 0x41fa
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/bitboard.cpp
// Function: antidiagMasks(int, unsigned long)
bitboard antidiagMasks (int sq, bitboard occupied){
    
    bitboard antiDiag = squareBitMask[sq];
    int iter = sq;
    while( (square_to_rank(square(iter)) < numOfRank-1) && (square_to_file(square(iter)) > 0) )
    {
        iter += noWe;
        antiDiag |= (antiDiag << noWe);
        if( squareBitMask[iter] & occupied) break;
    }
    
    //south east
    iter = sq;
    while( (square_to_rank(square(iter)) >= 0) && (square_to_file(square(iter)) < numOfFile-1) )
    {
        iter += soEa;
        antiDiag |= (antiDiag >> -soEa);
        if( squareBitMask[iter] & occupied) break;
        
    }
    
    return antiDiag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xec06(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x59d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x7, %ecx
movb %al, -0x1d(%rbp)
jge 0x42cd
movl -0x1c(%rbp), %edi
callq 0x59f0
cmpl $0x0, %eax
setg %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x42d6
jmp 0x430c
movl -0x1c(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
shlq $0x7, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0xeba6(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x430a
jmp 0x430c
jmp 0x42a8
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x59d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1e(%rbp)
jl 0x4337
movl -0x1c(%rbp), %edi
callq 0x59f0
cmpl $0x7, %eax
setl %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
testb $0x1, %al
jne 0x4340
jmp 0x4376
movl -0x1c(%rbp), %eax
addl $-0x7, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
shrq $0x7, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0xeb3c(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x4374
jmp 0x4376
jmp 0x4312
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: bjohnsonfl[P]Overhead-Chess-Engine-/bitboard.cpp
// Function: allKingAttacks()
void allKingAttacks(){
    bitboard kingA = 0ULL, kingH = 0ULL, kingMoves = 0ULL, king = 0ULL;
    square sq = a1;
    for(rank rk = rank_1; rk<numOfRank; rk++)
    {
        for(file f = file_a; f<numOfFile; f++)
        {
            sq = rankFile_to_sq(rk, f);
            kingA = squareBitMask[sq] & clearFile[file_a];
            kingH = squareBitMask[sq] & clearFile[file_h];
            king  = squareBitMask[sq];
            
            kingMoves |= (kingA << noWe);
            kingMoves |= (king  << nort);
            kingMoves |= (kingH << noEa);
            kingMoves |= (kingH << east);
            kingMoves |= (kingH >> -soEa);
            kingMoves |= (king  >> -south);
            kingMoves |= (kingA >> -soWe);
            kingMoves |= (kingA >> -west);
            
           // printBitboard(kingMoves);
            openBoardAttacks[p_king][sq] = kingMoves;
            kingMoves = 0ULL;
        }
        
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x8, -0x28(%rbp)
jge 0x46a9
movl $0x0, -0x2c(%rbp)
cmpl $0x8, -0x2c(%rbp)
jge 0x4697
movl -0x28(%rbp), %edi
movl -0x2c(%rbp), %esi
callq 0x5a00
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0xe8f5(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
andq 0xef6a(%rip), %rax      # 0x13520
movq %rax, -0x8(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0xe8da(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
andq 0xef87(%rip), %rax      # 0x13558
movq %rax, -0x10(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0xe8bf(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
shlq $0x7, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
shlq $0x8, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
shlq $0x9, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
shlq %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq $0x7, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
shrq $0x8, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
shrq $0x9, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0xef29(%rip), %rax      # 0x135a0
movq %rdx, 0xa00(%rax,%rcx,8)
movq $0x0, -0x18(%rbp)
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
callq 0x5a20
jmp 0x4587
jmp 0x4699
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x5a40
jmp 0x4576
addq $0x30, %rsp
popq %rbp
retq
nop
// File: bjohnsonfl[P]Overhead-Chess-Engine-/bitboard.cpp
// Function: allBishopAttacks()
void allBishopAttacks(){
    for(square sq= a1; sq<numOfSq; sq++){
     
        magicBishopMask[sq] = clearEdges &( squareBitMask[sq] ^(diagonalBitMask[sq] | antiDiagonalBitMask[sq]));
        openBoardAttacks[p_bishop][sq] =  squareBitMask[sq] ^(diagonalBitMask[sq] | antiDiagonalBitMask[sq]);
       // printBitboard(openBoardAttacks[p_bishop][sq]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x40, -0x4(%rbp)
jge 0x4940
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xe5fb(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rdx
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xe86b(%rip), %rax      # 0x13120
movq (%rax,%rcx,8), %rax
movl -0x4(%rbp), %ecx
movl %ecx, %esi
leaq 0xea5b(%rip), %rcx      # 0x13320
orq (%rcx,%rsi,8), %rax
xorq %rax, %rdx
movabsq $0x7e7e7e7e7e7e00, %rax # imm = 0x7E7E7E7E7E7E00
andq %rax, %rdx
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xe82bb(%rip), %rax     # 0xecba0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xe5ab(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rdx
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xe81b(%rip), %rax      # 0x13120
movq (%rax,%rcx,8), %rax
movl -0x4(%rbp), %ecx
movl %ecx, %esi
leaq 0xea0b(%rip), %rcx      # 0x13320
orq (%rcx,%rsi,8), %rax
xorq %rax, %rdx
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xec78(%rip), %rax      # 0x135a0
movq %rdx, 0x400(%rax,%rcx,8)
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x5a80
jmp 0x488f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/bitboard.cpp
// Function: vertMasks(int, unsigned long)
bitboard vertMasks (int sq, bitboard occupied){
    int iter = sq;
    bitboard bb = squareBitMask[sq];
    
    //vertical
    //north
    bitboard vert = bb;
    while( square_to_rank(square(iter)) < numOfRank-1 )
    {
        
        iter += nort;
        vert |= (vert << nort);
        if( squareBitMask[iter] & occupied) break;
    }
    
    //south
    iter = sq;
    while( square_to_rank(square(iter)) > 0)
    {
        iter +=south;
        vert |= (vert >> -south);
        if( squareBitMask[iter] & occupied) break;
    }
    
    return vert;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xd870(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x59d0
cmpl $0x7, %eax
jge 0x5683
movl -0x14(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
shlq $0x8, %rax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xd82f(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x5681
jmp 0x5683
jmp 0x5640
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x59d0
cmpl $0x0, %eax
jle 0x56cc
movl -0x14(%rbp), %eax
addl $-0x8, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
shrq $0x8, %rax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xd7e6(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x56ca
jmp 0x56cc
jmp 0x5689
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/bitboard.cpp
// Function: horizMasks(int, unsigned long)
bitboard horizMasks (int sq, bitboard occupied){
    uint iter = sq;
    bitboard bb = squareBitMask[sq];
    
    //horizontal
    //east
    bitboard horiz = bb;
    while( square_to_file(square(iter)) < numOfFile-1 )
    {
        
        iter += east;
        horiz |= (horiz << east);
        if( squareBitMask[iter] & occupied) break;
    }
    
    //west
    iter = sq;
    while( square_to_file(square(iter)) > 0)
    {
        iter +=west;
        horiz |= (horiz >> -west);
        if( squareBitMask[iter] & occupied) break;
    }
    return horiz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xd7a0(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x59f0
cmpl $0x7, %eax
jge 0x5753
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
shlq %rax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xd75f(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x5751
jmp 0x5753
jmp 0x5710
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x59f0
cmpl $0x0, %eax
jle 0x579c
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
shrq %rax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xd716(%rip), %rax      # 0x12ea0
movq (%rax,%rcx,8), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x579a
jmp 0x579c
jmp 0x5759
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/bitboard.cpp
// Function: sliderAttacks(square, unsigned long, pieceType)
bitboard sliderAttacks (square sq, bitboard occupency, pieceType pt)
{
    bitboard mask, magic, index;
    int shift =0;
    if(pt == p_rook) {
        mask = magicRookMask[sq];
        magic = magicRookNumbers[sq];
        shift = rookShifts[sq];
        index = magicIndex(mask&occupency, magic, shift);
        return *(magicRookIndex[sq] + index);
        
    }
    else{
        mask = magicBishopMask[sq];
        magic = magicBishopNumbers[sq];
        shift = bishopShifts[sq];
        index = magicIndex(mask&occupency, magic, shift);
        return *(magicBishopIndex[sq]+index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jne 0x5841
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1edc5(%rip), %rax     # 0x245a0
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1efb1(%rip), %rax     # 0x247a0
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x885d(%rip), %rax      # 0xe060
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movq -0x28(%rbp), %rdi
andq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x3c(%rbp), %edx
callq 0x58c0
movl %eax, %eax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1f171(%rip), %rax     # 0x249a0
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x58b1
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xe7353(%rip), %rax     # 0xecba0
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xe753f(%rip), %rax     # 0xecda0
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x88eb(%rip), %rax      # 0xe160
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movq -0x28(%rbp), %rdi
andq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x3c(%rbp), %edx
callq 0x58c0
movl %eax, %eax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xe76ff(%rip), %rax     # 0xecfa0
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: bjohnsonfl[P]Overhead-Chess-Engine-/bitboard.cpp
// Function: printBitboard(unsigned long)
void printBitboard(bitboard board)
{
    std::cout << "---------------\n";
    for(rank r = rank_8; r>=0; r--)
    {
        for(file f = file_a; f<numOfFile; f++)
        {
            if(board & squareBitMask[rankFile_to_sq(r, f)]) std::cout << "# ";
            else std::cout << "- ";
        }
        std::cout <<"\n";
    }
    std::cout << "---------------\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0xc6c5(%rip), %rdi      # 0x11fc8
leaq 0x8732(%rip), %rsi      # 0xe03c
callq 0x31e0
movl $0x7, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x59b5
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0x5992
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x5a00
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
leaq 0xd54f(%rip), %rcx      # 0x12ea0
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
je 0x5970
movq 0xc666(%rip), %rdi      # 0x11fc8
leaq 0x86e4(%rip), %rsi      # 0xe04d
callq 0x31e0
jmp 0x5983
movq 0xc651(%rip), %rdi      # 0x11fc8
leaq 0x86d2(%rip), %rsi      # 0xe050
callq 0x31e0
jmp 0x5985
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5a20
jmp 0x5927
movq 0xc62f(%rip), %rdi      # 0x11fc8
leaq 0x8a25(%rip), %rsi      # 0xe3c5
callq 0x31e0
leaq -0xc(%rbp), %rdi
xorl %esi, %esi
callq 0x5a60
jmp 0x5916
movq 0xc60c(%rip), %rdi      # 0x11fc8
leaq 0x8679(%rip), %rsi      # 0xe03c
callq 0x31e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: bjohnsonfl[P]Overhead-Chess-Engine-/moveGen.cpp
// Function: generateQuiet(position const&, candidate*)
candidate* generateQuiet(const position& pos, candidate* moveList){
    player us = pos.get_sideToPlay();
    player them = player(!us);
    bitboard quiets = ~(pos.get_pieces());
    bitboard clear7Rank = us == white ? clearRank[rank_8] : clearRank[rank_1];
    
    moveList = sliderMoves(pos, quiets, moveList);
    moveList = pawnPushMoves(pos, pos.get_pieces(us, p_pawn), us, quiets & clear7Rank, moveList);
    moveList = kingMoves(pos, quiets, moveList);
    moveList = knightMoves(pos.get_pieces(us, p_knight), quiets, moveList);
    
    
    return moveList;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x75c0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7690
xorq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x5b25
leaq 0xda45(%rip), %rax      # 0x13560
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x5b33
leaq 0xda34(%rip), %rax      # 0x13560
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x6820
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x76b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
andq -0x28(%rbp), %rcx
movq -0x10(%rbp), %r8
callq 0x6a80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x6c70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0x76b0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x6d80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)