LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/misc.c
// Function: fatald
void fatald(char *s, int d) {
  fprintf(stderr, "%s:%d on line %d of %s\n", s, d, Line, Infilename);
  fclose(Outfile);
  unlink(Outfilename);
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %ecx
movq %rdi, %rdx
movq 0x7a73(%rip), %rax      # 0xdff0
movq (%rax), %rdi
leaq 0x7de1(%rip), %rax      # 0xe368
movl (%rax), %r8d
leaq 0x7dff(%rip), %rax      # 0xe390
movq (%rax), %r9
leaq 0x4033(%rip), %rsi      # 0xa5ce
xorl %eax, %eax
callq 0x2100
leaq 0x7ddf(%rip), %rax      # 0xe388
movq (%rax), %rdi
callq 0x2070
leaq 0x7de0(%rip), %rax      # 0xe398
movq (%rax), %rdi
callq 0x2050
pushq $0x1
popq %rdi
callq 0x2170
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/misc.c
// Function: fatalc
void fatalc(char *s, int c) {
  fprintf(stderr, "%s:%c on line %d of %s\n", s, c, Line, Infilename);
  fclose(Outfile);
  unlink(Outfilename);
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %ecx
movq %rdi, %rdx
movq 0x7a18(%rip), %rax      # 0xdff0
movq (%rax), %rdi
leaq 0x7d86(%rip), %rax      # 0xe368
movl (%rax), %r8d
leaq 0x7da4(%rip), %rax      # 0xe390
movq (%rax), %r9
leaq 0x3ff0(%rip), %rsi      # 0xa5e6
xorl %eax, %eax
callq 0x2100
leaq 0x7d84(%rip), %rax      # 0xe388
movq (%rax), %rdi
callq 0x2070
leaq 0x7d85(%rip), %rax      # 0xe398
movq (%rax), %rdi
callq 0x2050
pushq $0x1
popq %rdi
callq 0x2170
nop
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/opt.c
// Function: fold
static struct ASTnode *fold(struct ASTnode *n) {

  if (n == NULL)
    return (NULL);

  // 折叠左子树和右子树
  n->left = fold(n->left);
  n->right = fold(n->right);

  // 如果两个子树都是A_INTLITs，使用fold2()折叠
  if (n->left && n->left->op == A_INTLIT) {
    if (n->right && n->right->op == A_INTLIT)
      n = fold2(n);
    else
      // 如果只是左子树是A_INTLIT,使用fold1()折叠
      n = fold1(n);
  }

  // 返回可能折叠过的树
  return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6692
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x662b
movq %rax, 0x20(%rbx)
movq 0x30(%rbx), %rdi
callq 0x662b
movq %rax, 0x30(%rbx)
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0x6694
cmpl $0x1a, 0x4(%rcx)
jne 0x6694
testq %rax, %rax
je 0x669e
cmpl $0x1a, 0x4(%rax)
jne 0x669e
movl 0x4(%rbx), %edx
addl $-0x15, %edx
cmpl $0x3, %edx
ja 0x6694
movl (%rcx), %ecx
movl (%rax), %r8d
leaq 0x3f7c(%rip), %rax      # 0xa600
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
addl %ecx, %r8d
jmp 0x66de
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl (%rcx), %r8d
movl 0x4(%rbx), %eax
cmpl $0x21, %eax
je 0x66de
cmpl $0x2d, %eax
je 0x66b8
cmpl $0x2c, %eax
jne 0x6694
notl %r8d
jmp 0x66de
xorl %eax, %eax
testl %r8d, %r8d
sete %al
movl %eax, %r8d
jmp 0x66de
imull %ecx, %r8d
jmp 0x66de
testl %r8d, %r8d
je 0x6694
movl %ecx, %eax
cltd
idivl %r8d
jmp 0x66c0
subl %r8d, %ecx
movl %ecx, %r8d
movl 0x8(%rbx), %esi
pushq $0x1a
popq %rdi
xorl %edx, %edx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x818c
nop
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/scan.c
// Function: next
static int next(void) {
  int c, l;

  if (Putback) {		// 如果putback有值，
    c = Putback;		// 就用putback的值
    Putback = 0;
    return (c);
  }

  c = fgetc(Infile);			// 从输入文件读入一个字符

  while (Linestart && c == '#') {	// 预处理开始
    Linestart = 0;			// 不在行首
    scan(&Token);			// 获取行号放到l
    if (Token.token != T_INTLIT)
      fatals("Expecting pre-processor line number, got:", Text);
    l = Token.intvalue;

    scan(&Token);			// 获得文件名放在Text
    if (Token.token != T_STRLIT)
      fatals("Expecting pre-processor file name, got:", Text);

    if (Text[0] != '<') {		// 如果这是真的文件名
      if (strcmp(Text, Infilename))	// 跟我们已有的不一样
	    Infilename = strdup(Text);	// 保存它，然后更新行号
      Line = l;
    }

    while ((c = fgetc(Infile)) != '\n'); // 调到下一行
    c = fgetc(Infile);			// 获取下一个字符
    Linestart = 1;			// 现在在行首了
  }

  Linestart = 0;			// 不在行首
  if ('\n' == c) {
    Line++;				// 增加行号
    Linestart = 1;			// 现在在行首了
  }
  return (c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x746e(%rip), %rcx      # 0xe370
movl (%rcx), %eax
testl %eax, %eax
je 0x6f10
andl $0x0, (%rcx)
jmp 0x700a
leaq 0x7469(%rip), %r13      # 0xe380
movq (%r13), %rdi
callq 0x20d0
leaq 0x7445(%rip), %rdx      # 0xe36c
cmpl $0x0, (%rdx)
setne %cl
leaq 0x746c(%rip), %rbx      # 0xe3a0
leaq 0x7455(%rip), %r14      # 0xe390
andl $0x0, (%rdx)
cmpl $0x23, %eax
jne 0x6ff3
testb $0x1, %cl
je 0x6ff3
movq %rbx, %rdi
callq 0x66f4
cmpl $0x33, (%rbx)
leaq 0x746e(%rip), %r15      # 0xe3d0
je 0x6f73
leaq 0x38de(%rip), %rdi      # 0xa849
movq %r15, %rsi
callq 0x641f
movl 0x10(%rbx), %r12d
movq %rbx, %rdi
callq 0x66f4
cmpl $0x34, (%rbx)
je 0x6f93
leaq 0x38e8(%rip), %rdi      # 0xa873
movq %r15, %rsi
callq 0x641f
cmpb $0x3c, (%r15)
je 0x6fc8
movq %r14, %r15
movq (%r14), %rsi
leaq 0x742a(%rip), %rdi      # 0xe3d0
callq 0x20f0
testl %eax, %eax
je 0x6fbe
leaq 0x741a(%rip), %rdi      # 0xe3d0
callq 0x2190
movq %rax, (%r15)
leaq 0x73a3(%rip), %rax      # 0xe368
movl %r12d, (%rax)
movq (%r13), %rdi
callq 0x20d0
cmpl $0xa, %eax
jne 0x6fc8
movq (%r13), %rdi
callq 0x20d0
leaq 0x7386(%rip), %rdx      # 0xe36c
movl $0x1, (%rdx)
movb $0x1, %cl
jmp 0x6f3b
cmpl $0xa, %eax
jne 0x700a
leaq 0x7369(%rip), %rax      # 0xe368
incl (%rax)
movl $0x1, (%rdx)
pushq $0xa
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/scan.c
// Function: scanint
static int scanint(int c) {
  int k, val = 0, radix = 10;

  // 一般都是10进制，除非是0开头
  if (c == '0') {
    // 如果接下来是'x', 16进制
    if ((c = next()) == 'x') {
      radix = 16;
      c = next();
    } else
      // 否则8进制
      radix = 8;

  }

  // 转换字符到整型
  while ((k = chrpos("0123456789abcdef", tolower(c))) >= 0) {
    if (k >= radix)
      fatalc("invalid digit in integer literal", c);
    val = val * radix + k;
    c = next();
  }

  // 遇到非整型字符，放回
  putback(c);
  return (val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x30, %edi
jne 0x7043
callq 0x6eed
cmpl $0x78, %eax
jne 0x7049
pushq $0x10
popq %r13
callq 0x6eed
movl %eax, %ebx
jmp 0x704f
movl %edi, %ebx
pushq $0xa
jmp 0x704d
movl %eax, %ebx
pushq $0x8
popq %r13
xorl %r14d, %r14d
leaq 0x3853(%rip), %r15      # 0xa8ac
movl %ebx, %edi
callq 0x2110
movl %eax, %edi
callq 0x720f
testl %eax, %eax
js 0x708d
movl %eax, %r12d
cmpl %r13d, %eax
jl 0x707d
movq %r15, %rdi
movl %ebx, %esi
callq 0x65c8
imull %r13d, %r14d
addl %r12d, %r14d
callq 0x6eed
movl %eax, %ebx
jmp 0x7059
leaq 0x72dc(%rip), %rax      # 0xe370
movl %ebx, (%rax)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/scan.c
// Function: scanch
static int scanch(void) {
  int i, c, c2;

  // 获取下个字符，并解释那些有反斜杠开头的字符
  c = next();
  if (c == '\\') {
    switch (c = next()) {
      case 'a':
	    return ('\a');
      case 'b':
	    return ('\b');
      case 'f':
	    return ('\f');
      case 'n':
	    return ('\n');
      case 'r':
	    return ('\r');
      case 't':
	    return ('\t');
      case 'v':
	    return ('\v');
      case '\\':
	    return ('\\');
      case '"':
	    return ('"');
      case '\'':
	    return ('\'');

    // 处理8进制，直到碰到不是8进制数字为止
    // 值放在c2，位数放在i，只允许3位8进制数字
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
        for (i = c2 = 0; isdigit(c) && c < '8'; c = next()) {
            if (++i > 3)
                break;
            c2 = c2 * 8 + (c - '0');
        }

	    putback(c);		// 返回非8进制字符
	    return (c2);
      case 'x':
	    return (hexchar());
      default:
	    fatalc("unknown escape sequence", c);
    }
  }
  return (c);			// 返回普通的字符（没有反斜杠转义的）
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x6eed
movl %eax, %ebx
cmpl $0x5c, %eax
jne 0x7204
callq 0x6eed
movl %eax, %ebx
leal -0x30(%rbx), %eax
cmpl $0x8, %eax
jb 0x7117
leal -0x6e(%rbx), %eax
cmpl $0xa, %eax
jbe 0x7161
cmpl $0x22, %ebx
je 0x7204
cmpl $0x27, %ebx
je 0x7204
cmpl $0x5c, %ebx
je 0x7204
cmpl $0x61, %ebx
je 0x7201
cmpl $0x62, %ebx
je 0x71fd
cmpl $0x66, %ebx
jne 0x7178
pushq $0xc
jmp 0x7203
xorl %r15d, %r15d
callq 0x21b0
movq %rax, %r14
movl %ebx, %eax
xorl %ebx, %ebx
cmpl $0x37, %eax
jg 0x7153
movq (%r14), %rcx
movslq %eax, %rdx
movzwl (%rcx,%rdx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
je 0x7153
cmpl $0x2, %r15d
ja 0x7153
incl %r15d
leal (%rax,%rbx,8), %ebx
addl $-0x30, %ebx
callq 0x6eed
jmp 0x7126
leaq 0x7216(%rip), %rcx      # 0xe370
movl %eax, (%rcx)
jmp 0x7204
leaq 0x35ec(%rip), %rcx      # 0xa754
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0xa
jmp 0x7203
leaq 0x374e(%rip), %rdi      # 0xa8cd
movl %ebx, %esi
callq 0x65c8
jmp 0x7204
pushq $0x9
jmp 0x7203
pushq $0xd
jmp 0x7203
xorl %ebx, %ebx
movb $0x1, %r15b
callq 0x21b0
movq %rax, %r14
movq (%r14), %r12
callq 0x6eed
movslq %eax, %rcx
testb $0x10, 0x1(%r12,%rcx,2)
je 0x71c8
movl %eax, %edi
callq 0x2110
movl %eax, %edi
callq 0x720f
shll $0x4, %ebx
addl %eax, %ebx
xorl %r15d, %r15d
jmp 0x719d
leaq 0x71a1(%rip), %rcx      # 0xe370
movl %eax, (%rcx)
testb $0x1, %r15b
je 0x71e3
leaq 0x3707(%rip), %rdi      # 0xa8e5
callq 0x6515
cmpl $0x100, %ebx            # imm = 0x100
jl 0x7204
leaq 0x370d(%rip), %rdi      # 0xa8ff
callq 0x6515
jmp 0x7204
pushq $0xb
jmp 0x7203
pushq $0x8
jmp 0x7203
pushq $0x7
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/scan.c
// Function: chrpos
static int chrpos(char *s, int c) {
  int i;
  for (i = 0; s[i] != '\0'; i++)
    if (s[i] == (char) c)
      return (i);
  return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsbl %dil, %edx
xorl %ecx, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq 0x3676(%rip), %rsi      # 0xa89b
cmpq $0x10, %rcx
je 0x723a
movsbl (%rcx,%rsi), %edi
cmpl %edi, %edx
je 0x7238
incq %rcx
jmp 0x7225
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/stmt.c
// Function: compound_statement
struct ASTnode *compound_statement(int inswitch) {
  struct ASTnode *left = NULL;
  struct ASTnode *tree;

  while (1) {
    // 遇到结束token,
    // 先判断结束token,来允许空的组合语句
    if (Token.token == T_RBRACE)
      return (left);
    if (inswitch && (Token.token == T_CASE || Token.token == T_DEFAULT))
      return (left);

    // 解析单一语句
    tree = single_statement();

    // 对于每个新tree,如果left为空,就保存到left上
    // 否则跟left粘在一起
    if (tree != NULL) {
      if (left == NULL)
	      left = tree;
      else
	      left = mkastnode(A_GLUE, P_NONE, NULL, left, NULL, tree, NULL, 0);
    }
  }
  return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
xorl %eax, %eax
leaq 0x714e(%rip), %r12      # 0xe3a0
pushq $0x1d
popq %r14
movq %rax, %r15
movl (%r12), %eax
cmpl $0x38, %eax
je 0x72a2
testl %ebx, %ebx
setne %cl
addl $-0x2f, %eax
cmpl $0x2, %eax
setb %al
testb %al, %cl
jne 0x72a2
callq 0x72ae
testq %rax, %rax
je 0x7259
testq %r15, %r15
je 0x7256
movl %r14d, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
movq %rax, %r9
pushq $0x0
pushq $0x0
callq 0x8108
addq $0x10, %rsp
jmp 0x7256
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: appendsym
void appendsym(struct symtable **head, struct symtable **tail,
	       struct symtable *node) {

  // 检查指针的有效性
  if (head == NULL || tail == NULL || node == NULL)
    fatal("Either head, tail or node is NULL in appendsym");

  // 加到列表
  if (*tail) {
    (*tail)->next = node;
    *tail = node;
  } else
    *head = *tail = node;
  node->next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
testq %rdx, %rdx
setne %al
testb %al, %cl
jne 0x787b
leaq 0x32b6(%rip), %rdi      # 0xab2c
callq 0x6515
movq (%r15), %rax
leaq 0x38(%rax), %rcx
testq %rax, %rax
cmoveq %r15, %rcx
cmovneq %r15, %r14
movq %rbx, (%rcx)
movq %rbx, (%r14)
andq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: newsym
struct symtable *newsym(char *name, int type, struct symtable *ctype,
			int stype, int class, int nelems, int posn) {

  // 分配内存，创建节点
  struct symtable *node = (struct symtable *) malloc(sizeof(struct symtable));
  if (node == NULL)
    fatal("Unable to malloc a symbol table node in newsym");

  // 填充值
  if (name == NULL)
    node->name = NULL;
  else
    node->name = strdup(name);
  node->type = type;
  node->ctype = ctype;
  node->stype = stype;
  node->class = class;
  node->nelems = nelems;

  // 对于指针和整型，直接设置大小
  // 对于structs/union，后面再设置
  if (ptrtype(type) || inttype(type))
    node->size = nelems * typesize(type, ctype);

  node->stu.st_posn = posn;
  node->next = NULL;
  node->member = NULL;
  node->initlist = NULL;
  return (node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x30(%rbp)
movl %r8d, -0x2c(%rbp)
movl %ecx, %r13d
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
pushq $0x48
popq %rdi
callq 0x2120
movq %rax, %r14
testq %rax, %rax
jne 0x78e1
leaq 0x327f(%rip), %rdi      # 0xab5b
callq 0x6515
testq %rbx, %rbx
je 0x78f0
movq %rbx, %rdi
callq 0x2190
jmp 0x78f2
xorl %eax, %eax
movl 0x10(%rbp), %ebx
movq %rax, 0x8(%r14)
movl %r12d, 0x10(%r14)
movq %r15, 0x18(%r14)
movl %r13d, 0x20(%r14)
movl -0x2c(%rbp), %eax
movl %eax, 0x24(%r14)
movl -0x30(%rbp), %r13d
movl %r13d, 0x2c(%r14)
movl %r12d, %edi
callq 0x8743
testl %eax, %eax
jne 0x792c
movl %r12d, %edi
callq 0x8728
testl %eax, %eax
je 0x793f
movl %r12d, %edi
movq %r15, %rsi
callq 0x87a1
imull %r13d, %eax
movl %eax, 0x28(%r14)
movl %ebx, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
andq $0x0, 0x40(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: addglob
struct symtable *addglob(char *name, int type, struct symtable *ctype,
			 int stype, int class, int nelems, int posn) {
  struct symtable *sym =
    newsym(name, type, ctype, stype, class, nelems, posn);
  // 对于structs/union，从它的类型节点那里拷贝大小
  if (type == P_STRUCT || type == P_UNION)
    sym->size = ctype->size;
  appendsym(&Globhead, &Globtail, sym);
  return (sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x78a3
movq %rax, %r14
cmpl $0x60, %r15d
je 0x798b
cmpl $0x50, %r15d
jne 0x7992
movl 0x28(%rbx), %eax
movl %eax, 0x28(%r14)
leaq 0x6c47(%rip), %rdi      # 0xe5e0
leaq 0x6c48(%rip), %rsi      # 0xe5e8
movq %r14, %rdx
callq 0x7844
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: addlocl
struct symtable *addlocl(char *name, int type, struct symtable *ctype,
			 int stype, int nelems) {
  struct symtable *sym = newsym(name, type, ctype, stype, C_LOCAL, nelems, 0);

  // 对于structs/union，从它的类型节点那里拷贝大小
  if (type == P_STRUCT || type == P_UNION)
    sym->size = ctype->size;
  appendsym(&Loclhead, &Locltail, sym);
  return (sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %r9d
movq %rdx, %rbx
movl %esi, %r15d
andl $0x0, (%rsp)
pushq $0x2
popq %r8
callq 0x78a3
movq %rax, %r14
cmpl $0x60, %r15d
je 0x79e5
cmpl $0x50, %r15d
jne 0x79ec
movl 0x28(%rbx), %eax
movl %eax, 0x28(%r14)
leaq 0x6bfd(%rip), %rdi      # 0xe5f0
leaq 0x6bfe(%rip), %rsi      # 0xe5f8
movq %r14, %rdx
callq 0x7844
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: addmemb
struct symtable *addmemb(char *name, int type, struct symtable *ctype,
			 int stype, int nelems) {
  struct symtable *sym =
    newsym(name, type, ctype, stype, C_MEMBER, nelems, 0);

  // 对于structs/union，从它的类型节点那里拷贝大小
  if (type == P_STRUCT || type == P_UNION)
    sym->size = ctype->size;
  appendsym(&Membhead, &Membtail, sym);
  return (sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %r9d
movq %rdx, %rbx
movl %esi, %r15d
andl $0x0, (%rsp)
pushq $0x8
popq %r8
callq 0x78a3
movq %rax, %r14
cmpl $0x60, %r15d
je 0x7a79
cmpl $0x50, %r15d
jne 0x7a80
movl 0x28(%rbx), %eax
movl %eax, 0x28(%r14)
leaq 0x6b89(%rip), %rdi      # 0xe610
leaq 0x6b8a(%rip), %rsi      # 0xe618
movq %r14, %rdx
callq 0x7844
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: findsyminlist
static struct symtable *findsyminlist(char *s, struct symtable *list,
				      int class) {
  for (; list != NULL; list = list->next)
    if ((list->name != NULL) && !strcmp(s, list->name))
      if (class == 0 || class == list->class)
	return (list);
  return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
testq %rbx, %rbx
je 0x7bee
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x7be8
movq %r15, %rdi
callq 0x20f0
testl %eax, %eax
jne 0x7be8
testl %r14d, %r14d
je 0x7bee
cmpl %r14d, 0x24(%rbx)
je 0x7bee
movq 0x38(%rbx), %rbx
jmp 0x7bc3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: findlocl
struct symtable *findlocl(char *s) {
  struct symtable *node;

  // 如果正在解析函数体，在参数表里面找
  if (Functionid) {
    node = findsyminlist(s, Functionid->member, 0);
    if (node)
      return (node);
  }
  return (findsyminlist(s, Loclhead, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x676c(%rip), %rax      # 0xe378
movq (%rax), %rax
testq %rax, %rax
je 0x7c2e
movq 0x40(%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7bb0
testq %rax, %rax
je 0x7c2e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x69bb(%rip), %rax      # 0xe5f0
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7bb0
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: findsymbol
struct symtable *findsymbol(char *s) {
  struct symtable *node;

  // 如果正在解析函数体，在参数表里面找
  if (Functionid) {
    node = findsyminlist(s, Functionid->member, 0);
    if (node)
      return (node);
  }
  // 否则，尝试在本地和全局列表里面看看
  node = findsyminlist(s, Loclhead, 0);
  if (node)
    return (node);
  return (findsyminlist(s, Globhead, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6720(%rip), %rax      # 0xe378
movq (%rax), %rax
testq %rax, %rax
je 0x7c73
movq 0x40(%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7bb0
testq %rax, %rax
jne 0x7c8c
leaq 0x6976(%rip), %rax      # 0xe5f0
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7bb0
testq %rax, %rax
je 0x7c93
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x6946(%rip), %rax      # 0xe5e0
movq (%rax), %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7bb0
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: clear_symtable
void clear_symtable(void) {
  Globhead = Globtail = NULL;
  Loclhead = Locltail = NULL;
  Parmhead = Parmtail = NULL;
  Membhead = Membtail = NULL;
  Structhead = Structtail = NULL;
  Unionhead = Uniontail = NULL;
  Enumhead = Enumtail = NULL;
  Typehead = Typetail = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x68a6(%rip), %rax      # 0xe5e8
andq $0x0, (%rax)
leaq 0x6893(%rip), %rax      # 0xe5e0
andq $0x0, (%rax)
leaq 0x68a0(%rip), %rax      # 0xe5f8
andq $0x0, (%rax)
leaq 0x688d(%rip), %rax      # 0xe5f0
andq $0x0, (%rax)
leaq 0x689a(%rip), %rax      # 0xe608
andq $0x0, (%rax)
leaq 0x6887(%rip), %rax      # 0xe600
andq $0x0, (%rax)
leaq 0x6894(%rip), %rax      # 0xe618
andq $0x0, (%rax)
leaq 0x6881(%rip), %rax      # 0xe610
andq $0x0, (%rax)
leaq 0x688e(%rip), %rax      # 0xe628
andq $0x0, (%rax)
leaq 0x687b(%rip), %rax      # 0xe620
andq $0x0, (%rax)
leaq 0x6888(%rip), %rax      # 0xe638
andq $0x0, (%rax)
leaq 0x6875(%rip), %rax      # 0xe630
andq $0x0, (%rax)
leaq 0x6882(%rip), %rax      # 0xe648
andq $0x0, (%rax)
leaq 0x686f(%rip), %rax      # 0xe640
andq $0x0, (%rax)
leaq 0x687c(%rip), %rax      # 0xe658
andq $0x0, (%rax)
leaq 0x6869(%rip), %rax      # 0xe650
andq $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: freestaticsyms
void freestaticsyms(void) {
  // g指向当前节点，prev指向前面那个
  struct symtable *g, *prev = NULL;

  // 在全局表里面查找
  for (g = Globhead; g != NULL; g = g->next) {
    if (g->class == C_STATIC) {

      // 如果prev不为空，跳过当前节点
      // 否则， g就是在头部，所以还是跳过当前节点
      if (prev != NULL)
	      prev->next = g->next;
      else
	      Globhead->next = g->next;

      // 如果g在尾部，就把Globtail指向前面那个节点(如果有的话)，或者指向Globhead
      if (g == Globtail) {
        if (prev != NULL)
          Globtail = prev;
        else
          Globtail = Globhead;
      }
    }
     // 在移到下一个节点前，使prev指向g
    prev = g;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x67b3(%rip), %rax      # 0xe5e8
movq (%rax), %rsi
leaq 0x67a1(%rip), %rcx      # 0xe5e0
movq (%rcx), %rcx
xorl %edx, %edx
movq %rcx, %rdi
testq %rdi, %rdi
je 0x7e86
movq %rdx, %r8
movq %rdi, %rdx
cmpl $0x5, 0x24(%rdi)
jne 0x7e6c
movq 0x38(%rdx), %rdi
testq %r8, %r8
je 0x7e72
movq %rdi, 0x38(%r8)
cmpq %rsi, %rdx
jne 0x7e47
jmp 0x7e7e
movq 0x38(%rdx), %rdi
jmp 0x7e47
movq %rdi, 0x38(%rcx)
cmpq %rsi, %rdx
jne 0x7e47
movq %rcx, %r8
movq %r8, (%rax)
movq %r8, %rsi
jmp 0x7e47
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: dumptable
void dumptable(struct symtable *head, char *name, int indent) {
  struct symtable *sym;

  if (head != NULL && name != NULL)
    printf("%s\n--------\n", name);
  for (sym = head; sym != NULL; sym = sym->next)
    dumpsym(sym, indent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x7eb9
leaq 0x2cd8(%rip), %rdi      # 0xab8a
xorl %eax, %eax
callq 0x2090
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
pushq $0x2a
popq %r12
pushq $0x20
popq %r13
testq %r14, %r14
je 0x8094
movl %ebx, %r15d
subl $0x1, %r15d
jb 0x7ee4
movl %r13d, %edi
callq 0x2030
jmp 0x7ed4
movl 0x10(%r14), %eax
addl $-0x10, %eax
shrl $0x4, %eax
cmpl $0x5, %eax
ja 0x7f45
leaq 0x2bee(%rip), %rcx      # 0xaae8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2ca3(%rip), %rdi      # 0xabad
jmp 0x7f4c
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x7f55
movq 0x8(%rax), %rsi
jmp 0x7f59
leaq 0x2c97(%rip), %rdi      # 0xabb9
jmp 0x7f4c
leaq 0x2c93(%rip), %rdi      # 0xabbe
jmp 0x7f4c
leaq 0x2c7f(%rip), %rdi      # 0xabb3
jmp 0x7f4c
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x7f62
movq 0x8(%rax), %rsi
jmp 0x7f66
leaq 0x2c8d(%rip), %rdi      # 0xabd9
xorl %eax, %eax
callq 0x2090
jmp 0x7f74
movq 0x8(%r14), %rsi
leaq 0x2c64(%rip), %rdi      # 0xabc4
jmp 0x7f6d
movq 0x8(%r14), %rsi
leaq 0x2c62(%rip), %rdi      # 0xabcf
xorl %eax, %eax
callq 0x2090
xorl %r15d, %r15d
movl 0x10(%r14), %eax
andl $0xf, %eax
cmpl %eax, %r15d
jae 0x7f90
movl %r12d, %edi
callq 0x2030
incl %r15d
jmp 0x7f77
movq 0x8(%r14), %rsi
leaq 0x2373(%rip), %rdi      # 0xa30e
xorl %eax, %eax
callq 0x2090
movl 0x20(%r14), %eax
testl %eax, %eax
je 0x7fd2
leaq 0x2dd8(%rip), %rdi      # 0xad89
cmpl $0x1, %eax
je 0x7fcb
cmpl $0x2, %eax
jne 0x7fc4
leaq 0x2c25(%rip), %rdi      # 0xabe7
jmp 0x7fcb
leaq 0x2c1f(%rip), %rdi      # 0xabea
xorl %eax, %eax
callq 0x2090
movl 0x24(%r14), %eax
decl %eax
leaq 0x2c7e(%rip), %rdi      # 0xac5d
cmpl $0xa, %eax
ja 0x7ff4
movl %eax, %eax
leaq 0x2b13(%rip), %rcx      # 0xab00
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
xorl %eax, %eax
callq 0x2090
movl 0x20(%r14), %eax
cmpl $0x2, %eax
je 0x802d
cmpl $0x1, %eax
je 0x8020
testl %eax, %eax
jne 0x8057
cmpl $0xa, 0x24(%r14)
jne 0x8045
movl (%r14), %esi
leaq 0x2c4f(%rip), %rdi      # 0xac6d
jmp 0x8050
movl 0x2c(%r14), %esi
leaq 0x2c4e(%rip), %rdi      # 0xac79
jmp 0x8050
movl 0x28(%r14), %edx
movl 0x2c(%r14), %esi
leaq 0x2c4a(%rip), %rdi      # 0xac86
xorl %eax, %eax
callq 0x2090
jmp 0x8057
movl 0x28(%r14), %esi
leaq 0x2c40(%rip), %rdi      # 0xac90
xorl %eax, %eax
callq 0x2090
movl 0x10(%r14), %eax
andl $-0x10, %eax
cmpl $0x60, %eax
je 0x8068
cmpl $0x50, %eax
jne 0x8076
movq 0x40(%r14), %rdi
xorl %esi, %esi
pushq $0x4
popq %rdx
callq 0x7e88
cmpl $0x1, 0x20(%r14)
jne 0x808b
movq 0x40(%r14), %rdi
xorl %esi, %esi
pushq $0x4
popq %rdx
callq 0x7e88
movq 0x38(%r14), %r14
jmp 0x7ec8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/sym.c
// Function: dumpsymtables
void dumpsymtables(void) {
  dumptable(Globhead, "Global", 0);
  printf("\n");
  dumptable(Enumhead, "Enums", 0);
  printf("\n");
  dumptable(Typehead, "Typedefs", 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x6530(%rip), %rax      # 0xe5e0
movq (%rax), %rdi
leaq 0x2add(%rip), %rsi      # 0xab97
xorl %edx, %edx
callq 0x7e88
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x2030
leaq 0x656e(%rip), %rax      # 0xe640
movq (%rax), %rdi
leaq 0x2ac2(%rip), %rsi      # 0xab9e
xorl %edx, %edx
callq 0x7e88
movl %ebx, %edi
callq 0x2030
leaq 0x655f(%rip), %rax      # 0xe650
movq (%rax), %rdi
leaq 0x2aa9(%rip), %rsi      # 0xaba4
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7e88
// File: /workspace/github_c_makefile_star2_O2/ejunjsh[P]mycc/tree.c
// Function: mkastnode
struct ASTnode *mkastnode(int op, int type,
			  struct symtable *ctype,
			  struct ASTnode *left,
			  struct ASTnode *mid,
			  struct ASTnode *right,
			  struct symtable *sym, int intvalue) {
  struct ASTnode *n;

  // 给新节点分配内存
  n = (struct ASTnode *) malloc(sizeof(struct ASTnode));
  if (n == NULL)
    fatal("Unable to malloc in mkastnode()");

  // 复制数据到这个新节点并返回
  n->op = op;
  n->type = type;
  n->ctype = ctype;
  n->left = left;
  n->mid = mid;
  n->right = right;
  n->sym = sym;
  n->atu.a_intvalue = intvalue;
  n->linenum= 0;
  return (n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x38(%rbp)
movq %r8, -0x30(%rbp)
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %r13d
movl %edi, %r14d
pushq $0x48
popq %rdi
callq 0x2120
movq %rax, %rbx
testq %rax, %rax
jne 0x8149
leaq 0x2c28(%rip), %rdi      # 0xad6c
callq 0x6515
movl %r14d, 0x4(%rbx)
movl %r13d, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq %r15, 0x20(%rbx)
movq -0x30(%rbp), %rax
movq %rax, 0x28(%rbx)
movq -0x38(%rbp), %rax
movq %rax, 0x30(%rbx)
movq 0x10(%rbp), %rax
movq %rax, 0x38(%rbx)
movl 0x18(%rbp), %eax
movl %eax, (%rbx)
andl $0x0, 0x40(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/events/events_counter.c
// Function: events_counter_ping
void
events_counter_ping(void)
{

	/* Print the current count. */
	printf("event %d\n", events_counter);

	/* Increment. */
	events_counter++;

	/* Check to see if we should interrupt the events. */
	if (events_counter == INTERRUPT_AT) {
		if (raise(SIGUSR1)) {
			warnp("raise(SIGUSR1) failed");
			exit(1);
		}
	}

	/* Emergency exit for runaway loops. */
	if (events_counter > INTERRUPT_BAIL) {
		warn0("events_interrupt() is broken.");
		exit(1);
	}
}

// Assembly:
pushq %rbx
movl 0x5dae(%rip), %esi      # 0x83d0
leaq 0x2a34(%rip), %rdi      # 0x505d
xorl %eax, %eax
callq 0x20e0
movl 0x5d9a(%rip), %eax      # 0x83d0
incl %eax
movl %eax, 0x5d92(%rip)      # 0x83d0
cmpl $0x4, %eax
jne 0x2655
pushq $0xa
popq %rdi
callq 0x2030
testl %eax, %eax
jne 0x2674
movl 0x5d7b(%rip), %eax      # 0x83d0
cmpl $0xb, %eax
jge 0x265c
popq %rbx
retq
leaq 0x2a1a(%rip), %rdi      # 0x507d
xorl %eax, %eax
callq 0x3cfc
callq 0x2070
andl $0x0, (%rax)
jmp 0x26a2
callq 0x2070
cmpl $0x0, (%rax)
jne 0x268e
leaq 0x29e2(%rip), %rdi      # 0x5067
xorl %eax, %eax
callq 0x3cfc
jmp 0x26a2
movq %rax, %rbx
leaq 0x29cf(%rip), %rdi      # 0x5067
xorl %eax, %eax
callq 0x3b6d
andl $0x0, (%rbx)
pushq $0x1
popq %rdi
callq 0x21f0
nop
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/events/events_interrupter.c
// Function: events_interrupter_init
int
events_interrupter_init(void)
{
	struct sigaction sa;

	/* Clear the flag. */
	events_interrupter_reset();

	/* Set up the SIGUSR1 handler. */
	sa.sa_handler = interrupt;
	if (sigemptyset(&sa.sa_mask)) {
		warnp("siginfo");
		goto err0;
	}
	sa.sa_flags = 0;
	if (sigaction(SIGUSR1, &sa, NULL)) {
		warnp("sigaction");
		goto err0;
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movl $0x0, 0x5d16(%rip)      # 0x83d4
leaq 0x94(%rip), %rax        # 0x2759
leaq 0x10(%rsp), %rdi
movq %rax, -0x8(%rdi)
callq 0x2150
testl %eax, %eax
je 0x26ed
callq 0x2070
cmpl $0x0, (%rax)
je 0x2729
movq %rax, %rbx
leaq 0x29cc(%rip), %rdi      # 0x50b7
jmp 0x271d
leaq 0x8(%rsp), %rsi
andl $0x0, 0x88(%rsi)
xorl %ebx, %ebx
pushq $0xa
popq %rdi
xorl %edx, %edx
callq 0x2090
testl %eax, %eax
je 0x2743
callq 0x2070
cmpl $0x0, (%rax)
je 0x2732
movq %rax, %rbx
leaq 0x29a2(%rip), %rdi      # 0x50bf
xorl %eax, %eax
callq 0x3b6d
andl $0x0, (%rbx)
jmp 0x2740
leaq 0x2987(%rip), %rdi      # 0x50b7
jmp 0x2739
leaq 0x2986(%rip), %rdi      # 0x50bf
xorl %eax, %eax
callq 0x3cfc
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/uhlin[P]enhanced-duc/source/daemonize.c
// Function: daemonize
void
daemonize(void)
{
	switch (fork()) {
	case FORK_FAILED:
		fatal(errno, "daemonize: cannot fork");
		break;
	case VALUE_CHILD_PROCESS:
		if (setsid() == -1)
			fatal(errno, "daemonize: trouble in becoming "
			    "the session leader");
		break;
	default:
		_exit(0);
	}

	/* Calls to the log functions before this log to stderr/stdout. */
	log_init();

	switch (redirect_standard_streams()) {
	case REDIR_STDERR_FAIL:
		log_warn(0, "daemonize: error redirecting stderr");
		break;
	case REDIR_STDIN_FAIL:
		log_warn(0, "daemonize: error redirecting stdin");
		break;
	case REDIR_STDOUT_FAIL:
		log_warn(0, "daemonize: error redirecting stdout");
		break;
	default:
	case REDIR_OK:
		log_debug("daemonize: all standard io-streams successfully "
		    "redirected");
		break;
	}

	if (is_already_running()) {
		fatal(0, "daemonize: fatal: a copy of the daemon is already "
		    "running!");
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
callq 0x4100
testl %eax, %eax
jne 0x4e26
callq 0x4490
cmpl $-0x1, %eax
je 0x4e42
callq 0x5725
callq 0x5488
cmpl $0x3, %eax
je 0x4d90
cmpl $0x2, %eax
je 0x4d87
cmpl $0x1, %eax
jne 0x4da2
leaq 0x435e(%rip), %rsi      # 0x90e3
jmp 0x4d97
leaq 0x4379(%rip), %rsi      # 0x9107
jmp 0x4d97
leaq 0x4393(%rip), %rsi      # 0x912a
xorl %edi, %edi
xorl %eax, %eax
callq 0x57ea
jmp 0x4db0
leaq 0x43a5(%rip), %rdi      # 0x914e
xorl %eax, %eax
callq 0x5684
movups 0x4469(%rip), %xmm0     # 0x9220
movaps %xmm0, 0x10(%rsp)
movups 0x444d(%rip), %xmm0     # 0x9210
movaps %xmm0, (%rsp)
leaq 0x42b2(%rip), %rdi      # 0x9080
pushq $0x42
popq %rsi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x4310
cmpl $-0x1, %eax
je 0x4e52
movl %eax, %ebx
pushq $0x6
popq %rsi
movq %rsp, %rdx
movl %eax, %edi
xorl %eax, %eax
callq 0x4270
cmpl $-0x1, %eax
je 0x4e69
movl %ebx, %edi
xorl %esi, %esi
callq 0x4600
callq 0x4680
movslq %eax, %rdx
leaq 0x43f8(%rip), %rsi      # 0x9208
movl %ebx, %edi
xorl %eax, %eax
callq 0x4240
movl %ebx, 0x9601(%rip)      # 0xe420
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
cmpl $-0x1, %eax
jne 0x4e3b
callq 0x4050
movl (%rax), %edi
leaq 0x4261(%rip), %rsi      # 0x909a
jmp 0x4e8a
xorl %edi, %edi
callq 0x4710
callq 0x4050
movl (%rax), %edi
leaq 0x4261(%rip), %rsi      # 0x90b1
jmp 0x4e8a
callq 0x4050
movl (%rax), %edi
leaq 0x4364(%rip), %rsi      # 0x91c4
leaq 0x4219(%rip), %rdx      # 0x9080
jmp 0x4ea1
callq 0x4050
movl (%rax), %ebp
movl %ebx, %edi
callq 0x47f0
cmpl $0xb, %ebp
je 0x4e81
cmpl $0xd, %ebp
jne 0x4e91
leaq 0x4301(%rip), %rsi      # 0x9189
xorl %edi, %edi
xorl %eax, %eax
callq 0x5513
leaq 0x434e(%rip), %rsi      # 0x91e6
leaq 0x41e1(%rip), %rdx      # 0x9080
movl %ebp, %edi
xorl %eax, %eax
callq 0x5513
// File: /workspace/github_c_makefile_star2_O2/uhlin[P]enhanced-duc/source/interpreter.cpp
// Function: Interpreter_processAllLines
void
Interpreter_processAllLines(FILE *fp, const char *path, Interpreter_vFunc func1,
    Interpreter_instFunc func2)
{
	char		buf[MAXLINE] = { '\0' };
	long int	line_num = 0;

	while (fgets(buf, sizeof buf, fp) != nullptr) {
		char			*line;
		const char		*cp;
		struct Interpreter_in	 in;

		cp = &buf[0];
		eatwhite(&cp);
		if (strings_match(cp, "") || *cp == CommentChar) {
			line_num++;
			continue;
		}

		line = trim(xstrdup(cp));

		in.path			= const_cast<char *>(path);
		in.line			= line;
		in.line_num		= ++line_num;
		in.validator_func	= func1;
		in.install_func		= func2;
		Interpreter(&in);

		free(line);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xcd8, %rsp            # imm = 0xCD8
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
leaq 0x50(%rsp), %r13
xorl %r15d, %r15d
movl $0xc80, %edx            # imm = 0xC80
movq %r13, %rdi
xorl %esi, %esi
callq 0x4220
leaq 0x8(%rsp), %rbp
leaq 0x4afb(%rip), %rbx      # 0x9ecb
movq %r13, %rdi
movl $0xc80, %esi            # imm = 0xC80
movq %r12, %rdx
callq 0x46f0
testq %rax, %rax
je 0x546a
movq %r13, 0x8(%rsp)
movq %rbp, %rdi
callq 0x5337
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x537d
testb %al, %al
jne 0x5410
cmpb $0x23, (%r14)
jne 0x5415
incq %r15
jmp 0x53d0
movq %r14, %rdi
callq 0x851e
movq %rax, %rdi
callq 0x8332
movq %rax, %r14
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %r14, 0x30(%rsp)
incq %r15
movq %r15, 0x38(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4ea8
movq %r14, %rdi
callq 0x4530
jmp 0x53d0
addq $0xcd8, %rsp            # imm = 0xCD8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/uhlin[P]enhanced-duc/source/log.c
// Function: redirect_standard_streams
redir_res_t
redirect_standard_streams(void)
{
	const char dev_null[] = "/dev/null";

	if (freopen(dev_null, "r+", stderr) == NULL)
		return REDIR_STDERR_FAIL;
	else if (freopen(dev_null, "r+", stdin) == NULL)
		return REDIR_STDIN_FAIL;
	else if (freopen(dev_null, "r+", stdout) == NULL)
		return REDIR_STDOUT_FAIL;
	return REDIR_OK;
}

// Assembly:
subq $0x18, %rsp
movabsq $0x6c756e2f7665642f, %rax # imm = 0x6C756E2F7665642F
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movw $0x6c, 0x8(%rdi)
movq 0x8b15(%rip), %rax      # 0xdfc0
movq (%rax), %rdx
leaq 0x3f87(%rip), %rsi      # 0x943c
callq 0x4450
testq %rax, %rax
je 0x5507
movq 0x8ada(%rip), %rax      # 0xdfa0
movq (%rax), %rdx
leaq 0x3f6c(%rip), %rsi      # 0x943c
leaq 0x8(%rsp), %rdi
callq 0x4450
testq %rax, %rax
je 0x550b
movq 0x8a9a(%rip), %rax      # 0xdf80
movq (%rax), %rdx
leaq 0x3f4c(%rip), %rsi      # 0x943c
leaq 0x8(%rsp), %rdi
callq 0x4450
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
leal (%rcx,%rcx,2), %eax
jmp 0x550e
pushq $0x1
jmp 0x550d
pushq $0x2
popq %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/uhlin[P]enhanced-duc/source/log.c
// Function: log_doit
static void
log_doit(int errCode, int priority, const char *fmt, va_list ap)
{
	char buf[2000] = { '\0' };

	(void) vsnprintf(buf, sizeof buf, fmt, ap);

	if (errCode) {
		(void) snprintf(&buf[strlen(buf)], sizeof buf - strlen(buf),
		    ": %s", strerror(errCode));
	}

	if (g_log_to_syslog)
		syslog(priority, "%s", buf);
	else {
		FILE *stream = stderr;

		switch (priority) {
		case LOG_INFO:
		case LOG_DEBUG:
			stream = stdout;
			break;
		}

		(void) fputs(buf, stream);
		(void) fputc('\n', stream);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7d8, %rsp            # imm = 0x7D8
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movl %edi, %ebp
movq %rsp, %r13
movl $0x7d0, %r14d           # imm = 0x7D0
movl $0x7d0, %edx            # imm = 0x7D0
movq %r13, %rdi
xorl %esi, %esi
callq 0x4220
movl $0x7d0, %esi            # imm = 0x7D0
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x42a0
testl %ebp, %ebp
je 0x5614
movq %rsp, %rdi
callq 0x41c0
leaq (%rsp,%rax), %r15
subq %rax, %r14
movl %ebp, %edi
callq 0x4160
leaq 0x5ba4(%rip), %rdx      # 0xb1a8
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x4700
cmpb $0x1, 0x90f6(%rip)      # 0xe711
jne 0x5642
leaq 0x4829(%rip), %rsi      # 0x9e4d
movq %rsp, %rdx
movl %ebx, %edi
xorl %eax, %eax
callq 0x40b0
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andl $-0x2, %ebx
cmpl $0x6, %ebx
jne 0x5653
movq 0x892f(%rip), %rax      # 0xdf80
jmp 0x565a
movq 0x8966(%rip), %rax      # 0xdfc0
movq (%rax), %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x44f0
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4550
// File: /workspace/github_c_makefile_star2_O2/uhlin[P]enhanced-duc/source/main.c
// Function: usage
static __dead void
usage(void)
{
	extern char *__progname;
	char *msgVersion = strdup_printf("%s%s%s %s by %s\n",
	    MAGENTA, g_programName, NORMAL,
	    g_programVersion,
	    g_programAuthor);
	char *msgUsage = strdup_printf("Usage: %s [OPTION] ...\n", __progname);

	(void) fputs(msgVersion, stderr);

	(void) fputc('\n', stderr);
	(void) fputs(msgUsage, stderr);

	free(msgVersion);
	free(msgUsage);

	for (const char **ppcc = &help_text[0];
	     ppcc < &help_text[nitems(help_text)]; ppcc++)
		(void) fputs(*ppcc, stderr);
	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x34bf(%rip), %rdi      # 0x97b2
leaq 0x34c9(%rip), %rsi      # 0x97c3
leaq 0x315f(%rip), %rdx      # 0x9460
leaq 0x34c1(%rip), %rcx      # 0x97c9
leaq 0x315e(%rip), %r8       # 0x946d
leaq 0x315c(%rip), %r9       # 0x9472
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x8468
movq %rax, %rbx
movq 0x7c7e(%rip), %rax      # 0xdfa8
movq (%rax), %rsi
leaq 0x349a(%rip), %rdi      # 0x97ce
xorl %eax, %eax
callq 0x8468
movq %rax, %r14
movq 0x7c7b(%rip), %r12      # 0xdfc0
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x44f0
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x4550
movq (%r12), %rsi
movq %r14, %rdi
callq 0x44f0
movq %rbx, %rdi
callq 0x4530
movq %r14, %rdi
callq 0x4530
leaq 0x7710(%rip), %rbx      # 0xda90
cmpq $0x60, %r15
jae 0x6399
movq (%r15,%rbx), %rdi
movq (%r12), %rsi
callq 0x44f0
addq $0x8, %r15
jmp 0x6380
pushq $0x1
popq %rdi
callq 0x4540
// File: /workspace/github_c_makefile_star2_O2/uhlin[P]enhanced-duc/source/my_vasprintf.c
// Function: my_vasprintf
int
my_vasprintf(char **ret, const char *format, va_list ap)
{
	va_list ap_copy;
	int sz;

	if (ret == NULL || format == NULL) {
		errno = EINVAL;
		return -1;
	}

	va_copy(ap_copy, ap);
	sz = vsnprintf(NULL, 0, format, ap_copy);
	va_end(ap_copy);

	if (sz < 0) {
		*ret = NULL;
		errno = ENOSYS;
		return -1;
	} else {
		sz += 1; /* +1 for `\0'. */
	}

	if ((*ret = malloc(sz)) == NULL) {
		errno = ENOMEM;
		return -1;
	}

	return vsnprintf(*ret, sz, format, ap);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x63d8
callq 0x4050
movl $0x16, (%rax)
jmp 0x6447
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdx), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x42a0
testl %eax, %eax
js 0x642b
movl %eax, %r12d
incl %r12d
movq %r12, %rdi
callq 0x45d0
movq %rax, (%r15)
testq %rax, %rax
je 0x643c
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x42a0
jmp 0x644a
andq $0x0, (%r15)
callq 0x4050
movl $0x26, (%rax)
jmp 0x6447
callq 0x4050
movl $0xc, (%rax)
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/uhlin[P]enhanced-duc/source/log.h
// Function: log_assert_arg_nonnull
__DUC_END_DECLS

static inline void
log_assert_arg_nonnull(const char *in_func, const char *arg_name,
		       const void *arg)
{
	if (arg == NULL) {
		fatal(EINVAL, "In %s: Argument \"%s\" is null  --  "
		    "assertion failed!",
		    (in_func ? in_func : "(no in_func)"),
		    (arg_name ? arg_name : "(no arg_name)"));
	}
}

// Assembly:
testq %rdx, %rdx
je 0x66c9
retq
pushq %rax
testq %rdi, %rdi
leaq 0x3b5b(%rip), %rdx      # 0xa22f
cmovneq %rdi, %rdx
testq %rsi, %rsi
leaq 0x3b5a(%rip), %rcx      # 0xa23c
cmovneq %rsi, %rcx
leaq 0x3b0e(%rip), %rsi      # 0xa1fb
pushq $0x16
popq %rdi
xorl %eax, %eax
callq 0x5513
// File: /workspace/github_c_makefile_star2_O2/uhlin[P]enhanced-duc/source/network-openssl.c
// Function: net_ssl_begin
int
net_ssl_begin(void)
{
	const char		*err_reason = "";
	static const int	 VALUE_HANDSHAKE_OK = 1;

	if (ssl != NULL) {
		err_reason = "the ssl object appears to be non-null";
		goto err;
	} else if ((ssl = SSL_new(ssl_ctx)) == NULL) {
		fatal(ENOMEM, "%s: unable to create a new ssl object",
		    __func__);
	} else if (!SSL_set_fd(ssl, g_socket)) {
		err_reason = "unable to associate the global socket fd with "
		    "the ssl object";
		goto err;
	}

	SSL_set_connect_state(ssl);

	if (SSL_connect(ssl) != VALUE_HANDSHAKE_OK) {
		err_reason = "handshake not ok!";
		goto err;
	}

	return 0;

  err:
	log_warn(0, "%s: %s", __func__, err_reason);
	return -1;
}

// Assembly:
pushq %rax
cmpq $0x0, 0x7f2a(%rip)      # 0xe7e0
je 0x68db
leaq 0x37b6(%rip), %rcx      # 0xa075
leaq 0x3858(%rip), %rsi      # 0xa11e
leaq 0x37f4(%rip), %rdx      # 0xa0c1
xorl %edi, %edi
xorl %eax, %eax
callq 0x57ea
pushq $-0x1
popq %rax
popq %rcx
retq
movq 0x7f06(%rip), %rdi      # 0xe7e8
callq 0x4430
movq %rax, 0x7ef2(%rip)      # 0xe7e0
testq %rax, %rax
je 0x693b
leaq 0x7b56(%rip), %rcx      # 0xe450
movl (%rcx), %esi
movq %rax, %rdi
callq 0x4290
testl %eax, %eax
je 0x6932
movq 0x7ed1(%rip), %rdi      # 0xe7e0
callq 0x4170
movq 0x7ec5(%rip), %rdi      # 0xe7e0
callq 0x4650
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
je 0x68d9
leaq 0x37dc(%rip), %rcx      # 0xa10c
jmp 0x68bf
leaq 0x3796(%rip), %rcx      # 0xa0cf
jmp 0x68bf
leaq 0x3759(%rip), %rsi      # 0xa09b
leaq 0x3778(%rip), %rdx      # 0xa0c1
pushq $0xc
popq %rdi
xorl %eax, %eax
callq 0x5513
// File: /workspace/github_c_makefile_star2_O2/uhlin[P]enhanced-duc/source/network-openssl.c
// Function: net_ssl_end
void
net_ssl_end(void)
{
	if (ssl) {
		switch (SSL_shutdown(ssl)) {
		case 0:
			log_debug("%s: SSL_shutdown: not yet finished",
			    __func__);
			(void) SSL_shutdown(ssl);
			break;
		case 1:
			/* success! */
			break;
		default:
			log_warn(0, "%s: SSL_shutdown: error", __func__);
			break;
		}

		SSL_free(ssl);
		ssl = NULL;
	}
}

// Assembly:
movq 0x7e86(%rip), %rdi      # 0xe7e0
testq %rdi, %rdi
je 0x69c0
pushq %rax
callq 0x44e0
cmpl $0x1, %eax
je 0x69a8
testl %eax, %eax
jne 0x6991
leaq 0x37b0(%rip), %rdi      # 0xa125
leaq 0x37cc(%rip), %rsi      # 0xa148
xorl %eax, %eax
callq 0x5684
movq 0x7e56(%rip), %rdi      # 0xe7e0
callq 0x44e0
jmp 0x69a8
leaq 0x37bc(%rip), %rsi      # 0xa154
leaq 0x37a9(%rip), %rdx      # 0xa148
xorl %edi, %edi
xorl %eax, %eax
callq 0x57ea
movq 0x7e31(%rip), %rdi      # 0xe7e0
callq 0x4250
andq $0x0, 0x7e24(%rip)      # 0xe7e0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/uhlin[P]enhanced-duc/source/network-openssl.c
// Function: verify_callback
static int
verify_callback(int ok, X509_STORE_CTX *ctx)
{
	X509		*cert = X509_STORE_CTX_get_current_cert(ctx);
	char		 issuer[256] = { '\0' };
	char		 subject[256] = { '\0' };
	const int	 depth = X509_STORE_CTX_get_error_depth(ctx);
	const int	 err = X509_STORE_CTX_get_error(ctx);

	(void) X509_NAME_oneline(X509_get_issuer_name(cert), issuer,
	    sizeof issuer);
	(void) X509_NAME_oneline(X509_get_subject_name(cert), subject,
	    sizeof subject);

	if (!ok) {
		log_warn(0, "Error with certificate at depth: %d", depth);
		log_warn(0, "  issuer  = %s", issuer);
		log_warn(0, "  subject = %s", subject);
		log_warn(0, "Reason: %s", X509_verify_cert_error_string(err));
	} else {
		log_debug("Cert verification OK!");
		log_debug("  issuer  = %s", issuer);
		log_debug("  subject = %s", subject);
	}
	return (ok);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbp
movl %edi, %ebx
movq %rsi, %rdi
callq 0x4740
movq %rax, %r14
leaq 0x100(%rsp), %r12
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
xorl %esi, %esi
callq 0x4220
movq %rsp, %r13
movl $0x100, %edx            # imm = 0x100
movq %r13, %rdi
xorl %esi, %esi
callq 0x4220
movq %rbp, %rdi
callq 0x42c0
movl %eax, %r15d
movq %rbp, %rdi
callq 0x4320
movl %eax, %ebp
movq %r14, %rdi
callq 0x4420
movq %rax, %rdi
movq %r12, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4300
movq %r14, %rdi
callq 0x4460
movq %rax, %rdi
movq %r13, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x4300
testl %ebx, %ebx
je 0x6c4c
leaq 0x36f1(%rip), %rdi      # 0xa30d
xorl %eax, %eax
callq 0x5684
leaq 0x36ba(%rip), %rdi      # 0xa2e4
leaq 0x100(%rsp), %rsi
xorl %eax, %eax
callq 0x5684
leaq 0x36b3(%rip), %rdi      # 0xa2f3
movq %rsp, %rsi
xorl %eax, %eax
callq 0x5684
jmp 0x6ca5
leaq 0x366d(%rip), %rsi      # 0xa2c0
xorl %edi, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x57ea
leaq 0x367e(%rip), %rsi      # 0xa2e4
leaq 0x100(%rsp), %rdx
xorl %edi, %edi
xorl %eax, %eax
callq 0x57ea
leaq 0x3675(%rip), %rsi      # 0xa2f3
movq %rsp, %rdx
xorl %edi, %edi
xorl %eax, %eax
callq 0x57ea
movslq %ebp, %rdi
callq 0x42e0
leaq 0x3669(%rip), %rsi      # 0xa302
xorl %edi, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x57ea
movl %ebx, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/uhlin[P]enhanced-duc/source/network-openssl.c
// Function: net_ssl_deinit
void
net_ssl_deinit(void)
{
	net_ssl_end();

	if (ssl_ctx) {
		SSL_CTX_free(ssl_ctx);
		ssl_ctx = NULL;
	}
}

// Assembly:
pushq %rax
callq 0x6953
movq 0x7b22(%rip), %rdi      # 0xe7e8
testq %rdi, %rdi
je 0x6cd8
callq 0x4090
andq $0x0, 0x7b10(%rip)      # 0xe7e8
popq %rax
retq
nop