LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_func_definition
Node *parse_func_definition(MemberInfo *ty_ident) {
  Node *decl;
  Token *ident = ty_ident->ident;
  Type *type = ty_ident->type;
  cur_fn = new_func(ident, type, NULL);
  // function definition
  Vector *params = vec_new();
  MemberInfo *cursor = type->params;
  while (cursor) {
    vec_push(params, new_node_lvar(new_lvar(cursor->ident, cursor->type),
                                   cursor->ident));
    cursor = cursor->next;
  }

  Node *body = parse_block();
  int max_offset;
  if (type->variadic) {
    max_offset = 128;
  } else {
    max_offset = 32;
  };
  if (locals) max_offset = locals->offset;
  decl = new_node_fdecl(ident, params, max_offset, body, type);
  cur_fn->body = decl;
  return decl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %rbx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5c1e
movq %rax, 0x99ca(%rip)      # 0x11270
xorl %eax, %eax
callq 0x34c8
movq %rax, %r15
leaq 0x18(%rbx), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x78e6
movq 0x8(%r12), %rdi
movq 0x10(%r12), %rsi
callq 0x575f
movq 0x8(%r12), %rsi
movq %rax, %rdi
callq 0x53c0
movq %r15, %rdi
movq %rax, %rsi
callq 0x34f6
jmp 0x78b4
callq 0x711b
cmpb $0x0, 0x38(%rbx)
movl $0x80, %ecx
pushq $0x20
popq %rdx
cmovnel %ecx, %edx
leaq 0x9947(%rip), %rcx      # 0x11248
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x790c
movl 0x18(%rcx), %edx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rcx
movq %rbx, %r8
callq 0x5947
movq 0x994c(%rip), %rcx      # 0x11270
movq %rax, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_array_initializer
Node *parse_array_initializer(Type *l_type) {
  Token *op_token = token;
  expect(TK_OP_BRACE);
  Vector *vec = vec_new();
  Type *ary_of = l_type->ptr_to;
  while (!peek(TK_CL_BRACE)) {
    Node *init = parse_initializer(ary_of);
    vec_push(vec, init);
    if (!consume_if(TK_COMMA)) break;
  }
  expect(TK_CL_BRACE);
  Node *node = new_node(ND_INIT, op_token);
  node->nodes = vec;
  node->type = new_type_array(ary_of, vec_len(vec));
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x98e2(%rip), %r12      # 0x11228
movq (%r12), %rbx
pushq $0x1f
popq %rdi
callq 0x5a46
xorl %eax, %eax
callq 0x34c8
movq %rax, %r15
movq 0x8(%r14), %r14
movq (%r12), %rax
cmpl $0x20, (%rax)
je 0x798f
movq %r14, %rdi
callq 0x7022
movq %r15, %rdi
movq %rax, %rsi
callq 0x34f6
movq (%r12), %rax
cmpl $0x23, (%rax)
jne 0x798f
movq 0x8(%rax), %rax
movq %rax, (%r12)
jmp 0x7964
pushq $0x20
popq %rdi
callq 0x5a46
pushq $0x3
popq %rdi
movq %rbx, %rsi
callq 0x563c
movq %rax, %rbx
movq %r15, 0x48(%rax)
movq %r15, %rdi
callq 0x34f2
movq %r14, %rdi
movl %eax, %esi
callq 0x90e7
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/parse.c
// Function: parse_struct_initializer
Node *parse_struct_initializer(Type *l_type) {
  Token *op_token = token;
  expect(TK_OP_BRACE);
  Vector *vec = vec_new();
  MemberInfo *member = l_type->member;
  while (!peek(TK_CL_BRACE)) {
    Node *init = parse_initializer(member->type);
    vec_push(vec, init);
    if (!consume_if(TK_COMMA)) break;
    member = member->next;
  }
  expect(TK_CL_BRACE);
  Node *node = new_node(ND_INIT, op_token);
  node->nodes = vec;
  node->type = new_type_struct();
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x9848(%rip), %r12      # 0x11228
movq (%r12), %rbx
pushq $0x1f
popq %rdi
callq 0x5a46
xorl %eax, %eax
callq 0x34c8
movq %rax, %r15
addq $0x20, %r14
movq (%r12), %rax
cmpl $0x20, (%rax)
je 0x7a2d
movq (%r14), %r14
movq 0x10(%r14), %rdi
callq 0x7022
movq %r15, %rdi
movq %rax, %rsi
callq 0x34f6
movq (%r12), %rax
cmpl $0x23, (%rax)
jne 0x7a2d
movq 0x8(%rax), %rax
movq %rax, (%r12)
jmp 0x79fe
pushq $0x20
popq %rdi
callq 0x5a46
pushq $0x3
popq %rdi
movq %rbx, %rsi
callq 0x563c
movq %rax, %rbx
movq %r15, 0x48(%rax)
xorl %eax, %eax
callq 0x912b
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/pp.c
// Function: pp
void pp() {
  Macro *m;
  for (Token *t = token; t; t = t->next) {
    // print_token(stderr, t);
    if (t->kind != TK_IDENT) continue;
    if (!(m = find_macro(t))) continue;
    Macro args_head;
    args_head.next = NULL;
    Macro *args = &args_head;
    if (m->params) {
      check_params(m, t, &args);
    }
    // for(Macro *args = args_head.next; args; args = args->next)
    // print_tokens(stderr, args->params);
    if (!m->subst) {
      Token *next_token = t->next;
      *t = *next_token;
      t = next_token;
      continue;
    }

    Token *next_token = t->next;
    *t = *(m->subst);
    while (t->next) {
      if (t->kind == TK_IDENT) {
        for (Token *param = m->params; param; param = param->next) {
          if (cmp_token(t, param)) {
            int i = param->num_val;
            // fprintf(stderr, "find: %d", i);
            // print_token(stderr, t);
            for (Macro *args = args_head.next; args; args = args->next) {
              if (i-- == 0) {
                Token *next = t->next;
                // copy_token(args->params, t);
                *t = *args->params;
                while (t->next) t - t->next;
                t->next = next;
                break;
              }
            }
            // fprintf(stderr, "\n");
            break;
          }
        }
      }
      t = t->next;
    }
    t->next = next_token;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x9335(%rip), %rbx      # 0x11228
leaq 0x8(%rsp), %r13
movq %rsp, %r14
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x800a
cmpl $0x0, (%rbx)
je 0x7f12
addq $0x8, %rbx
jmp 0x7efb
movq %rbx, %rdi
callq 0x8205
testq %rax, %rax
je 0x7f0c
movq %rax, %r15
andq $0x0, 0x8(%rsp)
movq %r13, (%rsp)
cmpq $0x0, 0x10(%rax)
je 0x7f41
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7d38
movq 0x18(%r15), %rax
movq 0x8(%rbx), %rbp
testq %rax, %rax
je 0x7fe9
addq $0x10, %r15
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
cmpq $0x0, 0x8(%rbx)
je 0x7fe0
cmpl $0x0, (%rbx)
je 0x7f7e
movq 0x8(%rbx), %rbx
jmp 0x7f6c
movq %r15, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x7f78
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5a72
testb %al, %al
jne 0x7f9f
addq $0x8, %r12
jmp 0x7f81
movl 0x10(%r12), %eax
incl %eax
movq %r13, %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x7f78
decl %eax
jne 0x7fa9
movq 0x8(%rbx), %rax
movq 0x10(%rcx), %rcx
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm2, 0x20(%rbx)
cmpq $0x0, 0x8(%rbx)
jne 0x8008
movq %rax, 0x8(%rbx)
jmp 0x7f78
movq %rbp, 0x8(%rbx)
jmp 0x7f0c
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups 0x20(%rbp), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbp, %rbx
jmp 0x7f0c
jmp 0x8008
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/tokenize.c
// Function: new_token
Token *new_token(TokenKind kind, Token *cur, char *str, int len) {
  Token *new_token = calloc(1, sizeof(Token));
  new_token->kind = kind;
  new_token->str = str;
  new_token->len = len;
  cur->next = new_token;
  return new_token;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x10d0
movl %ebp, (%rax)
movq %r14, 0x20(%rax)
movl %ebx, 0x28(%rax)
movq %rax, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/tokenize.c
// Function: dup_token
Token *dup_token(Token *src) {
  Token *new = calloc(1, sizeof(Token));
  *new = *src;
  new->next = NULL;
  return new;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x10d0
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
andq $0x0, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/tokenize.c
// Function: new_file_info
FileInfo *new_file_info(char *file_name, char *start) {
  FileInfo *fi = calloc(1, sizeof(FileInfo));
  fi->next = file_informations;
  fi->file_name = file_name;
  fi->start = start;
  if (file_informations) {
    fi->no = file_informations->no + 1;
  } else {
    fi->no = 1;
  };
  file_informations = fi;
  return fi;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x10d0
leaq 0x90e7(%rip), %rcx      # 0x11208
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
testq %rdx, %rdx
je 0x813b
movl 0x20(%rdx), %edx
incl %edx
jmp 0x813e
pushq $0x1
popq %rdx
movl %edx, 0x20(%rax)
movq %rax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/tokenize.c
// Function: new_macro
Macro *new_macro(Token *token, Token *params, Token *subst) {
  Macro *m = calloc(1, sizeof(Macro));
  m->token = token;
  m->params = params;
  m->subst = subst;
  m->next = macros;
  macros = m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x10d0
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq 0x9108(%rip), %rcx      # 0x11280
movq %rcx, (%rax)
movq %rax, 0x90fe(%rip)      # 0x11280
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/tokenize.c
// Function: dup_tokens
Token *dup_tokens(Token *src) {
  Token head;
  head.next = NULL;
  Token *t = &head;
  for (; src; src = src->next) {
    t->next = dup_token(src);
    t = t->next;
  }
  return head.next;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
andq $0x0, 0x8(%r14)
testq %rbx, %rbx
je 0x81b6
movq %rbx, %rdi
callq 0x8080
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rbx
movq %rax, %r14
jmp 0x819c
movq 0x10(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/tokenize.c
// Function: dup_macro
Macro *dup_macro(Macro *macro) {
  Macro *m = calloc(1, sizeof(Macro));
  m->token = macro->token;
  m->params = dup_tokens(macro->params);
  m->subst = dup_tokens(macro->subst);
  return m;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x10d0
movq %rax, %r14
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq 0x10(%rbx), %rdi
callq 0x8188
movq %rax, 0x10(%r14)
movq 0x18(%rbx), %rdi
callq 0x8188
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/tokenize.c
// Function: find_macro
Macro *find_macro(Token *token) {
  for (Macro *m = macros; m; m = m->next) {
    if (token->len == m->token->len &&
        strncmp(token->str, m->token->str, token->len) == 0) {
      return dup_macro(m);
    }
  }
  return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x906d(%rip), %rbx      # 0x11280
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x8248
movslq 0x28(%r14), %rdx
movq 0x8(%rbx), %rax
cmpl 0x28(%rax), %edx
jne 0x8213
movq 0x20(%r14), %rdi
movq 0x20(%rax), %rsi
callq 0x1050
testl %eax, %eax
jne 0x8213
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x81c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/tokenize.c
// Function: new_tok_context
TokContext *new_tok_context(FileInfo *file_info, Token *current_token,
                            char *char_ptr) {
  TokContext *ctx = calloc(1, sizeof(TokContext));
  ctx->file_info = file_info;
  ctx->cur = current_token;
  ctx->p = char_ptr;
  return ctx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10d0
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: new_type_ptr_to
Type *new_type_ptr_to(Type *ptr_to) {
  Type *type = calloc(1, sizeof(Type));
  type->ty = PTR;
  type->ptr_to = ptr_to;
  return type;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
callq 0x10d0
movl $0x9, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: new_type_array
Type *new_type_array(Type *ptr_to, int size) {
  Type *type = calloc(1, sizeof(Type));
  type->ty = ARRAY;
  type->ptr_to = ptr_to;
  type->array_size = size;
  return type;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
callq 0x10d0
movl $0xa, (%rax)
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: new_type_func
Type *new_type_func(Type *return_type) {
  Type *type = calloc(1, sizeof(Type));
  type->ty = FUNC;
  type->ptr_to = return_type;
  type->variadic = false;
  return type;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
callq 0x10d0
movl $0xb, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: new_type_enum_el
Type *new_type_enum_el(Token *ident, int i) {
  Type *type = calloc(1, sizeof(Type));
  type->ty = ENUM_EL;
  type->tag_name = ident;
  type->offset = i;
  return type;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
callq 0x10d0
movl $0xe, (%rax)
movq %r14, 0x30(%rax)
movl %ebx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: get_common_type
Type *get_common_type(Type *ty1, Type *ty2) {
  if (sizeof_type(ty1) < 4) ty1 = new_type_int();
  if (sizeof_type(ty2) < 4) ty2 = new_type_int();

  if (is_signed(ty1) == is_signed(ty2)) {
    if (sizeof_type(ty1) < sizeof_type(ty2)) {
      return ty2;
    } else {
      return ty1;
    }
  }

  if (is_signed(ty1)) {
    if (sizeof_type(ty2) >= sizeof_type(ty1)) {
      return ty2;
    } else {
      return ty1;
    };
  } else {
    if (sizeof_type(ty1) >= sizeof_type(ty2)) {
      return ty1;
    } else {
      return ty2;
    };
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x929b
cmpl $0x4, %eax
leaq 0x8065(%rip), %r15      # 0x11288
cmovlq %r15, %rbx
movq %r14, %rdi
callq 0x929b
cmpl $0x4, %eax
cmovlq %r15, %r14
movl (%rbx), %eax
decl %eax
testl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
sete %cl
movl (%r14), %edx
decl %edx
testl $0xfffffff9, %edx       # imm = 0xFFFFFFF9
sete %dl
xorb %cl, %dl
je 0x925b
testl $0xfffffff9, %eax       # imm = 0xFFFFFFF9
je 0x9281
movq %rbx, %rdi
callq 0x929b
movl %eax, %ebp
movq %r14, %rdi
callq 0x929b
cmpl %eax, %ebp
cmovlq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x929b
movl %eax, %ebp
movq %rbx, %rdi
callq 0x929b
cmpl %eax, %ebp
cmovgeq %r14, %rbx
jmp 0x9273
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: sizeof_type
int sizeof_type(Type *type) {
  switch (type->ty) {
    case VOID:
      return 0;
    case CHAR:
    case BOOL:
      return 1;
    case SHORT:
    case USHORT:
      return 2;
    case INT:
    case UINT:
    case ENUM_EL:
    case ENUM:
      return 4;
    case PTR:
    case LONG:
    case ULONG:
      return 8;
    case ARRAY:
      return type->array_size * sizeof_type(type->ptr_to);
    case STRUCT:
      return sizeof_struct(type);
    default:
      error("Internal error: can not calculate size of unknown type ID=%d",
            type->ty);
  }
}

// Assembly:
pushq %rbx
pushq $0x1
popq %rbx
leaq 0x27be(%rip), %rax      # 0xba64
movl (%rdi), %esi
cmpq $0xe, %rsi
ja 0x92e0
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
imull 0x10(%rdi), %ebx
movq 0x8(%rdi), %rdi
jmp 0x92a6
pushq $0x4
jmp 0x92cf
pushq $0x8
jmp 0x92cf
pushq $0x2
jmp 0x92cf
pushq $0x1
popq %rax
imull %ebx, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0x92d0
callq 0x93a0
jmp 0x92d0
leaq 0x2916(%rip), %rdi      # 0xbbfd
xorl %eax, %eax
callq 0x462f
jmp 0x92d0
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: alignof_struct
int alignof_struct(Type *type) {
  MemberInfo *cursor = type->member;
  TagName *tag = find_tag(type->tag_name);
  if (!tag) {
    if (!type->member) error("anonymous struct with no members.");
  } else
    cursor = tag->type->member;
  int align = 0;
  while (cursor) {
    int a = alignof_type(cursor->type);
    if (a > align) align = a;
    cursor = cursor->next;
  }
  return align;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x30(%rdi), %rdi
callq 0x5cca
testq %rax, %rax
je 0x931d
movq 0x10(%rax), %rax
movq 0x20(%rax), %r14
jmp 0x9332
cmpq $0x0, 0x20(%rbx)
jne 0x9332
leaq 0x2871(%rip), %rdi      # 0xbb9c
xorl %eax, %eax
callq 0x462f
xorl %ebx, %ebx
testq %r14, %r14
je 0x934c
movq 0x10(%r14), %rdi
callq 0x9356
cmpl %ebx, %eax
cmovgl %eax, %ebx
movq (%r14), %r14
jmp 0x9334
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: alignof_type
int alignof_type(Type *type) {
  switch (type->ty) {
    case VOID:
      return 0;
    case CHAR:
    case BOOL:
      return 1;
    case SHORT:
    case USHORT:
      return 2;
    case INT:
    case UINT:
    case ENUM_EL:
    case ENUM:
      return 4;
    case PTR:
    case LONG:
    case ULONG:
      return 8;
    case ARRAY:
      return alignof_type(type->ptr_to);
    case STRUCT:
      return alignof_struct(type);
    default:
      error("Internal error: can not calculate align of unknown type ID=%d.",
            type->ty);
  }
}

// Assembly:
pushq %rax
leaq 0x2742(%rip), %rax      # 0xbaa0
movl (%rdi), %esi
cmpq $0xe, %rsi
ja 0x9390
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%rdi), %rdi
jmp 0x935e
pushq $0x4
jmp 0x9383
pushq $0x8
jmp 0x9383
pushq $0x2
jmp 0x9383
pushq $0x1
popq %rax
popq %rcx
retq
xorl %eax, %eax
jmp 0x9384
popq %rax
jmp 0x92fa
leaq 0x2827(%rip), %rdi      # 0xbbbe
xorl %eax, %eax
callq 0x462f
jmp 0x9384
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: sizeof_struct
int sizeof_struct(Type *type) {
  MemberInfo *cursor;
  TagName *tag = find_tag(type->tag_name);
  if (!tag) {
    if (!type->member) error("anonymous struct with no members.");
    cursor = type->member;
  } else
    cursor = tag->type->member;
  int size = 0;
  while (cursor) {
    size = align_to(size, alignof_type(cursor->type));
    size += sizeof_type(cursor->type);  // sizeof_type(cursor);
    cursor = cursor->next;
  }
  return align_to(size, alignof_type(type));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x5cca
testq %rax, %rax
je 0x93c3
movq 0x10(%rax), %r12
addq $0x20, %r12
jmp 0x93dc
leaq 0x20(%rbx), %r12
cmpq $0x0, 0x20(%rbx)
jne 0x93dc
leaq 0x27c7(%rip), %rdi      # 0xbb9c
xorl %eax, %eax
callq 0x462f
xorl %r14d, %r14d
movq (%r12), %r12
testq %r12, %r12
je 0x9413
movq 0x10(%r12), %rdi
callq 0x9356
movl %eax, %r15d
leal (%r14,%r15), %eax
decl %eax
negl %r15d
andl %eax, %r15d
movq 0x10(%r12), %rdi
callq 0x929b
movl %eax, %r14d
addl %r15d, %r14d
jmp 0x93df
movq %rbx, %rdi
callq 0x9356
leal (%r14,%rax), %ecx
decl %ecx
negl %eax
andl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: is_identical_type
bool is_identical_type(Type *l_type, Type *r_type) {
  if (l_type->ty != r_type->ty) return false;
  if (is_void(l_type) && is_void(r_type)) return true;
  if (is_arith(l_type)) return true;
  if (is_array(l_type))
    return is_identical_type(l_type->ptr_to, r_type->ptr_to);
  if (is_struct(l_type)) {
    MemberInfo *l_mem = l_type->member;
    MemberInfo *r_mem = r_type->member;
    while (l_mem && r_mem) {
      if (!is_identical_type(l_mem->type, r_mem->type)) return false;
      l_mem = l_mem->next;
      r_mem = r_mem->next;
    }
    return !r_mem && !l_mem;
  }
  if (is_ptr(l_type)) {
    return is_identical_type(l_type->ptr_to, r_type->ptr_to);
  }
  if (is_func(l_type)) {
    return is_identical_type(l_type->ptr_to, r_type->ptr_to);
  }
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xe00, %ecx            # imm = 0xE00
movl (%r14), %edx
cmpl (%rbx), %edx
sete %al
jne 0x9468
cmpl $0xd, %edx
ja 0x9499
btl %edx, %ecx
jae 0x945e
movq 0x8(%rbx), %rbx
movq 0x8(%r14), %r14
jmp 0x9440
movl $0x21ff, %ecx           # imm = 0x21FF
btl %edx, %ecx
jae 0x9470
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x20, %r14
addq $0x20, %rbx
movq (%rbx), %rbx
movq (%r14), %r14
testq %r14, %r14
je 0x949d
testq %rbx, %rbx
je 0x949d
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x9431
testb %al, %al
jne 0x9478
xorl %eax, %eax
jmp 0x9468
orq %r14, %rbx
sete %al
jmp 0x9468
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: is_compatible_type
bool is_compatible_type(Type *l_type, Type *r_type) {
  if (is_arith(l_type) && is_arith(r_type)) return true;
  // if (is_arith(l_type) && !is_arith(r_type)) return false;
  // if (!is_arith(l_type) && is_arith(r_type)) return false;
  if (is_ptr(l_type) && is_ptr(r_type)) {
    if (is_void(l_type->ptr_to) || is_void(r_type->ptr_to)) return true;
    return is_identical_type(l_type->ptr_to, r_type->ptr_to);
  }
  if (is_func(l_type) && is_func(r_type))
    return is_identical_type(l_type, r_type);
  return false;
}

// Assembly:
movl (%rdi), %ecx
xorl %eax, %eax
leal -0x1(%rcx), %edx
cmpl $0xc, %edx
ja 0x9502
leaq 0x2624(%rip), %r8       # 0xbadc
movslq (%r8,%rdx,4), %rdx
addq %r8, %rdx
jmpq *%rdx
movl (%rsi), %edx
leal -0x1(%rdx), %r8d
cmpl $0xd, %r8d
jae 0x94db
movb $0x1, %al
movl $0x10ff, %r9d           # imm = 0x10FF
btl %r8d, %r9d
jb 0x9502
cmpl $0xb, %ecx
je 0x9505
cmpl $0x9, %ecx
je 0x94e9
jmp 0x950f
movl (%rsi), %edx
cmpl $0x9, %edx
jne 0x950f
movq 0x8(%rdi), %rdi
movb $0x1, %al
cmpl $0x0, (%rdi)
je 0x9502
movq 0x8(%rsi), %rsi
cmpl $0x0, (%rsi)
jne 0x950a
retq
movl (%rsi), %edx
cmpl $0xb, %edx
jne 0x950f
jmp 0x9431
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/sisshiki1969[P]monocc/src/type.c
// Function: is_assignable_type
bool is_assignable_type(Type *l_type, Type *r_type) {
  if (is_array(l_type)) {
    if (is_array(r_type)) {
      return true;
    }
    l_type = l_type->ptr_to;
  }
  if (is_void(l_type) || is_void(r_type)) return false;
  if (is_arith(l_type) && is_arith(r_type)) return true;
  if (is_ptr(l_type) && is_arith(r_type)) return true;
  if (is_ptr(l_type) && is_ptr(r_type) && is_void(r_type->ptr_to)) return true;
  while (l_type) {
    if (l_type->ty != r_type->ty) return false;
    if (l_type->ty != PTR && l_type->ty != ARRAY) return true;
    l_type = l_type->ptr_to;
    r_type = r_type->ptr_to;
  }
  error("Internal error: Invalid type structure.");
}

// Assembly:
pushq %rax
movl (%rdi), %ecx
cmpl $0xa, %ecx
jne 0x9527
movb $0x1, %al
cmpl $0xa, (%rsi)
je 0x955d
movq 0x8(%rdi), %rdi
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x955b
movl (%rsi), %edx
testl %edx, %edx
je 0x955b
leal -0x1(%rcx), %eax
cmpl $0x8, %eax
jae 0x9561
cmpl $0xe, %edx
jae 0x9554
leal -0x1(%rdx), %r8d
movb $0x1, %al
movzbl %r8b, %r8d
movl $0x10ff, %r9d           # imm = 0x10FF
btl %r8d, %r9d
jb 0x955d
cmpl $0x9, %ecx
jne 0x958a
jmp 0x956d
xorl %eax, %eax
andb $0x1, %al
popq %rcx
retq
cmpl $0x9, %ecx
je 0x956d
cmpl $0xd, %ecx
jne 0x958a
jmp 0x9539
movb $0x1, %al
leal -0x1(%rdx), %ecx
cmpl $0x8, %ecx
jb 0x955d
cmpl $0xd, %edx
je 0x955d
cmpl $0x9, %edx
jne 0x958a
movq 0x8(%rsi), %rcx
cmpl $0x0, (%rcx)
je 0x955d
testq %rdi, %rdi
je 0x95aa
movl (%rdi), %ecx
cmpl (%rsi), %ecx
sete %al
jne 0x955d
addl $-0x9, %ecx
cmpl $0x1, %ecx
ja 0x955d
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
jmp 0x958a
leaq 0x2689(%rip), %rdi      # 0xbc3a
xorl %eax, %eax
callq 0x462f
jmp 0x955d
// File: /workspace/github_c_makefile_star2_O2/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 0x773f(%rip), %r12      # 0x10ff8
movq (%r12), %rcx
leaq 0x23ca(%rip), %rdi      # 0xbc8e
pushq $0x7
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
callq 0x1190
movq (%r12), %rdi
movq %r14, %rsi
callq 0x3d91
movq (%r12), %rcx
leaq 0x23ac(%rip), %rdi      # 0xbc96
pushq $0x8
popq %rsi
movq %r15, %rdx
callq 0x1190
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x3d91
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10c0
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_21/entab.c
// Function: main
int main(void)
{
  int c;
  unsigned int line_pos = 0;
  unsigned int nr_of_spaces = 0;

  while ((c = getchar()) != EOF)
  {
    ++line_pos;

    if (c == ' ')
    {
      ++nr_of_spaces;

      if (line_pos % TAB_LENGTH == 0 && nr_of_spaces > 1)
      {
        putchar('\t');
        nr_of_spaces = 0;
      }
    }
    else
    {
      while (nr_of_spaces)
      {
        putchar(' ');
        --nr_of_spaces;
      }

      if (c == '\n')
      {
        line_pos = 0;
      }

      putchar(c);
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
pushq $0x9
popq %r15
pushq $0x20
popq %rbx
xorl %r12d, %r12d
xorl %r13d, %r13d
callq 0x1040
cmpl $-0x1, %eax
je 0x11b2
movl %eax, %ebp
incl %r12d
cmpl $0x20, %eax
jne 0x119c
incl %r13d
testb $0x7, %r12b
sete %al
cmpl $0x2, %r13d
setae %cl
movl %r15d, %ebp
testb %cl, %al
je 0x1167
jmp 0x11a9
movl %ebx, %edi
callq 0x1030
subl $0x1, %r13d
jae 0x1195
cmpl $0xa, %ebp
cmovel %r14d, %r12d
movl %ebp, %edi
callq 0x1030
jmp 0x1164
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/marcespie[P]unix-samples/lab/soshutdown.c
// Function: main
int
main()
{
	struct addrinfo hints, *res, *res0;
	int error;
	int s = -1;

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_flags = AI_PASSIVE;

	error = getaddrinfo("localhost", "ssh", &hints, &res0);
	if (error)
		errx(1, "%s", gai_strerror(error));
	for (res = res0; res; res = res->ai_next) {
		s = socket(res->ai_family, res->ai_socktype,
		    res->ai_protocol);
		if (s == -1)
			continue;
		if (connect(s, res->ai_addr, res->ai_addrlen) == -1) {
			warn("connect");
			close(s);
			s = -1;
			continue;
		}
		break;
	}
	if (s == -1)
		fprintf(stderr, "no ssh running here\n");
	int pid;

	errwrap(pid = fork());
	// so this is the fun thing: most fds in the system are shared
	// between processes: when you call close(), the underlying 
	// file/socket does NOT get closed
	if (pid == 0) {
		shutdown(s, SHUT_WR);
		exit(0);
	}
	pause();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
pushq $0x1
popq %rax
movl %eax, 0x8(%rdx)
movl %eax, (%rdx)
leaq 0xdde(%rip), %rdi       # 0x2004
leaq 0xde1(%rip), %rsi       # 0x200e
leaq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq 0x10d0
testl %eax, %eax
jne 0x12cd
leaq 0xdcc(%rip), %r14       # 0x2015
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1290
movl 0x4(%rbx), %edi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
callq 0x10f0
cmpl $-0x1, %eax
je 0x128a
movl %eax, %ebp
movq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
movl %eax, %edi
callq 0x10b0
cmpl $-0x1, %eax
jne 0x12af
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
movl %ebp, %edi
callq 0x1070
addq $0x28, %rbx
jmp 0x1249
movq 0x2d61(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd7c(%rip), %rdi       # 0x201d
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x10c0
pushq $-0x1
popq %rbp
callq 0x10e0
testl %eax, %eax
je 0x12e8
cmpl $-0x1, %eax
je 0x12f9
callq 0x1080
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %edi
callq 0x1060
leaq 0xd37(%rip), %rsi       # 0x2012
pushq $0x1
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
pushq $0x1
popq %rsi
movl %ebp, %edi
callq 0x1040
xorl %edi, %edi
callq 0x10a0
leaq 0xd32(%rip), %rsi       # 0x2032
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/PARKINHYO[P]BlackjackGame/mqueue/mqueue_server.c
// Function: main
int main()
{
	int id;
	struct msqid_ds msq_status;

	pthread_t threads[MAX_PLAYERS];
	msg buf;
	int count = 0;
	init_cards();
	int i;

	// 메세지큐 생성...
	msgid_Send_Main = msgget(KEY_VALUE_MAIN2, IPC_CREAT | PERM);
	msgid_Recv_Main = msgget(KEY_VALUE_MAIN, IPC_CREAT | PERM);

	msgctl(msgid_Recv_Main, IPC_STAT, &msq_status);

	// signal 생성...
	(void)signal(SIGINT, (void(*)()) set_shutdown);

	for (i = 0; i < 10; i++) {
		msgrcv(msgid_Recv_Main, (void*)&buf, sizeof(msg), 200, 0);
		printf("start! : %s", buf.data); // start 정상적으로 받습니다.
		if (strncmp(buf.data, "start", 5) == 0) {
			printf("correct!\n");
			pthread_create(&threads[count], NULL, play_game_one, (void *)(intptr_t)count); // 게임 실행 스레드 생성합니다.
			count +=1;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
callq 0x1aa4
movl $0xeb8d, %edi           # imm = 0xEB8D
movl $0x3b6, %esi            # imm = 0x3B6
callq 0x1030
movl %eax, 0x2d72(%rip)      # 0x4160
movl $0xeb8c, %edi           # imm = 0xEB8C
movl $0x3b6, %esi            # imm = 0x3B6
callq 0x1030
movl %eax, 0x2d61(%rip)      # 0x4164
pushq $0x2
popq %rbx
leaq -0x118(%rbp), %rdx
movl %eax, %edi
movl %ebx, %esi
callq 0x10f0
leaq 0x740(%rip), %rsi       # 0x1b5d
movl %ebx, %edi
callq 0x10a0
pushq $0xa
popq %r12
leaq -0x48(%rbp), %rbx
leaq 0xc42(%rip), %r13       # 0x2075
pushq $0x5
popq %r14
xorl %r15d, %r15d
subl $0x1, %r12d
jb 0x14ad
movl 0x2d1e(%rip), %edi      # 0x4164
movl $0xc8, %ecx
leaq -0x50(%rbp), %rsi
pushq $0x28
popq %rdx
xorl %r8d, %r8d
callq 0x1120
leaq 0xc08(%rip), %rdi       # 0x2069
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x10e0
testl %eax, %eax
jne 0x143a
leaq 0xd42(%rip), %rdi       # 0x21c6
callq 0x1060
movslq %r15d, %r15
leaq -0xa0(,%r15,8), %rdi
addq %rbp, %rdi
xorl %esi, %esi
leaq 0x21(%rip), %rdx        # 0x14c1
movq %r15, %rcx
callq 0x1100
incl %r15d
jmp 0x143a
xorl %eax, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/examples/custom_stream.c
// Function: main
int main(GT_UNUSED int argc, const char *argv[])
{
  GtNodeStream *custom_stream, *gff3_out_stream;
  GtError *err;
  int had_err;

  if (gt_version_check(GT_MAJOR_VERSION, GT_MINOR_VERSION, GT_MICRO_VERSION)) {
    fprintf(stderr, "error: %s\n", gt_version_check(GT_MAJOR_VERSION,
                                                    GT_MINOR_VERSION,
                                                    GT_MICRO_VERSION));
    return EXIT_FAILURE;
  }

  /* initialize */
  gt_lib_init();

  /* create error object */
  err = gt_error_new();

  /* create custom input stream  */
  custom_stream = custom_stream_new();

  /* create GFF3 output stream */
  gff3_out_stream = gt_gff3_out_stream_new(custom_stream, NULL);

  /* pull the features through the stream */
  had_err = gt_node_stream_pull(gff3_out_stream, err);

  /* handle error */
  if (had_err)
    fprintf(stderr, "%s: error: %s\n", argv[0], gt_error_get(err));

  /* free */
  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(custom_stream);
  gt_error_delete(err);

  if (had_err)
    return EXIT_FAILURE;
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
pushq $0x1
popq %rbp
pushq $0x6
popq %rdx
movl %ebp, %edi
movl %edx, %esi
callq 0xea88
testq %rax, %rax
jne 0x4836
callq 0x4c24
callq 0x4948
movq %rax, %rbx
callq 0x4893
movq %rax, %rdi
xorl %esi, %esi
callq 0x1543b
movq %rax, %r15
callq 0x4893
movq %rax, %rdi
movq %r15, %rsi
callq 0x1581d
movb $0x0, 0x10(%rax)
movq %r15, %rdi
xorl %esi, %esi
callq 0x13cd3
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1572f
movl %eax, %r13d
testl %eax, %eax
jne 0x4862
xorl %ebp, %ebp
testl %r13d, %r13d
setne %bpl
movq %r12, %rdi
callq 0x15517
movq %r15, %rdi
callq 0x15517
movq %rbx, %rdi
callq 0x4be9
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5e79b(%rip), %rax     # 0x62fd8
movq (%rax), %rbx
pushq $0x6
popq %rdx
movl %ebp, %edi
movl %edx, %esi
callq 0xea88
leaq 0x3d7b5(%rip), %rsi     # 0x42008
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4480
jmp 0x4825
movq 0x5e76f(%rip), %rax     # 0x62fd8
movq (%rax), %rbp
movq (%r14), %r14
movq %rbx, %rdi
callq 0x4ae5
leaq 0x3d786(%rip), %rsi     # 0x42004
movq %rbp, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x4480
jmp 0x4804
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/examples/custom_stream.c
// Function: custom_stream_class
static const GtNodeStreamClass* custom_stream_class(void)
{
 static const GtNodeStreamClass *nsc = NULL;
 if (!nsc) {
   nsc = gt_node_stream_class_new(sizeof (CustomStream),
                                  NULL, /* we don't need a dedicated free
                                           method, because our CustomStream
                                           doesn't own object which have to be
                                           freed separately */
                                  custom_stream_next);
 }
 return nsc;
}

// Assembly:
movq 0x5fb8e(%rip), %rax     # 0x64428
testq %rax, %rax
je 0x48a0
retq
pushq %rax
leaq 0x16(%rip), %rdx        # 0x48be
pushq $0x18
popq %rdi
xorl %esi, %esi
callq 0x153d4
movq %rax, 0x5fb6f(%rip)     # 0x64428
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/examples/custom_stream.c
// Function: custom_stream_next
static int custom_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                              GT_UNUSED GtError *err)
{
  CustomStream *cs = custom_stream_cast(ns);
  gt_error_check(err);
  if (!cs->emitted_standard_gene) {
    *gn = gt_feature_node_new_standard_gene();
    cs->emitted_standard_gene = true;
  }
  else
    *gn = NULL;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4893
movq %rax, %rdi
movq %r14, %rsi
callq 0x1581d
movq %rax, %r14
testq %r15, %r15
je 0x48f0
movq %r15, %rdi
callq 0x4a5b
testb %al, %al
jne 0x4910
cmpb $0x0, 0x10(%r14)
je 0x48fb
xorl %eax, %eax
jmp 0x4905
callq 0xf949
movb $0x1, 0x10(%r14)
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x5e6c1(%rip), %rax     # 0x62fd8
movq (%rax), %rdi
leaq 0x3d6f2(%rip), %rsi     # 0x42013
leaq 0x3d814(%rip), %rdx     # 0x4213c
leaq 0x3d82b(%rip), %rcx     # 0x4215a
leaq 0x3d837(%rip), %r8      # 0x4216d
pushq $0x19
popq %r9
xorl %eax, %eax
callq 0x4480
callq 0x4170
nop
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/rw-trie.c
// Function: cleanup_handler
void cleanup_handler(void * arg){
  int rv;
  rv = pthread_mutex_unlock(&lock);
  assert(rv == 0);
  rv = pthread_rwlock_unlock(&rwlock);
  assert(rv == 0);
}

// Assembly:
pushq %rax
leaq 0x4e04(%rip), %rdi      # 0x6138
callq 0x1130
testl %eax, %eax
jne 0x134f
leaq 0x4e1c(%rip), %rdi      # 0x6160
callq 0x1150
testl %eax, %eax
jne 0x1368
popq %rax
retq
leaq 0x1cae(%rip), %rdi      # 0x3004
leaq 0x1caf(%rip), %rsi      # 0x300c
leaq 0x1cb2(%rip), %rcx      # 0x3016
pushq $0x20
jmp 0x137f
leaq 0x1c95(%rip), %rdi      # 0x3004
leaq 0x1c96(%rip), %rsi      # 0x300c
leaq 0x1c99(%rip), %rcx      # 0x3016
pushq $0x22
popq %rdx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/rw-trie.c
// Function: search
int search(const char *string, size_t strlen, int32_t *ip4_address) {
  struct trie_node *found;
  int rv, result;
  pthread_cleanup_push(cleanup_handler,&lock);

  // Skip strings of length 0
  if (strlen == 0)
  return 0;

  // obtain the lock
  rv = pthread_rwlock_rdlock(&rwlock);
  assert(rv == 0);
  found = _search(root, string, strlen);

  if (found && ip4_address)
  *ip4_address = found->ip4_address;

  result = (found != NULL);

  // Return the lock
  pthread_cleanup_pop(1);
  assert(rv == 0);

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rdi
xorl %ebp, %ebp
movl %ebp, %esi
callq 0x11f0
testl %eax, %eax
jne 0x15fc
movq %rsp, %rdi
callq 0x11c0
testq %r14, %r14
je 0x15ef
leaq 0x4bb9(%rip), %rdi      # 0x6160
callq 0x10e0
testl %eax, %eax
jne 0x1609
movq 0x4be9(%rip), %rdi      # 0x61a0
movq %r15, %rsi
movq %r14, %rdx
callq 0x1486
testq %rax, %rax
sete %cl
testq %rbx, %rbx
sete %dl
orb %cl, %dl
jne 0x15d7
movl 0xc(%rax), %ecx
movl %ecx, (%rbx)
xorl %ebp, %ebp
testq %rax, %rax
setne %al
movb %al, %bpl
movq %rsp, %rdi
callq 0x10c0
callq 0x132c
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x132c
movq %rsp, %rdi
callq 0x1160
leaq 0x19f4(%rip), %rdi      # 0x3004
leaq 0x19f5(%rip), %rsi      # 0x300c
leaq 0x1b0a(%rip), %rcx      # 0x3128
movl $0x8c, %edx
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/rw-trie.c
// Function: delete
int delete(const char *string, size_t strlen) {
            int result = 0;
            // Skip strings of length 0
            if (strlen != 0) {
              int rv;
              // Obtain the lock
              pthread_cleanup_push(cleanup_handler,&lock);
              pthread_rwlock_wrlock(&rwlock);
              //assert(rv == 0);
              // Attempt to delete the node.
              result = (NULL != _delete(root, string, strlen));

              // if squatting is allowed and a key was deleted.
              if (allow_squatting && result) {
                printf("Thread: %lu Node deleted, broadcasting %s\n", (long) pthread_self(), string);
                rv = pthread_cond_broadcast(&cv);
                // Check to see if the broadcasr was successful
                assert(rv == 0);
              }

              // Unlock
              //rv = pthread_mutex_unlock(&lock);
              //assert(rv == 0);
              pthread_cleanup_pop(1);
            }
            return result;
          }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
testq %rsi, %rsi
je 0x1eb0
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
xorl %esi, %esi
callq 0x11f0
testl %eax, %eax
jne 0x1ebb
movq %rsp, %rdi
callq 0x11c0
leaq 0x431d(%rip), %rdi      # 0x6160
callq 0x1090
movq 0x4351(%rip), %rdi      # 0x61a0
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1c62
xorl %ebp, %ebp
testq %rax, %rax
setne %r14b
je 0x1e9c
leaq 0x4374(%rip), %rax      # 0x61e0
cmpl $0x0, (%rax)
je 0x1e9c
callq 0x1180
leaq 0x149c(%rip), %rdi      # 0x3319
xorl %ecx, %ecx
movq %rax, %rsi
movq %rbx, %rdx
movl %ecx, %eax
callq 0x10b0
leaq 0x431d(%rip), %rdi      # 0x61b0
callq 0x1070
testl %eax, %eax
jne 0x1ec8
movb %r14b, %bpl
movq %rsp, %rdi
callq 0x10c0
callq 0x132c
movl %ebp, %eax
jmp 0x1eb2
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x132c
movq %rsp, %rdi
callq 0x1160
leaq 0x1135(%rip), %rdi      # 0x3004
leaq 0x1136(%rip), %rsi      # 0x300c
leaq 0x1467(%rip), %rcx      # 0x3344
movl $0x1ac, %edx            # imm = 0x1AC
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/stevenmherring[P]DNS/rw-trie.c
// Function: print
void print() {
            int rv;
            // Obtain the lock
            rv = pthread_mutex_lock(&lock);
            assert(rv == 0);

            printf("Root is at %p\n", root);
            /* Do a simple depth-first search */
            if (root)
            _print(root,0,0);

            // Unlock
            rv = pthread_mutex_unlock(&lock);
            assert(rv == 0);
          }

// Assembly:
pushq %rax
leaq 0x412f(%rip), %rdi      # 0x6138
callq 0x1220
testl %eax, %eax
jne 0x204e
movq 0x4187(%rip), %rsi      # 0x61a0
leaq 0x13ef(%rip), %rdi      # 0x340f
xorl %eax, %eax
callq 0x10b0
movq 0x4172(%rip), %rdi      # 0x61a0
testq %rdi, %rdi
je 0x203c
xorl %esi, %esi
xorl %edx, %edx
callq 0x1ee7
leaq 0x40f5(%rip), %rdi      # 0x6138
callq 0x1130
testl %eax, %eax
jne 0x206d
popq %rax
retq
leaq 0xfaf(%rip), %rdi       # 0x3004
leaq 0xfb0(%rip), %rsi       # 0x300c
leaq 0x139f(%rip), %rcx      # 0x3402
movl $0x1d6, %edx            # imm = 0x1D6
callq 0x10d0
leaq 0xf90(%rip), %rdi       # 0x3004
leaq 0xf91(%rip), %rsi       # 0x300c
leaq 0x1380(%rip), %rcx      # 0x3402
movl $0x1df, %edx            # imm = 0x1DF
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O2/seuscq[P]rtk_hciattach/hciattach.c
// Function: uart_speed
static int uart_speed(int s)
{
	switch (s) {
	case 9600:
		return B9600;
	case 19200:
		return B19200;
	case 38400:
		return B38400;
	case 57600:
		return B57600;
	case 115200:
		return B115200;
	case 230400:
		return B230400;
	case 460800:
		return B460800;
	case 500000:
		return B500000;
	case 576000:
		return B576000;
	case 921600:
		return B921600;
	case 1000000:
		return B1000000;
	case 1152000:
		return B1152000;
	case 1500000:
		return B1500000;
	case 2000000:
		return B2000000;
#ifdef B2500000
	case 2500000:
		return B2500000;
#endif
#ifdef B3000000
	case 3000000:
		return B3000000;
#endif
#ifdef B3500000
	case 3500000:
		return B3500000;
#endif
#ifdef B4000000
	case 4000000:
		return B4000000;
#endif
	default:
		return B57600;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2580, %edi           # imm = 0x2580
je 0x2585
cmpl $0x3d0900, %edi         # imm = 0x3D0900
je 0x2569
cmpl $0x9600, %edi           # imm = 0x9600
je 0x252a
cmpl $0xe100, %edi           # imm = 0xE100
je 0x2523
cmpl $0x1c200, %edi          # imm = 0x1C200
je 0x2531
cmpl $0x38400, %edi          # imm = 0x38400
je 0x2577
cmpl $0x70800, %edi          # imm = 0x70800
je 0x2546
cmpl $0x7a120, %edi          # imm = 0x7A120
je 0x2538
cmpl $0x8ca00, %edi          # imm = 0x8CA00
je 0x258c
cmpl $0xe1000, %edi          # imm = 0xE1000
je 0x254d
cmpl $0xf4240, %edi          # imm = 0xF4240
je 0x2593
cmpl $0x119400, %edi         # imm = 0x119400
je 0x2562
cmpl $0x16e360, %edi         # imm = 0x16E360
je 0x257e
cmpl $0x1e8480, %edi         # imm = 0x1E8480
je 0x2570
cmpl $0x2625a0, %edi         # imm = 0x2625A0
je 0x253f
cmpl $0x2dc6c0, %edi         # imm = 0x2DC6C0
je 0x255b
cmpl $0x3567e0, %edi         # imm = 0x3567E0
je 0x2554
cmpl $0x4b00, %edi           # imm = 0x4B00
jne 0x2523
movl $0xe, %eax
jmp 0x2598
movl $0x1001, %eax           # imm = 0x1001
jmp 0x2598
movl $0xf, %eax
jmp 0x2598
movl $0x1002, %eax           # imm = 0x1002
jmp 0x2598
movl $0x1005, %eax           # imm = 0x1005
jmp 0x2598
movl $0x100c, %eax           # imm = 0x100C
jmp 0x2598
movl $0x1004, %eax           # imm = 0x1004
jmp 0x2598
movl $0x1007, %eax           # imm = 0x1007
jmp 0x2598
movl $0x100e, %eax           # imm = 0x100E
jmp 0x2598
movl $0x100d, %eax           # imm = 0x100D
jmp 0x2598
movl $0x1009, %eax           # imm = 0x1009
jmp 0x2598
movl $0x100f, %eax           # imm = 0x100F
jmp 0x2598
movl $0x100b, %eax           # imm = 0x100B
jmp 0x2598
movl $0x1003, %eax           # imm = 0x1003
jmp 0x2598
movl $0x100a, %eax           # imm = 0x100A
jmp 0x2598
movl $0xd, %eax
jmp 0x2598
movl $0x1006, %eax           # imm = 0x1006
jmp 0x2598
movl $0x1008, %eax           # imm = 0x1008
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/seuscq[P]rtk_hciattach/hciattach.c
// Function: read_hci_event
int read_hci_event(int fd, unsigned char* buf, int size) 
{
	int remain, r;
	int count = 0;

	if (size <= 0)
		return -1;

	/* The first byte identifies the packet type. For HCI event packets, it
	 * should be 0x04, so we read until we get to the 0x04. */
	while (1) {
		r = read(fd, buf, 1);
		if (r <= 0)
			return -1;
		if (buf[0] == 0x04)
			break;
	}
	count++;

	/* The next two bytes are the event code and parameter total length. */
	while (count < 3) {
		r = read(fd, buf + count, 3 - count);
		if (r <= 0)
			return -1;
		count += r;
	}

	/* Now we read the parameters. */
	if (buf[2] < (size - 3)) 
		remain = buf[2];
	else 
		remain = size - 3;

	while ((count - 3) < remain) {
		r = read(fd, buf + count, remain - (count - 3));
		if (r <= 0)
			return -1;
		count += r;
	}

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
testl %edx, %edx
jle 0x263f
movl %edx, %r14d
movq %rsi, %r15
movl %edi, %r12d
pushq $0x1
popq %r13
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x2110
testl %eax, %eax
jle 0x263f
cmpb $0x4, (%r15)
jne 0x25c0
pushq $0x1
popq %r13
pushq $0x3
popq %rbx
cmpl $0x2, %r13d
jg 0x2604
movl %r13d, %esi
addq %r15, %rsi
movl %ebx, %edx
subl %r13d, %edx
movl %r12d, %edi
callq 0x2110
addl %eax, %r13d
testl %eax, %eax
jg 0x25df
pushq $-0x1
popq %rbx
jmp 0x263f
movzbl 0x2(%r15), %eax
addl $-0x3, %r14d
cmpl %eax, %r14d
cmovgel %eax, %r14d
pushq $-0x1
popq %rbx
leal -0x3(%r13), %ecx
movl %r14d, %eax
subl %ecx, %eax
jle 0x263c
movl %r13d, %esi
addq %r15, %rsi
movslq %eax, %rdx
movl %r12d, %edi
callq 0x2110
addl %eax, %r13d
testl %eax, %eax
jg 0x2617
jmp 0x263f
movl %r13d, %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_O2/seuscq[P]rtk_hciattach/hciattach.c
// Function: usage
static void usage(void)
{
	printf("hciattach - HCI UART driver initialization utility\n");
	printf("Usage:\n");
	printf("\thciattach [-n] [-p] [-b] [-r] [-t timeout] [-s initial_speed] <tty> <type | id> [speed] [flow|noflow] [bdaddr]\n");
	printf("\thciattach -l\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x523e(%rip), %rdi      # 0x82d3
callq 0x2050
leaq 0x5265(%rip), %rdi      # 0x8306
callq 0x2050
leaq 0x5260(%rip), %rdi      # 0x830d
callq 0x2050
leaq 0x52c4(%rip), %rdi      # 0x837d
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/seuscq[P]rtk_hciattach/hciattach.c
// Function: bcsp_tshy_sig_alarm
static void bcsp_tshy_sig_alarm(int sig)
{
	unsigned char bcsp_sync_pkt[10] = {0xc0,0x00,0x41,0x00,0xbe,0xda,0xdc,0xed,0xed,0xc0};
	static int retries = 0;

	if (retries < bcsp_max_retries) {
		retries++;
		if (write(serial_fd, &bcsp_sync_pkt, 10) < 0)
			return;
		alarm(1);
		return;
	}

	tcflush(serial_fd, TCIOFLUSH);
	fprintf(stderr, "BCSP initialization timed out\n");
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x951b(%rip), %eax      # 0xc64c
cmpl 0x9199(%rip), %eax      # 0xc2d0
jge 0x3166
incl %eax
movl %eax, 0x950b(%rip)      # 0xc64c
movl 0x9501(%rip), %edi      # 0xc648
leaq 0x4f06(%rip), %rsi      # 0x8054
pushq $0xa
popq %rdx
callq 0x2070
testq %rax, %rax
js 0x3164
pushq $0x1
popq %rdi
popq %rbp
jmp 0x20f0
popq %rbp
retq
movl 0x94dc(%rip), %edi      # 0xc648
pushq $0x2
popq %rsi
callq 0x20a0
movq 0x8e7d(%rip), %rax      # 0xbff8
movq (%rax), %rcx
leaq 0x4fc3(%rip), %rdi      # 0x8148
pushq $0x1e
popq %rsi
pushq $0x1
popq %rdx
callq 0x22a0
pushq $0x1
popq %rdi
callq 0x2290