LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13400
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4d30
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdx
xorl %eax, %eax
movq $-0x1, %rcx
cmpq $0x0, %rdx
cmovlq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x13b60
movq -0x70(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x4c90
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4a70
movq %rax, -0x20(%rbp)
leaq 0x11b79(%rip), %rax     # 0x1eec2
cmpq %rax, -0x20(%rbp)
jne 0xd370
movq -0x8(%rbp), %rdi
leaq 0x11b68(%rip), %rsi     # 0x1eec2
callq 0xf4b0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11b3b(%rip), %rsi     # 0x1eeb6
callq 0xf4b0
movq -0x8(%rbp), %rdi
leaq 0x11b2b(%rip), %rsi     # 0x1eeb6
callq 0xf510
movq -0x10(%rbp), %rdi
movl $0x36, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x11b21(%rip), %rdx     # 0x1eece
callq 0xf540
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x11080
cmpq $0x0, -0x18(%rbp)
je 0xd3e8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x87af(%rip), %rsi      # 0x15bc7
callq 0x3c80
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9f40
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4a70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x106a0
cmpl $0x0, %eax
je 0xd479
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b00
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x11010
jmp 0xd48f
movq -0x8(%rbp), %rdi
callq 0x9ea0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11010
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x30, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x11989(%rip), %rdx     # 0x1eeaf
callq 0xf3b0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x11981(%rip), %rdx     # 0x1eebb
callq 0xf630
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0xd5be
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x22, %edx
callq 0x8fa0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %esi
callq 0x4cc0
jmp 0xd5f4
movq -0x10(%rbp), %rdi
movl $0x50, %esi
callq 0x11080
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl $0x22, %edx
callq 0x8fa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x10f70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveSign
static void ficlPrimitiveSign(ficlVm *vm)
{
    ficlCountedString *counted;
    int i;

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

    counted = FICL_POINTER_TO_COUNTED_STRING(vm->pad);
    i = ficlStackPopInteger(vm->dataStack);
    if (i < 0)
        counted->text[counted->length++] = '-';
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xd64c
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rdx
movb (%rdx), %cl
movb %cl, %sil
addb $0x1, %sil
movb %sil, (%rdx)
movzbl %cl, %ecx
movb $0x2d, 0x1(%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd7fc
cmpq $0x0, -0x10(%rbp)
jne 0xd7fe
jmp 0xd85b
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xd84e
movq -0x8(%rbp), %rdi
callq 0x8f80
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xd83a
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x3060
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x95e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %edx
callq 0xfe10
movq -0x8(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq 0x8ec6(%rip), %rsi      # 0x16783
callq 0x32c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
callq 0x95e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13340
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4cf0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4be0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x13740
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x4cc0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x4cc0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveUntilCoIm
static void ficlPrimitiveUntilCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

    ficlDictionaryAppendUnsigned(dictionary, ficlInstructionBranch0ParenWithCheck);
    resolveBackBranch(dictionary, vm, destTag);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x32, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x11489(%rip), %rdx     # 0x1eeaf
callq 0xf3b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x32, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x113e5(%rip), %rdx     # 0x1eebb
callq 0xf540
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movl $0x3, %esi
callq 0x4d90
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movl $0x3, %esi
callq 0x4d90
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x11080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movsbl -0x11(%rbp), %esi
callq 0x9030
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x7ff, -0x28(%rbp)     # imm = 0x7FF
jbe 0xdb86
movq $0x7ff, -0x28(%rbp)     # imm = 0x7FF
movq -0x28(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3060
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb $0x20, 0x1(%rax,%rcx)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, 0x1(%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4c60
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x80(%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x118, %rax            # imm = 0x118
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x22(%rbp)
je 0xdcf8
movsbl -0x21(%rbp), %eax
cmpl $0x29, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0xdd01
jmp 0xdd2c
movb -0x21(%rbp), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb 0x1(%rax), %al
movb %al, -0x21(%rbp)
jmp 0xdcdc
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xdd52
movsbl -0x21(%rbp), %eax
cmpl $0x29, %eax
jne 0xdd52
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
callq 0x95e0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
subq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq $0x1, 0x50(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x46, %ecx
movl $0x4, %r8d
callq 0x11220
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c60
movq -0x8(%rbp), %rdi
leaq 0x110a8(%rip), %rsi     # 0x1eea9
callq 0xf510
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4e, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x1105d(%rip), %rdx     # 0x1eea3
callq 0xf540
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x11039(%rip), %rdx     # 0x1eea0
callq 0xf540
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveAgainCoIm
static void ficlPrimitiveAgainCoIm(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x30, %esi
callq 0x11080
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq 0x10ff9(%rip), %rdx     # 0x1eeaf
callq 0xf3b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0xdf3e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x22, %edx
callq 0x8fa0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
addq $0x1, %rax
movl %eax, %edx
callq 0x9cc0
jmp 0xdf74
movq -0x10(%rbp), %rdi
movl $0x51, %esi
callq 0x11080
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl $0x22, %edx
callq 0x8fa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x10f70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movsbl -0x19(%rbp), %esi
callq 0x9030
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4cc0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdx
movq $-0x1, %rax
xorl %ecx, %ecx
cmpq $-0x1, %rdx
cmoveq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe08b
movq -0x8(%rbp), %rax
movswl 0x38(%rax), %eax
cmpl $0x0, %eax
jne 0xe08b
movq -0x8(%rbp), %rdi
movl $0xfffffefe, %esi       # imm = 0xFFFFFEFE
callq 0x8d90
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4c90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x80(%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x1a(%rbp)
je 0xe314
movsbl -0x19(%rbp), %ecx
xorl %eax, %eax
cmpl $0xd, %ecx
movb %al, -0x1a(%rbp)
je 0xe314
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0xe31d
jmp 0xe334
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb 0x1(%rax), %al
movb %al, -0x19(%rbp)
jmp 0xe2ea
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xe389
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xe387
movsbl -0x19(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0xe387
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0xe37b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xe387
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xe389
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
subq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitive2Constant
static void ficlPrimitive2Constant(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlString name = ficlVmGetWord(vm);
    
    FICL_STACK_CHECK(vm->dataStack, 2, 0);

	ficlDictionaryAppend2ConstantInstruction(dictionary, name, ficlInstruction2ConstantParen, ficlStackPop2Integer(vm->dataStack));
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9180
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b90
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %r8
movq -0x28(%rbp), %r9
movl $0x49, %ecx
callq 0x11300
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4a, %esi
callq 0x11080
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b00
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x11010
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b00
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x11010
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveDNegate
static void ficlPrimitiveDNegate(ficlVm *vm)
{
	ficl2Integer i = ficlStackPop2Integer(vm->dataStack);
	i = ficl2IntegerNegate(i);
	ficlStackPush2Integer(vm->dataStack, i);

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b90
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13250
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4d30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf930
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c60
cmpq $0x0, -0x18(%rbp)
je 0xe795
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c90
jmp 0xe7a7
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movl $0x1, %esi
callq 0x4c90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf950
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe85a
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4c90
jmp 0xe87d
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movl $0x1, %esi
callq 0x4c90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveToName
static void ficlPrimitiveToName(ficlVm *vm)
{
    ficlWord *word;

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

    word = ficlStackPopPointer(vm->dataStack);
    ficlStackPushPointer(vm->dataStack, word->name);
    ficlStackPushUnsigned(vm->dataStack, word->length);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movzbl 0xb(%rax), %eax
movl %eax, %esi
callq 0x4cc0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe96c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11b40
cmpl $0x0, %eax
je 0xe96c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveLastWord
static void ficlPrimitiveLastWord(ficlVm *vm)
{
    ficlDictionary *dictionary = ficlVmGetDictionary(vm);
    ficlWord *wp = dictionary->smudge;
    FICL_VM_ASSERT(vm, wp);
    ficlVmPush(vm, FICL_LVALUE_TO_CELL(wp));
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x93c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveHash
static void ficlPrimitiveHash(ficlVm *vm)
{
    ficlString s;
    FICL_STRING_SET_LENGTH(s, ficlStackPopUnsigned(vm->dataStack));
    FICL_STRING_SET_POINTER(s, ficlStackPopPointer(vm->dataStack));
    ficlStackPushUnsigned(vm->dataStack, ficlHashCode(s));
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10270
movq -0x20(%rbp), %rdi
movzwl %ax, %eax
movl %eax, %esi
callq 0x4cc0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0xeafd
movq -0x18(%rbp), %rax
movzbl 0xa(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %dl
xorl %eax, %eax
movq $-0x1, %rcx
testb $0x1, %dl
cmovneq %rcx, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movslq -0xc(%rbp), %rsi
callq 0x4c90
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveParseNoCopy
static void ficlPrimitiveParseNoCopy(ficlVm *vm)
{
    ficlString s;

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


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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x91c0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4cc0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x50, %esi
callq 0x11080
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
cmpq $0x0, -0x28(%rbp)
jbe 0xec82
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xec4b
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x20(%rbp), %rdi
callq 0xfad0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
movl $0x10, %edx
callq 0xfe10
movq -0x8(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq 0x763b(%rip), %rsi      # 0x16783
callq 0x32c0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x118, %rsi            # imm = 0x118
callq 0x95e0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8f80
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9180
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x10, -0x28(%rbp)
jl 0xf1cc
movq -0x8(%rbp), %rdi
leaq 0x7252(%rip), %rsi      # 0x16417
movb $0x0, %al
callq 0x8dc0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x87, %ecx
xorl %r8d, %r8d
callq 0x11220
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x11010
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x91c0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf24e
movq -0x8(%rbp), %rdi
movl $0xfffffeff, %esi       # imm = 0xFFFFFEFF
callq 0x8d90
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0xf30a
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x60(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xf27c
jmp 0xf30a
movq -0x40(%rbp), %rax
leaq -0x5467(%rip), %rcx     # 0x9e20
cmpq %rcx, 0x18(%rax)
jne 0xf2b4
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
je 0xf2b2
jmp 0xf324
jmp 0xf2fa
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4cc0
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x9940
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b70
cmpq $0x0, %rax
je 0xf2f8
jmp 0xf324
jmp 0xf2fa
jmp 0xf2fc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf255
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x6833(%rip), %rsi      # 0x15b50
movb $0x0, %al
callq 0x8dc0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hoobaa[P]ficl/primitives.c
// Function: ficlPrimitiveLookup
static void ficlPrimitiveLookup(ficlVm *vm)
{
    ficlString name;
    FICL_STRING_SET_LENGTH(name, ficlStackPopUnsigned(vm->dataStack));
    FICL_STRING_SET_POINTER(name, ficlStackPopPointer(vm->dataStack));
    ficlStackPushInteger(vm->dataStack, ficlVmParseWord(vm, name));
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b50
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x9d20
movq -0x20(%rbp), %rdi
movslq %eax, %rsi
callq 0x4c90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xf4b0
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x4b30
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11010
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)