LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/macro8x/macro8x.c
// Function: saveError
void saveError( char *mesg, WORD32 col )
{
  if( save_error_count < DIM( error_list ))
  {
    error_list[save_error_count].mesg = mesg;
    error_list[save_error_count].col = col;
    save_error_count++;
  }
  error_in_line = TRUE;

  if( listed )
  {
    printErrorMessages();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movslq 0x7dc5(%rip), %rax      # 0x10dcc
cmpq $0x14, %rax
jae 0x9055
movq -0x8(%rbp), %rcx
movslq 0x7db4(%rip), %rdx      # 0x10dcc
leaq 0x124d1(%rip), %rax     # 0x1b4f0
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movslq 0x7d98(%rip), %rdx      # 0x10dcc
leaq 0x124b5(%rip), %rax     # 0x1b4f0
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl 0x7d80(%rip), %eax      # 0x10dcc
addl $0x1, %eax
movl %eax, 0x7d77(%rip)      # 0x10dcc
movb $0x1, 0x11c54(%rip)     # 0x1acb0
cmpq $0x0, 0x1182c(%rip)     # 0x1a890
je 0x906b
callq 0x88b0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(unsigned char *c,unsigned long long *clen,
			const unsigned char *m, unsigned long long mlen,
			const unsigned char *ad,unsigned long long adlen,
			const unsigned char *nsec,
			const unsigned char *npub,
			const unsigned char *k)
{
  struct poet_ctx ctx;
  unsigned char *header = malloc((size_t) (adlen+CRYPTO_NPUBBYTES));
  unsigned char *tag = c+mlen;

  *clen=mlen+CRYPTO_NPUBBYTES;
  keysetup(&ctx, k);
  memcpy(header,ad,adlen);
  memcpy(header+adlen,npub,CRYPTO_NPUBBYTES);
  process_header(&ctx, header,adlen+CRYPTO_NPUBBYTES);
  encrypt_final(&ctx, m, mlen, c, tag);


  return 0;

}

// Assembly:
subq $0x498, %rsp            # imm = 0x498
movq 0x4b0(%rsp), %rax
movq 0x4a8(%rsp), %rax
movq 0x4a0(%rsp), %rax
movq %rdi, 0x490(%rsp)
movq %rsi, 0x488(%rsp)
movq %rdx, 0x480(%rsp)
movq %rcx, 0x478(%rsp)
movq %r8, 0x470(%rsp)
movq %r9, 0x468(%rsp)
movq 0x468(%rsp), %rdi
addq $0x10, %rdi
callq 0x1070
movq %rax, 0x8(%rsp)
movq 0x490(%rsp), %rax
addq 0x478(%rsp), %rax
movq %rax, (%rsp)
movq 0x478(%rsp), %rcx
addq $0x10, %rcx
movq 0x488(%rsp), %rax
movq %rcx, (%rax)
movq 0x4b0(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x1130
movq 0x8(%rsp), %rdi
movq 0x470(%rsp), %rsi
movq 0x468(%rsp), %rdx
callq 0x1120
movq 0x8(%rsp), %rax
movq 0x468(%rsp), %rcx
movq 0x4a8(%rsp), %rdx
movq (%rdx), %rsi
movq %rsi, (%rax,%rcx)
movq 0x8(%rdx), %rdx
movq %rdx, 0x8(%rax,%rcx)
movq 0x8(%rsp), %rsi
movq 0x468(%rsp), %rdx
addq $0x10, %rdx
leaq 0x10(%rsp), %rdi
callq 0x10e0
movq 0x480(%rsp), %rsi
movq 0x478(%rsp), %rdx
movq 0x490(%rsp), %rcx
movq (%rsp), %r8
leaq 0x10(%rsp), %rdi
callq 0x1080
xorl %eax, %eax
addq $0x498, %rsp            # imm = 0x498
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(unsigned char *m,unsigned long long *mlen,
			unsigned char *nsec,
			const unsigned char *c,unsigned long long clen,
			const unsigned char *ad,unsigned long long adlen,
			const unsigned char *npub,
			const unsigned char *k)
{
  struct poet_ctx ctx;
  unsigned char *header =  malloc((size_t) (adlen+CRYPTO_NPUBBYTES));
  unsigned char tag[CRYPTO_NPUBBYTES];
  int result;

  if(clen < CRYPTO_NPUBBYTES) return -1;
  *mlen = clen - CRYPTO_NPUBBYTES;

  keysetup(&ctx, k);
  memcpy(tag,c+(clen-CRYPTO_NPUBBYTES), CRYPTO_NPUBBYTES);

  memcpy(header,ad, adlen);
  memcpy(header+adlen, npub, CRYPTO_NPUBBYTES);
  process_header(&ctx, header, adlen+CRYPTO_NPUBBYTES);

  result = decrypt_final(&ctx, c, *mlen, tag,m);

  if (result) return -1;
  return 0;
}

// Assembly:
subq $0x4b8, %rsp            # imm = 0x4B8
movq 0x4d0(%rsp), %rax
movq 0x4c8(%rsp), %rax
movq 0x4c0(%rsp), %rax
movq %rdi, 0x4a8(%rsp)
movq %rsi, 0x4a0(%rsp)
movq %rdx, 0x498(%rsp)
movq %rcx, 0x490(%rsp)
movq %r8, 0x488(%rsp)
movq %r9, 0x480(%rsp)
movq 0x4c0(%rsp), %rdi
addq $0x10, %rdi
callq 0x1070
movq %rax, 0x20(%rsp)
cmpq $0x10, 0x488(%rsp)
jae 0x5fc0
movl $0xffffffff, 0x4b4(%rsp) # imm = 0xFFFFFFFF
jmp 0x60b7
movq 0x488(%rsp), %rcx
subq $0x10, %rcx
movq 0x4a0(%rsp), %rax
movq %rcx, (%rax)
movq 0x4d0(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x1130
movq 0x490(%rsp), %rax
movq 0x488(%rsp), %rcx
subq $0x10, %rcx
movq (%rax,%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax,%rcx), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x480(%rsp), %rsi
movq 0x4c0(%rsp), %rdx
callq 0x1120
movq 0x20(%rsp), %rax
movq 0x4c0(%rsp), %rcx
movq 0x4c8(%rsp), %rdx
movq (%rdx), %rsi
movq %rsi, (%rax,%rcx)
movq 0x8(%rdx), %rdx
movq %rdx, 0x8(%rax,%rcx)
movq 0x20(%rsp), %rsi
movq 0x4c0(%rsp), %rdx
addq $0x10, %rdx
leaq 0x28(%rsp), %rdi
callq 0x10e0
movq 0x490(%rsp), %rsi
movq 0x4a0(%rsp), %rax
movq (%rax), %rdx
leaq 0x10(%rsp), %rcx
movq 0x4a8(%rsp), %r8
leaq 0x28(%rsp), %rdi
callq 0x1090
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x60ac
movl $0xffffffff, 0x4b4(%rsp) # imm = 0xFFFFFFFF
jmp 0x60b7
movl $0x0, 0x4b4(%rsp)
movl 0x4b4(%rsp), %eax
addq $0x4b8, %rsp            # imm = 0x4B8
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ref/poet.c
// Function: keysetup
void keysetup(struct poet_ctx *ctx, const uint8_t key[KEYLEN_BITS]){

  uint8_t ctr[BLOCKLEN];
  AES_KEY aes_enc;

  memset(ctx->tau,0,BLOCKLEN);
  memset(ctr,0, BLOCKLEN);

  /* Generate block cipher key */
  AES_set_encrypt_key(key, KEYLEN_BITS, &aes_enc);
  AES_encrypt(ctr, ctx->k,  &aes_enc);

  AES_set_encrypt_key(ctx->k, KEYLEN_BITS, &(ctx->aes_enc));
  AES_set_decrypt_key(ctx->k, KEYLEN_BITS, &(ctx->aes_dec));

  /* Generate header key */
  ctr[BLOCKLEN-1]+=1; AES_encrypt(ctr, ctx->l,  &aes_enc);

  /* Generate almost XOR universal hash function keys */
  ctr[BLOCKLEN-1]+=1; AES_encrypt(ctr, ctx->lt,  &aes_enc);
  ctr[BLOCKLEN-1]+=1; AES_encrypt(ctr, ctx->lb,  &aes_enc);
  AES_set_encrypt_key(ctx->lt, KEYLEN_BITS, &(ctx->aes_lt));
  AES_set_encrypt_key(ctx->lb, KEYLEN_BITS, &(ctx->aes_lb));

  /* Generate tag masking keys */
  ctr[BLOCKLEN-1]+=1; AES_encrypt(ctr, ctx->tm,  &aes_enc);

}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq 0x120(%rsp), %rdi
addq $0x440, %rdi            # imm = 0x440
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
leaq 0x100(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
movq 0x118(%rsp), %rdi
movl $0x80, %esi
leaq 0xc(%rsp), %rdx
callq 0x10d0
leaq 0x100(%rsp), %rdi
movq 0x120(%rsp), %rsi
addq $0x3d0, %rsi            # imm = 0x3D0
leaq 0xc(%rsp), %rdx
callq 0x1060
movq 0x120(%rsp), %rdi
addq $0x3d0, %rdi            # imm = 0x3D0
movq 0x120(%rsp), %rdx
movl $0x80, %esi
callq 0x10d0
movq 0x120(%rsp), %rdi
addq $0x3d0, %rdi            # imm = 0x3D0
movq 0x120(%rsp), %rdx
addq $0xf4, %rdx
movl $0x80, %esi
callq 0x1050
movzbl 0x10f(%rsp), %eax
addl $0x1, %eax
movb %al, 0x10f(%rsp)
leaq 0x100(%rsp), %rdi
movq 0x120(%rsp), %rsi
addq $0x3f0, %rsi            # imm = 0x3F0
leaq 0xc(%rsp), %rdx
callq 0x1060
movzbl 0x10f(%rsp), %eax
addl $0x1, %eax
movb %al, 0x10f(%rsp)
leaq 0x100(%rsp), %rdi
movq 0x120(%rsp), %rsi
addq $0x400, %rsi            # imm = 0x400
leaq 0xc(%rsp), %rdx
callq 0x1060
movzbl 0x10f(%rsp), %eax
addl $0x1, %eax
movb %al, 0x10f(%rsp)
leaq 0x100(%rsp), %rdi
movq 0x120(%rsp), %rsi
addq $0x410, %rsi            # imm = 0x410
leaq 0xc(%rsp), %rdx
callq 0x1060
movq 0x120(%rsp), %rdi
addq $0x400, %rdi            # imm = 0x400
movq 0x120(%rsp), %rdx
addq $0x1e8, %rdx            # imm = 0x1E8
movl $0x80, %esi
callq 0x10d0
movq 0x120(%rsp), %rdi
addq $0x410, %rdi            # imm = 0x410
movq 0x120(%rsp), %rdx
addq $0x2dc, %rdx            # imm = 0x2DC
movl $0x80, %esi
callq 0x10d0
movzbl 0x10f(%rsp), %eax
addl $0x1, %eax
movb %al, 0x10f(%rsp)
leaq 0x100(%rsp), %rdi
movq 0x120(%rsp), %rsi
addq $0x3e0, %rsi            # imm = 0x3E0
leaq 0xc(%rsp), %rdx
callq 0x1060
addq $0x128, %rsp            # imm = 0x128
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ref/poet.c
// Function: encrypt_block
void encrypt_block(struct poet_ctx *ctx, const uint8_t plaintext[16],
		   uint8_t ciphertext[16])
{
  block tmp;
  TOP_HASH;
  xor_block(ctx->x, plaintext,ctx->x);

  AES_encrypt(ctx->x, tmp, &(ctx->aes_enc));

  BOTTOM_HASH;
  xor_block(ciphertext, tmp,ctx->y);

  memcpy(ctx->y, tmp, BLOCKLEN);
  ctx->mlen+=BLOCKLEN_BITS;

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
addq $0x420, %rdi            # imm = 0x420
movq 0x20(%rsp), %rsi
addq $0x420, %rsi            # imm = 0x420
movq 0x20(%rsp), %rdx
addq $0x1e8, %rdx            # imm = 0x1E8
callq 0x1100
movq 0x20(%rsp), %rdi
addq $0x420, %rdi            # imm = 0x420
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x420, %rdx            # imm = 0x420
callq 0x1110
movq 0x20(%rsp), %rdi
addq $0x420, %rdi            # imm = 0x420
movq %rsp, %rsi
movq 0x20(%rsp), %rdx
callq 0x1060
movq 0x20(%rsp), %rdi
addq $0x430, %rdi            # imm = 0x430
movq 0x20(%rsp), %rsi
addq $0x430, %rsi            # imm = 0x430
movq 0x20(%rsp), %rdx
addq $0x2dc, %rdx            # imm = 0x2DC
callq 0x1100
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
movq 0x20(%rsp), %rdx
addq $0x430, %rdx            # imm = 0x430
callq 0x1110
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x430(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x438(%rax)
movq 0x20(%rsp), %rax
movq 0x450(%rax), %rcx
addq $0x80, %rcx
movq %rcx, 0x450(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128poetv1aes4/ref/poet.c
// Function: decrypt_block
void decrypt_block(struct poet_ctx *ctx, const uint8_t ciphertext[16],
		   uint8_t plaintext[16])
{
  block tmp;
  BOTTOM_HASH;
  xor_block(ctx->y, ciphertext,ctx->y);

  AES_decrypt(ctx->y, tmp, &(ctx->aes_dec));

  TOP_HASH;
  xor_block(plaintext, tmp,ctx->x);

  memcpy(ctx->x, tmp, BLOCKLEN);
  ctx->mlen+=BLOCKLEN_BITS;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
addq $0x430, %rdi            # imm = 0x430
movq 0x20(%rsp), %rsi
addq $0x430, %rsi            # imm = 0x430
movq 0x20(%rsp), %rdx
addq $0x2dc, %rdx            # imm = 0x2DC
callq 0x1100
movq 0x20(%rsp), %rdi
addq $0x430, %rdi            # imm = 0x430
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0x430, %rdx            # imm = 0x430
callq 0x1110
movq 0x20(%rsp), %rdi
addq $0x430, %rdi            # imm = 0x430
movq %rsp, %rsi
movq 0x20(%rsp), %rdx
addq $0xf4, %rdx
callq 0x10c0
movq 0x20(%rsp), %rdi
addq $0x420, %rdi            # imm = 0x420
movq 0x20(%rsp), %rsi
addq $0x420, %rsi            # imm = 0x420
movq 0x20(%rsp), %rdx
addq $0x1e8, %rdx            # imm = 0x1E8
callq 0x1100
movq 0x10(%rsp), %rdi
movq %rsp, %rsi
movq 0x20(%rsp), %rdx
addq $0x420, %rdx            # imm = 0x420
callq 0x1110
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x420(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x428(%rax)
movq 0x20(%rsp), %rax
movq 0x450(%rax), %rcx
addq $0x80, %rcx
movq %rcx, 0x450(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/skinny_mutex.c
// Function: skinny_mutex_lock_slow
int skinny_mutex_lock_slow(skinny_mutex_t *skinny)
{
	for (;;) {
		struct common *head = skinny->val;
		if (head) {
			struct fat_mutex *fat;
			int res = fat_mutex_get(skinny, head, &fat);
			if (!res) {
				fat->refcount++;
				res = fat_mutex_lock(skinny, fat);
			}

			if (res >= 0)
				return res;

			/* skinny_mutex value changed under us, try
			   again. */
		}
		else {
			/* Recapitulate skinny_mutex_lock */
			if (cas(&skinny->val, head, (void *)1))
				return 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1328
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1360
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x1318
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13c0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x1326
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1356
jmp 0x1351
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movl $0x1, %edx
lock
cmpxchgq %rdx, (%rcx)
movq %rax, %rcx
sete %al
testb $0x1, %al
jne 0x1346
jmp 0x134f
movl $0x0, -0x4(%rbp)
jmp 0x1356
jmp 0x1351
jmp 0x12cc
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/skinny_mutex.c
// Function: fat_mutex_lock
static int fat_mutex_lock(skinny_mutex_t *skinny, struct fat_mutex *fat)
{
	if (fat->held) {
		/* The mutex is already held, so we have to wait for
		 * it. */
		fat->waiters++;

		do {
			int res, old_state, old_state2;

			/* skinny_mutex_lock is not a cancellation
			   point, but pthread_cond_wait is, so we need
			   to defer cancellation around it. */
			assert(!pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
						       &old_state));
			res = pthread_cond_wait(&fat->held_cond, &fat->mutex);
			assert(!pthread_setcancelstate(old_state, &old_state2));

			if (res) {
				fat->waiters--;
				return recover(res,
					       fat_mutex_release(skinny, fat));
			}
		} while (fat->held);

		fat->waiters--;
	}

	fat->held = 1;
	return pthread_mutex_unlock(&fat->mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x1(%rax)
je 0x14c4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl $0x1, %edi
leaq -0x20(%rbp), %rsi
callq 0x1070
cmpl $0x0, %eax
jne 0x1403
jmp 0x1422
leaq 0x1bfa(%rip), %rdi      # 0x3004
leaq 0x1c2f(%rip), %rsi      # 0x3040
movl $0x1f1, %edx            # imm = 0x1F1
leaq 0x1c32(%rip), %rcx      # 0x304f
callq 0x10c0
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0x1060
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %edi
leaq -0x24(%rbp), %rsi
callq 0x1070
cmpl $0x0, %eax
jne 0x144d
jmp 0x146c
leaq 0x1c34(%rip), %rdi      # 0x3088
leaq 0x1be5(%rip), %rsi      # 0x3040
movl $0x1f3, %edx            # imm = 0x1F3
leaq 0x1be8(%rip), %rcx      # 0x304f
callq 0x10c0
cmpl $0x0, -0x1c(%rbp)
je 0x14a4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1970
movl -0x28(%rbp), %edi
movl %eax, %esi
callq 0x17e0
movl %eax, -0x4(%rbp)
jmp 0x14dc
jmp 0x14a6
movq -0x18(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0x13ee
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x1(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x1100
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/skinny_mutex.c
// Function: skinny_mutex_trylock
int skinny_mutex_trylock(skinny_mutex_t *skinny)
{
	for (;;) {
		struct common *head = skinny->val;
		struct fat_mutex *fat;
		int res;

		switch ((uintptr_t)head) {
		case 0:
			if (cas(&skinny->val, head, (void *)1))
				return 0;

			break;

		case 1:
			return EBUSY;

		default:
			res = fat_mutex_peg(skinny, head, &fat);
			if (res > 0)
				return res;
			else if (res < 0)
				/* skinny_mutex value changed under us, try
				   again. */
				break;

			res = EBUSY;
			if (!fat->held) {
				fat->held = 1;
				fat->refcount++;
				res = 0;
			}

			return recover(res,
				       pthread_mutex_unlock(&fat->mutex));
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x1522
jmp 0x1516
movq -0x30(%rbp), %rax
subq $0x1, %rax
je 0x1551
jmp 0x155d
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movl $0x1, %edx
lock
cmpxchgq %rdx, (%rcx)
movq %rax, %rcx
sete %al
testb $0x1, %al
jne 0x1540
jmp 0x154c
movl $0x0, -0x4(%rbp)
jmp 0x15e0
jmp 0x15db
movl $0x10, -0x4(%rbp)
jmp 0x15e0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x15f0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x157f
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15e0
cmpl $0x0, -0x24(%rbp)
jge 0x1587
jmp 0x15db
jmp 0x1589
movl $0x10, -0x24(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0x15b9
movq -0x20(%rbp), %rax
movb $0x1, 0x1(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x1100
movl -0x34(%rbp), %edi
movl %eax, %esi
callq 0x17e0
movl %eax, -0x4(%rbp)
jmp 0x15e0
jmp 0x14fc
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/skinny_mutex.c
// Function: recover
static int recover(int res1, int res2)
{
	if (res2 == 0)
		return res1;

	if (res1 == 0)
		return res2;

	fprintf(stderr,
		"skinny_mutex: got error %d while recovering from %d\n",
		res2, res1);
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x17fc
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x182d
cmpl $0x0, -0x8(%rbp)
jne 0x180a
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x182d
movq 0x37e7(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
movl -0x8(%rbp), %ecx
leaq 0x1897(%rip), %rsi      # 0x30b8
movb $0x0, %al
callq 0x10e0
callq 0x1040
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/skinny_mutex.c
// Function: skinny_mutex_unlock_slow
int skinny_mutex_unlock_slow(skinny_mutex_t *skinny)
{
	struct fat_mutex *fat;
	int res = fat_mutex_get_held(skinny, &fat);

	if (res)
		return res;

	fat->held = 0;
	res = 0;
	if (fat->waiters)
		/* Wake a single waiter. */
		res = pthread_cond_signal(&fat->held_cond);

	return recover(res, fat_mutex_release(skinny, fat));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x18c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x186a
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x18b4
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1894
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x10d0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1970
movl -0x20(%rbp), %edi
movl %eax, %esi
callq 0x17e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/skinny_mutex.c
// Function: fat_mutex_get_held
static int fat_mutex_get_held(skinny_mutex_t *skinny, struct fat_mutex **fatp)
{
	for (;;) {
		int res;
		struct common *head = skinny->val;
		if (!head)
			return EPERM;

		res = fat_mutex_get(skinny, head, fatp);
		if (res == 0) {
			if ((*fatp)->held)
				return 0;

			res = pthread_mutex_unlock(&(*fatp)->mutex);
			if (res)
				return res;

			return EPERM;
		}

		if (res >= 0)
			return res;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x18eb
movl $0x1, -0x4(%rbp)
jmp 0x1958
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1360
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x1945
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x1(%rax)
je 0x191b
movl $0x0, -0x4(%rbp)
jmp 0x1958
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq $0x18, %rdi
callq 0x1100
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x193c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1958
movl $0x1, -0x4(%rbp)
jmp 0x1958
cmpl $0x0, -0x1c(%rbp)
jl 0x1953
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1958
jmp 0x18d0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/skinny_mutex.c
// Function: fat_mutex_release
static int fat_mutex_release(skinny_mutex_t *skinny, struct fat_mutex *fat)
{
	int keep, res;

	assert(!fat->held);

	/* If the decremented refcount reaches zero, then we know
	   there are no secondary peg chains or other threads pinning
	   the fat_mutex.  And if the skinny_mutex points to the
	   fat_mutex, then we know that there are no pegs on the
	   primary chain either.  So if the CAS succeeds in nulling
	   out the skinny_mutex, we can free the fat_mutex. */
	keep = (--fat->refcount || !strict_cas(&skinny->val, fat, NULL));

	res = pthread_mutex_unlock(&fat->mutex);
	if (keep || res)
		return res;

	res = pthread_mutex_destroy(&fat->mutex);
	if (res)
		return res;

	res = pthread_cond_destroy(&fat->held_cond);
	if (res)
		return res;

	free(fat);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0x198c
jmp 0x19ab
leaq 0x175a(%rip), %rdi      # 0x30ed
leaq 0x16a6(%rip), %rsi      # 0x3040
movl $0x1c4, %edx            # imm = 0x1C4
leaq 0x1752(%rip), %rcx      # 0x30f8
callq 0x10c0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x21(%rbp)
jne 0x19e0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
xorl %edx, %edx
lock
cmpxchgq %rdx, (%rcx)
movq %rax, %rcx
sete %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x1100
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x1a07
cmpl $0x0, -0x20(%rbp)
je 0x1a0f
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a5b
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x1090
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x1a2d
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a5b
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x1160
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x1a4b
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1a5b
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/skinny_mutex.c
// Function: skinny_mutex_cond_timedwait
int skinny_mutex_cond_timedwait(pthread_cond_t *cond, skinny_mutex_t *skinny,
				const struct timespec *abstime)
{
	struct cond_wait_cleanup c;
	int res = fat_mutex_get_held(skinny, &c.fat);
	if (res)
		return res;

	/* We will release the lock, so wake a waiter */
	if (c.fat->waiters) {
		res = pthread_cond_signal(&c.fat->held_cond);
		if (res) {
			pthread_mutex_unlock(&c.fat->mutex);
			return res;
		}
	}

       /* Relinquish the mutex.  But we leave our reference accounted
          for in fat->refcount in place, in order to pin the
          fat_mutex. */
	c.fat->held = 0;

	/* pthread_cond_wait is a cancellation point */
	pthread_cleanup_push(cond_wait_cleanup, &c);

	if (!abstime)
		res = pthread_cond_wait(cond, &c.fat->mutex);
	else
		res = pthread_cond_timedwait(cond, &c.fat->mutex, abstime);

	pthread_cleanup_pop(1);
	return recover(res, c.lock_res);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
addq $0x8, %rsi
callq 0x18c0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x1aac
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1bb6
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1ae7
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0x10d0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x1ae5
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x1100
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1bb6
jmp 0x1ae7
movq -0x30(%rbp), %rax
movb $0x0, 0x1(%rax)
leaq 0xda(%rip), %rax        # 0x1bd0
movq %rax, -0xb8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
callq 0x1190
movl %eax, -0xc4(%rbp)
movslq -0xc4(%rbp), %rax
cmpq $0x0, %rax
je 0x1b45
movq -0xb8(%rbp), %rax
movq -0xc0(%rbp), %rdi
callq *%rax
leaq -0xb0(%rbp), %rdi
callq 0x1130
leaq -0xb0(%rbp), %rdi
callq 0x1170
cmpq $0x0, -0x20(%rbp)
jne 0x1b6e
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x18, %rsi
callq 0x1060
movl %eax, -0x3c(%rbp)
jmp 0x1b86
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x18, %rsi
movq -0x20(%rbp), %rdx
callq 0x1150
movl %eax, -0x3c(%rbp)
jmp 0x1b88
jmp 0x1b8a
jmp 0x1b8c
leaq -0xb0(%rbp), %rdi
callq 0x10a0
movq -0xb8(%rbp), %rax
movq -0xc0(%rbp), %rdi
callq *%rax
movl -0x3c(%rbp), %edi
movl -0x28(%rbp), %esi
callq 0x17e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/skinny_mutex.c
// Function: skinny_mutex_promote
static int skinny_mutex_promote(skinny_mutex_t *skinny, void *head,
				struct fat_mutex **fatp)
{
	int res = ENOMEM;
	struct fat_mutex *fat = malloc(sizeof *fat);
	*fatp = fat;
	if (!fat)
		goto err;

	fat->common.peg = 0;
	fat->held = !!head;
	/* If the skinny_mutex is held, then refcount needs to account
	   for the pseudo-reference from the holding thread. */
	fat->refcount = fat->held;
	fat->waiters = 0;

	res = pthread_mutex_init(&fat->mutex, NULL);
	if (res)
		goto err_mutex_init;

	res = pthread_cond_init(&fat->held_cond, NULL);
	if (res)
		goto err_cond_init;

	res = pthread_mutex_lock(&fat->mutex);
	if (res)
		goto err_mutex_lock;

	/* The fat_mutex is now ready, so try to make the skinny_mutex
	   point to it. */
	if (cas(&skinny->val, head, fat))
		return 0;

	res = -1;
	pthread_mutex_unlock(&fat->mutex);
 err_mutex_lock:
	pthread_cond_destroy(&fat->held_cond);
 err_cond_init:
	pthread_mutex_destroy(&fat->mutex);
 err_mutex_init:
	free(fat);
 err:
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xc, -0x24(%rbp)
movl $0x70, %edi
callq 0x1110
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x30(%rbp)
jne 0x1c80
jmp 0x1d6f
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x30(%rbp), %rax
movzbl 0x1(%rax), %eax
movl %eax, %ecx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11a0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x1cde
jmp 0x1d66
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10f0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x1cfa
jmp 0x1d59
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x11b0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x1d12
jmp 0x1d4c
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rdx
lock
cmpxchgq %rdx, (%rcx)
movq %rax, %rcx
sete %al
testb $0x1, %al
jne 0x1d2f
jmp 0x1d38
movl $0x0, -0x4(%rbp)
jmp 0x1d75
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x1100
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
callq 0x1160
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x1090
movq -0x30(%rbp), %rdi
callq 0x1030
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/skinny_mutex.c
// Function: atomic_sub_and_test
static int atomic_sub_and_test(uint8_t *ptr, uint8_t x)
{
#if defined(__i386__) || defined(__x86_64__)
	uint8_t res;
        __asm__ volatile ("lock subb %2,%0; setne %1"
			  : "+m" (*ptr), "=qm" (res)
			  : "ir" (x) : "memory");
	return res;
#else
	return __sync_sub_and_fetch(ptr, x);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb -0x9(%rbp), %cl
lock
subb %cl, (%rax)
setne -0xa(%rbp)
movzbl -0xa(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/perf.c
// Function: measure
static void measure(void (*test)(struct test_results *res),
		    const char *name, int reps)
{
	struct test_results res;
	long long times[SETS];
	int i;

	printf("Measuring %s: ", name);
	fflush(stdout);

	res.reps = reps;

	for (i = 0; i < SETS; i++) {
		test(&res);
		times[i] = res.stop - res.start;
	}

	qsort(times, SETS, sizeof(long long), cmp_long_long);
	printf("best %dns, 50%%ile %dns\n", (int)(times[0] * 1000 / reps),
	       (int)(times[SETS / 2] * 1000 / reps));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x1332(%rip), %rdi      # 0x3183
movb $0x0, %al
callq 0x1080
movq 0x3179(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1120
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x84(%rbp)
cmpl $0xa, -0x84(%rbp)
jge 0x1eac
leaq -0x30(%rbp), %rdi
callq *-0x8(%rbp)
movq -0x20(%rbp), %rcx
subq -0x28(%rbp), %rcx
movslq -0x84(%rbp), %rax
movq %rcx, -0x80(%rbp,%rax,8)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x1e77
leaq -0x80(%rbp), %rdi
movl $0xa, %esi
movl $0x8, %edx
leaq 0x73f(%rip), %rcx       # 0x2600
callq 0x1050
imulq $0x3e8, -0x80(%rbp), %rax # imm = 0x3E8
movslq -0x14(%rbp), %rcx
cqto
idivq %rcx
movl %eax, %esi
imulq $0x3e8, -0x58(%rbp), %rax # imm = 0x3E8
movslq -0x14(%rbp), %rcx
cqto
idivq %rcx
movl %eax, %edx
leaq 0x129f(%rip), %rdi      # 0x3192
movb $0x0, %al
callq 0x1080
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/perf.c
// Function: lock_unlock
static void lock_unlock(struct test_results *res)
{
	mutex_t mutex;
	int i;

	assert(!mutex_init(&mutex));

	res->start = now_usecs();

	for (i = res->reps; i--;) {
		assert(!mutex_lock(&mutex));
		assert(!mutex_unlock(&mutex));
	}

	res->stop = now_usecs();

	assert(!mutex_destroy(&mutex));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2660
cmpl $0x0, %eax
jne 0x1f2c
jmp 0x1f4b
leaq 0x1278(%rip), %rdi      # 0x31ab
leaq 0x1285(%rip), %rsi      # 0x31bf
movl $0x4d, %edx
leaq 0x1280(%rip), %rcx      # 0x31c6
callq 0x10c0
callq 0x2680
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x1fd4
leaq -0x10(%rbp), %rdi
callq 0x26d0
cmpl $0x0, %eax
jne 0x1f84
jmp 0x1fa3
leaq 0x1263(%rip), %rdi      # 0x31ee
leaq 0x122d(%rip), %rsi      # 0x31bf
movl $0x52, %edx
leaq 0x1228(%rip), %rcx      # 0x31c6
callq 0x10c0
leaq -0x10(%rbp), %rdi
callq 0x2720
cmpl $0x0, %eax
jne 0x1fb3
jmp 0x1fd2
leaq 0x1248(%rip), %rdi      # 0x3202
leaq 0x11fe(%rip), %rsi      # 0x31bf
movl $0x53, %edx
leaq 0x11f9(%rip), %rcx      # 0x31c6
callq 0x10c0
jmp 0x1f64
callq 0x2680
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq -0x10(%rbp), %rdi
callq 0x2770
cmpl $0x0, %eax
jne 0x1ff4
jmp 0x2013
leaq 0x121d(%rip), %rdi      # 0x3218
leaq 0x11bd(%rip), %rsi      # 0x31bf
movl $0x58, %edx
leaq 0x11b8(%rip), %rcx      # 0x31c6
callq 0x10c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dpw[P]skinny-mutex/perf.c
// Function: cmp_long_long
static int cmp_long_long(const void *ap, const void *bp)
{
	long long a = *(long long *)ap;
	long long b = *(long long *)bp;

	if (a < b)
		return -1;
	else if (a > b)
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x2635
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x264f
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x2648
movl $0x1, -0x4(%rbp)
jmp 0x264f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/futex1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	while (1) {
		unsigned int addr = 0;

		futex(&addr, FUTEX_WAKE, 1, NULL, NULL, 0);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0xca, %edi
leaq -0x14(%rbp), %rsi
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movl %ecx, %edx
movq %r9, %r8
movl $0x0, (%rsp)
movb $0x0, %al
callq 0x1150
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2020
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/futex4.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	while (1) {
		unsigned int addr = 0;

		futex(&addr, FUTEX_WAIT_PRIVATE, 1, NULL, NULL, 0);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0xca, %edi
leaq -0x14(%rbp), %rsi
movl $0x80, %edx
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movb $0x0, %al
callq 0x1150
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2020
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/filter/hipass.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;

    FILE *in,*out;
    RRA *h;

    argIndex = processOptions(argc,argv);

    if (argc-argIndex == 0)
        {
        in = stdin;
        out = stdout;
        }
    else if (argc-argIndex == 1)
        {
        in = OpenFile(argv[argIndex],"r");
        out = stdout;
        }
    else if (argc-argIndex == 2)
        {
        in = OpenFile(argv[argIndex],"r");
        out = OpenFile(argv[argIndex+1],"w");
        }
    else
        {
        fprintf(stderr,"usage: hipass -h -a<N.M> -w<N.M> -d<N.M> -l<N.M> "
            "[<input rra file> [<output rra file>]]\n");
        exit(-1);
        }

    h = newRRAHeader();
    
    readRRAHeader(in,h,0);

    if (h->channels != 1)
        Fatal("hipass requires a mono RRA file\n");

    writeRRAHeader(out,h,"modifiedBy: hipass",0);

    filterloop(in,out,h);

    fclose(in);
    fclose(out);

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1490
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x1368
movq 0x6c8a(%rip), %rax      # 0x7fd8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0x6c74(%rip), %rax      # 0x7fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x140f
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x1, %eax
jne 0x139f
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x4282(%rip), %rsi      # 0x5608
callq 0x1980
movq %rax, -0x20(%rbp)
movq 0x6c3a(%rip), %rax      # 0x7fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x140d
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x2, %eax
jne 0x13e9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x424b(%rip), %rsi      # 0x5608
callq 0x1980
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3cc3(%rip), %rsi      # 0x50a1
callq 0x1980
movq %rax, -0x28(%rbp)
jmp 0x140b
movq 0x6c08(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x3ca9(%rip), %rsi      # 0x50a3
movb $0x0, %al
callq 0x1110
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x11d0
jmp 0x140d
jmp 0x140f
callq 0x1e60
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2360
movq -0x30(%rbp), %rax
cmpl $0x1, (%rax)
je 0x1440
leaq 0x3cc3(%rip), %rdi      # 0x50fc
movb $0x0, %al
callq 0x1830
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0x3cce(%rip), %rdx      # 0x511d
xorl %eax, %eax
movl %eax, %ecx
callq 0x3300
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1630
movq -0x20(%rbp), %rdi
callq 0x1070
movq -0x28(%rbp), %rdi
callq 0x1070
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../util/getopt.c
// Function: reset
static void
reset(int argc, char * const argv[])
{
	const char * p;

	/* If we have arguments, stash argv[0] for error messages. */
	if (argc > 0) {
		/* Find the basename, without leading directories. */
		for (p = cmdname = argv[0]; *p != '\0'; p++) {
			if (*p == '/')
				cmdname = p + 1;
		}
	}

	/* Discard any registered command-line options. */
	free(opts);
	opts = NULL;

	/* Register atexit handler if we haven't done so already. */
	if (!atexit_registered) {
		atexit(getopt_atexit);
		atexit_registered = 1;
	}

	/* We will start scanning from the first option. */
	optind = 1;

	/* We're not in the middle of any packed options. */
	packedopts = NULL;

	/* We haven't found any option yet. */
	opt_found = (size_t)(-1);

	/* We're not initialized yet. */
	getopt_initialized = 0;

	/* Finished resetting state. */
	optreset = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x1e20
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x32ed(%rip)      # 0x50d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1e1e
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x1e0e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, 0x32c2(%rip)      # 0x50d0
jmp 0x1e10
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1de7
jmp 0x1e20
movq 0x32b1(%rip), %rdi      # 0x50d8
callq 0x1030
movq $0x0, 0x32a1(%rip) # 0x50d8
cmpl $0x0, 0x32aa(%rip)      # 0x50e8
jne 0x1e56
leaq 0x769(%rip), %rdi       # 0x25b0
callq 0x25d0
movl $0x1, 0x3292(%rip)      # 0x50e8
movl $0x1, 0x3218(%rip)      # 0x5078
movq $0x0, 0x323d(%rip) # 0x50a8
movq $-0x1, 0x3242(%rip) # 0x50b8
movl $0x0, 0x3220(%rip)      # 0x50a0
movl $0x0, 0x31f6(%rip)      # 0x5080
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../util/getopt.c
// Function: searchopt
static size_t
searchopt(const char * os)
{
	size_t i;

	/* Scan the array of options. */
	for (i = 0; i < nopts; i++) {
		/* Is there an option in this slot? */
		if (opts[i].os == NULL)
			continue;

		/* Does this match up to the length of the option string? */
		if (strncmp(opts[i].os, os, opts[i].olen))
			continue;

		/* Do we have <option>\0 or <option>= ? */
		if ((os[opts[i].olen] == '\0') || (os[opts[i].olen] == '='))
			return (i);
	}

	/* Not found. */
	return (opt_default);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x3231(%rip), %rax      # 0x50e0
jae 0x1f61
movq 0x321c(%rip), %rax      # 0x50d8
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x1ecf
jmp 0x1f50
movq 0x3202(%rip), %rax      # 0x50d8
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq 0x31ec(%rip), %rax      # 0x50d8
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
callq 0x1050
cmpl $0x0, %eax
je 0x1f04
jmp 0x1f50
movq -0x10(%rbp), %rax
movq 0x31c9(%rip), %rcx      # 0x50d8
imulq $0x18, -0x18(%rbp), %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1f44
movq -0x10(%rbp), %rax
movq 0x31a9(%rip), %rcx      # 0x50d8
imulq $0x18, -0x18(%rbp), %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0x1f4e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f6c
jmp 0x1f50
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1ea4
movq 0x3158(%rip), %rax      # 0x50c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../util/getopt.c
// Function: getopt_lookup
size_t
getopt_lookup(const char * os)
{

	/*
	 * We only take this parameter so that we can assert that it's the
	 * same option string as we returned from getopt(); as such, it is
	 * unused in the absence of assertions.
	 */
	(void)os; /* UNUSED */

	/* Can't reset here. */
	if (optreset)
		DIE("Can't reset in the middle of getopt loop");

	/* We should only be called after initialization is complete. */
	assert(getopt_initialized);

	/* GETOPT_DUMMY should never get passed back to us. */
	assert(os != GETOPT_DUMMY);

	/*
	 * Make sure the option passed back to us corresponds to the one we
	 * found earlier.
	 */
	assert((opt_found == opt_missing) || (opt_found == opt_default) ||
	    ((opt_found < nopts) && (strcmp(os, opts[opt_found].os) == 0)));

	/* Return the option number we identified earlier. */
	return (opt_found);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x30ed(%rip)      # 0x5080
je 0x1ff7
jmp 0x1f97
jmp 0x1f99
cmpq $0x0, 0x312f(%rip)      # 0x50d0
je 0x1fc2
movq 0x304e(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x311c(%rip), %rdx      # 0x50d0
leaq 0x1191(%rip), %rsi      # 0x314c
movb $0x0, %al
callq 0x1090
movq 0x302f(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x11d5(%rip), %rsi      # 0x31a8
movb $0x0, %al
callq 0x1090
movq 0x3017(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1157(%rip), %rsi      # 0x3142
movb $0x0, %al
callq 0x1090
callq 0x1040
cmpl $0x0, 0x30a2(%rip)      # 0x50a0
je 0x2002
jmp 0x2021
leaq 0x128b(%rip), %rdi      # 0x3294
leaq 0x11c1(%rip), %rsi      # 0x31d1
movl $0x113, %edx            # imm = 0x113
leaq 0x11c6(%rip), %rcx      # 0x31e2
callq 0x1070
movq -0x8(%rbp), %rax
cmpq 0x305c(%rip), %rax      # 0x5088
je 0x2030
jmp 0x204f
leaq 0x11ce(%rip), %rdi      # 0x3205
leaq 0x1193(%rip), %rsi      # 0x31d1
movl $0x116, %edx            # imm = 0x116
leaq 0x1198(%rip), %rcx      # 0x31e2
callq 0x1070
movq 0x3062(%rip), %rax      # 0x50b8
cmpq 0x306b(%rip), %rax      # 0x50c8
je 0x20a2
movq 0x3052(%rip), %rax      # 0x50b8
cmpq 0x3053(%rip), %rax      # 0x50c0
je 0x20a2
movq 0x3042(%rip), %rax      # 0x50b8
cmpq 0x3063(%rip), %rax      # 0x50e0
jae 0x20a4
movq -0x8(%rbp), %rdi
movq 0x304e(%rip), %rax      # 0x50d8
imulq $0x18, 0x3026(%rip), %rcx # 0x50b8
addq %rcx, %rax
movq (%rax), %rsi
callq 0x1080
cmpl $0x0, %eax
jne 0x20a4
jmp 0x20c3
leaq 0x116d(%rip), %rdi      # 0x3218
leaq 0x111f(%rip), %rsi      # 0x31d1
movl $0x11d, %edx            # imm = 0x11D
leaq 0x1124(%rip), %rcx      # 0x31e2
callq 0x1070
movq 0x2fee(%rip), %rax      # 0x50b8
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../util/getopt.c
// Function: getopt_register_missing
void
getopt_register_missing(size_t ln)
{

	/* Can't reset here. */
	if (optreset)
		DIE("Can't reset in the middle of getopt loop");

	/* We should only be called during initialization. */
	assert(!getopt_initialized);

	/* Record missing-argument value. */
	opt_missing = ln;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x2d0d(%rip)      # 0x5080
je 0x23d7
jmp 0x2377
jmp 0x2379
cmpq $0x0, 0x2d4f(%rip)      # 0x50d0
je 0x23a2
movq 0x2c6e(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x2d3c(%rip), %rdx      # 0x50d0
leaq 0xdb1(%rip), %rsi       # 0x314c
movb $0x0, %al
callq 0x1090
movq 0x2c4f(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xdf5(%rip), %rsi       # 0x31a8
movb $0x0, %al
callq 0x1090
movq 0x2c37(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xd77(%rip), %rsi       # 0x3142
movb $0x0, %al
callq 0x1090
callq 0x1040
cmpl $0x0, 0x2cc2(%rip)      # 0x50a0
jne 0x23e2
jmp 0x2401
leaq 0xeaa(%rip), %rdi       # 0x3293
leaq 0xde1(%rip), %rsi       # 0x31d1
movl $0x14d, %edx            # imm = 0x14D
leaq 0xf4d(%rip), %rcx       # 0x3349
callq 0x1070
movq -0x8(%rbp), %rax
movq %rax, 0x2cbc(%rip)      # 0x50c8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../util/getopt.c
// Function: getopt_setrange
void
getopt_setrange(size_t maxopts)
{
	size_t i;

	/* Can't reset here. */
	if (optreset)
		DIE("Can't reset in the middle of getopt loop");

	/* We should only be called during initialization. */
	assert(!getopt_initialized);

	/* Allocate space for (potential) options. */
	opts = malloc(maxopts * sizeof(struct opt));
	if ((maxopts > 0) && (opts == NULL))
		DIE("Failed to allocate memory in getopt");

	/* Initialize options. */
	for (i = 0; i < maxopts; i++)
		opts[i].os = NULL;

	/* Record the number of (potential) options. */
	nopts = maxopts;

	/* Record default missing-argument and no-such-option values. */
	opt_missing = opt_default = maxopts + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x2c4d(%rip)      # 0x5080
je 0x2497
jmp 0x2437
jmp 0x2439
cmpq $0x0, 0x2c8f(%rip)      # 0x50d0
je 0x2462
movq 0x2bae(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x2c7c(%rip), %rdx      # 0x50d0
leaq 0xcf1(%rip), %rsi       # 0x314c
movb $0x0, %al
callq 0x1090
movq 0x2b8f(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xd35(%rip), %rsi       # 0x31a8
movb $0x0, %al
callq 0x1090
movq 0x2b77(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xcb7(%rip), %rsi       # 0x3142
movb $0x0, %al
callq 0x1090
callq 0x1040
cmpl $0x0, 0x2c02(%rip)      # 0x50a0
jne 0x24a2
jmp 0x24c1
leaq 0xdea(%rip), %rdi       # 0x3293
leaq 0xd21(%rip), %rsi       # 0x31d1
movl $0x15e, %edx            # imm = 0x15E
leaq 0xeb2(%rip), %rcx       # 0x336e
callq 0x1070
imulq $0x18, -0x8(%rbp), %rdi
callq 0x10a0
movq %rax, 0x2c06(%rip)      # 0x50d8
cmpq $0x0, -0x8(%rbp)
jbe 0x2545
cmpq $0x0, 0x2bf7(%rip)      # 0x50d8
jne 0x2545
jmp 0x24e5
jmp 0x24e7
cmpq $0x0, 0x2be1(%rip)      # 0x50d0
je 0x2510
movq 0x2b00(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x2bce(%rip), %rdx      # 0x50d0
leaq 0xc43(%rip), %rsi       # 0x314c
movb $0x0, %al
callq 0x1090
movq 0x2ae1(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xe6a(%rip), %rsi       # 0x338b
movb $0x0, %al
callq 0x1090
movq 0x2ac9(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0xc09(%rip), %rsi       # 0x3142
movb $0x0, %al
callq 0x1090
callq 0x1040
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0x257b
movq 0x2b7a(%rip), %rax      # 0x50d8
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x254d
movq -0x8(%rbp), %rax
movq %rax, 0x2b5a(%rip)      # 0x50e0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, 0x2b2b(%rip)      # 0x50c0
movq %rax, 0x2b2c(%rip)      # 0x50c8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)