LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveStringQuoteIm
static void ficlPrimitiveStringQuoteIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    if (vm->state == FICL_VM_STATE_INTERPRET)
    {
        ficlCountedString *counted = (ficlCountedString *)dictionary->here;
        ficlVmGetString(vm, counted, '\"');
        ficlStackPushPointer(vm->dataStack, counted->text);
        ficlStackPushUnsigned(vm->dataStack, counted->length);
    }
    else    /* FICL_VM_STATE_COMPILE state */
    {
	    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionStringLiteralParen);
        dictionary->here = FICL_POINTER_TO_CELL(ficlVmGetString(vm, (ficlCountedString *)dictionary->here, '\"'));
        ficlDictionaryAlign(dictionary);
    }

    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x68f3
movq %rax, %r14
cmpq $0x0, 0x50(%rbx)
je 0x9c63
movl $0x50, %esi
movq %r14, %rdi
callq 0xbf2c
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x22, %edx
callq 0x68fc
movq %rax, (%r14)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbeee
movq (%r14), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x22, %edx
callq 0x68fc
movq 0x60(%rbx), %rdi
leaq 0x1(%r14), %rsi
callq 0x4316
movq 0x60(%rbx), %rdi
movzbl (%r14), %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4338
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveType
static void ficlPrimitiveType(ficlVm *vm)
{
    ficlUnsigned length;
    char *s;

    FICL_STACK_CHECK(vm->dataStack, 2, 0);


    length = ficlStackPopUnsigned(vm->dataStack);
    s = ficlStackPopPointer(vm->dataStack);
	
	if ((s == NULL) || (length == 0))
		return;

    /* 
    ** Since we don't have an output primitive for a counted string
    ** (oops), make sure the string is null terminated. If not, copy
    ** and terminate it.
    */
    if (s[length] != 0)
    {
        char *here = (char *)ficlVmGetDictionary(vm)->here;
        if (s != here)
            strncpy(here, s, length);

        here[length] = '\0';
        s = here;
    }

    ficlVmTextOut(vm, s);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42ad
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x429d
movq %rax, %r15
testq %rax, %rax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
je 0x9dd4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x0, (%r15,%r14)
je 0x9e00
movq %rbx, %rdi
callq 0x68f3
movq (%rax), %r12
cmpq %r12, %r15
je 0x9df9
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3060
movb $0x0, (%r12,%r14)
jmp 0x9e03
movq %r15, %r12
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6b89
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveUDot
static void ficlPrimitiveUDot(ficlVm *vm)
{
    ficlUnsigned u;

    FICL_STACK_CHECK(vm->dataStack, 1, 0);

    u = ficlStackPopUnsigned(vm->dataStack);
    ficlUltoa(u, vm->pad, vm->base);
    strcat(vm->pad, " ");
    ficlVmTextOut(vm, vm->pad);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42ad
leaq 0x118(%rbx), %r14
movl 0x58(%rbx), %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0xb538
movq %r14, %rdi
callq 0x30e0
movw $0x20, 0x118(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b89
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveUMStar
static void ficlPrimitiveUMStar(ficlVm *vm)
{
	ficlUnsigned u2;
	ficlUnsigned u1;
	ficl2Unsigned ud;
	FICL_STACK_CHECK(vm->dataStack, 2, 2);

	u2 = ficlStackPopUnsigned(vm->dataStack);
	u1 = ficlStackPopUnsigned(vm->dataStack);

	ud = ficl2UnsignedMultiply(u1, u2);
	ficlStackPush2Unsigned(vm->dataStack, ud);
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42ad
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x42ad
movq %rax, %rdi
movq %r14, %rsi
callq 0xd553
movq 0x60(%rbx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4349
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveUMSlashMod
static void ficlPrimitiveUMSlashMod(ficlVm *vm)
{
	ficl2Unsigned ud;
	ficlUnsigned u1;
	ficl2UnsignedQR uqr;

	u1    = ficlStackPopUnsigned(vm->dataStack);
	ud    = ficlStackPop2Unsigned(vm->dataStack);
	uqr   = ficl2UnsignedDivide(ud, u1);
	ficlStackPushUnsigned(vm->dataStack, uqr.remainder);
	ficlStackPushUnsigned(vm->dataStack, FICL_2UNSIGNED_GET_LOW(uqr.quotient));
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42ad
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x42e9
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0xd67a
movq 0x8(%r15), %r14
movq 0x10(%r15), %rsi
movq 0x60(%rbx), %rdi
callq 0x4338
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x4338
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveVariable
static void ficlPrimitiveVariable(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);

    ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)ficlInstructionVariableParen, FICL_WORD_DEFAULT);
    ficlVmDictionaryAllotCells(vm, dictionary, 1);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x68f3
movq %rax, %r14
movq %rbx, %rdi
callq 0x69c5
movl $0x47, %ecx
movq %r14, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0xbfcc
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6f97
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveWhileCoIm
static void ficlPrimitiveWhileCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    FICL_STACK_CHECK(vm->dataStack, 2, 5);

    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionBranch0ParenWithCheck);
    markBranch(dictionary, vm, origTag);

	/* equivalent to 2swap */
    ficlStackRoll(vm->dataStack, 3);
    ficlStackRoll(vm->dataStack, 3);

    ficlDictionaryAppendUnsigned(dictionary, 1);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x68f3
movq %rax, %rbx
movl $0x32, %esi
movq %rax, %rdi
callq 0xbf2c
movq (%rbx), %rsi
movq 0x60(%r14), %rdi
callq 0x4316
movq 0x60(%r14), %rdi
leaq 0xdf2d(%rip), %rsi      # 0x17ecd
callq 0x4316
movq 0x60(%r14), %rdi
movl $0x3, %esi
callq 0x439d
movq 0x60(%r14), %rdi
movl $0x3, %esi
callq 0x439d
movl $0x1, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbf2c
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveDotParen
static void ficlPrimitiveDotParen(ficlVm *vm)
{
    char *from      = ficlVmGetInBuf(vm);
    char *stop      = ficlVmGetInBufEnd(vm);
    char *to     = vm->pad;
    char c;

    /*
    ** Note: the standard does not want leading spaces skipped.
    */
    for (c = *from; (from != stop) && (c != ')'); c = *++from)
        *to++ = c;

    *to = '\0';
    if ((from != stop) && (c == ')'))
        from++;

    ficlVmTextOut(vm, vm->pad);
    ficlVmUpdateTib(vm, from);
        
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x90(%rdi), %r8
movq 0x80(%rdi), %r9
movq 0x88(%rdi), %rdi
leaq (%r8,%r9), %rax
leaq 0x118(%rbx), %rsi
movb (%r8,%r9), %cl
cmpq %rdi, %rax
setne %dl
cmpb $0x29, %cl
setne %r10b
andb %dl, %r10b
cmpb $0x1, %r10b
jne 0xa0f0
leaq (%r9,%r8), %rax
incq %rax
movq %rsi, %r8
movq %rax, %rdx
movb %cl, (%r8)
incq %r8
movb (%rax), %cl
incq %rax
cmpq %rdi, %rdx
setne %dl
je 0xa0eb
cmpb $0x29, %cl
jne 0xa0d0
decq %rax
jmp 0xa0f3
movq %rsi, %r8
movb $0x0, (%r8)
cmpb $0x29, %cl
sete %cl
andb %dl, %cl
movzbl %cl, %r14d
addq %rax, %r14
movq %rbx, %rdi
callq 0x6b89
subq 0x90(%rbx), %r14
movq %r14, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveColonNoName
static void ficlPrimitiveColonNoName(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlWord *word;
    ficlString name;

    FICL_STRING_SET_LENGTH(name, 0);
    FICL_STRING_SET_POINTER(name, NULL);

    vm->state = FICL_VM_STATE_COMPILE;
    word = ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)ficlInstructionColonParen, FICL_WORD_DEFAULT | FICL_WORD_SMUDGED);
    ficlStackPushPointer(vm->dataStack, word);
    markControlTag(vm, colonTag);
    return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x68f3
movq $0x1, 0x50(%rbx)
movl $0x46, %ecx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x4, %r8d
callq 0xbfcc
movq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x4316
movq 0x60(%rbx), %rdi
leaq 0xdd58(%rip), %rsi      # 0x17ebb
popq %rbx
jmp 0x4316
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveQDoCoIm
static void ficlPrimitiveQDoCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionQDoParen);
    /*
    ** Allot space for a pointer to the end
    ** of the loop - "leave" uses this...
    */
    markBranch(dictionary, vm, leaveTag);
    ficlDictionaryAppendUnsigned(dictionary, 0);
    /*
    ** Mark location of head of loop...
    */
    markBranch(dictionary, vm, doTag);

    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x68f3
movq %rax, %r14
movl $0x4e, %esi
movq %rax, %rdi
callq 0xbf2c
movq (%r14), %rsi
movq 0x60(%rbx), %rdi
callq 0x4316
movq 0x60(%rbx), %rdi
leaq 0xdd19(%rip), %rsi      # 0x17eb5
callq 0x4316
movq %r14, %rdi
xorl %esi, %esi
callq 0xbf2c
movq (%r14), %rsi
movq 0x60(%rbx), %rdi
callq 0x4316
movq 0x60(%rbx), %rdi
leaq 0xdcf0(%rip), %rsi      # 0x17eb2
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4316
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveCountedStringQuoteIm
static void ficlPrimitiveCountedStringQuoteIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    if (vm->state == FICL_VM_STATE_INTERPRET)
    {
        ficlCountedString *counted = (ficlCountedString *) dictionary->here;
        ficlVmGetString(vm, counted, '\"');
        ficlStackPushPointer(vm->dataStack, counted);
		/* move HERE past string so it doesn't get overwritten.  --lch */
		ficlVmDictionaryAllot(vm, dictionary, counted->length + sizeof(ficlUnsigned8));
    }
    else    /* FICL_VM_STATE_COMPILE state */
    {
        ficlDictionaryAppendUnsigned(dictionary, ficlInstructionCStringLiteralParen);
        dictionary->here = FICL_POINTER_TO_CELL(ficlVmGetString(vm, (ficlCountedString *)dictionary->here, '\"'));
        ficlDictionaryAlign(dictionary);
    }

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x68f3
movq %rax, %rbx
cmpq $0x0, 0x50(%r14)
je 0xa247
movl $0x51, %esi
movq %rbx, %rdi
callq 0xbf2c
movq (%rbx), %rsi
movq %r14, %rdi
movl $0x22, %edx
callq 0x68fc
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xbeee
movq (%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x22, %edx
callq 0x68fc
movq 0x60(%r14), %rdi
movq %r15, %rsi
callq 0x4316
movzbl (%r15), %edx
incl %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6f8d
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveParse
static void ficlPrimitiveParse(ficlVm *vm)
{
    ficlString s;
    char delim;


    FICL_STACK_CHECK(vm->dataStack, 1, 2);


    delim = (char)ficlStackPopInteger(vm->dataStack);

    s = ficlVmParseStringEx(vm, delim, 0);
    ficlStackPushPointer(vm->dataStack, FICL_STRING_GET_POINTER(s));
    ficlStackPushUnsigned(vm->dataStack, FICL_STRING_GET_LENGTH(s));
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42bd
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x693f
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rdx, %rsi
callq 0x4316
movq 0x60(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4338
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveRefill
static void ficlPrimitiveRefill(ficlVm *vm)
{
    ficlInteger ret = (vm->sourceId.i == -1) ? FICL_FALSE : FICL_TRUE;
    if (ret && (vm->restart == 0))
        ficlVmThrow(vm, FICL_VM_STATUS_RESTART);

    ficlStackPushInteger(vm->dataStack, ret);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x78(%rdi), %r14
cmpq $-0x1, %r14
je 0xa2fc
cmpw $0x0, 0x38(%rbx)
jne 0xa2fc
movq %rbx, %rdi
movl $0xfffffefe, %esi       # imm = 0xFFFFFEFE
callq 0x67c2
xorl %esi, %esi
cmpq $-0x1, %r14
setne %sil
negq %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4327
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveBackslash
static void ficlPrimitiveBackslash(ficlVm *vm)
{
    char *trace        = ficlVmGetInBuf(vm);
    char *stop      = ficlVmGetInBufEnd(vm);
    char c = *trace;

    while ((trace != stop) && (c != '\r') && (c != '\n'))
    {
        c = *++trace;
    }

    /*
    ** Cope with DOS or UNIX-style EOLs -
    ** Check for /r, /n, /r/n, or /n/r end-of-line sequences,
    ** and point trace to next char. If EOL is \0, we're done.
    */
    if (trace != stop)
    {
        trace++;

        if ( (trace != stop) && (c != *trace) 
             && ((*trace == '\r') || (*trace == '\n')) )
            trace++;
    }

    ficlVmUpdateTib(vm, trace);
    return;
}

// Assembly:
movq 0x90(%rdi), %rax
movq 0x80(%rdi), %rdx
movq 0x88(%rdi), %rsi
leaq (%rax,%rdx), %rcx
cmpq %rsi, %rcx
je 0xa4c7
movq %rsi, %rcx
addq %rax, %rdx
incq %rdx
movzbl -0x1(%rdx), %r8d
cmpl $0xa, %r8d
je 0xa4aa
cmpl $0xd, %r8d
je 0xa4aa
leaq 0x1(%rdx), %r8
cmpq %rsi, %rdx
movq %r8, %rdx
jne 0xa48b
jmp 0xa4c7
cmpq %rsi, %rdx
je 0xa4c7
movzbl (%rdx), %ecx
cmpb %cl, %r8b
je 0xa4c4
cmpl $0xa, %ecx
je 0xa4c1
cmpl $0xd, %ecx
jne 0xa4c4
incq %rdx
movq %rdx, %rcx
subq %rax, %rcx
movq %rcx, 0x80(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitive2LiteralIm
static void ficlPrimitive2LiteralIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    ficlDictionaryAppendUnsigned(dictionary, ficlInstruction2LiteralParen);
    ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->dataStack));
    ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->dataStack));

    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x68f3
movq %rax, %r14
movl $0x4a, %esi
movq %rax, %rdi
callq 0xbf2c
movq 0x60(%rbx), %rdi
callq 0x428d
movq %r14, %rdi
movq %rax, %rsi
callq 0xbf11
movq 0x60(%rbx), %rdi
callq 0x428d
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbf11
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveAllocate
static void ficlPrimitiveAllocate(ficlVm *vm)
{
    size_t size;
    void *p;

    size = ficlStackPopInteger(vm->dataStack);
    p = ficlMalloc(size);
    ficlStackPushPointer(vm->dataStack, p);
    if (p)
        ficlStackPushInteger(vm->dataStack, 0);
    else
        ficlStackPushInteger(vm->dataStack, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42bd
movq %rax, %rdi
callq 0xb2eb
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x4316
xorl %esi, %esi
testq %r14, %r14
sete %sil
movq 0x60(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4327
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveResize
static void ficlPrimitiveResize(ficlVm *vm)
{
    size_t size;
    void *new, *old;

    size = ficlStackPopInteger(vm->dataStack);
    old = ficlStackPopPointer(vm->dataStack);
    new = ficlRealloc(old, size);
    if (new) 
    {
        ficlStackPushPointer(vm->dataStack, new);
        ficlStackPushInteger(vm->dataStack, 0);
    } 
    else 
    {
        ficlStackPushPointer(vm->dataStack, old);
        ficlStackPushInteger(vm->dataStack, 1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42bd
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x429d
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb2f0
movq 0x60(%rbx), %rdi
testq %rax, %rax
je 0xa811
movq %rax, %rsi
callq 0x4316
xorl %esi, %esi
jmp 0xa81e
movq %r14, %rsi
callq 0x4316
movl $0x1, %esi
movq 0x60(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4327
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveAddParseStep
static void ficlPrimitiveAddParseStep(ficlVm *vm)
{
    ficlWord *pStep;
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    FICL_STACK_CHECK(vm->dataStack, 1, 0);

    pStep = (ficlWord *)(ficlStackPop(vm->dataStack).p);
    if ((pStep != NULL) && ficlDictionaryIsAWord(dictionary, pStep))
        ficlSystemAddParseStep(vm->callback.system, pStep);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x68f3
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x428d
testq %rax, %rax
je 0xa8ae
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0xc61c
testl %eax, %eax
je 0xa8ae
movq 0x18(%rbx), %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x39c5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveIsObject
static void ficlPrimitiveIsObject(ficlVm *vm)
{
    int flag;
    ficlWord *word = (ficlWord *)ficlStackPopPointer(vm->dataStack);
    
    flag = ((word != NULL) && (word->flags & FICL_WORD_OBJECT)) ? FICL_TRUE : FICL_FALSE;
    ficlStackPushInteger(vm->dataStack, flag);
    return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x429d
testq %rax, %rax
je 0xa96b
movb 0xa(%rax), %al
shlb $0x4, %al
sarb $0x7, %al
movsbq %al, %rsi
jmp 0xa96d
xorl %esi, %esi
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0x4327
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveSLiteralCoIm
static void ficlPrimitiveSLiteralCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary;
    char *from;
	char *to;
    ficlUnsigned length;

    FICL_STACK_CHECK(vm->dataStack, 2, 0);

    dictionary = ficlVmGetDictionary(vm);
    length  = ficlStackPopUnsigned(vm->dataStack);
    from = ficlStackPopPointer(vm->dataStack);

    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionStringLiteralParen);
    to    = (char *) dictionary->here;
    *to++ = (char)   length;

    for (; length > 0; --length)
    {
        *to++ = *from++;
    }

    *to++ = 0;
    dictionary->here = FICL_POINTER_TO_CELL(ficlAlignPointer(to));
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
callq 0x68f3
movq %rax, %rbx
movq 0x60(%r15), %rdi
callq 0x42ad
movq %rax, %r14
movq 0x60(%r15), %rdi
callq 0x429d
movq %rax, %r15
movl $0x50, %esi
movq %rbx, %rdi
callq 0xbf2c
movq (%rbx), %rdi
movb %r14b, (%rdi)
leaq 0x1(%rdi), %rax
testq %r14, %r14
je 0xaa33
xorl %ecx, %ecx
movb (%r15,%rcx), %dl
movb %dl, (%rax)
incq %rax
incq %rcx
cmpq %rcx, %r14
jne 0xaa1e
leaq -0x1(%rax), %rdi
addq $0x2, %rdi
movb $0x0, (%rax)
callq 0xb39c
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveHexDot
static void ficlPrimitiveHexDot(ficlVm *vm)
{
    ficlUnsigned u;

    FICL_STACK_CHECK(vm->dataStack, 1, 0);

    u = ficlStackPopUnsigned(vm->dataStack);
    ficlUltoa(u, vm->pad, 16);
    strcat(vm->pad, " ");
    ficlVmTextOut(vm, vm->pad);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42ad
leaq 0x118(%rbx), %r14
movq %rax, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0xb538
movq %r14, %rdi
callq 0x30e0
movw $0x20, 0x118(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b89
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveUser
static void ficlPrimitiveUser(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);
    ficlCell c;

    c = ficlStackPop(vm->dataStack);
    if (c.i >= FICL_USER_CELLS)
    {
        ficlVmThrowError(vm, "Error - out of user space");
    }

    ficlDictionaryAppendWord(dictionary, name, (ficlPrimitive)ficlInstructionUserParen, FICL_WORD_DEFAULT);
    ficlDictionaryAppendCell(dictionary, c);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r12
callq 0x68f3
movq %rax, %rbx
movq %r12, %rdi
callq 0x69c5
movq %rax, %r14
movq %rdx, %r15
movq 0x60(%r12), %rdi
callq 0x428d
movq %rax, %r13
cmpq $0x10, %rax
jl 0xae1b
leaq 0x448f(%rip), %rsi      # 0xf2a0
movq %r12, %rdi
xorl %eax, %eax
callq 0x67d2
movl $0x87, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0xbfcc
movq %rbx, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xbf11
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveInterpret
static void ficlPrimitiveInterpret(ficlVm *vm)
{
    ficlString s;
    int i;
    ficlSystem *system;

    FICL_VM_ASSERT(vm, vm);

    system = vm->callback.system;
    s   = ficlVmGetWord0(vm);

    /*
    ** Get next word...if out of text, we're done.
    */
    if (s.length == 0)
    {
        ficlVmThrow(vm, FICL_VM_STATUS_OUT_OF_TEXT);
    }

    /*
    ** Run the parse chain against the incoming token until somebody eats it.
    ** Otherwise emit an error message and give up.
    */
    for (i=0; i < FICL_MAX_PARSE_STEPS; i++)
    {
        ficlWord *word = system->parseList[i];
           
        if (word == NULL)
            break;

        if (word->code == ficlPrimitiveParseStepParen)
        {
            ficlParseStep pStep;
            pStep = (ficlParseStep)(word->param->fn);
            if ((*pStep)(vm, s))
                return;
        }
        else
        {
            ficlStackPushPointer(vm->dataStack, FICL_STRING_GET_POINTER(s));
            ficlStackPushUnsigned(vm->dataStack, FICL_STRING_GET_LENGTH(s));
            ficlVmExecuteXT(vm, word);
            if (ficlStackPopInteger(vm->dataStack))
                return;
        }
    }

    ficlVmThrowError(vm, "%.*s not found", FICL_STRING_GET_LENGTH(s), FICL_STRING_GET_POINTER(s));

    return;                 /* back to inner interpreter */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r13
callq 0x69e8
movq %rax, %r14
movq %rdx, %r15
testq %rax, %rax
jne 0xae74
movq %rbx, %rdi
movl $0xfffffeff, %esi       # imm = 0xFFFFFEFF
callq 0x67c2
xorl %ebp, %ebp
movq 0x60(%r13,%rbp,8), %r12
testq %r12, %r12
je 0xaedc
leaq -0x3e53(%rip), %rax     # 0x7034
cmpq %rax, 0x18(%r12)
je 0xaec1
movq 0x60(%rbx), %rdi
movq %r15, %rsi
callq 0x4316
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x4338
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6da9
movq 0x60(%rbx), %rdi
callq 0x42bd
testq %rax, %rax
je 0xaed3
jmp 0xaf01
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x28(%r12)
testl %eax, %eax
jne 0xaf01
incq %rbp
cmpq $0x8, %rbp
jne 0xae76
leaq 0x3af6(%rip), %rsi      # 0xe9d9
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x67d2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: resolveBackBranch
static void resolveBackBranch(ficlDictionary *dictionary, ficlVm *vm, char *tag)
{
    ficlInteger offset;
    ficlCell *patchAddr;

    matchControlTag(vm, tag);

    FICL_STACK_CHECK(vm->dataStack, 1, 0);

    patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
    offset = patchAddr - dictionary->here;
    ficlDictionaryAppendCell(dictionary, FICL_LVALUE_TO_CELL(offset));

    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xb006
movq 0x60(%rbx), %rdi
callq 0x429d
subq (%r14), %rax
sarq $0x3, %rax
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbf11
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: resolveAbsBranch
static void resolveAbsBranch(ficlDictionary *dictionary, ficlVm *vm, char *wantTag)
{
    ficlCell *patchAddr;
    char *tag;

    FICL_STACK_CHECK(vm->dataStack, 2, 0);

    tag = ficlStackPopPointer(vm->dataStack);
    /*
    ** Changed the comparison below to compare the pointers first (by popular demand)
    */
    if ((tag != wantTag) && strcmp(tag, wantTag))
    {
        ficlVmTextOut(vm, "Warning -- Unmatched control word: ");
        ficlVmTextOut(vm, wantTag);
        ficlVmTextOut(vm, "\n");
    }

    patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
    *patchAddr = FICL_LVALUE_TO_CELL(dictionary->here);

    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x60(%rsi), %rdi
callq 0x429d
leaq 0xcf0b(%rip), %rcx      # 0x17eb5
cmpq %rcx, %rax
je 0xafef
leaq 0xceff(%rip), %rsi      # 0x17eb5
movq %rax, %rdi
callq 0x31a0
testl %eax, %eax
je 0xafef
leaq 0x4273(%rip), %rsi      # 0xf23c
movq %r14, %rdi
callq 0x6b89
leaq 0xcedd(%rip), %rsi      # 0x17eb5
movq %r14, %rdi
callq 0x6b89
leaq 0x3382(%rip), %rsi      # 0xe369
movq %r14, %rdi
callq 0x6b89
movq 0x60(%r14), %rdi
callq 0x429d
movq (%rbx), %rcx
movq %rcx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hoobaa[P]ficl/primitives.c
// Function: do_find
static void do_find(ficlVm *vm, ficlString name, void *returnForFailure)
{
    ficlWord *word;

    word = ficlDictionaryLookup(ficlVmGetDictionary(vm), name);
    if (word)
    {
        ficlStackPushPointer(vm->dataStack, word);
        ficlStackPushInteger(vm->dataStack, (ficlWordIsImmediate(word) ? 1 : -1));
    }
    else
    {
        ficlStackPushPointer(vm->dataStack, returnForFailure);
        ficlStackPushUnsigned(vm->dataStack, 0);
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x68f3
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xc1bf
movq 0x60(%rbx), %rdi
testq %rax, %rax
je 0xb0b6
movq %rax, %r15
movq %rax, %rsi
callq 0x4316
movq 0x60(%rbx), %rbx
movq %r15, %rdi
callq 0xb92c
xorl %esi, %esi
cmpl $0x1, %eax
sbbq %rsi, %rsi
orq $0x1, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4327
movq %r14, %rsi
callq 0x4316
movq 0x60(%rbx), %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4338
// File: /workspace/github_c_makefile_star2_O3/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 0xb136
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 0xddd0
addl %ebp, (%rbx)
movl (%r14), %edi
callq 0xde31
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb3f3
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 0xb3d8
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb484
movl $0x1, %eax
movl $0x2, %edx
cmpq %r14, %rdx
je 0xb482
incl %eax
leaq -0x1(,%rdx,2), %rsi
addq %rdx, %rdx
cmpq %r14, %rsi
jb 0xb469
jmp 0xb484
movl %eax, %ecx
movq %rdi, %rdx
negq %rdx
testb %bpl, %bpl
cmoveq %rdi, %rdx
testq %rdx, %rdx
je 0xb4c8
testl %ecx, %ecx
je 0xb4d1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
movl %ecx, %ecx
leaq 0x3f24(%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 0xb4af
jmp 0xb50c
leaq 0x1(%rbx), %r12
movb $0x30, (%rbx)
jmp 0xb50c
xorl %esi, %esi
movq %rsp, %r15
leaq 0x3ef3(%rip), %r13      # 0xf3d0
movq %rbx, %r12
movq %r15, %rdi
movq %r14, %rcx
callq 0xd67a
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 0xb4e0
testb %bpl, %bpl
je 0xb519
movb $0x2d, (%r12)
incq %r12
movb $0x0, (%r12)
movq %rbx, %rdi
callq 0xb3b0
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_O3/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 0xb595
movl %edx, %eax
movq %rdi, %rdx
movslq %eax, %r14
xorl %esi, %esi
leaq 0x8(%rsp), %r15
leaq 0x3e6d(%rip), %r13      # 0xf3d0
movq %rbx, %r12
movq %r15, %rdi
movq %r14, %rcx
callq 0xd67a
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 0xb566
jmp 0xb59c
leaq 0x1(%rbx), %r12
movb $0x30, (%rbx)
movb $0x0, (%r12)
movq %rbx, %rdi
callq 0xb3b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb603
callq 0x3340
movq %rax, %r14
leaq 0x1(%rbx), %r15
movq (%r14), %rax
movzbl %bpl, %r12d
testb $0x1, 0x1(%rax,%r12,2)
je 0xb5f8
callq 0x3330
movq (%rax), %rax
movb (%rax,%r12,4), %al
movb %al, -0x1(%r15)
movb (%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0xb5d9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb65a
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 0xb654
xorl %eax, %eax
testb %sil, %sil
je 0xb654
leaq 0x1(%rdx), %rsi
cmpq %rdx, %rbx
movq %rsi, %rdx
jne 0xb62f
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb689
movq %rsi, %r14
callq 0x3340
movq (%rax), %rax
movzbl (%rbx), %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0xb689
incq %rbx
cmpq %r14, %rbx
jne 0xb674
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r8
movq %rdi, %rbx
testq %rsi, %rsi
je 0xb724
movq %rsi, %r14
movb (%rsi), %cl
testb %cl, %cl
je 0xb715
incq %r14
xorl %eax, %eax
movq %rsp, %r15
movq %r15, %rsi
xorl %edx, %edx
cmpb $0xa, %cl
je 0xb6d7
movzbl %cl, %edi
cmpl $0xd, %edi
je 0xb6dc
incq %rax
movb %cl, (%rsi)
jmp 0xb6dc
movl $0x1, %edx
movb (%r14), %cl
leaq (%rsp,%rax), %rsi
testb %cl, %cl
je 0xb6ef
cmpq $0xfe, %rax
jle 0xb710
movb $0x0, (%rsi)
movq 0x20(%rbx), %rdi
movq %r15, %rsi
movq %r8, %r12
callq *%r8
movb (%r14), %cl
testb %cl, %cl
je 0xb715
movq %r12, %r8
xorl %eax, %eax
movq %r15, %rsi
xorl %edx, %edx
incq %r14
jmp 0xb6c3
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 *%r8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xb7ba
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movl %r14d, %ebp
movzbl (%rbx,%r15), %r12d
testq %r12, %r12
je 0xb7bc
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 0xb782
jmp 0xb7bc
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb85b
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzwl %cx, %ebp
movl 0x10(%r15), %ecx
cmpl $0x2, %ecx
jb 0xb824
movl %ebp, %eax
xorl %edx, %edx
divl %ecx
jmp 0xb826
xorl %edx, %edx
movq 0x18(%r15,%rdx,8), %r13
testq %r13, %r13
je 0xb853
movzbl 0xb(%r13), %eax
cmpq %r14, %rax
jne 0xb84d
movq 0x10(%r13), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xb60f
testl %eax, %eax
je 0xb85e
movq (%r13), %r13
jmp 0xb82b
movq (%r15), %r15
testq %r15, %r15
jne 0xb813
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_O3/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 0xb88b
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_O3/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 0x3a0e
movq %rax, %rbx
leaq 0x2a01(%rip), %rsi      # 0xe439
leaq 0xaf(%rip), %rdx        # 0xbaee
movq %rax, %rdi
xorl %ecx, %ecx
callq 0xc3c8
leaq 0x3a40(%rip), %rsi      # 0xf490
leaq 0x98(%rip), %rdx        # 0xbaef
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xc3c8
leaq 0x3a2d(%rip), %rsi      # 0xf495
leaq 0x23a(%rip), %rdx       # 0xbca9
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xc3c8
leaq 0x3a1e(%rip), %rsi      # 0xf49e
leaq 0x31c(%rip), %rdx       # 0xbda3
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xc3c8
leaq 0x3a0d(%rip), %rsi      # 0xf4a5
leaq 0x388(%rip), %rdx       # 0xbe27
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xc3c8
leaq 0x39fb(%rip), %rsi      # 0xf4ab
movl $0xf4240, %edx          # imm = 0xF4240
movq %rbx, %rdi
callq 0xc217
leaq 0x39f2(%rip), %rsi      # 0xf4b6
leaq 0x372(%rip), %rdx       # 0xbe3d
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0xc3c8
leaq 0x39de(%rip), %rsi      # 0xf4ba
leaq 0x399(%rip), %rdx       # 0xbe7c
movq %rbx, %rdi
xorl %ecx, %ecx
popq %rbx
jmp 0xc3c8
// File: /workspace/github_c_makefile_star2_O3/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 0x68f3
movq 0x18(%rax), %r13
movl 0x10(%r13), %ebp
movq %r14, %rdi
callq 0x6a69
testl %eax, %eax
jne 0xbcdd
movq %r14, %rdi
movl $0xfffffeff, %esi       # imm = 0xFFFFFEFF
callq 0x67c2
leaq 0x118(%r14), %rdi
leaq 0x3c6a(%rip), %rsi      # 0xf955
callq 0x32b0
testq %rax, %rax
je 0xbd86
movq %rax, %rbx
testq %rbp, %rbp
je 0xbd70
addq $0x18, %r13
leaq 0x3823(%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 0xbd22
movq %rbx, %rdi
leaq 0x37f3(%rip), %rsi      # 0xf529
movl %r12d, %edx
xorl %eax, %eax
callq 0x31b0
movq (%r14), %r14
testq %r14, %r14
je 0xbd5b
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x31b0
jmp 0xbd40
movl $0xa, %edi
movq %rbx, %rsi
callq 0x3150
incq %r12
cmpq %rbp, %r12
jne 0xbd0f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30c0
leaq 0x3787(%rip), %rsi      # 0xf514
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6b89
// File: /workspace/github_c_makefile_star2_O3/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 0x68fc
cmpb $0x0, 0x118(%rbx)
je 0xbe09
leaq 0x119(%rbx), %rdi
callq 0x3100
testl %eax, %eax
je 0xbe1f
leaq 0x3755(%rip), %rsi      # 0xf533
movq %r14, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x32f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6b89
movq %rbx, %rdi
movl $0xffffffc8, %esi       # imm = 0xFFFFFFC8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x67c2
leaq 0x373c(%rip), %rsi      # 0xf54c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b89
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6b89
leaq 0x2504(%rip), %rsi      # 0xe369
movq %rbx, %rdi
callq 0x6b89
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O3/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 0x68fc
cmpb $0x0, 0x118(%rbx)
je 0xbec7
leaq 0x119(%rbx), %rdi
callq 0x30f0
testl %eax, %eax
je 0xbed7
leaq 0x36bf(%rip), %rsi      # 0xf570
movq %rbx, %rdi
callq 0x6b89
movq %rbx, %rdi
movl $0xffffffc8, %esi       # imm = 0xFFFFFFC8
popq %rbx
jmp 0x67c2
leaq 0x36b9(%rip), %rsi      # 0xf587
movq %rbx, %rdi
popq %rbx
jmp 0x6b89
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xbf6f
xorl %eax, %eax
movb (%rsi,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
cmpq %rax, %rdx
jne 0xbf4b
leaq (%r14,%rax), %rdi
incq %rdi
movb $0x0, -0x1(%rdi)
movq %rdi, (%rbx)
callq 0xb39c
jmp 0xbf7a
movq %r14, %rdi
callq 0xb39c
movq %rax, %r14
movq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq