LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/lzuncompress.c
// Function: ficlLzDecodeHeaderField
int ficlLzDecodeHeaderField(const unsigned char *data, int *byteOffset)
	{
	unsigned char id;
	int networkOrder;
	int length;

	id = data[(*byteOffset)++];
	if (id < 252)
		return id;

	networkOrder = 0;
	length = (id == 253) ? 2: 4;

	ficlBitGetString(((unsigned char *)&networkOrder), data,
		(*byteOffset) * 8,
		length * 8, sizeof(networkOrder) * 8);
	(*byteOffset) += length;

	return ficlNetworkUnsigned32(networkOrder);
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edx
movl %edx, (%rsi)
movzbl (%rdi,%rax), %eax
cmpl $0xfb, %eax
jbe 0xb23a
movq %rdi, %rsi
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
xorl %ecx, %ecx
cmpl $0xfd, %eax
setne %cl
leal 0x2(,%rcx,2), %ebp
addl %ecx, %ecx
shll $0x3, %edx
leal 0x10(,%rcx,8), %ecx
movq %r14, %rdi
movl $0x20, %r8d
callq 0xdf40
addl %ebp, (%rbx)
movl (%r14), %edi
callq 0xdfa1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/utility.c
// Function: ficlStringReverse
char *ficlStringReverse( char *string )    
{                               /* reverse a string in-place */
    int i = strlen(string);
    char *p1 = string;          /* first char of string */
    char *p2 = string + i - 1;  /* last non-NULL char of string */
    char c;

    if (i > 1)
    {
        while (p1 < p2)
        {
            c = *p2;
            *p2 = *p1;
            *p1 = c;
            p1++; p2--;
        }
    }
        
    return string;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x30e0
cltq
cmpl $0x2, %eax
setge %cl
addq %rbx, %rax
decq %rax
cmpq %rbx, %rax
seta %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xb517
leaq 0x1(%rbx), %rcx
movb (%rax), %dl
movb -0x1(%rcx), %sil
movb %sil, (%rax)
movb %dl, -0x1(%rcx)
decq %rax
leaq 0x1(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jb 0xb4fc
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/utility.c
// Function: ficlLtoa
char *ficlLtoa( ficlInteger value, char *string, int radix )
{                               /* convert long to string, any base */
    char *cp = string;
    int sign = ((radix == 10) && (value < 0));
    int pwr;

    FICL_ASSERT(NULL, radix > 1);
    FICL_ASSERT(NULL, radix < 37);
    FICL_ASSERT(NULL, string);

    pwr = ficlIsPowerOfTwo((ficlUnsigned)radix);

    if (sign)
        value = -value;

    if (value == 0)
        *cp++ = '0';
    else if (pwr != 0)
    {
        ficlUnsigned v = (ficlUnsigned) value;
        ficlUnsigned mask = (ficlUnsigned) ~(-1 << pwr);
        while (v)
        {
            *cp++ = digits[v & mask];
            v >>= pwr;
        }
    }
    else
    {
        ficl2UnsignedQR result;
        ficl2Unsigned v;
		FICL_UNSIGNED_TO_2UNSIGNED((ficlUnsigned)value, v);
        while (FICL_2UNSIGNED_NOT_ZERO(v))
        {
            result = ficl2UnsignedDivide(v, (ficlUnsigned)radix);
            *cp++ = digits[result.remainder];
			v = result.quotient;
        }
    }

    if (sign)
        *cp++ = '-';

    *cp++ = '\0';

    return ficlStringReverse(string);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
cmpl $0xa, %edx
sete %al
testq %rdi, %rdi
sets %bpl
andb %al, %bpl
movslq %edx, %r14
xorl %ecx, %ecx
cmpl $0x2, %r14d
jb 0xb5a8
movl $0x1, %eax
movl $0x2, %edx
cmpq %r14, %rdx
je 0xb5a6
incl %eax
leaq -0x1(,%rdx,2), %rsi
addq %rdx, %rdx
cmpq %r14, %rsi
jb 0xb58d
jmp 0xb5a8
movl %eax, %ecx
movq %rdi, %rdx
negq %rdx
testb %bpl, %bpl
cmoveq %rdi, %rdx
testq %rdx, %rdx
je 0xb5ec
testl %ecx, %ecx
je 0xb5f5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
movl %ecx, %ecx
leaq 0x3e00(%rip), %rsi      # 0xf3d0
movq %rbx, %r12
movl %edx, %edi
andl %eax, %edi
movb (%rdi,%rsi), %dil
movb %dil, (%r12)
incq %r12
shrq %cl, %rdx
testq %rdx, %rdx
jne 0xb5d3
jmp 0xb630
leaq 0x1(%rbx), %r12
movb $0x30, (%rbx)
jmp 0xb630
xorl %esi, %esi
movq %rsp, %r15
leaq 0x3dcf(%rip), %r13      # 0xf3d0
movq %rbx, %r12
movq %r15, %rdi
movq %r14, %rcx
callq 0xd7ee
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movb (%rax,%r13), %al
movb %al, (%r12)
incq %r12
movq %rdx, %rax
orq %rsi, %rax
jne 0xb604
testb %bpl, %bpl
je 0xb63d
movb $0x2d, (%r12)
incq %r12
movb $0x0, (%r12)
movq %rbx, %rdi
callq 0xb4d4
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/utility.c
// Function: ficlUltoa
char *ficlUltoa(ficlUnsigned value, char *string, int radix )
{                               /* convert long to string, any base */
    char *cp = string;
    ficl2Unsigned ud;
    ficl2UnsignedQR result;

    FICL_ASSERT(NULL, radix > 1);
    FICL_ASSERT(NULL, radix < 37);
    FICL_ASSERT(NULL, string);

    if (value == 0)
        *cp++ = '0';
    else
    {
		FICL_UNSIGNED_TO_2UNSIGNED(value, ud);
        while (FICL_2UNSIGNED_NOT_ZERO(ud))
        {
            result = ficl2UnsignedDivide(ud, (ficlUnsigned)radix);
			ud = result.quotient;
            *cp++ = digits[result.remainder];
        }
    }

    *cp++ = '\0';

    return ficlStringReverse(string);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0xb6b9
movl %edx, %eax
movq %rdi, %rdx
movslq %eax, %r14
xorl %esi, %esi
leaq 0x8(%rsp), %r15
leaq 0x3d49(%rip), %r13      # 0xf3d0
movq %rbx, %r12
movq %r15, %rdi
movq %r14, %rcx
callq 0xd7ee
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
movb (%rax,%r13), %al
movb %al, (%r12)
incq %r12
movq %rdx, %rax
orq %rsi, %rax
jne 0xb68a
jmp 0xb6c0
leaq 0x1(%rbx), %r12
movb $0x30, (%rbx)
movb $0x0, (%r12)
movq %rbx, %rdi
callq 0xb4d4
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/utility.c
// Function: ficlStringCaseFold
char *ficlStringCaseFold(char *cp)
{
    char *oldCp = cp;

    while (*cp)
    {
        if (isupper((unsigned char)*cp))
            *cp = (char)tolower((unsigned char)*cp);
        cp++;
    }

    return oldCp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0xb727
callq 0x3340
movq %rax, %r14
leaq 0x1(%rbx), %r15
movq (%r14), %rax
movzbl %bpl, %r12d
testb $0x1, 0x1(%rax,%r12,2)
je 0xb71c
callq 0x3330
movq (%rax), %rax
movb (%rax,%r12,4), %al
movb %al, -0x1(%r15)
movb (%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0xb6fd
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/utility.c
// Function: ficlStrincmp
int ficlStrincmp(char *cp1, char *cp2, ficlUnsigned count)
{
    int i = 0;

    for (; 0 < count; ++cp1, ++cp2, --count)
    {
        i = tolower((unsigned char)*cp1) - tolower((unsigned char)*cp2);
        if (i != 0)
            return i;
        else if (*cp1 == '\0')
            return 0;
    }
    return 0;
}

// Assembly:
testq %rdx, %rdx
je 0xb77e
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x3330
movq (%rax), %rcx
decq %rbx
xorl %edx, %edx
movzbl (%r15,%rdx), %esi
movl (%rcx,%rsi,4), %eax
movzbl (%r14,%rdx), %edi
subl (%rcx,%rdi,4), %eax
jne 0xb778
xorl %eax, %eax
testb %sil, %sil
je 0xb778
leaq 0x1(%rdx), %rsi
cmpq %rdx, %rbx
movq %rsi, %rdx
jne 0xb753
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/utility.c
// Function: ficlStringSkipSpace
char *ficlStringSkipSpace(char *cp, char *end)
{
    FICL_ASSERT(NULL, cp);

    while ((cp != end) && isspace((unsigned char)*cp))
        cp++;

    return cp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xb7ad
movq %rsi, %r14
callq 0x3340
movq (%rax), %rax
movzbl (%rbx), %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0xb7ad
incq %rbx
cmpq %r14, %rbx
jne 0xb798
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/utility.c
// Function: ficlCompatibilityTextOutCallback
void ficlCompatibilityTextOutCallback(ficlCallback *callback, char *text, ficlCompatibilityOutputFunction outputFunction)
{
	char buffer[256];
	char *bufferStop = buffer + sizeof(buffer) - 1;

	if (text == NULL)
	{
		outputFunction(callback->vm, NULL, 0 /* false */);
		return;
	}

	while (*text)
	{
		int newline = 0 /* false */;
		char *trace = buffer;
		while ((*text) && (trace < bufferStop))
		{
			switch (*text)
			{
				/* throw away \r */
				case '\r':
					text++;
					continue;
				case '\n':
					text++;
					newline = !0 /* true */;
					break;
				default:
					*trace++ = *text++;
					break;
			}
		}
		
		*trace = 0;
		(outputFunction)(callback->vm, buffer, newline);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xb866
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0xb857
movq %rax, %r12
movq %rsp, %r15
movb (%r14), %cl
xorl %eax, %eax
testb %cl, %cl
je 0xb841
movb $0x1, %sil
xorl %edx, %edx
incq %r14
cmpb $0xd, %cl
jne 0xb80c
movb (%r14), %cl
testb %cl, %cl
setne %dil
incq %r14
testb %sil, %dil
jne 0xb7f4
jmp 0xb83c
movzbl %cl, %esi
cmpl $0xa, %esi
jne 0xb81b
movl $0x1, %edx
jmp 0xb821
movb %cl, (%rsp,%rax)
incq %rax
cmpq $0xff, %rax
setl %sil
movb (%r14), %cl
testb %cl, %cl
je 0xb843
cmpq $0xff, %rax
jl 0xb7f1
jmp 0xb843
decq %r14
jmp 0xb843
xorl %edx, %edx
movb $0x0, (%rsp,%rax)
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq *%r12
cmpb $0x0, (%r14)
jne 0xb7e3
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x20(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
nop
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/hash.c
// Function: ficlHashCode
ficlUnsigned16 ficlHashCode(ficlString s)
{   
    /* hashPJW */
    ficlUnsigned8 *trace;
    ficlUnsigned16 code = (ficlUnsigned16)s.length;
    ficlUnsigned16 shift = 0;

    if (s.length == 0)
        return 0;

    /* changed to run without errors under Purify -- lch */
    for (trace = (ficlUnsigned8 *)s.text; s.length && *trace; trace++, s.length--)
    {
        code = (ficlUnsigned16)((code << 4) + tolower(*trace));
        shift = (ficlUnsigned16)(code & 0xf000);
        if (shift)
        {
            code ^= (ficlUnsigned16)(shift >> 8);
            code ^= (ficlUnsigned16)shift;
        }
    }

    return (ficlUnsigned16)code;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xb8fa
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movl %r14d, %ebp
movzbl (%rbx,%r15), %r12d
testq %r12, %r12
je 0xb8fc
movzwl %bp, %ebp
shll $0x4, %ebp
callq 0x3330
movq (%rax), %rax
addl (%rax,%r12,4), %ebp
movl %ebp, %eax
shrl $0x8, %eax
andl $0xf0, %eax
andl $0xfff, %ebp            # imm = 0xFFF
xorl %eax, %ebp
incq %r15
cmpq %r15, %r14
jne 0xb8c2
jmp 0xb8fc
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/hash.c
// Function: ficlHashLookup
ficlWord *ficlHashLookup(ficlHash *hash, ficlString name, ficlUnsigned16 hashCode)
{
    ficlUnsigned nCmp = name.length;
    ficlWord *word;
    ficlUnsigned16 hashIdx;

    if (nCmp > FICL_NAME_LENGTH)
        nCmp = FICL_NAME_LENGTH;

    for (; hash != NULL; hash = hash->link)
    {
        if (hash->size > 1)
            hashIdx = (ficlUnsigned16)(hashCode % hash->size);
        else            /* avoid the modulo op for single threaded lists */
            hashIdx = 0;

        for (word = hash->table[hashIdx]; word; word = word->link)
        {
            if ( (word->length == name.length) 
                && (!ficlStrincmp(name.text, word->name, nCmp)) )
                return word;
#if FICL_ROBUST
            FICL_ASSERT_PHASH(hash, word != word->link);
#endif
        }
    }

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x1f, %rsi
movl $0x1f, %r12d
cmovbq %rsi, %r12
testq %rdi, %rdi
je 0xb99b
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzwl %cx, %ebp
movl 0x10(%r15), %ecx
cmpl $0x2, %ecx
jb 0xb964
movl %ebp, %eax
xorl %edx, %edx
divl %ecx
jmp 0xb966
xorl %edx, %edx
movq 0x18(%r15,%rdx,8), %r13
testq %r13, %r13
je 0xb993
movzbl 0xb(%r13), %eax
cmpq %r14, %rax
jne 0xb98d
movq 0x10(%r13), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xb733
testl %eax, %eax
je 0xb99e
movq (%r13), %r13
jmp 0xb96b
movq (%r15), %r15
testq %r15, %r15
jne 0xb953
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/hash.c
// Function: ficlHashReset
void ficlHashReset(ficlHash *hash)
{
    unsigned i;

    FICL_ASSERT_PHASH(hash, hash);

    for (i = 0; i < hash->size; i++)
    {
        hash->table[i] = NULL;
    }

    hash->link = NULL;
    hash->name = NULL;
    return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %edx
testq %rdx, %rdx
je 0xb9cb
leaq 0x18(%rbx), %rdi
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x3130
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/callback.c
// Function: ficlCallbackTextOut
void ficlCallbackTextOut(ficlCallback *callback, char *text)
{
	ficlOutputFunction textOut = NULL;

	if (callback != NULL)
	{
		if (callback->textOut != NULL)
			textOut = callback->textOut;
		else if ((callback->system != NULL) && (callback != &(callback->system->callback)))
		{
			ficlCallbackTextOut(&(callback->system->callback), text);
			return;
		}
	}

	if ((textOut == NULL) && (ficlSystemGlobal != NULL))
	{
		callback = &(ficlSystemGlobal->callback);
		textOut = callback->textOut;
	}
	
	if (textOut == NULL)
		textOut = ficlCallbackDefaultTextOut;

    (textOut)(callback, text);

    return;
}

// Assembly:
movq %rdi, %rax
movq %rax, %rdi
testq %rax, %rax
je 0xb9fd
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
jne 0xb9ff
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xb9fd
movl $0x0, %ecx
cmpq %rdi, %rax
jne 0xb9d7
jmp 0xb9ff
xorl %ecx, %ecx
testq %rcx, %rcx
sete %dl
leaq 0xca8c(%rip), %rax      # 0x18498
movq (%rax), %rax
testq %rax, %rax
setne %r8b
andb %dl, %r8b
cmpb $0x1, %r8b
jne 0xba26
movq 0x8(%rax), %rcx
movq %rax, %rdi
testq %rcx, %rcx
jne 0xba32
leaq -0x614(%rip), %rcx      # 0xb41e
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/callback.c
// Function: ficlCallbackErrorOut
void ficlCallbackErrorOut(ficlCallback *callback, char *text)
{
	ficlOutputFunction errorOut = NULL;

	if (callback != NULL)
	{
		if (callback->errorOut != NULL)
			errorOut = callback->errorOut;
		else if ((callback->system != NULL) && (callback != &(callback->system->callback)))
		{
			ficlCallbackErrorOut(&(callback->system->callback), text);
			return;
		}
	}

	if ((errorOut == NULL) && (ficlSystemGlobal != NULL))
	{
		callback = &(ficlSystemGlobal->callback);
		errorOut = callback->errorOut;
	}

	if (errorOut == NULL)
	{
		ficlCallbackTextOut(callback, text);
		return;
	}

    (errorOut)(callback, text);

    return;
}

// Assembly:
movq %rdi, %rax
movq %rax, %rdi
testq %rax, %rax
je 0xba5d
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
jne 0xba5f
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xba5d
movl $0x0, %ecx
cmpq %rdi, %rax
jne 0xba37
jmp 0xba5f
xorl %ecx, %ecx
testq %rcx, %rcx
sete %dl
leaq 0xca2c(%rip), %rax      # 0x18498
movq (%rax), %rax
testq %rax, %rax
setne %r8b
andb %dl, %r8b
cmpb $0x1, %r8b
jne 0xba86
movq 0x10(%rax), %rcx
movq %rax, %rdi
testq %rcx, %rcx
je 0xba8d
jmpq *%rcx
jmp 0xb9d4
nop
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/extras.c
// Function: ficlSystemCompileExtras
void ficlSystemCompileExtras(ficlSystem *system)
{
    ficlDictionary *dictionary = ficlSystemGetDictionary(system);

    ficlDictionarySetPrimitive(dictionary, "break",    ficlPrimitiveBreak,    FICL_WORD_DEFAULT);
    ficlDictionarySetPrimitive(dictionary, "load",     ficlPrimitiveLoad,     FICL_WORD_DEFAULT);
    ficlDictionarySetPrimitive(dictionary, "spewhash", ficlPrimitiveSpewHash, FICL_WORD_DEFAULT);
    ficlDictionarySetPrimitive(dictionary, "system",   ficlPrimitiveSystem,   FICL_WORD_DEFAULT);

#ifndef FICL_ANSI
    ficlDictionarySetPrimitive(dictionary, "clock",    ficlPrimitiveClock,    FICL_WORD_DEFAULT);
    ficlDictionarySetConstant(dictionary, "clocks/sec", CLOCKS_PER_SEC);
    ficlDictionarySetPrimitive(dictionary, "pwd",      ficlPrimitiveGetCwd,   FICL_WORD_DEFAULT);
    ficlDictionarySetPrimitive(dictionary, "cd",       ficlPrimitiveChDir,    FICL_WORD_DEFAULT);
#endif /* FICL_ANSI */

    return;
}

// Assembly:
pushq %rbx
callq 0x3a37
movq %rax, %rbx
leaq 0x2899(%rip), %rsi      # 0xe439
leaq 0xaf(%rip), %rdx        # 0xbc56
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xc509
leaq 0x38d8(%rip), %rsi      # 0xf490
leaq 0x98(%rip), %rdx        # 0xbc57
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xc509
leaq 0x38c5(%rip), %rsi      # 0xf495
leaq 0x23a(%rip), %rdx       # 0xbe11
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xc509
leaq 0x38b6(%rip), %rsi      # 0xf49e
leaq 0x31c(%rip), %rdx       # 0xbf0b
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xc509
leaq 0x38a5(%rip), %rsi      # 0xf4a5
leaq 0x388(%rip), %rdx       # 0xbf8f
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xc509
leaq 0x3893(%rip), %rsi      # 0xf4ab
movl $0xf4240, %edx          # imm = 0xF4240
movq %rbx, %rdi
callq 0xc36c
leaq 0x388a(%rip), %rsi      # 0xf4b6
leaq 0x372(%rip), %rdx       # 0xbfa5
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xc509
leaq 0x3876(%rip), %rsi      # 0xf4ba
leaq 0x399(%rip), %rdx       # 0xbfe4
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
jmp 0xc509
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/extras.c
// Function: ficlPrimitiveSpewHash
static void ficlPrimitiveSpewHash(ficlVm *vm)
{
    ficlHash *hash = ficlVmGetDictionary(vm)->forthWordlist;
    ficlWord *word;
    FILE *f;
    unsigned i;
    unsigned hashSize = hash->size;

    if (!ficlVmGetWordToPad(vm))
        ficlVmThrow(vm, FICL_VM_STATUS_OUT_OF_TEXT);

    f = fopen(vm->pad, "w");
    if (!f)
    {
        ficlVmTextOut(vm, "unable to open file\n");
        return;
    }

    for (i = 0; i < hashSize; i++)
    {
        int n = 0;

        word = hash->table[i];
        while (word)
        {
            n++;
            word = word->link;
        }

        fprintf(f, "%d\t%d", i, n);

        word = hash->table[i];
        while (word)
        {
            fprintf(f, "\t%s", word->name);
            word = word->link;
        }

        fprintf(f, "\n");
    }

    fclose(f);
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x699a
movq 0x18(%rax), %r13
movl 0x10(%r13), %ebp
movq %r14, %rdi
callq 0x6b66
testl %eax, %eax
jne 0xbe45
movq %r14, %rdi
movl $0xfffffeff, %esi       # imm = 0xFFFFFEFF
callq 0x6869
leaq 0x118(%r14), %rdi
leaq 0x3b02(%rip), %rsi      # 0xf955
callq 0x32b0
testq %rax, %rax
je 0xbeee
movq %rax, %rbx
testq %rbp, %rbp
je 0xbed8
addq $0x18, %r13
leaq 0x36bb(%rip), %r15      # 0xf52f
xorl %r12d, %r12d
leaq (,%r12,8), %r14
addq %r13, %r14
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %r14, %rax
movq (%rax), %rax
incl %ecx
testq %rax, %rax
jne 0xbe8a
movq %rbx, %rdi
leaq 0x368b(%rip), %rsi      # 0xf529
movl %r12d, %edx
xorl %eax, %eax
callq 0x31b0
movq (%r14), %r14
testq %r14, %r14
je 0xbec3
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x31b0
jmp 0xbea8
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3150
incq %r12
cmpq %rbp, %r12
jne 0xbe77
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30c0
leaq 0x361f(%rip), %rsi      # 0xf514
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6c86
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/extras.c
// Function: ficlPrimitiveSystem
static void ficlPrimitiveSystem(ficlVm *vm)
{
    ficlCountedString *counted = (ficlCountedString *)vm->pad;

    ficlVmGetString(vm, counted, '\n');
    if (FICL_COUNTED_STRING_GET_LENGTH(*counted) > 0)
    {
        int returnValue = system(FICL_COUNTED_STRING_GET_POINTER(*counted));
        if (returnValue)
        {
            sprintf(vm->pad, "System call returned %d\n", returnValue);
            ficlVmTextOut(vm, vm->pad);
            ficlVmThrow(vm, FICL_VM_STATUS_QUIT);
        }
    }
    else
    {
        ficlVmTextOut(vm, "Warning (system): nothing happened\n");
    }
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x118(%rdi), %r14
movq %r14, %rsi
movl $0xa, %edx
callq 0x69a3
cmpb $0x0, 0x118(%rbx)
je 0xbf71
leaq 0x119(%rbx), %rdi
callq 0x3100
testl %eax, %eax
je 0xbf87
leaq 0x35ed(%rip), %rsi      # 0xf533
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x32f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6c86
movq %rbx, %rdi
movl $0xffffffc8, %esi       # imm = 0xFFFFFFC8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6869
leaq 0x35d4(%rip), %rsi      # 0xf54c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c86
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/extras.c
// Function: ficlPrimitiveGetCwd
static void ficlPrimitiveGetCwd(ficlVm *vm)
{
    char *directory;

    directory = getcwd(NULL, 80);
    ficlVmTextOut(vm, directory);
    ficlVmTextOut(vm, "\n");
    free(directory);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x50, %esi
xorl %edi, %edi
callq 0x3140
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6c86
leaq 0x239c(%rip), %rsi      # 0xe369
movq %rbx, %rdi
callq 0x6c86
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/extras.c
// Function: ficlPrimitiveChDir
static void ficlPrimitiveChDir(ficlVm *vm)
{
    ficlCountedString *counted = (ficlCountedString *)vm->pad;
    ficlVmGetString(vm, counted, '\n');
    if (counted->length > 0)
    {
       int err = chdir(counted->text);
       if (err)
        {
            ficlVmTextOut(vm, "Error: path not found\n");
            ficlVmThrow(vm, FICL_VM_STATUS_QUIT);
        }
    }
    else
    {
        ficlVmTextOut(vm, "Warning (chdir): nothing happened\n");
    }
    return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x118(%rdi), %rsi
movl $0xa, %edx
callq 0x69a3
cmpb $0x0, 0x118(%rbx)
je 0xc02f
leaq 0x119(%rbx), %rdi
callq 0x30f0
testl %eax, %eax
je 0xc03f
leaq 0x3557(%rip), %rsi      # 0xf570
movq %rbx, %rdi
callq 0x6c86
movq %rbx, %rdi
movl $0xffffffc8, %esi       # imm = 0xFFFFFFC8
popq %rbx
jmp 0x6869
leaq 0x3551(%rip), %rsi      # 0xf587
movq %rbx, %rdi
popq %rbx
jmp 0x6c86
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppendData
void *ficlDictionaryAppendData(ficlDictionary *dictionary, void *data, ficlInteger length)
{
    char *here    = (char *)dictionary->here;
    char *oldHere = here;
	char *from    = (char *)data;
 
    if (length == 0)
    {
        ficlDictionaryAlign(dictionary);
        return (char *)dictionary->here;
    }

    while (length)
    {
        *here++ = *from++;
		length--;
    }

    *here++ = '\0';

    dictionary->here = FICL_POINTER_TO_CELL(here);
    ficlDictionaryAlign(dictionary);
    return oldHere;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %rdx, %rdx
je 0xc0d7
xorl %eax, %eax
movb (%rsi,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq %rax, %rdx
jne 0xc0b3
leaq (%r14,%rax), %rdi
incq %rdi
movb $0x0, -0x1(%rdi)
movq %rdi, (%rbx)
callq 0xb4c0
jmp 0xc0e2
movq %r14, %rdi
callq 0xb4c0
movq %rax, %r14
movq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppendConstantInstruction
ficlWord *ficlDictionaryAppendConstantInstruction(ficlDictionary *dictionary, ficlString name, ficlInstruction instruction, ficlInteger value)
{
	ficlWord *word = ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)instruction, FICL_WORD_DEFAULT);
	if (word != NULL)
		ficlDictionaryAppendUnsigned(dictionary, value);
	return word;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdi, %r14
xorl %r8d, %r8d
callq 0xc134
testq %rax, %rax
je 0xc12c
movq (%r14), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%r14)
movq %rbx, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppendWord
ficlWord *ficlDictionaryAppendWord(ficlDictionary *dictionary, 
                           ficlString name, 
                           ficlPrimitive code,
                           ficlUnsigned8 flags)
{
    ficlUnsigned8 length  = (ficlUnsigned8)FICL_STRING_GET_LENGTH(name);
    char *nameCopy;
    ficlWord *word;

    ficlDictionaryLock(dictionary, FICL_TRUE);

    /*
    ** NOTE: ficlDictionaryAppendString advances "here" as a side-effect.
    ** It must execute before word is initialized.
    */
    nameCopy       = ficlDictionaryAppendString(dictionary, name);
    word           = (ficlWord *)dictionary->here;
    dictionary->smudge = word;
    word->hash     = ficlHashCode(name);
    word->code     = code;
	word->semiParen = ficlInstructionSemiParen;
    word->flags    = (ficlUnsigned8)(flags | FICL_WORD_SMUDGED);
    word->length    = length;
    word->name     = nameCopy;
    /*
    ** Point "here" to first ficlCell of new word's param area...
    */
    dictionary->here   = word->param;

    if (!(flags & FICL_WORD_SMUDGED))
        ficlDictionaryUnsmudge(dictionary);

    ficlDictionaryLock(dictionary, FICL_FALSE);
    return word;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
cmpq $0x1f, %rsi
movl $0x1f, %edx
cmovlq %rsi, %rdx
movq %r12, %rsi
callq 0xc0a2
movq %rax, %r15
movq (%rbx), %r14
movq %r14, 0x10(%rbx)
movq %r13, %rdi
movq %r12, %rsi
callq 0xb8a9
movw %ax, 0x8(%r14)
movq (%rsp), %rax
movq %rax, 0x18(%r14)
movq $0x2b, 0x20(%r14)
movl %ebp, %eax
orb $0x4, %al
movb %al, 0xa(%r14)
movb %r13b, 0xb(%r14)
movq %r15, 0x10(%r14)
leaq 0x28(%r14), %rax
movq %rax, (%rbx)
testb $0x4, %bpl
jne 0xc1c7
movq 0x10(%rbx), %r15
cmpb $0x0, 0xb(%r15)
je 0xc1c2
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0xb907
andb $-0x5, 0xa(%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryAppend2ConstantInstruction
ficlWord *ficlDictionaryAppend2ConstantInstruction(ficlDictionary *dictionary, ficlString name, ficlInstruction instruction, ficl2Integer value)
{
	ficlWord *word = ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)instruction, FICL_WORD_DEFAULT);
	if (word != NULL)
	{
	    ficlDictionaryAppendUnsigned(dictionary, FICL_2UNSIGNED_GET_HIGH(value));
		ficlDictionaryAppendUnsigned(dictionary, FICL_2UNSIGNED_GET_LOW(value));
	}
	return word;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rdi, %r15
xorl %r8d, %r8d
callq 0xc134
testq %rax, %rax
je 0xc20e
movq (%r15), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%r15)
movq %r14, (%rcx)
movq (%r15), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%r15)
movq %rbx, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionarySetConstantInstruction
ficlWord *ficlDictionarySetConstantInstruction(ficlDictionary *dictionary, ficlString name, ficlInstruction instruction, ficlInteger value)
{
    ficlWord *word = ficlDictionaryLookup(dictionary, name);

    if (word == NULL)
    {
        word = ficlDictionaryAppendConstantInstruction(dictionary, name, instruction, value);
    }
    else
    {
		word->code = (ficlPrimitive)instruction;
        word->param[0] = FICL_LVALUE_TO_CELL(value);
    }
    return word;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
callq 0xc314
testq %rax, %rax
je 0xc2e4
movq %r15, 0x18(%rax)
movq %rax, %rcx
addq $0x28, %rcx
jmp 0xc307
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0xc134
testq %rax, %rax
je 0xc30a
movq (%r14), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%r14)
movq %rbx, (%rcx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryLookup
ficlWord *ficlDictionaryLookup(ficlDictionary *dictionary, ficlString name)
{
    ficlWord *word = NULL;
    ficlHash *hash;
    int i;
    ficlUnsigned16 hashCode   = ficlHashCode(name);

    FICL_DICTIONARY_ASSERT(dictionary, dictionary != NULL);

    ficlDictionaryLock(dictionary, FICL_TRUE);

    for (i = (int)dictionary->wordlistCount - 1; (i >= 0) && (!word); --i)
    {
        hash = dictionary->wordlists[i];
        word = ficlHashLookup(hash, name, hashCode);
    }

    ficlDictionaryLock(dictionary, FICL_TRUE);
    return word;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xb8a9
movslq 0xa8(%r15), %r12
testq %r12, %r12
jle 0xc361
movzwl %ax, %ebp
movq 0x20(%r15,%r12,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0xb929
cmpq $0x2, %r12
jl 0xc363
decq %r12
testq %rax, %rax
je 0xc33f
jmp 0xc363
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionarySet2ConstantInstruction
ficlWord *ficlDictionarySet2ConstantInstruction(ficlDictionary *dictionary, ficlString s, ficlInstruction instruction, ficl2Integer value)
{
    ficlWord *word;
    word = ficlDictionaryLookup(dictionary, s);

	/* only reuse the existing word if we're sure it has space for a 2constant */
    if ((word != NULL) &&
		((((ficlInstruction)word->code) == ficlInstruction2ConstantParen)
#if FICL_WANT_FLOAT
		  ||
		(((ficlInstruction)word->code) == ficlInstructionF2ConstantParen)
#endif /* FICL_WANT_FLOAT */
		)
		)
    {
		word->code = (ficlPrimitive)instruction;
        word->param[0].u = FICL_2UNSIGNED_GET_HIGH(value);
        word->param[1].u = FICL_2UNSIGNED_GET_LOW(value);
    }
    else
    {
        word = ficlDictionaryAppend2ConstantInstruction(dictionary, s, instruction, value);
    }

    return word;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r15
callq 0xc314
testq %rax, %rax
je 0xc3e8
movq 0x18(%rax), %rcx
cmpq $0x8a, %rcx
je 0xc3d7
cmpq $0x49, %rcx
jne 0xc3e8
movq %r12, 0x18(%rax)
movq %r14, 0x28(%rax)
movq %rax, %rcx
addq $0x30, %rcx
jmp 0xc418
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xc134
testq %rax, %rax
je 0xc41b
movq (%r15), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%r15)
movq %r14, (%rcx)
movq (%r15), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, (%r15)
movq %rbx, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionarySetPrimitive
ficlWord *ficlDictionarySetPrimitive(ficlDictionary *dictionary, 
                          char *name, 
                          ficlPrimitive code,
                          ficlUnsigned8 flags)
{
    ficlString s;
    ficlWord *word;

	FICL_STRING_SET_FROM_CSTRING(s, name);
    word = ficlDictionaryLookup(dictionary, s);

    if (word == NULL)
    {
        word = ficlDictionaryAppendPrimitive(dictionary, name, code, flags);
    }
    else
    {
		word->code = (ficlPrimitive)code;
		word->flags = flags;
    }
	return word;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x30e0
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xc314
testq %rax, %rax
je 0xc549
movq %rbx, 0x18(%rax)
movb %bpl, 0xa(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x30e0
movzbl %bpl, %r8d
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc134
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryCreateHashed
ficlDictionary  *ficlDictionaryCreateHashed(ficlSystem *system, unsigned size, unsigned bucketCount)
{
    ficlDictionary *dictionary;
    size_t nAlloc;

    nAlloc =  sizeof(ficlDictionary) + (size * sizeof (ficlCell))
            + sizeof(ficlHash) + (bucketCount - 1) * sizeof (ficlWord *);

    dictionary = ficlMalloc(nAlloc);
    FICL_SYSTEM_ASSERT(system, dictionary != NULL);

    dictionary->size = size;
	dictionary->system = system;

    ficlDictionaryEmpty(dictionary, bucketCount);
    return dictionary;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %eax
leal -0x1(%rbx), %ecx
addq %rax, %rcx
leaq 0xe0(,%rcx,8), %rdi
callq 0xb40f
movq %rax, %r15
movl %ebp, 0xac(%rax)
movq %r14, 0xb0(%rax)
movq %rax, %rdi
movl %ebx, %esi
callq 0xc6ac
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryEmpty
void ficlDictionaryEmpty(ficlDictionary *dictionary, unsigned bucketCount)
{
    ficlHash *hash;

    dictionary->here = dictionary->base;

    ficlDictionaryAlign(dictionary);
    hash = (ficlHash *)dictionary->here;
    ficlDictionaryAllot(dictionary, 
              sizeof (ficlHash) + (bucketCount - 1) * sizeof (ficlWord *));

    hash->size = bucketCount;
    ficlHashReset(hash);

    dictionary->forthWordlist = hash;
    dictionary->smudge = NULL;
    ficlDictionaryResetSearchOrder(dictionary);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
addq $0xb8, %rdi
movq %rdi, (%r14)
callq 0xb4c0
movq %rax, %r15
leal 0x18(,%rbx,8), %eax
cltq
addq %r15, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r15)
movq %r15, %rdi
callq 0xb9b0
movq %r15, 0x18(%r14)
movq $0x0, 0x10(%r14)
movq %r15, 0x20(%r14)
movl $0x1, 0xa8(%r14)
movq %r15, 0x28(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryCreateWordlist
ficlHash *ficlDictionaryCreateWordlist(ficlDictionary *dictionary, int bucketCount)
{
    ficlHash *hash;
    
    ficlDictionaryAlign(dictionary);
    hash    = (ficlHash *)dictionary->here;
    ficlDictionaryAllot(dictionary, sizeof (ficlHash) 
        + (bucketCount - 1) * sizeof (ficlWord *));

    hash->size = bucketCount;
    ficlHashReset(hash);
    return hash;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0xb4c0
movq %rax, %r15
leal 0x18(,%rbx,8), %eax
cltq
addq %r15, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r15)
movq %r15, %rdi
callq 0xb9b0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryIsAWord
int ficlDictionaryIsAWord(ficlDictionary *dictionary, ficlWord *word)
{
	if ( (((ficlInstruction)word) > ficlInstructionInvalid)
		&& (((ficlInstruction)word) < ficlInstructionLast) )
		return 1;

    if (!ficlDictionaryIncludes(dictionary, word))
       return 0;

    if (!ficlDictionaryIncludes(dictionary, word->name))
        return 0;

	if ((word->link != NULL) && !ficlDictionaryIncludes(dictionary, word->link))
		return 0;

    if ((word->length <= 0) || (word->name[word->length] != '\0'))
		return 0;

	if (strlen(word->name) != word->length)
		return 0;

	return 1;
}

// Assembly:
testq %rsi, %rsi
setg %cl
cmpq $0xb4, %rsi
setl %dl
movl $0x1, %eax
testb %dl, %cl
jne 0xc7ec
leaq 0xb8(%rdi), %rdx
xorl %eax, %eax
cmpq %rsi, %rdx
ja 0xc7ec
movl 0xac(%rdi), %ecx
leaq (%rdx,%rcx,8), %rcx
cmpq %rsi, %rcx
jbe 0xc7ec
movq 0x10(%rsi), %rcx
cmpq %rcx, %rdx
ja 0xc7ec
movl 0xac(%rdi), %r8d
leaq (%rdx,%r8,8), %r8
cmpq %rcx, %r8
jbe 0xc7ec
movq (%rsi), %r8
testq %r8, %r8
je 0xc7c8
cmpq %r8, %rdx
ja 0xc7ec
movl 0xac(%rdi), %edi
leaq (%rdx,%rdi,8), %rdx
cmpq %r8, %rdx
jbe 0xc7ec
pushq %rbx
movzbl 0xb(%rsi), %ebx
testq %rbx, %rbx
je 0xc7eb
cmpb $0x0, (%rcx,%rbx)
jne 0xc7eb
movq %rcx, %rdi
callq 0x30e0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rbx, %rcx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/dictionary.c
// Function: ficlDictionaryFindEnclosingWord
ficlWord *ficlDictionaryFindEnclosingWord(ficlDictionary *dictionary, ficlCell *cell)
{
    ficlWord *word;
    int i;

    if (!ficlDictionaryIncludes(dictionary, (void *)cell))
        return NULL;

    for (i = nSEARCH_CELLS; i > 0; --i, --cell)
    {
        word = (ficlWord *)(cell + 1 - (sizeof(ficlWord) / sizeof(ficlCell)));
        if (ficlDictionaryIsAWord(dictionary, word))
            return word;
    }

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0xb8(%rdi), %rax
cmpq %rsi, %rax
ja 0xc856
movq %rsi, %rbx
movq %rdi, %r14
movl 0xac(%rdi), %ecx
leaq (%rax,%rcx,8), %rax
cmpq %rsi, %rax
jbe 0xc856
addq $-0x28, %rbx
movl $0x65, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc75d
testl %eax, %eax
jne 0xc858
decl %ebp
addq $-0x8, %rbx
cmpl $0x1, %ebp
ja 0xc83c
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveIncludeFile
static void ficlPrimitiveIncludeFile(ficlVm *vm) /* ( i*x fileid -- j*x ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    ficlCell id = vm->sourceId;
    int  except = FICL_VM_STATUS_OUT_OF_TEXT;
    long currentPosition, totalSize;
    long size;
	ficlString s;
    vm->sourceId.p = (void *)ff;

    currentPosition = ftell(ff->f);
    totalSize = ficlFileSize(ff);
    size = totalSize - currentPosition;

    if ((totalSize != -1) && (currentPosition != -1) && (size > 0))
    {
        char *buffer = (char *)malloc(size);
        long got = fread(buffer, 1, size, ff->f);
        if (got == size)
		{
			FICL_STRING_SET_POINTER(s, buffer);
			FICL_STRING_SET_LENGTH(s, size);
            except = ficlVmExecuteString(vm, s);
		}
    }

    if ((except < 0) && (except != FICL_VM_STATUS_OUT_OF_TEXT))
        ficlVmThrow(vm, except);
	
    /*
    ** Pass an empty line with SOURCE-ID == -1 to flush
    ** any pending REFILLs (as required by FILE wordset)
    */
    vm->sourceId.i = -1;
	FICL_STRING_SET_FROM_CSTRING(s, "");
    ficlVmExecuteString(vm, s);

    vm->sourceId = id;
    ficlFileClose(ff);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42f1
movq %rax, %r14
movq 0x78(%rbx), %r13
movq %rax, 0x78(%rbx)
movq (%rax), %rdi
callq 0x31c0
movq %rax, %r12
movq %r14, %rdi
callq 0xb476
movq %rax, %r15
subq %r12, %r15
cmpq $-0x1, %rax
setne %al
cmpq $-0x1, %r12
setne %cl
andb %al, %cl
testq %r15, %r15
setg %al
andb %cl, %al
movl $0xfffffeff, %ebp       # imm = 0xFFFFFEFF
cmpb $0x1, %al
jne 0xcf26
movq %r15, %rdi
callq 0x3230
movq %rax, %r12
movq (%r14), %rcx
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x3090
cmpq %r15, %rax
jne 0xcf26
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6d08
movl %eax, %ebp
testl %ebp, %ebp
setns %al
cmpl $0xfffffeff, %ebp       # imm = 0xFFFFFEFF
sete %cl
orb %al, %cl
jne 0xcf42
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6869
movq $-0x1, 0x78(%rbx)
leaq 0x1419(%rip), %rdx      # 0xe36a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d08
movq %r13, 0x78(%rbx)
movq (%r14), %rbx
movq %r14, %rdi
callq 0x3030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30c0
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveReadFile
static void ficlPrimitiveReadFile(ficlVm *vm) /* ( c-addr u1 fileid -- u2 ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    int length = ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);
    int result;

    clearerr(ff->f);
    result = fread(address, 1, length, ff->f);

    ficlStackPushInteger(vm->dataStack, result);
    pushIor(vm, ferror(ff->f) == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42f1
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x4311
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %r12
movq (%r14), %rdi
callq 0x31f0
movslq %r15d, %rdx
movq (%r14), %rcx
movl $0x1, %esi
movq %r12, %rdi
callq 0x3090
movq 0x60(%rbx), %rdi
movslq %eax, %rsi
callq 0x437b
movq (%r14), %rdi
callq 0x3080
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd646
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveReadLine
static void ficlPrimitiveReadLine(ficlVm *vm) /* ( c-addr u1 fileid -- u2 flag ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    int length = ficlStackPopInteger(vm->dataStack);
    char *address = (char *)ficlStackPopPointer(vm->dataStack);
    int error;
    int flag;

    if (feof(ff->f))
        {
        ficlStackPushInteger(vm->dataStack, -1);
        ficlStackPushInteger(vm->dataStack, 0);
        ficlStackPushInteger(vm->dataStack, 0);
        return;
        }

    clearerr(ff->f);
    *address = 0;
    fgets(address, length, ff->f);

    error = ferror(ff->f);
    if (error != 0)
        {
        ficlStackPushInteger(vm->dataStack, -1);
        ficlStackPushInteger(vm->dataStack, 0);
        ficlStackPushInteger(vm->dataStack, error);
        return;
        }

    length = strlen(address);
    flag = (length > 0);
    if (length && ((address[length - 1] == '\r') || (address[length - 1] == '\n')))
        length--;
    
    ficlStackPushInteger(vm->dataStack, length);
    ficlStackPushInteger(vm->dataStack, flag);
    ficlStackPushInteger(vm->dataStack, 0); /* ior */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42f1
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x4311
movq %rax, %r12
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %r14
movq (%r15), %rdi
callq 0x31d0
testl %eax, %eax
je 0xd057
movq 0x60(%rbx), %rdi
movq $-0x1, %rsi
callq 0x437b
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x437b
movq 0x60(%rbx), %rdi
xorl %esi, %esi
jmp 0xd0a1
movq (%r15), %rdi
callq 0x31f0
movb $0x0, (%r14)
movq (%r15), %rdx
movq %r14, %rdi
movl %r12d, %esi
callq 0x3170
movq (%r15), %rdi
callq 0x3080
testl %eax, %eax
je 0xd0ae
movl %eax, %ebp
movq 0x60(%rbx), %rdi
movq $-0x1, %rsi
callq 0x437b
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x437b
movq 0x60(%rbx), %rdi
movslq %ebp, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x437b
movq %r14, %rdi
callq 0x30e0
testl %eax, %eax
je 0xd0da
leal -0x1(%rax), %ecx
movslq %ecx, %rcx
movzbl (%r14,%rcx), %edx
cmpl $0xd, %edx
je 0xd0d2
movq %rax, %rcx
cmpl $0xa, %edx
jne 0xd0dc
movq %rax, %rcx
decq %rcx
jmp 0xd0dc
xorl %ecx, %ecx
xorl %r14d, %r14d
testl %eax, %eax
setg %r14b
movq 0x60(%rbx), %rdi
movslq %ecx, %rsi
callq 0x437b
movq 0x60(%rbx), %rdi
movq %r14, %rsi
jmp 0xd04a
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveWriteFile
static void ficlPrimitiveWriteFile(ficlVm *vm) /* ( c-addr u1 fileid -- ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    int length = ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);

    clearerr(ff->f);
    fwrite(address, 1, length, ff->f);
    pushIor(vm, ferror(ff->f) == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42f1
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x4311
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %r12
movq (%r14), %rdi
callq 0x31f0
movslq %r15d, %rdx
movq (%r14), %rcx
movl $0x1, %esi
movq %r12, %rdi
callq 0x3300
movq (%r14), %rdi
callq 0x3080
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd646
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveWriteLine
static void ficlPrimitiveWriteLine(ficlVm *vm) /* ( c-addr u1 fileid -- ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    size_t length = (size_t)ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);

    clearerr(ff->f);
    if (fwrite(address, 1, length, ff->f) == length)
        fwrite("\n", 1, 1, ff->f);
    pushIor(vm, ferror(ff->f) == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42f1
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x4311
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %r12
movq (%r14), %rdi
callq 0x31f0
movq (%r14), %rcx
movl $0x1, %esi
movq %r12, %rdi
movq %r15, %rdx
callq 0x3300
cmpq %r15, %rax
jne 0xd1c6
movq (%r14), %rsi
movl $0xa, %edi
callq 0x3150
movq (%r14), %rdi
callq 0x3080
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd646
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveFilePosition
static void ficlPrimitiveFilePosition(ficlVm *vm) /* ( fileid -- ud ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    long ud = ftell(ff->f);
    ficlStackPushInteger(vm->dataStack, ud);
    pushIor(vm, ud != -1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42f1
movq (%rax), %rdi
callq 0x31c0
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x437b
xorl %esi, %esi
cmpq $-0x1, %r14
setne %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd646
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveFileSize
static void ficlPrimitiveFileSize(ficlVm *vm) /* ( fileid -- ud ior ) */
{
    ficlFile *ff = (ficlFile *)ficlStackPopPointer(vm->dataStack);
    long ud = ficlFileSize(ff);
    ficlStackPushInteger(vm->dataStack, ud);
    pushIor(vm, ud != -1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42f1
movq %rax, %rdi
callq 0xb476
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x437b
xorl %esi, %esi
cmpq $-0x1, %r14
setne %sil
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd646
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/fileaccess.c
// Function: ficlPrimitiveFileStatus
static void ficlPrimitiveFileStatus(ficlVm *vm) /* ( c-addr u -- x ior ) */
{
	int status;
	int ior;
	
    int length = ficlStackPopInteger(vm->dataStack);
    void *address = (void *)ficlStackPopPointer(vm->dataStack);

    char *filename = (char *)malloc(length + 1);
    memcpy(filename, address, length);
    filename[length] = 0;

	ior = ficlFileStatus(filename, &status);
	free(filename);

    ficlStackPushInteger(vm->dataStack, status);
    ficlStackPushInteger(vm->dataStack, ior);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x4311
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %r15
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0x3230
movq %rax, %r12
movslq %r14d, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3200
movb $0x0, (%r12,%r14)
leaq 0xc(%rsp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0xb440
movl %eax, %ebp
movq %r12, %rdi
callq 0x3030
movq 0x60(%rbx), %rdi
movslq (%r14), %rsi
callq 0x437b
movq 0x60(%rbx), %rdi
movslq %ebp, %rsi
callq 0x437b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq