LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_FindByName
int Jim_FindByName(const char *name, const char * const array[], size_t len)
{
    int i;

    for (i = 0; i < (int)len; i++) {
        if (array[i] && strcmp(array[i], name) == 0) {
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
jge 0x14564
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x14557
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x6300
cmpl $0x0, %eax
jne 0x14557
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1456b
jmp 0x14559
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1451b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: add_cmd_usage
static void add_cmd_usage(Jim_Interp *interp, const jim_subcmd_type * ct, Jim_Obj *cmd)
{
    if (cmd) {
        Jim_AppendStrings(interp, Jim_GetResult(interp), Jim_String(cmd), " ", NULL);
    }
    Jim_AppendStrings(interp, Jim_GetResult(interp), ct->cmd, NULL);
    if (ct->args && *ct->args) {
        Jim_AppendStrings(interp, Jim_GetResult(interp), " ", ct->args, NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x146a5
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7960
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
leaq 0x2923c(%rip), %rcx     # 0x3d8d5
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xca20
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0xca20
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x14703
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x14703
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x291de(%rip), %rdx     # 0x3d8d5
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0xca20
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: subcmd_cmd_list
static Jim_Obj *subcmd_cmd_list(Jim_Interp *interp, const jim_subcmd_type * ct, const char *sep)
{

    Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
    Jim_Obj *sortCmd[2];

    for (; ct->cmd; ct++) {
        if (!(ct->flags & JIM_MODFLAG_HIDDEN)) {
            Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, ct->cmd, -1));
        }
    }


    sortCmd[0] = Jim_NewStringObj(interp, "lsort", -1);
    sortCmd[1] = listObj;

    if (Jim_EvalObjVector(interp, 2, sortCmd) == JIM_OK) {
        return Jim_ListJoin(interp, Jim_GetResult(interp), sep, strlen(sep));
    }

    return Jim_GetResult(interp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x7b50
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x14cf6
movq -0x18(%rbp), %rax
movzwl 0x1c(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x14ce6
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7990
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x7bd0
jmp 0x14ce8
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0x14c97
movq -0x10(%rbp), %rdi
leaq 0x279c1(%rip), %rsi     # 0x3c6c2
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7990
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rdx
movl $0x2, %esi
callq 0x12aa0
cmpl $0x0, %eax
jne 0x14d6b
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6190
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movl %eax, %ecx
callq 0x10690
movq %rax, -0x8(%rbp)
jmp 0x14d76
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_CallSubCmd
int Jim_CallSubCmd(Jim_Interp *interp, const jim_subcmd_type * ct, int argc, Jim_Obj *const *argv)
{
    int ret = JIM_ERR;

    if (ct) {
        if (ct->flags & JIM_MODFLAG_FULLARGV) {
            ret = ct->function(interp, argc, argv);
        }
        else {
            ret = ct->function(interp, argc - 2, argv + 2);
        }
        if (ret < 0) {
            Jim_SubCmdArgError(interp, ct, argv[0]);
            ret = JIM_ERR;
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x14e91
movq -0x10(%rbp), %rax
movzwl 0x1c(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x14e4f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x24(%rbp)
jmp 0x14e6e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
subl $0x2, %esi
movq -0x20(%rbp), %rdx
addq $0x10, %rdx
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x14e8f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x145b0
movl $0x1, -0x24(%rbp)
jmp 0x14e91
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: utf8_fromunicode
int utf8_fromunicode(char *p, unsigned uc)
{
    if (uc <= 0x7f) {
        *p = uc;
        return 1;
    }
    else if (uc <= 0x7ff) {
        *p++ = 0xc0 | ((uc & 0x7c0) >> 6);
        *p = 0x80 | (uc & 0x3f);
        return 2;
    }
    else if (uc <= 0xffff) {
        *p++ = 0xe0 | ((uc & 0xf000) >> 12);
        *p++ = 0x80 | ((uc & 0xfc0) >> 6);
        *p = 0x80 | (uc & 0x3f);
        return 3;
    }

    else {
        *p++ = 0xf0 | ((uc & 0x1c0000) >> 18);
        *p++ = 0x80 | ((uc & 0x3f000) >> 12);
        *p++ = 0x80 | ((uc & 0xfc0) >> 6);
        *p = 0x80 | (uc & 0x3f);
        return 4;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x7f, -0x14(%rbp)
ja 0x14ec8
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x15004
cmpl $0x7ff, -0x14(%rbp)     # imm = 0x7FF
ja 0x14f13
movl -0x14(%rbp), %eax
andl $0x7c0, %eax            # imm = 0x7C0
shrl $0x6, %eax
orl $0xc0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x15004
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
ja 0x14f81
movl -0x14(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
shrl $0xc, %eax
orl $0xe0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
andl $0xfc0, %eax            # imm = 0xFC0
shrl $0x6, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x15004
movl -0x14(%rbp), %eax
andl $0x1c0000, %eax         # imm = 0x1C0000
shrl $0x12, %eax
orl $0xf0, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
andl $0x3f000, %eax          # imm = 0x3F000
shrl $0xc, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
andl $0xfc0, %eax            # imm = 0xFC0
shrl $0x6, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: regnext
static int regnext(regex_t *preg, int p )
{
	int offset;

	offset = NEXT(preg, p);

	if (offset == 0)
		return 0;

	if (OP(preg, p) == BACK)
		return(p-offset);
	else
		return(p+offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x162f1
movl $0x0, -0x4(%rbp)
jmp 0x16317
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x7, (%rax,%rcx,4)
jne 0x1630e
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16317
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: str_int_len
static int str_int_len(const int *seq)
{
	int n = 0;
	while (*seq++) {
		n++;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rbp)
cmpl $0x0, (%rax)
je 0x1634e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1632f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: regopsize
static int regopsize(regex_t *preg, int p )
{

	switch (OP(preg, p)) {
		case REP:
		case REPMIN:
		case REPX:
		case REPXMIN:
			return 5;

		case ANYOF:
		case ANYBUT:
		case EXACTLY: {
			int s = p + 2;
			while (preg->program[s++]) {
			}
			return s - p;
		}
	}
	return 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
addl $-0x4, %eax
subl $0x2, %eax
jb 0x163a7
jmp 0x16387
movl -0x1c(%rbp), %eax
subl $0x8, %eax
je 0x163a7
jmp 0x16391
movl -0x1c(%rbp), %eax
addl $-0xa, %eax
subl $0x3, %eax
ja 0x163d9
jmp 0x1639e
movl $0x5, -0x4(%rbp)
jmp 0x163e0
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x163ce
jmp 0x163b0
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x163e0
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: str_find
static const char *str_find(const char *string, int c, int nocase)
{
	if (nocase) {

		c = utf8_upper(c);
	}
	while (*string) {
		int ch;
		int n = reg_utf8_tounicode_case(string, &ch, nocase);
		if (c == ch) {
			return string;
		}
		string += n;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x16413
movl -0x14(%rbp), %edi
callq 0x60f0
movl %eax, -0x14(%rbp)
jmp 0x16415
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x16456
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq -0x1c(%rbp), %rsi
callq 0x344c0
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x16443
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1645e
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x16415
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: prefix_cmp
static int prefix_cmp(const int *prog, int proglen, const char *string, int nocase)
{
	const char *s = string;
	while (proglen && *s) {
		int ch;
		int n = reg_utf8_tounicode_case(s, &ch, nocase);
		if (ch != *prog) {
			return -1;
		}
		prog++;
		s += n;
		proglen--;
	}
	if (proglen == 0) {
		return s - string;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x39(%rbp)
je 0x164a9
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x164b2
jmp 0x16501
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq -0x34(%rbp), %rsi
callq 0x344c0
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x164d9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1651e
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
movl -0x38(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1648e
cmpl $0x0, -0x14(%rbp)
jne 0x16517
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x1651e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: regtry
static int regtry( regex_t *preg, const char *string )
{
	int i;

	preg->reginput = string;

	for (i = 0; i < preg->nmatch; i++) {
		preg->pmatch[i].rm_so = -1;
		preg->pmatch[i].rm_eo = -1;
	}
	if (regmatch(preg, 1)) {
		preg->pmatch[0].rm_so = string - preg->start;
		preg->pmatch[0].rm_eo = preg->reginput - preg->start;
		return(1);
	} else
		return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x16591
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl $0xffffffff, (%rax,%rcx,8) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl $0xffffffff, 0x4(%rax,%rcx,8) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x16553
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x348e0
cmpl $0x0, %eax
je 0x165e8
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x165ef
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_SignalId
const char *Jim_SignalId(int sig)
{
	static char buf[10];
	switch (sig) {
		case SIGINT: return "SIGINT";
		case SIGPIPE: return "SIGPIPE";

	}
	snprintf(buf, sizeof(buf), "%d", sig);
	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x2, %eax
je 0x168c2
jmp 0x168b8
movl -0x10(%rbp), %eax
subl $0xd, %eax
je 0x168cf
jmp 0x168dc
leaq 0x24bb2(%rip), %rax     # 0x3b47b
movq %rax, -0x8(%rbp)
jmp 0x16904
leaq 0x24bac(%rip), %rax     # 0x3b482
movq %rax, -0x8(%rbp)
jmp 0x16904
movl -0xc(%rbp), %ecx
leaq 0x31ad3(%rip), %rdi     # 0x483b9
movl $0xa, %esi
leaq 0x26bbc(%rip), %rdx     # 0x3d4ae
movb $0x0, %al
callq 0x61f0
leaq 0x31ab9(%rip), %rax     # 0x483b9
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: Jim_HistoryGetline
char *Jim_HistoryGetline(Jim_Interp *interp, const char *prompt)
{
#ifdef USE_LINENOISE
    struct JimCompletionInfo *compinfo = JimGetCompletionInfo(interp);
    char *result;
    Jim_Obj *objPtr;
    long mlmode = 0;
    if (compinfo->completion_command) {
        linenoiseSetCompletionCallback(JimCompletionCallback, compinfo);
    }
    if (compinfo->hints_command) {
        linenoiseSetHintsCallback(JimHintsCallback, compinfo);
        linenoiseSetFreeHintsCallback(JimFreeHintsCallback);
    }
    objPtr = Jim_GetVariableStr(interp, "history::multiline", JIM_NONE);
    if (objPtr && Jim_GetLong(interp, objPtr, &mlmode) == JIM_NONE) {
        linenoiseSetMultiLine(mlmode);
    }

    result = linenoise(prompt);

    linenoiseSetCompletionCallback(NULL, NULL);
    linenoiseSetHintsCallback(NULL, NULL);
    linenoiseSetFreeHintsCallback(NULL);
    return result;
#else
    int len;
    char *line = Jim_Alloc(MAX_LINE_LEN);

    fputs(prompt, stdout);
    fflush(stdout);

    if (fgets(line, MAX_LINE_LEN, stdin) == NULL) {
        Jim_Free(line);
        return NULL;
    }
    len = strlen(line);
    if (len && line[len - 1] == '\n') {
        line[len - 1] = '\0';
    }
    return line;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
movl $0x200, %esi            # imm = 0x200
callq *0x31961(%rip)          # 0x48290
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq 0x3163a(%rip), %rax     # 0x47f78
movq (%rax), %rsi
callq 0x6240
movq 0x3162b(%rip), %rax     # 0x47f78
movq (%rax), %rdi
callq 0x6390
movq -0x28(%rbp), %rdi
movq 0x31628(%rip), %rax     # 0x47f88
movq (%rax), %rdx
movl $0x200, %esi            # imm = 0x200
callq 0x62e0
cmpq $0x0, %rax
jne 0x1698e
movq 0x31916(%rip), %rax     # 0x48290
movq -0x28(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x169cf
movq -0x28(%rbp), %rdi
callq 0x6190
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x169c7
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x169c7
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: usage
void usage(const char* executable_name)
{
    printf("jimsh version %d.%d\n", JIM_VERSION / 100, JIM_VERSION % 100);
    printf("Usage: %s\n", executable_name);
    printf("or   : %s [options] [filename]\n", executable_name);
    printf("\n");
    printf("Without options: Interactive mode\n");
    printf("\n");
    printf("Options:\n");
    printf("      --version  : prints the version string\n");
    printf("      --help     : prints this text\n");
    printf("      -e CMD     : executes command CMD\n");
    printf("                   NOTE: all subsequent options will be passed as arguments to the command\n");
    printf("    [filename|-] : executes the script contained in the named file, or from stdin if \"-\"\n");
    printf("                   NOTE: all subsequent options will be passed to the script\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x247ea(%rip), %rdi     # 0x3b4bd
xorl %esi, %esi
movl $0x54, %edx
movb $0x0, %al
callq 0x61e0
movq -0x8(%rbp), %rsi
leaq 0x247e6(%rip), %rdi     # 0x3b4d2
movb $0x0, %al
callq 0x61e0
movq -0x8(%rbp), %rsi
leaq 0x247df(%rip), %rdi     # 0x3b4dd
movb $0x0, %al
callq 0x61e0
leaq 0x2499d(%rip), %rdi     # 0x3b6a9
movb $0x0, %al
callq 0x61e0
leaq 0x247e3(%rip), %rdi     # 0x3b4fd
movb $0x0, %al
callq 0x61e0
leaq 0x24981(%rip), %rdi     # 0x3b6a9
movb $0x0, %al
callq 0x61e0
leaq 0x247ea(%rip), %rdi     # 0x3b520
movb $0x0, %al
callq 0x61e0
leaq 0x247e6(%rip), %rdi     # 0x3b52a
movb $0x0, %al
callq 0x61e0
leaq 0x24806(%rip), %rdi     # 0x3b558
movb $0x0, %al
callq 0x61e0
leaq 0x2481d(%rip), %rdi     # 0x3b57d
movb $0x0, %al
callq 0x61e0
leaq 0x24838(%rip), %rdi     # 0x3b5a6
movb $0x0, %al
callq 0x61e0
leaq 0x24886(%rip), %rdi     # 0x3b602
movb $0x0, %al
callq 0x61e0
leaq 0x248d2(%rip), %rdi     # 0x3b65c
movb $0x0, %al
callq 0x61e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimSetArgv
static void JimSetArgv(Jim_Interp *interp, int argc, char *const argv[])
{
    int n;
    Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);


    for (n = 0; n < argc; n++) {
        Jim_Obj *obj = Jim_NewStringObj(interp, argv[n], -1);

        Jim_ListAppendElement(interp, listObj, obj);
    }

    Jim_SetVariableStr(interp, "argv", listObj);
    Jim_SetVariableStr(interp, "argc", Jim_NewIntObj(interp, argc));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x7b50
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1714f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7990
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7bd0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1710d
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x2686e(%rip), %rsi     # 0x3d9cc
callq 0xdec0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x8d60
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x2684b(%rip), %rsi     # 0x3d9d1
callq 0xdec0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_getfd
static int aio_cmd_getfd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);


    aio_flush(interp, af);

    Jim_SetResultInt(interp, af->fd);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x1b8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x18a70
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq 0x18(%rax), %rsi
callq 0x8d60
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movl 0x10(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rcx)
cmpl $0x0, %eax
jg 0x177e6
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x7a10
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_puts
static int aio_cmd_puts(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);
    int wlen;
    const char *wdata;
    Jim_Obj *strObj;
    int wnow = 0;
    int nl = 1;

    if (argc == 2) {
        if (!Jim_CompareStringImmediate(interp, argv[0], "-nonewline")) {
            return -1;
        }
        strObj = argv[1];
        nl = 0;
    }
    else {
        strObj = argv[0];
    }

#ifdef JIM_MAINTAINER
    if (Jim_IsShared(af->writebuf)) {
        Jim_DecrRefCount(interp, af->writebuf);
        af->writebuf = Jim_DuplicateObj(interp, af->writebuf);
        Jim_IncrRefCount(af->writebuf);
    }
#endif
    Jim_AppendObj(interp, af->writebuf, strObj);
    if (nl) {
        Jim_AppendString(interp, af->writebuf, "\n", 1);
    }


    wdata = Jim_GetString(af->writebuf, &wlen);
    switch (af->wbuft) {
        case WBUF_OPT_NONE:

            wnow = 1;
            break;

        case WBUF_OPT_LINE:

            if (nl || memchr(wdata, '\n', wlen) != NULL) {
                wnow = 1;
            }
            break;

        case WBUF_OPT_FULL:
            if (wlen >= af->wbuf_limit) {
                wnow = 1;
            }
            break;
    }

    if (wnow) {
        return aio_flush(interp, af);
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x1b8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x1, -0x48(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x17b13
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq 0x24cc3(%rip), %rdx     # 0x3c7ab
callq 0x77a0
cmpl $0x0, %eax
jne 0x17afe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x17bf5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x48(%rbp)
jmp 0x17b1e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x40(%rbp), %rdx
callq 0xc9e0
cmpl $0x0, -0x48(%rbp)
je 0x17b56
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
leaq 0x23b5d(%rip), %rdx     # 0x3b6a9
movl $0x1, %ecx
callq 0x8db0
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x89b0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
testl %eax, %eax
je 0x17b8f
jmp 0x17b7b
movl -0x4c(%rbp), %eax
subl $0x1, %eax
je 0x17b98
jmp 0x17b85
movl -0x4c(%rbp), %eax
subl $0x2, %eax
je 0x17bbf
jmp 0x17bd6
movl $0x1, -0x44(%rbp)
jmp 0x17bd6
cmpl $0x0, -0x48(%rbp)
jne 0x17bb6
movq -0x38(%rbp), %rdi
movslq -0x2c(%rbp), %rdx
movl $0xa, %esi
callq 0x62a0
cmpq $0x0, %rax
je 0x17bbd
movl $0x1, -0x44(%rbp)
jmp 0x17bd6
movslq -0x2c(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jb 0x17bd4
movl $0x1, -0x44(%rbp)
jmp 0x17bd6
cmpl $0x0, -0x44(%rbp)
je 0x17bee
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x18a70
movl %eax, -0x4(%rbp)
jmp 0x17bf5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_close
static int aio_cmd_close(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);
    if (argc == 3) {
        int option = -1;
#if defined(HAVE_SOCKETS)
        static const char * const options[] = { "r", "w", "-nodelete", NULL };
        enum { OPT_R, OPT_W, OPT_NODELETE };

        if (Jim_GetEnum(interp, argv[2], options, &option, NULL, JIM_ERRMSG) != JIM_OK) {
            return JIM_ERR;
        }
#endif
        switch (option) {
#if defined(HAVE_SHUTDOWN)
            case OPT_R:
            case OPT_W:
                if (shutdown(af->fd, option == OPT_R ? SHUT_RD : SHUT_WR) == 0) {
                    return JIM_OK;
                }
                JimAioSetError(interp, NULL);
                return JIM_ERR;
#endif
#if UNIX_SOCKETS
            case OPT_NODELETE:
                if (af->addr_family == PF_UNIX) {
                    af->flags |= AIO_NODELETE;
                    break;
                }

#endif
            default:
                Jim_SetResultString(interp, "not supported", -1);
                return JIM_ERR;
        }
    }


    af->flags &= ~AIO_KEEPOPEN;

    return Jim_DeleteCommand(interp, argv[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x1b8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x3, -0x14(%rbp)
jne 0x17e00
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
jmp 0x17da1
movq -0x10(%rbp), %rdi
leaq 0x25951(%rip), %rsi     # 0x3d6fd
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7990
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl 0x10(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rcx)
cmpl $0x0, %eax
jg 0x17dec
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x7a10
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x17e20
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0xd740
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_seek
static int aio_cmd_seek(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);
    int orig = SEEK_SET;
    jim_wide offset;

    if (argc == 2) {
        if (Jim_CompareStringImmediate(interp, argv[1], "start"))
            orig = SEEK_SET;
        else if (Jim_CompareStringImmediate(interp, argv[1], "current"))
            orig = SEEK_CUR;
        else if (Jim_CompareStringImmediate(interp, argv[1], "end"))
            orig = SEEK_END;
        else {
            return -1;
        }
    }
    if (Jim_GetWide(interp, argv[0], &offset) != JIM_OK) {
        return JIM_ERR;
    }
    if (orig != SEEK_CUR || offset != 0) {

        aio_flush(interp, af);
    }
    if (Jim_Lseek(af->fd, offset, orig) == -1) {
        JimAioSetError(interp, af->filename);
        return JIM_ERR;
    }
    if (af->readbuf) {
        Jim_FreeNewObj(interp, af->readbuf);
        af->readbuf = NULL;
    }
    af->flags &= ~AIO_EOF;
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x1b8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x17ee7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x22d1d(%rip), %rdx     # 0x3ab93
callq 0x77a0
cmpl $0x0, %eax
je 0x17e89
movl $0x0, -0x2c(%rbp)
jmp 0x17ee5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x239d7(%rip), %rdx     # 0x3b873
callq 0x77a0
cmpl $0x0, %eax
je 0x17eaf
movl $0x1, -0x2c(%rbp)
jmp 0x17ee3
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x247eb(%rip), %rdx     # 0x3c6ad
callq 0x77a0
cmpl $0x0, %eax
je 0x17ed5
movl $0x2, -0x2c(%rbp)
jmp 0x17ee1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x17f94
jmp 0x17ee3
jmp 0x17ee5
jmp 0x17ee7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x38(%rbp), %rdx
callq 0xf640
cmpl $0x0, %eax
je 0x17f0c
movl $0x1, -0x4(%rbp)
jmp 0x17f94
cmpl $0x1, -0x2c(%rbp)
jne 0x17f19
cmpq $0x0, -0x38(%rbp)
je 0x17f26
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x18a70
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x64b0
cmpq $-0x1, %rax
jne 0x17f58
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x188a0
movl $0x1, -0x4(%rbp)
jmp 0x17f94
movq -0x28(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x17f80
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x7a10
movq -0x28(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x28(%rbp), %rax
movl 0xc(%rax), %ecx
andl $-0x5, %ecx
movl %ecx, 0xc(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_ndelay
static int aio_cmd_ndelay(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);

    if (argc) {
        long nb;

        if (Jim_GetLong(interp, argv[0], &nb) != JIM_OK) {
            return JIM_ERR;
        }
        aio_set_nonblocking(af, nb);
    }
    Jim_SetResultInt(interp, (af->flags & AIO_NONBLOCK) ? 1 : 0);
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x1b8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x18119
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x30(%rbp), %rdx
callq 0xf4d0
cmpl $0x0, %eax
je 0x1810a
movl $0x1, -0x4(%rbp)
jmp 0x18186
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %esi
callq 0x186d0
jmp 0x1811b
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0xc(%rax), %edx
andl $0x10, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movslq %eax, %rsi
callq 0x8d60
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl 0x10(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rcx)
cmpl $0x0, %eax
jg 0x18174
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x7a10
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: aio_cmd_readsize
static int aio_cmd_readsize(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
    AioFile *af = Jim_CmdPrivData(interp);

    if (argc) {
        long l;
        if (Jim_GetLong(interp, argv[0], &l) != JIM_OK || l <= 0) {
            return JIM_ERR;
        }
        af->rbuf_len = l;
        if (af->rbuf) {
            af->rbuf = Jim_Realloc(af->rbuf, af->rbuf_len);
        }
    }
    Jim_SetResultInt(interp, af->rbuf_len);

    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x1b8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x18451
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x30(%rbp), %rdx
callq 0xf4d0
cmpl $0x0, %eax
jne 0x18408
cmpq $0x0, -0x30(%rbp)
jg 0x18414
movl $0x1, -0x4(%rbp)
jmp 0x184ac
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x1844f
movq 0x2fe5e(%rip), %rax     # 0x48290
movq -0x28(%rbp), %rcx
movq 0x40(%rcx), %rdi
movq -0x28(%rbp), %rcx
movq 0x48(%rcx), %rsi
callq *%rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0x18451
jmp 0x18453
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rsi
callq 0x8d60
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl 0x10(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rcx)
cmpl $0x0, %eax
jg 0x1849a
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x7a10
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: aio_start_nonblocking
static int aio_start_nonblocking(AioFile *af)
{
    int old = !!(af->flags & AIO_NONBLOCK);
    if (af->timeout) {
        aio_set_nonblocking(af, 1);
    }
    return old;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x18501
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x186d0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: aio_set_nonblocking
static void aio_set_nonblocking(AioFile *af, int nb)
{
#ifdef O_NDELAY
    int old = !!(af->flags & AIO_NONBLOCK);
    if (old != nb) {
        int fmode = fcntl(af->fd, F_GETFL);
        if (nb) {
            fmode |= O_NDELAY;
            af->flags |= AIO_NONBLOCK;
        }
        else {
            fmode &= ~O_NDELAY;
            af->flags &= ~AIO_NONBLOCK;
        }
        (void)fcntl(af->fd, F_SETFL, fmode);
    }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x18767
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x6400
movl %eax, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x18739
movl -0x14(%rbp), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0xc(%rax)
jmp 0x18751
movl -0x14(%rbp), %eax
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
andl $-0x11, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
movl -0x14(%rbp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x6400
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: aio_read_consume
static Jim_Obj *aio_read_consume(Jim_Interp *interp, AioFile *af, int neededLen)
{
    Jim_Obj *objPtr = NULL;

    if (neededLen < 0 || af->readbuf == NULL || Jim_Length(af->readbuf) <= neededLen) {
        objPtr = af->readbuf;
        af->readbuf = NULL;
    }
    else if (af->readbuf) {

        int len;
        const char *pt = Jim_GetString(af->readbuf, &len);

        objPtr  = Jim_NewStringObj(interp, pt, neededLen);
        aio_consume(af->readbuf, neededLen);
    }

    return objPtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x187ae
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x187ae
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xc700
cmpl -0x14(%rbp), %eax
jg 0x187c8
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
jmp 0x1880e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1880c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
leaq -0x24(%rbp), %rsi
callq 0x89b0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x7990
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x189c0
jmp 0x1880e
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimCheckStreamError
static int JimCheckStreamError(Jim_Interp *interp, AioFile *af)
{
    int ret = 0;
    if (!aio_eof(af)) {
        ret = af->fops->error(af);
        if (ret) {
            JimAioSetError(interp, af->filename);
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18820
cmpl $0x0, %eax
jne 0x18892
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x18890
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x188a0
jmp 0x18892
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimAioSetError
static void JimAioSetError(Jim_Interp *interp, Jim_Obj *name)
{
    AioFile *af = Jim_CmdPrivData(interp);

    if (name) {
        Jim_SetResultFormatted(interp, "%#s: %s", name, JimAioErrorString(af));
    }
    else {
        Jim_SetResultString(interp, JimAioErrorString(af), -1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x1b8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x188fa
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x18970
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x22f23(%rip), %rsi     # 0x3b814
movb $0x0, %al
callq 0x6b40
jmp 0x18961
jmp 0x188fc
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x18970
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7990
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movl 0x10(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rcx)
cmpl $0x0, %eax
jg 0x18954
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x7a10
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x18961
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: aio_consume
static void aio_consume(Jim_Obj *objPtr, int n)
{
    assert(objPtr->bytes);
    assert(n <= objPtr->length);


    memmove(objPtr->bytes, objPtr->bytes + n, objPtr->length - n + 1);
    objPtr->length -= n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x189db
jmp 0x189fa
leaq 0x22e3a(%rip), %rdi     # 0x3b81c
leaq 0x2232d(%rip), %rsi     # 0x3ad16
movl $0x8f2, %edx            # imm = 0x8F2
leaq 0x22e35(%rip), %rcx     # 0x3b82a
callq 0x6230
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jg 0x18a08
jmp 0x18a27
leaq 0x22e3c(%rip), %rdi     # 0x3b84b
leaq 0x22300(%rip), %rsi     # 0x3ad16
movl $0x8f3, %edx            # imm = 0x8F3
leaq 0x22e08(%rip), %rcx     # 0x3b82a
callq 0x6230
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
subl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x6410
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: aio_flush
static int aio_flush(Jim_Interp *interp, AioFile *af)
{
    int len;
    const char *pt = Jim_GetString(af->writebuf, &len);
    if (len) {
        int ret = af->fops->writer(af, pt, len);
        if (ret > 0) {

            aio_consume(af->writebuf, ret);
        }
        if (ret < 0) {
            return JimCheckStreamError(interp, af);
        }
        if (Jim_Length(af->writebuf)) {
#ifdef jim_ext_eventloop
            void *handler = Jim_FindFileHandler(interp, af->fd, JIM_EVENT_WRITABLE);
            if (handler == NULL) {
                Jim_CreateFileHandler(interp, af->fd, JIM_EVENT_WRITABLE, aio_autoflush, af, NULL);
                return JIM_OK;
            }
            else if (handler == af) {

                return JIM_OK;
            }
#endif

            Jim_SetResultString(interp, "send buffer is full", -1);
            return JIM_ERR;
        }
    }
    return JIM_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x89b0
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x18b5d
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x18ad0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0x189c0
cmpl $0x0, -0x2c(%rbp)
jge 0x18ae8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x18840
movl %eax, -0x4(%rbp)
jmp 0x18b64
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0xc700
cmpl $0x0, %eax
je 0x18b5b
jmp 0x18afc
movq -0x10(%rbp), %rdi
leaq 0x22d58(%rip), %rsi     # 0x3b85f
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x7990
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl 0x10(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rcx)
cmpl $0x0, %eax
jg 0x18b47
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x7a10
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x18b64
jmp 0x18b5d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: parse_posix_open_mode
static int parse_posix_open_mode(Jim_Interp *interp, Jim_Obj *modeObj)
{
    int i;
    int flags = 0;
    #ifndef O_NOCTTY

        #define O_NOCTTY 0
    #endif
    static const char * const modetypes[] = {
        "RDONLY", "WRONLY", "RDWR", "APPEND", "BINARY", "CREAT", "EXCL", "NOCTTY", "TRUNC", NULL
    };
    static const int modeflags[] = {
        O_RDONLY, O_WRONLY, O_RDWR, O_APPEND, 0, O_CREAT, O_EXCL, O_NOCTTY, O_TRUNC,
    };

    for (i = 0; i < Jim_ListLength(interp, modeObj); i++) {
        int opt;
        Jim_Obj *objPtr = Jim_ListGetIndex(interp, modeObj, i);
        if (Jim_GetEnum(interp, objPtr, modetypes, &opt, "access mode", JIM_ERRMSG) != JIM_OK) {
            return -1;
        }
        flags |= modeflags[opt];
    }
    return flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9b50
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x18dc3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x101d0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0x2df43(%rip), %rdx     # 0x46cc0
leaq -0x24(%rbp), %rcx
leaq 0x22b8d(%rip), %r8      # 0x3b915
movl $0x1, %r9d
callq 0x8590
cmpl $0x0, %eax
je 0x18da1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x18dc9
movslq -0x24(%rbp), %rcx
leaq 0x1ea84(%rip), %rax     # 0x37830
movl (%rax,%rcx,4), %eax
orl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18d3e
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/msteveb[P]autosetup/./jimsh0.c
// Function: JimCreatePipe
static int JimCreatePipe(Jim_Interp *interp, Jim_Obj *filenameObj, int flags)
{
    int p[2];

    if (pipe(p) != 0) {
        JimAioSetError(interp, NULL);
        return JIM_ERR;
    }

    return JimMakeChannelPair(interp, p, filenameObj, "aio.pipe%ld", 0, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x6280
cmpl $0x0, %eax
je 0x18e17
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x188a0
movl $0x1, -0x4(%rbp)
jmp 0x18e39
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %r9d
leaq 0x22af3(%rip), %rcx     # 0x3b921
xorl %r8d, %r8d
callq 0x18e50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)