LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: trav_refresh
static void
trav_refresh (struct rb_traverser *trav)
{
  assert (trav != NULL);

  trav->rb_generation = trav->rb_table->rb_generation;

  if (trav->rb_node != NULL)
    {
      rb_comparison_func *cmp = trav->rb_table->rb_compare;
      void *param = trav->rb_table->rb_param;
      struct rb_node *node = trav->rb_node;
      struct rb_node *i;

      trav->rb_height = 0;
      for (i = trav->rb_table->rb_root; i != node; )
        {
          assert (trav->rb_height < RB_MAX_HEIGHT);
          assert (i != NULL);

          trav->rb_stack[trav->rb_height++] = i;
          i = i->rb_link[cmp (node->rb_data, i->rb_data, param) > 0];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2c35
jmp 0x2c54
leaq 0x14d2(%rip), %rdi      # 0x410e
leaq 0x13d1(%rip), %rsi      # 0x4014
movl $0x1b3, %edx            # imm = 0x1B3
leaq 0x1952(%rip), %rcx      # 0x45a1
callq 0x1040
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x198(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2d91
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x190(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x2d8f
movq -0x8(%rbp), %rax
cmpq $0x30, 0x190(%rax)
jae 0x2cde
jmp 0x2cfd
leaq 0x1471(%rip), %rdi      # 0x4156
leaq 0x1328(%rip), %rsi      # 0x4014
movl $0x1c1, %edx            # imm = 0x1C1
leaq 0x18a9(%rip), %rcx      # 0x45a1
callq 0x1040
cmpq $0x0, -0x28(%rbp)
je 0x2d06
jmp 0x2d25
leaq 0x18bd(%rip), %rdi      # 0x45ca
leaq 0x1300(%rip), %rsi      # 0x4014
movl $0x1c2, %edx            # imm = 0x1C2
leaq 0x1881(%rip), %rcx      # 0x45a1
callq 0x1040
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movq 0x190(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x190(%rsi)
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, %ecx
movq -0x30(%rbp), %rax
cmpl $0x0, %ecx
setg %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x2cc0
jmp 0x2d91
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: rb_t_replace
void *
rb_t_replace (struct rb_traverser *trav, void *new)
{
  void *old;

  assert (trav != NULL && trav->rb_node != NULL && new != NULL);
  old = trav->rb_node->rb_data;
  trav->rb_node->rb_data = new;
  return old;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x302b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x302b
cmpq $0x0, -0x10(%rbp)
je 0x302b
jmp 0x304a
leaq 0x1305(%rip), %rdi      # 0x4337
leaq 0xfdb(%rip), %rsi       # 0x4014
movl $0x2e0, %edx            # imm = 0x2E0
leaq 0x1327(%rip), %rcx      # 0x436c
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: copy_error_recovery
static void
copy_error_recovery (struct rb_node **stack, int height,
                     struct rb_table *new, rb_item_func *destroy)
{
  assert (stack != NULL && height >= 0 && new != NULL);

  for (; height > 2; height -= 2)
    stack[height - 1]->rb_link[1] = NULL;
  rb_destroy (new, destroy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x34cd
cmpl $0x0, -0xc(%rbp)
jl 0x34cd
cmpq $0x0, -0x18(%rbp)
je 0x34cd
jmp 0x34ec
leaq 0x1100(%rip), %rdi      # 0x45d4
leaq 0xb39(%rip), %rsi       # 0x4014
movl $0x2ed, %edx            # imm = 0x2ED
leaq 0x1119(%rip), %rcx      # 0x4600
callq 0x1040
jmp 0x34ee
cmpl $0x2, -0xc(%rbp)
jle 0x3518
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, 0x8(%rax)
movl -0xc(%rbp), %eax
subl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0x34ee
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3530
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb.c
// Function: rb_destroy
void
rb_destroy (struct rb_table *tree, rb_item_func *destroy)
{
  struct rb_node *p, *q;

  assert (tree != NULL);

  for (p = tree->rb_root; p != NULL; p = q)
    if (p->rb_link[0] == NULL)
      {
        q = p->rb_link[1];
        if (destroy != NULL && p->rb_data != NULL)
          destroy (p->rb_data, tree->rb_param);
        tree->rb_alloc->libavl_free (tree->rb_alloc, p);
      }
    else
      {
        q = p->rb_link[0];
        p->rb_link[0] = q->rb_link[1];
        q->rb_link[1] = p;
      }

  tree->rb_alloc->libavl_free (tree->rb_alloc, tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3549
jmp 0x3568
leaq 0xee8(%rip), %rdi       # 0x4438
leaq 0xabd(%rip), %rsi       # 0x4014
movl $0x361, %edx            # imm = 0x361
leaq 0xee2(%rip), %rcx       # 0x4445
callq 0x1040
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x360d
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x35d8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x35bc
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x35bc
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
jmp 0x35fe
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3600
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x3573
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x8(%rbp), %rsi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb-c.c
// Function: test_int
int test_int(int n)
{
	int i, cnt = 0;
	uint64_t x = 11;
	intmap_t *d, *r;
	struct rb_table *h;

	h = rb_create(int_cmp, 0, 0);
	for (i = 0; i < n; ++i) {
		unsigned y = x % (n>>1);
		x = kad_splitmix64(x);
		d = (intmap_t*)malloc(sizeof(intmap_t));
		d->key = y; d->value = i;
		if (rb_find(h, d) == 0) {
			rb_insert(h, d);
			++cnt;
		} else {
			r = rb_delete(h, d);
			free(d); free(r);
			--cnt;
		}
	}
	rb_destroy(h, 0);
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movq $0xb, -0x18(%rbp)
leaq -0x71(%rip), %rdi       # 0x3790
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1190
movq %rax, -0x30(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x38cf
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x38f0
movq %rax, -0x18(%rbp)
movl $0x8, %edi
callq 0x1070
movq %rax, -0x20(%rbp)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1260
cmpq $0x0, %rax
jne 0x3893
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1900
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x38bf
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x19d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x28(%rbp), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x38c1
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3818
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3530
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb-c.c
// Function: kad_splitmix64
static inline uint64_t kad_splitmix64(uint64_t x)
{
	uint64_t z = (x += 0x9E3779B97F4A7C15ULL);
	z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9ULL;
	z = (z ^ (z >> 27)) * 0x94D049BB133111EBULL;
	return z ^ (z >> 31);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movabsq $-0x61c8864680b583eb, %rax # imm = 0x9E3779B97F4A7C15
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x1e, %rcx
xorq %rcx, %rax
movabsq $-0x40a7b892e31b1a47, %rcx # imm = 0xBF58476D1CE4E5B9
imulq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x1b, %rcx
xorq %rcx, %rax
movabsq $-0x6b2fb644ecceee15, %rcx # imm = 0x94D049BB133111EB
imulq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x1f, %rcx
xorq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/attractivechaos[P]rb-eval/rb-c.c
// Function: main
int main(int argc, char *argv[])
{
	int n = 2000000;
	if (argc > 1) n = atoi(argv[1]);
	fprintf(stderr, "%d\n", test_int(n));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1e8480, -0x14(%rbp)  # imm = 0x1E8480
cmpl $0x1, -0x8(%rbp)
jle 0x39a3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1080
movl %eax, -0x14(%rbp)
movq 0x264e(%rip), %rax      # 0x5ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x37e0
movq -0x20(%rbp), %rdi
movl %eax, %edx
leaq 0xc8e(%rip), %rsi       # 0x4654
movb $0x0, %al
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sheheryarbutt[P]Ext2-File-System/ext2_utils.c
// Function: remove_trailing_slash
void remove_trailing_slash(char * path){
	char* absPath=path;
	char last_element[2]; last_element[1]='\0'; 
	last_element[0]=absPath[(unsigned int)strlen(absPath)-1];
	 if (strcmp(last_element, "/")==0 ){ // removes "/" from the end
    	int path_length=(unsigned int)strlen(absPath);
    	char temp_new_path[path_length]; strcpy(temp_new_path,absPath);
    	temp_new_path[path_length-1]='\0'; strcpy(absPath,temp_new_path);    
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x30(%rbp), %rax
subl $0x1, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x12(%rbp)
leaq -0x12(%rbp), %rdi
leaq 0xf7a(%rip), %rsi       # 0x3040
callq 0x1080
cmpl $0x0, %eax
jne 0x212b
movq -0x10(%rbp), %rdi
callq 0x1060
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rsp
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1050
movq -0x38(%rbp), %rsi
movl -0x18(%rbp), %eax
subl $0x1, %eax
cltq
movb $0x0, (%rsi,%rax)
movq -0x10(%rbp), %rdi
callq 0x1050
movq -0x20(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sheheryarbutt[P]Ext2-File-System/ext2_utils.c
// Function: all_names
char ** all_names(char *path, int * total_length){
	char *absPath=malloc((unsigned int)strlen(path) + 1);
	strcpy(absPath,path);
	char **names=malloc(256* sizeof(char*));
	remove_trailing_slash(absPath);

	int num_names=0;
	while((unsigned int)strlen(absPath)){
		unsigned int path_len=(unsigned int)strlen(absPath);
		char * temp_name=basename(absPath);
		unsigned int temp_name_len=(unsigned int) strlen(temp_name);
		names[num_names]=malloc(temp_name_len); strcpy(names[num_names],temp_name);
		absPath[path_len-(temp_name_len+1)]='\0';
		num_names++;
	}
	 *total_length=num_names;
	return names;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1050
movl $0x800, %edi            # imm = 0x800
callq 0x10d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2080
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
cmpl $0x0, %eax
je 0x2238
movq -0x18(%rbp), %rdi
callq 0x1060
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1060
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %edi
callq 0x10d0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x30(%rbp), %rsi
callq 0x1050
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movl -0x34(%rbp), %edx
addl $0x1, %edx
subl %edx, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x21b4
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheheryarbutt[P]Ext2-File-System/ext2_utils.c
// Function: set_avail_db
int set_avail_db(){

	unsigned int * bb=(unsigned int *)(disk + (EXT2_BLOCK_SIZE*3));			   

	int i;
	 //4= 128/32 because 128 is the total blocks and 32 bits is 4 bytes=unsigned int
	for (i=0; i<4; i++){
		int j=0;	
		while(j<32){
			
			if (!(bb[i]&(1<<j))){
				// updating to notify data block in now in use
				bb[i]|=(1<<j);
				sb->s_free_blocks_count-=1;
				gd->bg_free_blocks_count-=1;
				return (32*i)+(j+1);
			}
			
			j++;
		}
		
	}
	return -1;					   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2a9d(%rip), %rax      # 0x50a8
movq (%rax), %rax
addq $0xc00, %rax            # imm = 0xC00
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x26c5
movl $0x0, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jge 0x26b5
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x18(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x26a7
movl -0x18(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
leaq 0x2a3d(%rip), %rax      # 0x50b0
movq (%rax), %rax
movl 0xc(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0xc(%rax)
leaq 0x2a32(%rip), %rax      # 0x50b8
movq (%rax), %rax
movzwl 0xc(%rax), %ecx
subl $0x1, %ecx
movw %cx, 0xc(%rax)
movl -0x14(%rbp), %eax
shll $0x5, %eax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x26cc
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2630
jmp 0x26b7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x261f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheheryarbutt[P]Ext2-File-System/ext2_utils.c
// Function: set_avail_ib
int set_avail_ib(){

	unsigned int * ib = (unsigned int *)(disk+(EXT2_BLOCK_SIZE*4));
	int j=EXT2_GOOD_OLD_FIRST_INO-1;
	while(j<32){
			if (!(ib[0]&(1<<j))){
				// updating to notify inode in now in use
				ib[0]|=1<<j;
				sb->s_free_inodes_count-=1;
				gd->bg_free_inodes_count-=1;
				return j+1;
			}
			
			j++;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x29bd(%rip), %rax      # 0x50a8
movq (%rax), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x10(%rbp)
movl $0xa, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jge 0x2770
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x2765
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
leaq 0x2977(%rip), %rax      # 0x50b0
movq (%rax), %rax
movl 0x10(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x10(%rax)
leaq 0x296c(%rip), %rax      # 0x50b8
movq (%rax), %rax
movzwl 0xe(%rax), %ecx
subl $0x1, %ecx
movw %cx, 0xe(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2777
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x26ff
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sheheryarbutt[P]Ext2-File-System/ext2_utils.c
// Function: create_inode
void create_inode(int avail_ib,unsigned short mode,unsigned int size,unsigned short link_count,unsigned short blocks,unsigned int *block_pointers){
	time_t rawtime; // for setting creation time
	struct ext2_inode inode;
	inode.i_mode=mode;        
	inode.i_uid=0;        
	inode.i_size=size;     
	inode.i_ctime=(unsigned int)(time( &rawtime ));       /* Creation time */
	inode.i_dtime=0;
	inode.i_gid=0;        
	inode.i_links_count=link_count; 
	inode.i_blocks=blocks;    
	inode.osd1=0;        
	for (int i=0;i<15;i++){
		inode.i_block[i]=block_pointers[i];
	}     /* Pointers to blocks */
	free(block_pointers);

	inode.i_generation=0;  
	inode.i_file_acl=0;    
	inode.i_dir_acl=0;    
	inode.i_faddr=0;       
	inode_table[avail_ib-1]=inode;
	if ((mode & EXT2_S_IFDIR) == EXT2_S_IFDIR){
		gd->bg_used_dirs_count+=1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movw %r8w, %ax
movl %edi, -0x4(%rbp)
movw %si, -0x6(%rbp)
movl %edx, -0xc(%rbp)
movw %cx, -0xe(%rbp)
movw %ax, -0x10(%rbp)
movq %r9, -0x18(%rbp)
movw -0x6(%rbp), %ax
movw %ax, -0xa0(%rbp)
movw $0x0, -0x9e(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x9c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10c0
movl %eax, -0x94(%rbp)
movl $0x0, -0x8c(%rbp)
movw $0x0, -0x88(%rbp)
movw -0xe(%rbp), %ax
movw %ax, -0x86(%rbp)
movzwl -0x10(%rbp), %eax
movl %eax, -0x84(%rbp)
movl $0x0, -0x7c(%rbp)
movl $0x0, -0xa4(%rbp)
cmpl $0xf, -0xa4(%rbp)
jge 0x283d
movq -0x18(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movslq -0xa4(%rbp), %rax
movl %ecx, -0x78(%rbp,%rax,4)
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x280a
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x30(%rbp)
leaq 0x2857(%rip), %rax      # 0x50c0
movq (%rax), %rdi
movl -0x4(%rbp), %eax
subl $0x1, %eax
cltq
shlq $0x7, %rax
addq %rax, %rdi
leaq -0xa0(%rbp), %rsi
movl $0x80, %edx
callq 0x10a0
movzwl -0x6(%rbp), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x28b1
leaq 0x2815(%rip), %rax      # 0x50b8
movq (%rax), %rax
movzwl 0x10(%rax), %ecx
addl $0x1, %ecx
movw %cx, 0x10(%rax)
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sheheryarbutt[P]Ext2-File-System/ext2_utils.c
// Function: create_entry
void create_entry(int dbaddr,unsigned int inode, unsigned short rec_len, unsigned char name_len, unsigned char file_type, char* name){
	//store entry at dbaddr= data block address
	struct ext2_dir_entry* new_entry = (struct ext2_dir_entry *)(disk+dbaddr); 
	new_entry->inode=inode;
	new_entry->rec_len=rec_len;
	new_entry->name_len=name_len;
	new_entry->file_type=file_type;
	// store name after dir entry struct
	memcpy(disk+dbaddr + sizeof(struct ext2_dir_entry), name, name_len); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movw %dx, -0xa(%rbp)
movb %cl, -0xb(%rbp)
movb %al, -0xc(%rbp)
movq %r9, -0x18(%rbp)
leaq 0x27c2(%rip), %rax      # 0x50a8
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movw -0xa(%rbp), %cx
movq -0x20(%rbp), %rax
movw %cx, 0x4(%rax)
movb -0xb(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x6(%rax)
movb -0xc(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x7(%rax)
leaq 0x2784(%rip), %rax      # 0x50a8
movq (%rax), %rdi
movslq -0x4(%rbp), %rax
addq %rax, %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
movzbl -0xb(%rbp), %eax
movl %eax, %edx
callq 0x10a0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/prog.c
// Function: main
int main(int argc, char *argv[])
{
	int i, delay, pid;

	/*
	 * Print a number of messages,
	 * use a random delay, so that processes terminate
	 * in random order.
	 */

	pid = getpid();
	srand(pid);
	delay = 30 + ((double)rand() / RAND_MAX) * DELAY;
	printf("%s: Starting, NMSG = %d, delay = %d\n",
		argv[0], NMSG, delay);

	for (i = 0; i < NMSG; i++) {
		printf("%s[%d]: This is message %d\n", argv[0], pid, i);
		compute(delay);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1030
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x1080
callq 0x1110
cvtsi2sd %eax, %xmm0
movsd 0xdc1(%rip), %xmm1      # 0x2018
divsd %xmm1, %xmm0
movsd 0xda5(%rip), %xmm1      # 0x2008
mulsd %xmm1, %xmm0
movsd 0xda1(%rip), %xmm1      # 0x2010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x18(%rbp), %ecx
leaq 0xd95(%rip), %rdi       # 0x2020
movl $0x64, %edx
movb $0x0, %al
callq 0x1060
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0x12d2
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x1c(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0xd8d(%rip), %rdi       # 0x2045
movb $0x0, %al
callq 0x1060
movl -0x18(%rbp), %edi
callq 0x1300
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x129e
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: compute
void compute(int count)
{
	long i;
	volatile long junk;

	junk = 0;
	for (i = 0; i < count * 1000000; i++) {
		junk++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
imull $0xf4240, -0x4(%rbp), %ecx # imm = 0xF4240
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x1344
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1317
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: change_pname
void
change_pname(const char *new_name)
{
	int ret;
	ret = prctl(PR_SET_NAME, new_name);
	if (ret == -1){
		perror("prctl set_name");
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0xf, %edi
movb $0x0, %al
callq 0x10a0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x138b
leaq 0xce5(%rip), %rdi       # 0x2061
callq 0x10d0
movl $0x1, %edi
callq 0x10f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: explain_wait_status
void
explain_wait_status(pid_t pid, int status)
{
	if (WIFEXITED(status))
		fprintf(stderr, "My PID = %ld: Child PID = %ld terminated normally, exit status = %d\n",
			(long)getpid(), (long)pid, WEXITSTATUS(status));
	else if (WIFSIGNALED(status))
		fprintf(stderr, "My PID = %ld: Child PID = %ld was terminated by a signal, signo = %d\n",
			(long)getpid(), (long)pid, WTERMSIG(status));
	else if (WIFSTOPPED(status))
		fprintf(stderr, "My PID = %ld: Child PID = %ld has been stopped by a signal, signo = %d\n",
			(long)getpid(), (long)pid, WSTOPSIG(status));
	else {
		fprintf(stderr, "%s: Internal error: Unhandled case, PID = %ld, status = %d\n",
			__func__, (long)pid, status);
		exit(1);
	}
	fflush(stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x13f9
movq 0x2c38(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x1030
movq -0x10(%rbp), %rdi
movslq %eax, %rdx
movslq -0x4(%rbp), %rcx
movl -0x8(%rbp), %r8d
andl $0xff00, %r8d           # imm = 0xFF00
sarl $0x8, %r8d
leaq 0xc83(%rip), %rsi       # 0x2070
movb $0x0, %al
callq 0x1090
jmp 0x14c1
movl -0x8(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x1442
movq 0x2be5(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x1030
movq -0x18(%rbp), %rdi
movslq %eax, %rdx
movslq -0x4(%rbp), %rcx
movl -0x8(%rbp), %r8d
andl $0x7f, %r8d
leaq 0xc7c(%rip), %rsi       # 0x20b5
movb $0x0, %al
callq 0x1090
jmp 0x14bf
movl -0x8(%rbp), %eax
andl $0xff, %eax
cmpl $0x7f, %eax
jne 0x148c
movq 0x2ba2(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x1030
movq -0x20(%rbp), %rdi
movslq %eax, %rdx
movslq -0x4(%rbp), %rcx
movl -0x8(%rbp), %r8d
andl $0xff00, %r8d           # imm = 0xFF00
sarl $0x8, %r8d
leaq 0xc78(%rip), %rsi       # 0x20fb
movb $0x0, %al
callq 0x1090
jmp 0x14bd
movq 0x2b65(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movslq -0x4(%rbp), %rcx
movl -0x8(%rbp), %r8d
leaq 0xc9e(%rip), %rsi       # 0x2143
leaq 0xcd3(%rip), %rdx       # 0x217f
movb $0x0, %al
callq 0x1090
movl $0x1, %edi
callq 0x10f0
jmp 0x14bf
jmp 0x14c1
movq 0x2b30(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: wait_for_ready_children
void
wait_for_ready_children(int cnt)
{
	int i;
	pid_t p;
	int status;

	for (i = 0; i < cnt; i++) {
		/* Wait for any child, also get status for stopped children */
		p = waitpid(-1, &status, WUNTRACED);
		explain_wait_status(p, status);
		if (!WIFSTOPPED(status)) {
			fprintf(stderr, "Parent: Child with PID %ld has died unexpectedly!\n",
				(long)p);
			exit(1);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x155b
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
leaq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x10c0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x13a0
movl -0x10(%rbp), %eax
andl $0xff, %eax
cmpl $0x7f, %eax
je 0x154e
movq 0x2ac9(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movslq -0xc(%rbp), %rdx
leaq 0xc56(%rip), %rsi       # 0x2193
movb $0x0, %al
callq 0x1090
movl $0x1, %edi
callq 0x10f0
jmp 0x1550
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x14f2
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: show_pstree
void
show_pstree(pid_t p)
{
	int ret;
	char cmd[1024];

	snprintf(cmd, sizeof(cmd), "echo; echo; pstree -G -c -p %ld; echo; echo",
		(long)p);
	cmd[sizeof(cmd)-1] = '\0';
	ret = system(cmd);
	if (ret < 0) {
		perror("system");
		exit(104);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movl %edi, -0x4(%rbp)
leaq -0x410(%rbp), %rdi
movslq -0x4(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
leaq 0xc31(%rip), %rdx       # 0x21c6
movb $0x0, %al
callq 0x1070
movb $0x0, -0x11(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x1050
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x15cb
leaq 0xc36(%rip), %rdi       # 0x21f2
callq 0x10d0
movl $0x68, %edi
callq 0x10f0
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/proc-common.c
// Function: create_shared_memory_area
void *create_shared_memory_area(unsigned int numbytes)
{
	int pages;
	void *addr;

	if (numbytes == 0) {
		fprintf(stderr, "%s: internal error: called for numbytes == 0\n", __func__);
		exit(1);
	}

	/* Determine the number of pages needed, round up the requested number of pages */
	pages = (numbytes - 1) / sysconf(_SC_PAGE_SIZE) + 1;

	/* Create a shared, anonymous mapping for this number of pages */
	addr = mmap(NULL, pages * sysconf(_SC_PAGE_SIZE),
		PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
	if (addr == MAP_FAILED) {
		perror("create_shared_memory_area: mmap failed");
		exit(1);
	}

	return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x161a
movq 0x2a00(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xbf7(%rip), %rsi       # 0x21f9
leaq 0xc1e(%rip), %rdx       # 0x2227
movb $0x0, %al
callq 0x1090
movl $0x1, %edi
callq 0x10f0
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movl $0x1e, %edi
callq 0x10e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cqto
idivq %rcx
addq $0x1, %rax
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1e, %edi
callq 0x10e0
movq -0x18(%rbp), %rsi
imulq %rax, %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x21, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x1040
movq %rax, -0x10(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x10(%rbp)
jne 0x16a1
leaq 0xbaf(%rip), %rdi       # 0x2241
callq 0x10d0
movl $0x1, %edi
callq 0x10f0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/tlb_flush1.c
// Function: testcase
void testcase(unsigned long *iteration, unsigned long nr)
{
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkstemp(tmpfile);
	unsigned long offset = 0;
	unsigned long pgsize = getpagesize();
	assert(fd >= 0);
	assert(ftruncate(fd, FILESIZE) == 0);
	unlink(tmpfile);
	unsigned long i;

	while (1) {
		char *addr = mmap(NULL, FILESIZE, PROT_READ|PROT_WRITE,
						MAP_PRIVATE, fd, offset);
		for (i = 0; i < FILESIZE; i += pgsize) {
			*(addr + i) = 1;
			madvise(addr + i, pgsize, MADV_DONTNEED);
			assert(*(addr + i) == 0);
			(*iteration)++;
		}
		munmap(addr, FILESIZE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1339(%rip), %rax      # 0x4310
movq %rax, -0x30(%rbp)
movq 0x1336(%rip), %rax      # 0x4318
movq %rax, -0x28(%rbp)
movq 0x1333(%rip), %rax      # 0x4320
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x21b0
movl %eax, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
callq 0x2270
cltq
movq %rax, -0x48(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x3018
jmp 0x3037
leaq 0x1274(%rip), %rdi      # 0x4293
leaq 0x1275(%rip), %rsi      # 0x429b
movl $0x16, %edx
leaq 0x127c(%rip), %rcx      # 0x42ae
callq 0x2110
movl -0x34(%rbp), %edi
movl $0x8000000, %esi        # imm = 0x8000000
callq 0x2100
cmpl $0x0, %eax
jne 0x304b
jmp 0x306a
leaq 0x128a(%rip), %rdi      # 0x42dc
leaq 0x1242(%rip), %rsi      # 0x429b
movl $0x17, %edx
leaq 0x1249(%rip), %rcx      # 0x42ae
callq 0x2110
leaq -0x30(%rbp), %rdi
callq 0x2080
movl -0x34(%rbp), %r8d
movq -0x40(%rbp), %r9
xorl %eax, %eax
movl %eax, %edi
movl $0x8000000, %esi        # imm = 0x8000000
movl $0x3, %edx
movl $0x2, %ecx
callq 0x20d0
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
cmpq $0x8000000, -0x50(%rbp) # imm = 0x8000000
jae 0x3119
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movq -0x58(%rbp), %rdi
addq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x4, %edx
callq 0x21f0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x30de
jmp 0x30fd
leaq 0x1214(%rip), %rdi      # 0x42f9
leaq 0x11af(%rip), %rsi      # 0x429b
movl $0x21, %edx
leaq 0x11b6(%rip), %rcx      # 0x42ae
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x309f
movq -0x58(%rbp), %rdi
movl $0x8000000, %esi        # imm = 0x8000000
callq 0x21c0
jmp 0x3073
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/bulk_update/main.c
// Function: main
int
main(int argc, char * argv[])
{
	struct sock_addr ** sas;
	int s;
	struct wire_requestqueue * Q;

	WARNP_INIT;

	/* Check number of arguments. */
	if (argc != 2) {
		fprintf(stderr, "usage: bulk_update %s\n", "<socketname>");
		exit(1);
	}

	/* Resolve the socket address and connect. */
	if ((sas = sock_resolve(argv[1])) == NULL) {
		warnp("Error resolving socket address: %s", argv[1]);
		exit(1);
	}
	if (sas[0] == NULL) {
		warn0("No addresses found for %s", argv[1]);
		exit(1);
	}
	if ((s = sock_connect(sas)) == -1)
		exit(1);

	/* Create a request queue. */
	if ((Q = wire_requestqueue_init(s)) == NULL) {
		warnp("Cannot create packet write queue");
		exit(1);
	}

	/* Start bulk updating. */
	if (bulkupdate(Q, stdin))
		exit(1);

	/* Free the request queue. */
	wire_requestqueue_destroy(Q);
	wire_requestqueue_free(Q);

	/* Free socket addresses. */
	sock_addr_freelist(sas);

	/* Success! */
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x248c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6700
jmp 0x248e
cmpl $0x2, -0x8(%rbp)
je 0x24bd
movq 0x12b5d(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xcb5f(%rip), %rsi      # 0xf004
leaq 0xcb6f(%rip), %rdx      # 0xf01b
movb $0x0, %al
callq 0x2200
movl $0x1, %edi
callq 0x22f0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4b50
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2525
jmp 0x24d6
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2503
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xcb39(%rip), %rdi      # 0xf028
movb $0x0, %al
callq 0x67c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2519
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xcb16(%rip), %rdi      # 0xf028
movb $0x0, %al
callq 0x6a10
jmp 0x251b
movl $0x1, %edi
callq 0x22f0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x255c
jmp 0x2531
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xcb0b(%rip), %rdi      # 0xf04b
movb $0x0, %al
callq 0x6a10
callq 0x20a0
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x22f0
movq -0x18(%rbp), %rdi
callq 0x5a20
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x2577
movl $0x1, %edi
callq 0x22f0
movl -0x1c(%rbp), %edi
callq 0x92d0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x25ca
jmp 0x258b
callq 0x20a0
cmpl $0x0, (%rax)
je 0x25b0
leaq 0xcac9(%rip), %rdi      # 0xf065
movb $0x0, %al
callq 0x67c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x25be
leaq 0xcaae(%rip), %rdi      # 0xf065
movb $0x0, %al
callq 0x6a10
jmp 0x25c0
movl $0x1, %edi
callq 0x22f0
movq -0x28(%rbp), %rdi
movq 0x12a03(%rip), %rax     # 0x14fd8
movq (%rax), %rsi
callq 0x2610
cmpl $0x0, %eax
je 0x25ec
movl $0x1, %edi
callq 0x22f0
movq -0x28(%rbp), %rdi
callq 0x98a0
movq -0x28(%rbp), %rdi
callq 0x98e0
movq -0x18(%rbp), %rdi
callq 0x5780
xorl %edi, %edi
callq 0x22f0
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/bulk_update/main.c
// Function: bulkupdate
static int
bulkupdate(struct wire_requestqueue * Q, FILE * f)
{
	struct bulkupdate_state C;
	uint8_t buf[40];	/* dummy */

	/* Initialize. */
	C.Q = Q;
	C.f = f;
	C.Nip = 0;
	C.generation = 0;
	C.failed = 0;
	C.done = 0;

	/* Allocate key and value structures. */
	memset(buf, 0, 40);
	if ((C.key = kvldskey_create(buf, 40)) == NULL)
		goto err0;
	if ((C.val = kvldskey_create(buf, 40)) == NULL)
		goto err1;

	/* Prepare benchmark time handling. */
	if ((C.B = bench_init(BENCHMARK_START, BENCHMARK_SECONDS)) == NULL) {
		warn0("bench_init");
		goto err2;
	}

	/* Send an initial batch of 4096 requests. */
	if (sendbatch(&C))
		goto err3;

	/* Wait until we've finished. */
	if (events_spin(&C.done) || C.failed) {
		warnp("SET request failed");
		goto err3;
	}

	/* Print median number of updates performed in a single second. */
	printf("%" PRIu64 "\n", bench_median(C.B));

	/* Free the key and value structures. */
	bench_free(C.B);
	kvldskey_free(C.val);
	kvldskey_free(C.key);

	/* Success! */
	return (0);

err3:
	bench_free(C.B);
err2:
	kvldskey_free(C.val);
err1:
	kvldskey_free(C.key);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x38(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x21b0
leaq -0x80(%rbp), %rdi
movl $0x28, %esi
callq 0x7220
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x267d
jmp 0x2790
leaq -0x80(%rbp), %rdi
movl $0x28, %esi
callq 0x7220
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x269a
jmp 0x2787
movl $0x32, %edi
movl $0xa, %esi
callq 0x6c50
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x26d3
jmp 0x26b5
leaq 0xc9ca(%rip), %rdi      # 0xf086
movb $0x0, %al
callq 0x6a10
callq 0x20a0
movl $0x0, (%rax)
jmp 0x277e
leaq -0x58(%rbp), %rdi
callq 0x27b0
cmpl $0x0, %eax
je 0x26e6
jmp 0x2775
leaq -0x58(%rbp), %rdi
addq $0x20, %rdi
callq 0x2c50
cmpl $0x0, %eax
jne 0x26fe
cmpl $0x0, -0x3c(%rbp)
je 0x2737
jmp 0x2700
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2725
leaq 0xc980(%rip), %rdi      # 0xf091
movb $0x0, %al
callq 0x67c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2733
leaq 0xc965(%rip), %rdi      # 0xf091
movb $0x0, %al
callq 0x6a10
jmp 0x2735
jmp 0x2775
movq -0x20(%rbp), %rdi
callq 0x70c0
movq %rax, %rsi
leaq 0xc95a(%rip), %rdi      # 0xf0a4
movb $0x0, %al
callq 0x2160
movq -0x20(%rbp), %rdi
callq 0x71e0
movq -0x28(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
jmp 0x2797
movq -0x20(%rbp), %rdi
callq 0x71e0
movq -0x28(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/bulk_update/main.c
// Function: sendbatch
static int
sendbatch(struct bulkupdate_state * C)
{

	while (C->Nip < 4096) {
		/* Try to read a key-value pair. */
		if (fread(C->key->buf, 40, 1, C->f) < 1) {
			C->generation++;
			rewind(C->f);
			continue;
		}
		if (fread(C->val->buf, 40, 1, C->f) < 1) {
			C->generation++;
			rewind(C->f);
			continue;
		}

		/* Create a new (somewhat arbitrary) value to record. */
		C->val->buf[39] += C->generation;

		/* Send the request. */
		if (proto_kvlds_request_set(C->Q, C->key, C->val,
		    callback_done, C))
			goto err0;
		C->Nip += 1;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1000, 0x10(%rax)     # imm = 0x1000
jae 0x28b6
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x28, %esi
movl $0x1, %edx
callq 0x20d0
cmpq $0x1, %rax
jae 0x2813
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2170
jmp 0x27bc
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x28, %esi
movl $0x1, %edx
callq 0x20d0
cmpq $0x1, %rax
jae 0x285b
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2170
jmp 0x27bc
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movzbl 0x28(%rax), %ecx
addl %edx, %ecx
movb %cl, 0x28(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %r8
leaq 0x3b(%rip), %rcx        # 0x28d0
callq 0x7670
cmpl $0x0, %eax
je 0x28a1
jmp 0x28bf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x27bc
movl $0x0, -0x4(%rbp)
jmp 0x28c6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/bench/bulk_update/main.c
// Function: callback_done
static int
callback_done(void * cookie, int failed)
{
	struct bulkupdate_state * C = cookie;

	/* This request is no longer in progress. */
	C->Nip -= 1;

	/* Did we fail? */
	if (failed) {
		C->done = 1;
		C->failed = 1;
	}

	/* Notify the benchmarking code, and check if we should quit. */
	if (bench_tick(C->B, &C->done)) {
		warnp("bench_tick");
		goto err0;
	}

	/* Send more requests if possible. */
	if ((!C->done) && sendbatch(C))
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x10(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x2913
movq -0x20(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x1c(%rax)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
callq 0x6e50
cmpl $0x0, %eax
je 0x2966
jmp 0x292f
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2954
leaq 0xc769(%rip), %rdi      # 0xf0a9
movb $0x0, %al
callq 0x67c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2962
leaq 0xc74e(%rip), %rdi      # 0xf0a9
movb $0x0, %al
callq 0x6a10
jmp 0x2964
jmp 0x2989
movq -0x20(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x2980
movq -0x20(%rbp), %rdi
callq 0x27b0
cmpl $0x0, %eax
je 0x2980
jmp 0x2989
movl $0x0, -0x4(%rbp)
jmp 0x2990
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/bench/bench.c
// Function: bench_tick
int
bench_tick(struct bench * B, int * done)
{
	struct timeval tv_now;

	/* Get current time. */
	if (monoclock_get(&tv_now)) {
		warnp("monoclock_get");
		goto err0;
	}

	/* Are we still waiting to start recording ticks? */
	if (B->started == 0) {
		/* Bail if it's not time to start counting items. */
		if (tv_cmp(tv_now, B->tv_start) < 0)
			goto done;

		/* Start recording ticks. */
		B->started = 1;

		/* Start tracking seconds. */
		B->tv_end.tv_sec = tv_now.tv_sec + 1;
		B->tv_end.tv_usec = tv_now.tv_usec;
	}

	/* Have we finished a second? */
	if (tv_cmp(tv_now, B->tv_end) > 0) {
		/* Prepare to record in a new position. */
		B->tick_pos++;

		/* Have we run out of seconds to record? */
		if (B->tick_pos >= B->num_seconds) {
			*done = 1;
			goto done;
		}

		/* Set up the next second. */
		B->tv_end.tv_sec = tv_now.tv_sec + 1;
		B->tv_end.tv_usec = tv_now.tv_usec;
	}

	/* Record value in the current position. */
	B->ticks[B->tick_pos]++;

done:
	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4830
cmpl $0x0, %eax
je 0x6eaa
jmp 0x6e70
callq 0x20a0
cmpl $0x0, (%rax)
je 0x6e95
leaq 0x8a04(%rip), %rdi      # 0xf885
movb $0x0, %al
callq 0x67c0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x6ea3
leaq 0x89e9(%rip), %rdi      # 0xf885
movb $0x0, %al
callq 0x6a10
jmp 0x6ea5
jmp 0x6f8a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x6efe
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x20(%rax), %rdx
movq 0x28(%rax), %rcx
callq 0x6fa0
cmpl $0x0, %eax
jge 0x6ed7
jmp 0x6f81
movq -0x10(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq 0x30(%rax), %rdx
movq 0x38(%rax), %rcx
callq 0x6fa0
cmpl $0x0, %eax
jle 0x6f65
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x6f49
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x6f81
movq -0x28(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
jmp 0x6f91
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/bench/bench.c
// Function: tv_cmp
static int
tv_cmp(const struct timeval a, const struct timeval b)
{

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x6fc7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7007
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x6fda
movl $0x1, -0x4(%rbp)
jmp 0x7007
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x6fed
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7007
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x7000
movl $0x1, -0x4(%rbp)
jmp 0x7007
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/liball/../lib/bench/bench.c
// Function: bench_mean
uint64_t
bench_mean(struct bench * B)
{
	size_t i;
	uint64_t sum = 0;

	/* Sanity check. */
	assert(B->num_seconds > 0);

	/* Calculate sum. */
	for (i = 0; i < B->num_seconds; i++)
		sum += B->ticks[i];

	/* Return the mean. */
	return (sum / B->num_seconds);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x7050
jmp 0x706f
leaq 0x883c(%rip), %rdi      # 0xf893
leaq 0x87e2(%rip), %rsi      # 0xf840
movl $0xb8, %edx
leaq 0x883c(%rip), %rcx      # 0xf8a6
callq 0x21a0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x70aa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7077
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq (%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)