LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/UCLA-StarAI[P]TrimBN/src/fnf/compiler.c
// Function: fnf_to_sdd_auto
SddNode* fnf_to_sdd_auto(Fnf* fnf, SddManager* manager) {
  SddCompilerOptions* options = sdd_manager_options(manager);
  int verbose      = options->verbose;
  BoolOp op        = fnf->op;
  SddSize count    = fnf->litset_count;
  LitSet** litsets = (LitSet**) malloc(count*sizeof(LitSet*));
  for (SddSize i=0; i<count; i++) litsets[i] = fnf->litsets + i;

  if(verbose) { printf("\nclauses: %ld ",count); fflush(stdout); }
  SddNode* node = ONE(manager,op);
  for(int i=0; i<count; i++) {
    sort_litsets_by_lca(litsets+i,count-i,manager);
    sdd_ref(node,manager);
    SddNode* l = apply_litset(litsets[i],manager);
    sdd_deref(node,manager);
    node = sdd_apply(l,node,op,manager);
    if(verbose) { printf("%ld ",count-i-1); fflush(stdout); }
  }
  free(litsets);
  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x6850
movl 0x58(%rax), %eax
movl %eax, 0xc(%rsp)
movzwl 0x18(%r14), %ebp
movq 0x8(%r14), %r15
leaq (,%r15,8), %rdi
callq 0x21b0
movq %rax, %r13
testq %r15, %r15
je 0x2719
movq 0x10(%r14), %rax
leaq 0x1(%r15), %rcx
andq $-0x2, %rcx
leaq -0x1(%r15), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x20a51(%rip), %xmm1    # 0x230f0
xorl %edx, %edx
movdqa 0x20a57(%rip), %xmm2    # 0x23100
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0x20a57(%rip), %xmm4    # 0x23110
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %esi
notl %esi
testb $0x1, %sil
je 0x26f0
movq %rax, (%r13,%rdx,8)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x2708
leaq 0x30(%rax), %rsi
movq %rsi, 0x8(%r13,%rdx,8)
addq $0x2, %rdx
paddq %xmm4, %xmm1
addq $0x60, %rax
cmpq %rdx, %rcx
jne 0x26b9
cmpl $0x0, 0xc(%rsp)
je 0x2740
leaq 0x209f9(%rip), %rdi     # 0x23120
movq %r15, %rsi
xorl %eax, %eax
callq 0x20e0
movq 0x28888(%rip), %rax     # 0x2afc0
movq (%rax), %rdi
callq 0x21c0
movq %rbx, %rdi
testw %bp, %bp
je 0x274f
callq 0x65b0
jmp 0x2754
callq 0x65a0
movq %rax, %r12
testq %r15, %r15
movq %r13, 0x10(%rsp)
je 0x27dd
movzwl %bp, %ebp
movq %r13, %r14
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2c13
movq %r12, %rdi
movq %rbx, %rsi
callq 0x99c0
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x27f9
movq %rax, %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0x9ab0
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0xba20
movq %rax, %r12
cmpl $0x0, 0xc(%rsp)
je 0x27d4
leaq -0x1(%r15), %rsi
leaq 0x2096c(%rip), %rdi     # 0x2312a
xorl %eax, %eax
callq 0x20e0
movq 0x287f4(%rip), %rax     # 0x2afc0
movq (%rax), %rdi
callq 0x21c0
addq $0x8, %r14
decq %r15
jne 0x2767
movq 0x10(%rsp), %rdi
callq 0x2030
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/UCLA-StarAI[P]TrimBN/src/fnf/compiler.c
// Function: apply_litset
SddNode* apply_litset(LitSet* litset, SddManager* manager) {

  BoolOp op            = litset->op; //conjoin (term) or disjoin (clause)
  SddLiteral* literals = litset->literals;
  SddNode* node        = ONE(manager,op); //will not be gc'd
  
  for(SddLiteral i=0; i<litset->literal_count; i++) {
    SddNode* literal = sdd_manager_literal(literals[i],manager);
    node             = sdd_apply(node,literal,op,manager);
  }
  
  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x18(%rdi), %ebp
movq 0x10(%rdi), %r12
movq %rsi, %rdi
testw %bp, %bp
je 0x2821
callq 0x65b0
jmp 0x2826
callq 0x65a0
movq %rax, %r15
cmpq $0x0, 0x8(%r14)
jle 0x285e
xorl %r13d, %r13d
movzwl %bp, %ebp
movq (%r12,%r13,8), %rdi
movq %rbx, %rsi
callq 0x65c0
movq %r15, %rdi
movq %rax, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0xba20
movq %rax, %r15
incq %r13
cmpq 0x8(%r14), %r13
jl 0x2836
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/UCLA-StarAI[P]TrimBN/src/fnf/compiler.c
// Function: fnf_to_sdd
SddNode* fnf_to_sdd(Fnf* fnf, SddManager* manager) {
  SddNode* test = degenerate_fnf_test(fnf,manager);
  if (test != NULL) return test;
  SddCompilerOptions* options = sdd_manager_options(manager);

  if(options->vtree_search_mode < 0) {
    sdd_manager_auto_gc_and_minimize_on(manager);
    return fnf_to_sdd_auto(fnf,manager);
  } else {
    sdd_manager_auto_gc_and_minimize_off(manager);
    return fnf_to_sdd_manual(fnf,manager);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x18(%rdi), %ecx
movq 0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x2ad3
movq 0x10(%r14), %rsi
addq $0x8, %rsi
xorl %eax, %eax
cmpq $0x0, (%rsi)
je 0x2ae2
addq $0x30, %rsi
decq %rdx
jne 0x2ac2
jmp 0x2aef
testw %cx, %cx
je 0x2ae7
movq %rbx, %rdi
callq 0x65b0
jmp 0x2aef
testw %cx, %cx
je 0x2ad8
movq %rbx, %rdi
callq 0x65a0
testq %rax, %rax
je 0x2afc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x6850
cmpl $0x0, 0x50(%rax)
js 0x2b24
movq %rbx, %rdi
callq 0x6160
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2870
movq %rbx, %rdi
callq 0x6150
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2638
nop
// File: /workspace/github_c_makefile_star2_O1/UCLA-StarAI[P]TrimBN/src/fnf/utils.c
// Function: litset_cmp_lca
int litset_cmp_lca(const void* litset1_loc, const void* litset2_loc) {

  LitSet* litset1 = *(LitSet**)litset1_loc;
  LitSet* litset2 = *(LitSet**)litset2_loc;

  Vtree* vtree1 = litset1->vtree;
  Vtree* vtree2 = litset2->vtree;
  SddLiteral p1 = sdd_vtree_position(vtree1);
  SddLiteral p2 = sdd_vtree_position(vtree2);
  
  if(vtree1!=vtree2 && (sdd_vtree_is_sub(vtree2,vtree1) || (!sdd_vtree_is_sub(vtree1,vtree2) && (p1 > p2)))) return 1;
  else if(vtree1!=vtree2 && (sdd_vtree_is_sub(vtree1,vtree2) || (!sdd_vtree_is_sub(vtree2,vtree1) && (p1 < p2)))) return -1;
  else {
	
  SddLiteral l1 = litset1->literal_count;
  SddLiteral l2 = litset2->literal_count;
  
  if(l1 > l2) return 1;
  else if(l1 < l2) return -1;
  else { 
    //so the litset order is unique
  	//without this, final litset order may depend on system
    SddSize id1 = litset1->id;
    SddSize id2 = litset2->id;
    if(id1 > id2) return 1;
    else if(id1 < id2) return -1;
    else return 0;
  }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rbp
movq (%rsi), %r15
movq 0x20(%rbp), %r14
movq 0x20(%r15), %r12
movq %r14, %rdi
callq 0x69b0
movq %rax, (%rsp)
movq %r12, %rdi
callq 0x69b0
cmpq %r12, %r14
je 0x2bd3
movq %rax, %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x9fe0
movl $0x1, %ebx
testl %eax, %eax
jne 0x2c02
movq %r14, %rdi
movq %r12, %rsi
callq 0x9fe0
testl %eax, %eax
sete %al
cmpq %r13, (%rsp)
setg %cl
testb %cl, %al
jne 0x2c02
movq %r14, %rdi
movq %r12, %rsi
callq 0x9fe0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x2c02
movq %r12, %rdi
movq %r14, %rsi
callq 0x9fe0
testl %eax, %eax
sete %al
cmpq %r13, (%rsp)
setl %cl
testb %cl, %al
jne 0x2c02
movq 0x8(%r15), %rax
movl $0x1, %ebx
cmpq %rax, 0x8(%rbp)
jg 0x2c02
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jl 0x2c02
movq (%rbp), %rax
movq (%r15), %rcx
xorl %edx, %edx
cmpq %rcx, %rax
sbbl %edx, %edx
cmpq %rcx, %rax
movl $0x1, %ebx
cmovbel %edx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/UCLA-StarAI[P]TrimBN/src/fnf/utils.c
// Function: sort_litsets_by_lca
void sort_litsets_by_lca(LitSet** litsets, SddSize size, SddManager* manager) {
  //compute lcas of litsets
  for(SddLiteral i=0; i<size; i++) {
    LitSet* litset = litsets[i];
    litset->vtree  = sdd_manager_lca_of_literals(litset->literal_count,litset->literals,manager);
  }
  //sort
  qsort((LitSet**)litsets,size,sizeof(LitSet*),litset_cmp_lca);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x2c4d
movq %rdx, %r15
xorl %r12d, %r12d
movq (%r14,%r12,8), %r13
movl 0x8(%r13), %edi
movq 0x10(%r13), %rsi
movq %r15, %rdx
callq 0xa060
movq %rax, 0x20(%r13)
incq %r12
cmpq %r12, %rbx
jne 0x2c2d
leaq -0x114(%rip), %rcx      # 0x2b40
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2060
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/UCLA-StarAI[P]TrimBN/src/fnf/fnf.c
// Function: print_fnf
void print_fnf(char* type, FILE* file, const Fnf* fnf) {
  fprintf(file,"p %s %"PRIlitS" %"PRIsS"\n",type,fnf->var_count,fnf->litset_count);
  for (SddSize i=0; i<fnf->litset_count; i++) {
    LitSet* litset = fnf->litsets + i;
    for (SddLiteral j=0; j<litset->literal_count; j++) fprintf(file,"%"PRIlitS" ",litset->literals[j]);
    fprintf(file,"0\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rdx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
leaq 0x20442(%rip), %rsi     # 0x23132
movq %r14, %rdi
xorl %eax, %eax
callq 0x2150
cmpq $0x0, 0x8(%rbx)
je 0x2d6c
leaq 0x20422(%rip), %r15     # 0x2312a
xorl %r13d, %r13d
movq 0x10(%rbx), %rbp
leaq (,%r13,2), %rax
addq %r13, %rax
shlq $0x4, %rax
cmpq $0x0, 0x8(%rbp,%rax)
jle 0x2d4a
addq %rax, %rbp
xorl %r12d, %r12d
movq 0x10(%rbp), %rax
movq (%rax,%r12,8), %rdx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2150
incq %r12
cmpq 0x8(%rbp), %r12
jl 0x2d2c
movl $0x2, %esi
movl $0x1, %edx
leaq 0x203e5(%rip), %rdi     # 0x23140
movq %r14, %rcx
callq 0x2290
incq %r13
cmpq 0x8(%rbx), %r13
jb 0x2d0b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/UCLA-StarAI[P]TrimBN/src/fnf/io.c
// Function: cnf_int_strtok
static int cnf_int_strtok() {
  static const char* whitespace = " \t\n\v\f\r";
  char* token = strtok(NULL,whitespace);
  test_parse_fnf_file(token == NULL,"Unexpected end of file.");
  return atoi(token);
}

// Assembly:
pushq %rbx
leaq 0x1fb68(%rip), %rsi     # 0x231cb
xorl %edi, %edi
callq 0x2230
movq %rax, %rbx
xorl %edi, %edi
testq %rax, %rax
sete %dil
leaq 0x1fb9c(%rip), %rsi     # 0x23219
callq 0x364d
movq %rbx, %rdi
popq %rbx
jmp 0x2260
nop
// File: /workspace/github_c_makefile_star2_O1/UCLA-StarAI[P]TrimBN/src/trim/move.c
// Function: is_feature_var_in_vtree
int is_feature_var_in_vtree(SddLiteral* const feature_vars,
    const size_t num_vars, Vtree* vtree) {
  if (sdd_vtree_is_leaf(vtree)) {
    SddLiteral var = sdd_vtree_var(vtree);
    for (int i = 0; i < num_vars; i++) { // enough to check 1 feature var
      if (feature_vars[i] == var) return 1;
    }
    return 0;
  }
  return is_feature_var_in_vtree(feature_vars, num_vars, sdd_vtree_left(vtree));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %r15, %rdi
callq 0x9df0
movq %r15, %rdi
testl %eax, %eax
jne 0x36b3
callq 0x6950
movq %rax, %r15
jmp 0x369a
callq 0x6990
testq %rbx, %rbx
setne %cl
je 0x36e2
cmpq %rax, (%r14)
je 0x36e2
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %rbx
je 0x36dc
leaq 0x1(%rcx), %rdx
cmpq %rax, (%r14,%rcx,8)
jne 0x36ca
cmpq %rbx, %rcx
setb %cl
movzbl %cl, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/UCLA-StarAI[P]TrimBN/src/trim/move.c
// Function: sdd_move_var_to_pos
SddNode* sdd_move_var_to_pos(SddLiteral var, int to_left, Vtree* new_sibling,
    SddNode* node, SddManager* manager) {
  if (to_left) {
    Vtree* left = sdd_vtree_left(new_sibling);
    if (left != NULL && sdd_vtree_var(left) == var) {
      return node;
    }
  } else {
    Vtree* right = sdd_vtree_right(new_sibling);
    if (right != NULL && sdd_vtree_var(right) == var) {
      return node;
    }
  }

  // Condition the SDD node on positive and negative literals of var.
  // Resulting SDD nodes do not contain var, and now we can move it freely.
  SddNode* node1 = sdd_condition(var, node, manager);
  SddNode* node0 = sdd_condition(-var, node, manager);

  // Garbage collect node
  sdd_ref(node1, manager);
  sdd_ref(node0, manager);
  sdd_deref(node, manager);
  sdd_manager_garbage_collect(manager);

  // Move variable to left/right of new_sibling and join the SDDs
  SddNode* tmp1;
  SddNode* tmp0;
  move_var_in_vtree(var, to_left ? 'l' : 'r', new_sibling, manager);
  node1 = sdd_conjoin(sdd_manager_literal(var,manager), tmp1=node1, manager);
  node0 = sdd_conjoin(sdd_manager_literal(-var,manager), tmp0=node0, manager);
  SddNode* return_node = sdd_disjoin(node1, node0, manager);

  // Garbage collect node1 and node0
  sdd_ref(return_node, manager);
  sdd_deref(tmp1, manager);
  sdd_deref(tmp0, manager);
  sdd_manager_garbage_collect(manager);

  return return_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbp
movq %rdx, %rdi
testl %esi, %esi
je 0x3716
callq 0x6950
movb $0x6c, %r12b
jmp 0x371e
callq 0x6960
movb $0x72, %r12b
testq %rax, %rax
je 0x3734
movq %rax, %rdi
callq 0x6990
cmpq %rbp, %rax
je 0x3813
movb %r12b, 0xf(%rsp)
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xdf30
movq %rax, %r13
movq %r15, 0x10(%rsp)
movq %rbp, %r15
negq %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xdf30
movq %rax, %r12
movq %r13, %rdi
movq %rbx, %rsi
callq 0x99c0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x99c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9ab0
movq %rbx, %rdi
callq 0x6630
movzbl 0xf(%rsp), %esi
movq %rbp, %rdi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0xa380
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x65c0
movq %rax, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x6610
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
callq 0x65c0
movq %rax, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x6610
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x6620
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x99c0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x9ab0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x9ab0
movq %rbx, %rdi
callq 0x6630
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/UCLA-StarAI[P]TrimBN/src/trim/move.c
// Function: sdd_move_feature_to_pos
SddNode* sdd_move_feature_to_pos(SddNode* node, SddManager* manager,
    SddLiteral* const feature_vars, const size_t num_vars, const int rl_pos,
    const int no_check) {
  SddNode* return_node = node;

  // new_sibling should point to rl_pos'th node in the rightmost path
  Vtree* new_sibling = sdd_vtree_of(node);  
  for (int i = 0; i < rl_pos; i++) new_sibling = sdd_vtree_right(new_sibling);

  // Return if already in position
  if (!no_check && is_feature_var_in_vtree(feature_vars, num_vars,
                                           sdd_vtree_left(new_sibling))) {
    return return_node;
  }

  for (int i = 0; i < num_vars; i++) {
    // Move the first indicator to the left of new_sibling, and the rest to
    // the right of new_sibling
    return_node = sdd_move_var_to_pos(feature_vars[i], (i==0), new_sibling,
                                      return_node, manager);
    new_sibling = sdd_vtree_of(sdd_manager_literal(feature_vars[i],manager));
  }

  return return_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x6600
movq %rax, %r13
testl %ebp, %ebp
jle 0x385f
movq %r13, %rdi
callq 0x6960
movq %rax, %r13
decl %ebp
jne 0x3850
cmpl $0x0, 0x4(%rsp)
je 0x386d
testq %r14, %r14
jne 0x3892
jmp 0x38d9
movq %r13, %rdi
callq 0x6950
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x368c
testl %eax, %eax
sete %al
testq %r14, %r14
setne %cl
testb %cl, %al
je 0x38d9
cmpq $0x1, %r14
adcq $0x0, %r14
xorl %ebp, %ebp
movq (%r15,%rbp,8), %rdi
xorl %esi, %esi
testq %rbp, %rbp
sete %sil
movq %r13, %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0x36eb
movq %rax, %rbx
movq (%r15,%rbp,8), %rdi
movq %r12, %rsi
callq 0x65c0
movq %rax, %rdi
callq 0x6600
movq %rax, %r13
incq %rbp
cmpq %rbp, %r14
jne 0x389c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/UCLA-StarAI[P]TrimBN/src/trim/search.c
// Function: update_constrained_positions
void update_constrained_positions(
    const Vtree* vtree, const int y, const int xy,
    SddLiteral* y_vtree, SddLiteral* xy_vtree) {
  if (y == 0) { // update Y-constrained vtree position
    *y_vtree = sdd_vtree_position(vtree);
  } 
  if (xy == 0) { // update XY-constrained vtree position
    *xy_vtree = sdd_vtree_position(vtree);
    return;
  }
  update_constrained_positions(sdd_vtree_right(vtree), y-1, xy-1, y_vtree, xy_vtree);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r12
xorl %r13d, %r13d
cmpl %r13d, %r15d
jne 0x3918
movq %r12, %rdi
callq 0x69b0
movq %rax, (%r14)
movq %r12, %rdi
cmpl %r13d, %ebp
je 0x392d
callq 0x6960
movq %rax, %r12
incl %r13d
jmp 0x3908
callq 0x69b0
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
movq 0x60(%rsp), %rbp
movq 0x58(%rsp), %rbx
movl 0x50(%rsp), %r13d
movq 0x28(%rdi), %rax
movslq %r9d, %rcx
movq (%rax,%rcx,8), %rax
movq (%rdx), %rdi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leal 0x1(%r13), %r8d
movq %r15, %rsi
xorl %r9d, %r9d
callq 0x3825
movq %rax, (%r12)
movq %r15, %rdi
callq 0x6890
movl 0x20(%r14), %edx
leaq 0x10(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rax, %rdi
movl %r13d, %esi
callq 0x38ec
cmpl $0x0, 0x68(%rsp)
je 0x3a0d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rdi
movq 0x8(%r14), %rdx
movq %r15, %rsi
callq 0xe2f0
movq %rax, %r15
movq 0x18(%r14), %rsi
movsd 0x30(%r14), %xmm0
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rax, %rdi
movq %rbx, %r8
callq 0xe6d0
movsd %xmm0, (%rbp)
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe3a0
// File: /workspace/github_c_makefile_star2_O1/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), %rax
movsd 0x8(%rax), %xmm0
movq (%rsi), %rax
subsd 0x8(%rax), %xmm0
movapd 0x1f25e(%rip), %xmm1    # 0x23250
xorpd %xmm2, %xmm2
xorl %eax, %eax
ucomisd %xmm2, %xmm0
andpd %xmm0, %xmm1
seta %al
xorl %ecx, %ecx
movsd 0x1f22b(%rip), %xmm0    # 0x23238
ucomisd %xmm1, %xmm0
leal -0x1(%rax,%rax), %eax
cmoval %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
xorl %ebx, %ebx
movl %ebp, %r12d
shrl $0x1f, %ebp
addl %r12d, %ebp
sarl %ebp
movslq %ebp, %r13
movq (%r15,%r13,8), %rsi
movq %r14, %rdi
callq 0x2140
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %r12d, %r12d
je 0x45f6
cmpl $0x1, %r12d
sete %dl
testl %eax, %eax
setne %sil
testb %sil, %dl
jne 0x45f6
testl %eax, %eax
je 0x45f4
js 0x45a9
leaq (%r15,%r13,8), %r15
subl %r13d, %r12d
addl %r13d, %ebx
movl %r12d, %ebp
jmp 0x45a9
movl %ebp, %ecx
addl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x4e1c
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax), %rdi
callq 0x2030
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2030
incq %r14
cmpq %r14, 0x20(%rbx)
ja 0x4df6
movq 0x28(%rbx), %rdi
callq 0x2030
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
shlq $0x3, %rax
subq %rax, %rdi
callq 0x2030
movq 0x40(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
movsd 0x30(%rdi), %xmm0
cvtss2sd 0x38(%rdi), %xmm1
leaq 0x1e4fc(%rip), %rdi     # 0x2336d
movb $0x2, %al
callq 0x20e0
cmpq $0x0, 0x20(%rbx)
je 0x4ef0
leaq 0x1e519(%rip), %r14     # 0x2339f
leaq 0x1e227(%rip), %r15     # 0x230b4
xorl %r12d, %r12d
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %rdx
movq %r14, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x20e0
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpq $0x0, 0x8(%rax)
je 0x4edd
xorl %r13d, %r13d
movq (%rax), %rax
movq (%rax,%r13,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x20e0
incq %r13
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpq %r13, 0x8(%rax)
ja 0x4ebb
movl $0xa, %edi
callq 0x2040
incq %r12
cmpq %r12, 0x20(%rbx)
ja 0x4e90
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %edi
callq 0x21b0
movq %rax, %r14
movq $0x0, (%rax)
movq %rbx, %rdi
callq 0x21b0
movq %rax, 0x8(%r14)
movl $0x0, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movsd %xmm0, (%rdi)
movss %xmm1, 0x10(%rdi)
testq %rdx, %rdx
je 0x4f72
xorl %eax, %eax
movb (%rsi,%rax), %cl
movq 0x8(%rdi), %r8
movb %cl, (%r8,%rax)
incq %rax
cmpq %rax, %rdx
jne 0x4f5f
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x61c2
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x4050
movl (%rax), %ebp
movq 0xcdde0(%rip), %rax     # 0xd3fb0
movq (%rax), %rdi
callq 0x45b0
testq %rbx, %rbx
je 0x6214
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq 0xcddcf(%rip), %rax     # 0xd3fd8
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x46c0
movq 0xcddbd(%rip), %r15     # 0xd3fd8
movq (%r15), %r14
testl %ebp, %ebp
je 0x6267
testq %rbx, %rbx
leaq 0xa91f1(%rip), %rax     # 0xaf41d
leaq 0xa9389(%rip), %rbx     # 0xaf5bc
cmoveq %rax, %rbx
movl %ebp, %edi
callq 0x4150
leaq 0xa72e8(%rip), %rsi     # 0xad52d
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x4730
movq (%r15), %rdi
callq 0x45b0
movl $0x1, %edi
callq 0x4600
movl $0xa, %edi
movq %r14, %rsi
callq 0x4660
jmp 0x6255
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl $0xff, %r14d
andl %r14d, %edi
callq 0x1060
movl %ebp, %edi
shrl $0x8, %edi
andl %r14d, %edi
movq %rbx, %rsi
callq 0x1060
movl %ebp, %edi
shrl $0x10, %edi
andl %r14d, %edi
movq %rbx, %rsi
callq 0x1060
shrl $0x18, %ebp
movl %ebp, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl $0x73, %edi
movq %rbx, %rsi
callq 0x1060
movl $0x6d, %edi
movq %rbx, %rsi
callq 0x1060
movl $0x70, %edi
movq %rbx, %rsi
callq 0x1060
movl $0x6c, %edi
movq %rbx, %rsi
callq 0x1060
movl $0x3c, %edi
movq %rbx, %rsi
callq 0x119c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x119c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x119c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x119c
movl $0x3c, %edi
movq %rbx, %rsi
callq 0x119c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x119c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x119c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x119c
movl $0x1, %edi
movq %rbx, %rsi
callq 0x119c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x119c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x119c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x119c
movl %r14d, %edi
movq %rbx, %rsi
callq 0x119c
movl %ebp, %edi
movq %rbx, %rsi
callq 0x119c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x119c
xorl %edi, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x119c
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
cmpl $0x4, %edi
jg 0x130c
movq (%r14), %rsi
leaq 0xd06(%rip), %rdi       # 0x2004
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1040
jmp 0x139a
movq 0x8(%r14), %r12
movq 0x10(%r14), %r13
movq 0x18(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1090
movq %rax, %rbx
movq 0x20(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1090
movq %rax, %r15
leaq 0xcfb(%rip), %rsi       # 0x2036
movq %r12, %rdi
callq 0x1080
testq %rax, %rax
je 0x13a6
movq %rax, %r14
leaq 0xd07(%rip), %rsi       # 0x2059
movq %r13, %rdi
callq 0x1080
testq %rax, %rax
je 0x13c3
movq %rax, %r13
movq %r14, %rdi
callq 0x1050
cmpl $-0x1, %eax
je 0x137b
movl %eax, %edi
movq %r13, %rsi
callq 0x1060
jmp 0x1362
movq %r14, %rdi
callq 0x1030
movq %r13, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x11e4
movq %r13, %rdi
callq 0x1030
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2c4b(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc82(%rip), %rsi       # 0x2039
movq %r12, %rdx
xorl %eax, %eax
callq 0x1070
jmp 0x13e6
movq 0x2c2e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc88(%rip), %rsi       # 0x205c
movq %r12, %rdx
xorl %eax, %eax
callq 0x1070
movq %r14, %rdi
callq 0x1030
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x139a
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsp, %rdi
movl $0x39, %esi
callq 0x11e0
testl %eax, %eax
jle 0x11d0
movl %eax, %ebp
leaq 0xe82(%rip), %rbx       # 0x2004
movq %rsp, %r14
movq 0x2e54(%rip), %r12      # 0x3fe0
leaq 0xe74(%rip), %r15       # 0x2007
cmpl $0x37, %ebp
jl 0x11a5
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1030
cmpl $0x39, %ebp
jl 0x11bd
cmpb $0xa, 0x38(%rsp)
je 0x11bd
movq (%r12), %rsi
movq %r15, %rdi
callq 0x1040
movq %r14, %rdi
movl $0x39, %esi
callq 0x11e0
movl %eax, %ebp
testl %eax, %eax
jg 0x1193
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/container.c
// Function: test_vec
void test_vec() {
  Vector *vec = vec_new();
  for (int i = 0; i < 100; i++) vec_push(vec, new_node_num(i, NULL));
  assert_expect(__LINE__, 100, vec_len(vec));
  assert_expect(__LINE__, 0, vec->data[0]->num_val);
  assert_expect(__LINE__, 50, vec->data[50]->num_val);
  assert_expect(__LINE__, 99, vec->data[99]->num_val);
  fprintf(stderr, "test_vec() cleared\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
pushq $0x10
popq %rdi
callq 0x1110
movq %rax, %rbx
pushq $0x28
popq %rdi
callq 0x1110
movq %rax, (%rbx)
movabsq $0x500000000, %rax      # imm = 0x500000000
movq %rax, 0x8(%rbx)
xorl %r14d, %r14d
movq %r14, %rdi
xorl %esi, %esi
callq 0x58ac
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3f66
incq %r14
cmpq $0x64, %r14
jne 0x120b
movslq 0x8(%rbx), %rdx
pushq $0x1c
popq %rdi
pushq $0x64
popq %rsi
callq 0x94c8
movq (%rbx), %rbx
movq (%rbx), %rax
movq 0x20(%rax), %rdx
pushq $0x1d
popq %rdi
xorl %esi, %esi
callq 0x94c8
movq 0x190(%rbx), %rax
movq 0x20(%rax), %rdx
pushq $0x1e
popq %rdi
pushq $0x32
popq %rsi
callq 0x94c8
movq 0x318(%rbx), %rax
movq 0x20(%rax), %rdx
pushq $0x1f
popq %rdi
pushq $0x63
popq %rsi
callq 0x94c8
movq 0x11d79(%rip), %rax     # 0x12ff8
movq (%rax), %rcx
leaq 0xb853(%rip), %rdi      # 0xcadc
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/error.c
// Function: print_error_line
void print_error_line(FileInfo *fi, PosInfo *pos, int len) {
  fprintf(stderr, "error in file: %s:%d\n", fi->file_name, pos->line);
  fprintf(stderr, "%.*s\n", pos->line_len, pos->line_start);
  fprintf(stderr, "%*s%.*s\n", pos->pos_in_line, "", len,
          "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq 0x11d4c(%rip), %r15     # 0x12ff8
movq (%r15), %rax
movq 0x8(%rdi), %rdx
movl (%rsi), %ecx
leaq 0xbd49(%rip), %rsi      # 0xd005
movq %rax, %rdi
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rdi
movl 0x10(%r14), %edx
movq 0x8(%r14), %rcx
leaq 0xb7dc(%rip), %rsi      # 0xcab4
xorl %eax, %eax
callq 0x10f0
movq (%r15), %rdi
movl 0x4(%r14), %edx
leaq 0xbd2e(%rip), %rsi      # 0xd01b
leaq 0xbe44(%rip), %rcx      # 0xd138
leaq 0xbd29(%rip), %r9       # 0xd024
movl %ebx, %r8d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O1/sisshiki1969[P]monocc/src/type.c
// Function: error_types
void error_types(Type *l_ty, Type *r_ty) {
  fprintf(stderr, "\nLeft: ");
  print_type(stderr, l_ty);
  fprintf(stderr, "\nRight: ");
  print_type(stderr, r_ty);
  fprintf(stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1180b(%rip), %r12     # 0x12ff8
movq (%r12), %rcx
leaq 0xc47a(%rip), %rdi      # 0xdc72
pushq $0x7
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
callq 0x1190
movq (%r12), %rdi
movq %r14, %rsi
callq 0x477f
movq (%r12), %rcx
leaq 0xc45c(%rip), %rdi      # 0xdc7a
pushq $0x8
popq %rsi
movq %r15, %rdx
callq 0x1190
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x477f
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10c0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl $0xa, %edi
callq 0x1110
movq %rax, %rbx
testq %rax, %rax
jne 0x1979
leaq 0xa7e6(%rip), %rdi      # 0xc158
xorl %eax, %eax
callq 0x50b0
movl 0x11869(%rip), %edx     # 0x131e8
leal 0x1(%rdx), %eax
movl %eax, 0x11860(%rip)     # 0x131e8
leaq 0xa7e5(%rip), %rsi      # 0xc174
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1170
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
callq 0x1958
movq %rax, %rbx
callq 0x1958
movq %rax, %r14
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %r14, 0x10(%rax)
movq %rbx, 0x8(%rax)
movq 0x1179e(%rip), %rcx     # 0x131f0
movq %rcx, (%rax)
movq %rax, 0x11794(%rip)     # 0x131f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1958
movq %rax, %r14
movl $0x1, %edi
movl $0x20, %esi
callq 0x10d0
movq %r14, 0x10(%rax)
movq $0x0, 0x8(%rax)
movq %rbx, 0x18(%rax)
movq 0x11757(%rip), %rcx     # 0x131f0
movq %rcx, (%rax)
movq %rax, 0x1174d(%rip)     # 0x131f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
cmpq $0x0, 0x1172a(%rip)     # 0x131f0
jne 0x1ad6
leaq 0xa6e2(%rip), %rsi      # 0xc1b1
xorl %eax, %eax
callq 0x52f9
movq 0x11713(%rip), %rax     # 0x131f0
movq 0x8(%rax), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
cmpq $0x0, 0x11704(%rip)     # 0x131f0
jne 0x1afc
leaq 0xa6f1(%rip), %rsi      # 0xc1e6
xorl %eax, %eax
callq 0x52f9
movq 0x116ed(%rip), %rax     # 0x131f0
movq 0x10(%rax), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x116df(%rip), %rbx     # 0x131f0
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1b22
cmpq $0x0, 0x18(%rbx)
je 0x1b11
jmp 0x1b30
leaq 0xa6f9(%rip), %rdi      # 0xc222
xorl %eax, %eax
callq 0x50b0
movq 0x18(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
callq 0xafa3
leal -0x1(%rax), %ecx
cmpl $0x8, %ecx
jae 0x1b5c
movl $0x8b, %edx
btl %ecx, %edx
jae 0x1b5c
movl %ecx, %eax
leaq 0xaf65(%rip), %rcx      # 0xcabc
movl (%rcx,%rax,4), %eax
jmp 0x1b6c
leaq 0xa6e3(%rip), %rdi      # 0xc246
movl %eax, %esi
xorl %eax, %eax
callq 0x50b0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xb354
movq %rax, %rbx
movq %rax, %rdi
callq 0x1b36
cmpl $0x3, %eax
ja 0x1c05
movl %eax, %eax
leaq 0xa471(%rip), %rcx      # 0xc004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1167d(%rip), %rax     # 0x13220
movq (%rax), %rcx
leaq 0xa6d5(%rip), %rdi      # 0xc282
jmp 0x1bfe
movq %rbx, %rdi
callq 0xaf02
leaq 0x11662(%rip), %rcx     # 0x13220
movq (%rcx), %rcx
testb %al, %al
je 0x1c18
leaq 0xa6da(%rip), %rdi      # 0xc2a6
jmp 0x1c1f
movq %rbx, %rdi
callq 0xaf02
leaq 0x11643(%rip), %rcx     # 0x13220
movq (%rcx), %rcx
testb %al, %al
je 0x1c26
leaq 0xa6f5(%rip), %rdi      # 0xc2e0
jmp 0x1c2d
leaq 0x1162c(%rip), %rax     # 0x13220
movq (%rax), %rcx
leaq 0xa696(%rip), %rdi      # 0xc294
movl $0x11, %esi
jmp 0x1c32
leaq 0xa70c(%rip), %rsi      # 0xc318
movq %r14, %rdi
xorl %eax, %eax
callq 0x552e
jmp 0x1c3c
leaq 0xa6a4(%rip), %rdi      # 0xc2c3
movl $0x1c, %esi
jmp 0x1c32
leaq 0xa6cf(%rip), %rdi      # 0xc2fc
movl $0x1b, %esi
movl $0x1, %edx
callq 0x1190
leaq 0x115dd(%rip), %rax     # 0x13220
movq (%rax), %rcx
leaq 0xa6ec(%rip), %rdi      # 0xc339
movl $0xa, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1b36
movl %eax, %ebp
movq %r14, %rdi
callq 0x1b36
cmpl %eax, %ebp
jle 0x1d46
movq %r14, %rdi
callq 0xaf02
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1b36
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1d04
leaq 0xa69c(%rip), %rax      # 0xc344
leaq 0xa69b(%rip), %r14      # 0xc34a
testb %bpl, %bpl
cmovneq %rax, %r14
leaq 0x11563(%rip), %r15     # 0x13220
movq (%r15), %rcx
leaq 0xa689(%rip), %rdi      # 0xc350
movl $0xa, %esi
movl $0x1, %edx
callq 0x1190
movq (%r15), %r15
movq %rbx, %rdi
callq 0x1b36
cltq
leaq 0x11416(%rip), %rcx     # 0x13100
leaq (%rcx,%rax,4), %rcx
leaq 0xa687(%rip), %rsi      # 0xc37c
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10f0
jmp 0x1d67
cmpl $0x1, %eax
jne 0x1d46
leaq 0x11510(%rip), %rbx     # 0x13220
movq (%rbx), %rcx
leaq 0xa636(%rip), %rdi      # 0xc350
movl $0xa, %esi
movl $0x1, %edx
callq 0x1190
movq %r14, %rdi
callq 0xaf02
movq (%rbx), %rcx
testb %al, %al
je 0x1d51
leaq 0xa61c(%rip), %rdi      # 0xc35b
movl $0x10, %esi
jmp 0x1d5d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa614(%rip), %rdi      # 0xc36c
movl $0xf, %esi
movl $0x1, %edx
callq 0x1190
leaq 0x114b2(%rip), %rax     # 0x13220
movq (%rax), %rcx
leaq 0xa5c1(%rip), %rdi      # 0xc339
movl $0xa, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
leal -0x17(%rcx), %eax
cmpl $0x4, %eax
ja 0x1e1d
leaq 0xa22a(%rip), %rcx      # 0xc014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
callq 0x1ead
leaq 0x1141d(%rip), %rax     # 0x13220
movq (%rax), %rcx
leaq 0xa543(%rip), %rdi      # 0xc350
movl $0xa, %esi
movl $0x1, %edx
popq %rbx
jmp 0x1190
cmpl $0x2, %ecx
jne 0x1e38
leaq 0x113f7(%rip), %rax     # 0x13220
movq (%rax), %rdi
movl 0x28(%rbx), %edx
leaq 0xa580(%rip), %rsi      # 0xc3b6
jmp 0x1ea5
leaq 0xa59f(%rip), %rsi      # 0xc3de
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
jmp 0x552e
leaq 0x113cf(%rip), %rax     # 0x13220
movq (%rax), %rdi
movq 0x50(%rbx), %rax
movl 0x28(%rax), %edx
movq 0x20(%rax), %rcx
leaq 0xa53a(%rip), %rsi      # 0xc3a0
xorl %eax, %eax
popq %rbx
jmp 0x10f0
movq 0x8(%rbx), %rdi
callq 0x1dd5
leaq 0x113a2(%rip), %rax     # 0x13220
movq (%rax), %rdi
movl 0x38(%rbx), %edx
leaq 0xa544(%rip), %rsi      # 0xc3cf
jmp 0x1ea5
movq 0x30(%rbx), %rax
leaq 0x11388(%rip), %rcx     # 0x13220
movq (%rcx), %rdi
movl 0x18(%rax), %edx
leaq 0xa4e4(%rip), %rsi      # 0xc389
xorl %eax, %eax
popq %rbx
jmp 0x10f0