LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x48, %edi
callq 0x2100
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9ea2
leaq 0x408a(%rip), %rdi      # 0xdf27
callq 0x8110
cmpq $0x0, -0x8(%rbp)
jne 0x9eb7
movq -0x30(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x9ecb
movq -0x8(%rbp), %rdi
callq 0x2150
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x2c(%rax)
movl -0xc(%rbp), %edi
callq 0xb720
cmpl $0x0, %eax
jne 0x9f19
movl -0xc(%rbp), %edi
callq 0xb6e0
cmpl $0x0, %eax
je 0x9f38
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xb7c0
movl -0x34(%rbp), %ecx
imull %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x28(%rax)
movl 0x10(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x9e60
movq %rax, -0x30(%rbp)
cmpl $0x50, -0xc(%rbp)
je 0x9fc2
cmpl $0x60, -0xc(%rbp)
jne 0x9fd0
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x30(%rbp), %rdx
leaq 0x8795(%rip), %rdi      # 0x12770
leaq 0x8796(%rip), %rsi      # 0x12778
callq 0x9de0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r9d
movl $0x2, %r8d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x9e60
movq %rax, -0x28(%rbp)
cmpl $0x50, -0xc(%rbp)
je 0xa050
cmpl $0x60, -0xc(%rbp)
jne 0xa05e
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x28(%rbp), %rdx
leaq 0x8717(%rip), %rdi      # 0x12780
leaq 0x8718(%rip), %rsi      # 0x12788
callq 0x9de0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r9d
movl $0x8, %r8d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x9e60
movq %rax, -0x28(%rbp)
cmpl $0x50, -0xc(%rbp)
je 0xa140
cmpl $0x60, -0xc(%rbp)
jne 0xa14e
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x28(%rbp), %rdx
leaq 0x8647(%rip), %rdi      # 0x127a0
leaq 0x8648(%rip), %rsi      # 0x127a8
callq 0x9de0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa389
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa379
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x20d0
cmpl $0x0, %eax
jne 0xa379
cmpl $0x0, -0x1c(%rbp)
je 0xa36d
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jne 0xa377
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa391
jmp 0xa379
jmp 0xa37b
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xa333
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x8155(%rip), %rax      # 0x12508
cmpq $0x0, (%rax)
je 0xa3e9
movq -0x10(%rbp), %rdi
leaq 0x8144(%rip), %rax      # 0x12508
movq (%rax), %rax
movq 0x40(%rax), %rsi
xorl %edx, %edx
callq 0xa320
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa3e7
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa402
jmp 0xa3e9
movq -0x10(%rbp), %rdi
leaq 0x838c(%rip), %rax      # 0x12780
movq (%rax), %rsi
xorl %edx, %edx
callq 0xa320
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x80e5(%rip), %rax      # 0x12508
cmpq $0x0, (%rax)
je 0xa459
movq -0x10(%rbp), %rdi
leaq 0x80d4(%rip), %rax      # 0x12508
movq (%rax), %rax
movq 0x40(%rax), %rsi
xorl %edx, %edx
callq 0xa320
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa457
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa49c
jmp 0xa459
movq -0x10(%rbp), %rdi
leaq 0x831c(%rip), %rax      # 0x12780
movq (%rax), %rsi
xorl %edx, %edx
callq 0xa320
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa483
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa49c
movq -0x10(%rbp), %rdi
leaq 0x82e2(%rip), %rax      # 0x12770
movq (%rax), %rsi
xorl %edx, %edx
callq 0xa320
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x819d(%rip), %rax      # 0x12778
movq $0x0, (%rax)
leaq 0x8187(%rip), %rax      # 0x12770
movq $0x0, (%rax)
leaq 0x8191(%rip), %rax      # 0x12788
movq $0x0, (%rax)
leaq 0x817b(%rip), %rax      # 0x12780
movq $0x0, (%rax)
leaq 0x8185(%rip), %rax      # 0x12798
movq $0x0, (%rax)
leaq 0x816f(%rip), %rax      # 0x12790
movq $0x0, (%rax)
leaq 0x8179(%rip), %rax      # 0x127a8
movq $0x0, (%rax)
leaq 0x8163(%rip), %rax      # 0x127a0
movq $0x0, (%rax)
leaq 0x816d(%rip), %rax      # 0x127b8
movq $0x0, (%rax)
leaq 0x8157(%rip), %rax      # 0x127b0
movq $0x0, (%rax)
leaq 0x8161(%rip), %rax      # 0x127c8
movq $0x0, (%rax)
leaq 0x814b(%rip), %rax      # 0x127c0
movq $0x0, (%rax)
leaq 0x8155(%rip), %rax      # 0x127d8
movq $0x0, (%rax)
leaq 0x813f(%rip), %rax      # 0x127d0
movq $0x0, (%rax)
leaq 0x8149(%rip), %rax      # 0x127e8
movq $0x0, (%rax)
leaq 0x8133(%rip), %rax      # 0x127e0
movq $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq $0x0, -0x10(%rbp)
leaq 0x804d(%rip), %rax      # 0x12770
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa7c6
movq -0x8(%rbp), %rax
cmpl $0x5, 0x24(%rax)
jne 0xa7ad
cmpq $0x0, -0x10(%rbp)
je 0xa758
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
jmp 0xa76e
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
leaq 0x8009(%rip), %rax      # 0x12770
movq (%rax), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
leaq 0x7fff(%rip), %rcx      # 0x12778
cmpq (%rcx), %rax
jne 0xa7ab
cmpq $0x0, -0x10(%rbp)
je 0xa795
movq -0x10(%rbp), %rcx
leaq 0x7fe8(%rip), %rax      # 0x12778
movq %rcx, (%rax)
jmp 0xa7a9
leaq 0x7fd4(%rip), %rax      # 0x12770
movq (%rax), %rcx
leaq 0x7fd2(%rip), %rax      # 0x12778
movq %rcx, (%rax)
jmp 0xa7ab
jmp 0xa7ad
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xa72a
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa803
cmpq $0x0, -0x10(%rbp)
je 0xa803
movq -0x10(%rbp), %rsi
leaq 0x375a(%rip), %rdi      # 0xdf56
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa82c
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xa840
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa80b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x7b45(%rip), %rax      # 0x12770
movq (%rax), %rdi
leaq 0x332e(%rip), %rsi      # 0xdf63
xorl %edx, %edx
callq 0xa7d0
leaq 0x1606(%rip), %rdi      # 0xc249
movb $0x0, %al
callq 0x2070
leaq 0x7b7f(%rip), %rax      # 0x127d0
movq (%rax), %rdi
leaq 0x330f(%rip), %rsi      # 0xdf6a
xorl %edx, %edx
callq 0xa7d0
leaq 0x15e0(%rip), %rdi      # 0xc249
movb $0x0, %al
callq 0x2070
leaq 0x7b69(%rip), %rax      # 0x127e0
movq (%rax), %rdi
leaq 0x32ef(%rip), %rsi      # 0xdf70
xorl %edx, %edx
callq 0xa7d0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movl $0x48, %edi
callq 0x2100
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xacd6
leaq 0x3467(%rip), %rdi      # 0xe138
callq 0x8110
movl -0x4(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x8(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
movl 0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/events/main.c
// Function: main
int
main(int argc, char * argv[])
{
	int empty_loop = 0;
	const char * filename_pid = NULL;

	WARNP_INIT;

	if (argc > 1) {
		empty_loop = 1;
		filename_pid = argv[1];
	}

	/* Set up response to SIGUSR1. */
	if (events_interrupter_init()) {
		warnp("events_interrupter_init()");
		goto err0;
	}

	/* Run tests. */
	if (empty_loop) {
		/* Needs external SIGUSR1 to cancel the event loop. */
		if (test_interrupt_empty_loop(filename_pid))
			goto err0;
	} else {
		if (test_interrupt_run())
			goto err0;
		if (test_interrupt_spin())
			goto err0;
		if (test_timer())
			goto err0;
	}

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x131b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3c40
jmp 0x131d
cmpl $0x1, -0x8(%rbp)
jle 0x1336
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x1960
cmpl $0x0, %eax
je 0x1379
jmp 0x1342
callq 0x1070
cmpl $0x0, (%rax)
je 0x1367
leaq 0x4cbd(%rip), %rdi      # 0x6010
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x1375
leaq 0x4ca2(%rip), %rdi      # 0x6010
movb $0x0, %al
callq 0x3f50
jmp 0x1377
jmp 0x13be
cmpl $0x0, -0x14(%rbp)
je 0x1391
movq -0x20(%rbp), %rdi
callq 0x13d0
cmpl $0x0, %eax
je 0x138f
jmp 0x13be
jmp 0x13b7
callq 0x1470
cmpl $0x0, %eax
je 0x139d
jmp 0x13be
callq 0x1520
cmpl $0x0, %eax
je 0x13a9
jmp 0x13be
callq 0x15d0
cmpl $0x0, %eax
je 0x13b5
jmp 0x13be
jmp 0x13b7
xorl %edi, %edi
callq 0x11b0
movl $0x1, %edi
callq 0x11b0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/events/main.c
// Function: test_interrupt_empty_loop
static int
test_interrupt_empty_loop(const char * filename_pid)
{
	int done = 0;
	int ret;

	/* Reset counter. */
	events_counter_reset();

	/* We've finished initializing stuff; write the pidfile. */
	if (write_pidfile(filename_pid))
		goto err0;

	/* Run event loop. */
	while ((ret = events_spin(&done))) {
		if (ret == -1) {
			warnp("error in event loop");
			goto err0;
		}
	}

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x1880
movq -0x10(%rbp), %rdi
callq 0x1680
cmpl $0x0, %eax
je 0x13f8
jmp 0x1455
jmp 0x13fa
leaq -0x14(%rbp), %rdi
callq 0x1d40
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x144c
cmpl $-0x1, -0x18(%rbp)
jne 0x144a
jmp 0x1413
callq 0x1070
cmpl $0x0, (%rax)
je 0x1438
leaq 0x4c06(%rip), %rdi      # 0x602a
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x1446
leaq 0x4beb(%rip), %rdi      # 0x602a
movb $0x0, %al
callq 0x3f50
jmp 0x1448
jmp 0x1455
jmp 0x13fa
movl $0x0, -0x4(%rbp)
jmp 0x145c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/events/main.c
// Function: test_interrupt_run
static int
test_interrupt_run(void)
{

	/* Reset counter. */
	events_counter_reset();

	/* Queue an event. */
	event_cookie = events_immediate_register(&event, NULL, 10);

	/* Run event loop. */
	do {
		if (events_run()) {
			warnp("error in event loop");
			goto err0;
		}
	} while (!events_interrupter_interrupted());

	/* Cancel the left-over event. */
	events_immediate_cancel(event_cookie);

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1880
leaq 0x37c(%rip), %rdi       # 0x1800
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x20a0
movq %rax, 0x7eff(%rip)      # 0x9398
callq 0x1b60
cmpl $0x0, %eax
je 0x14dc
jmp 0x14a5
callq 0x1070
cmpl $0x0, (%rax)
je 0x14ca
leaq 0x4b74(%rip), %rdi      # 0x602a
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x14d8
leaq 0x4b59(%rip), %rdi      # 0x602a
movb $0x0, %al
callq 0x3f50
jmp 0x14da
jmp 0x1504
jmp 0x14de
callq 0x1a80
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1499
movq 0x7ea2(%rip), %rdi      # 0x9398
callq 0x21f0
movl $0x0, -0x4(%rbp)
jmp 0x150b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/events/main.c
// Function: test_interrupt_spin
static int
test_interrupt_spin(void)
{
	int done = 0;
	int ret;

	/* Reset counter. */
	events_counter_reset();

	/* Queue an event. */
	event_cookie = events_immediate_register(&event, NULL, 10);

	/* Run event loop. */
	while ((ret = events_spin(&done))) {
		if (ret == -1) {
			warnp("error in event loop");
			goto err0;
		}
	}

	/* Cancel the left-over event. */
	events_immediate_cancel(event_cookie);

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
callq 0x1880
leaq 0x2c5(%rip), %rdi       # 0x1800
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x20a0
movq %rax, 0x7e48(%rip)      # 0x9398
leaq -0x8(%rbp), %rdi
callq 0x1d40
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x15a2
cmpl $-0x1, -0xc(%rbp)
jne 0x15a0
jmp 0x1569
callq 0x1070
cmpl $0x0, (%rax)
je 0x158e
leaq 0x4ab0(%rip), %rdi      # 0x602a
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x159c
leaq 0x4a95(%rip), %rdi      # 0x602a
movb $0x0, %al
callq 0x3f50
jmp 0x159e
jmp 0x15b7
jmp 0x1550
movq 0x7def(%rip), %rdi      # 0x9398
callq 0x21f0
movl $0x0, -0x4(%rbp)
jmp 0x15be
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/events/main.c
// Function: test_timer
static int
test_timer(void)
{
	int done = 0;
	int ret;

	/* Reset counter. */
	events_counter_reset();

	/* Queue an event. */
	event_cookie = events_timer_register_double(&event_timer, NULL, 0.01);

	/* Run event loop. */
	while ((ret = events_spin(&done))) {
		if (ret == -1) {
			warnp("error in event loop");
			goto err0;
		}
	}

	/* Cancel the left-over event. */
	events_timer_cancel(event_cookie);

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
callq 0x1880
leaq 0x255(%rip), %rdi       # 0x1840
xorl %eax, %eax
movl %eax, %esi
movsd 0x4a11(%rip), %xmm0     # 0x6008
callq 0x3630
movq %rax, 0x7d95(%rip)      # 0x9398
leaq -0x8(%rbp), %rdi
callq 0x1d40
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x1655
cmpl $-0x1, -0xc(%rbp)
jne 0x1653
jmp 0x161c
callq 0x1070
cmpl $0x0, (%rax)
je 0x1641
leaq 0x49fd(%rip), %rdi      # 0x602a
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x164f
leaq 0x49e2(%rip), %rdi      # 0x602a
movb $0x0, %al
callq 0x3f50
jmp 0x1651
jmp 0x166a
jmp 0x1603
movq 0x7d3c(%rip), %rdi      # 0x9398
callq 0x3690
movl $0x0, -0x4(%rbp)
jmp 0x1671
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/events/main.c
// Function: write_pidfile
static int
write_pidfile(const char * filename)
{
	FILE * fp;

	if ((fp = fopen(filename, "w")) == NULL) {
		warnp("fopen(%s)", filename);
		goto err0;
	}
	if (fprintf(fp, "%jd", (intmax_t)getpid()) < 0) {
		warnp("fprintf");
		goto err1;
	}
	if (fclose(fp)) {
		warnp("fclose");
		goto err0;
	}

	/* Success! */
	return (0);

err1:
	if (fclose(fp))
		warnp("fclose");
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x49a7(%rip), %rsi      # 0x603e
callq 0x1180
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x16ea
jmp 0x16a8
callq 0x1070
cmpl $0x0, (%rax)
je 0x16d1
movq -0x10(%rbp), %rsi
leaq 0x4983(%rip), %rdi      # 0x6040
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x16e3
movq -0x10(%rbp), %rsi
leaq 0x4964(%rip), %rdi      # 0x6040
movb $0x0, %al
callq 0x3f50
jmp 0x16e5
jmp 0x17e3
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x10b0
movq -0x20(%rbp), %rdi
movslq %eax, %rdx
leaq 0x4945(%rip), %rsi      # 0x604a
movb $0x0, %al
callq 0x1100
cmpl $0x0, %eax
jge 0x174a
jmp 0x1713
callq 0x1070
cmpl $0x0, (%rax)
je 0x1738
leaq 0x492a(%rip), %rdi      # 0x604e
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x1746
leaq 0x490f(%rip), %rdi      # 0x604e
movb $0x0, %al
callq 0x3f50
jmp 0x1748
jmp 0x179a
movq -0x18(%rbp), %rdi
callq 0x10c0
cmpl $0x0, %eax
je 0x1791
jmp 0x175a
callq 0x1070
cmpl $0x0, (%rax)
je 0x177f
leaq 0x48eb(%rip), %rdi      # 0x6056
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x178d
leaq 0x48d0(%rip), %rdi      # 0x6056
movb $0x0, %al
callq 0x3f50
jmp 0x178f
jmp 0x17e3
movl $0x0, -0x4(%rbp)
jmp 0x17ea
movq -0x18(%rbp), %rdi
callq 0x10c0
cmpl $0x0, %eax
je 0x17e1
jmp 0x17aa
callq 0x1070
cmpl $0x0, (%rax)
je 0x17cf
leaq 0x489b(%rip), %rdi      # 0x6056
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x17dd
leaq 0x4880(%rip), %rdi      # 0x6056
movb $0x0, %al
callq 0x3f50
jmp 0x17df
jmp 0x17e1
jmp 0x17e3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movl 0x7af6(%rip), %esi      # 0x93a0
leaq 0x47c9(%rip), %rdi      # 0x607a
movb $0x0, %al
callq 0x10d0
movl 0x7ae2(%rip), %eax      # 0x93a0
addl $0x1, %eax
movl %eax, 0x7ad9(%rip)      # 0x93a0
cmpl $0x4, 0x7ad2(%rip)      # 0x93a0
jne 0x1922
movl $0xa, %edi
callq 0x1030
cmpl $0x0, %eax
je 0x1920
jmp 0x18e1
callq 0x1070
cmpl $0x0, (%rax)
je 0x1906
leaq 0x4792(%rip), %rdi      # 0x6084
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x1914
leaq 0x4777(%rip), %rdi      # 0x6084
movb $0x0, %al
callq 0x3f50
jmp 0x1916
movl $0x1, %edi
callq 0x11b0
jmp 0x1922
cmpl $0xa, 0x7a77(%rip)      # 0x93a0
jle 0x1950
jmp 0x192d
leaq 0x4766(%rip), %rdi      # 0x609a
movb $0x0, %al
callq 0x3f50
callq 0x1070
movl $0x0, (%rax)
movl $0x1, %edi
callq 0x11b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
callq 0x1a50
leaq 0xe9(%rip), %rax        # 0x1a60
movq %rax, -0xa0(%rbp)
leaq -0xa0(%rbp), %rdi
addq $0x8, %rdi
callq 0x1110
cmpl $0x0, %eax
je 0x19cc
jmp 0x1995
callq 0x1070
cmpl $0x0, (%rax)
je 0x19ba
leaq 0x4712(%rip), %rdi      # 0x60b8
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x19c8
leaq 0x46f7(%rip), %rdi      # 0x60b8
movb $0x0, %al
callq 0x3f50
jmp 0x19ca
jmp 0x1a2f
movl $0x0, -0x18(%rbp)
movl $0xa, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1080
cmpl $0x0, %eax
je 0x1a26
jmp 0x19ef
callq 0x1070
cmpl $0x0, (%rax)
je 0x1a14
leaq 0x46c0(%rip), %rdi      # 0x60c0
movb $0x0, %al
callq 0x3d00
callq 0x1070
movl $0x0, (%rax)
jmp 0x1a22
leaq 0x46a5(%rip), %rdi      # 0x60c0
movb $0x0, %al
callq 0x3f50
jmp 0x1a24
jmp 0x1a2f
movl $0x0, -0x4(%rbp)
jmp 0x1a36
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/b64_decode.c
// Function: b64_decode
int
b64_decode(char const *src, uint8_t *target, size_t targsize)
{
	if (!b64rmap_initialized)
		b64_initialize_rmap ();

	if (target)
		return b64_decode_do ((unsigned char*)src, target, targsize);
	else
		return b64_decode_len ((unsigned char*)src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x0, 0xbeb5(%rip)      # 0x10810
jne 0x4962
callq 0x49a0
cmpq $0x0, -0x18(%rbp)
je 0x497f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4a80
movl %eax, -0x4(%rbp)
jmp 0x498b
movq -0x10(%rbp), %rdi
callq 0x4d90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/b64_decode.c
// Function: b64_initialize_rmap
static void
b64_initialize_rmap (void)
{
	int i;

	/* Null: end of string, stop parsing */
	b64rmap[0] = b64rmap_end;

	for (i = 1; i < 256; ++i) {
		/* Whitespaces */
		if (isspace(i))
			b64rmap[i] = b64rmap_space;
		/* Padding: stop parsing */
		else if (i == (unsigned char)Pad64)
			b64rmap[i] = b64rmap_end;
		/* Non-base64 char */
		else
			b64rmap[i] = b64rmap_invalid;
	}

	/* Fill reverse mapping for base64 chars */
	for (i = 0; Base64[i] != '\0'; ++i)
		b64rmap[(uint8_t)Base64[i]] = i;

	b64rmap_initialized = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $-0x3, 0xbe71(%rip)     # 0x10820
movl $0x1, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x4a1f
callq 0x4460
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x49ea
movslq -0x4(%rbp), %rcx
leaq 0xbe3c(%rip), %rax      # 0x10820
movb $-0x2, (%rax,%rcx)
jmp 0x4a12
cmpl $0x3d, -0x4(%rbp)
jne 0x4a01
movslq -0x4(%rbp), %rcx
leaq 0xbe25(%rip), %rax      # 0x10820
movb $-0x3, (%rax,%rcx)
jmp 0x4a10
movslq -0x4(%rbp), %rcx
leaq 0xbe14(%rip), %rax      # 0x10820
movb $-0x1, (%rax,%rcx)
jmp 0x4a12
jmp 0x4a14
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x49b6
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x65ff(%rip), %rax      # 0xb030
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x4a65
movl -0x4(%rbp), %eax
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0x65e6(%rip), %rax      # 0xb030
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xbdc9(%rip), %rax      # 0x10820
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4a26
movl $0x1, 0xbda1(%rip)      # 0x10810
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x40f0
movl %eax, %ecx
movl %ecx, -0x4(%rbp)
subl $-0x1, %eax
je 0x5282
jmp 0x5279
movl -0x4(%rbp), %eax
testl %eax, %eax
je 0x5297
jmp 0x52b8
callq 0x4050
movl (%rax), %edi
leaq 0x5e6a(%rip), %rsi      # 0xb0fa
movb $0x0, %al
callq 0x5fa0
callq 0x4480
cmpl $-0x1, %eax
jne 0x52b6
callq 0x4050
movl (%rax), %edi
leaq 0x5e62(%rip), %rsi      # 0xb111
movb $0x0, %al
callq 0x5fa0
jmp 0x52bf
xorl %edi, %edi
callq 0x4700
callq 0x6220
callq 0x5ef0
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x531e
movq -0x10(%rbp), %rax
leaq 0x5df1(%rip), %rcx      # 0xb0d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %edi, %edi
leaq 0x5e52(%rip), %rsi      # 0xb143
movb $0x0, %al
callq 0x6300
jmp 0x532e
xorl %edi, %edi
leaq 0x5e64(%rip), %rsi      # 0xb167
movb $0x0, %al
callq 0x6300
jmp 0x532e
xorl %edi, %edi
leaq 0x5e75(%rip), %rsi      # 0xb18a
movb $0x0, %al
callq 0x6300
jmp 0x532e
jmp 0x5320
leaq 0x5e87(%rip), %rdi      # 0xb1ae
movb $0x0, %al
callq 0x6170
callq 0x5350
testb $0x1, %al
jne 0x5339
jmp 0x5349
xorl %edi, %edi
leaq 0x5ea7(%rip), %rsi      # 0xb1e9
movb $0x0, %al
callq 0x5fa0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/daemonize.c
// Function: is_already_running
static bool
is_already_running(void)
{
	int	errno_save = 0;
	int	fd = -1;
	struct flock lock_ctx = {
		.l_type   = F_WRLCK,
		.l_whence = SEEK_SET,
		.l_start  = 0,
		.l_len    = 0,
		.l_pid    = -1,
	};

	if ((fd = open(g_lockfile_path, O_RDWR | O_CREAT, mode)) == -1) {
		fatal(errno, "is_already_running: can't open %s",
		    g_lockfile_path);
	}

	if (fcntl(fd, F_SETLK, &lock_ctx) == FAILED_TO_ACQUIRE_LOCK) {
		errno_save = errno;
		(void) close(fd);

		if (errno_save == EACCES || errno_save == EAGAIN)
			return true;
		else {
			fatal(errno_save, "is_already_running: can't lock %s",
			    g_lockfile_path);
		}
	}

	(void) ftruncate(fd, 0);
	(void) dprintf(fd, "%ld\n", (long int) getpid());
	g_lockfile_fd = fd;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq 0x5f03(%rip), %rax      # 0xb270
movq %rax, -0x30(%rbp)
movq 0x5f00(%rip), %rax      # 0xb278
movq %rax, -0x28(%rbp)
movq 0x5efd(%rip), %rax      # 0xb280
movq %rax, -0x20(%rbp)
movq 0x5efa(%rip), %rax      # 0xb288
movq %rax, -0x18(%rbp)
leaq 0x5d47(%rip), %rdi      # 0xb0e0
movl $0x42, %esi
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x4300
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
jne 0x53ce
callq 0x4050
movl (%rax), %edi
leaq 0x5e64(%rip), %rsi      # 0xb224
leaq 0x5d19(%rip), %rdx      # 0xb0e0
movb $0x0, %al
callq 0x5fa0
movl -0xc(%rbp), %edi
movl $0x6, %esi
leaq -0x30(%rbp), %rdx
movb $0x0, %al
callq 0x4260
cmpl $-0x1, %eax
jne 0x5422
callq 0x4050
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %edi
callq 0x47e0
cmpl $0xd, -0x8(%rbp)
je 0x5404
cmpl $0xb, -0x8(%rbp)
jne 0x540a
movb $0x1, -0x1(%rbp)
jmp 0x545a
movl -0x8(%rbp), %edi
leaq 0x5e32(%rip), %rsi      # 0xb246
leaq 0x5cc5(%rip), %rdx      # 0xb0e0
movb $0x0, %al
callq 0x5fa0
movl -0xc(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x45e0
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x4670
movl -0x34(%rbp), %edi
movslq %eax, %rdx
leaq 0x5e22(%rip), %rsi      # 0xb268
movb $0x0, %al
callq 0x4230
movl -0xc(%rbp), %eax
movl %eax, 0xafba(%rip)      # 0x10410
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/interpreter.cpp
// Function: copy_identifier(char const*&)
static char *
copy_identifier(const char *&id)
{
	size_t	 count = identifier_maxSize;
	char	*dest_buf = new char[count + 1];
	char	*dest = addrof(dest_buf[0]);

	while ((isalnum(*id) || *id == '_') && count > 1)
		*dest++ = *id++, count--;

	*dest = '\0';

	if (count == 1)
		fatal(EOVERFLOW, "%s: fatal: string was truncated", __func__);
	return dest_buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x40, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x4030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edi
callq 0x4430
cmpl $0x0, %eax
jne 0x5b45
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x5f, %ecx
movb %al, -0x21(%rbp)
jne 0x5b50
cmpq $0x1, -0x10(%rbp)
seta %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5b59
jmp 0x5b8b
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5b1d
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x1, -0x10(%rbp)
jne 0x5bb3
movl $0x4b, %edi
leaq 0x58af(%rip), %rsi      # 0xb454
leaq 0x58c8(%rip), %rdx      # 0xb474
movb $0x0, %al
callq 0x5fa0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/interpreter.cpp
// Function: copy_argument(char const*&)
static char *
copy_argument(const char *&arg)
{
	bool	 inside_arg = true;
	size_t	 count = argument_maxSize;
	char	*dest_buf = new char[count + 1];
	char	*dest = addrof(dest_buf[0]);

	while (*arg && count > 1) {
		if (*arg == ArgEnd) {
			inside_arg = false;
			arg++;
			break;
		}

		*dest++ = *arg++, count--;
	}

	*dest = '\0';

	if (inside_arg && count == 1)
		fatal(EOVERFLOW, "%s: fatal: string was truncated", __func__);
	if (inside_arg) {
		delete[] dest_buf;
		return nullptr;
	}
	return dest_buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq $0x200, -0x20(%rbp)     # imm = 0x200
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
callq 0x4030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0x5c4d
cmpq $0x1, -0x20(%rbp)
seta %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5c56
jmp 0x5cab
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x5c79
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x5cab
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5c31
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
testb $0x1, -0x11(%rbp)
je 0x5cd9
cmpq $0x1, -0x20(%rbp)
jne 0x5cd9
movl $0x4b, %edi
leaq 0x5789(%rip), %rsi      # 0xb454
leaq 0x57b2(%rip), %rdx      # 0xb484
movb $0x0, %al
callq 0x5fa0
testb $0x1, -0x11(%rbp)
je 0x5d00
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x5cf6
movq -0x40(%rbp), %rdi
callq 0x4580
movq $0x0, -0x8(%rbp)
jmp 0x5d08
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xce0, %rsp            # imm = 0xCE0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0xca0(%rbp), %rdi
xorl %esi, %esi
movl $0xc80, %edx            # imm = 0xC80
callq 0x4210
movq $0x0, -0xca8(%rbp)
leaq -0xca0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0xc80, %esi            # imm = 0xC80
callq 0x46e0
cmpq $0x0, %rax
je 0x5ecc
leaq -0xca0(%rbp), %rax
movq %rax, -0xcb8(%rbp)
leaq -0xcb8(%rbp), %rdi
callq 0x5bc0
movq -0xcb8(%rbp), %rdi
leaq 0x620b(%rip), %rsi      # 0xc02b
callq 0x5d70
testb $0x1, %al
jne 0x5e38
movq -0xcb8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x5e4c
movq -0xca8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xca8(%rbp)
jmp 0x5dd9
movq -0xcb8(%rbp), %rdi
callq 0xa610
movq %rax, %rdi
callq 0xa310
movq %rax, -0xcb0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xce0(%rbp)
movq -0xcb0(%rbp), %rax
movq %rax, -0xcd8(%rbp)
movq -0xca8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xca8(%rbp)
movq %rax, -0xcd0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xcc8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xcc0(%rbp)
leaq -0xce0(%rbp), %rdi
callq 0x5470
movq -0xcb0(%rbp), %rdi
callq 0x4510
jmp 0x5dd9
addq $0xce0, %rsp            # imm = 0xCE0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x5593(%rip), %rax      # 0xb492
movq %rax, -0xe(%rbp)
movw 0x5590(%rip), %ax       # 0xb49a
movw %ax, -0x6(%rbp)
leaq -0xe(%rbp), %rdi
movq 0xa0a7(%rip), %rax      # 0xffc0
movq (%rax), %rdx
leaq 0x5579(%rip), %rsi      # 0xb49c
callq 0x4440
cmpq $0x0, %rax
jne 0x5f37
movl $0x1, -0x4(%rbp)
jmp 0x5f94
leaq -0xe(%rbp), %rdi
movq 0xa05e(%rip), %rax      # 0xffa0
movq (%rax), %rdx
leaq 0x5550(%rip), %rsi      # 0xb49c
callq 0x4440
cmpq $0x0, %rax
jne 0x5f60
movl $0x2, -0x4(%rbp)
jmp 0x5f94
leaq -0xe(%rbp), %rdi
movq 0xa015(%rip), %rax      # 0xff80
movq (%rax), %rdx
leaq 0x5527(%rip), %rsi      # 0xb49c
callq 0x4440
cmpq $0x0, %rax
jne 0x5f89
movl $0x3, -0x4(%rbp)
jmp 0x5f94
jmp 0x5f8b
jmp 0x5f8d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/log.c
// Function: fatal
__dead void
fatal(int code, const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	log_doit(code, LOG_ERR, fmt, ap);
	va_end(ap);

	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x5fd8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movl $0x3, %esi
callq 0x6040
leaq -0x30(%rbp), %rax
callq 0x4220
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x810, %rsp            # imm = 0x810
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
leaq -0x7f0(%rbp), %rdi
xorl %esi, %esi
movl $0x7d0, %edx            # imm = 0x7D0
callq 0x4210
leaq -0x7f0(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x7d0, %esi            # imm = 0x7D0
callq 0x4290
cmpl $0x0, -0x4(%rbp)
je 0x60f0
leaq -0x7f0(%rbp), %rdi
callq 0x41b0
movq %rax, %rcx
leaq -0x7f0(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x808(%rbp)
leaq -0x7f0(%rbp), %rdi
callq 0x41b0
movq %rax, %rcx
movl $0x7d0, %eax            # imm = 0x7D0
subq %rcx, %rax
movq %rax, -0x800(%rbp)
movl -0x4(%rbp), %edi
callq 0x4150
movq -0x808(%rbp), %rdi
movq -0x800(%rbp), %rsi
movq %rax, %rcx
leaq 0x71ff(%rip), %rdx      # 0xd2e8
movb $0x0, %al
callq 0x46f0
testb $0x1, 0xa82a(%rip)      # 0x10921
je 0x6113
movl -0x8(%rbp), %edi
leaq -0x7f0(%rbp), %rdx
leaq 0x5ea3(%rip), %rsi      # 0xbfad
movb $0x0, %al
callq 0x40b0
jmp 0x6166
movq 0x9ea6(%rip), %rax      # 0xffc0
movq (%rax), %rax
movq %rax, -0x7f8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x6, %eax
subl $0x1, %eax
ja 0x6142
jmp 0x6131
movq 0x9e48(%rip), %rax      # 0xff80
movq (%rax), %rax
movq %rax, -0x7f8(%rbp)
leaq -0x7f0(%rbp), %rdi
movq -0x7f8(%rbp), %rsi
callq 0x44d0
movq -0x7f8(%rbp), %rsi
movl $0xa, %edi
callq 0x4530
addq $0x810, %rsp            # imm = 0x810
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/log.c
// Function: log_debug
void
log_debug(const char *fmt, ...)
{
	va_list ap;

	if (g_debug_mode) {
		va_start(ap, fmt);
		log_doit(0, LOG_DEBUG, fmt, ap);
		va_end(ap);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x61a5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
testb $0x1, 0xa74f(%rip)      # 0x10922
je 0x6211
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rcx
xorl %edi, %edi
movl $0x7, %esi
callq 0x6040
leaq -0x20(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uhlin[P]enhanced-duc/source/log.c
// Function: log_init
void
log_init(void)
{
	extern char	*__progname;
	static bool	 initialized = false;

	if (initialized)
		return;
	openlog(__progname, LOG_PID, LOG_DAEMON);
	g_log_to_syslog = initialized = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testb $0x1, 0xa6f8(%rip)      # 0x10923
je 0x622f
jmp 0x6256
movq 0x9d72(%rip), %rax      # 0xffa8
movq (%rax), %rdi
movl $0x1, %esi
movl $0x18, %edx
callq 0x4360
movb $0x1, 0xa6d4(%rip)      # 0x10923
movb $0x1, 0xa6cb(%rip)      # 0x10921
popq %rbp
retq
nopl (%rax,%rax)