LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_09/scdu_mod13.c
// Function: mod_crypt
void mod_crypt(char *text, size_t n)
{
        int i, c;
        char base;

        for (i = 0; i < n; i++) {
                if ((text[i] >= 'a') && (text[i] <= 'z')) 
                        base = 'a';
                else if ((text[i] >= 'A') && (text[i] <= 'Z'))
                        base = 'A';
		else
			continue;

                c = text[i] - base;
                c = (c + 13) % 26;
                text[i] = c + base;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x10df
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x1069
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7a, %eax
jg 0x1069
movb $0x61, -0x19(%rbp)
jmp 0x1095
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x1091
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5a, %eax
jg 0x1091
movb $0x41, -0x19(%rbp)
jmp 0x1093
jmp 0x10d1
jmp 0x1095
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x19(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0xd, %eax
movl $0x1a, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
movsbl -0x19(%rbp), %ecx
addl %ecx, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1033
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryuichiueda[P]glueutils/src/log2.c
// Function: usage
void usage(void){
	fputs("log2: write stderr to a file\n", stderr);
	fputs("usage: log2 <filename> <command> [args]\n", stderr);
	fputs("\nCopyright (C) 2021 Ryuichi Ueda\n", stderr);
	fputs("Released under the MIT License.\n", stderr);
	fputs("https://github.com/ryuichiueda/glueutils\n", stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2e3d(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe3f(%rip), %rdi       # 0x2004
callq 0x1060
movq 0x2e27(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe47(%rip), %rdi       # 0x2022
callq 0x1060
movq 0x2e11(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe5a(%rip), %rdi       # 0x204b
callq 0x1060
movq 0x2dfb(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe66(%rip), %rdi       # 0x206d
callq 0x1060
movq 0x2de5(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xe71(%rip), %rdi       # 0x208e
callq 0x1060
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryuichiueda[P]glueutils/src/log2.c
// Function: tryopen
int tryopen(char *filename){
	int fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0600);
	if(fd < 0){
		printf("Error: %s: %s\n", filename, strerror(errno));
		exit(1);
	}

	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x1070
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x12dd
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x10a0
movq -0x18(%rbp), %rsi
movq %rax, %rdx
leaq 0xdf7(%rip), %rdi       # 0x20c3
movb $0x0, %al
callq 0x1050
movl $0x1, %edi
callq 0x1090
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryuichiueda[P]glueutils/src/log2.c
// Function: main
int main(int argc, char * argv[])
{
	if(argc < 3){
		usage();
		exit(1);
	}

	int fd = tryopen(argv[1]);
	trydup2(fd, 2);

	return - execvp(argv[2], &argv[2]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x131b
callq 0x11b0
movl $0x1, %edi
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1280
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl $0x2, %esi
callq 0x1230
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x1080
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/fcollect64.c
// Function: main
int
main(void)
{
    int i;

    shmem_init();
    npes = shmem_n_pes();
    me = shmem_my_pe();

    for (i = 0; i < DST_SIZE; i++) {
        dst[i] = -1;
    }

    for (i = 0; i < SHMEM_COLLECT_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }

    shmem_barrier_all();

    shmem_fcollect64(dst, src, 2, 0, 0, npes, pSync);

    shmem_barrier_all();

    show_dst("AFTER");

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
callq 0x1080
callq 0x1040
movl %eax, 0x2ed4(%rip)      # 0x4090
callq 0x1060
movl %eax, 0x2ecd(%rip)      # 0x4094
movl $0x0, 0x10(%rsp)
cmpl $0x80, 0x10(%rsp)
jge 0x11fa
movslq 0x10(%rsp), %rcx
leaq 0x2ebb(%rip), %rax      # 0x40a0
movq $-0x1, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x11cf
movl $0x0, 0x10(%rsp)
cmpl $0x3, 0x10(%rsp)
jge 0x122a
movslq 0x10(%rsp), %rcx
leaq 0x328b(%rip), %rax      # 0x44a0
movq $-0x1, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1202
callq 0x1070
movl 0x2e5a(%rip), %r9d      # 0x4090
leaq 0x2e63(%rip), %rdi      # 0x40a0
leaq 0x2e1c(%rip), %rsi      # 0x4060
movl $0x2, %edx
xorl %r8d, %r8d
leaq 0x324d(%rip), %rax      # 0x44a0
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x1090
callq 0x1070
leaq 0xd99(%rip), %rdi       # 0x2004
callq 0x1280
callq 0x1050
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_06/define.c
// Function: main
int main(void)
{
  int c;
  char word[MAX_WORD_LEN];
  while ((c = get_word(word, MAX_WORD_LEN)) != EOF)
  {
    if (isalpha(c))
    {
      struct list_node *node_p = lookup(word);
      if (node_p != NULL)
      {
        printf("%s", node_p->definition);
      }
      else
      {
        printf("%s", word);
      }
    }
    else
    {

      if (c == '/')
      {
        ungetc(c, stdin);
        consume_comments();
      }
      else if (c == '\'')
      {
        ungetc(c, stdin);
        consume_char_literal();
      }
      else if (c == '"')
      {
        ungetc(c, stdin);
        consume_string_literal();
      }
      else if (c == '#')
      {
        ungetc(c, stdin);
        consume_preproc();
      }
      else
      {
        putc(c, stdout);
      }
    }
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
movl $0x64, %esi
callq 0x1310
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x1304
callq 0x10d0
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x1269
leaq -0x70(%rbp), %rdi
callq 0x1440
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
je 0x1252
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xdbb(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1070
jmp 0x1264
leaq -0x70(%rbp), %rsi
leaq 0xda7(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1070
jmp 0x12ff
cmpl $0x2f, -0x8(%rbp)
jne 0x1288
movl -0x8(%rbp), %edi
movq 0x2d67(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x10b0
callq 0x14b0
jmp 0x12fd
cmpl $0x27, -0x8(%rbp)
jne 0x12a7
movl -0x8(%rbp), %edi
movq 0x2d48(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x10b0
callq 0x1620
jmp 0x12fb
cmpl $0x22, -0x8(%rbp)
jne 0x12c6
movl -0x8(%rbp), %edi
movq 0x2d29(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x10b0
callq 0x1640
jmp 0x12f9
cmpl $0x23, -0x8(%rbp)
jne 0x12e5
movl -0x8(%rbp), %edi
movq 0x2d0a(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x10b0
callq 0x1660
jmp 0x12f7
movl -0x8(%rbp), %edi
movq 0x2ce9(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
jmp 0x12f9
jmp 0x12fb
jmp 0x12fd
jmp 0x12ff
jmp 0x11f2
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_06/define.c
// Function: consume_comments
void consume_comments(void)
{
  int c = getc(stdin);
  if (c == '/')
  {
    putc(c, stdout);

    c = getc(stdin);
    if (c == '/')
    {
      putc(c, stdout);
      while ((c = getc(stdin)) != '\n' && c != EOF)
      {
        putc(c, stdout);
      }
    }
    else if (c == '*')
    {
      putc(c, stdout);
      while ((c = getc(stdin)) != EOF)
      {
        putc(c, stdout);
        if (c == '*')
        {
          c = getc(stdin);
          putc(c, stdout);
          if (c == '/')
          {
            break;
          }
        }
      }

      c = getc(stdin);
      if (c == '/')
      {
        putc(c, stdout);
        return;
      }
    }
  }
  ungetc(c, stdin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x2b21(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, -0x4(%rbp)
cmpl $0x2f, -0x4(%rbp)
jne 0x1607
movl -0x4(%rbp), %edi
movq 0x2afa(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
movq 0x2af3(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, -0x4(%rbp)
cmpl $0x2f, -0x4(%rbp)
jne 0x155a
movl -0x4(%rbp), %edi
movq 0x2ad0(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
movq 0x2ac9(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, %ecx
movl %ecx, -0x4(%rbp)
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x5(%rbp)
je 0x1538
cmpl $-0x1, -0x4(%rbp)
setne %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x1541
jmp 0x1555
movl -0x4(%rbp), %edi
movq 0x2a8d(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
jmp 0x1510
jmp 0x1605
cmpl $0x2a, -0x4(%rbp)
jne 0x1603
movl -0x4(%rbp), %edi
movq 0x2a6a(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
movq 0x2a63(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, -0x4(%rbp)
cmpl $-0x1, %eax
je 0x15d5
movl -0x4(%rbp), %edi
movq 0x2a41(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
cmpl $0x2a, -0x4(%rbp)
jne 0x15d3
movq 0x2a34(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
movq 0x2a17(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
cmpl $0x2f, -0x4(%rbp)
jne 0x15d1
jmp 0x15d5
jmp 0x15d3
jmp 0x1576
movq 0x2a04(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, -0x4(%rbp)
cmpl $0x2f, -0x4(%rbp)
jne 0x1601
movl -0x4(%rbp), %edi
movq 0x29e1(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
jmp 0x1619
jmp 0x1603
jmp 0x1605
jmp 0x1607
movl -0x4(%rbp), %edi
movq 0x29cf(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_06/define.c
// Function: consume_preproc
void consume_preproc(void)
{
  int c = getc(stdin);
  if (c == '#')
  {
    putc(c, stdout);

    char word[MAX_WORD_LEN];
    consume_word(word, "Error: expected preprocessor directive.");

    enum directive_type directive = NONE;
    if (strcmp(word, "define") == 0)
    {
      directive = DEFINE;
    }
    else if (strcmp(word, "undef") == 0)
    {
      directive = UNDEF;
    }

    if (directive)
    {
      consume_blanks();
      consume_word(word, "Error: invalid name.");
    }

    if (directive == DEFINE)
    {
      consume_blanks();
      char definition[MAX_WORD_LEN];
      get_alnum_str(definition, MAX_WORD_LEN);
      printf("%s", definition);

      struct list_node *node_p = lookup(definition);
      if (node_p != NULL)
      {
        install(word, node_p->definition);
      }
      else
      {
        install(word, definition);
      }
    }
    else if (directive == UNDEF)
    {
      undef(word);
    }
  }
  else
  {
    ungetc(c, stdin);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq 0x296e(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, -0x4(%rbp)
cmpl $0x23, -0x4(%rbp)
jne 0x1790
movl -0x4(%rbp), %edi
movq 0x2947(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
leaq -0x70(%rbp), %rdi
leaq 0x963(%rip), %rsi       # 0x2007
callq 0x1ad0
movl $0x0, -0x74(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0x974(%rip), %rsi       # 0x202f
callq 0x1090
cmpl $0x0, %eax
jne 0x16ce
movl $0x1, -0x74(%rbp)
jmp 0x16ec
leaq -0x70(%rbp), %rdi
leaq 0x95d(%rip), %rsi       # 0x2036
callq 0x1090
cmpl $0x0, %eax
jne 0x16ea
movl $0x2, -0x74(%rbp)
jmp 0x16ec
cmpl $0x0, -0x74(%rbp)
je 0x1707
callq 0x1b50
leaq -0x70(%rbp), %rdi
leaq 0x93a(%rip), %rsi       # 0x203c
callq 0x1ad0
cmpl $0x1, -0x74(%rbp)
jne 0x177d
callq 0x1b50
leaq -0xe0(%rbp), %rdi
movl $0x64, %esi
callq 0x1a20
leaq -0xe0(%rbp), %rsi
leaq 0x8d3(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1070
leaq -0xe0(%rbp), %rdi
callq 0x1440
movq %rax, -0xe8(%rbp)
cmpq $0x0, -0xe8(%rbp)
je 0x176b
leaq -0x70(%rbp), %rdi
movq -0xe8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1860
jmp 0x177b
leaq -0x70(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1860
jmp 0x178e
cmpl $0x2, -0x74(%rbp)
jne 0x178c
leaq -0x70(%rbp), %rdi
callq 0x1940
jmp 0x178e
jmp 0x17a2
movl -0x4(%rbp), %edi
movq 0x2846(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x10b0
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_06/define.c
// Function: get_alnum_str
size_t get_alnum_str(char *str, size_t max_str_len)
{
  size_t i = 0;
  int c;
  while (isalnum(c = getc(stdin)) && i < max_str_len)
  {
    str[i++] = c;
  }
  str[i] = '\0';
  ungetc(c, stdin);
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
callq 0x10d0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x2595(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x8, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x1a7e
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
setb %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x1a87
jmp 0x1aa4
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x1a38
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x1c(%rbp), %edi
movq 0x2526(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x10b0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_06/define.c
// Function: consume_word
void consume_word(char *word, char *Error_str)
{
  int c;
  if ((c = get_word(word, MAX_WORD_LEN)) == EOF)
  {
    ungetc(c, stdin);
    return;
  }
  else if (!isalpha(c))
  {
    puts(Error_str);
  }
  printf("%s", word);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x64, %esi
callq 0x1310
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x1b0a
movl -0x14(%rbp), %edi
movq 0x24e0(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x10b0
jmp 0x1b41
callq 0x10d0
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0x1b2d
movq -0x10(%rbp), %rdi
callq 0x1050
jmp 0x1b2f
movq -0x8(%rbp), %rsi
leaq 0x4ca(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1070
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_06/define.c
// Function: consume_blanks
void consume_blanks(void)
{
  int c;
  while (isblank(c = getc(stdin)))
  {
    putc(c, stdout);
  }
  ungetc(c, stdin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x10d0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq 0x2475(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, -0x4(%rbp)
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1b9f
movl -0x4(%rbp), %edi
movq 0x2443(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
jmp 0x1b58
movl -0x4(%rbp), %edi
movq 0x2437(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_06/define.c
// Function: consume_chars_between
void consume_chars_between(char start, char end)
{
  int c = getc(stdin);
  if (c == start)
  {
    putc(c, stdout);
    while ((c = getc(stdin)) != EOF)
    {
      putc(c, stdout);
      if (c == '\\')
      {
        c = getc(stdin);
        putc(c, stdout);
        if (c == EOF)
        {
          break;
        }
      }
      else if (c == end)
      {
        return;
      }
    }
  }
  ungetc(c, stdin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movq 0x2405(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movsbl -0x1(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1c77
movl -0x8(%rbp), %edi
movq 0x23d9(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
movq 0x23d2(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x1c75
movl -0x8(%rbp), %edi
movq 0x23b0(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
cmpl $0x5c, -0x8(%rbp)
jne 0x1c64
movq 0x23a3(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10c0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
movq 0x2386(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1080
cmpl $-0x1, -0x8(%rbp)
jne 0x1c62
jmp 0x1c75
jmp 0x1c73
movl -0x8(%rbp), %eax
movsbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1c71
jmp 0x1c89
jmp 0x1c73
jmp 0x1c07
jmp 0x1c77
movl -0x8(%rbp), %edi
movq 0x235f(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/juliusHuelsmann[P]st-focus/x.c
// Function: xloadalpha
void
xloadalpha(void)
{
	float const usedAlpha = focused ? alpha : alphaUnfocused;
	if (opt_alpha) alpha = strtof(opt_alpha, NULL);
	dc.col[defaultbg].color.alpha = (unsigned short)(0xffff * usedAlpha);
	dc.col[defaultbg].pixel &= 0x00FFFFFF;
	dc.col[defaultbg].pixel |= (unsigned char)(0xff * usedAlpha) << 24;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x1033d(%rip)     # 0x1c15c
je 0xbe30
movss 0xb8f3(%rip), %xmm0     # 0x1771c
movss %xmm0, -0x8(%rbp)
jmp 0xbe3d
movss 0xb8e8(%rip), %xmm0     # 0x17720
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
cmpq $0x0, 0x10311(%rip)     # 0x1c160
je 0xbe69
movq 0x10308(%rip), %rdi     # 0x1c160
xorl %eax, %eax
movl %eax, %esi
callq 0x5450
movss %xmm0, 0xb8b3(%rip)     # 0x1771c
movss -0x4(%rbp), %xmm0
movss 0x6e5a(%rip), %xmm1     # 0x12cd0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movw %ax, %dx
movq 0x102e0(%rip), %rax     # 0x1c168
movl 0x102ca(%rip), %ecx     # 0x1c158
shlq $0x4, %rcx
movw %dx, 0xe(%rax,%rcx)
movq 0x102ca(%rip), %rax     # 0x1c168
movl 0x102b4(%rip), %ecx     # 0x1c158
shlq $0x4, %rcx
movq (%rax,%rcx), %rdx
andl $0xffffff, %edx         # imm = 0xFFFFFF
movq %rdx, (%rax,%rcx)
movss -0x4(%rbp), %xmm0
movss 0x6e11(%rip), %xmm1     # 0x12cd4
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movzbl %al, %eax
shll $0x18, %eax
movslq %eax, %rcx
movq 0x1028d(%rip), %rax     # 0x1c168
movl 0x10277(%rip), %edx     # 0x1c158
shlq $0x4, %rdx
addq %rdx, %rax
orq (%rax), %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/juliusHuelsmann[P]st-focus/x.c
// Function: xloadcols
void
xloadcols(void)
{
	static int loaded;
	Color *cp;

	if (!loaded) {
		dc.collen = 1 + (defaultbg = MAX(LEN(colorname), 256));
		dc.col = xmalloc((dc.collen) * sizeof(Color));
	}

	for (int i = 0; i+1 < dc.collen; ++i)
		if (!xloadcolor(i, NULL, &dc.col[i])) {
			if (colorname[i])
				die("could not allocate color '%s'\n", colorname[i]);
			else
				die("could not allocate color %d\n", i);
		}
	if (dc.collen) // cannot die, as the color is already loaded.
		xloadcolor(focused ?bg :bgUnfocused, NULL, &dc.col[defaultbg]);

	xloadalpha();
	loaded = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x10351(%rip)     # 0x1c260
jne 0xbf3d
movl $0x103, 0x1023d(%rip)   # imm = 0x103
movq $0x104, 0x1024a(%rip) # imm = 0x104
movq 0x10243(%rip), %rdi     # 0x1c170
shlq $0x4, %rdi
callq 0x5a30
movq %rax, 0x1022b(%rip)     # 0x1c168
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
cltq
cmpq 0x1021d(%rip), %rax     # 0x1c170
jae 0xbfcc
movl -0xc(%rbp), %edi
movq 0x10209(%rip), %rdx     # 0x1c168
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xc030
cmpl $0x0, %eax
jne 0xbfbc
movslq -0xc(%rbp), %rcx
leaq 0xb7ad(%rip), %rax      # 0x17730
cmpq $0x0, (%rax,%rcx,8)
je 0xbfa9
movslq -0xc(%rbp), %rcx
leaq 0xb79b(%rip), %rax      # 0x17730
movq (%rax,%rcx,8), %rsi
leaq 0x6eb0(%rip), %rdi      # 0x12e50
movb $0x0, %al
callq 0x5a80
jmp 0xbfba
movl -0xc(%rbp), %esi
leaq 0x6ebc(%rip), %rdi      # 0x12e6f
movb $0x0, %al
callq 0x5a80
jmp 0xbfbc
jmp 0xbfbe
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbf44
cmpq $0x0, 0x1019c(%rip)     # 0x1c170
je 0xc013
cmpl $0x0, 0x1017f(%rip)     # 0x1c15c
je 0xbfea
movl 0xb743(%rip), %eax      # 0x17728
movl %eax, -0x10(%rbp)
jmp 0xbff3
movl 0xb73c(%rip), %eax      # 0x1772c
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
movq 0x1016b(%rip), %rdx     # 0x1c168
movl 0x10155(%rip), %eax     # 0x1c158
shlq $0x4, %rax
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xc030
callq 0xbe10
movl $0x1, 0x1023e(%rip)     # 0x1c260
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/test/matrix.c
// Function: print_matrix
void print_matrix(matrix *t) {
    printf("\n");
    // printf("%d %d\n",t->r,t->c);
    // t->mat[5][5] = 34;

    for(int i = 0; i < t->r; i++) {
        for(int j = 0; j < t->c; j++) {
            // printf("%d ", t->mat[i][j]);
            // just for test case
            if(t->mat[i][j] != 80){
                final_check = 0;
            }
        }
        // printf("\n");
    }
    if(final_check == 1) {
        printf(GREEN "**PASSED** : MATRIX TEST with rows=%d, columns=%d\n" NONE, t->r, t->c);
    }
    else {
        printf(RED "**FAILED** : MATRIX TEST with rows=%d, columns=%d\n" NONE,  t->r, t->c);

    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x123e(%rip), %rdi      # 0x3031
movb $0x0, %al
callq 0x1090
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x1e5d
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x1e50
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
cmpl $0x50, (%rax,%rcx,4)
je 0x1e43
movl $0x0, 0x326d(%rip)      # 0x50b0
jmp 0x1e45
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1e14
jmp 0x1e52
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1e01
cmpl $0x1, 0x324c(%rip)      # 0x50b0
jne 0x1e84
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x11b8(%rip), %rdi      # 0x3033
movb $0x0, %al
callq 0x1090
jmp 0x1ea0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x11da(%rip), %rdi      # 0x3073
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/gen2space/gen2space.c
// Function: is_allocated
int is_allocated(void *p)
{
  return (((uintptr_t)p >= space_start
           && (uintptr_t)p < space_end)
          || (is_major
              /* During a major collection, also treat references
                 into the old generation's space as allocated: */
              && ((uintptr_t)p >= gen1_space_start
                  && (uintptr_t)p < gen1_space_end)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x2ddd(%rip), %rcx      # 0x44b0
cmpq (%rcx), %rax
jb 0x16ed
movq -0x8(%rbp), %rcx
movb $0x1, %al
leaq 0x29b3(%rip), %rdx      # 0x4098
cmpq (%rdx), %rcx
movb %al, -0x9(%rbp)
jb 0x172a
xorl %eax, %eax
cmpl $0x0, 0x2982(%rip)      # 0x4078
movb %al, -0xa(%rbp)
je 0x1724
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0x2978(%rip), %rcx      # 0x4080
movb %al, -0xb(%rbp)
jb 0x171e
movq -0x8(%rbp), %rax
cmpq 0x2950(%rip), %rax      # 0x4068
setb %al
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/hoomanist[P]carrot/ls.c
// Function: list
void list(char dirc[PATH_MAX])
{

	
    	DIR *d;
    	struct dirent *dir;
    	d = opendir(dirc);
    	if (d)
    	{
        	while ((dir = readdir(d)) != NULL)
        	{
            		printf("%s\n", dir->d_name);
        	}
        	closedir(d);
    	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11e6
jmp 0x11b2
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x11dd
movq -0x18(%rbp), %rsi
addq $0x13, %rsi
leaq 0xe30(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
jmp 0x11b2
movq -0x10(%rbp), %rdi
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoomanist[P]carrot/ls.c
// Function: current_directory
void current_directory(void)
{
	char cwd[PATH_MAX];
 	if (getcwd(cwd, sizeof(cwd)) != NULL) {
   		list(cwd);
	} else {
       		perror("getcwd() error");
   	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1000, %rsp           # imm = 0x1000
leaq -0x1000(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x1050
cmpq $0x0, %rax
je 0x1220
leaq -0x1000(%rbp), %rdi
callq 0x1190
jmp 0x122c
leaq 0xde1(%rip), %rdi       # 0x2008
callq 0x1080
addq $0x1000, %rsp           # imm = 0x1000
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoomanist[P]carrot/ls.c
// Function: main
int main(int argc, char **argv)
{
	if(argc == 1){
		current_directory();
		return 0;

	}
	else if( argc > 2 ) {
      		printf("Too many arguments supplied.\n");
   		return 0;
	}
	
	list(argv[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x126a
callq 0x11f0
movl $0x0, -0x4(%rbp)
jmp 0x1296
cmpl $0x2, -0x8(%rbp)
jle 0x1287
leaq 0xda0(%rip), %rdi       # 0x2017
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x1296
jmp 0x1289
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1190
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/tree.c
// Function: v2key
static char *v2key(int n)
{
	int i = 0;
	char tmp[10];

	while (n >= 26) {
		tmp[i++] = n % 26 + 'a';
		n /= 26;
	}
	tmp[i++] = n + 'a';

	char *s = malloc(i + 1);
	char *sp = s;
	while (i)
		*sp++ = tmp[--i];
	*sp = '\0';

	return s;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
cmpl $0x1a, 0x24(%rsp)
jl 0x172d
movl 0x24(%rsp), %eax
movl $0x1a, %ecx
cltd
idivl %ecx
addl $0x61, %edx
movb %dl, %cl
movl 0x20(%rsp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x20(%rsp)
cltq
movb %cl, 0x16(%rsp,%rax)
movl 0x24(%rsp), %eax
movl $0x1a, %ecx
cltd
idivl %ecx
movl %eax, 0x24(%rsp)
jmp 0x16f0
movl 0x24(%rsp), %eax
addl $0x61, %eax
movb %al, %cl
movl 0x20(%rsp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x20(%rsp)
cltq
movb %cl, 0x16(%rsp,%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1120
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x20(%rsp)
je 0x1791
movl 0x20(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x20(%rsp)
cltq
movb 0x16(%rsp,%rax), %cl
movq (%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rsp)
movb %cl, (%rax)
jmp 0x1766
movq (%rsp), %rax
movb $0x0, (%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/tree.c
// Function: walk
static bool walk(const void *key, const void *v, void *context)
{
#if 0
	printf("%s -> %d\n", (const char *)key, *(int *)v);
#endif
	/* Verify key and value pair */
	if (*(int *)v != key2v((const char *)key)) {
		printf("Error in walking tree\n");
		return false;	/* Stop */
	}
	return true;	/* Continue */
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
callq 0x19b0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
je 0x18f7
leaq 0x4790(%rip), %rdi      # 0x6079
movb $0x0, %al
callq 0x1090
movb $0x0, 0x27(%rsp)
jmp 0x18fc
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/tree.c
// Function: key2v
static int key2v(const char *key)
{
	int n = 0;
	while (*key) {
		n *= 26;
		n += *key - 'a';
		key++;
	}

	return n;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x19f3
imull $0x1a, -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
subl $0x61, %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x19bd
movl -0xc(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/execve-example.c
// Function: main
int main(int argc, char *argv[])
{
	char executable[] = "prog";
	char *newargv[] = { executable, NULL, NULL, NULL };
	char *newenviron[] = { NULL };

	printf("I am %s, PID = %ld\n",
		argv[0], (long)getpid());
	printf("About to replace myself with the executable %s...\n",
		executable);
	sleep(2);

	execve(executable, newargv, newenviron);

	/* execve() only returns on error */
	perror("execve");
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0xe48(%rip), %eax       # 0x2004
movl %eax, -0x15(%rbp)
movb 0xe43(%rip), %al        # 0x2008
movb %al, -0x11(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1050
leaq -0x15(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x1050
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
callq 0x1030
movq -0x50(%rbp), %rsi
movslq %eax, %rdx
leaq 0xdfb(%rip), %rdi       # 0x2009
movb $0x0, %al
callq 0x1040
leaq -0x15(%rbp), %rsi
leaq 0xdfd(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1040
movl $0x2, %edi
callq 0x1090
leaq -0x15(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x1060
leaq 0xe07(%rip), %rdi       # 0x2050
callq 0x1070
movl $0x1, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: logging
void logging(enum loglevel_t loglevel, char *format, ...)
{
	va_list arg;
	static const char *loglevel2str[] = {
		[DEBUG] = "DEBUG",
		[WARN]  = "WARN",
		[ERROR] = "ERROR",
		[FATAL] = "FATAL",
	};

	/* debug message is available on verbose mode */
	if ((loglevel == DEBUG) && (VERBOSE == false))
		return;

	fprintf(stderr, ">>%s<<\t", loglevel2str[loglevel]);

	va_start(arg, format);
	vfprintf(stderr, format, arg);
	va_end(arg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x2488
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)
cmpl $0x0, -0x4(%rbp)
jne 0x24b3
jmp 0x251a
movq 0x56b36(%rip), %rax     # 0x58ff0
movq (%rax), %rdi
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x56d17(%rip), %rax     # 0x591e0
movq (%rax,%rcx,8), %rdx
leaq 0x532a4(%rip), %rsi     # 0x55778
movb $0x0, %al
callq 0x2190
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)
movq 0x56aea(%rip), %rax     # 0x58ff0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2290
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: eopen
int eopen(const char *path, int flag)
{
	int fd;
	errno = 0;

	if ((fd = open(path, flag)) < 0) {
		logging(ERROR, "couldn't open \"%s\"\n", path);
		logging(ERROR, "open: %s\n", strerror(errno));
	}
	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x2060
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movb $0x0, %al
callq 0x2260
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jge 0x2599
movq -0x8(%rbp), %rdx
movl $0x2, %edi
leaq 0x53210(%rip), %rsi     # 0x55780
movb $0x0, %al
callq 0x2450
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x53203(%rip), %rsi     # 0x55795
movb $0x0, %al
callq 0x2450
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: eclose
int eclose(int fd)
{
	int ret;
	errno = 0;

	if ((ret = close(fd)) < 0)
		logging(ERROR, "close: %s\n", strerror(errno));

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
callq 0x2060
movl $0x0, (%rax)
movl -0x4(%rbp), %edi
callq 0x2140
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jge 0x25f8
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x531af(%rip), %rsi     # 0x557a0
movb $0x0, %al
callq 0x2450
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: efopen
FILE *efopen(const char *path, char *mode)
{
	FILE *fp;
	errno = 0;

	if ((fp = fopen(path, mode)) == NULL) {
		logging(ERROR, "couldn't open \"%s\"\n", path);
		logging(ERROR, "fopen: %s\n", strerror(errno));
	}
	return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2060
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2270
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x267b
movq -0x8(%rbp), %rdx
movl $0x2, %edi
leaq 0x5312e(%rip), %rsi     # 0x55780
movb $0x0, %al
callq 0x2450
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x53120(%rip), %rsi     # 0x55794
movb $0x0, %al
callq 0x2450
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: efclose
int efclose(FILE *fp)
{
	int ret;
	errno = 0;

	if ((ret = fclose(fp)) < 0)
		logging(ERROR, "fclose: %s\n", strerror(errno));

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2060
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x20c0
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jge 0x26da
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x530cc(%rip), %rsi     # 0x5579f
movb $0x0, %al
callq 0x2450
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: emmap
void *emmap(void *addr, size_t len, int prot, int flag, int fd, off_t offset)
{
	void *fp;
	errno = 0;

	if ((fp = mmap(addr, len, prot, flag, fd, offset)) == MAP_FAILED)
		logging(ERROR, "mmap: %s\n", strerror(errno));

	return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
callq 0x2060
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0x20e0
movq %rax, -0x30(%rbp)
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0x2766
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x5304c(%rip), %rsi     # 0x557ab
movb $0x0, %al
callq 0x2450
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: emunmap
int emunmap(void *ptr, size_t len)
{
	int ret;
	errno = 0;

	if ((ret = munmap(ptr, len)) < 0)
		logging(ERROR, "munmap: %s\n", strerror(errno));

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2060
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2220
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0x27c2
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x52ffa(%rip), %rsi     # 0x557b5
movb $0x0, %al
callq 0x2450
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: ecalloc
void *ecalloc(size_t nmemb, size_t size)
{
	void *ptr;
	errno = 0;

	if ((ptr = calloc(nmemb, size)) == NULL)
		logging(ERROR, "calloc: %s\n", strerror(errno));

	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2060
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2170
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2824
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x52fa4(%rip), %rsi     # 0x557c1
movb $0x0, %al
callq 0x2450
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: erealloc
void *erealloc(void *ptr, size_t size)
{
	void *new;
	errno = 0;

	if ((new = realloc(ptr, size)) == NULL)
		logging(ERROR, "realloc: %s\n", strerror(errno));

	return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2060
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2210
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2884
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x52f50(%rip), %rsi     # 0x557cd
movb $0x0, %al
callq 0x2450
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: eselect
int eselect(int maxfd, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *tv)
{
	int ret;
	errno = 0;

	if ((ret = select(maxfd, readfds, writefds, errorfds, tv)) < 0) {
		if (errno == EINTR)
			return eselect(maxfd, readfds, writefds, errorfds, tv);
		else
			logging(ERROR, "select: %s\n", strerror(errno));
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
callq 0x2060
movl $0x0, (%rax)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x21d0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jge 0x2921
callq 0x2060
cmpl $0x4, (%rax)
jne 0x28fd
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x2890
movl %eax, -0x4(%rbp)
jmp 0x2927
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x52ec2(%rip), %rsi     # 0x557da
movb $0x0, %al
callq 0x2450
jmp 0x2921
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: ewrite
ssize_t ewrite(int fd, const void *buf, size_t size)
{
	ssize_t ret;
	errno = 0;

	if ((ret = write(fd, buf, size)) < 0) {
		if (errno == EINTR) {
			logging(ERROR, "write: EINTR occurred\n");
			return ewrite(fd, buf, size);
		} else if (errno == EAGAIN || errno == EWOULDBLOCK) {
			logging(ERROR, "write: EAGAIN or EWOULDBLOCK occurred, sleep %d usec\n", SLEEP_TIME);
			usleep(SLEEP_TIME);
			return ewrite(fd, buf, size);
		} else {
			logging(ERROR, "write: %s\n", strerror(errno));
			return ret;
		}
	} else if (ret < (ssize_t) size) {
		logging(ERROR, "data size:%zu write size:%zd\n", size, ret);
		return ewrite(fd, (char *) buf + ret, size - ret);
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x2060
movl $0x0, (%rax)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x20b0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jge 0x2a1a
callq 0x2060
cmpl $0x4, (%rax)
jne 0x29a2
movl $0x2, %edi
leaq 0x52e64(%rip), %rsi     # 0x557e6
movb $0x0, %al
callq 0x2450
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2930
movq %rax, -0x8(%rbp)
jmp 0x2a67
callq 0x2060
cmpl $0xb, (%rax)
je 0x29b6
callq 0x2060
cmpl $0xb, (%rax)
jne 0x29ee
movl $0x2, %edi
leaq 0x52e3b(%rip), %rsi     # 0x557fd
movl $0x7530, %edx           # imm = 0x7530
movb $0x0, %al
callq 0x2450
movl $0x7530, %edi           # imm = 0x7530
callq 0x2340
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2930
movq %rax, -0x8(%rbp)
jmp 0x2a67
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x52e2a(%rip), %rsi     # 0x55833
movb $0x0, %al
callq 0x2450
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a67
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x2a5d
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x2, %edi
leaq 0x52e06(%rip), %rsi     # 0x5583e
movb $0x0, %al
callq 0x2450
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x28(%rbp), %rdx
callq 0x2930
movq %rax, -0x8(%rbp)
jmp 0x2a67
jmp 0x2a5f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: esigaction
int esigaction(int signo, struct sigaction *act, struct sigaction *oact)
{
	int ret;
	errno = 0;

	if ((ret = sigaction(signo, act, oact)) < 0)
		logging(ERROR, "sigaction: %s\n", strerror(errno));

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x2060
movl $0x0, (%rax)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2090
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x2ad8
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x52d8b(%rip), %rsi     # 0x5585c
movb $0x0, %al
callq 0x2450
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: etcgetattr
int etcgetattr(int fd, struct termios *tm)
{
	int ret;
	errno = 0;

	if ((ret = tcgetattr(fd, tm)) < 0)
		logging(ERROR, "tcgetattr: %s\n", strerror(errno));

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2060
movl $0x0, (%rax)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2240
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0x2b40
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x52d32(%rip), %rsi     # 0x5586b
movb $0x0, %al
callq 0x2450
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: etcsetattr
int etcsetattr(int fd, int action, const struct termios *tm)
{
	int ret;
	errno = 0;

	if ((ret = tcsetattr(fd, action, tm)) < 0)
		logging(ERROR, "tcgetattr: %s\n", strerror(errno));

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x2060
movl $0x0, (%rax)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x2250
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0x2ba6
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x52ccc(%rip), %rsi     # 0x5586b
movb $0x0, %al
callq 0x2450
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/uobikiemukot[P]yaft/./util.h
// Function: eopenpty
int eopenpty(int *amaster, int *aslave, char *aname,
	const struct termios *termp, const struct winsize *winsize)
{
	int master;
	char *name = NULL;
	errno = 0;

	if ((master = posix_openpt(O_RDWR | O_NOCTTY)) < 0
		|| grantpt(master) < 0
		|| unlockpt(master) < 0
		|| (name = ptsname(master)) == NULL) {
		logging(ERROR, "openpty: %s\n", strerror(errno));
		return -1;
	}
	*amaster = master;
	*aslave  = eopen(name, O_RDWR | O_NOCTTY);

	if (aname)
		/* XXX: we don't use the slave's name, do nothing */
		(void) aname;
		//strncpy(aname, name, _POSIX_TTY_NAME_MAX - 1);
		//snprintf(aname, _POSIX_TTY_NAME_MAX, "%s", name);
	if (termp)
		etcsetattr(*aslave, TCSAFLUSH, termp);
	if (winsize)
		ioctl(*aslave, TIOCSWINSZ, winsize);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
callq 0x2060
movl $0x0, (%rax)
movl $0x102, %edi            # imm = 0x102
callq 0x22f0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jl 0x2c1d
movl -0x34(%rbp), %edi
callq 0x22b0
cmpl $0x0, %eax
jl 0x2c1d
movl -0x34(%rbp), %edi
callq 0x2180
cmpl $0x0, %eax
jl 0x2c1d
movl -0x34(%rbp), %edi
callq 0x2040
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x2c48
callq 0x2060
movl (%rax), %edi
callq 0x22d0
movq %rax, %rdx
movl $0x2, %edi
leaq 0x52c42(%rip), %rsi     # 0x5587a
movb $0x0, %al
callq 0x2450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2cad
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x2530
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x2c6e
cmpq $0x0, -0x28(%rbp)
je 0x2c89
movq -0x18(%rbp), %rax
movl (%rax), %edi
movq -0x28(%rbp), %rdx
movl $0x2, %esi
callq 0x2b50
cmpq $0x0, -0x30(%rbp)
je 0x2ca6
movq -0x18(%rbp), %rax
movl (%rax), %edi
movq -0x30(%rbp), %rdx
movl $0x5414, %esi           # imm = 0x5414
movb $0x0, %al
callq 0x2130
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)