LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/UCLA-StarAI[P]TrimBN/src/trim/search.c
// Function: compute_maa_with_sdd
void compute_maa_with_sdd(SearchData* data, SearchResult* result, SddNode** node, SddManager* manager,
  char* subset, int feature_to_remove, int y_size, SddWmc* maa, SddWmc* bound, int move_only) {
  // Move feature_to_remove to left child of Y-constrained node
  Feature* feature = data->features[feature_to_remove];
  *node = sdd_move_feature_to_pos(*node, manager, feature->indicators,
                                  feature->num_indicators, y_size+1, 0); // need to move to y_size+1 since moving down

  Vtree* vtree = sdd_manager_vtree(manager);
  SddLiteral y_vtree, xy_vtree;   
  update_constrained_positions(vtree, y_size, data->num_features, &y_vtree, &xy_vtree);

  if (move_only) return;

  // Compute E-SDP
  EsdpManager* e_manager = esdp_manager_new(*node, manager, data->literal_weights);  
  *bound = compute_mpa(e_manager, data->decision, data->threshold, xy_vtree, y_vtree, maa);

  esdp_manager_free(e_manager);
}

// Assembly:
subq $0x58, %rsp
movl 0x78(%rsp), %eax
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movl 0x60(%rsp), %eax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
movq 0x50(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movl 0x60(%rsp), %r8d
addl $0x1, %r8d
xorl %r9d, %r9d
callq 0x3b00
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rdi
callq 0x7820
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl 0x60(%rsp), %esi
movq 0x50(%rsp), %rax
movq 0x20(%rax), %rax
movl %eax, %edx
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x3c40
cmpl $0x0, 0x78(%rsp)
je 0x3df0
jmp 0x3e4c
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0xf280
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x50(%rsp), %rax
movsd 0x30(%rax), %xmm0
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x68(%rsp), %r8
callq 0xf660
movq 0x70(%rsp), %rax
movsd %xmm0, (%rax)
movq (%rsp), %rdi
callq 0xf330
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/UCLA-StarAI[P]TrimBN/src/trim/search.c
// Function: cmp_by_bound_inc
static inline
int cmp_by_bound_inc(const void* n1, const void* n2) {
  const SddWmc s1 = (*((const SddWmc**) n1))[1];
  const SddWmc s2 = (*((const SddWmc**) n2))[1];
  SddWmc diff = s1 - s2;
  if (fabs(diff) < DBL_EPSILON) return 0;
  return (diff > 0) ? 1 : -1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x20(%rsp), %xmm0
subsd -0x28(%rsp), %xmm0
movsd %xmm0, -0x30(%rsp)
movsd -0x30(%rsp), %xmm1
movaps 0x1f931(%rip), %xmm0    # 0x24210
pand %xmm0, %xmm1
movsd 0x1f915(%rip), %xmm0    # 0x24200
ucomisd %xmm1, %xmm0
jbe 0x48fb
movl $0x0, -0x4(%rsp)
jmp 0x4919
movsd -0x30(%rsp), %xmm0
xorps %xmm1, %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
ucomisd %xmm1, %xmm0
cmoval %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/UCLA-StarAI[P]TrimBN/src/trim/utils.c
// Function: bsearch_locate
int bsearch_locate(char** sorted_arr, const int n, const char* str) {
  int mid = n / 2;
  int cmp = strcmp(str, sorted_arr[mid]);
  
  if (n == 0 || (n == 1 && cmp != 0)) {
    return -1;
  }

  if (cmp == 0) {
    return mid;
  } else if (cmp < 0) {
    return bsearch_locate(sorted_arr, mid, str);
  } else {
    return mid + bsearch_locate(sorted_arr+mid, n-mid, str);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl 0x24(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2120
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x5113
cmpl $0x1, 0x24(%rsp)
jne 0x511d
cmpl $0x0, 0x10(%rsp)
je 0x511d
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x5185
cmpl $0x0, 0x10(%rsp)
jne 0x512e
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x5185
cmpl $0x0, 0x10(%rsp)
jge 0x514e
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x50c0
movl %eax, 0x34(%rsp)
jmp 0x5185
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x14(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl 0x24(%rsp), %esi
subl 0x14(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x50c0
movl %eax, %ecx
movl 0xc(%rsp), %eax
addl %ecx, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/UCLA-StarAI[P]TrimBN/src/trim/utils.c
// Function: free_search_data
void free_search_data(SearchData* data) {
  for (int i = 0; i < data->num_features; i++) {
    free(data->features[i]->indicators);
    free(data->features[i]);
  }
  free(data->features);
  free(data->literal_weights - data->var_count);
  free(data->costs);
  free(data);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x5caf
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x2030
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5c61
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x2030
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rcx
xorl %eax, %eax
subq (%rcx), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x2030
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x2030
movq 0x10(%rsp), %rdi
callq 0x2030
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/UCLA-StarAI[P]TrimBN/src/trim/utils.c
// Function: print_search_data
void print_search_data(SearchData* data) {
  printf("num_features: %"PRIsS", threshold: %.2f, budget: %.2f\n",
         data->num_features, data->threshold, data->budget);
  for (int i = 0; i < data->num_features; i++) {
    printf("Feature %d: %d indicators ", i, data->features[i]->num_indicators);
    for (int j = 0; j < data->features[i]->num_indicators; j++) {
      printf("%d,", data->features[i]->indicators[j]);
    }
    printf("\n");
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x10(%rsp), %rax
movsd 0x30(%rax), %xmm0
movq 0x10(%rsp), %rax
movss 0x38(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x1e60a(%rip), %rdi     # 0x2433b
movb $0x2, %al
callq 0x20c0
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x5df8
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdx
leaq 0x1e5f8(%rip), %rdi     # 0x2436d
movb $0x0, %al
callq 0x20c0
movl $0x0, 0x8(%rsp)
movslq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x28(%rcx), %rcx
movslq 0xc(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq 0x8(%rcx), %rax
jae 0x5dda
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x1e354(%rip), %rdi     # 0x2411a
movb $0x0, %al
callq 0x20c0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5d84
leaq 0x1e480(%rip), %rdi     # 0x24261
movb $0x0, %al
callq 0x20c0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5d40
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/UCLA-StarAI[P]TrimBN/src/trim/utils.c
// Function: new_search_result
SearchResult* new_search_result(const SddSize num_features) {
  SearchResult* result =
      (SearchResult*) malloc(sizeof(SearchResult));
  result->best_score = 0;
  result->best_subset = (char*) malloc(num_features * sizeof(char));
  result->cost = 0;
  return result;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rdi
shlq $0x0, %rdi
callq 0x2190
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/UCLA-StarAI[P]TrimBN/src/trim/utils.c
// Function: update_search_result
void update_search_result(SearchResult* result, const SddWmc new_score,
    const float new_cost, const char* new_subset, const SddSize num_features) {
  result->best_score = new_score;
  result->cost = new_cost;
  for (int i = 0; i < num_features; i++) {
    result->best_subset[i] = new_subset[i];
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movss %xmm1, -0x14(%rsp)
movq %rsi, -0x20(%rsp)
movq %rdx, -0x28(%rsp)
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, (%rax)
movss -0x14(%rsp), %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, 0x10(%rax)
movl $0x0, -0x2c(%rsp)
movslq -0x2c(%rsp), %rax
cmpq -0x28(%rsp), %rax
jae 0x5f09
movq -0x20(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x5ed2
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/tabix.c
// Function: error_errno
static void HTS_FORMAT(HTS_PRINTF_FMT, 1, 2) HTS_NORETURN
error_errno(const char *format, ...)
{
    va_list ap;
    int eno = errno;
    fflush(stdout);
    if (format) {
        va_start(ap, format);
        vfprintf(stderr, format, ap);
        va_end(ap);
    }
    if (eno) {
        fprintf(stderr, "%s%s\n", format ? ": " : "", strerror(eno));
    } else {
        fprintf(stderr, "\n");
    }
    fflush(stderr);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x5e78
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x4050
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq 0x1270f8(%rip), %rax    # 0x12cfa8
movq (%rax), %rdi
callq 0x4590
cmpq $0x0, -0x8(%rbp)
je 0x5efe
leaq -0x20(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x1270e6(%rip), %rax    # 0x12cfd0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x4690
leaq -0x20(%rbp), %rax
cmpl $0x0, -0x24(%rbp)
je 0x5f5f
movq 0x1270c5(%rip), %rax    # 0x12cfd0
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x105685(%rip), %rax    # 0x10b5a5
leaq 0x10584d(%rip), %rcx    # 0x10b774
cmpq $0x0, %rdx
cmovneq %rcx, %rax
movq %rax, -0xe8(%rbp)
movl -0x24(%rbp), %edi
callq 0x4130
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rdx
movq %rax, %rcx
leaq 0x1036eb(%rip), %rsi    # 0x109641
movb $0x0, %al
callq 0x4700
jmp 0x5f77
movq 0x12706a(%rip), %rax    # 0x12cfd0
movq (%rax), %rdi
leaq 0x1032ba(%rip), %rsi    # 0x10922a
movb $0x0, %al
callq 0x4700
movq 0x127052(%rip), %rax    # 0x12cfd0
movq (%rax), %rdi
callq 0x4590
movl $0x1, %edi
callq 0x45e0
// File: /workspace/github_c_makefile_star2_O0/Mikejmoffitt[P]romtools/wavlooper/wavlooper.c
// Function: fwrite32le
void fwrite32le(uint32_t v, FILE *f)
{
	fputc(v & 0xFF, f);
	v = v >> 8;
	fputc(v & 0xFF, f);
	v = v >> 8;
	fputc(v & 0xFF, f);
	v = v >> 8;
	fputc(v & 0xFF, f);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x14(%rsp), %edi
andl $0xff, %edi
movq 0x8(%rsp), %rsi
callq 0x1060
movl 0x14(%rsp), %eax
shrl $0x8, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
andl $0xff, %edi
movq 0x8(%rsp), %rsi
callq 0x1060
movl 0x14(%rsp), %eax
shrl $0x8, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
andl $0xff, %edi
movq 0x8(%rsp), %rsi
callq 0x1060
movl 0x14(%rsp), %eax
shrl $0x8, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edi
andl $0xff, %edi
movq 0x8(%rsp), %rsi
callq 0x1060
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mikejmoffitt[P]romtools/wavlooper/wavlooper.c
// Function: write_smpl_chunk
void write_smpl_chunk(FILE *f, uint32_t start, uint32_t end)
{
	// $00 - $0F
	// The header.
	fputc('s', f);
	fputc('m', f);
	fputc('p', f);
	fputc('l', f);
	// Chunk size minus four
	fwrite32le(0x40 - 4, f);
	// Manufacturer (none)
	fwrite32le(0, f);
	// Product (none in particular)
	fwrite32le(0, f);

	// $10 - $1F
	// Sample period (unspecified)  TODO: Take from incoming wave file?
	fwrite32le(0, f);
	// MIDI unity node (irrelevant)
	fwrite32le(0x40 - 4, f);  // TODO: Isn't this unnecessary?
	// MIDI pitch fraction (n/a)
	fwrite32le(0, f);
	// SMPTE format
	fwrite32le(0, f);

	// $20 - $2B
	// SMPTE offset
	fwrite32le(0, f);
	// Number of sample loops
	fwrite32le(1, f);
	fwrite32le(0, f);

	// The sample loop begins.
	// ID
	fwrite32le(0, f);
	// Type (forward = 0)
	fwrite32le(0, f);
	// Start position
	fwrite32le(start, f);
	// End position
	fwrite32le(end, f);
	// Fraction
	fwrite32le(0, f);
	// Loops (infinity)
	fwrite32le(0, f);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movl $0x73, %edi
callq 0x1060
movq 0x10(%rsp), %rsi
movl $0x6d, %edi
callq 0x1060
movq 0x10(%rsp), %rsi
movl $0x70, %edi
callq 0x1060
movq 0x10(%rsp), %rsi
movl $0x6c, %edi
callq 0x1060
movq 0x10(%rsp), %rsi
movl $0x3c, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
movl $0x3c, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
movl $0x1, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x11a0
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11a0
movl 0x8(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x11a0
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x11a0
movq 0x10(%rsp), %rsi
xorl %edi, %edi
callq 0x11a0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mikejmoffitt[P]romtools/wavlooper/wavlooper.c
// Function: main
int main(int argc, char **argv)
{
	if (argc < 5)
	{
		usage(argv[0]);
		return 0;
	}

	const char *in_fname = argv[1];
	const char *out_fname = argv[2];
	const uint32_t start = strtoul(argv[3], NULL, 0);
	const uint32_t end = strtoul(argv[4], NULL, 0);

	FILE *fin = fopen(in_fname, "rb");
	if (!fin)
	{
		fprintf(stderr, "Could not open %s for reading.\n", in_fname);
		return -1;
	}

	FILE *fout = fopen(out_fname, "wb");
	if (!fout)
	{
		fprintf(stderr, "Could not open %s for writing.\n", in_fname);
		fclose(fin);
		return -1;
	}

	int fetch = 0;
	while ((fetch = fgetc(fin)) != EOF) fputc(fetch, fout);
	fclose(fin);

	write_smpl_chunk(fout, start, end);
	fclose(fout);
	return 0;
}

// Assembly:
subq $0x48, %rsp
movl $0x0, 0x44(%rsp)
movl %edi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
cmpl $0x5, 0x40(%rsp)
jge 0x13a6
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0x1350
movl $0x0, 0x44(%rsp)
jmp 0x14e2
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1090
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1090
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
leaq 0xc38(%rip), %rsi       # 0x2036
callq 0x1080
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x143a
movq 0x2be1(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
leaq 0xc13(%rip), %rsi       # 0x2039
movb $0x0, %al
callq 0x1070
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x14e2
movq 0x28(%rsp), %rdi
leaq 0xc13(%rip), %rsi       # 0x2059
callq 0x1080
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1489
movq 0x2b99(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
leaq 0xbee(%rip), %rsi       # 0x205c
movb $0x0, %al
callq 0x1070
movq 0x18(%rsp), %rdi
callq 0x1030
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x14e2
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1050
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
je 0x14b4
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x1060
jmp 0x1491
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
callq 0x1230
movq 0x10(%rsp), %rdi
callq 0x1030
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/yurrriq[P]knrc/src/longlines.c
// Function: main
int main()
{
    int len;
    char line[MAXLINE];

    while ((len = get_line(line, MAXLINE)) > 0) {
        if (len > MINLENGTH)
            printf("%s", line);
        if (len >= MAXLINE && line[MAXLINE - 1] != '\n')
            fputs("...\n", stdout);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x39, %esi
callq 0x11d0
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jle 0x11c4
cmpl $0x36, -0x8(%rbp)
jle 0x119d
leaq -0x50(%rbp), %rsi
leaq 0xe6e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
cmpl $0x39, -0x8(%rbp)
jl 0x11c2
movsbl -0x18(%rbp), %eax
cmpl $0xa, %eax
je 0x11c2
movq 0x2e2d(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xe4a(%rip), %rdi       # 0x2007
callq 0x1040
jmp 0x116f
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: is_binary_op
bool is_binary_op(NodeKind kind) {
  switch (kind) {
    case ND_ADD:
    case ND_SUB:
    case ND_MUL:
    case ND_DIV:
    case ND_EQ:
    case ND_NEQ:
    case ND_GE:
    case ND_GT:
    case ND_LAND:
    case ND_LOR:
    case ND_AND:
    case ND_OR:
    case ND_XOR:
    case ND_SHR:
    case ND_SHL:
      return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x4, %eax
subl $0xa, %eax
jb 0x12e4
jmp 0x12d7
movl -0xc(%rbp), %eax
addl $-0xf, %eax
subl $0x4, %eax
ja 0x12ea
jmp 0x12e4
movb $0x1, -0x1(%rbp)
jmp 0x12ee
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: is_expr
bool is_expr(NodeKind kind) {
  switch (kind) {
    case ND_IF:
    case ND_WHILE:
    case ND_BLOCK:
    case ND_FOR:
    case ND_SWITCH:
    case ND_CASE:
    case ND_DEFAULT:
    case ND_BREAK:
    case ND_CONTINUE:
    case ND_RETURN:
    case ND_FDECL:
      return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1d, %eax
subl $0xa, %eax
ja 0x131a
jmp 0x1314
movb $0x0, -0x1(%rbp)
jmp 0x131e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: new_label
char *new_label() {
  char *label = (char *)malloc(10);
  if (!label) error("Could not allocate memmory.");
  sprintf(label, ".L%06d", label_count++);
  return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xa, %edi
callq 0x1120
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x135b
leaq 0xddf4(%rip), %rdi      # 0xf148
movb $0x0, %al
callq 0x5970
movq -0x8(%rbp), %rdi
movl 0x13e73(%rip), %edx     # 0x151d8
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x13e68(%rip)     # 0x151d8
leaq 0xdded(%rip), %rsi      # 0xf164
movb $0x0, %al
callq 0x1170
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: push_loop
void push_loop() {
  char *continue_label = new_label();
  char *break_label = new_label();
  Loop *label = (Loop *)calloc(1, sizeof(Loop));
  label->break_dest = break_label;
  label->continue_dest = continue_label;
  label->next = labels;
  labels = label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x1330
movq %rax, -0x8(%rbp)
callq 0x1330
movq %rax, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x13d04(%rip), %rcx     # 0x151e0
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x13cf2(%rip)     # 0x151e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: push_loop_switch
void push_loop_switch(Node *node) {
  char *break_label = new_label();
  Loop *label = (Loop *)calloc(1, sizeof(Loop));
  label->break_dest = break_label;
  label->continue_dest = NULL;
  label->node = node;
  label->next = labels;
  labels = label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1330
movq %rax, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x13c8d(%rip), %rcx     # 0x151e0
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x13c7b(%rip)     # 0x151e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: get_continue
char *get_continue(Token *token) {
  if (!labels)
    error_at_token(token,
                   "a continue statement may only be used within a loop.");
  return labels->continue_dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x13c3c(%rip)     # 0x151e0
jne 0x15b8
movq -0x8(%rbp), %rdi
leaq 0xdbf0(%rip), %rsi      # 0xf1a1
movb $0x0, %al
callq 0x5d20
movq 0x13c21(%rip), %rax     # 0x151e0
movq 0x8(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: get_break
char *get_break(Token *token) {
  if (!labels)
    error_at_token(
        token, "a break statement may only be used within a loop or switch.");
  return labels->break_dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x13bfc(%rip)     # 0x151e0
jne 0x15f8
movq -0x8(%rbp), %rdi
leaq 0xdbe5(%rip), %rsi      # 0xf1d6
movb $0x0, %al
callq 0x5d20
movq 0x13be1(%rip), %rax     # 0x151e0
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: get_inner_switch
Node *get_inner_switch() {
  Loop *cursor = labels;
  while (cursor && !cursor->node) cursor = cursor->next;
  if (!cursor) error("get_inner_switch(): Internal error.");
  return cursor->node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x13bc1(%rip), %rax     # 0x151e0
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x1640
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x1649
jmp 0x1656
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1623
cmpq $0x0, -0x8(%rbp)
jne 0x166b
leaq 0xdbae(%rip), %rdi      # 0xf212
movb $0x0, %al
callq 0x5970
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: reg_size
int reg_size(Type *type) {
  int data_size = sizeof_type(type);
  if (data_size == 8)
    return 0;
  else if (data_size == 4)
    return 1;
  else if (data_size == 2)
    return 2;
  else if (data_size == 1)
    return 3;
  else
    error("Internal error in reg_size(): Illegal data size (%d bytes).",
          data_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd640
movl %eax, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jne 0x16a7
movl $0x0, -0x4(%rbp)
jmp 0x16eb
cmpl $0x4, -0x14(%rbp)
jne 0x16b6
movl $0x1, -0x4(%rbp)
jmp 0x16eb
cmpl $0x2, -0x14(%rbp)
jne 0x16c5
movl $0x2, -0x4(%rbp)
jmp 0x16eb
cmpl $0x1, -0x14(%rbp)
jne 0x16d4
movl $0x3, -0x4(%rbp)
jmp 0x16eb
movl -0x14(%rbp), %esi
leaq 0xdb58(%rip), %rdi      # 0xf236
movb $0x0, %al
callq 0x5970
jmp 0x16e7
jmp 0x16e9
jmp 0x16eb
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: load
void load(Node *node) {
  Type *ty = type(node);
  switch (reg_size(ty)) {
    case 0:
      fprintf(output, "\tmov  rax, [rax]\n");
      break;
    case 1:
      fprintf(output, "\tmov  eax, [rax]\n");
      break;
    case 2:
      if (is_signed(ty)) {
        fprintf(output, "\tmovsx  eax, WORD PTR [rax]\n");
      } else {
        fprintf(output, "\tmovzx  eax, WORD PTR [rax]\n");
      }
      break;
    case 3:
      if (is_signed(ty)) {
        fprintf(output, "\tmovsx eax, BYTE PTR [rax]\n");
      } else {
        fprintf(output, "\tmovzx eax, BYTE PTR [rax]\n");
      }
      break;
    default:
      error_at_node(node, "Size of the variable is unknown.");
  }
  fprintf(output, "\tpush rax\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdda0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1680
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x1805
movq -0x18(%rbp), %rax
leaq 0xd8c8(%rip), %rcx      # 0xf004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x13ac4(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xdb1c(%rip), %rsi      # 0xf272
movb $0x0, %al
callq 0x10f0
jmp 0x1817
leaq 0x13aa7(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xdb11(%rip), %rsi      # 0xf284
movb $0x0, %al
callq 0x10f0
jmp 0x1817
movq -0x10(%rbp), %rdi
callq 0xd4d0
testb $0x1, %al
jne 0x178e
jmp 0x17a8
leaq 0x13a7b(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xdaf7(%rip), %rsi      # 0xf296
movb $0x0, %al
callq 0x10f0
jmp 0x17c0
leaq 0x13a61(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xdafa(%rip), %rsi      # 0xf2b3
movb $0x0, %al
callq 0x10f0
jmp 0x1817
movq -0x10(%rbp), %rdi
callq 0xd4d0
testb $0x1, %al
jne 0x17d1
jmp 0x17eb
leaq 0x13a38(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xdaee(%rip), %rsi      # 0xf2d0
movb $0x0, %al
callq 0x10f0
jmp 0x1803
leaq 0x13a1e(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xdaf0(%rip), %rsi      # 0xf2ec
movb $0x0, %al
callq 0x10f0
jmp 0x1817
movq -0x8(%rbp), %rdi
leaq 0xdaf8(%rip), %rsi      # 0xf308
movb $0x0, %al
callq 0x6040
leaq 0x139f2(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xdb01(%rip), %rsi      # 0xf329
movb $0x0, %al
callq 0x10f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: cast
void cast(Type *ty_from, Type *ty_to) {
  // if (!is_arith(ty_from) || !is_arith(ty_to)) return;
  int sz_from = reg_size(ty_from);
  int sz_to = reg_size(ty_to);
  if (sz_from <= sz_to) {
    return;
  }
  char *mnemonic;
  if (is_signed(ty_to)) {
    mnemonic = "movsx";
  } else {
    mnemonic = "movzx";
  };
  switch (reg_size(ty_from)) {
    case 0:
      break;
    case 1:
      fprintf(output, "\tpop  rax\n");
      if (is_signed(ty_to)) {
        fprintf(output, "\tmovsx rax, eax\n");
      } else {
        fprintf(output, "\tmov  eax, eax\n");
      }
      fprintf(output, "\tpush rax\n");
      break;
    case 2:
    case 3:
      fprintf(output, "\tpop  rax\n");
      fprintf(output, "\t%s rax, %s\n", mnemonic, reg_rax[reg_size(ty_from)]);
      fprintf(output, "\tpush rax\n");
      break;
    default:
      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1680
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1680
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x1875
jmp 0x19bb
movq -0x10(%rbp), %rdi
callq 0xd4d0
testb $0x1, %al
jne 0x1884
jmp 0x1891
leaq 0xdaa9(%rip), %rax      # 0xf334
movq %rax, -0x20(%rbp)
jmp 0x189c
leaq 0xdaa2(%rip), %rax      # 0xf33a
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1680
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
testl %eax, %eax
je 0x18ca
jmp 0x18b0
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x18cf
jmp 0x18ba
movl -0x24(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x1942
jmp 0x19b9
jmp 0x19bb
leaq 0x1393a(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xda60(%rip), %rsi      # 0xf340
movb $0x0, %al
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0xd4d0
testb $0x1, %al
jne 0x18f6
jmp 0x1910
leaq 0x13913(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xda44(%rip), %rsi      # 0xf34b
movb $0x0, %al
callq 0x10f0
jmp 0x1928
leaq 0x138f9(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xda3b(%rip), %rsi      # 0xf35c
movb $0x0, %al
callq 0x10f0
leaq 0x138e1(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xd9f0(%rip), %rsi      # 0xf329
movb $0x0, %al
callq 0x10f0
jmp 0x19bb
leaq 0x138c7(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xd9ed(%rip), %rsi      # 0xf340
movb $0x0, %al
callq 0x10f0
leaq 0x138af(%rip), %rax     # 0x15210
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1680
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
cltq
leaq 0x13766(%rip), %rcx     # 0x150f0
shlq $0x2, %rax
addq %rax, %rcx
leaq 0xd9d4(%rip), %rsi      # 0xf36c
movb $0x0, %al
callq 0x10f0
leaq 0x1386a(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xd979(%rip), %rsi      # 0xf329
movb $0x0, %al
callq 0x10f0
jmp 0x19bb
jmp 0x19bb
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_addr_to_rax
void gen_addr_to_rax(Node *node) {
  if (node->kind == ND_LVAR) {
    emit_lvar_addr(node->lvar);
    return;
  } else if (node->kind == ND_GVAR) {
    emit_gvar_addr(node);
    return;
  } else if (node->kind == ND_DEREF) {
    gen(node->lhs);
    fprintf(output, "\tpop  rax\n");
  } else if (node->kind == ND_STR) {
    fprintf(output, "\tlea  rax, .LS%06d[rip]\n", node->str_id);
    return;
  } else if (node->kind == ND_MEMBER) {
    gen_addr_to_rax(node->lhs);
    fprintf(output, "\tadd  rax, %d\n", node->offset);
  } else {
    error_at_node(node, "Can not get address.");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x18, (%rax)
jne 0x1a87
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x19d0
jmp 0x1b49
movq -0x8(%rbp), %rax
cmpl $0x19, (%rax)
jne 0x1a9e
movq -0x8(%rbp), %rdi
callq 0x1a10
jmp 0x1b49
movq -0x8(%rbp), %rax
cmpl $0x17, (%rax)
jne 0x1ace
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1b50
leaq 0x13755(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xd87b(%rip), %rsi      # 0xf340
movb $0x0, %al
callq 0x10f0
jmp 0x1b45
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x1af8
leaq 0x13732(%rip), %rax     # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0xd8b7(%rip), %rsi      # 0xf3a6
movb $0x0, %al
callq 0x10f0
jmp 0x1b49
movq -0x8(%rbp), %rax
cmpl $0x1b, (%rax)
jne 0x1b2f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1a60
leaq 0x136fb(%rip), %rax     # 0x15210
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %edx
leaq 0xd899(%rip), %rsi      # 0xf3bf
movb $0x0, %al
callq 0x10f0
jmp 0x1b41
movq -0x8(%rbp), %rdi
leaq 0xd894(%rip), %rsi      # 0xf3ce
movb $0x0, %al
callq 0x6040
jmp 0x1b43
jmp 0x1b45
jmp 0x1b47
jmp 0x1b49
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: store
void store(Type *ty) {
  if (is_struct(ty)) {
    fprintf(output, "\tpop  rsi\n");

    int size = sizeof_type(ty);
    int i = 0;
    while (i <= size - 8) {
      fprintf(output, "\tmov  rdi, QWORD PTR [rsi + %d]\n", i);
      fprintf(output, "\tmov  QWORD PTR [rax + %d], rdi\n", i);
      i += 8;
    }
    while (i < size) {
      fprintf(output, "\tmov  dil, BYTE PTR [rsi + %d]\n", i);
      fprintf(output, "\tmov  BYTE PTR [rax + %d], dil\n", i);
      i++;
    }
    fprintf(output, "\tpush rax\n");
  } else {
    fprintf(output, "\tpop  rdi\n");
    fprintf(output, "\tmov  [rax], %s\n", reg_rdi[reg_size(ty)]);
    fprintf(output, "\tpush rdi\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd3b0
testb $0x1, %al
jne 0x254e
jmp 0x262c
leaq 0x12cbb(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xce84(%rip), %rsi      # 0xf3e3
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rdi
callq 0xd640
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x8, %ecx
cmpl %ecx, %eax
jg 0x25c7
leaq 0x12c83(%rip), %rax     # 0x15210
movq (%rax), %rdi
movl -0x10(%rbp), %edx
leaq 0xce54(%rip), %rsi      # 0xf3ee
movb $0x0, %al
callq 0x10f0
leaq 0x12c68(%rip), %rax     # 0x15210
movq (%rax), %rdi
movl -0x10(%rbp), %edx
leaq 0xce5a(%rip), %rsi      # 0xf40f
movb $0x0, %al
callq 0x10f0
movl -0x10(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x10(%rbp)
jmp 0x2579
jmp 0x25c9
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2612
leaq 0x12c38(%rip), %rax     # 0x15210
movq (%rax), %rdi
movl -0x10(%rbp), %edx
leaq 0xce4b(%rip), %rsi      # 0xf430
movb $0x0, %al
callq 0x10f0
leaq 0x12c1d(%rip), %rax     # 0x15210
movq (%rax), %rdi
movl -0x10(%rbp), %edx
leaq 0xce50(%rip), %rsi      # 0xf450
movb $0x0, %al
callq 0x10f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x25c9
leaq 0x12bf7(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xcd06(%rip), %rsi      # 0xf329
movb $0x0, %al
callq 0x10f0
jmp 0x2695
leaq 0x12bdd(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xce33(%rip), %rsi      # 0xf470
movb $0x0, %al
callq 0x10f0
leaq 0x12bc5(%rip), %rax     # 0x15210
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1680
movq -0x18(%rbp), %rdi
cltq
leaq 0x12a98(%rip), %rdx     # 0x15100
shlq $0x2, %rax
addq %rax, %rdx
leaq 0xce05(%rip), %rsi      # 0xf47b
movb $0x0, %al
callq 0x10f0
leaq 0x12b8c(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xcdfe(%rip), %rsi      # 0xf48c
movb $0x0, %al
callq 0x10f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_if
void gen_if(Node *node) {
  char *else_str = new_label();
  char *end_str = new_label();
  gen(node->lhs);
  fprintf(output, "\tpop  rax\n");
  fprintf(output, "\tcmp  rax, 0\n");
  fprintf(output, "\tje   %s\n", else_str);
  gen_stmt(node->rhs);
  emit_jmp(end_str);
  emit_label(else_str);
  gen_stmt(node->xhs);
  emit_label(end_str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1330
movq %rax, -0x10(%rbp)
callq 0x1330
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1b50
leaq 0x12b3e(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xcc64(%rip), %rsi      # 0xf340
movb $0x0, %al
callq 0x10f0
leaq 0x12b26(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xcda3(%rip), %rsi      # 0xf497
movb $0x0, %al
callq 0x10f0
leaq 0x12b0e(%rip), %rax     # 0x15210
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xcd95(%rip), %rsi      # 0xf4a5
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2760
movq -0x18(%rbp), %rdi
callq 0x13c0
movq -0x10(%rbp), %rdi
callq 0x1390
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2760
movq -0x18(%rbp), %rdi
callq 0x1390
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_while
void gen_while(Node *node) {
  push_loop();
  char *cond_str = get_continue(node->token);
  char *end_str = get_break(node->token);
  emit_label(cond_str);
  gen(node->lhs);
  fprintf(output, "\tpop  rax\n");
  fprintf(output, "\tcmp  rax, 0\n");
  fprintf(output, "\tje   %s\n", end_str);
  gen_stmt(node->rhs);
  emit_jmp(cond_str);
  emit_label(end_str);
  pop_loop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1490
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x1590
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x15d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1390
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1b50
leaq 0x12a10(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xcb36(%rip), %rsi      # 0xf340
movb $0x0, %al
callq 0x10f0
leaq 0x129f8(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xcc75(%rip), %rsi      # 0xf497
movb $0x0, %al
callq 0x10f0
leaq 0x129e0(%rip), %rax     # 0x15210
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0xcc67(%rip), %rsi      # 0xf4a5
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2760
movq -0x10(%rbp), %rdi
callq 0x13c0
movq -0x18(%rbp), %rdi
callq 0x1390
callq 0x1570
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_for
void gen_for(Node *node) {
  push_loop();
  char *loop_label = new_label();
  char *post_label = get_continue(node->token);
  char *end_label = get_break(node->token);
  gen(node->lhs);
  emit_label(loop_label);
  gen(node->rhs);
  fprintf(output, "\tpop  rax\n");
  fprintf(output, "\tcmp  rax, 0\n");
  fprintf(output, "\tje   %s\n", end_label);
  gen_stmt(node->nodes->data[0]);
  emit_label(post_label);
  gen(node->xhs);
  if (node->xhs) fprintf(output, "\tpop  rax\n");
  emit_jmp(loop_label);
  emit_label(end_label);
  pop_loop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1490
callq 0x1330
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x1590
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x15d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1b50
movq -0x10(%rbp), %rdi
callq 0x1390
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1b50
leaq 0x1293a(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xca60(%rip), %rsi      # 0xf340
movb $0x0, %al
callq 0x10f0
leaq 0x12922(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xcb9f(%rip), %rsi      # 0xf497
movb $0x0, %al
callq 0x10f0
leaq 0x1290a(%rip), %rax     # 0x15210
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xcb91(%rip), %rsi      # 0xf4a5
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2760
movq -0x18(%rbp), %rdi
callq 0x1390
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1b50
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2967
leaq 0x128ba(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xc9e0(%rip), %rsi      # 0xf340
movb $0x0, %al
callq 0x10f0
movq -0x10(%rbp), %rdi
callq 0x13c0
movq -0x20(%rbp), %rdi
callq 0x1390
callq 0x1570
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_block
void gen_block(Node *node) {
  if (!node) return;
  Vector *vec = node->nodes;
  int len = vec_len(vec);
  for (int i = 0; i < len; i++) gen_stmt(vec->data[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x29a5
jmp 0x29eb
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4000
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x29eb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2760
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x29c4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: builtin_va_start
void builtin_va_start(Node *node) {
  // void va_start(va_list ap, parmN);
  // typedef struct {
  //  int gp_offset;
  //  int fp_offset;
  //  void *overflow_arg_area;
  //  void *reg_save_area;
  //} va_list[1];
  int gp = vec_len(node->nodes);
  int fp = 0;
  // rdi = ap
  // ap->gp_offset = gp * 8
  fprintf(output, "\tmov  DWORD PTR [rdi], %d\n", gp * 8);
  // ap->fp_offset = 48 + fp * 8
  fprintf(output, "\tmov  DWORD PTR [rdi + 4], %d\n", 48 + fp * 8);
  // ap->reg_save_area = rbp - 128 (address for first arg(rdi))
  fprintf(output, "\tmov  [rdi + 16], rbp\n");
  fprintf(output, "\tsub  QWORD PTR [rdi + 16], 128\n");
  // this is dummy.
  fprintf(output, "\tpush rax\n");
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x4000
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
leaq 0x127e6(%rip), %rax     # 0x15210
movq (%rax), %rdi
movl -0xc(%rbp), %edx
shll $0x3, %edx
leaq 0xca75(%rip), %rsi      # 0xf4af
movb $0x0, %al
callq 0x10f0
leaq 0x127c8(%rip), %rax     # 0x15210
movq (%rax), %rdi
movl -0x10(%rbp), %edx
shll $0x3, %edx
addl $0x30, %edx
leaq 0xca6f(%rip), %rsi      # 0xf4ca
movb $0x0, %al
callq 0x10f0
leaq 0x127a7(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xca76(%rip), %rsi      # 0xf4e9
movb $0x0, %al
callq 0x10f0
leaq 0x1278f(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xca75(%rip), %rsi      # 0xf500
movb $0x0, %al
callq 0x10f0
leaq 0x12777(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xc886(%rip), %rsi      # 0xf329
movb $0x0, %al
callq 0x10f0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: gen_lnot
void gen_lnot(Node *node) {
  Type *l_ty = type(node->lhs);
  int reg_mode;
  char *false_label = new_label();
  char *exit_label = new_label();
  gen(node->lhs);

  if (!is_arith(l_ty) && !is_ptr(l_ty))
    error_at_node(node->lhs, "Illegal operation. (Type mismatch)");

  reg_mode = reg_size(l_ty);
  fprintf(output, "\tpop  rax\n");
  fprintf(output, "\tcmp  %s, 0\n", reg_rax[reg_mode]);
  fprintf(output, "\tjne  %s\n", false_label);

  fprintf(output, "\tmov  rax, 1\n");
  emit_jmp(exit_label);

  emit_label(false_label);
  fprintf(output, "\tmov  rax, 0\n");
  emit_label(exit_label);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xdda0
movq %rax, -0x10(%rbp)
callq 0x1330
movq %rax, -0x20(%rbp)
callq 0x1330
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1b50
movq -0x10(%rbp), %rdi
callq 0xd490
testb $0x1, %al
jne 0x343c
movq -0x10(%rbp), %rdi
callq 0xd350
testb $0x1, %al
jne 0x343c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xc33e(%rip), %rsi      # 0xf773
movb $0x0, %al
callq 0x6040
movq -0x10(%rbp), %rdi
callq 0x1680
movl %eax, -0x14(%rbp)
leaq 0x11dc1(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xbee7(%rip), %rsi      # 0xf340
movb $0x0, %al
callq 0x10f0
leaq 0x11da9(%rip), %rax     # 0x15210
movq (%rax), %rdi
movslq -0x14(%rbp), %rax
leaq 0x11c7b(%rip), %rdx     # 0x150f0
shlq $0x2, %rax
addq %rax, %rdx
leaq 0xc313(%rip), %rsi      # 0xf796
movb $0x0, %al
callq 0x10f0
leaq 0x11d7f(%rip), %rax     # 0x15210
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0xc312(%rip), %rsi      # 0xf7b1
movb $0x0, %al
callq 0x10f0
leaq 0x11d63(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xc2ec(%rip), %rsi      # 0xf7a3
movb $0x0, %al
callq 0x10f0
movq -0x28(%rbp), %rdi
callq 0x13c0
movq -0x20(%rbp), %rdi
callq 0x1390
leaq 0x11d39(%rip), %rax     # 0x15210
movq (%rax), %rdi
leaq 0xc0b5(%rip), %rsi      # 0xf596
movb $0x0, %al
callq 0x10f0
movq -0x28(%rbp), %rdi
callq 0x1390
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/codegen.c
// Function: eval_const
Node *eval_const(Node *node) {
  long res;
  switch (node->kind) {
    case ND_NUM:
      return node;
    case ND_ADD:
      res = eval_const(node->lhs)->num_val + eval_const(node->rhs)->num_val;
      return new_node_num(res, NULL);
    case ND_SUB:
      res = eval_const(node->lhs)->num_val - eval_const(node->rhs)->num_val;
      return new_node_num(res, NULL);
    case ND_MUL:
      res = eval_const(node->lhs)->num_val * eval_const(node->rhs)->num_val;
      return new_node_num(res, NULL);
    default:
      if (node->kind != ND_NUM)
        error_at_node(node,
                      "Calculation in an initializer is not supported yet.");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x3a94
movq -0x20(%rbp), %rax
leaq 0xb752(%rip), %rcx      # 0xf100
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3ab1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3980
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3980
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq 0x20(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x69f0
movq %rax, -0x8(%rbp)
jmp 0x3ab1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3980
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3980
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq 0x20(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x69f0
movq %rax, -0x8(%rbp)
jmp 0x3ab1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3980
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3980
movq %rax, %rcx
movq -0x38(%rbp), %rax
imulq 0x20(%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x69f0
movq %rax, -0x8(%rbp)
jmp 0x3ab1
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x3aaf
movq -0x10(%rbp), %rdi
leaq 0xbf46(%rip), %rsi      # 0xf9ee
movb $0x0, %al
callq 0x6040
jmp 0x3ab1
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sisshiki1969[P]monocc/src/container.c
// Function: vec_new
Vector *vec_new() {
  Vector *vec = (Vector *)malloc(sizeof(Vector));
  vec->data = (Node **)malloc(5 * sizeof(void *));
  vec->len = 0;
  vec->capacity = 5;
  return vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x1120
movq %rax, -0x8(%rbp)
movl $0x28, %edi
callq 0x1120
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0xc(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)