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

                                            /* (1) FICL_VM_STATE_COMPILE branch runtime */
    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionBranchParenWithCheck);
    matchControlTag(vm, origTag);
    patchAddr = 
        (ficlCell *)ficlStackPopPointer(vm->dataStack);   /* (2) pop "if" patch addr */
    markBranch(dictionary, vm, origTag);           /* (4) push "else" patch addr */
    ficlDictionaryAppendUnsigned(dictionary, 1);                 /* (1) FICL_VM_STATE_COMPILE patch placeholder */
    offset = dictionary->here - patchAddr;
    *patchAddr = FICL_LVALUE_TO_CELL(offset);      /* (3) Patch "if" */

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x699a
movq %rax, %rbx
movl $0x30, %esi
movq %rax, %rdi
callq 0xc094
leaq 0xe8a8(%rip), %r15      # 0x17ecd
movq %r14, %rdi
movq %r15, %rsi
callq 0xb108
movq 0x60(%r14), %rdi
callq 0x42f1
movq %rax, %r12
movq 0x60(%r14), %rdi
movq (%rbx), %rsi
callq 0x436a
movq 0x60(%r14), %rdi
movq %r15, %rsi
callq 0x436a
movl $0x1, %esi
movq %rbx, %rdi
callq 0xc094
movq (%rbx), %rax
subq %r12, %rax
sarq $0x3, %rax
movq %rax, (%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveEmit
static void ficlPrimitiveEmit(ficlVm *vm)
{
    char *buffer = vm->pad;
    int i;


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

    i = ficlStackPopInteger(vm->dataStack);
    buffer[0] = (char)i;
    buffer[1] = '\0';
    ficlVmTextOut(vm, buffer);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x118(%rdi), %r14
movq 0x60(%rdi), %rdi
callq 0x4311
movb %al, 0x118(%rbx)
movb $0x0, 0x119(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c86
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveEndcaseCoIm
static void ficlPrimitiveEndcaseCoIm(ficlVm *vm)
{
	ficlUnsigned fixupCount;
    ficlDictionary *dictionary;
    ficlCell *patchAddr;
    ficlInteger offset;

	/*
	** if the last OF ended with FALLTHROUGH,
	** just add the FALLTHROUGH fixup to the
	** ENDOF fixups
	*/
	if (ficlStackGetTop(vm->dataStack).p == fallthroughTag)
	{
		matchControlTag(vm, fallthroughTag);
		patchAddr = ficlStackPopPointer(vm->dataStack);
	    matchControlTag(vm, caseTag);
		fixupCount = ficlStackPopUnsigned(vm->dataStack);
		ficlStackPushPointer(vm->dataStack, patchAddr);
		ficlStackPushUnsigned(vm->dataStack, fixupCount + 1);
		markControlTag(vm, caseTag);
	}

    matchControlTag(vm, caseTag);

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

	fixupCount = ficlStackPopUnsigned(vm->dataStack);
    FICL_STACK_CHECK(vm->dataStack, fixupCount, 0);

    dictionary = ficlVmGetDictionary(vm);

    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionDrop);

	while (fixupCount--)
	{
		patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
		offset = dictionary->here - patchAddr;
		*patchAddr = FICL_LVALUE_TO_CELL(offset);
	}
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x42ae
leaq 0xe808(%rip), %rcx      # 0x17ed4
cmpq %rcx, %rax
jne 0x9731
leaq 0xe7fc(%rip), %rsi      # 0x17ed4
movq %rbx, %rdi
callq 0xb108
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %r14
leaq 0xe7d5(%rip), %r15      # 0x17ec8
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb108
movq 0x60(%rbx), %rdi
callq 0x4301
movq %rax, %r12
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x436a
movq 0x60(%rbx), %rdi
incq %r12
movq %r12, %rsi
callq 0x438c
movq 0x60(%rbx), %rdi
movq %r15, %rsi
callq 0x436a
leaq 0xe790(%rip), %rsi      # 0x17ec8
movq %rbx, %rdi
callq 0xb108
movq 0x60(%rbx), %rdi
callq 0x4301
movq %rax, %r14
movq %rbx, %rdi
callq 0x699a
movq %rax, %r15
movl $0x6a, %esi
movq %rax, %rdi
callq 0xc094
testq %r14, %r14
je 0x9784
movq 0x60(%rbx), %rdi
callq 0x42f1
movq (%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %rcx, (%rax)
decq %r14
jne 0x9769
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveEndofCoIm
static void ficlPrimitiveEndofCoIm(ficlVm *vm)
{
    ficlCell *patchAddr;
    ficlUnsigned fixupCount;
    ficlInteger offset;
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    FICL_STACK_CHECK(vm->dataStack, 4, 3);

	/* ensure we're in an OF, */
    matchControlTag(vm, ofTag);
	/* grab the address of the branch location after the OF */
    patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
	/* ensure we're also in a "case" */
    matchControlTag(vm, caseTag);
	/* grab the current number of ENDOF fixups */
	fixupCount = ficlStackPopUnsigned(vm->dataStack);

    /* FICL_VM_STATE_COMPILE branch runtime */
    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionBranchParenWithCheck);

	/* push a new ENDOF fixup, the updated count of ENDOF fixups, and the caseTag */
    ficlStackPushPointer(vm->dataStack, dictionary->here);
    ficlStackPushUnsigned(vm->dataStack, fixupCount + 1);
	markControlTag(vm, caseTag);

	/* reserve space for the ENDOF fixup */
    ficlDictionaryAppendUnsigned(dictionary, 2);

	/* and patch the original OF */
    offset = dictionary->here - patchAddr;
    *patchAddr = FICL_LVALUE_TO_CELL(offset);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x699a
movq %rax, %rbx
leaq 0xe735(%rip), %rsi      # 0x17ee0
movq %r14, %rdi
callq 0xb108
movq 0x60(%r14), %rdi
callq 0x42f1
movq %rax, %r15
leaq 0xe702(%rip), %r12      # 0x17ec8
movq %r14, %rdi
movq %r12, %rsi
callq 0xb108
movq 0x60(%r14), %rdi
callq 0x4301
movq %rax, %r13
movl $0x30, %esi
movq %rbx, %rdi
callq 0xc094
movq 0x60(%r14), %rdi
movq (%rbx), %rsi
callq 0x436a
movq 0x60(%r14), %rdi
incq %r13
movq %r13, %rsi
callq 0x438c
movq 0x60(%r14), %rdi
movq %r12, %rsi
callq 0x436a
movl $0x2, %esi
movq %rbx, %rdi
callq 0xc094
movq (%rbx), %rax
subq %r15, %rax
sarq $0x3, %rax
movq %rax, (%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveEnvironmentQ
static void ficlPrimitiveEnvironmentQ(ficlVm *vm)
{
    ficlDictionary *environment;
    ficlWord *word;
    ficlString name;

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


    environment = vm->callback.system->environment;
    name.length = ficlStackPopUnsigned(vm->dataStack);
    name.text    = ficlStackPopPointer(vm->dataStack);

    word = ficlDictionaryLookup(environment, name);

    if (word != NULL)
    {
        ficlVmExecuteWord(vm, word);
        ficlStackPushInteger(vm->dataStack, FICL_TRUE);
    }
    else
    {
        ficlStackPushInteger(vm->dataStack, FICL_FALSE);
    }
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x60(%rdi), %rdi
movq 0x40(%rax), %r14
callq 0x4301
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xc314
testq %rax, %rax
je 0x9881
movq %rbx, %rdi
movq %rax, %rsi
callq 0x53b5
movq $-0x1, %rsi
jmp 0x9883
xorl %esi, %esi
movq 0x60(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x437b
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveEvaluate
static void ficlPrimitiveEvaluate(ficlVm *vm)
{
    ficlCell id;
    int result;
	ficlString string;

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


    FICL_STRING_SET_LENGTH(string, ficlStackPopUnsigned(vm->dataStack));
    FICL_STRING_SET_POINTER(string, ficlStackPopPointer(vm->dataStack));

    id = vm->sourceId;
    vm->sourceId.i = -1;
    result = ficlVmExecuteString(vm, string);
    vm->sourceId = id;
    if (result != FICL_VM_STATUS_OUT_OF_TEXT)
        ficlVmThrow(vm, result);

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x4301
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x42f1
movq 0x78(%rbx), %r15
movq $-0x1, 0x78(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6d08
movq %r15, 0x78(%rbx)
cmpl $0xfffffeff, %eax       # imm = 0xFFFFFEFF
jne 0x98d9
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x6869
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveFallthroughCoIm
static void ficlPrimitiveFallthroughCoIm(ficlVm *vm)
{
    ficlCell *patchAddr;
    ficlInteger offset;
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    FICL_STACK_CHECK(vm->dataStack, 4, 3);

	/* ensure we're in an OF, */
    matchControlTag(vm, ofTag);
	/* grab the address of the branch location after the OF */
    patchAddr = (ficlCell *)ficlStackPopPointer(vm->dataStack);
	/* ensure we're also in a "case" */
    matchControlTag(vm, caseTag);

	/* okay, here we go.  put the case tag back. */
	markControlTag(vm, caseTag);

    /* FICL_VM_STATE_COMPILE branch runtime */
    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionBranchParenWithCheck);

	/* push a new FALLTHROUGH fixup and the fallthroughTag */
    ficlStackPushPointer(vm->dataStack, dictionary->here);
	markControlTag(vm, fallthroughTag);

	/* reserve space for the FALLTHROUGH fixup */
    ficlDictionaryAppendUnsigned(dictionary, 2);

	/* and patch the original OF */
    offset = dictionary->here - patchAddr;
    *patchAddr = FICL_LVALUE_TO_CELL(offset);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
callq 0x699a
movq %rax, %rbx
leaq 0xe5b1(%rip), %rsi      # 0x17ee0
movq %r15, %rdi
callq 0xb108
movq 0x60(%r15), %rdi
callq 0x42f1
movq %rax, %r14
leaq 0xe57e(%rip), %r12      # 0x17ec8
movq %r15, %rdi
movq %r12, %rsi
callq 0xb108
movq 0x60(%r15), %rdi
movq %r12, %rsi
callq 0x436a
movl $0x30, %esi
movq %rbx, %rdi
callq 0xc094
movq 0x60(%r15), %rdi
movq (%rbx), %rsi
callq 0x436a
movq 0x60(%r15), %rdi
leaq 0xe54f(%rip), %rsi      # 0x17ed4
callq 0x436a
movl $0x2, %esi
movq %rbx, %rdi
callq 0xc094
movq (%rbx), %rax
subq %r14, %rax
sarq $0x3, %rax
movq %rax, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveFMSlashMod
static void ficlPrimitiveFMSlashMod(ficlVm *vm)
{
	ficl2Integer d1;
	ficlInteger n1;
	ficl2IntegerQR qr;

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

	n1 = ficlStackPopInteger(vm->dataStack);
	d1 = ficlStackPop2Integer(vm->dataStack);
	qr = ficl2IntegerDivideFloored(d1, n1);
	ficlStackPushInteger(vm->dataStack, qr.remainder);
	ficlStackPushInteger(vm->dataStack, FICL_2UNSIGNED_GET_LOW(qr.quotient));
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x4311
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x4321
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0xd8b8
movq 0x8(%r15), %r14
movq 0x10(%r15), %rsi
movq 0x60(%rbx), %rdi
callq 0x437b
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x437b
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveIfCoIm
static void ficlPrimitiveIfCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionBranch0ParenWithCheck);
    markBranch(dictionary, vm, origTag);
    ficlDictionaryAppendUnsigned(dictionary, 1);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x699a
movq %rax, %r14
movl $0x32, %esi
movq %rax, %rdi
callq 0xc094
movq 0x60(%rbx), %rdi
movq (%r14), %rsi
callq 0x436a
movq 0x60(%rbx), %rdi
leaq 0xe433(%rip), %rsi      # 0x17ecd
callq 0x436a
movl $0x1, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc094
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveLoopCoIm
static void ficlPrimitiveLoopCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionLoopParen);
    resolveBackBranch(dictionary, vm, doTag);
    resolveAbsBranch(dictionary, vm, leaveTag);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x699a
movq %rax, %r14
movl $0x35, %esi
movq %rax, %rdi
callq 0xc094
leaq 0xe3cd(%rip), %rdx      # 0x17eb2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb05b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb092
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveMStar
static void ficlPrimitiveMStar(ficlVm *vm)
{
	ficlInteger n2;
	ficlInteger n1;
	ficl2Integer d;
	FICL_STACK_CHECK(vm->dataStack, 2, 2);

	n2 = ficlStackPopInteger(vm->dataStack);
	n1 = ficlStackPopInteger(vm->dataStack);

	d = ficl2IntegerMultiply(n1, n2);
	ficlStackPush2Integer(vm->dataStack, d);
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x4311
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x4311
movq %rax, %rdi
movq %r14, %rsi
callq 0xd713
movq 0x60(%rbx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x43be
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveMod
static void ficlPrimitiveMod(ficlVm *vm)
{
	ficl2Integer d1;
	ficlInteger n1;
	ficlInteger i;
	ficl2IntegerQR qr;
	FICL_STACK_CHECK(vm->dataStack, 2, 1);

	n1 = ficlStackPopInteger(vm->dataStack);
	i = ficlStackPopInteger(vm->dataStack);
	FICL_INTEGER_TO_2INTEGER(i, d1);
	qr = ficl2IntegerDivideSymmetric(d1, n1);
	ficlStackPushInteger(vm->dataStack, qr.remainder);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x4311
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x4311
movq %rax, %rsi
sarq $0x3f, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0xd970
movq 0x10(%r15), %rsi
movq 0x60(%rbx), %rdi
callq 0x437b
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveOfCoIm
static void ficlPrimitiveOfCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
	ficlCell *fallthroughFixup = NULL;

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

	if (ficlStackGetTop(vm->dataStack).p == fallthroughTag)
	{
		matchControlTag(vm, fallthroughTag);
		fallthroughFixup = ficlStackPopPointer(vm->dataStack);
	}

	matchControlTag(vm, caseTag);

	markControlTag(vm, caseTag);

    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionOfParen);
    markBranch(dictionary, vm, ofTag);
    ficlDictionaryAppendUnsigned(dictionary, 2);

	if (fallthroughFixup != NULL)
	{
		ficlInteger offset = dictionary->here - fallthroughFixup;
		*fallthroughFixup = FICL_LVALUE_TO_CELL(offset);
	}

    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x699a
movq %rax, %rbx
movq 0x60(%r14), %rdi
callq 0x42ae
leaq 0xe323(%rip), %rcx      # 0x17ed4
cmpq %rcx, %rax
jne 0x9bd3
leaq 0xe317(%rip), %rsi      # 0x17ed4
movq %r14, %rdi
callq 0xb108
movq 0x60(%r14), %rdi
callq 0x42f1
movq %rax, %r15
jmp 0x9bd6
xorl %r15d, %r15d
leaq 0xe2eb(%rip), %r12      # 0x17ec8
movq %r14, %rdi
movq %r12, %rsi
callq 0xb108
movq 0x60(%r14), %rdi
movq %r12, %rsi
callq 0x436a
movl $0x36, %esi
movq %rbx, %rdi
callq 0xc094
movq 0x60(%r14), %rdi
movq (%rbx), %rsi
callq 0x436a
movq 0x60(%r14), %rdi
leaq 0xe2c8(%rip), %rsi      # 0x17ee0
callq 0x436a
movl $0x2, %esi
movq %rbx, %rdi
callq 0xc094
testq %r15, %r15
je 0x9c3c
movq (%rbx), %rax
subq %r15, %rax
sarq $0x3, %rax
movq %rax, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitivePostponeCoIm
static void ficlPrimitivePostponeCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary  = ficlVmGetDictionary(vm);
    ficlWord *word;
    ficlWord *pComma = ficlSystemLookup(vm->callback.system, ",");
    FICL_VM_ASSERT(vm, pComma);

    ficlPrimitiveTick(vm);
    word = ficlStackGetTop(vm->dataStack).p;
    if (ficlWordIsImmediate(word))
    {
        ficlDictionaryAppendCell(dictionary, ficlStackPop(vm->dataStack));
    }
    else
    {
        ficlPrimitiveLiteralIm(vm);
        ficlDictionaryAppendCell(dictionary, FICL_LVALUE_TO_CELL(pComma));
    }
    
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x699a
movq %rax, %rbx
movq 0x18(%r14), %rdi
leaq 0x4ded(%rip), %rsi      # 0xea50
callq 0x3a0f
movq %rax, %r15
movq %r14, %rdi
callq 0x71df
movq 0x60(%r14), %rdi
callq 0x42ae
movq %rax, %rdi
callq 0xba94
testl %eax, %eax
je 0x9c96
movq 0x60(%r14), %rdi
callq 0x42e1
movq %rax, %r15
jmp 0x9c9e
movq %r14, %rdi
callq 0x718a
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xc079
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveRepeatCoIm
static void ficlPrimitiveRepeatCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionBranchParenWithCheck);
    /* expect "begin" branch marker */
    resolveBackBranch(dictionary, vm, destTag);
    /* expect "while" branch marker */
    resolveForwardBranch(dictionary, vm, origTag);
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x699a
movq %rax, %r14
movl $0x30, %esi
movq %rax, %rdi
callq 0xc094
leaq 0xe1d3(%rip), %rdx      # 0x17ec1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb05b
leaq 0xe1cd(%rip), %rsi      # 0x17ecd
movq %rbx, %rdi
callq 0xb108
movq 0x60(%rbx), %rdi
callq 0x42f1
movq (%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %rcx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x699a
movq %rax, %r14
cmpq $0x0, 0x50(%rbx)
je 0x9d6b
movl $0x50, %esi
movq %r14, %rdi
callq 0xc094
movq (%r14), %rsi
movq %rbx, %rdi
movl $0x22, %edx
callq 0x69a3
movq %rax, (%r14)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc056
movq (%r14), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x22, %edx
callq 0x69a3
movq 0x60(%rbx), %rdi
leaq 0x1(%r14), %rsi
callq 0x436a
movq 0x60(%rbx), %rdi
movzbl (%r14), %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x438c
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveSMSlashRem
static void ficlPrimitiveSMSlashRem(ficlVm *vm)
{
	ficl2Integer d1;
	ficlInteger n1;
	ficl2IntegerQR qr;
	
	FICL_STACK_CHECK(vm->dataStack, 3, 2);

	n1 = ficlStackPopInteger(vm->dataStack);
	d1 = ficlStackPop2Integer(vm->dataStack);
	qr = ficl2IntegerDivideSymmetric(d1, n1);
	ficlStackPushInteger(vm->dataStack, qr.remainder);
	ficlStackPushInteger(vm->dataStack, FICL_2UNSIGNED_GET_LOW(qr.quotient));
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x4311
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x4321
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0xd970
movq 0x8(%r15), %r14
movq 0x10(%r15), %rsi
movq 0x60(%rbx), %rdi
callq 0x437b
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x437b
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4301
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %r15
testq %rax, %rax
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
je 0x9edc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x0, (%r15,%r14)
je 0x9f08
movq %rbx, %rdi
callq 0x699a
movq (%rax), %r12
cmpq %r12, %r15
je 0x9f01
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3060
movb $0x0, (%r12,%r14)
jmp 0x9f0b
movq %r15, %r12
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6c86
// File: /workspace/github_c_makefile_star2_O1/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 0x4301
leaq 0x118(%rbx), %r14
movl 0x58(%rbx), %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0xb65c
movq %r14, %rdi
callq 0x30e0
movw $0x20, 0x118(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c86
// File: /workspace/github_c_makefile_star2_O1/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 0x4301
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x4301
movq %rax, %rdi
movq %r14, %rsi
callq 0xd6c7
movq 0x60(%rbx), %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x439d
// File: /workspace/github_c_makefile_star2_O1/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 0x4301
movq %rax, %r14
movq 0x60(%rbx), %rdi
callq 0x433d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0xd7ee
movq 0x8(%r15), %r14
movq 0x10(%r15), %rsi
movq 0x60(%rbx), %rdi
callq 0x438c
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x438c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x699a
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a72
movl $0x47, %ecx
movq %r14, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0xc134
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x709f
// File: /workspace/github_c_makefile_star2_O1/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 0x699a
movq %rax, %rbx
movl $0x32, %esi
movq %rax, %rdi
callq 0xc094
movq 0x60(%r14), %rdi
movq (%rbx), %rsi
callq 0x436a
movq 0x60(%r14), %rdi
leaq 0xde25(%rip), %rsi      # 0x17ecd
callq 0x436a
movq 0x60(%r14), %rdi
movl $0x3, %esi
callq 0x43f1
movq 0x60(%r14), %rdi
movl $0x3, %esi
callq 0x43f1
movl $0x1, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc094
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveWord
static void ficlPrimitiveWord(ficlVm *vm)
{
    ficlCountedString *counted;
    char delim;
    ficlString name;

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


    counted = (ficlCountedString *)vm->pad;
    delim = (char)ficlStackPopInteger(vm->dataStack);
    name = ficlVmParseStringEx(vm, delim, 1);

    if (FICL_STRING_GET_LENGTH(name) > FICL_PAD_SIZE - 1)
        FICL_STRING_SET_LENGTH(name, FICL_PAD_SIZE - 1);

    counted->length = (ficlUnsigned8)FICL_STRING_GET_LENGTH(name);
    strncpy(counted->text, FICL_STRING_GET_POINTER(name), FICL_STRING_GET_LENGTH(name));

	/* store an extra space at the end of the primitive... why? dunno yet.  Guy Carver did it. */
    counted->text[counted->length] = ' ';
    counted->text[counted->length + 1] = 0;

    ficlStackPushPointer(vm->dataStack, counted);
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x4311
movsbl %al, %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x69e6
movl $0x7ff, %r14d           # imm = 0x7FF
cmpq %r14, %rax
cmovbq %rax, %r14
leaq 0x118(%rbx), %r15
movb %r14b, 0x118(%rbx)
leaq 0x119(%rbx), %rdi
movq %rdx, %rsi
movq %r14, %rdx
callq 0x3060
movzbl %r14b, %eax
movw $0x20, 0x119(%rbx,%rax)
movq 0x60(%rbx), %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x436a
// File: /workspace/github_c_makefile_star2_O1/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 0xa1f8
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 0xa1f3
cmpb $0x29, %cl
jne 0xa1d8
decq %rax
jmp 0xa1fb
movq %rsi, %r8
movb $0x0, (%r8)
cmpb $0x29, %cl
sete %cl
andb %dl, %cl
movzbl %cl, %r14d
addq %rax, %r14
movq %rbx, %rdi
callq 0x6c86
subq 0x90(%rbx), %r14
movq %r14, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x699a
movq $0x1, 0x50(%rbx)
movl $0x46, %ecx
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x4, %r8d
callq 0xc134
movq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x436a
movq 0x60(%rbx), %rdi
leaq 0xdc50(%rip), %rsi      # 0x17ebb
popq %rbx
jmp 0x436a
// File: /workspace/github_c_makefile_star2_O1/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 0x699a
movq %rax, %r14
movl $0x4e, %esi
movq %rax, %rdi
callq 0xc094
movq 0x60(%rbx), %rdi
movq (%r14), %rsi
callq 0x436a
movq 0x60(%rbx), %rdi
leaq 0xdc11(%rip), %rsi      # 0x17eb5
callq 0x436a
movq %r14, %rdi
xorl %esi, %esi
callq 0xc094
movq 0x60(%rbx), %rdi
movq (%r14), %rsi
callq 0x436a
movq 0x60(%rbx), %rdi
leaq 0xdbe8(%rip), %rsi      # 0x17eb2
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x436a
// File: /workspace/github_c_makefile_star2_O1/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 0x699a
movq %rax, %rbx
cmpq $0x0, 0x50(%r14)
je 0xa34f
movl $0x51, %esi
movq %rbx, %rdi
callq 0xc094
movq (%rbx), %rsi
movq %r14, %rdi
movl $0x22, %edx
callq 0x69a3
movq %rax, (%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc056
movq (%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x22, %edx
callq 0x69a3
movq 0x60(%r14), %rdi
movq %r15, %rsi
callq 0x436a
movzbl (%r15), %edx
incl %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7095
// File: /workspace/github_c_makefile_star2_O1/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 0x4311
movsbl %al, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x69e6
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rdx, %rsi
callq 0x436a
movq 0x60(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x438c
// File: /workspace/github_c_makefile_star2_O1/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 0xa404
cmpw $0x0, 0x38(%rbx)
jne 0xa404
movq %rbx, %rdi
movl $0xfffffefe, %esi       # imm = 0xFFFFFEFE
callq 0x6869
xorl %esi, %esi
cmpq $-0x1, %r14
setne %sil
negq %rsi
movq 0x60(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x437b
// File: /workspace/github_c_makefile_star2_O1/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), %r8
movq 0x88(%rdi), %rdx
leaq (%rax,%r8), %rcx
cmpq %rdx, %rcx
sete %sil
je 0xa5e0
leaq (%r8,%rax), %rcx
incq %rcx
movzbl -0x1(%rcx), %r8d
cmpl $0xa, %r8d
je 0xa5bb
cmpl $0xd, %r8d
je 0xa5bb
leaq 0x1(%rcx), %r8
cmpq %rdx, %rcx
sete %sil
movq %r8, %rcx
jne 0xa595
movq %rdx, %rcx
jmp 0xa5e0
testb $0x1, %sil
je 0xa5c6
decq %rcx
jmp 0xa5e0
cmpq %rdx, %rcx
je 0xa5e0
movzbl (%rcx), %edx
cmpb %dl, %r8b
je 0xa5e0
cmpl $0xa, %edx
je 0xa5dd
cmpl $0xd, %edx
jne 0xa5e0
incq %rcx
subq %rax, %rcx
movq %rcx, 0x80(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x699a
movq %rax, %r14
movl $0x4a, %esi
movq %rax, %rdi
callq 0xc094
movq 0x60(%rbx), %rdi
callq 0x42e1
movq %r14, %rdi
movq %rax, %rsi
callq 0xc079
movq 0x60(%rbx), %rdi
callq 0x42e1
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc079
// File: /workspace/github_c_makefile_star2_O1/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitive2Variable
static void ficlPrimitive2Variable(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x699a
movq %rax, %r14
movq %rbx, %rdi
callq 0x6a72
movl $0x47, %ecx
movq %r14, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
callq 0xc134
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x709f
// File: /workspace/github_c_makefile_star2_O1/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 0x4311
movq %rax, %rdi
callq 0xb40f
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq %rax, %rsi
callq 0x436a
xorl %esi, %esi
testq %r14, %r14
sete %sil
movq 0x60(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x437b
// File: /workspace/github_c_makefile_star2_O1/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 0x4311
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x42f1
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0xb414
movq 0x60(%rbx), %rdi
testq %rax, %rax
je 0xa92a
movq %rax, %rsi
callq 0x436a
xorl %esi, %esi
jmp 0xa937
movq %r14, %rsi
callq 0x436a
movl $0x1, %esi
movq 0x60(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x437b
// File: /workspace/github_c_makefile_star2_O1/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 0x699a
movq %rax, %r15
movq 0x60(%rbx), %rdi
callq 0x42e1
testq %rax, %rax
je 0xa9c7
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0xc75d
testl %eax, %eax
je 0xa9c7
movq 0x18(%rbx), %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x39ee
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x42f1
testq %rax, %rax
je 0xaa84
movb 0xa(%rax), %al
shlb $0x4, %al
sarb $0x7, %al
movsbq %al, %rsi
jmp 0xaa86
xorl %esi, %esi
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0x437b
// File: /workspace/github_c_makefile_star2_O1/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 0x699a
movq %rax, %rbx
movq 0x60(%r15), %rdi
callq 0x4301
movq %rax, %r14
movq 0x60(%r15), %rdi
callq 0x42f1
movq %rax, %r15
movl $0x50, %esi
movq %rbx, %rdi
callq 0xc094
movq (%rbx), %rdi
movb %r14b, (%rdi)
leaq 0x1(%rdi), %rax
testq %r14, %r14
je 0xab4c
xorl %ecx, %ecx
movb (%r15,%rcx), %dl
movb %dl, (%rax)
incq %rax
incq %rcx
cmpq %rcx, %r14
jne 0xab37
leaq -0x1(%rax), %rdi
addq $0x2, %rdi
movb $0x0, (%rax)
callq 0xb4c0
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4301
leaq 0x118(%rbx), %r14
movq %rax, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0xb65c
movq %r14, %rdi
callq 0x30e0
movw $0x20, 0x118(%rbx,%rax)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c86
// File: /workspace/github_c_makefile_star2_O1/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 0x699a
movq %rax, %rbx
movq %r12, %rdi
callq 0x6a72
movq %rax, %r14
movq %rdx, %r15
movq 0x60(%r12), %rdi
callq 0x42e1
movq %rax, %r13
cmpq $0x10, %rax
jl 0xaeff
leaq 0x43ab(%rip), %rsi      # 0xf2a0
movq %r12, %rdi
xorl %eax, %eax
callq 0x6879
movl $0x87, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0xc134
movq %rbx, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc079
// File: /workspace/github_c_makefile_star2_O1/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 0x6a95
movq %rax, %r14
movq %rdx, %r15
testq %rax, %rax
jne 0xaf58
movq %rbx, %rdi
movl $0xfffffeff, %esi       # imm = 0xFFFFFEFF
callq 0x6869
xorl %ebp, %ebp
movq 0x60(%r13,%rbp,8), %r12
testq %r12, %r12
je 0xafaa
leaq -0x3e2f(%rip), %rax     # 0x713c
cmpq %rax, 0x18(%r12)
je 0xafb1
movq 0x60(%rbx), %rdi
movq %r15, %rsi
callq 0x436a
movq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x438c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6eaf
movq 0x60(%rbx), %rdi
callq 0x4311
movl $0x1, %ecx
testq %rax, %rax
jne 0xafca
jmp 0xafc8
movl $0x2, %ecx
jmp 0xafca
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x28(%r12)
movl $0x1, %ecx
testl %eax, %eax
jne 0xafca
xorl %ecx, %ecx
testl %ecx, %ecx
jne 0xafd9
incq %rbp
cmpq $0x8, %rbp
jne 0xaf5a
jmp 0xafde
cmpl $0x2, %ecx
jne 0xb003
leaq 0x39f4(%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 0x6879
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/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 0xb108
movq 0x60(%rbx), %rdi
callq 0x42f1
subq (%r14), %rax
sarq $0x3, %rax
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc079
// File: /workspace/github_c_makefile_star2_O1/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 0x42f1
leaq 0xce09(%rip), %rcx      # 0x17eb5
cmpq %rcx, %rax
je 0xb0f1
leaq 0xcdfd(%rip), %rsi      # 0x17eb5
movq %rax, %rdi
callq 0x31a0
testl %eax, %eax
je 0xb0f1
leaq 0x4171(%rip), %rsi      # 0xf23c
movq %r14, %rdi
callq 0x6c86
leaq 0xcddb(%rip), %rsi      # 0x17eb5
movq %r14, %rdi
callq 0x6c86
leaq 0x3280(%rip), %rsi      # 0xe369
movq %r14, %rdi
callq 0x6c86
movq 0x60(%r14), %rdi
callq 0x42f1
movq (%rbx), %rcx
movq %rcx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x699a
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xc314
movq 0x60(%rbx), %rdi
testq %rax, %rax
je 0xb1b8
movq %rax, %r15
movq %rax, %rsi
callq 0x436a
movq 0x60(%rbx), %rbx
movq %r15, %rdi
callq 0xba94
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 0x437b
movq %r14, %rsi
callq 0x436a
movq 0x60(%rbx), %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x438c
nop