LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/cryptorand.c
// Function: crypto_rand_uniform32_bounded
uint32_t
crypto_rand_uniform32_bounded(crypto_rand_state *st, uint32_t upper_bound)
{
    uint32_t r, min;

    if (upper_bound < 2)
        return 0;

    /* 2**32 % x == (2**32 - x) % x */
    min = -upper_bound % upper_bound;

    /*
     * This could theoretically loop forever but each retry has
     * p > 0.5 (worst case, usually far better) of selecting a
     * number inside the range we need, so it should rarely need
     * to re-roll.
     */
    for (;;) {
        r = crypto_rand_uniform32(st);
        if (r >= min)
            break;
    }

    return r % upper_bound;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jae 0x179e
movl $0x0, -0x4(%rbp)
jmp 0x17ce
xorl %eax, %eax
subl -0x14(%rbp), %eax
xorl %edx, %edx
divl -0x14(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17e0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jb 0x17c1
jmp 0x17c3
jmp 0x17ab
movl -0x18(%rbp), %eax
xorl %edx, %edx
divl -0x14(%rbp)
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/cryptorand.c
// Function: crypto_rand_uniform64_bounded
uint64_t
crypto_rand_uniform64_bounded(crypto_rand_state *st, uint64_t upper_bound)
{
    uint64_t r, min;

    if (upper_bound < 2)
        return 0;

    /* 2**64 % x == (2**64 - x) % x */
    min = -upper_bound % upper_bound;

    /*
     * This could theoretically loop forever but each retry has
     * p > 0.5 (worst case, usually far better) of selecting a
     * number inside the range we need, so it should rarely need
     * to re-roll.
     */
    for (;;) {
        r = crypto_rand_uniform64(st);
        if (r >= min)
            break;
    }

    return r % upper_bound;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jae 0x1831
movq $0x0, -0x8(%rbp)
jmp 0x186e
xorl %eax, %eax
subq -0x18(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1880
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x185c
jmp 0x185e
jmp 0x1843
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/./cipher.h
// Function: _aes_reinit
static void
__aes_reinit(crypto_rand_state *st)
{
    uint8_t *key = &st->buf[0];
    uint8_t *iv  = key + AESRAND_KEYSZ;

    __aes_key_setup(st, key, iv);

    // erase the key & iv, reduce the amount of rand we have
    memset(key, 0, AESRAND_KEYSZ + AESRAND_IVSZ);
    st->ptr = st->buf + (AESRAND_KEYSZ + AESRAND_IVSZ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x19b0
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1060
movq -0x8(%rbp), %rcx
addq $0x30, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x400(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/./cipher.h
// Function: _chacha_reinit
static void
__chacha_reinit(crypto_rand_state *st)
{
    uint8_t *key = &st->buf[0];
    uint8_t *iv  = key + ARC4R_KEYSZ;

    __chacha_key_setup(st, key, iv);

    // erase the key & iv, reduce the amount of rand we have
    memset(key, 0, ARC4R_KEYSZ + ARC4R_IVSZ);
    st->ptr = st->buf + (ARC4R_KEYSZ + ARC4R_IVSZ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2c60
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1060
movq -0x8(%rbp), %rcx
addq $0x28, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x400(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/./chacha_private.h
// Function: chacha_ivsetup
static inline void
chacha_ivsetup(chacha_ctx *x,const u8 *iv)
{
  x->input[12] = 0;
  x->input[13] = 0;
  x->input[14] = U8TO32_LITTLE(iv + 0);
  x->input[15] = U8TO32_LITTLE(iv + 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
shll $0x18, %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movzbl 0x6(%rax), %eax
shll $0x10, %eax
orl %eax, %ecx
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
shll $0x18, %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/cryptorand.c
// Function: rs_stir
static void
_rs_stir(crypto_rand_state* st)
{
    st->crypt_rekey(st);

    /* invalidate rand buf */
    memset(st->buf, 0, sizeof st->buf);
    st->ptr   = st->buf + sizeof st->buf;
    st->count = RAND_RESEED_BYTES;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x528(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x1060
movq -0x8(%rbp), %rcx
addq $0x400, %rcx            # imm = 0x400
movq -0x8(%rbp), %rax
movq %rcx, 0x400(%rax)
movq -0x8(%rbp), %rax
movq $0x20000, 0x408(%rax) # imm = 0x20000
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/aes.c
// Function: AES_CTR_xcrypt_buffer
void AES_CTR_xcrypt_buffer(struct AES_ctx* ctx, uint8_t* buf, size_t length)
{
  uint8_t buffer[AES_BLOCKLEN];
  
  size_t i;
  int bi;
  for (i = 0, bi = AES_BLOCKLEN; i < length; ++i, ++bi)
  {
    if (bi == AES_BLOCKLEN) /* we need to regen xor compliment in buffer */
    {
      
      memcpy(buffer, ctx->Iv, AES_BLOCKLEN);
      Cipher((state_t*)buffer,ctx->RoundKey);

      /* Increment Iv and handle overflow */
      for (bi = (AES_BLOCKLEN - 1); bi >= 0; --bi)
      {
	/* inc will overflow */
        if (ctx->Iv[bi] == 255)
	{
          ctx->Iv[bi] = 0;
          continue;
        } 
        ctx->Iv[bi] += 1;
        break;   
      }
      bi = 0;
    }

    buf[i] = (buf[i] ^ buffer[bi]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x10, -0x3c(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x34f4
cmpl $0x10, -0x3c(%rbp)
jne 0x34b6
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0xf8(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3500
movl $0xf, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0x34af
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movzbl 0xf0(%rax,%rcx), %eax
cmpl $0xff, %eax
jne 0x3488
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb $0x0, 0xf0(%rax,%rcx)
jmp 0x34a4
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movzbl 0xf0(%rax,%rcx), %edx
addl $0x1, %edx
movb %dl, 0xf0(%rax,%rcx)
jmp 0x34af
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3459
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movslq -0x3c(%rbp), %rcx
movzbl -0x30(%rbp,%rcx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3413
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/aes.c
// Function: Cipher
static void Cipher(state_t* state, const uint8_t* RoundKey)
{
  uint8_t round = 0;

  // Add the First round key to the state before starting the rounds.
  AddRoundKey(0, state, RoundKey);

  // There will be Nr rounds.
  // The first Nr-1 rounds are identical.
  // These Nr rounds are executed in the loop below.
  // Last one without MixColumns()
  for (round = 1; ; ++round)
  {
    SubBytes(state);
    ShiftRows(state);
    if (round == Nr) {
      break;
    }
    MixColumns(state);
    AddRoundKey(round, state, RoundKey);
  }
  // Add round key to last round
  AddRoundKey(Nr, state, RoundKey);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
xorl %edi, %edi
callq 0x3590
movb $0x1, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3620
movq -0x8(%rbp), %rdi
callq 0x36a0
movzbl -0x11(%rbp), %eax
cmpl $0xe, %eax
jne 0x3544
jmp 0x356a
movq -0x8(%rbp), %rdi
callq 0x3770
movb -0x11(%rbp), %al
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movzbl %al, %edi
callq 0x3590
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x3527
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0xe, %edi
callq 0x3590
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/aes.c
// Function: AddRoundKey
static void AddRoundKey(uint8_t round, state_t* state, const uint8_t* RoundKey)
{
  uint8_t i,j;
  for (i = 0; i < 4; ++i)
  {
    for (j = 0; j < 4; ++j)
    {
      (*state)[i][j] ^= RoundKey[(round * Nb * 4) + (i * Nb) + j];
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x4, %eax
jge 0x3612
movb $0x0, -0x1a(%rbp)
movzbl -0x1a(%rbp), %eax
cmpl $0x4, %eax
jge 0x3606
movq -0x18(%rbp), %rax
movzbl -0x1(%rbp), %ecx
shll $0x2, %ecx
shll $0x2, %ecx
movzbl -0x19(%rbp), %edx
shll $0x2, %edx
addl %edx, %ecx
movzbl -0x1a(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %esi
movq -0x10(%rbp), %rax
movzbl -0x19(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movzbl -0x1a(%rbp), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movb -0x1a(%rbp), %al
addb $0x1, %al
movb %al, -0x1a(%rbp)
jmp 0x35b3
jmp 0x3608
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x35a6
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/aes.c
// Function: SubBytes
static void SubBytes(state_t* state)
{
  uint8_t i, j;
  for (i = 0; i < 4; ++i)
  {
    for (j = 0; j < 4; ++j)
    {
      (*state)[j][i] = getSBoxValue((*state)[j][i]);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x4, %eax
jge 0x3691
movb $0x0, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
cmpl $0x4, %eax
jge 0x3685
movq -0x8(%rbp), %rax
movzbl -0xa(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movzbl -0x9(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xaae(%rip), %rax       # 0x4110
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movzbl -0xa(%rbp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movzbl -0x9(%rbp), %ecx
movb %dl, (%rax,%rcx)
movb -0xa(%rbp), %al
addb $0x1, %al
movb %al, -0xa(%rbp)
jmp 0x3639
jmp 0x3687
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x362c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/aes.c
// Function: ShiftRows
static void ShiftRows(state_t* state)
{
  uint8_t temp;

  // Rotate first row 1 columns to left  
  temp           = (*state)[0][1];
  (*state)[0][1] = (*state)[1][1];
  (*state)[1][1] = (*state)[2][1];
  (*state)[2][1] = (*state)[3][1];
  (*state)[3][1] = temp;

  // Rotate second row 2 columns to left  
  temp           = (*state)[0][2];
  (*state)[0][2] = (*state)[2][2];
  (*state)[2][2] = temp;

  temp           = (*state)[1][2];
  (*state)[1][2] = (*state)[3][2];
  (*state)[3][2] = temp;

  // Rotate third row 3 columns to left
  temp           = (*state)[0][3];
  (*state)[0][3] = (*state)[3][3];
  (*state)[3][3] = (*state)[2][3];
  (*state)[2][3] = (*state)[1][3];
  (*state)[1][3] = temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0x5(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movb 0x9(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x8(%rbp), %rax
movb 0xd(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x9(%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xd(%rax)
movq -0x8(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0xa(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xa(%rax)
movq -0x8(%rbp), %rax
movb 0x6(%rax), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0xe(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x6(%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xe(%rax)
movq -0x8(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0xf(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x8(%rbp), %rax
movb 0xb(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xf(%rax)
movq -0x8(%rbp), %rax
movb 0x7(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xb(%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x7(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/aes.c
// Function: MixColumns
static void MixColumns(state_t* state)
{
  uint8_t i;
  uint8_t Tmp, Tm, t;
  for (i = 0; i < 4; ++i)
  {  
    t   = (*state)[i][0];
    Tmp = (*state)[i][0] ^ (*state)[i][1] ^ (*state)[i][2] ^ (*state)[i][3] ;
    Tm  = (*state)[i][0] ^ (*state)[i][1] ; Tm = xtime(Tm);  (*state)[i][0] ^= Tm ^ Tmp ;
    Tm  = (*state)[i][1] ^ (*state)[i][2] ; Tm = xtime(Tm);  (*state)[i][1] ^= Tm ^ Tmp ;
    Tm  = (*state)[i][2] ^ (*state)[i][3] ; Tm = xtime(Tm);  (*state)[i][2] ^= Tm ^ Tmp ;
    Tm  = (*state)[i][3] ^ t ;              Tm = xtime(Tm);  (*state)[i][3] ^= Tm ^ Tmp ;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x4, %eax
jge 0x38f8
movq -0x8(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movb (%rax,%rcx,4), %al
movb %al, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movzbl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movzbl -0x9(%rbp), %edx
movzbl 0x1(%rcx,%rdx,4), %ecx
xorl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl -0x9(%rbp), %edx
movzbl 0x2(%rcx,%rdx,4), %ecx
xorl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl -0x9(%rbp), %edx
movzbl 0x3(%rcx,%rdx,4), %ecx
xorl %ecx, %eax
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movzbl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movzbl -0x9(%rbp), %edx
movzbl 0x1(%rcx,%rdx,4), %ecx
xorl %ecx, %eax
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %edi
callq 0x3900
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %esi
movzbl -0xa(%rbp), %eax
xorl %eax, %esi
movq -0x8(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movzbl (%rax,%rcx,4), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movzbl 0x1(%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movzbl -0x9(%rbp), %edx
movzbl 0x2(%rcx,%rdx,4), %ecx
xorl %ecx, %eax
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %edi
callq 0x3900
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %esi
movzbl -0xa(%rbp), %eax
xorl %eax, %esi
movq -0x8(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movzbl 0x1(%rax,%rcx,4), %edx
xorl %esi, %edx
movb %dl, 0x1(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movzbl 0x2(%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movzbl -0x9(%rbp), %edx
movzbl 0x3(%rcx,%rdx,4), %ecx
xorl %ecx, %eax
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %edi
callq 0x3900
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %esi
movzbl -0xa(%rbp), %eax
xorl %eax, %esi
movq -0x8(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movzbl 0x2(%rax,%rcx,4), %edx
xorl %esi, %edx
movb %dl, 0x2(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movzbl 0x3(%rax,%rcx,4), %eax
movzbl -0xc(%rbp), %ecx
xorl %ecx, %eax
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %edi
callq 0x3900
movb %al, -0xb(%rbp)
movzbl -0xb(%rbp), %esi
movzbl -0xa(%rbp), %eax
xorl %eax, %esi
movq -0x8(%rbp), %rax
movzbl -0x9(%rbp), %ecx
movzbl 0x3(%rax,%rcx,4), %edx
xorl %esi, %edx
movb %dl, 0x3(%rax,%rcx,4)
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x3780
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/error.c
// Function: error
void
error(int doexit, int err, const char* fmt, ...)
{
    va_list ap;

    fflush(stdout);
    fflush(stderr);
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);

    if (err > 0)
        fprintf(stderr, "\n  %s (Errno %d)\n", strerror(err), err);

    if (doexit) {
        fflush(stderr);
        exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x3968
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq 0x264a(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
callq 0x10b0
movq 0x265b(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
callq 0x10b0
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq 0x2628(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x10d0
leaq -0x30(%rbp), %rax
cmpl $0x0, -0x8(%rbp)
jle 0x3a1e
movq 0x2607(%rip), %rax      # 0x5ff8
movq (%rax), %rax
movq %rax, -0xe8(%rbp)
movl -0x8(%rbp), %edi
callq 0x1110
movq -0xe8(%rbp), %rdi
movq %rax, %rdx
movl -0x8(%rbp), %ecx
leaq 0x804(%rip), %rsi       # 0x421b
movb $0x0, %al
callq 0x1080
cmpl $0x0, -0x4(%rbp)
je 0x3a3d
movq 0x25cd(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
callq 0x10b0
movl $0x1, %edi
callq 0x10f0
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/posix_entropy.c
// Function: getentropy
int
getentropy(void* buf, size_t n)
{
    static int fd = -1;
    uint8_t* b    = (uint8_t*)buf;

    if (fd < 0)
        fd = randopen("/dev/urandom");

    while (n > 0)
    {
        ssize_t m = (read)(fd, b, n);

        if (m < 0) {
            if (errno == EINTR) continue;
            error(1, errno, "Fatal read error while reading rand dev");
        }
        b += m;
        n -= m;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x2631(%rip)      # 0x60a0
jge 0x3a83
leaq 0x7b5(%rip), %rdi       # 0x422d
callq 0x3b00
movl %eax, 0x261d(%rip)      # 0x60a0
jmp 0x3a85
cmpq $0x0, -0x10(%rbp)
jbe 0x3aed
movl 0x260e(%rip), %edi      # 0x60a0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x1070
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x3ad0
callq 0x1040
cmpl $0x4, (%rax)
jne 0x3ab6
jmp 0x3a85
callq 0x1040
movl (%rax), %esi
movl $0x1, %edi
leaq 0x771(%rip), %rdx       # 0x423a
movb $0x0, %al
callq 0x3930
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x3a85
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/opencoff[P]crypto-rand/posix_entropy.c
// Function: randopen
static int
randopen(const char* name)
{
    int fd = open(name, O_RDONLY);
    if (fd < 0)
        error(1, errno, "Cannot open system random number dev %s", name);


    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x10c0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x3b40
callq 0x1040
movl (%rax), %esi
movq -0x8(%rbp), %rcx
movl $0x1, %edi
leaq 0x729(%rip), %rdx       # 0x4262
movb $0x0, %al
callq 0x3930
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/clunk.c
// Function: computermove
struct move computermove(struct thudboard * board)
{
    struct move move;

    puts("Thinking...");
    fflush(stdout);
    // move = iterdeepen(board, SEARCHSECS);
    move = montecarlo(board, SEARCHSECS);
    showmove(& move);

    return move;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x68(%rbp)
movq %rsi, -0x8(%rbp)
leaq 0x4d57(%rip), %rdi      # 0x6072
callq 0x1050
movq 0x7cd1(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
callq 0x11f0
movq -0x8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movl $0x3c, %edx
callq 0x4f80
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x58, %edx
callq 0x11c0
movq -0x70(%rbp), %rdi
callq 0x4830
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/clunk.c
// Function: main
int main(int numargs, char * args[])
{
    struct thudboard * board = & board_data;
    struct move move;

    int memuse = 1024 * 1024 * (numargs > 1 ? strtol(args[1], NULL, 10)
                                            : sizeof(struct tableentry));

    setupgame(board, memuse);

    using_history();
    setupsides();

    int moves_since_capt = 0;
    while (moves_since_capt <= DRAW_DEADLINE)
    {
        putchar('\n');
        show(board);

        eval_count = 0;

        //time_t start = time(NULL);
        move = movefuncs[board->isdwarfturn ? DWARF : TROLL](board);
        //time_t elapsed = time(NULL) - start;
        //printf("Thinking took %d second%s.\n", elapsed, pl(elapsed));
        domoveupdatecapts(board, & move);

        //printf("evaluated %d board positions\n", eval_count);

        if (move.numcapts) moves_since_capt = 0;
        else moves_since_capt += 1;
    }

    printf("game over, final score: dwarf=%d, troll=%d\n", board->trollscaptured*4, board->dwarfscaptured);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7e78(%rip), %rax      # 0x9208
movq %rax, -0x18(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x13b9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1110
movq %rax, -0xd8(%rbp)
jmp 0x13c7
movl $0x20, %eax
movq %rax, -0xd8(%rbp)
jmp 0x13c7
movq -0xd8(%rbp), %rax
shlq $0x14, %rax
movl %eax, -0x74(%rbp)
movq -0x18(%rbp), %rdi
movl -0x74(%rbp), %esi
callq 0x1830
callq 0x1170
callq 0x14c0
movl $0x0, -0x78(%rbp)
cmpl $0xa, -0x78(%rbp)
jg 0x1489
movl $0xa, %edi
callq 0x10a0
movq -0x18(%rbp), %rdi
callq 0x3e50
leaq 0x7e72(%rip), %rax      # 0x9288
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movb (%rax), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movslq %eax, %rcx
leaq 0x7cd7(%rip), %rax      # 0x9110
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq *%rax
leaq -0x70(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
movl $0x58, %edx
callq 0x11c0
movq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4600
cmpl $0x0, -0x5c(%rbp)
je 0x147b
movl $0x0, -0x78(%rbp)
jmp 0x1484
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x13f2
movq -0x18(%rbp), %rax
movl 0x74(%rax), %esi
shll $0x2, %esi
movq -0x18(%rbp), %rax
movl 0x70(%rax), %edx
leaq 0x4b63(%rip), %rdi      # 0x6004
movb $0x0, %al
callq 0x1030
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/clunk.c
// Function: setupsides
void setupsides(void)
{
    char * answer;
sideagain:
    answer = readline("Would you like to play Dwarf or Troll?\n");
    if (! answer) exit(EXIT_SUCCESS);

    char c = toupper(answer[0]);
    free(answer);

    if (c == 'T') movefuncs[TROLL] = humanmove;
    else if (c == 'D') movefuncs[DWARF] = humanmove;
    else if (c == 'B') movefuncs[TROLL] = movefuncs[DWARF] = humanmove;
    else if (c == 'N') /* computer vs computer */;
    else goto sideagain;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x4b61(%rip), %rdi      # 0x6030
callq 0x1140
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x14e6
xorl %edi, %edi
callq 0x1090
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x1080
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10f0
movsbl -0x9(%rbp), %eax
cmpl $0x54, %eax
jne 0x1517
leaq 0x72(%rip), %rax        # 0x1580
movq %rax, 0x7c03(%rip)      # 0x9118
jmp 0x156d
movsbl -0x9(%rbp), %eax
cmpl $0x44, %eax
jne 0x1530
leaq 0x59(%rip), %rax        # 0x1580
movq %rax, 0x7be2(%rip)      # 0x9110
jmp 0x156b
movsbl -0x9(%rbp), %eax
cmpl $0x42, %eax
jne 0x1557
leaq 0x40(%rip), %rax        # 0x1580
movq %rax, 0x7bc9(%rip)      # 0x9110
leaq 0x32(%rip), %rax        # 0x1580
movq %rax, 0x7bc3(%rip)      # 0x9118
jmp 0x1569
movsbl -0x9(%rbp), %eax
cmpl $0x4e, %eax
jne 0x1562
jmp 0x1567
jmp 0x14c8
jmp 0x1569
jmp 0x156b
jmp 0x156d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/clunk.c
// Function: humanmove
struct move humanmove(struct thudboard * board)
{
    struct move move;

moveagain:
    move = getmove("Your move?\n");
    if (! legalmove(board, & move))
    {
        printf("illegal move\n");
        goto moveagain;
    }

    return move;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x68(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0x4ab9(%rip), %rsi      # 0x6058
callq 0x15f0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x58, %edx
callq 0x11c0
movq -0x70(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x4060
testb $0x1, %al
jne 0x15d7
leaq 0x4a96(%rip), %rdi      # 0x6064
movb $0x0, %al
callq 0x1030
jmp 0x1594
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: setup
void setup(struct thudboard * board)
{
    erase(board);

    board->isdwarfturn = true;
    board->captless = 0;

    for (int y=0; y < SIZE; ++y)
    {
        for (int x=0; x < SIZE; ++x)
        {
            switch (toupper(stdlayout[y][x]))
            {
            case 'D':
                placedwarf(board, (struct coord) {x,y});
                break;
            case 'T':
                placetroll(board, (struct coord) {x,y});
                break;
            case '#':
                set(board->blocks, (struct coord) {x,y});
                break;
            case '.':
                break;
            default:
                fprintf(stderr, "unknown board character\n");
                exit(1);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3d50
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x78(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0xf, -0xc(%rbp)
jge 0x1988
movl $0x0, -0x10(%rbp)
cmpl $0xf, -0x10(%rbp)
jge 0x1978
movslq -0xc(%rbp), %rcx
leaq 0x78bc(%rip), %rax      # 0x9170
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x1080
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
subl $0x23, %eax
je 0x1925
jmp 0x18d1
movl -0x2c(%rbp), %eax
subl $0x2e, %eax
je 0x1944
jmp 0x18db
movl -0x2c(%rbp), %eax
subl $0x44, %eax
je 0x18ef
jmp 0x18e5
movl -0x2c(%rbp), %eax
subl $0x54, %eax
je 0x190a
jmp 0x1946
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3d80
jmp 0x1968
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x20(%rbp), %rsi
callq 0x3a10
jmp 0x1968
movq -0x8(%rbp), %rdi
addq $0x3e, %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x28(%rbp), %rsi
callq 0x3de0
jmp 0x1968
jmp 0x1968
movq 0x769b(%rip), %rax      # 0x8fe8
movq (%rax), %rdi
leaq 0x47fe(%rip), %rsi      # 0x6155
movb $0x0, %al
callq 0x1190
movl $0x1, %edi
callq 0x1090
jmp 0x196a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x189f
jmp 0x197a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x188e
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: BROKEiterdeepen
struct move BROKEiterdeepen(struct thudboard * board, int searchtime)
{
    struct move bestmove;

    struct thudboard tempboard = * board;
    time_t stoptime = time(NULL) + searchtime;

    jmp_buf stopsearch;
    if (setjmp(stopsearch) == 0) for (int depth=1; true; depth += 1)
    {
        bestmove = zerowindow(& tempboard, depth, stoptime, stopsearch);

        //??? write to log?
        //printf("best move at depth %d: ", depth);
        //showmove(& bestmove);
    }

    return bestmove;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1d0(%rbp)
movq %rdi, -0x1c8(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x80, %edx
callq 0x11c0
xorl %eax, %eax
movl %eax, %edi
callq 0x11e0
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x98(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x1060
cmpl $0x0, %eax
jne 0x1a51
movl $0x1, -0x164(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x19ff
jmp 0x1a4f
movl -0x164(%rbp), %edx
movq -0x98(%rbp), %rcx
leaq -0x160(%rbp), %r8
leaq -0x1bc(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1a70
movq -0x1d0(%rbp), %rdi
leaq -0x1bc(%rbp), %rsi
movl $0x58, %edx
callq 0x11c0
movl -0x164(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x164(%rbp)
jmp 0x19f7
jmp 0x1a51
movq -0x1c8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: zerowindow
struct move zerowindow(struct thudboard * board, int depth,
                       time_t stoptime, jmp_buf stopsearch)
{
    struct movelist list = allmoves(board);
    struct moveheap queue = heapof(board, & list);

    //??? should make sure move exists
    struct scoredmove best = popscored(& queue);

    domove(board, best.move);
    best.score = mtdf(board, depth, best.score, stoptime, stopsearch);
    undomove(board, best.move);

    while (queue.used > 0)
    {
        struct scoredmove temp = popscored(& queue);

        domove(board, temp.move);

        int result = absearch(board, depth, FULL_WIDTH,
                              best.score-1, best.score, NULL,
                              stoptime, stopsearch);

        if (result > best.score)
        {
            best = temp;
            best.score = _mtdf(board, depth,
                               result, result, INT_MAX,
                               stoptime, stopsearch);
        }

        undomove(board, temp.move);
    }

    return * best.move;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, -0x70(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22f0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2340
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4cf0
movl %eax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x23f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x50(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x2450
movl %eax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x24a0
cmpl $0x0, -0x40(%rbp)
jle 0x1ba6
leaq -0x40(%rbp), %rdi
callq 0x4cf0
movl %eax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x23f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x50(%rbp), %ecx
subl $0x1, %ecx
movl -0x50(%rbp), %r8d
movq -0x18(%rbp), %r10
movq -0x20(%rbp), %rax
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1d00
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
cmpl -0x50(%rbp), %eax
jle 0x1b94
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x64(%rbp), %edx
movl -0x64(%rbp), %ecx
movq -0x18(%rbp), %r9
movq -0x20(%rbp), %rax
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movq %rax, (%rsp)
callq 0x24e0
movl %eax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x24a0
jmp 0x1afc
movq -0x78(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x58, %edx
callq 0x11c0
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: iterdeepen
struct move iterdeepen(struct thudboard * board, int searchtime)
{
    struct move bestmove;

    struct thudboard tempboard = * board;
    time_t stoptime = time(NULL) + searchtime;

    jmp_buf stopsearch;
    if (setjmp(stopsearch) == 0) for (int depth=1; true; depth += 1)
    {
        struct move move;
        absearch(& tempboard, depth, FULL_WIDTH,
                 INT_MIN, INT_MAX, & move,
                 stoptime, stopsearch);
        bestmove = move;

        // log to stderr
        fprintf(stderr, "best move at depth %d: ", depth);
        fshowmove(stderr, & bestmove);
    }

    return bestmove;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movq %rdi, -0x1c8(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x80, %edx
callq 0x11c0
xorl %eax, %eax
movl %eax, %edi
callq 0x11e0
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x98(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x1060
cmpl $0x0, %eax
jne 0x1ce6
movl $0x1, -0x164(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x1c46
jmp 0x1ce4
movl -0x164(%rbp), %esi
movq -0x98(%rbp), %r10
leaq -0x160(%rbp), %rax
leaq -0x90(%rbp), %rdi
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movl $0x80000000, %ecx       # imm = 0x80000000
leaq -0x1bc(%rbp), %r9
movl %r8d, %edx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1d00
movq -0x1d0(%rbp), %rdi
leaq -0x1bc(%rbp), %rsi
movl $0x58, %edx
callq 0x11c0
movq 0x7345(%rip), %rax      # 0x8fe8
movq (%rax), %rdi
movl -0x164(%rbp), %edx
leaq 0x448a(%rip), %rsi      # 0x613d
movb $0x0, %al
callq 0x1190
movq -0x1d0(%rbp), %rsi
movq 0x7320(%rip), %rax      # 0x8fe8
movq (%rax), %rdi
callq 0x20c0
movl -0x164(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x164(%rbp)
jmp 0x1c3b
jmp 0x1ce6
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: fshowmove
void fshowmove(FILE * stream, struct move * move)
{
    putc(move->isdwarfmove ? 'd' : 'T', stream);
    putc(' ', stream);
    fshowpos(stream, move->from);
    fputs("-", stream);
    fshowpos(stream, move->to);
    for (int i=0; i < move->numcapts; ++i)
    {
        fputs("x", stream);
        fshowpos(stream, move->capts[i]);
    }
    putc('\n', stream);
    fflush(stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %cl
movl $0x54, %edi
movl $0x64, %eax
testb $0x1, %cl
cmovnel %eax, %edi
movq -0x8(%rbp), %rsi
callq 0x1120
movq -0x8(%rbp), %rsi
movl $0x20, %edi
callq 0x1120
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x4(%rax), %rsi
callq 0x47c0
movq -0x8(%rbp), %rsi
leaq 0x40ee(%rip), %rdi      # 0x6207
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xc(%rax), %rsi
callq 0x47c0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x2173
movq -0x8(%rbp), %rsi
leaq 0x40bc(%rip), %rdi      # 0x6209
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rsi
callq 0x47c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2136
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x1120
movq -0x8(%rbp), %rdi
callq 0x11f0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: beamiterdeepen
struct move beamiterdeepen(struct thudboard * board, int searchtime)
{
    struct move bestmove;

    struct thudboard tempboard = * board;
    time_t stoptime = time(NULL) + searchtime;

    for (int depth=1; depth <= 4; depth += 1)
    {
        struct move move;
        absearch(& tempboard, depth, FULL_WIDTH,
                 INT_MIN, INT_MAX, & move,
                 0, NULL);
        bestmove = move;

        //??? write to log?
        //printf("best move at depth %d: ", depth);
        //showmove(& bestmove);
    }

    jmp_buf stopsearch;
    if (setjmp(stopsearch) == 0) for (int depth=5; true; depth += 1)
    {
        struct move move;
        absearch(& tempboard, depth, 20,
                 INT_MIN, INT_MAX, & move,
                 stoptime, stopsearch);
        bestmove = move;

        /*
        //??? won't work without a ttable fix of some kind
        bestmove = zerowindow(& tempboard, depth, stoptime, stopsearch);
        */

        //??? write to log?
        //printf("best width 20 move at depth %d: ", depth);
        //showmove(& bestmove);
    }

    return bestmove;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x230(%rbp)
movq %rdi, -0x228(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x80, %edx
callq 0x11c0
xorl %eax, %eax
movl %eax, %edi
callq 0x11e0
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x98(%rbp)
movl $0x1, -0x9c(%rbp)
cmpl $0x4, -0x9c(%rbp)
jg 0x2252
movl -0x9c(%rbp), %esi
leaq -0x90(%rbp), %rdi
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movl $0x80000000, %ecx       # imm = 0x80000000
leaq -0xf4(%rbp), %r9
xorl %eax, %eax
movl %r8d, %edx
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x1d00
movq -0x230(%rbp), %rdi
leaq -0xf4(%rbp), %rsi
movl $0x58, %edx
callq 0x11c0
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x21e6
leaq -0x1c0(%rbp), %rdi
callq 0x1060
cmpl $0x0, %eax
jne 0x22e0
movl $0x5, -0x1c4(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x2275
jmp 0x22de
movl -0x1c4(%rbp), %esi
movq -0x98(%rbp), %r10
leaq -0x1c0(%rbp), %rax
leaq -0x90(%rbp), %rdi
movl $0x14, %edx
movl $0x80000000, %ecx       # imm = 0x80000000
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
leaq -0x21c(%rbp), %r9
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1d00
movq -0x230(%rbp), %rdi
leaq -0x21c(%rbp), %rsi
movl $0x58, %edx
callq 0x11c0
movl -0x1c4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c4(%rbp)
jmp 0x226d
jmp 0x22e0
movq -0x228(%rbp), %rax
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: heapof
struct moveheap heapof(struct thudboard * board, struct movelist * list)
{
    bool isdwarfturn = board->isdwarfturn;

    struct moveheap heap;
    initheap(& heap);

    for (int i=0; i < list->used; ++i)
    {
        struct move * move = & (list->moves[i]);

        domove(board, move);
        int score = evaluate(board);
        if (isdwarfturn) score *= -1;
        undomove(board, move);

        insert(& heap, score, move);
    }

    return heap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x49c0
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x23db
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x23f0
movq -0x18(%rbp), %rdi
callq 0x2580
movl %eax, -0x34(%rbp)
testb $0x1, -0x21(%rbp)
je 0x23b3
imull $-0x1, -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x24a0
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x4a40
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x236b
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: domove
void domove(struct thudboard * board, struct move * move)
{
    if (move->numcapts) board->captless = 0;
    else board->captless += 1;

    if (board->isdwarfturn) dodwarf(board, move);
    else dotroll(board, move);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x2417
movq -0x8(%rbp), %rax
movl $0x0, 0x78(%rax)
jmp 0x2424
movq -0x8(%rbp), %rax
movl 0x78(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x78(%rax)
movq -0x8(%rbp), %rax
testb $0x1, (%rax)
je 0x243c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3860
jmp 0x2449
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3af0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: mtdf
int _mtdf(struct thudboard * board, int depth,
          int guess, int min, int max,
          time_t stoptime, jmp_buf stopsearch)
{
    do
    {
        int beta = guess + (guess == min);

        guess = absearch(board, depth, FULL_WIDTH,
                         beta-1, beta, NULL,
                         stoptime, stopsearch);

        if (guess < beta) max = guess;
        else min = guess;
    } while (min < max);

    return guess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl -0x10(%rbp), %ecx
cmpl -0x14(%rbp), %ecx
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movl -0x24(%rbp), %r8d
movq -0x20(%rbp), %r10
movq 0x10(%rbp), %rax
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x1d00
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x255a
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x2560
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x2562
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x2501
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: evaluate
int evaluate(struct thudboard * board)
{
    eval_count += 1;
    struct tableentry * entry = ttget(board->hash);
    if (entry) return entry->scoreguess;
    else return heuristic(board);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl 0x6cf6(%rip), %eax      # 0x9288
addl $0x1, %eax
movl %eax, 0x6ced(%rip)      # 0x9288
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x5980
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x25bf
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x25cb
movq -0x10(%rbp), %rdi
callq 0x4000
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: addmoves
void addmoves(int num, struct thudboard * board, struct genstate * ctx,
              struct movelist * list, struct moveheap * queue)
{
    bool isdwarfturn = board->isdwarfturn;

    struct move * move;

    for (int i=0; i < num; ++i)
    {
        move = next(list);
        * move = board->isdwarfturn ? nextdwarfplay(board, ctx)
                                    : nexttrollplay(board, ctx);
        if (! ctx->resume)
        {
            list->used -= 1;
            break;
        }

        domove(board, move);
        int score = evaluate(board);
        if (isdwarfturn) score *= -1;
        undomove(board, move);

        insert(queue, score, move);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2e7b
movq -0x20(%rbp), %rdi
callq 0x4ea0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x2ddb
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x94(%rbp), %rdi
callq 0x2e90
movq -0xf8(%rbp), %rdi
leaq -0x94(%rbp), %rsi
movl $0x58, %edx
callq 0x11c0
jmp 0x2e07
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0xec(%rbp), %rdi
callq 0x3280
movq -0xf8(%rbp), %rdi
leaq -0xec(%rbp), %rsi
movl $0x58, %edx
callq 0x11c0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2e1e
movq -0x20(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2e7b
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x23f0
movq -0x10(%rbp), %rdi
callq 0x2580
movl %eax, -0xf0(%rbp)
testb $0x1, -0x29(%rbp)
je 0x2e4d
imull $-0x1, -0xf0(%rbp), %eax
movl %eax, -0xf0(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x24a0
movq -0x28(%rbp), %rdi
movl -0xf0(%rbp), %esi
movq -0x38(%rbp), %rdx
callq 0x4a40
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2d80
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: nextpos
struct coord nextpos(bitboard bits, struct coord cur)
{
    cur.x += 1;

    for (int i=cur.y*SIZE+cur.x; i < SIZE*SIZE; ++i)
    {
        struct coord pos = (struct coord) {i % SIZE, i / SIZE};
        if (get(bits, pos)) return pos;
    }

    return initpos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
imull $0xf, -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0xe1, -0x1c(%rbp)
jge 0x371a
movl -0x1c(%rbp), %eax
movl $0xf, %ecx
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
movl -0x1c(%rbp), %eax
movl $0xf, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4930
testb $0x1, %al
jne 0x370b
jmp 0x370d
jmp 0x3725
jmp 0x370f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x36d3
movq 0x59ff(%rip), %rax      # 0x9120
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/icarroll[P]clunk/thudlib.c
// Function: dodwarf
void dodwarf(struct thudboard * board, struct move * move)
{
    if (move->numcapts > 0) capttroll(board, move->capts[0]);
    movedwarf(board, move->from, move->to);
    board->isdwarfturn = false;
    hashturn(board);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x388b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x38c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x4(%rcx), %rsi
movq 0xc(%rax), %rdx
callq 0x3910
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x5780
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)