LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
movl %edi, %ebx
movl $0xa, %r12d
cmpl $0x30, %edi
jne 0x710c
callq 0x6f8f
cmpl $0x78, %eax
jne 0x7104
movl $0x10, %r12d
callq 0x6f8f
movl %eax, %ebx
jmp 0x710c
movl %eax, %ebx
movl $0x8, %r12d
xorl %r14d, %r14d
leaq 0x4785(%rip), %r13      # 0xb89b
movl %ebx, %edi
callq 0x2110
movsbl %al, %eax
movb $0x30, %cl
xorl %r15d, %r15d
movsbl %cl, %ecx
cmpl %ecx, %eax
je 0x713c
movb 0x1(%r15,%r13), %cl
incq %r15
cmpq $0x10, %r15
jne 0x7125
jmp 0x7162
cmpl %r15d, %r12d
jg 0x714f
leaq 0x4764(%rip), %rdi      # 0xb8ac
movl %ebx, %esi
callq 0x69ee
imull %r12d, %r14d
addl %r14d, %r15d
callq 0x6f8f
movl %eax, %ebx
movl %r15d, %r14d
jmp 0x7116
leaq 0x8207(%rip), %rax      # 0xf370
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_O3/ejunjsh[P]mycc/scan.c
// Function: scanstr
static int scanstr(char *buf) {
  int i, c;

  // 循环直到没有缓存
  for (i = 0; i < TEXTLEN - 1; i++) {
    // 获取下一个字符，并放入到buf， 直到遇到双引号
    if ((c = scanch()) == '"') {
      buf[i] = 0;
      return (i);
    }
    buf[i] = (char)c;
  }

  // 用完buf[]空间
  fatal("String literal too long");
  return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
leaq 0x806b(%rip), %r14      # 0xf3d0
callq 0x717d
cmpl $0x22, %eax
je 0x738f
movb %al, (%r14,%rbx)
incq %rbx
cmpq $0x1ff, %rbx            # imm = 0x1FF
jne 0x7365
leaq 0x4597(%rip), %rdi      # 0xb91d
popq %rbx
popq %r14
popq %rbp
jmp 0x6937
movb $0x0, (%r14,%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ejunjsh[P]mycc/scan.c
// Function: scanident
static int scanident(int c, char *buf, int lim) {
  int i = 0;

  // 允许数字，字母，下划线
  while (isalpha(c) || isdigit(c) || '_' == c) {
    // 如果超过标识符长度限制，就报错，
    // 否则放入到buf[],并获取下个字符
    if (lim - 1 == i) {
      fatal("Identifier too long");
    } else if (i < lim - 1) {
      buf[i++] = (char)c;
    }
    c = next();
  }

  // 遇到无效字符，放回
  // 0作为终结符放到buf[]中，并返回长度
  putback(c);
  buf[i] = '\0';
  return (i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r15d
xorl %r13d, %r13d
callq 0x21a0
movq %rax, %rbx
leaq 0x4579(%rip), %r14      # 0xb935
leaq 0x800d(%rip), %r12      # 0xf3d0
movq (%rbx), %rax
movslq %r15d, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xa, %eax
jb 0x73e0
cmpl $0x5f, %r15d
je 0x73e0
andl $0x800, %eax            # imm = 0x800
je 0x740f
cmpl $0x1ff, %r13d           # imm = 0x1FF
jne 0x73f9
movq %r14, %rdi
callq 0x6937
movl $0x1ff, %r13d           # imm = 0x1FF
jmp 0x7405
jge 0x7405
movslq %r13d, %rax
incl %r13d
movb %r15b, (%r12,%rax)
callq 0x6f8f
movl %eax, %r15d
jmp 0x73c3
leaq 0x7f5a(%rip), %rax      # 0xf370
movl %r15d, (%rax)
movslq %r13d, %rax
movb $0x0, (%r12,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
leaq 0x7cff(%rip), %r15      # 0xf3a0
movl (%r15), %eax
cmpl $0x38, %eax
jne 0x76ae
xorl %r14d, %r14d
jmp 0x76fe
movl %edi, %ebx
xorl %r14d, %r14d
testl %ebx, %ebx
setne %cl
addl $-0x2f, %eax
cmpl $0x2, %eax
setb %al
testb %al, %cl
jne 0x76fe
callq 0x770c
testq %rax, %rax
je 0x76f6
testq %r14, %r14
je 0x76f3
movl $0x1d, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
xorl %r8d, %r8d
movq %rax, %r9
pushq $0x0
pushq $0x0
callq 0x8828
addq $0x10, %rsp
movq %rax, %r14
movl (%r15), %eax
cmpl $0x38, %eax
jne 0x76b3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7cef
leaq 0x3e42(%rip), %rdi      # 0xbb2c
callq 0x6937
movq (%r15), %rax
leaq 0x38(%rax), %rcx
testq %rax, %rax
cmoveq %r15, %rcx
cmovneq %r15, %r14
movq %rbx, (%rcx)
movq %rbx, (%r14)
movq $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x48, %edi
callq 0x2120
movq %rax, %r14
testq %rax, %rax
jne 0x7d5a
leaq 0x3e06(%rip), %rdi      # 0xbb5b
callq 0x6937
testq %rbx, %rbx
je 0x7d69
movq %rbx, %rdi
callq 0x2180
jmp 0x7d6b
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 0x8e43
testl %eax, %eax
jne 0x7da5
movl %r12d, %edi
callq 0x8e28
testl %eax, %eax
je 0x7db8
movl %r12d, %edi
movq %r15, %rsi
callq 0x8ea1
imull %r13d, %eax
movl %eax, 0x28(%r14)
movl %ebx, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
movq $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_O3/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, %r14
movl %esi, %r15d
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x7d1a
movq %rax, %rbx
cmpl $0x60, %r15d
je 0x7e07
cmpl $0x50, %r15d
jne 0x7e10
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
jmp 0x7e21
testq %rbx, %rbx
jne 0x7e21
leaq 0x3d10(%rip), %rdi      # 0xbb2c
callq 0x6937
leaq 0x77c0(%rip), %rax      # 0xf5e8
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x7e3c
movq %rax, %rcx
leaq 0x77a6(%rip), %rax      # 0xf5e0
jmp 0x7e40
addq $0x38, %rcx
movq %rbx, (%rcx)
movq %rbx, (%rax)
movq $0x0, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movl %esi, %r15d
movl $0x0, (%rsp)
movl $0x2, %r8d
callq 0x7d1a
movq %rax, %rbx
cmpl $0x60, %r15d
je 0x7e90
cmpl $0x50, %r15d
jne 0x7e99
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
jmp 0x7eaa
testq %rbx, %rbx
jne 0x7eaa
leaq 0x3c87(%rip), %rdi      # 0xbb2c
callq 0x6937
leaq 0x7747(%rip), %rax      # 0xf5f8
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x7ec5
movq %rax, %rcx
leaq 0x772d(%rip), %rax      # 0xf5f0
jmp 0x7ec9
addq $0x38, %rcx
movq %rbx, (%rcx)
movq %rbx, (%rax)
movq $0x0, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movl %esi, %r15d
movl $0x0, (%rsp)
movl $0x8, %r8d
callq 0x7d1a
movq %rax, %rbx
cmpl $0x60, %r15d
je 0x7f82
cmpl $0x50, %r15d
jne 0x7f8b
movl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
jmp 0x7f9c
testq %rbx, %rbx
jne 0x7f9c
leaq 0x3b95(%rip), %rdi      # 0xbb2c
callq 0x6937
leaq 0x7675(%rip), %rax      # 0xf618
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x7fb7
movq %rax, %rcx
leaq 0x765b(%rip), %rax      # 0xf610
jmp 0x7fbb
addq $0x38, %rcx
movq %rbx, (%rcx)
movq %rbx, (%rax)
movq $0x0, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x8207
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x81fe
movq %r15, %rdi
callq 0x20f0
testl %eax, %eax
jne 0x81fe
testl %r14d, %r14d
je 0x8209
cmpl %r14d, 0x24(%rbx)
je 0x8209
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0x81de
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %r14
leaq 0x7150(%rip), %rax      # 0xf378
movq (%rax), %rax
testq %rax, %rax
je 0x8254
movq 0x40(%rax), %rbx
testq %rbx, %rbx
je 0x8254
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x824e
movq %r14, %rdi
callq 0x20f0
testl %eax, %eax
je 0x8280
movq 0x38(%rbx), %rbx
jmp 0x8234
leaq 0x7395(%rip), %rax      # 0xf5f0
movq (%rax), %rbx
testq %rbx, %rbx
je 0x827e
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x8278
movq %r14, %rdi
callq 0x20f0
testl %eax, %eax
je 0x8280
movq 0x38(%rbx), %rbx
jmp 0x825e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %r14
leaq 0x70df(%rip), %rax      # 0xf378
movq (%rax), %rax
testq %rax, %rax
je 0x82c5
movq 0x40(%rax), %rbx
testq %rbx, %rbx
je 0x82c5
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x82bf
movq %r14, %rdi
callq 0x20f0
testl %eax, %eax
je 0x831b
movq 0x38(%rbx), %rbx
jmp 0x82a5
leaq 0x7324(%rip), %rax      # 0xf5f0
movq (%rax), %rbx
testq %rbx, %rbx
je 0x82ef
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x82e9
movq %r14, %rdi
callq 0x20f0
testl %eax, %eax
je 0x831b
movq 0x38(%rbx), %rbx
jmp 0x82cf
leaq 0x72ea(%rip), %rax      # 0xf5e0
movq (%rax), %rbx
testq %rbx, %rbx
je 0x8319
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x8313
movq %r14, %rdi
callq 0x20f0
testl %eax, %eax
je 0x831b
movq 0x38(%rbx), %rbx
jmp 0x82f9
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7184(%rip), %rcx      # 0xf5e8
xorl %eax, %eax
movq %rax, (%rcx)
leaq 0x7170(%rip), %rcx      # 0xf5e0
movq %rax, (%rcx)
leaq 0x717e(%rip), %rcx      # 0xf5f8
movq %rax, (%rcx)
leaq 0x716c(%rip), %rcx      # 0xf5f0
movq %rax, (%rcx)
leaq 0x717a(%rip), %rcx      # 0xf608
movq %rax, (%rcx)
leaq 0x7168(%rip), %rcx      # 0xf600
movq %rax, (%rcx)
leaq 0x7176(%rip), %rcx      # 0xf618
movq %rax, (%rcx)
leaq 0x7164(%rip), %rcx      # 0xf610
movq %rax, (%rcx)
leaq 0x7172(%rip), %rcx      # 0xf628
movq %rax, (%rcx)
leaq 0x7160(%rip), %rcx      # 0xf620
movq %rax, (%rcx)
leaq 0x716e(%rip), %rcx      # 0xf638
movq %rax, (%rcx)
leaq 0x715c(%rip), %rcx      # 0xf630
movq %rax, (%rcx)
leaq 0x716a(%rip), %rcx      # 0xf648
movq %rax, (%rcx)
leaq 0x7158(%rip), %rcx      # 0xf640
movq %rax, (%rcx)
leaq 0x7166(%rip), %rcx      # 0xf658
movq %rax, (%rcx)
leaq 0x7154(%rip), %rcx      # 0xf650
movq %rax, (%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x709a(%rip), %rax      # 0xf5e0
movq (%rax), %rax
testq %rax, %rax
je 0x859f
leaq 0x7093(%rip), %rcx      # 0xf5e8
movq (%rcx), %rsi
xorl %edx, %edx
movq %rax, %rdi
movq %rdx, %r8
movq %rdi, %rdx
cmpl $0x5, 0x24(%rdi)
jne 0x8583
movq 0x38(%rdx), %rdi
testq %r8, %r8
je 0x858e
movq %rdi, 0x38(%r8)
cmpq %rsi, %rdx
jne 0x8587
movq %r8, (%rcx)
movq %r8, %rsi
jmp 0x8587
movq 0x38(%rdx), %rdi
testq %rdi, %rdi
jne 0x855d
jmp 0x859f
movq %rdi, 0x38(%rax)
cmpq %rsi, %rdx
jne 0x8587
movq %rax, (%rcx)
movq %rax, %rsi
jmp 0x8587
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x85d4
leaq 0x35bf(%rip), %rdi      # 0xbb8a
xorl %eax, %eax
callq 0x2090
jmp 0x85dd
testq %r14, %r14
je 0x87b5
leaq 0x3679(%rip), %r15      # 0xbc5d
leaq 0x34fd(%rip), %r12      # 0xbae8
testl %ebx, %ebx
jle 0x8601
movl %ebx, %r13d
movl $0x20, %edi
callq 0x2030
decl %r13d
jne 0x85f2
movl 0x10(%r14), %eax
addl $-0x10, %eax
shrl $0x4, %eax
cmpl $0x5, %eax
ja 0x865b
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
leaq 0x358d(%rip), %rdi      # 0xbbad
jmp 0x8662
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x866b
movq 0x8(%rax), %rsi
jmp 0x866f
leaq 0x3581(%rip), %rdi      # 0xbbb9
jmp 0x8662
leaq 0x357d(%rip), %rdi      # 0xbbbe
jmp 0x8662
leaq 0x3569(%rip), %rdi      # 0xbbb3
jmp 0x8662
movq 0x18(%r14), %rax
testq %rax, %rax
je 0x8678
movq 0x8(%rax), %rsi
jmp 0x867c
leaq 0x3577(%rip), %rdi      # 0xbbd9
xorl %eax, %eax
callq 0x2090
jmp 0x868a
movq 0x8(%r14), %rsi
leaq 0x354e(%rip), %rdi      # 0xbbc4
jmp 0x8683
movq 0x8(%r14), %rsi
leaq 0x354c(%rip), %rdi      # 0xbbcf
xorl %eax, %eax
callq 0x2090
testb $0xf, 0x10(%r14)
je 0x86ad
xorl %r13d, %r13d
movl $0x2a, %edi
callq 0x2030
incl %r13d
movl 0x10(%r14), %eax
andl $0xf, %eax
cmpl %eax, %r13d
jb 0x8694
movq 0x8(%r14), %rsi
leaq 0x2c56(%rip), %rdi      # 0xb30e
xorl %eax, %eax
callq 0x2090
movl 0x20(%r14), %eax
testl %eax, %eax
je 0x86ef
leaq 0x36bb(%rip), %rdi      # 0xbd89
cmpl $0x1, %eax
je 0x86e8
cmpl $0x2, %eax
jne 0x86e1
leaq 0x3508(%rip), %rdi      # 0xbbe7
jmp 0x86e8
leaq 0x3502(%rip), %rdi      # 0xbbea
xorl %eax, %eax
callq 0x2090
movl 0x24(%r14), %eax
decl %eax
movq %r15, %rdi
cmpl $0xa, %eax
ja 0x870d
movl %eax, %eax
leaq 0x33fa(%rip), %rcx      # 0xbb00
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
xorl %eax, %eax
callq 0x2090
movl 0x20(%r14), %eax
cmpl $0x2, %eax
je 0x8746
cmpl $0x1, %eax
je 0x8739
testl %eax, %eax
jne 0x8770
cmpl $0xa, 0x24(%r14)
jne 0x875e
movl (%r14), %esi
leaq 0x3536(%rip), %rdi      # 0xbc6d
jmp 0x8769
movl 0x2c(%r14), %esi
leaq 0x3535(%rip), %rdi      # 0xbc79
jmp 0x8769
movl 0x28(%r14), %edx
movl 0x2c(%r14), %esi
leaq 0x3531(%rip), %rdi      # 0xbc86
xorl %eax, %eax
callq 0x2090
jmp 0x8770
movl 0x28(%r14), %esi
leaq 0x3527(%rip), %rdi      # 0xbc90
xorl %eax, %eax
callq 0x2090
movl 0x10(%r14), %eax
andl $-0x10, %eax
cmpl $0x60, %eax
je 0x8781
cmpl $0x50, %eax
jne 0x8791
movq 0x40(%r14), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x85a1
cmpl $0x1, 0x20(%r14)
jne 0x87a8
movq 0x40(%r14), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x85a1
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0x85eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x6e11(%rip), %rax      # 0xf5e0
movq (%rax), %rdi
leaq 0x33be(%rip), %rsi      # 0xbb97
xorl %edx, %edx
callq 0x85a1
movl $0xa, %edi
callq 0x2030
leaq 0x6e4f(%rip), %rax      # 0xf640
movq (%rax), %rdi
leaq 0x33a3(%rip), %rsi      # 0xbb9e
xorl %edx, %edx
callq 0x85a1
movl $0xa, %edi
callq 0x2030
leaq 0x6e3d(%rip), %rax      # 0xf650
movq (%rax), %rdi
leaq 0x3387(%rip), %rsi      # 0xbba4
xorl %edx, %edx
popq %rbp
jmp 0x85a1
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x5c73(%rip), %esi      # 0x83d0
leaq 0x28f9(%rip), %rdi      # 0x505d
xorl %eax, %eax
callq 0x20e0
movl 0x5c5f(%rip), %eax      # 0x83d0
incl %eax
movl %eax, 0x5c57(%rip)      # 0x83d0
cmpl $0x4, %eax
jne 0x2792
movl $0xa, %edi
callq 0x2030
testl %eax, %eax
jne 0x27b4
movl 0x5c3e(%rip), %eax      # 0x83d0
cmpl $0xb, %eax
jge 0x2799
popq %rbx
retq
leaq 0x28dd(%rip), %rdi      # 0x507d
xorl %eax, %eax
callq 0x40f7
callq 0x2070
movl $0x0, (%rax)
jmp 0x27e5
callq 0x2070
cmpl $0x0, (%rax)
jne 0x27ce
leaq 0x28a2(%rip), %rdi      # 0x5067
xorl %eax, %eax
callq 0x40f7
jmp 0x27e5
movq %rax, %rbx
leaq 0x288f(%rip), %rdi      # 0x5067
xorl %eax, %eax
callq 0x3fd8
movl $0x0, (%rbx)
movl $0x1, %edi
callq 0x21f0
nop
// File: /workspace/github_c_makefile_star2_O3/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, 0x5bd2(%rip)      # 0x83d4
leaq 0x9e(%rip), %rax        # 0x28a7
leaq 0x10(%rsp), %rdi
movq %rax, -0x8(%rdi)
callq 0x2150
testl %eax, %eax
je 0x2831
callq 0x2070
cmpl $0x0, (%rax)
je 0x2875
movq %rax, %rbx
leaq 0x2888(%rip), %rdi      # 0x50b7
jmp 0x2866
leaq 0x8(%rsp), %rsi
movl $0x0, 0x88(%rsi)
xorl %ebx, %ebx
movl $0xa, %edi
xorl %edx, %edx
callq 0x2090
testl %eax, %eax
je 0x2891
callq 0x2070
cmpl $0x0, (%rax)
je 0x287e
movq %rax, %rbx
leaq 0x2859(%rip), %rdi      # 0x50bf
xorl %eax, %eax
callq 0x3fd8
movl $0x0, (%rbx)
jmp 0x288c
leaq 0x283b(%rip), %rdi      # 0x50b7
jmp 0x2885
leaq 0x283a(%rip), %rdi      # 0x50bf
xorl %eax, %eax
callq 0x40f7
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4e62
callq 0x4490
cmpl $-0x1, %eax
je 0x4e7e
callq 0x57c4
callq 0x551c
cmpl $0x3, %eax
je 0x4dc8
cmpl $0x2, %eax
je 0x4dbf
cmpl $0x1, %eax
jne 0x4dda
leaq 0x4306(%rip), %rsi      # 0x90c3
jmp 0x4dcf
leaq 0x4321(%rip), %rsi      # 0x90e7
jmp 0x4dcf
leaq 0x433b(%rip), %rsi      # 0x910a
xorl %edi, %edi
xorl %eax, %eax
callq 0x588f
jmp 0x4de8
leaq 0x434d(%rip), %rdi      # 0x912e
xorl %eax, %eax
callq 0x5721
movups 0x4411(%rip), %xmm0     # 0x9200
movaps %xmm0, 0x10(%rsp)
movups 0x43f5(%rip), %xmm0     # 0x91f0
movaps %xmm0, (%rsp)
leaq 0x425a(%rip), %rdi      # 0x9060
movl $0x42, %esi
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x4310
cmpl $-0x1, %eax
je 0x4e8e
movl %eax, %ebx
movq %rsp, %rdx
movl %eax, %edi
movl $0x6, %esi
xorl %eax, %eax
callq 0x4270
cmpl $-0x1, %eax
je 0x4ea5
movl %ebx, %edi
xorl %esi, %esi
callq 0x4610
callq 0x4690
movslq %eax, %rdx
leaq 0x439c(%rip), %rsi      # 0x91e8
movl %ebx, %edi
xorl %eax, %eax
callq 0x4240
movl %ebx, 0x95c5(%rip)      # 0xe420
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
cmpl $-0x1, %eax
jne 0x4e77
callq 0x4050
movl (%rax), %edi
leaq 0x4205(%rip), %rsi      # 0x907a
jmp 0x4ec6
xorl %edi, %edi
callq 0x4720
callq 0x4050
movl (%rax), %edi
leaq 0x4205(%rip), %rsi      # 0x9091
jmp 0x4ec6
callq 0x4050
movl (%rax), %edi
leaq 0x4308(%rip), %rsi      # 0x91a4
leaq 0x41bd(%rip), %rdx      # 0x9060
jmp 0x4edd
callq 0x4050
movl (%rax), %ebp
movl %ebx, %edi
callq 0x4800
cmpl $0xb, %ebp
je 0x4ebd
cmpl $0xd, %ebp
jne 0x4ecd
leaq 0x42a5(%rip), %rsi      # 0x9169
xorl %edi, %edi
xorl %eax, %eax
callq 0x55ac
leaq 0x42f2(%rip), %rsi      # 0x91c6
leaq 0x4185(%rip), %rdx      # 0x9060
movl %ebp, %edi
xorl %eax, %eax
callq 0x55ac
// File: /workspace/github_c_makefile_star2_O3/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 $0xcc8, %rsp            # imm = 0xCC8
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r12
leaq 0x40(%rsp), %rbp
movl $0xc80, %edx            # imm = 0xC80
movq %rbp, %rdi
xorl %esi, %esi
callq 0x4220
movq %rbp, %rdi
movl $0xc80, %esi            # imm = 0xC80
movq %r12, %rdx
callq 0x4700
testq %rax, %rax
je 0x54fd
xorl %ebx, %ebx
movb 0x40(%rsp), %r14b
movsbl %r14b, %edi
callq 0x4080
movq %rbp, %r13
testl %eax, %eax
je 0x5486
movq %rbp, %r13
movb 0x1(%r13), %r14b
incq %r13
movsbl %r14b, %edi
callq 0x4080
testl %eax, %eax
jne 0x5472
cmpb $0x23, %r14b
je 0x5494
movzbl %r14b, %eax
testl %eax, %eax
jne 0x5499
incq %rbx
jmp 0x54e4
movq %r13, %rdi
callq 0x86ae
movq %rax, %rdi
callq 0x84bc
movq %rax, %r13
movq %r15, 0x18(%rsp)
movq %rax, 0x20(%rsp)
incq %rbx
movq %rbx, 0x28(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4ee4
movq %r13, %rdi
callq 0x4540
movq %rbp, %rdi
movl $0xc80, %esi            # imm = 0xC80
movq %r12, %rdx
callq 0x4700
testq %rax, %rax
jne 0x545a
addq $0xcc8, %rsp            # imm = 0xCC8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8a81(%rip), %rax      # 0xdfc0
movq (%rax), %rdx
leaq 0x3ed3(%rip), %rsi      # 0x941c
callq 0x4450
testq %rax, %rax
je 0x559b
movq 0x8a46(%rip), %rax      # 0xdfa0
movq (%rax), %rdx
leaq 0x3eb8(%rip), %rsi      # 0x941c
leaq 0x8(%rsp), %rdi
callq 0x4450
testq %rax, %rax
je 0x55a2
movq 0x8a06(%rip), %rax      # 0xdf80
movq (%rax), %rdx
leaq 0x3e98(%rip), %rsi      # 0x941c
leaq 0x8(%rsp), %rdi
callq 0x4450
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
leal (%rcx,%rcx,2), %eax
jmp 0x55a7
movl $0x1, %eax
jmp 0x55a7
movl $0x2, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x56af
movq %rsp, %rdi
callq 0x41c0
leaq (%rsp,%rax), %r15
subq %rax, %r14
movl %ebp, %edi
callq 0x4160
leaq 0x5ab9(%rip), %rdx      # 0xb158
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x4710
cmpb $0x1, 0x905b(%rip)      # 0xe711
jne 0x56dd
leaq 0x476e(%rip), %rsi      # 0x9e2d
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 0x56ee
movq 0x8894(%rip), %rax      # 0xdf80
jmp 0x56f5
movq 0x88cb(%rip), %rax      # 0xdfc0
movq (%rax), %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x44f0
movl $0xa, %edi
movq %rbx, %rsi
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4560
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x342a(%rip), %rdi      # 0x9792
leaq 0x3434(%rip), %rsi      # 0x97a3
leaq 0x30ca(%rip), %rdx      # 0x9440
leaq 0x342c(%rip), %rcx      # 0x97a9
leaq 0x30c9(%rip), %r8       # 0x944d
leaq 0x30c7(%rip), %r9       # 0x9452
xorl %eax, %eax
callq 0x85f8
movq %rax, %rbx
movq 0x7c0c(%rip), %rax      # 0xdfa8
movq (%rax), %rsi
leaq 0x3408(%rip), %rdi      # 0x97ae
xorl %eax, %eax
callq 0x85f8
movq %rax, %r14
movq 0x7c09(%rip), %r15      # 0xdfc0
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x44f0
movq (%r15), %rsi
movl $0xa, %edi
callq 0x4560
movq (%r15), %rsi
movq %r14, %rdi
callq 0x44f0
movq %rbx, %rdi
callq 0x4540
movq %r14, %rdi
callq 0x4540
movq $-0x8, %rbx
leaq 0x7698(%rip), %r14      # 0xda90
movq 0x8(%rbx,%r14), %rdi
movq (%r15), %rsi
callq 0x44f0
addq $0x8, %rbx
cmpq $0x58, %rbx
jb 0x63f8
movl $0x1, %edi
callq 0x4550
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x6444
callq 0x4050
movl $0x16, (%rax)
jmp 0x64b6
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 0x6497
movl %eax, %r12d
incl %r12d
movq %r12, %rdi
callq 0x45e0
movq %rax, (%r15)
testq %rax, %rax
je 0x64ab
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x42a0
jmp 0x64bb
movq $0x0, (%r15)
callq 0x4050
movl $0x26, (%rax)
jmp 0x64b6
callq 0x4050
movl $0xc, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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, 0x7e85(%rip)      # 0xe7e0
je 0x6982
leaq 0x36f1(%rip), %rcx      # 0xa055
leaq 0x3793(%rip), %rsi      # 0xa0fe
leaq 0x372f(%rip), %rdx      # 0xa0a1
xorl %edi, %edi
xorl %eax, %eax
callq 0x588f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
movq 0x7e5f(%rip), %rdi      # 0xe7e8
callq 0x4430
movq %rax, 0x7e4b(%rip)      # 0xe7e0
testq %rax, %rax
je 0x69e2
leaq 0x7aaf(%rip), %rcx      # 0xe450
movl (%rcx), %esi
movq %rax, %rdi
callq 0x4290
testl %eax, %eax
je 0x69d9
movq 0x7e2a(%rip), %rdi      # 0xe7e0
callq 0x4170
movq 0x7e1e(%rip), %rdi      # 0xe7e0
callq 0x4660
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
je 0x6980
leaq 0x3715(%rip), %rcx      # 0xa0ec
jmp 0x6964
leaq 0x36cf(%rip), %rcx      # 0xa0af
jmp 0x6964
leaq 0x3692(%rip), %rsi      # 0xa07b
leaq 0x36b1(%rip), %rdx      # 0xa0a1
movl $0xc, %edi
xorl %eax, %eax
callq 0x55ac
// File: /workspace/github_c_makefile_star2_O3/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 0x7ddd(%rip), %rdi      # 0xe7e0
testq %rdi, %rdi
je 0x6a6c
pushq %rax
callq 0x44e0
cmpl $0x1, %eax
je 0x6a51
testl %eax, %eax
jne 0x6a3a
leaq 0x36e7(%rip), %rdi      # 0xa105
leaq 0x3703(%rip), %rsi      # 0xa128
xorl %eax, %eax
callq 0x5721
movq 0x7dad(%rip), %rdi      # 0xe7e0
callq 0x44e0
jmp 0x6a51
leaq 0x36f3(%rip), %rsi      # 0xa134
leaq 0x36e0(%rip), %rdx      # 0xa128
xorl %edi, %edi
xorl %eax, %eax
callq 0x588f
movq 0x7d88(%rip), %rdi      # 0xe7e0
callq 0x4250
movq $0x0, 0x7d78(%rip) # 0xe7e0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4750
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 0x6d17
leaq 0x35eb(%rip), %rdi      # 0xa2d2
xorl %eax, %eax
callq 0x5721
leaq 0x35b4(%rip), %rdi      # 0xa2a9
leaq 0x100(%rsp), %rsi
xorl %eax, %eax
callq 0x5721
leaq 0x35ad(%rip), %rdi      # 0xa2b8
movq %rsp, %rsi
xorl %eax, %eax
callq 0x5721
jmp 0x6d70
leaq 0x3567(%rip), %rsi      # 0xa285
xorl %edi, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x588f
leaq 0x3578(%rip), %rsi      # 0xa2a9
leaq 0x100(%rsp), %rdx
xorl %edi, %edi
xorl %eax, %eax
callq 0x588f
leaq 0x356f(%rip), %rsi      # 0xa2b8
movq %rsp, %rdx
xorl %edi, %edi
xorl %eax, %eax
callq 0x588f
movslq %ebp, %rdi
callq 0x42e0
leaq 0x3563(%rip), %rsi      # 0xa2c7
xorl %edi, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x588f
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_O3/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 0x69fc
movq 0x7a57(%rip), %rdi      # 0xe7e8
testq %rdi, %rdi
je 0x6da6
callq 0x4090
movq $0x0, 0x7a42(%rip) # 0xe7e8
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/uhlin[P]enhanced-duc/source/network.c
// Function: net_send_plain
int
net_send_plain(const char *fmt, ...)
{
	bool		 ok = true;
	char		*buf = NULL;
	size_t		 newSize = 0;
	static const char
			 message_terminate[] = "\r\n\r\n";
	va_list		 ap;

	log_assert_arg_nonnull("net_send_plain", "fmt", fmt);

	va_start(ap, fmt);
	if (errno = 0, my_vasprintf(&buf, fmt, ap) < 0)
		fatal(errno, "net_send_plain: my_vasprintf");
	va_end(ap);

	newSize = strlen(buf) + nitems(message_terminate);
	buf = xrealloc(buf, newSize);

	if (strlcat(buf, message_terminate, newSize) >= newSize)
		fatal(EOVERFLOW, "net_send_plain: strlcat");
	if (errno = 0, send(g_socket, buf, strlen(buf), 0) == -1)
		ok = false;
	if (!ok)
		log_warn(errno, "net_send_plain: send");
	free(buf);
	return (ok ? 0 : -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x6e0c
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x6f13
movq %rdi, %r14
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %r15
movq %rax, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r15)
callq 0x4050
movq %rax, %rbx
movl $0x0, (%rax)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x641c
testl %eax, %eax
js 0x6f34
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x41c0
movq %rax, %r15
addq $0x5, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x87f1
movq %rax, 0x8(%rsp)
leaq 0x37af(%rip), %rsi      # 0xa648
movq %rax, %rdi
movq %r15, %rdx
callq 0x81fc
cmpq %r15, %rax
jae 0x6f3f
movl $0x0, (%rbx)
movl 0x7597(%rip), %ebp      # 0xe450
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x41c0
movl %ebp, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x4200
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x6eee
movl (%rbx), %edi
leaq 0x357a(%rip), %rsi      # 0xa461
xorl %eax, %eax
callq 0x588f
xorl %ebx, %ebx
cmpq $-0x1, %r14
sete %bl
movq 0x8(%rsp), %rdi
callq 0x4540
negl %ebx
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x32c1(%rip), %rsi      # 0xa1db
leaq 0x34fc(%rip), %rdx      # 0xa41d
leaq 0x3047(%rip), %rcx      # 0x9f6f
movl $0x16, %edi
xorl %eax, %eax
callq 0x55ac
movl (%rbx), %edi
leaq 0x34ef(%rip), %rsi      # 0xa42c
jmp 0x6f4b
leaq 0x3503(%rip), %rsi      # 0xa449
movl $0x4b, %edi
xorl %eax, %eax
callq 0x55ac
// File: /workspace/github_c_makefile_star2_O3/uhlin[P]enhanced-duc/source/network.c
// Function: net_recv_plain
int
net_recv_plain(char *recvbuf, size_t recvbuf_size)
{
#if IO_MULTIPLEXING
	const int	 maxfdp1 = g_socket + 1;
	fd_set		 readset;
	struct timeval	 tv;

	tv.tv_sec	= 10;
	tv.tv_usec	= 333;

	FD_ZERO(&readset);
	FD_SET(g_socket, &readset);

	if (select(maxfdp1, &readset, NULL, NULL, &tv) == -1) {
		log_warn(errno, "net_recv_plain: select");
		return -1;
	} else if (!FD_ISSET(g_socket, &readset)) {
		log_warn(0, "net_recv_plain: no data to receive  --  "
		    "timed out!");
		return -1;
	}
#endif /* IO_MULTIPLEXING */

	log_assert_arg_nonnull("net_recv_plain", "recvbuf", recvbuf);

	switch (recv(g_socket, recvbuf, recvbuf_size, 0)) {
	case -1:
		log_warn(errno, "net_recv_plain: recv");
		return -1;
	case 0:
		log_warn(0, "net_recv_plain: fatal: connection lost");
		return -1;
	default:
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x74e7(%rip), %ecx      # 0xe450
movq %rsp, %r8
movq $0xa, (%r8)
movq $0x14d, 0x8(%r8)        # imm = 0x14D
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
leal 0x1(%rcx), %edi
leal 0x3f(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
movl %eax, %edx
andl $-0x40, %edx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
sarl $0x6, %eax
cltq
orq %rdx, 0x10(%rsp,%rax,8)
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x43d0
cmpl $-0x1, %eax
je 0x7021
movl 0x7476(%rip), %edi      # 0xe450
leal 0x3f(%rdi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
sarl $0x6, %eax
cltq
movq 0x10(%rsp,%rax,8), %rax
btq %rdi, %rax
jae 0x7031
testq %r14, %r14
je 0x705d
xorl %ebp, %ebp
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x4150
testq %rax, %rax
je 0x703a
cmpq $-0x1, %rax
jne 0x704f
callq 0x4050
movl (%rax), %edi
leaq 0x34b0(%rip), %rsi      # 0xa4cf
jmp 0x7043
callq 0x4050
movl (%rax), %edi
leaq 0x3447(%rip), %rsi      # 0xa476
jmp 0x7043
leaq 0x3455(%rip), %rsi      # 0xa48d
jmp 0x7041
leaq 0x34a3(%rip), %rsi      # 0xa4e4
xorl %edi, %edi
xorl %eax, %eax
callq 0x588f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3177(%rip), %rsi      # 0xa1db
leaq 0x3455(%rip), %rdx      # 0xa4c0
leaq 0x2f8d(%rip), %rcx      # 0x9fff
movl $0x16, %edi
xorl %eax, %eax
callq 0x55ac
// File: /workspace/github_c_makefile_star2_O3/uhlin[P]enhanced-duc/source/network.c
// Function: net_connect
int
net_connect(void)
{
	bool			 connected = false;
	const char		*host = setting("sp_hostname");
	const char		*port = setting("port");
	struct addrinfo		*res, *rp;

	log_debug("connecting to %s (%s)...", host, port);

	if ((res = net_addr_resolve(host, port)) == NULL) {
		log_warn(0, "unable to get a list of ip addresses. "
		    "bogus hostname?");
		return -1;
	} else {
		log_debug("get a list of ip addresses complete");
	}

	for (rp = res; rp; rp = rp->ai_next) {
		g_socket =
		    socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);

		if (g_socket == SOCKET_CREATION_FAILED) {
			continue;
		} else if (connect(g_socket, rp->ai_addr, rp->ai_addrlen) == 0) {
			log_debug("connected!");
			connected = true;
			break;
		} else {
			(void) close(g_socket);
		}
	}

	freeaddrinfo(res);

	if (!connected || (ssl_is_enabled() && net_ssl_begin() == -1)) {
		log_warn(0, "failed to establish a connection");
		return -1;
	}
	if (ssl_is_enabled() &&
	    net_ssl_check_hostname(host, 0) == HOSTNAME_MISMATCH) {
		log_warn(0, "net_ssl_check_hostname: warning: "
		    "hostname checking failed: "
		    "hostname specified by 'sp_hostname' mismatch: "
		    "failed to establish a connection");
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2d29(%rip), %rdi      # 0x9db5
callq 0x7889
movq %rax, %rbx
leaq 0x3275(%rip), %rdi      # 0xa310
callq 0x7889
movq %rax, %r14
leaq 0x326b(%rip), %rdi      # 0xa315
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5721
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71ce
testq %rax, %rax
je 0x712f
movq %rax, %r14
leaq 0x3293(%rip), %rdi      # 0xa364
xorl %eax, %eax
callq 0x5721
movq %r14, %r15
movl 0x4(%r15), %edi
movl 0x8(%r15), %esi
movl 0xc(%r15), %edx
callq 0x40f0
movl %eax, 0x735e(%rip)      # 0xe450
cmpl $-0x1, %eax
je 0x7115
movq 0x18(%r15), %rsi
movl 0x10(%r15), %edx
movl %eax, %edi
callq 0x4360
testl %eax, %eax
je 0x7151
movl 0x7340(%rip), %edi      # 0xe450
callq 0x4800
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0x70db
movq %r14, %rdi
callq 0x45c0
leaq 0x32cf(%rip), %rsi      # 0xa3fc
jmp 0x7136
leaq 0x31f8(%rip), %rsi      # 0xa32e
xorl %edi, %edi
xorl %eax, %eax
callq 0x588f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3230(%rip), %rdi      # 0xa388
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x5721
movq %r14, %rdi
callq 0x45c0
leaq 0x31a0(%rip), %rdi      # 0xa310
callq 0x7889
leaq 0x34c8(%rip), %rsi      # 0xa644
movq %rax, %rdi
callq 0x4640
testl %eax, %eax
jne 0x7192
callq 0x6952
cmpl $-0x1, %eax
je 0x7126
leaq 0x3177(%rip), %rdi      # 0xa310
callq 0x7889
leaq 0x349f(%rip), %rsi      # 0xa644
movq %rax, %rdi
callq 0x4640
testl %eax, %eax
jne 0x7144
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x64c8
cmpl $0x1, %eax
jne 0x7144
leaq 0x31ca(%rip), %rsi      # 0xa393
jmp 0x7136