LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/eiselekd[P]MinimalLisp/./lf1.c
// Function: lf_apply_p
v *
lf_apply_p(lfctx *lfctx) 
{
    fctx *cctx = (fctx *)lfctx; v *env = 0;
    v *fn = POP; v *args = POP; v *r = 0, *benv; int a = 0, isop = 0;
    if( (isop = ((fn->tag == FUNC) ? 0 : 1)) || fwordp(fn)) {
        benv = TOSE;
        if (FN_FUNCENVP(fn))
            benv = funcenv(fn);
        /* if (FN_ARGBINDP(fn)) */
        /*     benv = evbind(car(func(fn)), args, benv); /\* error, todo: bind eval'ed args  *\/ */
        env = benv;
        a = (FN_ARGEVALP(fn)) ? 1 : 0;
    } else {
        fprintf(stderr, "Cannot apply to "); print((ctx*)cctx, stderr, fn); fprintf(stderr, "\n"); 
    }
    PUSH(env);
    PUSH(args);
    PUSH(fn);
    PUSH(mkInt(isop));
    PUSH(mkInt(a));
    return r;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x120(%rdi), %rcx
testq %rcx, %rcx
je 0xa9d4
movq 0x10(%rcx), %rax
movq %rax, 0x120(%rbx)
movq 0x8(%rcx), %r14
testq %rax, %rax
je 0xa9db
movq 0x10(%rax), %rsi
movq %rsi, 0x120(%rbx)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa9e5
xorl %esi, %esi
xorl %r14d, %r14d
jmp 0xa9dd
xorl %esi, %esi
movq $0x0, -0x30(%rbp)
movl (%r14), %r12d
movl %r12d, %r15d
andl $0xf, %r15d
cmpl $0x4, %r15d
je 0xaa9a
movq 0x178(%rbx), %rax
testq %rax, %rax
je 0xaa0b
movq 0x8(%rax), %rdi
jmp 0xaa0d
xorl %edi, %edi
testb $0x20, %r12b
je 0xaa17
movq 0x10(%r14), %rdi
shrl $0x4, %r12d
andl $0x1, %r12d
xorl %r13d, %r13d
cmpl $0x4, %r15d
setne %r13b
callq 0x2362
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x2362
movq %r14, %rdi
movq %rax, %rsi
callq 0x2362
movq %rax, 0x120(%rbx)
movq %r13, %rdi
callq 0x2383
movq 0x120(%rbx), %rsi
movq %rax, %rdi
callq 0x2362
movq %rax, 0x120(%rbx)
movq %r12, %rdi
callq 0x2383
movq 0x120(%rbx), %rsi
movq %rax, %rdi
callq 0x2362
movq %rax, 0x120(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5557(%rip), %r12      # 0xfff8
movq (%r12), %rcx
leaq 0x16b0(%rip), %rdi      # 0xc15c
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x21a0
movq (%r12), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2878
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x2090
movq 0x120(%rbx), %rsi
xorl %edi, %edi
xorl %r12d, %r12d
jmp 0xaa1f
// File: /workspace/github_c_makefile_star2_O2/eiselekd[P]MinimalLisp/./lf1.c
// Function: lf_remap
void
lf_remap(lfctx *lfctx)
{
    struct ctx *lctx = (struct ctx *) lfctx;
    struct fctx *fctx = (struct fctx *)lfctx;
    v *le = 0, *fe; struct lf_maps *c = m;
    while(c->ln && c->fn) {
        if ((le = assq(unique(lctx,c->ln, strlen(c->ln)), lctx->env)) &&
            (fe = assq(unique(lctx,c->fn, strlen(c->fn)), fctx->env))) {
            rplacd(le,cdr(fe));
            printf("Map %s to %s (0x%p)\n", c->ln, c->fn, cdr(fe));
        } else {
            printf("Cannot map %s to %s\n", c->ln, c->fn);
        }
        c++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4b41(%rip), %r15      # 0x102d8
leaq 0xcd6(%rip), %r14       # 0xc474
movq -0x8(%r15), %r12
testq %r12, %r12
je 0xb844
cmpq $0x0, (%r15)
je 0xb844
movq %r12, %rdi
callq 0x2060
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x32a0
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x27b2
testq %rax, %rax
je 0xb82a
movq %rax, %r12
movq (%r15), %r13
movq %r13, %rdi
callq 0x2060
movq %rbx, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x32a0
movq 0x148(%rbx), %rsi
movq %rax, %rdi
callq 0x27b2
testq %rax, %rax
je 0xb82a
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r12)
movq -0x8(%r15), %rsi
movq (%r15), %rdx
leaq 0xc3e(%rip), %rdi       # 0xc45f
xorl %eax, %eax
callq 0x2070
jmp 0xb83b
movq -0x8(%r15), %rsi
movq (%r15), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2070
addq $0x10, %r15
jmp 0xb79e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/soso7885[P]OPCUA_example/demo_src/server_datasource.c
// Function: readInteger
static UA_StatusCode
readInteger(void *handle, const UA_NodeId nodeid, UA_Boolean sourceTimeStamp,
            const UA_NumericRange *range, UA_DataValue *dataValue) {
    dataValue->hasValue = true;
    UA_Variant_setScalarCopy(&dataValue->value, (UA_UInt32*)handle, &UA_TYPES[UA_TYPES_INT32]);
    // we know the nodeid is a string
    UA_LOG_INFO(logger, UA_LOGCATEGORY_USERLAND, "Node read %.*s",
                nodeid.identifier.string.length, nodeid.identifier.string.data);
    UA_LOG_INFO(logger, UA_LOGCATEGORY_USERLAND, "read value %i", *(UA_UInt32*)handle);
    return UA_STATUSCODE_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
orb $0x1, (%rcx)
leaq 0x8(%rcx), %rdi
movl $0xc8, %edx
addq 0x2b98(%rip), %rdx      # 0x3fd8
movq %rbx, %rsi
callq 0x1080
movq 0x2c31(%rip), %r9       # 0x4080
testq %r9, %r9
je 0x1492
leaq 0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %r8
leaq 0xbc9(%rip), %rdx       # 0x2030
pushq $0x2
popq %rdi
pushq $0x5
popq %rsi
xorl %eax, %eax
callq *%r9
movq 0x2c07(%rip), %r8       # 0x4080
testq %r8, %r8
je 0x1492
movl (%rbx), %ecx
leaq 0xbb8(%rip), %rdx       # 0x203f
pushq $0x2
popq %rdi
pushq $0x5
popq %rsi
xorl %eax, %eax
callq *%r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/soso7885[P]OPCUA_example/demo_src/server_datasource.c
// Function: writeInteger
static UA_StatusCode
writeInteger(void *handle, const UA_NodeId nodeid,
             const UA_Variant *data, const UA_NumericRange *range) {
    if(UA_Variant_isScalar(data) && data->type == &UA_TYPES[UA_TYPES_INT32] && data->data){
        *(UA_UInt32*)handle = *(UA_UInt32*)data->data;
    }
    // we know the nodeid is a string
    UA_LOG_INFO(logger, UA_LOGCATEGORY_USERLAND, "Node written %.*s",
                nodeid.identifier.string.length, nodeid.identifier.string.data);
    UA_LOG_INFO(logger, UA_LOGCATEGORY_USERLAND, "written value %i", *(UA_UInt32*)handle);
    return UA_STATUSCODE_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rsi)
jne 0x14ca
movq 0x18(%rsi), %rax
cmpq $0x2, %rax
jb 0x14ca
movl $0xc8, %ecx
addq 0x2b17(%rip), %rcx      # 0x3fd8
cmpq %rcx, (%rsi)
jne 0x14ca
movl (%rax), %eax
movl %eax, (%rbx)
movq 0x2baf(%rip), %r9       # 0x4080
testq %r9, %r9
je 0x1514
leaq 0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rax), %r8
leaq 0xb64(%rip), %rdx       # 0x204d
pushq $0x2
popq %rdi
pushq $0x5
popq %rsi
xorl %eax, %eax
callq *%r9
movq 0x2b85(%rip), %r8       # 0x4080
testq %r8, %r8
je 0x1514
movl (%rbx), %ecx
leaq 0xb56(%rip), %rdx       # 0x205f
pushq $0x2
popq %rdi
pushq $0x5
popq %rsi
xorl %eax, %eax
callq *%r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %ecx, %ecx
movb $0x1a, %dl
cmpq %rcx, %rsi
je 0x105d
movb (%rdi,%rcx), %al
leal -0x61(%rax), %r9d
movb $0x61, %r8b
cmpb $0x1a, %r9b
jb 0x1046
leal -0x41(%rax), %r9d
movb $0x41, %r8b
cmpb $0x19, %r9b
ja 0x1058
subb %r8b, %al
addb $0xd, %al
cbtw
idivb %dl
movsbl %ah, %eax
addb %r8b, %al
movb %al, (%rdi,%rcx)
incq %rcx
jmp 0x1024
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x2e44(%rip), %rbx      # 0x3ff8
movq (%rbx), %rsi
leaq 0xe46(%rip), %rdi       # 0x2004
callq 0x1060
movq (%rbx), %rsi
leaq 0xe55(%rip), %rdi       # 0x2022
callq 0x1060
movq (%rbx), %rsi
leaq 0xe6f(%rip), %rdi       # 0x204b
callq 0x1060
movq (%rbx), %rsi
leaq 0xe82(%rip), %rdi       # 0x206d
callq 0x1060
movq (%rbx), %rsi
leaq 0xe94(%rip), %rdi       # 0x208e
popq %rbx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x1070
testl %eax, %eax
js 0x124d
popq %rbx
retq
callq 0x1030
movl (%rax), %edi
callq 0x10a0
leaq 0xe63(%rip), %rdi       # 0x20c3
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
pushq $0x1
popq %rdi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
cmpl $0x2, %edi
jle 0x12a5
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x1232
pushq $0x2
popq %rsi
movl %eax, %edi
callq 0x1200
movq 0x10(%rbx), %rdi
addq $0x10, %rbx
movq %rbx, %rsi
callq 0x1080
negl %eax
popq %rbx
retq
callq 0x11ac
pushq $0x1
popq %rdi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
callq 0x1090
callq 0x1050
movl %eax, 0x2edb(%rip)      # 0x40a0
callq 0x1070
movl %eax, 0x2ed4(%rip)      # 0x40a4
xorl %eax, %eax
leaq 0x2ed7(%rip), %rbx      # 0x40b0
cmpq $0x400, %rax            # imm = 0x400
je 0x11ec
orq $-0x1, (%rax,%rbx)
addq $0x8, %rax
jmp 0x11d9
xorl %eax, %eax
leaq 0x32bb(%rip), %r14      # 0x44b0
cmpq $0x18, %rax
je 0x1206
orq $-0x1, (%rax,%r14)
addq $0x8, %rax
jmp 0x11f5
callq 0x1080
movl 0x2e8e(%rip), %r9d      # 0x40a0
movq %r14, (%rsp)
leaq 0x2e53(%rip), %rsi      # 0x4070
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10a0
callq 0x1080
movl 0x2e6c(%rip), %edx      # 0x40a4
movl 0x2e62(%rip), %ecx      # 0x40a0
leaq 0xdc5(%rip), %rdi       # 0x200a
leaq 0xdb8(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1030
leaq 0xdc3(%rip), %r14       # 0x201d
xorl %r15d, %r15d
cmpq $0x400, %r15            # imm = 0x400
je 0x127a
movq (%r15,%rbx), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
addq $0x8, %r15
jmp 0x125d
pushq $0xa
popq %rdi
callq 0x1040
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsp, %rbx
pushq $0x64
popq %r14
movq 0x2dd8(%rip), %r12      # 0x3fe0
pushq $0x2f
popq %r13
leaq 0xdf1(%rip), %rbp       # 0x2004
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12f6
cmpl $-0x1, %eax
je 0x12e5
movl %eax, %r15d
callq 0x10e0
movq (%rax), %rax
movslq %r15d, %rcx
testb $0x4, 0x1(%rax,%rcx,2)
jne 0x1267
cmpl $0x22, %r15d
je 0x12b8
cmpl $0x23, %r15d
je 0x128c
cmpl $0x27, %r15d
je 0x12a2
cmpl $0x2f, %r15d
jne 0x12ce
movq (%r12), %rsi
movl %r13d, %edi
callq 0x10b0
callq 0x13e8
jmp 0x1213
movq %rbx, %rdi
callq 0x13a9
testq %rax, %rax
je 0x127d
movq 0x8(%rax), %rsi
movq %rbp, %rdi
jmp 0x1283
movq %rbp, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
jmp 0x1213
movq (%r12), %rsi
pushq $0x23
popq %rdi
callq 0x10b0
callq 0x14c9
jmp 0x1213
movq (%r12), %rsi
pushq $0x27
popq %rdi
callq 0x10b0
callq 0x14b5
jmp 0x1213
movq (%r12), %rsi
pushq $0x22
popq %rdi
callq 0x10b0
callq 0x14bf
jmp 0x1213
movq 0x2d03(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
movl %r15d, %edi
callq 0x1080
jmp 0x1213
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x2bec(%rip), %r14      # 0x3fe0
movq (%r14), %rdi
callq 0x10d0
cmpl $0x2f, %eax
jne 0x14a6
movq 0x2bcc(%rip), %r15      # 0x3fd8
movq (%r15), %rsi
pushq $0x2f
popq %rdi
callq 0x1080
movq (%r14), %rdi
callq 0x10d0
cmpl $0x2a, %eax
je 0x1447
cmpl $0x2f, %eax
jne 0x14a6
movq (%r15), %rsi
movl %eax, %edi
callq 0x1080
movq (%r14), %rdi
callq 0x10d0
cmpl $-0x1, %eax
je 0x14a6
cmpl $0xa, %eax
jne 0x1429
jmp 0x14a6
movq (%r15), %rsi
pushq $0x2a
popq %rdi
callq 0x1080
movq (%r14), %rdi
callq 0x10d0
cmpl $-0x1, %eax
je 0x1489
movl %eax, %ebx
movq (%r15), %rsi
movl %eax, %edi
callq 0x1080
cmpl $0x2a, %ebx
jne 0x1452
movq (%r14), %rdi
callq 0x10d0
movl %eax, %ebx
movq (%r15), %rsi
movl %eax, %edi
callq 0x1080
cmpl $0x2f, %ebx
jne 0x1452
movq (%r14), %rdi
callq 0x10d0
cmpl $0x2f, %eax
jne 0x14a6
movq (%r15), %rsi
pushq $0x2f
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1080
movq (%r14), %rsi
movl %eax, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0xe0, %rsp
movq 0x2b08(%rip), %rbx      # 0x3fe0
movq (%rbx), %rdi
callq 0x10d0
cmpl $0x23, %eax
jne 0x155d
movq 0x2aec(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
pushq $0x23
popq %rdi
callq 0x1080
leaq 0xb09(%rip), %rsi       # 0x2007
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x178e
leaq 0xb1f(%rip), %rsi       # 0x202f
pushq $0x7
popq %rdx
movq %rbx, %rdi
callq 0x10c0
testl %eax, %eax
je 0x156f
movl %eax, %ebx
leaq 0xb0e(%rip), %rsi       # 0x2036
movq %rsp, %rdi
pushq $0x6
popq %rdx
callq 0x10c0
testl %eax, %eax
jne 0x15cc
callq 0x17ec
leaq 0xaf5(%rip), %rsi       # 0x203c
movq %rsp, %rdi
callq 0x178e
testl %ebx, %ebx
je 0x1583
movq %rsp, %rdi
callq 0x169b
jmp 0x15cc
movq (%rbx), %rsi
movl %eax, %edi
addq $0xe0, %rsp
popq %rbx
jmp 0x10b0
callq 0x17ec
leaq 0xac1(%rip), %rsi       # 0x203c
movq %rsp, %rdi
callq 0x178e
callq 0x17ec
leaq 0x70(%rsp), %rbx
pushq $0x64
popq %rsi
movq %rbx, %rdi
callq 0x1725
leaq 0xa65(%rip), %rdi       # 0x2004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
callq 0x13a9
testq %rax, %rax
je 0x15bf
movq 0x8(%rax), %rsi
movq %rsp, %rdi
jmp 0x15c7
movq %rsp, %rdi
leaq 0x70(%rsp), %rsi
callq 0x161d
addq $0xe0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
callq 0x10e0
movq %rax, %r12
movq 0x2899(%rip), %r13      # 0x3fe0
movq (%r12), %rbp
movq (%r13), %rdi
callq 0x10d0
movslq %eax, %rcx
testb $0x8, (%rbp,%rcx,2)
je 0x176c
cmpq %r15, %rbx
jae 0x176c
movb %al, (%r14,%rbx)
incq %rbx
jmp 0x1747
movb $0x0, (%r14,%rbx)
movq (%r13), %rsi
movl %eax, %edi
callq 0x10b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x64
popq %rsi
callq 0x12f6
cmpl $-0x1, %eax
je 0x17d6
movl %eax, %ebp
callq 0x10e0
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x4, 0x1(%rax,%rcx,2)
jne 0x17c1
movq %r14, %rdi
callq 0x1050
leaq 0x83c(%rip), %rdi       # 0x2004
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
movq 0x2803(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
pushq $-0x1
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x10e0
movq %rax, %rbx
movq 0x27dd(%rip), %r14      # 0x3fe0
movq 0x27ce(%rip), %r15      # 0x3fd8
movq (%rbx), %r12
movq (%r14), %rdi
callq 0x10d0
movslq %eax, %rcx
testb $0x1, (%r12,%rcx,2)
je 0x182b
movq (%r15), %rsi
movl %eax, %edi
callq 0x1080
jmp 0x180a
movq (%r14), %rsi
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movl %edi, %r14d
movq 0x278c(%rip), %r15      # 0x3fe0
movq (%r15), %rdi
callq 0x10d0
movl %eax, %ebx
cmpl %r14d, %eax
jne 0x18c2
movq 0x276e(%rip), %r14      # 0x3fd8
movq (%r14), %rsi
movl %ebx, %edi
callq 0x1080
movsbl %bpl, %r12d
pushq $-0x1
popq %rbx
movq (%r15), %rdi
callq 0x10d0
cmpl $-0x1, %eax
je 0x18c2
movl %eax, %ebp
movq (%r14), %rsi
movl %eax, %edi
callq 0x1080
cmpl $0x5c, %ebp
jne 0x18b4
movq (%r15), %rdi
callq 0x10d0
movl %eax, %ebp
movq (%r14), %rsi
movl %eax, %edi
callq 0x1080
cmpl $-0x1, %ebp
jne 0x187b
jmp 0x18c2
cmpl %r12d, %ebp
jne 0x187b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rsi
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movss 0xadc0(%rip), %xmm1     # 0x144e0
movq 0xd439(%rip), %rdi      # 0x16b60
testq %rdi, %rdi
je 0x9747
xorl %esi, %esi
movss %xmm1, 0x4(%rsp)
callq 0x5450
movss 0x4(%rsp), %xmm1
movss %xmm0, 0xad95(%rip)     # 0x144dc
movss 0x42f1(%rip), %xmm0     # 0xda40
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movq 0xd40a(%rip), %rcx      # 0x16b68
movl 0xd3f4(%rip), %edx      # 0x16b58
shlq $0x4, %rdx
movw %ax, 0xe(%rcx,%rdx)
movq (%rcx,%rdx), %rax
andl $0xffffff, %eax         # imm = 0xFFFFFF
mulss 0x42c6(%rip), %xmm1     # 0xda44
cvttss2si %xmm1, %esi
shll $0x18, %esi
movslq %esi, %rsi
orq %rax, %rsi
movq %rsi, (%rcx,%rdx)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, 0xd4bd(%rip)      # 0x16c60
jne 0x97cb
movl $0x103, 0xd3a9(%rip)    # imm = 0x103
movq $0x104, 0xd3b6(%rip) # imm = 0x104
movl $0x1040, %edi           # imm = 0x1040
callq 0x5a0c
movq %rax, 0xd39d(%rip)      # 0x16b68
leaq 0x823e(%rip), %r12      # 0x11a10
pushq $-0x10
popq %r13
leaq 0x439a(%rip), %rbx      # 0xdb77
leaq 0x4374(%rip), %r14      # 0xdb58
xorl %ebp, %ebp
leaq 0x11(%r13), %rcx
movq 0xd37f(%rip), %rax      # 0x16b70
cmpq %rcx, %rax
jbe 0x9845
movq 0xd36b(%rip), %rdx      # 0x16b68
addq %rbp, %rdx
leaq 0x10(%r13), %r15
movl %r15d, %edi
xorl %esi, %esi
callq 0x9883
testl %eax, %eax
jne 0x9838
cmpq $0xf0, %r13
jae 0x982a
movq %rbx, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x5a36
jmp 0x9838
movq (%r12), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x5a36
addq $0x8, %r12
addq $0x10, %rbp
incq %r13
jmp 0x97e6
testq %rax, %rax
je 0x9868
movl 0xac9c(%rip), %edi      # 0x144ec
movl 0xd302(%rip), %edx      # 0x16b58
shlq $0x4, %rdx
addq 0xd307(%rip), %rdx      # 0x16b68
xorl %esi, %esi
callq 0x9883
callq 0x9717
movb $0x1, 0xd3ec(%rip)      # 0x16c60
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0xa
popq %rdi
callq 0x1050
movl 0x8(%rbx), %esi
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
xorl %edx, %edx
cmpq %rcx, %rdx
je 0x19a5
movl 0xc(%rbx), %edi
testl %edi, %edi
cmovlel %eax, %edi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x19a0
movq (%rbx), %r9
movq (%r9,%rdx,8), %r9
cmpl $0x50, (%r9,%r8,4)
je 0x199b
andl $0x0, 0x2715(%rip)      # 0x40b0
incq %r8
jmp 0x1981
incq %rdx
jmp 0x1971
cmpl $0x1, 0x2704(%rip)      # 0x40b0
movl 0xc(%rbx), %edx
leaq 0x67b(%rip), %rax       # 0x2031
leaq 0x6b4(%rip), %rdi       # 0x2071
cmoveq %rax, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10a0
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x3052(%rip), %rax      # 0x44b0
cmpq %rdi, (%rax)
ja 0x1473
leaq 0x2c2e(%rip), %rax      # 0x4098
cmpq %rdi, (%rax)
jbe 0x1473
pushq $0x1
popq %rax
retq
xorl %eax, %eax
cmpb $0x1, 0x2bfc(%rip)      # 0x4078
jne 0x1497
cmpq %rdi, 0x2bfb(%rip)      # 0x4080
setbe %al
cmpq %rdi, 0x2bd9(%rip)      # 0x4068
seta %cl
andb %al, %cl
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
callq 0x1040
testq %rax, %rax
je 0x11be
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1070
testq %rax, %rax
je 0x11b5
addq $0x13, %rax
movq %rax, %rdi
callq 0x1030
jmp 0x119a
movq %rbx, %rdi
popq %rbx
jmp 0x1060
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
cmpl $0x1, %edi
jne 0x1204
callq 0x11c0
jmp 0x1220
cmpl $0x3, %edi
jl 0x1217
leaq 0xe03(%rip), %rdi       # 0x2013
callq 0x1030
jmp 0x1220
movq 0x8(%rsi), %rdi
callq 0x118c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movl (%rsi), %ebx
xorl %ebp, %ebp
movsbl (%rdi), %eax
testl %eax, %eax
je 0x1642
imull $0x1a, %ebp, %ecx
leal (%rcx,%rax), %ebp
addl $-0x61, %ebp
incq %rdi
jmp 0x162d
cmpl %ebp, %ebx
je 0x1652
leaq 0x2a2a(%rip), %rdi      # 0x4077
callq 0x1060
cmpl %ebp, %ebx
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsp, %rbx
movb $0x0, 0x4(%rbx)
movl $0x676f7270, (%rbx)     # imm = 0x676F7270
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x10(%r14)
movq %rbx, (%r14)
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq (%rsi), %r12
callq 0x1030
movslq %eax, %rdx
leaq 0xe36(%rip), %rdi       # 0x2009
movq %r12, %rsi
xorl %eax, %eax
callq 0x1040
leaq 0xe39(%rip), %rdi       # 0x201d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
pushq $0x2
popq %rdi
callq 0x1080
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
leaq 0xe45(%rip), %rdi       # 0x2050
callq 0x1060
pushq $0x1
popq %rdi
callq 0x1070
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x24a5
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testl %edi, %edi
jne 0x24b4
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
movq %rsi, %rbx
movq 0x52b3a(%rip), %r14     # 0x54ff8
movq (%r14), %rax
movl %edi, %ecx
leaq 0x50aa(%rip), %rsi      # 0x7574
movslq (%rsi,%rcx,4), %rdx
addq %rsi, %rdx
leaq 0x4f38c(%rip), %rsi     # 0x51864
movq %rax, %rdi
xorl %eax, %eax
callq 0x2190
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rdx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2290
jmp 0x24a9
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movq %r15, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x2260
movl %eax, %ebx
testl %eax, %eax
jns 0x256e
leaq 0x4f328(%rip), %rsi     # 0x5186c
pushq $0x2
popq %rbp
movl %ebp, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x244c
movl (%r14), %edi
callq 0x22d0
leaq 0x4f31f(%rip), %rsi     # 0x51881
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movl %ebx, %edi
callq 0x2140
movl %eax, %ebx
testl %eax, %eax
jns 0x25b5
movl (%r14), %edi
callq 0x22d0
leaq 0x4f2e4(%rip), %rsi     # 0x5188c
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2270
movq %rax, %rbx
testq %rax, %rax
jne 0x261b
leaq 0x4f27b(%rip), %rsi     # 0x5186c
pushq $0x2
popq %rbp
movl %ebp, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x244c
movl (%r14), %edi
callq 0x22d0
leaq 0x4f271(%rip), %rsi     # 0x51880
movl %ebp, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movq %rbx, %rdi
callq 0x20c0
movl %eax, %ebx
testl %eax, %eax
jns 0x2665
movl (%r14), %edi
callq 0x22d0
leaq 0x4f233(%rip), %rsi     # 0x5188b
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %r15d, %ecx
movl %ebp, %r8d
movq (%rsp), %r9
callq 0x20e0
movq %rax, %rbx
cmpq $-0x1, %rax
jne 0x26d5
movl (%r14), %edi
callq 0x22d0
leaq 0x4f1cf(%rip), %rsi     # 0x51897
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2220
movl %eax, %ebx
testl %eax, %eax
jns 0x272a
movl (%r14), %edi
callq 0x22d0
leaq 0x4f184(%rip), %rsi     # 0x518a1
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2060
andl $0x0, (%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2170
movq %rax, %rbx
testq %rax, %rax
jne 0x2772
xorl %edi, %edi
callq 0x22d0
leaq 0x4f148(%rip), %rsi     # 0x518ad
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2210
movq %rax, %rbx
testq %rax, %rax
jne 0x27c2
movl (%r14), %edi
callq 0x22d0
leaq 0x4f104(%rip), %rsi     # 0x518b9
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %r13d
callq 0x2060
movq %rax, %rbx
andl $0x0, (%rbx)
movl %r13d, %edi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq (%rsp), %r8
callq 0x21d0
movl %eax, %ebp
testl %eax, %eax
jns 0x282c
movl (%rbx), %edi
cmpl $0x4, %edi
je 0x27ee
callq 0x22d0
leaq 0x4f0a7(%rip), %rsi     # 0x518c6
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movl %edi, %ebp
callq 0x2060
movq %rax, %r14
leaq 0x4f08a(%rip), %r13     # 0x518e9
andl $0x0, (%r14)
movl %ebp, %edi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x20b0
movq %rax, %r15
testq %rax, %rax
jns 0x28b6
movl (%r14), %edi
cmpl $0xb, %edi
je 0x2898
cmpl $0x4, %edi
jne 0x28e0
pushq $0x2
popq %rdi
leaq 0x4f043(%rip), %rsi     # 0x518d2
xorl %eax, %eax
callq 0x244c
jmp 0x285f
pushq $0x2
popq %rdi
movq %r13, %rsi
movl $0x7530, %edx           # imm = 0x7530
xorl %eax, %eax
callq 0x244c
movl $0x7530, %edi           # imm = 0x7530
callq 0x2340
jmp 0x285f
movq %r12, %r13
subq %r15, %r13
jle 0x28f9
pushq $0x2
popq %rdi
leaq 0x4f062(%rip), %rsi     # 0x5192a
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x244c
addq %r15, %rbx
movq %r13, %r12
jmp 0x2858
callq 0x22d0
leaq 0x4f033(%rip), %rsi     # 0x5191f
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movl %edi, %ebp
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2090
movl %eax, %ebx
testl %eax, %eax
jns 0x2954
movl (%r14), %edi
callq 0x22d0
leaq 0x4f001(%rip), %rsi     # 0x51948
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2240
movl %eax, %ebx
testl %eax, %eax
jns 0x29a1
movl (%r14), %edi
callq 0x22d0
leaq 0x4efc3(%rip), %rsi     # 0x51957
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r15d
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movl %r15d, %edi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x2250
movl %eax, %ebx
testl %eax, %eax
jns 0x29f1
movl (%r14), %edi
callq 0x22d0
leaq 0x4ef73(%rip), %rsi     # 0x51957
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %r12
callq 0x2060
movq %rax, %r13
andl $0x0, (%rax)
movl $0x102, %edi            # imm = 0x102
callq 0x22f0
testl %eax, %eax
js 0x2a93
movl %eax, %ebp
movl %eax, %edi
callq 0x22b0
testl %eax, %eax
js 0x2a93
movl %ebp, %edi
callq 0x2180
testl %eax, %eax
js 0x2a93
movl %ebp, %edi
callq 0x2040
testq %rax, %rax
je 0x2a93
movl %ebp, (%r12)
movq %rax, %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x2514
movl %eax, (%r14)
testq %r15, %r15
je 0x2a78
pushq $0x2
popq %rsi
movl %eax, %edi
movq %r15, %rdx
callq 0x29a8
testq %rbx, %rbx
je 0x2ac4
movl (%r14), %edi
xorl %ebp, %ebp
movl $0x5414, %esi           # imm = 0x5414
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2130
jmp 0x2ab3
movl (%r13), %edi
callq 0x22d0
leaq 0x4eec3(%rip), %rsi     # 0x51966
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x2ab3
// File: /workspace/github_c_makefile_star2_O2/uobikiemukot[P]yaft/./util.h
// Function: eforkpty
pid_t eforkpty(int *amaster, char *name,
	const struct termios *termp, const struct winsize *winsize)
{
	int master, slave;
	pid_t pid;

	if (eopenpty(&master, &slave, name, termp, winsize) < 0)
		return -1;

	errno = 0;
	pid   = fork();
	if (pid < 0) {
		logging(ERROR, "fork: %s\n", strerror(errno));
		return pid;
	} else if (pid == 0) { /* child */
		close(master);
		setsid();

		dup2(slave, STDIN_FILENO);
		dup2(slave, STDOUT_FILENO);
		dup2(slave, STDERR_FILENO);

		/* XXX: this ioctl may fail in Mac OS X
			ref http://www.opensource.apple.com/source/Libc/Libc-825.25/util/pty.c?txt */
		if (ioctl(slave, TIOCSCTTY, NULL))
			logging(WARN, "ioctl: TIOCSCTTY faild\n");
		close(slave);

		return 0;
	}
	/* parent */
	close(slave);
	*amaster = master;

	return pid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r8
movq %rdx, %rcx
movq %rdi, %r14
leaq 0x4(%rsp), %rdi
movq %rsp, %rsi
callq 0x29fe
testl %eax, %eax
js 0x2b12
callq 0x2060
movq %rax, %r15
andl $0x0, (%rax)
callq 0x2310
movl %eax, %ebx
testl %eax, %eax
js 0x2b17
je 0x2b35
movl (%rsp), %edi
callq 0x2140
movl 0x4(%rsp), %eax
movl %eax, (%r14)
jmp 0x2b91
pushq $-0x1
popq %rbx
jmp 0x2b91
movl (%r15), %edi
callq 0x22d0
leaq 0x4ee4d(%rip), %rsi     # 0x51973
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
jmp 0x2b91
movl 0x4(%rsp), %edi
callq 0x2140
callq 0x2150
movl (%rsp), %ebp
xorl %ebx, %ebx
movl %ebp, %edi
xorl %esi, %esi
callq 0x20f0
pushq $0x1
popq %rsi
movl %ebp, %edi
callq 0x20f0
pushq $0x2
popq %rsi
movl %ebp, %edi
callq 0x20f0
movl $0x540e, %esi           # imm = 0x540E
movl %ebp, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2130
testl %eax, %eax
je 0x2b8a
leaq 0x4edfd(%rip), %rsi     # 0x5197d
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x244c
movl %ebp, %edi
callq 0x2140
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/uobikiemukot[P]yaft/./util.h
// Function: esetenv
int esetenv(const char *name, const char *value, int overwrite)
{
	int ret;
	errno = 0;

	if ((ret = setenv(name, value, overwrite)) < 0)
		logging(ERROR, "setenv: %s\n", strerror(errno));

	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x20a0
movl %eax, %ebx
testl %eax, %eax
jns 0x2be8
movl (%r14), %edi
callq 0x22d0
leaq 0x4edba(%rip), %rsi     # 0x51995
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/uobikiemukot[P]yaft/./util.h
// Function: eexecvp
int eexecvp(const char *file, char *const argv[])
{
	int ret;
	errno = 0;

	if ((ret = execvp(file, (char * const *) argv)) < 0)
		logging(ERROR, "execvp: %s\n", strerror(errno));

	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2060
movq %rax, %r14
andl $0x0, (%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22a0
movl %eax, %ebx
testl %eax, %eax
jns 0x2c39
movl (%r14), %edi
callq 0x22d0
leaq 0x4ed75(%rip), %rsi     # 0x519a1
pushq $0x2
popq %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x244c
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq